@code-yeongyu/senpi-ai 2026.11.9 → 2026.11.10-1

package/dist/utils/openai-prompt-cache-lane.d.ts

@@ -0,0 +1,14 @@
+import type { Api, CacheRetention, Model } from "../types.ts";
+/**
+ * Which OpenAI prompt-cache contract a Responses-lane request runs under
+ * (https://developers.openai.com/api/docs/guides/prompt-caching, "Cache lifetime"):
+ *
+ * - `chatgpt-subscription`: signed-in ChatGPT usage (Codex backend or Sign in with ChatGPT). OpenAI keeps this
+ *   cache with no expiry (senpi#6290); no API doc publishes a lifetime, so it carries no TTL to schedule around.
+ * - `api-long`: GPT-5.6+ on a request that sends `prompt_cache_options.ttl: "12h"` (12-hour minimum lifetime).
+ * - `api-extended`: GPT-5.6+ at the default `"30m"` minimum lifetime.
+ * - `api-short`: earlier models, and gateways that proxy GPT-5.6+ ids without OpenAI's contract.
+ */
+export type OpenAIPromptCacheLane = "chatgpt-subscription" | "api-long" | "api-extended" | "api-short";
+export declare function classifyOpenAIPromptCacheLane(model: Model<Api>, retention: CacheRetention): OpenAIPromptCacheLane;
+//# sourceMappingURL=openai-prompt-cache-lane.d.ts.map

package/dist/utils/openai-prompt-cache-lane.js

@@ -0,0 +1,58 @@
+/** GPT-5.6 and later (`gpt-5.6-*`, `gpt-5.10`, `gpt-6-*`, `gpt-7`, ...). */
+const OPENAI_EXTENDED_CACHE_MODEL_ID = /^gpt-(?:5\.(?:[6-9]|\d{2,})|(?:[6-9]|\d{2,})(?:\.\d+)?)(?:-|$)/i;
+/** The Codex backend serves only signed-in ChatGPT usage, whatever provider id a models.json entry gives it. */
+const CHATGPT_CODEX_BACKEND_HOST = "chatgpt.com";
+/** Sign in with ChatGPT routes plan usage to the API host, so only the `siwc` compat flag tells it from an API key. */
+const SIWC_HOST = "api.openai.com";
+function hostnameOf(baseUrl) {
+    try {
+        return new URL(baseUrl).hostname.toLowerCase();
+    }
+    catch {
+        return undefined;
+    }
+}
+function responsesCompat(model) {
+    return model.compat;
+}
+function isChatGptSubscription(model) {
+    const host = hostnameOf(model.baseUrl);
+    if (model.api === "openai-codex-responses")
+        return host === CHATGPT_CODEX_BACKEND_HOST;
+    return model.api === "openai-responses" && host === SIWC_HOST && responsesCompat(model)?.siwc === true;
+}
+/**
+ * The OpenAI-operated Responses lanes serving a GPT-5.6+ model, where OpenAI documents a cache lifetime of at
+ * least 30 minutes. Gateways that merely proxy the same model ids keep the short lifetime: their routing does
+ * not carry that contract.
+ */
+function hasExtendedPromptCache(model) {
+    if (model.api === "openai-responses") {
+        if (responsesCompat(model)?.supportsExplicitPromptCacheMode === true)
+            return true;
+        if (model.provider !== "openai" && hostnameOf(model.baseUrl) !== "api.openai.com")
+            return false;
+    }
+    return OPENAI_EXTENDED_CACHE_MODEL_ID.test(model.id);
+}
+/**
+ * Mirrors the `openai-responses` adapter's `getPromptCacheOptions()`: `"12h"` is sent only on `long` retention,
+ * to a model that accepts `prompt_cache_options` outside Sign in with ChatGPT, unless compat opts out of long
+ * retention. Azure and Codex-protocol requests carry no `prompt_cache_options`.
+ */
+function sendsTwelveHourTtl(model, retention) {
+    const compat = responsesCompat(model);
+    return (retention === "long" &&
+        model.api === "openai-responses" &&
+        compat?.siwc !== true &&
+        compat?.supportsExplicitPromptCacheMode === true &&
+        compat.supportsLongCacheRetention !== false);
+}
+export function classifyOpenAIPromptCacheLane(model, retention) {
+    if (isChatGptSubscription(model))
+        return "chatgpt-subscription";
+    if (sendsTwelveHourTtl(model, retention))
+        return "api-long";
+    return hasExtendedPromptCache(model) ? "api-extended" : "api-short";
+}
+//# sourceMappingURL=openai-prompt-cache-lane.js.map

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

@@ -2,16 +2,19 @@ import type { AnthropicMessagesCompat, Api, Model, OpenAICompletionsCompat, Prov
 export declare const PROMPT_CACHE_TTL_SHORT_SECONDS = 300;
 export declare const PROMPT_CACHE_TTL_LONG_SECONDS = 3600;
 /**
- * OpenAI GPT-5.6 and later: `prompt_cache_options.ttl` accepts only `"30m"`, and the cache stays
- * eligible at least 30 minutes after the latest write or reuse.
+ * OpenAI GPT-5.6 and later: the default `prompt_cache_options.ttl: "30m"` keeps the cache eligible at least
+ * 30 minutes after the latest write or reuse.
  */
 export declare const PROMPT_CACHE_TTL_OPENAI_EXTENDED_SECONDS = 1800;
+/** OpenAI GPT-5.6 and later on the Responses API: `prompt_cache_options.ttl: "12h"`, a 12-hour minimum lifetime. */
+export declare const PROMPT_CACHE_TTL_OPENAI_LONG_SECONDS = 43200;
 /**
  * How long a provider promises to keep a prompt prefix cached.
  *
  * - `ttl`: an explicit expiry contract; `ttlSeconds` is the conservative lifetime after the last write or reuse.
- * - `best-effort`: the provider caches automatically but promises no expiry (direct DeepSeek clears unused entries
- *   after hours to days), so nothing needs to wake or ping solely to preserve the cache.
+ * - `best-effort`: the provider caches automatically with no expiry senpi can schedule around (direct DeepSeek
+ *   clears unused entries after hours to days; signed-in ChatGPT keeps its cache with no expiry), so nothing needs
+ *   to wake or ping solely to preserve the cache.
  * - `none`: caching is disabled or the lane has no known cache contract.
  */
 export type PromptCacheLifetime = {

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

@@ -1,16 +1,25 @@
+import { classifyOpenAIPromptCacheLane } from "./openai-prompt-cache-lane.js";
 import { getProviderEnvValue } from "./provider-env.js";
 export const PROMPT_CACHE_TTL_SHORT_SECONDS = 300;
 export const PROMPT_CACHE_TTL_LONG_SECONDS = 3600;
 /**
- * OpenAI GPT-5.6 and later: `prompt_cache_options.ttl` accepts only `"30m"`, and the cache stays
- * eligible at least 30 minutes after the latest write or reuse.
+ * OpenAI GPT-5.6 and later: the default `prompt_cache_options.ttl: "30m"` keeps the cache eligible at least
+ * 30 minutes after the latest write or reuse.
  */
 export const PROMPT_CACHE_TTL_OPENAI_EXTENDED_SECONDS = 1800;
+/** OpenAI GPT-5.6 and later on the Responses API: `prompt_cache_options.ttl: "12h"`, a 12-hour minimum lifetime. */
+export const PROMPT_CACHE_TTL_OPENAI_LONG_SECONDS = 43_200;
 const NO_PROMPT_CACHE = { kind: "none" };
 const BEST_EFFORT_PROMPT_CACHE = { kind: "best-effort" };
 function ttl(ttlSeconds) {
     return { kind: "ttl", ttlSeconds };
 }
+const OPENAI_LANE_PROMPT_CACHE_LIFETIME = {
+    "chatgpt-subscription": BEST_EFFORT_PROMPT_CACHE,
+    "api-long": ttl(PROMPT_CACHE_TTL_OPENAI_LONG_SECONDS),
+    "api-extended": ttl(PROMPT_CACHE_TTL_OPENAI_EXTENDED_SECONDS),
+    "api-short": ttl(PROMPT_CACHE_TTL_SHORT_SECONDS),
+};
 function hostnameOf(baseUrl) {
     try {
         return new URL(baseUrl).hostname.toLowerCase();
@@ -333,23 +342,6 @@ function resolveOpenAIResponsesCacheRetention(cacheRetention, env) {
 function isDirectDeepSeekModel(model) {
     return model.provider === "deepseek" || hostnameOf(model.baseUrl) === "api.deepseek.com";
 }
-/** GPT-5.6 and later (`gpt-5.6-*`, `gpt-5.10`, `gpt-6-*`, `gpt-7`, ...). */
-const OPENAI_EXTENDED_CACHE_MODEL_ID = /^gpt-(?:5\.(?:[6-9]|\d{2,})|(?:[6-9]|\d{2,})(?:\.\d+)?)(?:-|$)/i;
-/**
- * The OpenAI-operated Responses lanes (OpenAI API, Azure OpenAI, ChatGPT subscription) serving a GPT-5.6+
- * model, where OpenAI documents a cache lifetime of at least 30 minutes. Gateways that merely proxy the same
- * model ids keep the conservative short lifetime because their routing does not carry that contract.
- */
-function hasOpenAIExtendedPromptCache(model) {
-    if (model.api === "openai-responses") {
-        const responsesModel = model;
-        if (responsesModel.compat?.supportsExplicitPromptCacheMode === true)
-            return true;
-        if (responsesModel.provider !== "openai" && hostnameOf(responsesModel.baseUrl) !== "api.openai.com")
-            return false;
-    }
-    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",
@@ -429,9 +421,7 @@ export function resolvePromptCacheLifetime(model, env) {
             const retention = resolveOpenAIResponsesCacheRetention(model.cacheRetention, env);
             if (retention === "none")
                 return NO_PROMPT_CACHE;
-            return hasOpenAIExtendedPromptCache(model)
-                ? ttl(PROMPT_CACHE_TTL_OPENAI_EXTENDED_SECONDS)
-                : ttl(PROMPT_CACHE_TTL_SHORT_SECONDS);
+            return OPENAI_LANE_PROMPT_CACHE_LIFETIME[classifyOpenAIPromptCacheLane(model, retention)];
         }
         default:
             return NO_PROMPT_CACHE;

package/dist/utils/retry-hint.js

@@ -239,7 +239,10 @@ export function parseRetryAfterMsMarker(message) {
 /* ---------- 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.
+// from `nowMs` to the next such moment, or undefined.
+// Zone rule (senpi#5097): a time with no zone reads in the host's local zone, for every caller, as the user's own
+// clock. A reset in another zone is read correctly only when the text names it ("(UTC)", "(Asia/Seoul)"); a
+// zone-less time far from the truth only makes the hint long, and long hints already defer or fail over.
 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) {

package/dist/utils/validation.js

@@ -164,6 +164,84 @@ function normalizeOptionalNulls(value, schema) {
         }
     }
 }
+/** JSON types a schema accepts, or undefined when its shape does not say (const/enum/$ref/allOf). */
+function acceptedJsonTypes(schema) {
+    const types = getSchemaTypes(schema);
+    if (types.length > 0)
+        return new Set(types);
+    const members = schema.anyOf ?? schema.oneOf;
+    if (!Array.isArray(members) || members.length === 0)
+        return undefined;
+    const accepted = new Set();
+    for (const member of members) {
+        const memberTypes = acceptedJsonTypes(member);
+        if (memberTypes === undefined)
+            return undefined;
+        for (const type of memberTypes)
+            accepted.add(type);
+    }
+    return accepted;
+}
+function parseJsonStructure(text, accepted) {
+    const trimmed = text.trim();
+    const wantsArray = accepted.has("array") && trimmed.startsWith("[");
+    const wantsObject = accepted.has("object") && trimmed.startsWith("{");
+    if (!wantsArray && !wantsObject)
+        return undefined;
+    try {
+        const parsed = JSON.parse(trimmed);
+        if (wantsArray && Array.isArray(parsed))
+            return parsed;
+        if (wantsObject && matchesJsonType(parsed, "object"))
+            return parsed;
+    }
+    catch (error) {
+        if (!(error instanceof SyntaxError))
+            throw error;
+    }
+    return undefined;
+}
+/**
+ * Models sometimes send an array or object argument as its JSON text (senpi#6265: the later calls of a
+ * parallel generate_image turn carried `reference_image_paths` as `'["/a.png"]'`). Value.Convert would
+ * wrap that text into a one-element array that passes validation, so the tool ran with the JSON text
+ * as a path. Decode the text back to the structure the schema declares before conversion, only where
+ * the schema rejects strings and the text parses to that declared array/object.
+ */
+function decodeJsonEncodedStructures(value, schema) {
+    if (typeof value === "string") {
+        const accepted = acceptedJsonTypes(schema);
+        if (accepted === undefined || accepted.has("string"))
+            return value;
+        const decoded = parseJsonStructure(value, accepted);
+        return decoded === undefined ? value : decodeJsonEncodedStructures(decoded, schema);
+    }
+    const types = getSchemaTypes(schema);
+    if (Array.isArray(value) && types.includes("array")) {
+        const items = schema.items;
+        for (let index = 0; index < value.length; index++) {
+            const itemSchema = Array.isArray(items) ? items[index] : items;
+            if (itemSchema)
+                value[index] = decodeJsonEncodedStructures(value[index], itemSchema);
+        }
+        return value;
+    }
+    if (matchesJsonType(value, "object") && types.includes("object")) {
+        const record = value;
+        const properties = schema.properties ?? {};
+        const additional = schema.additionalProperties;
+        for (const key of Object.keys(record)) {
+            const propertySchema = Object.hasOwn(properties, key)
+                ? properties[key]
+                : typeof additional === "object"
+                    ? additional
+                    : undefined;
+            if (propertySchema)
+                record[key] = decodeJsonEncodedStructures(record[key], propertySchema);
+        }
+    }
+    return value;
+}
 function getValidator(schema) {
     const key = schema;
     const cached = validatorCache.get(key);
@@ -324,6 +402,7 @@ export function validateToolArguments(tool, toolCall) {
         return args;
     }
     normalizeOptionalNulls(args, tool.parameters);
+    decodeJsonEncodedStructures(args, tool.parameters);
     Value.Convert(tool.parameters, args);
     const validator = getValidator(tool.parameters);
     if (!Object.getOwnPropertySymbols(tool.parameters).includes(TYPEBOX_KIND)) {

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@code-yeongyu/senpi-ai",
-	"version": "2026.11.9",
+	"version": "2026.11.10-1",
 	"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.11.9",
+		"@earendil-works/pi-telemetry": "npm:@code-yeongyu/senpi-telemetry@2026.11.10-1",
 		"@google/genai": "2.23.0",
 		"@smithy/node-http-handler": "4.12.1",
 		"google-auth-library": "10.6.2",

package/dist/utils/fable55-launch.d.ts

@@ -1,21 +0,0 @@
-/**
- * Launch-day edit block. Fable 5.5 is UNRELEASED; these ids are provisional.
- * Confirm identity, optional snapshot and Claude Code floor from live evidence.
- * Prices, context/output limits and status/deprecation come ONLY from models.dev
- * during regeneration, never from a local guessed price card or catalog row.
- * Keep recommendations disabled unless the optional promotion commit is wanted.
- */
-export declare const FABLE55_LAUNCH: {
-    readonly modelId: "claude-fable-5-5";
-    readonly mythosModelId: "claude-mythos-5-5";
-    readonly snapshotId: string | null;
-    readonly minimumClaudeCodeVersion: string | null;
-    readonly released: false;
-    readonly promoteDefaults: false;
-    /** Server-side refusal fallbacks. Fable 5.1 baseline until Anthropic's launch docs name the 5.5 list. */
-    readonly refusalFallbackModels: readonly string[];
-    readonly metadataSource: "models.dev";
-};
-/** Carry the existing Fable/Mythos routing convention, including gateway spellings. */
-export declare function isFable55ModelId(modelId: string): boolean;
-//# sourceMappingURL=fable55-launch.d.ts.map

package/dist/utils/fable55-launch.js

@@ -1,37 +0,0 @@
-/**
- * Launch-day edit block. Fable 5.5 is UNRELEASED; these ids are provisional.
- * Confirm identity, optional snapshot and Claude Code floor from live evidence.
- * Prices, context/output limits and status/deprecation come ONLY from models.dev
- * during regeneration, never from a local guessed price card or catalog row.
- * Keep recommendations disabled unless the optional promotion commit is wanted.
- */
-export const FABLE55_LAUNCH = {
-    modelId: "claude-fable-5-5",
-    mythosModelId: "claude-mythos-5-5",
-    snapshotId: null,
-    minimumClaudeCodeVersion: null,
-    released: false,
-    promoteDefaults: false,
-    /** Server-side refusal fallbacks. Fable 5.1 baseline until Anthropic's launch docs name the 5.5 list. */
-    refusalFallbackModels: ["claude-opus-4-8", "claude-opus-5"],
-    metadataSource: "models.dev",
-};
-/** Carry the existing Fable/Mythos routing convention, including gateway spellings. */
-export function isFable55ModelId(modelId) {
-    const normalized = modelId.toLowerCase().replace(/\s+/g, "-");
-    return [FABLE55_LAUNCH.modelId, FABLE55_LAUNCH.mythosModelId, FABLE55_LAUNCH.snapshotId].some((id) => {
-        if (!id)
-            return false;
-        const family = id.replace(/^claude-/, "");
-        const dotted = family.replace(/-(\d+)-(\d+)$/, "-$1.$2");
-        return [family, dotted].some((marker) => {
-            const at = normalized.indexOf(marker);
-            if (at < 0)
-                return false;
-            const before = normalized[at - 1];
-            const after = normalized[at + marker.length];
-            return (!before || /[/@:._-]/.test(before)) && (!after || /[/@:._-]/.test(after));
-        });
-    });
-}
-//# sourceMappingURL=fable55-launch.js.map