@sensu-ai/sdk 0.1.5 → 0.5.0

package/dist/client.js

@@ -0,0 +1,837 @@
+import { randomUUID } from 'crypto';
+// ---------------------------------------------------------------------------
+// StepHandle — fluent API for a single step
+// ---------------------------------------------------------------------------
+export class StepHandle {
+    client;
+    stepId;
+    runId;
+    sessionId;
+    agentId;
+    orgId;
+    traceId;
+    spanId;
+    sequence;
+    stepName;
+    ended = false;
+    constructor(client, opts) {
+        this.client = client;
+        this.stepId = opts.stepId;
+        this.runId = opts.runId;
+        this.sessionId = opts.sessionId;
+        this.agentId = opts.agentId;
+        this.orgId = opts.orgId;
+        this.traceId = opts.traceId;
+        this.spanId = opts.spanId;
+        this.sequence = opts.sequence;
+        this.stepName = opts.name;
+    }
+    base() {
+        return {
+            event_id: randomUUID(),
+            timestamp: new Date().toISOString(),
+            org_id: this.orgId,
+            agent_id: this.agentId,
+            session_id: this.sessionId,
+            run_id: this.runId,
+            step_id: this.stepId,
+            trace_id: this.traceId,
+            span_id: randomUUID(),
+            parent_span_id: this.spanId,
+        };
+    }
+    /** Track an LLM call — wraps fn(), measures latency, emits event */
+    async trackLlm(opts) {
+        const startMs = Date.now();
+        const spanId = randomUUID();
+        const llmCallId = opts.llmCallId ?? randomUUID();
+        this.client.enqueue({
+            ...this.base(),
+            span_id: spanId,
+            event_type: 'llm.request.started',
+            provider: opts.provider,
+            model: opts.model,
+            max_context_tokens: opts.maxContextTokens,
+        });
+        let result;
+        let status = 'success';
+        let err;
+        try {
+            result = await opts.fn();
+        }
+        catch (e) {
+            status = 'error';
+            err = e;
+        }
+        const latencyMs = Date.now() - startMs;
+        // Try to extract token usage from common response shapes
+        const usage = extractUsage(result, opts.model);
+        const contextBreakdown = opts.extractContextBreakdown?.(result);
+        // Override cost estimate with live pricing when tokens are known
+        const inputTok = usage['input_tokens'] ?? 0;
+        const outputTok = usage['output_tokens'] ?? 0;
+        if (inputTok > 0 || outputTok > 0) {
+            try {
+                const [inputRate, outputRate] = await this.client.resolvePricing(opts.provider, opts.model);
+                usage['cost_usd_estimate'] =
+                    (inputTok / 1_000_000) * inputRate + (outputTok / 1_000_000) * outputRate;
+            }
+            catch {
+                // keep bundled estimate on failure
+            }
+        }
+        this.client.enqueue({
+            ...this.base(),
+            span_id: spanId,
+            event_type: 'llm.request.completed',
+            llm_call_id: llmCallId,
+            provider: opts.provider,
+            model: opts.model,
+            max_context_tokens: opts.maxContextTokens,
+            latency_ms: latencyMs,
+            status,
+            ...usage,
+            ...(contextBreakdown ? { context_breakdown: contextBreakdown } : {}),
+            ...(opts.messagesSnapshot?.length ? { messages_snapshot: opts.messagesSnapshot } : {}),
+            ...(opts.referencedChunkIds?.length ? { referenced_chunk_ids: opts.referencedChunkIds } : {}),
+        });
+        if (err)
+            throw err;
+        return result;
+    }
+    /**
+     * Track a streaming LLM call — consumes the async iterable, measures TTFT,
+     * and emits stream.token.received events as tokens arrive.
+     * Returns the full concatenated text.
+     */
+    async trackStreamingLlm(opts) {
+        const startMs = Date.now();
+        const llmCallId = opts.llmCallId ?? randomUUID();
+        const emitEvery = opts.emitEveryNTokens ?? 10;
+        const spanId = randomUUID();
+        this.client.enqueue({
+            ...this.base(),
+            span_id: spanId,
+            event_type: 'llm.request.started',
+            provider: opts.provider,
+            model: opts.model,
+            max_context_tokens: opts.maxContextTokens,
+            stream: true,
+        });
+        let ttftMs;
+        let tokenCount = 0;
+        let accumulated = '';
+        for await (const chunk of opts.stream) {
+            // Capture time-to-first-token on the very first chunk
+            if (ttftMs === undefined) {
+                ttftMs = Date.now() - startMs;
+            }
+            // Extract text from common chunk shapes (Anthropic / OpenAI streaming)
+            const text = extractStreamChunkText(chunk);
+            if (text) {
+                accumulated += text;
+                tokenCount++;
+            }
+            // Emit stream.token.received every N tokens
+            if (tokenCount > 0 && tokenCount % emitEvery === 0) {
+                this.client.enqueue({
+                    ...this.base(),
+                    event_type: 'stream.token.received',
+                    llm_call_id: llmCallId,
+                    tokens_so_far: tokenCount,
+                    ttft_ms: ttftMs,
+                });
+            }
+        }
+        const latencyMs = Date.now() - startMs;
+        this.client.enqueue({
+            ...this.base(),
+            span_id: spanId,
+            event_type: 'llm.request.completed',
+            llm_call_id: llmCallId,
+            provider: opts.provider,
+            model: opts.model,
+            max_context_tokens: opts.maxContextTokens,
+            latency_ms: latencyMs,
+            ttft_ms: ttftMs,
+            streamed: true,
+            status: 'success',
+        });
+        opts.onComplete?.(accumulated, ttftMs);
+        return accumulated;
+    }
+    /** Emit a raw LLM call event (when you have the stats already) */
+    recordLlm(opts) {
+        const { contextBreakdown, ...rest } = opts;
+        this.client.enqueue({
+            ...this.base(),
+            event_type: 'llm.request.completed',
+            ...rest,
+            ...(contextBreakdown ? { context_breakdown: contextBreakdown } : {}),
+        });
+    }
+    /** Track a tool call — wraps fn(), measures latency */
+    async trackTool(opts) {
+        const startMs = Date.now();
+        const toolCallId = randomUUID();
+        let result;
+        let status = 'success';
+        let err;
+        this.client.enqueue({
+            ...this.base(),
+            event_type: 'tool.call.started',
+            tool_name: opts.toolName,
+            tool_call_id: toolCallId,
+            retry_of: opts.retryOf,
+        });
+        try {
+            result = await opts.fn();
+        }
+        catch (e) {
+            status = 'error';
+            err = e;
+        }
+        const latencyMs = Date.now() - startMs;
+        const outputSize = estimateBytes(result);
+        this.client.enqueue({
+            ...this.base(),
+            event_type: 'tool.call.completed',
+            tool_name: opts.toolName,
+            latency_ms: latencyMs,
+            status,
+            output_size_bytes: outputSize,
+            tool_call_id: toolCallId,
+            retry_of: opts.retryOf,
+        });
+        this.client.notifyToolCall(this.runId, opts.toolName);
+        if (err)
+            throw err;
+        return result;
+    }
+    /** Track a retrieval call — wraps fn(), measures latency, emits started + completed */
+    async trackRetrieval(opts) {
+        const startMs = Date.now();
+        const spanId = randomUUID();
+        this.client.enqueue({
+            ...this.base(),
+            span_id: spanId,
+            event_type: 'retrieval.started',
+            vector_store_id: opts.vectorStoreId,
+            top_k: opts.topK,
+        });
+        let result;
+        let status = 'success';
+        let err;
+        try {
+            result = await opts.fn();
+        }
+        catch (e) {
+            status = 'error';
+            err = e;
+        }
+        const latencyMs = Date.now() - startMs;
+        this.client.enqueue({
+            ...this.base(),
+            span_id: spanId,
+            event_type: 'retrieval.completed',
+            vector_store_id: opts.vectorStoreId,
+            top_k: opts.topK,
+            latency_ms: latencyMs,
+            status,
+        });
+        if (err)
+            throw err;
+        return result;
+    }
+    /** Emit a raw retrieval completed event (when you have the stats already) */
+    recordRetrieval(opts) {
+        const chunks = opts.chunks;
+        this.client.enqueue({
+            ...this.base(),
+            event_type: 'retrieval.completed',
+            vector_store_id: opts.vectorStoreId,
+            top_k: opts.topK,
+            latency_ms: opts.latencyMs,
+            chunks_returned: opts.chunksReturned,
+            tokens_injected: opts.tokensInjected,
+            similarity_score_avg: opts.similarityScoreAvg,
+            status: opts.status,
+            ...(chunks?.length ? { chunks } : {}),
+        });
+    }
+    /** Track an embedding call — wraps fn(), measures latency */
+    async trackEmbedding(opts) {
+        const startMs = Date.now();
+        let result;
+        let err;
+        try {
+            result = await opts.fn();
+        }
+        catch (e) {
+            err = e;
+        }
+        const latencyMs = Date.now() - startMs;
+        this.client.enqueue({
+            ...this.base(),
+            event_type: 'embedding.created',
+            model: opts.model,
+            input_text_length: opts.inputTextLength,
+            batch_size: opts.batchSize,
+            latency_ms: latencyMs,
+        });
+        if (err)
+            throw err;
+        return result;
+    }
+    /** Emit a raw embedding event */
+    recordEmbedding(opts) {
+        this.client.enqueue({
+            ...this.base(),
+            event_type: 'embedding.created',
+            model: opts.model,
+            input_text_length: opts.inputTextLength,
+            token_count: opts.tokenCount,
+            latency_ms: opts.latencyMs,
+            cost_usd_estimate: opts.costUsdEstimate,
+            batch_size: opts.batchSize,
+        });
+    }
+    /** Track a guardrail check — wraps fn(), measures latency, handles block */
+    async trackGuardrail(opts) {
+        const startMs = Date.now();
+        this.client.enqueue({
+            ...this.base(),
+            event_type: 'guardrail.check.started',
+            guardrail_id: opts.guardrailId,
+            guardrail_type: opts.guardrailType,
+            input_hash: opts.inputHash,
+        });
+        let result = 'pass';
+        let err;
+        try {
+            result = await opts.fn();
+        }
+        catch (e) {
+            err = e;
+        }
+        const latencyMs = Date.now() - startMs;
+        this.client.enqueue({
+            ...this.base(),
+            event_type: 'guardrail.check.completed',
+            guardrail_id: opts.guardrailId,
+            guardrail_type: opts.guardrailType,
+            input_hash: opts.inputHash,
+            result,
+            latency_ms: latencyMs,
+        });
+        if (err)
+            throw err;
+        return result;
+    }
+    /** Emit a raw guardrail result (check or block) */
+    recordGuardrail(opts) {
+        if (opts.blocked) {
+            this.client.enqueue({
+                ...this.base(),
+                event_type: 'guardrail.blocked',
+                guardrail_id: opts.guardrailId,
+                guardrail_type: opts.guardrailType,
+                input_hash: opts.inputHash,
+                block_reason: opts.blockReason,
+                severity: opts.severity,
+            });
+        }
+        else {
+            this.client.enqueue({
+                ...this.base(),
+                event_type: 'guardrail.check.completed',
+                guardrail_id: opts.guardrailId,
+                guardrail_type: opts.guardrailType,
+                input_hash: opts.inputHash,
+                result: opts.result,
+                latency_ms: opts.latencyMs,
+            });
+        }
+    }
+    /** Record a prompt template render event */
+    recordPromptRender(opts) {
+        this.client.enqueue({
+            ...this.base(),
+            event_type: 'prompt.rendered',
+            template_id: opts.templateId,
+            template_version: opts.templateVersion,
+            rendered_token_count: opts.renderedTokenCount,
+            variable_count: opts.variableCount,
+            latency_ms: opts.latencyMs,
+        });
+    }
+    async end() {
+        if (this.ended)
+            return;
+        this.ended = true;
+        this.client.enqueue({
+            ...this.base(),
+            event_type: 'agent.step.completed',
+        });
+        await this.client.flush();
+    }
+}
+// ---------------------------------------------------------------------------
+// RunHandle — fluent API for a single run
+// ---------------------------------------------------------------------------
+export class RunHandle {
+    client;
+    runId;
+    sessionId;
+    agentId;
+    orgId;
+    traceId;
+    spanId;
+    stepCount = 0;
+    ended = false;
+    constructor(client, opts) {
+        this.client = client;
+        this.runId = opts.runId;
+        this.sessionId = opts.sessionId;
+        this.agentId = opts.agentId;
+        this.orgId = opts.orgId;
+        this.traceId = opts.traceId;
+        this.spanId = opts.spanId;
+    }
+    base() {
+        return {
+            event_id: randomUUID(),
+            timestamp: new Date().toISOString(),
+            org_id: this.orgId,
+            agent_id: this.agentId,
+            session_id: this.sessionId,
+            run_id: this.runId,
+            trace_id: this.traceId,
+            span_id: randomUUID(),
+            parent_span_id: this.spanId,
+        };
+    }
+    startStep(opts = {}) {
+        const stepId = opts.stepId ?? randomUUID();
+        const sequence = this.stepCount++;
+        this.client.enqueue({
+            ...this.base(),
+            step_id: stepId,
+            event_type: 'agent.step.started',
+            step_type: opts.stepType ?? 'llm',
+            step_name: opts.name,
+            sequence: opts.sequence ?? sequence,
+        });
+        return new StepHandle(this.client, {
+            stepId,
+            runId: this.runId,
+            sessionId: this.sessionId,
+            agentId: this.agentId,
+            orgId: this.orgId,
+            traceId: this.traceId,
+            spanId: this.spanId,
+            sequence: opts.sequence ?? sequence,
+            name: opts.name,
+        });
+    }
+    /** Record user feedback for this run */
+    recordFeedback(opts) {
+        this.client.enqueue({
+            ...this.base(),
+            event_type: 'feedback.received',
+            type: opts.type,
+            score: opts.score,
+            comment: opts.comment,
+            end_user_id: opts.endUserId,
+        });
+    }
+    /** Record an automated eval score for this run */
+    recordEvalScore(opts) {
+        this.client.enqueue({
+            ...this.base(),
+            event_type: 'eval.score.recorded',
+            metric: opts.metric,
+            score: opts.score,
+            evaluator_id: opts.evaluatorId,
+            model_used_for_eval: opts.modelUsedForEval,
+            ...(opts.stepId ? { step_id: opts.stepId } : {}),
+            ...(opts.llmCallId ? { llm_call_id: opts.llmCallId } : {}),
+        });
+    }
+    /** Emit an agent.handoff event from this run to another agent */
+    handoff(opts) {
+        this.client.enqueue({
+            ...this.base(),
+            event_type: 'agent.handoff',
+            to_agent_id: opts.toAgentId,
+            reason: opts.reason,
+            context_tokens_transferred: opts.contextTokensTransferred,
+        });
+    }
+    async end(status = 'completed') {
+        if (this.ended)
+            return;
+        this.ended = true;
+        const eventType = status === 'completed' ? 'agent.run.completed' : 'agent.run.failed';
+        this.client.enqueue({ ...this.base(), event_type: eventType });
+        this.client.clearRunLoopState(this.runId);
+        await this.client.flush();
+    }
+}
+// ---------------------------------------------------------------------------
+// SensuClient
+// ---------------------------------------------------------------------------
+export class SensuClient {
+    apiKey;
+    baseUrl;
+    agentId;
+    orgId;
+    batchSize;
+    flushIntervalMs;
+    disabled;
+    disableLivePricing;
+    onLoopDetected;
+    loopThreshold;
+    // runId → toolName → call count within that run
+    runToolCallCounts = new Map();
+    // provider:model → [inputPricePer1M, outputPricePer1M]
+    pricingCache = new Map();
+    buffer = [];
+    flushTimer = null;
+    constructor(opts = {}) {
+        const fromEnv = opts.fromEnv ?? false;
+        this.apiKey =
+            opts.apiKey ??
+                (fromEnv ? (process.env.SENSU_API_KEY ?? '') : '');
+        this.baseUrl =
+            opts.baseUrl ??
+                (fromEnv
+                    ? (process.env.SENSU_BASE_URL ?? 'http://localhost:3001')
+                    : 'http://localhost:3001');
+        this.agentId =
+            opts.agentId ??
+                (fromEnv ? (process.env.SENSU_AGENT_ID ?? 'unknown-agent') : 'unknown-agent');
+        this.orgId =
+            opts.orgId ??
+                (fromEnv ? (process.env.SENSU_ORG_ID ?? '') : '');
+        this.batchSize = opts.batchSize ?? 10;
+        this.flushIntervalMs = opts.flushIntervalMs ?? 2000;
+        this.disabled = opts.disabled ?? false;
+        this.disableLivePricing = opts.disableLivePricing ?? false;
+        this.onLoopDetected = opts.onLoopDetected;
+        this.loopThreshold = opts.loopThreshold ?? 5;
+        if (!this.disabled) {
+            this.flushTimer = setInterval(() => {
+                void this.flush();
+            }, this.flushIntervalMs);
+            if (this.flushTimer.unref)
+                this.flushTimer.unref();
+        }
+    }
+    /** Enqueue an event for batched sending */
+    enqueue(event) {
+        if (this.disabled)
+            return;
+        this.buffer.push(event);
+        if (this.buffer.length >= this.batchSize) {
+            void this.flush();
+        }
+    }
+    /** Flush all buffered events to the Sensu API */
+    async flush() {
+        if (this.disabled || this.buffer.length === 0)
+            return;
+        const events = this.buffer.splice(0);
+        try {
+            const res = await fetch(`${this.baseUrl}/api/v1/events`, {
+                method: 'POST',
+                headers: {
+                    'Content-Type': 'application/json',
+                    'X-API-Key': this.apiKey,
+                },
+                body: JSON.stringify({ events }),
+            });
+            if (!res.ok) {
+                const body = await res.text();
+                console.error(`[sensu:sdk] flush failed ${res.status}: ${body}`);
+            }
+        }
+        catch (err) {
+            // Re-queue on network error (best-effort)
+            console.error('[sensu:sdk] flush network error:', err);
+            this.buffer.unshift(...events);
+        }
+    }
+    /** Track a tool call for loop detection; fires onLoopDetected when threshold is reached. */
+    notifyToolCall(runId, toolName) {
+        if (!this.onLoopDetected)
+            return;
+        let runMap = this.runToolCallCounts.get(runId);
+        if (!runMap) {
+            runMap = new Map();
+            this.runToolCallCounts.set(runId, runMap);
+        }
+        const count = (runMap.get(toolName) ?? 0) + 1;
+        runMap.set(toolName, count);
+        if (count >= this.loopThreshold) {
+            this.onLoopDetected(toolName, count);
+        }
+    }
+    /** Remove per-run loop counters when the run ends to avoid memory leaks. */
+    clearRunLoopState(runId) {
+        this.runToolCallCounts.delete(runId);
+    }
+    /** Start a new agent run */
+    startRun(opts = {}) {
+        const runId = opts.runId ?? randomUUID();
+        const sessionId = opts.sessionId ?? randomUUID();
+        const traceId = randomUUID();
+        const spanId = randomUUID();
+        this.enqueue({
+            event_id: randomUUID(),
+            event_type: 'agent.run.started',
+            timestamp: new Date().toISOString(),
+            org_id: this.orgId,
+            agent_id: this.agentId,
+            session_id: sessionId,
+            run_id: runId,
+            trace_id: traceId,
+            span_id: spanId,
+            run_type: opts.runType,
+            end_user_id: opts.endUserId,
+        });
+        return new RunHandle(this, {
+            runId,
+            sessionId,
+            agentId: this.agentId,
+            orgId: this.orgId,
+            traceId,
+            spanId,
+        });
+    }
+    /**
+     * Spawn a child agent run from within a parent run.
+     * Emits `agent.spawned` on the parent and returns a RunHandle for the child.
+     */
+    spawnRun(parentRun, opts) {
+        const childRunId = opts.childRunId ?? randomUUID();
+        const childAgentId = opts.childAgentId;
+        const sessionId = opts.sessionId ?? parentRun.sessionId;
+        const traceId = parentRun.traceId;
+        const spanId = randomUUID();
+        // Emit agent.spawned on the parent run
+        this.enqueue({
+            event_id: randomUUID(),
+            event_type: 'agent.spawned',
+            timestamp: new Date().toISOString(),
+            org_id: this.orgId,
+            agent_id: parentRun.agentId,
+            session_id: sessionId,
+            run_id: parentRun.runId,
+            trace_id: traceId,
+            span_id: spanId,
+            child_run_id: childRunId,
+            child_agent_id: childAgentId,
+            spawn_reason: opts.spawnReason,
+        });
+        // Emit agent.run.started for the child run (child agent emits this itself in practice,
+        // but the SDK can also do it on behalf of known child agents)
+        this.enqueue({
+            event_id: randomUUID(),
+            event_type: 'agent.run.started',
+            timestamp: new Date().toISOString(),
+            org_id: this.orgId,
+            agent_id: childAgentId,
+            session_id: sessionId,
+            run_id: childRunId,
+            trace_id: traceId,
+            span_id: randomUUID(),
+            run_type: opts.runType,
+        });
+        return new RunHandle(this, {
+            runId: childRunId,
+            sessionId,
+            agentId: childAgentId,
+            orgId: this.orgId,
+            traceId,
+            spanId,
+        });
+    }
+    /** Explicitly start a session (sets channel and end_user_id) */
+    startSession(opts = {}) {
+        const sessionId = opts.sessionId ?? randomUUID();
+        const traceId = randomUUID();
+        const spanId = randomUUID();
+        this.enqueue({
+            event_id: randomUUID(),
+            event_type: 'session.started',
+            timestamp: new Date().toISOString(),
+            org_id: this.orgId,
+            agent_id: this.agentId,
+            session_id: sessionId,
+            run_id: sessionId, // run_id required by base schema; reuse session_id as placeholder
+            trace_id: traceId,
+            span_id: spanId,
+            channel: opts.channel,
+            end_user_id: opts.endUserId,
+        });
+        return sessionId;
+    }
+    /** Resume a previous session */
+    resumeSession(opts) {
+        const sessionId = opts.sessionId ?? randomUUID();
+        const traceId = randomUUID();
+        const spanId = randomUUID();
+        this.enqueue({
+            event_id: randomUUID(),
+            event_type: 'session.resumed',
+            timestamp: new Date().toISOString(),
+            org_id: this.orgId,
+            agent_id: this.agentId,
+            session_id: sessionId,
+            run_id: sessionId,
+            trace_id: traceId,
+            span_id: spanId,
+            resumed_from_session_id: opts.resumedFromSessionId,
+            channel: opts.channel,
+            end_user_id: opts.endUserId,
+        });
+        return sessionId;
+    }
+    /** Record a prompt version deployment (org-level event, not tied to a run) */
+    deployPromptVersion(opts) {
+        this.enqueue({
+            event_id: randomUUID(),
+            event_type: 'prompt.version.deployed',
+            timestamp: new Date().toISOString(),
+            org_id: this.orgId,
+            agent_id: this.agentId,
+            session_id: 'system',
+            run_id: 'system',
+            trace_id: randomUUID(),
+            span_id: randomUUID(),
+            template_id: opts.templateId,
+            new_version: opts.newVersion,
+            old_version: opts.oldVersion,
+            deployed_by: opts.deployedBy,
+        });
+    }
+    /**
+     * Resolve per-1M-token pricing for a model.
+     * Fetches from the Senzu API on first use and caches for the session lifetime.
+     * Falls back to the bundled MODEL_PRICING table if the API is unreachable or the
+     * model is unknown, and to a near-zero sentinel if it's missing from both.
+     */
+    async resolvePricing(provider, model) {
+        if (this.disableLivePricing || this.disabled || !this.apiKey) {
+            return MODEL_PRICING[model] ?? [0.001, 0.002];
+        }
+        const key = `${provider}:${model}`;
+        if (!this.pricingCache.has(key)) {
+            try {
+                const res = await fetch(`${this.baseUrl}/api/v1/pricing/models/${encodeURIComponent(provider)}/${encodeURIComponent(model)}`, { headers: { 'X-API-Key': this.apiKey } });
+                if (res.ok) {
+                    const data = (await res.json());
+                    if (data.inputPricePer1mTokens != null && data.outputPricePer1mTokens != null) {
+                        this.pricingCache.set(key, [data.inputPricePer1mTokens, data.outputPricePer1mTokens]);
+                    }
+                }
+            }
+            catch {
+                // Network error — fall through to local fallback
+            }
+        }
+        return this.pricingCache.get(key) ?? MODEL_PRICING[model] ?? [0.001, 0.002];
+    }
+    destroy() {
+        if (this.flushTimer)
+            clearInterval(this.flushTimer);
+    }
+}
+// ---------------------------------------------------------------------------
+// Helpers
+// ---------------------------------------------------------------------------
+// Pricing per 1M tokens [input, output] in USD
+const MODEL_PRICING = {
+    'claude-opus-4-6': [15.00, 75.00],
+    'claude-sonnet-4-6': [3.00, 15.00],
+    'claude-haiku-4-5-20251001': [0.80, 4.00],
+    'claude-3-5-sonnet-20241022': [3.00, 15.00],
+    'claude-3-5-haiku-20241022': [0.80, 4.00],
+    'claude-3-opus-20240229': [15.00, 75.00],
+    'gpt-4o': [2.50, 10.00],
+    'gpt-4o-mini': [0.15, 0.60],
+    'gpt-4-turbo': [10.00, 30.00],
+};
+function estimateCost(model, inputTokens, outputTokens) {
+    const pricing = MODEL_PRICING[model];
+    if (!pricing)
+        return 0;
+    const [inputPrice, outputPrice] = pricing;
+    return (inputTokens / 1_000_000) * inputPrice + (outputTokens / 1_000_000) * outputPrice;
+}
+function extractUsage(result, model) {
+    if (!result || typeof result !== 'object')
+        return {};
+    const r = result;
+    // Anthropic shape: { usage: { input_tokens, output_tokens, cache_read_input_tokens } }
+    if (r['usage'] && typeof r['usage'] === 'object') {
+        const u = r['usage'];
+        const inputTokens = num(u['input_tokens']) ?? 0;
+        const outputTokens = num(u['output_tokens']) ?? 0;
+        return {
+            input_tokens: inputTokens,
+            output_tokens: outputTokens,
+            cached_input_tokens: num(u['cache_read_input_tokens']),
+            total_tokens: inputTokens + outputTokens,
+            cost_usd_estimate: estimateCost(model, inputTokens, outputTokens),
+        };
+    }
+    // OpenAI shape: { choices: [...], usage: { prompt_tokens, completion_tokens, total_tokens } }
+    if (r['choices'] && r['usage'] && typeof r['usage'] === 'object') {
+        const u = r['usage'];
+        const inputTokens = num(u['prompt_tokens']) ?? 0;
+        const outputTokens = num(u['completion_tokens']) ?? 0;
+        return {
+            input_tokens: inputTokens,
+            output_tokens: outputTokens,
+            total_tokens: num(u['total_tokens']),
+            cost_usd_estimate: estimateCost(model, inputTokens, outputTokens),
+        };
+    }
+    return {};
+}
+function num(v) {
+    return typeof v === 'number' ? v : undefined;
+}
+function estimateBytes(v) {
+    try {
+        return JSON.stringify(v)?.length ?? 0;
+    }
+    catch {
+        return 0;
+    }
+}
+// Extract text from common streaming chunk shapes (Anthropic / OpenAI)
+function extractStreamChunkText(chunk) {
+    if (typeof chunk === 'string')
+        return chunk;
+    if (typeof chunk !== 'object' || chunk === null)
+        return '';
+    const c = chunk;
+    // Anthropic: { type: 'content_block_delta', delta: { type: 'text_delta', text: '...' } }
+    if (c['type'] === 'content_block_delta') {
+        const delta = c['delta'];
+        if (typeof delta?.['text'] === 'string')
+            return delta['text'];
+    }
+    // OpenAI: { choices: [{ delta: { content: '...' } }] }
+    const choices = c['choices'];
+    if (Array.isArray(choices) && choices.length > 0) {
+        const delta = choices[0]['delta'];
+        if (typeof delta?.['content'] === 'string')
+            return delta['content'];
+    }
+    return '';
+}
+//# sourceMappingURL=client.js.map