diff --git a/python/tests/harness/__init__.py b/python/tests/harness/__init__.py new file mode 100644 index 000000000..cf79047f1 --- /dev/null +++ b/python/tests/harness/__init__.py @@ -0,0 +1,238 @@ +"""Small, loopback-only utilities for OTLP contract tests.""" + +from __future__ import annotations + +import copy +import difflib +import json +import subprocess +import threading +from http import HTTPStatus +from http.server import BaseHTTPRequestHandler, ThreadingHTTPServer +from pathlib import Path +from typing import Any, Mapping, Optional, Sequence, Union +from urllib.parse import urlsplit +from urllib.request import Request, urlopen + + +class Receiver: + """An in-memory OTLP/HTTP receiver for tests. + + The receiver only listens on loopback and never forwards received spans. + """ + + def __init__(self) -> None: + self._spans: list[dict[str, Any]] = [] + self._requests: list[dict[str, Any]] = [] + self._lock = threading.Lock() + owner = self + + class Handler(BaseHTTPRequestHandler): + def _read_body(self) -> bytes: + # The Node OTLP exporter streams with Transfer-Encoding: chunked + # and sends no Content-Length, so both framings are accepted. + if "chunked" in self.headers.get("Transfer-Encoding", "").lower(): + chunks = [] + while True: + size_line = self.rfile.readline().split(b";", 1)[0].strip() + size = int(size_line, 16) + if size == 0: + while self.rfile.readline() not in (b"\r\n", b"\n", b""): + pass + return b"".join(chunks) + chunks.append(self.rfile.read(size)) + self.rfile.readline() + length = int(self.headers.get("Content-Length", "0")) + return self.rfile.read(length) + + def do_POST(self) -> None: # noqa: N802 - required by BaseHTTPRequestHandler + path = urlsplit(self.path).path + if path not in ("/v1/traces", "/tracer/v1/traces"): + self.send_error(HTTPStatus.NOT_FOUND) + return + + try: + body = self._read_body() + content_type = self.headers.get("Content-Type", "").lower() + + if content_type.startswith("application/json"): + request = json.loads(body.decode("utf-8")) + elif content_type.startswith(("application/x-protobuf", "application/protobuf")): + from google.protobuf.json_format import MessageToDict + from opentelemetry.proto.collector.trace.v1.trace_service_pb2 import ( + ExportTraceServiceRequest, + ) + + protobuf_request = ExportTraceServiceRequest() + protobuf_request.ParseFromString(body) + request = MessageToDict(protobuf_request) + else: + self.send_error(HTTPStatus.UNSUPPORTED_MEDIA_TYPE) + return + + spans: list[dict[str, Any]] = [] + resource_attributes: list[dict[str, Any]] = [] + for resource_spans in request.get( + "resourceSpans", request.get("resource_spans", []) + ): + resource_attributes.append( + _flatten_attributes( + resource_spans.get("resource", {}).get("attributes", []) + ) + ) + for scope_spans in resource_spans.get( + "scopeSpans", resource_spans.get("scope_spans", []) + ): + spans.extend(scope_spans.get("spans", [])) + except (ImportError, TypeError, UnicodeDecodeError, ValueError) as error: + self.send_error(HTTPStatus.BAD_REQUEST, str(error)) + return + + with owner._lock: + owner._spans.extend(copy.deepcopy(spans)) + owner._requests.append( + { + "path": path, + "headers": { + key.lower(): value for key, value in self.headers.items() + }, + "resource_attributes": resource_attributes, + } + ) + self.send_response(HTTPStatus.OK) + self.send_header("Content-Length", "0") + self.end_headers() + + def log_message(self, _format: str, *args: Any) -> None: + return + + self._server = ThreadingHTTPServer(("127.0.0.1", 0), Handler) + self.origin = "http://127.0.0.1:{0}".format(self._server.server_port) + self.endpoint = "{0}/v1/traces".format(self.origin) + self.collector_endpoint = "{0}/tracer/v1/traces".format(self.origin) + self._thread = threading.Thread(target=self._server.serve_forever, daemon=True) + self._thread.start() + + def __enter__(self) -> "Receiver": + return self + + def __exit__(self, _type: Any, _value: Any, _traceback: Any) -> None: + self._server.shutdown() + self._server.server_close() + self._thread.join() + + def spans(self) -> list[dict[str, Any]]: + """Return a copy of the decoded spans received so far.""" + with self._lock: + return copy.deepcopy(self._spans) + + def requests(self) -> list[dict[str, Any]]: + """Return one record per accepted export: path, lower-cased headers, resource attributes.""" + with self._lock: + return copy.deepcopy(self._requests) + + def clear(self) -> None: + """Remove every decoded span and request record received so far.""" + with self._lock: + self._spans.clear() + self._requests.clear() + + +def _flatten_attributes(attributes: Sequence[Mapping[str, Any]]) -> dict[str, Any]: + """Turn OTLP key/value attributes into a plain dict of scalar values.""" + flat: dict[str, Any] = {} + for attribute in attributes: + value = attribute.get("value", {}) + for kind in ("stringValue", "boolValue", "intValue", "doubleValue"): + if kind in value: + flat[attribute.get("key", "")] = value[kind] + break + else: + flat[attribute.get("key", "")] = value + return flat + + +def run( + argv: Sequence[str], + env: Mapping[str, str], + stdin: Optional[bytes], + timeout: float, +) -> subprocess.CompletedProcess[bytes]: + """Run one process and return its captured output, including after a timeout.""" + process = subprocess.Popen( + argv, + env=dict(env), + stdin=subprocess.PIPE, + stdout=subprocess.PIPE, + stderr=subprocess.PIPE, + ) + timed_out = False + try: + stdout, stderr = process.communicate(input=stdin, timeout=timeout) + except subprocess.TimeoutExpired: + timed_out = True + process.kill() + stdout, stderr = process.communicate() + + result = subprocess.CompletedProcess(argv, process.returncode, stdout, stderr) + result.timed_out = timed_out + return result + + +def post_otlp(spans: dict[str, Any], endpoint: str) -> int: + """Post one JSON-encoded OTLP request to a loopback receiver.""" + parsed = urlsplit(endpoint) + if parsed.scheme != "http" or parsed.hostname != "127.0.0.1": + raise ValueError("post_otlp only sends to a loopback HTTP endpoint") + + request = Request( + endpoint, + data=json.dumps(spans).encode("utf-8"), + headers={"Content-Type": "application/json"}, + method="POST", + ) + with urlopen(request, timeout=5) as response: + return response.status + + +def compare(actual: Sequence[dict[str, Any]], golden_path: Union[str, Path]) -> None: + """Fail with a diff unless span names, attributes, and statuses match a golden.""" + with Path(golden_path).open(encoding="utf-8") as golden_file: + expected = json.load(golden_file) + + def canonical(spans: Sequence[dict[str, Any]]) -> list[dict[str, Any]]: + normalized = [] + for span in spans: + attributes = span.get("attributes", []) + if isinstance(attributes, dict): + attributes = [ + {"key": key, "value": value} for key, value in attributes.items() + ] + normalized.append( + { + "name": span.get("name", ""), + "attributes": sorted( + attributes, + key=lambda attribute: json.dumps( + attribute, sort_keys=True, separators=(",", ":") + ), + ), + "status": span.get("status", {}), + } + ) + return normalized + + actual_normalized = canonical(actual) + expected_normalized = canonical(expected) + if actual_normalized != expected_normalized: + diff = "\n".join( + difflib.unified_diff( + json.dumps(expected_normalized, indent=2, sort_keys=True).splitlines(), + json.dumps(actual_normalized, indent=2, sort_keys=True).splitlines(), + fromfile=str(golden_path), + tofile="actual", + lineterm="", + ) + ) + print(diff) + raise AssertionError("spans do not match golden") diff --git a/python/tests/harness/test_harness.py b/python/tests/harness/test_harness.py new file mode 100644 index 000000000..bd61d5adc --- /dev/null +++ b/python/tests/harness/test_harness.py @@ -0,0 +1,189 @@ +"""Contract tests for the shared loopback-only harness.""" + +import json +import sys + +import pytest + +from tests.harness import Receiver, compare, post_otlp, run + + +def test_receiver_stores_posted_span_and_can_clear() -> None: + payload = { + "resourceSpans": [ + { + "scopeSpans": [ + { + "spans": [ + { + "traceId": "trace-id", + "spanId": "span-id", + "name": "harness.receiver", + "attributes": [ + {"key": "component", "value": {"stringValue": "test"}} + ], + "status": {"code": 1}, + } + ] + } + ] + } + ] + } + + with Receiver() as receiver: + assert post_otlp(payload, receiver.endpoint) == 200 + assert receiver.spans() == payload["resourceSpans"][0]["scopeSpans"][0]["spans"] + receiver.clear() + assert receiver.spans() == [] + + +def test_receiver_accepts_the_collector_path() -> None: + payload = { + "resourceSpans": [ + {"scopeSpans": [{"spans": [{"name": "collector.path"}]}]} + ] + } + + with Receiver() as receiver: + assert post_otlp(payload, receiver.collector_endpoint) == 200 + assert receiver.spans() == [{"name": "collector.path"}] + + +def _post_chunked(url: str, body: bytes, headers: dict) -> int: + """Send a body with Transfer-Encoding: chunked, as the Node OTLP exporter does.""" + import http.client + from urllib.parse import urlsplit + + parts = urlsplit(url) + connection = http.client.HTTPConnection(parts.hostname, parts.port, timeout=5) + try: + chunks = [body[: len(body) // 2], body[len(body) // 2 :]] + connection.request( + "POST", + parts.path, + body=iter(chunks), + headers={**headers, "Transfer-Encoding": "chunked"}, + encode_chunked=True, + ) + return connection.getresponse().status + finally: + connection.close() + + +def test_receiver_decodes_a_chunked_body() -> None: + payload = { + "resourceSpans": [ + {"scopeSpans": [{"spans": [{"name": "chunked.body"}]}]} + ] + } + + with Receiver() as receiver: + status = _post_chunked( + receiver.collector_endpoint, + json.dumps(payload).encode("utf-8"), + {"Content-Type": "application/json"}, + ) + assert status == 200 + assert receiver.spans() == [{"name": "chunked.body"}] + + +def test_receiver_records_path_headers_and_resource_attributes() -> None: + payload = { + "resourceSpans": [ + { + "resource": { + "attributes": [ + {"key": "project_name", "value": {"stringValue": "harness"}}, + {"key": "project_type", "value": {"stringValue": "observe"}}, + ] + }, + "scopeSpans": [{"spans": [{"name": "with.resource"}]}], + } + ] + } + + with Receiver() as receiver: + status = _post_chunked( + receiver.collector_endpoint, + json.dumps(payload).encode("utf-8"), + { + "Content-Type": "application/json", + "X-Api-Key": "test-key", + "X-Secret-Key": "test-secret", + }, + ) + assert status == 200 + [request] = receiver.requests() + assert request["path"] == "/tracer/v1/traces" + assert request["headers"]["x-api-key"] == "test-key" + assert request["headers"]["x-secret-key"] == "test-secret" + assert "authorization" not in request["headers"] + assert request["resource_attributes"] == [ + {"project_name": "harness", "project_type": "observe"} + ] + receiver.clear() + assert receiver.requests() == [] + + +def test_run_captures_output_and_kills_timed_out_process() -> None: + completed = run( + [ + sys.executable, + "-c", + "import sys; print('stdout'); sys.stderr.write('stderr\\n')", + ], + env={}, + stdin=b"", + timeout=1, + ) + assert completed.returncode == 0 + assert completed.stdout == b"stdout\n" + assert completed.stderr == b"stderr\n" + assert completed.timed_out is False + + timed_out = run( + [sys.executable, "-c", "import time; time.sleep(30)"], + env={}, + stdin=b"", + timeout=0.1, + ) + assert timed_out.timed_out is True + assert timed_out.returncode != 0 + + +def test_compare_accepts_normalized_match_and_prints_mismatch_diff(tmp_path, capsys) -> None: + golden = [ + { + "traceId": "golden-trace", + "spanId": "golden-span", + "startTimeUnixNano": "1", + "endTimeUnixNano": "2", + "name": "harness.compare", + "attributes": [ + {"key": "alpha", "value": {"stringValue": "a"}}, + {"key": "beta", "value": {"intValue": "2"}}, + ], + "status": {"code": 1}, + } + ] + golden_path = tmp_path / "spans.golden.json" + golden_path.write_text(json.dumps(golden), encoding="utf-8") + + actual = [ + { + "traceId": "other-trace", + "spanId": "other-span", + "startTimeUnixNano": "3", + "endTimeUnixNano": "4", + "name": "harness.compare", + "attributes": list(reversed(golden[0]["attributes"])), + "status": {"code": 1}, + } + ] + compare(actual, golden_path) + + actual[0]["name"] = "harness.mismatch" + with pytest.raises(AssertionError, match="spans do not match golden"): + compare(actual, golden_path) + assert "---" in capsys.readouterr().out diff --git a/typescript/packages/traceai_genkit/README.md b/typescript/packages/traceai_genkit/README.md new file mode 100644 index 000000000..47d2805a2 --- /dev/null +++ b/typescript/packages/traceai_genkit/README.md @@ -0,0 +1,206 @@ +# @traceai/genkit + +Send [Firebase Genkit](https://genkit.dev) (JavaScript) spans to Future AGI. Genkit already creates OpenTelemetry spans for flows, models, tools and steps. `FIGenkitSpanProcessor` is a span processor you pass to Genkit's `enableTelemetry({ spanProcessors })`. It maps Genkit's `genkit:*` attributes to Future AGI span kinds, model and token keys, and exports the mapped copy through `@traceai/fi-core`. + +Alpha. Validated with real `genkit` 1.42.0 (the latest stable release on npm on 2026-10-16) flows on Genkit's own test model (`mockModel` from `genkit/testing`), exported to a loopback OTLP receiver, and end to end with the Google AI plugin (`@genkit-ai/google-genai` 1.42.0, `gemini-3.8-flash` and `gemini-embedding-001`: retriever, embedder, tool call, streaming, a failing tool) exported to a local Future AGI collector. GCP telemetry was not called. + +JavaScript only. Genkit Python and Genkit Go are not covered. This package does not use the Firebase / Google Cloud plugin, cannot run next to it in one process in this release (see [Firebase / Google Cloud telemetry plugin](#firebase--google-cloud-telemetry-plugin)), and does not wrap `ai.generate()`. + +## Versions and licence + +| Item | Value | +|---|---| +| Tested pin | `genkit` 1.42.0 (`@genkit-ai/core` 1.42.0, `@genkit-ai/ai` 1.42.0) | +| Peer range | `genkit` `^1.42.0` | +| Node | 20.20.2, 22.23.3 and 26.8.1: the full contract suite (every journey) ran once per version with `NODE_BINARY` set to it, and jest ran once per version with that Node first on `PATH`. `TRACEAI_NODE_MATRIX` parametrizes only the CJS/ESM entry-point import check; each of the three runs set it to all three Nodes. See [Tests](#tests). | +| Genkit licence | Apache-2.0 (`node_modules/genkit/LICENSE`, `package.json` `license`) | + +`genkit` is a **peer dependency**. Install it yourself. This package never bundles or re-exports Genkit; the pack test hashes every file of the installed `genkit`, `@genkit-ai/core` and `@genkit-ai/ai` and checks that none ships in the tarball. + +## Install + +```bash +npm install @traceai/genkit @traceai/fi-core genkit +``` + +```bash +export FI_API_KEY="YOUR_API_KEY" +export FI_SECRET_KEY="YOUR_SECRET_KEY" +export FI_PROJECT_NAME="my-genkit-app" +``` + +fi-core sends the keys as the `X-Api-Key` / `X-Secret-Key` headers. They are never copied onto spans. + +## Set up + +```typescript +import { genkit } from "genkit"; // import genkit first: it initialises Genkit's telemetry provider +import { enableTelemetry, flushTracing } from "genkit/tracing"; +import { register, ProjectType } from "@traceai/fi-core"; +import { FIGenkitSpanProcessor, flushOnSignals } from "@traceai/genkit"; + +const tracerProvider = register({ + projectType: ProjectType.OBSERVE, + projectName: "my-genkit-app", // or FI_PROJECT_NAME; the collector drops a batch with no project_name + setGlobalTracerProvider: false, // required: Genkit's NodeSDK must own the global provider +}); + +await enableTelemetry({ + spanProcessors: [new FIGenkitSpanProcessor({ tracerProvider })], // content on by default; FI_HIDE_INPUTS / FI_HIDE_OUTPUTS hide it +}); + +const ai = genkit({ plugins: [/* your model plugins */] }); + +// Long-running server: flush on SIGTERM / SIGINT before Genkit's own exit handler runs. +flushOnSignals(flushTracing); +``` + +Three things the setup depends on, each checked in the installed 1.42.0 source: + +- `enableTelemetry` and `flushTracing` are exported from `genkit/tracing` (`genkit/src/tracing.ts:43-44`), not from `genkit`. They need Genkit's telemetry provider, which `genkit` / `genkit/beta` initialise at import (`genkit/src/common.ts:173-175`). Calling `enableTelemetry` before anything imported `genkit` throws `FAILED_PRECONDITION: TelemetryProvider is not initialized`. +- `register()` must get `setGlobalTracerProvider: false`. Genkit takes its tracer from the global OpenTelemetry API (`@genkit-ai/core` `src/tracing/instrumentation.ts:96,197`) and its NodeSDK cannot register a global provider once fi-core has. Genkit spans would then skip both this processor and the Dev UI exporter, and reach Future AGI raw (content included, no kind). The processor warns (`TRACEAI_GENKIT_GLOBAL_PROVIDER`) when it detects this. +- `enableTelemetry` keeps Genkit's own telemetry-server processor first and appends yours (`@genkit-ai/core` `src/tracing/node-telemetry-provider.ts:66-77`). The Genkit Dev UI keeps working. Passing `traceExporter` instead of `spanProcessors` throws in Genkit. +- Call `enableTelemetry({ spanProcessors })` before the first flow, model or tool runs. When a Genkit span starts and no `enableTelemetry` call has happened yet, Genkit calls `enableTelemetry({})` itself (`@genkit-ai/core` `src/tracing.ts:32-40`), and a later call of yours starts a second NodeSDK that does not receive Genkit's spans (see the Firebase section below). + +Metrics: `enableTelemetry({ spanProcessors })` passes no metric reader, and the NodeSDK Genkit uses (`@opentelemetry/sdk-node` 0.52.1) builds a meter provider only when one is configured, so no Genkit metrics go anywhere. `disableMetrics` and `forceDevExport` are options of the `@genkit-ai/google-cloud` plugin (`src/types.ts:92,110`), not of `enableTelemetry`'s `TelemetryConfig`; TypeScript rejects them there. + +### Firebase / Google Cloud telemetry plugin + +Using this package together with the Firebase / Google Cloud telemetry plugin (`enableFirebaseTelemetry()` from `@genkit-ai/firebase`, `enableGoogleCloudTelemetry()` from `@genkit-ai/google-cloud`, or `ENABLE_FIREBASE_MONITORING=true`) is **not supported in this release**. Use one or the other per process. + +Why: both plugins call the same `enableTelemetry()` (`@genkit-ai/firebase` `src/index.ts:40-44` -> `@genkit-ai/google-cloud` `src/index.ts:38-41`), and every `enableTelemetry()` call replaces Genkit's stored config and starts a second NodeSDK (`@genkit-ai/core` `src/tracing/node-telemetry-provider.ts:64,97-98`). Only the first NodeSDK becomes the global tracer provider, so only the first call's processors get Genkit's spans, while `flushTracing()` flushes only the last call's processors (`node-telemetry-provider.ts:143-151`). Whichever runs second gets no spans, and the first is no longer flushed by `flushTracing()`. Checked locally with genkit 1.42.0 and no plugin: two `enableTelemetry()` calls with recording processors, one flow; the first processor received the flow span and no flush, the second received no span and the flush. `ENABLE_FIREBASE_MONITORING=true` makes Genkit call `enableFirebaseTelemetry()` itself when a span starts before any `enableTelemetry()` call (`@genkit-ai/core` `src/tracing.ts:33,50-62`); the Firebase plugin itself was not run (it needs GCP). + +Cost: the Future AGI export adds no Google Cloud cost. The Firebase / Google Cloud plugin exports to Cloud Trace, Logging and Monitoring, which Google bills (Blaze plan), so exporting to both, for example from separate deployments, may cost on GCP for that copy only. + +## What you get + +### Span kinds + +`fi.span.kind` and `gen_ai.span.kind` are both set. The map is written from the type strings in the 1.42.0 source (`genkit:type` labels in `core/src/action.ts:538-543`, `core/src/flow.ts:219-221`, `ai/src/generate/action.ts:147-149`, `ai/src/prompt.ts:273-275,490-492`; action subtypes in `core/src/registry.ts:40-62`). + +| `genkit:type` | `genkit:metadata:subtype` | Kind | +|---|---|---| +| `action` | `model`, `background-model` | `LLM` | +| `action` | `tool`, `tool.v2` | `TOOL` | +| `action` | `retriever` | `RETRIEVER` | +| `action` | `embedder` | `EMBEDDING` | +| `action` | `reranker` | `RERANKER` | +| `action` | `evaluator` | `EVALUATOR` | +| `action` | `agent` (beta agents) | `AGENT` | +| `action` | `flow` and every other subtype (`custom`, `prompt`, `executable-prompt`, `util`, `indexer`, `resource`, ...) | `CHAIN` | +| `flowStep` (`ai.run()`), `util` (the `generate` span), `promptTemplate` (`render`), `dotprompt` | n/a | `CHAIN` | +| anything else, or no `genkit:type` | | not set; the span is still exported | + +### Attributes + +| Future AGI key | Source | Where | +|---|---|---| +| `fi.span.kind`, `gen_ai.span.kind` | table above | every Genkit span | +| `gen_ai.request.model`, `gen_ai.response.model` | `genkit:name` of the model action span without its plugin namespace: `googleai/gemini-3.5-flash` becomes `gemini-3.5-flash`, the name Future AGI's price table uses. The full registered name stays on `genkit:name`. Genkit reports no resolved model version, so both keys hold the requested model | model spans | +| `gen_ai.provider.name` | the plugin namespace: `googleai` → `google`, `vertexai` → `vertexai`, `openai` → `openai`, `anthropic` → `anthropic`, `deepseek` → `deepseek`, `xai` → `xai`, `ollama` → `ollama`, `mistral` → `mistralai`, `groq` → `groq`, `aws-bedrock` → `aws`, `azure-openai` → `azure`. Any other namespace: not set | model spans | +| `gen_ai.usage.input_tokens` / `output_tokens` / `total_tokens` | `usage.inputTokens` / `outputTokens` / `totalTokens` in the model span's `genkit:output` | model spans only | +| `gen_ai.usage.output_tokens.reasoning` / `gen_ai.usage.cache_read_tokens` | `usage.thoughtsTokens` / `cachedContentTokens`, when the model plugin reports them (the Google AI / Vertex AI plugin does; Gemini's `outputTokens` excludes thinking tokens, which are in `totalTokens`) | model spans only | +| `gen_ai.response.finish_reasons` | `finishReason` in the model span's `genkit:output` | model spans | +| `tool.name`, `gen_ai.tool.name` | `genkit:name` of the tool action span | tool spans | +| `session.id` | `genkit:metadata:agent:sessionId` (`ai/src/agent.ts:1061-1063`) | the beta agent span only | +| `session.id`, `user.id`, `metadata`, `tag.tags` | fi-core `setSession` / `setUser` / `setMetadata` / `setTags` around the flow call | every span started in that context | +| `embedding.model_name`, `gen_ai.provider.name` | `genkit:name` of the embedder action span without its plugin namespace (`googleai/gemini-embedding-001` becomes `gemini-embedding-001`), provider as for models | embedder spans | +| `input.value` / `output.value` (+ `application/json` mime types) | `genkit:input` / `genkit:output` | by default; `__REDACTED__` (no mime type) when hidden, see [Content](#content) | +| `genkit:*` | passed through, except the content keys below | every Genkit span | + +Cost is not set by this package: fi-collector prices each model span from its tokens and `gen_ai.request.model` (an exact lookup in its litellm price table), so a model the table lists, such as `gemini-3.5-flash`, gets a cost and one it does not list shows none. Unavailable at 1.42.0, and not set: user id (unless the app sets it), retriever documents, and the other `GenerationUsage` fields (the character / image / video / audio counters, `custom`). Those stay inside `genkit:output`. + +Tokens are written only on model call spans. The `generate` span's `genkit:output` repeats the last turn's usage; it stays inside that JSON and is not promoted. If any non-model span carries a key the collector promotes (`gen_ai.usage.*`, `llm.token_count.*`, `llm.usage.*`, `gen_ai.cost.*`, `llm.cost.*`; the cost prefixes cover the parts such as `gen_ai.cost.input` and `llm.cost.completion` as well as the totals), the processor moves it to `genkit.usage.`, so the trace-wide token and cost sums equal the model calls. + +Errors: Genkit sets the OTel status to `ERROR` and records an `exception` event on every span the error passes through (`core/src/tracing/instrumentation.ts:153-172`). Both are exported, without `exception.stacktrace` and without local paths, emails, or this machine's user and host names in the message; with inputs or outputs hidden the message itself is replaced (see [Content](#content)). `genkit:isFailureSource` marks the first failing span. + +### Session + +Genkit 1.42.0 has no session key on plain flows. Beta agents (`genkit/beta` `defineAgent` / `agent.chat()`) tag the agent span with `genkit:metadata:agent:sessionId`, which becomes `session.id` on that span. For flows, set the session yourself around the call: + +```typescript +import { context } from "@opentelemetry/api"; +import { setSession } from "@traceai/fi-core"; + +await context.with(setSession(context.active(), { sessionId: "chat-123" }), () => myFlow(input)); +``` + +## Content + +Content follows the traceAI `TraceConfig` convention, the same as every other traceAI instrumentor: Genkit's inputs and outputs (flow input and output, prompts and model responses, tool arguments and results, retriever queries and documents, embedder input and vectors) are **exported by default**, and the standard switches hide them. Set them as environment variables, or pass the same options as `traceConfig`; the option wins over the variable, and only the string `true` (any case) hides. + +```bash +export FI_HIDE_INPUTS=true # every span: genkit:input, genkit:init, genkit:metadata:resumed +export FI_HIDE_OUTPUTS=true # every span: genkit:output, genkit:metadata:interrupt +``` + +```typescript +new FIGenkitSpanProcessor({ tracerProvider, traceConfig: { hideInputs: true, hideOutputs: true } }); +``` + +| Switch (env / `traceConfig`) | Effect on the exported copy | +|---|---| +| `FI_HIDE_INPUTS` / `hideInputs` | Input-side keys dropped, `input.value` = `__REDACTED__`, no `input.mime_type`, and the error message rule below | +| `FI_HIDE_OUTPUTS` / `hideOutputs` | Output-side keys dropped, `output.value` = `__REDACTED__`, no `output.mime_type`, and the error message rule below | +| `FI_HIDE_INPUT_MESSAGES` / `FI_HIDE_OUTPUT_MESSAGES` | The same, on model spans only (a model span's input is the message list, its output the response message) | +| `FI_HIDE_INPUT_TEXT` / `FI_HIDE_OUTPUT_TEXT` | On model spans, every `text` and `reasoning` part becomes `__REDACTED__`; roles, tool requests, finish reason and usage stay | +| `FI_HIDE_EMBEDDING_VECTORS` | On embedder spans, every vector becomes `__REDACTED__` | + +Hidden or not, tokens, finish reason, model, provider, kinds, names and session are exported: they are read from Genkit's span before anything is hidden. + +Never exported, in either mode: + +| What | How | +|---|---| +| `genkit:metadata:context` (request context; Genkit redacts `auth` and `secrets`, headers can remain) | dropped | +| `exception.stacktrace` of `exception` events | dropped | +| Stack frames and local file paths in any exported string (content included) | frames removed; the working directory becomes `[cwd]`, the home directory `~`, other absolute local paths, `file://` URLs and Windows paths `[path]`. URL paths and Genkit action paths (`genkit:path`) are left alone | +| Emails and this machine's user and host names in the span status message and `exception.message` | replaced by `` / `` | + +Error messages: Genkit copies the thrown message to the span status and the `exception` event of every span the error passes through, and messages often quote user data: a tool that throws with its input in the text, Genkit's schema-validation error (`Schema validation failed. Parse Errors: ... Provided data: ...`, `@genkit-ai/core` `src/schema.ts:78`), the `validateSupport` model middleware (`Request: `, `@genkit-ai/ai` `src/model/middleware.ts:107-115`), a misconfigured `defineSimpleRetriever` (`Item: `, `src/retriever.ts:396-422`). By default the message is exported after the scrubbing above. With `FI_HIDE_INPUTS` or `FI_HIDE_OUTPUTS` on, the status message becomes `: __REDACTED__` (for example `Error: __REDACTED__`, or `400: __REDACTED__` for a Genkit `INVALID_ARGUMENT` error, whose recorded type is its HTTP code) and `exception.message` becomes `__REDACTED__`. The `ERROR` status, the event and `exception.type` are kept. Your app still receives the full error. + +The processor never changes Genkit's span. Genkit's Dev UI and any other exporter see the original attributes; Future AGI gets a mapped copy. + +The `captureContent` option of earlier pre-release builds is removed. Passing it logs a warning; `captureContent: false` still hides inputs and outputs (unless `traceConfig` or the `FI_HIDE_*` variables say otherwise), so an old configuration never exports more than it asked for. + +## Flush and shutdown + +- `flushTracing()` from `genkit/tracing` (`core/src/tracing.ts:113`) flushes every processor, this one included. Call it before a short script exits. +- `FIGenkitSpanProcessor.forceFlush()` and `shutdown()` never reject. Each is bounded by `flushTimeoutMillis` (default 30000 ms). A collector that is down is logged through the OTel diag logger; the flow still returns. +- `shutdown()` also shuts down the `register()` provider you passed, and Genkit's NodeSDK calls it on SIGTERM (`@genkit-ai/core` `src/tracing/node-telemetry-provider.ts:99,111`), so give Genkit its own `register()` provider instead of sharing one with other traceAI instrumentations. +- SIGTERM: `genkit` installs a SIGTERM / SIGINT listener at import that stops its reflection servers and calls `process.exit(0)` without flushing (`genkit/src/genkit.ts:786-793`). An app listener that awaits `flushTracing()` loses that race. `flushOnSignals(flush)` moves the listeners registered so far behind a bounded `flush` (default 10000 ms) and then runs them in order. Call it after `import "genkit"` and after `await enableTelemetry(...)`. It returns a function that restores the original listeners. +- Call `flushOnSignals` after every other SIGTERM / SIGINT listener is installed: a listener added later is not moved behind the flush and runs at once, in parallel with it, and a second signal (a second Ctrl-C) during the flush is ignored until the flush finishes or its timeout ends. +- Export goes through the fi-core provider's own span processor and exporter. This package adds no queue of its own. + +## Span inventory at 1.42.0 + +`contract/inventory.mjs` runs one flow (an `ai.run()` step, `generateStream` with a tool loop: two model calls, one tool) twice, once called and once streamed, on Genkit's `mockModel`, and records the spans Genkit hands to a processor. 14 spans, all from instrumentation scope `genkit-tracer`, all shaped like `@opentelemetry/sdk-trace-base` 1.25 spans (`parentSpanId`, `instrumentationLibrary`; the processor converts them for fi-core's 2.x exporter). + +| Span | `genkit:type` / subtype | Attribute keys (all strings unless noted) | +|---|---|---| +| flow (`inventoryFlow`) | `action` / `flow` | `genkit:type`, `genkit:metadata:subtype`, `genkit:key`, `genkit:name`, `genkit:isRoot` (boolean), `genkit:path`, `genkit:input`, `genkit:output`, `genkit:state`, `genkit:metadata:context` | +| step (`prepare`) | `flowStep` | `genkit:type`, `genkit:name`, `genkit:path`, `genkit:output`, `genkit:state` | +| `generate` | `util` | `genkit:type`, `genkit:name`, `genkit:path`, `genkit:input`, `genkit:output`, `genkit:state` | +| model (`inventory/mock`) | `action` / `model` | `genkit:type`, `genkit:metadata:subtype`, `genkit:key`, `genkit:name`, `genkit:path`, `genkit:input`, `genkit:output`, `genkit:state` | +| tool (`lookup`) | `action` / `tool` | same keys as the model span | + +The model span's `genkit:output` is the model response JSON: `message`, `finishReason`, `usage` (`inputTokens`, `outputTokens`, `totalTokens` from the mock), `latencyMs`. The `generate` span's `genkit:output` has `message`, `finishReason`, `usage` (the last turn's), `custom`, `request`. A beta agent run (contract `agent` journey) adds `render` (`promptTemplate`, `genkit:metadata:promptName`), a `runTurn-1` step (`flowStep`, `genkit:metadata:agent:snapshotId`) and the agent span (`action` / `agent`, `genkit:metadata:agent:sessionId`, `genkit:init`). Error spans add `genkit:isFailureSource`. + +## Tests + +From `typescript/packages/traceai_genkit`: + +```bash +pnpm exec jest +``` + +From the repository root (shared harness in `python/tests/harness`), once per Node version: + +```bash +NODE_BINARY=/path/to/node-v20.20.2/bin/node \ +TRACEAI_NODE_MATRIX=/path/to/node-v20.20.2/bin/node:/path/to/node-v22.23.3/bin/node:/path/to/node-v26.8.1/bin/node \ +PYTHONPATH=python/tests uv run --no-project --python 3.11 --with pytest --with protobuf --with opentelemetry-proto \ + pytest typescript/packages/traceai_genkit/contract -q -p no:cacheprovider --noconftest -o addopts='' +``` + +The contract suite builds the package, runs `contract/run_fixture.mjs` against the real fi-core exporter and the shared receiver, and checks the collector path and headers, the resource, span names, kinds and parenting, model and tokens, the trace token sum, content exported by default and hidden with `FI_HIDE_INPUTS` / `FI_HIDE_OUTPUTS` (tokens, kinds and model kept), no stack trace, local path, user or host name in any journey, one closed model span for a streamed flow, error status and exception events (the message replaced by the error type when content is hidden), schema-validation data absent from status and exception events with content hidden (and kept by default), SIGTERM flushing (with a control that shows a plain listener loses the race), a collector that is down, Genkit's Dev UI reflection server and telemetry export in `GENKIT_ENV=dev`, the inventory drift check, the packed tarball, and the CJS / ESM entry points. `NODE_BINARY` is the node every fixture journey and the inventory check run on (the build and `pnpm pack` steps use the `node` on `PATH`). `TRACEAI_NODE_MATRIX` (path-separated) parametrizes only the CJS / ESM entry-point import check, which loads the built package through a symlink in a temporary `node_modules` (not a clean `npm install`); unset, it is `NODE_BINARY` alone. Re-verification 2026-10-16 (TraceConfig privacy, embedder mapping): the contract suite ran once with `NODE_BINARY` 20.20.2 and once with 22.18.0, `TRACEAI_NODE_MATRIX` set to both: 22 passed per run (20 tests plus the import check on two Nodes). jest ran on the same two Nodes: 95 passed each. The earlier review rounds ran the suite on 20.20.2, 22.23.3 and 26.8.1. diff --git a/typescript/packages/traceai_genkit/contract/inventory.mjs b/typescript/packages/traceai_genkit/contract/inventory.mjs new file mode 100644 index 000000000..a8e32b061 --- /dev/null +++ b/typescript/packages/traceai_genkit/contract/inventory.mjs @@ -0,0 +1,89 @@ +/** + * Span inventory for the pinned genkit version (TH-8240, architecture section 1). + * + * Runs one flow with Genkit's own `mockModel` (genkit/testing) and one tool, + * once with generate() and once with streamFlow, and records every span Genkit + * hands to a span processor passed through `enableTelemetry({ spanProcessors })`. + * No network: GENKIT_TELEMETRY_SERVER is left unset, so Genkit's own + * TraceServerExporter skips the POST, and nothing is exported anywhere else. + * + * Usage: node contract/inventory.mjs [--values] + * Prints JSON: one entry per span with name, genkit:type, subtype, and the + * attribute keys with their JS types. `--values` also prints values (the dump + * then contains the fixture prompt and model output). + */ +import { genkit, z } from 'genkit'; +import { enableTelemetry, flushTracing } from 'genkit/tracing'; +import { mockModel } from 'genkit/testing'; + +const showValues = process.argv.includes('--values'); +const spans = []; +const recorder = { + onStart() {}, + onEnd(span) { + spans.push(span); + }, + forceFlush: async () => {}, + shutdown: async () => {}, +}; + +await enableTelemetry({ spanProcessors: [recorder] }); + +const ai = genkit({}); +const model = mockModel(ai, { + name: 'inventory/mock', + respond: (req, { sendChunk }) => { + const last = req.messages.at(-1); + if (last?.content?.some((p) => p.toolResponse)) { + sendChunk('final '); + return { text: 'final answer', usage: { inputTokens: 21, outputTokens: 4, totalTokens: 25 } }; + } + return { + toolRequests: [{ name: 'lookup', input: { id: 7 } }], + usage: { inputTokens: 11, outputTokens: 3, totalTokens: 14 }, + }; + }, +}); +const lookup = ai.defineTool( + { name: 'lookup', description: 'look up a record', inputSchema: z.object({ id: z.number() }), outputSchema: z.string() }, + async ({ id }) => `record-${id}` +); +const flow = ai.defineFlow({ name: 'inventoryFlow', inputSchema: z.string(), outputSchema: z.string() }, async (q, { sendChunk }) => { + const step = await ai.run('prepare', async () => q.trim()); + const { stream, response } = ai.generateStream({ model, prompt: step, tools: [lookup] }); + for await (const chunk of stream) sendChunk(chunk.text); + return (await response).text; +}); + +await flow(' hello '); +const streamed = flow.stream(' streamed '); +for await (const _ of streamed.stream) { + // drain +} +await streamed.output; +await flushTracing(); + +const out = spans.map((s) => { + const attrs = s.attributes; + const entry = { + name: s.name, + 'genkit:type': attrs['genkit:type'], + 'genkit:metadata:subtype': attrs['genkit:metadata:subtype'], + parentSpanId: s.parentSpanId ?? s.parentSpanContext?.spanId ?? null, + spanId: s.spanContext().spanId, + status: s.status, + events: s.events.map((e) => e.name), + keys: Object.fromEntries(Object.entries(attrs).map(([k, v]) => [k, typeof v])), + readableSpanShape: { + hasParentSpanId: 'parentSpanId' in s, + hasParentSpanContext: 'parentSpanContext' in s, + hasInstrumentationLibrary: 'instrumentationLibrary' in s, + hasInstrumentationScope: 'instrumentationScope' in s, + scope: (s.instrumentationScope ?? s.instrumentationLibrary)?.name, + }, + }; + if (showValues) entry.values = attrs; + return entry; +}); +process.stdout.write(JSON.stringify(out, null, 2) + '\n'); +process.exit(0); diff --git a/typescript/packages/traceai_genkit/contract/run_fixture.mjs b/typescript/packages/traceai_genkit/contract/run_fixture.mjs new file mode 100644 index 000000000..5d87b3a56 --- /dev/null +++ b/typescript/packages/traceai_genkit/contract/run_fixture.mjs @@ -0,0 +1,216 @@ +/** + * Contract fixture for the shared Python harness (python/tests/harness). + * + * Runs real genkit 1.42.0 flows with Genkit's own `mockModel` (genkit/testing) + * and a tool, with the BUILT @traceai/genkit package (imported by package name, + * so the package.json "exports" map is exercised) and the real @traceai/fi-core + * OTLP/HTTP exporter. No model vendor is called: the model is a local mock. + * + * Env: + * FI_BASE_URL, FI_API_KEY, FI_SECRET_KEY, FI_PROJECT_NAME read by fi-core register() + * GENKIT_TELEMETRY_SERVER optional; Genkit's own dev-UI trace exporter target + * JOURNEY tool | stream | error | schema | agent | sigterm | devserver + * FI_HIDE_INPUTS / FI_HIDE_OUTPUTS (and the other FI_HIDE_*) traceAI TraceConfig content switches, + * read by the processor from the environment (content is exported by default) + * SESSION_ID wrap the flow call in fi-core setSession() + * FI_GLOBAL_PROVIDER=1 misconfiguration control: register() as the global provider + * SIGNAL_MODE sigterm journey: helper (flushOnSignals, default) | plain (app listener only) + * + * Prints one JSON line on stdout: {"journey", "result"|"error", "traceIds", ...}. + */ +import { context } from '@opentelemetry/api'; +import { register, ProjectType, setSession } from '@traceai/fi-core'; +import { FIGenkitSpanProcessor, flushOnSignals } from '@traceai/genkit'; +import { genkit, z } from 'genkit'; +import { enableTelemetry, flushTracing } from 'genkit/tracing'; +import { mockModel } from 'genkit/testing'; + +export const PROMPT_MARKER = 'SECRET_PROMPT_MARKER'; +export const OUTPUT_MARKER = 'SECRET_OUTPUT_MARKER'; +export const TOOL_OUTPUT_MARKER = 'SECRET_TOOL_OUTPUT_MARKER'; +export const CHUNK_MARKER = 'SECRET_CHUNK_MARKER'; + +const journey = process.env.JOURNEY || 'tool'; + +// 1. Future AGI provider. setGlobalTracerProvider:false so Genkit's NodeSDK owns the global provider. +const tracerProvider = register({ + projectType: ProjectType.OBSERVE, + setGlobalTracerProvider: process.env.FI_GLOBAL_PROVIDER === '1', +}); + +// 2. Genkit telemetry with our processor appended after Genkit's own telemetry-server processor. +const processor = new FIGenkitSpanProcessor({ tracerProvider }); +await enableTelemetry({ spanProcessors: [processor] }); + +const ai = genkit({}); + +// Model call 1 asks for the tool; model call 2 answers. Usage per call: 11/3/14 and 21/4/25. +const toolModel = mockModel(ai, { + name: 'contract/tool-model', + respond: (request) => { + const last = request.messages.at(-1); + if (last?.content?.some((part) => part.toolResponse)) { + return { text: `final ${OUTPUT_MARKER}`, usage: { inputTokens: 21, outputTokens: 4, totalTokens: 25 } }; + } + return { + toolRequests: [{ name: 'lookup', input: { id: 7 } }], + usage: { inputTokens: 11, outputTokens: 3, totalTokens: 14 }, + }; + }, +}); + +// One streamed call: three chunks, usage 9/6/15. +const streamModel = mockModel(ai, { + name: 'contract/stream-model', + respond: (_request, { sendChunk }) => { + sendChunk('one '); + sendChunk('two '); + sendChunk(CHUNK_MARKER); + return { text: `one two ${CHUNK_MARKER}`, usage: { inputTokens: 9, outputTokens: 6, totalTokens: 15 } }; + }, +}); + +const lookup = ai.defineTool( + { name: 'lookup', description: 'look up a record', inputSchema: z.object({ id: z.number() }), outputSchema: z.string() }, + async ({ id }) => `${TOOL_OUTPUT_MARKER}-${id}` +); +const brokenLookup = ai.defineTool( + { name: 'brokenLookup', description: 'always fails', inputSchema: z.object({ id: z.number() }), outputSchema: z.string() }, + async () => { + throw new Error('lookup exploded'); + } +); +const brokenModel = mockModel(ai, { + name: 'contract/broken-model', + respond: () => ({ toolRequests: [{ name: 'brokenLookup', input: { id: 1 } }], usage: { inputTokens: 5, outputTokens: 1, totalTokens: 6 } }), +}); + +const qaFlow = ai.defineFlow({ name: 'qaFlow', inputSchema: z.string(), outputSchema: z.string() }, async (question) => { + const prepared = await ai.run('prepare', async () => question.trim()); + const response = await ai.generate({ model: toolModel, prompt: prepared, tools: [lookup] }); + return response.text; +}); + +const streamFlow = ai.defineFlow( + { name: 'streamFlow', inputSchema: z.string(), outputSchema: z.string(), streamSchema: z.string() }, + async (question, { sendChunk }) => { + const { stream, response } = ai.generateStream({ model: streamModel, prompt: question }); + for await (const chunk of stream) sendChunk(chunk.text); + return (await response).text; + } +); + +const failingFlow = ai.defineFlow({ name: 'failingFlow', inputSchema: z.string(), outputSchema: z.string() }, async (question) => { + const response = await ai.generate({ model: brokenModel, prompt: question, tools: [brokenLookup] }); + return response.text; +}); + +// Structured output the schema rejects: `answer` must be a string. Genkit's +// ValidationError (@genkit-ai/core src/schema.ts:78) embeds the model output +// after "Provided data:" and instrumentation.ts:156-162 writes that message to +// the generate and flow spans' status and exception events. +export const STRUCTURED_OUTPUT_TEXT = JSON.stringify({ answer: 42, note: 'SECRET_STRUCTURED_OUTPUT_MARKER' }); +const structuredModel = mockModel(ai, { + name: 'contract/structured-model', + respond: () => ({ text: STRUCTURED_OUTPUT_TEXT, usage: { inputTokens: 7, outputTokens: 5, totalTokens: 12 } }), +}); +const structuredFlow = ai.defineFlow({ name: 'structuredFlow', inputSchema: z.string() }, async (question) => { + const response = await ai.generate({ model: structuredModel, prompt: question, output: { schema: z.object({ answer: z.string() }) } }); + return response.output; +}); + +function withSession(fn) { + const sessionId = process.env.SESSION_ID; + if (!sessionId) return fn(); + return context.with(setSession(context.active(), { sessionId }), fn); +} + +function print(payload) { + process.stdout.write(JSON.stringify({ journey, ...payload }) + '\n'); +} + +async function flushAndExit(payload) { + // The documented shutdown path: Genkit's flushTracing() calls forceFlush() on + // every processor in TelemetryConfig.spanProcessors, ours included. + let flushError = null; + try { + await flushTracing(); + } catch (error) { + flushError = String(error); + } + print({ ...payload, flushError }); + process.exit(0); +} + +const prompt = ` ${PROMPT_MARKER} `; + +if (journey === 'tool') { + const started = Date.now(); + const result = await withSession(() => qaFlow(prompt)); + await flushAndExit({ result, flowMillis: Date.now() - started }); +} else if (journey === 'stream') { + const chunks = []; + const streamed = withSession(() => streamFlow.stream(prompt)); + for await (const chunk of streamed.stream) chunks.push(chunk); + const result = await streamed.output; + await flushAndExit({ result, chunks }); +} else if (journey === 'error') { + try { + await failingFlow(prompt); + await flushAndExit({ error: null }); + } catch (error) { + await flushAndExit({ error: String(error && error.message) }); + } +} else if (journey === 'schema') { + try { + const result = await structuredFlow(prompt); + await flushAndExit({ result, error: null }); + } catch (error) { + await flushAndExit({ error: String(error && error.message), modelOutput: STRUCTURED_OUTPUT_TEXT }); + } +} else if (journey === 'agent') { + // Beta agents (genkit/beta defineAgent): Genkit tags the agent span with + // genkit:metadata:agent:sessionId (@genkit-ai/ai src/agent.ts:1061-1063). + const { genkit: genkitBeta } = await import('genkit/beta'); + const beta = genkitBeta({}); + const agentModel = mockModel(beta, { + name: 'contract/agent-model', + respond: () => ({ text: `agent ${OUTPUT_MARKER}`, usage: { inputTokens: 3, outputTokens: 2, totalTokens: 5 } }), + }); + const agent = beta.defineAgent({ name: 'supportAgent', model: agentModel, system: 'Answer briefly.' }); + const chat = agent.chat(); + const response = await chat.send(PROMPT_MARKER); + await flushAndExit({ sessionId: response.sessionId, result: response.text }); +} else if (journey === 'sigterm') { + // AC-06: no explicit flush after the flow; the process is signalled while it is still serving. + // genkit/src/genkit.ts:786-793 registers a SIGTERM listener at import that calls process.exit(0) + // after stopping reflection servers; it does not flush. + setInterval(() => undefined, 1000); // a long-running server keeps the event loop alive + if ((process.env.SIGNAL_MODE || 'helper') === 'helper') { + // Documented path: flush first, then let Genkit's own listeners run (and exit). + flushOnSignals(async () => { + await flushTracing(); + print({ result: globalThis.__result, signal: 'SIGTERM', flushed: true }); + }); + } else { + // Control: an app listener that awaits flushTracing() races Genkit's exit listener. + process.on('SIGTERM', async () => { + await flushTracing(); + print({ result: globalThis.__result, signal: 'SIGTERM', flushed: true }); + process.exit(0); + }); + } + globalThis.__result = await qaFlow(prompt); + process.kill(process.pid, 'SIGTERM'); +} else if (journey === 'devserver') { + // AC-01: GENKIT_ENV=dev starts Genkit's reflection server (what the Dev UI + // drives). The harness calls /api/runAction, then sends SIGTERM. + flushOnSignals(async () => { + await flushTracing(); + print({ signal: 'SIGTERM', flushed: true }); + }); + print({ ready: true, pid: process.pid }); + setInterval(() => undefined, 1000); +} else { + throw new Error(`unknown JOURNEY ${journey}`); +} diff --git a/typescript/packages/traceai_genkit/contract/test_harness_contract.py b/typescript/packages/traceai_genkit/contract/test_harness_contract.py new file mode 100644 index 000000000..864729c98 --- /dev/null +++ b/typescript/packages/traceai_genkit/contract/test_harness_contract.py @@ -0,0 +1,803 @@ +"""Shared-harness contract tests for @traceai/genkit (TH-8240). + +The package is TypeScript. Each test starts the shared loopback Receiver +(python/tests/harness), runs `node contract/run_fixture.mjs`, and reads what the +real @traceai/fi-core OTLP/HTTP exporter posted to `{origin}/tracer/v1/traces`. +The fixture runs real genkit 1.42.0 flows on Genkit's own `mockModel` +(genkit/testing): no model vendor, no GCP, no network beyond 127.0.0.1. + +A second loopback server stands in for Genkit's telemetry server (the Dev UI +trace store, POST /api/traces) so the tests can show Genkit's own exporter keeps +working next to FIGenkitSpanProcessor. + +Run from the repo root: + PYTHONPATH=python/tests uv run --no-project --python 3.11 --with pytest \\ + --with protobuf --with opentelemetry-proto \\ + pytest typescript/packages/traceai_genkit/contract -q -p no:cacheprovider --noconftest -o addopts='' + +NODE_BINARY selects the node used for fixtures; TRACEAI_NODE_MATRIX (os.pathsep +separated node paths) widens the entry-point test. +""" + +from __future__ import annotations + +import hashlib +import json +import os +import shutil +import signal +import subprocess +import sys +import tarfile +import threading +import time +import urllib.request +from http.server import BaseHTTPRequestHandler, ThreadingHTTPServer +from pathlib import Path +from typing import Any, Dict, Iterator, List, Optional + +import pytest + +PKG_DIR = Path(__file__).resolve().parents[1] +REPO_ROOT = PKG_DIR.parents[2] +sys.path.insert(0, str(REPO_ROOT / "python" / "tests")) + +from harness import Receiver, run # noqa: E402 + +NODE = os.environ.get("NODE_BINARY") or shutil.which("node") or "node" +PNPM = shutil.which("pnpm") or "pnpm" +FIXTURE = PKG_DIR / "contract" / "run_fixture.mjs" +INVENTORY = PKG_DIR / "contract" / "inventory.mjs" +GENKIT_DIR = PKG_DIR / "node_modules" / "genkit" + +PROJECT = "th8240-harness-contract" +PLACEHOLDER_API_KEY = "contract-api-key-PLACEHOLDER" +PLACEHOLDER_SECRET_KEY = "contract-secret-key-PLACEHOLDER" +CONTENT_MARKERS = ( + "SECRET_PROMPT_MARKER", + "SECRET_OUTPUT_MARKER", + "SECRET_TOOL_OUTPUT_MARKER", + "SECRET_CHUNK_MARKER", + "SECRET_STRUCTURED_OUTPUT_MARKER", +) +REDACTED = "__REDACTED__" # fi-core REDACTED_VALUE +# The documented opt-out (traceAI TraceConfig): content is exported by default, these env vars hide it. +HIDE_ENV = {"FI_HIDE_INPUTS": "true", "FI_HIDE_OUTPUTS": "true"} +PROMOTED_EXACT = { + "gen_ai.usage.input_tokens", + "gen_ai.usage.output_tokens", + "gen_ai.usage.total_tokens", +} +PROMOTED_PREFIXES = ("gen_ai.usage.", "llm.token_count.", "llm.usage.", "gen_ai.cost.", "llm.cost.") +# Inventory at genkit 1.42.0 (contract/inventory.mjs): mockModel spans carry +# usage.inputTokens/outputTokens/totalTokens in genkit:output. thoughtsTokens and +# cachedContentTokens are mapped too (the google-genai plugin sets them), but the +# mock model never reports them, so the keys they map to must be absent here. +UNAVAILABLE_ON_FIXTURE = ("gen_ai.usage.output_tokens.reasoning", "gen_ai.usage.cache_read_tokens") + + +# --------------------------------------------------------------------------- helpers + + +def _check(result: subprocess.CompletedProcess, what: str) -> None: + assert not getattr(result, "timed_out", False), f"{what} timed out\n{result.stderr.decode()}" + assert result.returncode == 0, ( + f"{what} exited {result.returncode}\nstdout:\n{result.stdout.decode()}\nstderr:\n{result.stderr.decode()}" + ) + + +def _base_env() -> Dict[str, str]: + return { + "PATH": os.environ.get("PATH", ""), + "HOME": os.environ.get("HOME", ""), + "NO_PROXY": "127.0.0.1,localhost", + "no_proxy": "127.0.0.1,localhost", + } + + +def _fixture_env(receiver_origin: str, journey: str, extra: Optional[Dict[str, str]] = None) -> Dict[str, str]: + env = _base_env() + env.update( + { + "FI_BASE_URL": receiver_origin, # fi-core appends /tracer/v1/traces + "FI_API_KEY": PLACEHOLDER_API_KEY, + "FI_SECRET_KEY": PLACEHOLDER_SECRET_KEY, + "FI_PROJECT_NAME": PROJECT, + "JOURNEY": journey, + } + ) + env.update(extra or {}) + return env + + +def _last_json_line(stdout: bytes) -> Dict[str, Any]: + lines = [line for line in stdout.decode("utf-8").splitlines() if line.startswith("{")] + assert lines, f"no JSON line on stdout: {stdout!r}" + return json.loads(lines[-1]) + + +def _value(value: Dict[str, Any]) -> Any: + for key in ("stringValue", "boolValue", "doubleValue"): + if key in value: + return value[key] + if "intValue" in value: + return int(value["intValue"]) + if "arrayValue" in value: + return [_value(v) for v in value["arrayValue"].get("values", [])] + return value + + +def _attrs(span: Dict[str, Any]) -> Dict[str, Any]: + return {item["key"]: _value(item["value"]) for item in span.get("attributes", [])} + + +def _status_code(span: Dict[str, Any]) -> int: + code = span.get("status", {}).get("code", 0) + names = {"STATUS_CODE_UNSET": 0, "STATUS_CODE_OK": 1, "STATUS_CODE_ERROR": 2} + return names[code] if isinstance(code, str) else int(code) + + +def _by_name(spans: List[Dict[str, Any]], name: str) -> List[Dict[str, Any]]: + return [span for span in spans if span["name"] == name] + + +def _one(spans: List[Dict[str, Any]], name: str) -> Dict[str, Any]: + matches = _by_name(spans, name) + assert len(matches) == 1, f"expected one {name}, got {[s['name'] for s in spans]}" + return matches[0] + + +def _is_promoted(key: str) -> bool: + return key in PROMOTED_EXACT or key.startswith(PROMOTED_PREFIXES) + + +def _assert_collector_contract(requests: List[Dict[str, Any]]) -> None: + assert requests, "exporter sent nothing" + for request in requests: + assert request["path"] == "/tracer/v1/traces" + headers = request["headers"] + assert headers["x-api-key"] == PLACEHOLDER_API_KEY + assert headers["x-secret-key"] == PLACEHOLDER_SECRET_KEY + assert "authorization" not in headers + assert request["resource_attributes"] + for resource in request["resource_attributes"]: + assert resource["project_name"] == PROJECT + assert resource["project_type"] == "observe" + + +def _local_identity() -> List[str]: + """Strings that must never be exported in either mode: home and working directories, user and host names.""" + import getpass + import socket + + values = [os.path.expanduser("~"), os.getcwd(), str(REPO_ROOT)] + try: + values.append(getpass.getuser()) + except Exception: # noqa: BLE001 + pass + host = socket.gethostname() + values += [host, host.split(".")[0]] + return [v for v in values if v and len(v) >= 3 and v.lower() != "localhost"] + + +def _assert_no_local_identity(spans: List[Dict[str, Any]]) -> None: + """Never exported, content on or off: stack traces, local paths, user and host names, credentials.""" + blob = json.dumps(spans) + for value in _local_identity(): + assert value not in blob, value + for span in spans: + for event in span.get("events", []): + keys = {i["key"] for i in event.get("attributes", [])} + assert "exception.stacktrace" not in keys, (span["name"], event["name"]) + assert " at " not in blob # no V8 stack frame + assert PLACEHOLDER_API_KEY not in blob and PLACEHOLDER_SECRET_KEY not in blob + + +def _assert_no_content(spans: List[Dict[str, Any]]) -> None: + """Content hidden with FI_HIDE_INPUTS / FI_HIDE_OUTPUTS: no marker anywhere, no raw genkit content keys.""" + blob = json.dumps(spans) + for marker in CONTENT_MARKERS: + assert marker not in blob, marker + for span in spans: + attrs = _attrs(span) + for key in ("genkit:input", "genkit:output", "genkit:init", "genkit:metadata:context", "input.mime_type", "output.mime_type"): + assert key not in attrs, (span["name"], key) + for key in ("input.value", "output.value"): + assert attrs.get(key, REDACTED) == REDACTED, (span["name"], key) + _assert_no_local_identity(spans) + + +class TelemetryServerStandIn: + """Loopback stand-in for Genkit's telemetry server (`POST {GENKIT_TELEMETRY_SERVER}/api/traces`).""" + + def __init__(self) -> None: + self.posts: List[Dict[str, Any]] = [] + self._lock = threading.Lock() + owner = self + + class Handler(BaseHTTPRequestHandler): + def do_POST(self) -> None: # noqa: N802 + length = int(self.headers.get("Content-Length", "0")) + body = self.rfile.read(length) + try: + payload = json.loads(body.decode("utf-8")) if body else None + except ValueError: + payload = None + with owner._lock: + owner.posts.append({"path": self.path, "body": payload}) + self.send_response(200) + self.send_header("Content-Length", "0") + self.end_headers() + + def log_message(self, _format: str, *args: Any) -> None: + return + + self._server = ThreadingHTTPServer(("127.0.0.1", 0), Handler) + self.origin = f"http://127.0.0.1:{self._server.server_port}" + self._thread = threading.Thread(target=self._server.serve_forever, daemon=True) + self._thread.start() + + def traces(self) -> List[Dict[str, Any]]: + with self._lock: + return [post["body"] for post in self.posts if post["path"] == "/api/traces" and post["body"]] + + def spans(self) -> List[Dict[str, Any]]: + out: List[Dict[str, Any]] = [] + for trace in self.traces(): + out.extend(trace.get("spans", {}).values()) + return out + + def close(self) -> None: + self._server.shutdown() + self._server.server_close() + self._thread.join() + + +# --------------------------------------------------------------------------- fixtures + + +@pytest.fixture(scope="session") +def built_package() -> Path: + """Build dist/ (CJS + ESM) from the current sources; the fixture imports the built package by name.""" + result = run([PNPM, "--dir", str(PKG_DIR), "run", "build"], env=_base_env(), stdin=None, timeout=300) + _check(result, "pnpm run build") + assert (PKG_DIR / "dist" / "src" / "index.js").is_file() + assert (PKG_DIR / "dist" / "esm" / "index.js").is_file() + return PKG_DIR + + +@pytest.fixture(scope="session") +def tool_run(built_package: Path) -> Dict[str, Any]: + """One `qaFlow` run (prepare step, generate with a tool loop: 2 model calls, 1 tool) with a session id.""" + stand_in = TelemetryServerStandIn() + try: + with Receiver() as receiver: + env = _fixture_env( + receiver.origin, "tool", {"SESSION_ID": "sess-contract-1", "GENKIT_TELEMETRY_SERVER": stand_in.origin} + ) + result = run([NODE, str(FIXTURE)], env=env, stdin=None, timeout=90) + _check(result, "node run_fixture.mjs (tool)") + spans = receiver.spans() + requests = receiver.requests() + finally: + stand_in.close() + return {"output": _last_json_line(result.stdout), "spans": spans, "requests": requests, "genkit_spans": stand_in.spans()} + + +# --------------------------------------------------------------------------- tests + + +def test_tool_flow_reaches_collector_path_with_kinds_parenting_model_and_tokens(tool_run: Dict[str, Any]) -> None: + output, spans = tool_run["output"], tool_run["spans"] + assert output["result"] == "final SECRET_OUTPUT_MARKER" + assert output["flushError"] is None + _assert_collector_contract(tool_run["requests"]) + + assert sorted(s["name"] for s in spans) == sorted( + ["qaFlow", "prepare", "generate", "generate", "contract/tool-model", "contract/tool-model", "lookup"] + ) + assert len({s["traceId"] for s in spans}) == 1 + by_id = {s["spanId"]: s for s in spans} + + flow = _one(spans, "qaFlow") + prepare = _one(spans, "prepare") + tool = _one(spans, "lookup") + models = _by_name(spans, "contract/tool-model") + generates = _by_name(spans, "generate") + + # Parenting: flow is the root; prepare and the outer generate are its children. + assert not flow.get("parentSpanId") + assert prepare["parentSpanId"] == flow["spanId"] + outer = [g for g in generates if g["parentSpanId"] == flow["spanId"]] + inner = [g for g in generates if g["parentSpanId"] != flow["spanId"]] + assert len(outer) == 1 and len(inner) == 1 and inner[0]["parentSpanId"] == outer[0]["spanId"] + assert tool["parentSpanId"] == outer[0]["spanId"] + assert sorted(by_id[m["parentSpanId"]]["spanId"] for m in models) == sorted([outer[0]["spanId"], inner[0]["spanId"]]) + + # Kinds: fi.span.kind (read first by the collector) and gen_ai.span.kind. + def kinds(span: Dict[str, Any]) -> tuple: + a = _attrs(span) + return a.get("fi.span.kind"), a.get("gen_ai.span.kind") + + assert kinds(flow) == ("CHAIN", "CHAIN") + assert kinds(prepare) == ("CHAIN", "CHAIN") + assert all(kinds(g) == ("CHAIN", "CHAIN") for g in generates) + assert all(kinds(m) == ("LLM", "LLM") for m in models) + assert kinds(tool) == ("TOOL", "TOOL") + for span in spans: + assert span["kind"] in (1, "SPAN_KIND_INTERNAL") + assert _status_code(span) == 0 # Genkit leaves success spans UNSET + + # Model, tokens, finish reason: per model call, from genkit:name and genkit:output.usage. + usage = sorted( + ( + _attrs(m)["gen_ai.usage.input_tokens"], + _attrs(m)["gen_ai.usage.output_tokens"], + _attrs(m)["gen_ai.usage.total_tokens"], + ) + for m in models + ) + assert usage == [(11, 3, 14), (21, 4, 25)] + for model in models: + a = _attrs(model) + assert a["gen_ai.request.model"] == "tool-model" + assert "gen_ai.provider.name" not in a # "contract" is not a known model plugin + assert a["genkit:name"] == "contract/tool-model" + assert a["gen_ai.response.finish_reasons"] == ["stop"] + for key in UNAVAILABLE_ON_FIXTURE: + assert key not in a + t = _attrs(tool) + assert t["tool.name"] == "lookup" and t["gen_ai.tool.name"] == "lookup" + + # Session set by the app with fi-core setSession() around the flow call. + for span in spans: + assert _attrs(span)["session.id"] == "sess-contract-1" + + +def test_promoted_tokens_only_on_model_calls_and_trace_sum_equals_model_calls(tool_run: Dict[str, Any]) -> None: + spans = tool_run["spans"] + for span in spans: + a = _attrs(span) + promoted = [k for k in a if _is_promoted(k)] + if a.get("fi.span.kind") == "LLM": + assert "gen_ai.usage.input_tokens" in promoted + else: + assert promoted == [], (span["name"], promoted) + total_input = sum(_attrs(s).get("gen_ai.usage.input_tokens", 0) for s in spans) + total_output = sum(_attrs(s).get("gen_ai.usage.output_tokens", 0) for s in spans) + total = sum(_attrs(s).get("gen_ai.usage.total_tokens", 0) for s in spans) + # The mock model reported 11 + 21 input, 3 + 4 output, 14 + 25 total. The generate + # spans' own output repeats the last turn's usage (21/4/25); it must not be summed. + assert (total_input, total_output, total) == (32, 7, 39) + + +def test_content_is_exported_by_default_like_every_traceai_instrumentor(tool_run: Dict[str, Any]) -> None: + """traceAI TraceConfig default (fi-core DEFAULT_HIDE_* = false): inputs and outputs are exported.""" + spans = tool_run["spans"] + flow = _attrs(_one(spans, "qaFlow")) + tool = _attrs(_one(spans, "lookup")) + assert "SECRET_PROMPT_MARKER" in flow["input.value"] + assert "SECRET_OUTPUT_MARKER" in flow["output.value"] + assert flow["input.mime_type"] == "application/json" + assert "SECRET_TOOL_OUTPUT_MARKER" in tool["output.value"] + models = [_attrs(m) for m in _by_name(spans, "contract/tool-model")] + assert all("SECRET_PROMPT_MARKER" in m["input.value"] for m in models) + assert "genkit:metadata:context" not in flow # request context: never exported + _assert_no_local_identity(spans) + + +def test_genkit_own_trace_export_keeps_working_and_sees_unmodified_spans(tool_run: Dict[str, Any]) -> None: + """AC-01 (prod mode): Genkit's TraceServerExporter still receives every span, content intact.""" + genkit_spans = tool_run["genkit_spans"] + fi_spans = tool_run["spans"] + assert {s["spanId"] for s in genkit_spans} == {s["spanId"] for s in fi_spans} + flow = [s for s in genkit_spans if s["displayName"] == "qaFlow"][0] + assert "SECRET_PROMPT_MARKER" in flow["attributes"]["genkit:input"] + assert "fi.span.kind" not in flow["attributes"] # our mapping went to a copy, not Genkit's span + + +def test_fi_hide_inputs_and_outputs_hide_content_and_keep_kinds_and_tokens(built_package: Path) -> None: + """The documented opt-out: FI_HIDE_INPUTS=true + FI_HIDE_OUTPUTS=true in the environment.""" + with Receiver() as receiver: + result = run([NODE, str(FIXTURE)], env=_fixture_env(receiver.origin, "tool", HIDE_ENV), stdin=None, timeout=90) + _check(result, "node run_fixture.mjs (tool, FI_HIDE_INPUTS/OUTPUTS)") + spans = receiver.spans() + _assert_no_content(spans) + flow = _attrs(_one(spans, "qaFlow")) + assert flow["input.value"] == REDACTED and flow["output.value"] == REDACTED + models = [_attrs(m) for m in _by_name(spans, "contract/tool-model")] + assert sorted((m["gen_ai.usage.input_tokens"], m["gen_ai.usage.output_tokens"]) for m in models) == [(11, 3), (21, 4)] + assert all(m["fi.span.kind"] == "LLM" and m["gen_ai.request.model"] == "tool-model" for m in models) + assert _attrs(_one(spans, "lookup"))["tool.name"] == "lookup" + + +def test_stream_flow_has_one_closed_model_span(built_package: Path) -> None: + """AC-05: flow.stream() (streamFlow) produces one model span, ended, with usage.""" + with Receiver() as receiver: + result = run([NODE, str(FIXTURE)], env=_fixture_env(receiver.origin, "stream"), stdin=None, timeout=90) + _check(result, "node run_fixture.mjs (stream)") + spans = receiver.spans() + _assert_collector_contract(receiver.requests()) + output = _last_json_line(result.stdout) + assert output["chunks"] == ["one ", "two ", "SECRET_CHUNK_MARKER"] + assert output["result"] == "one two SECRET_CHUNK_MARKER" + + models = [s for s in spans if _attrs(s).get("fi.span.kind") == "LLM"] + assert len(models) == 1 + model = models[0] + assert model["name"] == "contract/stream-model" + assert int(model["endTimeUnixNano"]) >= int(model["startTimeUnixNano"]) > 0 + a = _attrs(model) + assert (a["gen_ai.usage.input_tokens"], a["gen_ai.usage.output_tokens"], a["gen_ai.usage.total_tokens"]) == (9, 6, 15) + flow = _one(spans, "streamFlow") + assert _attrs(flow)["fi.span.kind"] == "CHAIN" + generate = _one(spans, "generate") + assert model["parentSpanId"] == generate["spanId"] and generate["parentSpanId"] == flow["spanId"] + assert "SECRET_CHUNK_MARKER" in a["output.value"] # content on by default: the streamed answer + _assert_no_local_identity(spans) + + +def test_throwing_action_marks_error_with_exception_event(built_package: Path) -> None: + """AC-07: a tool throws; Genkit's span status is ERROR with an exception event, root included.""" + with Receiver() as receiver: + result = run([NODE, str(FIXTURE)], env=_fixture_env(receiver.origin, "error"), stdin=None, timeout=90) + _check(result, "node run_fixture.mjs (error)") + spans = receiver.spans() + output = _last_json_line(result.stdout) + assert output["error"] == "lookup exploded" + + root = _one(spans, "failingFlow") + tool = _one(spans, "brokenLookup") + assert not root.get("parentSpanId") + for span in (root, tool): + assert _status_code(span) == 2, span["name"] + assert span["status"].get("message") == "lookup exploded" + events = [e for e in span.get("events", []) if e["name"] == "exception"] + assert len(events) == 1, span["name"] + event_attrs = {i["key"]: _value(i["value"]) for i in events[0].get("attributes", [])} + assert event_attrs["exception.message"] == "lookup exploded" + assert _attrs(tool)["genkit:state"] == "error" + assert _attrs(tool)["fi.span.kind"] == "TOOL" + # Genkit marks only the first failing span as the failure source (instrumentation.ts:164-172). + assert _attrs(tool)["genkit:isFailureSource"] is True + assert "genkit:isFailureSource" not in _attrs(root) + _assert_no_local_identity(spans) # the exception events lose exception.stacktrace + + +def test_throwing_action_with_content_hidden_exports_error_type_only(built_package: Path) -> None: + """With FI_HIDE_INPUTS / FI_HIDE_OUTPUTS the error message (which can quote user data) is replaced.""" + with Receiver() as receiver: + result = run([NODE, str(FIXTURE)], env=_fixture_env(receiver.origin, "error", HIDE_ENV), stdin=None, timeout=90) + _check(result, "node run_fixture.mjs (error, hidden)") + spans = receiver.spans() + assert _last_json_line(result.stdout)["error"] == "lookup exploded" # the app still gets the full error + assert "lookup exploded" not in json.dumps(spans) + for span in (_one(spans, "failingFlow"), _one(spans, "brokenLookup")): + assert _status_code(span) == 2, span["name"] + assert span["status"]["message"] == f"Error: {REDACTED}", span["status"] + events = _exception_events(span) + assert events == [{"exception.type": "Error", "exception.message": REDACTED}], events + _assert_no_content(spans) + + +def _exception_events(span: Dict[str, Any]) -> List[Dict[str, Any]]: + return [ + {i["key"]: _value(i["value"]) for i in e.get("attributes", [])} for e in span.get("events", []) if e["name"] == "exception" + ] + + +def _run_schema_journey(extra: Optional[Dict[str, str]] = None) -> Dict[str, Any]: + with Receiver() as receiver: + result = run([NODE, str(FIXTURE)], env=_fixture_env(receiver.origin, "schema", extra), stdin=None, timeout=90) + _check(result, "node run_fixture.mjs (schema)") + spans = receiver.spans() + output = _last_json_line(result.stdout) + # Control: Genkit's ValidationError really carried the model output after "Provided data:". + assert "Schema validation failed" in output["error"], output + assert "Provided data:" in output["error"] and "SECRET_STRUCTURED_OUTPUT_MARKER" in output["error"], output + return {"output": output, "spans": spans} + + +def test_schema_validation_error_does_not_export_model_output_with_content_hidden(built_package: Path) -> None: + """N1: ai.generate with an output schema gets non-matching JSON from the model. Genkit's + ValidationError embeds that output in the error message, which Genkit writes to span status + and exception events. With FI_HIDE_INPUTS / FI_HIDE_OUTPUTS the model output must appear nowhere.""" + run_ = _run_schema_journey(HIDE_ENV) + spans, model_output = run_["spans"], run_["output"]["modelOutput"] + blob = json.dumps(spans) + assert "SECRET_STRUCTURED_OUTPUT_MARKER" not in blob + assert model_output not in blob and json.dumps(model_output) not in blob + assert "Provided data:" not in blob + _assert_no_content(spans) + + flow = _one(spans, "structuredFlow") + generate = _one(spans, "generate") + for span in (flow, generate): + assert _status_code(span) == 2, span["name"] + # Kept as recorded: sdk-trace-base 1.25 Span.recordException uses `error.code` first + # (GenkitError.code is the HTTP status, 400 for INVALID_ARGUMENT). + assert span["status"]["message"] == f"400: {REDACTED}", span["status"] + events = _exception_events(span) + assert events == [{"exception.type": "400", "exception.message": REDACTED}], (span["name"], events) + assert _attrs(generate)["genkit:isFailureSource"] is True + + +def test_schema_validation_error_keeps_data_by_default_but_never_the_stack_trace(built_package: Path) -> None: + """Control for N1: with content on (the default) the error message is exported; the stack trace is not.""" + spans = _run_schema_journey()["spans"] + generate = _one(spans, "generate") + assert "Provided data:" in generate["status"]["message"] + assert "SECRET_STRUCTURED_OUTPUT_MARKER" in generate["status"]["message"] + events = _exception_events(generate) + assert "SECRET_STRUCTURED_OUTPUT_MARKER" in events[0]["exception.message"] + assert "exception.stacktrace" not in events[0] + _assert_no_local_identity(spans) + + +def test_beta_agent_session_id_maps_to_session_id(built_package: Path) -> None: + """Session: the native key at 1.42.0 is genkit:metadata:agent:sessionId on the beta agent span.""" + with Receiver() as receiver: + result = run([NODE, str(FIXTURE)], env=_fixture_env(receiver.origin, "agent", HIDE_ENV), stdin=None, timeout=90) + _check(result, "node run_fixture.mjs (agent, content hidden)") + spans = receiver.spans() + _assert_collector_contract(receiver.requests()) + output = _last_json_line(result.stdout) + session_id = output["sessionId"] + assert session_id and output["result"] == "agent SECRET_OUTPUT_MARKER" + + agent = _one(spans, "supportAgent") + a = _attrs(agent) + assert not agent.get("parentSpanId") + assert (a["fi.span.kind"], a["gen_ai.span.kind"]) == ("AGENT", "AGENT") + assert a["session.id"] == session_id + assert a["genkit:metadata:agent:sessionId"] == session_id + assert "genkit:init" not in a # agent init state is input content, hidden by FI_HIDE_INPUTS + model = _one(spans, "contract/agent-model") + m = _attrs(model) + assert (m["fi.span.kind"], m["gen_ai.usage.input_tokens"], m["gen_ai.usage.output_tokens"]) == ("LLM", 3, 2) + assert _attrs(_one(spans, "render"))["fi.span.kind"] == "CHAIN" # genkit:type=promptTemplate + # Only the agent span carries the native session id; child spans do not. + assert [s["name"] for s in spans if "session.id" in _attrs(s)] == ["supportAgent"] + _assert_no_content(spans) + + +def test_sigterm_flush_on_signals_delivers_every_span(built_package: Path) -> None: + """AC-06: no explicit flush after the flow; SIGTERM -> flushOnSignals(flushTracing) -> zero spans dropped.""" + with Receiver() as receiver: + result = run([NODE, str(FIXTURE)], env=_fixture_env(receiver.origin, "sigterm"), stdin=None, timeout=90) + _check(result, "node run_fixture.mjs (sigterm)") # exit 0 comes from Genkit's own listener + spans = receiver.spans() + output = _last_json_line(result.stdout) + assert output["signal"] == "SIGTERM" and output["flushed"] is True + assert output["result"] == "final SECRET_OUTPUT_MARKER" + assert sorted(s["name"] for s in spans) == sorted( + ["qaFlow", "prepare", "generate", "generate", "contract/tool-model", "contract/tool-model", "lookup"] + ) + assert len({s["spanId"] for s in spans}) == 7 + + +def test_sigterm_app_listener_loses_the_race_with_genkit_exit(built_package: Path) -> None: + """Control for AC-06: an app SIGTERM listener that awaits flushTracing() never finishes, because + genkit's module-level listener (genkit/src/genkit.ts:786-793) calls process.exit(0) first.""" + with Receiver() as receiver: + result = run([NODE, str(FIXTURE)], env=_fixture_env(receiver.origin, "sigterm", {"SIGNAL_MODE": "plain"}), stdin=None, timeout=90) + _check(result, "node run_fixture.mjs (sigterm, plain listener)") + delivered = len(receiver.spans()) + assert b'"flushed":true' not in result.stdout + # Not asserted: how many of the 7 spans made it (observed 6 or 7 on a loopback collector). + print(f"plain SIGTERM listener: {delivered}/7 spans delivered") + + +def test_collector_down_never_breaks_the_flow(built_package: Path) -> None: + """Exporter failure: the flow returns, flushTracing() resolves, the process exits 0.""" + with Receiver() as receiver: + dead = receiver.origin + # The receiver is closed: the port now refuses connections. + started = time.monotonic() + result = run([NODE, str(FIXTURE)], env=_fixture_env(dead, "tool"), stdin=None, timeout=120) + elapsed = time.monotonic() - started + _check(result, "node run_fixture.mjs (collector down)") + output = _last_json_line(result.stdout) + assert output["result"] == "final SECRET_OUTPUT_MARKER" + assert output["flushError"] is None + assert elapsed < 60 + + +def test_global_provider_misconfiguration_is_warned_and_bypasses_mapping(built_package: Path) -> None: + """Control for the setup deviation: register() with the default setGlobalTracerProvider=true. + + Genkit's NodeSDK then cannot register its provider, Genkit uses the fi-core + provider directly, and raw spans (content included, no kind) reach the + collector. The processor warns at construction. + """ + with Receiver() as receiver: + result = run([NODE, str(FIXTURE)], env=_fixture_env(receiver.origin, "tool", {"FI_GLOBAL_PROVIDER": "1"}), stdin=None, timeout=90) + _check(result, "node run_fixture.mjs (global provider)") + spans = receiver.spans() + assert b"TRACEAI_GENKIT_GLOBAL_PROVIDER" in result.stderr + assert spans + assert all("fi.span.kind" not in _attrs(s) for s in spans) + assert "SECRET_PROMPT_MARKER" in json.dumps(spans) + + +def _wait_for_runtime_file(project: Path, deadline: float) -> Dict[str, Any]: + runtimes = project / ".genkit" / "runtimes" + while time.monotonic() < deadline: + for path in runtimes.glob("*.json") if runtimes.exists() else []: + try: + return json.loads(path.read_text()) + except ValueError: + pass + time.sleep(0.1) + raise AssertionError("Genkit reflection server never wrote its runtime file") + + +def test_dev_runtime_reflection_server_and_telemetry_server_still_work(built_package: Path, tmp_path: Path) -> None: + """AC-01 (dev mode): GENKIT_ENV=dev, the reflection server the Dev UI drives starts, runAction works, + Genkit's telemetry-server exporter gets the trace, and Future AGI gets the mapped copy.""" + project = tmp_path / "genkit-app" + project.mkdir() + (project / "package.json").write_text('{"name": "genkit-app", "private": true}') + stand_in = TelemetryServerStandIn() + try: + with Receiver() as receiver: + env = _fixture_env(receiver.origin, "devserver", {"GENKIT_ENV": "dev", "GENKIT_TELEMETRY_SERVER": stand_in.origin}) + process = subprocess.Popen([NODE, str(FIXTURE)], env=env, cwd=project, stdout=subprocess.PIPE, stderr=subprocess.PIPE) + try: + runtime = _wait_for_runtime_file(project, time.monotonic() + 60) + base = runtime["reflectionServerUrl"].replace("localhost", "127.0.0.1") + opener = urllib.request.build_opener(urllib.request.ProxyHandler({})) + with opener.open(f"{base}/api/__health", timeout=10) as response: + assert response.status == 200 + request = urllib.request.Request( + f"{base}/api/runAction", + data=json.dumps({"key": "/flow/qaFlow", "input": " dev ui question "}).encode(), + headers={"Content-Type": "application/json"}, + method="POST", + ) + with opener.open(request, timeout=60) as response: + run_action = json.loads(response.read().decode()) + trace_id = run_action["telemetry"]["traceId"] + assert run_action["result"] == "final SECRET_OUTPUT_MARKER" + # Genkit's telemetry-server exporter posts asynchronously: its flushTracing() does not wait + # for in-flight posts (sdk-trace-base 1.25 SimpleSpanProcessor). The Dev UI reads the trace + # later, so wait for it here before stopping the app. + deadline = time.monotonic() + 20 + while time.monotonic() < deadline: + if len({s["spanId"] for s in stand_in.spans() if s["traceId"] == trace_id}) >= 7: + break + time.sleep(0.1) + process.send_signal(signal.SIGTERM) + stdout, stderr = process.communicate(timeout=60) + assert b'"flushed":true' in stdout + finally: + if process.poll() is None: + process.kill() + process.communicate() + assert process.returncode == 0, stderr.decode() + fi_spans = receiver.spans() + _assert_collector_contract(receiver.requests()) + finally: + stand_in.close() + + genkit_spans = stand_in.spans() + assert {s["traceId"] for s in genkit_spans} >= {trace_id} + genkit_ids = {s["spanId"] for s in genkit_spans if s["traceId"] == trace_id} + fi_ids = {s["spanId"] for s in fi_spans if s["traceId"] == trace_id} + assert len(genkit_ids) == 7 and genkit_ids == fi_ids + assert all(_attrs(s).get("fi.span.kind") for s in fi_spans if s["traceId"] == trace_id) + _assert_no_local_identity(fi_spans) + + +def test_inventory_types_are_all_mapped(built_package: Path) -> None: + """Drift check: every (genkit:type, subtype) the pinned genkit emits for the fixture has a kind, + and every genkit:* key it emits is in GenkitAttributes.""" + result = run([NODE, str(INVENTORY)], env=_base_env(), stdin=None, timeout=90) + _check(result, "node inventory.mjs") + inventory = json.loads(result.stdout.decode()) + check = ( + "const m=require(process.argv[1]);const inv=JSON.parse(require('fs').readFileSync(0,'utf8'));" + "const known=new Set(Object.values(m.GenkitAttributes));const out=inv.map(s=>({name:s.name," + "kind:m.genkitSpanKind({'genkit:type':s['genkit:type'],'genkit:metadata:subtype':s['genkit:metadata:subtype']})||null," + "unknownKeys:Object.keys(s.keys).filter(k=>!known.has(k))}));process.stdout.write(JSON.stringify(out));" + ) + mapped = subprocess.run( + [NODE, "-e", check, str(PKG_DIR)], input=result.stdout, capture_output=True, env=_base_env(), timeout=60, check=True + ) + rows = json.loads(mapped.stdout.decode()) + assert len(rows) == len(inventory) == 14 + for row in rows: + assert row["kind"] is not None, row + assert row["unknownKeys"] == [], row + assert {s["genkit:type"] for s in inventory} == {"action", "flowStep", "util"} + assert {s.get("genkit:metadata:subtype") for s in inventory if s["genkit:type"] == "action"} == {"flow", "model", "tool"} + + +def test_genkit_is_apache_2_peer_dependency(built_package: Path) -> None: + manifest = json.loads((GENKIT_DIR / "package.json").read_text()) + assert manifest["version"] == "1.42.0" + assert manifest["license"] == "Apache-2.0" + assert "Apache License" in (GENKIT_DIR / "LICENSE").read_text()[:200] + ours = json.loads((PKG_DIR / "package.json").read_text()) + assert ours["peerDependencies"] == {"genkit": "^1.42.0"} + assert "genkit" not in ours["dependencies"] + assert ours["devDependencies"]["genkit"] == "1.42.0" + + +def _sha256(data: bytes) -> str: + return hashlib.sha256(data).hexdigest() + + +def _genkit_file_hashes() -> Dict[str, str]: + """Hash every file of the installed genkit, @genkit-ai/core and @genkit-ai/ai.""" + hashes: Dict[str, str] = {} + store = GENKIT_DIR.resolve().parent # node_modules dir inside the pnpm store entry + roots = [GENKIT_DIR.resolve(), (store / "@genkit-ai" / "ai").resolve(), (store / "@genkit-ai" / "core").resolve()] + for root in roots: + assert root.is_dir(), root + for file in root.rglob("*"): + if file.is_file() and "node_modules" not in file.relative_to(root).parts: + hashes[_sha256(file.read_bytes())] = str(file) + return hashes + + +def test_packed_tarball_has_no_genkit_sources(built_package: Path, tmp_path: Path) -> None: + result = run([PNPM, "--dir", str(PKG_DIR), "pack", "--pack-destination", str(tmp_path)], env=_base_env(), stdin=None, timeout=300) + _check(result, "pnpm pack") + tarballs = list(tmp_path.glob("*.tgz")) + assert len(tarballs) == 1, tarballs + genkit_hashes = _genkit_file_hashes() + assert len(genkit_hashes) > 100, "installed genkit not found; cannot compare" + with tarfile.open(tarballs[0]) as tar: + members = [m for m in tar.getmembers() if m.isfile()] + manifest = json.loads(tar.extractfile("package/package.json").read()) # type: ignore[union-attr] + for member in members: + data = tar.extractfile(member).read() # type: ignore[union-attr] + relative = member.name[len("package/"):] + assert relative.split("/")[0] in {"dist", "package.json", "README.md"}, relative + assert "node_modules" not in member.name and "__tests__" not in member.name and "contract" not in member.name + assert not relative.endswith(".tsbuildinfo"), f"build cache in tarball: {relative}" + assert _sha256(data) not in genkit_hashes, f"{relative} is a copy of {genkit_hashes[_sha256(data)]}" + assert b"Copyright 2024 Google LLC" not in data and b"Copyright 2025 Google LLC" not in data, relative + assert manifest["peerDependencies"] == {"genkit": "^1.42.0"} + assert "genkit" not in manifest.get("dependencies", {}) + assert not manifest.get("bundledDependencies") and not manifest.get("bundleDependencies") + assert manifest["license"] == "Apache-2.0" + assert all(not v.startswith("workspace:") for v in manifest.get("dependencies", {}).values()) + + +def _node_matrix() -> List[str]: + configured = [p for p in os.environ.get("TRACEAI_NODE_MATRIX", "").split(os.pathsep) if p] + return configured or [NODE] + + +def test_manifest_entry_points_exist_in_the_build(built_package: Path) -> None: + manifest = json.loads((PKG_DIR / "package.json").read_text()) + targets = [manifest["main"], manifest["module"], manifest["esnext"], manifest["types"]] + targets += list(manifest["exports"]["."].values()) + for target in targets: + assert (PKG_DIR / target).is_file(), target + assert json.loads((PKG_DIR / "dist" / "esm" / "package.json").read_text()) == {"type": "module"} + + +@pytest.mark.parametrize("node", _node_matrix()) +def test_esm_and_cjs_entry_points_import(built_package: Path, tmp_path: Path, node: str) -> None: + scope = tmp_path / "node_modules" / "@traceai" + scope.mkdir(parents=True) + (scope / "genkit").symlink_to(PKG_DIR, target_is_directory=True) + check = ( + "const names=['FIGenkitSpanProcessor','mapGenkitAttributes','genkitSpanKind','GenkitAttributes'];" + "function ok(m,kind){for(const n of names){if(!(n in m))throw new Error(kind+' missing '+n)}}" + ) + cjs = run( + [node, "-e", check + "ok(require('@traceai/genkit'),'cjs');console.log(process.version,'cjs ok')"], + env={**_base_env(), "NODE_PATH": str(tmp_path / "node_modules")}, + stdin=None, + timeout=60, + ) + script = tmp_path / "check.mjs" + script.write_text(check + "ok(await import('@traceai/genkit'),'esm');console.log(process.version,'esm ok');") + esm = run([node, str(script)], env=_base_env(), stdin=None, timeout=60) + _check(cjs, f"{node} require") + _check(esm, f"{node} import") + assert b"cjs ok" in cjs.stdout and b"esm ok" in esm.stdout diff --git a/typescript/packages/traceai_genkit/jest.config.js b/typescript/packages/traceai_genkit/jest.config.js new file mode 100644 index 000000000..c4f6e7ad6 --- /dev/null +++ b/typescript/packages/traceai_genkit/jest.config.js @@ -0,0 +1,26 @@ +module.exports = { + preset: 'ts-jest', + testEnvironment: 'node', + roots: ['/src'], + testMatch: ['**/__tests__/**/*.test.ts'], + testPathIgnorePatterns: ['/node_modules/'], + collectCoverageFrom: ['src/**/*.ts', '!src/**/*.d.ts', '!src/index.ts', '!src/__tests__/**'], + coverageDirectory: 'coverage', + coverageReporters: ['text', 'lcov'], + transform: { + '^.+\\.ts$': ['ts-jest', { + tsconfig: { + module: 'commonjs', + target: 'es2020', + strict: true, + esModuleInterop: true, + skipLibCheck: true + } + }] + }, + moduleNameMapper: { + '^@traceai/fi-core$': '/../fi-core/src', + '^@traceai/fi-semantic-conventions$': '/../fi-semantic-conventions/src' + }, + testTimeout: 15000 +}; diff --git a/typescript/packages/traceai_genkit/package.json b/typescript/packages/traceai_genkit/package.json new file mode 100644 index 000000000..07bc0161b --- /dev/null +++ b/typescript/packages/traceai_genkit/package.json @@ -0,0 +1,74 @@ +{ + "name": "@traceai/genkit", + "version": "0.1.0", + "description": "Export Firebase Genkit (JavaScript) native OpenTelemetry spans to Future AGI with a mapping span processor", + "main": "./dist/src/index.js", + "module": "./dist/esm/index.js", + "esnext": "./dist/esnext/index.js", + "types": "./dist/src/index.d.ts", + "exports": { + ".": { + "types": "./dist/src/index.d.ts", + "import": "./dist/esm/index.js", + "require": "./dist/src/index.js" + } + }, + "scripts": { + "prebuild": "rimraf dist", + "build": "tsc --build tsconfig.json tsconfig.esm.json tsconfig.esnext.json && tsc-alias -p tsconfig.esm.json && pnpm run postbuild", + "postbuild": "echo '{\"type\": \"module\"}' > ./dist/esm/package.json", + "test": "jest", + "prepare": "pnpm run build" + }, + "keywords": [ + "opentelemetry", + "tracing", + "genkit", + "firebase-genkit", + "llm", + "observability" + ], + "author": "Future AGI ", + "license": "Apache-2.0", + "repository": { + "type": "git", + "url": "git+https://github.com/future-agi/traceAI.git", + "directory": "typescript/packages/traceai_genkit" + }, + "bugs": { + "url": "https://github.com/future-agi/traceAI/issues" + }, + "homepage": "https://github.com/future-agi/traceAI/tree/main/typescript/packages/traceai_genkit#readme", + "engines": { + "node": ">=20.0.0" + }, + "dependencies": { + "@opentelemetry/api": "^1.9.0", + "@traceai/fi-core": "workspace:^", + "@traceai/fi-semantic-conventions": "workspace:^" + }, + "devDependencies": { + "@opentelemetry/resources": "^2.0.1", + "@opentelemetry/sdk-trace-base": "^2.0.1", + "@types/jest": "^29.5.14", + "@types/node": "^22.10.10", + "genkit": "1.42.0", + "jest": "^29.7.0", + "rimraf": "^6.0.1", + "ts-jest": "^29.2.5", + "tsc-alias": "^1.8.10", + "typescript": "^5.7.3" + }, + "peerDependencies": { + "genkit": "^1.42.0" + }, + "files": [ + "dist", + "README.md", + "!**/__tests__/**", + "!**/*.tsbuildinfo" + ], + "publishConfig": { + "access": "public" + } +} diff --git a/typescript/packages/traceai_genkit/src/__tests__/fixtures.ts b/typescript/packages/traceai_genkit/src/__tests__/fixtures.ts new file mode 100644 index 000000000..bb6dabdbc --- /dev/null +++ b/typescript/packages/traceai_genkit/src/__tests__/fixtures.ts @@ -0,0 +1,109 @@ +/** + * Attribute sets copied from spans genkit 1.42.0 emitted in contract/inventory.mjs + * (Genkit's own mockModel from `genkit/testing`, one tool). Only the prompt and + * outputs were replaced with markers so content assertions can search for them. + */ +import type { Attributes, HrTime, SpanContext } from "@opentelemetry/api"; +import type { GenkitReadableSpan, TimedEventLike } from "../processor"; + +export const PROMPT_MARKER = "SECRET_PROMPT_MARKER"; +export const OUTPUT_MARKER = "SECRET_OUTPUT_MARKER"; +export const TOOL_OUTPUT_MARKER = "SECRET_TOOL_OUTPUT_MARKER"; +export const TRACE_ID = "0af7651916cd43dd8448eb211c80319c"; + +export const flowAttributes = (): Attributes => ({ + "genkit:type": "action", + "genkit:metadata:subtype": "flow", + "genkit:key": "/flow/qaFlow", + "genkit:name": "qaFlow", + "genkit:isRoot": true, + "genkit:path": "/{qaFlow,t:flow}", + "genkit:metadata:context": JSON.stringify({ auth: "", headers: { "x-api-key": "SECRET_HEADER_MARKER" } }), + "genkit:input": JSON.stringify(` ${PROMPT_MARKER} `), + "genkit:output": JSON.stringify(`final ${OUTPUT_MARKER}`), + "genkit:state": "success", +}); + +export const flowStepAttributes = (): Attributes => ({ + "genkit:type": "flowStep", + "genkit:name": "prepare", + "genkit:path": "/{qaFlow,t:flow}/{prepare,t:flowStep}", + "genkit:output": JSON.stringify(PROMPT_MARKER), + "genkit:state": "success", +}); + +export const generateAttributes = (): Attributes => ({ + "genkit:type": "util", + "genkit:name": "generate", + "genkit:path": "/{qaFlow,t:flow}/{generate,t:util}", + "genkit:input": JSON.stringify({ model: "fixture/mock", messages: [{ role: "user", content: [{ text: PROMPT_MARKER }] }] }), + // The generate span's output repeats the LAST turn's usage (inventory: 21/4/25 on both generate spans). + "genkit:output": JSON.stringify({ + message: { role: "model", content: [{ text: OUTPUT_MARKER }] }, + finishReason: "stop", + usage: { inputTokens: 21, outputTokens: 4, totalTokens: 25 }, + }), + "genkit:state": "success", +}); + +export const modelAttributes = (usage: Record | null = { inputTokens: 11, outputTokens: 3, totalTokens: 14 }): Attributes => ({ + "genkit:type": "action", + "genkit:metadata:subtype": "model", + "genkit:key": "/model/fixture/mock", + "genkit:name": "fixture/mock", + "genkit:path": "/{qaFlow,t:flow}/{generate,t:util}/{fixture/mock,t:action,s:model}", + "genkit:input": JSON.stringify({ messages: [{ role: "user", content: [{ text: PROMPT_MARKER }] }], config: {} }), + "genkit:output": JSON.stringify({ + message: { role: "model", content: [{ toolRequest: { name: "lookup", input: { id: 7 } } }] }, + finishReason: "stop", + ...(usage ? { usage } : {}), + latencyMs: 0.31, + }), + "genkit:state": "success", +}); + +export const toolAttributes = (): Attributes => ({ + "genkit:type": "action", + "genkit:metadata:subtype": "tool", + "genkit:key": "/tool/lookup", + "genkit:name": "lookup", + "genkit:path": "/{qaFlow,t:flow}/{generate,t:util}/{lookup,t:action,s:tool}", + "genkit:input": JSON.stringify({ id: 7 }), + "genkit:output": JSON.stringify(TOOL_OUTPUT_MARKER), + "genkit:state": "success", +}); + +const T0: HrTime = [1_760_000_000, 0]; +const T1: HrTime = [1_760_000_001, 500]; + +/** A span shaped like sdk-trace-base 1.25 (the version genkit 1.42.0's NodeSDK uses). */ +export function v1Span(options: { + name: string; + attributes: Attributes; + spanId: string; + parentSpanId?: string; + traceId?: string; + status?: { code: number; message?: string }; + events?: TimedEventLike[]; +}): GenkitReadableSpan & { resource: unknown } { + const ctx: SpanContext = { traceId: options.traceId ?? TRACE_ID, spanId: options.spanId, traceFlags: 1 }; + return { + name: options.name, + kind: 0, + spanContext: () => ctx, + parentSpanId: options.parentSpanId, + startTime: T0, + endTime: T1, + status: options.status ?? { code: 0 }, + attributes: options.attributes, + links: [], + events: options.events ?? [], + duration: [1, 500], + ended: true, + resource: { attributes: { "service.name": "genkit-app" } }, + instrumentationLibrary: { name: "genkit-tracer", version: "v1" }, + droppedAttributesCount: 0, + droppedEventsCount: 0, + droppedLinksCount: 0, + }; +} diff --git a/typescript/packages/traceai_genkit/src/__tests__/mapping.test.ts b/typescript/packages/traceai_genkit/src/__tests__/mapping.test.ts new file mode 100644 index 000000000..8102c84c1 --- /dev/null +++ b/typescript/packages/traceai_genkit/src/__tests__/mapping.test.ts @@ -0,0 +1,505 @@ +import { FISpanKind } from "@traceai/fi-semantic-conventions"; +import { + GENKIT_ACTION_SUBTYPES, + GENKIT_CONTENT_KEYS, + GENKIT_INPUT_KEYS, + GENKIT_OUTPUT_KEYS, + HIDE_ALL, + SHOW_ALL, + type ContentPolicy, + GENKIT_USAGE_NOT_MAPPED, + SUBTYPE_TO_KIND, + USAGE_TO_ATTRIBUTE, + genkitSpanKind, + isPromotedUsageKey, + mapGenkitAttributes, +} from "../index"; +import { + OUTPUT_MARKER, + PROMPT_MARKER, + TOOL_OUTPUT_MARKER, + flowAttributes, + flowStepAttributes, + generateAttributes, + modelAttributes, + toolAttributes, +} from "./fixtures"; + +const kindOf = (attributes: Record) => [attributes["fi.span.kind"], attributes["gen_ai.span.kind"]]; + +describe("genkitSpanKind: kind map from the 1.42.0 type-string inventory", () => { + it.each([ + ["flow", FISpanKind.CHAIN], + ["model", FISpanKind.LLM], + ["background-model", FISpanKind.LLM], + ["tool", FISpanKind.TOOL], + ["tool.v2", FISpanKind.TOOL], + ["retriever", FISpanKind.RETRIEVER], + ["embedder", FISpanKind.EMBEDDING], + ["reranker", FISpanKind.RERANKER], + ["evaluator", FISpanKind.EVALUATOR], + ["agent", FISpanKind.AGENT], + ])("genkit:type=action, subtype=%s -> %s", (subtype, kind) => { + expect(genkitSpanKind({ "genkit:type": "action", "genkit:metadata:subtype": subtype })).toBe(kind); + }); + + it("maps every other 1.42.0 action subtype to CHAIN", () => { + const others = GENKIT_ACTION_SUBTYPES.filter((s) => SUBTYPE_TO_KIND[s] === undefined); + expect(others.sort()).toEqual( + [ + "agent-abort", + "agent-snapshot", + "cancel-operation", + "check-operation", + "custom", + "dynamic-action-provider", + "executable-prompt", + "indexer", + "prompt", + "resource", + "util", + ].sort(), + ); + for (const subtype of others) { + expect(genkitSpanKind({ "genkit:type": "action", "genkit:metadata:subtype": subtype })).toBe(FISpanKind.CHAIN); + } + }); + + it.each(["flowStep", "util", "promptTemplate", "dotprompt"])("genkit:type=%s -> CHAIN", (type) => { + expect(genkitSpanKind({ "genkit:type": type })).toBe(FISpanKind.CHAIN); + }); + + it("leaves spans without a known genkit:type unmapped", () => { + expect(genkitSpanKind({})).toBeUndefined(); + expect(genkitSpanKind({ "genkit:type": "somethingNew" })).toBeUndefined(); + expect(genkitSpanKind({ "http.method": "GET" })).toBeUndefined(); + const out = mapGenkitAttributes({ "genkit:type": "somethingNew", "genkit:name": "x" }); + expect(out["fi.span.kind"]).toBeUndefined(); + expect(out["gen_ai.span.kind"]).toBeUndefined(); + expect(out["genkit:name"]).toBe("x"); + }); + + it("writes both fi.span.kind and gen_ai.span.kind", () => { + expect(kindOf(mapGenkitAttributes(flowAttributes()))).toEqual(["CHAIN", "CHAIN"]); + expect(kindOf(mapGenkitAttributes(modelAttributes()))).toEqual(["LLM", "LLM"]); + expect(kindOf(mapGenkitAttributes(toolAttributes()))).toEqual(["TOOL", "TOOL"]); + expect(kindOf(mapGenkitAttributes(generateAttributes()))).toEqual(["CHAIN", "CHAIN"]); + expect(kindOf(mapGenkitAttributes(flowStepAttributes()))).toEqual(["CHAIN", "CHAIN"]); + }); + + it("does not overwrite a kind already on the span", () => { + const out = mapGenkitAttributes({ ...toolAttributes(), "fi.span.kind": "AGENT" }); + expect(out["fi.span.kind"]).toBe("AGENT"); + expect(out["gen_ai.span.kind"]).toBe("TOOL"); + }); +}); + +describe("model call spans", () => { + it("copies model name, usage and finish reason from the model action span", () => { + const out = mapGenkitAttributes(modelAttributes()); + expect(out["gen_ai.request.model"]).toBe("mock"); + expect(out["gen_ai.usage.input_tokens"]).toBe(11); + expect(out["gen_ai.usage.output_tokens"]).toBe(3); + expect(out["gen_ai.usage.total_tokens"]).toBe(14); + expect(out["gen_ai.response.finish_reasons"]).toEqual(["stop"]); + }); + + it("copies input/output/total tokens, plus the reasoning and cached-prompt counts real Gemini reports", () => { + expect(USAGE_TO_ATTRIBUTE).toEqual({ + inputTokens: "gen_ai.usage.input_tokens", + outputTokens: "gen_ai.usage.output_tokens", + totalTokens: "gen_ai.usage.total_tokens", + thoughtsTokens: "gen_ai.usage.output_tokens.reasoning", + cachedContentTokens: "gen_ai.usage.cache_read_tokens", + }); + }); + + it("maps thoughtsTokens and cachedContentTokens (set by @genkit-ai/google-genai) on model spans", () => { + // @genkit-ai/google-genai 1.42.0 lib/googleai/gemini.js:642-646 copies + // usageMetadata.thoughtsTokenCount / cachedContentTokenCount. A real + // gemini-3.8-flash call reported inputTokens 66, outputTokens 15, + // totalTokens 133: the 52 thinking tokens are only in thoughtsTokens. + const out = mapGenkitAttributes( + modelAttributes({ inputTokens: 66, outputTokens: 15, totalTokens: 133, thoughtsTokens: 52, cachedContentTokens: 8 }), + ); + expect(out["gen_ai.usage.output_tokens.reasoning"]).toBe(52); + expect(out["gen_ai.usage.cache_read_tokens"]).toBe(8); + expect(out["gen_ai.usage.output_tokens"]).toBe(15); + expect(out["gen_ai.usage.total_tokens"]).toBe(133); + }); + + it("leaves the other GenerationUsage fields unavailable (not copied)", () => { + // The character/media counters and `custom` are in GenerationUsageSchema + // (ai/src/model-types.ts:260-275) but neither the inventory nor the + // google-genai plugin sets them, so they are not mapped. + const out = mapGenkitAttributes( + modelAttributes({ + inputTokens: 5, + outputTokens: 6, + totalTokens: 11, + inputCharacters: 99, + outputImages: 1, + }), + ); + expect(Object.keys(out).filter(isPromotedUsageKey).sort()).toEqual( + ["gen_ai.usage.input_tokens", "gen_ai.usage.output_tokens", "gen_ai.usage.total_tokens"].sort(), + ); + expect(out["gen_ai.usage.output_tokens.reasoning"]).toBeUndefined(); + expect(out["gen_ai.usage.cache_read_tokens"]).toBeUndefined(); + expect(Object.keys(out).some((k) => /character|image/i.test(k))).toBe(false); + expect(GENKIT_USAGE_NOT_MAPPED).toEqual(expect.arrayContaining(["inputCharacters", "outputImages", "custom"])); + expect(GENKIT_USAGE_NOT_MAPPED).not.toContain("thoughtsTokens"); + expect(GENKIT_USAGE_NOT_MAPPED).not.toContain("cachedContentTokens"); + }); + + it.each([ + ["googleai/gemini-3.5-flash", "gemini-3.5-flash", "google"], + ["vertexai/gemini-3.5-flash", "gemini-3.5-flash", "vertexai"], + ["vertexai/claude-sonnet-5", "claude-sonnet-5", "vertexai"], + ["openai/gpt-4o-mini", "gpt-4o-mini", "openai"], + ["anthropic/claude-haiku-4-5", "claude-haiku-4-5", "anthropic"], + ["deepseek/deepseek-chat", "deepseek-chat", "deepseek"], + ["xai/grok-4.5", "grok-4.5", "xai"], + ["ollama/llama3.2", "llama3.2", "ollama"], + ["mistral/mistral-large-latest", "mistral-large-latest", "mistralai"], + ["groq/llama-3.3-70b-versatile", "llama-3.3-70b-versatile", "groq"], + ["aws-bedrock/amazon.nova-pro-v1:0", "amazon.nova-pro-v1:0", "aws"], + ["azure-openai/gpt-4o", "gpt-4o", "azure"], + ])("%s: model %s, provider %s (the collector prices by the bare model name)", (genkitName, model, provider) => { + const out = mapGenkitAttributes({ ...modelAttributes(), "genkit:name": genkitName }); + expect(out["gen_ai.request.model"]).toBe(model); + expect(out["gen_ai.response.model"]).toBe(model); + expect(out["gen_ai.provider.name"]).toBe(provider); + // The full registered name stays on the passed-through Genkit key. + expect(out["genkit:name"]).toBe(genkitName); + }); + + it("strips an unknown plugin namespace but leaves the provider unset", () => { + const out = mapGenkitAttributes({ ...modelAttributes(), "genkit:name": "together/meta-llama/Llama-3-70b" }); + expect(out["gen_ai.request.model"]).toBe("meta-llama/Llama-3-70b"); + expect(out["gen_ai.provider.name"]).toBeUndefined(); + }); + + it("keeps a model name with no namespace as is, with no provider", () => { + const out = mapGenkitAttributes({ ...modelAttributes(), "genkit:name": "my-model" }); + expect(out["gen_ai.request.model"]).toBe("my-model"); + expect(out["gen_ai.provider.name"]).toBeUndefined(); + }); + + it("sets no model or provider on non-model spans", () => { + const out = mapGenkitAttributes({ ...toolAttributes(), "genkit:name": "googleai/gemini-3.5-flash" }); + expect(out["gen_ai.request.model"]).toBeUndefined(); + expect(out["gen_ai.provider.name"]).toBeUndefined(); + }); + + it("records usage as unavailable (absent) when the model reported none", () => { + const out = mapGenkitAttributes(modelAttributes(null)); + for (const key of Object.keys(out)) { + expect(isPromotedUsageKey(key)).toBe(false); + } + expect(out["gen_ai.request.model"]).toBe("mock"); + }); + + it("does not throw on a truncated or non-JSON genkit:output", () => { + const attributes = { ...modelAttributes(), "genkit:output": '{"message":{"role":"model","content":[{"te' }; + const out = mapGenkitAttributes(attributes); + expect(out["gen_ai.usage.input_tokens"]).toBeUndefined(); + expect(out["fi.span.kind"]).toBe("LLM"); + }); + + it("puts promoted token keys only on model spans, never on flow / generate / tool spans", () => { + for (const attributes of [flowAttributes(), generateAttributes(), toolAttributes(), flowStepAttributes()]) { + const out = mapGenkitAttributes(attributes); + expect(Object.keys(out).filter(isPromotedUsageKey)).toEqual([]); + } + }); + + it("moves aggregate usage found on a non-model span to genkit.usage.*", () => { + const out = mapGenkitAttributes({ + ...flowAttributes(), + "gen_ai.usage.input_tokens": 32, + "llm.token_count.prompt": 32, + "llm.usage.total_tokens": 40, + "gen_ai.cost.total": 0.5, + "llm.cost.total": 0.5, + }); + expect(Object.keys(out).filter(isPromotedUsageKey)).toEqual([]); + expect(out["genkit.usage.gen_ai.usage.input_tokens"]).toBe(32); + expect(out["genkit.usage.llm.token_count.prompt"]).toBe(32); + expect(out["genkit.usage.llm.usage.total_tokens"]).toBe(40); + expect(out["genkit.usage.gen_ai.cost.total"]).toBe(0.5); + expect(out["genkit.usage.llm.cost.total"]).toBe(0.5); + }); + + it("matches the collector's promoted-key families", () => { + for (const key of [ + "gen_ai.usage.input_tokens", + "gen_ai.usage.output_tokens", + "gen_ai.usage.total_tokens", + "llm.token_count.prompt", + "llm.usage.prompt_tokens", + "gen_ai.cost.total", + "llm.cost.total", + ]) { + expect(isPromotedUsageKey(key)).toBe(true); + } + for (const key of ["genkit.usage.gen_ai.usage.input_tokens", "genkit:output", "gen_ai.request.model"]) { + expect(isPromotedUsageKey(key)).toBe(false); + } + }); + + it("treats every gen_ai.cost.* and llm.cost.* key as promoted, cost parts included", () => { + // fi-collector promotes the cost parts too when no total is present (DeriveHotKeys). + for (const key of [ + "gen_ai.cost.input", + "gen_ai.cost.output", + "gen_ai.cost.total", + "llm.cost.prompt", + "llm.cost.completion", + "llm.cost.total", + "gen_ai.cost.some_future_part", + ]) { + expect(isPromotedUsageKey(key)).toBe(true); + } + for (const key of ["genkit.usage.gen_ai.cost.input", "gen_ai.costs", "llm.costing", "cost.total"]) { + expect(isPromotedUsageKey(key)).toBe(false); + } + }); + + it("moves cost parts on a non-model span to genkit.usage.*, from span and context attributes", () => { + const out = mapGenkitAttributes( + { ...flowAttributes(), "gen_ai.cost.input": 0.01, "llm.cost.completion": 0.02 }, + { contextAttributes: { "gen_ai.cost.output": 0.03, "llm.cost.prompt": 0.04 } }, + ); + expect(Object.keys(out).filter((k) => k.startsWith("gen_ai.cost.") || k.startsWith("llm.cost."))).toEqual([]); + expect(out["genkit.usage.gen_ai.cost.input"]).toBe(0.01); + expect(out["genkit.usage.llm.cost.completion"]).toBe(0.02); + expect(out["genkit.usage.gen_ai.cost.output"]).toBe(0.03); + expect(out["genkit.usage.llm.cost.prompt"]).toBe(0.04); + }); + + it("keeps cost parts unprefixed on a model span", () => { + const out = mapGenkitAttributes(modelAttributes(), { contextAttributes: { "gen_ai.cost.input": 0.05 } }); + expect(out["gen_ai.cost.input"]).toBe(0.05); + expect(out["genkit.usage.gen_ai.cost.input"]).toBeUndefined(); + }); +}); + +describe("embedder spans", () => { + // Shape of a real @genkit-ai/google-genai 1.42.0 embedder span (gemini-embedding-001), vector shortened. + const embedderAttributes = () => ({ + "genkit:type": "action", + "genkit:metadata:subtype": "embedder", + "genkit:name": "googleai/gemini-embedding-001", + "genkit:input": JSON.stringify({ input: [{ content: [{ text: PROMPT_MARKER }] }], options: {} }), + "genkit:output": JSON.stringify({ embeddings: [{ embedding: [0.0145, -0.0166, 0.0121] }] }), + "genkit:state": "success", + }); + + it("sets EMBEDDING kind, the bare embedding.model_name and the provider", () => { + const out = mapGenkitAttributes(embedderAttributes()); + expect(out["fi.span.kind"]).toBe("EMBEDDING"); + expect(out["embedding.model_name"]).toBe("gemini-embedding-001"); + expect(out["gen_ai.provider.name"]).toBe("google"); + expect(out["gen_ai.request.model"]).toBeUndefined(); + expect(out["output.value"]).toContain("0.0145"); + }); + + it("FI_HIDE_EMBEDDING_VECTORS replaces the vectors and keeps the rest", () => { + const out = mapGenkitAttributes(embedderAttributes(), { policy: { ...SHOW_ALL, hideEmbeddingVectors: true } }); + expect(JSON.parse(String(out["output.value"]))).toEqual({ embeddings: [{ embedding: "__REDACTED__" }] }); + expect(out["genkit:output"]).toBe(out["output.value"]); + expect(out["input.value"]).toContain(PROMPT_MARKER); + // Only embedder outputs are touched. + const tool = mapGenkitAttributes(toolAttributes(), { policy: { ...SHOW_ALL, hideEmbeddingVectors: true } }); + expect(tool["output.value"]).toContain(TOOL_OUTPUT_MARKER); + }); +}); + +describe("tool spans", () => { + it("copies the tool action name to tool.name and gen_ai.tool.name", () => { + const out = mapGenkitAttributes(toolAttributes()); + expect(out["tool.name"]).toBe("lookup"); + expect(out["gen_ai.tool.name"]).toBe("lookup"); + }); +}); + +describe("content (traceAI TraceConfig)", () => { + const all = () => [flowAttributes(), flowStepAttributes(), generateAttributes(), modelAttributes(), toolAttributes()]; + const withExtras = (attributes: Record) => ({ + ...attributes, + "genkit:init": `{"state":"${PROMPT_MARKER}"}`, + "genkit:metadata:interrupt": `{"ask":"${OUTPUT_MARKER}"}`, + "genkit:metadata:resumed": `{"answer":"${PROMPT_MARKER}"}`, + }); + const policy = (p: Partial): ContentPolicy => ({ ...SHOW_ALL, ...p }); + + it("exports input and output by default (fi-core DEFAULT_HIDE_* = false)", () => { + const out = mapGenkitAttributes(toolAttributes()); + expect(out["input.value"]).toBe(JSON.stringify({ id: 7 })); + expect(out["output.value"]).toContain(TOOL_OUTPUT_MARKER); + expect(out["input.mime_type"]).toBe("application/json"); + expect(out["output.mime_type"]).toBe("application/json"); + expect(out["genkit:input"]).toBe(JSON.stringify({ id: 7 })); + expect(out["genkit:output"]).toContain(TOOL_OUTPUT_MARKER); + }); + + it("exports the model request and response by default", () => { + const out = mapGenkitAttributes(modelAttributes()); + expect(out["input.value"]).toContain(PROMPT_MARKER); + expect(out["output.value"]).toContain('"toolRequest"'); + }); + + it("hideInputs + hideOutputs drop every content key and set input/output.value to __REDACTED__", () => { + for (const attributes of all()) { + const out = mapGenkitAttributes(withExtras(attributes), { policy: policy({ hideInputs: true, hideOutputs: true }) }); + for (const key of GENKIT_CONTENT_KEYS) expect(out[key]).toBeUndefined(); + if (attributes["genkit:input"] !== undefined) expect(out["input.value"]).toBe("__REDACTED__"); + expect(out["input.mime_type"]).toBeUndefined(); + if (attributes["genkit:output"] !== undefined) expect(out["output.value"]).toBe("__REDACTED__"); + expect(out["output.mime_type"]).toBeUndefined(); + const blob = JSON.stringify(out); + for (const marker of [PROMPT_MARKER, OUTPUT_MARKER, TOOL_OUTPUT_MARKER]) expect(blob).not.toContain(marker); + } + }); + + it("hideInputs hides only the input side", () => { + const out = mapGenkitAttributes(withExtras(toolAttributes()), { policy: policy({ hideInputs: true }) }); + for (const key of GENKIT_INPUT_KEYS) expect(out[key]).toBeUndefined(); + expect(out["input.value"]).toBe("__REDACTED__"); + expect(out["output.value"]).toContain(TOOL_OUTPUT_MARKER); + expect(out["genkit:metadata:interrupt"]).toContain(OUTPUT_MARKER); + }); + + it("hideOutputs hides only the output side", () => { + const out = mapGenkitAttributes(withExtras(toolAttributes()), { policy: policy({ hideOutputs: true }) }); + for (const key of GENKIT_OUTPUT_KEYS) expect(out[key]).toBeUndefined(); + expect(out["output.value"]).toBe("__REDACTED__"); + expect(out["input.value"]).toBe(JSON.stringify({ id: 7 })); + expect(out["genkit:init"]).toContain(PROMPT_MARKER); + }); + + it("hideInputMessages / hideOutputMessages hide model request / response, not tool or flow content", () => { + const p = policy({ hideInputMessages: true, hideOutputMessages: true }); + const model = mapGenkitAttributes(modelAttributes(), { policy: p }); + expect(model["genkit:input"]).toBeUndefined(); + expect(model["genkit:output"]).toBeUndefined(); + expect(model["input.value"]).toBe("__REDACTED__"); + expect(model["output.value"]).toBe("__REDACTED__"); + expect(model["gen_ai.usage.total_tokens"]).toBe(14); + const tool = mapGenkitAttributes(toolAttributes(), { policy: p }); + expect(tool["output.value"]).toContain(TOOL_OUTPUT_MARKER); + }); + + it("hideInputText / hideOutputText redact message text on model spans and keep roles and usage", () => { + const textModel = { + ...modelAttributes(), + "genkit:output": JSON.stringify({ + message: { role: "model", content: [{ text: OUTPUT_MARKER }, { reasoning: OUTPUT_MARKER }] }, + finishReason: "stop", + usage: { inputTokens: 11, outputTokens: 3, totalTokens: 14 }, + }), + }; + const out = mapGenkitAttributes(textModel, { policy: policy({ hideInputText: true, hideOutputText: true }) }); + const input = JSON.parse(String(out["input.value"])); + const output = JSON.parse(String(out["output.value"])); + expect(JSON.stringify(input)).not.toContain(PROMPT_MARKER); + expect(JSON.stringify(output)).not.toContain(OUTPUT_MARKER); + expect(input.messages[0].role).toBe("user"); + expect(input.messages[0].content[0].text).toBe("__REDACTED__"); + expect(output.message.role).toBe("model"); + expect(output.usage.totalTokens).toBe(14); + expect(out["gen_ai.usage.total_tokens"]).toBe(14); + // Not a model span: the text flags do not apply (fi-core applies them to LLM messages only). + const tool = mapGenkitAttributes(toolAttributes(), { policy: policy({ hideInputText: true, hideOutputText: true }) }); + expect(tool["output.value"]).toContain(TOOL_OUTPUT_MARKER); + }); + + it("never exports genkit:metadata:context, in either mode", () => { + for (const p of [SHOW_ALL, HIDE_ALL]) { + const out = mapGenkitAttributes(flowAttributes(), { policy: p }); + expect(out["genkit:metadata:context"]).toBeUndefined(); + expect(JSON.stringify(out)).not.toContain("SECRET_HEADER_MARKER"); + } + }); + + it("keeps usage on model spans with outputs hidden (usage is read before the output is dropped)", () => { + const out = mapGenkitAttributes(modelAttributes(), { policy: HIDE_ALL }); + expect(out["genkit:output"]).toBeUndefined(); + expect(out["gen_ai.usage.total_tokens"]).toBe(14); + expect(out["gen_ai.response.finish_reasons"]).toEqual(["stop"]); + }); + + it("rewrites local paths and removes stack traces inside exported content, in either mode", () => { + const scrub = { cwd: "/srv/app", home: "/home/dev" }; + const out = mapGenkitAttributes( + { + ...toolAttributes(), + "genkit:output": JSON.stringify({ + file: "/srv/app/data/orders.json", + cfg: "/home/dev/.config/x", + other: "/Users/someone/notes.txt", + err: "boom\n at run (/srv/app/tool.js:1:2)", + url: "https://example.com/v1/models", + }), + }, + { scrub }, + ); + const output = String(out["output.value"]); + expect(output).not.toContain("/srv/app"); + expect(output).not.toContain("/home/dev"); + expect(output).not.toContain("/Users/someone"); + expect(output).not.toContain("tool.js:1:2"); + expect(output).toContain("[cwd]/data/orders.json"); + expect(output).toContain("~/.config/x"); + expect(output).toContain("https://example.com/v1/models"); + expect(out["genkit:output"]).toBe(output); + }); + + it("leaves Genkit action paths alone", () => { + const out = mapGenkitAttributes(flowAttributes(), { scrub: { cwd: "/srv/app" } }); + expect(out["genkit:path"]).toBe(flowAttributes()["genkit:path"]); + }); + + it("never modifies the source attributes", () => { + const source = modelAttributes(); + const before = JSON.stringify(source); + mapGenkitAttributes(source); + mapGenkitAttributes(source, { policy: HIDE_ALL }); + expect(JSON.stringify(source)).toBe(before); + }); +}); + +describe("session and context attributes", () => { + it("maps the beta agent session id to session.id", () => { + const out = mapGenkitAttributes({ + "genkit:type": "action", + "genkit:metadata:subtype": "agent", + "genkit:name": "supportAgent", + "genkit:metadata:agent:sessionId": "sess-agent-1", + }); + expect(out["session.id"]).toBe("sess-agent-1"); + expect(out["genkit:metadata:agent:sessionId"]).toBe("sess-agent-1"); + expect(out["fi.span.kind"]).toBe("AGENT"); + }); + + it("applies fi-core context attributes without overriding span keys", () => { + const out = mapGenkitAttributes( + { ...flowAttributes(), "user.id": "from-span" }, + { contextAttributes: { "session.id": "sess-ctx", "user.id": "from-context", "tag.tags": ["a"] } }, + ); + expect(out["session.id"]).toBe("sess-ctx"); + expect(out["user.id"]).toBe("from-span"); + expect(out["tag.tags"]).toEqual(["a"]); + }); + + it("does not let context attributes put promoted usage on a non-model span", () => { + const out = mapGenkitAttributes(flowAttributes(), { contextAttributes: { "gen_ai.usage.input_tokens": 3 } }); + expect(out["gen_ai.usage.input_tokens"]).toBeUndefined(); + expect(out["genkit.usage.gen_ai.usage.input_tokens"]).toBe(3); + }); + + it("sets no session.id when Genkit has none", () => { + expect(mapGenkitAttributes(flowAttributes())["session.id"]).toBeUndefined(); + }); +}); diff --git a/typescript/packages/traceai_genkit/src/__tests__/package.test.ts b/typescript/packages/traceai_genkit/src/__tests__/package.test.ts new file mode 100644 index 000000000..e7d3fcdbc --- /dev/null +++ b/typescript/packages/traceai_genkit/src/__tests__/package.test.ts @@ -0,0 +1,46 @@ +/** + * Package manifest contract: genkit is a peer dependency only, the tarball + * ships built output (no tests, no build caches), and the entry points match + * the build layout of the sibling packages (traceai_anthropic). + */ +import * as fs from "fs"; +import * as path from "path"; + +const root = path.resolve(__dirname, "..", ".."); +const manifest = JSON.parse(fs.readFileSync(path.join(root, "package.json"), "utf8")); +const sibling = JSON.parse(fs.readFileSync(path.join(root, "..", "traceai_anthropic", "package.json"), "utf8")); + +describe("@traceai/genkit package.json", () => { + it("keeps genkit a peer dependency (devDependency pinned for tests), never a dependency", () => { + expect(manifest.peerDependencies).toEqual({ genkit: "^1.42.0" }); + expect(manifest.devDependencies.genkit).toBe("1.42.0"); + expect(manifest.dependencies.genkit).toBeUndefined(); + expect(manifest.bundledDependencies ?? manifest.bundleDependencies).toBeUndefined(); + }); + + it("ships dist and README only, without tests or tsbuildinfo caches", () => { + expect(manifest.files).toEqual(["dist", "README.md", "!**/__tests__/**", "!**/*.tsbuildinfo"]); + }); + + it("uses the sibling packages' entry points and build script", () => { + for (const key of ["main", "module", "esnext", "types", "exports"]) { + expect(manifest[key]).toEqual(sibling[key]); + } + expect(manifest.scripts.build).toBe(sibling.scripts.build); + expect(manifest.scripts.postbuild).toBe(sibling.scripts.postbuild); + }); + + it("points repository metadata at future-agi/traceAI with this package's directory", () => { + expect(manifest.name).toBe("@traceai/genkit"); + expect(manifest.license).toBe("Apache-2.0"); + expect(manifest.repository).toEqual({ + type: "git", + url: sibling.repository.url, + directory: "typescript/packages/traceai_genkit", + }); + expect(manifest.bugs).toEqual(sibling.bugs); + expect(manifest.homepage).toBe( + "https://github.com/future-agi/traceAI/tree/main/typescript/packages/traceai_genkit#readme", + ); + }); +}); diff --git a/typescript/packages/traceai_genkit/src/__tests__/processor.test.ts b/typescript/packages/traceai_genkit/src/__tests__/processor.test.ts new file mode 100644 index 000000000..c6920bd05 --- /dev/null +++ b/typescript/packages/traceai_genkit/src/__tests__/processor.test.ts @@ -0,0 +1,365 @@ +import { context, diag, ROOT_CONTEXT, trace } from "@opentelemetry/api"; +import * as os from "os"; +import { + BasicTracerProvider, + InMemorySpanExporter, + SimpleSpanProcessor, + type ReadableSpan, +} from "@opentelemetry/sdk-trace-base"; +import { resourceFromAttributes } from "@opentelemetry/resources"; +import { ProjectType, register, setSession, setUser } from "@traceai/fi-core"; +import { FIGenkitSpanProcessor } from "../index"; +import { + PROMPT_MARKER, + TRACE_ID, + flowAttributes, + generateAttributes, + modelAttributes, + toolAttributes, + v1Span, +} from "./fixtures"; + +const HIDE_ENV = [ + "FI_HIDE_INPUTS", + "FI_HIDE_OUTPUTS", + "FI_HIDE_INPUT_MESSAGES", + "FI_HIDE_OUTPUT_MESSAGES", + "FI_HIDE_INPUT_TEXT", + "FI_HIDE_OUTPUT_TEXT", +]; +const savedEnv: Record = {}; +beforeEach(() => { + for (const key of HIDE_ENV) { + savedEnv[key] = process.env[key]; + delete process.env[key]; + } +}); +afterEach(() => { + for (const key of HIDE_ENV) { + if (savedEnv[key] === undefined) delete process.env[key]; + else process.env[key] = savedEnv[key]; + } +}); + +function fiLikeProvider() { + const exporter = new InMemorySpanExporter(); + const provider = new BasicTracerProvider({ + resource: resourceFromAttributes({ project_name: "unit-project", project_type: "observe" }), + spanProcessors: [new SimpleSpanProcessor(exporter)], + }); + return { exporter, provider }; +} + +function exportedByName(exporter: InMemorySpanExporter): Record { + return Object.fromEntries(exporter.getFinishedSpans().map((s) => [s.name, s])); +} + +describe("FIGenkitSpanProcessor: forwarding to the Future AGI provider", () => { + it("re-shapes sdk-trace-base 1.x spans for the 2.x exporter: parent, scope, FI resource", async () => { + const { exporter, provider } = fiLikeProvider(); + const processor = new FIGenkitSpanProcessor({ tracerProvider: provider }); + const flow = v1Span({ name: "qaFlow", attributes: flowAttributes(), spanId: "1111111111111111" }); + const model = v1Span({ name: "fixture/mock", attributes: modelAttributes(), spanId: "2222222222222222", parentSpanId: "1111111111111111" }); + processor.onEnd(model); + processor.onEnd(flow); + await processor.forceFlush(); + + const spans = exportedByName(exporter); + expect(Object.keys(spans).sort()).toEqual(["fixture/mock", "qaFlow"]); + const exportedModel = spans["fixture/mock"]; + expect(exportedModel.parentSpanContext?.spanId).toBe("1111111111111111"); + expect(exportedModel.parentSpanContext?.traceId).toBe(TRACE_ID); + expect(exportedModel.spanContext().spanId).toBe("2222222222222222"); + expect(spans.qaFlow.parentSpanContext).toBeUndefined(); + expect(exportedModel.instrumentationScope).toEqual({ name: "genkit-tracer", version: "v1" }); + expect(exportedModel.resource.attributes).toMatchObject({ project_name: "unit-project", project_type: "observe" }); + expect(exportedModel.attributes["fi.span.kind"]).toBe("LLM"); + expect(exportedModel.attributes["gen_ai.usage.input_tokens"]).toBe(11); + expect(exportedModel.startTime).toEqual(model.startTime); + expect(exportedModel.endTime).toEqual(model.endTime); + }); + + it("passes OTel status and exception events through", async () => { + const { exporter, provider } = fiLikeProvider(); + const processor = new FIGenkitSpanProcessor({ tracerProvider: provider }); + processor.onEnd( + v1Span({ + name: "lookup", + attributes: { ...toolAttributes(), "genkit:state": "error" }, + spanId: "3333333333333333", + status: { code: 2, message: "tool exploded" }, + events: [{ name: "exception", time: [1, 0], attributes: { "exception.type": "Error", "exception.message": "tool exploded" } }], + }), + ); + await processor.forceFlush(); + const [span] = exporter.getFinishedSpans(); + expect(span.status).toEqual({ code: 2, message: "tool exploded" }); + expect(span.events.map((e) => e.name)).toEqual(["exception"]); + expect(span.attributes["fi.span.kind"]).toBe("TOOL"); + }); + + it("never modifies Genkit's span (Genkit's own exporters read the same object)", async () => { + const { provider } = fiLikeProvider(); + const processor = new FIGenkitSpanProcessor({ tracerProvider: provider }); + const span = v1Span({ name: "generate", attributes: generateAttributes(), spanId: "4444444444444444" }); + const before = JSON.stringify(span.attributes); + processor.onEnd(span); + await processor.forceFlush(); + expect(JSON.stringify(span.attributes)).toBe(before); + expect(span.attributes["genkit:input"]).toContain(PROMPT_MARKER); + expect(span.resource).toEqual({ attributes: { "service.name": "genkit-app" } }); + }); + + it("exports content by default and hides it with traceConfig (option) or FI_HIDE_* (env)", async () => { + const span = v1Span({ name: "fixture/mock", attributes: modelAttributes(), spanId: "5555555555555555" }); + const on = fiLikeProvider(); + new FIGenkitSpanProcessor({ tracerProvider: on.provider }).onEnd(span); + expect(on.exporter.getFinishedSpans()[0].attributes["input.value"]).toContain(PROMPT_MARKER); + + const byOption = fiLikeProvider(); + new FIGenkitSpanProcessor({ tracerProvider: byOption.provider, traceConfig: { hideInputs: true, hideOutputs: true } }).onEnd(span); + expect(JSON.stringify(byOption.exporter.getFinishedSpans()[0].attributes)).not.toContain(PROMPT_MARKER); + expect(byOption.exporter.getFinishedSpans()[0].attributes["input.value"]).toBe("__REDACTED__"); + + process.env.FI_HIDE_INPUTS = "TRUE"; + process.env.FI_HIDE_OUTPUTS = "true"; + const byEnv = fiLikeProvider(); + new FIGenkitSpanProcessor({ tracerProvider: byEnv.provider }).onEnd(span); + expect(JSON.stringify(byEnv.exporter.getFinishedSpans()[0].attributes)).not.toContain(PROMPT_MARKER); + + // option > env, as in fi-core + const optionWins = fiLikeProvider(); + new FIGenkitSpanProcessor({ tracerProvider: optionWins.provider, traceConfig: { hideInputs: false, hideOutputs: false } }).onEnd(span); + expect(optionWins.exporter.getFinishedSpans()[0].attributes["input.value"]).toContain(PROMPT_MARKER); + + // only "true" hides (fi-core's env parsing) + process.env.FI_HIDE_INPUTS = "1"; + process.env.FI_HIDE_OUTPUTS = "yes"; + const notTrue = fiLikeProvider(); + new FIGenkitSpanProcessor({ tracerProvider: notTrue.provider }).onEnd(span); + expect(notTrue.exporter.getFinishedSpans()[0].attributes["input.value"]).toContain(PROMPT_MARKER); + }); + + it("treats the removed captureContent: false as hide inputs and outputs, with a warning", async () => { + const warn = jest.spyOn(diag, "warn").mockImplementation(() => undefined); + try { + const span = v1Span({ name: "fixture/mock", attributes: modelAttributes(), spanId: "5555555555555556" }); + const off = fiLikeProvider(); + new FIGenkitSpanProcessor({ tracerProvider: off.provider, captureContent: false }).onEnd(span); + expect(JSON.stringify(off.exporter.getFinishedSpans()[0].attributes)).not.toContain(PROMPT_MARKER); + const on = fiLikeProvider(); + new FIGenkitSpanProcessor({ tracerProvider: on.provider, captureContent: true }).onEnd(span); + expect(on.exporter.getFinishedSpans()[0].attributes["input.value"]).toContain(PROMPT_MARKER); + expect(warn.mock.calls.filter(([m]) => String(m).includes("captureContent was removed"))).toHaveLength(2); + } finally { + warn.mockRestore(); + } + }); + + it("applies session/user set with the fi-core context helpers at span start", async () => { + const { exporter, provider } = fiLikeProvider(); + const processor = new FIGenkitSpanProcessor({ tracerProvider: provider }); + const span = v1Span({ name: "qaFlow", attributes: flowAttributes(), spanId: "6666666666666666" }); + const ctx = setUser(setSession(ROOT_CONTEXT, { sessionId: "sess-42" }), { userId: "user-7" }); + processor.onStart(span, ctx); + processor.onEnd(span); + const [exported] = exporter.getFinishedSpans(); + expect(exported.attributes["session.id"]).toBe("sess-42"); + expect(exported.attributes["user.id"]).toBe("user-7"); + }); +}); + +describe("FIGenkitSpanProcessor: error text, stack traces and local identity", () => { + // @genkit-ai/core 1.42.0 src/schema.ts:78 (ValidationError) and src/error.ts:78 (GenkitError prefix). + // core/src/tracing/instrumentation.ts:156-162 copies e.message to status.message and records the exception. + const DATA_MARKER = "SECRET_STRUCTURED_OUTPUT_MARKER"; + const user = os.userInfo().username; + const host = os.hostname(); + const head = "INVALID_ARGUMENT: Schema validation failed. Parse Errors:\n\n- /answer: must be string\n\n"; + const message = + head + + `Provided data:\n\n${JSON.stringify({ answer: 42, note: DATA_MARKER }, null, 2)}\n\n` + + `owner jane.doe@example.com on ${host} as ${user}, config ${process.cwd()}/genkit.config.json, also /Users/someone/x.txt`; + const stacktrace = `GenkitError: ${message}\n at parseSchema (${process.cwd()}/node_modules/@genkit-ai/core/lib/schema.js:71:11)`; + const errorSpan = (spanId: string) => + v1Span({ + name: "generate", + attributes: { ...generateAttributes(), "genkit:state": "error" }, + spanId, + status: { code: 2, message }, + events: [ + { name: "custom", time: [1, 0], attributes: { note: "not an exception", where: `${os.homedir()}/notes` } }, + { + name: "exception", + time: [1, 5], + attributes: { "exception.type": "GenkitError", "exception.message": message, "exception.stacktrace": stacktrace }, + }, + ], + }); + const forbidden = ["jane.doe@example.com", user, host, process.cwd(), os.homedir(), "/Users/someone", "schema.js:71"]; + + it("default: exports the error message without paths, emails, user or host names, and never the stack trace", async () => { + const { exporter, provider } = fiLikeProvider(); + const span = errorSpan("9999999999999991"); + const processor = new FIGenkitSpanProcessor({ tracerProvider: provider }); + processor.onEnd(span); + await processor.forceFlush(); + const [exported] = exporter.getFinishedSpans(); + const blob = JSON.stringify({ status: exported.status, events: exported.events, attributes: exported.attributes }); + for (const value of forbidden) expect(blob).not.toContain(value); + // Content is on by default: the data Genkit quotes stays (it is the app's own content). + expect(exported.status.message).toContain(DATA_MARKER); + expect(exported.status.message).toContain(""); + expect(exported.status.message).toContain("[cwd]/genkit.config.json"); + expect(exported.events.map((e) => e.name)).toEqual(["custom", "exception"]); + expect(exported.events[0].attributes?.where).toBe("~/notes"); + const exception = exported.events[1]; + expect(exception.time).toEqual([1, 5]); + expect(exception.attributes?.["exception.type"]).toBe("GenkitError"); + expect(exception.attributes?.["exception.message"]).toBe(exported.status.message); + expect(exception.attributes).not.toHaveProperty("exception.stacktrace"); + // Genkit's own span (read by the Dev UI exporter) keeps the full message and stack. + expect(span.status.message).toBe(message); + expect(span.events[1].attributes?.["exception.stacktrace"]).toBe(stacktrace); + }); + + it("hidden (FI_HIDE_INPUTS / FI_HIDE_OUTPUTS): replaces the message with the error type and __REDACTED__", async () => { + for (const traceConfig of [{ hideInputs: true }, { hideOutputs: true }]) { + const { exporter, provider } = fiLikeProvider(); + const processor = new FIGenkitSpanProcessor({ tracerProvider: provider, traceConfig }); + processor.onEnd(errorSpan("9999999999999992")); + await processor.forceFlush(); + const [exported] = exporter.getFinishedSpans(); + const blob = JSON.stringify({ status: exported.status, events: exported.events, attributes: exported.attributes }); + expect(blob).not.toContain(DATA_MARKER); + for (const value of forbidden) expect(blob).not.toContain(value); + expect(exported.status).toEqual({ code: 2, message: "GenkitError: __REDACTED__" }); + expect(exported.events[1].attributes).toEqual({ "exception.type": "GenkitError", "exception.message": "__REDACTED__" }); + } + }); + + it("hidden: a status with no exception event becomes __REDACTED__", async () => { + const { exporter, provider } = fiLikeProvider(); + const processor = new FIGenkitSpanProcessor({ tracerProvider: provider, traceConfig: { hideInputs: true, hideOutputs: true } }); + processor.onEnd(v1Span({ name: "lookup", attributes: toolAttributes(), spanId: "9999999999999993", status: { code: 2, message: `bad ${DATA_MARKER}` } })); + await processor.forceFlush(); + expect(exporter.getFinishedSpans()[0].status).toEqual({ code: 2, message: "__REDACTED__" }); + }); + + it("leaves a plain error message unchanged by default and an OK status untouched", async () => { + const { exporter, provider } = fiLikeProvider(); + const processor = new FIGenkitSpanProcessor({ tracerProvider: provider }); + const events = [{ name: "exception", time: [1, 0] as [number, number], attributes: { "exception.type": "Error", "exception.message": "boom", "exception.stacktrace": "Error: boom\n at x (y.js:1:1)" } }]; + processor.onEnd(v1Span({ name: "lookup", attributes: toolAttributes(), spanId: "9999999999999994", status: { code: 2, message: "boom" }, events })); + processor.onEnd(v1Span({ name: "qaFlow", attributes: flowAttributes(), spanId: "9999999999999995" })); + await processor.forceFlush(); + const spans = exportedByName(exporter); + expect(spans.lookup.status).toEqual({ code: 2, message: "boom" }); + expect(spans.lookup.events[0].attributes).toEqual({ "exception.type": "Error", "exception.message": "boom" }); + expect(spans.qaFlow.status).toEqual({ code: 0 }); + }); +}); + +describe("FIGenkitSpanProcessor: failure isolation", () => { + it("onEnd never throws when the downstream processor throws", () => { + const { provider } = fiLikeProvider(); + const processor = new FIGenkitSpanProcessor({ tracerProvider: provider }); + (provider as any)._activeSpanProcessor.onEnd = () => { + throw new Error("exporter blew up"); + }; + expect(() => processor.onEnd(v1Span({ name: "x", attributes: flowAttributes(), spanId: "7777777777777777" }))).not.toThrow(); + }); + + it("onEnd never throws on a malformed span", () => { + const { provider } = fiLikeProvider(); + const processor = new FIGenkitSpanProcessor({ tracerProvider: provider }); + expect(() => processor.onEnd({} as any)).not.toThrow(); + expect(() => processor.onStart({}, undefined as any)).not.toThrow(); + }); + + it("forceFlush and shutdown resolve when the provider rejects or throws", async () => { + const provider = fiLikeProvider().provider; + const processor = new FIGenkitSpanProcessor({ tracerProvider: provider }); + provider.forceFlush = () => Promise.reject(new Error("collector down")); + provider.shutdown = () => { + throw new Error("sync shutdown failure"); + }; + await expect(processor.forceFlush()).resolves.toBeUndefined(); + await expect(processor.shutdown()).resolves.toBeUndefined(); + await expect(processor.shutdown()).resolves.toBeUndefined(); + }); + + it("forceFlush returns after flushTimeoutMillis when the exporter hangs", async () => { + const provider = fiLikeProvider().provider; + provider.forceFlush = () => new Promise(() => undefined); + const processor = new FIGenkitSpanProcessor({ tracerProvider: provider, flushTimeoutMillis: 50 }); + const started = Date.now(); + await expect(processor.forceFlush()).resolves.toBeUndefined(); + expect(Date.now() - started).toBeLessThan(2000); + }); + + it("drops spans after shutdown instead of throwing", async () => { + const { exporter, provider } = fiLikeProvider(); + const processor = new FIGenkitSpanProcessor({ tracerProvider: provider }); + await processor.shutdown(); + expect(() => processor.onEnd(v1Span({ name: "late", attributes: flowAttributes(), spanId: "8888888888888888" }))).not.toThrow(); + expect(exporter.getFinishedSpans()).toEqual([]); + }); + + it("shutdown flushes before shutting the provider down", async () => { + const order: string[] = []; + const provider = fiLikeProvider().provider; + const flush = provider.forceFlush.bind(provider); + const stop = provider.shutdown.bind(provider); + provider.forceFlush = async () => { + order.push("flush"); + await flush(); + }; + provider.shutdown = async () => { + order.push("shutdown"); + await stop(); + }; + await new FIGenkitSpanProcessor({ tracerProvider: provider }).shutdown(); + expect(order).toEqual(["flush", "shutdown"]); + }); +}); + +describe("FIGenkitSpanProcessor: construction", () => { + it("rejects something that is not a tracer provider", () => { + expect(() => new FIGenkitSpanProcessor({} as any)).toThrow(TypeError); + expect(() => new FIGenkitSpanProcessor({ tracerProvider: { forceFlush: async () => {}, shutdown: async () => {} } })).toThrow( + /register\(\) from @traceai\/fi-core/, + ); + }); + + it("reads the processor and resource of a real fi-core register() provider", async () => { + const provider = register({ + projectName: "unit-register", + projectType: ProjectType.OBSERVE, + setGlobalTracerProvider: false, + endpoint: "http://127.0.0.1:1", + headers: { "x-api-key": "PLACEHOLDER", "x-secret-key": "PLACEHOLDER" }, + }); + const processor = new FIGenkitSpanProcessor({ tracerProvider: provider }); + expect((processor as any).resource.attributes).toMatchObject({ project_name: "unit-register", project_type: "observe" }); + expect(typeof (processor as any).target.onEnd).toBe("function"); + await processor.shutdown(); + }); + + it("warns when the Future AGI provider was registered as the global provider", () => { + const { provider } = fiLikeProvider(); + const emit = jest.spyOn(process, "emitWarning").mockImplementation(() => undefined); + try { + trace.setGlobalTracerProvider(provider); + new FIGenkitSpanProcessor({ tracerProvider: provider }); + expect(emit).toHaveBeenCalledWith(expect.stringContaining("setGlobalTracerProvider: false"), expect.objectContaining({ code: "TRACEAI_GENKIT_GLOBAL_PROVIDER" })); + emit.mockClear(); + new FIGenkitSpanProcessor({ tracerProvider: fiLikeProvider().provider }); + expect(emit).not.toHaveBeenCalled(); + } finally { + trace.disable(); + context.disable(); + emit.mockRestore(); + } + }); +}); diff --git a/typescript/packages/traceai_genkit/src/__tests__/signals.test.ts b/typescript/packages/traceai_genkit/src/__tests__/signals.test.ts new file mode 100644 index 000000000..2678f44bc --- /dev/null +++ b/typescript/packages/traceai_genkit/src/__tests__/signals.test.ts @@ -0,0 +1,96 @@ +import { EventEmitter } from "events"; +import { flushOnSignals, type SignalTarget } from "../index"; + +function fakeProcess() { + const emitter = new EventEmitter(); + const kill = jest.fn(); + const target: SignalTarget = { + pid: 4242, + listeners: (event) => emitter.listeners(event), + on: (event, listener) => emitter.on(event, listener), + removeListener: (event, listener) => emitter.removeListener(event, listener as (...args: unknown[]) => void), + kill, + }; + return { emitter, target, kill }; +} + +const tick = () => new Promise((resolve) => setImmediate(resolve)); + +describe("flushOnSignals", () => { + it("awaits flush before the earlier listeners (Genkit's exit handler) run", async () => { + const { emitter, target } = fakeProcess(); + const order: string[] = []; + // Stand-ins for genkit.ts `shutdown` (calls process.exit) and node-telemetry-provider `cleanUpTracing`. + emitter.on("SIGTERM", () => order.push("genkit-exit")); + emitter.on("SIGTERM", () => order.push("genkit-sdk-cleanup")); + let release!: () => void; + const flushing = new Promise((resolve) => (release = resolve)); + flushOnSignals( + async () => { + order.push("flush-start"); + await flushing; + order.push("flush-done"); + }, + { target }, + ); + expect(emitter.listenerCount("SIGTERM")).toBe(1); + emitter.emit("SIGTERM", "SIGTERM"); + await tick(); + expect(order).toEqual(["flush-start"]); + release(); + await tick(); + await tick(); + expect(order).toEqual(["flush-start", "flush-done", "genkit-exit", "genkit-sdk-cleanup"]); + }); + + it("still runs the earlier listeners when flush rejects or hangs", async () => { + const { emitter, target } = fakeProcess(); + const seen: string[] = []; + emitter.on("SIGTERM", () => seen.push("exit")); + flushOnSignals(() => Promise.reject(new Error("collector down")), { target }); + emitter.emit("SIGTERM", "SIGTERM"); + await tick(); + await tick(); + expect(seen).toEqual(["exit"]); + + const second = fakeProcess(); + second.emitter.on("SIGINT", () => seen.push("int-exit")); + flushOnSignals(() => new Promise(() => undefined), { target: second.target, timeoutMillis: 20, signals: ["SIGINT"] }); + second.emitter.emit("SIGINT", "SIGINT"); + await new Promise((resolve) => setTimeout(resolve, 60)); + expect(seen).toEqual(["exit", "int-exit"]); + }); + + it("re-raises the signal when nothing else was listening", async () => { + const { emitter, target, kill } = fakeProcess(); + const flush = jest.fn(async () => undefined); + flushOnSignals(flush, { target, signals: ["SIGTERM"] }); + emitter.emit("SIGTERM", "SIGTERM"); + await tick(); + await tick(); + expect(flush).toHaveBeenCalledTimes(1); + expect(emitter.listenerCount("SIGTERM")).toBe(0); + expect(kill).toHaveBeenCalledWith(4242, "SIGTERM"); + }); + + it("flushes once even if the signal arrives twice", async () => { + const { emitter, target } = fakeProcess(); + const flush = jest.fn(async () => undefined); + emitter.on("SIGTERM", () => undefined); + flushOnSignals(flush, { target }); + emitter.emit("SIGTERM", "SIGTERM"); + emitter.emit("SIGTERM", "SIGTERM"); + await tick(); + expect(flush).toHaveBeenCalledTimes(1); + }); + + it("uninstall restores the original listeners", () => { + const { emitter, target } = fakeProcess(); + const original = () => undefined; + emitter.on("SIGTERM", original); + const uninstall = flushOnSignals(async () => undefined, { target }); + expect(emitter.listeners("SIGTERM")).not.toContain(original); + uninstall(); + expect(emitter.listeners("SIGTERM")).toEqual([original]); + }); +}); diff --git a/typescript/packages/traceai_genkit/src/__tests__/types.test.ts b/typescript/packages/traceai_genkit/src/__tests__/types.test.ts new file mode 100644 index 000000000..5964b0983 --- /dev/null +++ b/typescript/packages/traceai_genkit/src/__tests__/types.test.ts @@ -0,0 +1,36 @@ +/** + * Type-level contract with the pinned genkit: FIGenkitSpanProcessor must be + * accepted by `enableTelemetry({ spanProcessors })`, whose config type is + * `TelemetryConfig = Partial` (@genkit-ai/core + * src/telemetryTypes.ts:24 at 1.42.0). ts-jest type-checks this file, so a + * type error fails the suite. + */ +import type { TelemetryConfig } from "genkit"; +import type { enableTelemetry, flushTracing } from "genkit/tracing"; +import { BasicTracerProvider } from "@opentelemetry/sdk-trace-base"; +import { FIGenkitSpanProcessor } from "../index"; + +type EnableTelemetryArg = Parameters[0]; + +describe("genkit 1.42.0 type compatibility", () => { + it("is a valid spanProcessors entry of TelemetryConfig and enableTelemetry's argument", () => { + const processor = new FIGenkitSpanProcessor({ tracerProvider: new BasicTracerProvider() }); + const config: TelemetryConfig = { spanProcessors: [processor] }; + const arg: EnableTelemetryArg = config; + expect(arg.spanProcessors).toHaveLength(1); + }); + + it("flushTracing is the exported flush function and returns a promise", () => { + type Flush = typeof flushTracing; + const check: ReturnType extends Promise ? true : false = true; + expect(check).toBe(true); + }); + + it("TelemetryConfig has no forceDevExport / disableMetrics (those are @genkit-ai/google-cloud options)", () => { + // @ts-expect-error disableMetrics is not a TelemetryConfig key at genkit 1.42.0 + const a: TelemetryConfig = { disableMetrics: true }; + // @ts-expect-error forceDevExport is not a TelemetryConfig key at genkit 1.42.0 + const b: TelemetryConfig = { forceDevExport: true }; + expect([a, b]).toHaveLength(2); + }); +}); diff --git a/typescript/packages/traceai_genkit/src/attributes.ts b/typescript/packages/traceai_genkit/src/attributes.ts new file mode 100644 index 000000000..7e947d794 --- /dev/null +++ b/typescript/packages/traceai_genkit/src/attributes.ts @@ -0,0 +1,239 @@ +/** + * Genkit span attribute inventory and the Future AGI keys this package writes. + * + * Every Genkit key below was read from the installed genkit 1.42.0 sources + * (@genkit-ai/core and @genkit-ai/ai) and confirmed on spans dumped by + * contract/inventory.mjs (Genkit's own `mockModel` from `genkit/testing`). + * Nothing here is a guessed path. + */ +import { FISpanKind, LLMProvider, SemanticConventions } from "@traceai/fi-semantic-conventions"; + +/** + * Attribute keys Genkit 1.42.0 writes on its spans. + * + * - `genkit:type`, `genkit:metadata:subtype`, `genkit:key` are labels set at span + * start (core/src/action.ts:538-543, core/src/flow.ts:219-221, + * ai/src/generate/action.ts:147-149, ai/src/prompt.ts:273-275 and 490-492). + * - The rest come from `metadataToAttributes()` at span end + * (core/src/tracing/instrumentation.ts:176, 221-243): every SpanMetadata field + * becomes `genkit:`, and `metadata.metadata` entries become + * `genkit:metadata:`. + */ +export const GenkitAttributes = { + TYPE: "genkit:type", + SUBTYPE: "genkit:metadata:subtype", + KEY: "genkit:key", + NAME: "genkit:name", + PATH: "genkit:path", + STATE: "genkit:state", + IS_ROOT: "genkit:isRoot", + IS_FAILURE_SOURCE: "genkit:isFailureSource", + INPUT: "genkit:input", + OUTPUT: "genkit:output", + INIT: "genkit:init", + LAST_KNOWN_PARENT_SPAN_ID: "genkit:lastKnownParentSpanId", + /** core/src/action.ts:557-559. JSON of the action context, `auth`/`secrets` redacted by Genkit. */ + METADATA_CONTEXT: "genkit:metadata:context", + /** ai/src/tool.ts:538-540. Tool interrupt metadata (JSON). */ + METADATA_INTERRUPT: "genkit:metadata:interrupt", + /** ai/src/tool.ts:569-571. Resumed-tool metadata (JSON). */ + METADATA_RESUMED: "genkit:metadata:resumed", + /** ai/src/agent.ts:1061-1063 (beta agents). The agent session id. */ + METADATA_AGENT_SESSION_ID: "genkit:metadata:agent:sessionId", + /** ai/src/prompt.ts:269-271. The prompt a `render` (promptTemplate) span rendered. */ + METADATA_PROMPT_NAME: "genkit:metadata:promptName", + /** ai/src/agent.ts:486. The snapshot a server-managed agent turn persisted. */ + METADATA_AGENT_SNAPSHOT_ID: "genkit:metadata:agent:snapshotId", +} as const; + +/** `genkit:type` values at 1.42.0. */ +export const GenkitSpanType = { + /** Every registered action (core/src/action.ts:539). The real kind is in `genkit:metadata:subtype`. */ + ACTION: "action", + /** `ai.run()` steps inside a flow (core/src/flow.ts:220). */ + FLOW_STEP: "flowStep", + /** The `generate` helper span around the whole tool loop (ai/src/generate/action.ts:148). */ + UTIL: "util", + /** Prompt rendering (ai/src/prompt.ts:274). */ + PROMPT_TEMPLATE: "promptTemplate", + /** Executable prompt call (ai/src/prompt.ts:491). */ + DOTPROMPT: "dotprompt", +} as const; + +/** + * `genkit:metadata:subtype` values on `genkit:type=action` spans: the + * ActionType list in core/src/registry.ts:40-62 at 1.42.0. + */ +export const GENKIT_ACTION_SUBTYPES = [ + "custom", + "dynamic-action-provider", + "embedder", + "evaluator", + "executable-prompt", + "flow", + "indexer", + "model", + "background-model", + "check-operation", + "cancel-operation", + "prompt", + "reranker", + "retriever", + "tool", + "tool.v2", + "util", + "resource", + "agent", + "agent-snapshot", + "agent-abort", +] as const; + +/** Action subtypes with a dedicated Future AGI kind. Every other action is CHAIN. */ +export const SUBTYPE_TO_KIND: Readonly> = { + flow: FISpanKind.CHAIN, + model: FISpanKind.LLM, + "background-model": FISpanKind.LLM, + tool: FISpanKind.TOOL, + "tool.v2": FISpanKind.TOOL, + retriever: FISpanKind.RETRIEVER, + embedder: FISpanKind.EMBEDDING, + reranker: FISpanKind.RERANKER, + evaluator: FISpanKind.EVALUATOR, + agent: FISpanKind.AGENT, +}; + +/** Non-action `genkit:type` values. All are orchestration spans. */ +export const TYPE_TO_KIND: Readonly> = { + [GenkitSpanType.FLOW_STEP]: FISpanKind.CHAIN, + [GenkitSpanType.UTIL]: FISpanKind.CHAIN, + [GenkitSpanType.PROMPT_TEMPLATE]: FISpanKind.CHAIN, + [GenkitSpanType.DOTPROMPT]: FISpanKind.CHAIN, +}; + +/** + * Input-side content keys: hidden by `hideInputs` (FI_HIDE_INPUTS), and on model spans also by + * `hideInputMessages` (the model request is the message list). `genkit:init` is a beta agent's + * initial state; `genkit:metadata:resumed` is the data a resumed tool call was given. + */ +export const GENKIT_INPUT_KEYS: readonly string[] = [ + GenkitAttributes.INPUT, + GenkitAttributes.INIT, + GenkitAttributes.METADATA_RESUMED, +]; + +/** + * Output-side content keys: hidden by `hideOutputs` (FI_HIDE_OUTPUTS), and on model spans also by + * `hideOutputMessages`. `genkit:metadata:interrupt` is the payload a tool interrupt returned. + */ +export const GENKIT_OUTPUT_KEYS: readonly string[] = [GenkitAttributes.OUTPUT, GenkitAttributes.METADATA_INTERRUPT]; + +/** Every key that carries user content: {@link GENKIT_INPUT_KEYS} and {@link GENKIT_OUTPUT_KEYS}. */ +export const GENKIT_CONTENT_KEYS: readonly string[] = [...GENKIT_INPUT_KEYS, ...GENKIT_OUTPUT_KEYS]; + +/** Request context can hold credentials or headers. Never exported. */ +export const GENKIT_NEVER_EXPORTED_KEYS: readonly string[] = [GenkitAttributes.METADATA_CONTEXT]; + +/** + * GenerationUsage fields (ai/src/model-types.ts:260-275) copied from a model + * span's `genkit:output.usage`, and the Future AGI key each one goes to. + * + * inputTokens, outputTokens and totalTokens are on every inventoried model span + * (contract/inventory.mjs, Genkit's own `mockModel`). thoughtsTokens and + * cachedContentTokens are set by the Google AI / Vertex AI plugin + * (@genkit-ai/google-genai 1.42.0 lib/googleai/gemini.js:642-646, from + * usageMetadata.thoughtsTokenCount / cachedContentTokenCount) and were seen on + * real gemini-3.8-flash spans. Gemini's outputTokens excludes the thinking + * tokens, which only show up in totalTokens and thoughtsTokens. + */ +export const USAGE_TO_ATTRIBUTE: Readonly> = { + inputTokens: SemanticConventions.LLM_TOKEN_COUNT_PROMPT, + outputTokens: SemanticConventions.LLM_TOKEN_COUNT_COMPLETION, + totalTokens: SemanticConventions.LLM_TOKEN_COUNT_TOTAL, + thoughtsTokens: SemanticConventions.LLM_TOKEN_COUNT_COMPLETION_DETAILS_REASONING, + cachedContentTokens: SemanticConventions.LLM_TOKEN_COUNT_PROMPT_DETAILS_CACHE_READ, +}; + +/** + * GenerationUsageSchema fields at 1.42.0 that neither the inventory nor the + * google-genai plugin sets. They are unavailable: not copied to any Future AGI + * key (they stay inside `genkit:output`, which is exported unless + * `hideOutputs` / FI_HIDE_OUTPUTS hides it). + */ +export const GENKIT_USAGE_NOT_MAPPED: readonly string[] = [ + "inputCharacters", + "outputCharacters", + "inputImages", + "outputImages", + "inputVideos", + "outputVideos", + "inputAudioFiles", + "outputAudioFiles", + "custom", +]; + +/** + * Model plugin namespace (the part of a model action name before the first + * "/") -> `gen_ai.provider.name`. Only namespaces read from the published + * plugins are listed: googleai / vertexai (@genkit-ai/google-genai), openai / + * deepseek / xai (@genkit-ai/compat-oai), anthropic (genkitx-anthropic), + * ollama (genkitx-ollama), mistral (genkitx-mistral), groq (genkitx-groq), + * aws-bedrock (genkitx-aws-bedrock), azure-openai (genkitx-azure-openai). Any + * other namespace leaves the provider unset. Values are the fi-semantic-conventions + * LLMProvider values; "vertexai" is the Future AGI backend's provider value + * for Vertex AI (FiLLMProviderValues.VERTEXAI), which LLMProvider lacks. + */ +export const MODEL_NAMESPACE_TO_PROVIDER: Readonly> = { + googleai: LLMProvider.GOOGLE, + vertexai: "vertexai", + openai: LLMProvider.OPENAI, + deepseek: LLMProvider.DEEPSEEK, + xai: LLMProvider.XAI, + anthropic: LLMProvider.ANTHROPIC, + ollama: LLMProvider.OLLAMA, + mistral: LLMProvider.MISTRALAI, + groq: LLMProvider.GROQ, + "aws-bedrock": LLMProvider.AWS, + "azure-openai": LLMProvider.AZURE, +}; + +/** + * Split a registered model action name ("googleai/gemini-3.5-flash") into the + * plugin namespace and the vendor model id. fi-collector prices a span by an + * exact model-name lookup in its litellm table, which has "gemini-3.5-flash" + * and not "googleai/gemini-3.5-flash". A name with no "/" has no namespace. + */ +export function splitModelName(name: string): { namespace?: string; model: string } { + const at = name.indexOf("/"); + if (at <= 0 || at === name.length - 1) return { model: name }; + return { namespace: name.slice(0, at), model: name.slice(at + 1) }; +} + +/** The Future AGI span-kind keys. fi-collector reads `fi.span.kind`, then `gen_ai.span.kind`. */ +export const FI_SPAN_KIND = SemanticConventions.FI_SPAN_KIND; +export const GEN_AI_SPAN_KIND = "gen_ai.span.kind"; +export const GEN_AI_TOOL_NAME = "gen_ai.tool.name"; + +/** + * Prefix for usage/cost values found on a span that is not a model call. The + * collector promotes the plain keys on any span kind and Observe sums them over + * the trace, so they would double count. + */ +export const GENKIT_USAGE_PREFIX = "genkit.usage."; + +/** + * True for keys fi-collector promotes into token/cost columns on any span kind. + * Cost is matched by prefix: with no total present the collector also promotes + * the cost parts (`gen_ai.cost.input`/`output`, `llm.cost.prompt`/`completion`). + */ +export function isPromotedUsageKey(key: string): boolean { + return ( + key === SemanticConventions.LLM_TOKEN_COUNT_PROMPT || + key === SemanticConventions.LLM_TOKEN_COUNT_COMPLETION || + key === SemanticConventions.LLM_TOKEN_COUNT_TOTAL || + key.startsWith("gen_ai.usage.") || + key.startsWith("llm.token_count.") || + key.startsWith("llm.usage.") || + key.startsWith("gen_ai.cost.") || + key.startsWith("llm.cost.") + ); +} diff --git a/typescript/packages/traceai_genkit/src/index.ts b/typescript/packages/traceai_genkit/src/index.ts new file mode 100644 index 000000000..77dcc0426 --- /dev/null +++ b/typescript/packages/traceai_genkit/src/index.ts @@ -0,0 +1,51 @@ +export { + FIGenkitSpanProcessor, + exportEvents, + exportStatus, + toExportableSpan, + type ExportableSpan, + type ExportPrivacy, + type FIGenkitSpanProcessorOptions, + type FITracerProviderLike, + type GenkitReadableSpan, + type InstrumentationScopeLike, + type TimedEventLike, +} from "./processor"; +export { genkitSpanKind, mapGenkitAttributes, type MapOptions } from "./mapping"; +export { + FI_SPAN_KIND, + GEN_AI_SPAN_KIND, + GEN_AI_TOOL_NAME, + GENKIT_ACTION_SUBTYPES, + GENKIT_CONTENT_KEYS, + GENKIT_INPUT_KEYS, + GENKIT_OUTPUT_KEYS, + GENKIT_NEVER_EXPORTED_KEYS, + GENKIT_USAGE_NOT_MAPPED, + GENKIT_USAGE_PREFIX, + GenkitAttributes, + GenkitSpanType, + MODEL_NAMESPACE_TO_PROVIDER, + SUBTYPE_TO_KIND, + TYPE_TO_KIND, + USAGE_TO_ATTRIBUTE, + isPromotedUsageKey, + splitModelName, +} from "./attributes"; +export { flushOnSignals, type FlushOnSignalsOptions, type SignalTarget } from "./signals"; +export { + CWD_TOKEN, + HIDE_ALL, + PATH_REMOVED, + SHOW_ALL, + STACK_TRACE_REMOVED, + defaultScrubContext, + hidesFreeText, + redactEmbeddingVectors, + redactMessageText, + resolveContentPolicy, + scrubContent, + scrubErrorText, + type ContentPolicy, + type ScrubContext, +} from "./privacy"; diff --git a/typescript/packages/traceai_genkit/src/mapping.ts b/typescript/packages/traceai_genkit/src/mapping.ts new file mode 100644 index 000000000..f6fc0f9d3 --- /dev/null +++ b/typescript/packages/traceai_genkit/src/mapping.ts @@ -0,0 +1,254 @@ +import type { Attributes, AttributeValue } from "@opentelemetry/api"; +import { REDACTED_VALUE } from "@traceai/fi-core"; +import { FISpanKind, MimeType, SemanticConventions } from "@traceai/fi-semantic-conventions"; +import { + FI_SPAN_KIND, + GEN_AI_SPAN_KIND, + GEN_AI_TOOL_NAME, + GENKIT_INPUT_KEYS, + GENKIT_NEVER_EXPORTED_KEYS, + GENKIT_OUTPUT_KEYS, + GENKIT_USAGE_PREFIX, + GenkitAttributes, + GenkitSpanType, + MODEL_NAMESPACE_TO_PROVIDER, + SUBTYPE_TO_KIND, + TYPE_TO_KIND, + USAGE_TO_ATTRIBUTE, + isPromotedUsageKey, + splitModelName, +} from "./attributes"; +import { + type ContentPolicy, + redactEmbeddingVectors, + redactMessageText, + SHOW_ALL, + type ScrubContext, + scrubContent, +} from "./privacy"; + +export interface MapOptions { + /** + * Resolved TraceConfig content flags (see `resolveContentPolicy`). Default: fi-core's defaults, + * nothing hidden: `genkit:input` / `genkit:output` are exported and copied to `input.value` / + * `output.value`. + */ + policy?: ContentPolicy; + /** cwd / home directory rewritten in every exported string. Default: none (other local paths are still removed). */ + scrub?: ScrubContext; + /** + * Attributes read from the OTel context when the span started (fi-core + * `setSession`, `setUser`, `setMetadata`, `setTags`, `setAttributes`). Applied + * only where the span does not already carry the key. + */ + contextAttributes?: Attributes; +} + +/** + * Future AGI span kind for a Genkit span, or undefined when the span carries no + * known `genkit:type` (the span is still exported, just without a kind). + */ +export function genkitSpanKind(attributes: Attributes): FISpanKind | undefined { + const type = attributes[GenkitAttributes.TYPE]; + if (typeof type !== "string") { + return undefined; + } + if (type === GenkitSpanType.ACTION) { + const subtype = attributes[GenkitAttributes.SUBTYPE]; + if (typeof subtype === "string" && SUBTYPE_TO_KIND[subtype] !== undefined) { + return SUBTYPE_TO_KIND[subtype]; + } + // Every other registered action (custom, prompt, util, indexer, resource, ...). + return FISpanKind.CHAIN; + } + return TYPE_TO_KIND[type]; +} + +function parseJson(value: AttributeValue | undefined): unknown { + if (typeof value !== "string" || value.length === 0) { + return undefined; + } + try { + return JSON.parse(value); + } catch { + // Truncated by an attribute length limit, or not JSON. Usage is then unavailable. + return undefined; + } +} + +function isRecord(value: unknown): value is Record { + return typeof value === "object" && value !== null && !Array.isArray(value); +} + +/** Usage, finish reason and model for one model call, read from the model action span. */ +function modelCallAttributes(source: Attributes): Attributes { + const out: Attributes = {}; + const name = source[GenkitAttributes.NAME]; + if (typeof name === "string" && name.length > 0) { + // The registered model action name, e.g. "googleai/gemini-3.5-flash" (action.ts:535, 572). + // The model keys get the vendor id without the plugin namespace, so fi-collector can price + // the call; the full name stays on genkit:name. Genkit reports no resolved model version. + const { namespace, model } = splitModelName(name); + out[SemanticConventions.LLM_MODEL_NAME] = model; + out[SemanticConventions.GEN_AI_RESPONSE_MODEL] = model; + const provider = namespace === undefined ? undefined : MODEL_NAMESPACE_TO_PROVIDER[namespace]; + if (provider !== undefined) out[SemanticConventions.LLM_PROVIDER] = provider; + } + const response = parseJson(source[GenkitAttributes.OUTPUT]); + if (!isRecord(response)) { + return out; + } + const usage = response.usage; + if (isRecord(usage)) { + for (const [field, key] of Object.entries(USAGE_TO_ATTRIBUTE)) { + const value = usage[field]; + if (typeof value === "number" && Number.isFinite(value)) { + out[key] = value; + } + } + } + if (typeof response.finishReason === "string") { + out[SemanticConventions.GEN_AI_RESPONSE_FINISH_REASONS] = [response.finishReason]; + } + return out; +} + +/** How one side (input or output) of a span is exported. */ +type SideMode = "show" | "text" | "hide"; + +function sideModes(policy: ContentPolicy, isModelCall: boolean): { input: SideMode; output: SideMode } { + // On a model span `genkit:input` is the request (the message list) and `genkit:output` the + // response message, so the *_MESSAGES and *_TEXT flags apply there as they do to + // gen_ai.input.messages / gen_ai.output.messages in fi-core. + const input: SideMode = + policy.hideInputs || (isModelCall && policy.hideInputMessages) + ? "hide" + : isModelCall && policy.hideInputText + ? "text" + : "show"; + const output: SideMode = + policy.hideOutputs || (isModelCall && policy.hideOutputMessages) + ? "hide" + : isModelCall && policy.hideOutputText + ? "text" + : "show"; + return { input, output }; +} + +function sideValue( + value: AttributeValue, + mode: SideMode, + scrub: ScrubContext, + hideVectors: boolean, +): AttributeValue | undefined { + if (mode === "hide") return undefined; + if (typeof value !== "string") return value; + let text = mode === "text" ? (redactMessageText(value) ?? REDACTED_VALUE) : value; + if (hideVectors) text = redactEmbeddingVectors(text) as string; + return scrubContent(text, scrub); +} + +/** + * Map one Genkit span's attributes to the attributes exported to Future AGI. + * + * Returns a new object; `source` is never modified, because Genkit's own + * exporters (dev UI telemetry server, Firebase plugin) read the same span. + */ +export function mapGenkitAttributes(source: Attributes, options: MapOptions = {}): Attributes { + const policy = options.policy ?? SHOW_ALL; + const scrub = options.scrub ?? {}; + const kind = genkitSpanKind(source); + const isModelCall = kind === FISpanKind.LLM; + const modes = sideModes(policy, isModelCall); + // FI_HIDE_EMBEDDING_VECTORS: the vectors are in an embedder span's output. + const hideVectors = kind === FISpanKind.EMBEDDING && policy.hideEmbeddingVectors === true; + const out: Attributes = {}; + + for (const [key, value] of Object.entries(source)) { + if (value === undefined) continue; + if (GENKIT_NEVER_EXPORTED_KEYS.includes(key)) continue; + if (GENKIT_INPUT_KEYS.includes(key) || GENKIT_OUTPUT_KEYS.includes(key)) { + const isInput = GENKIT_INPUT_KEYS.includes(key); + const exported = sideValue(value, isInput ? modes.input : modes.output, scrub, hideVectors && !isInput); + if (exported !== undefined) out[key] = exported; + continue; + } + if (!isModelCall && isPromotedUsageKey(key)) { + // Aggregate usage on a non-model span would be summed again by Observe. + out[GENKIT_USAGE_PREFIX + key] = value; + continue; + } + out[key] = typeof value === "string" ? scrubContent(value, scrub) : value; + } + + if (kind !== undefined) { + if (out[FI_SPAN_KIND] === undefined) out[FI_SPAN_KIND] = kind; + if (out[GEN_AI_SPAN_KIND] === undefined) out[GEN_AI_SPAN_KIND] = kind; + } + + if (isModelCall) { + // Read from the source span before any content is hidden: tokens, finish reason and model are + // not content and stay available with FI_HIDE_OUTPUTS. + for (const [key, value] of Object.entries(modelCallAttributes(source))) { + if (value !== undefined && out[key] === undefined) out[key] = value; + } + } + + if (kind === FISpanKind.EMBEDDING) { + // The registered embedder action name, e.g. "googleai/gemini-embedding-001". + const name = source[GenkitAttributes.NAME]; + if (typeof name === "string" && name.length > 0) { + const { namespace, model } = splitModelName(name); + if (out[SemanticConventions.EMBEDDING_MODEL_NAME] === undefined) out[SemanticConventions.EMBEDDING_MODEL_NAME] = model; + const provider = namespace === undefined ? undefined : MODEL_NAMESPACE_TO_PROVIDER[namespace]; + if (provider !== undefined && out[SemanticConventions.LLM_PROVIDER] === undefined) out[SemanticConventions.LLM_PROVIDER] = provider; + } + } + + if (kind === FISpanKind.TOOL) { + const name = source[GenkitAttributes.NAME]; + if (typeof name === "string" && name.length > 0) { + if (out[SemanticConventions.TOOL_NAME] === undefined) out[SemanticConventions.TOOL_NAME] = name; + if (out[GEN_AI_TOOL_NAME] === undefined) out[GEN_AI_TOOL_NAME] = name; + } + } + + const agentSession = source[GenkitAttributes.METADATA_AGENT_SESSION_ID]; + if (typeof agentSession === "string" && agentSession.length > 0 && out[SemanticConventions.SESSION_ID] === undefined) { + out[SemanticConventions.SESSION_ID] = agentSession; + } + + if (options.contextAttributes) { + for (const [key, value] of Object.entries(options.contextAttributes)) { + if (value === undefined || out[key] !== undefined) continue; + if (isPromotedUsageKey(key) && !isModelCall) { + out[GENKIT_USAGE_PREFIX + key] = value; + } else { + out[key] = value; + } + } + } + + // input.value / output.value, the keys Future AGI shows as a span's input and output. A hidden + // side gets fi-core's "__REDACTED__" and no mime type, as fi-core's own masking does. + const input = source[GenkitAttributes.INPUT]; + if (typeof input === "string" && out[SemanticConventions.INPUT_VALUE] === undefined) { + if (modes.input === "hide") { + out[SemanticConventions.INPUT_VALUE] = REDACTED_VALUE; + } else { + out[SemanticConventions.INPUT_VALUE] = out[GenkitAttributes.INPUT] as string; + out[SemanticConventions.INPUT_MIME_TYPE] = MimeType.JSON; + } + } + const output = source[GenkitAttributes.OUTPUT]; + if (typeof output === "string" && out[SemanticConventions.OUTPUT_VALUE] === undefined) { + if (modes.output === "hide") { + out[SemanticConventions.OUTPUT_VALUE] = REDACTED_VALUE; + } else { + out[SemanticConventions.OUTPUT_VALUE] = out[GenkitAttributes.OUTPUT] as string; + out[SemanticConventions.OUTPUT_MIME_TYPE] = MimeType.JSON; + } + } + + return out; +} diff --git a/typescript/packages/traceai_genkit/src/privacy.ts b/typescript/packages/traceai_genkit/src/privacy.ts new file mode 100644 index 000000000..78216cdd7 --- /dev/null +++ b/typescript/packages/traceai_genkit/src/privacy.ts @@ -0,0 +1,313 @@ +/** + * Privacy for the exported copy of a Genkit span. + * + * Content follows the traceAI `TraceConfig` convention, like every traceAI instrumentor: Genkit's + * inputs and outputs (prompts, model responses, tool arguments and results, flow input/output) are + * exported by default, and the standard flags hide them: `FI_HIDE_INPUTS`, `FI_HIDE_OUTPUTS`, + * `FI_HIDE_INPUT_MESSAGES`, `FI_HIDE_OUTPUT_MESSAGES`, `FI_HIDE_INPUT_TEXT`, `FI_HIDE_OUTPUT_TEXT`, + * `FI_HIDE_EMBEDDING_VECTORS`, or the same options on `traceConfig`. Precedence and parsing are fi-core's: option > env var > + * default, and only the string "true" (any case) hides. + * + * Never exported, in either mode: Genkit's request context, stack traces, and local file paths + * (rewritten to `[cwd]`, `~` or `[path]`). Error text additionally loses emails and this + * machine's user and host names. + */ +import * as os from "os"; +import { + DEFAULT_HIDE_EMBEDDING_VECTORS, + DEFAULT_HIDE_INPUTS, + DEFAULT_HIDE_INPUT_MESSAGES, + DEFAULT_HIDE_INPUT_TEXT, + DEFAULT_HIDE_OUTPUTS, + DEFAULT_HIDE_OUTPUT_MESSAGES, + DEFAULT_HIDE_OUTPUT_TEXT, + FI_HIDE_EMBEDDING_VECTORS, + FI_HIDE_INPUTS, + FI_HIDE_INPUT_MESSAGES, + FI_HIDE_INPUT_TEXT, + FI_HIDE_OUTPUTS, + FI_HIDE_OUTPUT_MESSAGES, + FI_HIDE_OUTPUT_TEXT, + REDACTED_VALUE, + type TraceConfigOptions, +} from "@traceai/fi-core"; + +/** The fi-core TraceConfig flags this package reads, resolved. */ +export interface ContentPolicy { + hideInputs: boolean; + hideOutputs: boolean; + hideInputMessages: boolean; + hideOutputMessages: boolean; + hideInputText: boolean; + hideOutputText: boolean; + hideEmbeddingVectors: boolean; +} + +/** Content captured, nothing hidden: fi-core's defaults (`DEFAULT_HIDE_* = false`). */ +export const SHOW_ALL: Readonly = Object.freeze({ + hideInputs: DEFAULT_HIDE_INPUTS, + hideOutputs: DEFAULT_HIDE_OUTPUTS, + hideInputMessages: DEFAULT_HIDE_INPUT_MESSAGES, + hideOutputMessages: DEFAULT_HIDE_OUTPUT_MESSAGES, + hideInputText: DEFAULT_HIDE_INPUT_TEXT, + hideOutputText: DEFAULT_HIDE_OUTPUT_TEXT, + hideEmbeddingVectors: DEFAULT_HIDE_EMBEDDING_VECTORS, +}); + +/** Every content flag on. */ +export const HIDE_ALL: Readonly = Object.freeze({ + hideInputs: true, + hideOutputs: true, + hideInputMessages: true, + hideOutputMessages: true, + hideInputText: true, + hideOutputText: true, + hideEmbeddingVectors: true, +}); + +/** + * One fi-core boolean flag: option > env var > default, with fi-core's env rule + * (`value.toLowerCase() === "true"`). Read here because fi-core's `generateTraceConfig` is not + * exported and reads the env vars only when a config object is passed. + */ +function flag(option: boolean | undefined, envKey: string, fallback: boolean): boolean { + if (option !== undefined) return option; + const value = typeof process !== "undefined" ? process.env?.[envKey] : undefined; + if (value !== undefined) return value.toLowerCase() === "true"; + return fallback; +} + +/** + * Resolve the content flags. `fallback` replaces fi-core's defaults (used only for the removed + * `captureContent: false` option, which must never export more than it asked for). + */ +export function resolveContentPolicy( + traceConfig?: TraceConfigOptions, + fallback: Partial = {}, +): ContentPolicy { + const d = { ...SHOW_ALL, ...fallback }; + return { + hideInputs: flag(traceConfig?.hideInputs, FI_HIDE_INPUTS, d.hideInputs), + hideOutputs: flag(traceConfig?.hideOutputs, FI_HIDE_OUTPUTS, d.hideOutputs), + hideInputMessages: flag(traceConfig?.hideInputMessages, FI_HIDE_INPUT_MESSAGES, d.hideInputMessages), + hideOutputMessages: flag(traceConfig?.hideOutputMessages, FI_HIDE_OUTPUT_MESSAGES, d.hideOutputMessages), + hideInputText: flag(traceConfig?.hideInputText, FI_HIDE_INPUT_TEXT, d.hideInputText), + hideOutputText: flag(traceConfig?.hideOutputText, FI_HIDE_OUTPUT_TEXT, d.hideOutputText), + hideEmbeddingVectors: flag(traceConfig?.hideEmbeddingVectors, FI_HIDE_EMBEDDING_VECTORS, d.hideEmbeddingVectors), + }; +} + +/** True when free text written at run time (error messages) must not be exported. */ +export function hidesFreeText(policy: ContentPolicy): boolean { + return policy.hideInputs || policy.hideOutputs; +} + +const MAX_REDACT_DEPTH = 64; + +function redactTextFields(value: unknown, depth: number): unknown { + if (depth > MAX_REDACT_DEPTH) return REDACTED_VALUE; + if (Array.isArray(value)) return value.map((item) => redactTextFields(item, depth + 1)); + if (value && typeof value === "object") { + const out: Record = {}; + for (const [key, item] of Object.entries(value)) { + out[key] = (key === "text" || key === "reasoning") && typeof item === "string" ? REDACTED_VALUE : redactTextFields(item, depth + 1); + } + return out; + } + return value; +} + +/** + * A Genkit model request or response JSON with the text of every message part replaced by + * fi-core's `__REDACTED__` (roles, tool requests, finish reason and usage kept), for + * FI_HIDE_INPUT_TEXT / FI_HIDE_OUTPUT_TEXT. Genkit parts carry text as `{ text }` and model + * reasoning as `{ reasoning }` (@genkit-ai/ai model-types.ts). Not JSON: `__REDACTED__`. + */ +export function redactMessageText(value: unknown): string | undefined { + if (typeof value !== "string") return undefined; + try { + return JSON.stringify(redactTextFields(JSON.parse(value), 0)); + } catch { + return REDACTED_VALUE; + } +} + +/** + * A Genkit embedder response (`{ embeddings: [{ embedding: number[], metadata? }] }`) with every + * vector replaced by `__REDACTED__`, for FI_HIDE_EMBEDDING_VECTORS. Not JSON: unchanged. + */ +export function redactEmbeddingVectors(value: unknown): unknown { + if (typeof value !== "string") return value; + try { + const parsed = JSON.parse(value) as unknown; + if (!parsed || typeof parsed !== "object" || !Array.isArray((parsed as { embeddings?: unknown }).embeddings)) return value; + const response = parsed as { embeddings: unknown[] }; + return JSON.stringify({ + ...response, + embeddings: response.embeddings.map((item) => + item && typeof item === "object" && "embedding" in item ? { ...item, embedding: REDACTED_VALUE } : item, + ), + }); + } catch { + return value; + } +} + +// --------------------------------------------------------------------------------------------- +// Paths, stack traces and local identity. + +export const PATH_REMOVED = "[path]"; +export const CWD_TOKEN = "[cwd]"; +export const STACK_TRACE_REMOVED = "[stack trace removed]"; + +/** Where the paths to rewrite come from. */ +export interface ScrubContext { + /** The process working directory. */ + cwd?: string; + /** The user's home directory. */ + home?: string; +} + +const PYTHON_TRACEBACK = /Traceback \(most recent call last\):[\s\S]*/g; +/** + * A V8 stack: "\n at fn (file:line:col)" frames, from the first frame on. Also matches frames + * whose newline is JSON-escaped ("\\n at ...") in text that is not valid JSON. + */ +const JS_STACK = /(?:(?:\r?\n|(?:\\+r)?\\+n)[ \t]+at [^\r\n\\"]+)+/g; +const STACK_HINT = /(?:\n|\\n)[ \t]+at /; +const FILE_URL = /file:\/\/[^\s"'`<>]+/g; +const WINDOWS_PATH = /(?|*?]+/g; +const UNC_PATH = /(?|*?\\]+\\[^\s"'`<>|*?]+/g; +/** Absolute paths under the usual local roots; URL paths such as /v1/models and Genkit action paths are left alone. */ +const LOCAL_PATH = + /(?|*?,;)\]}]+/g; +const EMAIL = /[A-Za-z0-9._%+-]+@[A-Za-z0-9.-]+\.[A-Za-z]{2,}/g; + +function escapeRegExp(text: string): string { + return text.replace(/[.*+?^${}()|[\]\\]/g, "\\$&"); +} + +function replacePrefix(text: string, prefix: string | undefined, token: string): string { + if (!prefix || prefix === "/" || !(prefix.startsWith("/") || /^[A-Za-z]:\\/.test(prefix))) return text; + const trimmed = prefix.replace(/[\\/]+$/, ""); + if (trimmed.length < 2) return text; + // The prefix itself, then a separator, the end, or a non-path character (not /a/proj2 for /a/proj). + return text.replace(new RegExp(`${escapeRegExp(trimmed)}(?=[\\\\/]|$|[^\\w.-])`, "g"), token); +} + +/** process.cwd() and os.homedir(), each only if readable. */ +export function defaultScrubContext(): ScrubContext { + const ctx: ScrubContext = {}; + try { + ctx.cwd = process.cwd(); + } catch { + // no cwd (deleted directory) or no process + } + try { + ctx.home = os.homedir(); + } catch { + // no home directory + } + return ctx; +} + +/** Cheap pre-check: nothing to scrub without a path separator or a stack-trace shape. */ +function mayNeedScrub(text: string): boolean { + return /[/\\]/.test(text) || STACK_HINT.test(text) || text.includes("Traceback (most recent call last)"); +} + +/** Plain-text pass: stack traces out, local paths rewritten. Never inserts a raw newline. */ +function scrubText(text: string, ctx: ScrubContext): string { + let out = text; + if (out.includes("Traceback (most recent call last)")) out = out.replace(PYTHON_TRACEBACK, STACK_TRACE_REMOVED); + if (STACK_HINT.test(out)) out = out.replace(JS_STACK, ` ${STACK_TRACE_REMOVED}`); + if (!/[/\\]/.test(out)) return out; + out = out.replace(FILE_URL, PATH_REMOVED); + // Longest first: the cwd usually sits under the home directory. + const prefixes: Array<[string | undefined, string]> = [ + [ctx.cwd, CWD_TOKEN], + [ctx.home, "~"], + ]; + prefixes.sort((a, b) => (b[0]?.length ?? 0) - (a[0]?.length ?? 0)); + for (const [prefix, token] of prefixes) out = replacePrefix(out, prefix, token); + out = out.replace(WINDOWS_PATH, PATH_REMOVED); + out = out.replace(UNC_PATH, PATH_REMOVED); + out = out.replace(LOCAL_PATH, PATH_REMOVED); + return out; +} + +const MAX_JSON_DEPTH = 4; + +function looksLikeJson(text: string): boolean { + const start = text.trimStart()[0]; + return start === "{" || start === "["; +} + +/** Scrub every string inside parsed JSON (and JSON nested in those strings). */ +function scrubJsonValue(value: unknown, ctx: ScrubContext, depth: number): unknown { + if (typeof value === "string") return scrubString(value, ctx, depth + 1); + if (Array.isArray(value)) return value.map((item) => scrubJsonValue(item, ctx, depth)); + if (value && typeof value === "object") { + const out: Record = {}; + for (const [key, item] of Object.entries(value)) out[key] = scrubJsonValue(item, ctx, depth); + return out; + } + return value; +} + +function scrubString(text: string, ctx: ScrubContext, depth: number): string { + if (!text || !mayNeedScrub(text)) return text; + // Genkit serializes inputs, outputs and tool results to JSON, where a stack trace's newlines are + // escaped. Parse, scrub each string, and re-serialize only when something changed. + if (depth < MAX_JSON_DEPTH && looksLikeJson(text)) { + try { + const parsed = JSON.parse(text); + const scrubbed = JSON.stringify(scrubJsonValue(parsed, ctx, depth)); + return scrubbed === JSON.stringify(parsed) ? text : scrubbed; + } catch { + // not JSON after all: fall through to the text pass (escaped newlines are handled there) + } + } + return scrubText(text, ctx); +} + +/** + * Remove stack traces and rewrite local paths: the cwd becomes `[cwd]`, the home directory `~`, + * any other absolute local path, file URL or Windows path `[path]`. Applied to every exported + * string attribute, including JSON documents (inputs, outputs, tool results). + */ +export function scrubContent(text: string, ctx: ScrubContext = {}): string { + return scrubString(text, ctx, 0); +} + +let identity: string[] | undefined; + +/** This machine's user name and host names (3+ characters, not "localhost"), longest first. */ +function localIdentity(): string[] { + if (identity) return identity; + const out: string[] = []; + try { + const user = os.userInfo().username; + if (user && user.length >= 3) out.push(user); + } catch { + // no user info (sandboxed runtime) + } + try { + const host = os.hostname(); + for (const name of [host, host?.split(".")[0]]) { + if (name && name.length >= 3 && name.toLowerCase() !== "localhost" && !out.includes(name)) out.push(name); + } + } catch { + // no hostname + } + identity = out.sort((a, b) => b.length - a.length); + return identity; +} + +/** Error text as exported: `scrubContent`, then emails and this machine's user and host names. */ +export function scrubErrorText(text: string, ctx: ScrubContext = {}): string { + let out = scrubContent(text, ctx); + out = out.replace(EMAIL, ""); + for (const value of localIdentity()) out = out.split(value).join(""); + return out; +} diff --git a/typescript/packages/traceai_genkit/src/processor.ts b/typescript/packages/traceai_genkit/src/processor.ts new file mode 100644 index 000000000..33060aa10 --- /dev/null +++ b/typescript/packages/traceai_genkit/src/processor.ts @@ -0,0 +1,390 @@ +import { + diag, + type Attributes, + type AttributeValue, + type Context, + type HrTime, + type Link, + type SpanContext, + type SpanKind, + type SpanStatus, + trace, +} from "@opentelemetry/api"; +import { getAttributesFromContext, REDACTED_VALUE, type TraceConfigOptions } from "@traceai/fi-core"; +import { mapGenkitAttributes } from "./mapping"; +import { + type ContentPolicy, + defaultScrubContext, + hidesFreeText, + resolveContentPolicy, + SHOW_ALL, + type ScrubContext, + scrubContent, + scrubErrorText, +} from "./privacy"; + +/** Instrumentation scope as both sdk-trace-base 1.x (`instrumentationLibrary`) and 2.x (`instrumentationScope`) carry it. */ +export interface InstrumentationScopeLike { + readonly name: string; + readonly version?: string; + readonly schemaUrl?: string; +} + +export interface TimedEventLike { + readonly time: HrTime; + readonly name: string; + readonly attributes?: Attributes; + readonly droppedAttributesCount?: number; +} + +/** + * The parts of an OpenTelemetry ReadableSpan this processor reads. + * + * genkit 1.42.0 runs its NodeSDK on @opentelemetry/sdk-trace-base 1.25, whose + * spans carry `parentSpanId` and `instrumentationLibrary`. @traceai/fi-core + * exports with sdk-trace-base / OTLP transformer 2.x, which read + * `parentSpanContext` and `instrumentationScope`. Both shapes are accepted. + */ +export interface GenkitReadableSpan { + readonly name: string; + readonly kind: SpanKind; + spanContext(): SpanContext; + readonly parentSpanId?: string; + readonly parentSpanContext?: SpanContext; + readonly startTime: HrTime; + readonly endTime: HrTime; + readonly status: SpanStatus; + readonly attributes: Attributes; + readonly links: Link[]; + readonly events: TimedEventLike[]; + readonly duration: HrTime; + readonly ended: boolean; + readonly instrumentationLibrary?: InstrumentationScopeLike; + readonly instrumentationScope?: InstrumentationScopeLike; + readonly droppedAttributesCount?: number; + readonly droppedEventsCount?: number; + readonly droppedLinksCount?: number; +} + +/** The span shape handed to the Future AGI tracer provider's span processor (sdk-trace-base 2.x ReadableSpan). */ +export interface ExportableSpan extends GenkitReadableSpan { + readonly parentSpanContext: SpanContext | undefined; + readonly instrumentationScope: InstrumentationScopeLike; + readonly instrumentationLibrary: InstrumentationScopeLike; + readonly resource: unknown; + readonly droppedAttributesCount: number; + readonly droppedEventsCount: number; + readonly droppedLinksCount: number; +} + +interface TargetSpanProcessor { + onEnd(span: ExportableSpan): void; + forceFlush(): Promise; + shutdown(): Promise; +} + +/** A tracer provider from `@traceai/fi-core` `register()` (an sdk-trace-base BasicTracerProvider). */ +export interface FITracerProviderLike { + forceFlush(): Promise; + shutdown(): Promise; +} + +export interface FIGenkitSpanProcessorOptions { + /** + * The provider returned by `register()` from `@traceai/fi-core`. Create it with + * `setGlobalTracerProvider: false`: Genkit's NodeSDK must own the global + * provider, or Genkit's spans bypass every processor passed to + * `enableTelemetry`. + */ + tracerProvider: FITracerProviderLike; + /** + * traceAI content switches, as for every traceAI instrumentor. Content (Genkit's + * `genkit:input` / `genkit:output`, copied to `input.value` / `output.value`) is + * exported by default; `hideInputs` / `hideOutputs` (or `FI_HIDE_INPUTS=true` / + * `FI_HIDE_OUTPUTS=true`) hide it and drop error message text, and + * `hideInputMessages` / `hideOutputMessages` / `hideInputText` / `hideOutputText` + * apply to model spans. Precedence: option > env var > default. The env vars apply + * even when this option is not passed. + */ + traceConfig?: TraceConfigOptions; + /** + * Removed. Use `traceConfig` or the FI_HIDE_* env vars. Passing it logs a warning; + * `false` still hides inputs and outputs (unless `traceConfig` or the env vars say + * otherwise), so an old configuration never exports more than it asked for. + * @deprecated + */ + captureContent?: boolean; + /** Upper bound for `forceFlush()` / `shutdown()`. Default 30000 ms. They resolve, never reject. */ + flushTimeoutMillis?: number; +} + +const DEFAULT_FLUSH_TIMEOUT_MILLIS = 30_000; +const DEFAULT_SCOPE: InstrumentationScopeLike = { name: "genkit-tracer" }; + +const EXCEPTION_EVENT_NAME = "exception"; +const EXCEPTION_MESSAGE = "exception.message"; +const EXCEPTION_TYPE = "exception.type"; +/** Raw stack traces (local paths, module layout) are never exported. */ +const EXCEPTION_STACKTRACE = "exception.stacktrace"; + +export interface ExportPrivacy { + policy?: ContentPolicy; + scrub?: ScrubContext; +} + +function exceptionType(events: TimedEventLike[] | undefined): string | undefined { + if (!Array.isArray(events)) return undefined; + for (const event of events) { + const type = event?.name === EXCEPTION_EVENT_NAME ? event.attributes?.[EXCEPTION_TYPE] : undefined; + if (typeof type === "string" && type.length > 0) return type; + } + return undefined; +} + +/** + * The exported status. With inputs or outputs hidden the message (which can quote user data, as + * Genkit's schema-validation "Provided data:" errors and tool errors do) becomes + * `: __REDACTED__`; otherwise it is exported without local paths, stack traces, + * emails, or this machine's user and host names. + */ +export function exportStatus(status: SpanStatus, events: TimedEventLike[] | undefined, privacy: ExportPrivacy = {}): SpanStatus { + if (typeof status?.message !== "string" || status.message.length === 0) return status; + const policy = privacy.policy ?? SHOW_ALL; + if (hidesFreeText(policy)) { + const type = exceptionType(events); + return { ...status, message: type ? `${scrubErrorText(type, privacy.scrub)}: ${REDACTED_VALUE}` : REDACTED_VALUE }; + } + const message = scrubErrorText(status.message, privacy.scrub); + return message === status.message ? status : { ...status, message }; +} + +/** + * The exported events. Every `exception` event loses `exception.stacktrace`; its message follows + * the status rule above. String attributes of other events are scrubbed of local paths and stack + * traces. Genkit's own event objects are never modified. + */ +export function exportEvents(events: TimedEventLike[], privacy: ExportPrivacy = {}): TimedEventLike[] { + if (!Array.isArray(events)) return events; + const policy = privacy.policy ?? SHOW_ALL; + return events.map((event) => { + if (!event?.attributes) return event; + const isException = event.name === EXCEPTION_EVENT_NAME; + const attributes: Attributes = {}; + for (const [key, value] of Object.entries(event.attributes)) { + if (value === undefined) continue; + if (isException && key === EXCEPTION_STACKTRACE) continue; + if (isException && key === EXCEPTION_MESSAGE && typeof value === "string") { + attributes[key] = hidesFreeText(policy) ? REDACTED_VALUE : scrubErrorText(value, privacy.scrub); + continue; + } + attributes[key] = + typeof value === "string" + ? isException + ? scrubErrorText(value, privacy.scrub) + : scrubContent(value, privacy.scrub) + : value; + } + return { ...event, attributes }; + }); +} + +function resolveTarget(provider: FITracerProviderLike): { processor: TargetSpanProcessor; resource: unknown } { + // sdk-trace-base 2.x keeps these as TypeScript-private fields; 1.x exposed + // `activeSpanProcessor` and `resource`. There is no public accessor in either. + const p = provider as unknown as Record & { _config?: { resource?: unknown } }; + const processor = (p._activeSpanProcessor ?? p.activeSpanProcessor) as TargetSpanProcessor | undefined; + const resource = p._resource ?? p.resource ?? p._config?.resource; + if (!processor || typeof processor.onEnd !== "function" || typeof processor.forceFlush !== "function" || !resource) { + throw new TypeError( + "FIGenkitSpanProcessor: tracerProvider must be the provider returned by register() from @traceai/fi-core " + + "(an @opentelemetry/sdk-trace-base BasicTracerProvider).", + ); + } + return { processor, resource }; +} + +function isGlobalTracerProvider(provider: unknown): boolean { + try { + const global = trace.getTracerProvider() as { getDelegate?: () => unknown }; + return typeof global.getDelegate === "function" && global.getDelegate() === provider; + } catch { + return false; + } +} + +/** Build the sdk-trace-base 2.x view of a span with new attributes and the Future AGI resource. */ +export function toExportableSpan( + span: GenkitReadableSpan, + attributes: Attributes, + resource: unknown, + privacy: ExportPrivacy = {}, +): ExportableSpan { + const ctx = span.spanContext(); + let parentSpanContext = span.parentSpanContext; + const parentSpanId = parentSpanContext?.spanId ?? span.parentSpanId; + if (!parentSpanContext && parentSpanId) { + parentSpanContext = { traceId: ctx.traceId, spanId: parentSpanId, traceFlags: ctx.traceFlags, isRemote: false }; + } + const scope = span.instrumentationScope ?? span.instrumentationLibrary ?? DEFAULT_SCOPE; + return { + name: span.name, + kind: span.kind, + spanContext: () => ctx, + parentSpanId, + parentSpanContext, + startTime: span.startTime, + endTime: span.endTime, + status: exportStatus(span.status, span.events, privacy), + attributes, + links: span.links, + events: exportEvents(span.events, privacy), + duration: span.duration, + ended: span.ended, + resource, + instrumentationScope: scope, + instrumentationLibrary: scope, + droppedAttributesCount: span.droppedAttributesCount ?? 0, + droppedEventsCount: span.droppedEventsCount ?? 0, + droppedLinksCount: span.droppedLinksCount ?? 0, + }; +} + +function withTimeout(promise: Promise, millis: number, what: string): Promise { + let timer: ReturnType | undefined; + const timeout = new Promise((resolve) => { + timer = setTimeout(() => { + diag.warn(`FIGenkitSpanProcessor: ${what} did not finish within ${millis} ms`); + resolve(); + }, millis); + if (typeof timer === "object" && timer && "unref" in timer) timer.unref(); + }); + const settled = promise.then( + () => undefined, + (error: unknown) => { + diag.warn(`FIGenkitSpanProcessor: ${what} failed: ${error}`); + }, + ); + return Promise.race([settled, timeout]).finally(() => { + if (timer !== undefined) clearTimeout(timer); + }); +} + +function hasAttributes(attributes: Attributes): boolean { + for (const value of Object.values(attributes) as (AttributeValue | undefined)[]) { + if (value !== undefined) return true; + } + return false; +} + +/** + * A span processor for Genkit's `enableTelemetry({ spanProcessors })`. + * + * Genkit keeps its own telemetry-server processor first in the list + * (`@genkit-ai/core` tracing/node-telemetry-provider.ts:66-77), so the dev UI + * keeps working. For each ended Genkit span this processor builds a copy with + * Future AGI span kinds, model, usage and session mapped, content handled per + * the traceAI TraceConfig (exported by default, FI_HIDE_* hides it), stack + * traces and local paths removed, and the Future AGI resource (`project_name`, + * `project_type`), then hands it to the `@traceai/fi-core` provider's span + * processor and exporter. Genkit's span object is never modified. + * + * No method throws. Export failures are logged through the OTel diag logger. + */ +export class FIGenkitSpanProcessor { + private readonly provider: FITracerProviderLike; + private readonly target: TargetSpanProcessor; + private readonly resource: unknown; + private readonly policy: ContentPolicy; + private readonly scrub: ScrubContext; + private readonly flushTimeoutMillis: number; + private readonly contextAttributes = new WeakMap(); + private isShutdown = false; + private shutdownPromise: Promise | undefined; + + constructor(options: FIGenkitSpanProcessorOptions) { + if (!options || !options.tracerProvider) { + throw new TypeError("FIGenkitSpanProcessor: options.tracerProvider is required (register() from @traceai/fi-core)."); + } + this.provider = options.tracerProvider; + const { processor, resource } = resolveTarget(options.tracerProvider); + this.target = processor; + this.resource = resource; + if (options.captureContent !== undefined) { + diag.warn( + "@traceai/genkit: captureContent was removed. Content follows the traceAI TraceConfig: exported by default, " + + "hidden with traceConfig ({ hideInputs, hideOutputs, ... }) or FI_HIDE_INPUTS / FI_HIDE_OUTPUTS.", + ); + } + this.policy = resolveContentPolicy( + options.traceConfig, + options.captureContent === false ? { hideInputs: true, hideOutputs: true } : {}, + ); + this.scrub = defaultScrubContext(); + this.flushTimeoutMillis = options.flushTimeoutMillis ?? DEFAULT_FLUSH_TIMEOUT_MILLIS; + if (isGlobalTracerProvider(options.tracerProvider)) { + const message = + "@traceai/genkit: the Future AGI tracer provider is the global OpenTelemetry provider. Genkit's NodeSDK " + + "cannot register its own, so Genkit spans bypass FIGenkitSpanProcessor and Genkit's dev UI exporter. " + + "Call register({ ..., setGlobalTracerProvider: false })."; + diag.warn(message); + process.emitWarning(message, { code: "TRACEAI_GENKIT_GLOBAL_PROVIDER" }); + } + } + + onStart(span: object, parentContext: Context): void { + if (this.isShutdown) return; + try { + // Session, user, metadata and tags set with the fi-core context helpers + // around a flow call. Genkit creates its spans with that context. + const attributes = getAttributesFromContext(parentContext); + if (hasAttributes(attributes)) { + this.contextAttributes.set(span, attributes); + } + } catch (error) { + diag.debug(`FIGenkitSpanProcessor.onStart: ${error}`); + } + } + + onEnd(span: GenkitReadableSpan): void { + if (this.isShutdown) return; + try { + const contextAttributes = this.contextAttributes.get(span); + const attributes = mapGenkitAttributes(span.attributes, { + policy: this.policy, + scrub: this.scrub, + contextAttributes, + }); + this.target.onEnd(toExportableSpan(span, attributes, this.resource, { policy: this.policy, scrub: this.scrub })); + } catch (error) { + diag.warn(`FIGenkitSpanProcessor.onEnd: span not exported: ${error}`); + } + } + + /** Wait for spans handed to the Future AGI provider to be exported. Resolves even when export fails. */ + forceFlush(): Promise { + let flushing: Promise; + try { + flushing = this.provider.forceFlush(); + } catch (error) { + flushing = Promise.reject(error); + } + return withTimeout(flushing, this.flushTimeoutMillis, "forceFlush"); + } + + /** Flush, then shut down the Future AGI provider. Called by Genkit's NodeSDK shutdown. Resolves, never rejects. */ + shutdown(): Promise { + if (this.shutdownPromise) return this.shutdownPromise; + this.shutdownPromise = (async () => { + await this.forceFlush(); + this.isShutdown = true; + let closing: Promise; + try { + closing = this.provider.shutdown(); + } catch (error) { + closing = Promise.reject(error); + } + await withTimeout(closing, this.flushTimeoutMillis, "shutdown"); + })(); + return this.shutdownPromise; + } +} diff --git a/typescript/packages/traceai_genkit/src/signals.ts b/typescript/packages/traceai_genkit/src/signals.ts new file mode 100644 index 000000000..cd6b70e5e --- /dev/null +++ b/typescript/packages/traceai_genkit/src/signals.ts @@ -0,0 +1,97 @@ +import { diag } from "@opentelemetry/api"; + +type SignalListener = (signal: NodeJS.Signals) => unknown; + +/** The parts of `process` used here; injectable for tests. */ +export interface SignalTarget { + readonly pid: number; + listeners(event: NodeJS.Signals): Function[]; + on(event: NodeJS.Signals, listener: SignalListener): unknown; + removeListener(event: NodeJS.Signals, listener: Function): unknown; + kill(pid: number, signal?: NodeJS.Signals): unknown; +} + +export interface FlushOnSignalsOptions { + /** Default `["SIGTERM", "SIGINT"]`. */ + signals?: NodeJS.Signals[]; + /** Upper bound for `flush` before the earlier listeners run. Default 10000 ms. */ + timeoutMillis?: number; + /** Default `process`. */ + target?: SignalTarget; +} + +/** + * Run `flush` first when the process receives a signal, then hand the signal + * to the listeners that were installed before this call. + * + * genkit 1.42.0 installs a module-level SIGTERM/SIGINT listener that stops the + * reflection servers and calls `process.exit(0)` (genkit/src/genkit.ts:786-793). + * An app's own async SIGTERM listener that awaits `flushTracing()` loses that + * race, so spans still in flight are dropped. This helper takes the listeners + * registered so far (Genkit's, and Genkit's NodeSDK cleanup from + * `enableTelemetry`), awaits `flush` (bounded, errors swallowed), then calls them + * in their original order. With no earlier listener it re-raises the signal. + * + * Call it after `import "genkit"` and after `await enableTelemetry(...)`. + * Returns a function that restores the original listeners. + */ +export function flushOnSignals(flush: () => Promise, options: FlushOnSignalsOptions = {}): () => void { + const target: SignalTarget = options.target ?? (process as unknown as SignalTarget); + const signals = options.signals ?? ["SIGTERM", "SIGINT"]; + const timeoutMillis = options.timeoutMillis ?? 10_000; + const installed: { signal: NodeJS.Signals; listener: SignalListener; previous: Function[] }[] = []; + + for (const signal of signals) { + const previous = target.listeners(signal).slice(); + let handled = false; + const listener: SignalListener = async (received) => { + if (handled) return; + handled = true; + await boundedFlush(flush, timeoutMillis); + target.removeListener(signal, listener); + if (previous.length === 0) { + target.kill(target.pid, signal); + return; + } + for (const original of previous) { + try { + void (original as SignalListener).call(target, received ?? signal); + } catch (error) { + diag.warn(`flushOnSignals: ${signal} listener threw: ${error}`); + } + } + }; + for (const original of previous) target.removeListener(signal, original); + target.on(signal, listener); + installed.push({ signal, listener, previous }); + } + + return () => { + for (const { signal, listener, previous } of installed) { + target.removeListener(signal, listener); + const current = target.listeners(signal); + for (const original of previous) { + if (!current.includes(original)) target.on(signal, original as SignalListener); + } + } + }; +} + +async function boundedFlush(flush: () => Promise, timeoutMillis: number): Promise { + let timer: ReturnType | undefined; + try { + await Promise.race([ + Promise.resolve() + .then(flush) + .catch((error: unknown) => diag.warn(`flushOnSignals: flush failed: ${error}`)), + new Promise((resolve) => { + timer = setTimeout(() => { + diag.warn(`flushOnSignals: flush did not finish within ${timeoutMillis} ms`); + resolve(); + }, timeoutMillis); + }), + ]); + } finally { + if (timer !== undefined) clearTimeout(timer); + } +} diff --git a/typescript/packages/traceai_genkit/tsconfig.esm.json b/typescript/packages/traceai_genkit/tsconfig.esm.json new file mode 100644 index 000000000..e5d6f9b6c --- /dev/null +++ b/typescript/packages/traceai_genkit/tsconfig.esm.json @@ -0,0 +1,17 @@ +{ + "extends": "../../tsconfig.base.esm.json", + "compilerOptions": { + "outDir": "dist/esm", + "rootDir": "src", + "tsBuildInfoFile": "dist/esm/tsconfig.esm.tsbuildinfo", + "baseUrl": "./src" + }, + "include": [ + "src/**/*.ts" + ], + "references": [], + "exclude": [ + "src/**/*.test.ts", + "src/**/__tests__/**" + ] +} diff --git a/typescript/packages/traceai_genkit/tsconfig.esnext.json b/typescript/packages/traceai_genkit/tsconfig.esnext.json new file mode 100644 index 000000000..a99f0fe06 --- /dev/null +++ b/typescript/packages/traceai_genkit/tsconfig.esnext.json @@ -0,0 +1,17 @@ +{ + "extends": "../../tsconfig.base.esnext.json", + "compilerOptions": { + "outDir": "dist/esnext", + "rootDir": "src", + "tsBuildInfoFile": "dist/esnext/tsconfig.esnext.tsbuildinfo", + "baseUrl": "./src" + }, + "include": [ + "src/**/*.ts" + ], + "references": [], + "exclude": [ + "src/**/*.test.ts", + "src/**/__tests__/**" + ] +} diff --git a/typescript/packages/traceai_genkit/tsconfig.json b/typescript/packages/traceai_genkit/tsconfig.json new file mode 100644 index 000000000..087f63ee4 --- /dev/null +++ b/typescript/packages/traceai_genkit/tsconfig.json @@ -0,0 +1,14 @@ +{ + "extends": "../../tsconfig.base.json", + "compilerOptions": { + "outDir": "dist", + "rootDir": ".", + "baseUrl": "./src" + }, + "include": ["src/**/*.ts"], + "exclude": ["src/**/*.test.ts", "src/**/__tests__/**", "test/**/*.ts"], + "references": [ + { "path": "../fi-core" }, + { "path": "../fi-semantic-conventions" } + ] +} diff --git a/typescript/pnpm-lock.yaml b/typescript/pnpm-lock.yaml index c0f93ce14..350648910 100644 --- a/typescript/pnpm-lock.yaml +++ b/typescript/pnpm-lock.yaml @@ -630,6 +630,49 @@ importers: specifier: ^5.7.2 version: 5.8.3 + packages/traceai_genkit: + dependencies: + '@opentelemetry/api': + specifier: ^1.9.0 + version: 1.9.1 + '@traceai/fi-core': + specifier: workspace:^ + version: link:../fi-core + '@traceai/fi-semantic-conventions': + specifier: workspace:^ + version: link:../fi-semantic-conventions + devDependencies: + '@opentelemetry/resources': + specifier: ^2.0.1 + version: 2.7.1(@opentelemetry/api@1.9.1) + '@opentelemetry/sdk-trace-base': + specifier: ^2.0.1 + version: 2.7.1(@opentelemetry/api@1.9.1) + '@types/jest': + specifier: ^29.5.14 + version: 29.5.14 + '@types/node': + specifier: ^22.10.10 + version: 22.15.33 + genkit: + specifier: 1.42.0 + version: 1.42.0(@google-cloud/firestore@9.3.1)(firebase-admin@14.5.0) + jest: + specifier: ^29.7.0 + version: 29.7.0(@types/node@22.15.33)(ts-node@10.9.2(@types/node@22.15.33)(typescript@5.8.3)) + rimraf: + specifier: ^6.0.1 + version: 6.1.2 + ts-jest: + specifier: ^29.2.5 + version: 29.4.6(@babel/core@7.27.1)(@jest/transform@29.7.0)(@jest/types@29.6.3)(babel-jest@29.7.0(@babel/core@7.27.1))(jest-util@29.7.0)(jest@29.7.0(@types/node@22.15.33)(ts-node@10.9.2(@types/node@22.15.33)(typescript@5.8.3)))(typescript@5.8.3) + tsc-alias: + specifier: ^1.8.10 + version: 1.8.16 + typescript: + specifier: ^5.7.3 + version: 5.8.3 + packages/traceai_google_adk: dependencies: '@google/adk': @@ -2612,12 +2655,121 @@ packages: cpu: [x64] os: [win32] + '@fastify/busboy@3.2.2': + resolution: {integrity: sha512-yXSS27qPExaXeuLvMRMXOLtpipzfQYNjG3FkunDWKGfMYjKuhFXko9CVzqxm8jcF+lmtS9Fd89QNdh9XDjnbNg==} + '@finom/zod-to-json-schema@3.24.11': resolution: {integrity: sha512-fL656yBPiWebtfGItvtXLWrFNGlF1NcDFS0WdMQXMs9LluVg0CfT5E2oXYp0pidl0vVG53XkW55ysijNkU5/hA==} deprecated: 'Use https://www.npmjs.com/package/zod-v3-to-json-schema instead. See issue comment for details: https://github.com/StefanTerdell/zod-to-json-schema/issues/178#issuecomment-3533122539' peerDependencies: zod: ^4.0.14 + '@firebase/app-check-interop-types@0.3.5': + resolution: {integrity: sha512-qId34pVZ2CXTmtu4ofW5leiI93DvnOvIcr/5GT7MZPw5WXAi6nZoU+g9cNRgl7K90UJSbK0cXxten4meYMPyZg==} + + '@firebase/app-types@0.9.6': + resolution: {integrity: sha512-yPLahy7Esfu2w/yme3msVK4xTkDXQqq6szfQn8yVOQpCKiT5GVFjqNpLbuz6NkX0WuTwUidkmPewW3r4xkvpeg==} + + '@firebase/auth-interop-types@0.2.6': + resolution: {integrity: sha512-FgwZqDrBqgK0BHI70QTv1v/5wmuDF9f8fsJFvKSxoRlK2PPfSQtZAk2jhXu4pe9BZzFi/e4UYusU/bEQHdf6Qg==} + + '@firebase/component@0.7.5': + resolution: {integrity: sha512-vuFDcL91Q+2ZuBJkyOh86T4q0B4ffNTDjc/A38tybO56odQABxRTFLTIowCWqAKeIcgo37GowWMVgFF73gD8Qw==} + engines: {node: '>=20.0.0'} + + '@firebase/database-compat@2.1.7': + resolution: {integrity: sha512-lBq9sJm8MnJINKJnkAKSOj2MbC66xGoSVCcGkPtstl+lkoKEBtD46qHLbuDgW/WbLPoKVm17RIN8BxHj+Z2F2w==} + engines: {node: '>=20.0.0'} + peerDependencies: + '@firebase/app': 0.x + '@firebase/app-compat': 0.x + peerDependenciesMeta: + '@firebase/app': + optional: true + '@firebase/app-compat': + optional: true + + '@firebase/database-types@1.0.22': + resolution: {integrity: sha512-YAZNXsjY9EQQ+pKw/3ax8n5FgolHC7Qew7EY5RceYdl0R2ZP+kCv1O0DkKlcceue8uQCOreHCNN7PWVFpY1Nug==} + + '@firebase/database@1.1.5': + resolution: {integrity: sha512-/JGpvszLoNXNgzilRXocigGfFF4hbcPA9wN1i1kjJx6oKkXgkHteZYl3lQs1lJX3ETDf6bv7zI15lPMVUp4sAQ==} + engines: {node: '>=20.0.0'} + + '@firebase/logger@0.5.2': + resolution: {integrity: sha512-J2VO4NFTc0xQFrxV1B/lm5balicm9cwuX2acR9Yn41fN8KgUeQFo+VJV222IqW2FPSXKDu9uo5WdQFWf9TPbYg==} + engines: {node: '>=20.0.0'} + + '@firebase/util@1.15.3': + resolution: {integrity: sha512-c/z/gaIlaaLZEuGbE6sLUuJ61tskg1JghvhcNQzW948ASBinbVBBRnZTC4b4yt4LaEtJQkYlyzqLHcutFwEIvA==} + engines: {node: '>=20.0.0'} + + '@genkit-ai/ai@1.42.0': + resolution: {integrity: sha512-FV1bMjOnGX7RRPT/T4ZVoV83VTaxQ9ZYTKQSPXI8wvOCtJXoW30ODQI6V+fFuykD5pVKrfjRb73pe0n43J+/Kw==} + + '@genkit-ai/core@1.42.0': + resolution: {integrity: sha512-UYTty6exDYUtDWMUxbSijvyZ8tn7Bf+e0CnTFEo2qUO7IpOPgPFaXyUsLWD+EvsxhXWkLhVW2V/e/st60p792g==} + + '@genkit-ai/firebase@1.42.0': + resolution: {integrity: sha512-VFZ0VIs5g7zWk9BQaX5WSOLah6CxZ5LGDvUEd5SiFtXvFKCwBNzB8oDw9fVAmviRoApvrZ5pKPIITktIAgvOJA==} + peerDependencies: + '@google-cloud/firestore': ^7.11.0 + firebase: '>=11.5.0' + firebase-admin: '>=12.2' + genkit: ^1.42.0 + peerDependenciesMeta: + firebase: + optional: true + + '@genkit-ai/google-cloud@1.42.0': + resolution: {integrity: sha512-AfrnP/38BgaMOvAlzl9TSVeMkD6QHph8duefdS0T1oBiU3IxcLTvodrjfLLJlws6tU6nN/5TNrpyIQE8Qde6/g==} + peerDependencies: + genkit: ^1.42.0 + + '@google-cloud/common@6.1.0': + resolution: {integrity: sha512-Ohjxjvusr65+SiEVBrilpyn1ir9CM8ZqWjcf7bA8ph1GCunxI6bbwtcl7iGl67A7Lr4Nz7WpNzITNETwggc7pw==} + engines: {node: '>=18'} + + '@google-cloud/firestore-api@0.2.0': + resolution: {integrity: sha512-wfHJPZmLqzpy6FN6U+7HkkP/AKhGsbHSpEy/qL2TyI3/pKRAvpamQxZ2qvps5hMRgAjfuHCim+oeJj9RveCaqg==} + engines: {node: '>=18'} + + '@google-cloud/firestore@7.11.6': + resolution: {integrity: sha512-EW/O8ktzwLfyWBOsNuhRoMi8lrC3clHM5LVFhGvO1HCsLozCOOXRAlHrYBoE6HL42Sc8yYMuCb2XqcnJ4OOEpw==} + engines: {node: '>=14.0.0'} + + '@google-cloud/firestore@9.3.1': + resolution: {integrity: sha512-ofGTiSpfXrHrrS3KaDOmsupSzCHr4WVl1+s6Ke0F8rPBRyb/OuZSC8u1NjCKtt/fO7A1GvqASQGhdAwVsnGpQA==} + engines: {node: '>=22'} + + '@google-cloud/logging-api@0.2.0': + resolution: {integrity: sha512-VQ9YohbLMh4wtWfrXLRfEbAjy8JyC1OSXA6dX/A2hpB/0sqnb/97Hs+Ai2fR8t83V4c3u1l2G7CPVuZN8wlG+A==} + engines: {node: '>=18'} + + '@google-cloud/logging-winston@6.0.2': + resolution: {integrity: sha512-rrNs4XXLtk0BAnL6kTjfAH26a/zVGsuZHd6Vve3Ip1fT4/Irz2QJtqI0XiPbT/yfmKqFmYa44GWPXtPPAi56ug==} + engines: {node: '>=18'} + peerDependencies: + winston: '>=3.2.1' + + '@google-cloud/logging@11.4.0': + resolution: {integrity: sha512-UtDwKO+Ux9SEPhDGWfN9OPHHCQ1Kt/xgA1xWO12GsoxV6lhLZarHqL2hgOAzLzOP+qxsLkk2eOcSJDPexTEUSQ==} + engines: {node: '>=18'} + + '@google-cloud/modelarmor@0.4.1': + resolution: {integrity: sha512-CT9TpQF443aatjhRRvazrYNOvUot26HnFP3hhgmV89QYygNPB6owWvGFFOTsKK4zSvTDfkeeb+E6diVXxn9t4g==} + engines: {node: '>=14.0.0'} + + '@google-cloud/opentelemetry-cloud-monitoring-exporter@0.19.0': + resolution: {integrity: sha512-5SOPXwC6RET4ZvXxw5D97dp8fWpqWEunHrzrUUGXhG4UAeedQe1KvYV8CK+fnaAbN2l2ha6QDYspT6z40TVY0g==} + engines: {node: '>=14'} + deprecated: Google Cloud Platform now supports native OpenTelemetry Protocol (OTLP) endpoints via the Telemetry API. Please follow https://github.com/GoogleCloudPlatform/opentelemetry-operations-js/blob/main/MIGRATION.md + peerDependencies: + '@opentelemetry/api': ^1.0.0 + '@opentelemetry/core': ^1.0.0 + '@opentelemetry/resources': ^1.0.0 + '@opentelemetry/sdk-metrics': ^1.0.0 + '@google-cloud/opentelemetry-cloud-monitoring-exporter@0.21.0': resolution: {integrity: sha512-+lAew44pWt6rA4l8dQ1gGhH7Uo95wZKfq/GBf9aEyuNDDLQ2XppGEEReu6ujesSqTtZ8ueQFt73+7SReSHbwqg==} engines: {node: '>=18'} @@ -2627,6 +2779,16 @@ packages: '@opentelemetry/resources': ^2.0.0 '@opentelemetry/sdk-metrics': ^2.0.0 + '@google-cloud/opentelemetry-cloud-trace-exporter@2.4.1': + resolution: {integrity: sha512-Dq2IyAyA9PCjbjLOn86i2byjkYPC59b5ic8k/L4q5bBWH0Jro8lzMs8C0G5pJfqh2druj8HF+oAIAlSdWQ+Z9Q==} + engines: {node: '>=14'} + deprecated: Google Cloud Platform now supports native OpenTelemetry Protocol (OTLP) endpoints via the Telemetry API. Please follow https://github.com/GoogleCloudPlatform/opentelemetry-operations-js/blob/main/MIGRATION.md + peerDependencies: + '@opentelemetry/api': ^1.0.0 + '@opentelemetry/core': ^1.0.0 + '@opentelemetry/resources': ^1.0.0 + '@opentelemetry/sdk-trace-base': ^1.0.0 + '@google-cloud/opentelemetry-cloud-trace-exporter@3.0.0': resolution: {integrity: sha512-mUfLJBFo+ESbO0dAGboErx2VyZ7rbrHcQvTP99yH/J72dGaPbH2IzS+04TFbTbEd1VW5R9uK3xq2CqawQaG+1Q==} engines: {node: '>=18'} @@ -2636,6 +2798,13 @@ packages: '@opentelemetry/resources': ^2.0.0 '@opentelemetry/sdk-trace-base': ^2.0.0 + '@google-cloud/opentelemetry-resource-util@2.4.0': + resolution: {integrity: sha512-/7ujlMoKtDtrbQlJihCjQnm31n2s2RTlvJqcSbt2jV3OkCzPAdo3u31Q13HNugqtIRUSk7bUoLx6AzhURkhW4w==} + engines: {node: '>=14'} + deprecated: Google Cloud Platform now supports native OpenTelemetry Protocol (OTLP) endpoints via the Telemetry API. Please follow https://github.com/GoogleCloudPlatform/opentelemetry-operations-js/blob/main/MIGRATION.md + peerDependencies: + '@opentelemetry/resources': ^1.0.0 + '@google-cloud/opentelemetry-resource-util@3.0.0': resolution: {integrity: sha512-CGR/lNzIfTKlZoZFfS6CkVzx+nsC9gzy6S8VcyaLegfEJbiPjxbMLP7csyhJTvZe/iRRcQJxSk0q8gfrGqD3/Q==} engines: {node: '>=18'} @@ -2647,6 +2816,10 @@ packages: resolution: {integrity: sha512-DJS3s0OVH4zFDB1PzjxAsHqJT6sKVbRwwML0ZBP9PbU7Yebtu/7SWMRzvO2J3nUi9pRNITCfu4LJeooM2w4pjg==} engines: {node: '>=14.0.0'} + '@google-cloud/paginator@7.1.0': + resolution: {integrity: sha512-PNCXdAQgNoQODZuqyhmkN2nUpB2q9UFzawZ1oyCDyEyhcheRoCKJJhSKhEIeKpM/NCLnC6Q4We4HEkGCwNDnCA==} + engines: {node: '>=22'} + '@google-cloud/precise-date@4.0.0': resolution: {integrity: sha512-1TUx3KdaU3cN7nfCdNf+UVqA/PSX29Cjcox3fZZBtINlRrXVTmUkQnCKv2MbBUbCopbK4olAT1IHl76uZyCiVA==} engines: {node: '>=14.0.0'} @@ -2655,14 +2828,26 @@ packages: resolution: {integrity: sha512-MmaX6HeSvyPbWGwFq7mXdo0uQZLGBYCwziiLIGq5JVX+/bdI3SAq6bP98trV5eTWfLuvsMcIC1YJOF2vfteLFA==} engines: {node: '>=14.0.0'} + '@google-cloud/projectify@6.1.0': + resolution: {integrity: sha512-tKAx9q6vTtbgZcqCojKWK8k6Dy2XBsE7BkNrrBsblxNXrKImYnljqeGfYh9qnTrlTjC9F19pTyCkGcl3pFMW/w==} + engines: {node: '>=22'} + '@google-cloud/promisify@4.0.0': resolution: {integrity: sha512-Orxzlfb9c67A15cq2JQEyVc7wEsmFBmHjZWZYQMUyJ1qivXyMwdyNOs9odi79hze+2zqdTtu1E19IM/FtqZ10g==} engines: {node: '>=14'} + '@google-cloud/promisify@6.1.0': + resolution: {integrity: sha512-H+Rytzi5zYMyoAmU/zgYLgq7fJ9FY4QQEg4k6gfFx/RY1COJ2xxyIfe8bZ62lqEbWM1DJH7IYETqTFmqNtuUhQ==} + engines: {node: '>=22'} + '@google-cloud/storage@7.19.0': resolution: {integrity: sha512-n2FjE7NAOYyshogdc7KQOl/VZb4sneqPjWouSyia9CMDdMhRX5+RIbqalNmC7LOLzuLAN89VlF2HvG8na9G+zQ==} engines: {node: '>=14'} + '@google-cloud/storage@8.2.0': + resolution: {integrity: sha512-7ckgSjeEprV92VrlLjpYFA3PFerflvFtF7Ea86oQXGNCprGZq5rtpAVK0zgWnCy+44mLjms42M7MiWa433gz2A==} + engines: {node: '>=22'} + '@google-cloud/vertexai@1.10.0': resolution: {integrity: sha512-HqYqoivNtkq59po8m7KI0n+lWKdz4kabENncYQXZCX/hBWJfXtKAfR/2nUQsP+TwSfHKoA7zDL2RrJYIv/j3VQ==} engines: {node: '>=18.0.0'} @@ -3446,6 +3631,10 @@ packages: resolution: {integrity: sha512-JdZuKrhOYggqOpUljAq4WWNi5nB10PmgoF0y2CvedLGXd0kSawb/UBnWT8gg1ND3bHCNHStAIVT0ELlxJJRqrA==} engines: {node: '>=14'} + '@opentelemetry/api-logs@0.52.1': + resolution: {integrity: sha512-qnSqB2DQ9TPP96dl8cDubDvrUyWc0/sK81xHTK8eSUspzDM3bsewX903qclQFvVhgStjRWdC5bLb3kQqMkfV5A==} + engines: {node: '>=14'} + '@opentelemetry/api-logs@0.56.0': resolution: {integrity: sha512-Wr39+94UNNG3Ei9nv3pHd4AJ63gq5nSemMRpCd8fPwDL9rN3vK26lzxfH27mw16XzOSO+TpyQwBAMaLxaPWG0g==} engines: {node: '>=14'} @@ -3462,6 +3651,18 @@ packages: resolution: {integrity: sha512-gLyJlPHPZYdAk1JENA9LeHejZe1Ti77/pTeFm/nMXmQH/HFZlcS/O2XJB+L8fkbrNSqhdtlvjBVjxwUYanNH5Q==} engines: {node: '>=8.0.0'} + '@opentelemetry/auto-instrumentations-node@0.49.2': + resolution: {integrity: sha512-xtETEPmAby/3MMmedv8Z/873sdLTWg+Vq98rtm4wbwvAiXBB/ao8qRyzRlvR2MR6puEr+vIB/CXeyJnzNA3cyw==} + engines: {node: '>=14'} + peerDependencies: + '@opentelemetry/api': ^1.4.1 + + '@opentelemetry/context-async-hooks@1.25.1': + resolution: {integrity: sha512-UW/ge9zjvAEmRWVapOP0qyCvPulWU6cQxGxDbWEFfGOj1VBBZAuOqTo3X6yWmDTD3Xe15ysCZChHncr2xFMIfQ==} + engines: {node: '>=14'} + peerDependencies: + '@opentelemetry/api': '>=1.0.0 <1.10.0' + '@opentelemetry/context-async-hooks@1.30.1': resolution: {integrity: sha512-s5vvxXPVdjqS3kTLKMeBMvop9hbWkwzBpu+mUO2M7sZtlkyDJGwFe33wRKnbaYDo8ExRVBIIdwIGrqpxHuKttA==} engines: {node: '>=14'} @@ -3486,6 +3687,12 @@ packages: peerDependencies: '@opentelemetry/api': '>=1.0.0 <1.9.0' + '@opentelemetry/core@1.25.1': + resolution: {integrity: sha512-GeT/l6rBYWVQ4XArluLVB6WWQ8flHbdb6r2FCHC3smtdOAbrJBIv35tpV/yp9bmYUJf+xmZpu9DRTIeJVhFbEQ==} + engines: {node: '>=14'} + peerDependencies: + '@opentelemetry/api': '>=1.0.0 <1.10.0' + '@opentelemetry/core@1.30.1': resolution: {integrity: sha512-OOCM2C/QIURhJMuKaekP3TRBxBKxG/TWWA0TL2J6nXUtDnuCtccy49LUJF8xPFXMX+0LMcxFpCo8M9cGY1W6rQ==} engines: {node: '>=14'} @@ -3546,6 +3753,12 @@ packages: peerDependencies: '@opentelemetry/api': ^1.3.0 + '@opentelemetry/exporter-trace-otlp-grpc@0.52.1': + resolution: {integrity: sha512-pVkSH20crBwMTqB3nIN4jpQKUEoB0Z94drIHpYyEqs7UBr+I0cpYyOR3bqjA/UasQUMROb3GX8ZX4/9cVRqGBQ==} + engines: {node: '>=14'} + peerDependencies: + '@opentelemetry/api': ^1.0.0 + '@opentelemetry/exporter-trace-otlp-http@0.202.0': resolution: {integrity: sha512-/hKE8DaFCJuaQqE1IxpgkcjOolUIwgi3TgHElPVKGdGRBSmJMTmN/cr6vWa55pCJIXPyhKvcMrbrya7DZ3VmzA==} engines: {node: ^18.19.0 || >=20.6.0} @@ -3558,6 +3771,12 @@ packages: peerDependencies: '@opentelemetry/api': ^1.3.0 + '@opentelemetry/exporter-trace-otlp-http@0.52.1': + resolution: {integrity: sha512-05HcNizx0BxcFKKnS5rwOV+2GevLTVIRA0tRgWYyw4yCgR53Ic/xk83toYKts7kbzcI+dswInUg/4s8oyA+tqg==} + engines: {node: '>=14'} + peerDependencies: + '@opentelemetry/api': ^1.0.0 + '@opentelemetry/exporter-trace-otlp-http@0.57.2': resolution: {integrity: sha512-sB/gkSYFu+0w2dVQ0PWY9fAMl172PKMZ/JrHkkW8dmjCL0CYkmXeE+ssqIL/yBUTPOvpLIpenX5T9RwXRBW/3g==} engines: {node: '>=14'} @@ -3582,2674 +3801,3199 @@ packages: peerDependencies: '@opentelemetry/api': ^1.0.0 + '@opentelemetry/exporter-trace-otlp-proto@0.52.1': + resolution: {integrity: sha512-pt6uX0noTQReHXNeEslQv7x311/F1gJzMnp1HD2qgypLRPbXDeMzzeTngRTUaUbP6hqWNtPxuLr4DEoZG+TcEQ==} + engines: {node: '>=14'} + peerDependencies: + '@opentelemetry/api': ^1.0.0 + + '@opentelemetry/exporter-zipkin@1.25.1': + resolution: {integrity: sha512-RmOwSvkimg7ETwJbUOPTMhJm9A9bG1U8s7Zo3ajDh4zM7eYcycQ0dM7FbLD6NXWbI2yj7UY4q8BKinKYBQksyw==} + engines: {node: '>=14'} + peerDependencies: + '@opentelemetry/api': ^1.0.0 + '@opentelemetry/exporter-zipkin@2.7.1': resolution: {integrity: sha512-mfsD9bKAxcKrh5+y08TPodvClBO0CznBE3p79YAGnO81WI4LrdsGA65T53e4iTSbCalW4WaUpkbeJcbpyIUHfg==} engines: {node: ^18.19.0 || >=20.6.0} peerDependencies: '@opentelemetry/api': ^1.0.0 - '@opentelemetry/instrumentation@0.202.0': - resolution: {integrity: sha512-Uz3BxZWPgDwgHM2+vCKEQRh0R8WKrd/q6Tus1vThRClhlPO39Dyz7mDrOr6KuqGXAlBQ1e5Tnymzri4RMZNaWA==} - engines: {node: ^18.19.0 || >=20.6.0} + '@opentelemetry/instrumentation-amqplib@0.41.0': + resolution: {integrity: sha512-00Oi6N20BxJVcqETjgNzCmVKN+I5bJH/61IlHiIWd00snj1FdgiIKlpE4hYVacTB2sjIBB3nTbHskttdZEE2eg==} + engines: {node: '>=14'} peerDependencies: '@opentelemetry/api': ^1.3.0 - '@opentelemetry/instrumentation@0.46.0': - resolution: {integrity: sha512-a9TijXZZbk0vI5TGLZl+0kxyFfrXHhX6Svtz7Pp2/VBlCSKrazuULEyoJQrOknJyFWNMEmbbJgOciHCCpQcisw==} + '@opentelemetry/instrumentation-aws-lambda@0.43.0': + resolution: {integrity: sha512-pSxcWlsE/pCWQRIw92sV2C+LmKXelYkjkA7C5s39iPUi4pZ2lA1nIiw+1R/y2pDEhUHcaKkNyljQr3cx9ZpVlQ==} engines: {node: '>=14'} peerDependencies: '@opentelemetry/api': ^1.3.0 - '@opentelemetry/instrumentation@0.56.0': - resolution: {integrity: sha512-2KkGBKE+FPXU1F0zKww+stnlUxUTlBvLCiWdP63Z9sqXYeNI/ziNzsxAp4LAdUcTQmXjw1IWgvm5CAb/BHy99w==} + '@opentelemetry/instrumentation-aws-sdk@0.43.1': + resolution: {integrity: sha512-qLT2cCniJ5W+6PFzKbksnoIQuq9pS83nmgaExfUwXVvlwi0ILc50dea0tWBHZMkdIDa/zZdcuFrJ7+fUcSnRow==} engines: {node: '>=14'} peerDependencies: '@opentelemetry/api': ^1.3.0 - '@opentelemetry/instrumentation@0.57.2': - resolution: {integrity: sha512-BdBGhQBh8IjZ2oIIX6F2/Q3LKm/FDDKi6ccYKcBTeilh6SNdNKveDOLk73BkSJjQLJk6qe4Yh+hHw1UPhCDdrg==} + '@opentelemetry/instrumentation-bunyan@0.40.0': + resolution: {integrity: sha512-aZ4cXaGWwj79ZXSYrgFVsrDlE4mmf2wfvP9bViwRc0j75A6eN6GaHYHqufFGMTCqASQn5pIjjP+Bx+PWTGiofw==} engines: {node: '>=14'} peerDependencies: '@opentelemetry/api': ^1.3.0 - '@opentelemetry/otlp-exporter-base@0.201.1': - resolution: {integrity: sha512-FiS/mIWmZXyRxYGyXPHY+I/4+XrYVTD7Fz/zwOHkVPQsA1JTakAOP9fAi6trXMio0dIpzvQujLNiBqGM7ExrQw==} - engines: {node: ^18.19.0 || >=20.6.0} + '@opentelemetry/instrumentation-cassandra-driver@0.40.0': + resolution: {integrity: sha512-JxbM39JU7HxE9MTKKwi6y5Z3mokjZB2BjwfqYi4B3Y29YO3I42Z7eopG6qq06yWZc+nQli386UDQe0d9xKmw0A==} + engines: {node: '>=14'} peerDependencies: '@opentelemetry/api': ^1.3.0 - '@opentelemetry/otlp-exporter-base@0.202.0': - resolution: {integrity: sha512-nMEOzel+pUFYuBJg2znGmHJWbmvMbdX5/RhoKNKowguMbURhz0fwik5tUKplLcUtl8wKPL1y9zPnPxeBn65N0Q==} - engines: {node: ^18.19.0 || >=20.6.0} + '@opentelemetry/instrumentation-connect@0.38.0': + resolution: {integrity: sha512-2/nRnx3pjYEmdPIaBwtgtSviTKHWnDZN3R+TkRUnhIVrvBKVcq+I5B2rtd6mr6Fe9cHlZ9Ojcuh7pkNh/xdWWg==} + engines: {node: '>=14'} peerDependencies: '@opentelemetry/api': ^1.3.0 - '@opentelemetry/otlp-exporter-base@0.205.0': - resolution: {integrity: sha512-2MN0C1IiKyo34M6NZzD6P9Nv9Dfuz3OJ3rkZwzFmF6xzjDfqqCTatc9v1EpNfaP55iDOCLHFyYNCgs61FFgtUQ==} - engines: {node: ^18.19.0 || >=20.6.0} + '@opentelemetry/instrumentation-cucumber@0.8.0': + resolution: {integrity: sha512-ieTm4RBIlZt2brPwtX5aEZYtYnkyqhAVXJI9RIohiBVMe5DxiwCwt+2Exep/nDVqGPX8zRBZUl4AEw423OxJig==} + engines: {node: '>=14'} peerDependencies: - '@opentelemetry/api': ^1.3.0 + '@opentelemetry/api': ^1.0.0 - '@opentelemetry/otlp-exporter-base@0.218.0': - resolution: {integrity: sha512-ZwqpkNL5W7RyGJPDZ9g06DvKp8KFTWPJPN12anpMQYSKpTSU0z3EIZuPq9vPGpS8siFyOqDYDAuCwlNO9FqgbA==} - engines: {node: ^18.19.0 || >=20.6.0} + '@opentelemetry/instrumentation-dataloader@0.11.0': + resolution: {integrity: sha512-27urJmwkH4KDaMJtEv1uy2S7Apk4XbN4AgWMdfMJbi7DnOduJmeuA+DpJCwXB72tEWXo89z5T3hUVJIDiSNmNw==} + engines: {node: '>=14'} peerDependencies: '@opentelemetry/api': ^1.3.0 - '@opentelemetry/otlp-exporter-base@0.50.0': - resolution: {integrity: sha512-JUmjmrCmE1/fc4LjCQMqLfudgSl5OpUkzx7iA94b4jgeODM7zWxUoVXL7/CT7fWf47Cn+pmKjMvTCSESqZZ3mA==} + '@opentelemetry/instrumentation-dns@0.38.0': + resolution: {integrity: sha512-Um07I0TQXDWa+ZbEAKDFUxFH40dLtejtExDOMLNJ1CL8VmOmA71qx93Qi/QG4tGkiI1XWqr7gF/oiMCJ4m8buQ==} engines: {node: '>=14'} peerDependencies: - '@opentelemetry/api': ^1.0.0 + '@opentelemetry/api': ^1.3.0 - '@opentelemetry/otlp-exporter-base@0.57.2': - resolution: {integrity: sha512-XdxEzL23Urhidyebg5E6jZoaiW5ygP/mRjxLHixogbqwDy2Faduzb5N0o/Oi+XTIJu+iyxXdVORjXax+Qgfxag==} + '@opentelemetry/instrumentation-express@0.41.1': + resolution: {integrity: sha512-uRx0V3LPGzjn2bxAnV8eUsDT82vT7NTwI0ezEuPMBOTOsnPpGhWdhcdNdhH80sM4TrWrOfXm9HGEdfWE3TRIww==} engines: {node: '>=14'} peerDependencies: '@opentelemetry/api': ^1.3.0 - '@opentelemetry/otlp-grpc-exporter-base@0.202.0': - resolution: {integrity: sha512-yIEHVxFA5dmYif7lZbbB66qulLLhrklj6mI2X3cuGW5hYPyUErztEmbroM+6teu/XobBi9bLHid2VT4NIaRuGg==} - engines: {node: ^18.19.0 || >=20.6.0} + '@opentelemetry/instrumentation-fastify@0.38.0': + resolution: {integrity: sha512-HBVLpTSYpkQZ87/Df3N0gAw7VzYZV3n28THIBrJWfuqw3Or7UqdhnjeuMIPQ04BKk3aZc0cWn2naSQObbh5vXw==} + engines: {node: '>=14'} peerDependencies: '@opentelemetry/api': ^1.3.0 - '@opentelemetry/otlp-grpc-exporter-base@0.218.0': - resolution: {integrity: sha512-H/lCGJ536N98VpYJOaWTQOkv4Dx6TnmStK6Rqfu1W7KkFbPAx04hjdYEMZF/YbnHzPUSIK4kM6OE2GKGBTpV9A==} - engines: {node: ^18.19.0 || >=20.6.0} + '@opentelemetry/instrumentation-fs@0.14.0': + resolution: {integrity: sha512-pVc8P5AgliC1DphyyBUgsxXlm2XaPH4BpYvt7rAZDMIqUpRk8gs19SioABtKqqxvFzg5jPtgJfJsdxq0Y+maLw==} + engines: {node: '>=14'} peerDependencies: '@opentelemetry/api': ^1.3.0 - '@opentelemetry/otlp-proto-exporter-base@0.50.0': - resolution: {integrity: sha512-hlbn3eZbhxoK79Sq1ddj1f7qcx+PzsPQC/SFpJvaWgTaqacCbqJmpzWDKfRRCAC7iGX2Hj/sgpf8vysazqyMOw==} + '@opentelemetry/instrumentation-generic-pool@0.38.1': + resolution: {integrity: sha512-WvssuKCuavu/hlq661u82UWkc248cyI/sT+c2dEIj6yCk0BUkErY1D+9XOO+PmHdJNE+76i2NdcvQX5rJrOe/w==} engines: {node: '>=14'} - deprecated: Package no longer supported. Contact Support at https://www.npmjs.com/support for more info. peerDependencies: - '@opentelemetry/api': ^1.0.0 + '@opentelemetry/api': ^1.3.0 - '@opentelemetry/otlp-transformer@0.201.1': - resolution: {integrity: sha512-+q/8Yuhtu9QxCcjEAXEO8fXLjlSnrnVwfzi9jiWaMAppQp69MoagHHomQj02V2WnGjvBod5ajgkbK4IoWab50A==} - engines: {node: ^18.19.0 || >=20.6.0} + '@opentelemetry/instrumentation-graphql@0.42.0': + resolution: {integrity: sha512-N8SOwoKL9KQSX7z3gOaw5UaTeVQcfDO1c21csVHnmnmGUoqsXbArK2B8VuwPWcv6/BC/i3io+xTo7QGRZ/z28Q==} + engines: {node: '>=14'} peerDependencies: '@opentelemetry/api': ^1.3.0 - '@opentelemetry/otlp-transformer@0.202.0': - resolution: {integrity: sha512-5XO77QFzs9WkexvJQL9ksxL8oVFb/dfi9NWQSq7Sv0Efr9x3N+nb1iklP1TeVgxqJ7m1xWiC/Uv3wupiQGevMw==} - engines: {node: ^18.19.0 || >=20.6.0} + '@opentelemetry/instrumentation-grpc@0.52.1': + resolution: {integrity: sha512-EdSDiDSAO+XRXk/ZN128qQpBo1I51+Uay/LUPcPQhSRGf7fBPIEUBeOLQiItguGsug5MGOYjql2w/1wCQF3fdQ==} + engines: {node: '>=14'} peerDependencies: '@opentelemetry/api': ^1.3.0 - '@opentelemetry/otlp-transformer@0.205.0': - resolution: {integrity: sha512-KmObgqPtk9k/XTlWPJHdMbGCylRAmMJNXIRh6VYJmvlRDMfe+DonH41G7eenG8t4FXn3fxOGh14o/WiMRR6vPg==} - engines: {node: ^18.19.0 || >=20.6.0} + '@opentelemetry/instrumentation-hapi@0.40.0': + resolution: {integrity: sha512-8U/w7Ifumtd2bSN1OLaSwAAFhb9FyqWUki3lMMB0ds+1+HdSxYBe9aspEJEgvxAqOkrQnVniAPTEGf1pGM7SOw==} + engines: {node: '>=14'} peerDependencies: '@opentelemetry/api': ^1.3.0 - '@opentelemetry/otlp-transformer@0.218.0': - resolution: {integrity: sha512-CFaKH87WAzjuJ4awowTTLzUvMfaRfiOFG5+qm5S5ncyalRtN4ecQ+YmuANJSCrVPuvZFEkUgKhBPBndxi3rHsQ==} - engines: {node: ^18.19.0 || >=20.6.0} + '@opentelemetry/instrumentation-http@0.52.1': + resolution: {integrity: sha512-dG/aevWhaP+7OLv4BQQSEKMJv8GyeOp3Wxl31NHqE8xo9/fYMfEljiZphUHIfyg4gnZ9swMyWjfOQs5GUQe54Q==} + engines: {node: '>=14'} peerDependencies: '@opentelemetry/api': ^1.3.0 - '@opentelemetry/otlp-transformer@0.50.0': - resolution: {integrity: sha512-s0sl1Yfqd5q1Kjrf6DqXPWzErL+XHhrXOfejh4Vc/SMTNqC902xDsC8JQxbjuramWt/+hibfguIvi7Ns8VLolA==} + '@opentelemetry/instrumentation-ioredis@0.42.0': + resolution: {integrity: sha512-P11H168EKvBB9TUSasNDOGJCSkpT44XgoM6d3gRIWAa9ghLpYhl0uRkS8//MqPzcJVHr3h3RmfXIpiYLjyIZTw==} engines: {node: '>=14'} peerDependencies: - '@opentelemetry/api': '>=1.3.0 <1.9.0' + '@opentelemetry/api': ^1.3.0 - '@opentelemetry/otlp-transformer@0.57.2': - resolution: {integrity: sha512-48IIRj49gbQVK52jYsw70+Jv+JbahT8BqT2Th7C4H7RCM9d0gZ5sgNPoMpWldmfjvIsSgiGJtjfk9MeZvjhoig==} + '@opentelemetry/instrumentation-kafkajs@0.2.0': + resolution: {integrity: sha512-uKKmhEFd0zR280tJovuiBG7cfnNZT4kvVTvqtHPxQP7nOmRbJstCYHFH13YzjVcKjkmoArmxiSulmZmF7SLIlg==} engines: {node: '>=14'} peerDependencies: '@opentelemetry/api': ^1.3.0 - '@opentelemetry/propagator-b3@1.30.1': - resolution: {integrity: sha512-oATwWWDIJzybAZ4pO76ATN5N6FFbOA1otibAVlS8v90B4S1wClnhRUk7K+2CHAwN1JKYuj4jh/lpCEG5BAqFuQ==} + '@opentelemetry/instrumentation-knex@0.39.0': + resolution: {integrity: sha512-lRwTqIKQecPWDkH1KEcAUcFhCaNssbKSpxf4sxRTAROCwrCEnYkjOuqJHV+q1/CApjMTaKu0Er4LBv/6bDpoxA==} engines: {node: '>=14'} peerDependencies: - '@opentelemetry/api': '>=1.0.0 <1.10.0' + '@opentelemetry/api': ^1.3.0 - '@opentelemetry/propagator-jaeger@1.30.1': - resolution: {integrity: sha512-Pj/BfnYEKIOImirH76M4hDaBSx6HyZ2CXUqk+Kj02m6BB80c/yo4BdWkn/1gDFfU+YPY+bPR2U0DKBfdxCKwmg==} + '@opentelemetry/instrumentation-koa@0.42.0': + resolution: {integrity: sha512-H1BEmnMhho8o8HuNRq5zEI4+SIHDIglNB7BPKohZyWG4fWNuR7yM4GTlR01Syq21vODAS7z5omblScJD/eZdKw==} engines: {node: '>=14'} peerDependencies: - '@opentelemetry/api': '>=1.0.0 <1.10.0' + '@opentelemetry/api': ^1.3.0 - '@opentelemetry/resource-detector-gcp@0.40.3': - resolution: {integrity: sha512-C796YjBA5P1JQldovApYfFA/8bQwFfpxjUbOtGhn1YZkVTLoNQN+kvBwgALfTPWzug6fWsd0xhn9dzeiUcndag==} - engines: {node: ^18.19.0 || >=20.6.0} + '@opentelemetry/instrumentation-lru-memoizer@0.39.0': + resolution: {integrity: sha512-eU1Wx1RRTR/2wYXFzH9gcpB8EPmhYlNDIUHzUXjyUE0CAXEJhBLkYNlzdaVCoQDw2neDqS+Woshiia6+emWK9A==} + engines: {node: '>=14'} peerDependencies: - '@opentelemetry/api': ^1.0.0 + '@opentelemetry/api': ^1.3.0 - '@opentelemetry/resources@1.23.0': - resolution: {integrity: sha512-iPRLfVfcEQynYGo7e4Di+ti+YQTAY0h5mQEUJcHlU9JOqpb4x965O6PZ+wMcwYVY63G96KtdS86YCM1BF1vQZg==} + '@opentelemetry/instrumentation-memcached@0.38.0': + resolution: {integrity: sha512-tPmyqQEZNyrvg6G+iItdlguQEcGzfE+bJkpQifmBXmWBnoS5oU3UxqtyYuXGL2zI9qQM5yMBHH4nRXWALzy7WA==} engines: {node: '>=14'} peerDependencies: - '@opentelemetry/api': '>=1.0.0 <1.9.0' + '@opentelemetry/api': ^1.3.0 - '@opentelemetry/resources@1.30.1': - resolution: {integrity: sha512-5UxZqiAgLYGFjS4s9qm5mBVo433u+dSPUFWVWXmLAD4wB65oMCoXaJP1KJa9DIYYMeHu3z4BZcStG3LC593cWA==} + '@opentelemetry/instrumentation-mongodb@0.46.0': + resolution: {integrity: sha512-VF/MicZ5UOBiXrqBslzwxhN7TVqzu1/LN/QDpkskqM0Zm0aZ4CVRbUygL8d7lrjLn15x5kGIe8VsSphMfPJzlA==} engines: {node: '>=14'} peerDependencies: - '@opentelemetry/api': '>=1.0.0 <1.10.0' + '@opentelemetry/api': ^1.3.0 - '@opentelemetry/resources@2.0.1': - resolution: {integrity: sha512-dZOB3R6zvBwDKnHDTB4X1xtMArB/d324VsbiPkX/Yu0Q8T2xceRthoIVFhJdvgVM2QhGVUyX9tzwiNxGtoBJUw==} - engines: {node: ^18.19.0 || >=20.6.0} + '@opentelemetry/instrumentation-mongoose@0.41.0': + resolution: {integrity: sha512-ivJg4QnnabFxxoI7K8D+in7hfikjte38sYzJB9v1641xJk9Esa7jM3hmbPB7lxwcgWJLVEDvfPwobt1if0tXxA==} + engines: {node: '>=14'} peerDependencies: - '@opentelemetry/api': '>=1.3.0 <1.10.0' + '@opentelemetry/api': ^1.3.0 - '@opentelemetry/resources@2.1.0': - resolution: {integrity: sha512-1CJjf3LCvoefUOgegxi8h6r4B/wLSzInyhGP2UmIBYNlo4Qk5CZ73e1eEyWmfXvFtm1ybkmfb2DqWvspsYLrWw==} - engines: {node: ^18.19.0 || >=20.6.0} + '@opentelemetry/instrumentation-mysql2@0.40.0': + resolution: {integrity: sha512-0xfS1xcqUmY7WE1uWjlmI67Xg3QsSUlNT+AcXHeA4BDUPwZtWqF4ezIwLgpVZfHOnkAEheqGfNSWd1PIu3Wnfg==} + engines: {node: '>=14'} peerDependencies: - '@opentelemetry/api': '>=1.3.0 <1.10.0' + '@opentelemetry/api': ^1.3.0 - '@opentelemetry/resources@2.7.1': - resolution: {integrity: sha512-DeT6KKolmC4e/dRQvMQ/RwlnzhaqeiFOXY5ngoOPJ07GgVVKxZOg9EcrNZb5aTzUn+iCrJldAgOfQm1O/QfPAQ==} - engines: {node: ^18.19.0 || >=20.6.0} + '@opentelemetry/instrumentation-mysql@0.40.0': + resolution: {integrity: sha512-d7ja8yizsOCNMYIJt5PH/fKZXjb/mS48zLROO4BzZTtDfhNCl2UM/9VIomP2qkGIFVouSJrGr/T00EzY7bPtKA==} + engines: {node: '>=14'} peerDependencies: - '@opentelemetry/api': '>=1.3.0 <1.10.0' + '@opentelemetry/api': ^1.3.0 - '@opentelemetry/sdk-logs@0.201.1': - resolution: {integrity: sha512-Ug8gtpssUNUnfpotB9ZhnSsPSGDu+7LngTMgKl31mmVJwLAKyl6jC8diZrMcGkSgBh0o5dbg9puvLyR25buZfw==} - engines: {node: ^18.19.0 || >=20.6.0} + '@opentelemetry/instrumentation-nestjs-core@0.39.0': + resolution: {integrity: sha512-mewVhEXdikyvIZoMIUry8eb8l3HUjuQjSjVbmLVTt4NQi35tkpnHQrG9bTRBrl3403LoWZ2njMPJyg4l6HfKvA==} + engines: {node: '>=14'} peerDependencies: - '@opentelemetry/api': '>=1.4.0 <1.10.0' + '@opentelemetry/api': ^1.3.0 - '@opentelemetry/sdk-logs@0.202.0': - resolution: {integrity: sha512-pv8QiQLQzk4X909YKm0lnW4hpuQg4zHwJ4XBd5bZiXcd9urvrJNoNVKnxGHPiDVX/GiLFvr5DMYsDBQbZCypRQ==} - engines: {node: ^18.19.0 || >=20.6.0} + '@opentelemetry/instrumentation-net@0.38.0': + resolution: {integrity: sha512-stjow1PijcmUquSmRD/fSihm/H61DbjPlJuJhWUe7P22LFPjFhsrSeiB5vGj3vn+QGceNAs+kioUTzMGPbNxtg==} + engines: {node: '>=14'} peerDependencies: - '@opentelemetry/api': '>=1.4.0 <1.10.0' + '@opentelemetry/api': ^1.3.0 - '@opentelemetry/sdk-logs@0.205.0': - resolution: {integrity: sha512-nyqhNQ6eEzPWQU60Nc7+A5LIq8fz3UeIzdEVBQYefB4+msJZ2vuVtRuk9KxPMw1uHoHDtYEwkr2Ct0iG29jU8w==} - engines: {node: ^18.19.0 || >=20.6.0} + '@opentelemetry/instrumentation-pg@0.43.0': + resolution: {integrity: sha512-og23KLyoxdnAeFs1UWqzSonuCkePUzCX30keSYigIzJe/6WSYA8rnEI5lobcxPEzg+GcU06J7jzokuEHbjVJNw==} + engines: {node: '>=14'} peerDependencies: - '@opentelemetry/api': '>=1.4.0 <1.10.0' + '@opentelemetry/api': ^1.3.0 - '@opentelemetry/sdk-logs@0.218.0': - resolution: {integrity: sha512-QvnNdugatFTVCJXH0Mcu7GOOJSylA9j127kIezOE4YwTI4YbowRons2K4WZTv5FMS8T4q9P0NdaRHdkSmeAIag==} - engines: {node: ^18.19.0 || >=20.6.0} + '@opentelemetry/instrumentation-pino@0.41.0': + resolution: {integrity: sha512-Kpv0fJRk/8iMzMk5Ue5BsUJfHkBJ2wQoIi/qduU1a1Wjx9GLj6J2G17PHjPK5mnZjPNzkFOXFADZMfgDioliQw==} + engines: {node: '>=14'} peerDependencies: - '@opentelemetry/api': '>=1.4.0 <1.10.0' + '@opentelemetry/api': ^1.3.0 - '@opentelemetry/sdk-logs@0.50.0': - resolution: {integrity: sha512-PeUEupBB29p9nlPNqXoa1PUWNLsZnxG0DCDj3sHqzae+8y76B/A5hvZjg03ulWdnvBLYpnJslqzylG9E0IL87g==} + '@opentelemetry/instrumentation-redis-4@0.41.1': + resolution: {integrity: sha512-UqJAbxraBk7s7pQTlFi5ND4sAUs4r/Ai7gsAVZTQDbHl2kSsOp7gpHcpIuN5dpcI2xnuhM2tkH4SmEhbrv2S6Q==} engines: {node: '>=14'} peerDependencies: - '@opentelemetry/api': '>=1.4.0 <1.9.0' - '@opentelemetry/api-logs': '>=0.39.1' + '@opentelemetry/api': ^1.3.0 - '@opentelemetry/sdk-logs@0.57.2': - resolution: {integrity: sha512-TXFHJ5c+BKggWbdEQ/inpgIzEmS2BGQowLE9UhsMd7YYlUfBQJ4uax0VF/B5NYigdM/75OoJGhAV3upEhK+3gg==} + '@opentelemetry/instrumentation-redis@0.41.0': + resolution: {integrity: sha512-RJ1pwI3btykp67ts+5qZbaFSAAzacucwBet5/5EsKYtWBpHbWwV/qbGN/kIBzXg5WEZBhXLrR/RUq0EpEUpL3A==} engines: {node: '>=14'} peerDependencies: - '@opentelemetry/api': '>=1.4.0 <1.10.0' + '@opentelemetry/api': ^1.3.0 - '@opentelemetry/sdk-metrics@1.23.0': - resolution: {integrity: sha512-4OkvW6+wST4h6LFG23rXSTf6nmTf201h9dzq7bE0z5R9ESEVLERZz6WXwE7PSgg1gdjlaznm1jLJf8GttypFDg==} + '@opentelemetry/instrumentation-restify@0.40.0': + resolution: {integrity: sha512-sm/rH/GysY/KOEvZqYBZSLYFeXlBkHCgqPDgWc07tz+bHCN6mPs9P3otGOSTe7o3KAIM8Nc6ncCO59vL+jb2cA==} engines: {node: '>=14'} peerDependencies: - '@opentelemetry/api': '>=1.3.0 <1.9.0' + '@opentelemetry/api': ^1.3.0 - '@opentelemetry/sdk-metrics@1.30.1': - resolution: {integrity: sha512-q9zcZ0Okl8jRgmy7eNW3Ku1XSgg3sDLa5evHZpCwjspw7E8Is4K/haRPDJrBcX3YSn/Y7gUvFnByNYEKQNbNog==} + '@opentelemetry/instrumentation-router@0.39.0': + resolution: {integrity: sha512-LaXnVmD69WPC4hNeLzKexCCS19hRLrUw3xicneAMkzJSzNJvPyk7G6I7lz7VjQh1cooObPBt9gNyd3hhTCUrag==} engines: {node: '>=14'} peerDependencies: - '@opentelemetry/api': '>=1.3.0 <1.10.0' + '@opentelemetry/api': ^1.3.0 - '@opentelemetry/sdk-metrics@2.0.1': - resolution: {integrity: sha512-wf8OaJoSnujMAHWR3g+/hGvNcsC16rf9s1So4JlMiFaFHiE4HpIA3oUh+uWZQ7CNuK8gVW/pQSkgoa5HkkOl0g==} - engines: {node: ^18.19.0 || >=20.6.0} + '@opentelemetry/instrumentation-socket.io@0.41.0': + resolution: {integrity: sha512-7fzDe9/FpO6NFizC/wnzXXX7bF9oRchsD//wFqy5g5hVEgXZCQ70IhxjrKdBvgjyIejR9T9zTvfQ6PfVKfkCAw==} + engines: {node: '>=14'} peerDependencies: - '@opentelemetry/api': '>=1.9.0 <1.10.0' + '@opentelemetry/api': ^1.3.0 - '@opentelemetry/sdk-metrics@2.1.0': - resolution: {integrity: sha512-J9QX459mzqHLL9Y6FZ4wQPRZG4TOpMCyPOh6mkr/humxE1W2S3Bvf4i75yiMW9uyed2Kf5rxmLhTm/UK8vNkAw==} - engines: {node: ^18.19.0 || >=20.6.0} + '@opentelemetry/instrumentation-tedious@0.13.0': + resolution: {integrity: sha512-Pob0+0R62AqXH50pjazTeGBy/1+SK4CYpFUBV5t7xpbpeuQezkkgVGvLca84QqjBqQizcXedjpUJLgHQDixPQg==} + engines: {node: '>=14'} peerDependencies: - '@opentelemetry/api': '>=1.9.0 <1.10.0' + '@opentelemetry/api': ^1.3.0 - '@opentelemetry/sdk-metrics@2.7.1': - resolution: {integrity: sha512-MpDJdkiFDs3Pm1RHO3KByuZbuBdJEXEAkiC0+yJdsZGVCdf1RpHR6n+LHDcS7ffmfrt5kVCzJSCfm4z2C7v0uQ==} + '@opentelemetry/instrumentation-undici@0.5.0': + resolution: {integrity: sha512-aNTeSrFAVcM9qco5DfZ9DNXu6hpMRe8Kt8nCDHfMWDB3pwgGVUE76jTdohc+H/7eLRqh4L7jqs5NSQoHw7S6ww==} + engines: {node: '>=14'} + peerDependencies: + '@opentelemetry/api': ^1.7.0 + + '@opentelemetry/instrumentation-winston@0.39.0': + resolution: {integrity: sha512-v/1xziLJ9CyB3YDjBSBzbB70Qd0JwWTo36EqWK5m3AR0CzsyMQQmf3ZIZM6sgx7hXMcRQ0pnEYhg6nhrUQPm9A==} + engines: {node: '>=14'} + peerDependencies: + '@opentelemetry/api': ^1.3.0 + + '@opentelemetry/instrumentation@0.202.0': + resolution: {integrity: sha512-Uz3BxZWPgDwgHM2+vCKEQRh0R8WKrd/q6Tus1vThRClhlPO39Dyz7mDrOr6KuqGXAlBQ1e5Tnymzri4RMZNaWA==} engines: {node: ^18.19.0 || >=20.6.0} peerDependencies: - '@opentelemetry/api': '>=1.9.0 <1.10.0' + '@opentelemetry/api': ^1.3.0 - '@opentelemetry/sdk-trace-base@1.23.0': - resolution: {integrity: sha512-PzBmZM8hBomUqvCddF/5Olyyviayka44O5nDWq673np3ctnvwMOvNrsUORZjKja1zJbwEuD9niAGbnVrz3jwRQ==} + '@opentelemetry/instrumentation@0.46.0': + resolution: {integrity: sha512-a9TijXZZbk0vI5TGLZl+0kxyFfrXHhX6Svtz7Pp2/VBlCSKrazuULEyoJQrOknJyFWNMEmbbJgOciHCCpQcisw==} engines: {node: '>=14'} peerDependencies: - '@opentelemetry/api': '>=1.0.0 <1.9.0' + '@opentelemetry/api': ^1.3.0 - '@opentelemetry/sdk-trace-base@1.30.1': - resolution: {integrity: sha512-jVPgBbH1gCy2Lb7X0AVQ8XAfgg0pJ4nvl8/IiQA6nxOsPvS+0zMJaFSs2ltXe0J6C8dqjcnpyqINDJmU30+uOg==} + '@opentelemetry/instrumentation@0.52.1': + resolution: {integrity: sha512-uXJbYU/5/MBHjMp1FqrILLRuiJCs3Ofk0MeRDk8g1S1gD47U8X3JnSwcMO1rtRo1x1a7zKaQHaoYu49p/4eSKw==} engines: {node: '>=14'} peerDependencies: - '@opentelemetry/api': '>=1.0.0 <1.10.0' + '@opentelemetry/api': ^1.3.0 - '@opentelemetry/sdk-trace-base@2.0.1': - resolution: {integrity: sha512-xYLlvk/xdScGx1aEqvxLwf6sXQLXCjk3/1SQT9X9AoN5rXRhkdvIFShuNNmtTEPRBqcsMbS4p/gJLNI2wXaDuQ==} - engines: {node: ^18.19.0 || >=20.6.0} + '@opentelemetry/instrumentation@0.56.0': + resolution: {integrity: sha512-2KkGBKE+FPXU1F0zKww+stnlUxUTlBvLCiWdP63Z9sqXYeNI/ziNzsxAp4LAdUcTQmXjw1IWgvm5CAb/BHy99w==} + engines: {node: '>=14'} peerDependencies: - '@opentelemetry/api': '>=1.3.0 <1.10.0' + '@opentelemetry/api': ^1.3.0 - '@opentelemetry/sdk-trace-base@2.1.0': - resolution: {integrity: sha512-uTX9FBlVQm4S2gVQO1sb5qyBLq/FPjbp+tmGoxu4tIgtYGmBYB44+KX/725RFDe30yBSaA9Ml9fqphe1hbUyLQ==} - engines: {node: ^18.19.0 || >=20.6.0} + '@opentelemetry/instrumentation@0.57.2': + resolution: {integrity: sha512-BdBGhQBh8IjZ2oIIX6F2/Q3LKm/FDDKi6ccYKcBTeilh6SNdNKveDOLk73BkSJjQLJk6qe4Yh+hHw1UPhCDdrg==} + engines: {node: '>=14'} peerDependencies: - '@opentelemetry/api': '>=1.3.0 <1.10.0' + '@opentelemetry/api': ^1.3.0 - '@opentelemetry/sdk-trace-base@2.7.1': - resolution: {integrity: sha512-NAYIlsF8MPUsKqJMiDQJTMPOmlbawC1Iz/omMLygZ1C9am8fTKYjTaI+OZM+WTY3t3Glo0wnOg/6/pac6RGPPw==} + '@opentelemetry/otlp-exporter-base@0.201.1': + resolution: {integrity: sha512-FiS/mIWmZXyRxYGyXPHY+I/4+XrYVTD7Fz/zwOHkVPQsA1JTakAOP9fAi6trXMio0dIpzvQujLNiBqGM7ExrQw==} engines: {node: ^18.19.0 || >=20.6.0} peerDependencies: - '@opentelemetry/api': '>=1.3.0 <1.10.0' + '@opentelemetry/api': ^1.3.0 - '@opentelemetry/sdk-trace-node@1.30.1': - resolution: {integrity: sha512-cBjYOINt1JxXdpw1e5MlHmFRc5fgj4GW/86vsKFxJCJ8AL4PdVtYH41gWwl4qd4uQjqEL1oJVrXkSy5cnduAnQ==} - engines: {node: '>=14'} + '@opentelemetry/otlp-exporter-base@0.202.0': + resolution: {integrity: sha512-nMEOzel+pUFYuBJg2znGmHJWbmvMbdX5/RhoKNKowguMbURhz0fwik5tUKplLcUtl8wKPL1y9zPnPxeBn65N0Q==} + engines: {node: ^18.19.0 || >=20.6.0} peerDependencies: - '@opentelemetry/api': '>=1.0.0 <1.10.0' + '@opentelemetry/api': ^1.3.0 - '@opentelemetry/sdk-trace-node@2.0.1': - resolution: {integrity: sha512-UhdbPF19pMpBtCWYP5lHbTogLWx9N0EBxtdagvkn5YtsAnCBZzL7SjktG+ZmupRgifsHMjwUaCCaVmqGfSADmA==} + '@opentelemetry/otlp-exporter-base@0.205.0': + resolution: {integrity: sha512-2MN0C1IiKyo34M6NZzD6P9Nv9Dfuz3OJ3rkZwzFmF6xzjDfqqCTatc9v1EpNfaP55iDOCLHFyYNCgs61FFgtUQ==} engines: {node: ^18.19.0 || >=20.6.0} peerDependencies: - '@opentelemetry/api': '>=1.0.0 <1.10.0' + '@opentelemetry/api': ^1.3.0 - '@opentelemetry/sdk-trace-node@2.7.1': - resolution: {integrity: sha512-pCpQxU68lV+I9s9svqMyVu5iHdDDUnqUpSxqwyCU8A9ejEsSnMPCbearwsUO4yk08ZJzAIUCFuReMdVQvHrdvg==} + '@opentelemetry/otlp-exporter-base@0.218.0': + resolution: {integrity: sha512-ZwqpkNL5W7RyGJPDZ9g06DvKp8KFTWPJPN12anpMQYSKpTSU0z3EIZuPq9vPGpS8siFyOqDYDAuCwlNO9FqgbA==} engines: {node: ^18.19.0 || >=20.6.0} peerDependencies: - '@opentelemetry/api': '>=1.0.0 <1.10.0' - - '@opentelemetry/semantic-conventions@1.23.0': - resolution: {integrity: sha512-MiqFvfOzfR31t8cc74CTP1OZfz7MbqpAnLCra8NqQoaHJX6ncIRTdYOQYBDQ2uFISDq0WY8Y9dDTWvsgzzBYRg==} - engines: {node: '>=14'} + '@opentelemetry/api': ^1.3.0 - '@opentelemetry/semantic-conventions@1.28.0': - resolution: {integrity: sha512-lp4qAiMTD4sNWW4DbKLBkfiMZ4jbAboJIGOQr5DvciMRI494OapieI9qiODpOt0XBr1LjIDy1xAGAnVs5supTA==} + '@opentelemetry/otlp-exporter-base@0.50.0': + resolution: {integrity: sha512-JUmjmrCmE1/fc4LjCQMqLfudgSl5OpUkzx7iA94b4jgeODM7zWxUoVXL7/CT7fWf47Cn+pmKjMvTCSESqZZ3mA==} engines: {node: '>=14'} + peerDependencies: + '@opentelemetry/api': ^1.0.0 - '@opentelemetry/semantic-conventions@1.34.0': - resolution: {integrity: sha512-aKcOkyrorBGlajjRdVoJWHTxfxO1vCNHLJVlSDaRHDIdjU+pX8IYQPvPDkYiujKLbRnWU+1TBwEt0QRgSm4SGA==} + '@opentelemetry/otlp-exporter-base@0.52.1': + resolution: {integrity: sha512-z175NXOtX5ihdlshtYBe5RpGeBoTXVCKPPLiQlD6FHvpM4Ch+p2B0yWKYSrBfLH24H9zjJiBdTrtD+hLlfnXEQ==} engines: {node: '>=14'} + peerDependencies: + '@opentelemetry/api': ^1.0.0 - '@opentelemetry/semantic-conventions@1.41.1': - resolution: {integrity: sha512-/UhIkaZgPutTFmQ7RnIJGgDXZmtEJ7Dvi86xNTFWcnRxVRNk/aotsqDJYeEvDP+FSMB2SdW+pQzNMcWP0rwuNA==} + '@opentelemetry/otlp-exporter-base@0.57.2': + resolution: {integrity: sha512-XdxEzL23Urhidyebg5E6jZoaiW5ygP/mRjxLHixogbqwDy2Faduzb5N0o/Oi+XTIJu+iyxXdVORjXax+Qgfxag==} engines: {node: '>=14'} + peerDependencies: + '@opentelemetry/api': ^1.3.0 - '@petamoriken/float16@3.9.3': - resolution: {integrity: sha512-8awtpHXCx/bNpFt4mt2xdkgtgVvKqty8VbjHI/WWWQuEw+KLzFot3f4+LkQY9YmOtq7A5GdOnqoIC8Pdygjk2g==} - - '@pinecone-database/pinecone@4.1.0': - resolution: {integrity: sha512-WoVsbvmCgvZfjm/nCasJXuQ/tw0es5BpedLHvRScAm6xJ/nL07s3B0TrsM8m8rACTiUgbdYsdLY1W6cEBhS9xA==} - engines: {node: '>=18.0.0'} - - '@pinojs/redact@0.4.0': - resolution: {integrity: sha512-k2ENnmBugE/rzQfEcdWHcCY+/FM3VLzH9cYEsbdsoqrvzAKRhUZeRNhAZvB8OitQJ1TBed3yqWtdjzS6wJKBwg==} + '@opentelemetry/otlp-grpc-exporter-base@0.202.0': + resolution: {integrity: sha512-yIEHVxFA5dmYif7lZbbB66qulLLhrklj6mI2X3cuGW5hYPyUErztEmbroM+6teu/XobBi9bLHid2VT4NIaRuGg==} + engines: {node: ^18.19.0 || >=20.6.0} + peerDependencies: + '@opentelemetry/api': ^1.3.0 - '@pipecat-ai/client-js@1.6.0': - resolution: {integrity: sha512-riG/p9MDhy/mVo8x3ZGRdE55cgVgIcqkWsJcXb11CtG4j7xAszwcMdv7IOzRtTMSCD/2s7rwuv7Yi/D8bpDzNA==} + '@opentelemetry/otlp-grpc-exporter-base@0.218.0': + resolution: {integrity: sha512-H/lCGJ536N98VpYJOaWTQOkv4Dx6TnmStK6Rqfu1W7KkFbPAx04hjdYEMZF/YbnHzPUSIK4kM6OE2GKGBTpV9A==} + engines: {node: ^18.19.0 || >=20.6.0} + peerDependencies: + '@opentelemetry/api': ^1.3.0 - '@pkgjs/parseargs@0.11.0': - resolution: {integrity: sha512-+1VkjdD0QBLPodGrJUeqarH8VAIvQODIbwh9XpP5Syisf7YoQgsJKPNFoqqLQlu+VQ/tVSshMR6loPMn8U+dPg==} + '@opentelemetry/otlp-grpc-exporter-base@0.52.1': + resolution: {integrity: sha512-zo/YrSDmKMjG+vPeA9aBBrsQM9Q/f2zo6N04WMB3yNldJRsgpRBeLLwvAt/Ba7dpehDLOEFBd1i2JCoaFtpCoQ==} engines: {node: '>=14'} - - '@posthog/core@1.30.2': - resolution: {integrity: sha512-d7RTpfi+/q5+SZ+4f1WhanfEtNBz9onMmUxn3BO0GDT8N5ZT4DEP3LqFisqeP+xkJTaFPWCOVA/nGyKmUX9y9g==} - - '@posthog/types@1.378.1': - resolution: {integrity: sha512-bKOXVWySe5oKFjV6X9VW9jngIm14d4BvnT7l/Eb7e6DrT5uD+XclvbRdhC5f1/l5KwoIU+qswBobHRPlix2D1w==} - - '@protobuf-ts/grpc-transport@2.11.1': - resolution: {integrity: sha512-l6wrcFffY+tuNnuyrNCkRM8hDIsAZVLA8Mn7PKdVyYxITosYh60qW663p9kL6TWXYuDCL3oxH8ih3vLKTDyhtg==} peerDependencies: - '@grpc/grpc-js': ^1.6.0 - - '@protobuf-ts/plugin@2.11.1': - resolution: {integrity: sha512-HyuprDcw0bEEJqkOWe1rnXUP0gwYLij8YhPuZyZk6cJbIgc/Q0IFgoHQxOXNIXAcXM4Sbehh6kjVnCzasElw1A==} - hasBin: true + '@opentelemetry/api': ^1.0.0 - '@protobuf-ts/protoc@2.11.1': - resolution: {integrity: sha512-mUZJaV0daGO6HUX90o/atzQ6A7bbN2RSuHtdwo8SSF2Qoe3zHwa4IHyCN1evftTeHfLmdz+45qo47sL+5P8nyg==} - hasBin: true + '@opentelemetry/otlp-proto-exporter-base@0.50.0': + resolution: {integrity: sha512-hlbn3eZbhxoK79Sq1ddj1f7qcx+PzsPQC/SFpJvaWgTaqacCbqJmpzWDKfRRCAC7iGX2Hj/sgpf8vysazqyMOw==} + engines: {node: '>=14'} + deprecated: Package no longer supported. Contact Support at https://www.npmjs.com/support for more info. + peerDependencies: + '@opentelemetry/api': ^1.0.0 - '@protobuf-ts/runtime-rpc@2.11.1': - resolution: {integrity: sha512-4CqqUmNA+/uMz00+d3CYKgElXO9VrEbucjnBFEjqI4GuDrEQ32MaI3q+9qPBvIGOlL4PmHXrzM32vBPWRhQKWQ==} + '@opentelemetry/otlp-transformer@0.201.1': + resolution: {integrity: sha512-+q/8Yuhtu9QxCcjEAXEO8fXLjlSnrnVwfzi9jiWaMAppQp69MoagHHomQj02V2WnGjvBod5ajgkbK4IoWab50A==} + engines: {node: ^18.19.0 || >=20.6.0} + peerDependencies: + '@opentelemetry/api': ^1.3.0 - '@protobuf-ts/runtime@2.11.1': - resolution: {integrity: sha512-KuDaT1IfHkugM2pyz+FwiY80ejWrkH1pAtOBOZFuR6SXEFTsnb/jiQWQ1rCIrcKx2BtyxnxW6BWwsVSA/Ie+WQ==} + '@opentelemetry/otlp-transformer@0.202.0': + resolution: {integrity: sha512-5XO77QFzs9WkexvJQL9ksxL8oVFb/dfi9NWQSq7Sv0Efr9x3N+nb1iklP1TeVgxqJ7m1xWiC/Uv3wupiQGevMw==} + engines: {node: ^18.19.0 || >=20.6.0} + peerDependencies: + '@opentelemetry/api': ^1.3.0 - '@protobufjs/aspromise@1.1.2': - resolution: {integrity: sha512-j+gKExEuLmKwvz3OgROXtrJ2UG2x8Ch2YZUxahh+s1F2HZ+wAceUNLkvy6zKCPVRkU++ZWQrdxsUeQXmcg4uoQ==} + '@opentelemetry/otlp-transformer@0.205.0': + resolution: {integrity: sha512-KmObgqPtk9k/XTlWPJHdMbGCylRAmMJNXIRh6VYJmvlRDMfe+DonH41G7eenG8t4FXn3fxOGh14o/WiMRR6vPg==} + engines: {node: ^18.19.0 || >=20.6.0} + peerDependencies: + '@opentelemetry/api': ^1.3.0 - '@protobufjs/base64@1.1.2': - resolution: {integrity: sha512-AZkcAA5vnN/v4PDqKyMR5lx7hZttPDgClv83E//FMNhR2TMcLUhfRUBHCmSl0oi9zMgDDqRUJkSxO3wm85+XLg==} + '@opentelemetry/otlp-transformer@0.218.0': + resolution: {integrity: sha512-CFaKH87WAzjuJ4awowTTLzUvMfaRfiOFG5+qm5S5ncyalRtN4ecQ+YmuANJSCrVPuvZFEkUgKhBPBndxi3rHsQ==} + engines: {node: ^18.19.0 || >=20.6.0} + peerDependencies: + '@opentelemetry/api': ^1.3.0 - '@protobufjs/codegen@2.0.4': - resolution: {integrity: sha512-YyFaikqM5sH0ziFZCN3xDC7zeGaB/d0IUb9CATugHWbd1FRFwWwt4ld4OYMPWu5a3Xe01mGAULCdqhMlPl29Jg==} + '@opentelemetry/otlp-transformer@0.50.0': + resolution: {integrity: sha512-s0sl1Yfqd5q1Kjrf6DqXPWzErL+XHhrXOfejh4Vc/SMTNqC902xDsC8JQxbjuramWt/+hibfguIvi7Ns8VLolA==} + engines: {node: '>=14'} + peerDependencies: + '@opentelemetry/api': '>=1.3.0 <1.9.0' - '@protobufjs/eventemitter@1.1.0': - resolution: {integrity: sha512-j9ednRT81vYJ9OfVuXG6ERSTdEL1xVsNgqpkxMsbIabzSo3goCjDIveeGv5d03om39ML71RdmrGNjG5SReBP/Q==} + '@opentelemetry/otlp-transformer@0.52.1': + resolution: {integrity: sha512-I88uCZSZZtVa0XniRqQWKbjAUm73I8tpEy/uJYPPYw5d7BRdVk0RfTBQw8kSUl01oVWEuqxLDa802222MYyWHg==} + engines: {node: '>=14'} + peerDependencies: + '@opentelemetry/api': '>=1.3.0 <1.10.0' - '@protobufjs/fetch@1.1.0': - resolution: {integrity: sha512-lljVXpqXebpsijW71PZaCYeIcE5on1w5DlQy5WH6GLbFryLUrBD4932W/E2BSpfRJWseIL4v/KPgBFxDOIdKpQ==} + '@opentelemetry/otlp-transformer@0.57.2': + resolution: {integrity: sha512-48IIRj49gbQVK52jYsw70+Jv+JbahT8BqT2Th7C4H7RCM9d0gZ5sgNPoMpWldmfjvIsSgiGJtjfk9MeZvjhoig==} + engines: {node: '>=14'} + peerDependencies: + '@opentelemetry/api': ^1.3.0 - '@protobufjs/float@1.0.2': - resolution: {integrity: sha512-Ddb+kVXlXst9d+R9PfTIxh1EdNkgoRe5tOX6t01f1lYWOvJnSPDBlG241QLzcyPdoNTsblLUdujGSE4RzrTZGQ==} + '@opentelemetry/propagation-utils@0.30.16': + resolution: {integrity: sha512-ZVQ3Z/PQ+2GQlrBfbMMMT0U7MzvYZLCPP800+ooyaBqm4hMvuQHfP028gB9/db0mwkmyEAMad9houukUVxhwcw==} + engines: {node: '>=14'} + deprecated: The use of process spans has been removed from Messaging Semantic Conventions. It is now recommended to connect pub/sub spans via Span Links. See https://opentelemetry.io/docs/specs/semconv/messaging/messaging-spans/ for details. + peerDependencies: + '@opentelemetry/api': ^1.0.0 - '@protobufjs/inquire@1.1.0': - resolution: {integrity: sha512-kdSefcPdruJiFMVSbn801t4vFK7KB/5gd2fYvrxhuJYg8ILrmn9SKSX2tZdV6V+ksulWqS7aXjBcRXl3wHoD9Q==} + '@opentelemetry/propagator-aws-xray@1.26.2': + resolution: {integrity: sha512-k43wxTjKYvwfce9L4eT8fFYy/ATmCfPHZPZsyT/6ABimf2KE1HafoOsIcxLOtmNSZt6dCvBIYCrXaOWta20xJg==} + engines: {node: '>=14'} + peerDependencies: + '@opentelemetry/api': '>=1.0.0 <1.10.0' - '@protobufjs/path@1.1.2': - resolution: {integrity: sha512-6JOcJ5Tm08dOHAbdR3GrvP+yUUfkjG5ePsHYczMFLq3ZmMkAD98cDgcT2iA1lJ9NVwFd4tH/iSSoe44YWkltEA==} + '@opentelemetry/propagator-b3@1.25.1': + resolution: {integrity: sha512-p6HFscpjrv7//kE+7L+3Vn00VEDUJB0n6ZrjkTYHrJ58QZ8B3ajSJhRbCcY6guQ3PDjTbxWklyvIN2ojVbIb1A==} + engines: {node: '>=14'} + peerDependencies: + '@opentelemetry/api': '>=1.0.0 <1.10.0' - '@protobufjs/pool@1.1.0': - resolution: {integrity: sha512-0kELaGSIDBKvcgS4zkjz1PeddatrjYcmMWOlAuAPwAeccUrPHdUqo/J6LiymHHEiJT5NrF1UVwxY14f+fy4WQw==} + '@opentelemetry/propagator-b3@1.30.1': + resolution: {integrity: sha512-oATwWWDIJzybAZ4pO76ATN5N6FFbOA1otibAVlS8v90B4S1wClnhRUk7K+2CHAwN1JKYuj4jh/lpCEG5BAqFuQ==} + engines: {node: '>=14'} + peerDependencies: + '@opentelemetry/api': '>=1.0.0 <1.10.0' - '@protobufjs/utf8@1.1.0': - resolution: {integrity: sha512-Vvn3zZrhQZkkBE8LSuW3em98c0FwgO4nxzv6OdSxPKJIEKY2bGbHn+mhGIPerzI4twdxaP8/0+06HBpwf345Lw==} + '@opentelemetry/propagator-jaeger@1.25.1': + resolution: {integrity: sha512-nBprRf0+jlgxks78G/xq72PipVK+4or9Ypntw0gVZYNTCSK8rg5SeaGV19tV920CMqBD/9UIOiFr23Li/Q8tiA==} + engines: {node: '>=14'} + peerDependencies: + '@opentelemetry/api': '>=1.0.0 <1.10.0' - '@qdrant/js-client-rest@1.16.2': - resolution: {integrity: sha512-Zm4wEZURrZ24a+Hmm4l1QQYjiz975Ep3vF0yzWR7ICGcxittNz47YK2iBOk8kb8qseCu8pg7WmO1HOIsO8alvw==} - engines: {node: '>=18.17.0', pnpm: '>=8'} + '@opentelemetry/propagator-jaeger@1.30.1': + resolution: {integrity: sha512-Pj/BfnYEKIOImirH76M4hDaBSx6HyZ2CXUqk+Kj02m6BB80c/yo4BdWkn/1gDFfU+YPY+bPR2U0DKBfdxCKwmg==} + engines: {node: '>=14'} peerDependencies: - typescript: '>=4.7' + '@opentelemetry/api': '>=1.0.0 <1.10.0' - '@qdrant/openapi-typescript-fetch@1.2.6': - resolution: {integrity: sha512-oQG/FejNpItrxRHoyctYvT3rwGZOnK4jr3JdppO/c78ktDvkWiPXPHNsrDf33K9sZdRb6PR7gi4noIapu5q4HA==} - engines: {node: '>=18.0.0', pnpm: '>=8'} + '@opentelemetry/redis-common@0.36.2': + resolution: {integrity: sha512-faYX1N0gpLhej/6nyp6bgRjzAKXn5GOEMYY7YhciSfCoITAktLUtQ36d24QEWNA1/WA1y6qQunCe0OhHRkVl9g==} + engines: {node: '>=14'} - '@redis/bloom@1.2.0': - resolution: {integrity: sha512-HG2DFjYKbpNmVXsa0keLHp/3leGJz1mjh09f2RLGGLQZzSHpkmZWuwJbAvo3QcRY8p80m5+ZdXZdYOSBLlp7Cg==} + '@opentelemetry/resource-detector-alibaba-cloud@0.29.7': + resolution: {integrity: sha512-PExUl/R+reSQI6Y/eNtgAsk6RHk1ElYSzOa8/FHfdc/nLmx9sqMasBEpLMkETkzDP7t27ORuXe4F9vwkV2uwwg==} + engines: {node: '>=14'} peerDependencies: - '@redis/client': ^1.0.0 + '@opentelemetry/api': ^1.0.0 - '@redis/client@1.6.1': - resolution: {integrity: sha512-/KCsg3xSlR+nCK8/8ZYSknYxvXHwubJrU82F3Lm1Fp6789VQ0/3RJKfsmRXjqfaTA++23CvC3hqmqe/2GEt6Kw==} + '@opentelemetry/resource-detector-aws@1.12.0': + resolution: {integrity: sha512-Cvi7ckOqiiuWlHBdA1IjS0ufr3sltex2Uws2RK6loVp4gzIJyOijsddAI6IZ5kiO8h/LgCWe8gxPmwkTKImd+Q==} engines: {node: '>=14'} + peerDependencies: + '@opentelemetry/api': ^1.0.0 - '@redis/graph@1.1.1': - resolution: {integrity: sha512-FEMTcTHZozZciLRl6GiiIB4zGm5z5F3F6a6FZCyrfxdKOhFlGkiAqlexWMBzCi4DcRoyiOsuLfW+cjlGWyExOw==} + '@opentelemetry/resource-detector-azure@0.2.12': + resolution: {integrity: sha512-iIarQu6MiCjEEp8dOzmBvCSlRITPFTinFB2oNKAjU6xhx8d7eUcjNOKhBGQTvuCriZrxrEvDaEEY9NfrPQ6uYQ==} + engines: {node: '>=14'} peerDependencies: - '@redis/client': ^1.0.0 + '@opentelemetry/api': ^1.0.0 - '@redis/json@1.0.7': - resolution: {integrity: sha512-6UyXfjVaTBTJtKNG4/9Z8PSpKE6XgSyEb8iwaqDcy+uKrd/DGYHTWkUdnQDyzm727V7p21WUMhsqz5oy65kPcQ==} + '@opentelemetry/resource-detector-container@0.4.4': + resolution: {integrity: sha512-ZEN2mq7lIjQWJ8NTt1umtr6oT/Kb89856BOmESLSvgSHbIwOFYs7cSfSRH5bfiVw6dXTQAVbZA/wLgCHKrebJA==} + engines: {node: '>=14'} peerDependencies: - '@redis/client': ^1.0.0 + '@opentelemetry/api': ^1.0.0 - '@redis/search@1.2.0': - resolution: {integrity: sha512-tYoDBbtqOVigEDMAcTGsRlMycIIjwMCgD8eR2t0NANeQmgK/lvxNAvYyb6bZDD4frHRhIHkJu2TBRvB0ERkOmw==} + '@opentelemetry/resource-detector-gcp@0.29.13': + resolution: {integrity: sha512-vdotx+l3Q+89PeyXMgKEGnZ/CwzwMtuMi/ddgD9/5tKZ08DfDGB2Npz9m2oXPHRCjc4Ro6ifMqFlRyzIvgOjhg==} + engines: {node: '>=14'} peerDependencies: - '@redis/client': ^1.0.0 + '@opentelemetry/api': ^1.0.0 - '@redis/time-series@1.1.0': - resolution: {integrity: sha512-c1Q99M5ljsIuc4YdaCwfUEXsofakb9c8+Zse2qxTadu8TalLXuAESzLvFAvNVbkmSlvlzIQOLpBCmWI9wTOt+g==} + '@opentelemetry/resource-detector-gcp@0.40.3': + resolution: {integrity: sha512-C796YjBA5P1JQldovApYfFA/8bQwFfpxjUbOtGhn1YZkVTLoNQN+kvBwgALfTPWzug6fWsd0xhn9dzeiUcndag==} + engines: {node: ^18.19.0 || >=20.6.0} peerDependencies: - '@redis/client': ^1.0.0 - - '@rollup/rollup-android-arm-eabi@4.56.0': - resolution: {integrity: sha512-LNKIPA5k8PF1+jAFomGe3qN3bbIgJe/IlpDBwuVjrDKrJhVWywgnJvflMt/zkbVNLFtF1+94SljYQS6e99klnw==} - cpu: [arm] - os: [android] + '@opentelemetry/api': ^1.0.0 - '@rollup/rollup-android-arm64@4.56.0': - resolution: {integrity: sha512-lfbVUbelYqXlYiU/HApNMJzT1E87UPGvzveGg2h0ktUNlOCxKlWuJ9jtfvs1sKHdwU4fzY7Pl8sAl49/XaEk6Q==} - cpu: [arm64] - os: [android] + '@opentelemetry/resources@1.23.0': + resolution: {integrity: sha512-iPRLfVfcEQynYGo7e4Di+ti+YQTAY0h5mQEUJcHlU9JOqpb4x965O6PZ+wMcwYVY63G96KtdS86YCM1BF1vQZg==} + engines: {node: '>=14'} + peerDependencies: + '@opentelemetry/api': '>=1.0.0 <1.9.0' - '@rollup/rollup-darwin-arm64@4.56.0': - resolution: {integrity: sha512-EgxD1ocWfhoD6xSOeEEwyE7tDvwTgZc8Bss7wCWe+uc7wO8G34HHCUH+Q6cHqJubxIAnQzAsyUsClt0yFLu06w==} - cpu: [arm64] - os: [darwin] + '@opentelemetry/resources@1.25.1': + resolution: {integrity: sha512-pkZT+iFYIZsVn6+GzM0kSX+u3MSLCY9md+lIJOoKl/P+gJFfxJte/60Usdp8Ce4rOs8GduUpSPNe1ddGyDT1sQ==} + engines: {node: '>=14'} + peerDependencies: + '@opentelemetry/api': '>=1.0.0 <1.10.0' - '@rollup/rollup-darwin-x64@4.56.0': - resolution: {integrity: sha512-1vXe1vcMOssb/hOF8iv52A7feWW2xnu+c8BV4t1F//m9QVLTfNVpEdja5ia762j/UEJe2Z1jAmEqZAK42tVW3g==} - cpu: [x64] - os: [darwin] + '@opentelemetry/resources@1.30.1': + resolution: {integrity: sha512-5UxZqiAgLYGFjS4s9qm5mBVo433u+dSPUFWVWXmLAD4wB65oMCoXaJP1KJa9DIYYMeHu3z4BZcStG3LC593cWA==} + engines: {node: '>=14'} + peerDependencies: + '@opentelemetry/api': '>=1.0.0 <1.10.0' - '@rollup/rollup-freebsd-arm64@4.56.0': - resolution: {integrity: sha512-bof7fbIlvqsyv/DtaXSck4VYQ9lPtoWNFCB/JY4snlFuJREXfZnm+Ej6yaCHfQvofJDXLDMTVxWscVSuQvVWUQ==} - cpu: [arm64] - os: [freebsd] + '@opentelemetry/resources@2.0.1': + resolution: {integrity: sha512-dZOB3R6zvBwDKnHDTB4X1xtMArB/d324VsbiPkX/Yu0Q8T2xceRthoIVFhJdvgVM2QhGVUyX9tzwiNxGtoBJUw==} + engines: {node: ^18.19.0 || >=20.6.0} + peerDependencies: + '@opentelemetry/api': '>=1.3.0 <1.10.0' - '@rollup/rollup-freebsd-x64@4.56.0': - resolution: {integrity: sha512-KNa6lYHloW+7lTEkYGa37fpvPq+NKG/EHKM8+G/g9WDU7ls4sMqbVRV78J6LdNuVaeeK5WB9/9VAFbKxcbXKYg==} - cpu: [x64] - os: [freebsd] + '@opentelemetry/resources@2.1.0': + resolution: {integrity: sha512-1CJjf3LCvoefUOgegxi8h6r4B/wLSzInyhGP2UmIBYNlo4Qk5CZ73e1eEyWmfXvFtm1ybkmfb2DqWvspsYLrWw==} + engines: {node: ^18.19.0 || >=20.6.0} + peerDependencies: + '@opentelemetry/api': '>=1.3.0 <1.10.0' - '@rollup/rollup-linux-arm-gnueabihf@4.56.0': - resolution: {integrity: sha512-E8jKK87uOvLrrLN28jnAAAChNq5LeCd2mGgZF+fGF5D507WlG/Noct3lP/QzQ6MrqJ5BCKNwI9ipADB6jyiq2A==} - cpu: [arm] - os: [linux] - libc: [glibc] + '@opentelemetry/resources@2.7.1': + resolution: {integrity: sha512-DeT6KKolmC4e/dRQvMQ/RwlnzhaqeiFOXY5ngoOPJ07GgVVKxZOg9EcrNZb5aTzUn+iCrJldAgOfQm1O/QfPAQ==} + engines: {node: ^18.19.0 || >=20.6.0} + peerDependencies: + '@opentelemetry/api': '>=1.3.0 <1.10.0' - '@rollup/rollup-linux-arm-musleabihf@4.56.0': - resolution: {integrity: sha512-jQosa5FMYF5Z6prEpTCCmzCXz6eKr/tCBssSmQGEeozA9tkRUty/5Vx06ibaOP9RCrW1Pvb8yp3gvZhHwTDsJw==} - cpu: [arm] - os: [linux] - libc: [musl] + '@opentelemetry/sdk-logs@0.201.1': + resolution: {integrity: sha512-Ug8gtpssUNUnfpotB9ZhnSsPSGDu+7LngTMgKl31mmVJwLAKyl6jC8diZrMcGkSgBh0o5dbg9puvLyR25buZfw==} + engines: {node: ^18.19.0 || >=20.6.0} + peerDependencies: + '@opentelemetry/api': '>=1.4.0 <1.10.0' - '@rollup/rollup-linux-arm64-gnu@4.56.0': - resolution: {integrity: sha512-uQVoKkrC1KGEV6udrdVahASIsaF8h7iLG0U0W+Xn14ucFwi6uS539PsAr24IEF9/FoDtzMeeJXJIBo5RkbNWvQ==} - cpu: [arm64] - os: [linux] - libc: [glibc] + '@opentelemetry/sdk-logs@0.202.0': + resolution: {integrity: sha512-pv8QiQLQzk4X909YKm0lnW4hpuQg4zHwJ4XBd5bZiXcd9urvrJNoNVKnxGHPiDVX/GiLFvr5DMYsDBQbZCypRQ==} + engines: {node: ^18.19.0 || >=20.6.0} + peerDependencies: + '@opentelemetry/api': '>=1.4.0 <1.10.0' - '@rollup/rollup-linux-arm64-musl@4.56.0': - resolution: {integrity: sha512-vLZ1yJKLxhQLFKTs42RwTwa6zkGln+bnXc8ueFGMYmBTLfNu58sl5/eXyxRa2RarTkJbXl8TKPgfS6V5ijNqEA==} - cpu: [arm64] - os: [linux] - libc: [musl] + '@opentelemetry/sdk-logs@0.205.0': + resolution: {integrity: sha512-nyqhNQ6eEzPWQU60Nc7+A5LIq8fz3UeIzdEVBQYefB4+msJZ2vuVtRuk9KxPMw1uHoHDtYEwkr2Ct0iG29jU8w==} + engines: {node: ^18.19.0 || >=20.6.0} + peerDependencies: + '@opentelemetry/api': '>=1.4.0 <1.10.0' - '@rollup/rollup-linux-loong64-gnu@4.56.0': - resolution: {integrity: sha512-FWfHOCub564kSE3xJQLLIC/hbKqHSVxy8vY75/YHHzWvbJL7aYJkdgwD/xGfUlL5UV2SB7otapLrcCj2xnF1dg==} - cpu: [loong64] - os: [linux] - libc: [glibc] + '@opentelemetry/sdk-logs@0.218.0': + resolution: {integrity: sha512-QvnNdugatFTVCJXH0Mcu7GOOJSylA9j127kIezOE4YwTI4YbowRons2K4WZTv5FMS8T4q9P0NdaRHdkSmeAIag==} + engines: {node: ^18.19.0 || >=20.6.0} + peerDependencies: + '@opentelemetry/api': '>=1.4.0 <1.10.0' - '@rollup/rollup-linux-loong64-musl@4.56.0': - resolution: {integrity: sha512-z1EkujxIh7nbrKL1lmIpqFTc/sr0u8Uk0zK/qIEFldbt6EDKWFk/pxFq3gYj4Bjn3aa9eEhYRlL3H8ZbPT1xvA==} - cpu: [loong64] - os: [linux] - libc: [musl] + '@opentelemetry/sdk-logs@0.50.0': + resolution: {integrity: sha512-PeUEupBB29p9nlPNqXoa1PUWNLsZnxG0DCDj3sHqzae+8y76B/A5hvZjg03ulWdnvBLYpnJslqzylG9E0IL87g==} + engines: {node: '>=14'} + peerDependencies: + '@opentelemetry/api': '>=1.4.0 <1.9.0' + '@opentelemetry/api-logs': '>=0.39.1' - '@rollup/rollup-linux-ppc64-gnu@4.56.0': - resolution: {integrity: sha512-iNFTluqgdoQC7AIE8Q34R3AuPrJGJirj5wMUErxj22deOcY7XwZRaqYmB6ZKFHoVGqRcRd0mqO+845jAibKCkw==} - cpu: [ppc64] - os: [linux] - libc: [glibc] + '@opentelemetry/sdk-logs@0.52.1': + resolution: {integrity: sha512-MBYh+WcPPsN8YpRHRmK1Hsca9pVlyyKd4BxOC4SsgHACnl/bPp4Cri9hWhVm5+2tiQ9Zf4qSc1Jshw9tOLGWQA==} + engines: {node: '>=14'} + peerDependencies: + '@opentelemetry/api': '>=1.4.0 <1.10.0' - '@rollup/rollup-linux-ppc64-musl@4.56.0': - resolution: {integrity: sha512-MtMeFVlD2LIKjp2sE2xM2slq3Zxf9zwVuw0jemsxvh1QOpHSsSzfNOTH9uYW9i1MXFxUSMmLpeVeUzoNOKBaWg==} - cpu: [ppc64] - os: [linux] - libc: [musl] + '@opentelemetry/sdk-logs@0.57.2': + resolution: {integrity: sha512-TXFHJ5c+BKggWbdEQ/inpgIzEmS2BGQowLE9UhsMd7YYlUfBQJ4uax0VF/B5NYigdM/75OoJGhAV3upEhK+3gg==} + engines: {node: '>=14'} + peerDependencies: + '@opentelemetry/api': '>=1.4.0 <1.10.0' - '@rollup/rollup-linux-riscv64-gnu@4.56.0': - resolution: {integrity: sha512-in+v6wiHdzzVhYKXIk5U74dEZHdKN9KH0Q4ANHOTvyXPG41bajYRsy7a8TPKbYPl34hU7PP7hMVHRvv/5aCSew==} - cpu: [riscv64] - os: [linux] - libc: [glibc] + '@opentelemetry/sdk-metrics@1.23.0': + resolution: {integrity: sha512-4OkvW6+wST4h6LFG23rXSTf6nmTf201h9dzq7bE0z5R9ESEVLERZz6WXwE7PSgg1gdjlaznm1jLJf8GttypFDg==} + engines: {node: '>=14'} + peerDependencies: + '@opentelemetry/api': '>=1.3.0 <1.9.0' - '@rollup/rollup-linux-riscv64-musl@4.56.0': - resolution: {integrity: sha512-yni2raKHB8m9NQpI9fPVwN754mn6dHQSbDTwxdr9SE0ks38DTjLMMBjrwvB5+mXrX+C0npX0CVeCUcvvvD8CNQ==} - cpu: [riscv64] - os: [linux] - libc: [musl] + '@opentelemetry/sdk-metrics@1.25.1': + resolution: {integrity: sha512-9Mb7q5ioFL4E4dDrc4wC/A3NTHDat44v4I3p2pLPSxRvqUbDIQyMVr9uK+EU69+HWhlET1VaSrRzwdckWqY15Q==} + engines: {node: '>=14'} + peerDependencies: + '@opentelemetry/api': '>=1.3.0 <1.10.0' - '@rollup/rollup-linux-s390x-gnu@4.56.0': - resolution: {integrity: sha512-zhLLJx9nQPu7wezbxt2ut+CI4YlXi68ndEve16tPc/iwoylWS9B3FxpLS2PkmfYgDQtosah07Mj9E0khc3Y+vQ==} - cpu: [s390x] - os: [linux] - libc: [glibc] + '@opentelemetry/sdk-metrics@1.30.1': + resolution: {integrity: sha512-q9zcZ0Okl8jRgmy7eNW3Ku1XSgg3sDLa5evHZpCwjspw7E8Is4K/haRPDJrBcX3YSn/Y7gUvFnByNYEKQNbNog==} + engines: {node: '>=14'} + peerDependencies: + '@opentelemetry/api': '>=1.3.0 <1.10.0' - '@rollup/rollup-linux-x64-gnu@4.56.0': - resolution: {integrity: sha512-MVC6UDp16ZSH7x4rtuJPAEoE1RwS8N4oK9DLHy3FTEdFoUTCFVzMfJl/BVJ330C+hx8FfprA5Wqx4FhZXkj2Kw==} - cpu: [x64] - os: [linux] - libc: [glibc] + '@opentelemetry/sdk-metrics@2.0.1': + resolution: {integrity: sha512-wf8OaJoSnujMAHWR3g+/hGvNcsC16rf9s1So4JlMiFaFHiE4HpIA3oUh+uWZQ7CNuK8gVW/pQSkgoa5HkkOl0g==} + engines: {node: ^18.19.0 || >=20.6.0} + peerDependencies: + '@opentelemetry/api': '>=1.9.0 <1.10.0' - '@rollup/rollup-linux-x64-musl@4.56.0': - resolution: {integrity: sha512-ZhGH1eA4Qv0lxaV00azCIS1ChedK0V32952Md3FtnxSqZTBTd6tgil4nZT5cU8B+SIw3PFYkvyR4FKo2oyZIHA==} - cpu: [x64] - os: [linux] - libc: [musl] + '@opentelemetry/sdk-metrics@2.1.0': + resolution: {integrity: sha512-J9QX459mzqHLL9Y6FZ4wQPRZG4TOpMCyPOh6mkr/humxE1W2S3Bvf4i75yiMW9uyed2Kf5rxmLhTm/UK8vNkAw==} + engines: {node: ^18.19.0 || >=20.6.0} + peerDependencies: + '@opentelemetry/api': '>=1.9.0 <1.10.0' - '@rollup/rollup-openbsd-x64@4.56.0': - resolution: {integrity: sha512-O16XcmyDeFI9879pEcmtWvD/2nyxR9mF7Gs44lf1vGGx8Vg2DRNx11aVXBEqOQhWb92WN4z7fW/q4+2NYzCbBA==} - cpu: [x64] - os: [openbsd] + '@opentelemetry/sdk-metrics@2.7.1': + resolution: {integrity: sha512-MpDJdkiFDs3Pm1RHO3KByuZbuBdJEXEAkiC0+yJdsZGVCdf1RpHR6n+LHDcS7ffmfrt5kVCzJSCfm4z2C7v0uQ==} + engines: {node: ^18.19.0 || >=20.6.0} + peerDependencies: + '@opentelemetry/api': '>=1.9.0 <1.10.0' - '@rollup/rollup-openharmony-arm64@4.56.0': - resolution: {integrity: sha512-LhN/Reh+7F3RCgQIRbgw8ZMwUwyqJM+8pXNT6IIJAqm2IdKkzpCh/V9EdgOMBKuebIrzswqy4ATlrDgiOwbRcQ==} - cpu: [arm64] - os: [openharmony] + '@opentelemetry/sdk-node@0.52.1': + resolution: {integrity: sha512-uEG+gtEr6eKd8CVWeKMhH2olcCHM9dEK68pe0qE0be32BcCRsvYURhHaD1Srngh1SQcnQzZ4TP324euxqtBOJA==} + engines: {node: '>=14'} + peerDependencies: + '@opentelemetry/api': '>=1.3.0 <1.10.0' - '@rollup/rollup-win32-arm64-msvc@4.56.0': - resolution: {integrity: sha512-kbFsOObXp3LBULg1d3JIUQMa9Kv4UitDmpS+k0tinPBz3watcUiV2/LUDMMucA6pZO3WGE27P7DsfaN54l9ing==} - cpu: [arm64] - os: [win32] + '@opentelemetry/sdk-trace-base@1.23.0': + resolution: {integrity: sha512-PzBmZM8hBomUqvCddF/5Olyyviayka44O5nDWq673np3ctnvwMOvNrsUORZjKja1zJbwEuD9niAGbnVrz3jwRQ==} + engines: {node: '>=14'} + peerDependencies: + '@opentelemetry/api': '>=1.0.0 <1.9.0' - '@rollup/rollup-win32-ia32-msvc@4.56.0': - resolution: {integrity: sha512-vSSgny54D6P4vf2izbtFm/TcWYedw7f8eBrOiGGecyHyQB9q4Kqentjaj8hToe+995nob/Wv48pDqL5a62EWtg==} - cpu: [ia32] - os: [win32] + '@opentelemetry/sdk-trace-base@1.25.1': + resolution: {integrity: sha512-C8k4hnEbc5FamuZQ92nTOp8X/diCY56XUTnMiv9UTuJitCzaNNHAVsdm5+HLCdI8SLQsLWIrG38tddMxLVoftw==} + engines: {node: '>=14'} + peerDependencies: + '@opentelemetry/api': '>=1.0.0 <1.10.0' - '@rollup/rollup-win32-x64-gnu@4.56.0': - resolution: {integrity: sha512-FeCnkPCTHQJFbiGG49KjV5YGW/8b9rrXAM2Mz2kiIoktq2qsJxRD5giEMEOD2lPdgs72upzefaUvS+nc8E3UzQ==} - cpu: [x64] - os: [win32] + '@opentelemetry/sdk-trace-base@1.30.1': + resolution: {integrity: sha512-jVPgBbH1gCy2Lb7X0AVQ8XAfgg0pJ4nvl8/IiQA6nxOsPvS+0zMJaFSs2ltXe0J6C8dqjcnpyqINDJmU30+uOg==} + engines: {node: '>=14'} + peerDependencies: + '@opentelemetry/api': '>=1.0.0 <1.10.0' - '@rollup/rollup-win32-x64-msvc@4.56.0': - resolution: {integrity: sha512-H8AE9Ur/t0+1VXujj90w0HrSOuv0Nq9r1vSZF2t5km20NTfosQsGGUXDaKdQZzwuLts7IyL1fYT4hM95TI9c4g==} - cpu: [x64] - os: [win32] + '@opentelemetry/sdk-trace-base@2.0.1': + resolution: {integrity: sha512-xYLlvk/xdScGx1aEqvxLwf6sXQLXCjk3/1SQT9X9AoN5rXRhkdvIFShuNNmtTEPRBqcsMbS4p/gJLNI2wXaDuQ==} + engines: {node: ^18.19.0 || >=20.6.0} + peerDependencies: + '@opentelemetry/api': '>=1.3.0 <1.10.0' - '@sec-ant/readable-stream@0.4.1': - resolution: {integrity: sha512-831qok9r2t8AlxLko40y2ebgSDhenenCatLVeW/uBtnHPyhHOvG0C7TvfgecV+wHzIm5KUICgzmVpWS+IMEAeg==} + '@opentelemetry/sdk-trace-base@2.1.0': + resolution: {integrity: sha512-uTX9FBlVQm4S2gVQO1sb5qyBLq/FPjbp+tmGoxu4tIgtYGmBYB44+KX/725RFDe30yBSaA9Ml9fqphe1hbUyLQ==} + engines: {node: ^18.19.0 || >=20.6.0} + peerDependencies: + '@opentelemetry/api': '>=1.3.0 <1.10.0' - '@selderee/plugin-htmlparser2@0.11.0': - resolution: {integrity: sha512-P33hHGdldxGabLFjPPpaTxVolMrzrcegejx+0GxjrIb9Zv48D8yAIA/QTDR2dFl7Uz7urX8aX6+5bCZslr+gWQ==} + '@opentelemetry/sdk-trace-base@2.7.1': + resolution: {integrity: sha512-NAYIlsF8MPUsKqJMiDQJTMPOmlbawC1Iz/omMLygZ1C9am8fTKYjTaI+OZM+WTY3t3Glo0wnOg/6/pac6RGPPw==} + engines: {node: ^18.19.0 || >=20.6.0} + peerDependencies: + '@opentelemetry/api': '>=1.3.0 <1.10.0' - '@sinclair/typebox@0.27.8': - resolution: {integrity: sha512-+Fj43pSMwJs4KRrH/938Uf+uAELIgVBmQzg/q1YG10djyfA3TnrU8N8XzqCh/okZdszqBQTZf96idMfE5lnwTA==} + '@opentelemetry/sdk-trace-node@1.25.1': + resolution: {integrity: sha512-nMcjFIKxnFqoez4gUmihdBrbpsEnAX/Xj16sGvZm+guceYE0NE00vLhpDVK6f3q8Q4VFI5xG8JjlXKMB/SkTTQ==} + engines: {node: '>=14'} + peerDependencies: + '@opentelemetry/api': '>=1.0.0 <1.10.0' - '@sindresorhus/is@4.6.0': - resolution: {integrity: sha512-t09vSN3MdfsyCHoFcTRCH/iUtG7OJ0CsjzB8cjAmKc/va/kIgeDI/TxsigdncE/4be734m0cvIYwNaV4i2XqAw==} - engines: {node: '>=10'} + '@opentelemetry/sdk-trace-node@1.30.1': + resolution: {integrity: sha512-cBjYOINt1JxXdpw1e5MlHmFRc5fgj4GW/86vsKFxJCJ8AL4PdVtYH41gWwl4qd4uQjqEL1oJVrXkSy5cnduAnQ==} + engines: {node: '>=14'} + peerDependencies: + '@opentelemetry/api': '>=1.0.0 <1.10.0' - '@sindresorhus/merge-streams@4.0.0': - resolution: {integrity: sha512-tlqY9xq5ukxTUZBmoOp+m61cqwQD5pHJtFY3Mn8CA8ps6yghLH/Hw8UPdqg4OLmFW3IFlcXnQNmo/dh8HzXYIQ==} - engines: {node: '>=18'} + '@opentelemetry/sdk-trace-node@2.0.1': + resolution: {integrity: sha512-UhdbPF19pMpBtCWYP5lHbTogLWx9N0EBxtdagvkn5YtsAnCBZzL7SjktG+ZmupRgifsHMjwUaCCaVmqGfSADmA==} + engines: {node: ^18.19.0 || >=20.6.0} + peerDependencies: + '@opentelemetry/api': '>=1.0.0 <1.10.0' - '@sindresorhus/slugify@2.2.1': - resolution: {integrity: sha512-MkngSCRZ8JdSOCHRaYd+D01XhvU3Hjy6MGl06zhOk614hp9EOAp5gIkBeQg7wtmxpitU6eAL4kdiRMcJa2dlrw==} - engines: {node: '>=12'} + '@opentelemetry/sdk-trace-node@2.7.1': + resolution: {integrity: sha512-pCpQxU68lV+I9s9svqMyVu5iHdDDUnqUpSxqwyCU8A9ejEsSnMPCbearwsUO4yk08ZJzAIUCFuReMdVQvHrdvg==} + engines: {node: ^18.19.0 || >=20.6.0} + peerDependencies: + '@opentelemetry/api': '>=1.0.0 <1.10.0' - '@sindresorhus/transliterate@1.6.0': - resolution: {integrity: sha512-doH1gimEu3A46VX6aVxpHTeHrytJAG6HgdxntYnCFiIFHEM/ZGpG8KiZGBChchjQmG0XFIBL552kBTjVcMZXwQ==} - engines: {node: '>=12'} + '@opentelemetry/semantic-conventions@1.23.0': + resolution: {integrity: sha512-MiqFvfOzfR31t8cc74CTP1OZfz7MbqpAnLCra8NqQoaHJX6ncIRTdYOQYBDQ2uFISDq0WY8Y9dDTWvsgzzBYRg==} + engines: {node: '>=14'} - '@sinonjs/commons@3.0.1': - resolution: {integrity: sha512-K3mCHKQ9sVh8o1C9cxkwxaOmXoAMlDxC1mYyHrjqOWEcBjYr76t96zL2zlj5dUGZ3HSw240X1qgH3Mjf1yJWpQ==} + '@opentelemetry/semantic-conventions@1.25.1': + resolution: {integrity: sha512-ZDjMJJQRlyk8A1KZFCc+bCbsyrn1wTwdNt56F7twdfUfnHUZUq77/WfONCj8p72NZOyP7pNTdUWSTYC3GTbuuQ==} + engines: {node: '>=14'} - '@sinonjs/fake-timers@10.3.0': - resolution: {integrity: sha512-V4BG07kuYSUkTCSBHG8G8TNhM+F19jXFWnQtzj+we8DrkpSBCee9Z3Ms8yiGer/dlmhe35/Xdgyo3/0rQKg7YA==} + '@opentelemetry/semantic-conventions@1.28.0': + resolution: {integrity: sha512-lp4qAiMTD4sNWW4DbKLBkfiMZ4jbAboJIGOQr5DvciMRI494OapieI9qiODpOt0XBr1LjIDy1xAGAnVs5supTA==} + engines: {node: '>=14'} - '@smithy/abort-controller@4.2.8': - resolution: {integrity: sha512-peuVfkYHAmS5ybKxWcfraK7WBBP0J+rkfUcbHJJKQ4ir3UAUNQI+Y4Vt/PqSzGqgloJ5O1dk7+WzNL8wcCSXbw==} - engines: {node: '>=18.0.0'} + '@opentelemetry/semantic-conventions@1.34.0': + resolution: {integrity: sha512-aKcOkyrorBGlajjRdVoJWHTxfxO1vCNHLJVlSDaRHDIdjU+pX8IYQPvPDkYiujKLbRnWU+1TBwEt0QRgSm4SGA==} + engines: {node: '>=14'} - '@smithy/config-resolver@4.4.6': - resolution: {integrity: sha512-qJpzYC64kaj3S0fueiu3kXm8xPrR3PcXDPEgnaNMRn0EjNSZFoFjvbUp0YUDsRhN1CB90EnHJtbxWKevnH99UQ==} - engines: {node: '>=18.0.0'} + '@opentelemetry/semantic-conventions@1.41.1': + resolution: {integrity: sha512-/UhIkaZgPutTFmQ7RnIJGgDXZmtEJ7Dvi86xNTFWcnRxVRNk/aotsqDJYeEvDP+FSMB2SdW+pQzNMcWP0rwuNA==} + engines: {node: '>=14'} - '@smithy/core@3.21.1': - resolution: {integrity: sha512-NUH8R4O6FkN8HKMojzbGg/5pNjsfTjlMmeFclyPfPaXXUrbr5TzhWgbf7t92wfrpCHRgpjyz7ffASIS3wX28aA==} - engines: {node: '>=18.0.0'} + '@opentelemetry/sql-common@0.40.1': + resolution: {integrity: sha512-nSDlnHSqzC3pXn/wZEZVLuAuJ1MYMXPBwtv2qAbCa3847SaHItdE7SzUq/Jtb0KZmh1zfAbNi3AAMjztTT4Ugg==} + engines: {node: '>=14'} + peerDependencies: + '@opentelemetry/api': ^1.1.0 - '@smithy/credential-provider-imds@4.2.8': - resolution: {integrity: sha512-FNT0xHS1c/CPN8upqbMFP83+ul5YgdisfCfkZ86Jh2NSmnqw/AJ6x5pEogVCTVvSm7j9MopRU89bmDelxuDMYw==} - engines: {node: '>=18.0.0'} + '@petamoriken/float16@3.9.3': + resolution: {integrity: sha512-8awtpHXCx/bNpFt4mt2xdkgtgVvKqty8VbjHI/WWWQuEw+KLzFot3f4+LkQY9YmOtq7A5GdOnqoIC8Pdygjk2g==} - '@smithy/eventstream-codec@4.2.8': - resolution: {integrity: sha512-jS/O5Q14UsufqoGhov7dHLOPCzkYJl9QDzusI2Psh4wyYx/izhzvX9P4D69aTxcdfVhEPhjK+wYyn/PzLjKbbw==} + '@pinecone-database/pinecone@4.1.0': + resolution: {integrity: sha512-WoVsbvmCgvZfjm/nCasJXuQ/tw0es5BpedLHvRScAm6xJ/nL07s3B0TrsM8m8rACTiUgbdYsdLY1W6cEBhS9xA==} engines: {node: '>=18.0.0'} - '@smithy/eventstream-serde-browser@4.2.8': - resolution: {integrity: sha512-MTfQT/CRQz5g24ayXdjg53V0mhucZth4PESoA5IhvaWVDTOQLfo8qI9vzqHcPsdd2v6sqfTYqF5L/l+pea5Uyw==} - engines: {node: '>=18.0.0'} + '@pinojs/redact@0.4.0': + resolution: {integrity: sha512-k2ENnmBugE/rzQfEcdWHcCY+/FM3VLzH9cYEsbdsoqrvzAKRhUZeRNhAZvB8OitQJ1TBed3yqWtdjzS6wJKBwg==} - '@smithy/eventstream-serde-config-resolver@4.3.8': - resolution: {integrity: sha512-ah12+luBiDGzBruhu3efNy1IlbwSEdNiw8fOZksoKoWW1ZHvO/04MQsdnws/9Aj+5b0YXSSN2JXKy/ClIsW8MQ==} - engines: {node: '>=18.0.0'} + '@pipecat-ai/client-js@1.6.0': + resolution: {integrity: sha512-riG/p9MDhy/mVo8x3ZGRdE55cgVgIcqkWsJcXb11CtG4j7xAszwcMdv7IOzRtTMSCD/2s7rwuv7Yi/D8bpDzNA==} - '@smithy/eventstream-serde-node@4.2.8': - resolution: {integrity: sha512-cYpCpp29z6EJHa5T9WL0KAlq3SOKUQkcgSoeRfRVwjGgSFl7Uh32eYGt7IDYCX20skiEdRffyDpvF2efEZPC0A==} - engines: {node: '>=18.0.0'} + '@pkgjs/parseargs@0.11.0': + resolution: {integrity: sha512-+1VkjdD0QBLPodGrJUeqarH8VAIvQODIbwh9XpP5Syisf7YoQgsJKPNFoqqLQlu+VQ/tVSshMR6loPMn8U+dPg==} + engines: {node: '>=14'} - '@smithy/eventstream-serde-universal@4.2.8': - resolution: {integrity: sha512-iJ6YNJd0bntJYnX6s52NC4WFYcZeKrPUr1Kmmr5AwZcwCSzVpS7oavAmxMR7pMq7V+D1G4s9F5NJK0xwOsKAlQ==} - engines: {node: '>=18.0.0'} + '@posthog/core@1.30.2': + resolution: {integrity: sha512-d7RTpfi+/q5+SZ+4f1WhanfEtNBz9onMmUxn3BO0GDT8N5ZT4DEP3LqFisqeP+xkJTaFPWCOVA/nGyKmUX9y9g==} - '@smithy/fetch-http-handler@5.3.9': - resolution: {integrity: sha512-I4UhmcTYXBrct03rwzQX1Y/iqQlzVQaPxWjCjula++5EmWq9YGBrx6bbGqluGc1f0XEfhSkiY4jhLgbsJUMKRA==} - engines: {node: '>=18.0.0'} + '@posthog/types@1.378.1': + resolution: {integrity: sha512-bKOXVWySe5oKFjV6X9VW9jngIm14d4BvnT7l/Eb7e6DrT5uD+XclvbRdhC5f1/l5KwoIU+qswBobHRPlix2D1w==} - '@smithy/hash-node@4.2.8': - resolution: {integrity: sha512-7ZIlPbmaDGxVoxErDZnuFG18WekhbA/g2/i97wGj+wUBeS6pcUeAym8u4BXh/75RXWhgIJhyC11hBzig6MljwA==} - engines: {node: '>=18.0.0'} + '@protobuf-ts/grpc-transport@2.11.1': + resolution: {integrity: sha512-l6wrcFffY+tuNnuyrNCkRM8hDIsAZVLA8Mn7PKdVyYxITosYh60qW663p9kL6TWXYuDCL3oxH8ih3vLKTDyhtg==} + peerDependencies: + '@grpc/grpc-js': ^1.6.0 - '@smithy/invalid-dependency@4.2.8': - resolution: {integrity: sha512-N9iozRybwAQ2dn9Fot9kI6/w9vos2oTXLhtK7ovGqwZjlOcxu6XhPlpLpC+INsxktqHinn5gS2DXDjDF2kG5sQ==} - engines: {node: '>=18.0.0'} + '@protobuf-ts/plugin@2.11.1': + resolution: {integrity: sha512-HyuprDcw0bEEJqkOWe1rnXUP0gwYLij8YhPuZyZk6cJbIgc/Q0IFgoHQxOXNIXAcXM4Sbehh6kjVnCzasElw1A==} + hasBin: true - '@smithy/is-array-buffer@2.2.0': - resolution: {integrity: sha512-GGP3O9QFD24uGeAXYUjwSTXARoqpZykHadOmA8G5vfJPK0/DC67qa//0qvqrJzL1xc8WQWX7/yc7fwudjPHPhA==} - engines: {node: '>=14.0.0'} + '@protobuf-ts/protoc@2.11.1': + resolution: {integrity: sha512-mUZJaV0daGO6HUX90o/atzQ6A7bbN2RSuHtdwo8SSF2Qoe3zHwa4IHyCN1evftTeHfLmdz+45qo47sL+5P8nyg==} + hasBin: true - '@smithy/is-array-buffer@4.2.0': - resolution: {integrity: sha512-DZZZBvC7sjcYh4MazJSGiWMI2L7E0oCiRHREDzIxi/M2LY79/21iXt6aPLHge82wi5LsuRF5A06Ds3+0mlh6CQ==} - engines: {node: '>=18.0.0'} + '@protobuf-ts/runtime-rpc@2.11.1': + resolution: {integrity: sha512-4CqqUmNA+/uMz00+d3CYKgElXO9VrEbucjnBFEjqI4GuDrEQ32MaI3q+9qPBvIGOlL4PmHXrzM32vBPWRhQKWQ==} - '@smithy/middleware-content-length@4.2.8': - resolution: {integrity: sha512-RO0jeoaYAB1qBRhfVyq0pMgBoUK34YEJxVxyjOWYZiOKOq2yMZ4MnVXMZCUDenpozHue207+9P5ilTV1zeda0A==} - engines: {node: '>=18.0.0'} + '@protobuf-ts/runtime@2.11.1': + resolution: {integrity: sha512-KuDaT1IfHkugM2pyz+FwiY80ejWrkH1pAtOBOZFuR6SXEFTsnb/jiQWQ1rCIrcKx2BtyxnxW6BWwsVSA/Ie+WQ==} - '@smithy/middleware-endpoint@4.4.11': - resolution: {integrity: sha512-/WqsrycweGGfb9sSzME4CrsuayjJF6BueBmkKlcbeU5q18OhxRrvvKlmfw3tpDsK5ilx2XUJvoukwxHB0nHs/Q==} - engines: {node: '>=18.0.0'} + '@protobufjs/aspromise@1.1.2': + resolution: {integrity: sha512-j+gKExEuLmKwvz3OgROXtrJ2UG2x8Ch2YZUxahh+s1F2HZ+wAceUNLkvy6zKCPVRkU++ZWQrdxsUeQXmcg4uoQ==} - '@smithy/middleware-retry@4.4.27': - resolution: {integrity: sha512-xFUYCGRVsfgiN5EjsJJSzih9+yjStgMTCLANPlf0LVQkPDYCe0hz97qbdTZosFOiYlGBlHYityGRxrQ/hxhfVQ==} - engines: {node: '>=18.0.0'} + '@protobufjs/base64@1.1.2': + resolution: {integrity: sha512-AZkcAA5vnN/v4PDqKyMR5lx7hZttPDgClv83E//FMNhR2TMcLUhfRUBHCmSl0oi9zMgDDqRUJkSxO3wm85+XLg==} - '@smithy/middleware-serde@4.2.9': - resolution: {integrity: sha512-eMNiej0u/snzDvlqRGSN3Vl0ESn3838+nKyVfF2FKNXFbi4SERYT6PR392D39iczngbqqGG0Jl1DlCnp7tBbXQ==} - engines: {node: '>=18.0.0'} + '@protobufjs/codegen@2.0.4': + resolution: {integrity: sha512-YyFaikqM5sH0ziFZCN3xDC7zeGaB/d0IUb9CATugHWbd1FRFwWwt4ld4OYMPWu5a3Xe01mGAULCdqhMlPl29Jg==} - '@smithy/middleware-stack@4.2.8': - resolution: {integrity: sha512-w6LCfOviTYQjBctOKSwy6A8FIkQy7ICvglrZFl6Bw4FmcQ1Z420fUtIhxaUZZshRe0VCq4kvDiPiXrPZAe8oRA==} - engines: {node: '>=18.0.0'} + '@protobufjs/eventemitter@1.1.0': + resolution: {integrity: sha512-j9ednRT81vYJ9OfVuXG6ERSTdEL1xVsNgqpkxMsbIabzSo3goCjDIveeGv5d03om39ML71RdmrGNjG5SReBP/Q==} - '@smithy/node-config-provider@4.3.8': - resolution: {integrity: sha512-aFP1ai4lrbVlWjfpAfRSL8KFcnJQYfTl5QxLJXY32vghJrDuFyPZ6LtUL+JEGYiFRG1PfPLHLoxj107ulncLIg==} - engines: {node: '>=18.0.0'} + '@protobufjs/fetch@1.1.0': + resolution: {integrity: sha512-lljVXpqXebpsijW71PZaCYeIcE5on1w5DlQy5WH6GLbFryLUrBD4932W/E2BSpfRJWseIL4v/KPgBFxDOIdKpQ==} - '@smithy/node-http-handler@4.4.8': - resolution: {integrity: sha512-q9u+MSbJVIJ1QmJ4+1u+cERXkrhuILCBDsJUBAW1MPE6sFonbCNaegFuwW9ll8kh5UdyY3jOkoOGlc7BesoLpg==} - engines: {node: '>=18.0.0'} + '@protobufjs/float@1.0.2': + resolution: {integrity: sha512-Ddb+kVXlXst9d+R9PfTIxh1EdNkgoRe5tOX6t01f1lYWOvJnSPDBlG241QLzcyPdoNTsblLUdujGSE4RzrTZGQ==} - '@smithy/property-provider@4.2.8': - resolution: {integrity: sha512-EtCTbyIveCKeOXDSWSdze3k612yCPq1YbXsbqX3UHhkOSW8zKsM9NOJG5gTIya0vbY2DIaieG8pKo1rITHYL0w==} - engines: {node: '>=18.0.0'} + '@protobufjs/inquire@1.1.0': + resolution: {integrity: sha512-kdSefcPdruJiFMVSbn801t4vFK7KB/5gd2fYvrxhuJYg8ILrmn9SKSX2tZdV6V+ksulWqS7aXjBcRXl3wHoD9Q==} - '@smithy/protocol-http@5.3.8': - resolution: {integrity: sha512-QNINVDhxpZ5QnP3aviNHQFlRogQZDfYlCkQT+7tJnErPQbDhysondEjhikuANxgMsZrkGeiAxXy4jguEGsDrWQ==} - engines: {node: '>=18.0.0'} + '@protobufjs/path@1.1.2': + resolution: {integrity: sha512-6JOcJ5Tm08dOHAbdR3GrvP+yUUfkjG5ePsHYczMFLq3ZmMkAD98cDgcT2iA1lJ9NVwFd4tH/iSSoe44YWkltEA==} - '@smithy/querystring-builder@4.2.8': - resolution: {integrity: sha512-Xr83r31+DrE8CP3MqPgMJl+pQlLLmOfiEUnoyAlGzzJIrEsbKsPy1hqH0qySaQm4oWrCBlUqRt+idEgunKB+iw==} - engines: {node: '>=18.0.0'} + '@protobufjs/pool@1.1.0': + resolution: {integrity: sha512-0kELaGSIDBKvcgS4zkjz1PeddatrjYcmMWOlAuAPwAeccUrPHdUqo/J6LiymHHEiJT5NrF1UVwxY14f+fy4WQw==} - '@smithy/querystring-parser@4.2.8': - resolution: {integrity: sha512-vUurovluVy50CUlazOiXkPq40KGvGWSdmusa3130MwrR1UNnNgKAlj58wlOe61XSHRpUfIIh6cE0zZ8mzKaDPA==} - engines: {node: '>=18.0.0'} + '@protobufjs/utf8@1.1.0': + resolution: {integrity: sha512-Vvn3zZrhQZkkBE8LSuW3em98c0FwgO4nxzv6OdSxPKJIEKY2bGbHn+mhGIPerzI4twdxaP8/0+06HBpwf345Lw==} - '@smithy/service-error-classification@4.2.8': - resolution: {integrity: sha512-mZ5xddodpJhEt3RkCjbmUQuXUOaPNTkbMGR0bcS8FE0bJDLMZlhmpgrvPNCYglVw5rsYTpSnv19womw9WWXKQQ==} - engines: {node: '>=18.0.0'} + '@qdrant/js-client-rest@1.16.2': + resolution: {integrity: sha512-Zm4wEZURrZ24a+Hmm4l1QQYjiz975Ep3vF0yzWR7ICGcxittNz47YK2iBOk8kb8qseCu8pg7WmO1HOIsO8alvw==} + engines: {node: '>=18.17.0', pnpm: '>=8'} + peerDependencies: + typescript: '>=4.7' - '@smithy/shared-ini-file-loader@4.4.3': - resolution: {integrity: sha512-DfQjxXQnzC5UbCUPeC3Ie8u+rIWZTvuDPAGU/BxzrOGhRvgUanaP68kDZA+jaT3ZI+djOf+4dERGlm9mWfFDrg==} - engines: {node: '>=18.0.0'} + '@qdrant/openapi-typescript-fetch@1.2.6': + resolution: {integrity: sha512-oQG/FejNpItrxRHoyctYvT3rwGZOnK4jr3JdppO/c78ktDvkWiPXPHNsrDf33K9sZdRb6PR7gi4noIapu5q4HA==} + engines: {node: '>=18.0.0', pnpm: '>=8'} - '@smithy/signature-v4@5.3.8': - resolution: {integrity: sha512-6A4vdGj7qKNRF16UIcO8HhHjKW27thsxYci+5r/uVRkdcBEkOEiY8OMPuydLX4QHSrJqGHPJzPRwwVTqbLZJhg==} - engines: {node: '>=18.0.0'} + '@redis/bloom@1.2.0': + resolution: {integrity: sha512-HG2DFjYKbpNmVXsa0keLHp/3leGJz1mjh09f2RLGGLQZzSHpkmZWuwJbAvo3QcRY8p80m5+ZdXZdYOSBLlp7Cg==} + peerDependencies: + '@redis/client': ^1.0.0 - '@smithy/smithy-client@4.10.12': - resolution: {integrity: sha512-VKO/HKoQ5OrSHW6AJUmEnUKeXI1/5LfCwO9cwyao7CmLvGnZeM1i36Lyful3LK1XU7HwTVieTqO1y2C/6t3qtA==} - engines: {node: '>=18.0.0'} + '@redis/client@1.6.1': + resolution: {integrity: sha512-/KCsg3xSlR+nCK8/8ZYSknYxvXHwubJrU82F3Lm1Fp6789VQ0/3RJKfsmRXjqfaTA++23CvC3hqmqe/2GEt6Kw==} + engines: {node: '>=14'} - '@smithy/types@4.12.0': - resolution: {integrity: sha512-9YcuJVTOBDjg9LWo23Qp0lTQ3D7fQsQtwle0jVfpbUHy9qBwCEgKuVH4FqFB3VYu0nwdHKiEMA+oXz7oV8X1kw==} - engines: {node: '>=18.0.0'} + '@redis/graph@1.1.1': + resolution: {integrity: sha512-FEMTcTHZozZciLRl6GiiIB4zGm5z5F3F6a6FZCyrfxdKOhFlGkiAqlexWMBzCi4DcRoyiOsuLfW+cjlGWyExOw==} + peerDependencies: + '@redis/client': ^1.0.0 - '@smithy/url-parser@4.2.8': - resolution: {integrity: sha512-NQho9U68TGMEU639YkXnVMV3GEFFULmmaWdlu1E9qzyIePOHsoSnagTGSDv1Zi8DCNN6btxOSdgmy5E/hsZwhA==} - engines: {node: '>=18.0.0'} + '@redis/json@1.0.7': + resolution: {integrity: sha512-6UyXfjVaTBTJtKNG4/9Z8PSpKE6XgSyEb8iwaqDcy+uKrd/DGYHTWkUdnQDyzm727V7p21WUMhsqz5oy65kPcQ==} + peerDependencies: + '@redis/client': ^1.0.0 - '@smithy/util-base64@4.3.0': - resolution: {integrity: sha512-GkXZ59JfyxsIwNTWFnjmFEI8kZpRNIBfxKjv09+nkAWPt/4aGaEWMM04m4sxgNVWkbt2MdSvE3KF/PfX4nFedQ==} - engines: {node: '>=18.0.0'} + '@redis/search@1.2.0': + resolution: {integrity: sha512-tYoDBbtqOVigEDMAcTGsRlMycIIjwMCgD8eR2t0NANeQmgK/lvxNAvYyb6bZDD4frHRhIHkJu2TBRvB0ERkOmw==} + peerDependencies: + '@redis/client': ^1.0.0 - '@smithy/util-body-length-browser@4.2.0': - resolution: {integrity: sha512-Fkoh/I76szMKJnBXWPdFkQJl2r9SjPt3cMzLdOB6eJ4Pnpas8hVoWPYemX/peO0yrrvldgCUVJqOAjUrOLjbxg==} - engines: {node: '>=18.0.0'} + '@redis/time-series@1.1.0': + resolution: {integrity: sha512-c1Q99M5ljsIuc4YdaCwfUEXsofakb9c8+Zse2qxTadu8TalLXuAESzLvFAvNVbkmSlvlzIQOLpBCmWI9wTOt+g==} + peerDependencies: + '@redis/client': ^1.0.0 - '@smithy/util-body-length-node@4.2.1': - resolution: {integrity: sha512-h53dz/pISVrVrfxV1iqXlx5pRg3V2YWFcSQyPyXZRrZoZj4R4DeWRDo1a7dd3CPTcFi3kE+98tuNyD2axyZReA==} - engines: {node: '>=18.0.0'} + '@rollup/rollup-android-arm-eabi@4.56.0': + resolution: {integrity: sha512-LNKIPA5k8PF1+jAFomGe3qN3bbIgJe/IlpDBwuVjrDKrJhVWywgnJvflMt/zkbVNLFtF1+94SljYQS6e99klnw==} + cpu: [arm] + os: [android] - '@smithy/util-buffer-from@2.2.0': - resolution: {integrity: sha512-IJdWBbTcMQ6DA0gdNhh/BwrLkDR+ADW5Kr1aZmd4k3DIF6ezMV4R2NIAmT08wQJ3yUK82thHWmC/TnK/wpMMIA==} - engines: {node: '>=14.0.0'} + '@rollup/rollup-android-arm64@4.56.0': + resolution: {integrity: sha512-lfbVUbelYqXlYiU/HApNMJzT1E87UPGvzveGg2h0ktUNlOCxKlWuJ9jtfvs1sKHdwU4fzY7Pl8sAl49/XaEk6Q==} + cpu: [arm64] + os: [android] - '@smithy/util-buffer-from@4.2.0': - resolution: {integrity: sha512-kAY9hTKulTNevM2nlRtxAG2FQ3B2OR6QIrPY3zE5LqJy1oxzmgBGsHLWTcNhWXKchgA0WHW+mZkQrng/pgcCew==} - engines: {node: '>=18.0.0'} + '@rollup/rollup-darwin-arm64@4.56.0': + resolution: {integrity: sha512-EgxD1ocWfhoD6xSOeEEwyE7tDvwTgZc8Bss7wCWe+uc7wO8G34HHCUH+Q6cHqJubxIAnQzAsyUsClt0yFLu06w==} + cpu: [arm64] + os: [darwin] - '@smithy/util-config-provider@4.2.0': - resolution: {integrity: sha512-YEjpl6XJ36FTKmD+kRJJWYvrHeUvm5ykaUS5xK+6oXffQPHeEM4/nXlZPe+Wu0lsgRUcNZiliYNh/y7q9c2y6Q==} - engines: {node: '>=18.0.0'} + '@rollup/rollup-darwin-x64@4.56.0': + resolution: {integrity: sha512-1vXe1vcMOssb/hOF8iv52A7feWW2xnu+c8BV4t1F//m9QVLTfNVpEdja5ia762j/UEJe2Z1jAmEqZAK42tVW3g==} + cpu: [x64] + os: [darwin] - '@smithy/util-defaults-mode-browser@4.3.26': - resolution: {integrity: sha512-vva0dzYUTgn7DdE0uaha10uEdAgmdLnNFowKFjpMm6p2R0XDk5FHPX3CBJLzWQkQXuEprsb0hGz9YwbicNWhjw==} - engines: {node: '>=18.0.0'} + '@rollup/rollup-freebsd-arm64@4.56.0': + resolution: {integrity: sha512-bof7fbIlvqsyv/DtaXSck4VYQ9lPtoWNFCB/JY4snlFuJREXfZnm+Ej6yaCHfQvofJDXLDMTVxWscVSuQvVWUQ==} + cpu: [arm64] + os: [freebsd] - '@smithy/util-defaults-mode-node@4.2.29': - resolution: {integrity: sha512-c6D7IUBsZt/aNnTBHMTf+OVh+h/JcxUUgfTcIJaWRe6zhOum1X+pNKSZtZ+7fbOn5I99XVFtmrnXKv8yHHErTQ==} - engines: {node: '>=18.0.0'} + '@rollup/rollup-freebsd-x64@4.56.0': + resolution: {integrity: sha512-KNa6lYHloW+7lTEkYGa37fpvPq+NKG/EHKM8+G/g9WDU7ls4sMqbVRV78J6LdNuVaeeK5WB9/9VAFbKxcbXKYg==} + cpu: [x64] + os: [freebsd] - '@smithy/util-endpoints@3.2.8': - resolution: {integrity: sha512-8JaVTn3pBDkhZgHQ8R0epwWt+BqPSLCjdjXXusK1onwJlRuN69fbvSK66aIKKO7SwVFM6x2J2ox5X8pOaWcUEw==} - engines: {node: '>=18.0.0'} + '@rollup/rollup-linux-arm-gnueabihf@4.56.0': + resolution: {integrity: sha512-E8jKK87uOvLrrLN28jnAAAChNq5LeCd2mGgZF+fGF5D507WlG/Noct3lP/QzQ6MrqJ5BCKNwI9ipADB6jyiq2A==} + cpu: [arm] + os: [linux] + libc: [glibc] - '@smithy/util-hex-encoding@4.2.0': - resolution: {integrity: sha512-CCQBwJIvXMLKxVbO88IukazJD9a4kQ9ZN7/UMGBjBcJYvatpWk+9g870El4cB8/EJxfe+k+y0GmR9CAzkF+Nbw==} - engines: {node: '>=18.0.0'} + '@rollup/rollup-linux-arm-musleabihf@4.56.0': + resolution: {integrity: sha512-jQosa5FMYF5Z6prEpTCCmzCXz6eKr/tCBssSmQGEeozA9tkRUty/5Vx06ibaOP9RCrW1Pvb8yp3gvZhHwTDsJw==} + cpu: [arm] + os: [linux] + libc: [musl] - '@smithy/util-middleware@4.2.8': - resolution: {integrity: sha512-PMqfeJxLcNPMDgvPbbLl/2Vpin+luxqTGPpW3NAQVLbRrFRzTa4rNAASYeIGjRV9Ytuhzny39SpyU04EQreF+A==} - engines: {node: '>=18.0.0'} + '@rollup/rollup-linux-arm64-gnu@4.56.0': + resolution: {integrity: sha512-uQVoKkrC1KGEV6udrdVahASIsaF8h7iLG0U0W+Xn14ucFwi6uS539PsAr24IEF9/FoDtzMeeJXJIBo5RkbNWvQ==} + cpu: [arm64] + os: [linux] + libc: [glibc] - '@smithy/util-retry@4.2.8': - resolution: {integrity: sha512-CfJqwvoRY0kTGe5AkQokpURNCT1u/MkRzMTASWMPPo2hNSnKtF1D45dQl3DE2LKLr4m+PW9mCeBMJr5mCAVThg==} - engines: {node: '>=18.0.0'} + '@rollup/rollup-linux-arm64-musl@4.56.0': + resolution: {integrity: sha512-vLZ1yJKLxhQLFKTs42RwTwa6zkGln+bnXc8ueFGMYmBTLfNu58sl5/eXyxRa2RarTkJbXl8TKPgfS6V5ijNqEA==} + cpu: [arm64] + os: [linux] + libc: [musl] - '@smithy/util-stream@4.5.10': - resolution: {integrity: sha512-jbqemy51UFSZSp2y0ZmRfckmrzuKww95zT9BYMmuJ8v3altGcqjwoV1tzpOwuHaKrwQrCjIzOib499ymr2f98g==} - engines: {node: '>=18.0.0'} + '@rollup/rollup-linux-loong64-gnu@4.56.0': + resolution: {integrity: sha512-FWfHOCub564kSE3xJQLLIC/hbKqHSVxy8vY75/YHHzWvbJL7aYJkdgwD/xGfUlL5UV2SB7otapLrcCj2xnF1dg==} + cpu: [loong64] + os: [linux] + libc: [glibc] - '@smithy/util-uri-escape@4.2.0': - resolution: {integrity: sha512-igZpCKV9+E/Mzrpq6YacdTQ0qTiLm85gD6N/IrmyDvQFA4UnU3d5g3m8tMT/6zG/vVkWSU+VxeUyGonL62DuxA==} - engines: {node: '>=18.0.0'} + '@rollup/rollup-linux-loong64-musl@4.56.0': + resolution: {integrity: sha512-z1EkujxIh7nbrKL1lmIpqFTc/sr0u8Uk0zK/qIEFldbt6EDKWFk/pxFq3gYj4Bjn3aa9eEhYRlL3H8ZbPT1xvA==} + cpu: [loong64] + os: [linux] + libc: [musl] - '@smithy/util-utf8@2.3.0': - resolution: {integrity: sha512-R8Rdn8Hy72KKcebgLiv8jQcQkXoLMOGGv5uI1/k0l+snqkOzQ1R0ChUBCxWMlBsFMekWjq0wRudIweFs7sKT5A==} - engines: {node: '>=14.0.0'} + '@rollup/rollup-linux-ppc64-gnu@4.56.0': + resolution: {integrity: sha512-iNFTluqgdoQC7AIE8Q34R3AuPrJGJirj5wMUErxj22deOcY7XwZRaqYmB6ZKFHoVGqRcRd0mqO+845jAibKCkw==} + cpu: [ppc64] + os: [linux] + libc: [glibc] - '@smithy/util-utf8@4.2.0': - resolution: {integrity: sha512-zBPfuzoI8xyBtR2P6WQj63Rz8i3AmfAaJLuNG8dWsfvPe8lO4aCPYLn879mEgHndZH1zQ2oXmG8O1GGzzaoZiw==} - engines: {node: '>=18.0.0'} + '@rollup/rollup-linux-ppc64-musl@4.56.0': + resolution: {integrity: sha512-MtMeFVlD2LIKjp2sE2xM2slq3Zxf9zwVuw0jemsxvh1QOpHSsSzfNOTH9uYW9i1MXFxUSMmLpeVeUzoNOKBaWg==} + cpu: [ppc64] + os: [linux] + libc: [musl] - '@smithy/util-waiter@4.2.8': - resolution: {integrity: sha512-n+lahlMWk+aejGuax7DPWtqav8HYnWxQwR+LCG2BgCUmaGcTe9qZCFsmw8TMg9iG75HOwhrJCX9TCJRLH+Yzqg==} - engines: {node: '>=18.0.0'} + '@rollup/rollup-linux-riscv64-gnu@4.56.0': + resolution: {integrity: sha512-in+v6wiHdzzVhYKXIk5U74dEZHdKN9KH0Q4ANHOTvyXPG41bajYRsy7a8TPKbYPl34hU7PP7hMVHRvv/5aCSew==} + cpu: [riscv64] + os: [linux] + libc: [glibc] - '@smithy/uuid@1.1.0': - resolution: {integrity: sha512-4aUIteuyxtBUhVdiQqcDhKFitwfd9hqoSDYY2KRXiWtgoWJ9Bmise+KfEPDiVHWeJepvF8xJO9/9+WDIciMFFw==} - engines: {node: '>=18.0.0'} + '@rollup/rollup-linux-riscv64-musl@4.56.0': + resolution: {integrity: sha512-yni2raKHB8m9NQpI9fPVwN754mn6dHQSbDTwxdr9SE0ks38DTjLMMBjrwvB5+mXrX+C0npX0CVeCUcvvvD8CNQ==} + cpu: [riscv64] + os: [linux] + libc: [musl] - '@so-ric/colorspace@1.1.6': - resolution: {integrity: sha512-/KiKkpHNOBgkFJwu9sh48LkHSMYGyuTcSFK/qMBdnOAlrRJzRSXAOFB5qwzaVQuDl8wAvHVMkaASQDReTahxuw==} + '@rollup/rollup-linux-s390x-gnu@4.56.0': + resolution: {integrity: sha512-zhLLJx9nQPu7wezbxt2ut+CI4YlXi68ndEve16tPc/iwoylWS9B3FxpLS2PkmfYgDQtosah07Mj9E0khc3Y+vQ==} + cpu: [s390x] + os: [linux] + libc: [glibc] - '@standard-community/standard-json@0.3.5': - resolution: {integrity: sha512-4+ZPorwDRt47i+O7RjyuaxHRK/37QY/LmgxlGrRrSTLYoFatEOzvqIc85GTlM18SFZ5E91C+v0o/M37wZPpUHA==} - peerDependencies: - '@standard-schema/spec': ^1.0.0 - '@types/json-schema': ^7.0.15 - '@valibot/to-json-schema': ^1.3.0 - arktype: ^2.1.20 - effect: ^3.16.8 - quansync: ^0.2.11 - sury: ^10.0.0 - typebox: ^1.0.17 - valibot: ^1.1.0 - zod: ^3.25.0 || ^4.0.0 - zod-to-json-schema: ^3.24.5 - peerDependenciesMeta: - '@valibot/to-json-schema': - optional: true - arktype: - optional: true - effect: - optional: true - sury: - optional: true - typebox: - optional: true - valibot: - optional: true - zod: - optional: true - zod-to-json-schema: - optional: true + '@rollup/rollup-linux-x64-gnu@4.56.0': + resolution: {integrity: sha512-MVC6UDp16ZSH7x4rtuJPAEoE1RwS8N4oK9DLHy3FTEdFoUTCFVzMfJl/BVJ330C+hx8FfprA5Wqx4FhZXkj2Kw==} + cpu: [x64] + os: [linux] + libc: [glibc] - '@standard-community/standard-openapi@0.2.9': - resolution: {integrity: sha512-htj+yldvN1XncyZi4rehbf9kLbu8os2Ke/rfqoZHCMHuw34kiF3LP/yQPdA0tQ940y8nDq3Iou8R3wG+AGGyvg==} - peerDependencies: - '@standard-community/standard-json': ^0.3.5 - '@standard-schema/spec': ^1.0.0 - arktype: ^2.1.20 - effect: ^3.17.14 - openapi-types: ^12.1.3 - sury: ^10.0.0 - typebox: ^1.0.0 - valibot: ^1.1.0 - zod: ^3.25.0 || ^4.0.0 - zod-openapi: ^4 - peerDependenciesMeta: - arktype: - optional: true - effect: - optional: true - sury: - optional: true - typebox: - optional: true - valibot: - optional: true - zod: - optional: true - zod-openapi: - optional: true + '@rollup/rollup-linux-x64-musl@4.56.0': + resolution: {integrity: sha512-ZhGH1eA4Qv0lxaV00azCIS1ChedK0V32952Md3FtnxSqZTBTd6tgil4nZT5cU8B+SIw3PFYkvyR4FKo2oyZIHA==} + cpu: [x64] + os: [linux] + libc: [musl] - '@standard-schema/spec@1.1.0': - resolution: {integrity: sha512-l2aFy5jALhniG5HgqrD6jXLi/rUWrKvqN/qJx6yoJsgKhblVd+iqqU4RCXavm/jPityDo5TCvKMnpjKnOriy0w==} + '@rollup/rollup-openbsd-x64@4.56.0': + resolution: {integrity: sha512-O16XcmyDeFI9879pEcmtWvD/2nyxR9mF7Gs44lf1vGGx8Vg2DRNx11aVXBEqOQhWb92WN4z7fW/q4+2NYzCbBA==} + cpu: [x64] + os: [openbsd] - '@strands-agents/sdk@0.1.6': - resolution: {integrity: sha512-nQl1WlCSGYjcpo/dkZU5v/0gaLaAwNW4oPJm2N6gqvTXsaUO33COYqQb80fgdF57xw38K+a6OYmdmA4CGXqrdw==} - engines: {node: '>=20.0.0'} + '@rollup/rollup-openharmony-arm64@4.56.0': + resolution: {integrity: sha512-LhN/Reh+7F3RCgQIRbgw8ZMwUwyqJM+8pXNT6IIJAqm2IdKkzpCh/V9EdgOMBKuebIrzswqy4ATlrDgiOwbRcQ==} + cpu: [arm64] + os: [openharmony] - '@streamparser/json@0.0.22': - resolution: {integrity: sha512-b6gTSBjJ8G8SuO3Gbbj+zXbVx8NSs1EbpbMKpzGLWMdkR+98McH9bEjSz3+0mPJf68c5nxa3CrJHp5EQNXM6zQ==} + '@rollup/rollup-win32-arm64-msvc@4.56.0': + resolution: {integrity: sha512-kbFsOObXp3LBULg1d3JIUQMa9Kv4UitDmpS+k0tinPBz3watcUiV2/LUDMMucA6pZO3WGE27P7DsfaN54l9ing==} + cpu: [arm64] + os: [win32] - '@swc/helpers@0.5.18': - resolution: {integrity: sha512-TXTnIcNJQEKwThMMqBXsZ4VGAza6bvN4pa41Rkqoio6QBKMvo+5lexeTMScGCIxtzgQJzElcvIltani+adC5PQ==} + '@rollup/rollup-win32-ia32-msvc@4.56.0': + resolution: {integrity: sha512-vSSgny54D6P4vf2izbtFm/TcWYedw7f8eBrOiGGecyHyQB9q4Kqentjaj8hToe+995nob/Wv48pDqL5a62EWtg==} + cpu: [ia32] + os: [win32] - '@tootallnate/once@2.0.0': - resolution: {integrity: sha512-XCuKFP5PS55gnMVu3dty8KPatLqUoy/ZYzDzAGCQ8JNFCkLXzmI7vNHCR+XpbZaMWQK/vQubr7PkYq8g470J/A==} - engines: {node: '>= 10'} + '@rollup/rollup-win32-x64-gnu@4.56.0': + resolution: {integrity: sha512-FeCnkPCTHQJFbiGG49KjV5YGW/8b9rrXAM2Mz2kiIoktq2qsJxRD5giEMEOD2lPdgs72upzefaUvS+nc8E3UzQ==} + cpu: [x64] + os: [win32] - '@tsconfig/node10@1.0.11': - resolution: {integrity: sha512-DcRjDCujK/kCk/cUe8Xz8ZSpm8mS3mNNpta+jGCA6USEDfktlNvm1+IuZ9eTcDbNk41BHwpHHeW+N1lKCz4zOw==} + '@rollup/rollup-win32-x64-msvc@4.56.0': + resolution: {integrity: sha512-H8AE9Ur/t0+1VXujj90w0HrSOuv0Nq9r1vSZF2t5km20NTfosQsGGUXDaKdQZzwuLts7IyL1fYT4hM95TI9c4g==} + cpu: [x64] + os: [win32] - '@tsconfig/node12@1.0.11': - resolution: {integrity: sha512-cqefuRsh12pWyGsIoBKJA9luFu3mRxCA+ORZvA4ktLSzIuCUtWVxGIuXigEwO5/ywWFMZ2QEGKWvkZG1zDMTag==} + '@sec-ant/readable-stream@0.4.1': + resolution: {integrity: sha512-831qok9r2t8AlxLko40y2ebgSDhenenCatLVeW/uBtnHPyhHOvG0C7TvfgecV+wHzIm5KUICgzmVpWS+IMEAeg==} - '@tsconfig/node14@1.0.3': - resolution: {integrity: sha512-ysT8mhdixWK6Hw3i1V2AeRqZ5WfXg1G43mqoYlM2nc6388Fq5jcXyr5mRsqViLx/GJYdoL0bfXD8nmF+Zn/Iow==} + '@selderee/plugin-htmlparser2@0.11.0': + resolution: {integrity: sha512-P33hHGdldxGabLFjPPpaTxVolMrzrcegejx+0GxjrIb9Zv48D8yAIA/QTDR2dFl7Uz7urX8aX6+5bCZslr+gWQ==} - '@tsconfig/node16@1.0.4': - resolution: {integrity: sha512-vxhUy4J8lyeyinH7Azl1pdd43GJhZH/tP2weN8TntQblOY+A0XbT8DJk1/oCPuOOyg/Ja757rG0CgHcWC8OfMA==} + '@sinclair/typebox@0.27.8': + resolution: {integrity: sha512-+Fj43pSMwJs4KRrH/938Uf+uAELIgVBmQzg/q1YG10djyfA3TnrU8N8XzqCh/okZdszqBQTZf96idMfE5lnwTA==} - '@types/babel__core@7.20.5': - resolution: {integrity: sha512-qoQprZvz5wQFJwMDqeseRXWv3rqMvhgpbXFfVyWhbx9X47POIA6i/+dXefEmZKoAgOaTdaIgNSMqMIU61yRyzA==} + '@sindresorhus/is@4.6.0': + resolution: {integrity: sha512-t09vSN3MdfsyCHoFcTRCH/iUtG7OJ0CsjzB8cjAmKc/va/kIgeDI/TxsigdncE/4be734m0cvIYwNaV4i2XqAw==} + engines: {node: '>=10'} - '@types/babel__generator@7.27.0': - resolution: {integrity: sha512-ufFd2Xi92OAVPYsy+P4n7/U7e68fex0+Ee8gSG9KX7eo084CWiQ4sdxktvdl0bOPupXtVJPY19zk6EwWqUQ8lg==} + '@sindresorhus/merge-streams@4.0.0': + resolution: {integrity: sha512-tlqY9xq5ukxTUZBmoOp+m61cqwQD5pHJtFY3Mn8CA8ps6yghLH/Hw8UPdqg4OLmFW3IFlcXnQNmo/dh8HzXYIQ==} + engines: {node: '>=18'} - '@types/babel__template@7.4.4': - resolution: {integrity: sha512-h/NUaSyG5EyxBIp8YRxo4RMe2/qQgvyowRwVMzhYhBCONbW8PUsg4lkFMrhgZhUe5z3L3MiLDuvyJ/CaPa2A8A==} + '@sindresorhus/slugify@2.2.1': + resolution: {integrity: sha512-MkngSCRZ8JdSOCHRaYd+D01XhvU3Hjy6MGl06zhOk614hp9EOAp5gIkBeQg7wtmxpitU6eAL4kdiRMcJa2dlrw==} + engines: {node: '>=12'} - '@types/babel__traverse@7.20.7': - resolution: {integrity: sha512-dkO5fhS7+/oos4ciWxyEyjWe48zmG6wbCheo/G2ZnHx4fs3EU6YC6UM8rk56gAjNJ9P3MTH2jo5jb92/K6wbng==} + '@sindresorhus/transliterate@1.6.0': + resolution: {integrity: sha512-doH1gimEu3A46VX6aVxpHTeHrytJAG6HgdxntYnCFiIFHEM/ZGpG8KiZGBChchjQmG0XFIBL552kBTjVcMZXwQ==} + engines: {node: '>=12'} - '@types/body-parser@1.19.6': - resolution: {integrity: sha512-HLFeCYgz89uk22N5Qg3dvGvsv46B8GLvKKo1zKG4NybA8U2DiEO3w9lqGg29t/tfLRJpJ6iQxnVw4OnB7MoM9g==} + '@sinonjs/commons@3.0.1': + resolution: {integrity: sha512-K3mCHKQ9sVh8o1C9cxkwxaOmXoAMlDxC1mYyHrjqOWEcBjYr76t96zL2zlj5dUGZ3HSw240X1qgH3Mjf1yJWpQ==} - '@types/caseless@0.12.5': - resolution: {integrity: sha512-hWtVTC2q7hc7xZ/RLbxapMvDMgUnDvKvMOpKal4DrMyfGBUfB1oKaZlIRr6mJL+If3bAP6sV/QneGzF6tJjZDg==} + '@sinonjs/fake-timers@10.3.0': + resolution: {integrity: sha512-V4BG07kuYSUkTCSBHG8G8TNhM+F19jXFWnQtzj+we8DrkpSBCee9Z3Ms8yiGer/dlmhe35/Xdgyo3/0rQKg7YA==} - '@types/chai@5.2.3': - resolution: {integrity: sha512-Mw558oeA9fFbv65/y4mHtXDs9bPnFMZAL/jxdPFUpOHHIXX91mcgEHbS5Lahr+pwZFR8A7GQleRWeI6cGFC2UA==} + '@smithy/abort-controller@4.2.8': + resolution: {integrity: sha512-peuVfkYHAmS5ybKxWcfraK7WBBP0J+rkfUcbHJJKQ4ir3UAUNQI+Y4Vt/PqSzGqgloJ5O1dk7+WzNL8wcCSXbw==} + engines: {node: '>=18.0.0'} - '@types/command-line-args@5.2.3': - resolution: {integrity: sha512-uv0aG6R0Y8WHZLTamZwtfsDLVRnOa+n+n5rEvFWL5Na5gZ8V2Teab/duDPFzIIIhs9qizDpcavCusCLJZu62Kw==} + '@smithy/config-resolver@4.4.6': + resolution: {integrity: sha512-qJpzYC64kaj3S0fueiu3kXm8xPrR3PcXDPEgnaNMRn0EjNSZFoFjvbUp0YUDsRhN1CB90EnHJtbxWKevnH99UQ==} + engines: {node: '>=18.0.0'} - '@types/command-line-usage@5.0.4': - resolution: {integrity: sha512-BwR5KP3Es/CSht0xqBcUXS3qCAUVXwpRKsV2+arxeb65atasuXG9LykC9Ab10Cw3s2raH92ZqOeILaQbsB2ACg==} + '@smithy/core@3.21.1': + resolution: {integrity: sha512-NUH8R4O6FkN8HKMojzbGg/5pNjsfTjlMmeFclyPfPaXXUrbr5TzhWgbf7t92wfrpCHRgpjyz7ffASIS3wX28aA==} + engines: {node: '>=18.0.0'} - '@types/connect@3.4.38': - resolution: {integrity: sha512-K6uROf1LD88uDQqJCktA4yzL1YYAK6NgfsI0v/mTgyPKWsX1CnJ0XPSDhViejru1GcRkLWb8RlzFYJRqGUbaug==} + '@smithy/credential-provider-imds@4.2.8': + resolution: {integrity: sha512-FNT0xHS1c/CPN8upqbMFP83+ul5YgdisfCfkZ86Jh2NSmnqw/AJ6x5pEogVCTVvSm7j9MopRU89bmDelxuDMYw==} + engines: {node: '>=18.0.0'} - '@types/debug@4.1.13': - resolution: {integrity: sha512-KSVgmQmzMwPlmtljOomayoR89W4FynCAi3E8PPs7vmDVPe84hT+vGPKkJfThkmXs0x0jAaa9U8uW8bbfyS2fWw==} + '@smithy/eventstream-codec@4.2.8': + resolution: {integrity: sha512-jS/O5Q14UsufqoGhov7dHLOPCzkYJl9QDzusI2Psh4wyYx/izhzvX9P4D69aTxcdfVhEPhjK+wYyn/PzLjKbbw==} + engines: {node: '>=18.0.0'} - '@types/deep-eql@4.0.2': - resolution: {integrity: sha512-c9h9dVVMigMPc4bwTvC5dxqtqJZwQPePsWjPlpSOnojbor6pGqdk541lfA7AqFQr5pB1BRdq0juY9db81BwyFw==} + '@smithy/eventstream-serde-browser@4.2.8': + resolution: {integrity: sha512-MTfQT/CRQz5g24ayXdjg53V0mhucZth4PESoA5IhvaWVDTOQLfo8qI9vzqHcPsdd2v6sqfTYqF5L/l+pea5Uyw==} + engines: {node: '>=18.0.0'} - '@types/dom-mediacapture-record@1.0.22': - resolution: {integrity: sha512-mUMZLK3NvwRLcAAT9qmcK+9p7tpU2FHdDsntR3YI4+GY88XrgG4XiE7u1Q2LAN2/FZOz/tdMDC3GQCR4T8nFuw==} + '@smithy/eventstream-serde-config-resolver@4.3.8': + resolution: {integrity: sha512-ah12+luBiDGzBruhu3efNy1IlbwSEdNiw8fOZksoKoWW1ZHvO/04MQsdnws/9Aj+5b0YXSSN2JXKy/ClIsW8MQ==} + engines: {node: '>=18.0.0'} - '@types/estree@1.0.8': - resolution: {integrity: sha512-dWHzHa2WqEXI/O1E9OjrocMTKJl2mSrEolh1Iomrv6U+JuNwaHXsXx9bLu5gG7BUWFIN0skIQJQ/L1rIex4X6w==} + '@smithy/eventstream-serde-node@4.2.8': + resolution: {integrity: sha512-cYpCpp29z6EJHa5T9WL0KAlq3SOKUQkcgSoeRfRVwjGgSFl7Uh32eYGt7IDYCX20skiEdRffyDpvF2efEZPC0A==} + engines: {node: '>=18.0.0'} - '@types/events@3.0.3': - resolution: {integrity: sha512-trOc4AAUThEz9hapPtSd7wf5tiQKvTtu5b371UxXdTuqzIh0ArcRspRP0i0Viu+LXstIQ1z96t1nsPxT9ol01g==} + '@smithy/eventstream-serde-universal@4.2.8': + resolution: {integrity: sha512-iJ6YNJd0bntJYnX6s52NC4WFYcZeKrPUr1Kmmr5AwZcwCSzVpS7oavAmxMR7pMq7V+D1G4s9F5NJK0xwOsKAlQ==} + engines: {node: '>=18.0.0'} - '@types/express-serve-static-core@5.1.1': - resolution: {integrity: sha512-v4zIMr/cX7/d2BpAEX3KNKL/JrT1s43s96lLvvdTmza1oEvDudCqK9aF/djc/SWgy8Yh0h30TZx5VpzqFCxk5A==} + '@smithy/fetch-http-handler@5.3.9': + resolution: {integrity: sha512-I4UhmcTYXBrct03rwzQX1Y/iqQlzVQaPxWjCjula++5EmWq9YGBrx6bbGqluGc1f0XEfhSkiY4jhLgbsJUMKRA==} + engines: {node: '>=18.0.0'} - '@types/express@5.0.6': - resolution: {integrity: sha512-sKYVuV7Sv9fbPIt/442koC7+IIwK5olP1KWeD88e/idgoJqDm3JV/YUiPwkoKK92ylff2MGxSz1CSjsXelx0YA==} + '@smithy/hash-node@4.2.8': + resolution: {integrity: sha512-7ZIlPbmaDGxVoxErDZnuFG18WekhbA/g2/i97wGj+wUBeS6pcUeAym8u4BXh/75RXWhgIJhyC11hBzig6MljwA==} + engines: {node: '>=18.0.0'} - '@types/google-protobuf@3.15.12': - resolution: {integrity: sha512-40um9QqwHjRS92qnOaDpL7RmDK15NuZYo9HihiJRbYkMQZlWnuH8AdvbMy8/o6lgLmKbDUKa+OALCltHdbOTpQ==} + '@smithy/invalid-dependency@4.2.8': + resolution: {integrity: sha512-N9iozRybwAQ2dn9Fot9kI6/w9vos2oTXLhtK7ovGqwZjlOcxu6XhPlpLpC+INsxktqHinn5gS2DXDjDF2kG5sQ==} + engines: {node: '>=18.0.0'} - '@types/graceful-fs@4.1.9': - resolution: {integrity: sha512-olP3sd1qOEe5dXTSaFvQG+02VdRXcdytWLAZsAq1PecU8uqQAhkrnbli7DagjtXKW/Bl7YJbUsa8MPcuc8LHEQ==} + '@smithy/is-array-buffer@2.2.0': + resolution: {integrity: sha512-GGP3O9QFD24uGeAXYUjwSTXARoqpZykHadOmA8G5vfJPK0/DC67qa//0qvqrJzL1xc8WQWX7/yc7fwudjPHPhA==} + engines: {node: '>=14.0.0'} - '@types/http-errors@2.0.5': - resolution: {integrity: sha512-r8Tayk8HJnX0FztbZN7oVqGccWgw98T/0neJphO91KkmOzug1KkofZURD4UaD5uH8AqcFLfdPErnBod0u71/qg==} + '@smithy/is-array-buffer@4.2.0': + resolution: {integrity: sha512-DZZZBvC7sjcYh4MazJSGiWMI2L7E0oCiRHREDzIxi/M2LY79/21iXt6aPLHge82wi5LsuRF5A06Ds3+0mlh6CQ==} + engines: {node: '>=18.0.0'} - '@types/istanbul-lib-coverage@2.0.6': - resolution: {integrity: sha512-2QF/t/auWm0lsy8XtKVPG19v3sSOQlJe/YHZgfjb/KBBHOGSV+J2q/S671rcq9uTBrLAXmZpqJiaQbMT+zNU1w==} + '@smithy/middleware-content-length@4.2.8': + resolution: {integrity: sha512-RO0jeoaYAB1qBRhfVyq0pMgBoUK34YEJxVxyjOWYZiOKOq2yMZ4MnVXMZCUDenpozHue207+9P5ilTV1zeda0A==} + engines: {node: '>=18.0.0'} - '@types/istanbul-lib-report@3.0.3': - resolution: {integrity: sha512-NQn7AHQnk/RSLOxrBbGyJM/aVQ+pjj5HCgasFxc0K/KhoATfQ/47AyUl15I2yBUpihjmas+a+VJBOqecrFH+uA==} + '@smithy/middleware-endpoint@4.4.11': + resolution: {integrity: sha512-/WqsrycweGGfb9sSzME4CrsuayjJF6BueBmkKlcbeU5q18OhxRrvvKlmfw3tpDsK5ilx2XUJvoukwxHB0nHs/Q==} + engines: {node: '>=18.0.0'} - '@types/istanbul-reports@3.0.4': - resolution: {integrity: sha512-pk2B1NWalF9toCRu6gjBzR69syFjP4Od8WRAX+0mmf9lAjCRicLOWc+ZrxZHx/0XRjotgkF9t6iaMJ+aXcOdZQ==} + '@smithy/middleware-retry@4.4.27': + resolution: {integrity: sha512-xFUYCGRVsfgiN5EjsJJSzih9+yjStgMTCLANPlf0LVQkPDYCe0hz97qbdTZosFOiYlGBlHYityGRxrQ/hxhfVQ==} + engines: {node: '>=18.0.0'} - '@types/jest@29.5.14': - resolution: {integrity: sha512-ZN+4sdnLUbo8EVvVc2ao0GFW6oVrQRPn4K2lglySj7APvSrgzxHiNNK99us4WDMi57xxA2yggblIAMNhXOotLQ==} + '@smithy/middleware-serde@4.2.9': + resolution: {integrity: sha512-eMNiej0u/snzDvlqRGSN3Vl0ESn3838+nKyVfF2FKNXFbi4SERYT6PR392D39iczngbqqGG0Jl1DlCnp7tBbXQ==} + engines: {node: '>=18.0.0'} - '@types/json-schema@7.0.15': - resolution: {integrity: sha512-5+fP8P8MFNC+AyZCDxrB2pkZFPGzqQWUzpSeuuVLvm8VMcorNYavBqoFcxK8bQz4Qsbn4oUEEem4wDLfcysGHA==} + '@smithy/middleware-stack@4.2.8': + resolution: {integrity: sha512-w6LCfOviTYQjBctOKSwy6A8FIkQy7ICvglrZFl6Bw4FmcQ1Z420fUtIhxaUZZshRe0VCq4kvDiPiXrPZAe8oRA==} + engines: {node: '>=18.0.0'} - '@types/lodash-es@4.17.12': - resolution: {integrity: sha512-0NgftHUcV4v34VhXm8QBSftKVXtbkBG3ViCjs6+eJ5a6y6Mi/jiFGPc1sC7QK+9BFhWrURE3EOggmWaSxL9OzQ==} + '@smithy/node-config-provider@4.3.8': + resolution: {integrity: sha512-aFP1ai4lrbVlWjfpAfRSL8KFcnJQYfTl5QxLJXY32vghJrDuFyPZ6LtUL+JEGYiFRG1PfPLHLoxj107ulncLIg==} + engines: {node: '>=18.0.0'} - '@types/lodash@4.17.23': - resolution: {integrity: sha512-RDvF6wTulMPjrNdCoYRC8gNR880JNGT8uB+REUpC2Ns4pRqQJhGz90wh7rgdXDPpCczF3VGktDuFGVnz8zP7HA==} + '@smithy/node-http-handler@4.4.8': + resolution: {integrity: sha512-q9u+MSbJVIJ1QmJ4+1u+cERXkrhuILCBDsJUBAW1MPE6sFonbCNaegFuwW9ll8kh5UdyY3jOkoOGlc7BesoLpg==} + engines: {node: '>=18.0.0'} - '@types/mdast@4.0.4': - resolution: {integrity: sha512-kGaNbPh1k7AFzgpud/gMdvIm5xuECykRR+JnWKQno9TAXVa6WIVCGTPvYGekIDL4uwCZQSYbUxNBSb1aUo79oA==} + '@smithy/property-provider@4.2.8': + resolution: {integrity: sha512-EtCTbyIveCKeOXDSWSdze3k612yCPq1YbXsbqX3UHhkOSW8zKsM9NOJG5gTIya0vbY2DIaieG8pKo1rITHYL0w==} + engines: {node: '>=18.0.0'} - '@types/ms@2.1.0': - resolution: {integrity: sha512-GsCCIZDE/p3i96vtEqx+7dBUGXrc7zeSK3wwPHIaRThS+9OhWIXRqzs4d6k1SVU8g91DrNRWxWUGhp5KXQb2VA==} + '@smithy/protocol-http@5.3.8': + resolution: {integrity: sha512-QNINVDhxpZ5QnP3aviNHQFlRogQZDfYlCkQT+7tJnErPQbDhysondEjhikuANxgMsZrkGeiAxXy4jguEGsDrWQ==} + engines: {node: '>=18.0.0'} - '@types/node-fetch@2.6.12': - resolution: {integrity: sha512-8nneRWKCg3rMtF69nLQJnOYUcbafYeFSjqkw3jCRLsqkWFlHaoQrr5mXmofFGOx3DKn7UfmBMyov8ySvLRVldA==} + '@smithy/querystring-builder@4.2.8': + resolution: {integrity: sha512-Xr83r31+DrE8CP3MqPgMJl+pQlLLmOfiEUnoyAlGzzJIrEsbKsPy1hqH0qySaQm4oWrCBlUqRt+idEgunKB+iw==} + engines: {node: '>=18.0.0'} - '@types/node@18.19.100': - resolution: {integrity: sha512-ojmMP8SZBKprc3qGrGk8Ujpo80AXkrP7G2tOT4VWr5jlr5DHjsJF+emXJz+Wm0glmy4Js62oKMdZZ6B9Y+tEcA==} + '@smithy/querystring-parser@4.2.8': + resolution: {integrity: sha512-vUurovluVy50CUlazOiXkPq40KGvGWSdmusa3130MwrR1UNnNgKAlj58wlOe61XSHRpUfIIh6cE0zZ8mzKaDPA==} + engines: {node: '>=18.0.0'} - '@types/node@20.19.30': - resolution: {integrity: sha512-WJtwWJu7UdlvzEAUm484QNg5eAoq5QR08KDNx7g45Usrs2NtOPiX8ugDqmKdXkyL03rBqU5dYNYVQetEpBHq2g==} + '@smithy/service-error-classification@4.2.8': + resolution: {integrity: sha512-mZ5xddodpJhEt3RkCjbmUQuXUOaPNTkbMGR0bcS8FE0bJDLMZlhmpgrvPNCYglVw5rsYTpSnv19womw9WWXKQQ==} + engines: {node: '>=18.0.0'} - '@types/node@22.15.33': - resolution: {integrity: sha512-wzoocdnnpSxZ+6CjW4ADCK1jVmd1S/J3ArNWfn8FDDQtRm8dkDg7TA+mvek2wNrfCgwuZxqEOiB9B1XCJ6+dbw==} + '@smithy/shared-ini-file-loader@4.4.3': + resolution: {integrity: sha512-DfQjxXQnzC5UbCUPeC3Ie8u+rIWZTvuDPAGU/BxzrOGhRvgUanaP68kDZA+jaT3ZI+djOf+4dERGlm9mWfFDrg==} + engines: {node: '>=18.0.0'} - '@types/node@24.10.9': - resolution: {integrity: sha512-ne4A0IpG3+2ETuREInjPNhUGis1SFjv1d5asp8MzEAGtOZeTeHVDOYqOgqfhvseqg/iXty2hjBf1zAOb7RNiNw==} + '@smithy/signature-v4@5.3.8': + resolution: {integrity: sha512-6A4vdGj7qKNRF16UIcO8HhHjKW27thsxYci+5r/uVRkdcBEkOEiY8OMPuydLX4QHSrJqGHPJzPRwwVTqbLZJhg==} + engines: {node: '>=18.0.0'} - '@types/qs@6.14.0': - resolution: {integrity: sha512-eOunJqu0K1923aExK6y8p6fsihYEn/BYuQ4g0CxAAgFc4b/ZLN4CrsRZ55srTdqoiLzU2B2evC+apEIxprEzkQ==} + '@smithy/smithy-client@4.10.12': + resolution: {integrity: sha512-VKO/HKoQ5OrSHW6AJUmEnUKeXI1/5LfCwO9cwyao7CmLvGnZeM1i36Lyful3LK1XU7HwTVieTqO1y2C/6t3qtA==} + engines: {node: '>=18.0.0'} - '@types/range-parser@1.2.7': - resolution: {integrity: sha512-hKormJbkJqzQGhziax5PItDUTMAM9uE2XXQmM37dyd4hVM+5aVl7oVxMVUiVQn2oCQFN/LKCZdvSM0pFRqbSmQ==} + '@smithy/types@4.12.0': + resolution: {integrity: sha512-9YcuJVTOBDjg9LWo23Qp0lTQ3D7fQsQtwle0jVfpbUHy9qBwCEgKuVH4FqFB3VYu0nwdHKiEMA+oXz7oV8X1kw==} + engines: {node: '>=18.0.0'} - '@types/request@2.48.13': - resolution: {integrity: sha512-FGJ6udDNUCjd19pp0Q3iTiDkwhYup7J8hpMW9c4k53NrccQFFWKRho6hvtPPEhnXWKvukfwAlB6DbDz4yhH5Gg==} + '@smithy/url-parser@4.2.8': + resolution: {integrity: sha512-NQho9U68TGMEU639YkXnVMV3GEFFULmmaWdlu1E9qzyIePOHsoSnagTGSDv1Zi8DCNN6btxOSdgmy5E/hsZwhA==} + engines: {node: '>=18.0.0'} - '@types/retry@0.12.0': - resolution: {integrity: sha512-wWKOClTTiizcZhXnPY4wikVAwmdYHp8q6DmC+EJUzAMsycb7HB32Kh9RN4+0gExjmPmZSAQjgURXIGATPegAvA==} + '@smithy/util-base64@4.3.0': + resolution: {integrity: sha512-GkXZ59JfyxsIwNTWFnjmFEI8kZpRNIBfxKjv09+nkAWPt/4aGaEWMM04m4sxgNVWkbt2MdSvE3KF/PfX4nFedQ==} + engines: {node: '>=18.0.0'} - '@types/send@1.2.1': - resolution: {integrity: sha512-arsCikDvlU99zl1g69TcAB3mzZPpxgw0UQnaHeC1Nwb015xp8bknZv5rIfri9xTOcMuaVgvabfIRA7PSZVuZIQ==} + '@smithy/util-body-length-browser@4.2.0': + resolution: {integrity: sha512-Fkoh/I76szMKJnBXWPdFkQJl2r9SjPt3cMzLdOB6eJ4Pnpas8hVoWPYemX/peO0yrrvldgCUVJqOAjUrOLjbxg==} + engines: {node: '>=18.0.0'} - '@types/serve-static@2.2.0': - resolution: {integrity: sha512-8mam4H1NHLtu7nmtalF7eyBH14QyOASmcxHhSfEoRyr0nP/YdoesEtU+uSRvMe96TW/HPTtkoKqQLl53N7UXMQ==} + '@smithy/util-body-length-node@4.2.1': + resolution: {integrity: sha512-h53dz/pISVrVrfxV1iqXlx5pRg3V2YWFcSQyPyXZRrZoZj4R4DeWRDo1a7dd3CPTcFi3kE+98tuNyD2axyZReA==} + engines: {node: '>=18.0.0'} - '@types/shimmer@1.2.0': - resolution: {integrity: sha512-UE7oxhQLLd9gub6JKIAhDq06T0F6FnztwMNRvYgjeQSBeMc1ZG/tA47EwfduvkuQS8apbkM/lpLpWsaCeYsXVg==} + '@smithy/util-buffer-from@2.2.0': + resolution: {integrity: sha512-IJdWBbTcMQ6DA0gdNhh/BwrLkDR+ADW5Kr1aZmd4k3DIF6ezMV4R2NIAmT08wQJ3yUK82thHWmC/TnK/wpMMIA==} + engines: {node: '>=14.0.0'} - '@types/stack-utils@2.0.3': - resolution: {integrity: sha512-9aEbYZ3TbYMznPdcdr3SmIrLXwC/AKZXQeCf9Pgao5CKb8CyHuEX5jzWPTkvregvhRJHcpRO6BFoGW9ycaOkYw==} + '@smithy/util-buffer-from@4.2.0': + resolution: {integrity: sha512-kAY9hTKulTNevM2nlRtxAG2FQ3B2OR6QIrPY3zE5LqJy1oxzmgBGsHLWTcNhWXKchgA0WHW+mZkQrng/pgcCew==} + engines: {node: '>=18.0.0'} - '@types/tough-cookie@4.0.5': - resolution: {integrity: sha512-/Ad8+nIOV7Rl++6f1BdKxFSMgmoqEoYbHRpPcx3JEfv8VRsQe9Z4mCXeJBzxs7mbHY/XOZZuXlRNfhpVPbs6ZA==} + '@smithy/util-config-provider@4.2.0': + resolution: {integrity: sha512-YEjpl6XJ36FTKmD+kRJJWYvrHeUvm5ykaUS5xK+6oXffQPHeEM4/nXlZPe+Wu0lsgRUcNZiliYNh/y7q9c2y6Q==} + engines: {node: '>=18.0.0'} - '@types/triple-beam@1.3.5': - resolution: {integrity: sha512-6WaYesThRMCl19iryMYP7/x2OVgCtbIVflDGFpWnb9irXI3UjYE4AzmYuiUKY1AJstGijoY+MgUszMgRxIYTYw==} + '@smithy/util-defaults-mode-browser@4.3.26': + resolution: {integrity: sha512-vva0dzYUTgn7DdE0uaha10uEdAgmdLnNFowKFjpMm6p2R0XDk5FHPX3CBJLzWQkQXuEprsb0hGz9YwbicNWhjw==} + engines: {node: '>=18.0.0'} - '@types/unist@3.0.3': - resolution: {integrity: sha512-ko/gIFJRv177XgZsZcBwnqJN5x/Gien8qNOn0D5bQU/zAzVf9Zt3BlcUiLqhV9y4ARk0GbT3tnUiPNgnTXzc/Q==} + '@smithy/util-defaults-mode-node@4.2.29': + resolution: {integrity: sha512-c6D7IUBsZt/aNnTBHMTf+OVh+h/JcxUUgfTcIJaWRe6zhOum1X+pNKSZtZ+7fbOn5I99XVFtmrnXKv8yHHErTQ==} + engines: {node: '>=18.0.0'} - '@types/uuid@10.0.0': - resolution: {integrity: sha512-7gqG38EyHgyP1S+7+xomFtL+ZNHcKv6DwNaCZmJmo1vgMugyF3TCnXVg4t1uk89mLNwnLtnY3TpOpCOyp1/xHQ==} + '@smithy/util-endpoints@3.2.8': + resolution: {integrity: sha512-8JaVTn3pBDkhZgHQ8R0epwWt+BqPSLCjdjXXusK1onwJlRuN69fbvSK66aIKKO7SwVFM6x2J2ox5X8pOaWcUEw==} + engines: {node: '>=18.0.0'} - '@types/webidl-conversions@7.0.3': - resolution: {integrity: sha512-CiJJvcRtIgzadHCYXw7dqEnMNRjhGZlYK05Mj9OyktqV8uVT8fD2BFOB7S1uwBE3Kj2Z+4UyPmFw/Ixgw/LAlA==} + '@smithy/util-hex-encoding@4.2.0': + resolution: {integrity: sha512-CCQBwJIvXMLKxVbO88IukazJD9a4kQ9ZN7/UMGBjBcJYvatpWk+9g870El4cB8/EJxfe+k+y0GmR9CAzkF+Nbw==} + engines: {node: '>=18.0.0'} - '@types/whatwg-url@11.0.5': - resolution: {integrity: sha512-coYR071JRaHa+xoEvvYqvnIHaVqaYrLPbsufM9BF63HkwI5Lgmy2QR8Q5K/lYDYo5AK82wOvSOS0UsLTpTG7uQ==} + '@smithy/util-middleware@4.2.8': + resolution: {integrity: sha512-PMqfeJxLcNPMDgvPbbLl/2Vpin+luxqTGPpW3NAQVLbRrFRzTa4rNAASYeIGjRV9Ytuhzny39SpyU04EQreF+A==} + engines: {node: '>=18.0.0'} - '@types/ws@8.18.1': - resolution: {integrity: sha512-ThVF6DCVhA8kUGy+aazFQ4kXQ7E1Ty7A3ypFOe0IcJV8O/M511G99AW24irKrW56Wt44yG9+ij8FaqoBGkuBXg==} + '@smithy/util-retry@4.2.8': + resolution: {integrity: sha512-CfJqwvoRY0kTGe5AkQokpURNCT1u/MkRzMTASWMPPo2hNSnKtF1D45dQl3DE2LKLr4m+PW9mCeBMJr5mCAVThg==} + engines: {node: '>=18.0.0'} - '@types/yargs-parser@21.0.3': - resolution: {integrity: sha512-I4q9QU9MQv4oEOz4tAHJtNz1cwuLxn2F3xcc2iV5WdqLPpUnj30aUuxt1mAxYTG+oe8CZMV/+6rU4S4gRDzqtQ==} + '@smithy/util-stream@4.5.10': + resolution: {integrity: sha512-jbqemy51UFSZSp2y0ZmRfckmrzuKww95zT9BYMmuJ8v3altGcqjwoV1tzpOwuHaKrwQrCjIzOib499ymr2f98g==} + engines: {node: '>=18.0.0'} - '@types/yargs@17.0.33': - resolution: {integrity: sha512-WpxBCKWPLr4xSsHgz511rFJAM+wS28w2zEO1QDNY5zM/S8ok70NNfztH0xwhqKyaK0OHCbN98LDAZuy1ctxDkA==} + '@smithy/util-uri-escape@4.2.0': + resolution: {integrity: sha512-igZpCKV9+E/Mzrpq6YacdTQ0qTiLm85gD6N/IrmyDvQFA4UnU3d5g3m8tMT/6zG/vVkWSU+VxeUyGonL62DuxA==} + engines: {node: '>=18.0.0'} - '@typescript/vfs@1.6.2': - resolution: {integrity: sha512-hoBwJwcbKHmvd2QVebiytN1aELvpk9B74B4L1mFm/XT1Q/VOYAWl2vQ9AWRFtQq8zmz6enTpfTV8WRc4ATjW/g==} - peerDependencies: - typescript: '*' + '@smithy/util-utf8@2.3.0': + resolution: {integrity: sha512-R8Rdn8Hy72KKcebgLiv8jQcQkXoLMOGGv5uI1/k0l+snqkOzQ1R0ChUBCxWMlBsFMekWjq0wRudIweFs7sKT5A==} + engines: {node: '>=14.0.0'} - '@vercel/oidc@3.1.0': - resolution: {integrity: sha512-Fw28YZpRnA3cAHHDlkt7xQHiJ0fcL+NRcIqsocZQUSmbzeIKRpwttJjik5ZGanXP+vlA4SbTg+AbA3bP363l+w==} - engines: {node: '>= 20'} + '@smithy/util-utf8@4.2.0': + resolution: {integrity: sha512-zBPfuzoI8xyBtR2P6WQj63Rz8i3AmfAaJLuNG8dWsfvPe8lO4aCPYLn879mEgHndZH1zQ2oXmG8O1GGzzaoZiw==} + engines: {node: '>=18.0.0'} - '@vitest/expect@3.2.4': - resolution: {integrity: sha512-Io0yyORnB6sikFlt8QW5K7slY4OjqNX9jmJQ02QDda8lyM6B5oNgVWoSoKPac8/kgnCUzuHQKrSLtu/uOqqrig==} + '@smithy/util-waiter@4.2.8': + resolution: {integrity: sha512-n+lahlMWk+aejGuax7DPWtqav8HYnWxQwR+LCG2BgCUmaGcTe9qZCFsmw8TMg9iG75HOwhrJCX9TCJRLH+Yzqg==} + engines: {node: '>=18.0.0'} - '@vitest/mocker@3.2.4': - resolution: {integrity: sha512-46ryTE9RZO/rfDd7pEqFl7etuyzekzEhUbTW3BvmeO/BcCMEgq59BKhek3dXDWgAj4oMK6OZi+vRr1wPW6qjEQ==} - peerDependencies: - msw: ^2.4.9 - vite: ^5.0.0 || ^6.0.0 || ^7.0.0-0 - peerDependenciesMeta: - msw: - optional: true - vite: - optional: true + '@smithy/uuid@1.1.0': + resolution: {integrity: sha512-4aUIteuyxtBUhVdiQqcDhKFitwfd9hqoSDYY2KRXiWtgoWJ9Bmise+KfEPDiVHWeJepvF8xJO9/9+WDIciMFFw==} + engines: {node: '>=18.0.0'} - '@vitest/pretty-format@3.2.4': - resolution: {integrity: sha512-IVNZik8IVRJRTr9fxlitMKeJeXFFFN0JaB9PHPGQ8NKQbGpfjlTx9zO4RefN8gp7eqjNy8nyK3NZmBzOPeIxtA==} + '@so-ric/colorspace@1.1.6': + resolution: {integrity: sha512-/KiKkpHNOBgkFJwu9sh48LkHSMYGyuTcSFK/qMBdnOAlrRJzRSXAOFB5qwzaVQuDl8wAvHVMkaASQDReTahxuw==} - '@vitest/runner@3.2.4': - resolution: {integrity: sha512-oukfKT9Mk41LreEW09vt45f8wx7DordoWUZMYdY/cyAk7w5TWkTRCNZYF7sX7n2wB7jyGAl74OxgwhPgKaqDMQ==} + '@standard-community/standard-json@0.3.5': + resolution: {integrity: sha512-4+ZPorwDRt47i+O7RjyuaxHRK/37QY/LmgxlGrRrSTLYoFatEOzvqIc85GTlM18SFZ5E91C+v0o/M37wZPpUHA==} + peerDependencies: + '@standard-schema/spec': ^1.0.0 + '@types/json-schema': ^7.0.15 + '@valibot/to-json-schema': ^1.3.0 + arktype: ^2.1.20 + effect: ^3.16.8 + quansync: ^0.2.11 + sury: ^10.0.0 + typebox: ^1.0.17 + valibot: ^1.1.0 + zod: ^3.25.0 || ^4.0.0 + zod-to-json-schema: ^3.24.5 + peerDependenciesMeta: + '@valibot/to-json-schema': + optional: true + arktype: + optional: true + effect: + optional: true + sury: + optional: true + typebox: + optional: true + valibot: + optional: true + zod: + optional: true + zod-to-json-schema: + optional: true - '@vitest/snapshot@3.2.4': - resolution: {integrity: sha512-dEYtS7qQP2CjU27QBC5oUOxLE/v5eLkGqPE0ZKEIDGMs4vKWe7IjgLOeauHsR0D5YuuycGRO5oSRXnwnmA78fQ==} + '@standard-community/standard-openapi@0.2.9': + resolution: {integrity: sha512-htj+yldvN1XncyZi4rehbf9kLbu8os2Ke/rfqoZHCMHuw34kiF3LP/yQPdA0tQ940y8nDq3Iou8R3wG+AGGyvg==} + peerDependencies: + '@standard-community/standard-json': ^0.3.5 + '@standard-schema/spec': ^1.0.0 + arktype: ^2.1.20 + effect: ^3.17.14 + openapi-types: ^12.1.3 + sury: ^10.0.0 + typebox: ^1.0.0 + valibot: ^1.1.0 + zod: ^3.25.0 || ^4.0.0 + zod-openapi: ^4 + peerDependenciesMeta: + arktype: + optional: true + effect: + optional: true + sury: + optional: true + typebox: + optional: true + valibot: + optional: true + zod: + optional: true + zod-openapi: + optional: true - '@vitest/spy@3.2.4': - resolution: {integrity: sha512-vAfasCOe6AIK70iP5UD11Ac4siNUNJ9i/9PZ3NKx07sG6sUxeag1LWdNrMWeKKYBLlzuK+Gn65Yd5nyL6ds+nw==} + '@standard-schema/spec@1.1.0': + resolution: {integrity: sha512-l2aFy5jALhniG5HgqrD6jXLi/rUWrKvqN/qJx6yoJsgKhblVd+iqqU4RCXavm/jPityDo5TCvKMnpjKnOriy0w==} - '@vitest/utils@3.2.4': - resolution: {integrity: sha512-fB2V0JFrQSMsCo9HiSq3Ezpdv4iYaXRG1Sx8edX3MwxfyNn83mKiGzOcH+Fkxt4MHxr3y42fQi1oeAInqgX2QA==} + '@strands-agents/sdk@0.1.6': + resolution: {integrity: sha512-nQl1WlCSGYjcpo/dkZU5v/0gaLaAwNW4oPJm2N6gqvTXsaUO33COYqQb80fgdF57xw38K+a6OYmdmA4CGXqrdw==} + engines: {node: '>=20.0.0'} - '@workflow/serde@4.1.0-beta.2': - resolution: {integrity: sha512-8kkeoQKLDaKXefjV5dbhBj2aErfKp1Mc4pb6tj8144cF+Em5SPbyMbyLCHp+BVrFfFVCBluCtMx+jjvaFVZGww==} + '@streamparser/json@0.0.22': + resolution: {integrity: sha512-b6gTSBjJ8G8SuO3Gbbj+zXbVx8NSs1EbpbMKpzGLWMdkR+98McH9bEjSz3+0mPJf68c5nxa3CrJHp5EQNXM6zQ==} - '@zilliz/milvus2-sdk-node@2.6.9': - resolution: {integrity: sha512-qOaVIpQ3E4w6Dp4lp9QIIuGedpE5dWRhK9SRX+y9WXcq4EXYvcdfR2aG/Vb5tWBPQwcMrGb5z8gRfFy7/gRbIw==} + '@swc/helpers@0.5.18': + resolution: {integrity: sha512-TXTnIcNJQEKwThMMqBXsZ4VGAza6bvN4pa41Rkqoio6QBKMvo+5lexeTMScGCIxtzgQJzElcvIltani+adC5PQ==} - abort-controller-x@0.4.3: - resolution: {integrity: sha512-VtUwTNU8fpMwvWGn4xE93ywbogTYsuT+AUxAXOeelbXuQVIwNmC5YLeho9sH4vZ4ITW8414TTAOG1nW6uIVHCA==} + '@tootallnate/once@2.0.0': + resolution: {integrity: sha512-XCuKFP5PS55gnMVu3dty8KPatLqUoy/ZYzDzAGCQ8JNFCkLXzmI7vNHCR+XpbZaMWQK/vQubr7PkYq8g470J/A==} + engines: {node: '>= 10'} - abort-controller-x@0.5.0: - resolution: {integrity: sha512-yTt9CI0x+nRfX6BFMenEGP8ooPvErGH6AbFz20C2IeOLIlDsrw/VHpgne3GsCEuTA410IiFiaLVFKmgM4bKEPQ==} + '@tsconfig/node10@1.0.11': + resolution: {integrity: sha512-DcRjDCujK/kCk/cUe8Xz8ZSpm8mS3mNNpta+jGCA6USEDfktlNvm1+IuZ9eTcDbNk41BHwpHHeW+N1lKCz4zOw==} - abort-controller@3.0.0: - resolution: {integrity: sha512-h8lQ8tacZYnR3vNQTgibj+tODHI5/+l06Au2Pcriv/Gmet0eaj4TwWH41sO9wnHDiQsEj19q0drzdWdeAHtweg==} - engines: {node: '>=6.5'} + '@tsconfig/node12@1.0.11': + resolution: {integrity: sha512-cqefuRsh12pWyGsIoBKJA9luFu3mRxCA+ORZvA4ktLSzIuCUtWVxGIuXigEwO5/ywWFMZ2QEGKWvkZG1zDMTag==} - accepts@2.0.0: - resolution: {integrity: sha512-5cvg6CtKwfgdmVqY1WIiXKc3Q1bkRqGLi+2W/6ao+6Y7gu/RCwRuAhGEzh5B4KlszSuTLgZYuqFqo5bImjNKng==} - engines: {node: '>= 0.6'} + '@tsconfig/node14@1.0.3': + resolution: {integrity: sha512-ysT8mhdixWK6Hw3i1V2AeRqZ5WfXg1G43mqoYlM2nc6388Fq5jcXyr5mRsqViLx/GJYdoL0bfXD8nmF+Zn/Iow==} - acorn-import-assertions@1.9.0: - resolution: {integrity: sha512-cmMwop9x+8KFhxvKrKfPYmN6/pKTYYHBqLa0DfvVZcKMJWNyWLnaqND7dx/qn66R7ewM1UX5XMaDVP5wlVTaVA==} - deprecated: package has been renamed to acorn-import-attributes - peerDependencies: - acorn: ^8 + '@tsconfig/node16@1.0.4': + resolution: {integrity: sha512-vxhUy4J8lyeyinH7Azl1pdd43GJhZH/tP2weN8TntQblOY+A0XbT8DJk1/oCPuOOyg/Ja757rG0CgHcWC8OfMA==} - acorn-import-attributes@1.9.5: - resolution: {integrity: sha512-n02Vykv5uA3eHGM/Z2dQrcD56kL8TyDb2p1+0P83PClMnC/nc+anbQRhIOWnSq4Ke/KvDPrY3C9hDtC/A3eHnQ==} - peerDependencies: - acorn: ^8 + '@types/aws-lambda@8.10.122': + resolution: {integrity: sha512-vBkIh9AY22kVOCEKo5CJlyCgmSWvasC+SWUxL/x/vOwRobMpI/HG1xp/Ae3AqmSiZeLUbOhW0FCD3ZjqqUxmXw==} - acorn-walk@8.3.4: - resolution: {integrity: sha512-ueEepnujpqee2o5aIYnvHU6C0A42MNdsIDeqy5BydrkuC5R1ZuUFnm27EeFJGoEHJQgn3uleRvmTXaJgfXbt4g==} - engines: {node: '>=0.4.0'} + '@types/babel__core@7.20.5': + resolution: {integrity: sha512-qoQprZvz5wQFJwMDqeseRXWv3rqMvhgpbXFfVyWhbx9X47POIA6i/+dXefEmZKoAgOaTdaIgNSMqMIU61yRyzA==} - acorn@8.14.1: - resolution: {integrity: sha512-OvQ/2pUDKmgfCg++xsTX1wGxfTaszcHVcTctW4UJB4hibJx2HXxxO5UmVgyjMa+ZDsiaf5wWLXYpRWMmBI0QHg==} - engines: {node: '>=0.4.0'} - hasBin: true + '@types/babel__generator@7.27.0': + resolution: {integrity: sha512-ufFd2Xi92OAVPYsy+P4n7/U7e68fex0+Ee8gSG9KX7eo084CWiQ4sdxktvdl0bOPupXtVJPY19zk6EwWqUQ8lg==} - adm-zip@0.5.16: - resolution: {integrity: sha512-TGw5yVi4saajsSEgz25grObGHEUaDrniwvA2qwSC060KfqGPdglhvPMA2lPIoxs3PQIItj2iag35fONcQqgUaQ==} - engines: {node: '>=12.0'} + '@types/babel__template@7.4.4': + resolution: {integrity: sha512-h/NUaSyG5EyxBIp8YRxo4RMe2/qQgvyowRwVMzhYhBCONbW8PUsg4lkFMrhgZhUe5z3L3MiLDuvyJ/CaPa2A8A==} - agent-base@6.0.2: - resolution: {integrity: sha512-RZNwNclF7+MS/8bDg70amg32dyeZGZxiDuQmZxKLAlQjr3jGyLx+4Kkk58UO7D2QdgFIQCovuSuZESne6RG6XQ==} - engines: {node: '>= 6.0.0'} + '@types/babel__traverse@7.20.7': + resolution: {integrity: sha512-dkO5fhS7+/oos4ciWxyEyjWe48zmG6wbCheo/G2ZnHx4fs3EU6YC6UM8rk56gAjNJ9P3MTH2jo5jb92/K6wbng==} - agent-base@7.1.4: - resolution: {integrity: sha512-MnA+YT8fwfJPgBx3m60MNqakm30XOkyIoH1y6huTQvC0PwZG7ki8NacLBcrPbNoo8vEZy7Jpuk7+jMO+CUovTQ==} - engines: {node: '>= 14'} + '@types/body-parser@1.19.6': + resolution: {integrity: sha512-HLFeCYgz89uk22N5Qg3dvGvsv46B8GLvKKo1zKG4NybA8U2DiEO3w9lqGg29t/tfLRJpJ6iQxnVw4OnB7MoM9g==} - agentkeepalive@4.6.0: - resolution: {integrity: sha512-kja8j7PjmncONqaTsB8fQ+wE2mSU2DJ9D4XKoJ5PFWIdRMa6SLSN1ff4mOr4jCbfRSsxR4keIiySJU0N9T5hIQ==} - engines: {node: '>= 8.0.0'} + '@types/bunyan@1.8.9': + resolution: {integrity: sha512-ZqS9JGpBxVOvsawzmVt30sP++gSQMTejCkIAQ3VdadOcRE8izTyW66hufvwLeH+YEGP6Js2AW7Gz+RMyvrEbmw==} - ai@6.0.97: - resolution: {integrity: sha512-eZIAcBymwGhBwncRH/v9pillZNMeRCDkc4BwcvwXerXd7sxjVxRis3ZNCNCpP02pVH4NLs81ljm4cElC4vbNcQ==} - engines: {node: '>=18'} - peerDependencies: - zod: ^3.25.76 || ^4.1.8 + '@types/caseless@0.12.5': + resolution: {integrity: sha512-hWtVTC2q7hc7xZ/RLbxapMvDMgUnDvKvMOpKal4DrMyfGBUfB1oKaZlIRr6mJL+If3bAP6sV/QneGzF6tJjZDg==} - ajv-formats@3.0.1: - resolution: {integrity: sha512-8iUql50EUR+uUcdRQ3HDqa6EVyo3docL8g5WJ3FNcWmu62IbkGUue/pEyLBW8VGKKucTPgqeks4fIU1DA4yowQ==} - peerDependencies: - ajv: ^8.0.0 - peerDependenciesMeta: - ajv: - optional: true + '@types/chai@5.2.3': + resolution: {integrity: sha512-Mw558oeA9fFbv65/y4mHtXDs9bPnFMZAL/jxdPFUpOHHIXX91mcgEHbS5Lahr+pwZFR8A7GQleRWeI6cGFC2UA==} - ajv@8.17.1: - resolution: {integrity: sha512-B/gBuNg5SiMTrPkC+A2+cW0RszwxYmn6VYxB/inlBStS5nx6xHIt/ehKRhIMhqusl7a8LjQoZnjCs5vhwxOQ1g==} + '@types/command-line-args@5.2.3': + resolution: {integrity: sha512-uv0aG6R0Y8WHZLTamZwtfsDLVRnOa+n+n5rEvFWL5Na5gZ8V2Teab/duDPFzIIIhs9qizDpcavCusCLJZu62Kw==} - ajv@8.20.0: - resolution: {integrity: sha512-Thbli+OlOj+iMPYFBVBfJ3OmCAnaSyNn4M1vz9T6Gka5Jt9ba/HIR56joy65tY6kx/FCF5VXNB819Y7/GUrBGA==} + '@types/command-line-usage@5.0.4': + resolution: {integrity: sha512-BwR5KP3Es/CSht0xqBcUXS3qCAUVXwpRKsV2+arxeb65atasuXG9LykC9Ab10Cw3s2raH92ZqOeILaQbsB2ACg==} - ansi-escapes@4.3.2: - resolution: {integrity: sha512-gKXj5ALrKWQLsYG9jlTRmR/xKluxHV+Z9QEwNIgCfM1/uwPMCuzVVnh5mwTd+OuBZcwSIMbqssNWRm1lE51QaQ==} - engines: {node: '>=8'} + '@types/connect@3.4.36': + resolution: {integrity: sha512-P63Zd/JUGq+PdrM1lv0Wv5SBYeA2+CORvbrXbngriYY0jzLUWfQMQQxOhjONEz/wlHOAxOdY7CY65rgQdTjq2w==} - ansi-regex@5.0.1: - resolution: {integrity: sha512-quJQXlTSUGL2LH9SUXo8VwsY4soanhgo6LNSm84E1LBcE8s3O0wpdiRzyR9z/ZZJMlMWv37qOOb9pdJlMUEKFQ==} - engines: {node: '>=8'} + '@types/connect@3.4.38': + resolution: {integrity: sha512-K6uROf1LD88uDQqJCktA4yzL1YYAK6NgfsI0v/mTgyPKWsX1CnJ0XPSDhViejru1GcRkLWb8RlzFYJRqGUbaug==} - ansi-regex@6.2.2: - resolution: {integrity: sha512-Bq3SmSpyFHaWjPk8If9yc6svM8c56dB5BAtW4Qbw5jHTwwXXcTLoRMkpDJp6VL0XzlWaCHTXrkFURMYmD0sLqg==} - engines: {node: '>=12'} + '@types/debug@4.1.13': + resolution: {integrity: sha512-KSVgmQmzMwPlmtljOomayoR89W4FynCAi3E8PPs7vmDVPe84hT+vGPKkJfThkmXs0x0jAaa9U8uW8bbfyS2fWw==} - ansi-styles@4.3.0: - resolution: {integrity: sha512-zbB9rCJAT1rbjiVDb2hqKFHNYLxgtk8NURxZ3IZwD3F6NtxbXZQCnnSi1Lkx+IDohdPlFp222wVALIheZJQSEg==} - engines: {node: '>=8'} + '@types/deep-eql@4.0.2': + resolution: {integrity: sha512-c9h9dVVMigMPc4bwTvC5dxqtqJZwQPePsWjPlpSOnojbor6pGqdk541lfA7AqFQr5pB1BRdq0juY9db81BwyFw==} - ansi-styles@5.2.0: - resolution: {integrity: sha512-Cxwpt2SfTzTtXcfOlzGEee8O+c+MmUgGrNiBcXnuWxuFJHe6a5Hz7qwhwe5OgaSYI0IJvkLqWX1ASG+cJOkEiA==} - engines: {node: '>=10'} + '@types/dom-mediacapture-record@1.0.22': + resolution: {integrity: sha512-mUMZLK3NvwRLcAAT9qmcK+9p7tpU2FHdDsntR3YI4+GY88XrgG4XiE7u1Q2LAN2/FZOz/tdMDC3GQCR4T8nFuw==} - ansi-styles@6.2.3: - resolution: {integrity: sha512-4Dj6M28JB+oAH8kFkTLUo+a2jwOFkuqb3yucU0CANcRRUbxS0cP0nZYCGjcc3BNXwRIsUVmDGgzawme7zvJHvg==} - engines: {node: '>=12'} + '@types/estree@1.0.8': + resolution: {integrity: sha512-dWHzHa2WqEXI/O1E9OjrocMTKJl2mSrEolh1Iomrv6U+JuNwaHXsXx9bLu5gG7BUWFIN0skIQJQ/L1rIex4X6w==} - anymatch@3.1.3: - resolution: {integrity: sha512-KMReFUr0B4t+D+OBkjR3KYqvocp2XaSzO55UcB6mgQMd3KbcE+mWTyvVV7D/zsdEbNnV6acZUutkiHQXvTr1Rw==} - engines: {node: '>= 8'} + '@types/events@3.0.3': + resolution: {integrity: sha512-trOc4AAUThEz9hapPtSd7wf5tiQKvTtu5b371UxXdTuqzIh0ArcRspRP0i0Viu+LXstIQ1z96t1nsPxT9ol01g==} - apache-arrow@15.0.2: - resolution: {integrity: sha512-RvwlFxLRpO405PLGffx4N2PYLiF7FD86Q1hHl6J2XCWiq+tTCzpb9ngFw0apFDcXZBMpCzMuwAvA7hjyL1/73A==} - hasBin: true + '@types/express-serve-static-core@5.1.1': + resolution: {integrity: sha512-v4zIMr/cX7/d2BpAEX3KNKL/JrT1s43s96lLvvdTmza1oEvDudCqK9aF/djc/SWgy8Yh0h30TZx5VpzqFCxk5A==} - arg@4.1.3: - resolution: {integrity: sha512-58S9QDqG0Xx27YwPSt9fJxivjYl432YCwfDMfZ+71RAqUrZef7LrKQZ3LHLOwCS4FLNBplP533Zx895SeOCHvA==} + '@types/express@5.0.6': + resolution: {integrity: sha512-sKYVuV7Sv9fbPIt/442koC7+IIwK5olP1KWeD88e/idgoJqDm3JV/YUiPwkoKK92ylff2MGxSz1CSjsXelx0YA==} - argparse@1.0.10: - resolution: {integrity: sha512-o5Roy6tNG4SL/FOkCAN6RzjiakZS25RLYFrcMttJqbdd8BWrnA+fGz57iN5Pb06pvBGvl5gQ0B48dJlslXvoTg==} + '@types/google-protobuf@3.15.12': + resolution: {integrity: sha512-40um9QqwHjRS92qnOaDpL7RmDK15NuZYo9HihiJRbYkMQZlWnuH8AdvbMy8/o6lgLmKbDUKa+OALCltHdbOTpQ==} - argparse@2.0.1: - resolution: {integrity: sha512-8+9WqebbFzpX9OR+Wa6O29asIogeRMzcGtAINdpMHHyAg10f05aSFVBbcEqGf/PXw1EjAZ+q2/bEBg3DvurK3Q==} + '@types/graceful-fs@4.1.9': + resolution: {integrity: sha512-olP3sd1qOEe5dXTSaFvQG+02VdRXcdytWLAZsAq1PecU8uqQAhkrnbli7DagjtXKW/Bl7YJbUsa8MPcuc8LHEQ==} - array-back@3.1.0: - resolution: {integrity: sha512-TkuxA4UCOvxuDK6NZYXCalszEzj+TLszyASooky+i742l9TqsOdYCMJJupxRic61hwquNtppB3hgcuq9SVSH1Q==} - engines: {node: '>=6'} + '@types/http-errors@2.0.5': + resolution: {integrity: sha512-r8Tayk8HJnX0FztbZN7oVqGccWgw98T/0neJphO91KkmOzug1KkofZURD4UaD5uH8AqcFLfdPErnBod0u71/qg==} - array-back@6.2.2: - resolution: {integrity: sha512-gUAZ7HPyb4SJczXAMUXMGAvI976JoK3qEx9v1FTmeYuJj0IBiaKttG1ydtGKdkfqWkIkouke7nG8ufGy77+Cvw==} - engines: {node: '>=12.17'} + '@types/istanbul-lib-coverage@2.0.6': + resolution: {integrity: sha512-2QF/t/auWm0lsy8XtKVPG19v3sSOQlJe/YHZgfjb/KBBHOGSV+J2q/S671rcq9uTBrLAXmZpqJiaQbMT+zNU1w==} - array-union@2.1.0: - resolution: {integrity: sha512-HGyxoOTYUyCM6stUe6EJgnd4EoewAI7zMdfqO+kGjnlZmBDz/cR5pf8r/cR4Wq60sL/p0IkcjUEEPwS3GFrIyw==} - engines: {node: '>=8'} + '@types/istanbul-lib-report@3.0.3': + resolution: {integrity: sha512-NQn7AHQnk/RSLOxrBbGyJM/aVQ+pjj5HCgasFxc0K/KhoATfQ/47AyUl15I2yBUpihjmas+a+VJBOqecrFH+uA==} - arrify@2.0.1: - resolution: {integrity: sha512-3duEwti880xqi4eAMN8AyR4a0ByT90zoYdLlevfrvU43vb0YZwZVfxOgxWrLXXXpyugL0hNZc9G6BiB5B3nUug==} - engines: {node: '>=8'} + '@types/istanbul-reports@3.0.4': + resolution: {integrity: sha512-pk2B1NWalF9toCRu6gjBzR69syFjP4Od8WRAX+0mmf9lAjCRicLOWc+ZrxZHx/0XRjotgkF9t6iaMJ+aXcOdZQ==} - assertion-error@2.0.1: - resolution: {integrity: sha512-Izi8RQcffqCeNVgFigKli1ssklIbpHnCYc6AknXGYoB6grJqyeby7jv12JUQgmTAnIDnbck1uxksT4dzN3PWBA==} - engines: {node: '>=12'} + '@types/jest@29.5.14': + resolution: {integrity: sha512-ZN+4sdnLUbo8EVvVc2ao0GFW6oVrQRPn4K2lglySj7APvSrgzxHiNNK99us4WDMi57xxA2yggblIAMNhXOotLQ==} - async-retry@1.3.3: - resolution: {integrity: sha512-wfr/jstw9xNi/0teMHrRW7dsz3Lt5ARhYNZ2ewpadnhaIp5mbALhOAP+EAdsC7t4Z6wqsDVv9+W6gm1Dk9mEyw==} + '@types/json-schema@7.0.15': + resolution: {integrity: sha512-5+fP8P8MFNC+AyZCDxrB2pkZFPGzqQWUzpSeuuVLvm8VMcorNYavBqoFcxK8bQz4Qsbn4oUEEem4wDLfcysGHA==} - async@3.2.6: - resolution: {integrity: sha512-htCUDlxyyCLMgaM3xXg0C0LW2xqfuQ6p05pCEIsXuyQ+a1koYKTuBMzRNwmybfLgvJDMd0r1LTn4+E0Ti6C2AA==} + '@types/jsonwebtoken@9.0.10': + resolution: {integrity: sha512-asx5hIG9Qmf/1oStypjanR7iKTv0gXQ1Ov/jfrX6kS/EO0OFni8orbmGCn0672NHR3kXHwpAwR+B368ZGN/2rA==} - asynckit@0.4.0: - resolution: {integrity: sha512-Oei9OH4tRh0YqU3GxhX79dM/mwVgvbZJaSNaRk+bshkj0S5cfHcgYakreBjrHwatXKbz+IoIdYLxrKim2MjW0Q==} + '@types/lodash-es@4.17.12': + resolution: {integrity: sha512-0NgftHUcV4v34VhXm8QBSftKVXtbkBG3ViCjs6+eJ5a6y6Mi/jiFGPc1sC7QK+9BFhWrURE3EOggmWaSxL9OzQ==} - atomic-sleep@1.0.0: - resolution: {integrity: sha512-kNOjDqAh7px0XWNI+4QbzoiR/nTkHAWNud2uvnJquD1/x5a7EQZMJT0AczqK0Qn67oY/TTQ1LbUKajZpp3I9tQ==} - engines: {node: '>=8.0.0'} + '@types/lodash@4.17.23': + resolution: {integrity: sha512-RDvF6wTulMPjrNdCoYRC8gNR880JNGT8uB+REUpC2Ns4pRqQJhGz90wh7rgdXDPpCczF3VGktDuFGVnz8zP7HA==} - axios@1.13.5: - resolution: {integrity: sha512-cz4ur7Vb0xS4/KUN0tPWe44eqxrIu31me+fbang3ijiNscE129POzipJJA6zniq2C/Z6sJCjMimjS8Lc/GAs8Q==} - - babel-jest@29.7.0: - resolution: {integrity: sha512-BrvGY3xZSwEcCzKvKsCi2GgHqDqsYkOP4/by5xCgIwGXQxIEh+8ew3gmrE1y7XRR6LHZIj6yLYnUi/mm2KXKBg==} - engines: {node: ^14.15.0 || ^16.10.0 || >=18.0.0} - peerDependencies: - '@babel/core': ^7.8.0 + '@types/long@4.0.2': + resolution: {integrity: sha512-MqTGEo5bj5t157U6fA/BiDynNkn0YknVdh48CMPkTSpFTVmvao5UQmm7uEF6xBEo7qIMAlY/JSleYaE6VOdpaA==} - babel-plugin-istanbul@6.1.1: - resolution: {integrity: sha512-Y1IQok9821cC9onCx5otgFfRm7Lm+I+wwxOx738M/WLPZ9Q42m4IG5W0FNX8WLL2gYMZo3JkuXIH2DOpWM+qwA==} - engines: {node: '>=8'} + '@types/mdast@4.0.4': + resolution: {integrity: sha512-kGaNbPh1k7AFzgpud/gMdvIm5xuECykRR+JnWKQno9TAXVa6WIVCGTPvYGekIDL4uwCZQSYbUxNBSb1aUo79oA==} - babel-plugin-jest-hoist@29.6.3: - resolution: {integrity: sha512-ESAc/RJvGTFEzRwOTT4+lNDk/GNHMkKbNzsvT0qKRfDyyYTskxB5rnU2njIDYVxXCBHHEI1c0YwHob3WaYujOg==} - engines: {node: ^14.15.0 || ^16.10.0 || >=18.0.0} + '@types/memcached@2.2.10': + resolution: {integrity: sha512-AM9smvZN55Gzs2wRrqeMHVP7KE8KWgCJO/XL5yCly2xF6EKa4YlbpK+cLSAH4NG/Ah64HrlegmGqW8kYws7Vxg==} - babel-preset-current-node-syntax@1.1.0: - resolution: {integrity: sha512-ldYss8SbBlWva1bs28q78Ju5Zq1F+8BrqBZZ0VFhLBvhh6lCpC2o3gDJi/5DRLs9FgYZCnmPYIVFU4lRXCkyUw==} - peerDependencies: - '@babel/core': ^7.0.0 + '@types/ms@2.1.0': + resolution: {integrity: sha512-GsCCIZDE/p3i96vtEqx+7dBUGXrc7zeSK3wwPHIaRThS+9OhWIXRqzs4d6k1SVU8g91DrNRWxWUGhp5KXQb2VA==} - babel-preset-jest@29.6.3: - resolution: {integrity: sha512-0B3bhxR6snWXJZtR/RliHTDPRgn1sNHOR0yVtq/IiQFyuOVjFS+wuio/R4gSNkyYmKmJB4wGZv2NZanmKmTnNA==} - engines: {node: ^14.15.0 || ^16.10.0 || >=18.0.0} - peerDependencies: - '@babel/core': ^7.0.0 + '@types/mysql@2.15.22': + resolution: {integrity: sha512-wK1pzsJVVAjYCSZWQoWHziQZbNggXFDUEIGf54g4ZM/ERuP86uGdWeKZWMYlqTPMZfHJJvLPyogXGvCOg87yLQ==} - bail@2.0.2: - resolution: {integrity: sha512-0xO6mYd7JB2YesxDKplafRpsiOzPt9V02ddPCLbY1xYGPOX24NTyN50qnUxgCPcSoYMhKpAuBTjQoRZCAkUDRw==} + '@types/node-fetch@2.6.12': + resolution: {integrity: sha512-8nneRWKCg3rMtF69nLQJnOYUcbafYeFSjqkw3jCRLsqkWFlHaoQrr5mXmofFGOx3DKn7UfmBMyov8ySvLRVldA==} - balanced-match@1.0.2: - resolution: {integrity: sha512-3oSeUO0TMV67hN1AmbXsK4yaqU7tjiHlbxRDZOpH0KW9+CeX4bRAaX0Anxt0tx2MrpRpWwQaPwIlISEJhYU5Pw==} + '@types/node@18.19.100': + resolution: {integrity: sha512-ojmMP8SZBKprc3qGrGk8Ujpo80AXkrP7G2tOT4VWr5jlr5DHjsJF+emXJz+Wm0glmy4Js62oKMdZZ6B9Y+tEcA==} - base-64@0.1.0: - resolution: {integrity: sha512-Y5gU45svrR5tI2Vt/X9GPd3L0HNIKzGu202EjxrXMpuc2V2CiKgemAbUUsqYmZJvPtCXoUKjNZwBJzsNScUbXA==} + '@types/node@20.19.30': + resolution: {integrity: sha512-WJtwWJu7UdlvzEAUm484QNg5eAoq5QR08KDNx7g45Usrs2NtOPiX8ugDqmKdXkyL03rBqU5dYNYVQetEpBHq2g==} - base64-js@1.5.1: - resolution: {integrity: sha512-AKpaYlHn8t4SVbOHCy+b5+KKgvR4vrsD8vbvrbiQJps7fKDTkjkDry6ji0rUJjC0kzbNePLwzxq8iypo41qeWA==} + '@types/node@22.15.33': + resolution: {integrity: sha512-wzoocdnnpSxZ+6CjW4ADCK1jVmd1S/J3ArNWfn8FDDQtRm8dkDg7TA+mvek2wNrfCgwuZxqEOiB9B1XCJ6+dbw==} - beeai-framework@0.1.27: - resolution: {integrity: sha512-Hnq+mu1BbmtwxT1/uXUtfuKxvJ4j2fxWAq6nhMUtr/ZaevtEZKhgsDXZbTq00IHP/XXt9pjBYPI5w6hWq4AENw==} - peerDependencies: - '@a2a-js/sdk': ^0.3.4 - '@ai-sdk/amazon-bedrock': ^4.0.52 - '@ai-sdk/anthropic': ^3.0.39 - '@ai-sdk/azure': ^3.0.27 - '@ai-sdk/google-vertex': ^4.0.47 - '@ai-sdk/groq': ^3.0.22 - '@ai-sdk/openai': ^3.0.26 - '@aws-sdk/client-bedrock-runtime': ^3.848.0 - '@elastic/elasticsearch': ^8.0.0 - '@googleapis/customsearch': ^3.2.0 - '@ibm-cloud/watsonx-ai': '*' - '@langchain/community': ^0.2.28 - '@langchain/core': ^0.2.27 - '@modelcontextprotocol/sdk': ^1.18.2 - '@qdrant/js-client-rest': ^1.15.0 - '@zilliz/milvus2-sdk-node': ^2.6.0 - express: ^5.0.0 - ibm-cloud-sdk-core: '*' - ollama-ai-provider-v2: ^3.0.4 - sequelize: ^6.37.7 - yaml: ^2.6.1 - peerDependenciesMeta: - '@a2a-js/sdk': - optional: true - '@ai-sdk/amazon-bedrock': - optional: true - '@ai-sdk/anthropic': - optional: true - '@ai-sdk/azure': - optional: true - '@ai-sdk/google-vertex': - optional: true - '@ai-sdk/groq': - optional: true - '@ai-sdk/openai': - optional: true - '@elastic/elasticsearch': - optional: true - '@googleapis/customsearch': - optional: true - '@ibm-cloud/watsonx-ai': - optional: true - '@langchain/community': - optional: true - '@langchain/core': - optional: true - '@modelcontextprotocol/sdk': - optional: true - '@qdrant/js-client-rest': - optional: true - '@zilliz/milvus2-sdk-node': - optional: true - express: - optional: true - ibm-cloud-sdk-core: - optional: true - sequelize: - optional: true - yaml: - optional: true + '@types/node@24.10.9': + resolution: {integrity: sha512-ne4A0IpG3+2ETuREInjPNhUGis1SFjv1d5asp8MzEAGtOZeTeHVDOYqOgqfhvseqg/iXty2hjBf1zAOb7RNiNw==} - bignumber.js@9.3.1: - resolution: {integrity: sha512-Ko0uX15oIUS7wJ3Rb30Fs6SkVbLmPBAKdlm7q9+ak9bbIeFf0MwuBsQV6z7+X768/cHsfg+WlysDWJcmthjsjQ==} + '@types/pg-pool@2.0.4': + resolution: {integrity: sha512-qZAvkv1K3QbmHHFYSNRYPkRjOWRLBYrL4B9c+wG0GSVGBw0NtJwPcgx/DSddeDJvRGMHCEQ4VMEVfuJ/0gZ3XQ==} - binary-extensions@2.3.0: - resolution: {integrity: sha512-Ceh+7ox5qe7LJuLHoY0feh3pHuUDHAcRUeyL2VYghZwfpkNIy/+8Ocg0a3UuSoYzavmylwuLWQOf3hl0jjMMIw==} - engines: {node: '>=8'} + '@types/pg@8.6.1': + resolution: {integrity: sha512-1Kc4oAGzAl7uqUStZCDvaLFqZrW9qWSjXOmBfdgyBP5La7Us6Mg4GBvRlSoaZMhQF/zSj1C8CtKMBkoiT8eL8w==} - binary-search@1.3.6: - resolution: {integrity: sha512-nbE1WxOTTrUWIfsfZ4aHGYu5DOuNkbxGokjV6Z2kxfJK3uaAb8zNK1muzOeipoLHZjInT4Br88BHpzevc681xA==} + '@types/qs@6.14.0': + resolution: {integrity: sha512-eOunJqu0K1923aExK6y8p6fsihYEn/BYuQ4g0CxAAgFc4b/ZLN4CrsRZ55srTdqoiLzU2B2evC+apEIxprEzkQ==} - body-parser@2.2.2: - resolution: {integrity: sha512-oP5VkATKlNwcgvxi0vM0p/D3n2C3EReYVX+DNYs5TjZFn/oQt2j+4sVJtSMr18pdRr8wjTcBl6LoV+FUwzPmNA==} - engines: {node: '>=18'} + '@types/range-parser@1.2.7': + resolution: {integrity: sha512-hKormJbkJqzQGhziax5PItDUTMAM9uE2XXQmM37dyd4hVM+5aVl7oVxMVUiVQn2oCQFN/LKCZdvSM0pFRqbSmQ==} - bowser@2.13.1: - resolution: {integrity: sha512-OHawaAbjwx6rqICCKgSG0SAnT05bzd7ppyKLVUITZpANBaaMFBAsaNkto3LoQ31tyFP5kNujE8Cdx85G9VzOkw==} + '@types/request@2.48.13': + resolution: {integrity: sha512-FGJ6udDNUCjd19pp0Q3iTiDkwhYup7J8hpMW9c4k53NrccQFFWKRho6hvtPPEhnXWKvukfwAlB6DbDz4yhH5Gg==} - brace-expansion@1.1.11: - resolution: {integrity: sha512-iCuPHDFgrHX7H2vEI/5xpz07zSHB00TpugqhmYtVmMO6518mCuRMoOYFldEBl0g187ufozdaHgWKcYFb61qGiA==} + '@types/retry@0.12.0': + resolution: {integrity: sha512-wWKOClTTiizcZhXnPY4wikVAwmdYHp8q6DmC+EJUzAMsycb7HB32Kh9RN4+0gExjmPmZSAQjgURXIGATPegAvA==} - brace-expansion@2.0.2: - resolution: {integrity: sha512-Jt0vHyM+jmUBqojB7E1NIYadt0vI0Qxjxd2TErW94wDz+E2LAm5vKMXXwg6ZZBTHPuUlDgQHKXvjGBdfcF1ZDQ==} + '@types/send@1.2.1': + resolution: {integrity: sha512-arsCikDvlU99zl1g69TcAB3mzZPpxgw0UQnaHeC1Nwb015xp8bknZv5rIfri9xTOcMuaVgvabfIRA7PSZVuZIQ==} - braces@3.0.3: - resolution: {integrity: sha512-yQbXgO/OSZVD2IsiLlro+7Hf6Q18EJrKSEsdoMzKePKXct3gvD8oLcOQdIzGupr5Fj+EDe8gO/lxc1BzfMpxvA==} - engines: {node: '>=8'} + '@types/serve-static@2.2.0': + resolution: {integrity: sha512-8mam4H1NHLtu7nmtalF7eyBH14QyOASmcxHhSfEoRyr0nP/YdoesEtU+uSRvMe96TW/HPTtkoKqQLl53N7UXMQ==} - browserslist@4.24.5: - resolution: {integrity: sha512-FDToo4Wo82hIdgc1CQ+NQD0hEhmpPjrZ3hiUgwgOG6IuTdlpr8jdjyG24P6cNP1yJpTLzS5OcGgSw0xmDU1/Tw==} - engines: {node: ^6 || ^7 || ^8 || ^9 || ^10 || ^11 || ^12 || >=13.7} - hasBin: true + '@types/shimmer@1.2.0': + resolution: {integrity: sha512-UE7oxhQLLd9gub6JKIAhDq06T0F6FnztwMNRvYgjeQSBeMc1ZG/tA47EwfduvkuQS8apbkM/lpLpWsaCeYsXVg==} - bs-logger@0.2.6: - resolution: {integrity: sha512-pd8DCoxmbgc7hyPKOvxtqNcjYoOsABPQdcCUjGp3d42VR2CX1ORhk2A87oqqu5R1kk+76nsxZupkmyd+MVtCog==} - engines: {node: '>= 6'} + '@types/stack-utils@2.0.3': + resolution: {integrity: sha512-9aEbYZ3TbYMznPdcdr3SmIrLXwC/AKZXQeCf9Pgao5CKb8CyHuEX5jzWPTkvregvhRJHcpRO6BFoGW9ycaOkYw==} - bser@2.1.1: - resolution: {integrity: sha512-gQxTNE/GAfIIrmHLUE3oJyp5FO6HRBfhjnw4/wMmA63ZGDJnWBmgY/lyQBpnDUkGmAhbSe39tx2d/iTOAfglwQ==} + '@types/tedious@4.0.14': + resolution: {integrity: sha512-KHPsfX/FoVbUGbyYvk1q9MMQHLPeRZhRJZdO45Q4YjvFkv4hMNghCWTvy7rdKessBsmtz4euWCWAB6/tVpI1Iw==} - bson@6.10.4: - resolution: {integrity: sha512-WIsKqkSC0ABoBJuT1LEX+2HEvNmNKKgnTAyd0fL8qzK4SH2i9NXg+t08YtdZp/V9IZ33cxe3iV4yM0qg8lMQng==} - engines: {node: '>=16.20.1'} + '@types/tough-cookie@4.0.5': + resolution: {integrity: sha512-/Ad8+nIOV7Rl++6f1BdKxFSMgmoqEoYbHRpPcx3JEfv8VRsQe9Z4mCXeJBzxs7mbHY/XOZZuXlRNfhpVPbs6ZA==} - buffer-equal-constant-time@1.0.1: - resolution: {integrity: sha512-zRpUiDwd/xk6ADqPMATG8vc9VPrkck7T07OIx0gnjmJAnHnTVXNQG3vfvWNuiZIkwu9KrKdA1iJKfsfTVxE6NA==} + '@types/triple-beam@1.3.5': + resolution: {integrity: sha512-6WaYesThRMCl19iryMYP7/x2OVgCtbIVflDGFpWnb9irXI3UjYE4AzmYuiUKY1AJstGijoY+MgUszMgRxIYTYw==} - buffer-from@1.1.2: - resolution: {integrity: sha512-E+XQCRwSbaaiChtv6k6Dwgc+bx+Bs6vuKJHHl5kox/BaKbhiXzqQOwK4cO22yElGp2OCmjwVhT3HmxgyPGnJfQ==} + '@types/unist@3.0.3': + resolution: {integrity: sha512-ko/gIFJRv177XgZsZcBwnqJN5x/Gien8qNOn0D5bQU/zAzVf9Zt3BlcUiLqhV9y4ARk0GbT3tnUiPNgnTXzc/Q==} - buffer@6.0.3: - resolution: {integrity: sha512-FTiCpNxtwiZZHEZbcbTIcZjERVICn9yq/pDFkTl95/AxzD1naBctN7YO68riM/gLSDY7sdrMby8hofADYuuqOA==} + '@types/uuid@10.0.0': + resolution: {integrity: sha512-7gqG38EyHgyP1S+7+xomFtL+ZNHcKv6DwNaCZmJmo1vgMugyF3TCnXVg4t1uk89mLNwnLtnY3TpOpCOyp1/xHQ==} - bytes@3.1.2: - resolution: {integrity: sha512-/Nf7TyzTx6S3yRJObOAV7956r8cr2+Oj8AC5dt8wSP3BQAoeX58NoHyCU8P8zGkNXStjTSi6fzO6F0pBdcYbEg==} - engines: {node: '>= 0.8'} + '@types/webidl-conversions@7.0.3': + resolution: {integrity: sha512-CiJJvcRtIgzadHCYXw7dqEnMNRjhGZlYK05Mj9OyktqV8uVT8fD2BFOB7S1uwBE3Kj2Z+4UyPmFw/Ixgw/LAlA==} - cac@6.7.14: - resolution: {integrity: sha512-b6Ilus+c3RrdDk+JhLKUAQfzzgLEPy6wcXqS7f/xe1EETvsDP6GORG7SFuOs6cID5YkqchW/LXZbX5bc8j7ZcQ==} - engines: {node: '>=8'} + '@types/whatwg-url@11.0.5': + resolution: {integrity: sha512-coYR071JRaHa+xoEvvYqvnIHaVqaYrLPbsufM9BF63HkwI5Lgmy2QR8Q5K/lYDYo5AK82wOvSOS0UsLTpTG7uQ==} - call-bind-apply-helpers@1.0.2: - resolution: {integrity: sha512-Sp1ablJ0ivDkSzjcaJdxEunN5/XvksFJ2sMBFfq6x0ryhQV/2b/KwFe21cMpmHtPOSij8K99/wSfoEuTObmuMQ==} - engines: {node: '>= 0.4'} + '@types/ws@8.18.1': + resolution: {integrity: sha512-ThVF6DCVhA8kUGy+aazFQ4kXQ7E1Ty7A3ypFOe0IcJV8O/M511G99AW24irKrW56Wt44yG9+ij8FaqoBGkuBXg==} - call-bound@1.0.4: - resolution: {integrity: sha512-+ys997U96po4Kx/ABpBCqhA9EuxJaQWDQg7295H4hBphv3IZg0boBKuwYpt4YXp6MZ5AmZQnU/tyMTlRpaSejg==} - engines: {node: '>= 0.4'} + '@types/yargs-parser@21.0.3': + resolution: {integrity: sha512-I4q9QU9MQv4oEOz4tAHJtNz1cwuLxn2F3xcc2iV5WdqLPpUnj30aUuxt1mAxYTG+oe8CZMV/+6rU4S4gRDzqtQ==} - caller@1.1.0: - resolution: {integrity: sha512-n+21IZC3j06YpCWaxmUy5AnVqhmCIM2bQtqQyy00HJlmStRt6kwDX5F9Z97pqwAB+G/tgSz6q/kUBbNyQzIubw==} + '@types/yargs@17.0.33': + resolution: {integrity: sha512-WpxBCKWPLr4xSsHgz511rFJAM+wS28w2zEO1QDNY5zM/S8ok70NNfztH0xwhqKyaK0OHCbN98LDAZuy1ctxDkA==} - callsites@3.1.0: - resolution: {integrity: sha512-P8BjAsXvZS+VIDUI11hHCQEv74YT67YUi5JJFNWIqL235sBmjX4+qx9Muvls5ivyNENctx46xQLQ3aTuE7ssaQ==} - engines: {node: '>=6'} + '@typescript/vfs@1.6.2': + resolution: {integrity: sha512-hoBwJwcbKHmvd2QVebiytN1aELvpk9B74B4L1mFm/XT1Q/VOYAWl2vQ9AWRFtQq8zmz6enTpfTV8WRc4ATjW/g==} + peerDependencies: + typescript: '*' - camelcase-keys@9.1.3: - resolution: {integrity: sha512-Rircqi9ch8AnZscQcsA1C47NFdaO3wukpmIRzYcDOrmvgt78hM/sj5pZhZNec2NM12uk5vTwRHZ4anGcrC4ZTg==} - engines: {node: '>=16'} + '@vercel/oidc@3.1.0': + resolution: {integrity: sha512-Fw28YZpRnA3cAHHDlkt7xQHiJ0fcL+NRcIqsocZQUSmbzeIKRpwttJjik5ZGanXP+vlA4SbTg+AbA3bP363l+w==} + engines: {node: '>= 20'} - camelcase@4.1.0: - resolution: {integrity: sha512-FxAv7HpHrXbh3aPo4o2qxHay2lkLY3x5Mw3KeE4KQE8ysVfziWeRZDwcjauvwBSGEC/nXUPzZy8zeh4HokqOnw==} - engines: {node: '>=4'} + '@vitest/expect@3.2.4': + resolution: {integrity: sha512-Io0yyORnB6sikFlt8QW5K7slY4OjqNX9jmJQ02QDda8lyM6B5oNgVWoSoKPac8/kgnCUzuHQKrSLtu/uOqqrig==} - camelcase@5.3.1: - resolution: {integrity: sha512-L28STB170nwWS63UjtlEOE3dldQApaJXZkOI1uMFfzf3rRuPegHaHesyee+YxQ+W6SvRDQV6UrdOdRiR153wJg==} - engines: {node: '>=6'} + '@vitest/mocker@3.2.4': + resolution: {integrity: sha512-46ryTE9RZO/rfDd7pEqFl7etuyzekzEhUbTW3BvmeO/BcCMEgq59BKhek3dXDWgAj4oMK6OZi+vRr1wPW6qjEQ==} + peerDependencies: + msw: ^2.4.9 + vite: ^5.0.0 || ^6.0.0 || ^7.0.0-0 + peerDependenciesMeta: + msw: + optional: true + vite: + optional: true - camelcase@6.3.0: - resolution: {integrity: sha512-Gmy6FhYlCY7uOElZUSbxo2UCDH8owEk996gkbrpsgGtrJLM3J7jGxl9Ic7Qwwj4ivOE5AWZWRMecDdF7hqGjFA==} - engines: {node: '>=10'} + '@vitest/pretty-format@3.2.4': + resolution: {integrity: sha512-IVNZik8IVRJRTr9fxlitMKeJeXFFFN0JaB9PHPGQ8NKQbGpfjlTx9zO4RefN8gp7eqjNy8nyK3NZmBzOPeIxtA==} - camelcase@8.0.0: - resolution: {integrity: sha512-8WB3Jcas3swSvjIeA2yvCJ+Miyz5l1ZmB6HFb9R1317dt9LCQoswg/BGrmAmkWVEszSrrg4RwmO46qIm2OEnSA==} - engines: {node: '>=16'} + '@vitest/runner@3.2.4': + resolution: {integrity: sha512-oukfKT9Mk41LreEW09vt45f8wx7DordoWUZMYdY/cyAk7w5TWkTRCNZYF7sX7n2wB7jyGAl74OxgwhPgKaqDMQ==} - caniuse-lite@1.0.30001718: - resolution: {integrity: sha512-AflseV1ahcSunK53NfEs9gFWgOEmzr0f+kaMFA4xiLZlr9Hzt7HxcSpIFcnNCUkz6R6dWKa54rUz3HUmI3nVcw==} + '@vitest/snapshot@3.2.4': + resolution: {integrity: sha512-dEYtS7qQP2CjU27QBC5oUOxLE/v5eLkGqPE0ZKEIDGMs4vKWe7IjgLOeauHsR0D5YuuycGRO5oSRXnwnmA78fQ==} - ccount@2.0.1: - resolution: {integrity: sha512-eyrF0jiFpY+3drT6383f1qhkbGsLSifNAjA61IUjZjmLCWjItY6LB9ft9YhoDgwfmclB2zhu51Lc7+95b8NRAg==} + '@vitest/spy@3.2.4': + resolution: {integrity: sha512-vAfasCOe6AIK70iP5UD11Ac4siNUNJ9i/9PZ3NKx07sG6sUxeag1LWdNrMWeKKYBLlzuK+Gn65Yd5nyL6ds+nw==} - chai@5.3.3: - resolution: {integrity: sha512-4zNhdJD/iOjSH0A05ea+Ke6MU5mmpQcbQsSOkgdaUMJ9zTlDTD/GYlwohmIE2u0gaxHYiVHEn1Fw9mZ/ktJWgw==} - engines: {node: '>=18'} + '@vitest/utils@3.2.4': + resolution: {integrity: sha512-fB2V0JFrQSMsCo9HiSq3Ezpdv4iYaXRG1Sx8edX3MwxfyNn83mKiGzOcH+Fkxt4MHxr3y42fQi1oeAInqgX2QA==} - chalk-template@0.4.0: - resolution: {integrity: sha512-/ghrgmhfY8RaSdeo43hNXxpoHAtxdbskUHjPpfqUWGttFgycUhYPGx3YZBCnUCvOa7Doivn1IZec3DEGFoMgLg==} - engines: {node: '>=12'} + '@workflow/serde@4.1.0-beta.2': + resolution: {integrity: sha512-8kkeoQKLDaKXefjV5dbhBj2aErfKp1Mc4pb6tj8144cF+Em5SPbyMbyLCHp+BVrFfFVCBluCtMx+jjvaFVZGww==} - chalk@4.1.2: - resolution: {integrity: sha512-oKnbhFyRIXpUuez8iBMmyEa4nbj4IOQyuhc/wy9kY7/WVPcwIO9VA668Pu8RkO7+0G76SLROeyw9CpQ061i4mA==} - engines: {node: '>=10'} + '@zilliz/milvus2-sdk-node@2.6.9': + resolution: {integrity: sha512-qOaVIpQ3E4w6Dp4lp9QIIuGedpE5dWRhK9SRX+y9WXcq4EXYvcdfR2aG/Vb5tWBPQwcMrGb5z8gRfFy7/gRbIw==} - char-regex@1.0.2: - resolution: {integrity: sha512-kWWXztvZ5SBQV+eRgKFeh8q5sLuZY2+8WUIzlxWVTg+oGwY14qylx1KbKzHd8P6ZYkAg0xyIDU9JMHhyJMZ1jw==} - engines: {node: '>=10'} - - character-entities@2.0.2: - resolution: {integrity: sha512-shx7oQ0Awen/BRIdkjkvz54PnEEI/EjwXDSIZp86/KKdbafHh1Df/RYGBhn4hbe2+uKC9FnT5UCEdyPz3ai9hQ==} + abort-controller-x@0.4.3: + resolution: {integrity: sha512-VtUwTNU8fpMwvWGn4xE93ywbogTYsuT+AUxAXOeelbXuQVIwNmC5YLeho9sH4vZ4ITW8414TTAOG1nW6uIVHCA==} - charenc@0.0.2: - resolution: {integrity: sha512-yrLQ/yVUFXkzg7EDQsPieE/53+0RlaWTs+wBrvW36cyilJ2SaDWfl4Yj7MtLTXleV9uEKefbAGUPv2/iWSooRA==} + abort-controller-x@0.5.0: + resolution: {integrity: sha512-yTt9CI0x+nRfX6BFMenEGP8ooPvErGH6AbFz20C2IeOLIlDsrw/VHpgne3GsCEuTA410IiFiaLVFKmgM4bKEPQ==} - chat@4.30.0: - resolution: {integrity: sha512-8LXrauKckMmR83FcYC/R8nNEda5VJDDdIhZwUUu+hzaSbk4lqsro0IWm7rB1GGYXONRrUOG2XJlkNr4C15vgMA==} - engines: {node: '>=20'} - peerDependencies: - ai: ^6.0.182 - zod: ^3.0.0 || ^4.0.0 - peerDependenciesMeta: - ai: - optional: true - zod: - optional: true + abort-controller@3.0.0: + resolution: {integrity: sha512-h8lQ8tacZYnR3vNQTgibj+tODHI5/+l06Au2Pcriv/Gmet0eaj4TwWH41sO9wnHDiQsEj19q0drzdWdeAHtweg==} + engines: {node: '>=6.5'} - check-error@2.1.3: - resolution: {integrity: sha512-PAJdDJusoxnwm1VwW07VWwUN1sl7smmC3OKggvndJFadxxDRyFJBX/ggnu/KE4kQAB7a3Dp8f/YXC1FlUprWmA==} - engines: {node: '>= 16'} + accepts@1.3.8: + resolution: {integrity: sha512-PYAthTa2m2VKxuvSD3DPC/Gy+U+sOA1LAuT8mkmRuvw+NACSaeXEQ+NHcVF7rONl6qcaxV3Uuemwawk+7+SJLw==} + engines: {node: '>= 0.6'} - chokidar@3.6.0: - resolution: {integrity: sha512-7VT13fmjotKpGipCW9JEQAusEPE+Ei8nl6/g4FBAmIm0GOOLMua9NDDo/DWp0ZAxCr3cPq5ZpBqmPAQgDda2Pw==} - engines: {node: '>= 8.10.0'} + accepts@2.0.0: + resolution: {integrity: sha512-5cvg6CtKwfgdmVqY1WIiXKc3Q1bkRqGLi+2W/6ao+6Y7gu/RCwRuAhGEzh5B4KlszSuTLgZYuqFqo5bImjNKng==} + engines: {node: '>= 0.6'} - chromadb@1.10.5: - resolution: {integrity: sha512-+IeTjjf44pKUY3vp1BacwO2tFAPcWCd64zxPZZm98dVj/kbSBeaHKB2D6eX7iRLHS1PTVASuqoR6mAJ+nrsTBg==} - engines: {node: '>=14.17.0'} + acorn-import-assertions@1.9.0: + resolution: {integrity: sha512-cmMwop9x+8KFhxvKrKfPYmN6/pKTYYHBqLa0DfvVZcKMJWNyWLnaqND7dx/qn66R7ewM1UX5XMaDVP5wlVTaVA==} + deprecated: package has been renamed to acorn-import-attributes peerDependencies: - '@google/generative-ai': ^0.1.1 - cohere-ai: ^5.0.0 || ^6.0.0 || ^7.0.0 - ollama: ^0.5.0 - openai: ^3.0.0 || ^4.0.0 - voyageai: ^0.0.3-1 - peerDependenciesMeta: - '@google/generative-ai': - optional: true - cohere-ai: - optional: true - ollama: - optional: true - openai: - optional: true - voyageai: - optional: true + acorn: ^8 - ci-info@3.9.0: - resolution: {integrity: sha512-NIxF55hv4nSqQswkAeiOi1r83xy8JldOFDTWiug55KBu9Jnblncd2U6ViHmYgHf01TPZS77NJBhBMKdWj9HQMQ==} - engines: {node: '>=8'} + acorn-import-attributes@1.9.5: + resolution: {integrity: sha512-n02Vykv5uA3eHGM/Z2dQrcD56kL8TyDb2p1+0P83PClMnC/nc+anbQRhIOWnSq4Ke/KvDPrY3C9hDtC/A3eHnQ==} + peerDependencies: + acorn: ^8 - cjs-module-lexer@1.4.3: - resolution: {integrity: sha512-9z8TZaGM1pfswYeXrUpzPrkx8UnWYdhJclsiYMm6x/w5+nN+8Tf/LnAgfLGQCm59qAOxU8WwHEq2vNwF6i4j+Q==} + acorn-walk@8.3.4: + resolution: {integrity: sha512-ueEepnujpqee2o5aIYnvHU6C0A42MNdsIDeqy5BydrkuC5R1ZuUFnm27EeFJGoEHJQgn3uleRvmTXaJgfXbt4g==} + engines: {node: '>=0.4.0'} - cliui@8.0.1: - resolution: {integrity: sha512-BSeNnyus75C4//NQ9gQt1/csTXyo/8Sb+afLAkzAptFuMsod9HFokGNudZpi/oQV73hnVK+sR+5PVRMd+Dr7YQ==} - engines: {node: '>=12'} + acorn@8.14.1: + resolution: {integrity: sha512-OvQ/2pUDKmgfCg++xsTX1wGxfTaszcHVcTctW4UJB4hibJx2HXxxO5UmVgyjMa+ZDsiaf5wWLXYpRWMmBI0QHg==} + engines: {node: '>=0.4.0'} + hasBin: true - clone-deep@4.0.1: - resolution: {integrity: sha512-neHB9xuzh/wk0dIHweyAXv2aPGZIVk3pLMe+/RNzINf17fe0OG96QroktYAUm7SM1PBnzTabaLboqqxDyMU+SQ==} - engines: {node: '>=6'} + adm-zip@0.5.16: + resolution: {integrity: sha512-TGw5yVi4saajsSEgz25grObGHEUaDrniwvA2qwSC060KfqGPdglhvPMA2lPIoxs3PQIItj2iag35fONcQqgUaQ==} + engines: {node: '>=12.0'} - cluster-key-slot@1.1.2: - resolution: {integrity: sha512-RMr0FhtfXemyinomL4hrWcYJxmX6deFdCxpJzhDttxgO1+bcCnkk+9drydLVDmAMG7NE6aN/fl4F7ucU/90gAA==} - engines: {node: '>=0.10.0'} + agent-base@6.0.2: + resolution: {integrity: sha512-RZNwNclF7+MS/8bDg70amg32dyeZGZxiDuQmZxKLAlQjr3jGyLx+4Kkk58UO7D2QdgFIQCovuSuZESne6RG6XQ==} + engines: {node: '>= 6.0.0'} - co@4.6.0: - resolution: {integrity: sha512-QVb0dM5HvG+uaxitm8wONl7jltx8dqhfU33DcqtOZcLSVIKSDDLDi7+0LbAKiyI8hD9u42m2YxXSkMGWThaecQ==} - engines: {iojs: '>= 1.0.0', node: '>= 0.12.0'} + agent-base@7.1.4: + resolution: {integrity: sha512-MnA+YT8fwfJPgBx3m60MNqakm30XOkyIoH1y6huTQvC0PwZG7ki8NacLBcrPbNoo8vEZy7Jpuk7+jMO+CUovTQ==} + engines: {node: '>= 14'} - codsen-utils@1.7.3: - resolution: {integrity: sha512-YIFQQ1n2NSgwoB3sCe7RpkZzsrPxTMek6jc7wC9fXOm1wwfWAKja9gLOMEjlXOUd3LKV3o6Jci7n9BoHs5Z8Sg==} - engines: {node: '>=14.18.0'} + agentkeepalive@4.6.0: + resolution: {integrity: sha512-kja8j7PjmncONqaTsB8fQ+wE2mSU2DJ9D4XKoJ5PFWIdRMa6SLSN1ff4mOr4jCbfRSsxR4keIiySJU0N9T5hIQ==} + engines: {node: '>= 8.0.0'} - cohere-ai@7.20.0: - resolution: {integrity: sha512-h/3h3pcLXRUmkzp/W+/FWViEMcAFtSZ8YayCTFQXpib112uNSj3feApOtJg7v9lreWR1t7gznhE6N9KNCX5FOA==} - engines: {node: '>=18.0.0'} + ai@6.0.97: + resolution: {integrity: sha512-eZIAcBymwGhBwncRH/v9pillZNMeRCDkc4BwcvwXerXd7sxjVxRis3ZNCNCpP02pVH4NLs81ljm4cElC4vbNcQ==} + engines: {node: '>=18'} + peerDependencies: + zod: ^3.25.76 || ^4.1.8 - collect-v8-coverage@1.0.2: - resolution: {integrity: sha512-lHl4d5/ONEbLlJvaJNtsF/Lz+WvB07u2ycqTYbdrq7UypDXailES4valYb2eWiJFxZlVmpGekfqoxQhzyFdT4Q==} + ajv-formats@3.0.1: + resolution: {integrity: sha512-8iUql50EUR+uUcdRQ3HDqa6EVyo3docL8g5WJ3FNcWmu62IbkGUue/pEyLBW8VGKKucTPgqeks4fIU1DA4yowQ==} + peerDependencies: + ajv: ^8.0.0 + peerDependenciesMeta: + ajv: + optional: true - color-convert@2.0.1: - resolution: {integrity: sha512-RRECPsj7iu/xb5oKYcsFHSppFNnsj/52OVTRKb4zP5onXwVF3zVmmToNcOfGC+CRDpfK/U584fMg38ZHCaElKQ==} - engines: {node: '>=7.0.0'} + ajv@8.17.1: + resolution: {integrity: sha512-B/gBuNg5SiMTrPkC+A2+cW0RszwxYmn6VYxB/inlBStS5nx6xHIt/ehKRhIMhqusl7a8LjQoZnjCs5vhwxOQ1g==} - color-convert@3.1.3: - resolution: {integrity: sha512-fasDH2ont2GqF5HpyO4w0+BcewlhHEZOFn9c1ckZdHpJ56Qb7MHhH/IcJZbBGgvdtwdwNbLvxiBEdg336iA9Sg==} - engines: {node: '>=14.6'} + ajv@8.20.0: + resolution: {integrity: sha512-Thbli+OlOj+iMPYFBVBfJ3OmCAnaSyNn4M1vz9T6Gka5Jt9ba/HIR56joy65tY6kx/FCF5VXNB819Y7/GUrBGA==} - color-name@1.1.4: - resolution: {integrity: sha512-dOy+3AuW3a2wNbZHIuMZpTcgjGuLU/uBL/ubcZF9OXbDo8ff4O8yVp5Bf0efS8uEoYo5q4Fx7dY9OgQGXgAsQA==} + ansi-escapes@4.3.2: + resolution: {integrity: sha512-gKXj5ALrKWQLsYG9jlTRmR/xKluxHV+Z9QEwNIgCfM1/uwPMCuzVVnh5mwTd+OuBZcwSIMbqssNWRm1lE51QaQ==} + engines: {node: '>=8'} - color-name@2.1.0: - resolution: {integrity: sha512-1bPaDNFm0axzE4MEAzKPuqKWeRaT43U/hyxKPBdqTfmPF+d6n7FSoTFxLVULUJOmiLp01KjhIPPH+HrXZJN4Rg==} - engines: {node: '>=12.20'} + ansi-regex@5.0.1: + resolution: {integrity: sha512-quJQXlTSUGL2LH9SUXo8VwsY4soanhgo6LNSm84E1LBcE8s3O0wpdiRzyR9z/ZZJMlMWv37qOOb9pdJlMUEKFQ==} + engines: {node: '>=8'} - color-string@2.1.4: - resolution: {integrity: sha512-Bb6Cq8oq0IjDOe8wJmi4JeNn763Xs9cfrBcaylK1tPypWzyoy2G3l90v9k64kjphl/ZJjPIShFztenRomi8WTg==} - engines: {node: '>=18'} + ansi-regex@6.2.2: + resolution: {integrity: sha512-Bq3SmSpyFHaWjPk8If9yc6svM8c56dB5BAtW4Qbw5jHTwwXXcTLoRMkpDJp6VL0XzlWaCHTXrkFURMYmD0sLqg==} + engines: {node: '>=12'} - color@5.0.3: - resolution: {integrity: sha512-ezmVcLR3xAVp8kYOm4GS45ZLLgIE6SPAFoduLr6hTDajwb3KZ2F46gulK3XpcwRFb5KKGCSezCBAY4Dw4HsyXA==} - engines: {node: '>=18'} + ansi-styles@4.3.0: + resolution: {integrity: sha512-zbB9rCJAT1rbjiVDb2hqKFHNYLxgtk8NURxZ3IZwD3F6NtxbXZQCnnSi1Lkx+IDohdPlFp222wVALIheZJQSEg==} + engines: {node: '>=8'} - combined-stream@1.0.8: - resolution: {integrity: sha512-FQN4MRfuJeHf7cBbBMJFXhKSDq+2kAArBlmRBvcvFE5BB1HZKXtSFASDhdlz9zOYwxh8lDdnvmMOe/+5cdoEdg==} - engines: {node: '>= 0.8'} + ansi-styles@5.2.0: + resolution: {integrity: sha512-Cxwpt2SfTzTtXcfOlzGEee8O+c+MmUgGrNiBcXnuWxuFJHe6a5Hz7qwhwe5OgaSYI0IJvkLqWX1ASG+cJOkEiA==} + engines: {node: '>=10'} - command-line-args@5.2.1: - resolution: {integrity: sha512-H4UfQhZyakIjC74I9d34fGYDwk3XpSr17QhEd0Q3I9Xq1CETHo4Hcuo87WyWHpAF1aSLjLRf5lD9ZGX2qStUvg==} - engines: {node: '>=4.0.0'} + ansi-styles@6.2.3: + resolution: {integrity: sha512-4Dj6M28JB+oAH8kFkTLUo+a2jwOFkuqb3yucU0CANcRRUbxS0cP0nZYCGjcc3BNXwRIsUVmDGgzawme7zvJHvg==} + engines: {node: '>=12'} - command-line-usage@7.0.3: - resolution: {integrity: sha512-PqMLy5+YGwhMh1wS04mVG44oqDsgyLRSKJBdOo1bnYhMKBW65gZF1dRp2OZRhiTjgUHljy99qkO7bsctLaw35Q==} - engines: {node: '>=12.20.0'} + anymatch@3.1.3: + resolution: {integrity: sha512-KMReFUr0B4t+D+OBkjR3KYqvocp2XaSzO55UcB6mgQMd3KbcE+mWTyvVV7D/zsdEbNnV6acZUutkiHQXvTr1Rw==} + engines: {node: '>= 8'} - commander@10.0.1: - resolution: {integrity: sha512-y4Mg2tXshplEbSGzx7amzPwKKOCGuoSRP/CjEdwwk0FOGlUbq6lKuoyDZTNZkmxHdJtp54hdfY/JUrdL7Xfdug==} - engines: {node: '>=14'} + apache-arrow@15.0.2: + resolution: {integrity: sha512-RvwlFxLRpO405PLGffx4N2PYLiF7FD86Q1hHl6J2XCWiq+tTCzpb9ngFw0apFDcXZBMpCzMuwAvA7hjyL1/73A==} + hasBin: true - commander@9.5.0: - resolution: {integrity: sha512-KRs7WVDKg86PWiuAqhDrAQnTXZKraVcCc6vFdL14qrZ/DcWwuRo7VoiYXalXO7S5GKpqYiVEwCbgFDfxNHKJBQ==} - engines: {node: ^12.20.0 || >=14} + arg@4.1.3: + resolution: {integrity: sha512-58S9QDqG0Xx27YwPSt9fJxivjYl432YCwfDMfZ+71RAqUrZef7LrKQZ3LHLOwCS4FLNBplP533Zx895SeOCHvA==} - complex.js@2.4.3: - resolution: {integrity: sha512-UrQVSUur14tNX6tiP4y8T4w4FeJAX3bi2cIv0pu/DTLFNxoq7z2Yh83Vfzztj6Px3X/lubqQ9IrPp7Bpn6p4MQ==} + argparse@1.0.10: + resolution: {integrity: sha512-o5Roy6tNG4SL/FOkCAN6RzjiakZS25RLYFrcMttJqbdd8BWrnA+fGz57iN5Pb06pvBGvl5gQ0B48dJlslXvoTg==} - concat-map@0.0.1: - resolution: {integrity: sha512-/Srv4dswyQNBfohGpz9o6Yb3Gz3SrUDqBH5rTuhGR7ahtlbYKnVxw2bCFMRljaA7EXHaXZ8wsHdodFvbkhKmqg==} + argparse@2.0.1: + resolution: {integrity: sha512-8+9WqebbFzpX9OR+Wa6O29asIogeRMzcGtAINdpMHHyAg10f05aSFVBbcEqGf/PXw1EjAZ+q2/bEBg3DvurK3Q==} - console-table-printer@2.12.1: - resolution: {integrity: sha512-wKGOQRRvdnd89pCeH96e2Fn4wkbenSP6LMHfjfyNLMbGuHEFbMqQNuxXqd0oXG9caIOQ1FTvc5Uijp9/4jujnQ==} + array-back@3.1.0: + resolution: {integrity: sha512-TkuxA4UCOvxuDK6NZYXCalszEzj+TLszyASooky+i742l9TqsOdYCMJJupxRic61hwquNtppB3hgcuq9SVSH1Q==} + engines: {node: '>=6'} - content-disposition@1.0.1: - resolution: {integrity: sha512-oIXISMynqSqm241k6kcQ5UwttDILMK4BiurCfGEREw6+X9jkkpEe5T9FZaApyLGGOnFuyMWZpdolTXMtvEJ08Q==} - engines: {node: '>=18'} + array-back@6.2.2: + resolution: {integrity: sha512-gUAZ7HPyb4SJczXAMUXMGAvI976JoK3qEx9v1FTmeYuJj0IBiaKttG1ydtGKdkfqWkIkouke7nG8ufGy77+Cvw==} + engines: {node: '>=12.17'} - content-type@1.0.5: - resolution: {integrity: sha512-nTjqfcBFEipKdXCv4YDQWCfmcLZKm81ldF0pAopTvyrFGVbcR6P/VAAd5G7N+0tTr8QqiU0tFadD6FK4NtJwOA==} - engines: {node: '>= 0.6'} + array-flatten@1.1.1: + resolution: {integrity: sha512-PCVAQswWemu6UdxsDFFX/+gVeYqKAod3D3UVm91jHwynguOwAvYPhx8nNlM++NqRcK6CxxpUafjmhIdKiHibqg==} - convert-source-map@2.0.0: - resolution: {integrity: sha512-Kvp459HrV2FEJ1CAsi1Ku+MY3kasH19TFykTz2xWmMeq6bk2NU3XXvfJ+Q61m0xktWwt+1HSYf3JZsTms3aRJg==} + array-union@2.1.0: + resolution: {integrity: sha512-HGyxoOTYUyCM6stUe6EJgnd4EoewAI7zMdfqO+kGjnlZmBDz/cR5pf8r/cR4Wq60sL/p0IkcjUEEPwS3GFrIyw==} + engines: {node: '>=8'} - convict@6.2.4: - resolution: {integrity: sha512-qN60BAwdMVdofckX7AlohVJ2x9UvjTNoKVXCL2LxFk1l7757EJqf1nySdMkPQer0bt8kQ5lQiyZ9/2NvrFBuwQ==} - engines: {node: '>=6'} + arrify@2.0.1: + resolution: {integrity: sha512-3duEwti880xqi4eAMN8AyR4a0ByT90zoYdLlevfrvU43vb0YZwZVfxOgxWrLXXXpyugL0hNZc9G6BiB5B3nUug==} + engines: {node: '>=8'} - cookie-signature@1.2.2: - resolution: {integrity: sha512-D76uU73ulSXrD1UXF4KE2TMxVVwhsnCgfAyTg9k8P6KGZjlXKrOLe4dJQKI3Bxi5wjesZoFXJWElNWBjPZMbhg==} - engines: {node: '>=6.6.0'} + assertion-error@2.0.1: + resolution: {integrity: sha512-Izi8RQcffqCeNVgFigKli1ssklIbpHnCYc6AknXGYoB6grJqyeby7jv12JUQgmTAnIDnbck1uxksT4dzN3PWBA==} + engines: {node: '>=12'} - cookie@0.7.2: - resolution: {integrity: sha512-yki5XnKuf750l50uGTllt6kKILY4nQ1eNIQatoXEByZ5dWgnKqbnqmTrBE5B4N7lrMJKQ2ytWMiTO2o0v6Ew/w==} - engines: {node: '>= 0.6'} + async-mutex@0.5.0: + resolution: {integrity: sha512-1A94B18jkJ3DYq284ohPxoXbfTA5HsQ7/Mf4DEhcyLx3Bz27Rh59iScbB6EPiP+B+joue6YCxcMXSbFC1tZKwA==} - cors@2.8.6: - resolution: {integrity: sha512-tJtZBBHA6vjIAaF6EnIaq6laBBP9aq/Y3ouVJjEfoHbRBcHBAHYcMh/w8LDrk2PvIMMq8gmopa5D4V8RmbrxGw==} - engines: {node: '>= 0.10'} + async-retry@1.3.3: + resolution: {integrity: sha512-wfr/jstw9xNi/0teMHrRW7dsz3Lt5ARhYNZ2ewpadnhaIp5mbALhOAP+EAdsC7t4Z6wqsDVv9+W6gm1Dk9mEyw==} - create-jest@29.7.0: - resolution: {integrity: sha512-Adz2bdH0Vq3F53KEMJOoftQFutWCukm6J24wbPWRO4k1kMY7gS7ds/uoJkNuV8wDCtWWnuwGcJwpWcih+zEW1Q==} - engines: {node: ^14.15.0 || ^16.10.0 || >=18.0.0} - hasBin: true + async@3.2.6: + resolution: {integrity: sha512-htCUDlxyyCLMgaM3xXg0C0LW2xqfuQ6p05pCEIsXuyQ+a1koYKTuBMzRNwmybfLgvJDMd0r1LTn4+E0Ti6C2AA==} - create-require@1.1.1: - resolution: {integrity: sha512-dcKFX3jn0MpIaXjisoRvexIJVEKzaq7z2rZKxf+MSr9TkdmHmsU4m2lcLojrj/FHl8mk5VxMmYA+ftRkP/3oKQ==} + asynckit@0.4.0: + resolution: {integrity: sha512-Oei9OH4tRh0YqU3GxhX79dM/mwVgvbZJaSNaRk+bshkj0S5cfHcgYakreBjrHwatXKbz+IoIdYLxrKim2MjW0Q==} - croner@10.0.1: - resolution: {integrity: sha512-ixNtAJndqh173VQ4KodSdJEI6nuioBWI0V1ITNKhZZsO0pEMoDxz539T4FTTbSZ/xIOSuDnzxLVRqBVSvPNE2g==} - engines: {node: '>=18.0'} + atomic-sleep@1.0.0: + resolution: {integrity: sha512-kNOjDqAh7px0XWNI+4QbzoiR/nTkHAWNud2uvnJquD1/x5a7EQZMJT0AczqK0Qn67oY/TTQ1LbUKajZpp3I9tQ==} + engines: {node: '>=8.0.0'} - cross-fetch@3.2.0: - resolution: {integrity: sha512-Q+xVJLoGOeIMXZmbUK4HYk+69cQH6LudR0Vu/pRm2YlU/hDV9CiS0gKUMaWY5f2NeUH9C1nV3bsTlCo0FsTV1Q==} + axios@1.13.5: + resolution: {integrity: sha512-cz4ur7Vb0xS4/KUN0tPWe44eqxrIu31me+fbang3ijiNscE129POzipJJA6zniq2C/Z6sJCjMimjS8Lc/GAs8Q==} - cross-fetch@4.1.0: - resolution: {integrity: sha512-uKm5PU+MHTootlWEY+mZ4vvXoCn4fLQxT9dSc1sXVMSFkINTJVN8cAQROpwcKm8bJ/c7rgZVIBWzH5T78sNZZw==} + babel-jest@29.7.0: + resolution: {integrity: sha512-BrvGY3xZSwEcCzKvKsCi2GgHqDqsYkOP4/by5xCgIwGXQxIEh+8ew3gmrE1y7XRR6LHZIj6yLYnUi/mm2KXKBg==} + engines: {node: ^14.15.0 || ^16.10.0 || >=18.0.0} + peerDependencies: + '@babel/core': ^7.8.0 - cross-spawn@7.0.6: - resolution: {integrity: sha512-uV2QOWP2nWzsy2aMp8aRibhi9dlzF5Hgh5SHaB9OiTGEyDTiJJyx0uy51QXdyWbtAHNua4XJzUKca3OzKUd3vA==} - engines: {node: '>= 8'} - - crypt@0.0.2: - resolution: {integrity: sha512-mCxBlsHFYh9C+HVpiEacem8FEBnMXgU9gy4zmNC+SXAZNB/1idgp/aulFJ4FgCi7GPEVbfyng092GqL2k2rmow==} - - data-uri-to-buffer@4.0.1: - resolution: {integrity: sha512-0R9ikRb668HB7QDxT1vkpuUBtqc53YyAwMwGeUFKRojY/NWKvdZ+9UYtRfGmhqNbRkTSVpMbmyhXipFFv2cb/A==} - engines: {node: '>= 12'} + babel-plugin-istanbul@6.1.1: + resolution: {integrity: sha512-Y1IQok9821cC9onCx5otgFfRm7Lm+I+wwxOx738M/WLPZ9Q42m4IG5W0FNX8WLL2gYMZo3JkuXIH2DOpWM+qwA==} + engines: {node: '>=8'} - dayjs@1.11.19: - resolution: {integrity: sha512-t5EcLVS6QPBNqM2z8fakk/NKel+Xzshgt8FFKAn+qwlD1pzZWxh0nVCrvFK7ZDb6XucZeF9z8C7CBWTRIVApAw==} + babel-plugin-jest-hoist@29.6.3: + resolution: {integrity: sha512-ESAc/RJvGTFEzRwOTT4+lNDk/GNHMkKbNzsvT0qKRfDyyYTskxB5rnU2njIDYVxXCBHHEI1c0YwHob3WaYujOg==} + engines: {node: ^14.15.0 || ^16.10.0 || >=18.0.0} - debug@4.4.1: - resolution: {integrity: sha512-KcKCqiftBJcZr++7ykoDIEwSa3XWowTfNPo92BYxjXiyYEVrUQh2aLyhxBCwww+heortUFxEJYcRzosstTEBYQ==} - engines: {node: '>=6.0'} + babel-preset-current-node-syntax@1.1.0: + resolution: {integrity: sha512-ldYss8SbBlWva1bs28q78Ju5Zq1F+8BrqBZZ0VFhLBvhh6lCpC2o3gDJi/5DRLs9FgYZCnmPYIVFU4lRXCkyUw==} peerDependencies: - supports-color: '*' - peerDependenciesMeta: - supports-color: - optional: true + '@babel/core': ^7.0.0 - debug@4.4.3: - resolution: {integrity: sha512-RGwwWnwQvkVfavKVt22FGLw+xYSdzARwm0ru6DhTVA3umU5hZc28V3kO4stgYryrTlLpuvgI9GiijltAjNbcqA==} - engines: {node: '>=6.0'} + babel-preset-jest@29.6.3: + resolution: {integrity: sha512-0B3bhxR6snWXJZtR/RliHTDPRgn1sNHOR0yVtq/IiQFyuOVjFS+wuio/R4gSNkyYmKmJB4wGZv2NZanmKmTnNA==} + engines: {node: ^14.15.0 || ^16.10.0 || >=18.0.0} peerDependencies: - supports-color: '*' - peerDependenciesMeta: - supports-color: - optional: true + '@babel/core': ^7.0.0 - decamelize@1.2.0: - resolution: {integrity: sha512-z2S+W9X73hAUUki+N+9Za2lBlun89zigOyGrsax+KUQ6wKW4ZoWpEYBkGhQjwAjjDCkWxhY0VKEhk8wzY7F5cA==} - engines: {node: '>=0.10.0'} + bail@2.0.2: + resolution: {integrity: sha512-0xO6mYd7JB2YesxDKplafRpsiOzPt9V02ddPCLbY1xYGPOX24NTyN50qnUxgCPcSoYMhKpAuBTjQoRZCAkUDRw==} - decimal.js@10.6.0: - resolution: {integrity: sha512-YpgQiITW3JXGntzdUmyUR1V812Hn8T1YVXhCu+wO3OpS4eU9l4YdD3qjyiKdV6mvV29zapkMeD390UVEf2lkUg==} + balanced-match@1.0.2: + resolution: {integrity: sha512-3oSeUO0TMV67hN1AmbXsK4yaqU7tjiHlbxRDZOpH0KW9+CeX4bRAaX0Anxt0tx2MrpRpWwQaPwIlISEJhYU5Pw==} - decode-named-character-reference@1.3.0: - resolution: {integrity: sha512-GtpQYB283KrPp6nRw50q3U9/VfOutZOe103qlN7BPP6Ad27xYnOIWv4lPzo8HCAL+mMZofJ9KEy30fq6MfaK6Q==} + base-64@0.1.0: + resolution: {integrity: sha512-Y5gU45svrR5tI2Vt/X9GPd3L0HNIKzGu202EjxrXMpuc2V2CiKgemAbUUsqYmZJvPtCXoUKjNZwBJzsNScUbXA==} - dedent@1.6.0: - resolution: {integrity: sha512-F1Z+5UCFpmQUzJa11agbyPVMbpgT/qA3/SKyJ1jyBgm7dUcUEa8v9JwDkerSQXfakBwFljIxhOJqGkjUwZ9FSA==} + base64-js@1.5.1: + resolution: {integrity: sha512-AKpaYlHn8t4SVbOHCy+b5+KKgvR4vrsD8vbvrbiQJps7fKDTkjkDry6ji0rUJjC0kzbNePLwzxq8iypo41qeWA==} + + beeai-framework@0.1.27: + resolution: {integrity: sha512-Hnq+mu1BbmtwxT1/uXUtfuKxvJ4j2fxWAq6nhMUtr/ZaevtEZKhgsDXZbTq00IHP/XXt9pjBYPI5w6hWq4AENw==} peerDependencies: - babel-plugin-macros: ^3.1.0 + '@a2a-js/sdk': ^0.3.4 + '@ai-sdk/amazon-bedrock': ^4.0.52 + '@ai-sdk/anthropic': ^3.0.39 + '@ai-sdk/azure': ^3.0.27 + '@ai-sdk/google-vertex': ^4.0.47 + '@ai-sdk/groq': ^3.0.22 + '@ai-sdk/openai': ^3.0.26 + '@aws-sdk/client-bedrock-runtime': ^3.848.0 + '@elastic/elasticsearch': ^8.0.0 + '@googleapis/customsearch': ^3.2.0 + '@ibm-cloud/watsonx-ai': '*' + '@langchain/community': ^0.2.28 + '@langchain/core': ^0.2.27 + '@modelcontextprotocol/sdk': ^1.18.2 + '@qdrant/js-client-rest': ^1.15.0 + '@zilliz/milvus2-sdk-node': ^2.6.0 + express: ^5.0.0 + ibm-cloud-sdk-core: '*' + ollama-ai-provider-v2: ^3.0.4 + sequelize: ^6.37.7 + yaml: ^2.6.1 peerDependenciesMeta: - babel-plugin-macros: + '@a2a-js/sdk': + optional: true + '@ai-sdk/amazon-bedrock': + optional: true + '@ai-sdk/anthropic': + optional: true + '@ai-sdk/azure': + optional: true + '@ai-sdk/google-vertex': + optional: true + '@ai-sdk/groq': + optional: true + '@ai-sdk/openai': + optional: true + '@elastic/elasticsearch': + optional: true + '@googleapis/customsearch': + optional: true + '@ibm-cloud/watsonx-ai': + optional: true + '@langchain/community': + optional: true + '@langchain/core': + optional: true + '@modelcontextprotocol/sdk': + optional: true + '@qdrant/js-client-rest': + optional: true + '@zilliz/milvus2-sdk-node': + optional: true + express: + optional: true + ibm-cloud-sdk-core: + optional: true + sequelize: + optional: true + yaml: optional: true - deep-eql@5.0.2: - resolution: {integrity: sha512-h5k/5U50IJJFpzfL6nO9jaaumfjO/f2NjK/oYB2Djzm4p9L+3T9qWpZqZ2hAbLPuuYq9wrU08WQyBTL5GbPk5Q==} - engines: {node: '>=6'} + bignumber.js@9.3.1: + resolution: {integrity: sha512-Ko0uX15oIUS7wJ3Rb30Fs6SkVbLmPBAKdlm7q9+ak9bbIeFf0MwuBsQV6z7+X768/cHsfg+WlysDWJcmthjsjQ==} - deepmerge@4.3.1: - resolution: {integrity: sha512-3sUqbMEc77XqpdNO7FRyRog+eW3ph+GYCbj+rK+uYyRMuwsVy0rMiVtPn+QJlKFvWP/1PYpapqYn0Me2knFn+A==} - engines: {node: '>=0.10.0'} + binary-extensions@2.3.0: + resolution: {integrity: sha512-Ceh+7ox5qe7LJuLHoY0feh3pHuUDHAcRUeyL2VYghZwfpkNIy/+8Ocg0a3UuSoYzavmylwuLWQOf3hl0jjMMIw==} + engines: {node: '>=8'} - delayed-stream@1.0.0: - resolution: {integrity: sha512-ZySD7Nf91aLB0RxL4KGrKHBXl7Eds1DAmEdcoVawXnLD7SDhpNgtuII2aAkg7a7QS41jxPSZ17p4VdGnMHk3MQ==} - engines: {node: '>=0.4.0'} + binary-search@1.3.6: + resolution: {integrity: sha512-nbE1WxOTTrUWIfsfZ4aHGYu5DOuNkbxGokjV6Z2kxfJK3uaAb8zNK1muzOeipoLHZjInT4Br88BHpzevc681xA==} - depd@2.0.0: - resolution: {integrity: sha512-g7nH6P6dyDioJogAAGprGpCtVImJhpPk/roCzdb3fIh61/s/nPsfR6onyMwkCAR/OlC3yBC0lESvUoQEAssIrw==} - engines: {node: '>= 0.8'} + body-parser@1.20.8: + resolution: {integrity: sha512-JNcyFQ64OiijEkPzUBTCe+hyPXUD/3LEldGQ6iF5LR1w00mx9o7xtDWHXBY2iItjdCFGoilOLNQbH943ut7pHA==} + engines: {node: '>= 0.8', npm: 1.2.8000 || >= 1.4.16} - dequal@2.0.3: - resolution: {integrity: sha512-0je+qPKHEMohvfRTCEo3CrPG6cAzAYgmzKyxRiYSSDkS6eGJdyVJm7WaYA5ECaAD9wLB2T4EEeymA5aFVcYXCA==} - engines: {node: '>=6'} + body-parser@2.2.2: + resolution: {integrity: sha512-oP5VkATKlNwcgvxi0vM0p/D3n2C3EReYVX+DNYs5TjZFn/oQt2j+4sVJtSMr18pdRr8wjTcBl6LoV+FUwzPmNA==} + engines: {node: '>=18'} - detect-newline@3.1.0: - resolution: {integrity: sha512-TLz+x/vEXm/Y7P7wn1EJFNLxYpUD4TgMosxY6fAVJUnJMbupHBOncxyWUG9OpTaH9EBD7uFI5LfEgmMOc54DsA==} - engines: {node: '>=8'} + bowser@2.13.1: + resolution: {integrity: sha512-OHawaAbjwx6rqICCKgSG0SAnT05bzd7ppyKLVUITZpANBaaMFBAsaNkto3LoQ31tyFP5kNujE8Cdx85G9VzOkw==} - devlop@1.1.0: - resolution: {integrity: sha512-RWmIqhcFf1lRYBvNmr7qTNuyCt/7/ns2jbpp1+PalgE/rDQcBT0fioSMUpJ93irlUhC5hrg4cYqe6U+0ImW0rA==} + brace-expansion@1.1.11: + resolution: {integrity: sha512-iCuPHDFgrHX7H2vEI/5xpz07zSHB00TpugqhmYtVmMO6518mCuRMoOYFldEBl0g187ufozdaHgWKcYFb61qGiA==} - diff-sequences@29.6.3: - resolution: {integrity: sha512-EjePK1srD3P08o2j4f0ExnylqRs5B9tJjcp9t1krH2qRi8CCdsYfwe9JgSLurFBWwq4uOlipzfk5fHNvwFKr8Q==} - engines: {node: ^14.15.0 || ^16.10.0 || >=18.0.0} + brace-expansion@2.0.2: + resolution: {integrity: sha512-Jt0vHyM+jmUBqojB7E1NIYadt0vI0Qxjxd2TErW94wDz+E2LAm5vKMXXwg6ZZBTHPuUlDgQHKXvjGBdfcF1ZDQ==} - diff@4.0.2: - resolution: {integrity: sha512-58lmxKSA4BNyLz+HHMUzlOEpg09FV+ev6ZMe3vJihgdxzgcwZ8VoEEPmALCZG9LmqfVoNMMKpttIYTVG6uDY7A==} - engines: {node: '>=0.3.1'} + braces@3.0.3: + resolution: {integrity: sha512-yQbXgO/OSZVD2IsiLlro+7Hf6Q18EJrKSEsdoMzKePKXct3gvD8oLcOQdIzGupr5Fj+EDe8gO/lxc1BzfMpxvA==} + engines: {node: '>=8'} - digest-fetch@1.3.0: - resolution: {integrity: sha512-CGJuv6iKNM7QyZlM2T3sPAdZWd/p9zQiRNS9G+9COUCwzWFTs0Xp8NF5iePx7wtvhDykReiRRrSeNb4oMmB8lA==} + browserslist@4.24.5: + resolution: {integrity: sha512-FDToo4Wo82hIdgc1CQ+NQD0hEhmpPjrZ3hiUgwgOG6IuTdlpr8jdjyG24P6cNP1yJpTLzS5OcGgSw0xmDU1/Tw==} + engines: {node: ^6 || ^7 || ^8 || ^9 || ^10 || ^11 || ^12 || >=13.7} + hasBin: true - dir-glob@3.0.1: - resolution: {integrity: sha512-WkrWp9GR4KXfKGYzOLmTuGVi1UWFfws377n9cc55/tb6DuqyF6pcQ5AbiHEshaDpY9v6oaSr2XCDidGmMwdzIA==} - engines: {node: '>=8'} + bs-logger@0.2.6: + resolution: {integrity: sha512-pd8DCoxmbgc7hyPKOvxtqNcjYoOsABPQdcCUjGp3d42VR2CX1ORhk2A87oqqu5R1kk+76nsxZupkmyd+MVtCog==} + engines: {node: '>= 6'} - dom-serializer@2.0.0: - resolution: {integrity: sha512-wIkAryiqt/nV5EQKqQpo3SToSOV9J0DnbJqwK7Wv/Trc92zIAYZ4FlMu+JPFW1DfGFt81ZTCGgDEabffXeLyJg==} + bser@2.1.1: + resolution: {integrity: sha512-gQxTNE/GAfIIrmHLUE3oJyp5FO6HRBfhjnw4/wMmA63ZGDJnWBmgY/lyQBpnDUkGmAhbSe39tx2d/iTOAfglwQ==} - domelementtype@2.3.0: - resolution: {integrity: sha512-OLETBj6w0OsagBwdXnPdN0cnMfF9opN69co+7ZrbfPGrdpPVNBUj02spi6B1N7wChLQiPn4CSH/zJvXw56gmHw==} + bson@6.10.4: + resolution: {integrity: sha512-WIsKqkSC0ABoBJuT1LEX+2HEvNmNKKgnTAyd0fL8qzK4SH2i9NXg+t08YtdZp/V9IZ33cxe3iV4yM0qg8lMQng==} + engines: {node: '>=16.20.1'} - domhandler@5.0.3: - resolution: {integrity: sha512-cgwlv/1iFQiFnU96XXgROh8xTeetsnJiDsTc7TYCLFd9+/WNkIqPTxiM/8pSd8VIrhXGTf1Ny1q1hquVqDJB5w==} - engines: {node: '>= 4'} + buffer-equal-constant-time@1.0.1: + resolution: {integrity: sha512-zRpUiDwd/xk6ADqPMATG8vc9VPrkck7T07OIx0gnjmJAnHnTVXNQG3vfvWNuiZIkwu9KrKdA1iJKfsfTVxE6NA==} - domutils@3.2.2: - resolution: {integrity: sha512-6kZKyUajlDuqlHKVX1w7gyslj9MPIXzIFiz/rGu35uC1wMi+kMhQwGhl4lt9unC9Vb9INnY9Z3/ZA3+FhASLaw==} + buffer-from@1.1.2: + resolution: {integrity: sha512-E+XQCRwSbaaiChtv6k6Dwgc+bx+Bs6vuKJHHl5kox/BaKbhiXzqQOwK4cO22yElGp2OCmjwVhT3HmxgyPGnJfQ==} - dot-prop@6.0.1: - resolution: {integrity: sha512-tE7ztYzXHIeyvc7N+hR3oi7FIbf/NIjVP9hmAt3yMXzrQ072/fpjGLx2GxNxGxUl5V73MEqYzioOMoVhGMJ5cA==} - engines: {node: '>=10'} + buffer@6.0.3: + resolution: {integrity: sha512-FTiCpNxtwiZZHEZbcbTIcZjERVICn9yq/pDFkTl95/AxzD1naBctN7YO68riM/gLSDY7sdrMby8hofADYuuqOA==} - dotenv@16.5.0: - resolution: {integrity: sha512-m/C+AwOAr9/W1UOIZUo232ejMNnJAJtYQjUbHoNTBNTJSvqzzDh7vnrei3o3r3m9blf6ZoDkvcw0VmozNRFJxg==} - engines: {node: '>=12'} + bytes@3.1.2: + resolution: {integrity: sha512-/Nf7TyzTx6S3yRJObOAV7956r8cr2+Oj8AC5dt8wSP3BQAoeX58NoHyCU8P8zGkNXStjTSi6fzO6F0pBdcYbEg==} + engines: {node: '>= 0.8'} - dotenv@17.4.2: - resolution: {integrity: sha512-nI4U3TottKAcAD9LLud4Cb7b2QztQMUEfHbvhTH09bqXTxnSie8WnjPALV/WMCrJZ6UV/qHJ6L03OqO3LcdYZw==} - engines: {node: '>=12'} + cac@6.7.14: + resolution: {integrity: sha512-b6Ilus+c3RrdDk+JhLKUAQfzzgLEPy6wcXqS7f/xe1EETvsDP6GORG7SFuOs6cID5YkqchW/LXZbX5bc8j7ZcQ==} + engines: {node: '>=8'} - duck-duck-scrape@2.2.7: - resolution: {integrity: sha512-BEcglwnfx5puJl90KQfX+Q2q5vCguqyMpZcSRPBWk8OY55qWwV93+E+7DbIkrGDW4qkqPfUvtOUdi0lXz6lEMQ==} + call-bind-apply-helpers@1.0.2: + resolution: {integrity: sha512-Sp1ablJ0ivDkSzjcaJdxEunN5/XvksFJ2sMBFfq6x0ryhQV/2b/KwFe21cMpmHtPOSij8K99/wSfoEuTObmuMQ==} + engines: {node: '>= 0.4'} - dunder-proto@1.0.1: - resolution: {integrity: sha512-KIN/nDJBQRcXw0MLVhZE9iQHmG68qAVIBg9CqmUYjmQIhgij9U5MFvrqkUL5FbtyyzZuOeOt0zdeRe4UY7ct+A==} + call-bound@1.0.4: + resolution: {integrity: sha512-+ys997U96po4Kx/ABpBCqhA9EuxJaQWDQg7295H4hBphv3IZg0boBKuwYpt4YXp6MZ5AmZQnU/tyMTlRpaSejg==} engines: {node: '>= 0.4'} - duplexify@4.1.3: - resolution: {integrity: sha512-M3BmBhwJRZsSx38lZyhE53Csddgzl5R7xGJNk7CVddZD6CcmwMCH8J+7AprIrQKH7TonKxaCjcv27Qmf+sQ+oA==} + caller@1.1.0: + resolution: {integrity: sha512-n+21IZC3j06YpCWaxmUy5AnVqhmCIM2bQtqQyy00HJlmStRt6kwDX5F9Z97pqwAB+G/tgSz6q/kUBbNyQzIubw==} - eastasianwidth@0.2.0: - resolution: {integrity: sha512-I88TYZWc9XiYHRQ4/3c5rjjfgkjhLyW2luGIheGERbNQ6OY7yTybanSpDXZa8y7VUP9YmDcYa+eyq4ca7iLqWA==} + callsites@3.1.0: + resolution: {integrity: sha512-P8BjAsXvZS+VIDUI11hHCQEv74YT67YUi5JJFNWIqL235sBmjX4+qx9Muvls5ivyNENctx46xQLQ3aTuE7ssaQ==} + engines: {node: '>=6'} - ecdsa-sig-formatter@1.0.11: - resolution: {integrity: sha512-nagl3RYrbNv6kQkeJIpt6NJZy8twLB/2vtz6yN9Z4vRKHN4/QZJIEbqohALSgwKdnksuY3k5Addp5lg8sVoVcQ==} + camelcase-keys@9.1.3: + resolution: {integrity: sha512-Rircqi9ch8AnZscQcsA1C47NFdaO3wukpmIRzYcDOrmvgt78hM/sj5pZhZNec2NM12uk5vTwRHZ4anGcrC4ZTg==} + engines: {node: '>=16'} - ee-first@1.1.1: - resolution: {integrity: sha512-WMwm9LhRUo+WUaRN+vRuETqG89IgZphVSNkdFgeb6sS/E4OrDIN7t48CAewSHXc6C8lefD8KKfr5vY61brQlow==} + camelcase@4.1.0: + resolution: {integrity: sha512-FxAv7HpHrXbh3aPo4o2qxHay2lkLY3x5Mw3KeE4KQE8ysVfziWeRZDwcjauvwBSGEC/nXUPzZy8zeh4HokqOnw==} + engines: {node: '>=4'} - electron-to-chromium@1.5.155: - resolution: {integrity: sha512-ps5KcGGmwL8VaeJlvlDlu4fORQpv3+GIcF5I3f9tUKUlJ/wsysh6HU8P5L1XWRYeXfA0oJd4PyM8ds8zTFf6Ng==} + camelcase@5.3.1: + resolution: {integrity: sha512-L28STB170nwWS63UjtlEOE3dldQApaJXZkOI1uMFfzf3rRuPegHaHesyee+YxQ+W6SvRDQV6UrdOdRiR153wJg==} + engines: {node: '>=6'} - emittery@0.13.1: - resolution: {integrity: sha512-DeWwawk6r5yR9jFgnDKYt4sLS0LmHJJi3ZOnb5/JdbYwj3nW+FxQnHIjhBKz8YLC7oRNPVM9NQ47I3CVx34eqQ==} - engines: {node: '>=12'} + camelcase@6.3.0: + resolution: {integrity: sha512-Gmy6FhYlCY7uOElZUSbxo2UCDH8owEk996gkbrpsgGtrJLM3J7jGxl9Ic7Qwwj4ivOE5AWZWRMecDdF7hqGjFA==} + engines: {node: '>=10'} - emoji-regex@8.0.0: - resolution: {integrity: sha512-MSjYzcWNOA0ewAHpz0MxpYFvwg6yjy1NG3xteoqz644VCo/RPgnr1/GGt+ic3iJTzQ8Eu3TdM14SawnVUmGE6A==} + camelcase@8.0.0: + resolution: {integrity: sha512-8WB3Jcas3swSvjIeA2yvCJ+Miyz5l1ZmB6HFb9R1317dt9LCQoswg/BGrmAmkWVEszSrrg4RwmO46qIm2OEnSA==} + engines: {node: '>=16'} - emoji-regex@9.2.2: - resolution: {integrity: sha512-L18DaJsXSUk2+42pv8mLs5jJT2hqFkFE4j21wOmgbUqsZ2hL72NsUU785g9RXgo3s0ZNgVl42TiHp3ZtOv/Vyg==} - - enabled@2.0.0: - resolution: {integrity: sha512-AKrN98kuwOzMIdAizXGI86UFBoo26CL21UM763y1h/GMSJ4/OHU9k2YlsmBpyScFo/wbLzWQJBMCW4+IO3/+OQ==} - - encodeurl@2.0.0: - resolution: {integrity: sha512-Q0n9HRi4m6JuGIV1eFlmvJB7ZEVxu93IrMyiMsGC0lrMJMWzRgx6WGquyfQgZVb31vhGgXnfmPNNXmxnOkRBrg==} - engines: {node: '>= 0.8'} - - end-of-stream@1.4.5: - resolution: {integrity: sha512-ooEGc6HP26xXq/N+GCGOT0JKCLDGrq2bQUZrQ7gyrJiZANJ/8YDTxTpQBXGMn+WbIQXNVpyWymm7KYVICQnyOg==} + caniuse-lite@1.0.30001718: + resolution: {integrity: sha512-AflseV1ahcSunK53NfEs9gFWgOEmzr0f+kaMFA4xiLZlr9Hzt7HxcSpIFcnNCUkz6R6dWKa54rUz3HUmI3nVcw==} - entities@4.5.0: - resolution: {integrity: sha512-V0hjH4dGPh9Ao5p0MoRY6BVqtwCjhz6vI5LT8AJ55H+4g9/4vbHx1I54fS0XuclLhDHArPQCiMjDxjaL8fPxhw==} - engines: {node: '>=0.12'} + ccount@2.0.1: + resolution: {integrity: sha512-eyrF0jiFpY+3drT6383f1qhkbGsLSifNAjA61IUjZjmLCWjItY6LB9ft9YhoDgwfmclB2zhu51Lc7+95b8NRAg==} - error-ex@1.3.2: - resolution: {integrity: sha512-7dFHNmqeFSEt2ZBsCriorKnn3Z2pj+fd9kmI6QoWw4//DL+icEBfc0U7qJCisqrTsKTjw4fNFy2pW9OqStD84g==} + chai@5.3.3: + resolution: {integrity: sha512-4zNhdJD/iOjSH0A05ea+Ke6MU5mmpQcbQsSOkgdaUMJ9zTlDTD/GYlwohmIE2u0gaxHYiVHEn1Fw9mZ/ktJWgw==} + engines: {node: '>=18'} - es-define-property@1.0.1: - resolution: {integrity: sha512-e3nRfgfUZ4rNGL232gUgX06QNyyez04KdjFrF+LTRoOXmrOgFKDg4BCdsjW8EnT69eqdYGmRpJwiPVYNrCaW3g==} - engines: {node: '>= 0.4'} + chalk-template@0.4.0: + resolution: {integrity: sha512-/ghrgmhfY8RaSdeo43hNXxpoHAtxdbskUHjPpfqUWGttFgycUhYPGx3YZBCnUCvOa7Doivn1IZec3DEGFoMgLg==} + engines: {node: '>=12'} - es-errors@1.3.0: - resolution: {integrity: sha512-Zf5H2Kxt2xjTvbJvP2ZWLEICxA6j+hAmMzIlypy4xcBg1vKVnx89Wy0GbS+kf5cwCVFFzdCFh2XSCFNULS6csw==} - engines: {node: '>= 0.4'} + chalk@4.1.2: + resolution: {integrity: sha512-oKnbhFyRIXpUuez8iBMmyEa4nbj4IOQyuhc/wy9kY7/WVPcwIO9VA668Pu8RkO7+0G76SLROeyw9CpQ061i4mA==} + engines: {node: '>=10'} - es-module-lexer@1.7.0: - resolution: {integrity: sha512-jEQoCwk8hyb2AZziIOLhDqpm5+2ww5uIE6lkO/6jcOCusfk6LhMHpXXfBLXTZ7Ydyt0j4VoUQv6uGNYbdW+kBA==} + char-regex@1.0.2: + resolution: {integrity: sha512-kWWXztvZ5SBQV+eRgKFeh8q5sLuZY2+8WUIzlxWVTg+oGwY14qylx1KbKzHd8P6ZYkAg0xyIDU9JMHhyJMZ1jw==} + engines: {node: '>=10'} - es-object-atoms@1.1.1: - resolution: {integrity: sha512-FGgH2h8zKNim9ljj7dankFPcICIK9Cp5bm+c2gQSYePhpaG5+esrLODihIorn+Pe6FGJzWhXQotPv73jTaldXA==} - engines: {node: '>= 0.4'} + character-entities@2.0.2: + resolution: {integrity: sha512-shx7oQ0Awen/BRIdkjkvz54PnEEI/EjwXDSIZp86/KKdbafHh1Df/RYGBhn4hbe2+uKC9FnT5UCEdyPz3ai9hQ==} - es-set-tostringtag@2.1.0: - resolution: {integrity: sha512-j6vWzfrGVfyXxge+O0x5sh6cvxAog0a/4Rdd2K36zCMV5eJ+/+tOAngRO8cODMNWbVRdVlmGZQL2YS3yR8bIUA==} - engines: {node: '>= 0.4'} + charenc@0.0.2: + resolution: {integrity: sha512-yrLQ/yVUFXkzg7EDQsPieE/53+0RlaWTs+wBrvW36cyilJ2SaDWfl4Yj7MtLTXleV9uEKefbAGUPv2/iWSooRA==} - esbuild@0.27.2: - resolution: {integrity: sha512-HyNQImnsOC7X9PMNaCIeAm4ISCQXs5a5YasTXVliKv4uuBo1dKrG0A+uQS8M5eXjVMnLg3WgXaKvprHlFJQffw==} - engines: {node: '>=18'} - hasBin: true + chat@4.30.0: + resolution: {integrity: sha512-8LXrauKckMmR83FcYC/R8nNEda5VJDDdIhZwUUu+hzaSbk4lqsro0IWm7rB1GGYXONRrUOG2XJlkNr4C15vgMA==} + engines: {node: '>=20'} + peerDependencies: + ai: ^6.0.182 + zod: ^3.0.0 || ^4.0.0 + peerDependenciesMeta: + ai: + optional: true + zod: + optional: true - escalade@3.2.0: - resolution: {integrity: sha512-WUj2qlxaQtO4g6Pq5c29GTcWGDyd8itL8zTlipgECz3JesAiiOKotd8JU6otB3PACgG6xkJUyVhboMS+bje/jA==} - engines: {node: '>=6'} + check-error@2.1.3: + resolution: {integrity: sha512-PAJdDJusoxnwm1VwW07VWwUN1sl7smmC3OKggvndJFadxxDRyFJBX/ggnu/KE4kQAB7a3Dp8f/YXC1FlUprWmA==} + engines: {node: '>= 16'} - escape-html@1.0.3: - resolution: {integrity: sha512-NiSupZ4OeuGwr68lGIeym/ksIZMJodUGOSCZ/FSnTxcrekbvqrgdUxlJOMpijaKZVjAJrWrGs/6Jy8OMuyj9ow==} + chokidar@3.6.0: + resolution: {integrity: sha512-7VT13fmjotKpGipCW9JEQAusEPE+Ei8nl6/g4FBAmIm0GOOLMua9NDDo/DWp0ZAxCr3cPq5ZpBqmPAQgDda2Pw==} + engines: {node: '>= 8.10.0'} - escape-latex@1.2.0: - resolution: {integrity: sha512-nV5aVWW1K0wEiUIEdZ4erkGGH8mDxGyxSeqPzRNtWP7ataw+/olFObw7hujFWlVjNsaDFw5VZ5NzVSIqRgfTiw==} + chromadb@1.10.5: + resolution: {integrity: sha512-+IeTjjf44pKUY3vp1BacwO2tFAPcWCd64zxPZZm98dVj/kbSBeaHKB2D6eX7iRLHS1PTVASuqoR6mAJ+nrsTBg==} + engines: {node: '>=14.17.0'} + peerDependencies: + '@google/generative-ai': ^0.1.1 + cohere-ai: ^5.0.0 || ^6.0.0 || ^7.0.0 + ollama: ^0.5.0 + openai: ^3.0.0 || ^4.0.0 + voyageai: ^0.0.3-1 + peerDependenciesMeta: + '@google/generative-ai': + optional: true + cohere-ai: + optional: true + ollama: + optional: true + openai: + optional: true + voyageai: + optional: true - escape-string-regexp@2.0.0: - resolution: {integrity: sha512-UpzcLCXolUWcNu5HtVMHYdXJjArjsF9C0aNnquZYY4uW/Vu0miy5YoWvbV345HauVvcAUnpRuhMMcqTcGOY2+w==} + ci-info@3.9.0: + resolution: {integrity: sha512-NIxF55hv4nSqQswkAeiOi1r83xy8JldOFDTWiug55KBu9Jnblncd2U6ViHmYgHf01TPZS77NJBhBMKdWj9HQMQ==} engines: {node: '>=8'} - escape-string-regexp@5.0.0: - resolution: {integrity: sha512-/veY75JbMK4j1yjvuUxuVsiS/hr/4iHs9FTT6cgTexxdE0Ly/glccBAkloH/DofkjRbZU3bnoj38mOmhkZ0lHw==} - engines: {node: '>=12'} - - esprima@4.0.1: - resolution: {integrity: sha512-eGuFFw7Upda+g4p+QHvnW0RyTX/SVeJBDM/gCtMARO0cLuT2HcEKnTPvhjV6aGeqrCB/sbNop0Kszm0jsaWU4A==} - engines: {node: '>=4'} - hasBin: true - - estree-walker@3.0.3: - resolution: {integrity: sha512-7RUKfXgSMMkzt6ZuXmqapOurLGPPfgj6l9uRZ7lRGolvk0y2yocc35LdcxKC5PQZdn2DMqioAQ2NoWcrTKmm6g==} + cjs-module-lexer@1.4.3: + resolution: {integrity: sha512-9z8TZaGM1pfswYeXrUpzPrkx8UnWYdhJclsiYMm6x/w5+nN+8Tf/LnAgfLGQCm59qAOxU8WwHEq2vNwF6i4j+Q==} - etag@1.8.1: - resolution: {integrity: sha512-aIL5Fx7mawVa300al2BnEE4iNvo1qETxLrPI/o05L7z6go7fCw1J6EQmbK4FmJ2AS7kgVF/KEZWufBfdClMcPg==} - engines: {node: '>= 0.6'} + cliui@8.0.1: + resolution: {integrity: sha512-BSeNnyus75C4//NQ9gQt1/csTXyo/8Sb+afLAkzAptFuMsod9HFokGNudZpi/oQV73hnVK+sR+5PVRMd+Dr7YQ==} + engines: {node: '>=12'} - event-target-shim@5.0.1: - resolution: {integrity: sha512-i/2XbnSz/uxRCU6+NdVJgKWDTM427+MqYbkQzD321DuCQJUqOuJKIA0IM2+W2xtYHdKOmZ4dR6fExsd4SXL+WQ==} + clone-deep@4.0.1: + resolution: {integrity: sha512-neHB9xuzh/wk0dIHweyAXv2aPGZIVk3pLMe+/RNzINf17fe0OG96QroktYAUm7SM1PBnzTabaLboqqxDyMU+SQ==} engines: {node: '>=6'} - eventemitter3@4.0.7: - resolution: {integrity: sha512-8guHBZCwKnFhYdHr2ysuRWErTwhoN2X8XELRlrRwpmfeY2jjuUN4taQMsULKUVo1K4DvZl+0pgfyoysHxvmvEw==} + cluster-key-slot@1.1.2: + resolution: {integrity: sha512-RMr0FhtfXemyinomL4hrWcYJxmX6deFdCxpJzhDttxgO1+bcCnkk+9drydLVDmAMG7NE6aN/fl4F7ucU/90gAA==} + engines: {node: '>=0.10.0'} - eventemitter3@5.0.4: - resolution: {integrity: sha512-mlsTRyGaPBjPedk6Bvw+aqbsXDtoAyAzm5MO7JgU+yVRyMQ5O8bD4Kcci7BS85f93veegeCPkL8R4GLClnjLFw==} + co@4.6.0: + resolution: {integrity: sha512-QVb0dM5HvG+uaxitm8wONl7jltx8dqhfU33DcqtOZcLSVIKSDDLDi7+0LbAKiyI8hD9u42m2YxXSkMGWThaecQ==} + engines: {iojs: '>= 1.0.0', node: '>= 0.12.0'} - events@3.3.0: - resolution: {integrity: sha512-mQw+2fkQbALzQ7V0MY0IqdnXNOeTtP4r0lN9z7AAawCXgqea7bDii20AYrIBrFd/Hx0M2Ocz6S111CaFkUcb0Q==} - engines: {node: '>=0.8.x'} + codsen-utils@1.7.3: + resolution: {integrity: sha512-YIFQQ1n2NSgwoB3sCe7RpkZzsrPxTMek6jc7wC9fXOm1wwfWAKja9gLOMEjlXOUd3LKV3o6Jci7n9BoHs5Z8Sg==} + engines: {node: '>=14.18.0'} - eventsource-parser@3.0.6: - resolution: {integrity: sha512-Vo1ab+QXPzZ4tCa8SwIHJFaSzy4R6SHf7BY79rFBDf0idraZWAkYrDjDj8uWaSm3S2TK+hJ7/t1CEmZ7jXw+pg==} + cohere-ai@7.20.0: + resolution: {integrity: sha512-h/3h3pcLXRUmkzp/W+/FWViEMcAFtSZ8YayCTFQXpib112uNSj3feApOtJg7v9lreWR1t7gznhE6N9KNCX5FOA==} engines: {node: '>=18.0.0'} - eventsource-parser@3.1.0: - resolution: {integrity: sha512-kJezFj9YFAMLeORyi7aCLxLbD5/qWMQnoMVlVPyHIll7lgRJCc3JVln9Vgl9nwQi0YkMnhdGTMNn7CkRRAptMg==} - engines: {node: '>=18.0.0'} + collect-v8-coverage@1.0.2: + resolution: {integrity: sha512-lHl4d5/ONEbLlJvaJNtsF/Lz+WvB07u2ycqTYbdrq7UypDXailES4valYb2eWiJFxZlVmpGekfqoxQhzyFdT4Q==} - eventsource@3.0.7: - resolution: {integrity: sha512-CRT1WTyuQoD771GW56XEZFQ/ZoSfWid1alKGDYMmkt2yl8UXrVR4pspqWNEcqKvVIzg6PAltWjxcSSPrboA4iA==} - engines: {node: '>=18.0.0'} + color-convert@2.0.1: + resolution: {integrity: sha512-RRECPsj7iu/xb5oKYcsFHSppFNnsj/52OVTRKb4zP5onXwVF3zVmmToNcOfGC+CRDpfK/U584fMg38ZHCaElKQ==} + engines: {node: '>=7.0.0'} - execa@5.1.1: - resolution: {integrity: sha512-8uSpZZocAZRBAPIEINJj3Lo9HyGitllczc27Eh5YYojjMFMn8yHMDMaUHE2Jqfq05D/wucwI4JGURyXt1vchyg==} - engines: {node: '>=10'} + color-convert@3.1.3: + resolution: {integrity: sha512-fasDH2ont2GqF5HpyO4w0+BcewlhHEZOFn9c1ckZdHpJ56Qb7MHhH/IcJZbBGgvdtwdwNbLvxiBEdg336iA9Sg==} + engines: {node: '>=14.6'} - execa@9.6.1: - resolution: {integrity: sha512-9Be3ZoN4LmYR90tUoVu2te2BsbzHfhJyfEiAVfz7N5/zv+jduIfLrV2xdQXOHbaD6KgpGdO9PRPM1Y4Q9QkPkA==} - engines: {node: ^18.19.0 || >=20.5.0} + color-name@1.1.4: + resolution: {integrity: sha512-dOy+3AuW3a2wNbZHIuMZpTcgjGuLU/uBL/ubcZF9OXbDo8ff4O8yVp5Bf0efS8uEoYo5q4Fx7dY9OgQGXgAsQA==} - exit@0.1.2: - resolution: {integrity: sha512-Zk/eNKV2zbjpKzrsQ+n1G6poVbErQxJ0LBOJXaKZ1EViLzH+hrLu9cdXI4zw9dBQJslwBEpbQ2P1oS7nDxs6jQ==} - engines: {node: '>= 0.8.0'} + color-name@2.1.0: + resolution: {integrity: sha512-1bPaDNFm0axzE4MEAzKPuqKWeRaT43U/hyxKPBdqTfmPF+d6n7FSoTFxLVULUJOmiLp01KjhIPPH+HrXZJN4Rg==} + engines: {node: '>=12.20'} - expect-type@1.3.0: - resolution: {integrity: sha512-knvyeauYhqjOYvQ66MznSMs83wmHrCycNEN6Ao+2AeYEfxUIkuiVxdEa1qlGEPK+We3n0THiDciYSsCcgW/DoA==} - engines: {node: '>=12.0.0'} + color-string@2.1.4: + resolution: {integrity: sha512-Bb6Cq8oq0IjDOe8wJmi4JeNn763Xs9cfrBcaylK1tPypWzyoy2G3l90v9k64kjphl/ZJjPIShFztenRomi8WTg==} + engines: {node: '>=18'} - expect@29.7.0: - resolution: {integrity: sha512-2Zks0hf1VLFYI1kbh0I5jP3KHHyCHpkfyHBzsSXRFgl/Bg9mWYfMW8oD+PdMPlEwy5HNsR9JutYy6pMeOh61nw==} - engines: {node: ^14.15.0 || ^16.10.0 || >=18.0.0} + color@5.0.3: + resolution: {integrity: sha512-ezmVcLR3xAVp8kYOm4GS45ZLLgIE6SPAFoduLr6hTDajwb3KZ2F46gulK3XpcwRFb5KKGCSezCBAY4Dw4HsyXA==} + engines: {node: '>=18'} - expr-eval@2.0.2: - resolution: {integrity: sha512-4EMSHGOPSwAfBiibw3ndnP0AvjDWLsMvGOvWEZ2F96IGk0bIVdjQisOHxReSkE13mHcfbuCiXw+G4y0zv6N8Eg==} + colorette@2.0.20: + resolution: {integrity: sha512-IfEDxwoWIjkeXL1eXcDiow4UbKjhLdq6/EuSVR9GMN7KVH3r9gQ83e73hsz1Nd1T3ijd5xv1wcWRYO+D6kCI2w==} - express-rate-limit@7.5.1: - resolution: {integrity: sha512-7iN8iPMDzOMHPUYllBEsQdWVB6fPDMPqwjBaFrgr4Jgr/+okjvzAy+UHlYYL/Vs0OsOrMkwS6PJDkFlJwoxUnw==} - engines: {node: '>= 16'} - peerDependencies: - express: '>= 4.11' + combined-stream@1.0.8: + resolution: {integrity: sha512-FQN4MRfuJeHf7cBbBMJFXhKSDq+2kAArBlmRBvcvFE5BB1HZKXtSFASDhdlz9zOYwxh8lDdnvmMOe/+5cdoEdg==} + engines: {node: '>= 0.8'} - express-rate-limit@8.2.1: - resolution: {integrity: sha512-PCZEIEIxqwhzw4KF0n7QF4QqruVTcF73O5kFKUnGOyjbCCgizBBiFaYpd/fnBLUMPw/BWw9OsiN7GgrNYr7j6g==} - engines: {node: '>= 16'} - peerDependencies: - express: '>= 4.11' + command-line-args@5.2.1: + resolution: {integrity: sha512-H4UfQhZyakIjC74I9d34fGYDwk3XpSr17QhEd0Q3I9Xq1CETHo4Hcuo87WyWHpAF1aSLjLRf5lD9ZGX2qStUvg==} + engines: {node: '>=4.0.0'} - express@5.2.1: - resolution: {integrity: sha512-hIS4idWWai69NezIdRt2xFVofaF4j+6INOpJlVOLDO8zXGpUVEVzIYk12UUi2JzjEzWL3IOAxcTubgz9Po0yXw==} - engines: {node: '>= 18'} + command-line-usage@7.0.3: + resolution: {integrity: sha512-PqMLy5+YGwhMh1wS04mVG44oqDsgyLRSKJBdOo1bnYhMKBW65gZF1dRp2OZRhiTjgUHljy99qkO7bsctLaw35Q==} + engines: {node: '>=12.20.0'} - extend-shallow@2.0.1: - resolution: {integrity: sha512-zCnTtlxNoAiDc3gqY2aYAWFx7XWWiasuF2K8Me5WbN8otHKTUKBwjPtNpRs/rbUZm7KxWAaNj7P1a/p52GbVug==} - engines: {node: '>=0.10.0'} + commander@10.0.1: + resolution: {integrity: sha512-y4Mg2tXshplEbSGzx7amzPwKKOCGuoSRP/CjEdwwk0FOGlUbq6lKuoyDZTNZkmxHdJtp54hdfY/JUrdL7Xfdug==} + engines: {node: '>=14'} - extend@3.0.2: - resolution: {integrity: sha512-fjquC59cD7CyW6urNXK0FBufkZcoiGG80wTuPujX590cB5Ttln20E2UB4S/WARVqhXffZl2LNgS+gQdPIIim/g==} + commander@9.5.0: + resolution: {integrity: sha512-KRs7WVDKg86PWiuAqhDrAQnTXZKraVcCc6vFdL14qrZ/DcWwuRo7VoiYXalXO7S5GKpqYiVEwCbgFDfxNHKJBQ==} + engines: {node: ^12.20.0 || >=14} - fast-deep-equal@3.1.3: - resolution: {integrity: sha512-f3qQ9oQy9j2AhBe/H9VC91wLmKBCCU/gDOnKNAYG5hswO7BLKj09Hc5HYNz9cGI++xlpDCIgDaitVs03ATR84Q==} + complex.js@2.4.3: + resolution: {integrity: sha512-UrQVSUur14tNX6tiP4y8T4w4FeJAX3bi2cIv0pu/DTLFNxoq7z2Yh83Vfzztj6Px3X/lubqQ9IrPp7Bpn6p4MQ==} - fast-glob@3.3.3: - resolution: {integrity: sha512-7MptL8U0cqcFdzIzwOTHoilX9x5BrNqye7Z/LuC7kCMRio1EMSyqRK3BEAUD7sXRq4iT4AzTVuZdhgQ2TCvYLg==} - engines: {node: '>=8.6.0'} + concat-map@0.0.1: + resolution: {integrity: sha512-/Srv4dswyQNBfohGpz9o6Yb3Gz3SrUDqBH5rTuhGR7ahtlbYKnVxw2bCFMRljaA7EXHaXZ8wsHdodFvbkhKmqg==} - fast-json-stable-stringify@2.1.0: - resolution: {integrity: sha512-lhd/wF+Lk98HZoTCtlVraHtfh5XYijIjalXck7saUtuanSDyLMxnHhSXEDJqHxD7msR8D0uCmqlkwjCV8xvwHw==} + console-table-printer@2.12.1: + resolution: {integrity: sha512-wKGOQRRvdnd89pCeH96e2Fn4wkbenSP6LMHfjfyNLMbGuHEFbMqQNuxXqd0oXG9caIOQ1FTvc5Uijp9/4jujnQ==} - fast-uri@3.1.0: - resolution: {integrity: sha512-iPeeDKJSWf4IEOasVVrknXpaBV0IApz/gp7S2bb7Z4Lljbl2MGJRqInZiUrQwV16cpzw/D3S5j5Julj/gT52AA==} + content-disposition@0.5.4: + resolution: {integrity: sha512-FveZTNuGw04cxlAiWbzi6zTAL/lhehaWbTtgluJh4/E95DqMwTmha3KZN1aAWA8cFIhHzMZUvLevkw5Rqk+tSQ==} + engines: {node: '>= 0.6'} - fast-xml-parser@5.2.5: - resolution: {integrity: sha512-pfX9uG9Ki0yekDHx2SiuRIyFdyAr1kMIMitPvb0YBo8SUfKvia7w7FIyd/l6av85pFYRhZscS75MwMnbvY+hcQ==} - hasBin: true + content-disposition@1.0.1: + resolution: {integrity: sha512-oIXISMynqSqm241k6kcQ5UwttDILMK4BiurCfGEREw6+X9jkkpEe5T9FZaApyLGGOnFuyMWZpdolTXMtvEJ08Q==} + engines: {node: '>=18'} - fast-xml-parser@5.3.7: - resolution: {integrity: sha512-JzVLro9NQv92pOM/jTCR6mHlJh2FGwtomH8ZQjhFj/R29P2Fnj38OgPJVtcvYw6SuKClhgYuwUZf5b3rd8u2mA==} - hasBin: true + content-type@1.0.5: + resolution: {integrity: sha512-nTjqfcBFEipKdXCv4YDQWCfmcLZKm81ldF0pAopTvyrFGVbcR6P/VAAd5G7N+0tTr8QqiU0tFadD6FK4NtJwOA==} + engines: {node: '>= 0.6'} - fastq@1.20.1: - resolution: {integrity: sha512-GGToxJ/w1x32s/D2EKND7kTil4n8OVk/9mycTc4VDza13lOvpUZTGX3mFSCtV9ksdGBVzvsyAVLM6mHFThxXxw==} + convert-source-map@2.0.0: + resolution: {integrity: sha512-Kvp459HrV2FEJ1CAsi1Ku+MY3kasH19TFykTz2xWmMeq6bk2NU3XXvfJ+Q61m0xktWwt+1HSYf3JZsTms3aRJg==} - fb-watchman@2.0.2: - resolution: {integrity: sha512-p5161BqbuCaSnB8jIbzQHOlpgsPmK5rJVDfDKO91Axs5NC1uu3HRQm6wt9cd9/+GtQQIO53JdGXXoyDpTAsgYA==} + convict@6.2.4: + resolution: {integrity: sha512-qN60BAwdMVdofckX7AlohVJ2x9UvjTNoKVXCL2LxFk1l7757EJqf1nySdMkPQer0bt8kQ5lQiyZ9/2NvrFBuwQ==} + engines: {node: '>=6'} - fdir@6.5.0: - resolution: {integrity: sha512-tIbYtZbucOs0BRGqPJkshJUYdL+SDH7dVM8gjy+ERp3WAUjLEFJE+02kanyHtwjWOnwrKYBiwAmM0p4kLJAnXg==} - engines: {node: '>=12.0.0'} - peerDependencies: - picomatch: ^3 || ^4 - peerDependenciesMeta: - picomatch: - optional: true + cookie-signature@1.0.7: + resolution: {integrity: sha512-NXdYc3dLr47pBkpUCHtKSwIOQXLVn8dZEuywboCOJY/osA0wFSLlSawr3KN8qXJEyX66FcONTH8EIlVuK0yyFA==} - fecha@4.2.3: - resolution: {integrity: sha512-OP2IUU6HeYKJi3i0z4A19kHMQoLVs4Hc+DPqqxI2h/DPZHTm/vjsfC6P0b4jCMy14XizLBqvndQ+UilD7707Jw==} + cookie-signature@1.2.2: + resolution: {integrity: sha512-D76uU73ulSXrD1UXF4KE2TMxVVwhsnCgfAyTg9k8P6KGZjlXKrOLe4dJQKI3Bxi5wjesZoFXJWElNWBjPZMbhg==} + engines: {node: '>=6.6.0'} - fetch-blob@3.2.0: - resolution: {integrity: sha512-7yAQpD2UMJzLi1Dqv7qFYnPbaPx7ZfFK6PiIxQ4PfkGPyNyl2Ugx+a/umUonmKqjhM4DnfbMvdX6otXq83soQQ==} - engines: {node: ^12.20 || >= 14.13} + cookie@0.7.2: + resolution: {integrity: sha512-yki5XnKuf750l50uGTllt6kKILY4nQ1eNIQatoXEByZ5dWgnKqbnqmTrBE5B4N7lrMJKQ2ytWMiTO2o0v6Ew/w==} + engines: {node: '>= 0.6'} - figures@6.1.0: - resolution: {integrity: sha512-d+l3qxjSesT4V7v2fh+QnmFnUWv9lSpjarhShNTgBOfA0ttejbQUAlHLitbjkoRiDulW0OPoQPYIGhIC8ohejg==} - engines: {node: '>=18'} + cors@2.8.6: + resolution: {integrity: sha512-tJtZBBHA6vjIAaF6EnIaq6laBBP9aq/Y3ouVJjEfoHbRBcHBAHYcMh/w8LDrk2PvIMMq8gmopa5D4V8RmbrxGw==} + engines: {node: '>= 0.10'} - fill-range@7.1.1: - resolution: {integrity: sha512-YsGpe3WHLK8ZYi4tWDg2Jy3ebRz2rXowDxnld4bkQB00cc/1Zw9AWnC0i9ztDJitivtQvaI9KaLyKrc+hBW0yg==} - engines: {node: '>=8'} + create-jest@29.7.0: + resolution: {integrity: sha512-Adz2bdH0Vq3F53KEMJOoftQFutWCukm6J24wbPWRO4k1kMY7gS7ds/uoJkNuV8wDCtWWnuwGcJwpWcih+zEW1Q==} + engines: {node: ^14.15.0 || ^16.10.0 || >=18.0.0} + hasBin: true - finalhandler@2.1.1: - resolution: {integrity: sha512-S8KoZgRZN+a5rNwqTxlZZePjT/4cnm0ROV70LedRHZ0p8u9fRID0hJUZQpkKLzro8LfmC8sx23bY6tVNxv8pQA==} - engines: {node: '>= 18.0.0'} + create-require@1.1.1: + resolution: {integrity: sha512-dcKFX3jn0MpIaXjisoRvexIJVEKzaq7z2rZKxf+MSr9TkdmHmsU4m2lcLojrj/FHl8mk5VxMmYA+ftRkP/3oKQ==} - find-replace@3.0.0: - resolution: {integrity: sha512-6Tb2myMioCAgv5kfvP5/PkZZ/ntTpVK39fHY7WkWBgvbeE+VHd/tZuZ4mrC+bxh4cfOZeYKVPaJIZtZXV7GNCQ==} - engines: {node: '>=4.0.0'} + croner@10.0.1: + resolution: {integrity: sha512-ixNtAJndqh173VQ4KodSdJEI6nuioBWI0V1ITNKhZZsO0pEMoDxz539T4FTTbSZ/xIOSuDnzxLVRqBVSvPNE2g==} + engines: {node: '>=18.0'} - find-up@4.1.0: - resolution: {integrity: sha512-PpOwAdQ/YlXQ2vj8a3h8IipDuYRi3wceVQQGYWxNINccq40Anw7BlsEXCMbt1Zt+OLA6Fq9suIpIWD0OsnISlw==} - engines: {node: '>=8'} + cross-fetch@3.2.0: + resolution: {integrity: sha512-Q+xVJLoGOeIMXZmbUK4HYk+69cQH6LudR0Vu/pRm2YlU/hDV9CiS0gKUMaWY5f2NeUH9C1nV3bsTlCo0FsTV1Q==} - flat@5.0.2: - resolution: {integrity: sha512-b6suED+5/3rTpUBdG1gupIl8MPFCAMA0QXwmljLhvCUKcUvdE4gWky9zpuGCcXHOsz4J9wPGNWq6OKpmIzz3hQ==} - hasBin: true + cross-fetch@4.1.0: + resolution: {integrity: sha512-uKm5PU+MHTootlWEY+mZ4vvXoCn4fLQxT9dSc1sXVMSFkINTJVN8cAQROpwcKm8bJ/c7rgZVIBWzH5T78sNZZw==} - flatbuffers@23.5.26: - resolution: {integrity: sha512-vE+SI9vrJDwi1oETtTIFldC/o9GsVKRM+s6EL0nQgxXlYV1Vc4Tk30hj4xGICftInKQKj1F3up2n8UbIVobISQ==} + cross-spawn@7.0.6: + resolution: {integrity: sha512-uV2QOWP2nWzsy2aMp8aRibhi9dlzF5Hgh5SHaB9OiTGEyDTiJJyx0uy51QXdyWbtAHNua4XJzUKca3OzKUd3vA==} + engines: {node: '>= 8'} - fn.name@1.1.0: - resolution: {integrity: sha512-GRnmB5gPyJpAhTQdSZTSp9uaPSvl09KoYcMQtsB9rQoOmzs9dH6ffeccH+Z+cv6P68Hu5bC6JjRh4Ah/mHSNRw==} + crypt@0.0.2: + resolution: {integrity: sha512-mCxBlsHFYh9C+HVpiEacem8FEBnMXgU9gy4zmNC+SXAZNB/1idgp/aulFJ4FgCi7GPEVbfyng092GqL2k2rmow==} - follow-redirects@1.15.11: - resolution: {integrity: sha512-deG2P0JfjrTxl50XGCDyfI97ZGVCxIpfKYmfyrQ54n5FO/0gfIES8C/Psl6kWVDolizcaaxZJnTS0QSMxvnsBQ==} - engines: {node: '>=4.0'} + data-uri-to-buffer@4.0.1: + resolution: {integrity: sha512-0R9ikRb668HB7QDxT1vkpuUBtqc53YyAwMwGeUFKRojY/NWKvdZ+9UYtRfGmhqNbRkTSVpMbmyhXipFFv2cb/A==} + engines: {node: '>= 12'} + + dayjs@1.11.19: + resolution: {integrity: sha512-t5EcLVS6QPBNqM2z8fakk/NKel+Xzshgt8FFKAn+qwlD1pzZWxh0nVCrvFK7ZDb6XucZeF9z8C7CBWTRIVApAw==} + + debug@2.6.9: + resolution: {integrity: sha512-bC7ElrdJaJnPbAP+1EotYvqZsb3ecl5wi6Bfi6BJTUcNowp6cvspg0jXznRTKDjm/E7AdgFBVeAPVMNcKGsHMA==} peerDependencies: - debug: '*' + supports-color: '*' peerDependenciesMeta: - debug: + supports-color: optional: true - foreground-child@3.3.1: - resolution: {integrity: sha512-gIXjKqtFuWEgzFRJA9WCQeSJLZDjgJUOMCMzxtvFq/37KojM1BFGufqsCy0r4qSQmYLsZYMeyRqzIWOMup03sw==} - engines: {node: '>=14'} + debug@4.4.1: + resolution: {integrity: sha512-KcKCqiftBJcZr++7ykoDIEwSa3XWowTfNPo92BYxjXiyYEVrUQh2aLyhxBCwww+heortUFxEJYcRzosstTEBYQ==} + engines: {node: '>=6.0'} + peerDependencies: + supports-color: '*' + peerDependenciesMeta: + supports-color: + optional: true - form-data-encoder@1.7.2: - resolution: {integrity: sha512-qfqtYan3rxrnCk1VYaA4H+Ms9xdpPqvLZa6xmMgFvhO32x7/3J/ExcTd6qpxM0vH2GdMI+poehyBZvqfMTto8A==} + debug@4.4.3: + resolution: {integrity: sha512-RGwwWnwQvkVfavKVt22FGLw+xYSdzARwm0ru6DhTVA3umU5hZc28V3kO4stgYryrTlLpuvgI9GiijltAjNbcqA==} + engines: {node: '>=6.0'} + peerDependencies: + supports-color: '*' + peerDependenciesMeta: + supports-color: + optional: true - form-data-encoder@4.1.0: - resolution: {integrity: sha512-G6NsmEW15s0Uw9XnCg+33H3ViYRyiM0hMrMhhqQOR8NFc5GhYrI+6I3u7OTw7b91J2g8rtvMBZJDbcGb2YUniw==} - engines: {node: '>= 18'} + decamelize@1.2.0: + resolution: {integrity: sha512-z2S+W9X73hAUUki+N+9Za2lBlun89zigOyGrsax+KUQ6wKW4ZoWpEYBkGhQjwAjjDCkWxhY0VKEhk8wzY7F5cA==} + engines: {node: '>=0.10.0'} - form-data@2.5.5: - resolution: {integrity: sha512-jqdObeR2rxZZbPSGL+3VckHMYtu+f9//KXBsVny6JSX/pa38Fy+bGjuG8eW/H6USNQWhLi8Num++cU2yOCNz4A==} - engines: {node: '>= 0.12'} + decimal.js@10.6.0: + resolution: {integrity: sha512-YpgQiITW3JXGntzdUmyUR1V812Hn8T1YVXhCu+wO3OpS4eU9l4YdD3qjyiKdV6mvV29zapkMeD390UVEf2lkUg==} - form-data@4.0.2: - resolution: {integrity: sha512-hGfm/slu0ZabnNt4oaRZ6uREyfCj6P4fT/n6A1rGV+Z0VdGXjfOhVUpkn6qVQONHGIFwmveGXyDs75+nr6FM8w==} - engines: {node: '>= 6'} + decode-named-character-reference@1.3.0: + resolution: {integrity: sha512-GtpQYB283KrPp6nRw50q3U9/VfOutZOe103qlN7BPP6Ad27xYnOIWv4lPzo8HCAL+mMZofJ9KEy30fq6MfaK6Q==} - form-data@4.0.5: - resolution: {integrity: sha512-8RipRLol37bNs2bhoV67fiTEvdTrbMUYcFTiy3+wuuOnUog2QBHCZWXDRijWQfAkhBj2Uf5UnVaiWwA5vdd82w==} - engines: {node: '>= 6'} + dedent@1.6.0: + resolution: {integrity: sha512-F1Z+5UCFpmQUzJa11agbyPVMbpgT/qA3/SKyJ1jyBgm7dUcUEa8v9JwDkerSQXfakBwFljIxhOJqGkjUwZ9FSA==} + peerDependencies: + babel-plugin-macros: ^3.1.0 + peerDependenciesMeta: + babel-plugin-macros: + optional: true - formdata-node@4.4.1: - resolution: {integrity: sha512-0iirZp3uVDjVGt9p49aTaqjk84TrglENEDuqfdlZQ1roC9CWlPk6Avf8EEnZNcAqPonwkG35x4n3ww/1THYAeQ==} - engines: {node: '>= 12.20'} + deep-eql@5.0.2: + resolution: {integrity: sha512-h5k/5U50IJJFpzfL6nO9jaaumfjO/f2NjK/oYB2Djzm4p9L+3T9qWpZqZ2hAbLPuuYq9wrU08WQyBTL5GbPk5Q==} + engines: {node: '>=6'} - formdata-node@6.0.3: - resolution: {integrity: sha512-8e1++BCiTzUno9v5IZ2J6bv4RU+3UKDmqWUQD0MIMVCd9AdhWkO1gw57oo1mNEX1dMq2EGI+FbWz4B92pscSQg==} - engines: {node: '>= 18'} + deepmerge@4.3.1: + resolution: {integrity: sha512-3sUqbMEc77XqpdNO7FRyRog+eW3ph+GYCbj+rK+uYyRMuwsVy0rMiVtPn+QJlKFvWP/1PYpapqYn0Me2knFn+A==} + engines: {node: '>=0.10.0'} - formdata-polyfill@4.0.10: - resolution: {integrity: sha512-buewHzMvYL29jdeQTVILecSaZKnt/RJWjoZCF5OW60Z67/GmSLBkOFM7qh1PI3zFNtJbaZL5eQu1vLfazOwj4g==} - engines: {node: '>=12.20.0'} + delayed-stream@1.0.0: + resolution: {integrity: sha512-ZySD7Nf91aLB0RxL4KGrKHBXl7Eds1DAmEdcoVawXnLD7SDhpNgtuII2aAkg7a7QS41jxPSZ17p4VdGnMHk3MQ==} + engines: {node: '>=0.4.0'} - forwarded@0.2.0: - resolution: {integrity: sha512-buRG0fpBtRHSTCOASe6hD258tEubFoRLb4ZNA6NxMVHNw2gOcwHo9wyablzMzOA5z9xA9L1KNjk/Nt6MT9aYow==} - engines: {node: '>= 0.6'} + depd@2.0.0: + resolution: {integrity: sha512-g7nH6P6dyDioJogAAGprGpCtVImJhpPk/roCzdb3fIh61/s/nPsfR6onyMwkCAR/OlC3yBC0lESvUoQEAssIrw==} + engines: {node: '>= 0.8'} - fraction.js@5.3.4: - resolution: {integrity: sha512-1X1NTtiJphryn/uLQz3whtY6jK3fTqoE3ohKs0tT+Ujr1W59oopxmoEh7Lu5p6vBaPbgoM0bzveAW4Qi5RyWDQ==} + dequal@2.0.3: + resolution: {integrity: sha512-0je+qPKHEMohvfRTCEo3CrPG6cAzAYgmzKyxRiYSSDkS6eGJdyVJm7WaYA5ECaAD9wLB2T4EEeymA5aFVcYXCA==} + engines: {node: '>=6'} - fresh@2.0.0: - resolution: {integrity: sha512-Rx/WycZ60HOaqLKAi6cHRKKI7zxWbJ31MhntmtwMoaTeF7XFH9hhBp8vITaMidfljRQ6eYWCKkaTK+ykVJHP2A==} - engines: {node: '>= 0.8'} + destroy@1.2.0: + resolution: {integrity: sha512-2sJGJTaXIIaR1w4iJSNoN0hnMY7Gpc/n8D4qSCJw8QqFWXf7cuAgnEHxBpweaVcPevC2l3KpjYCx3NypQQgaJg==} + engines: {node: '>= 0.8', npm: 1.2.8000 || >= 1.4.16} - fs.realpath@1.0.0: - resolution: {integrity: sha512-OO0pH2lK6a0hZnAdau5ItzHPI6pUlvI7jMVnxUQRtw4owF2wk8lOSabtGDCTP4Ggrg2MbGnWO9X8K1t4+fGMDw==} + detect-newline@3.1.0: + resolution: {integrity: sha512-TLz+x/vEXm/Y7P7wn1EJFNLxYpUD4TgMosxY6fAVJUnJMbupHBOncxyWUG9OpTaH9EBD7uFI5LfEgmMOc54DsA==} + engines: {node: '>=8'} - fsevents@2.3.3: - resolution: {integrity: sha512-5xoDfX+fL7faATnagmWPpbFtwh/R77WmMMqqHGS65C3vvB0YHrgF+B1YmZ3441tMj5n63k0212XNoJwzlhffQw==} - engines: {node: ^8.16.0 || ^10.6.0 || >=11.0.0} - os: [darwin] + devlop@1.1.0: + resolution: {integrity: sha512-RWmIqhcFf1lRYBvNmr7qTNuyCt/7/ns2jbpp1+PalgE/rDQcBT0fioSMUpJ93irlUhC5hrg4cYqe6U+0ImW0rA==} - function-bind@1.1.2: - resolution: {integrity: sha512-7XHNxH7qX9xG5mIwxkhumTox/MIRNcOgDrxWsMt2pAr23WHp6MrRlN7FBSFpCpr+oVO0F744iUgR82nJMfG2SA==} + diff-sequences@29.6.3: + resolution: {integrity: sha512-EjePK1srD3P08o2j4f0ExnylqRs5B9tJjcp9t1krH2qRi8CCdsYfwe9JgSLurFBWwq4uOlipzfk5fHNvwFKr8Q==} + engines: {node: ^14.15.0 || ^16.10.0 || >=18.0.0} - gaxios@6.7.1: - resolution: {integrity: sha512-LDODD4TMYx7XXdpwxAVRAIAuB0bzv0s+ywFonY46k126qzQHT9ygyoa9tncmOiQmmDrik65UYsEkv3lbfqQ3yQ==} - engines: {node: '>=14'} + diff@4.0.2: + resolution: {integrity: sha512-58lmxKSA4BNyLz+HHMUzlOEpg09FV+ev6ZMe3vJihgdxzgcwZ8VoEEPmALCZG9LmqfVoNMMKpttIYTVG6uDY7A==} + engines: {node: '>=0.3.1'} - gaxios@7.1.3: - resolution: {integrity: sha512-YGGyuEdVIjqxkxVH1pUTMY/XtmmsApXrCVv5EU25iX6inEPbV+VakJfLealkBtJN69AQmh1eGOdCl9Sm1UP6XQ==} - engines: {node: '>=18'} + digest-fetch@1.3.0: + resolution: {integrity: sha512-CGJuv6iKNM7QyZlM2T3sPAdZWd/p9zQiRNS9G+9COUCwzWFTs0Xp8NF5iePx7wtvhDykReiRRrSeNb4oMmB8lA==} - gcp-metadata@6.1.1: - resolution: {integrity: sha512-a4tiq7E0/5fTjxPAaH4jpjkSv/uCaU2p5KC6HVGrvl0cDjA8iBZv4vv1gyzlmK0ZUKqwpOyQMKzZQe3lTit77A==} - engines: {node: '>=14'} + dir-glob@3.0.1: + resolution: {integrity: sha512-WkrWp9GR4KXfKGYzOLmTuGVi1UWFfws377n9cc55/tb6DuqyF6pcQ5AbiHEshaDpY9v6oaSr2XCDidGmMwdzIA==} + engines: {node: '>=8'} - gcp-metadata@8.1.2: - resolution: {integrity: sha512-zV/5HKTfCeKWnxG0Dmrw51hEWFGfcF2xiXqcA3+J90WDuP0SvoiSO5ORvcBsifmx/FoIjgQN3oNOGaQ5PhLFkg==} - engines: {node: '>=18'} + dom-serializer@2.0.0: + resolution: {integrity: sha512-wIkAryiqt/nV5EQKqQpo3SToSOV9J0DnbJqwK7Wv/Trc92zIAYZ4FlMu+JPFW1DfGFt81ZTCGgDEabffXeLyJg==} - generative-bayesian-network@2.1.80: - resolution: {integrity: sha512-LyCc23TIFvZDkUJclZ3ixCZvd+dhktr9Aug1EKz5VrfJ2eA5J2HrprSwWRna3VObU2Wy8quXMUF8j2em0bJSLw==} + domelementtype@2.3.0: + resolution: {integrity: sha512-OLETBj6w0OsagBwdXnPdN0cnMfF9opN69co+7ZrbfPGrdpPVNBUj02spi6B1N7wChLQiPn4CSH/zJvXw56gmHw==} - generic-pool@3.9.0: - resolution: {integrity: sha512-hymDOu5B53XvN4QT9dBmZxPX4CWhBPPLguTZ9MMFeFa/Kg0xWVfylOVNlJji/E7yTZWFd/q9GO5TxDLq156D7g==} + domhandler@5.0.3: + resolution: {integrity: sha512-cgwlv/1iFQiFnU96XXgROh8xTeetsnJiDsTc7TYCLFd9+/WNkIqPTxiM/8pSd8VIrhXGTf1Ny1q1hquVqDJB5w==} engines: {node: '>= 4'} - gensync@1.0.0-beta.2: - resolution: {integrity: sha512-3hN7NaskYvMDLQY55gnW3NQ+mesEAepTqlg+VEbj7zzqEMBVNhzcGYYeqFo/TlYz6eQiFcp1HcsCZO+nGgS8zg==} - engines: {node: '>=6.9.0'} + domutils@3.2.2: + resolution: {integrity: sha512-6kZKyUajlDuqlHKVX1w7gyslj9MPIXzIFiz/rGu35uC1wMi+kMhQwGhl4lt9unC9Vb9INnY9Z3/ZA3+FhASLaw==} - get-caller-file@2.0.5: - resolution: {integrity: sha512-DyFP3BM/3YHTQOCUL/w0OZHR0lpKeGrxotcHWcqNEdnltqFwXVfhEBQ94eIo34AfQpo0rGki4cyIiftY06h2Fg==} - engines: {node: 6.* || 8.* || >= 10.*} + dot-prop@6.0.1: + resolution: {integrity: sha512-tE7ztYzXHIeyvc7N+hR3oi7FIbf/NIjVP9hmAt3yMXzrQ072/fpjGLx2GxNxGxUl5V73MEqYzioOMoVhGMJ5cA==} + engines: {node: '>=10'} - get-intrinsic@1.3.0: - resolution: {integrity: sha512-9fSjSaos/fRIVIp+xSJlE6lfwhES7LNtKaCBIamHsjr2na1BiABJPo0mOjjz8GJDURarmCPGqaiVg5mfjb98CQ==} - engines: {node: '>= 0.4'} + dotenv@16.5.0: + resolution: {integrity: sha512-m/C+AwOAr9/W1UOIZUo232ejMNnJAJtYQjUbHoNTBNTJSvqzzDh7vnrei3o3r3m9blf6ZoDkvcw0VmozNRFJxg==} + engines: {node: '>=12'} - get-package-type@0.1.0: - resolution: {integrity: sha512-pjzuKtY64GYfWizNAJ0fr9VqttZkNiK2iS430LtIHzjBEr6bX8Am2zm4sW4Ro5wjWW5cAlRL1qAMTcXbjNAO2Q==} - engines: {node: '>=8.0.0'} + dotenv@17.4.2: + resolution: {integrity: sha512-nI4U3TottKAcAD9LLud4Cb7b2QztQMUEfHbvhTH09bqXTxnSie8WnjPALV/WMCrJZ6UV/qHJ6L03OqO3LcdYZw==} + engines: {node: '>=12'} - get-proto@1.0.1: - resolution: {integrity: sha512-sTSfBjoXBp89JvIKIefqw7U2CCebsc74kiY6awiGogKtoSGbgjYE/G/+l9sF3MWFPNc9IcoOC4ODfKHfxFmp0g==} + dotprompt@1.1.2: + resolution: {integrity: sha512-24EU+eORQbPywBicIP44BiqykzEXFwZq1ZQKO5TEr9KrrENyDA7I1NzqhtmmEdQVfAXka0DEbSLPN5nerCqJ8A==} + + duck-duck-scrape@2.2.7: + resolution: {integrity: sha512-BEcglwnfx5puJl90KQfX+Q2q5vCguqyMpZcSRPBWk8OY55qWwV93+E+7DbIkrGDW4qkqPfUvtOUdi0lXz6lEMQ==} + + dunder-proto@1.0.1: + resolution: {integrity: sha512-KIN/nDJBQRcXw0MLVhZE9iQHmG68qAVIBg9CqmUYjmQIhgij9U5MFvrqkUL5FbtyyzZuOeOt0zdeRe4UY7ct+A==} engines: {node: '>= 0.4'} - get-stream@6.0.1: - resolution: {integrity: sha512-ts6Wi+2j3jQjqi70w5AlN8DFnkSwC+MqmxEzdEALB2qXZYV3X/b1CTfgPLGJNMeAWxdPfU8FO1ms3NUfaHCPYg==} - engines: {node: '>=10'} + duplexify@4.1.3: + resolution: {integrity: sha512-M3BmBhwJRZsSx38lZyhE53Csddgzl5R7xGJNk7CVddZD6CcmwMCH8J+7AprIrQKH7TonKxaCjcv27Qmf+sQ+oA==} - get-stream@9.0.1: - resolution: {integrity: sha512-kVCxPF3vQM/N0B1PmoqVUqgHP+EeVjmZSQn+1oCRPxd2P21P2F19lIgbR3HBosbB1PUhOAoctJnfEn2GbN2eZA==} - engines: {node: '>=18'} + eastasianwidth@0.2.0: + resolution: {integrity: sha512-I88TYZWc9XiYHRQ4/3c5rjjfgkjhLyW2luGIheGERbNQ6OY7yTybanSpDXZa8y7VUP9YmDcYa+eyq4ca7iLqWA==} - get-tsconfig@4.13.0: - resolution: {integrity: sha512-1VKTZJCwBrvbd+Wn3AOgQP/2Av+TfTCOlE4AcRJE72W1ksZXbAx8PPBR9RzgTeSPzlPMHrbANMH3LbltH73wxQ==} + ecdsa-sig-formatter@1.0.11: + resolution: {integrity: sha512-nagl3RYrbNv6kQkeJIpt6NJZy8twLB/2vtz6yN9Z4vRKHN4/QZJIEbqohALSgwKdnksuY3k5Addp5lg8sVoVcQ==} - glob-parent@5.1.2: - resolution: {integrity: sha512-AOIgSQCepiJYwP3ARnGx+5VnTu2HBYdzbGP45eLw1vr3zB3vZLeyed1sC9hnbcOc9/SrMyM5RPQrkGz4aS9Zow==} - engines: {node: '>= 6'} + ee-first@1.1.1: + resolution: {integrity: sha512-WMwm9LhRUo+WUaRN+vRuETqG89IgZphVSNkdFgeb6sS/E4OrDIN7t48CAewSHXc6C8lefD8KKfr5vY61brQlow==} - glob@10.5.0: - resolution: {integrity: sha512-DfXN8DfhJ7NH3Oe7cFmu3NCu1wKbkReJ8TorzSAFbSKrlNaQSKfIzqYqVY8zlbs2NLBbWpRiU52GX2PbaBVNkg==} - hasBin: true + electron-to-chromium@1.5.155: + resolution: {integrity: sha512-ps5KcGGmwL8VaeJlvlDlu4fORQpv3+GIcF5I3f9tUKUlJ/wsysh6HU8P5L1XWRYeXfA0oJd4PyM8ds8zTFf6Ng==} - glob@13.0.0: - resolution: {integrity: sha512-tvZgpqk6fz4BaNZ66ZsRaZnbHvP/jG3uKJvAZOwEVUL4RTA5nJeeLYfyN9/VA8NX/V3IBG+hkeuGpKjvELkVhA==} - engines: {node: 20 || >=22} + emittery@0.13.1: + resolution: {integrity: sha512-DeWwawk6r5yR9jFgnDKYt4sLS0LmHJJi3ZOnb5/JdbYwj3nW+FxQnHIjhBKz8YLC7oRNPVM9NQ47I3CVx34eqQ==} + engines: {node: '>=12'} - glob@7.2.3: - resolution: {integrity: sha512-nFR0zLpU2YCaRxwoCJvL6UvCH2JFyFVIvwTLsIf21AuHlMskA1hhTdk+LlYJtOlYt9v6dvszD2BGRqBL+iQK9Q==} - deprecated: Glob versions prior to v9 are no longer supported + emoji-regex@8.0.0: + resolution: {integrity: sha512-MSjYzcWNOA0ewAHpz0MxpYFvwg6yjy1NG3xteoqz644VCo/RPgnr1/GGt+ic3iJTzQ8Eu3TdM14SawnVUmGE6A==} - globals@11.12.0: - resolution: {integrity: sha512-WOBp/EEGUiIsJSp7wcv/y6MO+lV9UoncWqxuFfm8eBwzWNgyfBd6Gz+IeKQ9jCmyhoH99g15M3T+QaVHFjizVA==} - engines: {node: '>=4'} + emoji-regex@9.2.2: + resolution: {integrity: sha512-L18DaJsXSUk2+42pv8mLs5jJT2hqFkFE4j21wOmgbUqsZ2hL72NsUU785g9RXgo3s0ZNgVl42TiHp3ZtOv/Vyg==} - globby@11.1.0: - resolution: {integrity: sha512-jhIXaOzy1sb8IyocaruWSn1TjmnBVs8Ayhcy83rmxNJ8q2uWKCAj3CnJY+KpGSXCueAPc0i05kVvVKtP1t9S3g==} - engines: {node: '>=10'} + enabled@2.0.0: + resolution: {integrity: sha512-AKrN98kuwOzMIdAizXGI86UFBoo26CL21UM763y1h/GMSJ4/OHU9k2YlsmBpyScFo/wbLzWQJBMCW4+IO3/+OQ==} - google-auth-library@10.5.0: - resolution: {integrity: sha512-7ABviyMOlX5hIVD60YOfHw4/CxOfBhyduaYB+wbFWCWoni4N7SLcV46hrVRktuBbZjFC9ONyqamZITN7q3n32w==} - engines: {node: '>=18'} + encodeurl@2.0.0: + resolution: {integrity: sha512-Q0n9HRi4m6JuGIV1eFlmvJB7ZEVxu93IrMyiMsGC0lrMJMWzRgx6WGquyfQgZVb31vhGgXnfmPNNXmxnOkRBrg==} + engines: {node: '>= 0.8'} - google-auth-library@9.15.1: - resolution: {integrity: sha512-Jb6Z0+nvECVz+2lzSMt9u98UsoakXxA2HGHMCxh+so3n90XgYWkq5dur19JAJV7ONiJY22yBTyJB1TSkvPq9Ng==} - engines: {node: '>=14'} + end-of-stream@1.4.5: + resolution: {integrity: sha512-ooEGc6HP26xXq/N+GCGOT0JKCLDGrq2bQUZrQ7gyrJiZANJ/8YDTxTpQBXGMn+WbIQXNVpyWymm7KYVICQnyOg==} - google-logging-utils@0.0.2: - resolution: {integrity: sha512-NEgUnEcBiP5HrPzufUkBzJOD/Sxsco3rLNo1F1TNf7ieU8ryUzBhqba8r756CjLX7rn3fHl6iLEwPYuqpoKgQQ==} - engines: {node: '>=14'} + entities@4.5.0: + resolution: {integrity: sha512-V0hjH4dGPh9Ao5p0MoRY6BVqtwCjhz6vI5LT8AJ55H+4g9/4vbHx1I54fS0XuclLhDHArPQCiMjDxjaL8fPxhw==} + engines: {node: '>=0.12'} - google-logging-utils@1.1.3: - resolution: {integrity: sha512-eAmLkjDjAFCVXg7A1unxHsLf961m6y17QFqXqAXGj/gVkKFrEICfStRfwUlGNfeCEjNRa32JEWOUTlYXPyyKvA==} - engines: {node: '>=14'} + error-ex@1.3.2: + resolution: {integrity: sha512-7dFHNmqeFSEt2ZBsCriorKnn3Z2pj+fd9kmI6QoWw4//DL+icEBfc0U7qJCisqrTsKTjw4fNFy2pW9OqStD84g==} - google-protobuf@3.21.4: - resolution: {integrity: sha512-MnG7N936zcKTco4Jd2PX2U96Kf9PxygAPKBug+74LHzmHXmceN16MmRcdgZv+DGef/S9YvQAfRsNCn4cjf9yyQ==} + es-define-property@1.0.1: + resolution: {integrity: sha512-e3nRfgfUZ4rNGL232gUgX06QNyyez04KdjFrF+LTRoOXmrOgFKDg4BCdsjW8EnT69eqdYGmRpJwiPVYNrCaW3g==} + engines: {node: '>= 0.4'} - googleapis-common@7.2.0: - resolution: {integrity: sha512-/fhDZEJZvOV3X5jmD+fKxMqma5q2Q9nZNSF3kn1F18tpxmA86BcTxAGBQdM0N89Z3bEaIs+HVznSmFJEAmMTjA==} - engines: {node: '>=14.0.0'} + es-errors@1.3.0: + resolution: {integrity: sha512-Zf5H2Kxt2xjTvbJvP2ZWLEICxA6j+hAmMzIlypy4xcBg1vKVnx89Wy0GbS+kf5cwCVFFzdCFh2XSCFNULS6csw==} + engines: {node: '>= 0.4'} - googleapis@137.1.0: - resolution: {integrity: sha512-2L7SzN0FLHyQtFmyIxrcXhgust77067pkkduqkbIpDuj9JzVnByxsRrcRfUMFQam3rQkWW2B0f1i40IwKDWIVQ==} - engines: {node: '>=14.0.0'} + es-module-lexer@1.7.0: + resolution: {integrity: sha512-jEQoCwk8hyb2AZziIOLhDqpm5+2ww5uIE6lkO/6jcOCusfk6LhMHpXXfBLXTZ7Ydyt0j4VoUQv6uGNYbdW+kBA==} - gopd@1.2.0: - resolution: {integrity: sha512-ZUKRh6/kUFoAiTAtTYPZJ3hw9wNxx+BIBOijnlG9PnrJsCcSjs1wyyD6vJpaYtgnzDrKYRSqf3OO6Rfa93xsRg==} + es-object-atoms@1.1.1: + resolution: {integrity: sha512-FGgH2h8zKNim9ljj7dankFPcICIK9Cp5bm+c2gQSYePhpaG5+esrLODihIorn+Pe6FGJzWhXQotPv73jTaldXA==} engines: {node: '>= 0.4'} - graceful-fs@4.2.11: - resolution: {integrity: sha512-RbJ5/jmFcNNCcDV5o9eTnBLJ/HszWV0P73bc+Ff4nS/rJj+YaS6IGyiOL0VoBYX+l1Wrl3k63h/KrH+nhJ0XvQ==} + es-set-tostringtag@2.1.0: + resolution: {integrity: sha512-j6vWzfrGVfyXxge+O0x5sh6cvxAog0a/4Rdd2K36zCMV5eJ+/+tOAngRO8cODMNWbVRdVlmGZQL2YS3yR8bIUA==} + engines: {node: '>= 0.4'} - graphql-request@6.1.0: - resolution: {integrity: sha512-p+XPfS4q7aIpKVcgmnZKhMNqhltk20hfXtkaIkTfjjmiKMJ5xrt5c743cL03y/K7y1rg3WrIC49xGiEQ4mxdNw==} - peerDependencies: - graphql: 14 - 16 + esbuild@0.27.2: + resolution: {integrity: sha512-HyNQImnsOC7X9PMNaCIeAm4ISCQXs5a5YasTXVliKv4uuBo1dKrG0A+uQS8M5eXjVMnLg3WgXaKvprHlFJQffw==} + engines: {node: '>=18'} + hasBin: true - graphql@16.12.0: - resolution: {integrity: sha512-DKKrynuQRne0PNpEbzuEdHlYOMksHSUI8Zc9Unei5gTsMNA2/vMpoMz/yKba50pejK56qj98qM0SjYxAKi13gQ==} - engines: {node: ^12.22.0 || ^14.16.0 || ^16.0.0 || >=17.0.0} + escalade@3.2.0: + resolution: {integrity: sha512-WUj2qlxaQtO4g6Pq5c29GTcWGDyd8itL8zTlipgECz3JesAiiOKotd8JU6otB3PACgG6xkJUyVhboMS+bje/jA==} + engines: {node: '>=6'} - gray-matter@4.0.3: - resolution: {integrity: sha512-5v6yZd4JK3eMI3FqqCouswVqwugaA9r4dNZB1wwcmrD02QkV5H0y7XBQW8QwQqEaZY1pM9aqORSORhJRdNK44Q==} - engines: {node: '>=6.0'} + escape-html@1.0.3: + resolution: {integrity: sha512-NiSupZ4OeuGwr68lGIeym/ksIZMJodUGOSCZ/FSnTxcrekbvqrgdUxlJOMpijaKZVjAJrWrGs/6Jy8OMuyj9ow==} - groq-sdk@0.9.1: - resolution: {integrity: sha512-yFZ3+I0Oe/u+4PUKDUG8q5KpP9Hgc+ujhlBaAbcc4EMJb2RMn/atqG8i+Vnk7s+2K4rJ49mviO/kY0i9LbskCA==} + escape-latex@1.2.0: + resolution: {integrity: sha512-nV5aVWW1K0wEiUIEdZ4erkGGH8mDxGyxSeqPzRNtWP7ataw+/olFObw7hujFWlVjNsaDFw5VZ5NzVSIqRgfTiw==} - gtoken@7.1.0: - resolution: {integrity: sha512-pCcEwRi+TKpMlxAQObHDQ56KawURgyAf6jtIY046fJ5tIv3zDe/LEIubckAO8fj6JnAxLdmWkUfNyulQ2iKdEw==} - engines: {node: '>=14.0.0'} + escape-string-regexp@2.0.0: + resolution: {integrity: sha512-UpzcLCXolUWcNu5HtVMHYdXJjArjsF9C0aNnquZYY4uW/Vu0miy5YoWvbV345HauVvcAUnpRuhMMcqTcGOY2+w==} + engines: {node: '>=8'} - gtoken@8.0.0: - resolution: {integrity: sha512-+CqsMbHPiSTdtSO14O51eMNlrp9N79gmeqmXeouJOhfucAedHw9noVe/n5uJk3tbKE6a+6ZCQg3RPhVhHByAIw==} - engines: {node: '>=18'} + escape-string-regexp@5.0.0: + resolution: {integrity: sha512-/veY75JbMK4j1yjvuUxuVsiS/hr/4iHs9FTT6cgTexxdE0Ly/glccBAkloH/DofkjRbZU3bnoj38mOmhkZ0lHw==} + engines: {node: '>=12'} - handlebars@4.7.8: - resolution: {integrity: sha512-vafaFqs8MZkRrSX7sFVUdo3ap/eNiLnb4IakshzvP56X5Nr1iGKAIqdX6tMlm6HcNRIkr6AxO5jFEoJzzpT8aQ==} - engines: {node: '>=0.4.7'} + esprima@4.0.1: + resolution: {integrity: sha512-eGuFFw7Upda+g4p+QHvnW0RyTX/SVeJBDM/gCtMARO0cLuT2HcEKnTPvhjV6aGeqrCB/sbNop0Kszm0jsaWU4A==} + engines: {node: '>=4'} hasBin: true - has-flag@4.0.0: - resolution: {integrity: sha512-EykJT/Q1KjTWctppgIAgfSO0tKVuZUjhgMr17kqTumMl6Afv3EISleU7qZUzoXDFTAHTDC4NOoG/ZxU3EvlMPQ==} - engines: {node: '>=8'} + estree-walker@3.0.3: + resolution: {integrity: sha512-7RUKfXgSMMkzt6ZuXmqapOurLGPPfgj6l9uRZ7lRGolvk0y2yocc35LdcxKC5PQZdn2DMqioAQ2NoWcrTKmm6g==} - has-symbols@1.1.0: - resolution: {integrity: sha512-1cDNdwJ2Jaohmb3sg4OmKaMBwuC48sYni5HUw2DvsC8LjGTLK9h+eb1X6RyuOHe4hT0ULCW68iomhjUoKUqlPQ==} - engines: {node: '>= 0.4'} + etag@1.8.1: + resolution: {integrity: sha512-aIL5Fx7mawVa300al2BnEE4iNvo1qETxLrPI/o05L7z6go7fCw1J6EQmbK4FmJ2AS7kgVF/KEZWufBfdClMcPg==} + engines: {node: '>= 0.6'} - has-tostringtag@1.0.2: - resolution: {integrity: sha512-NqADB8VjPFLM2V0VvHUewwwsw0ZWBaIdgo+ieHtK3hasLz4qeCRjYcqfB6AQrBggRKppKF8L52/VqdVsO47Dlw==} - engines: {node: '>= 0.4'} + event-target-shim@5.0.1: + resolution: {integrity: sha512-i/2XbnSz/uxRCU6+NdVJgKWDTM427+MqYbkQzD321DuCQJUqOuJKIA0IM2+W2xtYHdKOmZ4dR6fExsd4SXL+WQ==} + engines: {node: '>=6'} - hasown@2.0.2: - resolution: {integrity: sha512-0hJU9SCPvmMzIBdZFqNPXWa6dqh7WdH0cII9y+CyS8rG3nL48Bclra9HmKhVVUHyPWNH5Y7xDwAB7bfgSjkUMQ==} - engines: {node: '>= 0.4'} + eventemitter3@4.0.7: + resolution: {integrity: sha512-8guHBZCwKnFhYdHr2ysuRWErTwhoN2X8XELRlrRwpmfeY2jjuUN4taQMsULKUVo1K4DvZl+0pgfyoysHxvmvEw==} - header-generator@2.1.80: - resolution: {integrity: sha512-7gvv2Xm6Q0gNN3BzMD/D3sGvSJRcV1+k8XehPmBYTpTkBmKshwnYyi0jJJnpP3S6YP7vdOoEobeBV87aG9YTtQ==} - engines: {node: '>=16.0.0'} + eventemitter3@5.0.4: + resolution: {integrity: sha512-mlsTRyGaPBjPedk6Bvw+aqbsXDtoAyAzm5MO7JgU+yVRyMQ5O8bD4Kcci7BS85f93veegeCPkL8R4GLClnjLFw==} - hono-openapi@1.3.0: - resolution: {integrity: sha512-xDvCWpWEIv0weEmnl3EjRQzqbHIO8LnfzMuYOCmbuyE5aes6aXxLg4vM3ybnoZD5TiTUkA6PuRQPJs3R7WRBig==} - peerDependencies: - '@hono/standard-validator': ^0.2.0 - '@standard-community/standard-json': ^0.3.5 - '@standard-community/standard-openapi': ^0.2.9 - '@types/json-schema': ^7.0.15 - hono: ^4.8.3 - openapi-types: ^12.1.3 - peerDependenciesMeta: - '@hono/standard-validator': - optional: true - hono: - optional: true + events@3.3.0: + resolution: {integrity: sha512-mQw+2fkQbALzQ7V0MY0IqdnXNOeTtP4r0lN9z7AAawCXgqea7bDii20AYrIBrFd/Hx0M2Ocz6S111CaFkUcb0Q==} + engines: {node: '>=0.8.x'} - hono@4.11.5: - resolution: {integrity: sha512-WemPi9/WfyMwZs+ZUXdiwcCh9Y+m7L+8vki9MzDw3jJ+W9Lc+12HGsd368Qc1vZi1xwW8BWMMsnK5efYKPdt4g==} - engines: {node: '>=16.9.0'} + eventsource-parser@3.0.6: + resolution: {integrity: sha512-Vo1ab+QXPzZ4tCa8SwIHJFaSzy4R6SHf7BY79rFBDf0idraZWAkYrDjDj8uWaSm3S2TK+hJ7/t1CEmZ7jXw+pg==} + engines: {node: '>=18.0.0'} - hono@4.12.23: - resolution: {integrity: sha512-eIaZ9qDgu7XV0pxOCrg7/WhnQ6Ivm22UcxhXx/A3dcbqbbYgBEkc6e/J/s7j2tS96zoB0S9VBdLwQNCWwUo4LA==} - engines: {node: '>=16.9.0'} + eventsource-parser@3.1.0: + resolution: {integrity: sha512-kJezFj9YFAMLeORyi7aCLxLbD5/qWMQnoMVlVPyHIll7lgRJCc3JVln9Vgl9nwQi0YkMnhdGTMNn7CkRRAptMg==} + engines: {node: '>=18.0.0'} - html-entities@2.6.0: - resolution: {integrity: sha512-kig+rMn/QOVRvr7c86gQ8lWXq+Hkv6CbAH1hLu+RG338StTpE8Z0b44SDVaqVu7HGKf27frdmUYEs9hTUX/cLQ==} + eventsource@3.0.7: + resolution: {integrity: sha512-CRT1WTyuQoD771GW56XEZFQ/ZoSfWid1alKGDYMmkt2yl8UXrVR4pspqWNEcqKvVIzg6PAltWjxcSSPrboA4iA==} + engines: {node: '>=18.0.0'} - html-escaper@2.0.2: - resolution: {integrity: sha512-H2iMtd0I4Mt5eYiapRdIDjp+XzelXQ0tFE4JS7YFwFevXXMmOp9myNrUvCg0D6ws8iqkRPBfKHgbwig1SmlLfg==} + execa@5.1.1: + resolution: {integrity: sha512-8uSpZZocAZRBAPIEINJj3Lo9HyGitllczc27Eh5YYojjMFMn8yHMDMaUHE2Jqfq05D/wucwI4JGURyXt1vchyg==} + engines: {node: '>=10'} - html-to-text@9.0.5: - resolution: {integrity: sha512-qY60FjREgVZL03vJU6IfMV4GDjGBIoOyvuFdpBDIX9yTlDw0TjxVBQp+P8NvpdIXNJvfWBTNul7fsAQJq2FNpg==} - engines: {node: '>=14'} + execa@9.6.1: + resolution: {integrity: sha512-9Be3ZoN4LmYR90tUoVu2te2BsbzHfhJyfEiAVfz7N5/zv+jduIfLrV2xdQXOHbaD6KgpGdO9PRPM1Y4Q9QkPkA==} + engines: {node: ^18.19.0 || >=20.5.0} - htmlparser2@8.0.2: - resolution: {integrity: sha512-GYdjWKDkbRLkZ5geuHs5NY1puJ+PXwP7+fHPRz06Eirsb9ugf6d8kkXav6ADhcODhFFPMIXyxkxSuMf3D6NCFA==} + exit@0.1.2: + resolution: {integrity: sha512-Zk/eNKV2zbjpKzrsQ+n1G6poVbErQxJ0LBOJXaKZ1EViLzH+hrLu9cdXI4zw9dBQJslwBEpbQ2P1oS7nDxs6jQ==} + engines: {node: '>= 0.8.0'} - http-errors@2.0.1: - resolution: {integrity: sha512-4FbRdAX+bSdmo4AUFuS0WNiPz8NgFt+r8ThgNWmlrjQjt1Q7ZR9+zTlce2859x4KSXrwIsaeTqDoKQmtP8pLmQ==} - engines: {node: '>= 0.8'} + expect-type@1.3.0: + resolution: {integrity: sha512-knvyeauYhqjOYvQ66MznSMs83wmHrCycNEN6Ao+2AeYEfxUIkuiVxdEa1qlGEPK+We3n0THiDciYSsCcgW/DoA==} + engines: {node: '>=12.0.0'} - http-proxy-agent@5.0.0: - resolution: {integrity: sha512-n2hY8YdoRE1i7r6M0w9DIw5GgZN0G25P8zLCRQ8rjXtTU3vsNFBI/vWK/UIeE6g5MUUz6avwAPXmL6Fy9D/90w==} - engines: {node: '>= 6'} + expect@29.7.0: + resolution: {integrity: sha512-2Zks0hf1VLFYI1kbh0I5jP3KHHyCHpkfyHBzsSXRFgl/Bg9mWYfMW8oD+PdMPlEwy5HNsR9JutYy6pMeOh61nw==} + engines: {node: ^14.15.0 || ^16.10.0 || >=18.0.0} - https-proxy-agent@5.0.1: - resolution: {integrity: sha512-dFcAjpTQFgoLMzC2VwU+C/CbS7uRL0lWmxDITmqm7C+7F0Odmj6s9l6alZc6AELXhrnggM2CeWSXHGOdX2YtwA==} - engines: {node: '>= 6'} + expr-eval@2.0.2: + resolution: {integrity: sha512-4EMSHGOPSwAfBiibw3ndnP0AvjDWLsMvGOvWEZ2F96IGk0bIVdjQisOHxReSkE13mHcfbuCiXw+G4y0zv6N8Eg==} - https-proxy-agent@7.0.6: - resolution: {integrity: sha512-vK9P5/iUfdl95AI+JVyUuIcVtd4ofvtrOr3HNtM2yxC9bnMbEdp3x01OhQNnjb8IJYi38VlTE3mBXwcfvywuSw==} - engines: {node: '>= 14'} + express-rate-limit@7.5.1: + resolution: {integrity: sha512-7iN8iPMDzOMHPUYllBEsQdWVB6fPDMPqwjBaFrgr4Jgr/+okjvzAy+UHlYYL/Vs0OsOrMkwS6PJDkFlJwoxUnw==} + engines: {node: '>= 16'} + peerDependencies: + express: '>= 4.11' - human-signals@2.1.0: - resolution: {integrity: sha512-B4FFZ6q/T2jhhksgkbEW3HBvWIfDW85snkQgawt07S7J5QXTk6BkNV+0yAeZrM5QpMAdYlocGoljn0sJ/WQkFw==} - engines: {node: '>=10.17.0'} + express-rate-limit@8.2.1: + resolution: {integrity: sha512-PCZEIEIxqwhzw4KF0n7QF4QqruVTcF73O5kFKUnGOyjbCCgizBBiFaYpd/fnBLUMPw/BWw9OsiN7GgrNYr7j6g==} + engines: {node: '>= 16'} + peerDependencies: + express: '>= 4.11' - human-signals@8.0.1: - resolution: {integrity: sha512-eKCa6bwnJhvxj14kZk5NCPc6Hb6BdsU9DZcOnmQKSnO1VKrfV0zCvtttPZUsBvjmNDn8rpcJfpwSYnHBjc95MQ==} - engines: {node: '>=18.18.0'} + express@4.22.3: + resolution: {integrity: sha512-Bdcs4+3qlpVlx2NRn6fgX2Ue2/gGRaPeawebgclM0ERSCqDpA+owF1fdPwjJUTAJWMTuAaxjDf+hzb0/4eKvvw==} + engines: {node: '>= 0.10.0'} - humanize-ms@1.2.1: - resolution: {integrity: sha512-Fl70vYtsAFb/C06PTS9dZBo7ihau+Tu/DNCk/OyHhea07S+aeMWpFFkUaXRa8fI+ScZbEI8dfSxwY7gxZ9SAVQ==} + express@5.2.1: + resolution: {integrity: sha512-hIS4idWWai69NezIdRt2xFVofaF4j+6INOpJlVOLDO8zXGpUVEVzIYk12UUi2JzjEzWL3IOAxcTubgz9Po0yXw==} + engines: {node: '>= 18'} - iconv-lite@0.6.3: - resolution: {integrity: sha512-4fCk79wshMdzMp2rH06qWrJE4iolqLhCUH+OiuIgU++RB0+94NlDL81atO7GX55uUKueo0txHNtvEyI6D7WdMw==} + extend-shallow@2.0.1: + resolution: {integrity: sha512-zCnTtlxNoAiDc3gqY2aYAWFx7XWWiasuF2K8Me5WbN8otHKTUKBwjPtNpRs/rbUZm7KxWAaNj7P1a/p52GbVug==} engines: {node: '>=0.10.0'} - iconv-lite@0.7.2: - resolution: {integrity: sha512-im9DjEDQ55s9fL4EYzOAv0yMqmMBSZp6G0VvFyTMPKWxiSBHUj9NW/qqLmXUwXrrM7AvqSlTCfvqRb0cM8yYqw==} - engines: {node: '>=0.10.0'} + extend@3.0.2: + resolution: {integrity: sha512-fjquC59cD7CyW6urNXK0FBufkZcoiGG80wTuPujX590cB5Ttln20E2UB4S/WARVqhXffZl2LNgS+gQdPIIim/g==} - ieee754@1.2.1: - resolution: {integrity: sha512-dcyqhDvX1C46lXZcVqCpK+FtMRQVdIMN6/Df5js2zouUsqG7I6sFxitIC+7KYK29KdXOLHdu9zL4sFnoVQnqaA==} + fast-deep-equal@3.1.3: + resolution: {integrity: sha512-f3qQ9oQy9j2AhBe/H9VC91wLmKBCCU/gDOnKNAYG5hswO7BLKj09Hc5HYNz9cGI++xlpDCIgDaitVs03ATR84Q==} - ignore@5.3.2: - resolution: {integrity: sha512-hsBTNUqQTDwkWtcdYI2i06Y/nUBEsNEDJKjWdigLvegy8kDuJAS8uRlpkkcQpyEXL0Z/pjDy5HBmMjRCJ2gq+g==} - engines: {node: '>= 4'} + fast-glob@3.3.3: + resolution: {integrity: sha512-7MptL8U0cqcFdzIzwOTHoilX9x5BrNqye7Z/LuC7kCMRio1EMSyqRK3BEAUD7sXRq4iT4AzTVuZdhgQ2TCvYLg==} + engines: {node: '>=8.6.0'} - ignore@7.0.5: - resolution: {integrity: sha512-Hs59xBNfUIunMFgWAbGX5cq6893IbWg4KnrjbYwX3tx0ztorVgTDA6B2sxf8ejHJ4wz8BqGUMYlnzNBer5NvGg==} - engines: {node: '>= 4'} + fast-json-stable-stringify@2.1.0: + resolution: {integrity: sha512-lhd/wF+Lk98HZoTCtlVraHtfh5XYijIjalXck7saUtuanSDyLMxnHhSXEDJqHxD7msR8D0uCmqlkwjCV8xvwHw==} - import-in-the-middle@1.14.2: - resolution: {integrity: sha512-5tCuY9BV8ujfOpwtAGgsTx9CGUapcFMEEyByLv1B+v2+6DhAcw+Zr0nhQT7uwaZ7DiourxFEscghOR8e1aPLQw==} + fast-uri@3.1.0: + resolution: {integrity: sha512-iPeeDKJSWf4IEOasVVrknXpaBV0IApz/gp7S2bb7Z4Lljbl2MGJRqInZiUrQwV16cpzw/D3S5j5Julj/gT52AA==} - import-in-the-middle@1.7.1: - resolution: {integrity: sha512-1LrZPDtW+atAxH42S6288qyDFNQ2YCty+2mxEPRtfazH6Z5QwkaBSTS2ods7hnVJioF6rkRfNoA6A/MstpFXLg==} - - import-local@3.2.0: - resolution: {integrity: sha512-2SPlun1JUPWoM6t3F0dw0FkCF/jWY8kttcY4f599GLTSjh2OCuuhdTkJQsEcZzBqbXZGKMK2OqW1oZsjtf/gQA==} - engines: {node: '>=8'} + fast-xml-parser@5.2.5: + resolution: {integrity: sha512-pfX9uG9Ki0yekDHx2SiuRIyFdyAr1kMIMitPvb0YBo8SUfKvia7w7FIyd/l6av85pFYRhZscS75MwMnbvY+hcQ==} hasBin: true - imurmurhash@0.1.4: - resolution: {integrity: sha512-JmXMZ6wuvDmLiHEml9ykzqO6lwFbof0GG4IkcGaENdCRDDmMVnny7s5HsIgHCbaq0w2MyPhDqkhTUgS2LU2PHA==} - engines: {node: '>=0.8.19'} + fast-xml-parser@5.3.7: + resolution: {integrity: sha512-JzVLro9NQv92pOM/jTCR6mHlJh2FGwtomH8ZQjhFj/R29P2Fnj38OgPJVtcvYw6SuKClhgYuwUZf5b3rd8u2mA==} + hasBin: true - inflight@1.0.6: - resolution: {integrity: sha512-k92I/b08q4wvFscXCLvqfsHCrjrF7yiXsQuIVvVE7N82W3+aqpzuUdBbfhWcy/FZR3/4IgflMgKLOsvPDrGCJA==} - deprecated: This module is not supported, and leaks memory. Do not use it. Check out lru-cache if you want a good and tested way to coalesce async requests by a key value, which is much more comprehensive and powerful. + fastq@1.20.1: + resolution: {integrity: sha512-GGToxJ/w1x32s/D2EKND7kTil4n8OVk/9mycTc4VDza13lOvpUZTGX3mFSCtV9ksdGBVzvsyAVLM6mHFThxXxw==} - infobox-parser@3.6.4: - resolution: {integrity: sha512-d2lTlxKZX7WsYxk9/UPt51nkmZv5tbC75SSw4hfHqZ3LpRAn6ug0oru9xI2X+S78va3aUAze3xl/UqMuwLmJUw==} + faye-websocket@0.11.4: + resolution: {integrity: sha512-CzbClwlXAuiRQAlUyfqPgvPoNKTckTPGfwZV4ZdAhVcP2lh9KUxJg2b5GkE7XbjKQ3YJnQ9z6D9ntLAlB+tP8g==} + engines: {node: '>=0.8.0'} - inherits@2.0.4: - resolution: {integrity: sha512-k/vGaX4/Yla3WzyMCvTQOXYeIHvqOKtnqBduzTHpzpQZzAskKMhZ2K+EnBiSM9zGSoIFeMpXKxa4dYeZIQqewQ==} + fb-watchman@2.0.2: + resolution: {integrity: sha512-p5161BqbuCaSnB8jIbzQHOlpgsPmK5rJVDfDKO91Axs5NC1uu3HRQm6wt9cd9/+GtQQIO53JdGXXoyDpTAsgYA==} - ip-address@10.0.1: - resolution: {integrity: sha512-NWv9YLW4PoW2B7xtzaS3NCot75m6nK7Icdv0o3lfMceJVRfSoQwqD4wEH5rLwoKJwUiZ/rfpiVBhnaF0FK4HoA==} - engines: {node: '>= 12'} + fdir@6.5.0: + resolution: {integrity: sha512-tIbYtZbucOs0BRGqPJkshJUYdL+SDH7dVM8gjy+ERp3WAUjLEFJE+02kanyHtwjWOnwrKYBiwAmM0p4kLJAnXg==} + engines: {node: '>=12.0.0'} + peerDependencies: + picomatch: ^3 || ^4 + peerDependenciesMeta: + picomatch: + optional: true - ipaddr.js@1.9.1: - resolution: {integrity: sha512-0KI/607xoxSToH7GjN1FfSbLoU0+btTicjsQSWQlh/hZykN8KpmMf7uYwPW3R+akZ6R/w18ZlXSHBYXiYUPO3g==} - engines: {node: '>= 0.10'} + fecha@4.2.3: + resolution: {integrity: sha512-OP2IUU6HeYKJi3i0z4A19kHMQoLVs4Hc+DPqqxI2h/DPZHTm/vjsfC6P0b4jCMy14XizLBqvndQ+UilD7707Jw==} - is-any-array@2.0.1: - resolution: {integrity: sha512-UtilS7hLRu++wb/WBAw9bNuP1Eg04Ivn1vERJck8zJthEvXCBEBpGR/33u/xLKWEQf95803oalHrVDptcAvFdQ==} + fetch-blob@3.2.0: + resolution: {integrity: sha512-7yAQpD2UMJzLi1Dqv7qFYnPbaPx7ZfFK6PiIxQ4PfkGPyNyl2Ugx+a/umUonmKqjhM4DnfbMvdX6otXq83soQQ==} + engines: {node: ^12.20 || >= 14.13} - is-arrayish@0.2.1: - resolution: {integrity: sha512-zz06S8t0ozoDXMG+ube26zeCTNXcKIPJZJi8hBrF4idCLms4CG9QtK7qBl1boi5ODzFpjswb5JPmHCbMpjaYzg==} + figures@6.1.0: + resolution: {integrity: sha512-d+l3qxjSesT4V7v2fh+QnmFnUWv9lSpjarhShNTgBOfA0ttejbQUAlHLitbjkoRiDulW0OPoQPYIGhIC8ohejg==} + engines: {node: '>=18'} - is-binary-path@2.1.0: - resolution: {integrity: sha512-ZMERYes6pDydyuGidse7OsHxtbI7WVeUEozgR/g7rd0xUimYNlvZRE/K2MgZTjWy725IfelLeVcEM97mmtRGXw==} + fill-range@7.1.1: + resolution: {integrity: sha512-YsGpe3WHLK8ZYi4tWDg2Jy3ebRz2rXowDxnld4bkQB00cc/1Zw9AWnC0i9ztDJitivtQvaI9KaLyKrc+hBW0yg==} engines: {node: '>=8'} - is-buffer@1.1.6: - resolution: {integrity: sha512-NcdALwpXkTm5Zvvbk7owOUSvVvBKDgKP5/ewfXEznmQFfs4ZRmanOeKBTjRVjka3QFoN6XJ+9F3USqfHqTaU5w==} - - is-core-module@2.16.1: - resolution: {integrity: sha512-UfoeMA6fIJ8wTYFEUjelnaGI67v6+N7qXJEvQuIGa99l4xsCruSYOVSQ0uPANn4dAzm8lkYPaKLrrijLq7x23w==} - engines: {node: '>= 0.4'} + finalhandler@1.3.2: + resolution: {integrity: sha512-aA4RyPcd3badbdABGDuTXCMTtOneUCAYH/gxoYRTZlIJdF0YPWuGqiAsIrhNnnqdXGswYk6dGujem4w80UJFhg==} + engines: {node: '>= 0.8'} - is-extendable@0.1.1: - resolution: {integrity: sha512-5BMULNob1vgFX6EjQw5izWDxrecWK9AM72rugNr0TFldMOi0fj6Jk+zeKIt0xGj4cEfQIJth4w3OKWOJ4f+AFw==} - engines: {node: '>=0.10.0'} + finalhandler@2.1.1: + resolution: {integrity: sha512-S8KoZgRZN+a5rNwqTxlZZePjT/4cnm0ROV70LedRHZ0p8u9fRID0hJUZQpkKLzro8LfmC8sx23bY6tVNxv8pQA==} + engines: {node: '>= 18.0.0'} - is-extglob@2.1.1: - resolution: {integrity: sha512-SbKbANkN603Vi4jEZv49LeVJMn4yGwsbzZworEoyEiutsN3nJYdbO36zfhGJ6QEDpOZIFkDtnq5JRxmvl3jsoQ==} - engines: {node: '>=0.10.0'} + find-replace@3.0.0: + resolution: {integrity: sha512-6Tb2myMioCAgv5kfvP5/PkZZ/ntTpVK39fHY7WkWBgvbeE+VHd/tZuZ4mrC+bxh4cfOZeYKVPaJIZtZXV7GNCQ==} + engines: {node: '>=4.0.0'} - is-fullwidth-code-point@3.0.0: - resolution: {integrity: sha512-zymm5+u+sCsSWyD9qNaejV3DFvhCKclKdizYaJUuHA83RLjb7nSuGnddCHGv0hk+KY7BMAlsWeK4Ueg6EV6XQg==} + find-up@4.1.0: + resolution: {integrity: sha512-PpOwAdQ/YlXQ2vj8a3h8IipDuYRi3wceVQQGYWxNINccq40Anw7BlsEXCMbt1Zt+OLA6Fq9suIpIWD0OsnISlw==} engines: {node: '>=8'} - is-generator-fn@2.1.0: - resolution: {integrity: sha512-cTIB4yPYL/Grw0EaSzASzg6bBy9gqCofvWN8okThAYIxKJZC+udlRAmGbM0XLeniEJSs8uEgHPGuHSe1XsOLSQ==} - engines: {node: '>=6'} + firebase-admin@14.5.0: + resolution: {integrity: sha512-DElmgmaH9aPXu2dWXGQiDoan33UfTnbfAAKaue4fwEZxmpdaNrTk5DmuFn+vVDki2KZ6TiaC0IHRWcEzcDxB3Q==} + engines: {node: '>=22'} - is-glob@4.0.3: - resolution: {integrity: sha512-xelSayHH36ZgE7ZWhli7pW34hNbNl8Ojv5KVmkJD4hBdD3th8Tfk9vYasLM+mXWOZhFkgZfxhLSnrwRr4elSSg==} - engines: {node: '>=0.10.0'} + flat@5.0.2: + resolution: {integrity: sha512-b6suED+5/3rTpUBdG1gupIl8MPFCAMA0QXwmljLhvCUKcUvdE4gWky9zpuGCcXHOsz4J9wPGNWq6OKpmIzz3hQ==} + hasBin: true - is-network-error@1.3.2: - resolution: {integrity: sha512-PhBY86zaxNZUuWP6h13Vu5oFe0XY6/UlKzQnYFELzGVHygP3MxmvTfYSG7GN3aIab/iWudSMgjSnG9Dq+nHrgA==} - engines: {node: '>=16'} + flatbuffers@23.5.26: + resolution: {integrity: sha512-vE+SI9vrJDwi1oETtTIFldC/o9GsVKRM+s6EL0nQgxXlYV1Vc4Tk30hj4xGICftInKQKj1F3up2n8UbIVobISQ==} - is-number@7.0.0: - resolution: {integrity: sha512-41Cifkg6e8TylSpdtTpeLVMqvSBEVzTttHvERD741+pnZ8ANv0004MRL43QKPDlK9cGvNp6NZWZUBlbGXYxxng==} - engines: {node: '>=0.12.0'} + fn.name@1.1.0: + resolution: {integrity: sha512-GRnmB5gPyJpAhTQdSZTSp9uaPSvl09KoYcMQtsB9rQoOmzs9dH6ffeccH+Z+cv6P68Hu5bC6JjRh4Ah/mHSNRw==} - is-obj@2.0.0: - resolution: {integrity: sha512-drqDG3cbczxxEJRoOXcOjtdp1J/lyp1mNn0xaznRs8+muBhgQcrnbspox5X5fOw0HnMnbfDzvnEMEtqDEJEo8w==} - engines: {node: '>=8'} + follow-redirects@1.15.11: + resolution: {integrity: sha512-deG2P0JfjrTxl50XGCDyfI97ZGVCxIpfKYmfyrQ54n5FO/0gfIES8C/Psl6kWVDolizcaaxZJnTS0QSMxvnsBQ==} + engines: {node: '>=4.0'} + peerDependencies: + debug: '*' + peerDependenciesMeta: + debug: + optional: true - is-plain-obj@4.1.0: - resolution: {integrity: sha512-+Pgi+vMuUNkJyExiMBt5IlFoMyKnr5zhJ4Uspz58WOhBF5QoIZkFyNHIbBAtHwzVAgk5RtndVNsDRN61/mmDqg==} - engines: {node: '>=12'} + foreground-child@3.3.1: + resolution: {integrity: sha512-gIXjKqtFuWEgzFRJA9WCQeSJLZDjgJUOMCMzxtvFq/37KojM1BFGufqsCy0r4qSQmYLsZYMeyRqzIWOMup03sw==} + engines: {node: '>=14'} - is-plain-object@2.0.4: - resolution: {integrity: sha512-h5PpgXkWitc38BBMYawTYMWJHFZJVnBquFE57xFpjB8pJFiF6gZ+bU+WyI/yqXiFR5mdLsgYNaPe8uao6Uv9Og==} - engines: {node: '>=0.10.0'} + form-data-encoder@1.7.2: + resolution: {integrity: sha512-qfqtYan3rxrnCk1VYaA4H+Ms9xdpPqvLZa6xmMgFvhO32x7/3J/ExcTd6qpxM0vH2GdMI+poehyBZvqfMTto8A==} - is-promise@4.0.0: - resolution: {integrity: sha512-hvpoI6korhJMnej285dSg6nu1+e6uxs7zG3BYAm5byqDsgJNWwxzM6z6iZiAgQR4TJ30JmBTOwqZUw3WlyH3AQ==} + form-data-encoder@4.1.0: + resolution: {integrity: sha512-G6NsmEW15s0Uw9XnCg+33H3ViYRyiM0hMrMhhqQOR8NFc5GhYrI+6I3u7OTw7b91J2g8rtvMBZJDbcGb2YUniw==} + engines: {node: '>= 18'} - is-stream@2.0.1: - resolution: {integrity: sha512-hFoiJiTl63nn+kstHGBtewWSKnQLpyb155KHheA1l39uvtO9nWIop1p3udqPcUd/xbF1VLMO4n7OI6p7RbngDg==} - engines: {node: '>=8'} + form-data@2.5.5: + resolution: {integrity: sha512-jqdObeR2rxZZbPSGL+3VckHMYtu+f9//KXBsVny6JSX/pa38Fy+bGjuG8eW/H6USNQWhLi8Num++cU2yOCNz4A==} + engines: {node: '>= 0.12'} - is-stream@4.0.1: - resolution: {integrity: sha512-Dnz92NInDqYckGEUJv689RbRiTSEHCQ7wOVeALbkOz999YpqT46yMRIGtSNl2iCL1waAZSx40+h59NV/EwzV/A==} - engines: {node: '>=18'} + form-data@4.0.2: + resolution: {integrity: sha512-hGfm/slu0ZabnNt4oaRZ6uREyfCj6P4fT/n6A1rGV+Z0VdGXjfOhVUpkn6qVQONHGIFwmveGXyDs75+nr6FM8w==} + engines: {node: '>= 6'} - is-unicode-supported@2.1.0: - resolution: {integrity: sha512-mE00Gnza5EEB3Ds0HfMyllZzbBrmLOX3vfWoj9A9PEnTfratQ/BcaJOuMhnkhjXvb2+FkY3VuHqtAGpTPmglFQ==} - engines: {node: '>=18'} + form-data@4.0.5: + resolution: {integrity: sha512-8RipRLol37bNs2bhoV67fiTEvdTrbMUYcFTiy3+wuuOnUog2QBHCZWXDRijWQfAkhBj2Uf5UnVaiWwA5vdd82w==} + engines: {node: '>= 6'} - isexe@2.0.0: - resolution: {integrity: sha512-RHxMLp9lnKHGHRng9QFhRCMbYAcVpn69smSGcq3f36xjgVVWThj4qqLbTLlq7Ssj8B+fIQ1EuCEGI2lKsyQeIw==} + formdata-node@4.4.1: + resolution: {integrity: sha512-0iirZp3uVDjVGt9p49aTaqjk84TrglENEDuqfdlZQ1roC9CWlPk6Avf8EEnZNcAqPonwkG35x4n3ww/1THYAeQ==} + engines: {node: '>= 12.20'} - isobject@3.0.1: - resolution: {integrity: sha512-WhB9zCku7EGTj/HQQRz5aUQEUeoQZH2bWcltRErOpymJ4boYE6wL9Tbr23krRPSZ+C5zqNSrSw+Cc7sZZ4b7vg==} - engines: {node: '>=0.10.0'} + formdata-node@6.0.3: + resolution: {integrity: sha512-8e1++BCiTzUno9v5IZ2J6bv4RU+3UKDmqWUQD0MIMVCd9AdhWkO1gw57oo1mNEX1dMq2EGI+FbWz4B92pscSQg==} + engines: {node: '>= 18'} - isomorphic-fetch@3.0.0: - resolution: {integrity: sha512-qvUtwJ3j6qwsF3jLxkZ72qCgjMysPzDfeV240JHiGZsANBYd+EEuu35v7dfrJ9Up0Ak07D7GGSkGhCHTqg/5wA==} + formdata-polyfill@4.0.10: + resolution: {integrity: sha512-buewHzMvYL29jdeQTVILecSaZKnt/RJWjoZCF5OW60Z67/GmSLBkOFM7qh1PI3zFNtJbaZL5eQu1vLfazOwj4g==} + engines: {node: '>=12.20.0'} - istanbul-lib-coverage@3.2.2: - resolution: {integrity: sha512-O8dpsF+r0WV/8MNRKfnmrtCWhuKjxrq2w+jpzBL5UZKTi2LeVWnWOmWRxFlesJONmc+wLAGvKQZEOanko0LFTg==} - engines: {node: '>=8'} + forwarded@0.2.0: + resolution: {integrity: sha512-buRG0fpBtRHSTCOASe6hD258tEubFoRLb4ZNA6NxMVHNw2gOcwHo9wyablzMzOA5z9xA9L1KNjk/Nt6MT9aYow==} + engines: {node: '>= 0.6'} - istanbul-lib-instrument@5.2.1: - resolution: {integrity: sha512-pzqtp31nLv/XFOzXGuvhCb8qhjmTVo5vjVk19XE4CRlSWz0KoeJ3bw9XsA7nOp9YBf4qHjwBxkDzKcME/J29Yg==} - engines: {node: '>=8'} + fraction.js@5.3.4: + resolution: {integrity: sha512-1X1NTtiJphryn/uLQz3whtY6jK3fTqoE3ohKs0tT+Ujr1W59oopxmoEh7Lu5p6vBaPbgoM0bzveAW4Qi5RyWDQ==} - istanbul-lib-instrument@6.0.3: - resolution: {integrity: sha512-Vtgk7L/R2JHyyGW07spoFlB8/lpjiOLTjMdms6AFMraYt3BaJauod/NGrfnVG/y4Ix1JEuMRPDPEj2ua+zz1/Q==} - engines: {node: '>=10'} + fresh@0.5.2: + resolution: {integrity: sha512-zJ2mQYM18rEFOudeV4GShTGIQ7RbzA7ozbU9I/XBpm7kqgMywgmylMwXHxZJmkVoYkna9d2pVXVXPdYTP9ej8Q==} + engines: {node: '>= 0.6'} - istanbul-lib-report@3.0.1: - resolution: {integrity: sha512-GCfE1mtsHGOELCU8e/Z7YWzpmybrx/+dSTfLrvY8qRmaY6zXTKWn6WQIjaAFw069icm6GVMNkgu0NzI4iPZUNw==} - engines: {node: '>=10'} + fresh@2.0.0: + resolution: {integrity: sha512-Rx/WycZ60HOaqLKAi6cHRKKI7zxWbJ31MhntmtwMoaTeF7XFH9hhBp8vITaMidfljRQ6eYWCKkaTK+ykVJHP2A==} + engines: {node: '>= 0.8'} - istanbul-lib-source-maps@4.0.1: - resolution: {integrity: sha512-n3s8EwkdFIJCG3BPKBYvskgXGoy88ARzvegkitk60NxRdwltLOTaH7CUiMRXvwYorl0Q712iEjcWB+fK/MrWVw==} - engines: {node: '>=10'} + fs.realpath@1.0.0: + resolution: {integrity: sha512-OO0pH2lK6a0hZnAdau5ItzHPI6pUlvI7jMVnxUQRtw4owF2wk8lOSabtGDCTP4Ggrg2MbGnWO9X8K1t4+fGMDw==} - istanbul-reports@3.1.7: - resolution: {integrity: sha512-BewmUXImeuRk2YY0PVbxgKAysvhRPUQE0h5QRM++nVWyubKGV0l8qQ5op8+B2DOmwSe63Jivj0BjkPQVf8fP5g==} - engines: {node: '>=8'} + fsevents@2.3.3: + resolution: {integrity: sha512-5xoDfX+fL7faATnagmWPpbFtwh/R77WmMMqqHGS65C3vvB0YHrgF+B1YmZ3441tMj5n63k0212XNoJwzlhffQw==} + engines: {node: ^8.16.0 || ^10.6.0 || >=11.0.0} + os: [darwin] - jackspeak@3.4.3: - resolution: {integrity: sha512-OGlZQpz2yfahA/Rd1Y8Cd9SIEsqvXkLVoSw/cgwhnhFMDbsQFeZYoJJ7bIZBS9BcamUW96asq/npPWugM+RQBw==} + function-bind@1.1.2: + resolution: {integrity: sha512-7XHNxH7qX9xG5mIwxkhumTox/MIRNcOgDrxWsMt2pAr23WHp6MrRlN7FBSFpCpr+oVO0F744iUgR82nJMfG2SA==} - javascript-natural-sort@0.7.1: - resolution: {integrity: sha512-nO6jcEfZWQXDhOiBtG2KvKyEptz7RVbpGP4vTD2hLBdmNQSsCiicO2Ioinv6UI4y9ukqnBpy+XZ9H6uLNgJTlw==} + functional-red-black-tree@1.0.1: + resolution: {integrity: sha512-dsKNQNdj6xA3T+QlADDA7mOSlX0qiMINjn0cgr+eGHGsbSHzTabcIogz2+p/iqP1Xs6EP/sS2SbqH+brGTbq0g==} - jest-changed-files@29.7.0: - resolution: {integrity: sha512-fEArFiwf1BpQ+4bXSprcDc3/x4HSzL4al2tozwVpDFpsxALjLYdyiIK4e5Vz66GQJIbXJ82+35PtysofptNX2w==} - engines: {node: ^14.15.0 || ^16.10.0 || >=18.0.0} + gaxios@6.7.1: + resolution: {integrity: sha512-LDODD4TMYx7XXdpwxAVRAIAuB0bzv0s+ywFonY46k126qzQHT9ygyoa9tncmOiQmmDrik65UYsEkv3lbfqQ3yQ==} + engines: {node: '>=14'} - jest-circus@29.7.0: - resolution: {integrity: sha512-3E1nCMgipcTkCocFwM90XXQab9bS+GMsjdpmPrlelaxwD93Ad8iVEjX/vvHPdLPnFf+L40u+5+iutRdA1N9myw==} - engines: {node: ^14.15.0 || ^16.10.0 || >=18.0.0} + gaxios@7.1.3: + resolution: {integrity: sha512-YGGyuEdVIjqxkxVH1pUTMY/XtmmsApXrCVv5EU25iX6inEPbV+VakJfLealkBtJN69AQmh1eGOdCl9Sm1UP6XQ==} + engines: {node: '>=18'} - jest-cli@29.7.0: - resolution: {integrity: sha512-OVVobw2IubN/GSYsxETi+gOe7Ka59EFMR/twOU3Jb2GnKKeMGJB5SGUUrEz3SFVmJASUdZUzy83sLNNQ2gZslg==} - engines: {node: ^14.15.0 || ^16.10.0 || >=18.0.0} - hasBin: true - peerDependencies: - node-notifier: ^8.0.1 || ^9.0.0 || ^10.0.0 - peerDependenciesMeta: - node-notifier: - optional: true + gaxios@7.3.1: + resolution: {integrity: sha512-kB3rzJV7d9juLZh8/56QTXCwQfxyhdOMdyYk1HdQKFtF8TJTDTZQJtixWIwXdE9Jji91mC41DUNpjleo4L4eAQ==} + engines: {node: '>=18'} - jest-config@29.7.0: - resolution: {integrity: sha512-uXbpfeQ7R6TZBqI3/TxCU4q4ttk3u0PJeC+E0zbfSoSjq6bJ7buBPxzQPL0ifrkY4DNu4JUdk0ImlBUYi840eQ==} - engines: {node: ^14.15.0 || ^16.10.0 || >=18.0.0} - peerDependencies: - '@types/node': '*' - ts-node: '>=9.0.0' - peerDependenciesMeta: - '@types/node': - optional: true - ts-node: - optional: true + gcp-metadata@6.1.1: + resolution: {integrity: sha512-a4tiq7E0/5fTjxPAaH4jpjkSv/uCaU2p5KC6HVGrvl0cDjA8iBZv4vv1gyzlmK0ZUKqwpOyQMKzZQe3lTit77A==} + engines: {node: '>=14'} - jest-diff@29.7.0: - resolution: {integrity: sha512-LMIgiIrhigmPrs03JHpxUh2yISK3vLFPkAodPeo0+BuF7wA2FoQbkEg1u8gBYBThncu7e1oEDUfIXVuTqLRUjw==} - engines: {node: ^14.15.0 || ^16.10.0 || >=18.0.0} + gcp-metadata@8.1.2: + resolution: {integrity: sha512-zV/5HKTfCeKWnxG0Dmrw51hEWFGfcF2xiXqcA3+J90WDuP0SvoiSO5ORvcBsifmx/FoIjgQN3oNOGaQ5PhLFkg==} + engines: {node: '>=18'} - jest-docblock@29.7.0: - resolution: {integrity: sha512-q617Auw3A612guyaFgsbFeYpNP5t2aoUNLwBUbc/0kD1R4t9ixDbyFTHd1nok4epoVFpr7PmeWHrhvuV3XaJ4g==} - engines: {node: ^14.15.0 || ^16.10.0 || >=18.0.0} + gcp-metadata@9.0.4: + resolution: {integrity: sha512-p6WvbXOhfwnVtv/MyPq5kBiVhfV/qglMIxwwTVNEI1Ha1HmOgz5uHYHtYO6SfGckFaXe8blA11IJJ3wqXmvmBA==} + engines: {node: '>=22'} - jest-each@29.7.0: - resolution: {integrity: sha512-gns+Er14+ZrEoC5fhOfYCY1LOHHr0TI+rQUHZS8Ttw2l7gl+80eHc/gFf2Ktkw0+SIACDTeWvpFcv3B04VembQ==} - engines: {node: ^14.15.0 || ^16.10.0 || >=18.0.0} + generative-bayesian-network@2.1.80: + resolution: {integrity: sha512-LyCc23TIFvZDkUJclZ3ixCZvd+dhktr9Aug1EKz5VrfJ2eA5J2HrprSwWRna3VObU2Wy8quXMUF8j2em0bJSLw==} - jest-environment-node@29.7.0: - resolution: {integrity: sha512-DOSwCRqXirTOyheM+4d5YZOrWcdu0LNZ87ewUoywbcb2XR4wKgqiG8vNeYwhjFMbEkfju7wx2GYH0P2gevGvFw==} - engines: {node: ^14.15.0 || ^16.10.0 || >=18.0.0} + generic-pool@3.9.0: + resolution: {integrity: sha512-hymDOu5B53XvN4QT9dBmZxPX4CWhBPPLguTZ9MMFeFa/Kg0xWVfylOVNlJji/E7yTZWFd/q9GO5TxDLq156D7g==} + engines: {node: '>= 4'} - jest-get-type@29.6.3: - resolution: {integrity: sha512-zrteXnqYxfQh7l5FHyL38jL39di8H8rHoecLH3JNxH3BwOrBsNeabdap5e0I23lD4HHI8W5VFBZqG4Eaq5LNcw==} - engines: {node: ^14.15.0 || ^16.10.0 || >=18.0.0} + genkit@1.42.0: + resolution: {integrity: sha512-yGdsoIo0UQtkNUrKWGQdRihGzbGf2njxYqcpDbkWdQPzMG7/s5caS0ovM+WDdkWPKwMBwxAD+8f9uQmDI7ZOCQ==} - jest-haste-map@29.7.0: - resolution: {integrity: sha512-fP8u2pyfqx0K1rGn1R9pyE0/KTn+G7PxktWidOBTqFPLYX0b9ksaMFkhK5vrS3DVun09pckLdlx90QthlW7AmA==} - engines: {node: ^14.15.0 || ^16.10.0 || >=18.0.0} + gensync@1.0.0-beta.2: + resolution: {integrity: sha512-3hN7NaskYvMDLQY55gnW3NQ+mesEAepTqlg+VEbj7zzqEMBVNhzcGYYeqFo/TlYz6eQiFcp1HcsCZO+nGgS8zg==} + engines: {node: '>=6.9.0'} - jest-leak-detector@29.7.0: - resolution: {integrity: sha512-kYA8IJcSYtST2BY9I+SMC32nDpBT3J2NvWJx8+JCuCdl/CR1I4EKUJROiP8XtCcxqgTTBGJNdbB1A8XRKbTetw==} - engines: {node: ^14.15.0 || ^16.10.0 || >=18.0.0} + get-caller-file@2.0.5: + resolution: {integrity: sha512-DyFP3BM/3YHTQOCUL/w0OZHR0lpKeGrxotcHWcqNEdnltqFwXVfhEBQ94eIo34AfQpo0rGki4cyIiftY06h2Fg==} + engines: {node: 6.* || 8.* || >= 10.*} - jest-matcher-utils@29.7.0: - resolution: {integrity: sha512-sBkD+Xi9DtcChsI3L3u0+N0opgPYnCRPtGcQYrgXmR+hmt/fYfWAL0xRXYU8eWOdfuLgBe0YCW3AFtnRLagq/g==} - engines: {node: ^14.15.0 || ^16.10.0 || >=18.0.0} + get-intrinsic@1.3.0: + resolution: {integrity: sha512-9fSjSaos/fRIVIp+xSJlE6lfwhES7LNtKaCBIamHsjr2na1BiABJPo0mOjjz8GJDURarmCPGqaiVg5mfjb98CQ==} + engines: {node: '>= 0.4'} - jest-message-util@29.7.0: - resolution: {integrity: sha512-GBEV4GRADeP+qtB2+6u61stea8mGcOT4mCtrYISZwfu9/ISHFJ/5zOMXYbpBE9RsS5+Gb63DW4FgmnKJ79Kf6w==} - engines: {node: ^14.15.0 || ^16.10.0 || >=18.0.0} + get-package-type@0.1.0: + resolution: {integrity: sha512-pjzuKtY64GYfWizNAJ0fr9VqttZkNiK2iS430LtIHzjBEr6bX8Am2zm4sW4Ro5wjWW5cAlRL1qAMTcXbjNAO2Q==} + engines: {node: '>=8.0.0'} - jest-mock@29.7.0: - resolution: {integrity: sha512-ITOMZn+UkYS4ZFh83xYAOzWStloNzJFO2s8DWrE4lhtGD+AorgnbkiKERe4wQVBydIGPx059g6riW5Btp6Llnw==} - engines: {node: ^14.15.0 || ^16.10.0 || >=18.0.0} + get-port@5.1.1: + resolution: {integrity: sha512-g/Q1aTSDOxFpchXC4i8ZWvxA1lnPqx/JHqcpIw0/LX9T8x/GBbi6YnlN5nhaKIFkT8oFsscUKgDJYxfwfS6QsQ==} + engines: {node: '>=8'} - jest-pnp-resolver@1.2.3: - resolution: {integrity: sha512-+3NpwQEnRoIBtx4fyhblQDPgJI0H1IEIkX7ShLUjPGA7TtUTvI1oiKi3SR4oBR0hQhQR80l4WAe5RrXBwWMA8w==} - engines: {node: '>=6'} - peerDependencies: - jest-resolve: '*' - peerDependenciesMeta: - jest-resolve: - optional: true + get-proto@1.0.1: + resolution: {integrity: sha512-sTSfBjoXBp89JvIKIefqw7U2CCebsc74kiY6awiGogKtoSGbgjYE/G/+l9sF3MWFPNc9IcoOC4ODfKHfxFmp0g==} + engines: {node: '>= 0.4'} - jest-regex-util@29.6.3: - resolution: {integrity: sha512-KJJBsRCyyLNWCNBOvZyRDnAIfUiRJ8v+hOBQYGn8gDyF3UegwiP4gwRR3/SDa42g1YbVycTidUF3rKjyLFDWbg==} - engines: {node: ^14.15.0 || ^16.10.0 || >=18.0.0} + get-stream@6.0.1: + resolution: {integrity: sha512-ts6Wi+2j3jQjqi70w5AlN8DFnkSwC+MqmxEzdEALB2qXZYV3X/b1CTfgPLGJNMeAWxdPfU8FO1ms3NUfaHCPYg==} + engines: {node: '>=10'} - jest-resolve-dependencies@29.7.0: - resolution: {integrity: sha512-un0zD/6qxJ+S0et7WxeI3H5XSe9lTBBR7bOHCHXkKR6luG5mwDDlIzVQ0V5cZCuoTgEdcdwzTghYkTWfubi+nA==} - engines: {node: ^14.15.0 || ^16.10.0 || >=18.0.0} + get-stream@9.0.1: + resolution: {integrity: sha512-kVCxPF3vQM/N0B1PmoqVUqgHP+EeVjmZSQn+1oCRPxd2P21P2F19lIgbR3HBosbB1PUhOAoctJnfEn2GbN2eZA==} + engines: {node: '>=18'} - jest-resolve@29.7.0: - resolution: {integrity: sha512-IOVhZSrg+UvVAshDSDtHyFCCBUl/Q3AAJv8iZ6ZjnZ74xzvwuzLXid9IIIPgTnY62SJjfuupMKZsZQRsCvxEgA==} - engines: {node: ^14.15.0 || ^16.10.0 || >=18.0.0} + get-tsconfig@4.13.0: + resolution: {integrity: sha512-1VKTZJCwBrvbd+Wn3AOgQP/2Av+TfTCOlE4AcRJE72W1ksZXbAx8PPBR9RzgTeSPzlPMHrbANMH3LbltH73wxQ==} - jest-runner@29.7.0: - resolution: {integrity: sha512-fsc4N6cPCAahybGBfTRcq5wFR6fpLznMg47sY5aDpsoejOcVYFb07AHuSnR0liMcPTgBsA3ZJL6kFOjPdoNipQ==} - engines: {node: ^14.15.0 || ^16.10.0 || >=18.0.0} + glob-parent@5.1.2: + resolution: {integrity: sha512-AOIgSQCepiJYwP3ARnGx+5VnTu2HBYdzbGP45eLw1vr3zB3vZLeyed1sC9hnbcOc9/SrMyM5RPQrkGz4aS9Zow==} + engines: {node: '>= 6'} - jest-runtime@29.7.0: - resolution: {integrity: sha512-gUnLjgwdGqW7B4LvOIkbKs9WGbn+QLqRQQ9juC6HndeDiezIwhDP+mhMwHWCEcfQ5RUXa6OPnFF8BJh5xegwwQ==} - engines: {node: ^14.15.0 || ^16.10.0 || >=18.0.0} + glob@10.5.0: + resolution: {integrity: sha512-DfXN8DfhJ7NH3Oe7cFmu3NCu1wKbkReJ8TorzSAFbSKrlNaQSKfIzqYqVY8zlbs2NLBbWpRiU52GX2PbaBVNkg==} + hasBin: true - jest-snapshot@29.7.0: - resolution: {integrity: sha512-Rm0BMWtxBcioHr1/OX5YCP8Uov4riHvKPknOGs804Zg9JGZgmIBkbtlxJC/7Z4msKYVbIJtfU+tKb8xlYNfdkw==} - engines: {node: ^14.15.0 || ^16.10.0 || >=18.0.0} + glob@13.0.0: + resolution: {integrity: sha512-tvZgpqk6fz4BaNZ66ZsRaZnbHvP/jG3uKJvAZOwEVUL4RTA5nJeeLYfyN9/VA8NX/V3IBG+hkeuGpKjvELkVhA==} + engines: {node: 20 || >=22} - jest-util@29.7.0: - resolution: {integrity: sha512-z6EbKajIpqGKU56y5KBUgy1dt1ihhQJgWzUlZHArA/+X2ad7Cb5iF+AK1EWVL/Bo7Rz9uurpqw6SiBCefUbCGA==} - engines: {node: ^14.15.0 || ^16.10.0 || >=18.0.0} + glob@7.2.3: + resolution: {integrity: sha512-nFR0zLpU2YCaRxwoCJvL6UvCH2JFyFVIvwTLsIf21AuHlMskA1hhTdk+LlYJtOlYt9v6dvszD2BGRqBL+iQK9Q==} + deprecated: Glob versions prior to v9 are no longer supported - jest-validate@29.7.0: - resolution: {integrity: sha512-ZB7wHqaRGVw/9hST/OuFUReG7M8vKeq0/J2egIGLdvjHCmYqGARhzXmtgi+gVeZ5uXFF219aOc3Ls2yLg27tkw==} - engines: {node: ^14.15.0 || ^16.10.0 || >=18.0.0} + globals@11.12.0: + resolution: {integrity: sha512-WOBp/EEGUiIsJSp7wcv/y6MO+lV9UoncWqxuFfm8eBwzWNgyfBd6Gz+IeKQ9jCmyhoH99g15M3T+QaVHFjizVA==} + engines: {node: '>=4'} - jest-watcher@29.7.0: - resolution: {integrity: sha512-49Fg7WXkU3Vl2h6LbLtMQ/HyB6rXSIX7SqvBLQmssRBGN9I0PNvPmAmCWSOY6SOvrjhI/F7/bGAv9RtnsPA03g==} - engines: {node: ^14.15.0 || ^16.10.0 || >=18.0.0} + globby@11.1.0: + resolution: {integrity: sha512-jhIXaOzy1sb8IyocaruWSn1TjmnBVs8Ayhcy83rmxNJ8q2uWKCAj3CnJY+KpGSXCueAPc0i05kVvVKtP1t9S3g==} + engines: {node: '>=10'} - jest-worker@29.7.0: - resolution: {integrity: sha512-eIz2msL/EzL9UFTFFx7jBTkeZfku0yUAyZZZmJ93H2TYEiroIx2PQjEXcwYtYl8zXCxb+PAmA2hLIt/6ZEkPHw==} - engines: {node: ^14.15.0 || ^16.10.0 || >=18.0.0} + google-auth-library@10.5.0: + resolution: {integrity: sha512-7ABviyMOlX5hIVD60YOfHw4/CxOfBhyduaYB+wbFWCWoni4N7SLcV46hrVRktuBbZjFC9ONyqamZITN7q3n32w==} + engines: {node: '>=18'} - jest@29.7.0: - resolution: {integrity: sha512-NIy3oAFp9shda19hy4HK0HRTWKtPJmGdnvywu01nOqNC2vZg+Z+fvJDxpMQA88eb2I9EcafcdjYgsDthnYTvGw==} - engines: {node: ^14.15.0 || ^16.10.0 || >=18.0.0} - hasBin: true - peerDependencies: - node-notifier: ^8.0.1 || ^9.0.0 || ^10.0.0 - peerDependenciesMeta: - node-notifier: - optional: true + google-auth-library@10.9.1: + resolution: {integrity: sha512-i1ydyHrqcIxXkWh/uBmVkzCvIuq5yiK2ATndIe5XxKholrG/MTYP9xGYka4sQhrbIAgGjL2B6NOE7rFaiF3fXw==} + engines: {node: '>=18'} - joplin-turndown-plugin-gfm@1.0.12: - resolution: {integrity: sha512-qL4+1iycQjZ1fs8zk3jSRk7cg3ROBUHk7GKtiLAQLFzLPKErnILUvz5DLszSQvz3s1sTjPbywLDISVUtBY6HaA==} + google-auth-library@11.1.0: + resolution: {integrity: sha512-YIBq5KNoHQrZ9PM4PeodDBqqBGlSTIxh1zibN8u3zNIO9UJg8gvKuCpdKV7fWXhsZ2zRkU6FhGrgKNgLJ2IRgw==} + engines: {node: '>=22'} - jose@5.10.0: - resolution: {integrity: sha512-s+3Al/p9g32Iq+oqXxkW//7jk2Vig6FF1CFqzVXoTUXt2qz89YWbL+OwS17NFYEvxC35n0FKeGO2LGYSxeM2Gg==} + google-auth-library@9.15.1: + resolution: {integrity: sha512-Jb6Z0+nvECVz+2lzSMt9u98UsoakXxA2HGHMCxh+so3n90XgYWkq5dur19JAJV7ONiJY22yBTyJB1TSkvPq9Ng==} + engines: {node: '>=14'} - jose@6.1.3: - resolution: {integrity: sha512-0TpaTfihd4QMNwrz/ob2Bp7X04yuxJkjRGi4aKmOqwhov54i6u79oCv7T+C7lo70MKH6BesI3vscD1yb/yzKXQ==} + google-gax@4.6.1: + resolution: {integrity: sha512-V6eky/xz2mcKfAd1Ioxyd6nmA61gao3n01C+YeuIwu3vzM9EDR6wcVzMSIbLMDXWeoi9SHYctXuKYC5uJUT3eQ==} + engines: {node: '>=14'} - js-tiktoken@1.0.20: - resolution: {integrity: sha512-Xlaqhhs8VfCd6Sh7a1cFkZHQbYTLCwVJJWiHVxBYzLPxW0XsoxBy1hitmjkdIjD3Aon5BXLHFwU5O8WUx6HH+A==} + google-gax@5.0.8: + resolution: {integrity: sha512-M4vpZcXQIC1gqIVGQ7eaU3jXQA6zecStyTXu514TYfThlgSurYJOxHZo9fzU6hAgwPWvuEynAVHWyaIk80VeEA==} + engines: {node: '>=18'} - js-tokens@4.0.0: - resolution: {integrity: sha512-RdJUflcE3cUzKiMqQgsCu06FPu9UdIJO0beYbPhHN4k6apgJtifcoCtT9bcxOpYBtpD2kCM6Sbzg4CausW/PKQ==} + google-gax@6.10.0: + resolution: {integrity: sha512-P9+6mNoC97uSUj55MptrxNj9muoDwc05mcY49R8jyg3kqzkPK+uWHApLuAHsNPKh3dtk1M1IuVZIto8e/fvpQA==} + engines: {node: '>=22'} - js-tokens@9.0.1: - resolution: {integrity: sha512-mxa9E9ITFOt0ban3j6L5MpjwegGz6lBQmM1IJkWeBZGcMxto50+eWdjC/52xDbS2vy0k7vIMK0Fe2wfL9OQSpQ==} + google-logging-utils@0.0.2: + resolution: {integrity: sha512-NEgUnEcBiP5HrPzufUkBzJOD/Sxsco3rLNo1F1TNf7ieU8ryUzBhqba8r756CjLX7rn3fHl6iLEwPYuqpoKgQQ==} + engines: {node: '>=14'} - js-yaml@3.14.1: - resolution: {integrity: sha512-okMH7OXXJ7YrN9Ok3/SXrnu4iX9yOk+25nqX4imS2npuvTYDmo/QEZoqwZkYaIDk3jVvBOTOIEgEhaLOynBS9g==} - hasBin: true + google-logging-utils@1.1.3: + resolution: {integrity: sha512-eAmLkjDjAFCVXg7A1unxHsLf961m6y17QFqXqAXGj/gVkKFrEICfStRfwUlGNfeCEjNRa32JEWOUTlYXPyyKvA==} + engines: {node: '>=14'} - js-yaml@4.1.0: - resolution: {integrity: sha512-wpxZs9NoxZaJESJGIZTyDEaYpl0FKSA+FB9aJiyemKhMwkxQg63h4T1KJgUGHpTqPDNRcmmYLugrRjJlBtWvRA==} - hasBin: true + google-logging-utils@2.0.1: + resolution: {integrity: sha512-HMhaQghlOTvbcb3c4T5jmmOMtG3JUF1iOQMezaJXL86CDS+Tm2vHd0IeLFRAx3+ewd+bo9E1HFHoy17X5aJa9A==} + engines: {node: '>=22'} - jsesc@3.1.0: - resolution: {integrity: sha512-/sM3dO2FOzXjKQhJuo0Q173wf2KOo8t4I8vHy6lF9poUp7bKT0/NHE8fPX23PwfhnykfqnC2xRxOnVw5XuGIaA==} - engines: {node: '>=6'} - hasBin: true + google-protobuf@3.21.4: + resolution: {integrity: sha512-MnG7N936zcKTco4Jd2PX2U96Kf9PxygAPKBug+74LHzmHXmceN16MmRcdgZv+DGef/S9YvQAfRsNCn4cjf9yyQ==} - json-bigint@1.0.0: - resolution: {integrity: sha512-SiPv/8VpZuWbvLSMtTDU8hEfrZWg/mH/nV/b4o0CYbSxu1UIQPLdwKOCIyLQX+VIPO5vrLX3i8qtqFyhdPSUSQ==} + googleapis-common@7.2.0: + resolution: {integrity: sha512-/fhDZEJZvOV3X5jmD+fKxMqma5q2Q9nZNSF3kn1F18tpxmA86BcTxAGBQdM0N89Z3bEaIs+HVznSmFJEAmMTjA==} + engines: {node: '>=14.0.0'} - json-bignum@0.0.3: - resolution: {integrity: sha512-2WHyXj3OfHSgNyuzDbSxI1w2jgw5gkWSWhS7Qg4bWXx1nLk3jnbwfUeS0PSba3IzpTUWdHxBieELUzXRjQB2zg==} - engines: {node: '>=0.8'} + googleapis@137.1.0: + resolution: {integrity: sha512-2L7SzN0FLHyQtFmyIxrcXhgust77067pkkduqkbIpDuj9JzVnByxsRrcRfUMFQam3rQkWW2B0f1i40IwKDWIVQ==} + engines: {node: '>=14.0.0'} - json-parse-even-better-errors@2.3.1: - resolution: {integrity: sha512-xyFwyhro/JEof6Ghe2iz2NcXoj2sloNsWr/XsERDK/oiPCfaNhl5ONfp+jQdAZRQQ0IJWNzH9zIZF7li91kh2w==} + gopd@1.2.0: + resolution: {integrity: sha512-ZUKRh6/kUFoAiTAtTYPZJ3hw9wNxx+BIBOijnlG9PnrJsCcSjs1wyyD6vJpaYtgnzDrKYRSqf3OO6Rfa93xsRg==} + engines: {node: '>= 0.4'} - json-schema-to-zod@2.8.1: - resolution: {integrity: sha512-fRr1mHgZ7hboLKBUdR428gd9dIHUFGivUqOeiDcSmyXkNZCtB1uGaZLvsjZ4GaN5pwBIs+TGIOf6s+Rp5/R/zA==} - hasBin: true + graceful-fs@4.2.11: + resolution: {integrity: sha512-RbJ5/jmFcNNCcDV5o9eTnBLJ/HszWV0P73bc+Ff4nS/rJj+YaS6IGyiOL0VoBYX+l1Wrl3k63h/KrH+nhJ0XvQ==} - json-schema-traverse@1.0.0: - resolution: {integrity: sha512-NM8/P9n3XjXhIZn1lLhkFaACTOURQXjWhV4BA/RnOv8xvgqtqpAX9IO4mRQxSx1Rlo4tqzeqb0sOlruaOy3dug==} + graphql-request@6.1.0: + resolution: {integrity: sha512-p+XPfS4q7aIpKVcgmnZKhMNqhltk20hfXtkaIkTfjjmiKMJ5xrt5c743cL03y/K7y1rg3WrIC49xGiEQ4mxdNw==} + peerDependencies: + graphql: 14 - 16 - json-schema-typed@8.0.2: - resolution: {integrity: sha512-fQhoXdcvc3V28x7C7BMs4P5+kNlgUURe2jmUT1T//oBRMDrqy1QPelJimwZGo7Hg9VPV3EQV5Bnq4hbFy2vetA==} + graphql@16.12.0: + resolution: {integrity: sha512-DKKrynuQRne0PNpEbzuEdHlYOMksHSUI8Zc9Unei5gTsMNA2/vMpoMz/yKba50pejK56qj98qM0SjYxAKi13gQ==} + engines: {node: ^12.22.0 || ^14.16.0 || ^16.0.0 || >=17.0.0} - json-schema@0.4.0: - resolution: {integrity: sha512-es94M3nTIfsEPisRafak+HDLfHXnKBhV3vU5eqPcS3flIWqcxJWgXHXiey3YrpaNsanY5ei1VoYEbOzijuq9BA==} + gray-matter@4.0.3: + resolution: {integrity: sha512-5v6yZd4JK3eMI3FqqCouswVqwugaA9r4dNZB1wwcmrD02QkV5H0y7XBQW8QwQqEaZY1pM9aqORSORhJRdNK44Q==} + engines: {node: '>=6.0'} - json5@2.2.3: - resolution: {integrity: sha512-XmOWe7eyHYH14cLdVPoyg+GOH3rYX++KpzrylJwSW98t3Nk+U8XOl8FWKOgwtzdb8lXGf6zYwDUzeHMWfxasyg==} - engines: {node: '>=6'} - hasBin: true + groq-sdk@0.9.1: + resolution: {integrity: sha512-yFZ3+I0Oe/u+4PUKDUG8q5KpP9Hgc+ujhlBaAbcc4EMJb2RMn/atqG8i+Vnk7s+2K4rJ49mviO/kY0i9LbskCA==} - jsonpointer@5.0.1: - resolution: {integrity: sha512-p/nXbhSEcu3pZRdkW1OfJhpsVtW1gd4Wa1fnQc9YLiTfAjn0312eMKimbdIQzuZl9aa9xUGaRlP9T/CJE/ditQ==} - engines: {node: '>=0.10.0'} + gtoken@7.1.0: + resolution: {integrity: sha512-pCcEwRi+TKpMlxAQObHDQ56KawURgyAf6jtIY046fJ5tIv3zDe/LEIubckAO8fj6JnAxLdmWkUfNyulQ2iKdEw==} + engines: {node: '>=14.0.0'} - jsonrepair@3.13.2: - resolution: {integrity: sha512-Leuly0nbM4R+S5SVJk3VHfw1oxnlEK9KygdZvfUtEtTawNDyzB4qa1xWTmFt1aeoA7sXZkVTRuIixJ8bAvqVUg==} + gtoken@8.0.0: + resolution: {integrity: sha512-+CqsMbHPiSTdtSO14O51eMNlrp9N79gmeqmXeouJOhfucAedHw9noVe/n5uJk3tbKE6a+6ZCQg3RPhVhHByAIw==} + engines: {node: '>=18'} + + handlebars@4.7.8: + resolution: {integrity: sha512-vafaFqs8MZkRrSX7sFVUdo3ap/eNiLnb4IakshzvP56X5Nr1iGKAIqdX6tMlm6HcNRIkr6AxO5jFEoJzzpT8aQ==} + engines: {node: '>=0.4.7'} hasBin: true - jwa@2.0.1: - resolution: {integrity: sha512-hRF04fqJIP8Abbkq5NKGN0Bbr3JxlQ+qhZufXVr0DvujKy93ZCbXZMHDL4EOtodSbCWxOqR8MS1tXA5hwqCXDg==} + has-flag@4.0.0: + resolution: {integrity: sha512-EykJT/Q1KjTWctppgIAgfSO0tKVuZUjhgMr17kqTumMl6Afv3EISleU7qZUzoXDFTAHTDC4NOoG/ZxU3EvlMPQ==} + engines: {node: '>=8'} - jws@4.0.1: - resolution: {integrity: sha512-EKI/M/yqPncGUUh44xz0PxSidXFr/+r0pA70+gIYhjv+et7yxM+s29Y+VGDkovRofQem0fs7Uvf4+YmAdyRduA==} + has-symbols@1.1.0: + resolution: {integrity: sha512-1cDNdwJ2Jaohmb3sg4OmKaMBwuC48sYni5HUw2DvsC8LjGTLK9h+eb1X6RyuOHe4hT0ULCW68iomhjUoKUqlPQ==} + engines: {node: '>= 0.4'} - kind-of@6.0.3: - resolution: {integrity: sha512-dcS1ul+9tmeD95T+x28/ehLgd9mENa3LsvDTtzm3vyBEO7RPptvAD+t44WVXaUjTBRcrpFeFlC8WCruUR456hw==} - engines: {node: '>=0.10.0'} + has-tostringtag@1.0.2: + resolution: {integrity: sha512-NqADB8VjPFLM2V0VvHUewwwsw0ZWBaIdgo+ieHtK3hasLz4qeCRjYcqfB6AQrBggRKppKF8L52/VqdVsO47Dlw==} + engines: {node: '>= 0.4'} - kleur@3.0.3: - resolution: {integrity: sha512-eTIzlVOSUR+JxdDFepEYcBMtZ9Qqdef+rnzWdRZuMbOywu5tO2w2N7rqjoANZ5k9vywhL6Br1VRjUIgTQx4E8w==} - engines: {node: '>=6'} + hasown@2.0.2: + resolution: {integrity: sha512-0hJU9SCPvmMzIBdZFqNPXWa6dqh7WdH0cII9y+CyS8rG3nL48Bclra9HmKhVVUHyPWNH5Y7xDwAB7bfgSjkUMQ==} + engines: {node: '>= 0.4'} - kuler@2.0.0: - resolution: {integrity: sha512-Xq9nH7KlWZmXAtodXDDRE7vs6DU1gTU8zYDHDiWLSip45Egwq3plLHzPn27NgvzL2r1LMPC1vdqh98sQxtqj4A==} + header-generator@2.1.80: + resolution: {integrity: sha512-7gvv2Xm6Q0gNN3BzMD/D3sGvSJRcV1+k8XehPmBYTpTkBmKshwnYyi0jJJnpP3S6YP7vdOoEobeBV87aG9YTtQ==} + engines: {node: '>=16.0.0'} - langchain@0.1.37: - resolution: {integrity: sha512-rpaLEJtRrLYhAViEp7/aHfSkxbgSqHJ5n10tXv3o4kHP/wOin85RpTgewwvGjEaKc3797jOg+sLSk6a7e0UlMg==} - engines: {node: '>=18'} + hono-openapi@1.3.0: + resolution: {integrity: sha512-xDvCWpWEIv0weEmnl3EjRQzqbHIO8LnfzMuYOCmbuyE5aes6aXxLg4vM3ybnoZD5TiTUkA6PuRQPJs3R7WRBig==} peerDependencies: - '@aws-sdk/client-s3': ^3.310.0 - '@aws-sdk/client-sagemaker-runtime': ^3.310.0 - '@aws-sdk/client-sfn': ^3.310.0 - '@aws-sdk/credential-provider-node': ^3.388.0 - '@azure/storage-blob': ^12.15.0 - '@browserbasehq/sdk': '*' - '@gomomento/sdk': ^1.51.1 - '@gomomento/sdk-core': ^1.51.1 - '@gomomento/sdk-web': ^1.51.1 - '@google-ai/generativelanguage': ^0.2.1 - '@google-cloud/storage': ^6.10.1 || ^7.7.0 - '@mendable/firecrawl-js': ^0.0.13 - '@notionhq/client': ^2.2.10 - '@pinecone-database/pinecone': '*' - '@supabase/supabase-js': ^2.10.0 - '@vercel/kv': ^0.2.3 - '@xata.io/client': ^0.28.0 - apify-client: ^2.7.1 - assemblyai: ^4.0.0 - axios: '*' - cheerio: ^1.0.0-rc.12 - chromadb: '*' - convex: ^1.3.1 + '@hono/standard-validator': ^0.2.0 + '@standard-community/standard-json': ^0.3.5 + '@standard-community/standard-openapi': ^0.2.9 + '@types/json-schema': ^7.0.15 + hono: ^4.8.3 + openapi-types: ^12.1.3 + peerDependenciesMeta: + '@hono/standard-validator': + optional: true + hono: + optional: true + + hono@4.11.5: + resolution: {integrity: sha512-WemPi9/WfyMwZs+ZUXdiwcCh9Y+m7L+8vki9MzDw3jJ+W9Lc+12HGsd368Qc1vZi1xwW8BWMMsnK5efYKPdt4g==} + engines: {node: '>=16.9.0'} + + hono@4.12.23: + resolution: {integrity: sha512-eIaZ9qDgu7XV0pxOCrg7/WhnQ6Ivm22UcxhXx/A3dcbqbbYgBEkc6e/J/s7j2tS96zoB0S9VBdLwQNCWwUo4LA==} + engines: {node: '>=16.9.0'} + + html-entities@2.6.0: + resolution: {integrity: sha512-kig+rMn/QOVRvr7c86gQ8lWXq+Hkv6CbAH1hLu+RG338StTpE8Z0b44SDVaqVu7HGKf27frdmUYEs9hTUX/cLQ==} + + html-escaper@2.0.2: + resolution: {integrity: sha512-H2iMtd0I4Mt5eYiapRdIDjp+XzelXQ0tFE4JS7YFwFevXXMmOp9myNrUvCg0D6ws8iqkRPBfKHgbwig1SmlLfg==} + + html-to-text@9.0.5: + resolution: {integrity: sha512-qY60FjREgVZL03vJU6IfMV4GDjGBIoOyvuFdpBDIX9yTlDw0TjxVBQp+P8NvpdIXNJvfWBTNul7fsAQJq2FNpg==} + engines: {node: '>=14'} + + htmlparser2@8.0.2: + resolution: {integrity: sha512-GYdjWKDkbRLkZ5geuHs5NY1puJ+PXwP7+fHPRz06Eirsb9ugf6d8kkXav6ADhcODhFFPMIXyxkxSuMf3D6NCFA==} + + http-errors@2.0.1: + resolution: {integrity: sha512-4FbRdAX+bSdmo4AUFuS0WNiPz8NgFt+r8ThgNWmlrjQjt1Q7ZR9+zTlce2859x4KSXrwIsaeTqDoKQmtP8pLmQ==} + engines: {node: '>= 0.8'} + + http-parser-js@0.5.10: + resolution: {integrity: sha512-Pysuw9XpUq5dVc/2SMHpuTY01RFl8fttgcyunjL7eEMhGM3cI4eOmiCycJDVCo/7O7ClfQD3SaI6ftDzqOXYMA==} + + http-proxy-agent@5.0.0: + resolution: {integrity: sha512-n2hY8YdoRE1i7r6M0w9DIw5GgZN0G25P8zLCRQ8rjXtTU3vsNFBI/vWK/UIeE6g5MUUz6avwAPXmL6Fy9D/90w==} + engines: {node: '>= 6'} + + http-proxy-agent@7.0.2: + resolution: {integrity: sha512-T1gkAiYYDWYx3V5Bmyu7HcfcvL7mUrTWiM6yOfa3PIphViJ/gFPbvidQ+veqSOHci/PxBcDabeUNCzpOODJZig==} + engines: {node: '>= 14'} + + https-proxy-agent@5.0.1: + resolution: {integrity: sha512-dFcAjpTQFgoLMzC2VwU+C/CbS7uRL0lWmxDITmqm7C+7F0Odmj6s9l6alZc6AELXhrnggM2CeWSXHGOdX2YtwA==} + engines: {node: '>= 6'} + + https-proxy-agent@7.0.6: + resolution: {integrity: sha512-vK9P5/iUfdl95AI+JVyUuIcVtd4ofvtrOr3HNtM2yxC9bnMbEdp3x01OhQNnjb8IJYi38VlTE3mBXwcfvywuSw==} + engines: {node: '>= 14'} + + human-signals@2.1.0: + resolution: {integrity: sha512-B4FFZ6q/T2jhhksgkbEW3HBvWIfDW85snkQgawt07S7J5QXTk6BkNV+0yAeZrM5QpMAdYlocGoljn0sJ/WQkFw==} + engines: {node: '>=10.17.0'} + + human-signals@8.0.1: + resolution: {integrity: sha512-eKCa6bwnJhvxj14kZk5NCPc6Hb6BdsU9DZcOnmQKSnO1VKrfV0zCvtttPZUsBvjmNDn8rpcJfpwSYnHBjc95MQ==} + engines: {node: '>=18.18.0'} + + humanize-ms@1.2.1: + resolution: {integrity: sha512-Fl70vYtsAFb/C06PTS9dZBo7ihau+Tu/DNCk/OyHhea07S+aeMWpFFkUaXRa8fI+ScZbEI8dfSxwY7gxZ9SAVQ==} + + iconv-lite@0.4.24: + resolution: {integrity: sha512-v3MXnZAcvnywkTUEZomIActle7RXXeedOR31wwl7VlyoXO4Qi9arvSenNQWne1TcRwhCL1HwLI21bEqdpj8/rA==} + engines: {node: '>=0.10.0'} + + iconv-lite@0.6.3: + resolution: {integrity: sha512-4fCk79wshMdzMp2rH06qWrJE4iolqLhCUH+OiuIgU++RB0+94NlDL81atO7GX55uUKueo0txHNtvEyI6D7WdMw==} + engines: {node: '>=0.10.0'} + + iconv-lite@0.7.2: + resolution: {integrity: sha512-im9DjEDQ55s9fL4EYzOAv0yMqmMBSZp6G0VvFyTMPKWxiSBHUj9NW/qqLmXUwXrrM7AvqSlTCfvqRb0cM8yYqw==} + engines: {node: '>=0.10.0'} + + ieee754@1.2.1: + resolution: {integrity: sha512-dcyqhDvX1C46lXZcVqCpK+FtMRQVdIMN6/Df5js2zouUsqG7I6sFxitIC+7KYK29KdXOLHdu9zL4sFnoVQnqaA==} + + ignore@5.3.2: + resolution: {integrity: sha512-hsBTNUqQTDwkWtcdYI2i06Y/nUBEsNEDJKjWdigLvegy8kDuJAS8uRlpkkcQpyEXL0Z/pjDy5HBmMjRCJ2gq+g==} + engines: {node: '>= 4'} + + ignore@7.0.5: + resolution: {integrity: sha512-Hs59xBNfUIunMFgWAbGX5cq6893IbWg4KnrjbYwX3tx0ztorVgTDA6B2sxf8ejHJ4wz8BqGUMYlnzNBer5NvGg==} + engines: {node: '>= 4'} + + import-in-the-middle@1.14.2: + resolution: {integrity: sha512-5tCuY9BV8ujfOpwtAGgsTx9CGUapcFMEEyByLv1B+v2+6DhAcw+Zr0nhQT7uwaZ7DiourxFEscghOR8e1aPLQw==} + + import-in-the-middle@1.7.1: + resolution: {integrity: sha512-1LrZPDtW+atAxH42S6288qyDFNQ2YCty+2mxEPRtfazH6Z5QwkaBSTS2ods7hnVJioF6rkRfNoA6A/MstpFXLg==} + + import-local@3.2.0: + resolution: {integrity: sha512-2SPlun1JUPWoM6t3F0dw0FkCF/jWY8kttcY4f599GLTSjh2OCuuhdTkJQsEcZzBqbXZGKMK2OqW1oZsjtf/gQA==} + engines: {node: '>=8'} + hasBin: true + + imurmurhash@0.1.4: + resolution: {integrity: sha512-JmXMZ6wuvDmLiHEml9ykzqO6lwFbof0GG4IkcGaENdCRDDmMVnny7s5HsIgHCbaq0w2MyPhDqkhTUgS2LU2PHA==} + engines: {node: '>=0.8.19'} + + inflight@1.0.6: + resolution: {integrity: sha512-k92I/b08q4wvFscXCLvqfsHCrjrF7yiXsQuIVvVE7N82W3+aqpzuUdBbfhWcy/FZR3/4IgflMgKLOsvPDrGCJA==} + deprecated: This module is not supported, and leaks memory. Do not use it. Check out lru-cache if you want a good and tested way to coalesce async requests by a key value, which is much more comprehensive and powerful. + + infobox-parser@3.6.4: + resolution: {integrity: sha512-d2lTlxKZX7WsYxk9/UPt51nkmZv5tbC75SSw4hfHqZ3LpRAn6ug0oru9xI2X+S78va3aUAze3xl/UqMuwLmJUw==} + + inherits@2.0.4: + resolution: {integrity: sha512-k/vGaX4/Yla3WzyMCvTQOXYeIHvqOKtnqBduzTHpzpQZzAskKMhZ2K+EnBiSM9zGSoIFeMpXKxa4dYeZIQqewQ==} + + ip-address@10.0.1: + resolution: {integrity: sha512-NWv9YLW4PoW2B7xtzaS3NCot75m6nK7Icdv0o3lfMceJVRfSoQwqD4wEH5rLwoKJwUiZ/rfpiVBhnaF0FK4HoA==} + engines: {node: '>= 12'} + + ipaddr.js@1.9.1: + resolution: {integrity: sha512-0KI/607xoxSToH7GjN1FfSbLoU0+btTicjsQSWQlh/hZykN8KpmMf7uYwPW3R+akZ6R/w18ZlXSHBYXiYUPO3g==} + engines: {node: '>= 0.10'} + + is-any-array@2.0.1: + resolution: {integrity: sha512-UtilS7hLRu++wb/WBAw9bNuP1Eg04Ivn1vERJck8zJthEvXCBEBpGR/33u/xLKWEQf95803oalHrVDptcAvFdQ==} + + is-arrayish@0.2.1: + resolution: {integrity: sha512-zz06S8t0ozoDXMG+ube26zeCTNXcKIPJZJi8hBrF4idCLms4CG9QtK7qBl1boi5ODzFpjswb5JPmHCbMpjaYzg==} + + is-binary-path@2.1.0: + resolution: {integrity: sha512-ZMERYes6pDydyuGidse7OsHxtbI7WVeUEozgR/g7rd0xUimYNlvZRE/K2MgZTjWy725IfelLeVcEM97mmtRGXw==} + engines: {node: '>=8'} + + is-buffer@1.1.6: + resolution: {integrity: sha512-NcdALwpXkTm5Zvvbk7owOUSvVvBKDgKP5/ewfXEznmQFfs4ZRmanOeKBTjRVjka3QFoN6XJ+9F3USqfHqTaU5w==} + + is-core-module@2.16.1: + resolution: {integrity: sha512-UfoeMA6fIJ8wTYFEUjelnaGI67v6+N7qXJEvQuIGa99l4xsCruSYOVSQ0uPANn4dAzm8lkYPaKLrrijLq7x23w==} + engines: {node: '>= 0.4'} + + is-extendable@0.1.1: + resolution: {integrity: sha512-5BMULNob1vgFX6EjQw5izWDxrecWK9AM72rugNr0TFldMOi0fj6Jk+zeKIt0xGj4cEfQIJth4w3OKWOJ4f+AFw==} + engines: {node: '>=0.10.0'} + + is-extglob@2.1.1: + resolution: {integrity: sha512-SbKbANkN603Vi4jEZv49LeVJMn4yGwsbzZworEoyEiutsN3nJYdbO36zfhGJ6QEDpOZIFkDtnq5JRxmvl3jsoQ==} + engines: {node: '>=0.10.0'} + + is-fullwidth-code-point@3.0.0: + resolution: {integrity: sha512-zymm5+u+sCsSWyD9qNaejV3DFvhCKclKdizYaJUuHA83RLjb7nSuGnddCHGv0hk+KY7BMAlsWeK4Ueg6EV6XQg==} + engines: {node: '>=8'} + + is-generator-fn@2.1.0: + resolution: {integrity: sha512-cTIB4yPYL/Grw0EaSzASzg6bBy9gqCofvWN8okThAYIxKJZC+udlRAmGbM0XLeniEJSs8uEgHPGuHSe1XsOLSQ==} + engines: {node: '>=6'} + + is-glob@4.0.3: + resolution: {integrity: sha512-xelSayHH36ZgE7ZWhli7pW34hNbNl8Ojv5KVmkJD4hBdD3th8Tfk9vYasLM+mXWOZhFkgZfxhLSnrwRr4elSSg==} + engines: {node: '>=0.10.0'} + + is-network-error@1.3.2: + resolution: {integrity: sha512-PhBY86zaxNZUuWP6h13Vu5oFe0XY6/UlKzQnYFELzGVHygP3MxmvTfYSG7GN3aIab/iWudSMgjSnG9Dq+nHrgA==} + engines: {node: '>=16'} + + is-number@7.0.0: + resolution: {integrity: sha512-41Cifkg6e8TylSpdtTpeLVMqvSBEVzTttHvERD741+pnZ8ANv0004MRL43QKPDlK9cGvNp6NZWZUBlbGXYxxng==} + engines: {node: '>=0.12.0'} + + is-obj@2.0.0: + resolution: {integrity: sha512-drqDG3cbczxxEJRoOXcOjtdp1J/lyp1mNn0xaznRs8+muBhgQcrnbspox5X5fOw0HnMnbfDzvnEMEtqDEJEo8w==} + engines: {node: '>=8'} + + is-plain-obj@4.1.0: + resolution: {integrity: sha512-+Pgi+vMuUNkJyExiMBt5IlFoMyKnr5zhJ4Uspz58WOhBF5QoIZkFyNHIbBAtHwzVAgk5RtndVNsDRN61/mmDqg==} + engines: {node: '>=12'} + + is-plain-object@2.0.4: + resolution: {integrity: sha512-h5PpgXkWitc38BBMYawTYMWJHFZJVnBquFE57xFpjB8pJFiF6gZ+bU+WyI/yqXiFR5mdLsgYNaPe8uao6Uv9Og==} + engines: {node: '>=0.10.0'} + + is-promise@4.0.0: + resolution: {integrity: sha512-hvpoI6korhJMnej285dSg6nu1+e6uxs7zG3BYAm5byqDsgJNWwxzM6z6iZiAgQR4TJ30JmBTOwqZUw3WlyH3AQ==} + + is-stream@2.0.1: + resolution: {integrity: sha512-hFoiJiTl63nn+kstHGBtewWSKnQLpyb155KHheA1l39uvtO9nWIop1p3udqPcUd/xbF1VLMO4n7OI6p7RbngDg==} + engines: {node: '>=8'} + + is-stream@4.0.1: + resolution: {integrity: sha512-Dnz92NInDqYckGEUJv689RbRiTSEHCQ7wOVeALbkOz999YpqT46yMRIGtSNl2iCL1waAZSx40+h59NV/EwzV/A==} + engines: {node: '>=18'} + + is-unicode-supported@2.1.0: + resolution: {integrity: sha512-mE00Gnza5EEB3Ds0HfMyllZzbBrmLOX3vfWoj9A9PEnTfratQ/BcaJOuMhnkhjXvb2+FkY3VuHqtAGpTPmglFQ==} + engines: {node: '>=18'} + + isexe@2.0.0: + resolution: {integrity: sha512-RHxMLp9lnKHGHRng9QFhRCMbYAcVpn69smSGcq3f36xjgVVWThj4qqLbTLlq7Ssj8B+fIQ1EuCEGI2lKsyQeIw==} + + isobject@3.0.1: + resolution: {integrity: sha512-WhB9zCku7EGTj/HQQRz5aUQEUeoQZH2bWcltRErOpymJ4boYE6wL9Tbr23krRPSZ+C5zqNSrSw+Cc7sZZ4b7vg==} + engines: {node: '>=0.10.0'} + + isomorphic-fetch@3.0.0: + resolution: {integrity: sha512-qvUtwJ3j6qwsF3jLxkZ72qCgjMysPzDfeV240JHiGZsANBYd+EEuu35v7dfrJ9Up0Ak07D7GGSkGhCHTqg/5wA==} + + istanbul-lib-coverage@3.2.2: + resolution: {integrity: sha512-O8dpsF+r0WV/8MNRKfnmrtCWhuKjxrq2w+jpzBL5UZKTi2LeVWnWOmWRxFlesJONmc+wLAGvKQZEOanko0LFTg==} + engines: {node: '>=8'} + + istanbul-lib-instrument@5.2.1: + resolution: {integrity: sha512-pzqtp31nLv/XFOzXGuvhCb8qhjmTVo5vjVk19XE4CRlSWz0KoeJ3bw9XsA7nOp9YBf4qHjwBxkDzKcME/J29Yg==} + engines: {node: '>=8'} + + istanbul-lib-instrument@6.0.3: + resolution: {integrity: sha512-Vtgk7L/R2JHyyGW07spoFlB8/lpjiOLTjMdms6AFMraYt3BaJauod/NGrfnVG/y4Ix1JEuMRPDPEj2ua+zz1/Q==} + engines: {node: '>=10'} + + istanbul-lib-report@3.0.1: + resolution: {integrity: sha512-GCfE1mtsHGOELCU8e/Z7YWzpmybrx/+dSTfLrvY8qRmaY6zXTKWn6WQIjaAFw069icm6GVMNkgu0NzI4iPZUNw==} + engines: {node: '>=10'} + + istanbul-lib-source-maps@4.0.1: + resolution: {integrity: sha512-n3s8EwkdFIJCG3BPKBYvskgXGoy88ARzvegkitk60NxRdwltLOTaH7CUiMRXvwYorl0Q712iEjcWB+fK/MrWVw==} + engines: {node: '>=10'} + + istanbul-reports@3.1.7: + resolution: {integrity: sha512-BewmUXImeuRk2YY0PVbxgKAysvhRPUQE0h5QRM++nVWyubKGV0l8qQ5op8+B2DOmwSe63Jivj0BjkPQVf8fP5g==} + engines: {node: '>=8'} + + jackspeak@3.4.3: + resolution: {integrity: sha512-OGlZQpz2yfahA/Rd1Y8Cd9SIEsqvXkLVoSw/cgwhnhFMDbsQFeZYoJJ7bIZBS9BcamUW96asq/npPWugM+RQBw==} + + javascript-natural-sort@0.7.1: + resolution: {integrity: sha512-nO6jcEfZWQXDhOiBtG2KvKyEptz7RVbpGP4vTD2hLBdmNQSsCiicO2Ioinv6UI4y9ukqnBpy+XZ9H6uLNgJTlw==} + + jest-changed-files@29.7.0: + resolution: {integrity: sha512-fEArFiwf1BpQ+4bXSprcDc3/x4HSzL4al2tozwVpDFpsxALjLYdyiIK4e5Vz66GQJIbXJ82+35PtysofptNX2w==} + engines: {node: ^14.15.0 || ^16.10.0 || >=18.0.0} + + jest-circus@29.7.0: + resolution: {integrity: sha512-3E1nCMgipcTkCocFwM90XXQab9bS+GMsjdpmPrlelaxwD93Ad8iVEjX/vvHPdLPnFf+L40u+5+iutRdA1N9myw==} + engines: {node: ^14.15.0 || ^16.10.0 || >=18.0.0} + + jest-cli@29.7.0: + resolution: {integrity: sha512-OVVobw2IubN/GSYsxETi+gOe7Ka59EFMR/twOU3Jb2GnKKeMGJB5SGUUrEz3SFVmJASUdZUzy83sLNNQ2gZslg==} + engines: {node: ^14.15.0 || ^16.10.0 || >=18.0.0} + hasBin: true + peerDependencies: + node-notifier: ^8.0.1 || ^9.0.0 || ^10.0.0 + peerDependenciesMeta: + node-notifier: + optional: true + + jest-config@29.7.0: + resolution: {integrity: sha512-uXbpfeQ7R6TZBqI3/TxCU4q4ttk3u0PJeC+E0zbfSoSjq6bJ7buBPxzQPL0ifrkY4DNu4JUdk0ImlBUYi840eQ==} + engines: {node: ^14.15.0 || ^16.10.0 || >=18.0.0} + peerDependencies: + '@types/node': '*' + ts-node: '>=9.0.0' + peerDependenciesMeta: + '@types/node': + optional: true + ts-node: + optional: true + + jest-diff@29.7.0: + resolution: {integrity: sha512-LMIgiIrhigmPrs03JHpxUh2yISK3vLFPkAodPeo0+BuF7wA2FoQbkEg1u8gBYBThncu7e1oEDUfIXVuTqLRUjw==} + engines: {node: ^14.15.0 || ^16.10.0 || >=18.0.0} + + jest-docblock@29.7.0: + resolution: {integrity: sha512-q617Auw3A612guyaFgsbFeYpNP5t2aoUNLwBUbc/0kD1R4t9ixDbyFTHd1nok4epoVFpr7PmeWHrhvuV3XaJ4g==} + engines: {node: ^14.15.0 || ^16.10.0 || >=18.0.0} + + jest-each@29.7.0: + resolution: {integrity: sha512-gns+Er14+ZrEoC5fhOfYCY1LOHHr0TI+rQUHZS8Ttw2l7gl+80eHc/gFf2Ktkw0+SIACDTeWvpFcv3B04VembQ==} + engines: {node: ^14.15.0 || ^16.10.0 || >=18.0.0} + + jest-environment-node@29.7.0: + resolution: {integrity: sha512-DOSwCRqXirTOyheM+4d5YZOrWcdu0LNZ87ewUoywbcb2XR4wKgqiG8vNeYwhjFMbEkfju7wx2GYH0P2gevGvFw==} + engines: {node: ^14.15.0 || ^16.10.0 || >=18.0.0} + + jest-get-type@29.6.3: + resolution: {integrity: sha512-zrteXnqYxfQh7l5FHyL38jL39di8H8rHoecLH3JNxH3BwOrBsNeabdap5e0I23lD4HHI8W5VFBZqG4Eaq5LNcw==} + engines: {node: ^14.15.0 || ^16.10.0 || >=18.0.0} + + jest-haste-map@29.7.0: + resolution: {integrity: sha512-fP8u2pyfqx0K1rGn1R9pyE0/KTn+G7PxktWidOBTqFPLYX0b9ksaMFkhK5vrS3DVun09pckLdlx90QthlW7AmA==} + engines: {node: ^14.15.0 || ^16.10.0 || >=18.0.0} + + jest-leak-detector@29.7.0: + resolution: {integrity: sha512-kYA8IJcSYtST2BY9I+SMC32nDpBT3J2NvWJx8+JCuCdl/CR1I4EKUJROiP8XtCcxqgTTBGJNdbB1A8XRKbTetw==} + engines: {node: ^14.15.0 || ^16.10.0 || >=18.0.0} + + jest-matcher-utils@29.7.0: + resolution: {integrity: sha512-sBkD+Xi9DtcChsI3L3u0+N0opgPYnCRPtGcQYrgXmR+hmt/fYfWAL0xRXYU8eWOdfuLgBe0YCW3AFtnRLagq/g==} + engines: {node: ^14.15.0 || ^16.10.0 || >=18.0.0} + + jest-message-util@29.7.0: + resolution: {integrity: sha512-GBEV4GRADeP+qtB2+6u61stea8mGcOT4mCtrYISZwfu9/ISHFJ/5zOMXYbpBE9RsS5+Gb63DW4FgmnKJ79Kf6w==} + engines: {node: ^14.15.0 || ^16.10.0 || >=18.0.0} + + jest-mock@29.7.0: + resolution: {integrity: sha512-ITOMZn+UkYS4ZFh83xYAOzWStloNzJFO2s8DWrE4lhtGD+AorgnbkiKERe4wQVBydIGPx059g6riW5Btp6Llnw==} + engines: {node: ^14.15.0 || ^16.10.0 || >=18.0.0} + + jest-pnp-resolver@1.2.3: + resolution: {integrity: sha512-+3NpwQEnRoIBtx4fyhblQDPgJI0H1IEIkX7ShLUjPGA7TtUTvI1oiKi3SR4oBR0hQhQR80l4WAe5RrXBwWMA8w==} + engines: {node: '>=6'} + peerDependencies: + jest-resolve: '*' + peerDependenciesMeta: + jest-resolve: + optional: true + + jest-regex-util@29.6.3: + resolution: {integrity: sha512-KJJBsRCyyLNWCNBOvZyRDnAIfUiRJ8v+hOBQYGn8gDyF3UegwiP4gwRR3/SDa42g1YbVycTidUF3rKjyLFDWbg==} + engines: {node: ^14.15.0 || ^16.10.0 || >=18.0.0} + + jest-resolve-dependencies@29.7.0: + resolution: {integrity: sha512-un0zD/6qxJ+S0et7WxeI3H5XSe9lTBBR7bOHCHXkKR6luG5mwDDlIzVQ0V5cZCuoTgEdcdwzTghYkTWfubi+nA==} + engines: {node: ^14.15.0 || ^16.10.0 || >=18.0.0} + + jest-resolve@29.7.0: + resolution: {integrity: sha512-IOVhZSrg+UvVAshDSDtHyFCCBUl/Q3AAJv8iZ6ZjnZ74xzvwuzLXid9IIIPgTnY62SJjfuupMKZsZQRsCvxEgA==} + engines: {node: ^14.15.0 || ^16.10.0 || >=18.0.0} + + jest-runner@29.7.0: + resolution: {integrity: sha512-fsc4N6cPCAahybGBfTRcq5wFR6fpLznMg47sY5aDpsoejOcVYFb07AHuSnR0liMcPTgBsA3ZJL6kFOjPdoNipQ==} + engines: {node: ^14.15.0 || ^16.10.0 || >=18.0.0} + + jest-runtime@29.7.0: + resolution: {integrity: sha512-gUnLjgwdGqW7B4LvOIkbKs9WGbn+QLqRQQ9juC6HndeDiezIwhDP+mhMwHWCEcfQ5RUXa6OPnFF8BJh5xegwwQ==} + engines: {node: ^14.15.0 || ^16.10.0 || >=18.0.0} + + jest-snapshot@29.7.0: + resolution: {integrity: sha512-Rm0BMWtxBcioHr1/OX5YCP8Uov4riHvKPknOGs804Zg9JGZgmIBkbtlxJC/7Z4msKYVbIJtfU+tKb8xlYNfdkw==} + engines: {node: ^14.15.0 || ^16.10.0 || >=18.0.0} + + jest-util@29.7.0: + resolution: {integrity: sha512-z6EbKajIpqGKU56y5KBUgy1dt1ihhQJgWzUlZHArA/+X2ad7Cb5iF+AK1EWVL/Bo7Rz9uurpqw6SiBCefUbCGA==} + engines: {node: ^14.15.0 || ^16.10.0 || >=18.0.0} + + jest-validate@29.7.0: + resolution: {integrity: sha512-ZB7wHqaRGVw/9hST/OuFUReG7M8vKeq0/J2egIGLdvjHCmYqGARhzXmtgi+gVeZ5uXFF219aOc3Ls2yLg27tkw==} + engines: {node: ^14.15.0 || ^16.10.0 || >=18.0.0} + + jest-watcher@29.7.0: + resolution: {integrity: sha512-49Fg7WXkU3Vl2h6LbLtMQ/HyB6rXSIX7SqvBLQmssRBGN9I0PNvPmAmCWSOY6SOvrjhI/F7/bGAv9RtnsPA03g==} + engines: {node: ^14.15.0 || ^16.10.0 || >=18.0.0} + + jest-worker@29.7.0: + resolution: {integrity: sha512-eIz2msL/EzL9UFTFFx7jBTkeZfku0yUAyZZZmJ93H2TYEiroIx2PQjEXcwYtYl8zXCxb+PAmA2hLIt/6ZEkPHw==} + engines: {node: ^14.15.0 || ^16.10.0 || >=18.0.0} + + jest@29.7.0: + resolution: {integrity: sha512-NIy3oAFp9shda19hy4HK0HRTWKtPJmGdnvywu01nOqNC2vZg+Z+fvJDxpMQA88eb2I9EcafcdjYgsDthnYTvGw==} + engines: {node: ^14.15.0 || ^16.10.0 || >=18.0.0} + hasBin: true + peerDependencies: + node-notifier: ^8.0.1 || ^9.0.0 || ^10.0.0 + peerDependenciesMeta: + node-notifier: + optional: true + + joplin-turndown-plugin-gfm@1.0.12: + resolution: {integrity: sha512-qL4+1iycQjZ1fs8zk3jSRk7cg3ROBUHk7GKtiLAQLFzLPKErnILUvz5DLszSQvz3s1sTjPbywLDISVUtBY6HaA==} + + jose@5.10.0: + resolution: {integrity: sha512-s+3Al/p9g32Iq+oqXxkW//7jk2Vig6FF1CFqzVXoTUXt2qz89YWbL+OwS17NFYEvxC35n0FKeGO2LGYSxeM2Gg==} + + jose@6.1.3: + resolution: {integrity: sha512-0TpaTfihd4QMNwrz/ob2Bp7X04yuxJkjRGi4aKmOqwhov54i6u79oCv7T+C7lo70MKH6BesI3vscD1yb/yzKXQ==} + + js-tiktoken@1.0.20: + resolution: {integrity: sha512-Xlaqhhs8VfCd6Sh7a1cFkZHQbYTLCwVJJWiHVxBYzLPxW0XsoxBy1hitmjkdIjD3Aon5BXLHFwU5O8WUx6HH+A==} + + js-tokens@4.0.0: + resolution: {integrity: sha512-RdJUflcE3cUzKiMqQgsCu06FPu9UdIJO0beYbPhHN4k6apgJtifcoCtT9bcxOpYBtpD2kCM6Sbzg4CausW/PKQ==} + + js-tokens@9.0.1: + resolution: {integrity: sha512-mxa9E9ITFOt0ban3j6L5MpjwegGz6lBQmM1IJkWeBZGcMxto50+eWdjC/52xDbS2vy0k7vIMK0Fe2wfL9OQSpQ==} + + js-yaml@3.14.1: + resolution: {integrity: sha512-okMH7OXXJ7YrN9Ok3/SXrnu4iX9yOk+25nqX4imS2npuvTYDmo/QEZoqwZkYaIDk3jVvBOTOIEgEhaLOynBS9g==} + hasBin: true + + js-yaml@4.1.0: + resolution: {integrity: sha512-wpxZs9NoxZaJESJGIZTyDEaYpl0FKSA+FB9aJiyemKhMwkxQg63h4T1KJgUGHpTqPDNRcmmYLugrRjJlBtWvRA==} + hasBin: true + + jsesc@3.1.0: + resolution: {integrity: sha512-/sM3dO2FOzXjKQhJuo0Q173wf2KOo8t4I8vHy6lF9poUp7bKT0/NHE8fPX23PwfhnykfqnC2xRxOnVw5XuGIaA==} + engines: {node: '>=6'} + hasBin: true + + json-bigint@1.0.0: + resolution: {integrity: sha512-SiPv/8VpZuWbvLSMtTDU8hEfrZWg/mH/nV/b4o0CYbSxu1UIQPLdwKOCIyLQX+VIPO5vrLX3i8qtqFyhdPSUSQ==} + + json-bignum@0.0.3: + resolution: {integrity: sha512-2WHyXj3OfHSgNyuzDbSxI1w2jgw5gkWSWhS7Qg4bWXx1nLk3jnbwfUeS0PSba3IzpTUWdHxBieELUzXRjQB2zg==} + engines: {node: '>=0.8'} + + json-parse-even-better-errors@2.3.1: + resolution: {integrity: sha512-xyFwyhro/JEof6Ghe2iz2NcXoj2sloNsWr/XsERDK/oiPCfaNhl5ONfp+jQdAZRQQ0IJWNzH9zIZF7li91kh2w==} + + json-schema-to-zod@2.8.1: + resolution: {integrity: sha512-fRr1mHgZ7hboLKBUdR428gd9dIHUFGivUqOeiDcSmyXkNZCtB1uGaZLvsjZ4GaN5pwBIs+TGIOf6s+Rp5/R/zA==} + hasBin: true + + json-schema-traverse@1.0.0: + resolution: {integrity: sha512-NM8/P9n3XjXhIZn1lLhkFaACTOURQXjWhV4BA/RnOv8xvgqtqpAX9IO4mRQxSx1Rlo4tqzeqb0sOlruaOy3dug==} + + json-schema-typed@8.0.2: + resolution: {integrity: sha512-fQhoXdcvc3V28x7C7BMs4P5+kNlgUURe2jmUT1T//oBRMDrqy1QPelJimwZGo7Hg9VPV3EQV5Bnq4hbFy2vetA==} + + json-schema@0.4.0: + resolution: {integrity: sha512-es94M3nTIfsEPisRafak+HDLfHXnKBhV3vU5eqPcS3flIWqcxJWgXHXiey3YrpaNsanY5ei1VoYEbOzijuq9BA==} + + json5@2.2.3: + resolution: {integrity: sha512-XmOWe7eyHYH14cLdVPoyg+GOH3rYX++KpzrylJwSW98t3Nk+U8XOl8FWKOgwtzdb8lXGf6zYwDUzeHMWfxasyg==} + engines: {node: '>=6'} + hasBin: true + + jsonpointer@5.0.1: + resolution: {integrity: sha512-p/nXbhSEcu3pZRdkW1OfJhpsVtW1gd4Wa1fnQc9YLiTfAjn0312eMKimbdIQzuZl9aa9xUGaRlP9T/CJE/ditQ==} + engines: {node: '>=0.10.0'} + + jsonrepair@3.13.2: + resolution: {integrity: sha512-Leuly0nbM4R+S5SVJk3VHfw1oxnlEK9KygdZvfUtEtTawNDyzB4qa1xWTmFt1aeoA7sXZkVTRuIixJ8bAvqVUg==} + hasBin: true + + jsonwebtoken@9.0.3: + resolution: {integrity: sha512-MT/xP0CrubFRNLNKvxJ2BYfy53Zkm++5bX9dtuPbqAeQpTVe0MQTFhao8+Cp//EmJp244xt6Drw/GVEGCUj40g==} + engines: {node: '>=12', npm: '>=6'} + + jwa@2.0.1: + resolution: {integrity: sha512-hRF04fqJIP8Abbkq5NKGN0Bbr3JxlQ+qhZufXVr0DvujKy93ZCbXZMHDL4EOtodSbCWxOqR8MS1tXA5hwqCXDg==} + + jwks-rsa@4.1.0: + resolution: {integrity: sha512-sbkByqyATKYJP5F4RXj03N5TUNC0QLTjCAZvwTzC4BwJZ8e0/cWxN8YROnyUth2g1/ONWi4eSFHeu6oYalrc3Q==} + engines: {node: ^20.19.0 || ^22.12.0 || >= 23.0.0} + + jws@4.0.1: + resolution: {integrity: sha512-EKI/M/yqPncGUUh44xz0PxSidXFr/+r0pA70+gIYhjv+et7yxM+s29Y+VGDkovRofQem0fs7Uvf4+YmAdyRduA==} + + kind-of@6.0.3: + resolution: {integrity: sha512-dcS1ul+9tmeD95T+x28/ehLgd9mENa3LsvDTtzm3vyBEO7RPptvAD+t44WVXaUjTBRcrpFeFlC8WCruUR456hw==} + engines: {node: '>=0.10.0'} + + kleur@3.0.3: + resolution: {integrity: sha512-eTIzlVOSUR+JxdDFepEYcBMtZ9Qqdef+rnzWdRZuMbOywu5tO2w2N7rqjoANZ5k9vywhL6Br1VRjUIgTQx4E8w==} + engines: {node: '>=6'} + + kuler@2.0.0: + resolution: {integrity: sha512-Xq9nH7KlWZmXAtodXDDRE7vs6DU1gTU8zYDHDiWLSip45Egwq3plLHzPn27NgvzL2r1LMPC1vdqh98sQxtqj4A==} + + langchain@0.1.37: + resolution: {integrity: sha512-rpaLEJtRrLYhAViEp7/aHfSkxbgSqHJ5n10tXv3o4kHP/wOin85RpTgewwvGjEaKc3797jOg+sLSk6a7e0UlMg==} + engines: {node: '>=18'} + peerDependencies: + '@aws-sdk/client-s3': ^3.310.0 + '@aws-sdk/client-sagemaker-runtime': ^3.310.0 + '@aws-sdk/client-sfn': ^3.310.0 + '@aws-sdk/credential-provider-node': ^3.388.0 + '@azure/storage-blob': ^12.15.0 + '@browserbasehq/sdk': '*' + '@gomomento/sdk': ^1.51.1 + '@gomomento/sdk-core': ^1.51.1 + '@gomomento/sdk-web': ^1.51.1 + '@google-ai/generativelanguage': ^0.2.1 + '@google-cloud/storage': ^6.10.1 || ^7.7.0 + '@mendable/firecrawl-js': ^0.0.13 + '@notionhq/client': ^2.2.10 + '@pinecone-database/pinecone': '*' + '@supabase/supabase-js': ^2.10.0 + '@vercel/kv': ^0.2.3 + '@xata.io/client': ^0.28.0 + apify-client: ^2.7.1 + assemblyai: ^4.0.0 + axios: '*' + cheerio: ^1.0.0-rc.12 + chromadb: '*' + convex: ^1.3.1 couchbase: ^4.3.0 d3-dsv: ^2.0.0 epub2: ^3.0.1 @@ -6652,6 +7396,9 @@ packages: resolution: {integrity: sha512-qsda+H8jTaUaN/x5vzW2rzc+8Rw4TAQ/4KjB46IwK5VH+IlVeeeje/EoZRpiXvIqjFgK84QffqPztGI3VBLG1A==} engines: {node: '>=6'} + limiter@1.1.5: + resolution: {integrity: sha512-FWWMIEOxz3GwUI4Ts/IvgVy6LPvoMPgjMdQ185nN6psJyBJ4yOpzqm695/h5umdLJg2vW3GR5iG11MAkR2AzJA==} + lines-and-columns@1.2.4: resolution: {integrity: sha512-7ylylesZQ/PV29jhEDl3Ufjo6ZX7gCqJr5F7PKrqc93v7fzSymt1BpwEU8nAUXs8qzzvqhbjhK5QZg6Mt/HkBg==} @@ -6681,16 +7428,40 @@ packages: lodash.clonedeep@4.5.0: resolution: {integrity: sha512-H5ZhCF25riFd9uB5UCkVKo61m3S/xZk1x4wA6yp/L3RFP6Z/eHH1ymQcGLo7J3GMPfm0V/7m1tryHuGVxpqEBQ==} + lodash.includes@4.3.0: + resolution: {integrity: sha512-W3Bx6mdkRTGtlJISOvVD/lbqjTlPPUDTMnlXZFnVwi9NKJ6tiAk6LVdlhZMm17VZisqhKcgzpO5Wz91PCt5b0w==} + + lodash.isboolean@3.0.3: + resolution: {integrity: sha512-Bz5mupy2SVbPHURB98VAcw+aHh4vRV5IPNhILUCsOzRmsTmSQ17jIuqopAentWoehktxGd9e/hbIXq980/1QJg==} + lodash.isequal@4.5.0: resolution: {integrity: sha512-pDo3lu8Jhfjqls6GkMgpahsF9kCyayhgykjyLMNFTKWrpVdAQtYyB4muAMWozBB4ig/dtWAmsMxLEI8wuz+DYQ==} deprecated: This package is deprecated. Use require('node:util').isDeepStrictEqual instead. + lodash.isinteger@4.0.4: + resolution: {integrity: sha512-DBwtEWN2caHQ9/imiNeEA5ys1JoRtRfY3d7V9wkqtbycnAmTvRRmbHKDV4a0EYc678/dia0jrte4tjYwVBaZUA==} + + lodash.isnumber@3.0.3: + resolution: {integrity: sha512-QYqzpfwO3/CWf3XP+Z+tkQsfaLL/EnUlXWVkIk5FUPc4sBdTehEqZONuyRt2P67PXAk+NXmTBcc97zw9t1FQrw==} + + lodash.isplainobject@4.0.6: + resolution: {integrity: sha512-oSXzaWypCMHkPC3NvBEaPHf0KsA5mvPrOPgQWDsbg8n7orZ290M0BmC/jgRZ4vcJ6DTAhjrsSYgdsW/F+MFOBA==} + + lodash.isstring@4.0.1: + resolution: {integrity: sha512-0wJxfxH1wgO3GrbuP+dTTk7op+6L41QCXbGINEmD+ny/G/eCqGzxyCsh7159S+mgDDcoarnBw6PC1PS5+wUGgw==} + + lodash.mapvalues@4.6.0: + resolution: {integrity: sha512-JPFqXFeZQ7BfS00H58kClY7SPVeHertPE0lNuCyZ26/XlN8TvakYD7b9bGyNmXbT/D3BbtPAAmq90gPWqLkxlQ==} + lodash.memoize@4.1.2: resolution: {integrity: sha512-t7j+NzmgnQzTAYXcsHYLgimltOV1MXHtlOWf6GjL9Kj8GK5FInw5JotxvbOs+IvV1/Dzo04/fCGfLVs7aXb4Ag==} lodash.merge@4.6.2: resolution: {integrity: sha512-0KpjqXRVvrYyCsX1swR/XTK0va6VQkQM6MNo7PqW77ByjAhoARA8EfrP1N4+KlKj8YS0ZUCtRT/YUuhyYDujIQ==} + lodash.once@4.1.1: + resolution: {integrity: sha512-Sb487aTOCr9drQVL8pIxOzVhafOjZN9UU54hiN8PU3uAiSV7lx1yYNpbNmex2PK6dSJoNTSJUUswT651yww3Mg==} + lodash@4.17.23: resolution: {integrity: sha512-LgVTMpQtIopCi79SJeDiP0TfWi5CNEc/L/aRdTh3yIvmZXTnheWpKjSZhnvMl8iXbC1tFg9gdHHDMLoV7CnG+w==} @@ -6729,6 +7500,9 @@ packages: resolution: {integrity: sha512-ERJq3FOzJTxBbFjZ7iDs+NiK4VI9Wz+RdrrAB8dio1oV+YvdPzUEE4QNiT2VD51DkIbCYRUUzCRkssXCHqSnKQ==} engines: {node: 14 || >=16.14} + lru-memoizer@3.0.0: + resolution: {integrity: sha512-m83w/cYXLdUIboKSPxzPAGfYnk+vqeDYXuoSrQRw1q+yVEd8IXhvMufN8Q5TIPe7e2jyX4SRNrDJI2Skw1yznQ==} + magic-bytes.js@1.13.0: resolution: {integrity: sha512-afO2mnxW7GDTXMm5/AoN1WuOcdoKhtgXjIvHmobqTD1grNplhGdv3PFOyjCVmrnOZBIT/gD/koDKpYG+0mvHcg==} @@ -6797,6 +7571,10 @@ packages: mdast-util-to-string@4.0.0: resolution: {integrity: sha512-0H44vDimn51F0YwvxSJSm0eCDOJTRlmN0R1yBh4HLj9wiV1Dn0QoXGbvFAWj2hSItVTlCmBF1hqKlIyUBVFLPg==} + media-typer@0.3.0: + resolution: {integrity: sha512-dq+qelQ9akHpcOl/gUVRTxVIOkAJ1wR3QAvb4RsVjS8oVoFjDGTc679wJYmUmknUF5HwMLOgb5O+a3KxfWapPQ==} + engines: {node: '>= 0.6'} + media-typer@1.1.0: resolution: {integrity: sha512-aisnrDP4GNe06UcKFnV5bfMNPBUw4jsLGaWwWfnH3v02GnBuXX2MCVn5RbrWo0j3pczUilYblq7fQ7Nw2t5XKw==} engines: {node: '>= 0.8'} @@ -6804,6 +7582,9 @@ packages: memory-pager@1.5.0: resolution: {integrity: sha512-ZS4Bp4r/Zoeq6+NLJpP+0Zzm0pR8whtGPf1XExKLJBAczGMnSi3It14OiNCStjQjM6NU1okjQGSxgEZN8eBYKg==} + merge-descriptors@1.0.3: + resolution: {integrity: sha512-gaNvAS7TZ897/rVaZ0nMtAyxNyi/pdbjbAwUpFQpN70GqnVfOiXpeUUMKRBmzXaSQ8DdTX4/0ms62r2K+hE6mQ==} + merge-descriptors@2.0.0: resolution: {integrity: sha512-Snk314V5ayFLhp3fkUREub6WtjBfPdCPY1Ln8/8munuLuiYhsABgBVWsozAG+MWMbVEvcdcpbi9R7ww22l9Q3g==} engines: {node: '>=18'} @@ -6815,6 +7596,10 @@ packages: resolution: {integrity: sha512-8q7VEgMJW4J8tcfVPy8g09NcQwZdbwFEqhe/WZkoIzjn/3TGDwtOCYtXGxA3O8tPzpczCCDgv+P2P5y00ZJOOg==} engines: {node: '>= 8'} + methods@1.1.2: + resolution: {integrity: sha512-iclAHeNqNm68zFtnZ0e+1L2yUIdvzNoauKU4WBA3VvH/vPFieF7qfRlwUZU+DA9P9bPXIS90ulxoUoCH23sV2w==} + engines: {node: '>= 0.6'} + micromark-core-commonmark@2.0.3: resolution: {integrity: sha512-RDBrHEMSxVFLg6xvnXmb1Ayr2WzLAWjeSATAoxwKYJV94TeNavgoIdA0a9ytzDSVzBy2YKFK+emCPOEibLeCrg==} @@ -6919,6 +7704,11 @@ packages: resolution: {integrity: sha512-Lbgzdk0h4juoQ9fCKXW4by0UJqj+nOOrI9MJ1sSj4nI8aI2eo1qmvQEie4VD1glsS250n15LsWsYtCugiStS5A==} engines: {node: '>=18'} + mime@1.6.0: + resolution: {integrity: sha512-x0Vn8spI+wuJ1O6S7gnbaQg8Pxh4NNHb7KSINmEWKiPE4RKOplvijn+NkmYmmRgP68mc70j2EbeTFRsrswaQeg==} + engines: {node: '>=4'} + hasBin: true + mime@3.0.0: resolution: {integrity: sha512-jSCU7/VB1loIWBZe14aEYHU/+1UMEHoaO7qxCOVJOw9GgH72VAWppxNcjU+x9a2k3GSIBXNKxXQFqRvvZ7vr3A==} engines: {node: '>=10.0.0'} @@ -6994,6 +7784,9 @@ packages: socks: optional: true + ms@2.0.0: + resolution: {integrity: sha512-Tpp60P6IUJDTuOq/5Z8cdskzJujfwqfOTkrwIwj7IRISpnkJnT6SyJ4PCPnGMoFjC9ddhal5KVIYtAt97ix05A==} + ms@2.1.3: resolution: {integrity: sha512-6FlzubTLZG3J2a/NVCAleEhjzq5oxgHyaCU9yYXvcLsvoVaHJq/s5xXI6/XXP6tz7R9xAOtHnSO/tXtF3WRTlA==} @@ -7018,6 +7811,10 @@ packages: engines: {node: '>= 4.4.x'} hasBin: true + negotiator@0.6.3: + resolution: {integrity: sha512-+EUsqGPLsM+j/zdChZjsnX51g4XrHFOIXwfnCVPGlQk/k5giakcKsuxCObBRu6DSm9opw/O6slWbJdghQM4bBg==} + engines: {node: '>= 0.6'} + negotiator@1.0.0: resolution: {integrity: sha512-8Ofs/AUQh8MaEcrlq5xOX0CQ9ypTF5dl78mjlMNfOK08fzpgTHQRQPBxcPlEtIw0yRpws+Zo/3r+5WRby7u3Gg==} engines: {node: '>= 0.6'} @@ -7247,6 +8044,9 @@ packages: resolution: {integrity: sha512-CiyeOxFT/JZyN5m0z9PfXw4SCBJ6Sygz1Dpl0wqjlhDEGGBP1GnsUVEL0p63hoG1fcj3fHynXi9NYO4nWOL+qQ==} engines: {node: '>= 0.8'} + partial-json@0.1.7: + resolution: {integrity: sha512-Njv/59hHaokb/hRUjce3Hdv12wd60MtM9Z5Olmn+nehe0QDAsRtRbJPvJ0Z91TusF0SuZRIvnM+S4l6EIP8leA==} + path-exists@4.0.0: resolution: {integrity: sha512-ak9Qy5Q7jYb2Wwcey5Fpvg2KoAc/ZIhLSLOSBmRmygPsGwkVVt0fZa0qrtMz+m6tJTAHfZQ8FnmB4MG4LWy7/w==} engines: {node: '>=8'} @@ -7274,6 +8074,9 @@ packages: resolution: {integrity: sha512-oWyT4gICAu+kaA7QWk/jvCHWarMKNs6pXOGWKDTr7cw4IGcUbW+PeTfbaQiLGheFRpjo6O9J0PmyMfQPjH71oA==} engines: {node: 20 || >=22} + path-to-regexp@0.1.13: + resolution: {integrity: sha512-A/AGNMFN3c8bOlvV9RreMdrv7jsmF9XIfDeCd87+I8RNg6s78BhJxMu69NEMHBSJFxKidViTEdruRwEk/WIKqA==} + path-to-regexp@8.3.0: resolution: {integrity: sha512-7jdwVIRtsP8MYpdXSwOS0YdD0Du+qOoF/AEPIt88PcCFrZCzx41oxku1jD88hZBwbNUIEfpqvuhjFaMAqMTWnA==} @@ -7423,6 +8226,18 @@ packages: resolution: {integrity: sha512-NxNv/kLguCA7p3jE8oL2aEBsrJWgAakBpgmgK6lpPWV+WuOmY6r2/zbAVnP+T8bQlA0nzHXSJSJW0Hq7ylaD2Q==} engines: {node: '>= 6'} + proto3-json-serializer@2.0.2: + resolution: {integrity: sha512-SAzp/O4Yh02jGdRc+uIrGoe87dkN/XtwxfZ4ZyafJHymd79ozp5VG5nyZ7ygqPM5+cpLDjjGnYFUkngonyDPOQ==} + engines: {node: '>=14.0.0'} + + proto3-json-serializer@3.0.4: + resolution: {integrity: sha512-E1sbAYg3aEbXrq0n1ojJkRHQJGE1kaE/O6GLA94y8rnJBfgvOPTOd1b9hOceQK1FFZI9qMh1vBERCyO2ifubcw==} + engines: {node: '>=18'} + + proto3-json-serializer@4.0.2: + resolution: {integrity: sha512-VUQlb/J2WjOG8BKhdLwJUz+MKxSMtBGYh+TaNmRtiYVhlIzXjzeAGIx7gtc3lXlA2iURzfF2+cXaQvC2ofwzpg==} + engines: {node: '>=22'} + protobufjs@7.5.1: resolution: {integrity: sha512-3qx3IRjR9WPQKagdwrKjO3Gu8RgQR2qqw+1KnigWhoVjFqegIj1K3bP11sGqhxrO46/XL7lekuG4jmjL+4cLsw==} engines: {node: '>=12.0.0'} @@ -7438,6 +8253,12 @@ packages: proxy-from-env@1.1.0: resolution: {integrity: sha512-D+zkORCbA9f1tdWRK0RaCR3GPv50cMxcrz4X8k5LTSUD1Dkw47mKJEZQNunItRTkWwgtaUSo1RVFRIG9ZXiFYg==} + pump@3.0.4: + resolution: {integrity: sha512-VS7sjc6KR7e1ukRFhQSY5LM2uBWAUPiOPa/A3mkKmiMwSmRFUITt0xuj+/lesgnCv+dPIEYlkzrcyXgquIHMcA==} + + pumpify@2.0.1: + resolution: {integrity: sha512-m7KOje7jZxrmutanlkS1daj1dS6z6BgslzOXmcSEpIlCxM3VJH7lG5QLeck/6hgF6F4crFf01UtQmNsJfweTAw==} + punycode@2.3.1: resolution: {integrity: sha512-vYt7UD1U9Wg6138shLtLOvdAu+8DsC/ilFtEVHcH+wydcSpNE20AfSOduf6MkRFahL5FY7X1oU7nKVZFtfq8Fg==} engines: {node: '>=6'} @@ -7454,6 +8275,10 @@ packages: resolution: {integrity: sha512-4EK3+xJl8Ts67nLYNwqw/dsFVnCf+qR7RgXSK9jEEm9unao3njwMDdmsdvoKBKHzxd7tCYz5e5M+SnMjdtXGQQ==} engines: {node: '>=0.6'} + qs@6.16.0: + resolution: {integrity: sha512-h6fhOIaRrID2CbEY2fqs+7t+UXZo+MLAnU5gRIq85uFtdiUPCdsApMlHhXogKVM4HM2DVbIjGNTTYH2OcmP1vA==} + engines: {node: '>=0.6'} + quansync@0.2.11: resolution: {integrity: sha512-AifT7QEbW9Nri4tAwR5M/uzpBuqfZf+zwaEM/QkzEjj7NBuFD2rBuy0K3dE+8wltbezDV7JMA0WfnCPYRSYbXA==} @@ -7494,6 +8319,10 @@ packages: resolution: {integrity: sha512-JsTMmurWEOPYowp1OwUbjcfXyDfaTB+AWoiZwjV+3qOv0uUI7A1CExGwyFwfXEO5HYThOTDC96qC9a6BYqFbyg==} engines: {node: '>=14.18.0'} + raw-body@2.5.3: + resolution: {integrity: sha512-s4VSOf6yN0rvbRZGxs8Om5CWj6seneMwK3oDb4lWDH0UPhWcxwOWw5+qk24bxq87szX1ydrwylIOp2uG1ojUpA==} + engines: {node: '>= 0.8'} + raw-body@3.0.2: resolution: {integrity: sha512-K5zQjDllxWkf7Z5xJdV0/B0WTNqx6vxG70zJE4N0kBs4LovmEYWJzQGxC9bS9RAKu3bgM40lrd5zoLJ12MQ5BA==} engines: {node: '>= 0.10'} @@ -7571,6 +8400,14 @@ packages: resolution: {integrity: sha512-dUOvLMJ0/JJYEn8NrpOaGNE7X3vpI5XlZS/u0ANjqtcZVKnIxP7IgCFwrKTxENw29emmwug53awKtaMm4i9g5w==} engines: {node: '>=14'} + retry-request@8.0.4: + resolution: {integrity: sha512-pI6/7eabUYkZxamkOq0g0uMxKLLGnjzhefY+vL8bVXag5rto4OU2YBTPytWLuHH7aEKD6fn7kJycQfid0Mwnkw==} + engines: {node: '>=18'} + + retry-request@9.0.1: + resolution: {integrity: sha512-4kGHEBl0ME6gR+8QB1sPMyg58jUxLUcCZNeqLDrfqzk0eWQN8XJFmeu7fmZCjlZCRW0S2u64Ik1HkO/0sWgCYQ==} + engines: {node: '>=22'} + retry@0.13.1: resolution: {integrity: sha512-XQBQ3I8W1Cge0Seh+6gjj03LbmRFWuoszgK9ooCpwYIrhhoO80pfq4cUkU5DkknwfOfFteRwlZ56PYOGYyFWdg==} engines: {node: '>= 4'} @@ -7659,6 +8496,10 @@ packages: engines: {node: '>=10'} hasBin: true + send@0.19.2: + resolution: {integrity: sha512-VMbMxbDeehAxpOtWJXlcUS5E8iXh6QmN+BkRX1GARS3wRaXEEgzCcB10gTQazO42tpNIya8xIyNx8fll1OFPrg==} + engines: {node: '>= 0.8.0'} + send@1.2.1: resolution: {integrity: sha512-1gnZf7DFcoIcajTjTwjwuDjzuz4PPcY2StKPlsGAQ1+YH20IRVrBaXSWmdjowTJ6u8Rc01PoYOGHXfP1mYcZNQ==} engines: {node: '>= 18'} @@ -7666,6 +8507,10 @@ packages: serialize-error-cjs@0.2.0: resolution: {integrity: sha512-Phvx+w3MTgexuKnaIOkehfKCg1uF/DWfCRqg6F6haFz0qnyn1Fboo5MRedcgZitgi/chw+lM5hxZhw4OSA0gqQ==} + serve-static@1.16.3: + resolution: {integrity: sha512-x0RTqQel6g5SY7Lg6ZreMmsOzncHFU7nhnRWkKgWuMTu5NN0DR5oruckMqRvacAN9d5w6ARnRBXl9xhDCgfMeA==} + engines: {node: '>= 0.8.0'} + serve-static@2.2.1: resolution: {integrity: sha512-xRXBn0pPqQTVQiC8wyQrKs2MOlX24zQ0POGaj0kultvoOCstBQM5yvOhAVSUwOMjQtTvsPWoNCHfPGwaaQJhTw==} engines: {node: '>= 18'} @@ -7692,6 +8537,10 @@ packages: resolution: {integrity: sha512-FCLHtRD/gnpCiCHEiJLOwdmFP+wzCmDEkc9y7NsYxeF4u7Btsn1ZuwgwJGxImImHicJArLP4R0yX4c2KCrMrTA==} engines: {node: '>= 0.4'} + side-channel-list@1.0.1: + resolution: {integrity: sha512-mjn/0bi/oUURjc5Xl7IaWi/OJJJumuoJFQJfDDyO46+hBWsfaVM65TBHq2eoZBhzl9EchxOijpkbRC8SVBQU0w==} + engines: {node: '>= 0.4'} + side-channel-map@1.0.1: resolution: {integrity: sha512-VCjCNfgMsby3tTdo02nbjtM/ewra6jPHmpThenkTYh8pG9ucZ/1P8So4u4FGBek/BjpOVsDCMoLA/iuBKIFXRA==} engines: {node: '>= 0.4'} @@ -7704,6 +8553,10 @@ packages: resolution: {integrity: sha512-ZX99e6tRweoUXqR+VBrslhda51Nh5MTQwou5tnUDgbtyM0dBgmhEDtWGP/xbKn6hqfPRHujUNwz5fy/wbbhnpw==} engines: {node: '>= 0.4'} + side-channel@1.1.1: + resolution: {integrity: sha512-6x6dK6zJdpTzF4sQeNYxwtvBzf6Eg4GtlesS94HOvTudUeyK2WXAaIfmDgsyslYrRBeFIlsi54AYsFGUuhmvrQ==} + engines: {node: '>= 0.4'} + siginfo@2.0.0: resolution: {integrity: sha512-ybx0WO1/8bSBLEWXZvEd7gMW3Sn3JFlW3TvX1nREbDLRNQNaeNN8WK0meBwPdAaOI7TtRRRJn/Es1zhrrCHu7g==} @@ -7859,6 +8712,14 @@ packages: resolution: {integrity: sha512-iK5/YhZxq5GO5z8wb0bY1317uDF3Zjpha0QFFLA8/trAoiLbQD0HUbMesEaxyzUgDxi2QlcbM8IvqOlEjgoXBA==} engines: {node: '>=12.17'} + teeny-request@10.1.4: + resolution: {integrity: sha512-R1Cg4Vu0UULeDfHL/kjABLaTW++9yD/B6n2g48y5dJ04hsEaxcfmAqbNDzNsbqAYJyIpZafjklLG9YxRu9uzOg==} + engines: {node: '>=18'} + + teeny-request@11.0.1: + resolution: {integrity: sha512-bNr5j2YjSdajgCVsp+8JVjRf1uHIbpNISLeKp/7V1NnVMX3Gh6H/kECNGlm2Q3I68ACODQ0iv6aZ3Rvm8WgLGA==} + engines: {node: '>=22'} + teeny-request@9.0.0: resolution: {integrity: sha512-resvxdc6Mgb7YEThw6G6bExlXKkv6+YbuzGg9xuXxSgxJF7Ozs+o8Y9+2R3sArdWdW8nOokoQb1yrpFB0pQK2g==} engines: {node: '>=14'} @@ -8010,6 +8871,10 @@ packages: resolution: {integrity: sha512-TeTSQ6H5YHvpqVwBRcnLDCBnDOHWYu7IvGbHT6N8AOymcr9PJGjc1GTtiWZTYg0NCgYwvnYWEkVChQAr9bjfwA==} engines: {node: '>=16'} + type-is@1.6.18: + resolution: {integrity: sha512-TkRKr9sUTxEH8MdfuCSP7VizJyzRNMjj2J2do2Jr3Kym598JVdEksuzPQCnlFPW4ky9Q+iA+ma9BGm06XQBy8g==} + engines: {node: '>= 0.6'} + type-is@2.0.1: resolution: {integrity: sha512-OZs6gsjF4vMp32qrCbiVSkrFmXtG/AZhY3t0iAMrMBiAZyV9oALtXO8hsrHbMXF9x6L3grlFuwW2oAz7cav+Gw==} engines: {node: '>= 0.6'} @@ -8091,12 +8956,19 @@ packages: peerDependencies: browserslist: '>= 4.21.0' + uri-templates@0.2.0: + resolution: {integrity: sha512-EWkjYEN0L6KOfEoOH6Wj4ghQqU7eBZMJqRHQnxQAq+dSEzRPClkWjf8557HkWQXF6BrAUoLSAyy9i3RVTliaNg==} + url-template@2.0.8: resolution: {integrity: sha512-XdVKMF4SJ0nP/O7XIPB0JwAEuT9lDIYnNsK8yGVe43y0AWoKeJNdv3ZNWh7ksJ6KqQFjOO6ox/VEitLnaVNufw==} util-deprecate@1.0.2: resolution: {integrity: sha512-EPD5q1uXyFxJpCrLnCc1nHnq3gOa6DZBocAIiI2TaSCA7VCJ1UJDMagCzIkXNsUYfD1daK//LTEQ8xiIbrHtcw==} + utils-merge@1.0.1: + resolution: {integrity: sha512-pMZTvIkT1d+TFGvDOqodOclx0QWkkgi6Tdoa8gC8ffGAAqz9pzPTZWAybbsHHoED/ztMtkv/VoYTYyShUn81hA==} + engines: {node: '>= 0.4.0'} + uuid@10.0.0: resolution: {integrity: sha512-8XkAphELsDnEGrDxUOHB3RGvXz6TeuYSGEZBOjtTtPm2lwhGBjLgOzLHB63IUWfBpNucQjND6d3AOudO+H3RWQ==} hasBin: true @@ -8237,6 +9109,14 @@ packages: resolution: {integrity: sha512-5fALBcroIl31OeXAdd1YUntxiZl1eHlZZWzNg3U4Fn+J9/cGL3eT80YlrsWGvj2ojuz1rZr2OXkgCzIxAZ7vRQ==} engines: {node: '>=6.0.0', npm: '>=3.10.0'} + websocket-driver@0.7.5: + resolution: {integrity: sha512-ZL2+3c7kMBdIRCMz6l8jQMHyGVxj+UL+xVk74Ombiciboca8rHa15L86B19E5oh1pL9Ii/uj54gtsIrZGMo6zA==} + engines: {node: '>=0.8.0'} + + websocket-extensions@0.1.4: + resolution: {integrity: sha512-OqedPIGOfsDlo31UNwYbCFMSaO9m9G/0faIHj5/dZFDMFqPTcx6UwqyOy3COEaEOg/9VsGIpdqn62W5KhoKSpg==} + engines: {node: '>=0.8.0'} + whatwg-fetch@3.6.20: resolution: {integrity: sha512-EqhiFU6daOA8kpjOWTL0olhVOF3i7OrFzSYiGsEMB8GcXS+RrzauAERX65xMeNWVqxA6HXH2m69Z9LaKKdisfg==} @@ -9467,10 +10347,274 @@ snapshots: '@esbuild/win32-x64@0.27.2': optional: true + '@fastify/busboy@3.2.2': + optional: true + '@finom/zod-to-json-schema@3.24.11(zod@4.3.6)': dependencies: zod: 4.3.6 + '@firebase/app-check-interop-types@0.3.5': + optional: true + + '@firebase/app-types@0.9.6': + dependencies: + '@firebase/logger': 0.5.2 + optional: true + + '@firebase/auth-interop-types@0.2.6': + optional: true + + '@firebase/component@0.7.5': + dependencies: + '@firebase/util': 1.15.3 + tslib: 2.8.1 + optional: true + + '@firebase/database-compat@2.1.7': + dependencies: + '@firebase/component': 0.7.5 + '@firebase/database': 1.1.5 + '@firebase/database-types': 1.0.22 + '@firebase/logger': 0.5.2 + '@firebase/util': 1.15.3 + tslib: 2.8.1 + optional: true + + '@firebase/database-types@1.0.22': + dependencies: + '@firebase/app-types': 0.9.6 + '@firebase/util': 1.15.3 + optional: true + + '@firebase/database@1.1.5': + dependencies: + '@firebase/app-check-interop-types': 0.3.5 + '@firebase/auth-interop-types': 0.2.6 + '@firebase/component': 0.7.5 + '@firebase/logger': 0.5.2 + '@firebase/util': 1.15.3 + faye-websocket: 0.11.4 + tslib: 2.8.1 + optional: true + + '@firebase/logger@0.5.2': + dependencies: + tslib: 2.8.1 + optional: true + + '@firebase/util@1.15.3': + dependencies: + tslib: 2.8.1 + optional: true + + '@genkit-ai/ai@1.42.0(@google-cloud/firestore@9.3.1)(firebase-admin@14.5.0)(genkit@1.42.0(@google-cloud/firestore@9.3.1)(firebase-admin@14.5.0))': + dependencies: + '@genkit-ai/core': 1.42.0(@google-cloud/firestore@9.3.1)(firebase-admin@14.5.0)(genkit@1.42.0(@google-cloud/firestore@9.3.1)(firebase-admin@14.5.0)) + '@opentelemetry/api': 1.9.1 + '@types/node': 20.19.30 + colorette: 2.0.20 + dotprompt: 1.1.2 + handlebars: 4.7.8 + json5: 2.2.3 + node-fetch: 3.3.2 + partial-json: 0.1.7 + uri-templates: 0.2.0 + uuid: 10.0.0 + transitivePeerDependencies: + - '@google-cloud/firestore' + - bufferutil + - encoding + - firebase + - firebase-admin + - genkit + - supports-color + - utf-8-validate + + '@genkit-ai/core@1.42.0(@google-cloud/firestore@9.3.1)(firebase-admin@14.5.0)(genkit@1.42.0(@google-cloud/firestore@9.3.1)(firebase-admin@14.5.0))': + dependencies: + '@opentelemetry/api': 1.9.1 + '@opentelemetry/api-logs': 0.52.1 + '@opentelemetry/context-async-hooks': 1.25.1(@opentelemetry/api@1.9.1) + '@opentelemetry/core': 1.25.1(@opentelemetry/api@1.9.1) + '@opentelemetry/sdk-logs': 0.52.1(@opentelemetry/api@1.9.1) + '@opentelemetry/sdk-metrics': 1.25.1(@opentelemetry/api@1.9.1) + '@opentelemetry/sdk-node': 0.52.1(@opentelemetry/api@1.9.1) + '@opentelemetry/sdk-trace-base': 1.25.1(@opentelemetry/api@1.9.1) + '@types/json-schema': 7.0.15 + ajv: 8.20.0 + ajv-formats: 3.0.1(ajv@8.20.0) + async-mutex: 0.5.0 + cors: 2.8.6 + dotprompt: 1.1.2 + express: 4.22.3 + get-port: 5.1.1 + json-schema: 0.4.0 + ws: 8.21.0 + zod: 3.25.76 + zod-to-json-schema: 3.25.1(zod@3.25.76) + optionalDependencies: + '@cfworker/json-schema': 4.1.1 + '@genkit-ai/firebase': 1.42.0(@google-cloud/firestore@9.3.1)(firebase-admin@14.5.0)(genkit@1.42.0(@google-cloud/firestore@9.3.1)(firebase-admin@14.5.0)) + transitivePeerDependencies: + - '@google-cloud/firestore' + - bufferutil + - encoding + - firebase + - firebase-admin + - genkit + - supports-color + - utf-8-validate + + '@genkit-ai/firebase@1.42.0(@google-cloud/firestore@9.3.1)(firebase-admin@14.5.0)(genkit@1.42.0(@google-cloud/firestore@9.3.1)(firebase-admin@14.5.0))': + dependencies: + '@genkit-ai/google-cloud': 1.42.0(genkit@1.42.0(@google-cloud/firestore@9.3.1)(firebase-admin@14.5.0)) + '@google-cloud/firestore': 9.3.1 + firebase-admin: 14.5.0 + genkit: 1.42.0(@google-cloud/firestore@9.3.1)(firebase-admin@14.5.0) + transitivePeerDependencies: + - encoding + - supports-color + optional: true + + '@genkit-ai/google-cloud@1.42.0(genkit@1.42.0(@google-cloud/firestore@9.3.1)(firebase-admin@14.5.0))': + dependencies: + '@google-cloud/firestore': 7.11.6 + '@google-cloud/logging-winston': 6.0.2(winston@3.19.0) + '@google-cloud/modelarmor': 0.4.1 + '@google-cloud/opentelemetry-cloud-monitoring-exporter': 0.19.0(@opentelemetry/api@1.9.1)(@opentelemetry/core@1.25.1(@opentelemetry/api@1.9.1))(@opentelemetry/resources@1.25.1(@opentelemetry/api@1.9.1))(@opentelemetry/sdk-metrics@1.25.1(@opentelemetry/api@1.9.1)) + '@google-cloud/opentelemetry-cloud-trace-exporter': 2.4.1(@opentelemetry/api@1.9.1)(@opentelemetry/core@1.25.1(@opentelemetry/api@1.9.1))(@opentelemetry/resources@1.25.1(@opentelemetry/api@1.9.1))(@opentelemetry/sdk-trace-base@1.25.1(@opentelemetry/api@1.9.1)) + '@google-cloud/opentelemetry-resource-util': 2.4.0(@opentelemetry/resources@1.25.1(@opentelemetry/api@1.9.1)) + '@opentelemetry/api': 1.9.1 + '@opentelemetry/auto-instrumentations-node': 0.49.2(@opentelemetry/api@1.9.1) + '@opentelemetry/core': 1.25.1(@opentelemetry/api@1.9.1) + '@opentelemetry/instrumentation': 0.52.1(@opentelemetry/api@1.9.1) + '@opentelemetry/instrumentation-pino': 0.41.0(@opentelemetry/api@1.9.1) + '@opentelemetry/instrumentation-winston': 0.39.0(@opentelemetry/api@1.9.1) + '@opentelemetry/resources': 1.25.1(@opentelemetry/api@1.9.1) + '@opentelemetry/sdk-metrics': 1.25.1(@opentelemetry/api@1.9.1) + '@opentelemetry/sdk-node': 0.52.1(@opentelemetry/api@1.9.1) + '@opentelemetry/sdk-trace-base': 1.25.1(@opentelemetry/api@1.9.1) + genkit: 1.42.0(@google-cloud/firestore@9.3.1)(firebase-admin@14.5.0) + google-auth-library: 9.15.1 + node-fetch: 3.3.2 + winston: 3.19.0 + transitivePeerDependencies: + - encoding + - supports-color + optional: true + + '@google-cloud/common@6.1.0': + dependencies: + '@google-cloud/projectify': 4.0.0 + '@google-cloud/promisify': 4.0.0 + arrify: 2.0.1 + duplexify: 4.1.3 + extend: 3.0.2 + google-auth-library: 10.9.1 + html-entities: 2.6.0 + retry-request: 8.0.4 + teeny-request: 10.1.4 + transitivePeerDependencies: + - supports-color + optional: true + + '@google-cloud/firestore-api@0.2.0': + dependencies: + google-gax: 5.0.8 + transitivePeerDependencies: + - supports-color + optional: true + + '@google-cloud/firestore@7.11.6': + dependencies: + '@opentelemetry/api': 1.9.1 + fast-deep-equal: 3.1.3 + functional-red-black-tree: 1.0.1 + google-gax: 4.6.1 + protobufjs: 7.5.4 + transitivePeerDependencies: + - encoding + - supports-color + optional: true + + '@google-cloud/firestore@9.3.1': + dependencies: + '@google-cloud/firestore-api': 0.2.0 + '@opentelemetry/api': 1.9.1 + fast-deep-equal: 3.1.3 + functional-red-black-tree: 1.0.1 + google-gax: 6.10.0 + protobufjs: 7.5.4 + transitivePeerDependencies: + - supports-color + optional: true + + '@google-cloud/logging-api@0.2.0': + dependencies: + google-gax: 5.0.8 + transitivePeerDependencies: + - supports-color + optional: true + + '@google-cloud/logging-winston@6.0.2(winston@3.19.0)': + dependencies: + '@google-cloud/logging': 11.4.0 + google-auth-library: 10.5.0 + lodash.mapvalues: 4.6.0 + winston: 3.19.0 + winston-transport: 4.9.0 + transitivePeerDependencies: + - encoding + - supports-color + optional: true + + '@google-cloud/logging@11.4.0': + dependencies: + '@google-cloud/common': 6.1.0 + '@google-cloud/logging-api': 0.2.0 + '@google-cloud/paginator': 5.0.2 + '@google-cloud/projectify': 4.0.0 + '@google-cloud/promisify': 4.0.0 + '@grpc/grpc-js': 1.14.3 + '@opentelemetry/api': 1.9.1 + arrify: 2.0.1 + dot-prop: 6.0.1 + extend: 3.0.2 + gcp-metadata: 6.1.1 + google-auth-library: 10.9.1 + google-gax: 4.6.1 + long: 5.3.2 + on-finished: 2.4.1 + pumpify: 2.0.1 + stream-events: 1.0.5 + transitivePeerDependencies: + - encoding + - supports-color + optional: true + + '@google-cloud/modelarmor@0.4.1': + dependencies: + google-gax: 5.0.8 + transitivePeerDependencies: + - supports-color + optional: true + + '@google-cloud/opentelemetry-cloud-monitoring-exporter@0.19.0(@opentelemetry/api@1.9.1)(@opentelemetry/core@1.25.1(@opentelemetry/api@1.9.1))(@opentelemetry/resources@1.25.1(@opentelemetry/api@1.9.1))(@opentelemetry/sdk-metrics@1.25.1(@opentelemetry/api@1.9.1))': + dependencies: + '@google-cloud/opentelemetry-resource-util': 2.4.0(@opentelemetry/resources@1.25.1(@opentelemetry/api@1.9.1)) + '@google-cloud/precise-date': 4.0.0 + '@opentelemetry/api': 1.9.1 + '@opentelemetry/core': 1.25.1(@opentelemetry/api@1.9.1) + '@opentelemetry/resources': 1.25.1(@opentelemetry/api@1.9.1) + '@opentelemetry/sdk-metrics': 1.25.1(@opentelemetry/api@1.9.1) + google-auth-library: 9.15.1 + googleapis: 137.1.0 + transitivePeerDependencies: + - encoding + - supports-color + optional: true + '@google-cloud/opentelemetry-cloud-monitoring-exporter@0.21.0(@opentelemetry/api@1.9.0)(@opentelemetry/core@2.7.1(@opentelemetry/api@1.9.0))(@opentelemetry/resources@2.7.1(@opentelemetry/api@1.9.0))(@opentelemetry/sdk-metrics@2.7.1(@opentelemetry/api@1.9.0))': dependencies: '@google-cloud/opentelemetry-resource-util': 3.0.0(@opentelemetry/core@2.7.1(@opentelemetry/api@1.9.0))(@opentelemetry/resources@2.7.1(@opentelemetry/api@1.9.0)) @@ -9485,6 +10629,21 @@ snapshots: - encoding - supports-color + '@google-cloud/opentelemetry-cloud-trace-exporter@2.4.1(@opentelemetry/api@1.9.1)(@opentelemetry/core@1.25.1(@opentelemetry/api@1.9.1))(@opentelemetry/resources@1.25.1(@opentelemetry/api@1.9.1))(@opentelemetry/sdk-trace-base@1.25.1(@opentelemetry/api@1.9.1))': + dependencies: + '@google-cloud/opentelemetry-resource-util': 2.4.0(@opentelemetry/resources@1.25.1(@opentelemetry/api@1.9.1)) + '@grpc/grpc-js': 1.14.3 + '@grpc/proto-loader': 0.7.15 + '@opentelemetry/api': 1.9.1 + '@opentelemetry/core': 1.25.1(@opentelemetry/api@1.9.1) + '@opentelemetry/resources': 1.25.1(@opentelemetry/api@1.9.1) + '@opentelemetry/sdk-trace-base': 1.25.1(@opentelemetry/api@1.9.1) + google-auth-library: 9.15.1 + transitivePeerDependencies: + - encoding + - supports-color + optional: true + '@google-cloud/opentelemetry-cloud-trace-exporter@3.0.0(@opentelemetry/api@1.9.0)(@opentelemetry/core@2.7.1(@opentelemetry/api@1.9.0))(@opentelemetry/resources@2.7.1(@opentelemetry/api@1.9.0))(@opentelemetry/sdk-trace-base@1.30.1(@opentelemetry/api@1.9.0))': dependencies: '@google-cloud/opentelemetry-resource-util': 3.0.0(@opentelemetry/core@2.7.1(@opentelemetry/api@1.9.0))(@opentelemetry/resources@2.7.1(@opentelemetry/api@1.9.0)) @@ -9499,6 +10658,16 @@ snapshots: - encoding - supports-color + '@google-cloud/opentelemetry-resource-util@2.4.0(@opentelemetry/resources@1.25.1(@opentelemetry/api@1.9.1))': + dependencies: + '@opentelemetry/resources': 1.25.1(@opentelemetry/api@1.9.1) + '@opentelemetry/semantic-conventions': 1.41.1 + gcp-metadata: 6.1.1 + transitivePeerDependencies: + - encoding + - supports-color + optional: true + '@google-cloud/opentelemetry-resource-util@3.0.0(@opentelemetry/core@2.7.1(@opentelemetry/api@1.9.0))(@opentelemetry/resources@2.7.1(@opentelemetry/api@1.9.0))': dependencies: '@opentelemetry/core': 2.7.1(@opentelemetry/api@1.9.0) @@ -9514,12 +10683,20 @@ snapshots: arrify: 2.0.1 extend: 3.0.2 + '@google-cloud/paginator@7.1.0': + dependencies: + extend: 3.0.2 + '@google-cloud/precise-date@4.0.0': {} '@google-cloud/projectify@4.0.0': {} + '@google-cloud/projectify@6.1.0': {} + '@google-cloud/promisify@4.0.0': {} + '@google-cloud/promisify@6.1.0': {} + '@google-cloud/storage@7.19.0': dependencies: '@google-cloud/paginator': 5.0.2 @@ -9541,6 +10718,26 @@ snapshots: - encoding - supports-color + '@google-cloud/storage@8.2.0': + dependencies: + '@google-cloud/paginator': 7.1.0 + '@google-cloud/projectify': 6.1.0 + '@google-cloud/promisify': 6.1.0 + abort-controller: 3.0.0 + async-retry: 1.3.3 + duplexify: 4.1.3 + fast-xml-parser: 5.3.7 + gaxios: 6.7.1 + google-auth-library: 9.15.1 + html-entities: 2.6.0 + mime: 3.0.0 + p-limit: 3.1.0 + retry-request: 9.0.1 + teeny-request: 11.0.1 + transitivePeerDependencies: + - encoding + - supports-color + '@google-cloud/vertexai@1.10.0': dependencies: google-auth-library: 9.15.1 @@ -9606,1038 +10803,1524 @@ snapshots: '@grpc/proto-loader': 0.7.15 '@types/node': 22.15.33 - '@grpc/proto-loader@0.7.15': - dependencies: - lodash.camelcase: 4.3.0 - long: 5.3.2 - protobufjs: 7.5.1 - yargs: 17.7.2 + '@grpc/proto-loader@0.7.15': + dependencies: + lodash.camelcase: 4.3.0 + long: 5.3.2 + protobufjs: 7.5.1 + yargs: 17.7.2 + + '@grpc/proto-loader@0.8.0': + dependencies: + lodash.camelcase: 4.3.0 + long: 5.3.2 + protobufjs: 7.5.4 + yargs: 17.7.2 + + '@guardrails-ai/core@0.1.1(ws@8.21.0)': + dependencies: + lodash.clonedeep: 4.5.0 + pythonia: 1.2.6(ws@8.21.0) + transitivePeerDependencies: + - ws + + '@hono/node-server@1.19.9': {} + + '@hono/node-server@1.19.9(hono@4.11.5)': + dependencies: + hono: 4.11.5 + optional: true + + '@hono/node-server@1.19.9(hono@4.12.23)': + dependencies: + hono: 4.12.23 + + '@huggingface/inference@2.8.1': + dependencies: + '@huggingface/tasks': 0.12.30 + + '@huggingface/tasks@0.12.30': {} + + '@instructor-ai/instructor@1.7.0(zod@4.3.6)': + dependencies: + zod: 4.3.6 + zod-stream: 3.0.0(zod@4.3.6) + zod-validation-error: 3.5.4(zod@4.3.6) + + '@isaacs/balanced-match@4.0.1': {} + + '@isaacs/brace-expansion@5.0.0': + dependencies: + '@isaacs/balanced-match': 4.0.1 + + '@isaacs/cliui@8.0.2': + dependencies: + string-width: 5.1.2 + string-width-cjs: string-width@4.2.3 + strip-ansi: 7.1.2 + strip-ansi-cjs: strip-ansi@6.0.1 + wrap-ansi: 8.1.0 + wrap-ansi-cjs: wrap-ansi@7.0.0 + + '@isaacs/ttlcache@2.1.5': {} + + '@istanbuljs/load-nyc-config@1.1.0': + dependencies: + camelcase: 5.3.1 + find-up: 4.1.0 + get-package-type: 0.1.0 + js-yaml: 3.14.1 + resolve-from: 5.0.0 + + '@istanbuljs/schema@0.1.3': {} + + '@jest/console@29.7.0': + dependencies: + '@jest/types': 29.6.3 + '@types/node': 22.15.33 + chalk: 4.1.2 + jest-message-util: 29.7.0 + jest-util: 29.7.0 + slash: 3.0.0 + + '@jest/core@29.7.0(ts-node@10.9.2(@types/node@22.15.33)(typescript@5.8.3))': + dependencies: + '@jest/console': 29.7.0 + '@jest/reporters': 29.7.0 + '@jest/test-result': 29.7.0 + '@jest/transform': 29.7.0 + '@jest/types': 29.6.3 + '@types/node': 22.15.33 + ansi-escapes: 4.3.2 + chalk: 4.1.2 + ci-info: 3.9.0 + exit: 0.1.2 + graceful-fs: 4.2.11 + jest-changed-files: 29.7.0 + jest-config: 29.7.0(@types/node@22.15.33)(ts-node@10.9.2(@types/node@22.15.33)(typescript@5.8.3)) + jest-haste-map: 29.7.0 + jest-message-util: 29.7.0 + jest-regex-util: 29.6.3 + jest-resolve: 29.7.0 + jest-resolve-dependencies: 29.7.0 + jest-runner: 29.7.0 + jest-runtime: 29.7.0 + jest-snapshot: 29.7.0 + jest-util: 29.7.0 + jest-validate: 29.7.0 + jest-watcher: 29.7.0 + micromatch: 4.0.8 + pretty-format: 29.7.0 + slash: 3.0.0 + strip-ansi: 6.0.1 + transitivePeerDependencies: + - babel-plugin-macros + - supports-color + - ts-node + + '@jest/environment@29.7.0': + dependencies: + '@jest/fake-timers': 29.7.0 + '@jest/types': 29.6.3 + '@types/node': 22.15.33 + jest-mock: 29.7.0 + + '@jest/expect-utils@29.7.0': + dependencies: + jest-get-type: 29.6.3 + + '@jest/expect@29.7.0': + dependencies: + expect: 29.7.0 + jest-snapshot: 29.7.0 + transitivePeerDependencies: + - supports-color + + '@jest/fake-timers@29.7.0': + dependencies: + '@jest/types': 29.6.3 + '@sinonjs/fake-timers': 10.3.0 + '@types/node': 22.15.33 + jest-message-util: 29.7.0 + jest-mock: 29.7.0 + jest-util: 29.7.0 + + '@jest/globals@29.7.0': + dependencies: + '@jest/environment': 29.7.0 + '@jest/expect': 29.7.0 + '@jest/types': 29.6.3 + jest-mock: 29.7.0 + transitivePeerDependencies: + - supports-color + + '@jest/reporters@29.7.0': + dependencies: + '@bcoe/v8-coverage': 0.2.3 + '@jest/console': 29.7.0 + '@jest/test-result': 29.7.0 + '@jest/transform': 29.7.0 + '@jest/types': 29.6.3 + '@jridgewell/trace-mapping': 0.3.25 + '@types/node': 22.15.33 + chalk: 4.1.2 + collect-v8-coverage: 1.0.2 + exit: 0.1.2 + glob: 7.2.3 + graceful-fs: 4.2.11 + istanbul-lib-coverage: 3.2.2 + istanbul-lib-instrument: 6.0.3 + istanbul-lib-report: 3.0.1 + istanbul-lib-source-maps: 4.0.1 + istanbul-reports: 3.1.7 + jest-message-util: 29.7.0 + jest-util: 29.7.0 + jest-worker: 29.7.0 + slash: 3.0.0 + string-length: 4.0.2 + strip-ansi: 6.0.1 + v8-to-istanbul: 9.3.0 + transitivePeerDependencies: + - supports-color + + '@jest/schemas@29.6.3': + dependencies: + '@sinclair/typebox': 0.27.8 + + '@jest/source-map@29.6.3': + dependencies: + '@jridgewell/trace-mapping': 0.3.25 + callsites: 3.1.0 + graceful-fs: 4.2.11 + + '@jest/test-result@29.7.0': + dependencies: + '@jest/console': 29.7.0 + '@jest/types': 29.6.3 + '@types/istanbul-lib-coverage': 2.0.6 + collect-v8-coverage: 1.0.2 + + '@jest/test-sequencer@29.7.0': + dependencies: + '@jest/test-result': 29.7.0 + graceful-fs: 4.2.11 + jest-haste-map: 29.7.0 + slash: 3.0.0 + + '@jest/transform@29.7.0': + dependencies: + '@babel/core': 7.27.1 + '@jest/types': 29.6.3 + '@jridgewell/trace-mapping': 0.3.25 + babel-plugin-istanbul: 6.1.1 + chalk: 4.1.2 + convert-source-map: 2.0.0 + fast-json-stable-stringify: 2.1.0 + graceful-fs: 4.2.11 + jest-haste-map: 29.7.0 + jest-regex-util: 29.6.3 + jest-util: 29.7.0 + micromatch: 4.0.8 + pirates: 4.0.7 + slash: 3.0.0 + write-file-atomic: 4.0.2 + transitivePeerDependencies: + - supports-color + + '@jest/types@29.6.3': + dependencies: + '@jest/schemas': 29.6.3 + '@types/istanbul-lib-coverage': 2.0.6 + '@types/istanbul-reports': 3.0.4 + '@types/node': 22.15.33 + '@types/yargs': 17.0.33 + chalk: 4.1.2 + + '@jridgewell/gen-mapping@0.3.8': + dependencies: + '@jridgewell/set-array': 1.2.1 + '@jridgewell/sourcemap-codec': 1.5.5 + '@jridgewell/trace-mapping': 0.3.25 + + '@jridgewell/resolve-uri@3.1.2': {} + + '@jridgewell/set-array@1.2.1': {} + + '@jridgewell/sourcemap-codec@1.5.0': {} - '@grpc/proto-loader@0.8.0': + '@jridgewell/sourcemap-codec@1.5.5': {} + + '@jridgewell/trace-mapping@0.3.25': dependencies: - lodash.camelcase: 4.3.0 - long: 5.3.2 - protobufjs: 7.5.4 - yargs: 17.7.2 + '@jridgewell/resolve-uri': 3.1.2 + '@jridgewell/sourcemap-codec': 1.5.5 - '@guardrails-ai/core@0.1.1(ws@8.21.0)': + '@jridgewell/trace-mapping@0.3.9': dependencies: - lodash.clonedeep: 4.5.0 - pythonia: 1.2.6(ws@8.21.0) - transitivePeerDependencies: - - ws + '@jridgewell/resolve-uri': 3.1.2 + '@jridgewell/sourcemap-codec': 1.5.0 - '@hono/node-server@1.19.9': {} + '@js-sdsl/ordered-map@4.4.2': {} - '@hono/node-server@1.19.9(hono@4.11.5)': - dependencies: - hono: 4.11.5 + '@lancedb/lancedb-darwin-arm64@0.4.20': optional: true - '@hono/node-server@1.19.9(hono@4.12.23)': - dependencies: - hono: 4.12.23 - - '@huggingface/inference@2.8.1': - dependencies: - '@huggingface/tasks': 0.12.30 + '@lancedb/lancedb-darwin-x64@0.4.20': + optional: true - '@huggingface/tasks@0.12.30': {} + '@lancedb/lancedb-linux-arm64-gnu@0.4.20': + optional: true - '@instructor-ai/instructor@1.7.0(zod@4.3.6)': - dependencies: - zod: 4.3.6 - zod-stream: 3.0.0(zod@4.3.6) - zod-validation-error: 3.5.4(zod@4.3.6) + '@lancedb/lancedb-linux-x64-gnu@0.4.20': + optional: true - '@isaacs/balanced-match@4.0.1': {} + '@lancedb/lancedb-win32-x64-msvc@0.4.20': + optional: true - '@isaacs/brace-expansion@5.0.0': + '@lancedb/lancedb@0.4.20(ws@8.21.0)(zod@3.25.76)': dependencies: - '@isaacs/balanced-match': 4.0.1 + apache-arrow: 15.0.2 + openai: 4.98.0(ws@8.21.0)(zod@3.25.76) + optionalDependencies: + '@lancedb/lancedb-darwin-arm64': 0.4.20 + '@lancedb/lancedb-darwin-x64': 0.4.20 + '@lancedb/lancedb-linux-arm64-gnu': 0.4.20 + '@lancedb/lancedb-linux-x64-gnu': 0.4.20 + '@lancedb/lancedb-win32-x64-msvc': 0.4.20 + transitivePeerDependencies: + - encoding + - ws + - zod - '@isaacs/cliui@8.0.2': + '@langchain/community@0.0.57(@aws-crypto/sha256-js@5.2.0)(@aws-sdk/client-bedrock-runtime@3.975.0)(@aws-sdk/credential-provider-node@3.972.1)(@huggingface/inference@2.8.1)(@pinecone-database/pinecone@4.1.0)(@qdrant/js-client-rest@1.16.2(typescript@5.8.3))(@smithy/util-utf8@2.3.0)(@zilliz/milvus2-sdk-node@2.6.9)(chromadb@1.10.5(cohere-ai@7.20.0)(ollama@0.5.18)(openai@4.98.0(ws@8.21.0)(zod@3.24.4)))(cohere-ai@7.20.0)(duck-duck-scrape@2.2.7)(html-to-text@9.0.5)(lodash@4.17.23)(mongodb@6.21.0(@aws-sdk/credential-providers@3.975.0))(openai@4.98.0(ws@8.21.0)(zod@3.24.4))(pg@8.17.2)(redis@4.7.1)(ws@8.21.0)': dependencies: - string-width: 5.1.2 - string-width-cjs: string-width@4.2.3 - strip-ansi: 7.1.2 - strip-ansi-cjs: strip-ansi@6.0.1 - wrap-ansi: 8.1.0 - wrap-ansi-cjs: wrap-ansi@7.0.0 - - '@isaacs/ttlcache@2.1.5': {} + '@langchain/core': 0.1.63(openai@4.98.0(ws@8.21.0)(zod@3.24.4)) + '@langchain/openai': 0.0.34(ws@8.21.0) + expr-eval: 2.0.2 + flat: 5.0.2 + langsmith: 0.1.68(openai@4.98.0(ws@8.21.0)(zod@3.24.4)) + uuid: 9.0.1 + zod: 3.25.76 + zod-to-json-schema: 3.25.1(zod@3.25.76) + optionalDependencies: + '@aws-crypto/sha256-js': 5.2.0 + '@aws-sdk/client-bedrock-runtime': 3.975.0 + '@aws-sdk/credential-provider-node': 3.972.1 + '@huggingface/inference': 2.8.1 + '@pinecone-database/pinecone': 4.1.0 + '@qdrant/js-client-rest': 1.16.2(typescript@5.8.3) + '@smithy/util-utf8': 2.3.0 + '@zilliz/milvus2-sdk-node': 2.6.9 + chromadb: 1.10.5(cohere-ai@7.20.0)(ollama@0.5.18)(openai@4.98.0(ws@8.21.0)(zod@3.24.4)) + cohere-ai: 7.20.0 + duck-duck-scrape: 2.2.7 + html-to-text: 9.0.5 + lodash: 4.17.23 + mongodb: 6.21.0(@aws-sdk/credential-providers@3.975.0) + pg: 8.17.2 + redis: 4.7.1 + ws: 8.21.0 + transitivePeerDependencies: + - encoding + - openai - '@istanbuljs/load-nyc-config@1.1.0': + '@langchain/core@0.1.63(openai@4.98.0(ws@8.21.0)(zod@3.24.4))': dependencies: - camelcase: 5.3.1 - find-up: 4.1.0 - get-package-type: 0.1.0 - js-yaml: 3.14.1 - resolve-from: 5.0.0 - - '@istanbuljs/schema@0.1.3': {} + ansi-styles: 5.2.0 + camelcase: 6.3.0 + decamelize: 1.2.0 + js-tiktoken: 1.0.20 + langsmith: 0.1.68(openai@4.98.0(ws@8.21.0)(zod@3.24.4)) + ml-distance: 4.0.1 + mustache: 4.2.0 + p-queue: 6.6.2 + p-retry: 4.6.2 + uuid: 9.0.1 + zod: 3.25.76 + zod-to-json-schema: 3.25.1(zod@3.25.76) + transitivePeerDependencies: + - openai - '@jest/console@29.7.0': + '@langchain/core@0.2.36(openai@4.104.0(ws@8.21.0)(zod@3.25.76))': dependencies: - '@jest/types': 29.6.3 - '@types/node': 22.15.33 - chalk: 4.1.2 - jest-message-util: 29.7.0 - jest-util: 29.7.0 - slash: 3.0.0 + ansi-styles: 5.2.0 + camelcase: 6.3.0 + decamelize: 1.2.0 + js-tiktoken: 1.0.20 + langsmith: 0.1.68(openai@4.104.0(ws@8.21.0)(zod@3.25.76)) + mustache: 4.2.0 + p-queue: 6.6.2 + p-retry: 4.6.2 + uuid: 10.0.0 + zod: 3.25.76 + zod-to-json-schema: 3.25.1(zod@3.25.76) + transitivePeerDependencies: + - openai - '@jest/core@29.7.0(ts-node@10.9.2(@types/node@22.15.33)(typescript@5.8.3))': + '@langchain/core@0.2.36(openai@4.98.0(ws@8.21.0)(zod@3.24.4))': dependencies: - '@jest/console': 29.7.0 - '@jest/reporters': 29.7.0 - '@jest/test-result': 29.7.0 - '@jest/transform': 29.7.0 - '@jest/types': 29.6.3 - '@types/node': 22.15.33 - ansi-escapes: 4.3.2 - chalk: 4.1.2 - ci-info: 3.9.0 - exit: 0.1.2 - graceful-fs: 4.2.11 - jest-changed-files: 29.7.0 - jest-config: 29.7.0(@types/node@22.15.33)(ts-node@10.9.2(@types/node@22.15.33)(typescript@5.8.3)) - jest-haste-map: 29.7.0 - jest-message-util: 29.7.0 - jest-regex-util: 29.6.3 - jest-resolve: 29.7.0 - jest-resolve-dependencies: 29.7.0 - jest-runner: 29.7.0 - jest-runtime: 29.7.0 - jest-snapshot: 29.7.0 - jest-util: 29.7.0 - jest-validate: 29.7.0 - jest-watcher: 29.7.0 - micromatch: 4.0.8 - pretty-format: 29.7.0 - slash: 3.0.0 - strip-ansi: 6.0.1 + ansi-styles: 5.2.0 + camelcase: 6.3.0 + decamelize: 1.2.0 + js-tiktoken: 1.0.20 + langsmith: 0.1.68(openai@4.98.0(ws@8.21.0)(zod@3.24.4)) + mustache: 4.2.0 + p-queue: 6.6.2 + p-retry: 4.6.2 + uuid: 10.0.0 + zod: 3.25.76 + zod-to-json-schema: 3.25.1(zod@3.25.76) transitivePeerDependencies: - - babel-plugin-macros - - supports-color - - ts-node + - openai - '@jest/environment@29.7.0': + '@langchain/core@0.2.36(openai@6.22.0(ws@8.21.0)(zod@4.3.6))': dependencies: - '@jest/fake-timers': 29.7.0 - '@jest/types': 29.6.3 - '@types/node': 22.15.33 - jest-mock: 29.7.0 + ansi-styles: 5.2.0 + camelcase: 6.3.0 + decamelize: 1.2.0 + js-tiktoken: 1.0.20 + langsmith: 0.1.68(openai@6.22.0(ws@8.21.0)(zod@4.3.6)) + mustache: 4.2.0 + p-queue: 6.6.2 + p-retry: 4.6.2 + uuid: 10.0.0 + zod: 3.25.76 + zod-to-json-schema: 3.25.1(zod@3.25.76) + transitivePeerDependencies: + - openai + optional: true - '@jest/expect-utils@29.7.0': + '@langchain/core@0.3.56(openai@4.98.0(ws@8.21.0)(zod@3.24.4))': dependencies: - jest-get-type: 29.6.3 + '@cfworker/json-schema': 4.1.1 + ansi-styles: 5.2.0 + camelcase: 6.3.0 + decamelize: 1.2.0 + js-tiktoken: 1.0.20 + langsmith: 0.3.29(openai@4.98.0(ws@8.21.0)(zod@3.24.4)) + mustache: 4.2.0 + p-queue: 6.6.2 + p-retry: 4.6.2 + uuid: 10.0.0 + zod: 3.24.4 + zod-to-json-schema: 3.24.5(zod@3.24.4) + transitivePeerDependencies: + - openai - '@jest/expect@29.7.0': + '@langchain/openai@0.0.34(ws@8.21.0)': dependencies: - expect: 29.7.0 - jest-snapshot: 29.7.0 + '@langchain/core': 0.2.36(openai@4.104.0(ws@8.21.0)(zod@3.25.76)) + js-tiktoken: 1.0.20 + openai: 4.104.0(ws@8.21.0)(zod@3.25.76) + zod: 3.25.76 + zod-to-json-schema: 3.25.1(zod@3.25.76) transitivePeerDependencies: - - supports-color + - encoding + - ws - '@jest/fake-timers@29.7.0': + '@langchain/openai@0.2.11(ws@8.21.0)': dependencies: - '@jest/types': 29.6.3 - '@sinonjs/fake-timers': 10.3.0 - '@types/node': 22.15.33 - jest-message-util: 29.7.0 - jest-mock: 29.7.0 - jest-util: 29.7.0 + '@langchain/core': 0.2.36(openai@4.104.0(ws@8.21.0)(zod@3.25.76)) + js-tiktoken: 1.0.20 + openai: 4.104.0(ws@8.21.0)(zod@3.25.76) + zod: 3.25.76 + zod-to-json-schema: 3.25.1(zod@3.25.76) + transitivePeerDependencies: + - encoding + - ws - '@jest/globals@29.7.0': + '@langchain/openai@0.3.16(@langchain/core@0.3.56(openai@4.98.0(ws@8.21.0)(zod@3.24.4)))(ws@8.21.0)': dependencies: - '@jest/environment': 29.7.0 - '@jest/expect': 29.7.0 - '@jest/types': 29.6.3 - jest-mock: 29.7.0 + '@langchain/core': 0.3.56(openai@4.98.0(ws@8.21.0)(zod@3.24.4)) + js-tiktoken: 1.0.20 + openai: 4.104.0(ws@8.21.0)(zod@3.25.76) + zod: 3.25.76 + zod-to-json-schema: 3.25.1(zod@3.25.76) transitivePeerDependencies: - - supports-color + - encoding + - ws - '@jest/reporters@29.7.0': + '@langchain/textsplitters@0.0.3(openai@4.98.0(ws@8.21.0)(zod@3.24.4))': dependencies: - '@bcoe/v8-coverage': 0.2.3 - '@jest/console': 29.7.0 - '@jest/test-result': 29.7.0 - '@jest/transform': 29.7.0 - '@jest/types': 29.6.3 - '@jridgewell/trace-mapping': 0.3.25 - '@types/node': 22.15.33 - chalk: 4.1.2 - collect-v8-coverage: 1.0.2 - exit: 0.1.2 - glob: 7.2.3 - graceful-fs: 4.2.11 - istanbul-lib-coverage: 3.2.2 - istanbul-lib-instrument: 6.0.3 - istanbul-lib-report: 3.0.1 - istanbul-lib-source-maps: 4.0.1 - istanbul-reports: 3.1.7 - jest-message-util: 29.7.0 - jest-util: 29.7.0 - jest-worker: 29.7.0 - slash: 3.0.0 - string-length: 4.0.2 - strip-ansi: 6.0.1 - v8-to-istanbul: 9.3.0 + '@langchain/core': 0.2.36(openai@4.98.0(ws@8.21.0)(zod@3.24.4)) + js-tiktoken: 1.0.20 transitivePeerDependencies: - - supports-color + - openai - '@jest/schemas@29.6.3': + '@langchain/textsplitters@0.1.0(@langchain/core@0.3.56(openai@4.98.0(ws@8.21.0)(zod@3.24.4)))': dependencies: - '@sinclair/typebox': 0.27.8 + '@langchain/core': 0.3.56(openai@4.98.0(ws@8.21.0)(zod@3.24.4)) + js-tiktoken: 1.0.20 - '@jest/source-map@29.6.3': - dependencies: - '@jridgewell/trace-mapping': 0.3.25 - callsites: 3.1.0 - graceful-fs: 4.2.11 + '@livekit/mutex@1.1.1': {} - '@jest/test-result@29.7.0': + '@livekit/protocol@1.44.0': dependencies: - '@jest/console': 29.7.0 - '@jest/types': 29.6.3 - '@types/istanbul-lib-coverage': 2.0.6 - collect-v8-coverage: 1.0.2 + '@bufbuild/protobuf': 1.10.1 - '@jest/test-sequencer@29.7.0': + '@livekit/rtc-node-darwin-arm64@0.5.1': + optional: true + + '@livekit/rtc-node-darwin-x64@0.5.1': + optional: true + + '@livekit/rtc-node-linux-arm64-gnu@0.5.1': + optional: true + + '@livekit/rtc-node-linux-x64-gnu@0.5.1': + optional: true + + '@livekit/rtc-node-win32-x64-msvc@0.5.1': + optional: true + + '@livekit/rtc-node@0.5.1': dependencies: - '@jest/test-result': 29.7.0 - graceful-fs: 4.2.11 - jest-haste-map: 29.7.0 - slash: 3.0.0 + '@bufbuild/protobuf': 1.10.1 + typed-emitter: 2.1.0 + optionalDependencies: + '@livekit/rtc-node-darwin-arm64': 0.5.1 + '@livekit/rtc-node-darwin-x64': 0.5.1 + '@livekit/rtc-node-linux-arm64-gnu': 0.5.1 + '@livekit/rtc-node-linux-x64-gnu': 0.5.1 + '@livekit/rtc-node-win32-x64-msvc': 0.5.1 - '@jest/transform@29.7.0': + '@llamaindex/core@0.6.22': dependencies: - '@babel/core': 7.27.1 - '@jest/types': 29.6.3 - '@jridgewell/trace-mapping': 0.3.25 - babel-plugin-istanbul: 6.1.1 - chalk: 4.1.2 - convert-source-map: 2.0.0 - fast-json-stable-stringify: 2.1.0 - graceful-fs: 4.2.11 - jest-haste-map: 29.7.0 - jest-regex-util: 29.6.3 - jest-util: 29.7.0 - micromatch: 4.0.8 - pirates: 4.0.7 - slash: 3.0.0 - write-file-atomic: 4.0.2 + '@finom/zod-to-json-schema': 3.24.11(zod@4.3.6) + '@llamaindex/env': 0.1.30 + '@types/node': 24.10.9 + magic-bytes.js: 1.13.0 + zod: 4.3.6 transitivePeerDependencies: - - supports-color + - '@huggingface/transformers' + - gpt-tokenizer - '@jest/types@29.6.3': + '@llamaindex/env@0.1.30': dependencies: - '@jest/schemas': 29.6.3 - '@types/istanbul-lib-coverage': 2.0.6 - '@types/istanbul-reports': 3.0.4 - '@types/node': 22.15.33 - '@types/yargs': 17.0.33 - chalk: 4.1.2 + '@aws-crypto/sha256-js': 5.2.0 + js-tiktoken: 1.0.20 + pathe: 1.1.2 - '@jridgewell/gen-mapping@0.3.8': + '@llamaindex/node-parser@2.0.22(@llamaindex/core@0.6.22)(@llamaindex/env@0.1.30)(tree-sitter@0.22.4)(web-tree-sitter@0.24.7)': dependencies: - '@jridgewell/set-array': 1.2.1 - '@jridgewell/sourcemap-codec': 1.5.5 - '@jridgewell/trace-mapping': 0.3.25 + '@llamaindex/core': 0.6.22 + '@llamaindex/env': 0.1.30 + html-to-text: 9.0.5 + tree-sitter: 0.22.4 + web-tree-sitter: 0.24.7 - '@jridgewell/resolve-uri@3.1.2': {} + '@llamaindex/openai@0.4.22(@llamaindex/core@0.6.22)(@llamaindex/env@0.1.30)(ws@8.21.0)(zod@4.3.6)': + dependencies: + '@llamaindex/core': 0.6.22 + '@llamaindex/env': 0.1.30 + openai: 5.23.2(ws@8.21.0)(zod@4.3.6) + transitivePeerDependencies: + - ws + - zod - '@jridgewell/set-array@1.2.1': {} + '@llamaindex/workflow-core@1.3.3(@modelcontextprotocol/sdk@1.29.0(@cfworker/json-schema@4.1.1)(zod@4.3.6))(hono@4.12.23)(rxjs@7.8.2)(zod@4.3.6)': + optionalDependencies: + '@modelcontextprotocol/sdk': 1.29.0(@cfworker/json-schema@4.1.1)(zod@4.3.6) + hono: 4.12.23 + rxjs: 7.8.2 + zod: 4.3.6 - '@jridgewell/sourcemap-codec@1.5.0': {} + '@llamaindex/workflow@1.1.24(@llamaindex/core@0.6.22)(@llamaindex/env@0.1.30)(@modelcontextprotocol/sdk@1.29.0(@cfworker/json-schema@4.1.1)(zod@4.3.6))(hono@4.12.23)(rxjs@7.8.2)(zod@4.3.6)': + dependencies: + '@llamaindex/core': 0.6.22 + '@llamaindex/env': 0.1.30 + '@llamaindex/workflow-core': 1.3.3(@modelcontextprotocol/sdk@1.29.0(@cfworker/json-schema@4.1.1)(zod@4.3.6))(hono@4.12.23)(rxjs@7.8.2)(zod@4.3.6) + transitivePeerDependencies: + - '@modelcontextprotocol/sdk' + - hono + - next + - p-retry + - rxjs + - zod - '@jridgewell/sourcemap-codec@1.5.5': {} + '@lukeed/csprng@1.1.0': {} - '@jridgewell/trace-mapping@0.3.25': + '@lukeed/uuid@2.0.1': dependencies: - '@jridgewell/resolve-uri': 3.1.2 - '@jridgewell/sourcemap-codec': 1.5.5 + '@lukeed/csprng': 1.1.0 - '@jridgewell/trace-mapping@0.3.9': + '@mastra/core@1.37.1(@bufbuild/protobuf@2.11.0)(@cfworker/json-schema@4.1.1)(@grpc/grpc-js@1.14.3)(@standard-community/standard-json@0.3.5(@standard-schema/spec@1.1.0)(@types/json-schema@7.0.15)(quansync@0.2.11)(zod-to-json-schema@3.25.1(zod@4.3.6))(zod@4.3.6))(@standard-community/standard-openapi@0.2.9(@standard-community/standard-json@0.3.5(@standard-schema/spec@1.1.0)(@types/json-schema@7.0.15)(quansync@0.2.11)(zod-to-json-schema@3.25.1(zod@4.3.6))(zod@4.3.6))(@standard-schema/spec@1.1.0)(openapi-types@12.1.3)(zod@4.3.6))(@types/json-schema@7.0.15)(express@5.2.1)(openapi-types@12.1.3)(rxjs@7.8.2)(zod@4.3.6)': dependencies: - '@jridgewell/resolve-uri': 3.1.2 - '@jridgewell/sourcemap-codec': 1.5.0 - - '@js-sdsl/ordered-map@4.4.2': {} + '@a2a-js/sdk': 0.3.13(@bufbuild/protobuf@2.11.0)(@grpc/grpc-js@1.14.3)(express@5.2.1) + '@ai-sdk/provider-utils-v5': '@ai-sdk/provider-utils@3.0.25(zod@4.3.6)' + '@ai-sdk/provider-utils-v6': '@ai-sdk/provider-utils@4.0.27(zod@4.3.6)' + '@ai-sdk/provider-v5': '@ai-sdk/provider@2.0.3' + '@ai-sdk/provider-v6': '@ai-sdk/provider@3.0.10' + '@ai-sdk/ui-utils-v5': '@ai-sdk/ui-utils@1.2.11(zod@4.3.6)' + '@isaacs/ttlcache': 2.1.5 + '@lukeed/uuid': 2.0.1 + '@mastra/schema-compat': 1.2.10(zod@4.3.6) + '@modelcontextprotocol/sdk': 1.29.0(@cfworker/json-schema@4.1.1)(zod@4.3.6) + '@sindresorhus/slugify': 2.2.1 + '@standard-schema/spec': 1.1.0 + ajv: 8.20.0 + chat: 4.30.0(zod@4.3.6) + croner: 10.0.1 + dotenv: 17.4.2 + execa: 9.6.1 + fastq: 1.20.1 + gray-matter: 4.0.3 + hono: 4.12.23 + hono-openapi: 1.3.0(@standard-community/standard-json@0.3.5(@standard-schema/spec@1.1.0)(@types/json-schema@7.0.15)(quansync@0.2.11)(zod-to-json-schema@3.25.1(zod@4.3.6))(zod@4.3.6))(@standard-community/standard-openapi@0.2.9(@standard-community/standard-json@0.3.5(@standard-schema/spec@1.1.0)(@types/json-schema@7.0.15)(quansync@0.2.11)(zod-to-json-schema@3.25.1(zod@4.3.6))(zod@4.3.6))(@standard-schema/spec@1.1.0)(openapi-types@12.1.3)(zod@4.3.6))(@types/json-schema@7.0.15)(hono@4.12.23)(openapi-types@12.1.3) + ignore: 7.0.5 + json-schema: 0.4.0 + lru-cache: 11.5.1 + p-map: 7.0.4 + p-retry: 7.1.1 + picomatch: 4.0.3 + posthog-node: 5.35.11(rxjs@7.8.2) + tokenx: 1.3.0 + ws: 8.21.0 + xxhash-wasm: 1.1.0 + zod: 4.3.6 + transitivePeerDependencies: + - '@bufbuild/protobuf' + - '@cfworker/json-schema' + - '@grpc/grpc-js' + - '@hono/standard-validator' + - '@standard-community/standard-json' + - '@standard-community/standard-openapi' + - '@types/json-schema' + - ai + - bufferutil + - express + - openapi-types + - rxjs + - supports-color + - utf-8-validate - '@lancedb/lancedb-darwin-arm64@0.4.20': - optional: true + '@mastra/observability@1.14.0(@mastra/core@1.37.1(@bufbuild/protobuf@2.11.0)(@cfworker/json-schema@4.1.1)(@grpc/grpc-js@1.14.3)(@standard-community/standard-json@0.3.5(@standard-schema/spec@1.1.0)(@types/json-schema@7.0.15)(quansync@0.2.11)(zod-to-json-schema@3.25.1(zod@4.3.6))(zod@4.3.6))(@standard-community/standard-openapi@0.2.9(@standard-community/standard-json@0.3.5(@standard-schema/spec@1.1.0)(@types/json-schema@7.0.15)(quansync@0.2.11)(zod-to-json-schema@3.25.1(zod@4.3.6))(zod@4.3.6))(@standard-schema/spec@1.1.0)(openapi-types@12.1.3)(zod@4.3.6))(@types/json-schema@7.0.15)(express@5.2.1)(openapi-types@12.1.3)(rxjs@7.8.2)(zod@4.3.6))(zod@4.3.6)': + dependencies: + '@mastra/core': 1.37.1(@bufbuild/protobuf@2.11.0)(@cfworker/json-schema@4.1.1)(@grpc/grpc-js@1.14.3)(@standard-community/standard-json@0.3.5(@standard-schema/spec@1.1.0)(@types/json-schema@7.0.15)(quansync@0.2.11)(zod-to-json-schema@3.25.1(zod@4.3.6))(zod@4.3.6))(@standard-community/standard-openapi@0.2.9(@standard-community/standard-json@0.3.5(@standard-schema/spec@1.1.0)(@types/json-schema@7.0.15)(quansync@0.2.11)(zod-to-json-schema@3.25.1(zod@4.3.6))(zod@4.3.6))(@standard-schema/spec@1.1.0)(openapi-types@12.1.3)(zod@4.3.6))(@types/json-schema@7.0.15)(express@5.2.1)(openapi-types@12.1.3)(rxjs@7.8.2)(zod@4.3.6) + zod: 4.3.6 - '@lancedb/lancedb-darwin-x64@0.4.20': - optional: true + '@mastra/otel-exporter@1.2.0(@mastra/core@1.37.1(@bufbuild/protobuf@2.11.0)(@cfworker/json-schema@4.1.1)(@grpc/grpc-js@1.14.3)(@standard-community/standard-json@0.3.5(@standard-schema/spec@1.1.0)(@types/json-schema@7.0.15)(quansync@0.2.11)(zod-to-json-schema@3.25.1(zod@4.3.6))(zod@4.3.6))(@standard-community/standard-openapi@0.2.9(@standard-community/standard-json@0.3.5(@standard-schema/spec@1.1.0)(@types/json-schema@7.0.15)(quansync@0.2.11)(zod-to-json-schema@3.25.1(zod@4.3.6))(zod@4.3.6))(@standard-schema/spec@1.1.0)(openapi-types@12.1.3)(zod@4.3.6))(@types/json-schema@7.0.15)(express@5.2.1)(openapi-types@12.1.3)(rxjs@7.8.2)(zod@4.3.6))(zod@4.3.6)': + dependencies: + '@mastra/core': 1.37.1(@bufbuild/protobuf@2.11.0)(@cfworker/json-schema@4.1.1)(@grpc/grpc-js@1.14.3)(@standard-community/standard-json@0.3.5(@standard-schema/spec@1.1.0)(@types/json-schema@7.0.15)(quansync@0.2.11)(zod-to-json-schema@3.25.1(zod@4.3.6))(zod@4.3.6))(@standard-community/standard-openapi@0.2.9(@standard-community/standard-json@0.3.5(@standard-schema/spec@1.1.0)(@types/json-schema@7.0.15)(quansync@0.2.11)(zod-to-json-schema@3.25.1(zod@4.3.6))(zod@4.3.6))(@standard-schema/spec@1.1.0)(openapi-types@12.1.3)(zod@4.3.6))(@types/json-schema@7.0.15)(express@5.2.1)(openapi-types@12.1.3)(rxjs@7.8.2)(zod@4.3.6) + '@mastra/observability': 1.14.0(@mastra/core@1.37.1(@bufbuild/protobuf@2.11.0)(@cfworker/json-schema@4.1.1)(@grpc/grpc-js@1.14.3)(@standard-community/standard-json@0.3.5(@standard-schema/spec@1.1.0)(@types/json-schema@7.0.15)(quansync@0.2.11)(zod-to-json-schema@3.25.1(zod@4.3.6))(zod@4.3.6))(@standard-community/standard-openapi@0.2.9(@standard-community/standard-json@0.3.5(@standard-schema/spec@1.1.0)(@types/json-schema@7.0.15)(quansync@0.2.11)(zod-to-json-schema@3.25.1(zod@4.3.6))(zod@4.3.6))(@standard-schema/spec@1.1.0)(openapi-types@12.1.3)(zod@4.3.6))(@types/json-schema@7.0.15)(express@5.2.1)(openapi-types@12.1.3)(rxjs@7.8.2)(zod@4.3.6))(zod@4.3.6) + '@opentelemetry/api': 1.9.1 + '@opentelemetry/api-logs': 0.218.0 + '@opentelemetry/core': 2.7.1(@opentelemetry/api@1.9.1) + '@opentelemetry/resources': 2.7.1(@opentelemetry/api@1.9.1) + '@opentelemetry/sdk-logs': 0.218.0(@opentelemetry/api@1.9.1) + '@opentelemetry/sdk-trace-base': 2.7.1(@opentelemetry/api@1.9.1) + '@opentelemetry/sdk-trace-node': 2.7.1(@opentelemetry/api@1.9.1) + '@opentelemetry/semantic-conventions': 1.41.1 + optionalDependencies: + '@grpc/grpc-js': 1.14.3 + '@opentelemetry/exporter-logs-otlp-grpc': 0.218.0(@opentelemetry/api@1.9.1) + '@opentelemetry/exporter-logs-otlp-http': 0.218.0(@opentelemetry/api@1.9.1) + '@opentelemetry/exporter-logs-otlp-proto': 0.218.0(@opentelemetry/api@1.9.1) + '@opentelemetry/exporter-trace-otlp-grpc': 0.218.0(@opentelemetry/api@1.9.1) + '@opentelemetry/exporter-trace-otlp-http': 0.218.0(@opentelemetry/api@1.9.1) + '@opentelemetry/exporter-trace-otlp-proto': 0.218.0(@opentelemetry/api@1.9.1) + '@opentelemetry/exporter-zipkin': 2.7.1(@opentelemetry/api@1.9.1) + transitivePeerDependencies: + - zod - '@lancedb/lancedb-linux-arm64-gnu@0.4.20': - optional: true + '@mastra/schema-compat@1.2.10(zod@4.3.6)': + dependencies: + json-schema-to-zod: 2.8.1 + zod: 4.3.6 + zod-from-json-schema: 0.5.2 + zod-from-json-schema-v3: zod-from-json-schema@0.0.5 + zod-to-json-schema: 3.25.1(zod@4.3.6) - '@lancedb/lancedb-linux-x64-gnu@0.4.20': - optional: true + '@mistralai/mistralai@1.13.0': + dependencies: + zod: 3.25.76 + zod-to-json-schema: 3.25.1(zod@3.25.76) - '@lancedb/lancedb-win32-x64-msvc@0.4.20': - optional: true + '@mixmark-io/domino@2.2.0': {} - '@lancedb/lancedb@0.4.20(ws@8.21.0)(zod@3.25.76)': + '@modelcontextprotocol/sdk@1.25.3(@cfworker/json-schema@4.1.1)(hono@4.12.23)(zod@3.24.4)': dependencies: - apache-arrow: 15.0.2 - openai: 4.98.0(ws@8.21.0)(zod@3.25.76) + '@hono/node-server': 1.19.9(hono@4.12.23) + ajv: 8.17.1 + ajv-formats: 3.0.1(ajv@8.17.1) + content-type: 1.0.5 + cors: 2.8.6 + cross-spawn: 7.0.6 + eventsource: 3.0.7 + eventsource-parser: 3.0.6 + express: 5.2.1 + express-rate-limit: 7.5.1(express@5.2.1) + jose: 6.1.3 + json-schema-typed: 8.0.2 + pkce-challenge: 5.0.1 + raw-body: 3.0.2 + zod: 3.24.4 + zod-to-json-schema: 3.25.1(zod@3.24.4) optionalDependencies: - '@lancedb/lancedb-darwin-arm64': 0.4.20 - '@lancedb/lancedb-darwin-x64': 0.4.20 - '@lancedb/lancedb-linux-arm64-gnu': 0.4.20 - '@lancedb/lancedb-linux-x64-gnu': 0.4.20 - '@lancedb/lancedb-win32-x64-msvc': 0.4.20 + '@cfworker/json-schema': 4.1.1 transitivePeerDependencies: - - encoding - - ws - - zod + - hono + - supports-color - '@langchain/community@0.0.57(@aws-crypto/sha256-js@5.2.0)(@aws-sdk/client-bedrock-runtime@3.975.0)(@aws-sdk/credential-provider-node@3.972.1)(@huggingface/inference@2.8.1)(@pinecone-database/pinecone@4.1.0)(@qdrant/js-client-rest@1.16.2(typescript@5.8.3))(@smithy/util-utf8@2.3.0)(@zilliz/milvus2-sdk-node@2.6.9)(chromadb@1.10.5(cohere-ai@7.20.0)(ollama@0.5.18)(openai@4.98.0(ws@8.21.0)(zod@3.24.4)))(cohere-ai@7.20.0)(duck-duck-scrape@2.2.7)(html-to-text@9.0.5)(lodash@4.17.23)(mongodb@6.21.0(@aws-sdk/credential-providers@3.975.0))(openai@4.98.0(ws@8.21.0)(zod@3.24.4))(pg@8.17.2)(redis@4.7.1)(ws@8.21.0)': + '@modelcontextprotocol/sdk@1.25.3(@cfworker/json-schema@4.1.1)(zod@4.3.6)': dependencies: - '@langchain/core': 0.1.63(openai@4.98.0(ws@8.21.0)(zod@3.24.4)) - '@langchain/openai': 0.0.34(ws@8.21.0) - expr-eval: 2.0.2 - flat: 5.0.2 - langsmith: 0.1.68(openai@4.98.0(ws@8.21.0)(zod@3.24.4)) - uuid: 9.0.1 - zod: 3.25.76 - zod-to-json-schema: 3.25.1(zod@3.25.76) + '@hono/node-server': 1.19.9 + ajv: 8.17.1 + ajv-formats: 3.0.1(ajv@8.17.1) + content-type: 1.0.5 + cors: 2.8.6 + cross-spawn: 7.0.6 + eventsource: 3.0.7 + eventsource-parser: 3.0.6 + express: 5.2.1 + express-rate-limit: 7.5.1(express@5.2.1) + jose: 6.1.3 + json-schema-typed: 8.0.2 + pkce-challenge: 5.0.1 + raw-body: 3.0.2 + zod: 4.3.6 + zod-to-json-schema: 3.25.1(zod@4.3.6) optionalDependencies: - '@aws-crypto/sha256-js': 5.2.0 - '@aws-sdk/client-bedrock-runtime': 3.975.0 - '@aws-sdk/credential-provider-node': 3.972.1 - '@huggingface/inference': 2.8.1 - '@pinecone-database/pinecone': 4.1.0 - '@qdrant/js-client-rest': 1.16.2(typescript@5.8.3) - '@smithy/util-utf8': 2.3.0 - '@zilliz/milvus2-sdk-node': 2.6.9 - chromadb: 1.10.5(cohere-ai@7.20.0)(ollama@0.5.18)(openai@4.98.0(ws@8.21.0)(zod@3.24.4)) - cohere-ai: 7.20.0 - duck-duck-scrape: 2.2.7 - html-to-text: 9.0.5 - lodash: 4.17.23 - mongodb: 6.21.0(@aws-sdk/credential-providers@3.975.0) - pg: 8.17.2 - redis: 4.7.1 - ws: 8.21.0 + '@cfworker/json-schema': 4.1.1 transitivePeerDependencies: - - encoding - - openai + - hono + - supports-color - '@langchain/core@0.1.63(openai@4.98.0(ws@8.21.0)(zod@3.24.4))': + '@modelcontextprotocol/sdk@1.26.0(@cfworker/json-schema@4.1.1)(zod@4.3.6)': dependencies: - ansi-styles: 5.2.0 - camelcase: 6.3.0 - decamelize: 1.2.0 - js-tiktoken: 1.0.20 - langsmith: 0.1.68(openai@4.98.0(ws@8.21.0)(zod@3.24.4)) - ml-distance: 4.0.1 - mustache: 4.2.0 - p-queue: 6.6.2 - p-retry: 4.6.2 - uuid: 9.0.1 - zod: 3.25.76 - zod-to-json-schema: 3.25.1(zod@3.25.76) + '@hono/node-server': 1.19.9(hono@4.11.5) + ajv: 8.17.1 + ajv-formats: 3.0.1(ajv@8.17.1) + content-type: 1.0.5 + cors: 2.8.6 + cross-spawn: 7.0.6 + eventsource: 3.0.7 + eventsource-parser: 3.0.6 + express: 5.2.1 + express-rate-limit: 8.2.1(express@5.2.1) + hono: 4.11.5 + jose: 6.1.3 + json-schema-typed: 8.0.2 + pkce-challenge: 5.0.1 + raw-body: 3.0.2 + zod: 4.3.6 + zod-to-json-schema: 3.25.1(zod@4.3.6) + optionalDependencies: + '@cfworker/json-schema': 4.1.1 transitivePeerDependencies: - - openai + - supports-color + optional: true - '@langchain/core@0.2.36(openai@4.104.0(ws@8.21.0)(zod@3.25.76))': + '@modelcontextprotocol/sdk@1.29.0(@cfworker/json-schema@4.1.1)(zod@4.3.6)': dependencies: - ansi-styles: 5.2.0 - camelcase: 6.3.0 - decamelize: 1.2.0 - js-tiktoken: 1.0.20 - langsmith: 0.1.68(openai@4.104.0(ws@8.21.0)(zod@3.25.76)) - mustache: 4.2.0 - p-queue: 6.6.2 - p-retry: 4.6.2 - uuid: 10.0.0 - zod: 3.25.76 - zod-to-json-schema: 3.25.1(zod@3.25.76) + '@hono/node-server': 1.19.9(hono@4.12.23) + ajv: 8.20.0 + ajv-formats: 3.0.1(ajv@8.20.0) + content-type: 1.0.5 + cors: 2.8.6 + cross-spawn: 7.0.6 + eventsource: 3.0.7 + eventsource-parser: 3.0.6 + express: 5.2.1 + express-rate-limit: 8.2.1(express@5.2.1) + hono: 4.12.23 + jose: 6.1.3 + json-schema-typed: 8.0.2 + pkce-challenge: 5.0.1 + raw-body: 3.0.2 + zod: 4.3.6 + zod-to-json-schema: 3.25.1(zod@4.3.6) + optionalDependencies: + '@cfworker/json-schema': 4.1.1 transitivePeerDependencies: - - openai + - supports-color - '@langchain/core@0.2.36(openai@4.98.0(ws@8.21.0)(zod@3.24.4))': + '@mongodb-js/saslprep@1.4.5': dependencies: - ansi-styles: 5.2.0 - camelcase: 6.3.0 - decamelize: 1.2.0 - js-tiktoken: 1.0.20 - langsmith: 0.1.68(openai@4.98.0(ws@8.21.0)(zod@3.24.4)) - mustache: 4.2.0 - p-queue: 6.6.2 - p-retry: 4.6.2 - uuid: 10.0.0 - zod: 3.25.76 - zod-to-json-schema: 3.25.1(zod@3.25.76) - transitivePeerDependencies: - - openai + sparse-bitfield: 3.0.3 - '@langchain/core@0.2.36(openai@6.22.0(ws@8.21.0)(zod@4.3.6))': + '@nodelib/fs.scandir@2.1.5': dependencies: - ansi-styles: 5.2.0 - camelcase: 6.3.0 - decamelize: 1.2.0 - js-tiktoken: 1.0.20 - langsmith: 0.1.68(openai@6.22.0(ws@8.21.0)(zod@4.3.6)) - mustache: 4.2.0 - p-queue: 6.6.2 - p-retry: 4.6.2 - uuid: 10.0.0 - zod: 3.25.76 - zod-to-json-schema: 3.25.1(zod@3.25.76) - transitivePeerDependencies: - - openai - optional: true + '@nodelib/fs.stat': 2.0.5 + run-parallel: 1.2.0 - '@langchain/core@0.3.56(openai@4.98.0(ws@8.21.0)(zod@3.24.4))': + '@nodelib/fs.stat@2.0.5': {} + + '@nodelib/fs.walk@1.2.8': dependencies: - '@cfworker/json-schema': 4.1.1 - ansi-styles: 5.2.0 - camelcase: 6.3.0 - decamelize: 1.2.0 - js-tiktoken: 1.0.20 - langsmith: 0.3.29(openai@4.98.0(ws@8.21.0)(zod@3.24.4)) - mustache: 4.2.0 - p-queue: 6.6.2 - p-retry: 4.6.2 - uuid: 10.0.0 - zod: 3.24.4 - zod-to-json-schema: 3.24.5(zod@3.24.4) + '@nodelib/fs.scandir': 2.1.5 + fastq: 1.20.1 + + '@openai/agents-core@0.4.15(@cfworker/json-schema@4.1.1)(ws@8.19.0)(zod@4.3.6)': + dependencies: + debug: 4.4.3 + openai: 6.22.0(ws@8.19.0)(zod@4.3.6) + optionalDependencies: + '@modelcontextprotocol/sdk': 1.26.0(@cfworker/json-schema@4.1.1)(zod@4.3.6) + zod: 4.3.6 transitivePeerDependencies: - - openai + - '@cfworker/json-schema' + - supports-color + - ws - '@langchain/openai@0.0.34(ws@8.21.0)': + '@openai/agents-core@0.4.15(@cfworker/json-schema@4.1.1)(ws@8.21.0)(zod@4.3.6)': dependencies: - '@langchain/core': 0.2.36(openai@4.104.0(ws@8.21.0)(zod@3.25.76)) - js-tiktoken: 1.0.20 - openai: 4.104.0(ws@8.21.0)(zod@3.25.76) - zod: 3.25.76 - zod-to-json-schema: 3.25.1(zod@3.25.76) + debug: 4.4.3 + openai: 6.22.0(ws@8.21.0)(zod@4.3.6) + optionalDependencies: + '@modelcontextprotocol/sdk': 1.26.0(@cfworker/json-schema@4.1.1)(zod@4.3.6) + zod: 4.3.6 + transitivePeerDependencies: + - '@cfworker/json-schema' + - supports-color + - ws + + '@openai/agents-openai@0.4.15(@cfworker/json-schema@4.1.1)(ws@8.21.0)(zod@4.3.6)': + dependencies: + '@openai/agents-core': 0.4.15(@cfworker/json-schema@4.1.1)(ws@8.21.0)(zod@4.3.6) + debug: 4.4.3 + openai: 6.22.0(ws@8.21.0)(zod@4.3.6) + zod: 4.3.6 transitivePeerDependencies: - - encoding + - '@cfworker/json-schema' + - supports-color - ws - '@langchain/openai@0.2.11(ws@8.21.0)': + '@openai/agents-realtime@0.4.15(@cfworker/json-schema@4.1.1)(zod@4.3.6)': dependencies: - '@langchain/core': 0.2.36(openai@4.104.0(ws@8.21.0)(zod@3.25.76)) - js-tiktoken: 1.0.20 - openai: 4.104.0(ws@8.21.0)(zod@3.25.76) - zod: 3.25.76 - zod-to-json-schema: 3.25.1(zod@3.25.76) + '@openai/agents-core': 0.4.15(@cfworker/json-schema@4.1.1)(ws@8.19.0)(zod@4.3.6) + '@types/ws': 8.18.1 + debug: 4.4.3 + ws: 8.19.0 + zod: 4.3.6 transitivePeerDependencies: - - encoding - - ws + - '@cfworker/json-schema' + - bufferutil + - supports-color + - utf-8-validate - '@langchain/openai@0.3.16(@langchain/core@0.3.56(openai@4.98.0(ws@8.21.0)(zod@3.24.4)))(ws@8.21.0)': + '@openai/agents@0.4.15(@cfworker/json-schema@4.1.1)(ws@8.21.0)(zod@4.3.6)': dependencies: - '@langchain/core': 0.3.56(openai@4.98.0(ws@8.21.0)(zod@3.24.4)) - js-tiktoken: 1.0.20 - openai: 4.104.0(ws@8.21.0)(zod@3.25.76) - zod: 3.25.76 - zod-to-json-schema: 3.25.1(zod@3.25.76) + '@openai/agents-core': 0.4.15(@cfworker/json-schema@4.1.1)(ws@8.21.0)(zod@4.3.6) + '@openai/agents-openai': 0.4.15(@cfworker/json-schema@4.1.1)(ws@8.21.0)(zod@4.3.6) + '@openai/agents-realtime': 0.4.15(@cfworker/json-schema@4.1.1)(zod@4.3.6) + debug: 4.4.3 + openai: 6.22.0(ws@8.21.0)(zod@4.3.6) + zod: 4.3.6 transitivePeerDependencies: - - encoding + - '@cfworker/json-schema' + - bufferutil + - supports-color + - utf-8-validate - ws - '@langchain/textsplitters@0.0.3(openai@4.98.0(ws@8.21.0)(zod@3.24.4))': + '@opentelemetry/api-logs@0.201.1': dependencies: - '@langchain/core': 0.2.36(openai@4.98.0(ws@8.21.0)(zod@3.24.4)) - js-tiktoken: 1.0.20 - transitivePeerDependencies: - - openai + '@opentelemetry/api': 1.9.0 - '@langchain/textsplitters@0.1.0(@langchain/core@0.3.56(openai@4.98.0(ws@8.21.0)(zod@3.24.4)))': + '@opentelemetry/api-logs@0.202.0': dependencies: - '@langchain/core': 0.3.56(openai@4.98.0(ws@8.21.0)(zod@3.24.4)) - js-tiktoken: 1.0.20 + '@opentelemetry/api': 1.9.0 - '@livekit/mutex@1.1.1': {} + '@opentelemetry/api-logs@0.205.0': + dependencies: + '@opentelemetry/api': 1.9.0 - '@livekit/protocol@1.44.0': + '@opentelemetry/api-logs@0.218.0': dependencies: - '@bufbuild/protobuf': 1.10.1 + '@opentelemetry/api': 1.9.1 - '@livekit/rtc-node-darwin-arm64@0.5.1': - optional: true + '@opentelemetry/api-logs@0.50.0': + dependencies: + '@opentelemetry/api': 1.9.0 - '@livekit/rtc-node-darwin-x64@0.5.1': - optional: true + '@opentelemetry/api-logs@0.52.1': + dependencies: + '@opentelemetry/api': 1.9.1 - '@livekit/rtc-node-linux-arm64-gnu@0.5.1': - optional: true + '@opentelemetry/api-logs@0.56.0': + dependencies: + '@opentelemetry/api': 1.9.0 - '@livekit/rtc-node-linux-x64-gnu@0.5.1': - optional: true + '@opentelemetry/api-logs@0.57.2': + dependencies: + '@opentelemetry/api': 1.9.0 - '@livekit/rtc-node-win32-x64-msvc@0.5.1': + '@opentelemetry/api@1.9.0': {} + + '@opentelemetry/api@1.9.1': {} + + '@opentelemetry/auto-instrumentations-node@0.49.2(@opentelemetry/api@1.9.1)': + dependencies: + '@opentelemetry/api': 1.9.1 + '@opentelemetry/instrumentation': 0.52.1(@opentelemetry/api@1.9.1) + '@opentelemetry/instrumentation-amqplib': 0.41.0(@opentelemetry/api@1.9.1) + '@opentelemetry/instrumentation-aws-lambda': 0.43.0(@opentelemetry/api@1.9.1) + '@opentelemetry/instrumentation-aws-sdk': 0.43.1(@opentelemetry/api@1.9.1) + '@opentelemetry/instrumentation-bunyan': 0.40.0(@opentelemetry/api@1.9.1) + '@opentelemetry/instrumentation-cassandra-driver': 0.40.0(@opentelemetry/api@1.9.1) + '@opentelemetry/instrumentation-connect': 0.38.0(@opentelemetry/api@1.9.1) + '@opentelemetry/instrumentation-cucumber': 0.8.0(@opentelemetry/api@1.9.1) + '@opentelemetry/instrumentation-dataloader': 0.11.0(@opentelemetry/api@1.9.1) + '@opentelemetry/instrumentation-dns': 0.38.0(@opentelemetry/api@1.9.1) + '@opentelemetry/instrumentation-express': 0.41.1(@opentelemetry/api@1.9.1) + '@opentelemetry/instrumentation-fastify': 0.38.0(@opentelemetry/api@1.9.1) + '@opentelemetry/instrumentation-fs': 0.14.0(@opentelemetry/api@1.9.1) + '@opentelemetry/instrumentation-generic-pool': 0.38.1(@opentelemetry/api@1.9.1) + '@opentelemetry/instrumentation-graphql': 0.42.0(@opentelemetry/api@1.9.1) + '@opentelemetry/instrumentation-grpc': 0.52.1(@opentelemetry/api@1.9.1) + '@opentelemetry/instrumentation-hapi': 0.40.0(@opentelemetry/api@1.9.1) + '@opentelemetry/instrumentation-http': 0.52.1(@opentelemetry/api@1.9.1) + '@opentelemetry/instrumentation-ioredis': 0.42.0(@opentelemetry/api@1.9.1) + '@opentelemetry/instrumentation-kafkajs': 0.2.0(@opentelemetry/api@1.9.1) + '@opentelemetry/instrumentation-knex': 0.39.0(@opentelemetry/api@1.9.1) + '@opentelemetry/instrumentation-koa': 0.42.0(@opentelemetry/api@1.9.1) + '@opentelemetry/instrumentation-lru-memoizer': 0.39.0(@opentelemetry/api@1.9.1) + '@opentelemetry/instrumentation-memcached': 0.38.0(@opentelemetry/api@1.9.1) + '@opentelemetry/instrumentation-mongodb': 0.46.0(@opentelemetry/api@1.9.1) + '@opentelemetry/instrumentation-mongoose': 0.41.0(@opentelemetry/api@1.9.1) + '@opentelemetry/instrumentation-mysql': 0.40.0(@opentelemetry/api@1.9.1) + '@opentelemetry/instrumentation-mysql2': 0.40.0(@opentelemetry/api@1.9.1) + '@opentelemetry/instrumentation-nestjs-core': 0.39.0(@opentelemetry/api@1.9.1) + '@opentelemetry/instrumentation-net': 0.38.0(@opentelemetry/api@1.9.1) + '@opentelemetry/instrumentation-pg': 0.43.0(@opentelemetry/api@1.9.1) + '@opentelemetry/instrumentation-pino': 0.41.0(@opentelemetry/api@1.9.1) + '@opentelemetry/instrumentation-redis': 0.41.0(@opentelemetry/api@1.9.1) + '@opentelemetry/instrumentation-redis-4': 0.41.1(@opentelemetry/api@1.9.1) + '@opentelemetry/instrumentation-restify': 0.40.0(@opentelemetry/api@1.9.1) + '@opentelemetry/instrumentation-router': 0.39.0(@opentelemetry/api@1.9.1) + '@opentelemetry/instrumentation-socket.io': 0.41.0(@opentelemetry/api@1.9.1) + '@opentelemetry/instrumentation-tedious': 0.13.0(@opentelemetry/api@1.9.1) + '@opentelemetry/instrumentation-undici': 0.5.0(@opentelemetry/api@1.9.1) + '@opentelemetry/instrumentation-winston': 0.39.0(@opentelemetry/api@1.9.1) + '@opentelemetry/resource-detector-alibaba-cloud': 0.29.7(@opentelemetry/api@1.9.1) + '@opentelemetry/resource-detector-aws': 1.12.0(@opentelemetry/api@1.9.1) + '@opentelemetry/resource-detector-azure': 0.2.12(@opentelemetry/api@1.9.1) + '@opentelemetry/resource-detector-container': 0.4.4(@opentelemetry/api@1.9.1) + '@opentelemetry/resource-detector-gcp': 0.29.13(@opentelemetry/api@1.9.1) + '@opentelemetry/resources': 1.30.1(@opentelemetry/api@1.9.1) + '@opentelemetry/sdk-node': 0.52.1(@opentelemetry/api@1.9.1) + transitivePeerDependencies: + - encoding + - supports-color optional: true - '@livekit/rtc-node@0.5.1': + '@opentelemetry/context-async-hooks@1.25.1(@opentelemetry/api@1.9.1)': dependencies: - '@bufbuild/protobuf': 1.10.1 - typed-emitter: 2.1.0 - optionalDependencies: - '@livekit/rtc-node-darwin-arm64': 0.5.1 - '@livekit/rtc-node-darwin-x64': 0.5.1 - '@livekit/rtc-node-linux-arm64-gnu': 0.5.1 - '@livekit/rtc-node-linux-x64-gnu': 0.5.1 - '@livekit/rtc-node-win32-x64-msvc': 0.5.1 + '@opentelemetry/api': 1.9.1 - '@llamaindex/core@0.6.22': + '@opentelemetry/context-async-hooks@1.30.1(@opentelemetry/api@1.9.0)': dependencies: - '@finom/zod-to-json-schema': 3.24.11(zod@4.3.6) - '@llamaindex/env': 0.1.30 - '@types/node': 24.10.9 - magic-bytes.js: 1.13.0 - zod: 4.3.6 - transitivePeerDependencies: - - '@huggingface/transformers' - - gpt-tokenizer + '@opentelemetry/api': 1.9.0 - '@llamaindex/env@0.1.30': + '@opentelemetry/context-async-hooks@2.0.1(@opentelemetry/api@1.9.0)': dependencies: - '@aws-crypto/sha256-js': 5.2.0 - js-tiktoken: 1.0.20 - pathe: 1.1.2 + '@opentelemetry/api': 1.9.0 - '@llamaindex/node-parser@2.0.22(@llamaindex/core@0.6.22)(@llamaindex/env@0.1.30)(tree-sitter@0.22.4)(web-tree-sitter@0.24.7)': + '@opentelemetry/context-async-hooks@2.7.1(@opentelemetry/api@1.9.1)': dependencies: - '@llamaindex/core': 0.6.22 - '@llamaindex/env': 0.1.30 - html-to-text: 9.0.5 - tree-sitter: 0.22.4 - web-tree-sitter: 0.24.7 + '@opentelemetry/api': 1.9.1 - '@llamaindex/openai@0.4.22(@llamaindex/core@0.6.22)(@llamaindex/env@0.1.30)(ws@8.21.0)(zod@4.3.6)': + '@opentelemetry/core@1.23.0(@opentelemetry/api@1.9.0)': dependencies: - '@llamaindex/core': 0.6.22 - '@llamaindex/env': 0.1.30 - openai: 5.23.2(ws@8.21.0)(zod@4.3.6) - transitivePeerDependencies: - - ws - - zod + '@opentelemetry/api': 1.9.0 + '@opentelemetry/semantic-conventions': 1.23.0 - '@llamaindex/workflow-core@1.3.3(@modelcontextprotocol/sdk@1.29.0(@cfworker/json-schema@4.1.1)(zod@4.3.6))(hono@4.12.23)(rxjs@7.8.2)(zod@4.3.6)': - optionalDependencies: - '@modelcontextprotocol/sdk': 1.29.0(@cfworker/json-schema@4.1.1)(zod@4.3.6) - hono: 4.12.23 - rxjs: 7.8.2 - zod: 4.3.6 + '@opentelemetry/core@1.25.1(@opentelemetry/api@1.9.1)': + dependencies: + '@opentelemetry/api': 1.9.1 + '@opentelemetry/semantic-conventions': 1.25.1 - '@llamaindex/workflow@1.1.24(@llamaindex/core@0.6.22)(@llamaindex/env@0.1.30)(@modelcontextprotocol/sdk@1.29.0(@cfworker/json-schema@4.1.1)(zod@4.3.6))(hono@4.12.23)(rxjs@7.8.2)(zod@4.3.6)': + '@opentelemetry/core@1.30.1(@opentelemetry/api@1.9.0)': dependencies: - '@llamaindex/core': 0.6.22 - '@llamaindex/env': 0.1.30 - '@llamaindex/workflow-core': 1.3.3(@modelcontextprotocol/sdk@1.29.0(@cfworker/json-schema@4.1.1)(zod@4.3.6))(hono@4.12.23)(rxjs@7.8.2)(zod@4.3.6) - transitivePeerDependencies: - - '@modelcontextprotocol/sdk' - - hono - - next - - p-retry - - rxjs - - zod + '@opentelemetry/api': 1.9.0 + '@opentelemetry/semantic-conventions': 1.28.0 - '@lukeed/csprng@1.1.0': {} + '@opentelemetry/core@1.30.1(@opentelemetry/api@1.9.1)': + dependencies: + '@opentelemetry/api': 1.9.1 + '@opentelemetry/semantic-conventions': 1.28.0 + optional: true - '@lukeed/uuid@2.0.1': + '@opentelemetry/core@2.0.1(@opentelemetry/api@1.9.0)': dependencies: - '@lukeed/csprng': 1.1.0 + '@opentelemetry/api': 1.9.0 + '@opentelemetry/semantic-conventions': 1.34.0 - '@mastra/core@1.37.1(@bufbuild/protobuf@2.11.0)(@cfworker/json-schema@4.1.1)(@grpc/grpc-js@1.14.3)(@standard-community/standard-json@0.3.5(@standard-schema/spec@1.1.0)(@types/json-schema@7.0.15)(quansync@0.2.11)(zod-to-json-schema@3.25.1(zod@4.3.6))(zod@4.3.6))(@standard-community/standard-openapi@0.2.9(@standard-community/standard-json@0.3.5(@standard-schema/spec@1.1.0)(@types/json-schema@7.0.15)(quansync@0.2.11)(zod-to-json-schema@3.25.1(zod@4.3.6))(zod@4.3.6))(@standard-schema/spec@1.1.0)(openapi-types@12.1.3)(zod@4.3.6))(@types/json-schema@7.0.15)(express@5.2.1)(openapi-types@12.1.3)(rxjs@7.8.2)(zod@4.3.6)': + '@opentelemetry/core@2.1.0(@opentelemetry/api@1.9.0)': dependencies: - '@a2a-js/sdk': 0.3.13(@bufbuild/protobuf@2.11.0)(@grpc/grpc-js@1.14.3)(express@5.2.1) - '@ai-sdk/provider-utils-v5': '@ai-sdk/provider-utils@3.0.25(zod@4.3.6)' - '@ai-sdk/provider-utils-v6': '@ai-sdk/provider-utils@4.0.27(zod@4.3.6)' - '@ai-sdk/provider-v5': '@ai-sdk/provider@2.0.3' - '@ai-sdk/provider-v6': '@ai-sdk/provider@3.0.10' - '@ai-sdk/ui-utils-v5': '@ai-sdk/ui-utils@1.2.11(zod@4.3.6)' - '@isaacs/ttlcache': 2.1.5 - '@lukeed/uuid': 2.0.1 - '@mastra/schema-compat': 1.2.10(zod@4.3.6) - '@modelcontextprotocol/sdk': 1.29.0(@cfworker/json-schema@4.1.1)(zod@4.3.6) - '@sindresorhus/slugify': 2.2.1 - '@standard-schema/spec': 1.1.0 - ajv: 8.20.0 - chat: 4.30.0(zod@4.3.6) - croner: 10.0.1 - dotenv: 17.4.2 - execa: 9.6.1 - fastq: 1.20.1 - gray-matter: 4.0.3 - hono: 4.12.23 - hono-openapi: 1.3.0(@standard-community/standard-json@0.3.5(@standard-schema/spec@1.1.0)(@types/json-schema@7.0.15)(quansync@0.2.11)(zod-to-json-schema@3.25.1(zod@4.3.6))(zod@4.3.6))(@standard-community/standard-openapi@0.2.9(@standard-community/standard-json@0.3.5(@standard-schema/spec@1.1.0)(@types/json-schema@7.0.15)(quansync@0.2.11)(zod-to-json-schema@3.25.1(zod@4.3.6))(zod@4.3.6))(@standard-schema/spec@1.1.0)(openapi-types@12.1.3)(zod@4.3.6))(@types/json-schema@7.0.15)(hono@4.12.23)(openapi-types@12.1.3) - ignore: 7.0.5 - json-schema: 0.4.0 - lru-cache: 11.5.1 - p-map: 7.0.4 - p-retry: 7.1.1 - picomatch: 4.0.3 - posthog-node: 5.35.11(rxjs@7.8.2) - tokenx: 1.3.0 - ws: 8.21.0 - xxhash-wasm: 1.1.0 - zod: 4.3.6 - transitivePeerDependencies: - - '@bufbuild/protobuf' - - '@cfworker/json-schema' - - '@grpc/grpc-js' - - '@hono/standard-validator' - - '@standard-community/standard-json' - - '@standard-community/standard-openapi' - - '@types/json-schema' - - ai - - bufferutil - - express - - openapi-types - - rxjs - - supports-color - - utf-8-validate + '@opentelemetry/api': 1.9.0 + '@opentelemetry/semantic-conventions': 1.34.0 - '@mastra/observability@1.14.0(@mastra/core@1.37.1(@bufbuild/protobuf@2.11.0)(@cfworker/json-schema@4.1.1)(@grpc/grpc-js@1.14.3)(@standard-community/standard-json@0.3.5(@standard-schema/spec@1.1.0)(@types/json-schema@7.0.15)(quansync@0.2.11)(zod-to-json-schema@3.25.1(zod@4.3.6))(zod@4.3.6))(@standard-community/standard-openapi@0.2.9(@standard-community/standard-json@0.3.5(@standard-schema/spec@1.1.0)(@types/json-schema@7.0.15)(quansync@0.2.11)(zod-to-json-schema@3.25.1(zod@4.3.6))(zod@4.3.6))(@standard-schema/spec@1.1.0)(openapi-types@12.1.3)(zod@4.3.6))(@types/json-schema@7.0.15)(express@5.2.1)(openapi-types@12.1.3)(rxjs@7.8.2)(zod@4.3.6))(zod@4.3.6)': + '@opentelemetry/core@2.7.1(@opentelemetry/api@1.9.0)': dependencies: - '@mastra/core': 1.37.1(@bufbuild/protobuf@2.11.0)(@cfworker/json-schema@4.1.1)(@grpc/grpc-js@1.14.3)(@standard-community/standard-json@0.3.5(@standard-schema/spec@1.1.0)(@types/json-schema@7.0.15)(quansync@0.2.11)(zod-to-json-schema@3.25.1(zod@4.3.6))(zod@4.3.6))(@standard-community/standard-openapi@0.2.9(@standard-community/standard-json@0.3.5(@standard-schema/spec@1.1.0)(@types/json-schema@7.0.15)(quansync@0.2.11)(zod-to-json-schema@3.25.1(zod@4.3.6))(zod@4.3.6))(@standard-schema/spec@1.1.0)(openapi-types@12.1.3)(zod@4.3.6))(@types/json-schema@7.0.15)(express@5.2.1)(openapi-types@12.1.3)(rxjs@7.8.2)(zod@4.3.6) - zod: 4.3.6 + '@opentelemetry/api': 1.9.0 + '@opentelemetry/semantic-conventions': 1.41.1 + + '@opentelemetry/core@2.7.1(@opentelemetry/api@1.9.1)': + dependencies: + '@opentelemetry/api': 1.9.1 + '@opentelemetry/semantic-conventions': 1.41.1 + + '@opentelemetry/exporter-logs-otlp-grpc@0.218.0(@opentelemetry/api@1.9.1)': + dependencies: + '@grpc/grpc-js': 1.14.3 + '@opentelemetry/api': 1.9.1 + '@opentelemetry/core': 2.7.1(@opentelemetry/api@1.9.1) + '@opentelemetry/otlp-exporter-base': 0.218.0(@opentelemetry/api@1.9.1) + '@opentelemetry/otlp-grpc-exporter-base': 0.218.0(@opentelemetry/api@1.9.1) + '@opentelemetry/otlp-transformer': 0.218.0(@opentelemetry/api@1.9.1) + '@opentelemetry/sdk-logs': 0.218.0(@opentelemetry/api@1.9.1) + optional: true + + '@opentelemetry/exporter-logs-otlp-http@0.218.0(@opentelemetry/api@1.9.0)': + dependencies: + '@opentelemetry/api': 1.9.0 + '@opentelemetry/api-logs': 0.218.0 + '@opentelemetry/core': 2.7.1(@opentelemetry/api@1.9.0) + '@opentelemetry/otlp-exporter-base': 0.218.0(@opentelemetry/api@1.9.0) + '@opentelemetry/otlp-transformer': 0.218.0(@opentelemetry/api@1.9.0) + '@opentelemetry/sdk-logs': 0.218.0(@opentelemetry/api@1.9.0) + + '@opentelemetry/exporter-logs-otlp-http@0.218.0(@opentelemetry/api@1.9.1)': + dependencies: + '@opentelemetry/api': 1.9.1 + '@opentelemetry/api-logs': 0.218.0 + '@opentelemetry/core': 2.7.1(@opentelemetry/api@1.9.1) + '@opentelemetry/otlp-exporter-base': 0.218.0(@opentelemetry/api@1.9.1) + '@opentelemetry/otlp-transformer': 0.218.0(@opentelemetry/api@1.9.1) + '@opentelemetry/sdk-logs': 0.218.0(@opentelemetry/api@1.9.1) + optional: true - '@mastra/otel-exporter@1.2.0(@mastra/core@1.37.1(@bufbuild/protobuf@2.11.0)(@cfworker/json-schema@4.1.1)(@grpc/grpc-js@1.14.3)(@standard-community/standard-json@0.3.5(@standard-schema/spec@1.1.0)(@types/json-schema@7.0.15)(quansync@0.2.11)(zod-to-json-schema@3.25.1(zod@4.3.6))(zod@4.3.6))(@standard-community/standard-openapi@0.2.9(@standard-community/standard-json@0.3.5(@standard-schema/spec@1.1.0)(@types/json-schema@7.0.15)(quansync@0.2.11)(zod-to-json-schema@3.25.1(zod@4.3.6))(zod@4.3.6))(@standard-schema/spec@1.1.0)(openapi-types@12.1.3)(zod@4.3.6))(@types/json-schema@7.0.15)(express@5.2.1)(openapi-types@12.1.3)(rxjs@7.8.2)(zod@4.3.6))(zod@4.3.6)': + '@opentelemetry/exporter-logs-otlp-proto@0.218.0(@opentelemetry/api@1.9.1)': dependencies: - '@mastra/core': 1.37.1(@bufbuild/protobuf@2.11.0)(@cfworker/json-schema@4.1.1)(@grpc/grpc-js@1.14.3)(@standard-community/standard-json@0.3.5(@standard-schema/spec@1.1.0)(@types/json-schema@7.0.15)(quansync@0.2.11)(zod-to-json-schema@3.25.1(zod@4.3.6))(zod@4.3.6))(@standard-community/standard-openapi@0.2.9(@standard-community/standard-json@0.3.5(@standard-schema/spec@1.1.0)(@types/json-schema@7.0.15)(quansync@0.2.11)(zod-to-json-schema@3.25.1(zod@4.3.6))(zod@4.3.6))(@standard-schema/spec@1.1.0)(openapi-types@12.1.3)(zod@4.3.6))(@types/json-schema@7.0.15)(express@5.2.1)(openapi-types@12.1.3)(rxjs@7.8.2)(zod@4.3.6) - '@mastra/observability': 1.14.0(@mastra/core@1.37.1(@bufbuild/protobuf@2.11.0)(@cfworker/json-schema@4.1.1)(@grpc/grpc-js@1.14.3)(@standard-community/standard-json@0.3.5(@standard-schema/spec@1.1.0)(@types/json-schema@7.0.15)(quansync@0.2.11)(zod-to-json-schema@3.25.1(zod@4.3.6))(zod@4.3.6))(@standard-community/standard-openapi@0.2.9(@standard-community/standard-json@0.3.5(@standard-schema/spec@1.1.0)(@types/json-schema@7.0.15)(quansync@0.2.11)(zod-to-json-schema@3.25.1(zod@4.3.6))(zod@4.3.6))(@standard-schema/spec@1.1.0)(openapi-types@12.1.3)(zod@4.3.6))(@types/json-schema@7.0.15)(express@5.2.1)(openapi-types@12.1.3)(rxjs@7.8.2)(zod@4.3.6))(zod@4.3.6) '@opentelemetry/api': 1.9.1 '@opentelemetry/api-logs': 0.218.0 '@opentelemetry/core': 2.7.1(@opentelemetry/api@1.9.1) + '@opentelemetry/otlp-exporter-base': 0.218.0(@opentelemetry/api@1.9.1) + '@opentelemetry/otlp-transformer': 0.218.0(@opentelemetry/api@1.9.1) '@opentelemetry/resources': 2.7.1(@opentelemetry/api@1.9.1) '@opentelemetry/sdk-logs': 0.218.0(@opentelemetry/api@1.9.1) '@opentelemetry/sdk-trace-base': 2.7.1(@opentelemetry/api@1.9.1) - '@opentelemetry/sdk-trace-node': 2.7.1(@opentelemetry/api@1.9.1) - '@opentelemetry/semantic-conventions': 1.41.1 - optionalDependencies: + optional: true + + '@opentelemetry/exporter-metrics-otlp-http@0.205.0(@opentelemetry/api@1.9.0)': + dependencies: + '@opentelemetry/api': 1.9.0 + '@opentelemetry/core': 2.1.0(@opentelemetry/api@1.9.0) + '@opentelemetry/otlp-exporter-base': 0.205.0(@opentelemetry/api@1.9.0) + '@opentelemetry/otlp-transformer': 0.205.0(@opentelemetry/api@1.9.0) + '@opentelemetry/resources': 2.1.0(@opentelemetry/api@1.9.0) + '@opentelemetry/sdk-metrics': 2.1.0(@opentelemetry/api@1.9.0) + + '@opentelemetry/exporter-trace-otlp-grpc@0.202.0(@opentelemetry/api@1.9.0)': + dependencies: '@grpc/grpc-js': 1.14.3 - '@opentelemetry/exporter-logs-otlp-grpc': 0.218.0(@opentelemetry/api@1.9.1) - '@opentelemetry/exporter-logs-otlp-http': 0.218.0(@opentelemetry/api@1.9.1) - '@opentelemetry/exporter-logs-otlp-proto': 0.218.0(@opentelemetry/api@1.9.1) - '@opentelemetry/exporter-trace-otlp-grpc': 0.218.0(@opentelemetry/api@1.9.1) - '@opentelemetry/exporter-trace-otlp-http': 0.218.0(@opentelemetry/api@1.9.1) - '@opentelemetry/exporter-trace-otlp-proto': 0.218.0(@opentelemetry/api@1.9.1) - '@opentelemetry/exporter-zipkin': 2.7.1(@opentelemetry/api@1.9.1) - transitivePeerDependencies: - - zod + '@opentelemetry/api': 1.9.0 + '@opentelemetry/core': 2.0.1(@opentelemetry/api@1.9.0) + '@opentelemetry/otlp-exporter-base': 0.202.0(@opentelemetry/api@1.9.0) + '@opentelemetry/otlp-grpc-exporter-base': 0.202.0(@opentelemetry/api@1.9.0) + '@opentelemetry/otlp-transformer': 0.202.0(@opentelemetry/api@1.9.0) + '@opentelemetry/resources': 2.0.1(@opentelemetry/api@1.9.0) + '@opentelemetry/sdk-trace-base': 2.0.1(@opentelemetry/api@1.9.0) - '@mastra/schema-compat@1.2.10(zod@4.3.6)': + '@opentelemetry/exporter-trace-otlp-grpc@0.218.0(@opentelemetry/api@1.9.1)': dependencies: - json-schema-to-zod: 2.8.1 - zod: 4.3.6 - zod-from-json-schema: 0.5.2 - zod-from-json-schema-v3: zod-from-json-schema@0.0.5 - zod-to-json-schema: 3.25.1(zod@4.3.6) + '@grpc/grpc-js': 1.14.3 + '@opentelemetry/api': 1.9.1 + '@opentelemetry/core': 2.7.1(@opentelemetry/api@1.9.1) + '@opentelemetry/otlp-exporter-base': 0.218.0(@opentelemetry/api@1.9.1) + '@opentelemetry/otlp-grpc-exporter-base': 0.218.0(@opentelemetry/api@1.9.1) + '@opentelemetry/otlp-transformer': 0.218.0(@opentelemetry/api@1.9.1) + '@opentelemetry/resources': 2.7.1(@opentelemetry/api@1.9.1) + '@opentelemetry/sdk-trace-base': 2.7.1(@opentelemetry/api@1.9.1) + optional: true - '@mistralai/mistralai@1.13.0': + '@opentelemetry/exporter-trace-otlp-grpc@0.52.1(@opentelemetry/api@1.9.1)': dependencies: - zod: 3.25.76 - zod-to-json-schema: 3.25.1(zod@3.25.76) + '@grpc/grpc-js': 1.14.3 + '@opentelemetry/api': 1.9.1 + '@opentelemetry/core': 1.25.1(@opentelemetry/api@1.9.1) + '@opentelemetry/otlp-grpc-exporter-base': 0.52.1(@opentelemetry/api@1.9.1) + '@opentelemetry/otlp-transformer': 0.52.1(@opentelemetry/api@1.9.1) + '@opentelemetry/resources': 1.25.1(@opentelemetry/api@1.9.1) + '@opentelemetry/sdk-trace-base': 1.25.1(@opentelemetry/api@1.9.1) - '@mixmark-io/domino@2.2.0': {} + '@opentelemetry/exporter-trace-otlp-http@0.202.0(@opentelemetry/api@1.9.0)': + dependencies: + '@opentelemetry/api': 1.9.0 + '@opentelemetry/core': 2.0.1(@opentelemetry/api@1.9.0) + '@opentelemetry/otlp-exporter-base': 0.202.0(@opentelemetry/api@1.9.0) + '@opentelemetry/otlp-transformer': 0.202.0(@opentelemetry/api@1.9.0) + '@opentelemetry/resources': 2.0.1(@opentelemetry/api@1.9.0) + '@opentelemetry/sdk-trace-base': 2.0.1(@opentelemetry/api@1.9.0) - '@modelcontextprotocol/sdk@1.25.3(@cfworker/json-schema@4.1.1)(hono@4.12.23)(zod@3.24.4)': + '@opentelemetry/exporter-trace-otlp-http@0.218.0(@opentelemetry/api@1.9.0)': dependencies: - '@hono/node-server': 1.19.9(hono@4.12.23) - ajv: 8.17.1 - ajv-formats: 3.0.1(ajv@8.17.1) - content-type: 1.0.5 - cors: 2.8.6 - cross-spawn: 7.0.6 - eventsource: 3.0.7 - eventsource-parser: 3.0.6 - express: 5.2.1 - express-rate-limit: 7.5.1(express@5.2.1) - jose: 6.1.3 - json-schema-typed: 8.0.2 - pkce-challenge: 5.0.1 - raw-body: 3.0.2 - zod: 3.24.4 - zod-to-json-schema: 3.25.1(zod@3.24.4) - optionalDependencies: - '@cfworker/json-schema': 4.1.1 - transitivePeerDependencies: - - hono - - supports-color + '@opentelemetry/api': 1.9.0 + '@opentelemetry/core': 2.7.1(@opentelemetry/api@1.9.0) + '@opentelemetry/otlp-exporter-base': 0.218.0(@opentelemetry/api@1.9.0) + '@opentelemetry/otlp-transformer': 0.218.0(@opentelemetry/api@1.9.0) + '@opentelemetry/resources': 2.7.1(@opentelemetry/api@1.9.0) + '@opentelemetry/sdk-trace-base': 2.7.1(@opentelemetry/api@1.9.0) - '@modelcontextprotocol/sdk@1.25.3(@cfworker/json-schema@4.1.1)(zod@4.3.6)': + '@opentelemetry/exporter-trace-otlp-http@0.218.0(@opentelemetry/api@1.9.1)': dependencies: - '@hono/node-server': 1.19.9 - ajv: 8.17.1 - ajv-formats: 3.0.1(ajv@8.17.1) - content-type: 1.0.5 - cors: 2.8.6 - cross-spawn: 7.0.6 - eventsource: 3.0.7 - eventsource-parser: 3.0.6 - express: 5.2.1 - express-rate-limit: 7.5.1(express@5.2.1) - jose: 6.1.3 - json-schema-typed: 8.0.2 - pkce-challenge: 5.0.1 - raw-body: 3.0.2 - zod: 4.3.6 - zod-to-json-schema: 3.25.1(zod@4.3.6) - optionalDependencies: - '@cfworker/json-schema': 4.1.1 - transitivePeerDependencies: - - hono - - supports-color + '@opentelemetry/api': 1.9.1 + '@opentelemetry/core': 2.7.1(@opentelemetry/api@1.9.1) + '@opentelemetry/otlp-exporter-base': 0.218.0(@opentelemetry/api@1.9.1) + '@opentelemetry/otlp-transformer': 0.218.0(@opentelemetry/api@1.9.1) + '@opentelemetry/resources': 2.7.1(@opentelemetry/api@1.9.1) + '@opentelemetry/sdk-trace-base': 2.7.1(@opentelemetry/api@1.9.1) + optional: true - '@modelcontextprotocol/sdk@1.26.0(@cfworker/json-schema@4.1.1)(zod@4.3.6)': + '@opentelemetry/exporter-trace-otlp-http@0.52.1(@opentelemetry/api@1.9.1)': dependencies: - '@hono/node-server': 1.19.9(hono@4.11.5) - ajv: 8.17.1 - ajv-formats: 3.0.1(ajv@8.17.1) - content-type: 1.0.5 - cors: 2.8.6 - cross-spawn: 7.0.6 - eventsource: 3.0.7 - eventsource-parser: 3.0.6 - express: 5.2.1 - express-rate-limit: 8.2.1(express@5.2.1) - hono: 4.11.5 - jose: 6.1.3 - json-schema-typed: 8.0.2 - pkce-challenge: 5.0.1 - raw-body: 3.0.2 - zod: 4.3.6 - zod-to-json-schema: 3.25.1(zod@4.3.6) - optionalDependencies: - '@cfworker/json-schema': 4.1.1 - transitivePeerDependencies: - - supports-color + '@opentelemetry/api': 1.9.1 + '@opentelemetry/core': 1.25.1(@opentelemetry/api@1.9.1) + '@opentelemetry/otlp-exporter-base': 0.52.1(@opentelemetry/api@1.9.1) + '@opentelemetry/otlp-transformer': 0.52.1(@opentelemetry/api@1.9.1) + '@opentelemetry/resources': 1.25.1(@opentelemetry/api@1.9.1) + '@opentelemetry/sdk-trace-base': 1.25.1(@opentelemetry/api@1.9.1) + + '@opentelemetry/exporter-trace-otlp-http@0.57.2(@opentelemetry/api@1.9.0)': + dependencies: + '@opentelemetry/api': 1.9.0 + '@opentelemetry/core': 1.30.1(@opentelemetry/api@1.9.0) + '@opentelemetry/otlp-exporter-base': 0.57.2(@opentelemetry/api@1.9.0) + '@opentelemetry/otlp-transformer': 0.57.2(@opentelemetry/api@1.9.0) + '@opentelemetry/resources': 1.30.1(@opentelemetry/api@1.9.0) + '@opentelemetry/sdk-trace-base': 1.30.1(@opentelemetry/api@1.9.0) + + '@opentelemetry/exporter-trace-otlp-proto@0.201.1(@opentelemetry/api@1.9.0)': + dependencies: + '@opentelemetry/api': 1.9.0 + '@opentelemetry/core': 2.0.1(@opentelemetry/api@1.9.0) + '@opentelemetry/otlp-exporter-base': 0.201.1(@opentelemetry/api@1.9.0) + '@opentelemetry/otlp-transformer': 0.201.1(@opentelemetry/api@1.9.0) + '@opentelemetry/resources': 2.0.1(@opentelemetry/api@1.9.0) + '@opentelemetry/sdk-trace-base': 2.0.1(@opentelemetry/api@1.9.0) + + '@opentelemetry/exporter-trace-otlp-proto@0.218.0(@opentelemetry/api@1.9.1)': + dependencies: + '@opentelemetry/api': 1.9.1 + '@opentelemetry/core': 2.7.1(@opentelemetry/api@1.9.1) + '@opentelemetry/otlp-exporter-base': 0.218.0(@opentelemetry/api@1.9.1) + '@opentelemetry/otlp-transformer': 0.218.0(@opentelemetry/api@1.9.1) + '@opentelemetry/resources': 2.7.1(@opentelemetry/api@1.9.1) + '@opentelemetry/sdk-trace-base': 2.7.1(@opentelemetry/api@1.9.1) optional: true - '@modelcontextprotocol/sdk@1.29.0(@cfworker/json-schema@4.1.1)(zod@4.3.6)': + '@opentelemetry/exporter-trace-otlp-proto@0.50.0(@opentelemetry/api@1.9.0)': dependencies: - '@hono/node-server': 1.19.9(hono@4.12.23) - ajv: 8.20.0 - ajv-formats: 3.0.1(ajv@8.20.0) - content-type: 1.0.5 - cors: 2.8.6 - cross-spawn: 7.0.6 - eventsource: 3.0.7 - eventsource-parser: 3.0.6 - express: 5.2.1 - express-rate-limit: 8.2.1(express@5.2.1) - hono: 4.12.23 - jose: 6.1.3 - json-schema-typed: 8.0.2 - pkce-challenge: 5.0.1 - raw-body: 3.0.2 - zod: 4.3.6 - zod-to-json-schema: 3.25.1(zod@4.3.6) - optionalDependencies: - '@cfworker/json-schema': 4.1.1 - transitivePeerDependencies: - - supports-color + '@opentelemetry/api': 1.9.0 + '@opentelemetry/core': 1.23.0(@opentelemetry/api@1.9.0) + '@opentelemetry/otlp-exporter-base': 0.50.0(@opentelemetry/api@1.9.0) + '@opentelemetry/otlp-proto-exporter-base': 0.50.0(@opentelemetry/api@1.9.0) + '@opentelemetry/otlp-transformer': 0.50.0(@opentelemetry/api@1.9.0) + '@opentelemetry/resources': 1.23.0(@opentelemetry/api@1.9.0) + '@opentelemetry/sdk-trace-base': 1.23.0(@opentelemetry/api@1.9.0) - '@mongodb-js/saslprep@1.4.5': + '@opentelemetry/exporter-trace-otlp-proto@0.52.1(@opentelemetry/api@1.9.1)': dependencies: - sparse-bitfield: 3.0.3 + '@opentelemetry/api': 1.9.1 + '@opentelemetry/core': 1.25.1(@opentelemetry/api@1.9.1) + '@opentelemetry/otlp-exporter-base': 0.52.1(@opentelemetry/api@1.9.1) + '@opentelemetry/otlp-transformer': 0.52.1(@opentelemetry/api@1.9.1) + '@opentelemetry/resources': 1.25.1(@opentelemetry/api@1.9.1) + '@opentelemetry/sdk-trace-base': 1.25.1(@opentelemetry/api@1.9.1) - '@nodelib/fs.scandir@2.1.5': + '@opentelemetry/exporter-zipkin@1.25.1(@opentelemetry/api@1.9.1)': dependencies: - '@nodelib/fs.stat': 2.0.5 - run-parallel: 1.2.0 + '@opentelemetry/api': 1.9.1 + '@opentelemetry/core': 1.25.1(@opentelemetry/api@1.9.1) + '@opentelemetry/resources': 1.25.1(@opentelemetry/api@1.9.1) + '@opentelemetry/sdk-trace-base': 1.25.1(@opentelemetry/api@1.9.1) + '@opentelemetry/semantic-conventions': 1.25.1 - '@nodelib/fs.stat@2.0.5': {} + '@opentelemetry/exporter-zipkin@2.7.1(@opentelemetry/api@1.9.1)': + dependencies: + '@opentelemetry/api': 1.9.1 + '@opentelemetry/core': 2.7.1(@opentelemetry/api@1.9.1) + '@opentelemetry/resources': 2.7.1(@opentelemetry/api@1.9.1) + '@opentelemetry/sdk-trace-base': 2.7.1(@opentelemetry/api@1.9.1) + '@opentelemetry/semantic-conventions': 1.41.1 + optional: true - '@nodelib/fs.walk@1.2.8': + '@opentelemetry/instrumentation-amqplib@0.41.0(@opentelemetry/api@1.9.1)': dependencies: - '@nodelib/fs.scandir': 2.1.5 - fastq: 1.20.1 + '@opentelemetry/api': 1.9.1 + '@opentelemetry/core': 1.30.1(@opentelemetry/api@1.9.1) + '@opentelemetry/instrumentation': 0.52.1(@opentelemetry/api@1.9.1) + '@opentelemetry/semantic-conventions': 1.41.1 + transitivePeerDependencies: + - supports-color + optional: true - '@openai/agents-core@0.4.15(@cfworker/json-schema@4.1.1)(ws@8.19.0)(zod@4.3.6)': + '@opentelemetry/instrumentation-aws-lambda@0.43.0(@opentelemetry/api@1.9.1)': dependencies: - debug: 4.4.3 - openai: 6.22.0(ws@8.19.0)(zod@4.3.6) - optionalDependencies: - '@modelcontextprotocol/sdk': 1.26.0(@cfworker/json-schema@4.1.1)(zod@4.3.6) - zod: 4.3.6 + '@opentelemetry/api': 1.9.1 + '@opentelemetry/instrumentation': 0.52.1(@opentelemetry/api@1.9.1) + '@opentelemetry/propagator-aws-xray': 1.26.2(@opentelemetry/api@1.9.1) + '@opentelemetry/resources': 1.30.1(@opentelemetry/api@1.9.1) + '@opentelemetry/semantic-conventions': 1.41.1 + '@types/aws-lambda': 8.10.122 transitivePeerDependencies: - - '@cfworker/json-schema' - supports-color - - ws + optional: true - '@openai/agents-core@0.4.15(@cfworker/json-schema@4.1.1)(ws@8.21.0)(zod@4.3.6)': + '@opentelemetry/instrumentation-aws-sdk@0.43.1(@opentelemetry/api@1.9.1)': dependencies: - debug: 4.4.3 - openai: 6.22.0(ws@8.21.0)(zod@4.3.6) - optionalDependencies: - '@modelcontextprotocol/sdk': 1.26.0(@cfworker/json-schema@4.1.1)(zod@4.3.6) - zod: 4.3.6 + '@opentelemetry/api': 1.9.1 + '@opentelemetry/core': 1.30.1(@opentelemetry/api@1.9.1) + '@opentelemetry/instrumentation': 0.52.1(@opentelemetry/api@1.9.1) + '@opentelemetry/propagation-utils': 0.30.16(@opentelemetry/api@1.9.1) + '@opentelemetry/semantic-conventions': 1.41.1 transitivePeerDependencies: - - '@cfworker/json-schema' - supports-color - - ws + optional: true - '@openai/agents-openai@0.4.15(@cfworker/json-schema@4.1.1)(ws@8.21.0)(zod@4.3.6)': + '@opentelemetry/instrumentation-bunyan@0.40.0(@opentelemetry/api@1.9.1)': dependencies: - '@openai/agents-core': 0.4.15(@cfworker/json-schema@4.1.1)(ws@8.21.0)(zod@4.3.6) - debug: 4.4.3 - openai: 6.22.0(ws@8.21.0)(zod@4.3.6) - zod: 4.3.6 + '@opentelemetry/api': 1.9.1 + '@opentelemetry/api-logs': 0.52.1 + '@opentelemetry/instrumentation': 0.52.1(@opentelemetry/api@1.9.1) + '@types/bunyan': 1.8.9 transitivePeerDependencies: - - '@cfworker/json-schema' - supports-color - - ws + optional: true - '@openai/agents-realtime@0.4.15(@cfworker/json-schema@4.1.1)(zod@4.3.6)': + '@opentelemetry/instrumentation-cassandra-driver@0.40.0(@opentelemetry/api@1.9.1)': dependencies: - '@openai/agents-core': 0.4.15(@cfworker/json-schema@4.1.1)(ws@8.19.0)(zod@4.3.6) - '@types/ws': 8.18.1 - debug: 4.4.3 - ws: 8.19.0 - zod: 4.3.6 + '@opentelemetry/api': 1.9.1 + '@opentelemetry/instrumentation': 0.52.1(@opentelemetry/api@1.9.1) + '@opentelemetry/semantic-conventions': 1.41.1 transitivePeerDependencies: - - '@cfworker/json-schema' - - bufferutil - supports-color - - utf-8-validate + optional: true - '@openai/agents@0.4.15(@cfworker/json-schema@4.1.1)(ws@8.21.0)(zod@4.3.6)': + '@opentelemetry/instrumentation-connect@0.38.0(@opentelemetry/api@1.9.1)': dependencies: - '@openai/agents-core': 0.4.15(@cfworker/json-schema@4.1.1)(ws@8.21.0)(zod@4.3.6) - '@openai/agents-openai': 0.4.15(@cfworker/json-schema@4.1.1)(ws@8.21.0)(zod@4.3.6) - '@openai/agents-realtime': 0.4.15(@cfworker/json-schema@4.1.1)(zod@4.3.6) - debug: 4.4.3 - openai: 6.22.0(ws@8.21.0)(zod@4.3.6) - zod: 4.3.6 + '@opentelemetry/api': 1.9.1 + '@opentelemetry/core': 1.30.1(@opentelemetry/api@1.9.1) + '@opentelemetry/instrumentation': 0.52.1(@opentelemetry/api@1.9.1) + '@opentelemetry/semantic-conventions': 1.41.1 + '@types/connect': 3.4.36 transitivePeerDependencies: - - '@cfworker/json-schema' - - bufferutil - supports-color - - utf-8-validate - - ws + optional: true - '@opentelemetry/api-logs@0.201.1': + '@opentelemetry/instrumentation-cucumber@0.8.0(@opentelemetry/api@1.9.1)': dependencies: - '@opentelemetry/api': 1.9.0 + '@opentelemetry/api': 1.9.1 + '@opentelemetry/instrumentation': 0.52.1(@opentelemetry/api@1.9.1) + '@opentelemetry/semantic-conventions': 1.41.1 + transitivePeerDependencies: + - supports-color + optional: true - '@opentelemetry/api-logs@0.202.0': + '@opentelemetry/instrumentation-dataloader@0.11.0(@opentelemetry/api@1.9.1)': dependencies: - '@opentelemetry/api': 1.9.0 + '@opentelemetry/api': 1.9.1 + '@opentelemetry/instrumentation': 0.52.1(@opentelemetry/api@1.9.1) + transitivePeerDependencies: + - supports-color + optional: true - '@opentelemetry/api-logs@0.205.0': + '@opentelemetry/instrumentation-dns@0.38.0(@opentelemetry/api@1.9.1)': dependencies: - '@opentelemetry/api': 1.9.0 + '@opentelemetry/api': 1.9.1 + '@opentelemetry/instrumentation': 0.52.1(@opentelemetry/api@1.9.1) + semver: 7.7.3 + transitivePeerDependencies: + - supports-color + optional: true - '@opentelemetry/api-logs@0.218.0': + '@opentelemetry/instrumentation-express@0.41.1(@opentelemetry/api@1.9.1)': dependencies: '@opentelemetry/api': 1.9.1 + '@opentelemetry/core': 1.30.1(@opentelemetry/api@1.9.1) + '@opentelemetry/instrumentation': 0.52.1(@opentelemetry/api@1.9.1) + '@opentelemetry/semantic-conventions': 1.41.1 + transitivePeerDependencies: + - supports-color + optional: true - '@opentelemetry/api-logs@0.50.0': + '@opentelemetry/instrumentation-fastify@0.38.0(@opentelemetry/api@1.9.1)': dependencies: - '@opentelemetry/api': 1.9.0 + '@opentelemetry/api': 1.9.1 + '@opentelemetry/core': 1.30.1(@opentelemetry/api@1.9.1) + '@opentelemetry/instrumentation': 0.52.1(@opentelemetry/api@1.9.1) + '@opentelemetry/semantic-conventions': 1.41.1 + transitivePeerDependencies: + - supports-color + optional: true - '@opentelemetry/api-logs@0.56.0': + '@opentelemetry/instrumentation-fs@0.14.0(@opentelemetry/api@1.9.1)': dependencies: - '@opentelemetry/api': 1.9.0 + '@opentelemetry/api': 1.9.1 + '@opentelemetry/core': 1.30.1(@opentelemetry/api@1.9.1) + '@opentelemetry/instrumentation': 0.52.1(@opentelemetry/api@1.9.1) + transitivePeerDependencies: + - supports-color + optional: true - '@opentelemetry/api-logs@0.57.2': + '@opentelemetry/instrumentation-generic-pool@0.38.1(@opentelemetry/api@1.9.1)': dependencies: - '@opentelemetry/api': 1.9.0 + '@opentelemetry/api': 1.9.1 + '@opentelemetry/instrumentation': 0.52.1(@opentelemetry/api@1.9.1) + transitivePeerDependencies: + - supports-color + optional: true - '@opentelemetry/api@1.9.0': {} + '@opentelemetry/instrumentation-graphql@0.42.0(@opentelemetry/api@1.9.1)': + dependencies: + '@opentelemetry/api': 1.9.1 + '@opentelemetry/instrumentation': 0.52.1(@opentelemetry/api@1.9.1) + transitivePeerDependencies: + - supports-color + optional: true - '@opentelemetry/api@1.9.1': {} + '@opentelemetry/instrumentation-grpc@0.52.1(@opentelemetry/api@1.9.1)': + dependencies: + '@opentelemetry/api': 1.9.1 + '@opentelemetry/instrumentation': 0.52.1(@opentelemetry/api@1.9.1) + '@opentelemetry/semantic-conventions': 1.25.1 + transitivePeerDependencies: + - supports-color + optional: true - '@opentelemetry/context-async-hooks@1.30.1(@opentelemetry/api@1.9.0)': + '@opentelemetry/instrumentation-hapi@0.40.0(@opentelemetry/api@1.9.1)': dependencies: - '@opentelemetry/api': 1.9.0 + '@opentelemetry/api': 1.9.1 + '@opentelemetry/core': 1.30.1(@opentelemetry/api@1.9.1) + '@opentelemetry/instrumentation': 0.52.1(@opentelemetry/api@1.9.1) + '@opentelemetry/semantic-conventions': 1.41.1 + transitivePeerDependencies: + - supports-color + optional: true - '@opentelemetry/context-async-hooks@2.0.1(@opentelemetry/api@1.9.0)': + '@opentelemetry/instrumentation-http@0.52.1(@opentelemetry/api@1.9.1)': dependencies: - '@opentelemetry/api': 1.9.0 + '@opentelemetry/api': 1.9.1 + '@opentelemetry/core': 1.25.1(@opentelemetry/api@1.9.1) + '@opentelemetry/instrumentation': 0.52.1(@opentelemetry/api@1.9.1) + '@opentelemetry/semantic-conventions': 1.25.1 + semver: 7.7.3 + transitivePeerDependencies: + - supports-color + optional: true - '@opentelemetry/context-async-hooks@2.7.1(@opentelemetry/api@1.9.1)': + '@opentelemetry/instrumentation-ioredis@0.42.0(@opentelemetry/api@1.9.1)': dependencies: '@opentelemetry/api': 1.9.1 + '@opentelemetry/instrumentation': 0.52.1(@opentelemetry/api@1.9.1) + '@opentelemetry/redis-common': 0.36.2 + '@opentelemetry/semantic-conventions': 1.41.1 + transitivePeerDependencies: + - supports-color + optional: true - '@opentelemetry/core@1.23.0(@opentelemetry/api@1.9.0)': + '@opentelemetry/instrumentation-kafkajs@0.2.0(@opentelemetry/api@1.9.1)': dependencies: - '@opentelemetry/api': 1.9.0 - '@opentelemetry/semantic-conventions': 1.23.0 + '@opentelemetry/api': 1.9.1 + '@opentelemetry/instrumentation': 0.52.1(@opentelemetry/api@1.9.1) + '@opentelemetry/semantic-conventions': 1.41.1 + transitivePeerDependencies: + - supports-color + optional: true - '@opentelemetry/core@1.30.1(@opentelemetry/api@1.9.0)': + '@opentelemetry/instrumentation-knex@0.39.0(@opentelemetry/api@1.9.1)': dependencies: - '@opentelemetry/api': 1.9.0 - '@opentelemetry/semantic-conventions': 1.28.0 + '@opentelemetry/api': 1.9.1 + '@opentelemetry/instrumentation': 0.52.1(@opentelemetry/api@1.9.1) + '@opentelemetry/semantic-conventions': 1.41.1 + transitivePeerDependencies: + - supports-color + optional: true - '@opentelemetry/core@2.0.1(@opentelemetry/api@1.9.0)': + '@opentelemetry/instrumentation-koa@0.42.0(@opentelemetry/api@1.9.1)': dependencies: - '@opentelemetry/api': 1.9.0 - '@opentelemetry/semantic-conventions': 1.34.0 + '@opentelemetry/api': 1.9.1 + '@opentelemetry/core': 1.30.1(@opentelemetry/api@1.9.1) + '@opentelemetry/instrumentation': 0.52.1(@opentelemetry/api@1.9.1) + '@opentelemetry/semantic-conventions': 1.41.1 + transitivePeerDependencies: + - supports-color + optional: true - '@opentelemetry/core@2.1.0(@opentelemetry/api@1.9.0)': + '@opentelemetry/instrumentation-lru-memoizer@0.39.0(@opentelemetry/api@1.9.1)': dependencies: - '@opentelemetry/api': 1.9.0 - '@opentelemetry/semantic-conventions': 1.34.0 + '@opentelemetry/api': 1.9.1 + '@opentelemetry/instrumentation': 0.52.1(@opentelemetry/api@1.9.1) + transitivePeerDependencies: + - supports-color + optional: true - '@opentelemetry/core@2.7.1(@opentelemetry/api@1.9.0)': + '@opentelemetry/instrumentation-memcached@0.38.0(@opentelemetry/api@1.9.1)': dependencies: - '@opentelemetry/api': 1.9.0 + '@opentelemetry/api': 1.9.1 + '@opentelemetry/instrumentation': 0.52.1(@opentelemetry/api@1.9.1) '@opentelemetry/semantic-conventions': 1.41.1 + '@types/memcached': 2.2.10 + transitivePeerDependencies: + - supports-color + optional: true - '@opentelemetry/core@2.7.1(@opentelemetry/api@1.9.1)': + '@opentelemetry/instrumentation-mongodb@0.46.0(@opentelemetry/api@1.9.1)': dependencies: '@opentelemetry/api': 1.9.1 + '@opentelemetry/instrumentation': 0.52.1(@opentelemetry/api@1.9.1) + '@opentelemetry/sdk-metrics': 1.30.1(@opentelemetry/api@1.9.1) '@opentelemetry/semantic-conventions': 1.41.1 + transitivePeerDependencies: + - supports-color + optional: true - '@opentelemetry/exporter-logs-otlp-grpc@0.218.0(@opentelemetry/api@1.9.1)': + '@opentelemetry/instrumentation-mongoose@0.41.0(@opentelemetry/api@1.9.1)': dependencies: - '@grpc/grpc-js': 1.14.3 '@opentelemetry/api': 1.9.1 - '@opentelemetry/core': 2.7.1(@opentelemetry/api@1.9.1) - '@opentelemetry/otlp-exporter-base': 0.218.0(@opentelemetry/api@1.9.1) - '@opentelemetry/otlp-grpc-exporter-base': 0.218.0(@opentelemetry/api@1.9.1) - '@opentelemetry/otlp-transformer': 0.218.0(@opentelemetry/api@1.9.1) - '@opentelemetry/sdk-logs': 0.218.0(@opentelemetry/api@1.9.1) + '@opentelemetry/core': 1.30.1(@opentelemetry/api@1.9.1) + '@opentelemetry/instrumentation': 0.52.1(@opentelemetry/api@1.9.1) + '@opentelemetry/semantic-conventions': 1.41.1 + transitivePeerDependencies: + - supports-color optional: true - '@opentelemetry/exporter-logs-otlp-http@0.218.0(@opentelemetry/api@1.9.0)': + '@opentelemetry/instrumentation-mysql2@0.40.0(@opentelemetry/api@1.9.1)': dependencies: - '@opentelemetry/api': 1.9.0 - '@opentelemetry/api-logs': 0.218.0 - '@opentelemetry/core': 2.7.1(@opentelemetry/api@1.9.0) - '@opentelemetry/otlp-exporter-base': 0.218.0(@opentelemetry/api@1.9.0) - '@opentelemetry/otlp-transformer': 0.218.0(@opentelemetry/api@1.9.0) - '@opentelemetry/sdk-logs': 0.218.0(@opentelemetry/api@1.9.0) + '@opentelemetry/api': 1.9.1 + '@opentelemetry/instrumentation': 0.52.1(@opentelemetry/api@1.9.1) + '@opentelemetry/semantic-conventions': 1.41.1 + '@opentelemetry/sql-common': 0.40.1(@opentelemetry/api@1.9.1) + transitivePeerDependencies: + - supports-color + optional: true - '@opentelemetry/exporter-logs-otlp-http@0.218.0(@opentelemetry/api@1.9.1)': + '@opentelemetry/instrumentation-mysql@0.40.0(@opentelemetry/api@1.9.1)': dependencies: '@opentelemetry/api': 1.9.1 - '@opentelemetry/api-logs': 0.218.0 - '@opentelemetry/core': 2.7.1(@opentelemetry/api@1.9.1) - '@opentelemetry/otlp-exporter-base': 0.218.0(@opentelemetry/api@1.9.1) - '@opentelemetry/otlp-transformer': 0.218.0(@opentelemetry/api@1.9.1) - '@opentelemetry/sdk-logs': 0.218.0(@opentelemetry/api@1.9.1) + '@opentelemetry/instrumentation': 0.52.1(@opentelemetry/api@1.9.1) + '@opentelemetry/semantic-conventions': 1.41.1 + '@types/mysql': 2.15.22 + transitivePeerDependencies: + - supports-color optional: true - '@opentelemetry/exporter-logs-otlp-proto@0.218.0(@opentelemetry/api@1.9.1)': + '@opentelemetry/instrumentation-nestjs-core@0.39.0(@opentelemetry/api@1.9.1)': dependencies: '@opentelemetry/api': 1.9.1 - '@opentelemetry/api-logs': 0.218.0 - '@opentelemetry/core': 2.7.1(@opentelemetry/api@1.9.1) - '@opentelemetry/otlp-exporter-base': 0.218.0(@opentelemetry/api@1.9.1) - '@opentelemetry/otlp-transformer': 0.218.0(@opentelemetry/api@1.9.1) - '@opentelemetry/resources': 2.7.1(@opentelemetry/api@1.9.1) - '@opentelemetry/sdk-logs': 0.218.0(@opentelemetry/api@1.9.1) - '@opentelemetry/sdk-trace-base': 2.7.1(@opentelemetry/api@1.9.1) + '@opentelemetry/instrumentation': 0.52.1(@opentelemetry/api@1.9.1) + '@opentelemetry/semantic-conventions': 1.41.1 + transitivePeerDependencies: + - supports-color optional: true - '@opentelemetry/exporter-metrics-otlp-http@0.205.0(@opentelemetry/api@1.9.0)': + '@opentelemetry/instrumentation-net@0.38.0(@opentelemetry/api@1.9.1)': dependencies: - '@opentelemetry/api': 1.9.0 - '@opentelemetry/core': 2.1.0(@opentelemetry/api@1.9.0) - '@opentelemetry/otlp-exporter-base': 0.205.0(@opentelemetry/api@1.9.0) - '@opentelemetry/otlp-transformer': 0.205.0(@opentelemetry/api@1.9.0) - '@opentelemetry/resources': 2.1.0(@opentelemetry/api@1.9.0) - '@opentelemetry/sdk-metrics': 2.1.0(@opentelemetry/api@1.9.0) + '@opentelemetry/api': 1.9.1 + '@opentelemetry/instrumentation': 0.52.1(@opentelemetry/api@1.9.1) + '@opentelemetry/semantic-conventions': 1.41.1 + transitivePeerDependencies: + - supports-color + optional: true - '@opentelemetry/exporter-trace-otlp-grpc@0.202.0(@opentelemetry/api@1.9.0)': + '@opentelemetry/instrumentation-pg@0.43.0(@opentelemetry/api@1.9.1)': dependencies: - '@grpc/grpc-js': 1.14.3 - '@opentelemetry/api': 1.9.0 - '@opentelemetry/core': 2.0.1(@opentelemetry/api@1.9.0) - '@opentelemetry/otlp-exporter-base': 0.202.0(@opentelemetry/api@1.9.0) - '@opentelemetry/otlp-grpc-exporter-base': 0.202.0(@opentelemetry/api@1.9.0) - '@opentelemetry/otlp-transformer': 0.202.0(@opentelemetry/api@1.9.0) - '@opentelemetry/resources': 2.0.1(@opentelemetry/api@1.9.0) - '@opentelemetry/sdk-trace-base': 2.0.1(@opentelemetry/api@1.9.0) + '@opentelemetry/api': 1.9.1 + '@opentelemetry/instrumentation': 0.52.1(@opentelemetry/api@1.9.1) + '@opentelemetry/semantic-conventions': 1.41.1 + '@opentelemetry/sql-common': 0.40.1(@opentelemetry/api@1.9.1) + '@types/pg': 8.6.1 + '@types/pg-pool': 2.0.4 + transitivePeerDependencies: + - supports-color + optional: true - '@opentelemetry/exporter-trace-otlp-grpc@0.218.0(@opentelemetry/api@1.9.1)': + '@opentelemetry/instrumentation-pino@0.41.0(@opentelemetry/api@1.9.1)': dependencies: - '@grpc/grpc-js': 1.14.3 '@opentelemetry/api': 1.9.1 - '@opentelemetry/core': 2.7.1(@opentelemetry/api@1.9.1) - '@opentelemetry/otlp-exporter-base': 0.218.0(@opentelemetry/api@1.9.1) - '@opentelemetry/otlp-grpc-exporter-base': 0.218.0(@opentelemetry/api@1.9.1) - '@opentelemetry/otlp-transformer': 0.218.0(@opentelemetry/api@1.9.1) - '@opentelemetry/resources': 2.7.1(@opentelemetry/api@1.9.1) - '@opentelemetry/sdk-trace-base': 2.7.1(@opentelemetry/api@1.9.1) + '@opentelemetry/api-logs': 0.52.1 + '@opentelemetry/core': 1.30.1(@opentelemetry/api@1.9.1) + '@opentelemetry/instrumentation': 0.52.1(@opentelemetry/api@1.9.1) + transitivePeerDependencies: + - supports-color optional: true - '@opentelemetry/exporter-trace-otlp-http@0.202.0(@opentelemetry/api@1.9.0)': + '@opentelemetry/instrumentation-redis-4@0.41.1(@opentelemetry/api@1.9.1)': dependencies: - '@opentelemetry/api': 1.9.0 - '@opentelemetry/core': 2.0.1(@opentelemetry/api@1.9.0) - '@opentelemetry/otlp-exporter-base': 0.202.0(@opentelemetry/api@1.9.0) - '@opentelemetry/otlp-transformer': 0.202.0(@opentelemetry/api@1.9.0) - '@opentelemetry/resources': 2.0.1(@opentelemetry/api@1.9.0) - '@opentelemetry/sdk-trace-base': 2.0.1(@opentelemetry/api@1.9.0) + '@opentelemetry/api': 1.9.1 + '@opentelemetry/instrumentation': 0.52.1(@opentelemetry/api@1.9.1) + '@opentelemetry/redis-common': 0.36.2 + '@opentelemetry/semantic-conventions': 1.41.1 + transitivePeerDependencies: + - supports-color + optional: true - '@opentelemetry/exporter-trace-otlp-http@0.218.0(@opentelemetry/api@1.9.0)': + '@opentelemetry/instrumentation-redis@0.41.0(@opentelemetry/api@1.9.1)': dependencies: - '@opentelemetry/api': 1.9.0 - '@opentelemetry/core': 2.7.1(@opentelemetry/api@1.9.0) - '@opentelemetry/otlp-exporter-base': 0.218.0(@opentelemetry/api@1.9.0) - '@opentelemetry/otlp-transformer': 0.218.0(@opentelemetry/api@1.9.0) - '@opentelemetry/resources': 2.7.1(@opentelemetry/api@1.9.0) - '@opentelemetry/sdk-trace-base': 2.7.1(@opentelemetry/api@1.9.0) + '@opentelemetry/api': 1.9.1 + '@opentelemetry/instrumentation': 0.52.1(@opentelemetry/api@1.9.1) + '@opentelemetry/redis-common': 0.36.2 + '@opentelemetry/semantic-conventions': 1.41.1 + transitivePeerDependencies: + - supports-color + optional: true - '@opentelemetry/exporter-trace-otlp-http@0.218.0(@opentelemetry/api@1.9.1)': + '@opentelemetry/instrumentation-restify@0.40.0(@opentelemetry/api@1.9.1)': dependencies: '@opentelemetry/api': 1.9.1 - '@opentelemetry/core': 2.7.1(@opentelemetry/api@1.9.1) - '@opentelemetry/otlp-exporter-base': 0.218.0(@opentelemetry/api@1.9.1) - '@opentelemetry/otlp-transformer': 0.218.0(@opentelemetry/api@1.9.1) - '@opentelemetry/resources': 2.7.1(@opentelemetry/api@1.9.1) - '@opentelemetry/sdk-trace-base': 2.7.1(@opentelemetry/api@1.9.1) + '@opentelemetry/core': 1.30.1(@opentelemetry/api@1.9.1) + '@opentelemetry/instrumentation': 0.52.1(@opentelemetry/api@1.9.1) + '@opentelemetry/semantic-conventions': 1.41.1 + transitivePeerDependencies: + - supports-color optional: true - '@opentelemetry/exporter-trace-otlp-http@0.57.2(@opentelemetry/api@1.9.0)': + '@opentelemetry/instrumentation-router@0.39.0(@opentelemetry/api@1.9.1)': dependencies: - '@opentelemetry/api': 1.9.0 - '@opentelemetry/core': 1.30.1(@opentelemetry/api@1.9.0) - '@opentelemetry/otlp-exporter-base': 0.57.2(@opentelemetry/api@1.9.0) - '@opentelemetry/otlp-transformer': 0.57.2(@opentelemetry/api@1.9.0) - '@opentelemetry/resources': 1.30.1(@opentelemetry/api@1.9.0) - '@opentelemetry/sdk-trace-base': 1.30.1(@opentelemetry/api@1.9.0) + '@opentelemetry/api': 1.9.1 + '@opentelemetry/instrumentation': 0.52.1(@opentelemetry/api@1.9.1) + '@opentelemetry/semantic-conventions': 1.41.1 + transitivePeerDependencies: + - supports-color + optional: true - '@opentelemetry/exporter-trace-otlp-proto@0.201.1(@opentelemetry/api@1.9.0)': + '@opentelemetry/instrumentation-socket.io@0.41.0(@opentelemetry/api@1.9.1)': dependencies: - '@opentelemetry/api': 1.9.0 - '@opentelemetry/core': 2.0.1(@opentelemetry/api@1.9.0) - '@opentelemetry/otlp-exporter-base': 0.201.1(@opentelemetry/api@1.9.0) - '@opentelemetry/otlp-transformer': 0.201.1(@opentelemetry/api@1.9.0) - '@opentelemetry/resources': 2.0.1(@opentelemetry/api@1.9.0) - '@opentelemetry/sdk-trace-base': 2.0.1(@opentelemetry/api@1.9.0) + '@opentelemetry/api': 1.9.1 + '@opentelemetry/instrumentation': 0.52.1(@opentelemetry/api@1.9.1) + '@opentelemetry/semantic-conventions': 1.41.1 + transitivePeerDependencies: + - supports-color + optional: true - '@opentelemetry/exporter-trace-otlp-proto@0.218.0(@opentelemetry/api@1.9.1)': + '@opentelemetry/instrumentation-tedious@0.13.0(@opentelemetry/api@1.9.1)': dependencies: '@opentelemetry/api': 1.9.1 - '@opentelemetry/core': 2.7.1(@opentelemetry/api@1.9.1) - '@opentelemetry/otlp-exporter-base': 0.218.0(@opentelemetry/api@1.9.1) - '@opentelemetry/otlp-transformer': 0.218.0(@opentelemetry/api@1.9.1) - '@opentelemetry/resources': 2.7.1(@opentelemetry/api@1.9.1) - '@opentelemetry/sdk-trace-base': 2.7.1(@opentelemetry/api@1.9.1) + '@opentelemetry/instrumentation': 0.52.1(@opentelemetry/api@1.9.1) + '@opentelemetry/semantic-conventions': 1.41.1 + '@types/tedious': 4.0.14 + transitivePeerDependencies: + - supports-color optional: true - '@opentelemetry/exporter-trace-otlp-proto@0.50.0(@opentelemetry/api@1.9.0)': + '@opentelemetry/instrumentation-undici@0.5.0(@opentelemetry/api@1.9.1)': dependencies: - '@opentelemetry/api': 1.9.0 - '@opentelemetry/core': 1.23.0(@opentelemetry/api@1.9.0) - '@opentelemetry/otlp-exporter-base': 0.50.0(@opentelemetry/api@1.9.0) - '@opentelemetry/otlp-proto-exporter-base': 0.50.0(@opentelemetry/api@1.9.0) - '@opentelemetry/otlp-transformer': 0.50.0(@opentelemetry/api@1.9.0) - '@opentelemetry/resources': 1.23.0(@opentelemetry/api@1.9.0) - '@opentelemetry/sdk-trace-base': 1.23.0(@opentelemetry/api@1.9.0) + '@opentelemetry/api': 1.9.1 + '@opentelemetry/core': 1.30.1(@opentelemetry/api@1.9.1) + '@opentelemetry/instrumentation': 0.52.1(@opentelemetry/api@1.9.1) + transitivePeerDependencies: + - supports-color + optional: true - '@opentelemetry/exporter-zipkin@2.7.1(@opentelemetry/api@1.9.1)': + '@opentelemetry/instrumentation-winston@0.39.0(@opentelemetry/api@1.9.1)': dependencies: '@opentelemetry/api': 1.9.1 - '@opentelemetry/core': 2.7.1(@opentelemetry/api@1.9.1) - '@opentelemetry/resources': 2.7.1(@opentelemetry/api@1.9.1) - '@opentelemetry/sdk-trace-base': 2.7.1(@opentelemetry/api@1.9.1) - '@opentelemetry/semantic-conventions': 1.41.1 + '@opentelemetry/api-logs': 0.52.1 + '@opentelemetry/instrumentation': 0.52.1(@opentelemetry/api@1.9.1) + transitivePeerDependencies: + - supports-color optional: true '@opentelemetry/instrumentation@0.202.0(@opentelemetry/api@1.9.0)': @@ -10660,6 +12343,18 @@ snapshots: transitivePeerDependencies: - supports-color + '@opentelemetry/instrumentation@0.52.1(@opentelemetry/api@1.9.1)': + dependencies: + '@opentelemetry/api': 1.9.1 + '@opentelemetry/api-logs': 0.52.1 + '@types/shimmer': 1.2.0 + import-in-the-middle: 1.14.2 + require-in-the-middle: 7.5.2 + semver: 7.7.3 + shimmer: 1.2.1 + transitivePeerDependencies: + - supports-color + '@opentelemetry/instrumentation@0.56.0(@opentelemetry/api@1.9.0)': dependencies: '@opentelemetry/api': 1.9.0 @@ -10720,6 +12415,12 @@ snapshots: '@opentelemetry/api': 1.9.0 '@opentelemetry/core': 1.23.0(@opentelemetry/api@1.9.0) + '@opentelemetry/otlp-exporter-base@0.52.1(@opentelemetry/api@1.9.1)': + dependencies: + '@opentelemetry/api': 1.9.1 + '@opentelemetry/core': 1.25.1(@opentelemetry/api@1.9.1) + '@opentelemetry/otlp-transformer': 0.52.1(@opentelemetry/api@1.9.1) + '@opentelemetry/otlp-exporter-base@0.57.2(@opentelemetry/api@1.9.0)': dependencies: '@opentelemetry/api': 1.9.0 @@ -10743,6 +12444,14 @@ snapshots: '@opentelemetry/otlp-transformer': 0.218.0(@opentelemetry/api@1.9.1) optional: true + '@opentelemetry/otlp-grpc-exporter-base@0.52.1(@opentelemetry/api@1.9.1)': + dependencies: + '@grpc/grpc-js': 1.14.3 + '@opentelemetry/api': 1.9.1 + '@opentelemetry/core': 1.25.1(@opentelemetry/api@1.9.1) + '@opentelemetry/otlp-exporter-base': 0.52.1(@opentelemetry/api@1.9.1) + '@opentelemetry/otlp-transformer': 0.52.1(@opentelemetry/api@1.9.1) + '@opentelemetry/otlp-proto-exporter-base@0.50.0(@opentelemetry/api@1.9.0)': dependencies: '@opentelemetry/api': 1.9.0 @@ -10814,6 +12523,17 @@ snapshots: '@opentelemetry/sdk-metrics': 1.23.0(@opentelemetry/api@1.9.0) '@opentelemetry/sdk-trace-base': 1.23.0(@opentelemetry/api@1.9.0) + '@opentelemetry/otlp-transformer@0.52.1(@opentelemetry/api@1.9.1)': + dependencies: + '@opentelemetry/api': 1.9.1 + '@opentelemetry/api-logs': 0.52.1 + '@opentelemetry/core': 1.25.1(@opentelemetry/api@1.9.1) + '@opentelemetry/resources': 1.25.1(@opentelemetry/api@1.9.1) + '@opentelemetry/sdk-logs': 0.52.1(@opentelemetry/api@1.9.1) + '@opentelemetry/sdk-metrics': 1.25.1(@opentelemetry/api@1.9.1) + '@opentelemetry/sdk-trace-base': 1.25.1(@opentelemetry/api@1.9.1) + protobufjs: 7.5.4 + '@opentelemetry/otlp-transformer@0.57.2(@opentelemetry/api@1.9.0)': dependencies: '@opentelemetry/api': 1.9.0 @@ -10825,16 +12545,83 @@ snapshots: '@opentelemetry/sdk-trace-base': 1.30.1(@opentelemetry/api@1.9.0) protobufjs: 7.5.4 + '@opentelemetry/propagation-utils@0.30.16(@opentelemetry/api@1.9.1)': + dependencies: + '@opentelemetry/api': 1.9.1 + optional: true + + '@opentelemetry/propagator-aws-xray@1.26.2(@opentelemetry/api@1.9.1)': + dependencies: + '@opentelemetry/api': 1.9.1 + optional: true + + '@opentelemetry/propagator-b3@1.25.1(@opentelemetry/api@1.9.1)': + dependencies: + '@opentelemetry/api': 1.9.1 + '@opentelemetry/core': 1.25.1(@opentelemetry/api@1.9.1) + '@opentelemetry/propagator-b3@1.30.1(@opentelemetry/api@1.9.0)': dependencies: '@opentelemetry/api': 1.9.0 '@opentelemetry/core': 1.30.1(@opentelemetry/api@1.9.0) + '@opentelemetry/propagator-jaeger@1.25.1(@opentelemetry/api@1.9.1)': + dependencies: + '@opentelemetry/api': 1.9.1 + '@opentelemetry/core': 1.25.1(@opentelemetry/api@1.9.1) + '@opentelemetry/propagator-jaeger@1.30.1(@opentelemetry/api@1.9.0)': dependencies: '@opentelemetry/api': 1.9.0 '@opentelemetry/core': 1.30.1(@opentelemetry/api@1.9.0) + '@opentelemetry/redis-common@0.36.2': + optional: true + + '@opentelemetry/resource-detector-alibaba-cloud@0.29.7(@opentelemetry/api@1.9.1)': + dependencies: + '@opentelemetry/api': 1.9.1 + '@opentelemetry/core': 1.30.1(@opentelemetry/api@1.9.1) + '@opentelemetry/resources': 1.30.1(@opentelemetry/api@1.9.1) + '@opentelemetry/semantic-conventions': 1.41.1 + optional: true + + '@opentelemetry/resource-detector-aws@1.12.0(@opentelemetry/api@1.9.1)': + dependencies: + '@opentelemetry/api': 1.9.1 + '@opentelemetry/core': 1.30.1(@opentelemetry/api@1.9.1) + '@opentelemetry/resources': 1.30.1(@opentelemetry/api@1.9.1) + '@opentelemetry/semantic-conventions': 1.41.1 + optional: true + + '@opentelemetry/resource-detector-azure@0.2.12(@opentelemetry/api@1.9.1)': + dependencies: + '@opentelemetry/api': 1.9.1 + '@opentelemetry/core': 1.30.1(@opentelemetry/api@1.9.1) + '@opentelemetry/resources': 1.30.1(@opentelemetry/api@1.9.1) + '@opentelemetry/semantic-conventions': 1.41.1 + optional: true + + '@opentelemetry/resource-detector-container@0.4.4(@opentelemetry/api@1.9.1)': + dependencies: + '@opentelemetry/api': 1.9.1 + '@opentelemetry/core': 1.30.1(@opentelemetry/api@1.9.1) + '@opentelemetry/resources': 1.30.1(@opentelemetry/api@1.9.1) + '@opentelemetry/semantic-conventions': 1.41.1 + optional: true + + '@opentelemetry/resource-detector-gcp@0.29.13(@opentelemetry/api@1.9.1)': + dependencies: + '@opentelemetry/api': 1.9.1 + '@opentelemetry/core': 1.30.1(@opentelemetry/api@1.9.1) + '@opentelemetry/resources': 1.30.1(@opentelemetry/api@1.9.1) + '@opentelemetry/semantic-conventions': 1.41.1 + gcp-metadata: 6.1.1 + transitivePeerDependencies: + - encoding + - supports-color + optional: true + '@opentelemetry/resource-detector-gcp@0.40.3(@opentelemetry/api@1.9.0)': dependencies: '@opentelemetry/api': 1.9.0 @@ -10851,12 +12638,25 @@ snapshots: '@opentelemetry/core': 1.23.0(@opentelemetry/api@1.9.0) '@opentelemetry/semantic-conventions': 1.23.0 + '@opentelemetry/resources@1.25.1(@opentelemetry/api@1.9.1)': + dependencies: + '@opentelemetry/api': 1.9.1 + '@opentelemetry/core': 1.25.1(@opentelemetry/api@1.9.1) + '@opentelemetry/semantic-conventions': 1.25.1 + '@opentelemetry/resources@1.30.1(@opentelemetry/api@1.9.0)': dependencies: '@opentelemetry/api': 1.9.0 '@opentelemetry/core': 1.30.1(@opentelemetry/api@1.9.0) '@opentelemetry/semantic-conventions': 1.28.0 + '@opentelemetry/resources@1.30.1(@opentelemetry/api@1.9.1)': + dependencies: + '@opentelemetry/api': 1.9.1 + '@opentelemetry/core': 1.30.1(@opentelemetry/api@1.9.1) + '@opentelemetry/semantic-conventions': 1.28.0 + optional: true + '@opentelemetry/resources@2.0.1(@opentelemetry/api@1.9.0)': dependencies: '@opentelemetry/api': 1.9.0 @@ -10925,6 +12725,13 @@ snapshots: '@opentelemetry/core': 1.23.0(@opentelemetry/api@1.9.0) '@opentelemetry/resources': 1.23.0(@opentelemetry/api@1.9.0) + '@opentelemetry/sdk-logs@0.52.1(@opentelemetry/api@1.9.1)': + dependencies: + '@opentelemetry/api': 1.9.1 + '@opentelemetry/api-logs': 0.52.1 + '@opentelemetry/core': 1.25.1(@opentelemetry/api@1.9.1) + '@opentelemetry/resources': 1.25.1(@opentelemetry/api@1.9.1) + '@opentelemetry/sdk-logs@0.57.2(@opentelemetry/api@1.9.0)': dependencies: '@opentelemetry/api': 1.9.0 @@ -10939,12 +12746,26 @@ snapshots: '@opentelemetry/resources': 1.23.0(@opentelemetry/api@1.9.0) lodash.merge: 4.6.2 + '@opentelemetry/sdk-metrics@1.25.1(@opentelemetry/api@1.9.1)': + dependencies: + '@opentelemetry/api': 1.9.1 + '@opentelemetry/core': 1.25.1(@opentelemetry/api@1.9.1) + '@opentelemetry/resources': 1.25.1(@opentelemetry/api@1.9.1) + lodash.merge: 4.6.2 + '@opentelemetry/sdk-metrics@1.30.1(@opentelemetry/api@1.9.0)': dependencies: '@opentelemetry/api': 1.9.0 '@opentelemetry/core': 1.30.1(@opentelemetry/api@1.9.0) '@opentelemetry/resources': 1.30.1(@opentelemetry/api@1.9.0) + '@opentelemetry/sdk-metrics@1.30.1(@opentelemetry/api@1.9.1)': + dependencies: + '@opentelemetry/api': 1.9.1 + '@opentelemetry/core': 1.30.1(@opentelemetry/api@1.9.1) + '@opentelemetry/resources': 1.30.1(@opentelemetry/api@1.9.1) + optional: true + '@opentelemetry/sdk-metrics@2.0.1(@opentelemetry/api@1.9.0)': dependencies: '@opentelemetry/api': 1.9.0 @@ -10970,6 +12791,25 @@ snapshots: '@opentelemetry/resources': 2.7.1(@opentelemetry/api@1.9.1) optional: true + '@opentelemetry/sdk-node@0.52.1(@opentelemetry/api@1.9.1)': + dependencies: + '@opentelemetry/api': 1.9.1 + '@opentelemetry/api-logs': 0.52.1 + '@opentelemetry/core': 1.25.1(@opentelemetry/api@1.9.1) + '@opentelemetry/exporter-trace-otlp-grpc': 0.52.1(@opentelemetry/api@1.9.1) + '@opentelemetry/exporter-trace-otlp-http': 0.52.1(@opentelemetry/api@1.9.1) + '@opentelemetry/exporter-trace-otlp-proto': 0.52.1(@opentelemetry/api@1.9.1) + '@opentelemetry/exporter-zipkin': 1.25.1(@opentelemetry/api@1.9.1) + '@opentelemetry/instrumentation': 0.52.1(@opentelemetry/api@1.9.1) + '@opentelemetry/resources': 1.25.1(@opentelemetry/api@1.9.1) + '@opentelemetry/sdk-logs': 0.52.1(@opentelemetry/api@1.9.1) + '@opentelemetry/sdk-metrics': 1.25.1(@opentelemetry/api@1.9.1) + '@opentelemetry/sdk-trace-base': 1.25.1(@opentelemetry/api@1.9.1) + '@opentelemetry/sdk-trace-node': 1.25.1(@opentelemetry/api@1.9.1) + '@opentelemetry/semantic-conventions': 1.25.1 + transitivePeerDependencies: + - supports-color + '@opentelemetry/sdk-trace-base@1.23.0(@opentelemetry/api@1.9.0)': dependencies: '@opentelemetry/api': 1.9.0 @@ -10977,6 +12817,13 @@ snapshots: '@opentelemetry/resources': 1.23.0(@opentelemetry/api@1.9.0) '@opentelemetry/semantic-conventions': 1.23.0 + '@opentelemetry/sdk-trace-base@1.25.1(@opentelemetry/api@1.9.1)': + dependencies: + '@opentelemetry/api': 1.9.1 + '@opentelemetry/core': 1.25.1(@opentelemetry/api@1.9.1) + '@opentelemetry/resources': 1.25.1(@opentelemetry/api@1.9.1) + '@opentelemetry/semantic-conventions': 1.25.1 + '@opentelemetry/sdk-trace-base@1.30.1(@opentelemetry/api@1.9.0)': dependencies: '@opentelemetry/api': 1.9.0 @@ -11012,6 +12859,16 @@ snapshots: '@opentelemetry/resources': 2.7.1(@opentelemetry/api@1.9.1) '@opentelemetry/semantic-conventions': 1.41.1 + '@opentelemetry/sdk-trace-node@1.25.1(@opentelemetry/api@1.9.1)': + dependencies: + '@opentelemetry/api': 1.9.1 + '@opentelemetry/context-async-hooks': 1.25.1(@opentelemetry/api@1.9.1) + '@opentelemetry/core': 1.25.1(@opentelemetry/api@1.9.1) + '@opentelemetry/propagator-b3': 1.25.1(@opentelemetry/api@1.9.1) + '@opentelemetry/propagator-jaeger': 1.25.1(@opentelemetry/api@1.9.1) + '@opentelemetry/sdk-trace-base': 1.25.1(@opentelemetry/api@1.9.1) + semver: 7.7.3 + '@opentelemetry/sdk-trace-node@1.30.1(@opentelemetry/api@1.9.0)': dependencies: '@opentelemetry/api': 1.9.0 @@ -11038,12 +12895,20 @@ snapshots: '@opentelemetry/semantic-conventions@1.23.0': {} + '@opentelemetry/semantic-conventions@1.25.1': {} + '@opentelemetry/semantic-conventions@1.28.0': {} '@opentelemetry/semantic-conventions@1.34.0': {} '@opentelemetry/semantic-conventions@1.41.1': {} + '@opentelemetry/sql-common@0.40.1(@opentelemetry/api@1.9.1)': + dependencies: + '@opentelemetry/api': 1.9.1 + '@opentelemetry/core': 1.30.1(@opentelemetry/api@1.9.1) + optional: true + '@petamoriken/float16@3.9.3': {} '@pinecone-database/pinecone@4.1.0': {} @@ -11619,6 +13484,9 @@ snapshots: '@tsconfig/node16@1.0.4': {} + '@types/aws-lambda@8.10.122': + optional: true + '@types/babel__core@7.20.5': dependencies: '@babel/parser': 7.27.2 @@ -11645,6 +13513,11 @@ snapshots: '@types/connect': 3.4.38 '@types/node': 22.15.33 + '@types/bunyan@1.8.9': + dependencies: + '@types/node': 22.15.33 + optional: true + '@types/caseless@0.12.5': {} '@types/chai@5.2.3': @@ -11656,6 +13529,11 @@ snapshots: '@types/command-line-usage@5.0.4': {} + '@types/connect@3.4.36': + dependencies: + '@types/node': 22.15.33 + optional: true + '@types/connect@3.4.38': dependencies: '@types/node': 22.15.33 @@ -11710,18 +13588,37 @@ snapshots: '@types/json-schema@7.0.15': {} + '@types/jsonwebtoken@9.0.10': + dependencies: + '@types/ms': 2.1.0 + '@types/node': 22.15.33 + optional: true + '@types/lodash-es@4.17.12': dependencies: '@types/lodash': 4.17.23 '@types/lodash@4.17.23': {} + '@types/long@4.0.2': + optional: true + '@types/mdast@4.0.4': dependencies: '@types/unist': 3.0.3 + '@types/memcached@2.2.10': + dependencies: + '@types/node': 22.15.33 + optional: true + '@types/ms@2.1.0': {} + '@types/mysql@2.15.22': + dependencies: + '@types/node': 22.15.33 + optional: true + '@types/node-fetch@2.6.12': dependencies: '@types/node': 22.15.33 @@ -11743,6 +13640,18 @@ snapshots: dependencies: undici-types: 7.16.0 + '@types/pg-pool@2.0.4': + dependencies: + '@types/pg': 8.6.1 + optional: true + + '@types/pg@8.6.1': + dependencies: + '@types/node': 22.15.33 + pg-protocol: 1.11.0 + pg-types: 2.2.0 + optional: true + '@types/qs@6.14.0': {} '@types/range-parser@1.2.7': {} @@ -11769,6 +13678,11 @@ snapshots: '@types/stack-utils@2.0.3': {} + '@types/tedious@4.0.14': + dependencies: + '@types/node': 22.15.33 + optional: true + '@types/tough-cookie@4.0.5': {} '@types/triple-beam@1.3.5': {} @@ -11866,6 +13780,11 @@ snapshots: dependencies: event-target-shim: 5.0.1 + accepts@1.3.8: + dependencies: + mime-types: 2.1.35 + negotiator: 0.6.3 + accepts@2.0.0: dependencies: mime-types: 3.0.2 @@ -11974,12 +13893,18 @@ snapshots: array-back@6.2.2: {} + array-flatten@1.1.1: {} + array-union@2.1.0: {} arrify@2.0.1: {} assertion-error@2.0.1: {} + async-mutex@0.5.0: + dependencies: + tslib: 2.8.1 + async-retry@1.3.3: dependencies: retry: 0.13.1 @@ -12110,6 +14035,23 @@ snapshots: binary-search@1.3.6: {} + body-parser@1.20.8: + dependencies: + bytes: 3.1.2 + content-type: 1.0.5 + debug: 2.6.9 + depd: 2.0.0 + destroy: 1.2.0 + http-errors: 2.0.1 + iconv-lite: 0.4.24 + on-finished: 2.4.1 + qs: 6.16.0 + raw-body: 2.5.3 + type-is: 1.6.18 + unpipe: 1.0.0 + transitivePeerDependencies: + - supports-color + body-parser@2.2.2: dependencies: bytes: 3.1.2 @@ -12338,6 +14280,8 @@ snapshots: color-convert: 3.1.3 color-string: 2.1.4 + colorette@2.0.20: {} + combined-stream@1.0.8: dependencies: delayed-stream: 1.0.0 @@ -12368,6 +14312,10 @@ snapshots: dependencies: simple-wcswidth: 1.0.1 + content-disposition@0.5.4: + dependencies: + safe-buffer: 5.2.1 + content-disposition@1.0.1: {} content-type@1.0.5: {} @@ -12379,6 +14327,8 @@ snapshots: lodash.clonedeep: 4.5.0 yargs-parser: 20.2.9 + cookie-signature@1.0.7: {} + cookie-signature@1.2.2: {} cookie@0.7.2: {} @@ -12461,6 +14411,10 @@ snapshots: dayjs@1.11.19: {} + debug@2.6.9: + dependencies: + ms: 2.0.0 + debug@4.4.1: dependencies: ms: 2.1.3 @@ -12489,6 +14443,8 @@ snapshots: dequal@2.0.3: {} + destroy@1.2.0: {} + detect-newline@3.1.0: {} devlop@1.1.0: @@ -12534,6 +14490,11 @@ snapshots: dotenv@17.4.2: {} + dotprompt@1.1.2: + dependencies: + handlebars: 4.7.8 + yaml: 2.8.0 + duck-duck-scrape@2.2.7: dependencies: html-entities: 2.6.0 @@ -12712,6 +14673,42 @@ snapshots: express: 5.2.1 ip-address: 10.0.1 + express@4.22.3: + dependencies: + accepts: 1.3.8 + array-flatten: 1.1.1 + body-parser: 1.20.8 + content-disposition: 0.5.4 + content-type: 1.0.5 + cookie: 0.7.2 + cookie-signature: 1.0.7 + debug: 2.6.9 + depd: 2.0.0 + encodeurl: 2.0.0 + escape-html: 1.0.3 + etag: 1.8.1 + finalhandler: 1.3.2 + fresh: 0.5.2 + http-errors: 2.0.1 + merge-descriptors: 1.0.3 + methods: 1.1.2 + on-finished: 2.4.1 + parseurl: 1.3.3 + path-to-regexp: 0.1.13 + proxy-addr: 2.0.7 + qs: 6.16.0 + range-parser: 1.2.1 + safe-buffer: 5.2.1 + send: 0.19.2 + serve-static: 1.16.3 + setprototypeof: 1.2.0 + statuses: 2.0.2 + type-is: 1.6.18 + utils-merge: 1.0.1 + vary: 1.1.2 + transitivePeerDependencies: + - supports-color + express@5.2.1: dependencies: accepts: 2.0.0 @@ -12777,6 +14774,11 @@ snapshots: dependencies: reusify: 1.1.0 + faye-websocket@0.11.4: + dependencies: + websocket-driver: 0.7.5 + optional: true + fb-watchman@2.0.2: dependencies: bser: 2.1.1 @@ -12800,6 +14802,18 @@ snapshots: dependencies: to-regex-range: 5.0.1 + finalhandler@1.3.2: + dependencies: + debug: 2.6.9 + encodeurl: 2.0.0 + escape-html: 1.0.3 + on-finished: 2.4.1 + parseurl: 1.3.3 + statuses: 2.0.2 + unpipe: 1.0.0 + transitivePeerDependencies: + - supports-color + finalhandler@2.1.1: dependencies: debug: 4.4.1 @@ -12820,6 +14834,25 @@ snapshots: locate-path: 5.0.0 path-exists: 4.0.0 + firebase-admin@14.5.0: + dependencies: + '@fastify/busboy': 3.2.2 + '@firebase/database-compat': 2.1.7 + '@firebase/database-types': 1.0.22 + fast-deep-equal: 3.1.3 + google-auth-library: 11.1.0 + jsonwebtoken: 9.0.3 + jwks-rsa: 4.1.0 + optionalDependencies: + '@google-cloud/firestore': 9.3.1 + '@google-cloud/storage': 8.2.0 + transitivePeerDependencies: + - '@firebase/app' + - '@firebase/app-compat' + - encoding + - supports-color + optional: true + flat@5.0.2: {} flatbuffers@23.5.26: {} @@ -12876,6 +14909,8 @@ snapshots: fraction.js@5.3.4: {} + fresh@0.5.2: {} + fresh@2.0.0: {} fs.realpath@1.0.0: {} @@ -12885,6 +14920,9 @@ snapshots: function-bind@1.1.2: {} + functional-red-black-tree@1.0.1: + optional: true + gaxios@6.7.1: dependencies: extend: 3.0.2 @@ -12905,6 +14943,15 @@ snapshots: transitivePeerDependencies: - supports-color + gaxios@7.3.1: + dependencies: + extend: 3.0.2 + https-proxy-agent: 7.0.6 + node-fetch: 3.3.2 + transitivePeerDependencies: + - supports-color + optional: true + gcp-metadata@6.1.1: dependencies: gaxios: 6.7.1 @@ -12922,6 +14969,15 @@ snapshots: transitivePeerDependencies: - supports-color + gcp-metadata@9.0.4: + dependencies: + gaxios: 7.3.1 + google-logging-utils: 2.0.1 + json-bigint: 1.0.0 + transitivePeerDependencies: + - supports-color + optional: true + generative-bayesian-network@2.1.80: dependencies: adm-zip: 0.5.16 @@ -12929,6 +14985,20 @@ snapshots: generic-pool@3.9.0: {} + genkit@1.42.0(@google-cloud/firestore@9.3.1)(firebase-admin@14.5.0): + dependencies: + '@genkit-ai/ai': 1.42.0(@google-cloud/firestore@9.3.1)(firebase-admin@14.5.0)(genkit@1.42.0(@google-cloud/firestore@9.3.1)(firebase-admin@14.5.0)) + '@genkit-ai/core': 1.42.0(@google-cloud/firestore@9.3.1)(firebase-admin@14.5.0)(genkit@1.42.0(@google-cloud/firestore@9.3.1)(firebase-admin@14.5.0)) + uuid: 10.0.0 + transitivePeerDependencies: + - '@google-cloud/firestore' + - bufferutil + - encoding + - firebase + - firebase-admin + - supports-color + - utf-8-validate + gensync@1.0.0-beta.2: {} get-caller-file@2.0.5: {} @@ -12948,6 +15018,8 @@ snapshots: get-package-type@0.1.0: {} + get-port@5.1.1: {} + get-proto@1.0.1: dependencies: dunder-proto: 1.0.1 @@ -13015,6 +15087,30 @@ snapshots: transitivePeerDependencies: - supports-color + google-auth-library@10.9.1: + dependencies: + base64-js: 1.5.1 + ecdsa-sig-formatter: 1.0.11 + gaxios: 7.3.1 + gcp-metadata: 8.1.2 + google-logging-utils: 1.1.3 + jws: 4.0.1 + transitivePeerDependencies: + - supports-color + optional: true + + google-auth-library@11.1.0: + dependencies: + base64-js: 1.5.1 + ecdsa-sig-formatter: 1.0.11 + gaxios: 7.3.1 + gcp-metadata: 9.0.4 + google-logging-utils: 2.0.1 + jws: 4.0.1 + transitivePeerDependencies: + - supports-color + optional: true + google-auth-library@9.15.1: dependencies: base64-js: 1.5.1 @@ -13027,10 +15123,66 @@ snapshots: - encoding - supports-color + google-gax@4.6.1: + dependencies: + '@grpc/grpc-js': 1.14.3 + '@grpc/proto-loader': 0.7.15 + '@types/long': 4.0.2 + abort-controller: 3.0.0 + duplexify: 4.1.3 + google-auth-library: 9.15.1 + node-fetch: 2.7.0 + object-hash: 3.0.0 + proto3-json-serializer: 2.0.2 + protobufjs: 7.5.4 + retry-request: 7.0.2 + uuid: 9.0.1 + transitivePeerDependencies: + - encoding + - supports-color + optional: true + + google-gax@5.0.8: + dependencies: + '@grpc/grpc-js': 1.14.3 + '@grpc/proto-loader': 0.8.0 + duplexify: 4.1.3 + google-auth-library: 10.5.0 + google-logging-utils: 1.1.3 + node-fetch: 3.3.2 + object-hash: 3.0.0 + proto3-json-serializer: 3.0.4 + protobufjs: 7.5.4 + retry-request: 8.0.4 + rimraf: 5.0.10 + transitivePeerDependencies: + - supports-color + optional: true + + google-gax@6.10.0: + dependencies: + '@grpc/grpc-js': 1.14.3 + '@grpc/proto-loader': 0.8.0 + '@opentelemetry/api': 1.9.1 + duplexify: 4.1.3 + google-auth-library: 11.1.0 + google-logging-utils: 2.0.1 + node-fetch: 3.3.2 + object-hash: 3.0.0 + proto3-json-serializer: 4.0.2 + protobufjs: 7.5.4 + retry-request: 9.0.1 + transitivePeerDependencies: + - supports-color + optional: true + google-logging-utils@0.0.2: {} google-logging-utils@1.1.3: {} + google-logging-utils@2.0.1: + optional: true + google-protobuf@3.21.4: {} googleapis-common@7.2.0: @@ -13170,6 +15322,9 @@ snapshots: statuses: 2.0.2 toidentifier: 1.0.1 + http-parser-js@0.5.10: + optional: true + http-proxy-agent@5.0.0: dependencies: '@tootallnate/once': 2.0.0 @@ -13178,6 +15333,13 @@ snapshots: transitivePeerDependencies: - supports-color + http-proxy-agent@7.0.2: + dependencies: + agent-base: 7.1.4 + debug: 4.4.3 + transitivePeerDependencies: + - supports-color + https-proxy-agent@5.0.1: dependencies: agent-base: 6.0.2 @@ -13200,6 +15362,10 @@ snapshots: dependencies: ms: 2.1.3 + iconv-lite@0.4.24: + dependencies: + safer-buffer: 2.1.2 + iconv-lite@0.6.3: dependencies: safer-buffer: 2.1.2 @@ -13836,12 +16002,38 @@ snapshots: jsonrepair@3.13.2: {} + jsonwebtoken@9.0.3: + dependencies: + jws: 4.0.1 + lodash.includes: 4.3.0 + lodash.isboolean: 3.0.3 + lodash.isinteger: 4.0.4 + lodash.isnumber: 3.0.3 + lodash.isplainobject: 4.0.6 + lodash.isstring: 4.0.1 + lodash.once: 4.1.1 + ms: 2.1.3 + semver: 7.7.3 + optional: true + jwa@2.0.1: dependencies: buffer-equal-constant-time: 1.0.1 ecdsa-sig-formatter: 1.0.11 safe-buffer: 5.2.1 + jwks-rsa@4.1.0: + dependencies: + '@types/jsonwebtoken': 9.0.10 + debug: 4.4.3 + jose: 6.1.3 + limiter: 1.1.5 + lru-cache: 11.5.1 + lru-memoizer: 3.0.0 + transitivePeerDependencies: + - supports-color + optional: true + jws@4.0.1: dependencies: jwa: 2.0.1 @@ -14065,6 +16257,9 @@ snapshots: leven@3.1.0: {} + limiter@1.1.5: + optional: true + lines-and-columns@1.2.4: {} livekit-client@2.17.2(@types/dom-mediacapture-record@1.0.22): @@ -14120,12 +16315,36 @@ snapshots: lodash.clonedeep@4.5.0: {} + lodash.includes@4.3.0: + optional: true + + lodash.isboolean@3.0.3: + optional: true + lodash.isequal@4.5.0: {} + lodash.isinteger@4.0.4: + optional: true + + lodash.isnumber@3.0.3: + optional: true + + lodash.isplainobject@4.0.6: + optional: true + + lodash.isstring@4.0.1: + optional: true + + lodash.mapvalues@4.6.0: + optional: true + lodash.memoize@4.1.2: {} lodash.merge@4.6.2: {} + lodash.once@4.1.1: + optional: true + lodash@4.17.23: {} logform@2.7.0: @@ -14157,6 +16376,12 @@ snapshots: lru-cache@9.1.2: {} + lru-memoizer@3.0.0: + dependencies: + lodash.clonedeep: 4.5.0 + lru-cache: 11.5.1 + optional: true + magic-bytes.js@1.13.0: {} magic-string@0.30.21: @@ -14299,16 +16524,22 @@ snapshots: dependencies: '@types/mdast': 4.0.4 + media-typer@0.3.0: {} + media-typer@1.1.0: {} memory-pager@1.5.0: {} + merge-descriptors@1.0.3: {} + merge-descriptors@2.0.0: {} merge-stream@2.0.0: {} merge2@1.4.1: {} + methods@1.1.2: {} + micromark-core-commonmark@2.0.3: dependencies: decode-named-character-reference: 1.3.0 @@ -14517,6 +16748,8 @@ snapshots: dependencies: mime-db: 1.54.0 + mime@1.6.0: {} + mime@3.0.0: {} mimic-fn@2.1.0: {} @@ -14573,6 +16806,8 @@ snapshots: optionalDependencies: '@aws-sdk/credential-providers': 3.975.0 + ms@2.0.0: {} + ms@2.1.3: {} mustache@4.2.0: {} @@ -14588,6 +16823,8 @@ snapshots: iconv-lite: 0.6.3 sax: 1.4.4 + negotiator@0.6.3: {} + negotiator@1.0.0: {} neo-async@2.6.2: {} @@ -14823,6 +17060,8 @@ snapshots: parseurl@1.3.3: {} + partial-json@0.1.7: {} + path-exists@4.0.0: {} path-is-absolute@1.0.1: {} @@ -14843,6 +17082,8 @@ snapshots: lru-cache: 11.2.4 minipass: 7.1.2 + path-to-regexp@0.1.13: {} + path-to-regexp@8.3.0: {} path-type@4.0.0: {} @@ -14985,6 +17226,21 @@ snapshots: kleur: 3.0.3 sisteransi: 1.0.5 + proto3-json-serializer@2.0.2: + dependencies: + protobufjs: 7.5.4 + optional: true + + proto3-json-serializer@3.0.4: + dependencies: + protobufjs: 7.5.4 + optional: true + + proto3-json-serializer@4.0.2: + dependencies: + protobufjs: 7.5.4 + optional: true + protobufjs@7.5.1: dependencies: '@protobufjs/aspromise': 1.1.2 @@ -15022,6 +17278,19 @@ snapshots: proxy-from-env@1.1.0: {} + pump@3.0.4: + dependencies: + end-of-stream: 1.4.5 + once: 1.4.0 + optional: true + + pumpify@2.0.1: + dependencies: + duplexify: 4.1.3 + inherits: 2.0.4 + pump: 3.0.4 + optional: true + punycode@2.3.1: {} pure-rand@6.1.0: {} @@ -15036,6 +17305,11 @@ snapshots: dependencies: side-channel: 1.1.0 + qs@6.16.0: + dependencies: + es-define-property: 1.0.1 + side-channel: 1.1.1 + quansync@0.2.11: {} queue-lit@1.5.2: {} @@ -15069,6 +17343,13 @@ snapshots: ranges-sort@6.1.3: {} + raw-body@2.5.3: + dependencies: + bytes: 3.1.2 + http-errors: 2.0.1 + iconv-lite: 0.4.24 + unpipe: 1.0.0 + raw-body@3.0.2: dependencies: bytes: 3.1.2 @@ -15174,6 +17455,21 @@ snapshots: - encoding - supports-color + retry-request@8.0.4: + dependencies: + extend: 3.0.2 + teeny-request: 10.1.4 + transitivePeerDependencies: + - supports-color + optional: true + + retry-request@9.0.1: + dependencies: + extend: 3.0.2 + teeny-request: 11.0.1 + transitivePeerDependencies: + - supports-color + retry@0.13.1: {} reusify@1.1.0: {} @@ -15275,6 +17571,24 @@ snapshots: semver@7.7.3: {} + send@0.19.2: + dependencies: + debug: 2.6.9 + depd: 2.0.0 + destroy: 1.2.0 + encodeurl: 2.0.0 + escape-html: 1.0.3 + etag: 1.8.1 + fresh: 0.5.2 + http-errors: 2.0.1 + mime: 1.6.0 + ms: 2.1.3 + on-finished: 2.4.1 + range-parser: 1.2.1 + statuses: 2.0.2 + transitivePeerDependencies: + - supports-color + send@1.2.1: dependencies: debug: 4.4.3 @@ -15293,6 +17607,15 @@ snapshots: serialize-error-cjs@0.2.0: {} + serve-static@1.16.3: + dependencies: + encodeurl: 2.0.0 + escape-html: 1.0.3 + parseurl: 1.3.3 + send: 0.19.2 + transitivePeerDependencies: + - supports-color + serve-static@2.2.1: dependencies: encodeurl: 2.0.0 @@ -15321,6 +17644,11 @@ snapshots: es-errors: 1.3.0 object-inspect: 1.13.4 + side-channel-list@1.0.1: + dependencies: + es-errors: 1.3.0 + object-inspect: 1.13.4 + side-channel-map@1.0.1: dependencies: call-bound: 1.0.4 @@ -15344,6 +17672,14 @@ snapshots: side-channel-map: 1.0.1 side-channel-weakmap: 1.0.2 + side-channel@1.1.1: + dependencies: + es-errors: 1.3.0 + object-inspect: 1.13.4 + side-channel-list: 1.0.1 + side-channel-map: 1.0.1 + side-channel-weakmap: 1.0.2 + siginfo@2.0.0: {} signal-exit@3.0.7: {} @@ -15478,6 +17814,25 @@ snapshots: array-back: 6.2.2 wordwrapjs: 5.1.1 + teeny-request@10.1.4: + dependencies: + http-proxy-agent: 7.0.2 + https-proxy-agent: 7.0.6 + node-fetch: 3.3.2 + stream-events: 1.0.5 + transitivePeerDependencies: + - supports-color + optional: true + + teeny-request@11.0.1: + dependencies: + http-proxy-agent: 7.0.2 + https-proxy-agent: 7.0.6 + node-fetch: 3.3.2 + stream-events: 1.0.5 + transitivePeerDependencies: + - supports-color + teeny-request@9.0.0: dependencies: http-proxy-agent: 5.0.0 @@ -15668,6 +18023,11 @@ snapshots: type-fest@4.41.0: {} + type-is@1.6.18: + dependencies: + media-typer: 0.3.0 + mime-types: 2.1.35 + type-is@2.0.1: dependencies: content-type: 1.0.5 @@ -15740,10 +18100,14 @@ snapshots: escalade: 3.2.0 picocolors: 1.1.1 + uri-templates@0.2.0: {} + url-template@2.0.8: {} util-deprecate@1.0.2: {} + utils-merge@1.0.1: {} + uuid@10.0.0: {} uuid@11.1.0: {} @@ -15882,6 +18246,16 @@ snapshots: dependencies: sdp: 3.2.1 + websocket-driver@0.7.5: + dependencies: + http-parser-js: 0.5.10 + safe-buffer: 5.2.1 + websocket-extensions: 0.1.4 + optional: true + + websocket-extensions@0.1.4: + optional: true + whatwg-fetch@3.6.20: {} whatwg-url@14.2.0: