@argosvix/sdk 0.1.0

package/dist/client.js

@@ -0,0 +1,887 @@
+import { calculateCost } from "./pricing.js";
+import { Recorder } from "./recorder.js";
+const wrappedClients = new WeakMap();
+const wrappedGeminiModels = new WeakSet();
+/**
+ * Wrap an AI provider SDK client to transparently record every call.
+ *
+ * Supported: OpenAI (chat.completions + responses), Anthropic (messages),
+ * Mistral (chat.complete + chat.stream), Gemini (legacy `@google/generative-ai`
+ * + current `@google/genai`).
+ *
+ * Provider detection: constructor-name fingerprint with shape-based fallback.
+ * For composite or adapter clients, pass `config.provider` to override detection.
+ *
+ * Idempotency: wrapping the same client twice is a no-op.
+ *
+ * @example
+ * import OpenAI from "openai";
+ * import { wrap, getRecorder } from "@argosvix/sdk";
+ *
+ * const client = wrap(new OpenAI(), { apiKey: "...", tags: { service: "bot" } });
+ * const recorder = getRecorder(client);
+ */
+export function wrap(client, config = {}) {
+    if (wrappedClients.has(client)) {
+        return client;
+    }
+    const provider = detectProvider(client, config.provider);
+    if (provider === "unknown") {
+        return client;
+    }
+    const recorder = new Recorder(config);
+    switch (provider) {
+        case "openai": {
+            if (isOpenAIChatLike(client))
+                wrapOpenAIChat(client, recorder, config);
+            if (isOpenAIResponsesLike(client))
+                wrapOpenAIResponses(client, recorder, config);
+            break;
+        }
+        case "anthropic": {
+            if (isAnthropicLike(client))
+                wrapAnthropic(client, recorder, config);
+            break;
+        }
+        case "mistral": {
+            if (isMistralLike(client))
+                wrapMistral(client, recorder, config);
+            break;
+        }
+        case "gemini": {
+            if (isGeminiLegacyLike(client))
+                wrapGeminiLegacy(client, recorder, config);
+            if (isGeminiNewLike(client))
+                wrapGeminiNew(client, recorder, config);
+            break;
+        }
+    }
+    wrappedClients.set(client, recorder);
+    return client;
+}
+export function getRecorder(client) {
+    return wrappedClients.get(client) ?? null;
+}
+/**
+ * Resolve provider. config.provider override has priority; otherwise
+ * constructor name fingerprint, with shape-based check as final fallback.
+ * Returns "unknown" if no provider can be reliably identified.
+ */
+function detectProvider(client, override) {
+    if (override)
+        return override;
+    const ctorName = (client.constructor?.name ?? "").toLowerCase();
+    if (ctorName.includes("openai"))
+        return "openai";
+    if (ctorName.includes("anthropic"))
+        return "anthropic";
+    if (ctorName.includes("mistral"))
+        return "mistral";
+    if (ctorName.includes("googlegenai") ||
+        ctorName.includes("googlegenerativeai") ||
+        ctorName === "genai" ||
+        ctorName === "ai") {
+        return "gemini";
+    }
+    // Shape fallback for cases where constructor name is unavailable (e.g. generic Object).
+    if (isGeminiLegacyLike(client) || isGeminiNewLike(client))
+        return "gemini";
+    if (isAnthropicLike(client) && !isOpenAIChatLike(client) && !isMistralLike(client)) {
+        return "anthropic";
+    }
+    if (isMistralLike(client) && !isOpenAIChatLike(client))
+        return "mistral";
+    if (isOpenAIChatLike(client) || isOpenAIResponsesLike(client))
+        return "openai";
+    return "unknown";
+}
+function extractErrorDetails(err) {
+    if (!err || typeof err !== "object")
+        return undefined;
+    const e = err;
+    const details = {};
+    const status = e.status ?? e.statusCode;
+    if (typeof status === "number")
+        details.statusCode = status;
+    if (typeof e.code === "string")
+        details.code = e.code;
+    if (typeof e.type === "string")
+        details.type = e.type;
+    if (typeof e.param === "string")
+        details.param = e.param;
+    const retryAfterHeader = e.headers?.["retry-after"] ?? e.headers?.["Retry-After"];
+    if (retryAfterHeader) {
+        const n = Number(retryAfterHeader);
+        if (!Number.isNaN(n))
+            details.retryAfter = n;
+    }
+    return Object.keys(details).length > 0 ? details : undefined;
+}
+function isOpenAIChatLike(client) {
+    const c = client;
+    return typeof c?.chat?.completions?.create === "function";
+}
+function wrapOpenAIChat(client, recorder, config) {
+    const c = client;
+    const originalCreate = c.chat.completions.create.bind(c.chat.completions);
+    c.chat.completions.create = async function (...args) {
+        const start = Date.now();
+        const requestArgs = args[0] || {};
+        const id = generateId();
+        const isStream = requestArgs.stream === true;
+        try {
+            const response = await originalCreate(...args);
+            if (isStream) {
+                return wrapOpenAIStream(response, recorder, requestArgs, start, id, config);
+            }
+            const r = response;
+            const latencyMs = Date.now() - start;
+            const model = r.model || requestArgs.model || "unknown";
+            const promptTokens = r.usage?.prompt_tokens ?? 0;
+            const completionTokens = r.usage?.completion_tokens ?? 0;
+            recorder.record({
+                id,
+                provider: "openai",
+                model,
+                promptTokens,
+                completionTokens,
+                totalTokens: r.usage?.total_tokens ?? promptTokens + completionTokens,
+                costUsd: calculateCost("openai", model, promptTokens, completionTokens),
+                latencyMs,
+                timestamp: new Date().toISOString(),
+                tags: { ...(config.tags ?? {}) },
+                requestMeta: buildOpenAIRequestMeta(requestArgs),
+            });
+            return response;
+        }
+        catch (err) {
+            const errorDetails = extractErrorDetails(err);
+            recorder.record({
+                id,
+                provider: "openai",
+                model: requestArgs.model || "unknown",
+                promptTokens: 0,
+                completionTokens: 0,
+                totalTokens: 0,
+                costUsd: 0,
+                latencyMs: Date.now() - start,
+                timestamp: new Date().toISOString(),
+                tags: { ...(config.tags ?? {}) },
+                error: err instanceof Error ? err.message : String(err),
+                ...(errorDetails ? { errorDetails } : {}),
+                requestMeta: buildOpenAIRequestMeta(requestArgs),
+            });
+            throw err;
+        }
+    };
+}
+async function* wrapOpenAIStream(stream, recorder, requestArgs, start, id, config) {
+    let finalModel = requestArgs.model || "unknown";
+    let promptTokens = 0;
+    let completionTokens = 0;
+    let reportedTotal;
+    try {
+        for await (const chunk of stream) {
+            if (chunk.model)
+                finalModel = chunk.model;
+            if (chunk.usage) {
+                promptTokens = chunk.usage.prompt_tokens ?? promptTokens;
+                completionTokens = chunk.usage.completion_tokens ?? completionTokens;
+                if (typeof chunk.usage.total_tokens === "number") {
+                    reportedTotal = chunk.usage.total_tokens;
+                }
+            }
+            yield chunk;
+        }
+        recorder.record({
+            id,
+            provider: "openai",
+            model: finalModel,
+            promptTokens,
+            completionTokens,
+            totalTokens: reportedTotal ?? promptTokens + completionTokens,
+            costUsd: calculateCost("openai", finalModel, promptTokens, completionTokens),
+            latencyMs: Date.now() - start,
+            timestamp: new Date().toISOString(),
+            tags: { ...(config.tags ?? {}) },
+            requestMeta: buildOpenAIRequestMeta(requestArgs),
+        });
+    }
+    catch (err) {
+        const errorDetails = extractErrorDetails(err);
+        recorder.record({
+            id,
+            provider: "openai",
+            model: finalModel,
+            promptTokens,
+            completionTokens,
+            totalTokens: reportedTotal ?? promptTokens + completionTokens,
+            costUsd: calculateCost("openai", finalModel, promptTokens, completionTokens),
+            latencyMs: Date.now() - start,
+            timestamp: new Date().toISOString(),
+            tags: { ...(config.tags ?? {}) },
+            error: err instanceof Error ? err.message : String(err),
+            ...(errorDetails ? { errorDetails } : {}),
+            requestMeta: buildOpenAIRequestMeta(requestArgs),
+        });
+        throw err;
+    }
+}
+function buildOpenAIRequestMeta(requestArgs) {
+    const meta = {};
+    if (Array.isArray(requestArgs.messages))
+        meta.messagesCount = requestArgs.messages.length;
+    if (typeof requestArgs.temperature === "number")
+        meta.temperature = requestArgs.temperature;
+    const maxTokens = requestArgs.max_tokens ?? requestArgs.max_completion_tokens;
+    if (typeof maxTokens === "number")
+        meta.maxTokens = maxTokens;
+    return meta;
+}
+function isOpenAIResponsesLike(client) {
+    const c = client;
+    return typeof c?.responses?.create === "function";
+}
+function wrapOpenAIResponses(client, recorder, config) {
+    const c = client;
+    const originalCreate = c.responses.create.bind(c.responses);
+    c.responses.create = async function (...args) {
+        const start = Date.now();
+        const requestArgs = args[0] || {};
+        const id = generateId();
+        const isStream = requestArgs.stream === true;
+        if (isStream) {
+            // Note: responses API streaming support is deferred to a later phase.
+            // eslint-disable-next-line no-console
+            console.warn("[argosvix] responses.create with stream:true is not yet observed");
+            return originalCreate(...args);
+        }
+        try {
+            const response = (await originalCreate(...args));
+            const latencyMs = Date.now() - start;
+            const model = response.model || requestArgs.model || "unknown";
+            const promptTokens = response.usage?.input_tokens ?? 0;
+            const completionTokens = response.usage?.output_tokens ?? 0;
+            recorder.record({
+                id,
+                provider: "openai",
+                model,
+                promptTokens,
+                completionTokens,
+                totalTokens: response.usage?.total_tokens ?? promptTokens + completionTokens,
+                costUsd: calculateCost("openai", model, promptTokens, completionTokens),
+                latencyMs,
+                timestamp: new Date().toISOString(),
+                tags: { ...(config.tags ?? {}) },
+                requestMeta: buildResponsesRequestMeta(requestArgs),
+            });
+            return response;
+        }
+        catch (err) {
+            const errorDetails = extractErrorDetails(err);
+            recorder.record({
+                id,
+                provider: "openai",
+                model: requestArgs.model || "unknown",
+                promptTokens: 0,
+                completionTokens: 0,
+                totalTokens: 0,
+                costUsd: 0,
+                latencyMs: Date.now() - start,
+                timestamp: new Date().toISOString(),
+                tags: { ...(config.tags ?? {}) },
+                error: err instanceof Error ? err.message : String(err),
+                ...(errorDetails ? { errorDetails } : {}),
+                requestMeta: buildResponsesRequestMeta(requestArgs),
+            });
+            throw err;
+        }
+    };
+}
+function buildResponsesRequestMeta(requestArgs) {
+    const meta = {};
+    if (Array.isArray(requestArgs.input))
+        meta.messagesCount = requestArgs.input.length;
+    else if (typeof requestArgs.input === "string")
+        meta.messagesCount = 1;
+    if (typeof requestArgs.temperature === "number")
+        meta.temperature = requestArgs.temperature;
+    if (typeof requestArgs.max_output_tokens === "number")
+        meta.maxTokens = requestArgs.max_output_tokens;
+    return meta;
+}
+function isAnthropicLike(client) {
+    const c = client;
+    return typeof c?.messages?.create === "function";
+}
+function wrapAnthropic(client, recorder, config) {
+    const c = client;
+    const originalCreate = c.messages.create.bind(c.messages);
+    c.messages.create = async function (...args) {
+        const start = Date.now();
+        const requestArgs = args[0] || {};
+        const id = generateId();
+        const isStream = requestArgs.stream === true;
+        try {
+            const response = await originalCreate(...args);
+            if (isStream) {
+                return wrapAnthropicStream(response, recorder, requestArgs, start, id, config);
+            }
+            const r = response;
+            const latencyMs = Date.now() - start;
+            const model = r.model || requestArgs.model || "unknown";
+            const promptTokens = r.usage?.input_tokens ?? 0;
+            const completionTokens = r.usage?.output_tokens ?? 0;
+            recorder.record({
+                id,
+                provider: "anthropic",
+                model,
+                promptTokens,
+                completionTokens,
+                totalTokens: promptTokens + completionTokens,
+                costUsd: calculateCost("anthropic", model, promptTokens, completionTokens),
+                latencyMs,
+                timestamp: new Date().toISOString(),
+                tags: { ...(config.tags ?? {}) },
+                requestMeta: buildAnthropicRequestMeta(requestArgs),
+            });
+            return response;
+        }
+        catch (err) {
+            const errorDetails = extractErrorDetails(err);
+            recorder.record({
+                id,
+                provider: "anthropic",
+                model: requestArgs.model || "unknown",
+                promptTokens: 0,
+                completionTokens: 0,
+                totalTokens: 0,
+                costUsd: 0,
+                latencyMs: Date.now() - start,
+                timestamp: new Date().toISOString(),
+                tags: { ...(config.tags ?? {}) },
+                error: err instanceof Error ? err.message : String(err),
+                ...(errorDetails ? { errorDetails } : {}),
+                requestMeta: buildAnthropicRequestMeta(requestArgs),
+            });
+            throw err;
+        }
+    };
+}
+async function* wrapAnthropicStream(stream, recorder, requestArgs, start, id, config) {
+    let model = requestArgs.model || "unknown";
+    let promptTokens = 0;
+    let completionTokens = 0;
+    try {
+        for await (const event of stream) {
+            if (event.type === "message_start" && event.message) {
+                if (event.message.model)
+                    model = event.message.model;
+                if (event.message.usage) {
+                    promptTokens = event.message.usage.input_tokens ?? promptTokens;
+                    completionTokens = event.message.usage.output_tokens ?? completionTokens;
+                }
+            }
+            if (event.type === "message_delta" && event.usage) {
+                completionTokens = event.usage.output_tokens ?? completionTokens;
+            }
+            yield event;
+        }
+        recorder.record({
+            id,
+            provider: "anthropic",
+            model,
+            promptTokens,
+            completionTokens,
+            totalTokens: promptTokens + completionTokens,
+            costUsd: calculateCost("anthropic", model, promptTokens, completionTokens),
+            latencyMs: Date.now() - start,
+            timestamp: new Date().toISOString(),
+            tags: { ...(config.tags ?? {}) },
+            requestMeta: buildAnthropicRequestMeta(requestArgs),
+        });
+    }
+    catch (err) {
+        const errorDetails = extractErrorDetails(err);
+        recorder.record({
+            id,
+            provider: "anthropic",
+            model,
+            promptTokens,
+            completionTokens,
+            totalTokens: promptTokens + completionTokens,
+            costUsd: calculateCost("anthropic", model, promptTokens, completionTokens),
+            latencyMs: Date.now() - start,
+            timestamp: new Date().toISOString(),
+            tags: { ...(config.tags ?? {}) },
+            error: err instanceof Error ? err.message : String(err),
+            ...(errorDetails ? { errorDetails } : {}),
+            requestMeta: buildAnthropicRequestMeta(requestArgs),
+        });
+        throw err;
+    }
+}
+function buildAnthropicRequestMeta(requestArgs) {
+    const meta = {};
+    if (Array.isArray(requestArgs.messages))
+        meta.messagesCount = requestArgs.messages.length;
+    if (typeof requestArgs.temperature === "number")
+        meta.temperature = requestArgs.temperature;
+    if (typeof requestArgs.max_tokens === "number")
+        meta.maxTokens = requestArgs.max_tokens;
+    return meta;
+}
+function isMistralLike(client) {
+    const c = client;
+    return typeof c?.chat?.complete === "function";
+}
+function wrapMistral(client, recorder, config) {
+    const c = client;
+    const originalComplete = c.chat.complete.bind(c.chat);
+    c.chat.complete = async function (...args) {
+        const start = Date.now();
+        const requestArgs = args[0] || {};
+        const id = generateId();
+        try {
+            const response = (await originalComplete(...args));
+            const latencyMs = Date.now() - start;
+            const model = response.model || requestArgs.model || "unknown";
+            const promptTokens = response.usage?.prompt_tokens ?? 0;
+            const completionTokens = response.usage?.completion_tokens ?? 0;
+            recorder.record({
+                id,
+                provider: "mistral",
+                model,
+                promptTokens,
+                completionTokens,
+                totalTokens: response.usage?.total_tokens ?? promptTokens + completionTokens,
+                costUsd: calculateCost("mistral", model, promptTokens, completionTokens),
+                latencyMs,
+                timestamp: new Date().toISOString(),
+                tags: { ...(config.tags ?? {}) },
+                requestMeta: buildMistralRequestMeta(requestArgs),
+            });
+            return response;
+        }
+        catch (err) {
+            const errorDetails = extractErrorDetails(err);
+            recorder.record({
+                id,
+                provider: "mistral",
+                model: requestArgs.model || "unknown",
+                promptTokens: 0,
+                completionTokens: 0,
+                totalTokens: 0,
+                costUsd: 0,
+                latencyMs: Date.now() - start,
+                timestamp: new Date().toISOString(),
+                tags: { ...(config.tags ?? {}) },
+                error: err instanceof Error ? err.message : String(err),
+                ...(errorDetails ? { errorDetails } : {}),
+                requestMeta: buildMistralRequestMeta(requestArgs),
+            });
+            throw err;
+        }
+    };
+    if (typeof c.chat.stream === "function") {
+        const originalStream = c.chat.stream.bind(c.chat);
+        c.chat.stream = async function (...args) {
+            const start = Date.now();
+            const requestArgs = args[0] || {};
+            const id = generateId();
+            try {
+                const stream = (await originalStream(...args));
+                return wrapMistralStream(stream, recorder, requestArgs, start, id, config);
+            }
+            catch (err) {
+                // H-2: stream initialization error (= auth/validation/connection)
+                const errorDetails = extractErrorDetails(err);
+                recorder.record({
+                    id,
+                    provider: "mistral",
+                    model: requestArgs.model || "unknown",
+                    promptTokens: 0,
+                    completionTokens: 0,
+                    totalTokens: 0,
+                    costUsd: 0,
+                    latencyMs: Date.now() - start,
+                    timestamp: new Date().toISOString(),
+                    tags: { ...(config.tags ?? {}) },
+                    error: err instanceof Error ? err.message : String(err),
+                    ...(errorDetails ? { errorDetails } : {}),
+                    requestMeta: buildMistralRequestMeta(requestArgs),
+                });
+                throw err;
+            }
+        };
+    }
+}
+async function* wrapMistralStream(stream, recorder, requestArgs, start, id, config) {
+    let model = requestArgs.model || "unknown";
+    let promptTokens = 0;
+    let completionTokens = 0;
+    let reportedTotal;
+    try {
+        for await (const chunk of stream) {
+            const inner = chunk.data ?? chunk;
+            if (inner.model)
+                model = inner.model;
+            if (inner.usage) {
+                promptTokens = inner.usage.prompt_tokens ?? promptTokens;
+                completionTokens = inner.usage.completion_tokens ?? completionTokens;
+                if (typeof inner.usage.total_tokens === "number") {
+                    reportedTotal = inner.usage.total_tokens;
+                }
+            }
+            yield chunk;
+        }
+        recorder.record({
+            id,
+            provider: "mistral",
+            model,
+            promptTokens,
+            completionTokens,
+            totalTokens: reportedTotal ?? promptTokens + completionTokens,
+            costUsd: calculateCost("mistral", model, promptTokens, completionTokens),
+            latencyMs: Date.now() - start,
+            timestamp: new Date().toISOString(),
+            tags: { ...(config.tags ?? {}) },
+            requestMeta: buildMistralRequestMeta(requestArgs),
+        });
+    }
+    catch (err) {
+        const errorDetails = extractErrorDetails(err);
+        recorder.record({
+            id,
+            provider: "mistral",
+            model,
+            promptTokens,
+            completionTokens,
+            totalTokens: reportedTotal ?? promptTokens + completionTokens,
+            costUsd: calculateCost("mistral", model, promptTokens, completionTokens),
+            latencyMs: Date.now() - start,
+            timestamp: new Date().toISOString(),
+            tags: { ...(config.tags ?? {}) },
+            error: err instanceof Error ? err.message : String(err),
+            ...(errorDetails ? { errorDetails } : {}),
+            requestMeta: buildMistralRequestMeta(requestArgs),
+        });
+        throw err;
+    }
+}
+function buildMistralRequestMeta(requestArgs) {
+    const meta = {};
+    if (Array.isArray(requestArgs.messages))
+        meta.messagesCount = requestArgs.messages.length;
+    if (typeof requestArgs.temperature === "number")
+        meta.temperature = requestArgs.temperature;
+    if (typeof requestArgs.max_tokens === "number")
+        meta.maxTokens = requestArgs.max_tokens;
+    return meta;
+}
+function isGeminiLegacyLike(client) {
+    const c = client;
+    return typeof c?.getGenerativeModel === "function";
+}
+function wrapGeminiLegacy(client, recorder, config) {
+    const c = client;
+    const originalGetModel = c.getGenerativeModel.bind(c);
+    c.getGenerativeModel = function (params) {
+        const modelInstance = originalGetModel(params);
+        // Idempotent re-wrap: track model instances via WeakSet to avoid double-wrap.
+        if (wrappedGeminiModels.has(modelInstance)) {
+            return modelInstance;
+        }
+        wrappedGeminiModels.add(modelInstance);
+        wrapGeminiLegacyModel(modelInstance, params.model, recorder, config);
+        return modelInstance;
+    };
+}
+function wrapGeminiLegacyModel(model, modelName, recorder, config) {
+    const originalGenerate = model.generateContent.bind(model);
+    model.generateContent = async function (...args) {
+        const start = Date.now();
+        const id = generateId();
+        const requestArgs = args[0];
+        try {
+            const result = (await originalGenerate(...args));
+            const usage = result.response?.usageMetadata;
+            const promptTokens = usage?.promptTokenCount ?? 0;
+            const completionTokens = usage?.candidatesTokenCount ?? 0;
+            recorder.record({
+                id,
+                provider: "gemini",
+                model: modelName,
+                promptTokens,
+                completionTokens,
+                totalTokens: usage?.totalTokenCount ?? promptTokens + completionTokens,
+                costUsd: calculateCost("gemini", modelName, promptTokens, completionTokens),
+                latencyMs: Date.now() - start,
+                timestamp: new Date().toISOString(),
+                tags: { ...(config.tags ?? {}) },
+                requestMeta: buildGeminiRequestMeta(requestArgs),
+            });
+            return result;
+        }
+        catch (err) {
+            const errorDetails = extractErrorDetails(err);
+            recorder.record({
+                id,
+                provider: "gemini",
+                model: modelName,
+                promptTokens: 0,
+                completionTokens: 0,
+                totalTokens: 0,
+                costUsd: 0,
+                latencyMs: Date.now() - start,
+                timestamp: new Date().toISOString(),
+                tags: { ...(config.tags ?? {}) },
+                error: err instanceof Error ? err.message : String(err),
+                ...(errorDetails ? { errorDetails } : {}),
+                requestMeta: buildGeminiRequestMeta(requestArgs),
+            });
+            throw err;
+        }
+    };
+    if (typeof model.generateContentStream === "function") {
+        const originalStream = model.generateContentStream.bind(model);
+        model.generateContentStream = async function (...args) {
+            const start = Date.now();
+            const id = generateId();
+            const requestArgs = args[0];
+            try {
+                const result = (await originalStream(...args));
+                if (!result.stream)
+                    return result;
+                // C-2 fix: wrap stream with our async iterator + record in finally
+                const originalStreamRef = result.stream;
+                const wrappedStream = (async function* () {
+                    try {
+                        for await (const chunk of originalStreamRef) {
+                            yield chunk;
+                        }
+                        const finalResponse = await result.response;
+                        const usage = finalResponse?.usageMetadata;
+                        const promptTokens = usage?.promptTokenCount ?? 0;
+                        const completionTokens = usage?.candidatesTokenCount ?? 0;
+                        recorder.record({
+                            id,
+                            provider: "gemini",
+                            model: modelName,
+                            promptTokens,
+                            completionTokens,
+                            totalTokens: usage?.totalTokenCount ?? promptTokens + completionTokens,
+                            costUsd: calculateCost("gemini", modelName, promptTokens, completionTokens),
+                            latencyMs: Date.now() - start,
+                            timestamp: new Date().toISOString(),
+                            tags: { ...(config.tags ?? {}) },
+                            requestMeta: buildGeminiRequestMeta(requestArgs),
+                        });
+                    }
+                    catch (err) {
+                        const errorDetails = extractErrorDetails(err);
+                        recorder.record({
+                            id,
+                            provider: "gemini",
+                            model: modelName,
+                            promptTokens: 0,
+                            completionTokens: 0,
+                            totalTokens: 0,
+                            costUsd: 0,
+                            latencyMs: Date.now() - start,
+                            timestamp: new Date().toISOString(),
+                            tags: { ...(config.tags ?? {}) },
+                            error: err instanceof Error ? err.message : String(err),
+                            ...(errorDetails ? { errorDetails } : {}),
+                            requestMeta: buildGeminiRequestMeta(requestArgs),
+                        });
+                        throw err;
+                    }
+                })();
+                return { ...result, stream: wrappedStream };
+            }
+            catch (err) {
+                const errorDetails = extractErrorDetails(err);
+                recorder.record({
+                    id,
+                    provider: "gemini",
+                    model: modelName,
+                    promptTokens: 0,
+                    completionTokens: 0,
+                    totalTokens: 0,
+                    costUsd: 0,
+                    latencyMs: Date.now() - start,
+                    timestamp: new Date().toISOString(),
+                    tags: { ...(config.tags ?? {}) },
+                    error: err instanceof Error ? err.message : String(err),
+                    ...(errorDetails ? { errorDetails } : {}),
+                    requestMeta: buildGeminiRequestMeta(requestArgs),
+                });
+                throw err;
+            }
+        };
+    }
+}
+function isGeminiNewLike(client) {
+    const c = client;
+    return typeof c?.models?.generateContent === "function";
+}
+function wrapGeminiNew(client, recorder, config) {
+    const c = client;
+    const originalGenerate = c.models.generateContent.bind(c.models);
+    c.models.generateContent = async function (...args) {
+        const start = Date.now();
+        const id = generateId();
+        const requestArgs = args[0] || {};
+        const modelName = requestArgs.model || "unknown";
+        try {
+            const result = (await originalGenerate(...args));
+            const usage = result.usageMetadata;
+            const promptTokens = usage?.promptTokenCount ?? 0;
+            const completionTokens = usage?.candidatesTokenCount ?? 0;
+            recorder.record({
+                id,
+                provider: "gemini",
+                model: modelName,
+                promptTokens,
+                completionTokens,
+                totalTokens: usage?.totalTokenCount ?? promptTokens + completionTokens,
+                costUsd: calculateCost("gemini", modelName, promptTokens, completionTokens),
+                latencyMs: Date.now() - start,
+                timestamp: new Date().toISOString(),
+                tags: { ...(config.tags ?? {}) },
+                requestMeta: buildGeminiNewRequestMeta(requestArgs),
+            });
+            return result;
+        }
+        catch (err) {
+            const errorDetails = extractErrorDetails(err);
+            recorder.record({
+                id,
+                provider: "gemini",
+                model: modelName,
+                promptTokens: 0,
+                completionTokens: 0,
+                totalTokens: 0,
+                costUsd: 0,
+                latencyMs: Date.now() - start,
+                timestamp: new Date().toISOString(),
+                tags: { ...(config.tags ?? {}) },
+                error: err instanceof Error ? err.message : String(err),
+                ...(errorDetails ? { errorDetails } : {}),
+                requestMeta: buildGeminiNewRequestMeta(requestArgs),
+            });
+            throw err;
+        }
+    };
+    if (typeof c.models.generateContentStream === "function") {
+        const originalStream = c.models.generateContentStream.bind(c.models);
+        c.models.generateContentStream = async function (...args) {
+            const start = Date.now();
+            const id = generateId();
+            const requestArgs = args[0] || {};
+            const modelName = requestArgs.model || "unknown";
+            try {
+                const stream = (await originalStream(...args));
+                // C-2 + H-3 fix: AsyncGenerator wrap with finally-record + error tied to consumption
+                return (async function* () {
+                    let lastUsage;
+                    try {
+                        for await (const chunk of stream) {
+                            if (chunk.usageMetadata)
+                                lastUsage = chunk.usageMetadata;
+                            yield chunk;
+                        }
+                        const promptTokens = lastUsage?.promptTokenCount ?? 0;
+                        const completionTokens = lastUsage?.candidatesTokenCount ?? 0;
+                        recorder.record({
+                            id,
+                            provider: "gemini",
+                            model: modelName,
+                            promptTokens,
+                            completionTokens,
+                            totalTokens: lastUsage?.totalTokenCount ?? promptTokens + completionTokens,
+                            costUsd: calculateCost("gemini", modelName, promptTokens, completionTokens),
+                            latencyMs: Date.now() - start,
+                            timestamp: new Date().toISOString(),
+                            tags: { ...(config.tags ?? {}) },
+                            requestMeta: buildGeminiNewRequestMeta(requestArgs),
+                        });
+                    }
+                    catch (err) {
+                        const errorDetails = extractErrorDetails(err);
+                        recorder.record({
+                            id,
+                            provider: "gemini",
+                            model: modelName,
+                            promptTokens: lastUsage?.promptTokenCount ?? 0,
+                            completionTokens: lastUsage?.candidatesTokenCount ?? 0,
+                            totalTokens: lastUsage?.totalTokenCount ??
+                                (lastUsage?.promptTokenCount ?? 0) +
+                                    (lastUsage?.candidatesTokenCount ?? 0),
+                            costUsd: 0,
+                            latencyMs: Date.now() - start,
+                            timestamp: new Date().toISOString(),
+                            tags: { ...(config.tags ?? {}) },
+                            error: err instanceof Error ? err.message : String(err),
+                            ...(errorDetails ? { errorDetails } : {}),
+                            requestMeta: buildGeminiNewRequestMeta(requestArgs),
+                        });
+                        throw err;
+                    }
+                })();
+            }
+            catch (err) {
+                const errorDetails = extractErrorDetails(err);
+                recorder.record({
+                    id,
+                    provider: "gemini",
+                    model: modelName,
+                    promptTokens: 0,
+                    completionTokens: 0,
+                    totalTokens: 0,
+                    costUsd: 0,
+                    latencyMs: Date.now() - start,
+                    timestamp: new Date().toISOString(),
+                    tags: { ...(config.tags ?? {}) },
+                    error: err instanceof Error ? err.message : String(err),
+                    ...(errorDetails ? { errorDetails } : {}),
+                    requestMeta: buildGeminiNewRequestMeta(requestArgs),
+                });
+                throw err;
+            }
+        };
+    }
+}
+function buildGeminiRequestMeta(requestArgs) {
+    const meta = {};
+    if (typeof requestArgs === "string")
+        meta.messagesCount = 1;
+    else if (Array.isArray(requestArgs))
+        meta.messagesCount = requestArgs.length;
+    else if (requestArgs &&
+        typeof requestArgs === "object" &&
+        "contents" in requestArgs &&
+        Array.isArray(requestArgs.contents)) {
+        meta.messagesCount = requestArgs.contents.length;
+    }
+    return meta;
+}
+function buildGeminiNewRequestMeta(requestArgs) {
+    const meta = {};
+    if (Array.isArray(requestArgs.contents)) {
+        meta.messagesCount = requestArgs.contents.length;
+    }
+    else if (typeof requestArgs.contents === "string") {
+        meta.messagesCount = 1;
+    }
+    return meta;
+}
+/**
+ * Lightweight ID generator (not strictly ULID-compatible). Will be swapped for
+ * the `ulid` library in a later release.
+ */
+function generateId() {
+    return `${Date.now().toString(36)}${Math.random().toString(36).slice(2, 10)}`;
+}
+//# sourceMappingURL=client.js.map