@argosvix/sdk 0.1.2 → 0.3.0-alpha.1

package/CHANGELOG.md

@@ -4,6 +4,50 @@ All notable changes to `@argosvix/sdk` are documented in this file.
 The format is loosely based on [Keep a Changelog](https://keepachangelog.com/en/1.1.0/),
 and the project follows [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
+## [0.3.0-alpha.1] - 2026-06-01
+
+Pre-release adding the foundation for the **Pro+ plaintext content capture**
+feature. The SDK can now optionally send prompt and completion bodies in
+addition to metadata when the user explicitly opts in via dashboard consent.
+The backend gate (`PLAINTEXT_STORAGE_ENABLED` env + per-account
+`plaintext_storage_optin` column) is still closed by default, so this release
+does not actually persist plaintext anywhere until the feature ships in
+production.
+
+### Added
+- `ArgosvixConfig.captureContent` (default `false`). When set to `true`, the
+  SDK extracts prompt / completion text from supported providers and forwards
+  them on the ingest payload. Without this flag, no plaintext is ever sent.
+- `ArgosvixConfig.disablePiiRedaction` (default `false`). When `captureContent`
+  is `true`, the SDK runs a built-in PII redaction pass (email, credit card,
+  phone, マイナンバー, IPv4, IPv6) over the captured bodies before send.
+  Setting this flag disables the filter at the user's own risk.
+- `LlmCallRecord.promptBody`, `completionBody`, and `toolCalls` fields populated
+  only when `captureContent` is `true`.
+- New `redaction.ts` module with `redactPii()` and `redactToolCall()` helpers.
+- Double safety net inside `Recorder.record()`: even if a wrapper accidentally
+  attaches `promptBody` while `captureContent` is `false`, the recorder strips
+  the field before buffering. This makes wrapper bugs non-leaky.
+
+### Provider coverage in this release
+- OpenAI Chat Completions (non-stream success path): prompt body, completion
+  body, and tool calls captured.
+- Anthropic Messages (non-stream success path): prompt body and completion body
+  captured (tool calls in a follow-up).
+- OpenAI Responses, Mistral, Gemini (Legacy and New): metadata still recorded,
+  but `promptBody` / `completionBody` are omitted. A one-time `console.warn`
+  fires when `captureContent` is enabled to make this visible.
+- All streaming paths across every provider: same as above. Coverage will
+  expand in `0.3.0-alpha.2+`.
+
+### Notes
+- This is an `alpha` pre-release. Do not enable `captureContent` in production
+  until the corresponding dashboard opt-in UI ships and the legal documents
+  (v2.1) flip to production. See https://argosvix.com/ja/docs/plaintext for the
+  rollout status.
+- Existing users who do not set `captureContent` are unaffected. The default
+  behavior — metadata-only ingest — is byte-identical to 0.2.0.
+
 ## [0.1.2] - 2026-05-22
 
 Documentation-only release that aligns the npm README with global SaaS norms.

package/LICENSE

@@ -1,6 +1,6 @@
 MIT License
 
-Copyright (c) 2026 jissocyu
+Copyright (c) 2026 Yuto Makihara
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal

package/README.md

@@ -140,6 +140,108 @@ The [`examples/`](../../examples/) directory contains minimum-viable integration
 - [`examples/lambda-gemini/`](../../examples/lambda-gemini/) — AWS Lambda with `@google/genai` (note: container-reuse semantics).
 - [`examples/workers-anthropic/`](../../examples/workers-anthropic/) — Cloudflare Workers with the `flushClient` pattern.
 
+## Alert webhooks
+
+Argosvix can deliver alert notifications to any HTTPS endpoint of your choice (in addition to email and Slack). Configure a webhook channel from <https://dashboard.argosvix.com/en/alerts>; this section documents the public contract so you can implement a receiver.
+
+### Delivery
+
+- Method: `POST`
+- Content-Type: `application/json`
+- Timeout: 5 seconds (no retry — the next evaluator cycle will re-fire if the condition still holds)
+- Redirects: disabled (`fetch redirect: "error"`)
+- URL constraints: HTTPS only; private / loopback / link-local / cloud-metadata IPs and URLs with credentials are rejected at registration time
+
+### Headers
+
+| Header | Value |
+|---|---|
+| `User-Agent` | `Argosvix-Webhook/1.0` |
+| `X-Argosvix-Event` | `alert.triggered` (only event type for now) |
+| `X-Argosvix-Signature` | `sha256=<hex>` — present only when a signing secret is configured |
+| `X-Argosvix-Timestamp` | ISO-8601 UTC — present only when a signing secret is configured |
+
+### Payload
+
+```jsonc
+{
+  "alertId": "01HXZ...",
+  "name": "monthly cost > $50",
+  "alertType": "monthly_budget",   // cost_threshold | error_rate | latency_degradation | monthly_budget
+  "thresholdValue": 50,
+  "observedValue": 64.20,
+  "windowMinutes": 60,
+  "windowDescription": "60 min",
+  "filterProvider": "openai",       // or null
+  "filterModel": null,              // or string
+  "comparison": "exceeded threshold",
+  "triggeredAt": "2026-05-25T10:23:45.678Z",
+  "dashboardUrl": "https://dashboard.argosvix.com/en/alerts?alertId=01HXZ..."
+}
+```
+
+`thresholdValue` and `observedValue` units are USD for cost alerts, percent for `error_rate`, and milliseconds for `latency_degradation`. Schema is stable: new fields may be added (additive only); existing fields keep their names and semantics.
+
+### Verifying the signature
+
+When a signing secret is configured, the signature header is computed as:
+
+```
+X-Argosvix-Signature = "sha256=" + hex(HMAC_SHA256(secret, X-Argosvix-Timestamp + "." + body))
+```
+
+Reject any request whose signature does not match (and optionally drop requests with a timestamp older than your replay window).
+
+```typescript
+// Node 18+ — verifyArgosvixSignature.ts
+import { createHmac, timingSafeEqual } from "node:crypto";
+
+export function verifyArgosvixSignature(
+  secret: string,
+  body: string,            // raw request body string
+  signatureHeader: string, // "sha256=<hex>"
+  timestampHeader: string, // ISO-8601 string
+  maxAgeMs = 5 * 60 * 1000,
+): boolean {
+  const ts = Date.parse(timestampHeader);
+  if (Number.isNaN(ts) || Math.abs(Date.now() - ts) > maxAgeMs) return false;
+
+  const expected = "sha256=" +
+    createHmac("sha256", secret).update(`${timestampHeader}.${body}`).digest("hex");
+  const a = Buffer.from(signatureHeader, "utf8");
+  const b = Buffer.from(expected, "utf8");
+  return a.length === b.length && timingSafeEqual(a, b);
+}
+```
+
+```python
+# Python 3 — verify_argosvix_signature.py
+import hashlib, hmac, time
+from datetime import datetime, timezone
+
+def verify_argosvix_signature(secret: str, body: str,
+                              signature_header: str, timestamp_header: str,
+                              max_age_seconds: int = 300) -> bool:
+    try:
+        ts = datetime.fromisoformat(timestamp_header.replace("Z", "+00:00"))
+    except ValueError:
+        return False
+    if abs(time.time() - ts.timestamp()) > max_age_seconds:
+        return False
+    expected = "sha256=" + hmac.new(
+        secret.encode(), f"{timestamp_header}.{body}".encode(), hashlib.sha256
+    ).hexdigest()
+    return hmac.compare_digest(signature_header, expected)
+```
+
+### Tag-key conventions
+
+Tag keys used in queries (`channelTargets.webhook.url` request paths, dashboard filters, etc.) must match `^[A-Za-z0-9_](?:[A-Za-z0-9_-]{0,62}[A-Za-z0-9_])?$` — alphanumeric plus `_` `-`, no leading/trailing hyphen, 1–64 characters. Sticking to this in the SDK `tags: { ... }` map keeps every downstream filter / aggregation usable.
+
+### Residual SSRF risk (DNS rebinding)
+
+Hostname validation happens at registration and at delivery time, but Cloudflare Workers does not expose connect-level IP control, so an attacker-controlled DNS that flips a public name to an RFC1918 / metadata IP between checks can still bypass the policy. Treat webhook receivers as part of your trust boundary; do not host them inside private networks that your perimeter would otherwise protect.
+
 ## API
 
 ### `wrap<T>(client: T, config?: ArgosvixConfig): T`

package/dist/client.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"client.d.ts","sourceRoot":"","sources":["../src/client.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,cAAc,EAA2B,MAAM,YAAY,CAAC;AAE1E,OAAO,EAAE,QAAQ,EAAE,MAAM,eAAe,CAAC;AAKzC;;;;;;;;;;;;;;;;;;GAkBG;AACH,wBAAgB,IAAI,CAAC,CAAC,SAAS,MAAM,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,GAAE,cAAmB,GAAG,CAAC,CAiChF;AAED,wBAAgB,WAAW,CAAC,MAAM,EAAE,MAAM,GAAG,QAAQ,GAAG,IAAI,CAE3D"}
+{"version":3,"file":"client.d.ts","sourceRoot":"","sources":["../src/client.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,cAAc,EAA2B,MAAM,YAAY,CAAC;AAE1E,OAAO,EAAE,QAAQ,EAAE,MAAM,eAAe,CAAC;AAKzC;;;;;;;;;;;;;;;;;;GAkBG;AACH,wBAAgB,IAAI,CAAC,CAAC,SAAS,MAAM,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,GAAE,cAAmB,GAAG,CAAC,CA6ChF;AAED,wBAAgB,WAAW,CAAC,MAAM,EAAE,MAAM,GAAG,QAAQ,GAAG,IAAI,CAE3D"}

package/dist/client.js

@@ -56,6 +56,20 @@ export function wrap(client, config = {}) {
             break;
         }
     }
+    // 平文 capture が有効でも、未対応 provider / 経路では promptBody や
+    // completionBody が乗らないことを 1 回だけ console.warn で明示する。
+    // v0.3.0-alpha.1 対応 = openai (Chat Completions) と anthropic (Messages)
+    // の非ストリーミング success path のみ。 OpenAI Responses や Mistral、
+    // Gemini、 全 streaming 経路は段階追加。
+    if (config.captureContent === true) {
+        if (provider === "openai" && isOpenAIResponsesLike(client)) {
+            warnUnsupportedCaptureProvider("openai (Responses API)");
+        }
+        if (provider === "mistral")
+            warnUnsupportedCaptureProvider("mistral");
+        if (provider === "gemini")
+            warnUnsupportedCaptureProvider("gemini");
+    }
     wrappedClients.set(client, recorder);
     return client;
 }
@@ -95,6 +109,153 @@ function detectProvider(client, override) {
         return "openai";
     return "unknown";
 }
+/**
+ * F-2 carry = wrap config に渡された trace 軸 (traceId / spanId /
+ * parentSpanId) を record に乗せる helper。 全 provider の record()
+ * 呼び出しで spread して 一律 carry する。 未指定 field は object に
+ * 出さない (= JSON 送信 payload 軽量化 + backend で undefined と NULL
+ * の区別 不要)。
+ */
+function buildTraceMeta(config) {
+    const meta = {};
+    if (config.traceId)
+        meta.traceId = config.traceId;
+    if (config.spanId)
+        meta.spanId = config.spanId;
+    if (config.parentSpanId)
+        meta.parentSpanId = config.parentSpanId;
+    return meta;
+}
+/**
+ * Pro+ 平文保存機能の SDK 側 opt-in 抽出 helper。
+ *
+ * captureContent が true のときに wrapper が呼んで、 provider 毎の
+ * request / response 形状から prompt / completion / tool calls を 文字列
+ * (および JSON 文字列)として抽出する。 PII redaction は Recorder 側で
+ * 一括して適用されるので、 ここでは生の文字列を返すのみ。
+ *
+ * v0.3.0-alpha.1 段階の対応 provider:
+ *   - openai (Chat Completions) = 全項目対応
+ *   - anthropic (Messages) = prompt + completion 対応(tool call は段階追加)
+ *   - 他 provider と全 streaming 経路 = 未対応、 captureContent が true でも
+ *     promptBody / completionBody は付与されない(段階4 以降で順次追加)。
+ *     console.warn で明示する。
+ */
+function extractOpenAIChatPromptBody(requestArgs) {
+    if (!Array.isArray(requestArgs.messages) || requestArgs.messages.length === 0) {
+        return undefined;
+    }
+    try {
+        return JSON.stringify(requestArgs.messages);
+    }
+    catch {
+        return undefined;
+    }
+}
+function extractOpenAIChatCompletionBody(response) {
+    if (!response || typeof response !== "object")
+        return undefined;
+    const choices = response.choices;
+    if (!Array.isArray(choices) || choices.length === 0)
+        return undefined;
+    const first = choices[0];
+    const content = first?.message?.content;
+    if (typeof content === "string")
+        return content;
+    // content が array (multi-modal の場合) の場合は JSON 文字列で carry
+    if (Array.isArray(content)) {
+        try {
+            return JSON.stringify(content);
+        }
+        catch {
+            return undefined;
+        }
+    }
+    return undefined;
+}
+function extractOpenAIChatToolCalls(response) {
+    if (!response || typeof response !== "object")
+        return undefined;
+    const choices = response.choices;
+    if (!Array.isArray(choices) || choices.length === 0)
+        return undefined;
+    const first = choices[0];
+    const toolCalls = first?.message?.tool_calls;
+    if (!Array.isArray(toolCalls) || toolCalls.length === 0)
+        return undefined;
+    const result = [];
+    for (const tc of toolCalls) {
+        if (!tc || typeof tc !== "object")
+            continue;
+        const fn = tc.function;
+        const name = typeof fn?.name === "string" ? fn.name : "unknown";
+        const args = typeof fn?.arguments === "string"
+            ? fn.arguments
+            : fn?.arguments !== undefined
+                ? safeStringify(fn.arguments)
+                : undefined;
+        result.push(args !== undefined ? { name, arguments: args } : { name });
+    }
+    return result.length > 0 ? result : undefined;
+}
+function extractAnthropicPromptBody(requestArgs) {
+    if (!Array.isArray(requestArgs.messages) || requestArgs.messages.length === 0) {
+        return undefined;
+    }
+    try {
+        return JSON.stringify(requestArgs.messages);
+    }
+    catch {
+        return undefined;
+    }
+}
+function extractAnthropicCompletionBody(response) {
+    if (!response || typeof response !== "object")
+        return undefined;
+    // Anthropic response shape = { content: [{ type: "text", text: "..." }, ...] }
+    const content = response.content;
+    if (Array.isArray(content)) {
+        const texts = [];
+        for (const block of content) {
+            if (block && typeof block === "object") {
+                const t = block.type;
+                const txt = block.text;
+                if (t === "text" && typeof txt === "string") {
+                    texts.push(txt);
+                }
+            }
+        }
+        if (texts.length > 0)
+            return texts.join("\n");
+        // text block がなければ全 content を JSON 文字列として carry
+        try {
+            return JSON.stringify(content);
+        }
+        catch {
+            return undefined;
+        }
+    }
+    return undefined;
+}
+function safeStringify(value) {
+    try {
+        return JSON.stringify(value);
+    }
+    catch {
+        return undefined;
+    }
+}
+let captureContentWarnedProviders = null;
+function warnUnsupportedCaptureProvider(label) {
+    if (captureContentWarnedProviders === null) {
+        captureContentWarnedProviders = new Set();
+    }
+    if (captureContentWarnedProviders.has(label))
+        return;
+    captureContentWarnedProviders.add(label);
+    // eslint-disable-next-line no-console
+    console.warn(`[argosvix] captureContent is enabled but ${label} body extraction is not yet supported in this SDK version. Metadata is still recorded; plaintext is omitted. Coverage will expand in subsequent releases.`);
+}
 function extractErrorDetails(err) {
     if (!err || typeof err !== "object")
         return undefined;
@@ -139,7 +300,7 @@ function wrapOpenAIChat(client, recorder, config) {
             const model = r.model || requestArgs.model || "unknown";
             const promptTokens = r.usage?.prompt_tokens ?? 0;
             const completionTokens = r.usage?.completion_tokens ?? 0;
-            recorder.record({
+            const record = {
                 id,
                 provider: "openai",
                 model,
@@ -150,8 +311,21 @@ function wrapOpenAIChat(client, recorder, config) {
                 latencyMs,
                 timestamp: new Date().toISOString(),
                 tags: { ...(config.tags ?? {}) },
+                ...buildTraceMeta(config),
                 requestMeta: buildOpenAIRequestMeta(requestArgs),
-            });
+            };
+            if (config.captureContent === true) {
+                const promptBody = extractOpenAIChatPromptBody(requestArgs);
+                if (promptBody !== undefined)
+                    record.promptBody = promptBody;
+                const completionBody = extractOpenAIChatCompletionBody(response);
+                if (completionBody !== undefined)
+                    record.completionBody = completionBody;
+                const toolCalls = extractOpenAIChatToolCalls(response);
+                if (toolCalls !== undefined)
+                    record.toolCalls = toolCalls;
+            }
+            recorder.record(record);
             return response;
         }
         catch (err) {
@@ -167,6 +341,7 @@ function wrapOpenAIChat(client, recorder, config) {
                 latencyMs: Date.now() - start,
                 timestamp: new Date().toISOString(),
                 tags: { ...(config.tags ?? {}) },
+                ...buildTraceMeta(config),
                 error: err instanceof Error ? err.message : String(err),
                 ...(errorDetails ? { errorDetails } : {}),
                 requestMeta: buildOpenAIRequestMeta(requestArgs),
@@ -204,6 +379,7 @@ async function* wrapOpenAIStream(stream, recorder, requestArgs, start, id, confi
             latencyMs: Date.now() - start,
             timestamp: new Date().toISOString(),
             tags: { ...(config.tags ?? {}) },
+            ...buildTraceMeta(config),
             requestMeta: buildOpenAIRequestMeta(requestArgs),
         });
     }
@@ -220,6 +396,7 @@ async function* wrapOpenAIStream(stream, recorder, requestArgs, start, id, confi
             latencyMs: Date.now() - start,
             timestamp: new Date().toISOString(),
             tags: { ...(config.tags ?? {}) },
+            ...buildTraceMeta(config),
             error: err instanceof Error ? err.message : String(err),
             ...(errorDetails ? { errorDetails } : {}),
             requestMeta: buildOpenAIRequestMeta(requestArgs),
@@ -273,6 +450,7 @@ function wrapOpenAIResponses(client, recorder, config) {
                 latencyMs,
                 timestamp: new Date().toISOString(),
                 tags: { ...(config.tags ?? {}) },
+                ...buildTraceMeta(config),
                 requestMeta: buildResponsesRequestMeta(requestArgs),
             });
             return response;
@@ -290,6 +468,7 @@ function wrapOpenAIResponses(client, recorder, config) {
                 latencyMs: Date.now() - start,
                 timestamp: new Date().toISOString(),
                 tags: { ...(config.tags ?? {}) },
+                ...buildTraceMeta(config),
                 error: err instanceof Error ? err.message : String(err),
                 ...(errorDetails ? { errorDetails } : {}),
                 requestMeta: buildResponsesRequestMeta(requestArgs),
@@ -332,7 +511,7 @@ function wrapAnthropic(client, recorder, config) {
             const model = r.model || requestArgs.model || "unknown";
             const promptTokens = r.usage?.input_tokens ?? 0;
             const completionTokens = r.usage?.output_tokens ?? 0;
-            recorder.record({
+            const record = {
                 id,
                 provider: "anthropic",
                 model,
@@ -343,8 +522,18 @@ function wrapAnthropic(client, recorder, config) {
                 latencyMs,
                 timestamp: new Date().toISOString(),
                 tags: { ...(config.tags ?? {}) },
+                ...buildTraceMeta(config),
                 requestMeta: buildAnthropicRequestMeta(requestArgs),
-            });
+            };
+            if (config.captureContent === true) {
+                const promptBody = extractAnthropicPromptBody(requestArgs);
+                if (promptBody !== undefined)
+                    record.promptBody = promptBody;
+                const completionBody = extractAnthropicCompletionBody(response);
+                if (completionBody !== undefined)
+                    record.completionBody = completionBody;
+            }
+            recorder.record(record);
             return response;
         }
         catch (err) {
@@ -360,6 +549,7 @@ function wrapAnthropic(client, recorder, config) {
                 latencyMs: Date.now() - start,
                 timestamp: new Date().toISOString(),
                 tags: { ...(config.tags ?? {}) },
+                ...buildTraceMeta(config),
                 error: err instanceof Error ? err.message : String(err),
                 ...(errorDetails ? { errorDetails } : {}),
                 requestMeta: buildAnthropicRequestMeta(requestArgs),
@@ -398,6 +588,7 @@ async function* wrapAnthropicStream(stream, recorder, requestArgs, start, id, co
             latencyMs: Date.now() - start,
             timestamp: new Date().toISOString(),
             tags: { ...(config.tags ?? {}) },
+            ...buildTraceMeta(config),
             requestMeta: buildAnthropicRequestMeta(requestArgs),
         });
     }
@@ -414,6 +605,7 @@ async function* wrapAnthropicStream(stream, recorder, requestArgs, start, id, co
             latencyMs: Date.now() - start,
             timestamp: new Date().toISOString(),
             tags: { ...(config.tags ?? {}) },
+            ...buildTraceMeta(config),
             error: err instanceof Error ? err.message : String(err),
             ...(errorDetails ? { errorDetails } : {}),
             requestMeta: buildAnthropicRequestMeta(requestArgs),
@@ -459,6 +651,7 @@ function wrapMistral(client, recorder, config) {
                 latencyMs,
                 timestamp: new Date().toISOString(),
                 tags: { ...(config.tags ?? {}) },
+                ...buildTraceMeta(config),
                 requestMeta: buildMistralRequestMeta(requestArgs),
             });
             return response;
@@ -476,6 +669,7 @@ function wrapMistral(client, recorder, config) {
                 latencyMs: Date.now() - start,
                 timestamp: new Date().toISOString(),
                 tags: { ...(config.tags ?? {}) },
+                ...buildTraceMeta(config),
                 error: err instanceof Error ? err.message : String(err),
                 ...(errorDetails ? { errorDetails } : {}),
                 requestMeta: buildMistralRequestMeta(requestArgs),
@@ -507,6 +701,7 @@ function wrapMistral(client, recorder, config) {
                     latencyMs: Date.now() - start,
                     timestamp: new Date().toISOString(),
                     tags: { ...(config.tags ?? {}) },
+                    ...buildTraceMeta(config),
                     error: err instanceof Error ? err.message : String(err),
                     ...(errorDetails ? { errorDetails } : {}),
                     requestMeta: buildMistralRequestMeta(requestArgs),
@@ -546,6 +741,7 @@ async function* wrapMistralStream(stream, recorder, requestArgs, start, id, conf
             latencyMs: Date.now() - start,
             timestamp: new Date().toISOString(),
             tags: { ...(config.tags ?? {}) },
+            ...buildTraceMeta(config),
             requestMeta: buildMistralRequestMeta(requestArgs),
         });
     }
@@ -562,6 +758,7 @@ async function* wrapMistralStream(stream, recorder, requestArgs, start, id, conf
             latencyMs: Date.now() - start,
             timestamp: new Date().toISOString(),
             tags: { ...(config.tags ?? {}) },
+            ...buildTraceMeta(config),
             error: err instanceof Error ? err.message : String(err),
             ...(errorDetails ? { errorDetails } : {}),
             requestMeta: buildMistralRequestMeta(requestArgs),
@@ -619,6 +816,7 @@ function wrapGeminiLegacyModel(model, modelName, recorder, config) {
                 latencyMs: Date.now() - start,
                 timestamp: new Date().toISOString(),
                 tags: { ...(config.tags ?? {}) },
+                ...buildTraceMeta(config),
                 requestMeta: buildGeminiRequestMeta(requestArgs),
             });
             return result;
@@ -636,6 +834,7 @@ function wrapGeminiLegacyModel(model, modelName, recorder, config) {
                 latencyMs: Date.now() - start,
                 timestamp: new Date().toISOString(),
                 tags: { ...(config.tags ?? {}) },
+                ...buildTraceMeta(config),
                 error: err instanceof Error ? err.message : String(err),
                 ...(errorDetails ? { errorDetails } : {}),
                 requestMeta: buildGeminiRequestMeta(requestArgs),
@@ -675,6 +874,7 @@ function wrapGeminiLegacyModel(model, modelName, recorder, config) {
                             latencyMs: Date.now() - start,
                             timestamp: new Date().toISOString(),
                             tags: { ...(config.tags ?? {}) },
+                            ...buildTraceMeta(config),
                             requestMeta: buildGeminiRequestMeta(requestArgs),
                         });
                     }
@@ -691,6 +891,7 @@ function wrapGeminiLegacyModel(model, modelName, recorder, config) {
                             latencyMs: Date.now() - start,
                             timestamp: new Date().toISOString(),
                             tags: { ...(config.tags ?? {}) },
+                            ...buildTraceMeta(config),
                             error: err instanceof Error ? err.message : String(err),
                             ...(errorDetails ? { errorDetails } : {}),
                             requestMeta: buildGeminiRequestMeta(requestArgs),
@@ -713,6 +914,7 @@ function wrapGeminiLegacyModel(model, modelName, recorder, config) {
                     latencyMs: Date.now() - start,
                     timestamp: new Date().toISOString(),
                     tags: { ...(config.tags ?? {}) },
+                    ...buildTraceMeta(config),
                     error: err instanceof Error ? err.message : String(err),
                     ...(errorDetails ? { errorDetails } : {}),
                     requestMeta: buildGeminiRequestMeta(requestArgs),
@@ -750,6 +952,7 @@ function wrapGeminiNew(client, recorder, config) {
                 latencyMs: Date.now() - start,
                 timestamp: new Date().toISOString(),
                 tags: { ...(config.tags ?? {}) },
+                ...buildTraceMeta(config),
                 requestMeta: buildGeminiNewRequestMeta(requestArgs),
             });
             return result;
@@ -767,6 +970,7 @@ function wrapGeminiNew(client, recorder, config) {
                 latencyMs: Date.now() - start,
                 timestamp: new Date().toISOString(),
                 tags: { ...(config.tags ?? {}) },
+                ...buildTraceMeta(config),
                 error: err instanceof Error ? err.message : String(err),
                 ...(errorDetails ? { errorDetails } : {}),
                 requestMeta: buildGeminiNewRequestMeta(requestArgs),
@@ -805,6 +1009,7 @@ function wrapGeminiNew(client, recorder, config) {
                             latencyMs: Date.now() - start,
                             timestamp: new Date().toISOString(),
                             tags: { ...(config.tags ?? {}) },
+                            ...buildTraceMeta(config),
                             requestMeta: buildGeminiNewRequestMeta(requestArgs),
                         });
                     }
@@ -823,6 +1028,7 @@ function wrapGeminiNew(client, recorder, config) {
                             latencyMs: Date.now() - start,
                             timestamp: new Date().toISOString(),
                             tags: { ...(config.tags ?? {}) },
+                            ...buildTraceMeta(config),
                             error: err instanceof Error ? err.message : String(err),
                             ...(errorDetails ? { errorDetails } : {}),
                             requestMeta: buildGeminiNewRequestMeta(requestArgs),
@@ -844,6 +1050,7 @@ function wrapGeminiNew(client, recorder, config) {
                     latencyMs: Date.now() - start,
                     timestamp: new Date().toISOString(),
                     tags: { ...(config.tags ?? {}) },
+                    ...buildTraceMeta(config),
                     error: err instanceof Error ? err.message : String(err),
                     ...(errorDetails ? { errorDetails } : {}),
                     requestMeta: buildGeminiNewRequestMeta(requestArgs),