@code-yeongyu/senpi-ai 2026.9.29 → 2026.10.1-2

package/dist/api/openai-responses.js

@@ -1,7 +1,6 @@
 import OpenAI from "openai";
 import { calculateCost, clampThinkingLevel, inferOpenAIThinkingLevelMap, supportsMax, supportsXhigh, } from "../models.js";
 import { readProviderDiagnostic } from "../provider-diagnostic.js";
-import { splitDeferredTools } from "../utils/deferred-tools.js";
 import { formatProviderError, normalizeProviderError } from "../utils/error-body.js";
 import { AssistantMessageEventStream } from "../utils/event-stream.js";
 import { formatGitHubCopilotToolLimitError, limitGitHubCopilotTools, recordGitHubCopilotToolLimit, } from "../utils/github-copilot-tool-limit.js";
@@ -11,6 +10,7 @@ import { awaitProviderTransport, openAICompatibleProviderDiagnosticFromError, }
 import { getProviderEnvValue } from "../utils/provider-env.js";
 import { retryProviderRequest } from "../utils/provider-retry.js";
 import { sendWithForcedToolChoiceFallback } from "../utils/tool-choice-fallback.js";
+import { getCurrentTools, getDeclaredTools, normalizeContext, resolveTranscript } from "../utils/transcript.js";
 import { isCloudflareProvider, resolveCloudflareBaseUrl } from "./cloudflare.js";
 import { createGrammarToolInputProperties } from "./constrained-sampling.js";
 import { withGitHubCopilotFailureNote } from "./github-copilot-errors.js";
@@ -18,7 +18,7 @@ import { buildCopilotDynamicHeaders, hasCopilotVisionInput } from "./github-copi
 import { resolveOpenAIClientAuth } from "./openai-client-auth.js";
 import { clampOpenAIPromptCacheKey } from "./openai-prompt-cache.js";
 import { findPromptCacheComparisonResponseId, withPromptCacheComparison, } from "./openai-responses-prompt-cache.js";
-import { convertResponsesMessages, convertResponsesTools, processResponsesStream } from "./openai-responses-shared.js";
+import { convertResponsesMessages, convertResponsesTools, processResponsesStream, resolveResponsesDeferredToolsMode, resolveResponsesToolPlacement, } from "./openai-responses-shared.js";
 import { buildBaseOptions, clampMaxForOpenAI, OPENAI_RESPONSES_RESERVED_BODY_KEYS } from "./simple-options.js";
 import { startWebSocketLiveness } from "./websocket-liveness.js";
 import { createWebSocketTransportFailure } from "./websocket-transport-failure.js";
@@ -29,6 +29,7 @@ const SESSION_WEBSOCKET_CACHE_TTL_MS = 5 * 60 * 1000;
 // OpenAI Responses rejects max_output_tokens below 16: https://github.com/earendil-works/pi/issues/6265
 const OPENAI_RESPONSES_MIN_OUTPUT_TOKENS = 16;
 const PROMPT_CACHE_PREWARM_TIMEOUT_MS = 30_000;
+const CHATGPT_USAGE_URL = "https://chatgpt.com/settings/usage";
 const websocketSessionCache = new Map();
 /** True when tool_choice forces a specific tool or mode (anything but "auto"/"none"). */
 function isForcedOpenAIResponsesToolChoice(toolChoice) {
@@ -54,6 +55,7 @@ function getCompat(model, env) {
     const isNativeEndpoint = isOpenAIResponsesNativeEndpoint(model, env);
     return {
         supportsDeveloperRole: model.compat?.supportsDeveloperRole ?? true,
+        supportsMidConvoSystemMessages: model.compat?.supportsMidConvoSystemMessages ?? false,
         sessionAffinityFormat: model.compat?.sessionAffinityFormat ?? detectSessionAffinityFormat(model),
         supportsLongCacheRetention: model.compat?.supportsLongCacheRetention ?? true,
         supportsWebSocket: model.compat?.supportsWebSocket ?? isNativeEndpoint,
@@ -150,15 +152,15 @@ function allowedReference(tool) {
  * senpi#2095: `tools` carries every tool declared this session, so removing a tool never rewrites the
  * cached prefix; the callable subset rides `tool_choice: allowed_tools` instead. Hosted tools a payload
  * hook added stay callable, and deferred tools (declared by transcript items rather than `tools`) are
- * referenced by name. An empty subset forbids tool calls. An explicit `tool_choice` always wins.
+ * referenced by name. A declared tool a payload hook removed from `tools` is not referenced (senpi#2234).
+ * An empty subset forbids tool calls. An explicit `tool_choice` always wins.
  */
-function applyAllowedToolsChoice(params, context, compat) {
-    const activeToolNames = context.activeToolNames;
+function applyAllowedToolsChoice(params, context, activeToolNames, compat) {
     if (!compat.supportsAllowedTools || activeToolNames === undefined || params.tool_choice !== undefined) {
         return params;
     }
     const active = new Set(activeToolNames);
-    const declaredTools = context.tools ?? [];
+    const declaredTools = getCurrentTools(context.messages);
     if (declaredTools.every((tool) => active.has(tool.name)))
         return params;
     const allowed = [];
@@ -171,8 +173,10 @@ function applyAllowedToolsChoice(params, context, compat) {
         }
         allowed.push(allowedReference(tool));
     }
+    // Tools missing from the request-level `tools` placement are the ones transcript items load in place.
+    const requestToolNames = new Set(resolveResponsesToolPlacement(context.messages, resolveResponsesDeferredToolsMode(compat) !== undefined).requestTools.map((tool) => tool.name));
     for (const tool of declaredTools) {
-        if (namedInTools.has(tool.name) || !active.has(tool.name))
+        if (namedInTools.has(tool.name) || !active.has(tool.name) || requestToolNames.has(tool.name))
             continue;
         const [converted] = convertResponsesTools([tool], {
             supportsStrictMode: compat.supportsStrictMode,
@@ -184,14 +188,19 @@ function applyAllowedToolsChoice(params, context, compat) {
     const toolChoice = allowed.length > 0 ? { type: "allowed_tools", mode: "auto", tools: allowed } : "none";
     return { ...params, tool_choice: toolChoice };
 }
-function formatOpenAIResponsesError(error) {
-    return formatProviderError(normalizeProviderError(error), "OpenAI API error");
+function formatOpenAIResponsesError(error, provider) {
+    const errorMessage = formatProviderError(normalizeProviderError(error), `${provider === "openai" ? "OpenAI" : provider} API error`);
+    // Sign in with ChatGPT shares the subscription's usage limit with other apps.
+    return errorMessage.includes("subscription_sharing_usage_limit_exceeded")
+        ? `${errorMessage}\nCheck your ChatGPT usage: ${CHATGPT_USAGE_URL}`
+        : errorMessage;
 }
 /**
  * Generate function for OpenAI Responses API
  */
 export const stream = (model, context, options) => {
     const stream = new AssistantMessageEventStream();
+    const normalizedContext = resolveTranscript(context, getCompat(model).supportsMidConvoSystemMessages);
     // Start async processing
     (async () => {
         const output = {
@@ -216,15 +225,15 @@ export const stream = (model, context, options) => {
             const cacheRetention = resolveCacheRetention(options?.cacheRetention, options?.env);
             const cacheSessionId = cacheRetention === "none" ? undefined : options?.sessionId;
             const compat = getCompat(model, options?.env);
-            const grammarToolInputProperties = createGrammarToolInputProperties(context.tools, compat.supportsOpenAIGrammarTools);
-            const client = createClient(model, context, clientAuth.apiKey, clientAuth.headers, options?.fetch, cacheSessionId, options?.env);
-            let params = buildParams(model, context, options, compat, grammarToolInputProperties);
+            const grammarToolInputProperties = createGrammarToolInputProperties(getDeclaredTools(normalizedContext.messages), compat.supportsOpenAIGrammarTools);
+            const client = createClient(model, normalizedContext, clientAuth.apiKey, clientAuth.headers, options?.fetch, cacheSessionId, options?.env);
+            let params = buildParams(model, normalizedContext, options, compat, grammarToolInputProperties);
             const nextParams = await options?.onPayload?.(params, model);
             if (nextParams !== undefined) {
                 params = nextParams;
             }
             params = sanitizeUnsupportedNativeTools(params, compat);
-            params = applyAllowedToolsChoice(params, context, compat);
+            params = applyAllowedToolsChoice(params, normalizedContext, context.activeToolNames, compat);
             const limitedTools = limitGitHubCopilotTools(model.provider, params.tools, params.tool_choice);
             if (limitedTools.omittedCount > 0) {
                 params = { ...params, tools: limitedTools.tools };
@@ -234,7 +243,7 @@ export const stream = (model, context, options) => {
             if (transport !== "sse" && compat.supportsWebSocket) {
                 let websocketStarted = false;
                 try {
-                    await processWebSocketStream(resolveOpenAIResponsesWebSocketUrl(model, options?.env), params, buildWebSocketHeaders(model, context, clientAuth.apiKey, clientAuth.headers, cacheSessionId, options?.env), output, stream, model, () => {
+                    await processWebSocketStream(resolveOpenAIResponsesWebSocketUrl(model, options?.env), params, buildWebSocketHeaders(model, normalizedContext, clientAuth.apiKey, clientAuth.headers, cacheSessionId, options?.env), output, stream, model, () => {
                         websocketStarted = true;
                     }, cacheSessionId, grammarToolInputProperties, options);
                     if (options?.signal?.aborted) {
@@ -276,6 +285,7 @@ export const stream = (model, context, options) => {
             await options?.onResponse?.({ status: response.status, headers: headersToRecord(response.headers) }, model);
             stream.push({ type: "start", partial: output });
             await processResponsesStream(openaiStream, output, stream, model, {
+                onProviderStreamEvent: options?.onProviderStreamEvent,
                 serviceTier: options?.serviceTier,
                 grammarToolInputProperties,
                 applyServiceTierPricing: (usage, serviceTier) => applyServiceTierPricing(usage, serviceTier, model),
@@ -305,7 +315,7 @@ export const stream = (model, context, options) => {
                 : undefined;
             if (providerDiagnostic !== undefined)
                 output.providerDiagnostic = providerDiagnostic;
-            output.errorMessage = withGitHubCopilotFailureNote(formatGitHubCopilotToolLimitError(output, formatOpenAIResponsesError(error)), model.provider, error);
+            output.errorMessage = withGitHubCopilotFailureNote(formatGitHubCopilotToolLimitError(output, formatOpenAIResponsesError(error, model.provider)), model.provider, error);
             stream.push({ type: "error", reason: output.stopReason, error: output });
             stream.end();
         }
@@ -337,12 +347,12 @@ function resolveSimpleOptions(model, context, options) {
  * prefix matches the reasoning effort, service tier, and cache options that turn sends.
  */
 export async function warmOpenAIResponsesPromptCache(model, context, options) {
-    const prefix = { ...context, messages: [] };
+    const prefix = normalizeContext({ ...context, messages: [] });
     const resolved = resolveSimpleOptions(model, prefix, options);
     const clientAuth = resolveOpenAIClientAuth(model.provider, resolved.apiKey, resolved.headers);
     const cacheRetention = resolveCacheRetention(resolved.cacheRetention, resolved.env);
     const compat = getCompat(model, resolved.env);
-    const grammarToolInputProperties = createGrammarToolInputProperties(prefix.tools, compat.supportsOpenAIGrammarTools);
+    const grammarToolInputProperties = createGrammarToolInputProperties(getDeclaredTools(prefix.messages), compat.supportsOpenAIGrammarTools);
     const client = createClient(model, prefix, clientAuth.apiKey, clientAuth.headers, resolved.fetch, cacheRetention === "none" ? undefined : resolved.sessionId, resolved.env);
     let params = buildParams(model, prefix, resolved, compat, grammarToolInputProperties);
     const nextParams = await resolved.onPayload?.(params, model);
@@ -412,13 +422,8 @@ function createClient(model, context, apiKey, optionsHeaders, fetch, sessionId,
         defaultHeaders: headers,
     });
 }
-function buildParams(model, context, options, compat = getCompat(model, options?.env), grammarToolInputProperties = createGrammarToolInputProperties(context.tools, compat.supportsOpenAIGrammarTools)) {
-    const deferredToolsMode = compat.supportsAdditionalTools
-        ? "additional-tools"
-        : compat.supportsToolSearch
-            ? "tool-search"
-            : undefined;
-    const toolPlacement = splitDeferredTools(context, deferredToolsMode !== undefined);
+function buildParams(model, context, options, compat = getCompat(model, options?.env), grammarToolInputProperties = createGrammarToolInputProperties(getDeclaredTools(context.messages), compat.supportsOpenAIGrammarTools)) {
+    const toolPlacement = resolveResponsesToolPlacement(context.messages, resolveResponsesDeferredToolsMode(compat) !== undefined);
     const requestedReasoningEffort = options?.reasoningEffort ?? (options?.reasoningSummary ? "medium" : undefined);
     const thinkingLevelMap = inferOpenAIThinkingLevelMap(model);
     const mappedReasoningEffort = requestedReasoningEffort === undefined ? undefined : thinkingLevelMap?.[requestedReasoningEffort];
@@ -432,8 +437,9 @@ function buildParams(model, context, options, compat = getCompat(model, options?
         // nor a previous prefix unless the system prompt carries an explicit breakpoint.
         systemPromptCacheBreakpoint: compat.supportsExplicitPromptCacheMode && cacheRetention !== "none",
         grammarToolInputProperties,
-        deferredTools: toolPlacement.deferred,
-        deferredToolsMode,
+        supportsMidConvoSystemMessages: compat.supportsMidConvoSystemMessages,
+        supportsAdditionalTools: compat.supportsAdditionalTools,
+        supportsToolSearch: compat.supportsToolSearch,
         toolOptions: {
             supportsStrictMode: compat.supportsStrictMode,
             supportsOpenAIGrammarTools: compat.supportsOpenAIGrammarTools,
@@ -465,8 +471,8 @@ function buildParams(model, context, options, compat = getCompat(model, options?
     if (options?.serviceTier !== undefined) {
         params.service_tier = options.serviceTier;
     }
-    if (toolPlacement.immediate.length > 0) {
-        params.tools = convertResponsesTools(toolPlacement.immediate, {
+    if (toolPlacement.requestTools.length > 0) {
+        params.tools = convertResponsesTools(toolPlacement.requestTools, {
             supportsStrictMode: compat.supportsStrictMode,
             supportsOpenAIGrammarTools: compat.supportsOpenAIGrammarTools,
         });
@@ -491,10 +497,8 @@ function buildParams(model, context, options, compat = getCompat(model, options?
             params.include = ["reasoning.encrypted_content"];
     }
     applyExtraBodyToResponsesParams(params, options?.extraBody);
-    // Last so custom keys override the named request fields.
-    if (options?.samplingParams) {
-        Object.assign(params, options.samplingParams);
-    }
+    // Last so custom keys override the named request fields. Per-request keys override model defaults.
+    Object.assign(params, model.samplingParams, options?.samplingParams);
     return params;
 }
 function applyExtraBodyToResponsesParams(params, extraBody) {
@@ -856,6 +860,10 @@ function buildWebSocketHeaders(model, context, apiKey, optionsHeaders, sessionId
 }
 function getServiceTierCostMultiplier(model, serviceTier) {
     switch (serviceTier) {
+        case "ultrafast":
+            // OpenAI publishes an Ultrafast price for GPT-6 Astra only: 6x Standard on every
+            // token class and context tier. Any other model keeps its base rate.
+            return model.id === "gpt-6-astra" ? 6 : 1;
         case "flex":
             return 0.5;
         case "priority":

package/dist/api/openrouter-images.d.ts

@@ -1,3 +1,4 @@
 import type { ImagesFunction, ImagesOptions } from "../types.ts";
-export declare const generateImages: ImagesFunction<"openrouter-images", ImagesOptions>;
+/** Image generation over OpenRouter's chat completions endpoint. */
+export declare const generateImages: ImagesFunction<ImagesOptions>;
 //# sourceMappingURL=openrouter-images.d.ts.map

package/dist/api/openrouter-images.js

@@ -3,6 +3,7 @@ import { formatProviderError, normalizeProviderError } from "../utils/error-body
 import { headersToRecord, providerHeadersToRecord } from "../utils/headers.js";
 import { retryProviderRequest } from "../utils/provider-retry.js";
 import { sanitizeSurrogates } from "../utils/sanitize-unicode.js";
+/** Image generation over OpenRouter's chat completions endpoint. */
 export const generateImages = async (model, context, options) => {
     const output = {
         api: model.api,

package/dist/api/pi-messages.d.ts

@@ -8,7 +8,7 @@
  * Radius gateway, but any backend implementing it can be used, e.g. via a
  * models.json custom provider with `"api": "pi-messages"`.
  */
-import type { AssistantMessage, SimpleStreamOptions, StreamFunction, StreamOptions, ThinkingLevel, ToolCall } from "../types.ts";
+import type { AssistantMessage, JsonObject, SimpleStreamOptions, StreamFunction, StreamOptions, ThinkingLevel, ToolCall } from "../types.ts";
 export interface PiMessagesOptions extends StreamOptions {
     reasoning?: ThinkingLevel;
     toolChoice?: "auto" | "none" | "required" | {
@@ -90,8 +90,8 @@ export type PiMessagesEvent = {
 };
 export declare class PiMessagesResponseError extends Error {
     code?: string;
-    readonly diagnosticDetails: Record<string, unknown>;
-    constructor(message: string, code: string | undefined, diagnosticDetails: Record<string, unknown>);
+    readonly diagnosticDetails: JsonObject;
+    constructor(message: string, code: string | undefined, diagnosticDetails: JsonObject);
 }
 export declare const stream: StreamFunction<"pi-messages", PiMessagesOptions>;
 export declare const streamSimple: StreamFunction<"pi-messages", SimpleStreamOptions>;

package/dist/api/pi-messages.js

@@ -52,8 +52,8 @@ function createPiMessagesResponseError(model, url, response, body) {
         url: url.toString(),
         status: response.status,
         statusText: response.statusText,
-        error: errorBody?.error,
-        body: errorBody ? undefined : truncateDiagnosticString(body),
+        ...(errorBody?.error === undefined ? {} : { error: errorBody.error }),
+        ...(errorBody ? {} : { body: truncateDiagnosticString(body) }),
         timestampMs: Date.now(),
     });
 }
@@ -301,6 +301,7 @@ export const stream = (model, context, options) => {
                 throw new Error(`${model.provider} response has no body`);
             }
             for await (const piEvent of readPiMessagesEvents(response.body)) {
+                await options?.onProviderStreamEvent?.(piEvent, model);
                 const event = convertEvent(piEvent);
                 eventStream.push(event);
                 if (event.type === "done" || event.type === "error") {

package/dist/api/simple-options.d.ts

@@ -1,4 +1,4 @@
-import type { Api, Context, Model, SimpleStreamOptions, StreamOptions, ThinkingBudgets, ThinkingLevel } from "../types.ts";
+import type { Api, Model, SimpleStreamOptions, StreamOptions, ThinkingBudgets, ThinkingLevel, TranscriptContext } from "../types.ts";
 export { CONTEXT_GUARD_MIN_WINDOW, CONTEXT_SAFETY_TOKENS, ContextWindowExhaustedError, clampMaxTokensToContext, MIN_ANSWER_TOKENS, } from "./context-room.ts";
 /**
  * Merge user-supplied extraBody fields into a provider request payload, skipping
@@ -17,7 +17,7 @@ export declare const GOOGLE_RESERVED_BODY_KEYS: ReadonlySet<string>;
 export declare const ANTHROPIC_RESERVED_BODY_KEYS: ReadonlySet<string>;
 export declare const MISTRAL_RESERVED_BODY_KEYS: ReadonlySet<string>;
 export declare const BEDROCK_RESERVED_BODY_KEYS: ReadonlySet<string>;
-export declare function buildBaseOptions(model: Model<Api>, context: Context, options?: SimpleStreamOptions, apiKey?: string): StreamOptions;
+export declare function buildBaseOptions(model: Model<Api>, context: TranscriptContext, options?: SimpleStreamOptions, apiKey?: string): StreamOptions;
 export declare const DEFAULT_THINKING_BUDGETS: ThinkingBudgets;
 export declare function clampReasoning(effort: ThinkingLevel | undefined): Exclude<ThinkingLevel, "xhigh" | "max"> | undefined;
 /**

package/dist/api/simple-options.js

@@ -122,6 +122,7 @@ export function buildBaseOptions(model, context, options, apiKey) {
         extraBody: options?.extraBody,
         onPayload: options?.onPayload,
         onResponse: options?.onResponse,
+        onProviderStreamEvent: options?.onProviderStreamEvent,
         timeoutMs: options?.timeoutMs,
         websocketConnectTimeoutMs: options?.websocketConnectTimeoutMs,
         maxRetries: options?.maxRetries,

package/dist/api/system-one-shared.d.ts

@@ -0,0 +1,23 @@
+import type { ClassifierApi, ClassifierContext, ClassifierModel, ClassifierOptions, ClassifierResult } from "../types.ts";
+/** TypeSafe System One request body without the transport-specific envelope. */
+export interface SystemOneWireRequest {
+    state: ClassifierContext["state"];
+    questions: Record<string, unknown>;
+}
+/** Differences between services that serve System One models. */
+export interface SystemOneTransport {
+    /** Classifier API implemented by this transport. */
+    api: ClassifierApi;
+    /** Service name used in error messages. */
+    label: string;
+    /** Absolute request URL. */
+    url(model: ClassifierModel<ClassifierApi>): URL;
+    /** Wraps the System One request in the service's request envelope. */
+    payload(model: ClassifierModel<ClassifierApi>, request: SystemOneWireRequest): unknown;
+    /** Extracts the System One output (`{ answers, usage }`) from the service's response envelope. */
+    output(body: unknown): Record<string, unknown>;
+}
+export declare function isRecord(value: unknown): value is Record<string, unknown>;
+/** Runs one System One classification over the given transport. */
+export declare function classifySystemOne(transport: SystemOneTransport, model: ClassifierModel<ClassifierApi>, context: ClassifierContext, options: ClassifierOptions | undefined): Promise<ClassifierResult>;
+//# sourceMappingURL=system-one-shared.d.ts.map

package/dist/api/system-one-shared.js

@@ -0,0 +1,183 @@
+import { calculateCost } from "../models.js";
+import { formatProviderError, normalizeProviderError } from "../utils/error-body.js";
+import { headersToRecord, providerHeadersToRecord } from "../utils/headers.js";
+import { retryProviderRequest } from "../utils/provider-retry.js";
+function httpError(label, response, body) {
+    const error = new Error(`${label} returned ${response.status}`);
+    error.status = response.status;
+    error.headers = response.headers;
+    error.body = body;
+    return error;
+}
+function timeoutError(timeoutMs) {
+    const error = new Error(`Request timed out after ${timeoutMs}ms`);
+    error.name = "TimeoutError";
+    error.status = undefined;
+    error.headers = undefined;
+    error.body = "";
+    return error;
+}
+export function isRecord(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function requiredNumber(label, value, field) {
+    if (typeof value !== "number" || !Number.isFinite(value)) {
+        throw new Error(`${label} returned an invalid ${field}`);
+    }
+    return value;
+}
+function probabilities(label, value, id) {
+    if (!isRecord(value))
+        throw new Error(`${label} returned invalid probabilities for ${id}`);
+    return Object.fromEntries(Object.entries(value).map(([key, probability]) => [
+        key,
+        requiredNumber(label, probability, `probability for ${id}.${key}`),
+    ]));
+}
+function parseAnswers(label, value, context) {
+    if (!isRecord(value))
+        throw new Error(`${label} returned an unexpected response`);
+    const answers = [];
+    for (const [id, question] of Object.entries(context.questions)) {
+        const answer = value[id];
+        if (!isRecord(answer))
+            throw new Error(`${label} did not return an answer for ${id}`);
+        if (question.type === "choice") {
+            if (answer.type !== "choice" || typeof answer.choice !== "string") {
+                throw new Error(`${label} did not return a choice answer for ${id}`);
+            }
+            answers.push([
+                id,
+                {
+                    type: "choice",
+                    choice: answer.choice,
+                    probabilities: probabilities(label, answer.probabilities, id),
+                    confidence: requiredNumber(label, answer.confidence, `confidence for ${id}`),
+                },
+            ]);
+        }
+        else if (question.type === "score") {
+            if (answer.type !== "score")
+                throw new Error(`${label} did not return a score answer for ${id}`);
+            answers.push([
+                id,
+                {
+                    type: "score",
+                    score: requiredNumber(label, answer.score, `score for ${id}`),
+                    confidence: requiredNumber(label, answer.confidence, `confidence for ${id}`),
+                },
+            ]);
+        }
+        else {
+            if (answer.type !== "noul")
+                throw new Error(`${label} did not return a bool answer for ${id}`);
+            answers.push([
+                id,
+                {
+                    type: "bool",
+                    probability: requiredNumber(label, answer.noul, `probability for ${id}`),
+                },
+            ]);
+        }
+    }
+    return Object.fromEntries(answers);
+}
+function tokenCount(value) {
+    return typeof value === "number" && Number.isFinite(value) && value > 0 ? value : 0;
+}
+/**
+ * Usage from System One's `{ input_tokens, output_tokens }`, priced from the model catalog like chat
+ * usage. A missing or malformed usage object leaves the result without usage instead of failing it.
+ */
+function parseUsage(value, model) {
+    if (!isRecord(value) || (value.input_tokens === undefined && value.output_tokens === undefined))
+        return undefined;
+    const input = tokenCount(value.input_tokens);
+    const output = tokenCount(value.output_tokens);
+    const usage = {
+        input,
+        output,
+        cacheRead: 0,
+        cacheWrite: 0,
+        totalTokens: input + output,
+        cost: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0, total: 0 },
+    };
+    calculateCost(model, usage);
+    return usage;
+}
+/** Maps public `bool` questions to TypeSafe's wire-level `noul` type. */
+function wireRequest(context) {
+    return {
+        state: context.state,
+        questions: Object.fromEntries(Object.entries(context.questions).map(([id, question]) => [
+            id,
+            question.type === "bool" ? { ...question, type: "noul" } : question,
+        ])),
+    };
+}
+function requestHeaders(model, apiKey, optionsHeaders) {
+    return (providerHeadersToRecord({ authorization: `Bearer ${apiKey}`, "content-type": "application/json" }, model.headers, optionsHeaders) ?? {});
+}
+/** Runs one System One classification over the given transport. */
+export async function classifySystemOne(transport, model, context, options) {
+    const output = {
+        api: model.api,
+        provider: model.provider,
+        model: model.id,
+        answers: {},
+        stopReason: "stop",
+        timestamp: Date.now(),
+    };
+    try {
+        if (model.api !== transport.api)
+            throw new Error(`Unsupported classifier API: ${model.api}`);
+        if (!options?.apiKey)
+            throw new Error(`No API key for provider: ${model.provider}`);
+        const apiKey = options.apiKey;
+        let payload = transport.payload(model, wireRequest(context));
+        const transformed = await options.onPayload?.(payload, model);
+        if (transformed !== undefined)
+            payload = transformed;
+        const requestFetch = options.fetch ?? globalThis.fetch;
+        const { response, body } = await retryProviderRequest(async () => {
+            const timeoutSignal = options.timeoutMs !== undefined ? AbortSignal.timeout(options.timeoutMs) : undefined;
+            const signal = options.signal && timeoutSignal
+                ? AbortSignal.any([options.signal, timeoutSignal])
+                : (options.signal ?? timeoutSignal);
+            try {
+                const next = await requestFetch(transport.url(model), {
+                    method: "POST",
+                    headers: requestHeaders(model, apiKey, options.headers),
+                    body: JSON.stringify(payload),
+                    signal,
+                });
+                if (!next.ok)
+                    throw httpError(transport.label, next, await next.text());
+                return { response: next, body: (await next.json()) };
+            }
+            catch (error) {
+                if (timeoutSignal?.aborted && !options.signal?.aborted)
+                    throw timeoutError(options.timeoutMs);
+                throw error;
+            }
+        }, {
+            maxRetries: options.maxRetries ?? 2,
+            maxRetryDelayMs: options.maxRetryDelayMs,
+            signal: options.signal,
+        });
+        await options.onResponse?.({ status: response.status, headers: headersToRecord(response.headers) }, model);
+        const result = transport.output(body);
+        // Set before parsing answers: a request with malformed answers was still billed.
+        const usage = parseUsage(result.usage, model);
+        if (usage)
+            output.usage = usage;
+        output.answers = parseAnswers(transport.label, result.answers, context);
+        return output;
+    }
+    catch (error) {
+        output.stopReason = options?.signal?.aborted ? "aborted" : "error";
+        output.errorMessage = formatProviderError(normalizeProviderError(error), `${transport.label} error`);
+        return output;
+    }
+}
+//# sourceMappingURL=system-one-shared.js.map

package/dist/api/transform-messages.js

@@ -88,8 +88,8 @@ export function transformMessages(messages, model, normalizeToolCallId, options
     const normalizeSameModelToolCallIds = options.normalizeSameModelToolCallIds ?? false;
     // First pass: transform messages (unsupported image downgrade, thinking blocks, tool call ID normalization)
     const transformed = imageAwareMessages.map((msg) => {
-        // User messages pass through unchanged
-        if (msg.role === "user") {
+        // System and user messages pass through unchanged
+        if (msg.role === "system" || msg.role === "user") {
             return msg;
         }
         // Handle toolResult messages - normalize toolCallId if we have a mapping
@@ -168,6 +168,9 @@ export function transformMessages(messages, model, normalizeToolCallId, options
     // result after its declaring assistant. Results are emitted adjacent to their
     // calls because Anthropic requires that ordering. A reused ID starts a new
     // pairing window, so a later result cannot repair an earlier call.
+    // System messages are transparent to this accounting: they keep their source
+    // position, and because matched results are pulled forward, one that lands
+    // between a call and its result is emitted after that result.
     const result = [];
     const toolResultsById = new Map();
     const nextToolCallIndexById = new Map();

package/dist/api/typesafe-system-one.d.ts

@@ -0,0 +1,4 @@
+import type { ClassifierFunction, ClassifierOptions } from "../types.ts";
+/** TypeSafe System One classification with public `bool` values mapped to wire-level `noul`. */
+export declare const classify: ClassifierFunction<ClassifierOptions>;
+//# sourceMappingURL=typesafe-system-one.d.ts.map

package/dist/api/typesafe-system-one.js

@@ -0,0 +1,19 @@
+import { classifySystemOne, isRecord } from "./system-one-shared.js";
+/**
+ * TypeSafe's native System One protocol. OpenRouter serves the same protocol,
+ * so both providers use this API with different base URLs.
+ */
+const transport = {
+    api: "typesafe-system-one",
+    label: "System One API",
+    url: (model) => new URL("systemone", `${model.baseUrl.replace(/\/+$/u, "")}/`),
+    payload: (model, request) => ({ model: model.id, ...request }),
+    output: (body) => {
+        if (!isRecord(body))
+            throw new Error("System One API returned an unexpected response");
+        return body;
+    },
+};
+/** TypeSafe System One classification with public `bool` values mapped to wire-level `noul`. */
+export const classify = (model, context, options) => classifySystemOne(transport, model, context, options);
+//# sourceMappingURL=typesafe-system-one.js.map

package/dist/api/typesafe-system-one.lazy.d.ts

@@ -0,0 +1,3 @@
+import type { ProviderClassifier } from "../types.ts";
+export declare const typesafeSystemOneApi: () => ProviderClassifier;
+//# sourceMappingURL=typesafe-system-one.lazy.d.ts.map

package/dist/api/typesafe-system-one.lazy.js

@@ -0,0 +1,4 @@
+export const typesafeSystemOneApi = () => ({
+    classify: async (model, context, options) => (await import("./typesafe-system-one.js")).classify(model, context, options),
+});
+//# sourceMappingURL=typesafe-system-one.lazy.js.map

package/dist/api-registry.d.ts

@@ -1,6 +1,6 @@
-import type { Api, AssistantMessageEventStream, Context, Model, SimpleStreamOptions, StreamFunction, StreamOptions } from "./types.ts";
-export type ApiStreamFunction = (model: Model<Api>, context: Context, options?: StreamOptions) => AssistantMessageEventStream;
-export type ApiStreamSimpleFunction = (model: Model<Api>, context: Context, options?: SimpleStreamOptions) => AssistantMessageEventStream;
+import type { Api, AssistantMessageEventStream, Model, SimpleStreamOptions, StreamFunction, StreamOptions, TranscriptContext } from "./types.ts";
+export type ApiStreamFunction = (model: Model<Api>, context: TranscriptContext, options?: StreamOptions) => AssistantMessageEventStream;
+export type ApiStreamSimpleFunction = (model: Model<Api>, context: TranscriptContext, options?: SimpleStreamOptions) => AssistantMessageEventStream;
 export interface ApiProvider<TApi extends Api = Api, TOptions extends StreamOptions = StreamOptions> {
     api: TApi;
     stream: StreamFunction<TApi, TOptions>;

package/dist/auth/helpers.js

@@ -46,7 +46,7 @@ export function lazyOAuth(input) {
         isSubscription: input.isSubscription,
         loginLabel: input.loginLabel,
         ...(input.rejectedTokenStatuses === undefined ? {} : { rejectedTokenStatuses: input.rejectedTokenStatuses }),
-        login: async (interaction) => (await loaded()).login(interaction),
+        login: async (interaction, options) => (await loaded()).login(interaction, options),
         refresh: async (credential, signal) => (await loaded()).refresh(credential, signal),
         toAuth: async (credential) => (await loaded()).toAuth(credential),
     };

package/dist/auth/oauth/anthropic-callback-listener.js

@@ -10,8 +10,8 @@
  *
  * NOTE: Node-only (http.createServer); reached through the lazy OAuth loader.
  */
+import { oauthErrorHtml, oauthSuccessHtml } from "../../utils/oauth-page.js";
 import { formatErrorDetails } from "./error-details.js";
-import { oauthErrorHtml, oauthSuccessHtml } from "./oauth-page.js";
 export const PREFERRED_CALLBACK_PORT = 53692;
 export const CALLBACK_PATH = "/callback";
 const BIND_FAILURE_CODES = new Set(["EACCES", "EADDRINUSE", "EPERM"]);