@jxburros/ai-nugget 0.3.1 → 0.6.0

package/dist/redact.js

@@ -1,4 +1,8 @@
-const SECRET_PATTERNS = [
+/**
+ * Prefixed secret formats. Each pattern is anchored on a vendor prefix that is
+ * distinctive enough that a match is a secret, not a coincidence.
+ */
+export const SECRET_PATTERNS = [
     /sk-[A-Za-z0-9_-]{20,}/g,
     /sk-proj-[A-Za-z0-9_-]{20,}/g,
     /sk-ant-[A-Za-z0-9_-]{20,}/g,
@@ -20,6 +24,27 @@ const SECRET_PATTERNS = [
     /-----BEGIN [A-Z ]*PRIVATE KEY-----[\s\S]*?-----END [A-Z ]*PRIVATE KEY-----/g,
     /eyJ[A-Za-z0-9_-]+\.[A-Za-z0-9_-]+\.[A-Za-z0-9_-]+/g,
 ];
+/**
+ * Unprefixed/opaque secrets — Azure OpenAI `api-key` values, AWS *secret*
+ * access keys, generic bearer/session tokens — carry no distinctive prefix, so
+ * matching them on shape alone would redact commit SHAs, content hashes, and
+ * base64 payloads. These patterns instead anchor on the *label* that precedes
+ * the value (`api-key: …`, `"aws_secret_access_key": "…"`, `password=…`) and
+ * redact only the value, keeping the label readable in logs.
+ *
+ * Exact-match registration (`SessionRedactor.addSecret`, which the handler does
+ * for every resolved key) remains the only guaranteed catch for a bare,
+ * unlabeled, unprefixed secret.
+ */
+export const LABELED_SECRET_PATTERNS = [
+    new RegExp(
+    // Lookbehind rather than `\b` so an underscore-joined prefix still matches
+    // the label (`aws_secret_access_key`, `azure_api_key`).
+    String.raw `(?<![A-Za-z0-9])(api[_-]?key|apikey|secret[_-]?access[_-]?key|access[_-]?token|auth[_-]?token|session[_-]?token|client[_-]?secret|refresh[_-]?token|private[_-]?key|password|passwd)` +
+        // Optional closing quote handles JSON keys (`"api_key": "…"`).
+        String.raw `(["']?\s*[:=]\s*|\s+)` +
+        String.raw `(["']?)([A-Za-z0-9/+_.~-]{16,}={0,2})\3`, 'gi'),
+];
 export function createDefaultRedactor(extraSecrets = []) {
     const secrets = new Set([...extraSecrets].filter((value) => value.length >= 6));
     return {
@@ -27,6 +52,9 @@ export function createDefaultRedactor(extraSecrets = []) {
             let output = text;
             for (const pattern of SECRET_PATTERNS)
                 output = output.replace(pattern, '[REDACTED]');
+            for (const pattern of LABELED_SECRET_PATTERNS) {
+                output = output.replace(pattern, (_match, label, separator, quote) => `${label}${separator}${quote}[REDACTED]${quote}`);
+            }
             for (const secret of secrets)
                 output = output.split(secret).join('[REDACTED]');
             return output;

package/dist/transport.d.ts

@@ -1,7 +1,9 @@
-export declare function withTimeout(ms: number, external?: AbortSignal): {
+export declare function withTimeout(ms: number, external?: AbortSignal, idleMs?: number): {
     signal: AbortSignal;
     done(): void;
     timedOut(): boolean;
+    /** Reset the idle timer. No-op unless `idleMs` was supplied. Call on each chunk. */
+    bump(): void;
 };
 export declare function fetchJson(url: string, init: RequestInit & {
     timeoutMs: number;

package/dist/transport.js

@@ -1,11 +1,25 @@
 import { AIError, classify, fromUnknown } from './errors.js';
-export function withTimeout(ms, external) {
+export function withTimeout(ms, external, idleMs) {
     const controller = new AbortController();
     let didTimeOut = false;
     const timer = setTimeout(() => {
         didTimeOut = true;
         controller.abort(new AIError(`Request timed out after ${ms}ms`, { kind: 'timeout' }));
     }, ms);
+    // Optional idle timeout: aborts only when no chunk has arrived for `idleMs`,
+    // rearmed on every `bump()`. Keeps a long but healthy stream alive while the
+    // total `ms` ceiling still bounds a truly stuck call.
+    let idleTimer;
+    const armIdle = () => {
+        if (idleMs === undefined)
+            return;
+        if (idleTimer)
+            clearTimeout(idleTimer);
+        idleTimer = setTimeout(() => {
+            didTimeOut = true;
+            controller.abort(new AIError(`Request idle for ${idleMs}ms`, { kind: 'timeout' }));
+        }, idleMs);
+    };
     const onAbort = () => controller.abort(external?.reason);
     if (external) {
         if (external.aborted)
@@ -13,15 +27,21 @@ export function withTimeout(ms, external) {
         else
             external.addEventListener('abort', onAbort, { once: true });
     }
+    armIdle();
     return {
         signal: controller.signal,
         done() {
             clearTimeout(timer);
+            if (idleTimer)
+                clearTimeout(idleTimer);
             external?.removeEventListener('abort', onAbort);
         },
         timedOut() {
             return didTimeOut;
         },
+        bump() {
+            armIdle();
+        },
     };
 }
 export async function fetchJson(url, init) {

package/dist/types.d.ts

@@ -1,3 +1,5 @@
+import type { KnownProvider } from './adapters/profiles.js';
+export type { KnownProvider };
 export type Role = 'system' | 'user' | 'assistant' | 'tool';
 export interface ContentPart {
     type: 'text' | 'image';
@@ -42,14 +44,39 @@ export interface ChatRequest {
     stopSequences?: string[];
     signal?: AbortSignal;
     metadata?: Record<string, unknown>;
+    /**
+     * Provider-native request fields the nugget does not model as first-class
+     * options — an escape hatch so a caller can reach a capability without waiting
+     * for a library release. Merged into the outgoing provider request body:
+     * shallow at the top level, and one level deep into the provider's own nested
+     * option container (Ollama `options`, Google `generationConfig`). Examples:
+     * `{ options: { num_ctx: 8192 }, keep_alive: '30m' }` (Ollama),
+     * `{ reasoning_effort: 'high' }` (OpenAI), `{ thinking: { type: 'enabled' } }`
+     * (Anthropic), `{ safetySettings: [...] }` (Google). Values here win over the
+     * nugget's own fields on a key collision, so use with care.
+     */
+    providerOptions?: Record<string, unknown>;
 }
 export interface Connection {
     id: string;
-    provider: string;
+    /**
+     * A provider with a profile in the table, or any other string — an unknown
+     * key with a `baseUrl` resolves through the `openai-compat` escape hatch.
+     * The union is there for autocomplete and typo-catching; the `string & {}`
+     * arm keeps the escape hatch open.
+     */
+    provider: KnownProvider | (string & {});
     baseUrl?: string;
     keyRef?: KeyRef;
     timeoutMs?: number;
     headers?: Record<string, string>;
+    /**
+     * Idle timeout for streaming calls: aborts the stream only if no bytes arrive
+     * for this many milliseconds, resetting on every chunk. Distinct from
+     * `timeoutMs`, which bounds the total call lifetime. Set this (and a generous
+     * `timeoutMs`) for long local generations that stream slowly but healthily.
+     */
+    idleTimeoutMs?: number;
 }
 export type KeyRef = {
     kind: 'none';
@@ -103,8 +130,27 @@ export interface ModelSource {
     connectionId: string;
     baseUrl?: string;
 }
+export interface EmbedRequest {
+    model: string;
+    /** One string, or a batch of strings embedded in a single call. */
+    input: string | string[];
+    signal?: AbortSignal;
+    metadata?: Record<string, unknown>;
+    /** Provider-native passthrough, same contract as {@link ChatRequest.providerOptions}. */
+    providerOptions?: Record<string, unknown>;
+}
+export interface EmbedResult {
+    /** One vector per input, in input order. */
+    embeddings: number[][];
+    model: string;
+    usage: Usage;
+    source: ModelSource;
+    raw?: unknown;
+}
 export declare function modelRef(source: ModelSource, model: string): string;
-export type AIErrorKind = 'auth' | 'rate_limit' | 'timeout' | 'network' | 'server' | 'invalid_request' | 'invalid_response' | 'context_length' | 'canceled' | 'policy_blocked' | 'key_unavailable' | 'tool_error' | 'budget_exceeded';
+export type AIErrorKind = 'auth' | 'rate_limit' | 'timeout' | 'network' | 'server' | 'invalid_request' | 'invalid_response'
+/** 404/410 — endpoint, deployment, or model not found (wrong baseUrl/model, or a misrouted edge). */
+ | 'not_found' | 'context_length' | 'canceled' | 'policy_blocked' | 'key_unavailable' | 'tool_error' | 'budget_exceeded';
 export type StreamEvent = {
     type: 'start';
     callId: string;
@@ -113,6 +159,9 @@ export type StreamEvent = {
 } | {
     type: 'delta';
     text: string;
+} | {
+    type: 'reasoning';
+    text: string;
 } | {
     type: 'tool_call';
     call: ToolCall;
@@ -141,6 +190,7 @@ export interface ProviderAdapter {
         ok: boolean;
         detail?: string;
     }>;
+    embed?(conn: ResolvedConnection, req: EmbedRequest): Promise<EmbedResult>;
 }
 export interface ModelInfo {
     id: string;
@@ -168,6 +218,15 @@ export interface CallInfo {
     provider: string;
     model: string;
     metadata?: Record<string, unknown>;
+    /**
+     * The fully resolved connection for this call — base URL defaulted from the
+     * provider profile and auth headers applied. Present whenever `beforeCall`
+     * runs after resolution (chat/stream and probes), letting a hook validate the
+     * *effective* endpoint (e.g. a request-time SSRF/DNS-rebinding re-check on the
+     * resolved `baseUrl`) without duplicating profile logic. The resolved
+     * `apiKey` is intentionally not exposed here.
+     */
+    resolved?: Omit<ResolvedConnection, 'apiKey'>;
 }
 export interface CallRecord {
     callId: string;
@@ -187,5 +246,40 @@ export interface CallRecord {
     metadata?: Record<string, unknown>;
     promptChars: number;
     responseChars: number;
+    /**
+     * Estimated cost of this call in USD, computed by the optional `pricing` hook
+     * passed to the handler. Undefined when no pricing hook is configured or the
+     * hook returns nothing for this provider/model.
+     */
+    costUsd?: number;
+}
+/**
+ * Minimal [Standard Schema](https://standardschema.dev) validator surface. Any
+ * Zod / Valibot / ArkType schema (v1+) satisfies this via its `~standard`
+ * property, so `chatParsed` can validate model output against a schema the app
+ * already owns — with zero dependency added to this library.
+ */
+export interface StandardSchemaV1<Output = unknown> {
+    readonly '~standard': {
+        readonly version: 1;
+        readonly vendor: string;
+        readonly validate: (value: unknown) => StandardSchemaResult<Output> | Promise<StandardSchemaResult<Output>>;
+    };
+}
+export type StandardSchemaResult<Output> = {
+    readonly value: Output;
+    readonly issues?: undefined;
+} | {
+    readonly issues: ReadonlyArray<{
+        readonly message: string;
+        readonly path?: ReadonlyArray<PropertyKey | {
+            readonly key: PropertyKey;
+        }>;
+    }>;
+};
+/** Output of {@link AIHandler.chatParsed}: the validated value plus the raw chat result. */
+export interface ParsedResult<T> {
+    data: T;
+    result: ChatResult;
 }
 //# sourceMappingURL=types.d.ts.map

package/dist/util.d.ts

@@ -4,5 +4,21 @@ export declare function asString(value: unknown): string | undefined;
 export declare function asNumber(value: unknown): number | undefined;
 export declare function promptChars(messages: ChatMessage[]): number;
 export declare function textFromMessages(messages: ChatMessage[]): string;
+export declare function globalEnv(): Record<string, string | undefined>;
+/**
+ * Merges app-supplied {@link ChatRequest.providerOptions} into a provider
+ * request body: shallow at the top level, and one level deep for each key in
+ * `nestedKeys` where both sides are plain objects (Ollama `options`, Google
+ * `generationConfig`). Values in `providerOptions` win on collision.
+ */
+export declare function applyProviderOptions(body: Record<string, unknown>, providerOptions: Record<string, unknown> | undefined, nestedKeys?: readonly string[]): Record<string, unknown>;
+/** Joins a base URL and path without producing a double slash, even if `base` ends with `/`. */
+export declare function joinUrl(base: string, path: string): string;
+/**
+ * Runs `fn` over `items` with at most `limit` in flight at once, preserving
+ * input order in the returned array. Used to probe many local models
+ * concurrently without opening an unbounded number of sockets.
+ */
+export declare function mapWithConcurrency<T, R>(items: readonly T[], limit: number, fn: (item: T, index: number) => Promise<R>): Promise<R[]>;
 export declare function sleep(ms: number, signal?: AbortSignal): Promise<void>;
 //# sourceMappingURL=util.d.ts.map

package/dist/util.js

@@ -21,6 +21,56 @@ export function textFromMessages(messages) {
         return message.content.map((part) => part.text ?? '').join('');
     }).join('\n');
 }
+export function globalEnv() {
+    const maybeProcess = globalThis;
+    return maybeProcess.process?.env ?? {};
+}
+/**
+ * Merges app-supplied {@link ChatRequest.providerOptions} into a provider
+ * request body: shallow at the top level, and one level deep for each key in
+ * `nestedKeys` where both sides are plain objects (Ollama `options`, Google
+ * `generationConfig`). Values in `providerOptions` win on collision.
+ */
+export function applyProviderOptions(body, providerOptions, nestedKeys = []) {
+    if (!providerOptions)
+        return body;
+    const merged = { ...body };
+    for (const [key, value] of Object.entries(providerOptions)) {
+        const base = asRecord(merged[key]);
+        if (nestedKeys.includes(key) && base && asRecord(value)) {
+            merged[key] = { ...base, ...value };
+        }
+        else {
+            merged[key] = value;
+        }
+    }
+    return merged;
+}
+/** Joins a base URL and path without producing a double slash, even if `base` ends with `/`. */
+export function joinUrl(base, path) {
+    return `${base.replace(/\/+$/, '')}/${path.replace(/^\/+/, '')}`;
+}
+/**
+ * Runs `fn` over `items` with at most `limit` in flight at once, preserving
+ * input order in the returned array. Used to probe many local models
+ * concurrently without opening an unbounded number of sockets.
+ */
+export async function mapWithConcurrency(items, limit, fn) {
+    const results = new Array(items.length);
+    let next = 0;
+    const workerCount = Math.max(1, Math.min(limit, items.length));
+    const worker = async () => {
+        for (;;) {
+            const index = next;
+            next += 1;
+            if (index >= items.length)
+                return;
+            results[index] = await fn(items[index], index);
+        }
+    };
+    await Promise.all(Array.from({ length: workerCount }, worker));
+    return results;
+}
 export function sleep(ms, signal) {
     if (ms <= 0)
         return Promise.resolve();

package/nugget/VERSION.txt

@@ -1,2 +1,2 @@
-0.3.1
-a15d2e448ed391c96856ccb9b4f423d229a7bfd684bf394a5c3d93a5fcd876f6
+0.6.0
+762595605eef73dde3751687e21190d8281be3ade9d699d02620920f6c021de2

package/nugget/dist/adapters/engines/anthropic.d.ts

@@ -0,0 +1,14 @@
+import type { ChatRequest, ChatResult, ModelInfo, ProviderAdapter, ResolvedConnection, StreamEvent } from '../../types.js';
+export declare class AnthropicAdapter implements ProviderAdapter {
+    readonly provider: string;
+    constructor(provider: string);
+    chat(conn: ResolvedConnection, req: ChatRequest): Promise<ChatResult>;
+    stream(conn: ResolvedConnection, req: ChatRequest): AsyncIterable<StreamEvent>;
+    /**
+     * Lists models from Anthropic's `/v1/models` endpoint (auth + version headers
+     * already applied to `conn.headers`). The endpoint does not report a context
+     * window, so `contextWindow` is left undefined rather than guessed.
+     */
+    listModels(conn: ResolvedConnection): Promise<ModelInfo[]>;
+}
+//# sourceMappingURL=anthropic.d.ts.map

package/nugget/dist/adapters/engines/anthropic.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"anthropic.d.ts","sourceRoot":"","sources":["../../../src/adapters/engines/anthropic.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAe,WAAW,EAAE,UAAU,EAAE,SAAS,EAAE,eAAe,EAAE,kBAAkB,EAAE,WAAW,EAAY,MAAM,gBAAgB,CAAC;AAMlJ,qBAAa,gBAAiB,YAAW,eAAe;IACtD,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAC;gBACd,QAAQ,EAAE,MAAM;IAItB,IAAI,CAAC,IAAI,EAAE,kBAAkB,EAAE,GAAG,EAAE,WAAW,GAAG,OAAO,CAAC,UAAU,CAAC;IAUpE,MAAM,CAAC,IAAI,EAAE,kBAAkB,EAAE,GAAG,EAAE,WAAW,GAAG,aAAa,CAAC,WAAW,CAAC;IA2HrF;;;;OAIG;IACG,UAAU,CAAC,IAAI,EAAE,kBAAkB,GAAG,OAAO,CAAC,SAAS,EAAE,CAAC;CAajE"}

package/nugget/dist/adapters/engines/anthropic.js

@@ -0,0 +1,305 @@
+import { AIError } from '../../errors.js';
+import { estimatedUsage } from '../../tokens.js';
+import { fetchJson, postResponse, sseLines } from '../../transport.js';
+import { applyProviderOptions, asNumber, asRecord, asString, joinUrl, textFromMessages } from '../../util.js';
+import { DEFAULT_TIMEOUT_MS, parseArgs, randomId, safeParse, streamAnomaly, streamError, streamTimeout } from './base.js';
+const JSON_MODE_TOOL = 'json_output';
+export class AnthropicAdapter {
+    provider;
+    constructor(provider) {
+        this.provider = provider;
+    }
+    async chat(conn, req) {
+        let result;
+        for await (const event of this.stream(conn, req)) {
+            if (event.type === 'done')
+                result = event.result;
+            if (event.type === 'error')
+                throw event.error;
+        }
+        if (!result)
+            throw new AIError('Anthropic stream ended without a result', { kind: 'invalid_response', provider: conn.provider });
+        return result;
+    }
+    async *stream(conn, req) {
+        const started = Date.now();
+        const jsonMode = req.responseFormat?.type === 'json' && !req.tools?.length;
+        let firstTokenMs = null;
+        let text = '';
+        let inputTokens;
+        let outputTokens;
+        let stopReason;
+        let sawTerminal = false;
+        const emittedTools = [];
+        // Partial tool_use blocks keyed by content-block index (input_json_delta accumulation).
+        const blocks = new Map();
+        const timeout = streamTimeout(conn, req.signal);
+        yield { type: 'start', callId: '', provider: conn.provider, model: req.model };
+        // Anthropic JSON mode is implemented as a forced `json_output` tool, which
+        // cannot coexist with the caller's own tools — same silent-downgrade shape
+        // as Gemini, so it gets the same signal rather than quietly dropping.
+        if (req.responseFormat?.type === 'json' && req.tools?.length) {
+            yield {
+                type: 'context',
+                kind: 'json_mode_downgraded',
+                data: { reason: 'Anthropic JSON mode uses a forced tool and cannot be combined with caller tools; the request was sent without JSON mode', provider: conn.provider },
+            };
+        }
+        try {
+            const res = await postResponse(`${conn.baseUrl}/v1/messages`, body(req, jsonMode), conn.headers, timeout.signal, conn.provider);
+            const contentType = res.headers.get('content-type') ?? '';
+            if (!contentType.includes('text/event-stream')) {
+                const data = await res.json();
+                const parsed = parseResponse(data);
+                inputTokens = parsed.inputTokens;
+                outputTokens = parsed.outputTokens;
+                stopReason = parsed.stopReason;
+                sawTerminal = true;
+                if (jsonMode) {
+                    text = jsonTextFrom(parsed.toolCalls, parsed.text);
+                    if (text)
+                        yield { type: 'delta', text };
+                }
+                else {
+                    text = parsed.text;
+                    if (text)
+                        yield { type: 'delta', text };
+                    for (const call of parsed.toolCalls) {
+                        emittedTools.push(call);
+                        yield { type: 'tool_call', call };
+                    }
+                }
+            }
+            else {
+                for await (const line of sseLines(res)) {
+                    timeout.bump();
+                    const record = asRecord(safeParse(line));
+                    if (!record)
+                        continue;
+                    const type = asString(record.type);
+                    if (type === 'message_start') {
+                        const usage = asRecord(asRecord(record.message)?.usage);
+                        inputTokens = asNumber(usage?.input_tokens) ?? inputTokens;
+                        outputTokens = asNumber(usage?.output_tokens) ?? outputTokens;
+                    }
+                    else if (type === 'content_block_start') {
+                        const index = asNumber(record.index) ?? 0;
+                        const block = asRecord(record.content_block);
+                        if (block?.type === 'tool_use') {
+                            blocks.set(index, { id: asString(block.id) ?? randomId(), name: asString(block.name) ?? 'unknown', raw: '' });
+                        }
+                    }
+                    else if (type === 'content_block_delta') {
+                        const index = asNumber(record.index) ?? 0;
+                        const delta = asRecord(record.delta);
+                        if (delta?.type === 'text_delta') {
+                            const piece = asString(delta.text) ?? '';
+                            if (piece) {
+                                if (firstTokenMs === null)
+                                    firstTokenMs = Date.now() - started;
+                                text += piece;
+                                yield { type: 'delta', text: piece };
+                            }
+                        }
+                        else if (delta?.type === 'thinking_delta') {
+                            // Extended-thinking tokens ride the reasoning channel, kept out of `text`.
+                            const piece = asString(delta.thinking) ?? '';
+                            if (piece)
+                                yield { type: 'reasoning', text: piece };
+                        }
+                        else if (delta?.type === 'input_json_delta') {
+                            const partial = blocks.get(index);
+                            if (partial)
+                                partial.raw += asString(delta.partial_json) ?? '';
+                        }
+                    }
+                    else if (type === 'content_block_stop') {
+                        const index = asNumber(record.index) ?? 0;
+                        const partial = blocks.get(index);
+                        if (partial) {
+                            const call = { id: partial.id, name: partial.name, raw: partial.raw, arguments: parseArgs(partial.raw) };
+                            blocks.delete(index);
+                            if (jsonMode && call.name === JSON_MODE_TOOL) {
+                                text = jsonTextFrom([call], text);
+                                if (firstTokenMs === null)
+                                    firstTokenMs = Date.now() - started;
+                                yield { type: 'delta', text };
+                            }
+                            else {
+                                emittedTools.push(call);
+                                yield { type: 'tool_call', call };
+                            }
+                        }
+                    }
+                    else if (type === 'message_stop') {
+                        sawTerminal = true;
+                    }
+                    else if (type === 'message_delta') {
+                        const delta = asRecord(record.delta);
+                        if (asString(delta?.stop_reason))
+                            sawTerminal = true;
+                        stopReason = asString(delta?.stop_reason) ?? stopReason;
+                        const usage = asRecord(record.usage);
+                        outputTokens = asNumber(usage?.output_tokens) ?? outputTokens;
+                    }
+                }
+            }
+            if (!sawTerminal)
+                yield streamAnomaly('stream ended without a stop_reason or message_stop');
+            const hasTools = emittedTools.length > 0;
+            yield { type: 'done', result: {
+                    text,
+                    toolCalls: hasTools ? emittedTools : undefined,
+                    finishReason: mapStop(stopReason, hasTools),
+                    usage: inputTokens !== undefined || outputTokens !== undefined ? { inputTokens, outputTokens, estimated: false } : estimatedUsage(textFromMessages(req.messages), text),
+                    timing: { firstTokenMs, totalMs: Date.now() - started },
+                    model: req.model,
+                    source: { provider: conn.provider, connectionId: conn.id, baseUrl: conn.baseUrl },
+                } };
+        }
+        catch (error) {
+            throw streamError(error, timeout, conn.provider);
+        }
+        finally {
+            timeout.done();
+        }
+    }
+    /**
+     * Lists models from Anthropic's `/v1/models` endpoint (auth + version headers
+     * already applied to `conn.headers`). The endpoint does not report a context
+     * window, so `contextWindow` is left undefined rather than guessed.
+     */
+    async listModels(conn) {
+        const { data } = await fetchJson(joinUrl(conn.baseUrl, '/v1/models'), {
+            method: 'GET',
+            headers: conn.headers,
+            timeoutMs: Math.min(conn.timeoutMs ?? DEFAULT_TIMEOUT_MS, 15_000),
+            provider: conn.provider,
+        });
+        const rows = Array.isArray(asRecord(data)?.data) ? asRecord(data).data : [];
+        return rows
+            .map((row) => asString(asRecord(row)?.id))
+            .filter((id) => Boolean(id))
+            .map((id) => ({ id, source: { provider: conn.provider, connectionId: conn.id, baseUrl: conn.baseUrl } }));
+    }
+}
+function body(req, jsonMode) {
+    const system = req.messages.filter((m) => m.role === 'system').map((m) => textContent(m.content)).join('\n\n') || undefined;
+    const base = {
+        model: req.model,
+        max_tokens: req.maxTokens ?? 4096,
+        temperature: req.temperature,
+        top_p: req.topP,
+        stop_sequences: req.stopSequences,
+        system,
+        messages: toAnthropicMessages(req.messages.filter((m) => m.role !== 'system')),
+        stream: true,
+    };
+    if (jsonMode) {
+        // Forced-tool JSON mode: Anthropic has no response_format, so we make the
+        // model answer through a single required tool whose input is the JSON we want.
+        base.tools = [{ name: JSON_MODE_TOOL, description: 'Return the answer as a JSON object.', input_schema: schemaFor(req) }];
+        base.tool_choice = { type: 'tool', name: JSON_MODE_TOOL };
+    }
+    else if (req.tools?.length) {
+        base.tools = req.tools.map((tool) => ({ name: tool.name, description: tool.description, input_schema: tool.parameters }));
+        if (typeof req.toolChoice === 'object')
+            base.tool_choice = { type: 'tool', name: req.toolChoice.name };
+        else if (req.toolChoice === 'auto')
+            base.tool_choice = { type: 'auto' };
+        else if (req.toolChoice === 'none')
+            base.tool_choice = { type: 'none' };
+    }
+    // providerOptions carries Anthropic-native fields (`thinking`, `metadata`,
+    // top-level `cache_control` extras, `service_tier`, …) without a release.
+    return applyProviderOptions(base, req.providerOptions);
+}
+function toAnthropicMessages(messages) {
+    const out = [];
+    for (let index = 0; index < messages.length; index += 1) {
+        const message = messages[index];
+        if (message.role !== 'tool') {
+            out.push(toAnthropicMessage(message));
+            continue;
+        }
+        const content = [];
+        while (index < messages.length && messages[index]?.role === 'tool') {
+            const toolMessage = messages[index];
+            content.push({ type: 'tool_result', tool_use_id: toolMessage.toolCallId ?? '', content: textContent(toolMessage.content) });
+            index += 1;
+        }
+        index -= 1;
+        out.push({ role: 'user', content });
+    }
+    return out;
+}
+function toAnthropicMessage(m) {
+    // Tool-role messages are handled by toAnthropicMessages' batching loop and
+    // never reach here, so no tool branch is needed.
+    // assistant turns that carried tool calls replay them as tool_use blocks,
+    // preserving any text/image content parts that accompanied the calls.
+    if (m.role === 'assistant' && m.toolCalls?.length) {
+        const content = [...contentBlocks(m.content)];
+        for (const call of m.toolCalls)
+            content.push({ type: 'tool_use', id: call.id, name: call.name, input: call.arguments ?? {} });
+        return { role: 'assistant', content };
+    }
+    return {
+        role: m.role === 'assistant' ? 'assistant' : 'user',
+        content: typeof m.content === 'string' ? m.content : contentBlocks(m.content),
+    };
+}
+/** Maps text/image content — a string or a ContentPart[] — onto Anthropic content blocks. */
+function contentBlocks(content) {
+    if (typeof content === 'string')
+        return content ? [{ type: 'text', text: content }] : [];
+    return content.map((part) => part.type === 'image'
+        ? { type: 'image', source: { type: 'base64', media_type: part.mimeType ?? 'image/png', data: part.imageBase64 ?? '' } }
+        : { type: 'text', text: part.text ?? '' });
+}
+function textContent(content) {
+    if (typeof content === 'string')
+        return content;
+    if (!content)
+        return '';
+    return content.filter((part) => part.type === 'text').map((part) => part.text ?? '').join('\n');
+}
+function parseResponse(data) {
+    const record = asRecord(data);
+    const content = Array.isArray(record?.content) ? record.content : [];
+    let text = '';
+    const toolCalls = [];
+    for (const blockValue of content) {
+        const block = asRecord(blockValue);
+        if (block?.type === 'text')
+            text += asString(block.text) ?? '';
+        if (block?.type === 'tool_use') {
+            toolCalls.push({
+                id: asString(block.id) ?? randomId(),
+                name: asString(block.name) ?? 'unknown',
+                arguments: block.input ?? {},
+                raw: JSON.stringify(block.input ?? {}),
+            });
+        }
+    }
+    const usage = asRecord(record?.usage);
+    return { text, inputTokens: asNumber(usage?.input_tokens), outputTokens: asNumber(usage?.output_tokens), stopReason: asString(record?.stop_reason), toolCalls };
+}
+function schemaFor(req) {
+    const schema = req.responseFormat?.type === 'json' ? req.responseFormat.schema : undefined;
+    return schema ?? { type: 'object' };
+}
+function jsonTextFrom(toolCalls, fallback) {
+    const json = toolCalls.find((call) => call.name === JSON_MODE_TOOL) ?? toolCalls[0];
+    if (json)
+        return json.raw && json.raw.trim() ? json.raw : JSON.stringify(json.arguments ?? {});
+    return fallback;
+}
+function mapStop(stop, hasTools) {
+    if (stop === 'tool_use' && hasTools)
+        return 'tool';
+    if (stop === 'max_tokens')
+        return 'length';
+    return 'stop';
+}
+//# sourceMappingURL=anthropic.js.map