vanspod 0.0.0-stage → 0.1.2

package/dist/adapters/claude-response.js

@@ -0,0 +1,79 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.responsesToClaude = responsesToClaude;
+exports.chatToClaude = chatToClaude;
+const types_1 = require("./types");
+const claude_reasoning_1 = require("./claude-reasoning");
+const chat_output_1 = require("./chat-output");
+function responsesToClaude(body, model, mode = "off") {
+    if (body.status !== "completed" && body.status !== "incomplete")
+        throw new types_1.AdapterError("Responses 未正常完成。", 502);
+    if (body.status === "incomplete") {
+        const reason = (0, types_1.object)(body.incomplete_details, "incomplete_details").reason;
+        if (reason !== "max_output_tokens")
+            throw new types_1.AdapterError(`Responses 未完成，原因 ${String(reason)} 無法轉換為 Claude stop_reason。`, 502);
+    }
+    const content = [];
+    for (const value of (0, types_1.list)(body.output, "Responses output")) {
+        const item = (0, types_1.object)(value, "output item");
+        if (item.type === "message")
+            for (const raw of (0, types_1.list)(item.content, "message content")) {
+                const part = (0, types_1.object)(raw, "output part");
+                if (part.type !== "output_text" || (Array.isArray(part.annotations) && part.annotations.length))
+                    throw new types_1.AdapterError("Claude 無法轉換此 Responses 輸出內容。", 502);
+                content.push({ type: "text", text: (0, types_1.string)(part.text, "output text") });
+            }
+        else if (item.type === "function_call") {
+            let input;
+            try {
+                input = JSON.parse((0, types_1.string)(item.arguments, "arguments"));
+            }
+            catch {
+                throw new types_1.AdapterError("上游工具參數不是有效 JSON。", 502);
+            }
+            content.push({ type: "tool_use", id: (0, types_1.string)(item.call_id, "call_id"), name: (0, types_1.string)(item.name, "tool name"), input: (0, types_1.object)(input, "tool input") });
+        }
+        else if (item.type === "reasoning") {
+            const reasoning = mode === "off" ? undefined : (0, claude_reasoning_1.responsesReasoning)(item);
+            if (reasoning)
+                content.push((0, claude_reasoning_1.thinkingBlock)(reasoning, mode, model));
+        }
+        else
+            throw new types_1.AdapterError(`Claude 無法保留 Responses 輸出 ${String(item.type)}。`, 502);
+    }
+    const usage = body.usage ? (0, types_1.object)(body.usage, "usage") : {};
+    return { id: body.id ?? "msg_vanspod", type: "message", role: "assistant", model, content,
+        stop_reason: body.status === "incomplete" ? "max_tokens" : content.some(c => c.type === "tool_use") ? "tool_use" : "end_turn",
+        stop_sequence: null, usage: { input_tokens: usage.input_tokens ?? 0, output_tokens: usage.output_tokens ?? 0 } };
+}
+function chatToClaude(body, model, mode = "off") {
+    const choice = (0, types_1.object)((0, types_1.list)(body.choices, "choices")[0], "choice");
+    const message = (0, types_1.object)(choice.message, "Chat message");
+    (0, chat_output_1.validateChatContent)(message, true);
+    const content = [];
+    const reasoning = message.reasoning_content ?? message.reasoning;
+    if (mode !== "off" && typeof reasoning === "string" && reasoning)
+        content.push((0, claude_reasoning_1.thinkingBlock)({ text: reasoning }, mode, model));
+    if (message.content !== null && message.content !== undefined)
+        content.push({ type: "text", text: (0, types_1.string)(message.content, "Chat content") });
+    const tools = new chat_output_1.ChatToolCalls();
+    tools.add(message.tool_calls === undefined ? [] : (0, types_1.list)(message.tool_calls, "tool_calls").map((call, index) => ({ ...(0, types_1.object)(call, "tool call"), index })));
+    const calls = tools.completed();
+    if (choice.finish_reason === "tool_calls" && !calls.length)
+        throw new types_1.AdapterError("上游工具呼叫缺少識別資訊。", 502);
+    for (const value of calls) {
+        const call = (0, types_1.object)(value, "tool call"), fn = (0, types_1.object)(call.function, "tool function");
+        let input;
+        try {
+            input = JSON.parse((0, types_1.string)(fn.arguments, "arguments"));
+        }
+        catch {
+            throw new types_1.AdapterError("上游工具參數不是有效 JSON。", 502);
+        }
+        content.push({ type: "tool_use", id: (0, types_1.string)(call.id, "tool id"), name: (0, types_1.string)(fn.name, "tool name"), input: (0, types_1.object)(input, "tool input") });
+    }
+    const usage = body.usage ? (0, types_1.object)(body.usage, "usage") : {};
+    (0, chat_output_1.chatFinishReason)(choice.finish_reason);
+    return { id: body.id ?? "msg_vanspod", type: "message", role: "assistant", model, content, stop_reason: choice.finish_reason === "length" ? "max_tokens" : choice.finish_reason === "tool_calls" ? "tool_use" : "end_turn",
+        stop_sequence: null, usage: { input_tokens: usage.prompt_tokens ?? 0, output_tokens: usage.completion_tokens ?? 0 } };
+}

package/dist/adapters/index.js

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.modelApiAdapter = modelApiAdapter;
+const responses_1 = require("./responses");
+const chat_1 = require("./chat");
+const messages_1 = require("./messages");
+const types_1 = require("./types");
+const responses = new responses_1.ResponsesAdapter();
+const chat = new chat_1.ChatAdapter();
+const messages = new messages_1.MessagesAdapter();
+function modelApiAdapter(id) {
+    if (id === "responses")
+        return responses;
+    if (id === "chat")
+        return chat;
+    if (id === "messages")
+        return messages;
+    throw new types_1.AdapterError("無效的 model API adapter。");
+}

package/dist/adapters/messages-stream.js

@@ -0,0 +1,126 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MessagesStream = void 0;
+exports.chatToMessagesStream = chatToMessagesStream;
+const node_crypto_1 = require("node:crypto");
+const types_1 = require("./types");
+const stream_1 = require("./stream");
+const claude_reasoning_1 = require("./claude-reasoning");
+const chat_output_1 = require("./chat-output");
+class MessagesStream {
+    model;
+    blocks = new Map();
+    inputTokens = 0;
+    outputTokens = 0;
+    constructor(model) {
+        this.model = model;
+    }
+    start() { return (0, stream_1.event)("message_start", { message: { id: `msg_${(0, node_crypto_1.randomUUID)()}`, type: "message", role: "assistant", model: this.model, content: [], stop_reason: null, stop_sequence: null, usage: { input_tokens: 0, output_tokens: 0 } } }); }
+    usage(input, output) { if (typeof input === "number")
+        this.inputTokens = input; if (typeof output === "number")
+        this.outputTokens = output; }
+    text(key, delta) {
+        let block = this.blocks.get(key), out = "";
+        if (!block) {
+            block = { index: this.blocks.size, kind: "text", value: "", closed: false };
+            this.blocks.set(key, block);
+            out += (0, stream_1.event)("content_block_start", { index: block.index, content_block: { type: "text", text: "" } });
+        }
+        block.value += delta;
+        return out + (0, stream_1.event)("content_block_delta", { index: block.index, delta: { type: "text_delta", text: delta } });
+    }
+    tool(key, id, name) {
+        if (this.blocks.has(key))
+            return "";
+        const block = { index: this.blocks.size, kind: "tool", value: "", closed: false };
+        this.blocks.set(key, block);
+        return (0, stream_1.event)("content_block_start", { index: block.index, content_block: { type: "tool_use", id, name, input: {} } });
+    }
+    // The signature only exists once the upstream has finished the reasoning, so the block is sent whole.
+    thinking(key, reasoning, mode) {
+        if (mode === "off" || this.blocks.has(key))
+            return "";
+        const index = this.blocks.size, block = (0, claude_reasoning_1.thinkingBlock)(reasoning, mode, this.model);
+        this.blocks.set(key, { index, kind: "thinking", value: "", closed: true });
+        return (0, stream_1.event)("content_block_start", { index, content_block: { type: "thinking", thinking: "", signature: "" } })
+            + (block.thinking ? (0, stream_1.event)("content_block_delta", { index, delta: { type: "thinking_delta", thinking: block.thinking } }) : "")
+            + (0, stream_1.event)("content_block_delta", { index, delta: { type: "signature_delta", signature: block.signature } }) + (0, stream_1.event)("content_block_stop", { index });
+    }
+    arguments(key, delta) {
+        const block = this.blocks.get(key);
+        if (!block || block.kind !== "tool")
+            throw new types_1.AdapterError("上游工具串流缺少識別資訊。", 502);
+        block.value += delta;
+        return (0, stream_1.event)("content_block_delta", { index: block.index, delta: { type: "input_json_delta", partial_json: delta } });
+    }
+    reconcile(key, value) {
+        const previous = this.blocks.get(key)?.value ?? "";
+        if (!value.startsWith(previous))
+            throw new types_1.AdapterError("上游完成內容與串流內容不一致。", 502);
+        const rest = value.slice(previous.length);
+        return rest ? this.blocks.get(key)?.kind === "tool" ? this.arguments(key, rest) : this.text(key, rest) : "";
+    }
+    finish(reason) {
+        let out = "";
+        for (const block of this.blocks.values()) {
+            if (block.kind === "tool") {
+                try {
+                    (0, types_1.object)(JSON.parse(block.value || "{}"), "tool input");
+                }
+                catch {
+                    throw new types_1.AdapterError("上游工具參數不是有效 JSON 物件。", 502);
+                }
+            }
+            if (!block.closed) {
+                out += (0, stream_1.event)("content_block_stop", { index: block.index });
+                block.closed = true;
+            }
+        }
+        return out + (0, stream_1.event)("message_delta", { delta: { stop_reason: reason, stop_sequence: null }, usage: { input_tokens: this.inputTokens, output_tokens: this.outputTokens } }) + (0, stream_1.event)("message_stop", {});
+    }
+}
+exports.MessagesStream = MessagesStream;
+async function* chatToMessagesStream(response, model, mode = "off") {
+    const output = new MessagesStream(model);
+    yield output.start();
+    const tools = new chat_output_1.ChatToolCalls();
+    let finish, reasoning = "", thoughts = 0;
+    // Reasoning comes before the answer it led to; it becomes one block when that answer starts.
+    const thought = () => { const text = reasoning; reasoning = ""; return text ? output.thinking(`thinking:${thoughts++}`, { text }, mode) : ""; };
+    for await (const frame of (0, stream_1.frames)(response)) {
+        if (frame.data === "[DONE]")
+            continue;
+        const body = frame.data;
+        if (body.error)
+            throw new types_1.AdapterError("Chat 上游串流回報失敗。", 502);
+        if (body.usage) {
+            const usage = (0, types_1.object)(body.usage, "usage");
+            output.usage(usage.prompt_tokens, usage.completion_tokens);
+        }
+        for (const raw of (body.choices ?? [])) {
+            const choice = (0, types_1.object)(raw, "choice"), delta = (0, types_1.object)(choice.delta ?? {}, "delta");
+            (0, chat_output_1.validateChatContent)(delta, true);
+            const reasoned = delta.reasoning_content ?? delta.reasoning;
+            if (typeof reasoned === "string")
+                reasoning += reasoned;
+            if (typeof delta.content === "string" && delta.content) {
+                yield thought();
+                yield output.text("text", delta.content);
+            }
+            if (delta.tool_calls !== undefined)
+                tools.add(delta.tool_calls);
+            if (choice.finish_reason != null)
+                finish = choice.finish_reason;
+        }
+    }
+    finish = (0, chat_output_1.chatFinishReason)(finish);
+    const calls = tools.completed();
+    if (finish === "tool_calls" && !calls.length)
+        throw new types_1.AdapterError("上游工具呼叫缺少識別資訊。", 502);
+    yield thought();
+    for (const call of calls) {
+        yield output.tool(`tool:${call.index}`, call.id, call.function.name);
+        yield output.arguments(`tool:${call.index}`, call.function.arguments);
+    }
+    yield output.finish(finish === "tool_calls" ? "tool_use" : finish === "length" ? "max_tokens" : "end_turn");
+}

package/dist/adapters/messages.js

@@ -0,0 +1,21 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MessagesAdapter = void 0;
+const types_1 = require("./types");
+const stream_1 = require("./stream");
+const transport_1 = require("./transport");
+const claude_reasoning_1 = require("./claude-reasoning");
+class MessagesAdapter {
+    id = "messages";
+    async send(request) {
+        if (request.client !== "claude")
+            throw new types_1.AdapterError("Messages adapter 僅支援 Claude Code。");
+        const headers = { "Content-Type": "application/json", "anthropic-version": "2023-06-01", Authorization: `Bearer ${request.apiKey}` };
+        for (const name of ["anthropic-version", "anthropic-beta"])
+            if (request.headers?.[name])
+                headers[name] = request.headers[name];
+        const { response, abort } = await (0, transport_1.upstreamRequest)(request, "/v1/messages", { ...(0, claude_reasoning_1.withoutReplayedThinking)(request.body), model: request.model }, headers);
+        return response.ok && request.body.stream === true ? (0, stream_1.streamResponse)((0, stream_1.nativeStream)(response, "messages"), abort) : response;
+    }
+}
+exports.MessagesAdapter = MessagesAdapter;

package/dist/adapters/responses-stream.js

@@ -0,0 +1,70 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.responsesToMessagesStream = responsesToMessagesStream;
+const messages_stream_1 = require("./messages-stream");
+const claude_response_1 = require("./claude-response");
+const types_1 = require("./types");
+const stream_1 = require("./stream");
+const claude_reasoning_1 = require("./claude-reasoning");
+async function* responsesToMessagesStream(response, model, mode = "off") {
+    const output = new messages_stream_1.MessagesStream(model);
+    yield output.start();
+    let terminal;
+    for await (const frame of (0, stream_1.frames)(response)) {
+        if (frame.data === "[DONE]")
+            continue;
+        const body = frame.data, type = String(body.type);
+        if (type === "error" || type === "response.failed")
+            throw new types_1.AdapterError("Responses 上游串流回報失敗。", 502);
+        if (type === "response.output_text.delta")
+            yield output.text(`text:${body.item_id}:${body.content_index ?? 0}`, (0, types_1.string)(body.delta, "text delta"));
+        else if (type === "response.output_item.added") {
+            const item = (0, types_1.object)(body.item, "output item");
+            if (item.type === "function_call") {
+                const key = `tool:${(0, types_1.string)(item.id, "item id")}`;
+                yield output.tool(key, (0, types_1.string)(item.call_id, "call id"), (0, types_1.string)(item.name, "tool name"));
+                if (typeof item.arguments === "string" && item.arguments)
+                    yield output.arguments(key, item.arguments);
+            }
+            else if (item.type !== "message" && item.type !== "reasoning")
+                throw new types_1.AdapterError(`Claude 無法保留 Responses 輸出 ${String(item.type)}。`, 502);
+        }
+        else if (type === "response.output_item.done") {
+            const item = (0, types_1.object)(body.item, "output item"), reasoning = item.type === "reasoning" ? (0, claude_reasoning_1.responsesReasoning)(item) : undefined;
+            if (reasoning)
+                yield output.thinking(`reasoning:${item.id ?? body.output_index}`, reasoning, mode);
+        }
+        else if (type === "response.function_call_arguments.delta")
+            yield output.arguments(`tool:${body.item_id}`, (0, types_1.string)(body.delta, "arguments delta"));
+        else if (type === "response.completed" || type === "response.incomplete")
+            terminal = (0, types_1.object)(body.response, "response");
+        else if (/^response\.(refusal|custom_tool_call)/.test(type))
+            throw new types_1.AdapterError("Claude 無法保留此 Responses 串流內容。", 502);
+    }
+    if (!terminal)
+        throw new types_1.AdapterError("Responses 串流中斷，未收到完成事件。", 502);
+    const message = (0, claude_response_1.responsesToClaude)(terminal, model, mode);
+    for (const [position, value] of (0, types_1.list)(terminal.output, "output").entries()) {
+        const item = (0, types_1.object)(value, "output item");
+        if (item.type === "message") {
+            const parts = (0, types_1.list)(item.content, "content");
+            for (let index = 0; index < parts.length; index++) {
+                const part = (0, types_1.object)(parts[index], "content part");
+                yield output.reconcile(`text:${item.id}:${index}`, (0, types_1.string)(part.text, "output text"));
+            }
+        }
+        else if (item.type === "reasoning") {
+            const reasoning = (0, claude_reasoning_1.responsesReasoning)(item);
+            if (reasoning)
+                yield output.thinking(`reasoning:${item.id ?? position}`, reasoning, mode);
+        }
+        else if (item.type === "function_call") {
+            const key = `tool:${item.id}`;
+            yield output.tool(key, (0, types_1.string)(item.call_id, "call_id"), (0, types_1.string)(item.name, "name"));
+            yield output.reconcile(key, (0, types_1.string)(item.arguments, "arguments"));
+        }
+    }
+    const usage = (0, types_1.object)(message.usage, "usage");
+    output.usage(usage.input_tokens, usage.output_tokens);
+    yield output.finish((0, types_1.string)(message.stop_reason, "stop_reason"));
+}

package/dist/adapters/responses.js

@@ -0,0 +1,28 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ResponsesAdapter = void 0;
+const claude_request_1 = require("./claude-request");
+const claude_reasoning_1 = require("./claude-reasoning");
+const claude_response_1 = require("./claude-response");
+const responses_stream_1 = require("./responses-stream");
+const stream_1 = require("./stream");
+const transport_1 = require("./transport");
+const request_1 = require("../codexWire/request");
+const responses_tools_1 = require("../codexWire/responses-tools");
+class ResponsesAdapter {
+    id = "responses";
+    async send(request) {
+        const normalized = request.client === "codex" ? (0, request_1.normalizeCodexRequest)(request.body) : undefined;
+        const tools = normalized ? new responses_tools_1.CodexResponsesTools(normalized) : undefined;
+        const body = normalized ? { ...(0, request_1.codexResponsesUpstreamBody)(normalized), model: request.model } : (0, claude_request_1.claudeToResponses)(request.body, request.model);
+        const { response, abort } = await (normalized ? transport_1.upstreamRequest : claude_reasoning_1.upstreamRequestWithReplay)(request, "/v1/responses", body);
+        if (!response.ok)
+            return response;
+        if (request.body.stream === true)
+            return (0, stream_1.streamResponse)(request.client === "codex" ? (0, stream_1.nativeStream)(response, "responses", tools?.hasCustomTools ? data => tools.events(data) : undefined) : (0, responses_stream_1.responsesToMessagesStream)(response, request.model, (0, claude_reasoning_1.thinkingMode)(request.body)), abort);
+        if (request.client === "codex")
+            return tools?.hasCustomTools ? (0, transport_1.jsonResponse)(response, body => tools.response(body)) : response;
+        return (0, transport_1.jsonResponse)(response, body => (0, claude_response_1.responsesToClaude)(body, request.model, (0, claude_reasoning_1.thinkingMode)(request.body)));
+    }
+}
+exports.ResponsesAdapter = ResponsesAdapter;

package/dist/adapters/stream.js

@@ -0,0 +1,99 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.event = event;
+exports.frames = frames;
+exports.streamResponse = streamResponse;
+exports.nativeStream = nativeStream;
+const types_1 = require("./types");
+function event(type, body) {
+    return `event: ${type}\ndata: ${JSON.stringify({ type, ...body })}\n\n`;
+}
+async function* frames(response) {
+    if (!response.body)
+        throw new types_1.AdapterError("上游串流沒有正文。", 502);
+    const reader = response.body.getReader(), decoder = new TextDecoder();
+    let buffer = "";
+    try {
+        while (true) {
+            const next = await reader.read();
+            buffer += next.done ? decoder.decode() : decoder.decode(next.value, { stream: true });
+            let match;
+            while ((match = /\r?\n\r?\n/.exec(buffer))) {
+                const raw = buffer.slice(0, match.index + match[0].length);
+                buffer = buffer.slice(raw.length);
+                const data = raw.split(/\r?\n/).filter(line => line.startsWith("data:")).map(line => line.slice(5).trimStart()).join("\n");
+                if (!data)
+                    continue;
+                if (data === "[DONE]")
+                    yield { raw, data };
+                else {
+                    let parsed;
+                    try {
+                        parsed = JSON.parse(data);
+                    }
+                    catch {
+                        throw new types_1.AdapterError("上游 SSE 資料不是有效 JSON。", 502);
+                    }
+                    yield { raw, data: (0, types_1.object)(parsed, "SSE data") };
+                }
+            }
+            if (buffer.length > 1_048_576)
+                throw new types_1.AdapterError("上游 SSE 事件過大。", 502);
+            if (next.done) {
+                if (buffer.trim())
+                    throw new types_1.AdapterError("上游 SSE 事件未完整結束。", 502);
+                break;
+            }
+        }
+    }
+    finally {
+        await reader.cancel().catch(() => { });
+        reader.releaseLock();
+    }
+}
+// Pull-based transformation preserves backpressure; cancellation releases the upstream reader.
+function streamResponse(source, abortUpstream) {
+    const encoder = new TextEncoder();
+    return new Response(new ReadableStream({
+        async pull(controller) {
+            try {
+                const next = await source.next();
+                if (next.done)
+                    controller.close();
+                else
+                    controller.enqueue(encoder.encode(next.value));
+            }
+            catch (error) {
+                abortUpstream();
+                controller.error(error);
+            }
+        },
+        async cancel() { abortUpstream(); await source.return(undefined).catch(() => { }); },
+    }), { headers: { "Content-Type": "text/event-stream; charset=utf-8", "Cache-Control": "no-cache" } });
+}
+async function* nativeStream(response, wire, transform) {
+    let completed = false;
+    let sequence = 0;
+    for await (const frame of frames(response)) {
+        if (frame.data !== "[DONE]") {
+            const type = frame.data.type;
+            if (type === "error" || type === "response.failed")
+                throw new types_1.AdapterError("上游串流回報失敗。", 502);
+            if (wire === "responses" ? type === "response.completed" || type === "response.incomplete" : type === "message_stop")
+                completed = true;
+        }
+        if (transform && frame.data !== "[DONE]") {
+            for (const data of transform(frame.data))
+                yield event(stringEventType(data.type), { ...data, sequence_number: sequence++ });
+        }
+        else
+            yield frame.raw;
+    }
+    if (!completed)
+        throw new types_1.AdapterError("上游串流中斷，未收到完成事件。", 502);
+}
+function stringEventType(type) {
+    if (typeof type !== "string")
+        throw new types_1.AdapterError("上游 SSE 缺少事件類型。", 502);
+    return type;
+}

package/dist/adapters/transport.js

@@ -0,0 +1,26 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.upstreamRequest = upstreamRequest;
+exports.jsonResponse = jsonResponse;
+const types_1 = require("./types");
+async function upstreamRequest(request, path, body, extraHeaders = {}) {
+    const controller = new AbortController();
+    const response = await fetch(`${request.routerBaseUrl.replace(/\/+$/, "")}${path}`, {
+        method: "POST", signal: AbortSignal.any([request.signal, controller.signal]),
+        headers: { ...extraHeaders, "Content-Type": "application/json", Authorization: `Bearer ${request.apiKey}` },
+        body: JSON.stringify(body),
+    });
+    if (response.ok && body.stream === true && !response.headers.get("content-type")?.includes("text/event-stream")) {
+        controller.abort();
+        throw new types_1.AdapterError("上游沒有回傳所要求的 SSE 串流。", 502);
+    }
+    return { response, abort: () => controller.abort() };
+}
+async function jsonResponse(response, convert) {
+    try {
+        return Response.json(convert((0, types_1.object)(await response.json(), "upstream response")));
+    }
+    catch (error) {
+        throw new types_1.AdapterError(error instanceof types_1.AdapterError ? error.message : "上游 JSON 回應格式無效。", 502);
+    }
+}

package/dist/adapters/types.js

@@ -0,0 +1,35 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AdapterError = void 0;
+exports.object = object;
+exports.list = list;
+exports.string = string;
+exports.allowedFields = allowedFields;
+class AdapterError extends Error {
+    status;
+    constructor(message, status = 400) {
+        super(message);
+        this.status = status;
+    }
+}
+exports.AdapterError = AdapterError;
+function object(value, context) {
+    if (!value || typeof value !== "object" || Array.isArray(value))
+        throw new AdapterError(`${context} 必須是物件。`);
+    return value;
+}
+function list(value, context) {
+    if (!Array.isArray(value))
+        throw new AdapterError(`${context} 必須是陣列。`);
+    return value;
+}
+function string(value, context) {
+    if (typeof value !== "string")
+        throw new AdapterError(`${context} 必須是文字。`);
+    return value;
+}
+function allowedFields(value, fields, context) {
+    const unsupported = Object.keys(value).find(key => value[key] !== undefined && !fields.includes(key));
+    if (unsupported)
+        throw new AdapterError(`${context} 無法轉換欄位 ${unsupported}。`);
+}

package/dist/appearance.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.resolveAppearance = resolveAppearance;
+/** 這台電腦選過的外觀蓋過系統。沒選過才跟系統。 */
+function resolveAppearance(stored, systemDark) {
+    if (stored === "light" || stored === "dark") {
+        return stored;
+    }
+    return systemDark ? "dark" : "light";
+}