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

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,
@@ -323,6 +330,38 @@ function hasOpenAIExtendedPromptCache(model) {
     }
     return OPENAI_EXTENDED_CACHE_MODEL_ID.test(model.id);
 }
+/** Env that puts Claude Code on API-key, gateway or cloud billing, where it caches the main conversation for 5 minutes. */
+const CLAUDE_CODE_API_BILLING_ENV = [
+    "ANTHROPIC_API_KEY",
+    "ANTHROPIC_AUTH_TOKEN",
+    "ANTHROPIC_BASE_URL",
+    "CLAUDE_CODE_USE_BEDROCK",
+    "CLAUDE_CODE_USE_VERTEX",
+    "CLAUDE_CODE_USE_FOUNDRY",
+];
+function isEnabledFlag(value) {
+    return value !== undefined && !/^(?:|0|false|no|off)$/i.test(value.trim());
+}
+/**
+ * The Claude SDK lane's cache TTL is chosen by Claude Code, not senpi: `CLAUDE_CODE_PROMPT_CACHE_TTL`
+ * (`5m` | `1h`) wins, then `FORCE_PROMPT_CACHING_5M` and `ENABLE_PROMPT_CACHING_1H`; otherwise a Claude
+ * subscription gets 1 hour and API-key, gateway or cloud billing gets 5 minutes. A subscription past its
+ * usage limits also drops to 5 minutes, which nothing here can observe.
+ */
+function claudeCodePromptCacheTtlSeconds(env) {
+    const explicit = getProviderEnvValue("CLAUDE_CODE_PROMPT_CACHE_TTL", env)?.trim().toLowerCase();
+    if (explicit === "5m")
+        return PROMPT_CACHE_TTL_SHORT_SECONDS;
+    if (explicit === "1h")
+        return PROMPT_CACHE_TTL_LONG_SECONDS;
+    if (isEnabledFlag(getProviderEnvValue("FORCE_PROMPT_CACHING_5M", env)))
+        return PROMPT_CACHE_TTL_SHORT_SECONDS;
+    if (isEnabledFlag(getProviderEnvValue("ENABLE_PROMPT_CACHING_1H", env)))
+        return PROMPT_CACHE_TTL_LONG_SECONDS;
+    return CLAUDE_CODE_API_BILLING_ENV.some((name) => getProviderEnvValue(name, env) !== undefined)
+        ? PROMPT_CACHE_TTL_SHORT_SECONDS
+        : PROMPT_CACHE_TTL_LONG_SECONDS;
+}
 /**
  * Classify the active model's prompt-cache lifetime from the provider's documented cache contract.
  * `cacheRetention: "none"` (or `PI_CACHE_RETENTION` resolving to it) always wins.
@@ -330,8 +369,7 @@ function hasOpenAIExtendedPromptCache(model) {
 export function resolvePromptCacheLifetime(model, env) {
     switch (model.api) {
         case "claude-sdk-oauth":
-            // The Claude SDK owns prompt caching for this lane and uses Anthropic's default 5m TTL.
-            return ttl(PROMPT_CACHE_TTL_SHORT_SECONDS);
+            return ttl(claudeCodePromptCacheTtlSeconds(env));
         case "anthropic-messages": {
             const anthropicModel = model;
             const retention = resolveAnthropicCacheRetention(anthropicModel.cacheRetention, env, "short");

package/dist/utils/provider-failure-description.d.ts

@@ -16,4 +16,11 @@ export declare function stripTurnRetrySuppressionPrefix(message: string): string
  * the caller can fall back to the (marker-stripped) raw text.
  */
 export declare function describeProviderFailureForUser(errorMessage: string | undefined, options?: ProviderStallDescriptionOptions): string | undefined;
+/**
+ * The turn-ending message for a provider module that can no longer be imported because the
+ * installed package was replaced under the running process (#2358), or undefined for any other
+ * failure. It carries the no-turn-retry marker: every model in a fallback chain needs a module from
+ * the same install, so a retry or fallback would only repeat the failure.
+ */
+export declare function describeReplacedInstall(error: unknown): string | undefined;
 //# sourceMappingURL=provider-failure-description.d.ts.map

package/dist/utils/provider-failure-description.js

@@ -60,4 +60,25 @@ export function describeProviderFailureForUser(errorMessage, options = {}) {
         sentences.push(RECOVERY_SENTENCE[options.recovery]);
     return sentences.join(" ");
 }
+// Node: "Cannot find module '/…/chunks/x-HASH.js' imported from …"; Bun: the same with a relative
+// specifier, or "ENOENT reading \"/…/chunks/x-HASH.js\"" when the file vanished after resolution.
+const MISSING_MODULE_PATTERNS = [/^Cannot find module ['"]([^'"]+)['"]/, /^ENOENT reading ['"]([^'"]+)['"]/];
+const SHIPPED_MODULE = /^(?:\.{1,2}[\\/]|[\\/]|[A-Za-z]:[\\/]|file:).*\.m?js$/;
+/**
+ * The turn-ending message for a provider module that can no longer be imported because the
+ * installed package was replaced under the running process (#2358), or undefined for any other
+ * failure. It carries the no-turn-retry marker: every model in a fallback chain needs a module from
+ * the same install, so a retry or fallback would only repeat the failure.
+ */
+export function describeReplacedInstall(error) {
+    if (!(error instanceof Error))
+        return undefined;
+    for (const pattern of MISSING_MODULE_PATTERNS) {
+        const missing = pattern.exec(error.message)?.[1];
+        if (missing !== undefined && SHIPPED_MODULE.test(missing)) {
+            return `${TURN_RETRY_SUPPRESSION_PREFIX}The installed package changed while this session was running, so ${missing.split(/[\\/]/).at(-1)} can no longer be loaded. Restart and resume this session to continue.`;
+        }
+    }
+    return undefined;
+}
 //# sourceMappingURL=provider-failure-description.js.map

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",
@@ -179,10 +184,23 @@ const RETRYABLE_PROVIDER_ERROR_PATTERN = buildProviderErrorPattern([
     escapeRegExp(FORWARDED_EMPTY_TOOL_USE_ERROR),
     // gRPC based providers (e.g. NVIDIA NIM)
     "ResourceExhausted",
+    // Claude subscription per-request rejection that names no policy reason:
+    // `{"type":"error","error":{"type":"forbidden","message":"Request not allowed"}}`
+    // (senpi#2376). The same credential answered neighbouring requests with 200 and
+    // the burst ended by itself, so a bounded same-model retry recovers where an
+    // immediate fallback hop stranded the session. Anchored on the exact `forbidden`
+    // type plus the reason-less message, in either field order, so permission_error
+    // and forbidden rejections that carry a reason stay terminal.
+    '"type"\\s*:\\s*"forbidden"\\s*,\\s*"message"\\s*:\\s*"Request not allowed\\.?"',
+    '"message"\\s*:\\s*"Request not allowed\\.?"\\s*,\\s*"type"\\s*:\\s*"forbidden"',
     // Claude Agent SDK session.json lock contention. A second stream/resume
     // 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/tool-schema-compat.d.ts

@@ -24,4 +24,6 @@ export declare function normalizeToolParametersForMoonshot(schema: Record<string
  * Schemas that are already plain objects are returned untouched.
  */
 export declare function resolveRootObjectSchema(schema: Record<string, unknown>): Record<string, unknown>;
+/** Bedrock Converse rejects root combiners, including allOf, even with an object type (#1947). */
+export declare function normalizeToolParametersForBedrock(schema: Record<string, unknown>): Record<string, unknown>;
 //# sourceMappingURL=tool-schema-compat.d.ts.map

package/dist/utils/tool-schema-compat.js

@@ -92,9 +92,10 @@ function collapseConstUnion(node) {
  * so the root's own `properties` and `required` are merged with the branches'
  * rather than replaced by them.
  */
-function mergeRootObjectUnion(schema) {
-    const branches = Array.isArray(schema.anyOf) ? schema.anyOf : Array.isArray(schema.oneOf) ? schema.oneOf : undefined;
-    if (branches === undefined || branches.length === 0)
+function mergeRootObjectUnion(schema, combiner) {
+    const selected = combiner ?? (Array.isArray(schema.anyOf) ? "anyOf" : "oneOf");
+    const branches = schema[selected];
+    if (!Array.isArray(branches) || branches.length === 0)
         return undefined;
     if (schema.properties !== undefined && !isJsonObject(schema.properties))
         return undefined;
@@ -121,12 +122,11 @@ function mergeRootObjectUnion(schema) {
             properties[name] =
                 existing === undefined || JSON.stringify(existing) === JSON.stringify(propertySchema)
                     ? propertySchema
-                    : { anyOf: [existing, propertySchema] };
+                    : { [selected === "allOf" ? "allOf" : "anyOf"]: [existing, propertySchema] };
         }
     }
-    // Only names required by EVERY branch stay required; a name required by one
-    // branch alone would reject payloads the union accepts. Root-level `required`
-    // applies to all branches, so it is unioned back in.
+    // Unions require only branch-common names; intersections require every branch's
+    // names. Root-level required always applies.
     const rootRequired = Array.isArray(schema.required)
         ? schema.required.filter((name) => typeof name === "string")
         : [];
@@ -137,8 +137,15 @@ function mergeRootObjectUnion(schema) {
     const commonBranchRequired = firstBranchRequired
         ? [...firstBranchRequired].filter((name) => branchRequiredSets.every((names) => names.has(name)))
         : [];
-    const required = [...new Set([...rootRequired, ...commonBranchRequired])];
-    const { anyOf: _anyOf, oneOf: _oneOf, ...rest } = schema;
+    const required = [
+        ...new Set([
+            ...rootRequired,
+            ...(selected === "allOf" ? branchRequiredSets.flatMap((names) => [...names]) : commonBranchRequired),
+        ]),
+    ];
+    const rest = { ...schema };
+    for (const key of combiner ? [combiner] : ["anyOf", "oneOf"])
+        delete rest[key];
     return {
         ...rest,
         type: "object",
@@ -230,6 +237,18 @@ export function normalizeToolParametersForMoonshot(schema) {
 export function resolveRootObjectSchema(schema) {
     return mergeRootObjectUnion(structuredClone(schema)) ?? schema;
 }
+/** Bedrock Converse rejects root combiners, including allOf, even with an object type (#1947). */
+export function normalizeToolParametersForBedrock(schema) {
+    let normalized = structuredClone(schema);
+    for (const combiner of COMBINER_KEYS) {
+        const branches = normalized[combiner];
+        if (Array.isArray(branches)) {
+            normalized[combiner] = branches.map((branch) => isJsonObject(branch) ? normalizeToolParametersForBedrock(branch) : branch);
+        }
+        normalized = mergeRootObjectUnion(normalized, combiner) ?? normalized;
+    }
+    return { type: "object", ...normalized };
+}
 function stripMoonshotAnnotations(node) {
     if (Array.isArray(node)) {
         return node.map((child) => stripMoonshotAnnotations(child));

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