narraeon 0.1.1 → 0.2.0

package/dist/node/runtime/model/ModelConnectionStore.js

@@ -1,7 +1,7 @@
 import { randomUUID } from "node:crypto";
 import { chmod, mkdir, open, readFile, rename, stat, unlink, } from "node:fs/promises";
 import { join } from "node:path";
-import { modelProviderPresets, } from "../../protocol/modelConnections.js";
+import { hasCLIProxyThinkingSuffix, modelReasoningPolicyIssue, modelProviderPresets, } from "../../protocol/modelConnections.js";
 const libraryFileName = "model-connections-v1.json";
 const maxModelListBytes = 1024 * 1024;
 export class ModelConnectionUnavailableError extends Error {
@@ -204,6 +204,26 @@ function normalizeSaveInput(input, existing) {
     const provider = validateProvider(input.provider);
     const baseUrl = normalizeBaseUrl(requiredTrimmed(input.baseUrl, "Base URL", 4096));
     const modelId = requiredTrimmed(input.modelId, "Model ID", 512);
+    const dialect = validateDialect(input.dialect ?? existing?.dialect);
+    const reasoningEffort = validateReasoningEffort(input.reasoningEffort ?? existing?.reasoningEffort);
+    const reasoningSummary = validateReasoningSummary(input.reasoningSummary ?? existing?.reasoningSummary);
+    const thinkingMode = validateThinkingMode(input.thinkingMode ?? existing?.thinkingMode);
+    const thinkingBudgetTokens = validateThinkingBudgetTokens(input.thinkingBudgetTokens !== undefined
+        ? input.thinkingBudgetTokens
+        : thinkingMode === "enabled"
+            ? existing?.thinkingBudgetTokens
+            : null);
+    validateTokenLimits(input.contextWindowTokens, input.maxOutputTokens);
+    validateReasoningPolicy({
+        provider,
+        dialect,
+        modelId,
+        effort: reasoningEffort,
+        summary: reasoningSummary,
+        thinking: thinkingMode,
+        thinkingBudgetTokens,
+        maxOutputTokens: input.maxOutputTokens,
+    });
     const explicitApiKey = normalizeOptionalApiKey(input.apiKey);
     const apiKey = explicitApiKey ??
         (existing?.provider === provider && existing.baseUrl === baseUrl
@@ -213,15 +233,19 @@ function normalizeSaveInput(input, existing) {
         throw new Error(existing === undefined
             ? "A new model configuration requires an API key"
             : "The endpoint or protocol changed; enter the API key again because old credentials are never forwarded to a new endpoint");
-    validateTokenLimits(input.contextWindowTokens, input.maxOutputTokens);
     validatePresetBinding(presetId, provider, baseUrl);
     return {
         name,
         presetId,
         provider,
+        dialect,
         baseUrl,
         apiKey,
         modelId,
+        reasoningEffort,
+        reasoningSummary,
+        thinkingMode,
+        thinkingBudgetTokens,
         contextWindowTokens: input.contextWindowTokens,
         maxOutputTokens: input.maxOutputTokens,
     };
@@ -253,19 +277,52 @@ function validateStoredConnection(value) {
     const name = requiredTrimmed(value.name, "Configuration name", 160);
     const presetId = validatePresetId(value.presetId);
     const provider = validateProvider(value.provider);
+    const dialect = validateDialect(value.dialect);
     const baseUrl = normalizeBaseUrl(requiredTrimmed(value.baseUrl, "Base URL"));
     const apiKey = requiredTrimmed(value.apiKey, "API Key", 16_384);
     const modelId = requiredTrimmed(value.modelId, "Model ID", 512);
+    let reasoningEffort = validateReasoningEffort(value.reasoningEffort);
+    const reasoningSummary = validateReasoningSummary(value.reasoningSummary);
+    let thinkingMode = validateThinkingMode(value.thinkingMode);
+    const thinkingBudgetTokens = validateThinkingBudgetTokens(value.thinkingBudgetTokens);
+    // Before Thinking became an independent field, Anthropic effort=none meant
+    // disabled thinking and a non-default summary implicitly activated adaptive
+    // thinking. Normalize that released shape without reinterpreting new data.
+    if (value.thinkingMode === undefined && provider === "anthropic_messages") {
+        if (reasoningEffort === "none") {
+            reasoningEffort = "provider_default";
+            thinkingMode = "disabled";
+        }
+        else if (reasoningSummary !== "provider_default" &&
+            !(dialect === "cliproxyapi" && hasCLIProxyThinkingSuffix(modelId))) {
+            thinkingMode = "adaptive";
+        }
+    }
     validateTokenLimits(value.contextWindowTokens, value.maxOutputTokens);
+    validateReasoningPolicy({
+        provider,
+        dialect,
+        modelId,
+        effort: reasoningEffort,
+        summary: reasoningSummary,
+        thinking: thinkingMode,
+        thinkingBudgetTokens,
+        maxOutputTokens: value.maxOutputTokens,
+    });
     validatePresetBinding(presetId, provider, baseUrl);
     return {
         id,
         name,
         presetId,
         provider,
+        dialect,
         baseUrl,
         apiKey,
         modelId,
+        reasoningEffort,
+        reasoningSummary,
+        thinkingMode,
+        thinkingBudgetTokens,
         contextWindowTokens: value.contextWindowTokens,
         maxOutputTokens: value.maxOutputTokens,
     };
@@ -276,8 +333,13 @@ function toView(connection) {
         name: connection.name,
         presetId: connection.presetId,
         provider: connection.provider,
+        dialect: connection.dialect,
         baseUrl: connection.baseUrl,
         modelId: connection.modelId,
+        reasoningEffort: connection.reasoningEffort,
+        reasoningSummary: connection.reasoningSummary,
+        thinkingMode: connection.thinkingMode,
+        thinkingBudgetTokens: connection.thinkingBudgetTokens,
         contextWindowTokens: connection.contextWindowTokens,
         maxOutputTokens: connection.maxOutputTokens,
         hasApiKey: true,
@@ -286,9 +348,14 @@ function toView(connection) {
 function toBinding(connection) {
     return structuredClone({
         provider: connection.provider,
+        dialect: connection.dialect,
         baseUrl: connection.baseUrl,
         apiKey: connection.apiKey,
         modelId: connection.modelId,
+        reasoningEffort: connection.reasoningEffort,
+        reasoningSummary: connection.reasoningSummary,
+        thinkingMode: connection.thinkingMode,
+        thinkingBudgetTokens: connection.thinkingBudgetTokens,
         contextWindowTokens: connection.contextWindowTokens,
         maxOutputTokens: connection.maxOutputTokens,
     });
@@ -300,6 +367,60 @@ function validateProvider(value) {
         throw new Error("Model-connection protocol is invalid");
     return value;
 }
+function validateDialect(value) {
+    if (value === undefined)
+        return "standard";
+    if (value !== "standard" && value !== "cliproxyapi")
+        throw new Error("Model-provider dialect is invalid");
+    return value;
+}
+function validateReasoningEffort(value) {
+    if (value === undefined)
+        return "provider_default";
+    if (value !== "provider_default" &&
+        value !== "none" &&
+        value !== "minimal" &&
+        value !== "low" &&
+        value !== "medium" &&
+        value !== "high" &&
+        value !== "xhigh" &&
+        value !== "max")
+        throw new Error("Model reasoning effort is invalid");
+    return value;
+}
+function validateReasoningSummary(value) {
+    if (value === undefined)
+        return "provider_default";
+    if (value !== "provider_default" &&
+        value !== "auto" &&
+        value !== "concise" &&
+        value !== "detailed" &&
+        value !== "none")
+        throw new Error("Model reasoning-summary policy is invalid");
+    return value;
+}
+function validateThinkingMode(value) {
+    if (value === undefined)
+        return "provider_default";
+    if (value !== "provider_default" &&
+        value !== "adaptive" &&
+        value !== "enabled" &&
+        value !== "disabled")
+        throw new Error("Model thinking mode is invalid");
+    return value;
+}
+function validateThinkingBudgetTokens(value) {
+    if (value === undefined || value === null)
+        return null;
+    if (!Number.isSafeInteger(value) || Number(value) < 0)
+        throw new Error("Model thinking token budget is invalid");
+    return Number(value);
+}
+function validateReasoningPolicy(input) {
+    const issue = modelReasoningPolicyIssue(input);
+    if (issue !== null)
+        throw new Error(issue);
+}
 function validatePresetId(value) {
     if (typeof value !== "string" ||
         !modelProviderPresets.some(({ id }) => id === value))

package/dist/node/runtime/model/ModelHost.js

@@ -4,7 +4,8 @@ export function equalModelHostBinding(left, right) {
         left.modelId === right.modelId &&
         left.contextWindowTokens === right.contextWindowTokens &&
         left.maxOutputTokens === right.maxOutputTokens &&
-        left.protocolConfigFingerprint === right.protocolConfigFingerprint);
+        left.protocolConfigFingerprint === right.protocolConfigFingerprint &&
+        left.cacheStrategy === right.cacheStrategy);
 }
 /** The persisted operation binding is unavailable in the current Runtime. */
 export class ModelHostBindingMismatchError extends Error {
@@ -14,6 +15,14 @@ export class ModelHostBindingMismatchError extends Error {
         this.name = "ModelHostBindingMismatchError";
     }
 }
+/** The logical session cannot continue without its provider-native payload. */
+export class ModelHostContinuationError extends Error {
+    kind = "continuation_unavailable";
+    constructor(message, options) {
+        super(message, options);
+        this.name = "ModelHostContinuationError";
+    }
+}
 /** A deterministic provider failure: the operation may be failed safely. */
 export class ModelHostFailureError extends Error {
     kind = "failed";
@@ -31,6 +40,11 @@ export class ModelHostOutcomeUnknownError extends Error {
     }
 }
 /** Deterministic adapter for exercising the true external ModelHost port. */
+/**
+ * Deterministic test double. Its synthetic provider state is fixture data, not
+ * a production continuation codec; real adapters must retain returned native
+ * state and never call scriptedProviderState.
+ */
 export class ScriptedModelHost {
     requests = [];
     #binding;
@@ -57,8 +71,8 @@ export class ScriptedModelHost {
         for (const delta of deltas ?? [])
             observer?.onDelta?.(structuredClone(delta));
         const providerState = response.providerState ??
-            (continuation === "available"
-                ? scriptedProviderState(this.#binding.provider, this.#responseIndex)
+            (continuation !== "lost"
+                ? scriptedProviderState(this.#binding.provider, this.#responseIndex, response)
                 : undefined);
         this.#responseIndex += 1;
         return Promise.resolve({
@@ -69,21 +83,72 @@ export class ScriptedModelHost {
         });
     }
 }
-function scriptedProviderState(provider, responseIndex) {
-    if (provider === "openai_responses")
+function scriptedProviderState(provider, responseIndex, response) {
+    if (provider === "openai_responses") {
+        const output = [];
+        if (response.reasoningContent !== undefined)
+            output.push({
+                type: "reasoning",
+                summary: [{ type: "summary_text", text: response.reasoningContent }],
+            });
+        if (response.text !== undefined)
+            output.push({
+                type: "message",
+                role: "assistant",
+                content: [{ type: "output_text", text: response.text }],
+            });
+        for (const call of response.toolCalls ?? [])
+            output.push({
+                type: "function_call",
+                call_id: call.id,
+                name: call.name,
+                arguments: JSON.stringify(call.arguments),
+            });
         return {
             protocol: "openai_responses",
-            output: [],
+            output,
             responseId: `scripted-${responseIndex}`,
         };
-    if (provider === "anthropic_messages")
+    }
+    if (provider === "anthropic_messages") {
+        const content = [];
+        if (response.reasoningContent !== undefined)
+            content.push({ type: "thinking", thinking: response.reasoningContent });
+        if (response.text !== undefined)
+            content.push({ type: "text", text: response.text });
+        for (const call of response.toolCalls ?? [])
+            content.push({
+                type: "tool_use",
+                id: call.id,
+                name: call.name,
+                input: structuredClone(call.arguments),
+            });
         return {
             protocol: "anthropic_messages",
-            content: [],
+            content,
             responseId: `scripted-${responseIndex}`,
         };
+    }
     return {
         protocol: "chat_completions",
-        assistantMessage: { role: "assistant", content: null },
+        assistantMessage: {
+            role: "assistant",
+            content: response.text ?? null,
+            ...(response.reasoningContent === undefined
+                ? {}
+                : { reasoning_content: response.reasoningContent }),
+            ...((response.toolCalls ?? []).length === 0
+                ? {}
+                : {
+                    tool_calls: response.toolCalls.map((call) => ({
+                        id: call.id,
+                        type: "function",
+                        function: {
+                            name: call.name,
+                            arguments: JSON.stringify(call.arguments),
+                        },
+                    })),
+                }),
+        },
     };
 }

package/dist/node/runtime/model/ModelHostStream.js

@@ -4,8 +4,10 @@ export async function aggregateChatModelStream(body, onDelta) {
     let content = "";
     let reasoningContent = "";
     let usage;
+    let stopReason;
     let completed = false;
     let sawPayload = false;
+    const providerMessage = { role: "assistant" };
     const calls = new Map();
     for await (const event of modelHostEvents(body)) {
         if (event.data === "[DONE]") {
@@ -31,9 +33,12 @@ export async function aggregateChatModelStream(body, onDelta) {
                 choiceValue.finish_reason !== null &&
                 typeof choiceValue.finish_reason !== "string")
                 throw new Error("Chat SSE finish_reason is invalid");
+            if (typeof choiceValue.finish_reason === "string")
+                stopReason = choiceValue.finish_reason;
             const delta = choiceValue.delta;
             if (delta.role !== undefined && delta.role !== "assistant")
                 throw new Error("Chat SSE assistant role is invalid");
+            mergeChatProviderDelta(providerMessage, delta);
             if (delta.content !== undefined &&
                 delta.content !== null &&
                 typeof delta.content !== "string")
@@ -113,6 +118,7 @@ export async function aggregateChatModelStream(body, onDelta) {
         return { id: call.id, name: call.name, arguments: call.arguments };
     });
     const assistantMessage = {
+        ...providerMessage,
         role: "assistant",
         content: content === "" ? null : content,
         ...(reasoningContent === "" ? {} : { reasoning_content: reasoningContent }),
@@ -132,8 +138,50 @@ export async function aggregateChatModelStream(body, onDelta) {
         assistantMessage,
         toolCalls,
         usage,
+        ...(stopReason === undefined ? {} : { stopReason }),
     };
 }
+/**
+ * Preserve compatibility fields carried by Chat SSE deltas without pretending
+ * they are part of the Runtime projection. Known fields are rebuilt below from
+ * their protocol-defined fragment rules; unknown fields stay opaque here.
+ */
+function mergeChatProviderDelta(target, delta) {
+    for (const [key, value] of Object.entries(delta)) {
+        if (key === "role" ||
+            key === "content" ||
+            key === "reasoning_content" ||
+            key === "tool_calls" ||
+            value === undefined)
+            continue;
+        target[key] = mergeOpaqueDelta(target[key], value);
+    }
+}
+function mergeOpaqueDelta(current, fragment) {
+    if (fragment === null)
+        return current ?? null;
+    if (typeof fragment === "string")
+        return typeof current === "string" ? current + fragment : fragment;
+    if (Array.isArray(fragment)) {
+        const result = Array.isArray(current) ? structuredClone(current) : [];
+        for (const item of fragment) {
+            if (isRecord(item) && Number.isSafeInteger(item.index)) {
+                const index = Number(item.index);
+                result[index] = mergeOpaqueDelta(result[index], item);
+            }
+            else
+                result.push(structuredClone(item));
+        }
+        return result;
+    }
+    if (isRecord(fragment)) {
+        const result = isRecord(current) ? structuredClone(current) : {};
+        for (const [key, value] of Object.entries(fragment))
+            result[key] = mergeOpaqueDelta(result[key], value);
+        return result;
+    }
+    return structuredClone(fragment);
+}
 export async function aggregateAnthropicModelStream(body, onDelta) {
     const blocks = new Map();
     const usage = {};
@@ -153,7 +201,8 @@ export async function aggregateAnthropicModelStream(body, onDelta) {
                 if (started || !isRecord(payload.message))
                     throw new Error("Anthropic SSE message_start is invalid");
                 if (payload.message.role !== "assistant" ||
-                    !Array.isArray(payload.message.content))
+                    !Array.isArray(payload.message.content) ||
+                    payload.message.content.length !== 0)
                     throw new Error("Anthropic SSE initial message is invalid");
                 started = true;
                 responseId = stringOrUndefined(payload.message.id);
@@ -357,10 +406,21 @@ function mergeUsage(target, value) {
         "output_tokens",
         "cache_read_input_tokens",
         "cache_creation_input_tokens",
+        "thinking_tokens",
     ]) {
         if (value[field] !== undefined)
             target[field] = value[field];
     }
+    // Anthropic reports the billed thinking subset only on the final
+    // message_delta. Preserve the nested object so the shared usage normalizer
+    // sees the same shape for streaming and non-streaming responses.
+    if (isRecord(value.output_tokens_details))
+        target.output_tokens_details = {
+            ...(isRecord(target.output_tokens_details)
+                ? target.output_tokens_details
+                : {}),
+            ...structuredClone(value.output_tokens_details),
+        };
 }
 function stringOrUndefined(value) {
     return typeof value === "string" ? value : undefined;

package/dist/node/runtime/model/SettingAuthorStream.js

@@ -1,118 +1,21 @@
-import { providerStreamEvents, providerStreamJson } from "./ProviderStream.js";
-export async function aggregateChatSettingStream(body, onDelta) {
-    let content = "";
-    let reasoningContent = "";
-    let usage = null;
-    // Tool calls arrive as fragments keyed by index; id and name usually only
-    // appear on the first fragment, while arguments accumulate across many.
-    const calls = new Map();
-    for await (const event of providerStreamEvents(body)) {
-        const payload = providerStreamJson(event.data);
-        if (!isRecord(payload))
-            continue;
-        if (isRecord(payload.usage))
-            usage = payload.usage;
-        const choices = Array.isArray(payload.choices)
-            ? payload.choices
-            : [];
-        const choice = choices[0];
-        if (!isRecord(choice) || !isRecord(choice.delta))
-            continue;
-        const { delta } = choice;
-        if (typeof delta.content === "string" && delta.content !== "") {
-            content += delta.content;
-            onDelta?.({ kind: "text", text: delta.content });
-        }
-        if (typeof delta.reasoning_content === "string" &&
-            delta.reasoning_content !== "") {
-            reasoningContent += delta.reasoning_content;
-            onDelta?.({ kind: "reasoning", text: delta.reasoning_content });
-        }
-        if (!Array.isArray(delta.tool_calls))
-            continue;
-        for (const [position, fragment] of delta.tool_calls.entries()) {
-            if (!isRecord(fragment))
-                continue;
-            const index = typeof fragment.index === "number" ? fragment.index : position;
-            const current = calls.get(index) ?? { id: "", name: "", arguments: "" };
-            if (typeof fragment.id === "string" && fragment.id !== "")
-                current.id = fragment.id;
-            const call = isRecord(fragment.function) ? fragment.function : {};
-            if (typeof call.name === "string" && call.name !== "")
-                current.name = call.name;
-            if (typeof call.arguments === "string" && call.arguments !== "") {
-                current.arguments += call.arguments;
-                onDelta?.({ kind: "tool", text: call.arguments });
-            }
-            calls.set(index, current);
-        }
-    }
-    return {
-        content,
-        reasoningContent,
-        toolCalls: [...calls.entries()]
-            .sort(([left], [right]) => left - right)
-            .map(([, call]) => call),
-        usage,
-    };
+import { aggregateAnthropicModelStream, aggregateChatModelStream, } from "./ModelHostStream.js";
+export function aggregateChatSettingStream(body, onDelta) {
+    return aggregateChatModelStream(body, onDelta);
 }
 export async function aggregateAnthropicSettingStream(body, onDelta) {
-    let content = "";
-    let reasoningContent = "";
-    let inputTokens;
-    let outputTokens;
-    // Anthropic streams one block at a time, so the open block's index decides
-    // which accumulator a delta belongs to.
-    const blocks = new Map();
-    for await (const event of providerStreamEvents(body)) {
-        const payload = providerStreamJson(event.data);
-        if (!isRecord(payload))
-            continue;
-        if (isRecord(payload.message) && isRecord(payload.message.usage))
-            inputTokens = payload.message.usage.input_tokens;
-        if (isRecord(payload.usage) && payload.usage.output_tokens !== undefined)
-            outputTokens = payload.usage.output_tokens;
-        const index = typeof payload.index === "number" ? payload.index : -1;
-        if (payload.type === "content_block_start") {
-            const block = isRecord(payload.content_block)
-                ? payload.content_block
-                : {};
-            if (block.type === "tool_use")
-                blocks.set(index, {
-                    id: typeof block.id === "string" ? block.id : "",
-                    name: typeof block.name === "string" ? block.name : "",
-                    arguments: "",
-                });
-            continue;
-        }
-        if (payload.type !== "content_block_delta" || !isRecord(payload.delta))
-            continue;
-        const { delta } = payload;
-        if (typeof delta.text === "string" && delta.text !== "") {
-            content += delta.text;
-            onDelta?.({ kind: "text", text: delta.text });
-        }
-        if (typeof delta.thinking === "string" && delta.thinking !== "") {
-            reasoningContent += delta.thinking;
-            onDelta?.({ kind: "reasoning", text: delta.thinking });
-        }
-        if (typeof delta.partial_json === "string" && delta.partial_json !== "") {
-            const current = blocks.get(index);
-            if (current !== undefined) {
-                current.arguments += delta.partial_json;
-                onDelta?.({ kind: "tool", text: delta.partial_json });
-            }
-        }
-    }
+    const result = await aggregateAnthropicModelStream(body, onDelta);
     return {
-        content,
-        reasoningContent,
-        toolCalls: [...blocks.entries()]
-            .sort(([left], [right]) => left - right)
-            .map(([, call]) => call),
-        usage: { input_tokens: inputTokens, output_tokens: outputTokens },
+        content: result.text,
+        reasoningContent: result.reasoningContent,
+        providerContent: result.content,
+        toolCalls: result.toolCalls,
+        usage: result.usage,
+        ...(result.responseId === undefined
+            ? {}
+            : { responseId: result.responseId }),
+        ...(result.model === undefined ? {} : { model: result.model }),
+        ...(result.stopReason === undefined
+            ? {}
+            : { stopReason: result.stopReason }),
     };
 }
-function isRecord(value) {
-    return typeof value === "object" && value !== null && !Array.isArray(value);
-}