vanspod 0.0.0-stage → 0.1.2

package/dist/clientRoutes.js

@@ -0,0 +1,118 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CLIENT_ROUTE_IDS = void 0;
+exports.supportedClientRouteAdapters = supportedClientRouteAdapters;
+exports.isClientRouteAdapter = isClientRouteAdapter;
+exports.defaultClientRoutes = defaultClientRoutes;
+exports.defaultClientRouteSettings = defaultClientRouteSettings;
+exports.createClientRouteSettingsStorage = createClientRouteSettingsStorage;
+const node_crypto_1 = require("node:crypto");
+const promises_1 = __importDefault(require("node:fs/promises"));
+const node_path_1 = __importDefault(require("node:path"));
+exports.CLIENT_ROUTE_IDS = ["codex", "claudeCode", "vsCodeChat"];
+const SUPPORTED_ADAPTERS = {
+    codex: ["responses", "chat"],
+    claudeCode: ["responses", "chat", "messages"],
+    vsCodeChat: ["responses", "chat"],
+};
+function supportedClientRouteAdapters(route) {
+    return [...SUPPORTED_ADAPTERS[route]];
+}
+function isClientRouteAdapter(route, adapter) {
+    return SUPPORTED_ADAPTERS[route].some(candidate => candidate === adapter);
+}
+function defaultClientRoutes() {
+    return {
+        codex: { id: "codex", mode: "native", adapter: "responses", health: "gray", restart: "ready" },
+        claudeCode: { id: "claudeCode", mode: "native", adapter: "responses", health: "gray", restart: "ready" },
+        vsCodeChat: { id: "vsCodeChat", mode: "native", adapter: "responses", health: "gray", restart: "ready" },
+    };
+}
+function defaultClientRouteSettings() {
+    const routes = defaultClientRoutes();
+    return {
+        codex: { mode: routes.codex.mode, adapter: routes.codex.adapter },
+        claudeCode: { mode: routes.claudeCode.mode, adapter: routes.claudeCode.adapter },
+        vsCodeChat: { mode: routes.vsCodeChat.mode, adapter: routes.vsCodeChat.adapter },
+    };
+}
+function isMode(value) {
+    return value === "native" || value === "classroom";
+}
+function routePreference(route, value) {
+    if (!value || typeof value !== "object" || Array.isArray(value))
+        throw new Error("Client Route 設定格式無效。");
+    const record = value;
+    if (!isMode(record.mode) || typeof record.adapter !== "string" || !isClientRouteAdapter(route, record.adapter)) {
+        throw new Error("Client Route 設定格式無效。");
+    }
+    return { mode: record.mode, adapter: record.adapter };
+}
+function parseClientRouteSettings(value) {
+    if (!value || typeof value !== "object" || Array.isArray(value))
+        throw new Error("Client Route 設定格式無效。");
+    const document = value;
+    if (document.version === 1) {
+        const adapters = document.adapters;
+        if (!adapters || typeof adapters.codex !== "string" || !isClientRouteAdapter("codex", adapters.codex) ||
+            typeof adapters.claude !== "string" || !isClientRouteAdapter("claudeCode", adapters.claude)) {
+            throw new Error("Client Route 設定格式無效。");
+        }
+        return {
+            codex: { mode: "native", adapter: adapters.codex },
+            claudeCode: { mode: "native", adapter: adapters.claude },
+            vsCodeChat: { mode: "native", adapter: "responses" },
+        };
+    }
+    if (document.version !== 2 || !document.routes || typeof document.routes !== "object" || Array.isArray(document.routes)) {
+        throw new Error("Client Route 設定版本無效。");
+    }
+    const routes = document.routes;
+    return {
+        codex: routePreference("codex", routes.codex),
+        claudeCode: routePreference("claudeCode", routes.claudeCode),
+        vsCodeChat: routePreference("vsCodeChat", routes.vsCodeChat),
+    };
+}
+function createClientRouteSettingsStorage(filename) {
+    return {
+        async load() {
+            let raw;
+            try {
+                raw = await promises_1.default.readFile(filename, "utf8");
+            }
+            catch (error) {
+                if (error.code === "ENOENT")
+                    return defaultClientRouteSettings();
+                throw new Error("無法讀取 Client Route 設定。");
+            }
+            let document;
+            try {
+                document = JSON.parse(raw);
+            }
+            catch {
+                throw new Error("無法讀取 Client Route 設定。");
+            }
+            return parseClientRouteSettings(document);
+        },
+        async save(settings) {
+            const value = {
+                codex: routePreference("codex", settings.codex),
+                claudeCode: routePreference("claudeCode", settings.claudeCode),
+                vsCodeChat: routePreference("vsCodeChat", settings.vsCodeChat),
+            };
+            await promises_1.default.mkdir(node_path_1.default.dirname(filename), { recursive: true });
+            const temporary = `${filename}.${(0, node_crypto_1.randomUUID)()}.tmp`;
+            try {
+                await promises_1.default.writeFile(temporary, JSON.stringify({ version: 2, routes: value }) + "\n", "utf8");
+                await promises_1.default.rename(temporary, filename);
+            }
+            finally {
+                await promises_1.default.rm(temporary, { force: true });
+            }
+        },
+    };
+}

package/dist/clientSettingsBackup.js

@@ -0,0 +1,110 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.clientSettingsBackup = clientSettingsBackup;
+exports.optionalText = optionalText;
+const promises_1 = __importDefault(require("node:fs/promises"));
+const node_path_1 = __importDefault(require("node:path"));
+/** One durable journal per client, shared by route, model and cache writes. */
+function clientSettingsBackup(file, resources) {
+    async function load() {
+        const raw = await optionalText(file);
+        if (raw === null)
+            return {};
+        const parsed = JSON.parse(raw);
+        if (!parsed || typeof parsed !== "object" || Array.isArray(parsed))
+            throw new Error("Invalid client settings backup");
+        for (const [id, value] of Object.entries(parsed)) {
+            const entry = value;
+            if (!resources[id] || !entry || (entry.original !== null && typeof entry.original !== "string") || typeof entry.written !== "string" || (entry.previousWritten !== undefined && typeof entry.previousWritten !== "string") || !Array.isArray(entry.keys) || entry.keys.some(key => typeof key !== "string"))
+                throw new Error("Invalid client settings backup");
+        }
+        return parsed;
+    }
+    async function save(journal) {
+        await promises_1.default.mkdir(node_path_1.default.dirname(file), { recursive: true });
+        const temporary = `${file}.tmp`;
+        try {
+            await promises_1.default.writeFile(temporary, JSON.stringify(journal) + "\n", "utf8");
+            await promises_1.default.rename(temporary, file);
+        }
+        finally {
+            await promises_1.default.rm(temporary, { force: true });
+        }
+    }
+    return {
+        async seed(id, original, keys) {
+            const journal = await load();
+            if (journal[id])
+                return;
+            const current = await optionalText(resources[id].file);
+            if (current === null)
+                return;
+            journal[id] = { original, written: current, keys };
+            await save(journal);
+        },
+        async write(id, next, keys, original) {
+            const resource = resources[id];
+            const journal = await load();
+            const current = await optionalText(resource.file);
+            const entry = journal[id] ?? { original: original === undefined ? current : original, written: current ?? "", keys: [] };
+            if (journal[id] && current !== entry.written && current !== entry.previousWritten) {
+                // Preserve intervening edits before a classroom replay takes ownership.
+                if (current === null)
+                    entry.original = null;
+                else {
+                    let baseline = resource.restore(current, entry.original ?? "", entry.written, entry.keys);
+                    if (entry.previousWritten !== undefined)
+                        baseline = resource.restore(baseline, entry.original ?? "", entry.previousWritten, entry.keys);
+                    entry.original = baseline;
+                }
+            }
+            journal[id] = { ...entry, previousWritten: entry.written, written: next, keys: [...new Set([...entry.keys, ...keys])] };
+            // Persist both the baseline and planned write before touching the client.
+            await save(journal);
+            if (next !== current) {
+                await promises_1.default.mkdir(node_path_1.default.dirname(resource.file), { recursive: true });
+                await promises_1.default.writeFile(resource.file, next, "utf8");
+            }
+        },
+        async restore(ids) {
+            const journal = await load();
+            const selected = ids ? new Set(ids) : undefined;
+            for (const [id, entry] of Object.entries(journal)) {
+                if (selected && !selected.has(id))
+                    continue;
+                const resource = resources[id];
+                const current = await optionalText(resource.file);
+                if (current === null)
+                    continue; // An external deletion must stay deleted.
+                const exact = current === entry.written || current === entry.previousWritten;
+                let next = exact ? entry.original : resource.restore(current, entry.original ?? "", entry.written, entry.keys);
+                if (!exact && next !== null && entry.previousWritten !== undefined)
+                    next = resource.restore(next, entry.original ?? "", entry.previousWritten, entry.keys);
+                if (next === null)
+                    await promises_1.default.rm(resource.file, { force: true });
+                else if (next !== current)
+                    await promises_1.default.writeFile(resource.file, next, "utf8");
+            }
+            // Keep every unselected resource and the whole journal on any failed
+            // restoration, so independently detected clients can retry safely.
+            const remaining = Object.fromEntries(Object.entries(journal).filter(([id]) => selected && !selected.has(id)));
+            if (Object.keys(remaining).length)
+                await save(remaining);
+            else
+                await promises_1.default.rm(file, { force: true });
+        },
+    };
+}
+async function optionalText(file) {
+    try {
+        return await promises_1.default.readFile(file, "utf8");
+    }
+    catch (error) {
+        if (error.code === "ENOENT")
+            return null;
+        throw error;
+    }
+}

package/dist/clientTraffic.js

@@ -0,0 +1,26 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createClientTraffic = createClientTraffic;
+// The page asks once a second; a request shorter than that must still be seen.
+const LINGER_MS = 1500;
+function createClientTraffic(now = Date.now) {
+    const inFlight = { codex: 0, claude: 0, vscode: 0 };
+    const lastEndedAt = { codex: -Infinity, claude: -Infinity, vscode: -Infinity };
+    const isFlowing = (client) => inFlight[client] > 0 || now() - lastEndedAt[client] < LINGER_MS;
+    return {
+        begin(client) {
+            inFlight[client] += 1;
+            let done = false;
+            return () => {
+                if (done)
+                    return;
+                done = true;
+                inFlight[client] -= 1;
+                lastEndedAt[client] = now();
+            };
+        },
+        flowing() {
+            return { codex: isFlowing("codex"), claude: isFlowing("claude"), vscode: isFlowing("vscode") };
+        },
+    };
+}

package/dist/clipboard.js

@@ -0,0 +1,32 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.writeClipboard = writeClipboard;
+const node_child_process_1 = require("node:child_process");
+const node_path_1 = __importDefault(require("node:path"));
+// clip.exe starts in ~25ms versus ~700ms for PowerShell, and reads UTF-16LE input without a BOM
+// as Unicode. It normalizes LF to CRLF, which Windows editors and terminals expect anyway.
+const CLIP = node_path_1.default.join(process.env.SystemRoot ?? "C:\\Windows", "System32", "clip.exe");
+function writeClipboard(text) {
+    return new Promise((resolve, reject) => {
+        const child = (0, node_child_process_1.spawn)(CLIP, [], { stdio: ["pipe", "ignore", "pipe"], windowsHide: true });
+        let failed = false;
+        child.on("error", () => {
+            failed = true;
+            reject(new Error("clipboard failed"));
+        });
+        child.stderr.on("data", () => {
+            failed = true;
+        });
+        child.on("close", (code) => {
+            if (!failed && code === 0) {
+                resolve();
+                return;
+            }
+            reject(new Error("clipboard failed"));
+        });
+        child.stdin.end(Buffer.from(text, "utf16le"));
+    });
+}

package/dist/codexWebSearch.js

@@ -0,0 +1,80 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.codexWebSearch = codexWebSearch;
+const types_1 = require("./adapters/types");
+const webSearch_1 = require("./webSearch");
+// Codex's web__run tool posts every command to /alpha/search and reads the reply as
+// codex-api's SearchResponse { encrypted_output, output, results }: `output` is the
+// text handed to the model, `results` only feeds the client's own display.
+// Router's POST /v1/search knows none of this (ADR-0007); the translation lives here.
+// A failure is still a 200: Codex treats a non-2xx reply as fatal to the whole turn
+// (and retries 5xx first), so the model would never get to tell the student why.
+const MAX_QUERIES = 3;
+// These commands have no stand-in at all, so the ban here is wider than NO_SHELL's: one
+// curl to a weather or quote site is not a search, yet it is exactly what must not happen.
+function unsupported(commands) {
+    return `課堂模式沒有這些網路指令。${commands.length ? `These web commands are not supported in this classroom session and were not run: ${commands.join(", ")}.` : "This request named no web command that this classroom session runs."} Searching is done with search_query (searching by query text); its results already include a text snippet of each page. Do not retry the unsupported commands. Do not use shell commands (curl, wget, scripts) to get that information some other way. If that is not enough, tell the user this classroom session cannot do it.`;
+}
+// open, click and find read a page Codex already knows the address of. That is not Web
+// Search (CONTEXT.md): Router is not called, so whether the Class Session allows Web
+// Search is never asked, and the Coding Agent fetches the page itself.
+const READ_COMMANDS = ["open", "click", "find"];
+// What is written back to the model; a longer ref_id is still answered, just not quoted.
+const MAX_URL_LENGTH = 2000;
+/** `afterRefusal`: the reply already carries a refusal this must not be read as part of. */
+function readYourself(commands, names, afterRefusal) {
+    const refs = names.flatMap(name => Array.isArray(commands[name]) ? commands[name] : [])
+        .map(item => item?.ref_id)
+        .filter((ref) => typeof ref === "string");
+    const urls = [...new Set(refs.filter(ref => ref.length <= MAX_URL_LENGTH && /^https?:\/\/\S+$/i.test(ref)))];
+    // The model reads only `output`, where resultsText numbers the results from 1 and
+    // never prints the ref_id (turn0search0 is result [1]) that envelope gives the client.
+    const referenceId = refs.find(ref => /^\w{1,64}$/.test(ref));
+    const resultNumber = /^turn\d+search(\d+)$/.exec(referenceId ?? "");
+    return [`課堂模式沒有開網頁的指令，要讀的網頁請自行讀取。The ${names.join(", ")} command${names.length > 1 ? "s are" : " is"} not run for you in this classroom session.`,
+        ...(afterRefusal ? ["This is separate from the above: reading a page is not a web search, and asking to read a page is not retrying it."] : []),
+        "To read a page, fetch it yourself.",
+        ...(urls.length ? [`Requested: ${urls.join(" ")}`] : []),
+        "Fetch only the page you asked for, once, with a single shell command; keep the readable text rather than the full HTML, and truncate long output.",
+        ...(resultNumber ? [`Reference ids are not kept in this classroom session: ${referenceId} is result [${Number(resultNumber[1]) + 1}] of your latest web search results, so use the URL listed there.`]
+            : referenceId ? [`A reference id such as ${referenceId} is not kept in this classroom session: use the URL of the page itself.`] : []),
+        ...(names.includes("click") ? ["Link numbers are not kept either: for a numbered link, fetch the page, find the link you meant, and then fetch the URL it points to."] : []),
+        ...(names.includes("find") ? ["To find text in a page, fetch the page and search its text for the pattern yourself."] : []),
+        "Do not follow links from a page on your own. To read another page, call open or click again and the same applies to that page."].join(" ");
+}
+function envelope(output, results = []) {
+    return Response.json({ encrypted_output: null, output,
+        results: results.map((result, index) => ({ type: "text_result", ref_id: `turn0search${index}`, url: result.url, title: result.title, snippet: result.text })) });
+}
+function resultsText(queries, results) {
+    if (results.length === 0)
+        return `No web search results were found for: ${queries.join(" | ")}`;
+    return [`Web search results for: ${queries.join(" | ")}`,
+        ...results.map((result, index) => `[${index + 1}] ${result.title}\nURL: ${result.url}\n${result.text}`)].join("\n\n");
+}
+async function codexWebSearch(upstream, baseUrl) {
+    let body;
+    try {
+        body = JSON.parse(upstream.body ?? "");
+    }
+    catch {
+        throw new types_1.AdapterError("請求正文必須是有效 JSON。");
+    }
+    const commands = (0, types_1.object)((0, types_1.object)(body, "request").commands ?? {}, "commands");
+    const queries = (Array.isArray(commands.search_query) ? commands.search_query : [])
+        .map(item => { const q = item?.q; return typeof q === "string" ? q.trim().slice(0, webSearch_1.MAX_QUERY_LENGTH) : ""; })
+        .filter(Boolean).slice(0, MAX_QUERIES);
+    // response_length only shapes a search; every other key is a command Router does not run.
+    const otherCommands = Object.keys(commands).filter(name => name !== "search_query" && name !== "response_length"
+        && commands[name] != null && !(Array.isArray(commands[name]) && commands[name].length === 0));
+    const readCommands = otherCommands.filter(name => READ_COMMANDS.includes(name));
+    const unsupportedCommands = otherCommands.filter(name => !READ_COMMANDS.includes(name));
+    const nothingToRun = queries.length === 0 && readCommands.length === 0;
+    const reply = queries.length ? await (0, webSearch_1.webSearch)(queries, baseUrl, upstream.apiKey ?? "", upstream.signal) : undefined;
+    const failure = reply && "errorCode" in reply ? (0, webSearch_1.explainSearchFailure)(reply.errorCode) : undefined;
+    const refusals = [...(failure ? [failure] : []), ...(unsupportedCommands.length || nothingToRun ? [unsupported(unsupportedCommands)] : [])];
+    // The permission to read a page comes last, after every refusal it is an exception to.
+    const output = [...(reply && "results" in reply ? [resultsText(queries, reply.results)] : []), ...refusals,
+        ...(readCommands.length ? [readYourself(commands, readCommands, refusals.length > 0)] : [])].join("\n\n");
+    return envelope(output, reply && "results" in reply ? reply.results : []);
+}

package/dist/codexWire/apply-patch-envelope.js

@@ -0,0 +1,139 @@
+"use strict";
+// Representation repair for top-level Codex apply_patch custom-tool payloads.
+//
+// Some routed models decorate the first and last lines as
+// `*** Begin Patch ***` / `*** End Patch ***`. Codex rejects those otherwise
+// valid custom-tool payloads. Repair of executable bodies is deliberately limited to
+// unambiguous wrapper mistakes: one recognized alternate field or one complete outer
+// Markdown fence. Ordinary `exec` JavaScript remains byte-identical.
+//
+// This is the same intent boundary as `src/lib/tool-argument-integers.ts`:
+// repair the one faithful reading, leave genuine patch content alone.
+//
+// One accepted exception, added 2026-09-05: a body that is ITSELF one complete
+// operation-bearing envelope, submitted as the `exec` body. That shape is never valid
+// JavaScript — `*** Begin Patch` fails to parse at the leading `**` — so it has zero
+// executable readings and exactly one faithful one. `isCompletePatchEnvelope` recognizes
+// it and the CALLERS retarget it to the apply_patch helper; the repair functions here are
+// unchanged and still return every exec body byte-identical. JavaScript that merely
+// mentions an envelope keeps a real executable reading and is left alone.
+// See devlog/_plan/260905_apply_patch_envelope_gap.
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.freeformFallbackKeys = freeformFallbackKeys;
+exports.unwrapFreeformToolInput = unwrapFreeformToolInput;
+exports.normalizeApplyPatchDelimiters = normalizeApplyPatchDelimiters;
+exports.isCompletePatchEnvelope = isCompletePatchEnvelope;
+exports.mayBecomePatchEnvelope = mayBecomePatchEnvelope;
+exports.repairFreeformToolInput = repairFreeformToolInput;
+const PATCH_BEGIN = "*** Begin Patch";
+const PATCH_END = "*** End Patch";
+const TOP_LEVEL_PATCH_ENVELOPE = /^(\*\*\* Begin Patch(?: \*\*\*)?)(\r?\n)([\s\S]*)(\r?\n)(\*\*\* End Patch(?: \*\*\*)?)(\r?\n)?$/;
+const PATCH_OPERATION_LINE = /^\*\*\* (?:Add|Update|Delete) File: .+$/m;
+const OUTER_MARKDOWN_CODE_FENCE = /^```[^\r\n]*\r?\n([\s\S]*?)\r?\n```$/;
+const FREEFORM_FALLBACK_KEYS = {
+    exec: ["code", "script", "js", "javascript", "command", "cmd", "content"],
+    apply_patch: ["patch", "content"],
+};
+/** The field names a tool's freeform wrapper may unwrap through, besides canonical `input`. */
+function freeformFallbackKeys(toolName) {
+    return FREEFORM_FALLBACK_KEYS[toolName] ?? [];
+}
+function stripMarkdownCodeFence(text, toolName) {
+    if (toolName !== "exec" && toolName !== "apply_patch")
+        return text;
+    const match = OUTER_MARKDOWN_CODE_FENCE.exec(text.trim());
+    return match ? match[1] : text;
+}
+/** Unwrap the `{input:string}` function-call wrapper used for freeform tools. */
+function unwrapFreeformToolInput(argumentsText, toolName = "") {
+    if (typeof argumentsText !== "string")
+        return "";
+    try {
+        const parsed = JSON.parse(argumentsText);
+        if (parsed && typeof parsed === "object" && !Array.isArray(parsed)) {
+            const record = parsed;
+            if (Object.prototype.hasOwnProperty.call(record, "input")) {
+                return typeof record.input === "string"
+                    ? stripMarkdownCodeFence(record.input, toolName)
+                    : argumentsText;
+            }
+            const fallbackKeys = freeformFallbackKeys(toolName);
+            const candidates = fallbackKeys.filter(key => typeof record[key] === "string");
+            if (candidates.length === 1) {
+                return stripMarkdownCodeFence(record[candidates[0]], toolName);
+            }
+        }
+    }
+    catch {
+        // The string is the freeform body, not nested JSON.
+    }
+    return stripMarkdownCodeFence(argumentsText, toolName);
+}
+/**
+ * Strip trailing `***` only from the outer lines of one complete patch.
+ * Internal patch content, incomplete envelopes, and non-patch text are exact
+ * pass-throughs.
+ */
+function normalizeApplyPatchDelimiters(text) {
+    const match = TOP_LEVEL_PATCH_ENVELOPE.exec(text);
+    if (!match)
+        return text;
+    const [, begin, beginBreak, body, endBreak, end, trailingBreak = ""] = match;
+    if (!PATCH_OPERATION_LINE.test(body))
+        return text;
+    if (begin === PATCH_BEGIN && end === PATCH_END)
+        return text;
+    return `${PATCH_BEGIN}${beginBreak}${body}${endBreak}${PATCH_END}${trailingBreak}`;
+}
+/**
+ * True when a body is one COMPLETE top-level patch envelope carrying a real file
+ * operation.
+ *
+ * A code-mode `exec` body is JavaScript, and this shape is never valid JavaScript: a
+ * leading `*** Begin Patch` fails to parse at the `**`. So a body satisfying this
+ * predicate cannot be a program the caller meant to run, which is what makes reading it
+ * as an apply_patch call the one faithful reading rather than a guess.
+ *
+ * Deliberately strict, and reusing the same two checks `normalizeApplyPatchDelimiters`
+ * uses: a second, looser notion of "looks like a patch" is how a repair boundary drifts.
+ * JavaScript that merely CONTAINS an envelope in a string, template, or comment fails the
+ * anchored match and is left alone.
+ */
+function isCompletePatchEnvelope(text) {
+    const match = TOP_LEVEL_PATCH_ENVELOPE.exec(text);
+    if (!match)
+        return false;
+    return PATCH_OPERATION_LINE.test(match[3] ?? "");
+}
+/**
+ * True when a PARTIAL buffer could still grow into a complete patch envelope.
+ *
+ * Streaming decides per delta, before the body is complete, while
+ * `isCompletePatchEnvelope` can only answer once it is. Without this the bridge would
+ * stream raw envelope bytes and then replace them with compiled helper JavaScript at
+ * completion — the rewind that path explicitly refuses to perform.
+ *
+ * Deliberately one-sided: it holds a buffer that MIGHT become an envelope and never
+ * claims one will. A held buffer that turns out to be something else still reaches the
+ * client in the authoritative completed item; only the live preview is skipped.
+ */
+function mayBecomePatchEnvelope(text) {
+    if (text === "")
+        return false;
+    return text.startsWith(PATCH_BEGIN) || PATCH_BEGIN.startsWith(text);
+}
+/**
+ * Repair freeform input before Codex sees it.
+ *
+ * Only a bare or reserved-`functions` tool may receive fallback-field or outer-fence
+ * repair, and only `apply_patch` may receive delimiter repair. Remote namespaces own
+ * their grammar; those bodies and every other freeform input are unwrapped and left
+ * byte-exact.
+ */
+function repairFreeformToolInput(argumentsText, toolName = "", namespace) {
+    const ownsApplyPatchGrammar = namespace === undefined || namespace === "functions";
+    const unwrapped = unwrapFreeformToolInput(argumentsText, ownsApplyPatchGrammar ? toolName : "");
+    return ownsApplyPatchGrammar && toolName === "apply_patch"
+        ? normalizeApplyPatchDelimiters(unwrapped)
+        : unwrapped;
+}

package/dist/codexWire/chat-options.js

@@ -0,0 +1,51 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.codexChatOptions = codexChatOptions;
+const types_1 = require("../adapters/types");
+// Build Chat options by projection, as opposed to validating the whole client
+// envelope. Codex may add private transport fields (such as access_programs);
+// those are not model options and must neither reject the turn nor reach Chat.
+const DIRECT_FIELDS = ["temperature", "top_p", "parallel_tool_calls", "store", "metadata", "user", "stream_options", "prompt_cache_key", "prompt_cache_retention", "safety_identifier", "service_tier", "stop", "presence_penalty", "frequency_penalty"];
+function codexChatOptions(body, responseFormat) {
+    // Explicitly reject known semantic features that this adapter cannot retain.
+    // Content, tool declarations and reasoning have their own strict validation.
+    for (const key of ["prompt", "context_management", "audio", "modalities", "prediction", "max_tool_calls", "logprobs", "top_logprobs"])
+        if (body[key] != null)
+            throw new types_1.AdapterError(`Chat 無法保留 ${key} 的請求語意。`);
+    for (const key of ["previous_response_id", "conversation"])
+        if (body[key] != null)
+            throw new types_1.AdapterError(`Chat 無法恢復 ${key}；請傳送完整 input 歷史。`);
+    if (body.background != null && body.background !== false)
+        throw new types_1.AdapterError("Chat 無法轉換背景執行請求。");
+    if (body.truncation != null && body.truncation !== "disabled")
+        throw new types_1.AdapterError("Chat 無法保留自動截斷 input 的設定。");
+    if (body.include !== undefined)
+        for (const include of (0, types_1.list)(body.include, "include")) {
+            // Chat has no encrypted reasoning to include; this only requests optional
+            // output. Replayed encrypted_content in input is skipped as opaque.
+            if (include !== "reasoning.encrypted_content")
+                throw new types_1.AdapterError(`Chat 無法轉換 include 選項 ${String(include)}。`);
+        }
+    const fields = Object.fromEntries(DIRECT_FIELDS.filter(key => body[key] !== undefined).map(key => [key, body[key]]));
+    if (body.max_output_tokens !== undefined)
+        fields.max_completion_tokens = body.max_output_tokens;
+    if (body.reasoning !== undefined) {
+        const reasoning = (0, types_1.object)(body.reasoning, "reasoning");
+        // Match opencodex's reasoning-config projection: context and future
+        // config extensions are not Chat options. Input reasoning items are
+        // handled separately when the input history is converted.
+        if (reasoning.summary != null && !["auto", "concise", "detailed", "none"].includes(String(reasoning.summary)))
+            throw new types_1.AdapterError("Chat 無法轉換此 reasoning summary 設定。");
+        if (reasoning.effort !== undefined)
+            fields.reasoning_effort = reasoning.effort === "ultra" ? "max" : reasoning.effort;
+    }
+    if (body.text !== undefined) {
+        const text = (0, types_1.object)(body.text, "text");
+        (0, types_1.allowedFields)(text, ["format", "verbosity"], "Chat text");
+        if (text.format !== undefined)
+            fields.response_format = responseFormat(text.format);
+        if (text.verbosity !== undefined)
+            fields.verbosity = text.verbosity;
+    }
+    return fields;
+}

package/dist/codexWire/chat-tools.js

@@ -0,0 +1,80 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.codexChatTools = codexChatTools;
+exports.restoreChatToolEvent = restoreChatToolEvent;
+exports.restoreChatToolResponse = restoreChatToolResponse;
+exports.restoreChatToolStream = restoreChatToolStream;
+const types_1 = require("../adapters/types");
+const request_1 = require("./request");
+/** Chat has flat tool names; keep an explicit mapping back to Codex namespaces. */
+function codexChatTools(raw) {
+    const body = (0, request_1.normalizeCodexRequest)(raw);
+    const identities = new Map();
+    const aliases = new Map();
+    const tools = body.tools === undefined ? [] : (0, types_1.list)(body.tools, "tools");
+    const occupied = new Set(tools.map(value => (0, types_1.object)(value, "tool").name));
+    const flattened = tools.flatMap(value => {
+        const tool = (0, types_1.object)(value, "tool");
+        if (tool.type !== "namespace")
+            return [tool];
+        (0, types_1.allowedFields)(tool, ["type", "name", "description", "tools"], "Chat namespace");
+        const namespace = (0, types_1.string)(tool.name, "namespace");
+        return (0, types_1.list)(tool.tools, "namespace tools").map(value => {
+            const child = (0, types_1.object)(value, "namespace tool");
+            if (child.type !== "function" && child.type !== "custom")
+                throw new types_1.AdapterError("Chat 無法轉換此 namespace 工具。");
+            const name = (0, types_1.string)(child.name, "tool name"), key = JSON.stringify([namespace, name]);
+            if (aliases.has(key))
+                throw new types_1.AdapterError("Chat namespace 工具名稱重複。");
+            let alias = `${namespace}__${name}`;
+            if (alias.length > 64 || !/^[a-zA-Z0-9_-]+$/.test(alias) || occupied.has(alias)) {
+                let index = identities.size;
+                do {
+                    alias = `vanspod_tool_${index++}`;
+                } while (occupied.has(alias));
+            }
+            occupied.add(alias);
+            aliases.set(key, alias);
+            identities.set(alias, { name, namespace });
+            return { ...child, name: alias, description: `${namespace}.${name}${tool.description ? ` (${tool.description})` : ""}${child.description ? `: ${child.description}` : ""}` };
+        });
+    });
+    const translate = (value) => {
+        if (value.namespace === undefined)
+            return value;
+        const alias = aliases.get(JSON.stringify([value.namespace, value.name]));
+        if (!alias)
+            throw new types_1.AdapterError("Chat 無法找到此 namespace 工具的宣告。");
+        const { namespace: _namespace, ...rest } = value;
+        return { ...rest, name: alias };
+    };
+    return {
+        body: { ...body, ...(body.tools !== undefined ? { tools: flattened } : {}),
+            ...(Array.isArray(body.input) ? { input: body.input.map(value => {
+                    const item = (0, types_1.object)(value, "input item");
+                    return item.type === "function_call" || item.type === "custom_tool_call" ? translate(item) : item;
+                }) } : {}),
+            ...(body.tool_choice && typeof body.tool_choice === "object" ? { tool_choice: translate((0, types_1.object)(body.tool_choice, "tool_choice")) } : {}),
+        },
+        restore(item) {
+            if (item.type !== "function_call" && item.type !== "custom_tool_call")
+                return item;
+            const identity = typeof item.name === "string" ? identities.get(item.name) : undefined;
+            return identity ? { ...item, ...identity } : item;
+        },
+    };
+}
+function restoreChatToolEvent(data, restore) {
+    if (data.item)
+        return { ...data, item: restore((0, types_1.object)(data.item, "output item")) };
+    if (data.response)
+        return { ...data, response: restoreChatToolResponse((0, types_1.object)(data.response, "response"), restore) };
+    return data;
+}
+function restoreChatToolResponse(body, restore) {
+    return Array.isArray(body.output) ? { ...body, output: body.output.map(value => restore((0, types_1.object)(value, "output item"))) } : body;
+}
+async function* restoreChatToolStream(source, restore) {
+    for await (const chunk of source)
+        yield chunk.replace(/^data: (.+)$/gm, (line, raw) => raw === "[DONE]" ? line : `data: ${JSON.stringify(restoreChatToolEvent((0, types_1.object)(JSON.parse(raw), "event"), restore))}`);
+}