@lensagent/core 0.1.0 → 0.1.2

package/dist/runtime/model.js

@@ -1,18 +1,29 @@
+import { assertContextBoundaries } from '../core/context-boundaries.js';
+import { randomUUID } from 'node:crypto';
+import { sha256 } from './model-audit.js';
 import { createAnthropic } from '@ai-sdk/anthropic';
 import { createOpenAI } from '@ai-sdk/openai';
 import { createOpenAICompatible } from '@ai-sdk/openai-compatible';
-import { jsonSchema, stepCountIs, streamText, tool } from 'ai';
-import { jsonValue, toolArguments } from '../core/codec.js';
+import { jsonSchema, streamText, tool } from 'ai';
+import { canonicalize } from 'json-canonicalize';
+import { digest, jsonValue, toolArguments } from '../core/codec.js';
 import { fail } from '../core/domain.js';
 import { resolveSecret } from '../config/runtime.js';
-import { resolveProfile } from './profile.js';
+import { resolveProfile, resolveReasoningEffort } from './profile.js';
+import { record, selectCacheBreakpoints } from './cache.js';
+import { estimateTokens } from './tokenizer.js';
+import { imageMessages, imageReference, imageTokenEstimate, materializeImages } from './images.js';
 import { assertProviderManifest, providerManifest } from './manifests.js';
 export class AiModelGateway {
     config;
     target;
-    constructor(config, target) {
+    artifacts;
+    audit;
+    constructor(config, target, artifacts, audit) {
         this.config = config;
         this.target = target;
+        this.artifacts = artifacts;
+        this.audit = audit;
     }
     resolve(reference, config = this.config.current.config) {
         const { providerId, modelId } = splitReference(reference);
@@ -26,177 +37,363 @@ export class AiModelGateway {
             contextWindowTokens: model.contextWindowTokens,
             profile: resolveProfile(config, model.harnessProfile),
             usageReliable: model.usageReliable ?? false,
-            cacheSupported: model.cacheSupported ?? false,
-            programmaticToolCallingSupported: model.programmaticToolCallingSupported ?? false
+            cacheSupported: (model.promptCache ?? provider.promptCache)?.mode !== undefined ? (model.promptCache ?? provider.promptCache)?.mode !== 'off' : model.cacheSupported ?? false
         };
     }
-    async *stream(request, config = this.config.current.config) {
+    async *stream(request, config = this.config.current.config, compiled = compileModelRequest(request, config)) {
+        assertContextBoundaries(request.messages);
         const { providerId, modelId } = splitReference(request.model);
         const providerConfig = config.providers[providerId];
         const modelConfig = providerConfig?.models[modelId];
         if (providerConfig === undefined || modelConfig === undefined)
             fail('MODEL_NOT_FOUND', 404, `Model ${request.model} is not configured.`);
         assertProviderManifest(providerManifest(config, providerId), request.model, this.target);
-        const resolved = createModel(providerId, modelConfig.wireModel ?? modelId, providerConfig);
-        const programmatic = request.programmaticToolCalling;
-        if (programmatic !== undefined && resolved.programmaticTool === undefined) {
-            fail('ADAPTER_INCOMPATIBLE', 503, 'The configured Provider Adapter does not support hosted Programmatic Tool Calling.');
-        }
-        const callers = new Map();
+        const requestId = randomUUID();
+        const report = this.audit === undefined ? undefined : (event) => {
+            this.audit?.append({ ...event, model_request_id: requestId, context: request.auditContext ?? null,
+                provider_id: providerId, model_id: modelConfig.wireModel ?? modelId,
+                input_manifest: request.messages.map(message => ({ role: message.role, context_item_id: message.contextItemId ?? null,
+                    content_sha256: sha256(message.content), content_bytes: Buffer.byteLength(message.content),
+                    tool_call_id: message.toolCallId ?? null, images: message.images ?? [] })) });
+        };
+        const resolved = createModel(providerId, modelConfig.wireModel ?? modelId, providerConfig, compiled.bodyOptions, report);
         const ordinals = new Map();
-        const toolSet = tools(request.tools, programmatic, resolved.programmaticTool, callers, ordinals);
-        const instructions = request.messages.filter((message) => message.role === 'system').map((message) => message.content).join('\n\n');
-        const conversation = request.messages.filter((message) => message.role !== 'system');
         const result = streamText({
             model: resolved.model,
-            ...(instructions.length === 0 ? {} : { instructions }),
-            ...(conversation.length === 0 ? { prompt: '' } : { messages: conversation.map(aiMessage) }),
-            tools: toolSet,
-            ...(programmatic === undefined ? {} : {
-                experimental_toolCallers: Object.fromEntries(programmatic.capabilityIds
-                    .filter((capabilityId) => capabilityId !== 'programmatic_tool_run' && capabilityId !== 'capability_search')
-                    .map((capabilityId) => [capabilityId, ['programmatic_tool_run', 'AI_SDK_DIRECT_TOOL_CALL']])),
-                stopWhen: stepCountIs(programmatic.maxToolCalls + 1),
-                onToolExecutionStart: (event) => {
-                    const caller = providerCaller(event.toolCall.providerMetadata);
-                    if (caller.parentProviderCallId !== null)
-                        callers.set(event.toolCall.toolCallId, caller.parentProviderCallId);
-                }
-            }),
+            allowSystemInMessages: true,
+            messages: await materializeImages(compiled.messages, request.messages, this.artifacts),
+            tools: tools(compiled.tools),
+            providerOptions: compiled.providerOptions,
+            toolChoice: compiled.toolChoice,
             maxRetries: 0,
-            ...(request.maxOutputTokens === undefined ? {} : { maxOutputTokens: request.maxOutputTokens }),
-            abortSignal: request.signal,
-            ...(request.reasoningEffort === null ? {} : { providerOptions: reasoningOptions(providerId, providerConfig.adapter, request.reasoningEffort) })
+            ...(compiled.maxOutputTokens === null ? {} : { maxOutputTokens: compiled.maxOutputTokens }),
+            abortSignal: request.signal
         });
-        let ordinal = 0;
-        for await (const part of result.stream) {
-            if (part.type === 'text-delta')
-                yield { type: 'text', text: part.text };
-            else if (part.type === 'reasoning-delta')
-                yield { type: 'thinking', text: part.text };
-            else if (part.type === 'tool-input-start') {
-                const toolOrdinal = ordinal++;
-                ordinals.set(part.id, toolOrdinal);
-                yield { type: 'toolStart', ordinal: toolOrdinal, id: part.id, name: part.toolName };
-            }
-            else if (part.type === 'tool-call') {
-                const toolOrdinal = ordinals.get(part.toolCallId) ?? ordinal++;
-                ordinals.set(part.toolCallId, toolOrdinal);
-                const caller = providerCaller(part.providerMetadata);
-                yield {
-                    type: 'tool',
-                    ordinal: toolOrdinal,
-                    id: part.toolCallId,
-                    name: part.toolName,
-                    // Not `jsonValue`: a Provider hands back a raw JSON string when the model calls a tool that was
-                    // not in the request's manifest, and storing that string poisons the Context permanently.
-                    arguments: toolArguments(part.input),
-                    ...(caller.parentProviderCallId === null ? {} : { parentProviderCallId: caller.parentProviderCallId }),
-                    ...(part.providerExecuted === true ? { providerExecuted: true } : {}),
-                    ...(caller.programmatic ? { programmaticCaller: true } : {})
-                };
-            }
-            else if (part.type === 'tool-result') {
-                const toolOrdinal = ordinals.get(part.toolCallId) ?? ordinal++;
-                ordinals.set(part.toolCallId, toolOrdinal);
-                yield {
-                    type: 'toolResult',
-                    ordinal: toolOrdinal,
-                    id: part.toolCallId,
-                    name: part.toolName,
-                    output: jsonValue(part.output),
-                    ...(part.providerExecuted === true ? { providerExecuted: true } : {})
-                };
-            }
-            else if (part.type === 'finish') {
-                yield {
-                    type: 'usage',
-                    inputTokens: part.totalUsage.inputTokens ?? 0,
-                    outputTokens: part.totalUsage.outputTokens ?? 0
-                };
-                yield { type: 'end', reason: part.finishReason };
-            }
-            else if (part.type === 'error') {
-                throw part.error;
-            }
-            else if (part.type === 'abort') {
-                throw new Error(part.reason ?? 'Model request aborted.');
+        let streamCompleted = false;
+        try {
+            let ordinal = 0;
+            let finishReason;
+            const openBlocks = new Set();
+            let reportedCache;
+            for await (const part of result.stream) {
+                if (part.type === 'text-start')
+                    openBlocks.add(`text:${part.id}`);
+                else if (part.type === 'text-end')
+                    openBlocks.delete(`text:${part.id}`);
+                else if (part.type === 'reasoning-start')
+                    openBlocks.add(`reasoning:${part.id}`);
+                else if (part.type === 'reasoning-end')
+                    openBlocks.delete(`reasoning:${part.id}`);
+                else if (part.type === 'tool-input-start')
+                    openBlocks.add(`tool:${part.id}`);
+                else if (part.type === 'tool-input-end')
+                    openBlocks.delete(`tool:${part.id}`);
+                if (part.type === 'start-step' && part.warnings.length > 0)
+                    yield { type: 'providerWarnings', warnings: jsonValue(part.warnings) };
+                else if (part.type === 'text-delta')
+                    yield { type: 'text', text: part.text };
+                else if (part.type === 'reasoning-delta')
+                    yield { type: 'thinking', text: part.text };
+                else if (part.type === 'tool-input-start') {
+                    const toolOrdinal = ordinal++;
+                    ordinals.set(part.id, toolOrdinal);
+                    yield { type: 'toolStart', ordinal: toolOrdinal, id: part.id, name: part.toolName };
+                }
+                else if (part.type === 'tool-call') {
+                    const toolOrdinal = ordinals.get(part.toolCallId) ?? ordinal++;
+                    ordinals.set(part.toolCallId, toolOrdinal);
+                    yield {
+                        type: 'tool',
+                        ordinal: toolOrdinal,
+                        id: part.toolCallId,
+                        name: part.toolName,
+                        // Not `jsonValue`: a Provider hands back a raw JSON string when the model calls a tool that was
+                        // not in the request's manifest, and storing that string poisons the Context permanently.
+                        arguments: toolArguments(part.input),
+                        ...(part.providerExecuted === true ? { providerExecuted: true } : {}),
+                    };
+                }
+                else if (part.type === 'tool-result') {
+                    const toolOrdinal = ordinals.get(part.toolCallId) ?? ordinal++;
+                    ordinals.set(part.toolCallId, toolOrdinal);
+                    yield {
+                        type: 'toolResult',
+                        ordinal: toolOrdinal,
+                        id: part.toolCallId,
+                        name: part.toolName,
+                        output: jsonValue(part.output),
+                        ...(part.providerExecuted === true ? { providerExecuted: true } : {})
+                    };
+                }
+                else if (part.type === 'finish-step' && providerConfig.adapter !== '@ai-sdk/openai-compatible') {
+                    const raw = record(part.usage.raw);
+                    const details = record(raw?.input_tokens_details);
+                    const read = providerConfig.adapter === '@ai-sdk/openai' ? details?.cached_tokens : raw?.cache_read_input_tokens;
+                    const write = providerConfig.adapter === '@ai-sdk/openai' ? details?.cache_write_tokens : raw?.cache_creation_input_tokens;
+                    const noCache = providerConfig.adapter === '@ai-sdk/anthropic' ? raw?.input_tokens : typeof read === 'number' ? part.usage.inputTokenDetails.noCacheTokens : undefined;
+                    reportedCache = { ...(typeof read === 'number' ? { cacheReadTokens: read } : {}), ...(typeof write === 'number' ? { cacheWriteTokens: write } : {}), ...(typeof noCache === 'number' ? { uncachedInputTokens: noCache } : {}) };
+                }
+                else if (part.type === 'finish') {
+                    yield {
+                        type: 'usage',
+                        inputTokens: part.totalUsage.inputTokens ?? 0,
+                        outputTokens: part.totalUsage.outputTokens ?? 0,
+                        ...(reportedCache ?? {
+                            ...(part.totalUsage.inputTokenDetails.cacheReadTokens === undefined ? {} : { cacheReadTokens: part.totalUsage.inputTokenDetails.cacheReadTokens }),
+                            ...(part.totalUsage.inputTokenDetails.cacheWriteTokens === undefined ? {} : { cacheWriteTokens: part.totalUsage.inputTokenDetails.cacheWriteTokens }),
+                            ...(part.totalUsage.inputTokenDetails.noCacheTokens === undefined ? {} : { uncachedInputTokens: part.totalUsage.inputTokenDetails.noCacheTokens })
+                        })
+                    };
+                    finishReason = part.finishReason;
+                }
+                else if (part.type === 'error') {
+                    throw part.error;
+                }
+                else if (part.type === 'abort') {
+                    throw new Error(part.reason ?? 'Model request aborted.');
+                }
             }
+            request.signal.throwIfAborted();
+            if (finishReason !== 'stop' && finishReason !== 'tool-calls')
+                fail('MODEL_RESPONSE_INCOMPLETE', 502, `Model response did not complete: ${finishReason ?? 'missing finish'}.`);
+            if (openBlocks.size > 0)
+                fail('MODEL_RESPONSE_INCOMPLETE', 502, 'Model response contains unfinished content blocks.');
+            const responses = await result.responseMessages;
+            const content = responses.flatMap(message => message.role === 'assistant' && Array.isArray(message.content) ? message.content : []);
+            // JSON serialization removes SDK optional undefined fields without interpreting opaque metadata.
+            const response = JSON.parse(JSON.stringify({ route: responseRoute(providerId, providerConfig, modelId), content }));
+            assertReasoningState(response, providerConfig.adapter, resolveProfile(config, modelConfig.harnessProfile));
+            report?.({ event_type: 'model_stream_completed', outcome: 'validated_response', finish_reason: finishReason });
+            streamCompleted = true;
+            yield { type: 'response', response };
+            yield { type: 'end', reason: finishReason };
+        }
+        finally {
+            if (!streamCompleted)
+                report?.({ event_type: 'model_stream_incomplete', outcome: 'unknown', cancelled: request.signal.aborted });
         }
     }
 }
-function reasoningOptions(providerId, adapter, effort) {
+// This representation is shared by attempt diagnostics and the SDK send path.
+// Local Context identities and annotations never enter the Provider fingerprint.
+export function compileModelRequest(request, config, previous) {
+    assertContextBoundaries(request.messages);
+    const { providerId, modelId } = splitReference(request.model);
+    const provider = config.providers[providerId];
+    const model = provider?.models[modelId];
+    if (provider === undefined || model === undefined)
+        fail('MODEL_NOT_FOUND', 404, `Model ${request.model} is not configured.`);
+    const profile = resolveProfile(config, model.harnessProfile);
+    const reasoningEffort = request.reasoningEffort === null ? null : resolveReasoningEffort(config, request.model, request.reasoningEffort);
+    const bodyOptions = reasoningBody(provider.adapter, reasoningEffort);
+    if (profile.value.semantics.reasoningStateRoundTrip === 'required' && provider.adapter === '@ai-sdk/openai-compatible') {
+        fail('MODEL_REASONING_UNSUPPORTED', 400, 'This adapter cannot guarantee required reasoning state round trips.');
+    }
+    const route = responseRoute(providerId, provider, modelId);
+    for (const message of request.messages) {
+        if (message.response === undefined) {
+            if (profile.value.semantics.reasoningStateRoundTrip === 'required' && message.toolCalls?.length)
+                fail('MODEL_REASONING_STATE_MISSING', 409, 'Historical tool calls have no complete Provider response state.');
+            continue;
+        }
+        if (message.response.content.some(part => part.type === 'reasoning' || part.type === 'reasoning-file')) {
+            if (message.response.route !== route)
+                fail('MODEL_REASONING_STATE_INCOMPATIBLE', 409, 'Reasoning state cannot be replayed on a different Provider or model route.');
+            assertReasoningState(message.response, provider.adapter, profile);
+        }
+    }
+    const settings = model.promptCache ?? provider.promptCache;
+    const enabled = config.providerPromptCache?.enabled ?? profile.value.cache.enabledByDefault;
+    const mode = enabled ? settings?.mode ?? (model.cacheSupported === true ? 'implicit' : 'off') : 'off';
+    if ((mode === 'anthropic' && provider.adapter !== '@ai-sdk/anthropic') || (mode === 'openai-explicit' && provider.adapter !== '@ai-sdk/openai')) {
+        fail('CONFIG_INVALID', 400, `Cache mode ${mode} does not match ${provider.adapter}.`);
+    }
+    if ((mode === 'anthropic' && settings?.ttl === '30m') || (mode === 'openai-explicit' && settings?.ttl !== undefined && settings.ttl !== '30m')) {
+        fail('CONFIG_INVALID', 400, `Cache TTL does not match ${mode}.`);
+    }
+    const routeDigest = digest({ providerId, model: model.wireModel ?? modelId, adapter: provider.adapter, options: provider.options });
+    const rawTools = request.tools.map(({ id, description, inputSchema }) => ({ id, description, inputSchema })).sort((a, b) => a.id < b.id ? -1 : a.id > b.id ? 1 : 0);
+    const systems = request.messages.filter((message) => message.role === 'system');
+    const logical = [...systems, ...imageMessages(request.messages.filter((message) => message.role !== 'system'))];
+    const baselineSource = { systems: systems.map(({ role, content }) => ({ role, content })), tools: rawTools };
+    const sourceDigest = digest(baselineSource);
+    const prior = record(previous?.request);
+    const savedBaseline = record(prior?.baseline);
+    const reuseBaseline = prior?.routeDigest === routeDigest && savedBaseline?.sourceDigest === sourceDigest;
+    // Restore the actual finalized header, not a newly rendered variant, on restart/retry.
+    const baseline = reuseBaseline ? savedBaseline
+        : { sourceDigest, messages: JSON.parse(canonicalize(baselineSource.systems)), tools: JSON.parse(canonicalize(rawTools)) };
+    const definitions = [...baseline.tools];
+    const messages = JSON.parse(canonicalize([
+        ...baseline.messages, ...logical.filter((message) => message.role !== 'system').map(message => aiMessage(message, route))
+    ]));
+    if (mode === 'openai-explicit') {
+        for (const [index, message] of messages.entries()) {
+            if (message.role !== 'tool')
+                continue;
+            messages[index] = { ...message, content: message.content.map((part) => {
+                    if (part.type !== 'tool-result')
+                        return part;
+                    const text = part.output.type === 'json' ? canonicalize(part.output.value) : part.output.type === 'text' ? part.output.value : '';
+                    return { ...part, output: { type: 'content', value: [{ type: 'text', text }] } };
+                }) };
+        }
+    }
+    const namespace = provider.adapter === '@ai-sdk/openai' ? 'openai' : provider.adapter === '@ai-sdk/anthropic' ? 'anthropic' : providerId;
+    const providerOptions = {};
+    if (provider.adapter === '@ai-sdk/openai')
+        providerOptions.openai = { ...providerOptions.openai, store: false, include: ['reasoning.encrypted_content'] };
+    if (mode !== 'off' && provider.adapter === '@ai-sdk/openai') {
+        providerOptions[namespace] = {
+            ...providerOptions[namespace],
+            ...(request.cacheIdentity === undefined ? {} : { promptCacheKey: request.cacheIdentity }),
+            ...(mode === 'openai-explicit' ? { promptCacheOptions: { mode: 'explicit', ttl: '30m' } } : {}),
+            ...(settings?.retention === undefined ? {} : { promptCacheRetention: settings.retention })
+        };
+    }
+    const minimum = settings?.minimumEligiblePrefixTokens ?? config.providerPromptCache?.minimumEligiblePrefixTokens ?? profile.value.cache.minimumEligiblePrefixTokens;
+    const maximum = Math.min(4, settings?.maximumBreakpoints ?? config.providerPromptCache?.maximumBreakpoints ?? profile.value.cache.maximumBreakpoints);
+    const toolsTokens = estimateTokens(canonicalize(definitions)).expected;
+    let cumulative = toolsTokens;
+    let blocks = definitions.length;
+    let prefix = digest({ routeDigest, tools: definitions, providerOptions, bodyOptions });
+    const entries = messages.map((message, ordinal) => {
+        cumulative += estimateTokens(canonicalize(message)).expected;
+        if (message.role === 'user' && Array.isArray(message.content))
+            cumulative += message.content.filter(part => part.type === 'image').length * imageTokenEstimate;
+        prefix = digest([prefix, digest(message)]);
+        blocks += typeof message.content === 'string' ? 1 : message.content.length;
+        return { ordinal, prefixTokens: cumulative, prefixDigest: prefix, eligible: cumulative >= minimum, blocks };
+    });
+    const { breakpoints, candidates, ttls } = selectCacheBreakpoints(logical, entries, {
+        mode, maximum, minimum, positions: settings?.positions ?? ['tool', 'system', 'message'], toolsTokens, hasTools: definitions.length > 0, ttl: settings?.ttl === '1h' ? '1h' : '5m',
+        supported: messages.map((message) => typeof message.content === 'string' ? message.content.length > 0
+            : mode === 'anthropic' ? message.content.length > 0 && !['reasoning', 'reasoning-file'].includes(message.content.at(-1)?.type ?? '') : message.role === 'tool'),
+        ...(record(previous?.preparation)?.cache_plan === undefined ? {} : { previous: record(previous?.preparation)?.cache_plan })
+    });
+    for (const ordinal of breakpoints) {
+        const ttl = ttls[ordinal];
+        if (ordinal === -1) {
+            const index = definitions.length - 1;
+            const definition = definitions[index];
+            definitions[index] = { ...definition, providerOptions: { anthropic: { cacheControl: { type: 'ephemeral', ttl: ttl ?? '5m' } } } };
+            continue;
+        }
+        const message = messages[ordinal];
+        const hint = mode === 'anthropic' ? { anthropic: { cacheControl: { type: 'ephemeral', ttl: ttl ?? settings?.ttl ?? '5m' } } } : { openai: { promptCacheBreakpoint: { mode: 'explicit' } } };
+        if (mode === 'openai-explicit' && message.role === 'tool') {
+            messages[ordinal] = { ...message, content: message.content.map((part, index) => {
+                    if (index !== message.content.length - 1 || part.type !== 'tool-result' || part.output.type !== 'content')
+                        return part;
+                    const output = part.output;
+                    return { ...part, output: { ...output, value: output.value.map((value, i) => i === output.value.length - 1 ? { ...value, providerOptions: hint } : value) } };
+                }) };
+        }
+        else if (message.role === 'system')
+            messages[ordinal] = { ...message, providerOptions: hint };
+        else if (typeof message.content === 'string')
+            messages[ordinal] = { ...message, content: [{ type: 'text', text: message.content, providerOptions: hint }] };
+        else
+            messages[ordinal] = { ...message, content: message.content.map((part, index) => {
+                    if (index !== message.content.length - 1 || part.type === 'reasoning' || part.type === 'reasoning-file')
+                        return part;
+                    const options = 'providerOptions' in part ? part.providerOptions : undefined;
+                    return { ...part, providerOptions: { ...options, [namespace]: { ...options?.[namespace], ...hint[namespace] } } };
+                }) };
+    }
+    // This Anthropic SDK removes schemas for `none`. Keep the cacheable schema prefix;
+    // the Compactor consumer rejects every tool event and never executes one.
+    const toolChoice = request.toolChoice === 'none' && provider.adapter !== '@ai-sdk/anthropic' ? 'none' : 'auto';
+    const fingerprint = digest({ model: model.wireModel ?? modelId, adapter: provider.adapter, messages: messages, tools: definitions, providerOptions, bodyOptions, toolChoice, maxOutputTokens: request.maxOutputTokens ?? null });
+    return {
+        version: 1, model: request.model, wireModel: model.wireModel ?? modelId, adapter: provider.adapter, routeDigest,
+        baseline, messages, tools: definitions, providerOptions, bodyOptions, toolChoice, reasoningEffort,
+        maxOutputTokens: request.maxOutputTokens ?? null,
+        cachePlan: { status: mode === 'off' ? 'disabled' : 'planned', mode, fingerprintVersion: 2, providerVisibleFingerprint: fingerprint,
+            hintsApplied: breakpoints.length > 0, breakpoints, candidates, ttls, entries, cacheIdentity: request.cacheIdentity ?? null,
+            model: request.model, routeDigest, systemDigest: digest(baseline.messages), toolsDigest: digest(baseline.tools), toolsTokens,
+            requestOptionsDigest: digest({ providerOptions, bodyOptions }), baselineRestored: reuseBaseline,
+            historyIds: logical.map((message) => message.contextItemId ?? ''), historyKinds: logical.map((message) => typeof message.metadata?.purpose === 'string' ? message.metadata.purpose : message.role),
+            snippedIds: logical.filter((message) => message.metadata?.snipped === true).map((message) => message.contextItemId ?? '') }
+    };
+}
+function reasoningBody(adapter, effort) {
+    if (effort === null)
+        return {};
     if (adapter === '@ai-sdk/openai')
-        return { openai: { reasoningEffort: effort } };
+        return { reasoning: { effort } };
     if (adapter === '@ai-sdk/anthropic')
-        return { anthropic: { effort } };
-    return { [providerId]: { reasoningEffort: effort } };
+        return { output_config: { effort } };
+    return { reasoning_effort: effort };
 }
-function createModel(providerId, modelId, config) {
+function createModel(providerId, modelId, config, bodyOptions, report) {
     const apiKey = resolveSecret(config.options.apiKey);
+    // Effort is user-owned. SDK enums must not reject or transform it before the
+    // endpoint sees it. Preserve other SDK-generated fields, headers and cancellation.
+    const transport = { fetch: (async (url, init) => {
+            const body = JSON.parse(init?.body);
+            for (const [key, value] of Object.entries(bodyOptions)) {
+                const fields = record(value);
+                body[key] = fields === undefined ? value : { ...record(body[key]), ...fields };
+            }
+            const serialized = JSON.stringify(body);
+            const destination = new URL(url instanceof Request ? url.url : url);
+            const transportId = randomUUID();
+            const base = { transport_id: transportId, destination_origin: destination.origin,
+                destination_path_sha256: sha256(destination.pathname), body_sha256: sha256(serialized), body_bytes: Buffer.byteLength(serialized) };
+            report?.({ ...base, event_type: 'model_send_started' });
+            let response;
+            try {
+                response = await fetch(url, { ...init, body: serialized, redirect: 'error' });
+            }
+            catch (error) {
+                report?.({ ...base, event_type: 'model_send_failed', outcome: 'unknown' });
+                throw error;
+            }
+            report?.({ ...base, event_type: 'model_response_headers', status: response.status,
+                outcome: 'headers_received_stream_not_confirmed' });
+            return response;
+        }) };
     if (config.adapter === '@ai-sdk/openai') {
-        const provider = createOpenAI({ ...(apiKey === undefined ? {} : { apiKey }), ...(config.options.baseURL === undefined ? {} : { baseURL: config.options.baseURL }), ...(config.options.headers === undefined ? {} : { headers: config.options.headers }) });
-        return { model: provider(modelId), programmaticTool: provider.tools.programmaticToolCalling() };
+        const provider = createOpenAI({ ...transport, ...(apiKey === undefined ? {} : { apiKey }), ...(config.options.baseURL === undefined ? {} : { baseURL: config.options.baseURL }), ...(config.options.headers === undefined ? {} : { headers: config.options.headers }) });
+        return { model: provider(modelId) };
     }
     if (config.adapter === '@ai-sdk/anthropic') {
-        return { model: createAnthropic({ ...(apiKey === undefined ? {} : { apiKey }), ...(config.options.baseURL === undefined ? {} : { baseURL: config.options.baseURL }), ...(config.options.headers === undefined ? {} : { headers: config.options.headers }) })(modelId) };
+        return { model: createAnthropic({ ...transport, ...(apiKey === undefined ? {} : { apiKey }), ...(config.options.baseURL === undefined ? {} : { baseURL: config.options.baseURL }), ...(config.options.headers === undefined ? {} : { headers: config.options.headers }) })(modelId) };
     }
     if (config.options.baseURL === undefined)
         fail('CONFIG_INVALID', 503, `Provider ${providerId} requires options.baseURL.`);
-    return { model: createOpenAICompatible({ name: providerId, baseURL: config.options.baseURL, ...(apiKey === undefined ? {} : { apiKey }), ...(config.options.headers === undefined ? {} : { headers: config.options.headers }) })(modelId) };
+    return { model: createOpenAICompatible({ ...transport, name: providerId, baseURL: config.options.baseURL, ...(apiKey === undefined ? {} : { apiKey }), ...(config.options.headers === undefined ? {} : { headers: config.options.headers }), convertUsage: compatibleUsage })(modelId) };
 }
-function tools(definitions, programmatic, providerTool, callers, ordinals) {
-    const result = {};
-    for (const definition of definitions) {
-        if (definition.id === 'programmatic_tool_run')
-            continue;
-        const eligible = programmatic?.capabilityIds.includes(definition.id) === true;
-        const descriptor = {
+function compatibleUsage(usage) {
+    const number = (value) => typeof value === 'number' && Number.isFinite(value) && value >= 0 ? value : undefined;
+    const details = usage?.prompt_tokens_details;
+    const outputDetails = usage?.completion_tokens_details;
+    const total = number(usage?.prompt_tokens);
+    const read = number(usage?.prompt_cache_hit_tokens) ?? number(details?.cached_tokens);
+    const miss = number(usage?.prompt_cache_miss_tokens) ?? (total === undefined || read === undefined ? undefined : Math.max(0, total - read));
+    const output = number(usage?.completion_tokens);
+    const reasoning = number(outputDetails?.reasoning_tokens);
+    return { inputTokens: { total, noCache: miss, cacheRead: read, cacheWrite: undefined },
+        outputTokens: { total: output, text: output === undefined || reasoning === undefined ? undefined : Math.max(0, output - reasoning), reasoning } };
+}
+function tools(definitions) {
+    return Object.fromEntries(definitions.map((definition) => [definition.id, tool({
             description: definition.description,
+            ...(definition.providerOptions === undefined ? {} : { providerOptions: definition.providerOptions }),
             inputSchema: jsonSchema(definition.inputSchema),
-            outputSchema: jsonSchema((definition.outputSchema ?? { type: 'object', additionalProperties: true }))
-        };
-        if (eligible) {
-            result[definition.id] = tool({
-                ...descriptor,
-                providerOptions: { openai: { outputSchema: definition.outputSchema ?? { type: 'object', additionalProperties: true } } },
-                execute: (input, options) => {
-                    const parentProviderCallId = callers.get(options.toolCallId);
-                    return programmatic.execute({
-                        capabilityId: definition.id,
-                        arguments: jsonValue(input),
-                        providerCallId: options.toolCallId,
-                        ordinal: ordinals.get(options.toolCallId) ?? 0,
-                        ...(parentProviderCallId === undefined ? {} : { parentProviderCallId })
-                    }, options.abortSignal);
-                }
-            });
-        }
-        else {
-            result[definition.id] = tool(descriptor);
-        }
-    }
-    if (programmatic !== undefined && providerTool !== undefined)
-        result.programmatic_tool_run = providerTool;
-    return result;
+            ...(definition.outputSchema === undefined ? {} : { outputSchema: jsonSchema(definition.outputSchema) })
+        })]));
 }
-function providerCaller(value) {
-    if (typeof value !== 'object' || value === null || Array.isArray(value))
-        return { programmatic: false, parentProviderCallId: null };
-    const candidates = [value, ...Object.values(value).filter(isObject)];
-    for (const candidate of candidates) {
-        const caller = candidate.caller;
-        if (!isObject(caller) || caller.type !== 'program')
-            continue;
-        const id = caller.callerId ?? caller.caller_id ?? caller.toolId ?? caller.tool_id;
-        return { programmatic: true, parentProviderCallId: typeof id === 'string' && id.length > 0 ? id : null };
+function aiMessage(message, route) {
+    if (message.role === 'assistant' && message.response?.route === route)
+        return { role: 'assistant', content: message.response.content };
+    if (message.role === 'user' && message.images?.length) {
+        return { role: 'user', content: [
+                { type: 'text', text: message.content },
+                ...message.images.map(image => ({ type: 'image', image: imageReference(image) }))
+            ] };
     }
-    return { programmatic: false, parentProviderCallId: null };
-}
-function isObject(value) {
-    return typeof value === 'object' && value !== null && !Array.isArray(value);
-}
-function aiMessage(message) {
     if (message.role === 'assistant' && message.toolCalls !== undefined) {
         return {
             role: 'assistant',
@@ -224,6 +421,34 @@ function aiMessage(message) {
     }
     return { role: message.role, content: message.content };
 }
+function responseRoute(providerId, provider, modelId) {
+    return digest({ providerId, adapter: provider.adapter, baseURL: provider.options.baseURL ?? null, model: provider.models[modelId]?.wireModel ?? modelId });
+}
+function assertReasoningState(response, adapter, profile) {
+    // OpenAI may split one reasoning item into multiple summaries; only the final
+    // summary carries its ciphertext, and the SDK rejoins them by itemId on replay.
+    const encryptedItems = new Set(response.content.flatMap(part => {
+        if (part.type !== 'reasoning')
+            return [];
+        const metadata = part.providerOptions?.openai;
+        return typeof metadata?.reasoningEncryptedContent === 'string' && typeof metadata.itemId === 'string' ? [metadata.itemId] : [];
+    }));
+    for (const part of response.content) {
+        if (part.type !== 'reasoning' && part.type !== 'reasoning-file')
+            continue;
+        if (profile.value.semantics.reasoningStateRoundTrip === 'forbidden' || profile.value.semantics.thinkingContinuation === 'forbidden') {
+            fail('MODEL_REASONING_STATE_FORBIDDEN', 409, 'The Model Profile forbids replaying reasoning state.');
+        }
+        const metadata = part.providerOptions;
+        if (adapter === '@ai-sdk/openai-compatible' && profile.value.semantics.reasoningStateRoundTrip === 'optional')
+            continue;
+        if (adapter === '@ai-sdk/anthropic' && (typeof metadata?.anthropic?.signature === 'string' || typeof metadata?.anthropic?.redactedData === 'string'))
+            continue;
+        if (adapter === '@ai-sdk/openai' && (typeof metadata?.openai?.reasoningEncryptedContent === 'string' || (typeof metadata?.openai?.itemId === 'string' && encryptedItems.has(metadata.openai.itemId))))
+            continue;
+        fail('MODEL_REASONING_STATE_MISSING', 502, 'The Provider returned reasoning without replayable state.');
+    }
+}
 function toolOutput(content) {
     try {
         const parsed = JSON.parse(content);

package/dist/runtime/observability.d.ts

@@ -14,6 +14,7 @@ export declare class Observability {
     constructor(root: string, config: HarnessConfig['observability']);
     record(component: string, operation: string, outcome: string, durationMs: number, fields?: Readonly<Record<string, Json>>): void;
     increment(name: string, amount?: number): void;
+    status(): Readonly<Record<string, Json>>;
     logs(limit: number): readonly RuntimeRecord[];
     traces(limit: number): readonly RuntimeRecord[];
     agentOps(limit: number): readonly RuntimeRecord[];