@code-yeongyu/senpi-ai 2026.9.30 → 2026.10.1

package/dist/utils/model-operations.js

@@ -0,0 +1,47 @@
+import { ModelsError } from "./models-error.js";
+/** The type of a model. Models without `type` are chat models. */
+export function getModelType(model) {
+    return model.type ?? "chat";
+}
+/** Runtime-checked model type narrowing, including legacy chat models without `type`. */
+export function isModelType(model, type) {
+    return getModelType(model) === type;
+}
+export function assertChatModel(model) {
+    if (!isModelType(model, "chat")) {
+        throw new ModelsError("provider", `Model ${model.provider}/${model.id} is not a chat model`);
+    }
+}
+export function assertImageModel(model) {
+    if (!isModelType(model, "image")) {
+        throw new ModelsError("provider", `Model ${model.provider}/${model.id} is not an image model`);
+    }
+}
+export function assertClassifierModel(model) {
+    if (!isModelType(model, "classifier")) {
+        throw new ModelsError("provider", `Model ${model.provider}/${model.id} is not a classifier model`);
+    }
+}
+export function imageErrorResult(model, error, aborted = false) {
+    return {
+        api: model.api,
+        provider: model.provider,
+        model: model.id,
+        output: [],
+        stopReason: aborted ? "aborted" : "error",
+        errorMessage: error instanceof Error ? error.message : String(error),
+        timestamp: Date.now(),
+    };
+}
+export function classifierErrorResult(model, error, aborted = false) {
+    return {
+        api: model.api,
+        provider: model.provider,
+        model: model.id,
+        answers: {},
+        stopReason: aborted ? "aborted" : "error",
+        errorMessage: error instanceof Error ? error.message : String(error),
+        timestamp: Date.now(),
+    };
+}
+//# sourceMappingURL=model-operations.js.map

package/dist/utils/models-error.d.ts

@@ -0,0 +1,8 @@
+export type ModelsErrorCode = "model_source" | "model_validation" | "provider" | "stream" | "auth" | "oauth";
+export declare class ModelsError extends Error {
+    readonly code: ModelsErrorCode;
+    constructor(code: ModelsErrorCode, message: string, options?: {
+        cause?: unknown;
+    });
+}
+//# sourceMappingURL=models-error.d.ts.map

package/dist/utils/models-error.js

@@ -0,0 +1,18 @@
+import { formatThrownValue } from "./diagnostics.js";
+export class ModelsError extends Error {
+    constructor(code, message, options) {
+        super(withCauseDetail(message, options?.cause), options);
+        this.name = "ModelsError";
+        this.code = code;
+    }
+}
+/** Callers surface `error.message` only, so keep the underlying reason in it. */
+function withCauseDetail(message, cause) {
+    if (cause === undefined || cause === null)
+        return message;
+    const detail = formatThrownValue(cause).trim();
+    if (!detail || message.includes(detail))
+        return message;
+    return `${message}: ${detail}`;
+}
+//# sourceMappingURL=models-error.js.map

package/dist/utils/overflow.d.ts

@@ -28,6 +28,7 @@ import type { AssistantMessage } from "../types.ts";
  * - Kimi For Coding: "exceeded model token limit: X (requested: Y)"
  * - DS4: "Prompt has X tokens, but the configured context size is Y tokens"
  * - DashScope/Qwen: "Range of input length should be [1, X]"
+ * - z.ai: "Prompt too long"
  *
  * **Unreliable detection:**
  * - z.ai: Sometimes accepts overflow silently (detectable via usage.input > contextWindow),

package/dist/utils/overflow.js

@@ -29,7 +29,7 @@
  * - kiro-lb gateways: "Request payload is 1095225 bytes, over the 1085435 byte limit Kiro accepts." / "Request payload is N tokens, over the M token limit Kiro accepts." (HTTP 400 local payload guard)
  * - Kiro upstream via kiro-lb: "Model context limit reached. Conversation size exceeds model capacity." (CONTENT_LENGTH_EXCEEDS_THRESHOLD token overflow)
  * - Mistral: "Prompt contains X tokens ... too large for model with Y maximum context length"
- * - z.ai: Does NOT error, accepts overflow silently - handled via usage.input > contextWindow
+ * - z.ai: `{"code":"1261","message":"Prompt too long"}` or silent overflow via usage.input > contextWindow
  * - Xiaomi MiMo: Truncates input to fill contextWindow exactly, then returns finish_reason "length"
  *   with output=0 (no room left to generate). Detected via stopReason "length" + zero output +
  *   input filling the context window.
@@ -41,7 +41,7 @@
 const OVERFLOW_PATTERNS = [
     /^Context window exhausted: /, // pi-ai pre-flight guard: no answer room left, provider never called
     /^The conversation is too long to resend \(about \d+ tokens, limit \d+\)/, // anthropic-subscription cold-seed budget: re-send refused before dispatch
-    /prompt is too long/i, // Anthropic token overflow
+    /prompt (?:is )?too long/i, // Anthropic and z.ai token overflow
     /request_too_large/i, // Anthropic request byte-size overflow (HTTP 413)
     /input is too long for requested model/i, // Amazon Bedrock
     /exceeds (?:(?:the|this) )?(?:model'?s )?context window/i, // OpenAI (Completions & Responses API)
@@ -65,11 +65,11 @@ const OVERFLOW_PATTERNS = [
     /context[_ ]length[_ ]exceeded/i, // Generic fallback
     /too many tokens/i, // Generic fallback
     /token limit exceeded/i, // Generic fallback
-    /^4(?:00|13)\s*(?:status code)?\s*\(no body\)/i, // Cerebras: 400/413 with no body
     /(?:request[ _])?(?:body|entity|payload)[_ ]too[_ ]large/i, // Gateway HTTP 413 byte-size rejections ("Request body too large", "Request Entity Too Large", "body_too_large", "Payload Too Large"). Substring-anchored by design (JSON bodies lack an adjacent status code); a non-context size rejection (e.g. an oversized image) can over-match, which costs one bounded shrink-retry, never a wedge.
     /Request payload is \d+ (?:bytes, over the \d+ byte|tokens, over the \d+ token) limit Kiro accepts\./, // kiro-lb local byte/token payload guard (HTTP 400; Anthropic uses invalid_request_error, OpenAI uses detail).
     /Model context limit reached\. Conversation size exceeds model capacity\./, // kiro-lb enhancement of Kiro CONTENT_LENGTH_EXCEEDS_THRESHOLD
 ];
+const CEREBRAS_BODYLESS_OVERFLOW_PATTERN = /^4(?:00|13)\s*(?:status code)?\s*\(no body\)/i;
 /**
  * Patterns that indicate non-overflow errors (e.g. rate limiting, server errors).
  * Error messages matching any of these are excluded from overflow detection
@@ -133,6 +133,7 @@ const RESOURCE_EXHAUSTED_PATTERN = /resource.?exhausted/i;
  * - Kimi For Coding: "exceeded model token limit: X (requested: Y)"
  * - DS4: "Prompt has X tokens, but the configured context size is Y tokens"
  * - DashScope/Qwen: "Range of input length should be [1, X]"
+ * - z.ai: "Prompt too long"
  *
  * **Unreliable detection:**
  * - z.ai: Sometimes accepts overflow silently (detectable via usage.input > contextWindow),
@@ -163,8 +164,13 @@ export function isContextOverflow(message, contextWindow) {
     if (message.stopReason === "error" && message.errorMessage) {
         // Skip messages matching known non-overflow patterns (e.g. throttling / rate-limit)
         const isNonOverflow = NON_OVERFLOW_PATTERNS.some((p) => p.test(message.errorMessage));
-        if (!isNonOverflow && OVERFLOW_PATTERNS.some((p) => p.test(message.errorMessage))) {
-            return true;
+        if (!isNonOverflow) {
+            if (OVERFLOW_PATTERNS.some((p) => p.test(message.errorMessage))) {
+                return true;
+            }
+            if (message.provider === "cerebras" && CEREBRAS_BODYLESS_OVERFLOW_PATTERN.test(message.errorMessage)) {
+                return true;
+            }
         }
         const usage = message.usage;
         const hasTokenEvidence = (usage.totalTokens || usage.input + usage.output + usage.cacheRead + usage.cacheWrite) > 0;

package/dist/utils/prompt-cache-ttl.js

@@ -70,6 +70,8 @@ export function getAnthropicCompat(model) {
         unsignedThinkingReplay: model.compat?.unsignedThinkingReplay ?? (model.compat?.allowEmptySignature ? "empty-signature" : "text"),
         allowedFallbackModels: model.compat?.allowedFallbackModels ?? [],
         supportsStrictTools: model.compat?.supportsStrictTools ?? false,
+        supportsMidConvoSystemMessages: model.compat?.supportsMidConvoSystemMessages ?? false,
+        supportsMidConvoToolChanges: model.compat?.supportsMidConvoToolChanges ?? false,
         supportsToolReferences: model.compat?.supportsToolReferences ?? defaultSupportsToolReferences(model),
         // Default: first-party Anthropic only. Anthropic-compatible providers
         // (kimi-coding, fireworks, copilot, gateways) may execute the server-side
@@ -98,10 +100,10 @@ function detectOpenAICompletionsCompat(model) {
     const isCloudflareAiGateway = provider === "cloudflare-ai-gateway" || baseUrl.includes("gateway.ai.cloudflare.com");
     const isNvidia = provider === "nvidia" || baseUrl.includes("integrate.api.nvidia.com");
     const isAntLing = provider === "ant-ling" || baseUrl.includes("api.ant-ling.com");
+    const isCerebras = provider === "cerebras" || baseUrl.includes("cerebras.ai");
     const isDeepSeek = provider === "deepseek" || baseUrl.toLowerCase().includes("deepseek.com");
     const isNonStandard = isNvidia ||
-        provider === "cerebras" ||
-        baseUrl.includes("cerebras.ai") ||
+        isCerebras ||
         provider === "xai" ||
         baseUrl.includes("api.x.ai") ||
         isTogether ||
@@ -154,11 +156,14 @@ function detectOpenAICompletionsCompat(model) {
         vercelGatewayRouting: {},
         chatTemplateKwargs: {},
         zaiToolStream: false,
-        supportsStrictMode: !isMoonshot && !isTogether && !isCloudflareAiGateway && !isNvidia,
+        // OpenAI compatibility alone does not imply strict JSON-schema tool support.
+        supportsStrictMode: false,
         toolSchemaFlavor: isMoonshot ? "moonshot-mfjs" : undefined,
         supportsDisabledThinking: true,
         toolCallFormat: undefined,
         supportsOpenAIGrammarTools: false,
+        supportsMidConvoSystemMessages: false,
+        supportsMidConvoToolAdditions: false,
         cacheControlFormat,
         sendSessionAffinityHeaders: isOpenRouter,
         deferredToolsMode: undefined,
@@ -205,6 +210,8 @@ export function getOpenAICompletionsCompat(model) {
         toolSchemaFlavor: model.compat.toolSchemaFlavor ?? detected.toolSchemaFlavor,
         toolCallFormat: model.compat.toolCallFormat ?? detected.toolCallFormat,
         supportsOpenAIGrammarTools: model.compat.supportsOpenAIGrammarTools ?? detected.supportsOpenAIGrammarTools,
+        supportsMidConvoSystemMessages: model.compat.supportsMidConvoSystemMessages ?? detected.supportsMidConvoSystemMessages,
+        supportsMidConvoToolAdditions: model.compat.supportsMidConvoToolAdditions ?? detected.supportsMidConvoToolAdditions,
         cacheControlFormat: model.compat.cacheControlFormat ?? detected.cacheControlFormat,
         sendSessionAffinityHeaders: model.compat.sendSessionAffinityHeaders ?? detected.sendSessionAffinityHeaders,
         deferredToolsMode: model.compat.deferredToolsMode ?? detected.deferredToolsMode,

package/dist/utils/retry.js

@@ -84,6 +84,9 @@ const NON_RETRYABLE_PROVIDER_ERROR_PATTERN = buildProviderErrorPattern([
     "tools\\.[^ ]*function\\.parameters",
     "tools\\.\\d+\\.function\\.parameters",
     "invalid tool schema",
+    // Sign in with ChatGPT: the subscription's shared usage limit, which resets
+    // after hours rather than seconds.
+    "subscription_sharing_usage_limit_exceeded",
 ]);
 const RETRYABLE_PROVIDER_ERROR_PATTERN = buildProviderErrorPattern([
     // Local credential/auth sidecar lock exhaustion is infrastructure contention,
@@ -91,6 +94,7 @@ const RETRYABLE_PROVIDER_ERROR_PATTERN = buildProviderErrorPattern([
     "Credential store is busy: lock",
     // Generic provider load, HTTP status, and server-side transient failures.
     "overloaded",
+    "currently experiencing high demand",
     "rate.?limit",
     "too many requests",
     "429",
@@ -98,6 +102,7 @@ const RETRYABLE_PROVIDER_ERROR_PATTERN = buildProviderErrorPattern([
     "502",
     "503",
     "504",
+    "520",
     // Cloudflare 522 (Connection timed out): origin stopped responding; transient
     // like the other 5xx gateway statuses, surfaced as "Error: error code: 522".
     "522",
@@ -192,6 +197,10 @@ const RETRYABLE_PROVIDER_ERROR_PATTERN = buildProviderErrorPattern([
     // hits proper-lockfile while the previous subprocess still holds the file.
     // Same-process retry recovers; hopping providers cannot release that lock.
     "Lock file is already being held",
+    // Sign in with ChatGPT: usage or user data temporarily unavailable. Usage
+    // failures can arrive mid-stream without an HTTP 503 in the message.
+    "subscription_sharing_usage_unavailable",
+    "subscription_sharing_user_unavailable",
 ]);
 export const DEFAULT_MAX_AGENT_RETRY_DELAY_MS = 60_000;
 /**

package/dist/utils/text.d.ts

@@ -1,6 +1,14 @@
-import type { ImageContent, ProviderNativeContent, TextContent, ThinkingContent, ToolCall } from "../types.ts";
+import type { ImageContent, ProviderNativeContent, SystemMessage, TextContent, ThinkingContent, ToolCall } from "../types.ts";
 type Content = TextContent | ImageContent | ThinkingContent | ToolCall | ProviderNativeContent;
 /** Extract and join text from message content. */
 export declare function contentText(content: string | readonly Content[], separator?: string): string;
+/** Render a system message as a complete prompt: its content followed by its sections. */
+export declare function getSystemMessageText(message: SystemMessage): string;
+/**
+ * Render a later system message for APIs that accept system messages mid-conversation.
+ * Section changes are framed by name so the model can relate them to the leading prompt.
+ * This framing is request-time only and may change between versions.
+ */
+export declare function renderSystemMessageUpdate(message: SystemMessage): string;
 export {};
 //# sourceMappingURL=text.d.ts.map

package/dist/utils/text.js

@@ -7,4 +7,30 @@ export function contentText(content, separator = "\n") {
         .map((block) => block.text)
         .join(separator);
 }
+/** Render a system message as a complete prompt: its content followed by its sections. */
+export function getSystemMessageText(message) {
+    const parts = [contentText(message.content)];
+    for (const text of Object.values(message.sections ?? {})) {
+        if (text !== null)
+            parts.push(text);
+    }
+    return parts.filter((part) => part.length > 0).join("\n\n");
+}
+/**
+ * Render a later system message for APIs that accept system messages mid-conversation.
+ * Section changes are framed by name so the model can relate them to the leading prompt.
+ * This framing is request-time only and may change between versions.
+ */
+export function renderSystemMessageUpdate(message) {
+    const parts = [];
+    const text = contentText(message.content);
+    if (text.length > 0)
+        parts.push(text);
+    for (const [name, value] of Object.entries(message.sections ?? {})) {
+        parts.push(value === null
+            ? `Removed system prompt section "${name}".`
+            : `Updated system prompt section "${name}":\n\n${value}`);
+    }
+    return parts.join("\n\n");
+}
 //# sourceMappingURL=text.js.map

package/dist/utils/transcript.d.ts

@@ -0,0 +1,85 @@
+import type { Context, Message, SystemMessage, Tool, ToolReference, TranscriptContext } from "../types.ts";
+export type { TranscriptContext } from "../types.ts";
+/**
+ * Build the leading system message for a prompt and tool set. Returns undefined when
+ * both are empty, so an empty transcript stays empty.
+ */
+export declare function createInitialSystemMessage(systemPrompt: string | undefined, tools: Tool[] | undefined): SystemMessage | undefined;
+/**
+ * Fold `Context.systemPrompt` and `Context.tools` into a leading system message.
+ * This is the only entry point that produces a {@link TranscriptContext}; every
+ * provider-facing function expects the result. `Context.activeToolNames` is carried
+ * over unchanged (senpi#2095 allowed-tools): it has no system-message representation.
+ */
+export declare function normalizeContext(context: Context): TranscriptContext;
+/**
+ * Any message list. The replay helpers only read entries whose role is `"system"`, so
+ * agent transcripts that carry custom message roles can be passed without filtering.
+ */
+export type TranscriptMessages = readonly {
+    role: string;
+}[];
+/** Return the leading system message, if the transcript starts with one. */
+export declare function getInitialSystemMessage(messages: TranscriptMessages): SystemMessage | undefined;
+/** Drop the leading system message for APIs that carry the prompt outside the message list. */
+export declare function withoutInitialSystemMessage(messages: Message[]): Message[];
+/** Resolve the tools available after applying every transcript delta in order. */
+export declare function getCurrentTools(messages: TranscriptMessages): Tool[];
+/**
+ * Replay every system message into one leading system message holding the current
+ * prompt and tools. Later `content` is appended to the base prompt, `sections` are
+ * patched by name, and tools are resolved with {@link getCurrentTools}.
+ */
+export declare function getCurrentSystemMessage(messages: TranscriptMessages): SystemMessage | undefined;
+/** Render the current system prompt text after replaying every system message. */
+export declare function getCurrentSystemPrompt(messages: TranscriptMessages): string;
+/**
+ * Rebuild the transcript for APIs without mid-conversation system messages: the replayed
+ * system message leads, and every later system message is dropped.
+ */
+export declare function collapseSystemMessages(context: TranscriptContext): TranscriptContext;
+/** Keep later system messages in place when the model accepts them; otherwise collapse them. */
+export declare function resolveTranscript(context: TranscriptContext, supportsMidConvoSystemMessages: boolean | undefined): TranscriptContext;
+/** Strip executable and display-only fields from a tool before transcript comparison or persistence. */
+export declare function toToolDeclaration(tool: Tool): Tool;
+/**
+ * Whether two tools declare the same interface to the model.
+ *
+ * Both sides go through {@link toToolDeclaration} first: its JSON round-trip drops the
+ * typebox symbol keys and `undefined` fields that a structural comparison would see, and
+ * builds both objects with the same key order, so comparing the serialized declarations
+ * is exact. This avoids a deep-equal dependency in a browser-safe package.
+ */
+export declare function declarationsEqual(left: Tool, right: Tool): boolean;
+export interface ToolStateChanges {
+    toolsAdded: Tool[];
+    toolsRemoved: ToolReference[];
+}
+/** Compare two complete tool states. A changed definition is a removal followed by an addition. */
+export declare function getToolStateChanges(previous: readonly Tool[], current: readonly Tool[]): ToolStateChanges;
+/** Every definition referenced by transcript tool state, in first-declaration order. */
+export declare function getDeclaredTools(messages: TranscriptMessages): Tool[];
+/**
+ * Whether a tool name was declared twice with different definitions. Transports that
+ * reference tools by name (Anthropic `tool_addition`/`tool_removal`) cannot express that.
+ */
+export declare function hasToolRedefinitions(messages: TranscriptMessages): boolean;
+/** Whether tool history contains a removal or same-name redeclaration that an addition-only transport cannot replay. */
+export declare function hasNonAdditiveToolChanges(messages: TranscriptMessages): boolean;
+export interface TranscriptTools {
+    /** Tools sent in the top-level request field. */
+    requestTools: Tool[];
+    /**
+     * Whether later system messages carry their own `toolsAdded` as in-place additions.
+     * When false, `requestTools` already holds the complete current tool set.
+     */
+    anchorsAdditions: boolean;
+}
+/**
+ * Split tool declarations between the top-level request field and in-place additions.
+ * Transports that can anchor additions at a system message keep the initial tools at the
+ * top and load later ones where they appear; that only works when no tool was removed or
+ * redeclared, so everything else sends the current tool list.
+ */
+export declare function resolveTranscriptTools(messages: TranscriptMessages, supportsToolAdditions: boolean): TranscriptTools;
+//# sourceMappingURL=transcript.d.ts.map

package/dist/utils/transcript.js

@@ -0,0 +1,205 @@
+import { contentText, getSystemMessageText } from "./text.js";
+/**
+ * Build the leading system message for a prompt and tool set. Returns undefined when
+ * both are empty, so an empty transcript stays empty.
+ */
+export function createInitialSystemMessage(systemPrompt, tools) {
+    const hasSystemPrompt = systemPrompt !== undefined && systemPrompt.length > 0;
+    const hasTools = tools !== undefined && tools.length > 0;
+    if (!hasSystemPrompt && !hasTools)
+        return undefined;
+    return {
+        role: "system",
+        content: systemPrompt ?? "",
+        ...(hasTools ? { toolsAdded: tools } : {}),
+        timestamp: 0,
+    };
+}
+/**
+ * Fold `Context.systemPrompt` and `Context.tools` into a leading system message.
+ * This is the only entry point that produces a {@link TranscriptContext}; every
+ * provider-facing function expects the result. `Context.activeToolNames` is carried
+ * over unchanged (senpi#2095 allowed-tools): it has no system-message representation.
+ */
+export function normalizeContext(context) {
+    const initialMessage = createInitialSystemMessage(context.systemPrompt, context.tools);
+    const messages = initialMessage ? [initialMessage, ...context.messages] : context.messages;
+    return (context.activeToolNames ? { messages, activeToolNames: context.activeToolNames } : { messages });
+}
+function isSystemMessage(message) {
+    return message.role === "system";
+}
+/** Return the leading system message, if the transcript starts with one. */
+export function getInitialSystemMessage(messages) {
+    const first = messages[0];
+    return first && isSystemMessage(first) ? first : undefined;
+}
+/** Drop the leading system message for APIs that carry the prompt outside the message list. */
+export function withoutInitialSystemMessage(messages) {
+    return getInitialSystemMessage(messages) ? messages.slice(1) : messages;
+}
+/** Resolve the tools available after applying every transcript delta in order. */
+export function getCurrentTools(messages) {
+    const tools = new Map();
+    for (const message of messages) {
+        if (!isSystemMessage(message))
+            continue;
+        for (const tool of message.toolsRemoved ?? [])
+            tools.delete(tool.name);
+        for (const tool of message.toolsAdded ?? [])
+            tools.set(tool.name, tool);
+    }
+    return [...tools.values()];
+}
+/**
+ * Replay every system message into one leading system message holding the current
+ * prompt and tools. Later `content` is appended to the base prompt, `sections` are
+ * patched by name, and tools are resolved with {@link getCurrentTools}.
+ */
+export function getCurrentSystemMessage(messages) {
+    const content = [];
+    const sections = new Map();
+    let timestamp;
+    for (const message of messages) {
+        if (!isSystemMessage(message))
+            continue;
+        timestamp ??= message.timestamp;
+        const text = contentText(message.content);
+        if (text.length > 0)
+            content.push(text);
+        for (const [name, value] of Object.entries(message.sections ?? {})) {
+            if (value === null)
+                sections.delete(name);
+            else
+                sections.set(name, value);
+        }
+    }
+    const tools = getCurrentTools(messages);
+    if (timestamp === undefined && tools.length === 0)
+        return undefined;
+    return {
+        role: "system",
+        content: content.join("\n\n"),
+        ...(sections.size > 0 ? { sections: Object.fromEntries(sections) } : {}),
+        ...(tools.length > 0 ? { toolsAdded: tools } : {}),
+        timestamp: timestamp ?? 0,
+    };
+}
+/** Render the current system prompt text after replaying every system message. */
+export function getCurrentSystemPrompt(messages) {
+    const message = getCurrentSystemMessage(messages);
+    return message ? getSystemMessageText(message) : "";
+}
+/**
+ * Rebuild the transcript for APIs without mid-conversation system messages: the replayed
+ * system message leads, and every later system message is dropped.
+ */
+export function collapseSystemMessages(context) {
+    const head = getCurrentSystemMessage(context.messages);
+    const messages = context.messages.filter((message) => message.role !== "system");
+    return { ...context, messages: head ? [head, ...messages] : messages };
+}
+/** Keep later system messages in place when the model accepts them; otherwise collapse them. */
+export function resolveTranscript(context, supportsMidConvoSystemMessages) {
+    return supportsMidConvoSystemMessages ? context : collapseSystemMessages(context);
+}
+/** Strip executable and display-only fields from a tool before transcript comparison or persistence. */
+export function toToolDeclaration(tool) {
+    return {
+        name: tool.name,
+        description: tool.description,
+        parameters: JSON.parse(JSON.stringify(tool.parameters)),
+        ...(tool.constrainedSampling === undefined ? {} : { constrainedSampling: tool.constrainedSampling }),
+    };
+}
+/**
+ * Whether two tools declare the same interface to the model.
+ *
+ * Both sides go through {@link toToolDeclaration} first: its JSON round-trip drops the
+ * typebox symbol keys and `undefined` fields that a structural comparison would see, and
+ * builds both objects with the same key order, so comparing the serialized declarations
+ * is exact. This avoids a deep-equal dependency in a browser-safe package.
+ */
+export function declarationsEqual(left, right) {
+    return JSON.stringify(toToolDeclaration(left)) === JSON.stringify(toToolDeclaration(right));
+}
+/** Compare two complete tool states. A changed definition is a removal followed by an addition. */
+export function getToolStateChanges(previous, current) {
+    const previousTools = new Map(previous.map((tool) => [tool.name, tool]));
+    const currentTools = new Map(current.map((tool) => [tool.name, tool]));
+    return {
+        toolsAdded: current
+            .filter((tool) => {
+            const previousTool = previousTools.get(tool.name);
+            return previousTool === undefined || !declarationsEqual(previousTool, tool);
+        })
+            .map(toToolDeclaration),
+        toolsRemoved: previous
+            .filter((tool) => {
+            const currentTool = currentTools.get(tool.name);
+            return currentTool === undefined || !declarationsEqual(tool, currentTool);
+        })
+            .map((tool) => ({ name: tool.name })),
+    };
+}
+/** Every definition referenced by transcript tool state, in first-declaration order. */
+export function getDeclaredTools(messages) {
+    const definitions = new Map();
+    for (const message of messages) {
+        if (!isSystemMessage(message))
+            continue;
+        for (const tool of message.toolsAdded ?? [])
+            definitions.set(tool.name, tool);
+    }
+    return [...definitions.values()];
+}
+/**
+ * Whether a tool name was declared twice with different definitions. Transports that
+ * reference tools by name (Anthropic `tool_addition`/`tool_removal`) cannot express that.
+ */
+export function hasToolRedefinitions(messages) {
+    const declared = new Map();
+    for (const message of messages) {
+        if (!isSystemMessage(message))
+            continue;
+        for (const tool of message.toolsAdded ?? []) {
+            const previous = declared.get(tool.name);
+            if (previous !== undefined && !declarationsEqual(previous, tool))
+                return true;
+            declared.set(tool.name, tool);
+        }
+    }
+    return false;
+}
+/** Whether tool history contains a removal or same-name redeclaration that an addition-only transport cannot replay. */
+export function hasNonAdditiveToolChanges(messages) {
+    const declared = new Set();
+    for (const message of messages) {
+        if (!isSystemMessage(message))
+            continue;
+        if ((message.toolsRemoved?.length ?? 0) > 0)
+            return true;
+        for (const tool of message.toolsAdded ?? []) {
+            if (declared.has(tool.name))
+                return true;
+            declared.add(tool.name);
+        }
+    }
+    return false;
+}
+/**
+ * Split tool declarations between the top-level request field and in-place additions.
+ * Transports that can anchor additions at a system message keep the initial tools at the
+ * top and load later ones where they appear; that only works when no tool was removed or
+ * redeclared, so everything else sends the current tool list.
+ */
+export function resolveTranscriptTools(messages, supportsToolAdditions) {
+    const anchorsAdditions = supportsToolAdditions && !hasNonAdditiveToolChanges(messages);
+    return {
+        requestTools: anchorsAdditions
+            ? (getInitialSystemMessage(messages)?.toolsAdded ?? [])
+            : getCurrentTools(messages),
+        anchorsAdditions,
+    };
+}
+//# sourceMappingURL=transcript.js.map

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@code-yeongyu/senpi-ai",
-	"version": "2026.9.30",
+	"version": "2026.10.1",
 	"description": "Unified LLM API with automatic model discovery and provider configuration",
 	"type": "module",
 	"main": "./dist/index.js",
@@ -73,19 +73,18 @@
 		"generate-models": "tsx scripts/generate-models.ts --strict",
 		"hydrate-model-data": "tsx scripts/generate-models.ts --strict --data-only",
 		"generate-model-catalog": "tsx scripts/generate-models.ts --strict --json-only --json-output ../../.artifacts/model-catalog",
-		"generate-image-models": "tsx scripts/generate-image-models.ts --strict",
 		"check:model-data": "tsx scripts/check-model-data.ts",
 		"build": "tsgo -p tsconfig.build.json && shx chmod +x dist/cli.js && shx rm -rf dist/providers/data && shx cp -r src/providers/data dist/providers/data",
 		"build:offline": "npm run check:model-data && tsc -p tsconfig.build.json && shx chmod +x dist/cli.js && shx rm -rf dist/providers/data && shx cp -r src/providers/data dist/providers/data",
 		"test": "vitest --run",
-		"prepublishOnly": "shx rm -rf dist && tsx scripts/generate-models.ts && tsx scripts/generate-image-models.ts && tsc -p tsconfig.build.json && shx chmod +x dist/cli.js",
+		"prepublishOnly": "shx rm -rf dist && tsx scripts/generate-models.ts && tsc -p tsconfig.build.json && shx chmod +x dist/cli.js",
 		"dev": "tsc -p tsconfig.build.json --watch --preserveWatchOutput",
 		"dev:tsc": "tsc -p tsconfig.build.json --watch --preserveWatchOutput"
 	},
 	"dependencies": {
 		"@anthropic-ai/sdk": "0.127.0",
 		"@aws-sdk/client-bedrock-runtime": "3.1136.0",
-		"@earendil-works/pi-telemetry": "npm:@code-yeongyu/senpi-telemetry@2026.9.30",
+		"@earendil-works/pi-telemetry": "npm:@code-yeongyu/senpi-telemetry@2026.10.1",
 		"@google/genai": "2.23.0",
 		"@smithy/node-http-handler": "4.12.1",
 		"http-proxy-agent": "9.1.0",