@code-yeongyu/senpi-ai 2026.10.30-2 → 2026.10.31-2

package/dist/types.d.ts

@@ -513,6 +513,14 @@ export interface SystemMessage {
      * the original. Avoid integer-like names; JSON objects reorder those.
      */
     sections?: Record<string, string | null>;
+    /**
+     * Leading message only: the start of the rendered prompt that is the same across sessions in the same
+     * working directory. Providers with block-level prompt caching (Anthropic) send it as its own block
+     * holding the system cache breakpoint when the rendered prompt still starts with it, so another session
+     * reads it from cache even when the rest differs; a rewrite that no longer starts with it sends one block.
+     * Request-time only; rendered text is unchanged (senpi#4447).
+     */
+    stablePrefix?: string;
     /** Complete definitions of tools that become available at this point. */
     toolsAdded?: Tool[];
     /** Tools that stop being available at this point. */
@@ -769,6 +777,12 @@ export interface ToolReference {
  */
 export interface Context {
     systemPrompt?: string;
+    /**
+     * Leading part of `systemPrompt` that is the same across sessions in the same working directory; the rest
+     * changes between sessions (memory, MCP instructions). Folded into the leading system message as
+     * `stablePrefix` when `systemPrompt` starts with it (senpi#4447).
+     */
+    systemPromptStablePrefix?: string;
     messages: Message[];
     tools?: Tool[];
     /**
@@ -941,6 +955,8 @@ export interface OpenAICompletionsCompat {
     supportsMidConvoToolAdditions?: boolean;
     /** Whether the provider supports the `strict` field in tool definitions. Default: false; generated capable models enable it explicitly. */
     supportsStrictMode?: boolean;
+    /** Whether function tools may mix strict and non-strict sampling in one request. Default: true. */
+    mixedStrictTools?: boolean;
     /**
      * Provider-specific JSON Schema flavor for tool parameters. `"moonshot-mfjs"`
      * normalizes schemas for Moonshot / Kimi backends that enforce a stricter subset.

package/dist/utils/chatgpt-subscription-auth.d.ts

@@ -8,4 +8,11 @@ export declare const CHATGPT_SUBSCRIPTION_AUTH_CLAIM_PATH = "https://api.openai.
  * browser consumers.
  */
 export declare function extractChatGptSubscriptionAccountId(token: string): string | undefined;
+/**
+ * The signed-in person a Codex access token belongs to, for telling one saved account from another.
+ * `chatgpt_account_id` names the workspace and is shared by every member of a Team workspace, so the
+ * identity is the per-member `chatgpt_account_user_id`, or the user id scoped to the workspace when
+ * that claim is absent. A token without either has no identity.
+ */
+export declare function extractChatGptSubscriptionIdentity(token: string): string | undefined;
 //# sourceMappingURL=chatgpt-subscription-auth.d.ts.map

package/dist/utils/chatgpt-subscription-auth.js

@@ -8,6 +8,22 @@ export const CHATGPT_SUBSCRIPTION_AUTH_CLAIM_PATH = "https://api.openai.com/auth
  * browser consumers.
  */
 export function extractChatGptSubscriptionAccountId(token) {
+    return claimString(authClaims(token), "chatgpt_account_id");
+}
+/**
+ * The signed-in person a Codex access token belongs to, for telling one saved account from another.
+ * `chatgpt_account_id` names the workspace and is shared by every member of a Team workspace, so the
+ * identity is the per-member `chatgpt_account_user_id`, or the user id scoped to the workspace when
+ * that claim is absent. A token without either has no identity.
+ */
+export function extractChatGptSubscriptionIdentity(token) {
+    const auth = authClaims(token);
+    const workspace = claimString(auth, "chatgpt_account_id");
+    const user = claimString(auth, "chatgpt_user_id") ?? claimString(auth, "user_id");
+    return (claimString(auth, "chatgpt_account_user_id") ??
+        (user !== undefined && workspace !== undefined ? `${user}/${workspace}` : undefined));
+}
+function authClaims(token) {
     try {
         const parts = token.split(".");
         const encodedPayload = parts.length === 3 ? parts[1] : undefined;
@@ -18,13 +34,14 @@ export function extractChatGptSubscriptionAccountId(token) {
         if (!payload || typeof payload !== "object")
             return undefined;
         const auth = Reflect.get(payload, CHATGPT_SUBSCRIPTION_AUTH_CLAIM_PATH);
-        if (!auth || typeof auth !== "object")
-            return undefined;
-        const accountId = Reflect.get(auth, "chatgpt_account_id");
-        return typeof accountId === "string" && accountId.length > 0 ? accountId : undefined;
+        return auth && typeof auth === "object" ? auth : undefined;
     }
     catch {
         return undefined;
     }
 }
+function claimString(claims, key) {
+    const value = claims === undefined ? undefined : Reflect.get(claims, key);
+    return typeof value === "string" && value.length > 0 ? value : undefined;
+}
 //# sourceMappingURL=chatgpt-subscription-auth.js.map

package/dist/utils/prompt-cache-ttl.d.ts

@@ -24,7 +24,8 @@ export type PromptCacheLifetime = {
 };
 export declare function isAnthropicApiBaseUrl(baseUrl: string): boolean;
 export declare function getAnthropicCompat(model: Model<"anthropic-messages">): Required<Omit<AnthropicMessagesCompat, "forceAdaptiveThinking" | "supportsMidConvoEffort" | "sessionAffinityFormat">> & Pick<AnthropicMessagesCompat, "sessionAffinityFormat">;
-export type ResolvedOpenAICompletionsCompat = Omit<Required<OpenAICompletionsCompat>, "vllmPriority" | "cacheControlFormat" | "toolCallFormat" | "deferredToolsMode" | "toolSchemaFlavor" | "supportsPromptCacheKey" | "chatTemplateArgs" | "supportsThinkingTokenBudget" | "thinkingTokenBudgetField" | "veniceParameters" | "supportsForcedToolChoice" | "supportsWebSearch"> & {
+export type ResolvedOpenAICompletionsCompat = Omit<Required<OpenAICompletionsCompat>, "vllmPriority" | "cacheControlFormat" | "toolCallFormat" | "deferredToolsMode" | "toolSchemaFlavor" | "supportsPromptCacheKey" | "chatTemplateArgs" | "supportsThinkingTokenBudget" | "thinkingTokenBudgetField" | "veniceParameters" | "supportsForcedToolChoice" | "supportsWebSearch" | "mixedStrictTools"> & {
+    mixedStrictTools?: OpenAICompletionsCompat["mixedStrictTools"];
     supportsWebSearch?: OpenAICompletionsCompat["supportsWebSearch"];
     /** Declared forced tool_choice support; absent means supported. */
     supportsForcedToolChoice?: OpenAICompletionsCompat["supportsForcedToolChoice"];

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

@@ -161,6 +161,7 @@ function detectOpenAICompletionsCompat(model) {
         zaiToolStream: false,
         // OpenAI compatibility alone does not imply strict JSON-schema tool support.
         supportsStrictMode: false,
+        mixedStrictTools: true,
         toolSchemaFlavor: isMoonshot ? "moonshot-mfjs" : undefined,
         supportsDisabledThinking: true,
         toolCallFormat: undefined,
@@ -211,6 +212,7 @@ export function getOpenAICompletionsCompat(model) {
         supportsThinkingTokenBudget: model.compat.supportsThinkingTokenBudget ?? detected.supportsThinkingTokenBudget,
         thinkingTokenBudgetField: model.compat.thinkingTokenBudgetField ?? detected.thinkingTokenBudgetField,
         supportsStrictMode: model.compat.supportsStrictMode ?? detected.supportsStrictMode,
+        mixedStrictTools: model.compat.mixedStrictTools ?? detected.mixedStrictTools,
         toolSchemaFlavor: model.compat.toolSchemaFlavor ?? detected.toolSchemaFlavor,
         toolCallFormat: model.compat.toolCallFormat ?? detected.toolCallFormat,
         supportsOpenAIGrammarTools: model.compat.supportsOpenAIGrammarTools ?? detected.supportsOpenAIGrammarTools,

package/dist/utils/retry-hint.d.ts

@@ -6,7 +6,8 @@
  *   2. retry-after header      (strict integer delta-seconds `^\d+$`, else HTTP-date)
  *   3. x-ratelimit-reset{,-requests,-tokens}  (epoch seconds, max-wins)
  *   4. JSON retryDelay strings (ms/s/m units, recursive, max-wins; numeric rejected)
- *   5. body prose              (ms-marker, seconds-marker, relative, resets-in, resets-at ISO8601)
+ *   5. body prose              (ms-marker, seconds-marker, relative, resets-in, resets-at ISO8601,
+ *                              wall clock with an optional zone: "resets 12am (Asia/Seoul)")
  *
  * Eligibility gate: status 429 OR body marks rate-limit error.
  * Explicit zero = 0 (beats lower-precedence positives).
@@ -21,4 +22,5 @@ export interface RetryHintInput {
 export declare function extract429RetryAfterMs(input: RetryHintInput, nowMs?: number): number | undefined;
 export declare function appendRetryAfterMsMarker(message: string, hintMs: number): string;
 export declare function parseRetryAfterMsMarker(message: string): number | undefined;
+export declare function clockResetMs(text: string, nowMs: number): number | undefined;
 //# sourceMappingURL=retry-hint.d.ts.map

package/dist/utils/retry-hint.js

@@ -6,7 +6,8 @@
  *   2. retry-after header      (strict integer delta-seconds `^\d+$`, else HTTP-date)
  *   3. x-ratelimit-reset{,-requests,-tokens}  (epoch seconds, max-wins)
  *   4. JSON retryDelay strings (ms/s/m units, recursive, max-wins; numeric rejected)
- *   5. body prose              (ms-marker, seconds-marker, relative, resets-in, resets-at ISO8601)
+ *   5. body prose              (ms-marker, seconds-marker, relative, resets-in, resets-at ISO8601,
+ *                              wall clock with an optional zone: "resets 12am (Asia/Seoul)")
  *
  * Eligibility gate: status 429 OR body marks rate-limit error.
  * Explicit zero = 0 (beats lower-precedence positives).
@@ -145,7 +146,8 @@ function fromBodyProse(bodyText, nowMs) {
         if (!Number.isNaN(parsed))
             return clampAbsolute(parsed, nowMs);
     }
-    return undefined;
+    // resets <wall clock> [(<IANA zone>)], the shape Claude Code writes (senpi#1771)
+    return clockResetMs(bodyText, nowMs);
 }
 /* ---------- helpers ---------- */
 function dateHeaderMs(h) {
@@ -234,4 +236,80 @@ export function parseRetryAfterMsMarker(message) {
         return undefined;
     return Number.parseInt(m[1], 10);
 }
+/* ---------- wall-clock reset prose ---------- */
+// A reset written as a wall clock: "resets 12am (Asia/Seoul)", "resets Oct 2, 9am", "try again at 12:00 AM".
+// Shared with the credential pool (reset-time.ts) so both read the text the same way (senpi#1771). Milliseconds
+// from `nowMs` to the next such moment, or undefined; a time with no zone reads in the host's local zone.
+const MONTHS = ["jan", "feb", "mar", "apr", "may", "jun", "jul", "aug", "sep", "oct", "nov", "dec"];
+const CLOCK_RE = /\b(?:resets?|try again)\s+(?:at\s+|on\s+)?(?:([a-z]{3})[a-z]*\.?\s+(\d{1,2}),?\s+(?:at\s+)?)?(\d{1,2})(?::(\d{2}))?\s*([ap])\.?\s?m\b\.?(?:\s*\(([A-Za-z_]+(?:\/[A-Za-z0-9_+-]+)*)\))?/i;
+export function clockResetMs(text, nowMs) {
+    const match = CLOCK_RE.exec(text);
+    if (!match)
+        return undefined;
+    const [, monthName, dayText, hourText, minuteText, meridiem, zoneText] = match;
+    const hour12 = Number.parseInt(hourText ?? "", 10);
+    const minute = minuteText === undefined ? 0 : Number.parseInt(minuteText, 10);
+    if (hour12 < 1 || hour12 > 12 || minute > 59)
+        return undefined;
+    const hour = (hour12 % 12) + (meridiem?.toLowerCase() === "p" ? 12 : 0);
+    const zone = zoneText ?? Intl.DateTimeFormat().resolvedOptions().timeZone;
+    if (!isValidTimeZone(zone))
+        return undefined;
+    const today = zonedParts(zone, nowMs);
+    if (monthName !== undefined) {
+        const month = MONTHS.indexOf(monthName.toLowerCase());
+        const day = Number.parseInt(dayText ?? "", 10);
+        if (month < 0 || day < 1 || day > 31)
+            return undefined;
+        let target = zonedToEpoch(zone, today.year, month, day, hour, minute);
+        if (target <= nowMs)
+            target = zonedToEpoch(zone, today.year + 1, month, day, hour, minute);
+        return target - nowMs;
+    }
+    let target = zonedToEpoch(zone, today.year, today.month, today.day, hour, minute);
+    if (target <= nowMs)
+        target = zonedToEpoch(zone, today.year, today.month, today.day + 1, hour, minute);
+    return target - nowMs;
+}
+function isValidTimeZone(zone) {
+    try {
+        new Intl.DateTimeFormat("en-US", { timeZone: zone });
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+function zonedParts(zone, epochMs) {
+    const parts = new Intl.DateTimeFormat("en-US", {
+        timeZone: zone,
+        hourCycle: "h23",
+        year: "numeric",
+        month: "numeric",
+        day: "numeric",
+        hour: "numeric",
+        minute: "numeric",
+        second: "numeric",
+    }).formatToParts(epochMs);
+    const get = (type) => Number.parseInt(parts.find((part) => part.type === type)?.value ?? "0", 10);
+    return {
+        year: get("year"),
+        month: get("month") - 1,
+        day: get("day"),
+        hour: get("hour"),
+        minute: get("minute"),
+        second: get("second"),
+    };
+}
+function zoneOffsetMs(zone, epochMs) {
+    const p = zonedParts(zone, epochMs);
+    const wallAsUtc = Date.UTC(p.year, p.month, p.day, p.hour, p.minute, p.second);
+    return wallAsUtc - Math.floor(epochMs / 1000) * 1000;
+}
+/** The instant a wall-clock time in `zone` names; two passes settle a DST boundary. */
+function zonedToEpoch(zone, year, month, day, hour, minute) {
+    const wall = Date.UTC(year, month, day, hour, minute);
+    const first = wall - zoneOffsetMs(zone, wall);
+    return wall - zoneOffsetMs(zone, first);
+}
 //# sourceMappingURL=retry-hint.js.map

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

@@ -148,16 +148,51 @@ function mergeRootObjectUnion(schema, combiner) {
             ...(selected === "allOf" ? branchRequiredSets.flatMap((names) => [...names]) : commonBranchRequired),
         ]),
     ];
+    // A union's merged root drops each branch's own required names; keep them visible to the model (#5138).
+    const hints = selected === "allOf"
+        ? []
+        : objectBranches.flatMap((branch, index) => {
+            const own = [...(branchRequiredSets[index] ?? [])].filter((name) => !required.includes(name));
+            return own.length === 0 ? [] : [`REQUIRED for ${describeBranch(branch, index)}: ${own.join(", ")}.`];
+        });
+    const description = hints.length === 0
+        ? undefined
+        : [typeof schema.description === "string" ? schema.description : "", ...hints].filter(Boolean).join(" ");
     const rest = { ...schema };
     for (const key of combiner ? [combiner] : ["anyOf", "oneOf"])
         delete rest[key];
     return {
         ...rest,
+        ...(description === undefined ? {} : { description }),
         type: "object",
         properties,
         ...(required.length > 0 ? { required } : {}),
     };
 }
+/** Names a union branch by its first literal-valued property (`action=run`), else by position. */
+function describeBranch(branch, index) {
+    if (isJsonObject(branch.properties)) {
+        for (const [name, propertySchema] of Object.entries(branch.properties)) {
+            const values = literalValues(propertySchema);
+            if (values.length > 0)
+                return `${name}=${values.join("|")}`;
+        }
+    }
+    return `option ${index + 1}`;
+}
+function literalValues(schema) {
+    if (!isJsonObject(schema))
+        return [];
+    if (Object.hasOwn(schema, "const"))
+        return [String(schema.const)];
+    if (Array.isArray(schema.enum))
+        return schema.enum.map(String);
+    const branches = schema.anyOf;
+    if (!Array.isArray(branches))
+        return [];
+    const values = branches.map((branch) => literalValues(branch));
+    return values.every((value) => value.length === 1) ? values.flat() : [];
+}
 function normalizeNode(node, isRoot = false) {
     if (Array.isArray(node)) {
         return node.map((child) => normalizeNode(child));

package/dist/utils/transcript.d.ts

@@ -4,7 +4,7 @@ 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;
+export declare function createInitialSystemMessage(systemPrompt: string | undefined, tools: Tool[] | undefined, stablePrefix?: string): 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

package/dist/utils/transcript.js

@@ -3,14 +3,20 @@ 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) {
+export function createInitialSystemMessage(systemPrompt, tools, stablePrefix) {
     const hasSystemPrompt = systemPrompt !== undefined && systemPrompt.length > 0;
     const hasTools = tools !== undefined && tools.length > 0;
     if (!hasSystemPrompt && !hasTools)
         return undefined;
+    const splitsPrompt = hasSystemPrompt &&
+        stablePrefix !== undefined &&
+        stablePrefix.length > 0 &&
+        stablePrefix.length < systemPrompt.length &&
+        systemPrompt.startsWith(stablePrefix);
     return {
         role: "system",
         content: systemPrompt ?? "",
+        ...(splitsPrompt ? { stablePrefix } : {}),
         ...(hasTools ? { toolsAdded: tools } : {}),
         timestamp: 0,
     };
@@ -22,7 +28,7 @@ export function createInitialSystemMessage(systemPrompt, tools) {
  * over unchanged (senpi#2095 allowed-tools): it has no system-message representation.
  */
 export function normalizeContext(context) {
-    const initialMessage = createInitialSystemMessage(context.systemPrompt, context.tools);
+    const initialMessage = createInitialSystemMessage(context.systemPrompt, context.tools, context.systemPromptStablePrefix);
     const messages = initialMessage ? [initialMessage, ...context.messages] : context.messages;
     return (context.activeToolNames ? { messages, activeToolNames: context.activeToolNames } : { messages });
 }
@@ -60,9 +66,12 @@ export function getCurrentSystemMessage(messages) {
     const content = [];
     const sections = new Map();
     let timestamp;
+    let stablePrefix;
     for (const message of messages) {
         if (!isSystemMessage(message))
             continue;
+        if (timestamp === undefined)
+            stablePrefix = message.stablePrefix;
         timestamp ??= message.timestamp;
         const text = contentText(message.content);
         if (text.length > 0)
@@ -80,6 +89,7 @@ export function getCurrentSystemMessage(messages) {
     return {
         role: "system",
         content: content.join("\n\n"),
+        ...(stablePrefix === undefined ? {} : { stablePrefix }),
         ...(sections.size > 0 ? { sections: Object.fromEntries(sections) } : {}),
         ...(tools.length > 0 ? { toolsAdded: tools } : {}),
         timestamp: timestamp ?? 0,

package/dist/utils/validation.js

@@ -185,6 +185,111 @@ function formatValidationPath(error) {
     const path = error.instancePath.replace(/^\//, "").replace(/\//g, ".");
     return path || "root";
 }
+function constValues(schema) {
+    if (!schema)
+        return undefined;
+    if ("const" in schema)
+        return [schema.const];
+    if (Array.isArray(schema.enum) && schema.enum.length > 0)
+        return [...schema.enum];
+    const members = schema.anyOf ?? schema.oneOf;
+    if (!Array.isArray(members) || members.length === 0)
+        return undefined;
+    const values = [];
+    for (const member of members) {
+        const memberValues = constValues(member);
+        if (!memberValues)
+            return undefined;
+        values.push(...memberValues);
+    }
+    return values;
+}
+function discriminatedBranches(members, property) {
+    const seen = new Set();
+    const branches = [];
+    for (const member of members) {
+        const propertySchema = member.properties?.[property];
+        const values = constValues(propertySchema);
+        if (!values || values.some((value) => seen.has(value)))
+            return undefined;
+        for (const value of values)
+            seen.add(value);
+        branches.push({
+            schema: member,
+            values,
+            optional: !(member.required ?? []).includes(property),
+            defaultValue: propertySchema?.default,
+        });
+    }
+    return branches;
+}
+/** An anyOf/oneOf of object branches that every carry a const-valued property with disjoint values. */
+function findDiscriminatedUnion(schema) {
+    const members = schema.anyOf ?? schema.oneOf;
+    if (!Array.isArray(members) || members.length < 2)
+        return undefined;
+    const [first] = members;
+    if (!first?.properties || !members.every((member) => member.properties !== undefined))
+        return undefined;
+    for (const property of Object.keys(first.properties)) {
+        const branches = discriminatedBranches(members, property);
+        if (!branches)
+            continue;
+        const defaultValue = schema.properties?.[property]?.default ??
+            branches.map((branch) => branch.defaultValue).find((value) => value !== undefined);
+        return { property, branches, defaultValue };
+    }
+    return undefined;
+}
+function selectBranch(union, value) {
+    if (value !== undefined) {
+        const branch = union.branches.find((candidate) => candidate.values.includes(value));
+        return branch ? { branch, value, defaulted: false } : "unknown";
+    }
+    if (union.defaultValue !== undefined) {
+        const branch = union.branches.find((candidate) => candidate.values.includes(union.defaultValue));
+        if (branch)
+            return { branch, value: union.defaultValue, defaulted: true };
+    }
+    const optional = union.branches.filter((candidate) => candidate.optional);
+    const [only] = optional;
+    if (optional.length === 1 && only && only.values.length === 1) {
+        return { branch: only, value: only.values[0], defaulted: true };
+    }
+    return undefined;
+}
+/**
+ * For a discriminated union, report only the branch the arguments address, as one line, so the caller
+ * sees which field to fix instead of every branch's mismatch. Undefined means use the full error list.
+ */
+function formatDiscriminatedUnionError(schema, validator, args) {
+    if (typeof args !== "object" || args === null || Array.isArray(args))
+        return undefined;
+    const union = findDiscriminatedUnion(schema);
+    if (!union)
+        return undefined;
+    const received = args[union.property];
+    const selected = selectBranch(union, received);
+    if (selected === undefined)
+        return undefined;
+    if (selected === "unknown") {
+        const allowed = union.branches.flatMap((branch) => branch.values).map((value) => JSON.stringify(value));
+        return `  - ${union.property}: must be one of ${allowed.join(", ")} (received ${JSON.stringify(received)})`;
+    }
+    const branchValidator = getSubSchemaValidator(selected.branch.schema);
+    if (!branchValidator)
+        return undefined;
+    const rootErrors = validator
+        .Errors(args)
+        .filter((error) => error.keyword !== "anyOf" && error.keyword !== "oneOf")
+        .filter((error) => !/^#\/(?:anyOf|oneOf)(?:\/|$)/.test(error.schemaPath));
+    const messages = [...rootErrors, ...branchValidator.Errors(args)].map((error) => `${formatValidationPath(error)}: ${error.message}`);
+    const unique = [...new Set(messages)];
+    if (unique.length === 0)
+        return undefined;
+    const label = `for ${union.property} ${JSON.stringify(selected.value)}${selected.defaulted ? ` (default when ${union.property} is omitted)` : ""}`;
+    return `  - ${label}: ${unique.join("; ")}`;
+}
 /**
  * Finds a tool by name and validates the tool call arguments against its TypeBox schema
  * @param tools Array of tool definitions
@@ -238,10 +343,12 @@ export function validateToolArguments(tool, toolCall) {
     if (validator.Check(args)) {
         return args;
     }
-    const errors = validator
-        .Errors(args)
-        .map((error) => `  - ${formatValidationPath(error)}: ${error.message}`)
-        .join("\n") || "Unknown validation error";
+    const errors = formatDiscriminatedUnionError(tool.parameters, validator, args) ??
+        (validator
+            .Errors(args)
+            .map((error) => `  - ${formatValidationPath(error)}: ${error.message}`)
+            .join("\n") ||
+            "Unknown validation error");
     const errorMessage = `Validation failed for tool "${toolCall.name}":\n${errors}\n\nReceived arguments:\n${JSON.stringify(toolCall.arguments, null, 2)}`;
     throw new Error(errorMessage);
 }

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@code-yeongyu/senpi-ai",
-	"version": "2026.10.30-2",
+	"version": "2026.10.31-2",
 	"description": "Unified LLM API with automatic model discovery and provider configuration",
 	"type": "module",
 	"main": "./dist/index.js",
@@ -88,7 +88,7 @@
 	"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.10.30-2",
+		"@earendil-works/pi-telemetry": "npm:@code-yeongyu/senpi-telemetry@2026.10.31-2",
 		"@google/genai": "2.23.0",
 		"@smithy/node-http-handler": "4.12.1",
 		"google-auth-library": "10.6.2",

package/dist/auth/oauth/anthropic-callback-listener.d.ts

@@ -1,40 +0,0 @@
-/**
- * Loopback callback listener for the Anthropic OAuth flow.
- *
- * The OAuth client accepts any `localhost` port on the `/callback` path (the
- * Claude Code CLI itself binds a random port per login), so the listener
- * prefers the historical port 53692 and falls back to an ephemeral port when
- * another login - in this process or in another one - still holds it. With a
- * fixed port, a second login on the same machine sent its browser redirect to
- * the OTHER process's listener, which could only answer "State mismatch".
- *
- * NOTE: Node-only (http.createServer); reached through the lazy OAuth loader.
- */
-export type CallbackCode = {
-    code: string;
-    state: string;
-};
-export type CallbackListener = {
-    /** Bound loopback port; `undefined` when no port could be bound (manual-only login). */
-    port?: number;
-    redirectUri: string;
-    callbackUnavailable?: {
-        code: string;
-    };
-    waitForCode: () => Promise<CallbackCode | null>;
-    cancelWait: () => void;
-    close: () => Promise<void>;
-};
-export type CallbackListenerApis = {
-    createServer: typeof import("node:http").createServer;
-};
-export declare const PREFERRED_CALLBACK_PORT = 53692;
-export declare const CALLBACK_PATH = "/callback";
-export declare function callbackRedirectUri(port: number): string;
-/**
- * Binds the preferred port, then an ephemeral one; when neither can be bound
- * the login continues in manual mode with the registered preferred-port
- * redirect URI, so a pasted redirect URL still exchanges.
- */
-export declare function startCallbackListener(apis: CallbackListenerApis, expectedState: string, host: string): Promise<CallbackListener>;
-//# sourceMappingURL=anthropic-callback-listener.d.ts.map