@yuandc/aica 0.1.0

package/dist/acp/providers/opencode/provider.js

@@ -0,0 +1,489 @@
+import fs from "node:fs";
+import path from "node:path";
+import { eventFromAcpSessionUpdate, statusFromAcpSessionUpdate } from "../../client/acp-events.js";
+import { contextUsageFromAcpSessionUpdate } from "../../client/context-usage.js";
+import { defaultAcpRuntimePool } from "../../client/acp-runtime-pool.js";
+export const openCodeCapabilities = {
+    sessionResume: true,
+    imageInput: true,
+    fileAttachment: true,
+    filesystem: true,
+    terminal: true,
+    permissionRequest: true,
+    configOptions: true,
+    usage: true,
+    contextUsage: true,
+    contextCompaction: false,
+    plan: true,
+    diff: true
+};
+export class OpenCodeProvider {
+    id = "opencode";
+    name = "OpenCode";
+    capabilities = openCodeCapabilities;
+    async createSession(input) {
+        return new OpenCodeSession(input.cwd, input.providerSessionId ?? null, input.timeoutMs);
+    }
+}
+class OpenCodeSession {
+    cwd;
+    providerSessionId;
+    defaultTimeoutMs;
+    lease = null;
+    sessionResponse = null;
+    statusCallback = null;
+    updateCallback = null;
+    permissionCallback = null;
+    userInputCallback = null;
+    canExecuteTools = true;
+    abortHandler = null;
+    statusTimeline = [];
+    updates = [];
+    content = "";
+    latestContextUsage = null;
+    contextWindow = 0;
+    resumedExistingSession = false;
+    constructor(cwd, providerSessionId, defaultTimeoutMs = readOpenCodePromptTimeoutMs()) {
+        this.cwd = cwd;
+        this.providerSessionId = providerSessionId;
+        this.defaultTimeoutMs = defaultTimeoutMs;
+    }
+    async sendPrompt(input) {
+        if (!fs.existsSync(input.cwd) || !fs.statSync(input.cwd).isDirectory()) {
+            throw new Error(`Project root does not exist or is not a directory: ${input.cwd}`);
+        }
+        const startedAt = Date.now();
+        this.statusCallback = input.onStatus ?? null;
+        this.updateCallback = input.onUpdate ?? null;
+        this.permissionCallback = input.onPermissionRequest ?? null;
+        this.userInputCallback = input.onUserInputRequest ?? null;
+        this.canExecuteTools = input.canExecuteTools !== false;
+        this.attachAbortSignal(input.signal);
+        this.content = "";
+        this.updates.length = 0;
+        this.statusTimeline.length = 0;
+        this.latestContextUsage = null;
+        this.contextWindow = positiveNumber(input.contextWindow);
+        let client = null;
+        let started = null;
+        let sessionId = this.providerSessionId;
+        let promptResponse;
+        try {
+            this.emitStatus("initializing", "OpenCode ACP 启动中", "opencode acp");
+            const lease = await this.acquireRuntime(input.cwd);
+            this.lease = lease;
+            client = lease.client;
+            started = lease.started;
+            await this.initialize(lease);
+            sessionId = await this.establishSession(lease, input);
+            await this.applyConfig(client, sessionId, input);
+            this.emitStatus("thinking", "思考中");
+            const prompt = promptBlocksToOpenCodeAcpContent(input.prompt, input.promptBlocks);
+            try {
+                promptResponse = await this.promptWithAbort(client, {
+                    sessionId,
+                    prompt,
+                    timeoutMs: input.timeoutMs ?? this.defaultTimeoutMs,
+                    signal: input.signal
+                });
+            }
+            catch (error) {
+                if (!this.resumedExistingSession || !isInvalidParamsError(error))
+                    throw error;
+                // OpenCode can successfully load a persisted session whose prompt endpoint
+                // is no longer compatible after an upstream/runtime change. Reusing it would
+                // make every queued Chat Room task fail identically. Retry once from a fresh
+                // ACP session; a second failure is surfaced unchanged to the caller.
+                this.appendStderr("OpenCode resumed session rejected session/prompt with Invalid params; creating a fresh session and retrying once.\n");
+                await this.lease?.dispose().catch(() => void 0);
+                this.lease = null;
+                this.providerSessionId = null;
+                this.sessionResponse = null;
+                this.resumedExistingSession = false;
+                this.emitStatus("resuming", "OpenCode 会话已失效，正在新建", "session/prompt invalid params");
+                const freshLease = await this.acquireRuntime(input.cwd);
+                this.lease = freshLease;
+                client = freshLease.client;
+                started = freshLease.started;
+                await this.initialize(freshLease);
+                sessionId = await this.establishSession(freshLease, input);
+                await this.applyConfig(client, sessionId, input);
+                this.emitStatus("thinking", "思考中");
+                promptResponse = await this.promptWithAbort(client, {
+                    sessionId,
+                    prompt,
+                    timeoutMs: input.timeoutMs ?? this.defaultTimeoutMs,
+                    signal: input.signal
+                });
+            }
+        }
+        finally {
+            if (this.abortHandler && input.signal) {
+                input.signal.removeEventListener("abort", this.abortHandler);
+                this.abortHandler = null;
+            }
+            this.releaseLease();
+        }
+        this.emitStatus("completed", "已完成");
+        return {
+            providerSessionId: sessionId,
+            cliType: "builtin",
+            agentType: "opencode",
+            effectiveConfig: {
+                model: openCodeModelValue(input.model) || null,
+                mode: input.mode || null,
+                configOptionValues: input.configOptionValues ?? null,
+                command: started.command,
+                processPid: started.child.pid ?? null,
+                provider: "opencode",
+                protocol: "acp"
+            },
+            command: started.command,
+            args: started.args,
+            cwd: input.cwd,
+            exitCode: started.child.exitCode,
+            signal: started.child.signalCode,
+            durationMs: Date.now() - startedAt,
+            stdout: client.rpc.stdout,
+            stderr: client.rpc.stderr,
+            content: this.content.trim(),
+            updates: [...this.updates],
+            statusTimeline: [...this.statusTimeline],
+            contextUsage: this.latestContextUsage,
+            promptResponse
+        };
+    }
+    async cancel() {
+        if (this.providerSessionId)
+            this.lease?.client.cancel(this.providerSessionId);
+    }
+    async close() {
+        this.statusCallback = null;
+        this.updateCallback = null;
+        this.permissionCallback = null;
+        this.userInputCallback = null;
+        this.canExecuteTools = true;
+        if (this.abortHandler)
+            this.abortHandler = null;
+        this.releaseLease();
+    }
+    async acquireRuntime(cwd) {
+        const command = process.env.ACA_OPENCODE_COMMAND || "opencode";
+        return defaultAcpRuntimePool.acquire({
+            providerId: "opencode",
+            cwd,
+            providerSessionId: this.providerSessionId,
+            command,
+            args: ["acp", "--cwd", cwd],
+            onSessionUpdate: (params) => this.handleSessionUpdate(params),
+            onClientRequest: (method, params) => this.handleClientRequest(method, params)
+        });
+    }
+    async initialize(lease) {
+        if (lease.initialized)
+            return;
+        await lease.client.initialize(60_000);
+        lease.markInitialized();
+    }
+    async establishSession(lease, input) {
+        const client = lease.client;
+        const initialConfig = initialOpenCodeConfig(input);
+        this.resumedExistingSession = false;
+        if (lease.providerSessionId && lease.sessionEstablished) {
+            if (openCodeSessionModelMatches(lease.sessionResponse, input.model)) {
+                this.providerSessionId = lease.providerSessionId;
+                this.sessionResponse = lease.sessionResponse;
+                this.resumedExistingSession = true;
+                return lease.providerSessionId;
+            }
+            this.providerSessionId = null;
+        }
+        else if (this.providerSessionId) {
+            try {
+                this.emitStatus("resuming", "OpenCode 会话恢复中", "session/load");
+                const loaded = await client.loadSession({ sessionId: this.providerSessionId, cwd: input.cwd }, 60_000);
+                this.sessionResponse = objectOrNull(loaded);
+                if (openCodeSessionModelMatches(this.sessionResponse, input.model)) {
+                    const sessionId = sessionIdFromResponse(loaded) || this.providerSessionId;
+                    this.providerSessionId = sessionId;
+                    lease.setProviderSession({ providerSessionId: sessionId, sessionResponse: this.sessionResponse });
+                    this.resumedExistingSession = true;
+                    return sessionId;
+                }
+                this.appendStderr(`OpenCode model changed from ${openCodeCurrentModelId(this.sessionResponse) ?? "unknown"} to ${openCodeModelValue(input.model) || "default"}, creating new session\n`);
+                this.providerSessionId = null;
+            }
+            catch {
+                this.providerSessionId = null;
+            }
+        }
+        this.emitStatus("acp", "OpenCode 会话创建中", "session/new");
+        const created = await client.newSession({ cwd: input.cwd, config: initialConfig }, 120_000);
+        this.sessionResponse = objectOrNull(created);
+        const sessionId = sessionIdFromResponse(created);
+        if (!sessionId)
+            throw new Error("OpenCode ACP session/new did not return sessionId");
+        this.providerSessionId = sessionId;
+        lease.setProviderSession({ providerSessionId: sessionId, sessionResponse: this.sessionResponse });
+        return sessionId;
+    }
+    async applyConfig(client, sessionId, input) {
+        const mode = openCodeModeValue(input.mode);
+        if (mode) {
+            await client.setSessionMode({ sessionId, modeId: mode }, 60_000).catch((error) => {
+                this.appendStderr(`OpenCode mode config failed: ${errorMessage(error)}\n`);
+            });
+        }
+    }
+    handleSessionUpdate(params) {
+        this.updates.push({ method: "session/update", params });
+        this.latestContextUsage = contextUsageFromAcpSessionUpdate(params, this.contextWindow) ?? this.latestContextUsage;
+        const event = eventFromAcpSessionUpdate(params);
+        if (event) {
+            if (event.type === "agent_message_chunk")
+                this.content += event.text ?? "";
+            this.updateCallback?.(event);
+        }
+        const status = statusFromAcpSessionUpdate(params);
+        if (status)
+            this.emitStatus(status.phase, status.label, status.detail, status.updateType);
+    }
+    async handleClientRequest(method, params) {
+        if (!this.canExecuteTools && (method === "fs/read_text_file" || method === "fs/write_text_file")) {
+            throw new Error(`Chat Room role policy disabled tool execution: ${method}`);
+        }
+        switch (method) {
+            case "fs/read_text_file":
+                return this.readTextFile(params);
+            case "fs/write_text_file":
+                return this.writeTextFile(params);
+            case "session/request_permission":
+                return this.requestPermission(params);
+            case "elicitation/create":
+            case "session/request_user_input":
+                return this.requestUserInput(params);
+            default:
+                throw new Error(`Unsupported OpenCode ACP client request: ${method}`);
+        }
+    }
+    readTextFile(params) {
+        const filePath = resolveScopedPath(this.cwd, stringParam(params, "path") || stringParam(params, "filePath"));
+        return { content: fs.readFileSync(filePath, "utf8") };
+    }
+    writeTextFile(params) {
+        const filePath = resolveScopedPath(this.cwd, stringParam(params, "path") || stringParam(params, "filePath"));
+        const content = stringParam(params, "content") ?? stringParam(params, "text") ?? "";
+        fs.mkdirSync(path.dirname(filePath), { recursive: true });
+        fs.writeFileSync(filePath, content, "utf8");
+        return {};
+    }
+    attachAbortSignal(signal) {
+        if (!signal)
+            return;
+        this.abortHandler = () => {
+            void this.cancel();
+        };
+        if (signal.aborted)
+            throw new Error("OpenCode prompt cancelled");
+        signal.addEventListener("abort", this.abortHandler, { once: true });
+    }
+    async promptWithAbort(client, input) {
+        const promptPromise = client.prompt({ sessionId: input.sessionId, prompt: input.prompt }, input.timeoutMs);
+        if (!input.signal)
+            return promptPromise;
+        if (input.signal.aborted) {
+            await this.lease?.dispose().catch(() => void 0);
+            throw new Error("OpenCode prompt cancelled");
+        }
+        let abortHandler = null;
+        const abortPromise = new Promise((_, reject) => {
+            abortHandler = () => {
+                client.cancel(input.sessionId);
+                void this.lease?.dispose().catch(() => void 0);
+                reject(new Error("OpenCode prompt cancelled"));
+            };
+            input.signal?.addEventListener("abort", abortHandler, { once: true });
+        });
+        try {
+            return await Promise.race([promptPromise, abortPromise]);
+        }
+        finally {
+            if (abortHandler)
+                input.signal.removeEventListener("abort", abortHandler);
+        }
+    }
+    async requestPermission(params) {
+        if (!this.permissionCallback)
+            return { outcome: { outcome: "cancelled" } };
+        const record = objectOrNull(params) ?? {};
+        const request = objectOrNull(record.request) ?? record;
+        const rawOptions = Array.isArray(request.options) ? request.options : [];
+        const options = rawOptions.map((option, index) => {
+            const item = objectOrNull(option) ?? {};
+            return {
+                optionId: String(item.optionId ?? item.id ?? index),
+                kind: String(item.kind ?? item.outcome ?? "choice"),
+                ...(typeof item.label === "string" ? { label: item.label } : {})
+            };
+        });
+        this.emitStatus("requestPermission", "等待授权", permissionRequestDetail(request), "session/request_permission");
+        return this.permissionCallback({
+            requestId: String(request.requestId ?? request.id ?? `opencode-permission-${Date.now()}`),
+            params,
+            options
+        });
+    }
+    async requestUserInput(params) {
+        if (!this.userInputCallback)
+            return { outcome: { outcome: "cancelled" } };
+        const record = objectOrNull(params) ?? {};
+        const request = objectOrNull(record.request) ?? record;
+        this.emitStatus("requestPermission", "等待输入", userInputRequestDetail(request), "elicitation/create");
+        return this.userInputCallback({
+            requestId: String(request.requestId ?? request.id ?? `opencode-input-${Date.now()}`),
+            prompt: String(request.prompt ?? request.message ?? request.question ?? ""),
+            params,
+            ...(typeof request.defaultValue === "string" ? { defaultValue: request.defaultValue } : {})
+        });
+    }
+    emitStatus(phase, label, detail, updateType) {
+        const status = {
+            phase,
+            label,
+            ...(detail ? { detail } : {}),
+            ...(updateType ? { updateType } : {}),
+            atMs: Date.now()
+        };
+        const last = this.statusTimeline[this.statusTimeline.length - 1];
+        if (last && last.phase === status.phase && last.label === status.label && last.detail === status.detail && last.updateType === status.updateType)
+            return;
+        this.statusTimeline.push(status);
+        this.statusCallback?.(status);
+    }
+    appendStderr(value) {
+        const client = this.lease?.client;
+        if (client)
+            client.rpc.stderr += value;
+    }
+    releaseLease() {
+        this.lease?.release();
+        this.lease = null;
+    }
+}
+function sessionIdFromResponse(value) {
+    const record = objectOrNull(value);
+    const sessionId = record?.sessionId;
+    return typeof sessionId === "string" && sessionId.trim() ? sessionId.trim() : null;
+}
+function objectOrNull(value) {
+    return value && typeof value === "object" && !Array.isArray(value) ? value : null;
+}
+function positiveNumber(value) {
+    return typeof value === "number" && Number.isFinite(value) && value > 0 ? value : 0;
+}
+function initialOpenCodeConfig(input) {
+    const model = openCodeModelValue(input.model);
+    const mode = openCodeModeValue(input.mode);
+    return {
+        ...openCodeExtraConfig(input.configOptionValues),
+        ...(model ? { model } : {}),
+        ...(mode ? { mode } : {})
+    };
+}
+function openCodeExtraConfig(values) {
+    const result = {};
+    for (const [key, value] of Object.entries(values ?? {})) {
+        if (["model", "mode", "reasoning_effort", "effort", "variant"].includes(key))
+            continue;
+        result[key] = value;
+    }
+    return result;
+}
+function openCodeSessionModelMatches(response, requestedModel) {
+    const model = openCodeModelValue(requestedModel);
+    if (!model)
+        return true;
+    const currentModel = openCodeCurrentModelId(response);
+    return !currentModel || currentModel === model;
+}
+function openCodeCurrentModelId(response) {
+    const models = objectOrNull(response?.models);
+    const value = models?.currentModelId;
+    return typeof value === "string" && value.trim() ? value.trim() : null;
+}
+function openCodeModeValue(mode) {
+    const normalized = String(mode || "").trim();
+    if (!normalized)
+        return null;
+    if (["agent-full-access", "full-access", "bypassPermissions", "danger-full-access"].includes(normalized))
+        return "build";
+    if (normalized === "read-only")
+        return "plan";
+    return normalized;
+}
+function stringParam(params, key) {
+    const record = objectOrNull(params);
+    const value = record?.[key];
+    return typeof value === "string" && value.trim() ? value : null;
+}
+function resolveScopedPath(root, filePath) {
+    if (!filePath)
+        throw new Error("ACP file request did not include a path");
+    const resolved = path.resolve(root, filePath);
+    const rootResolved = path.resolve(root);
+    if (resolved !== rootResolved && !resolved.startsWith(`${rootResolved}${path.sep}`)) {
+        throw new Error(`ACP file request is outside project root: ${filePath}`);
+    }
+    return resolved;
+}
+function permissionRequestDetail(request) {
+    const params = objectOrNull(request.params) ?? request;
+    for (const key of ["command", "cwd", "reason", "grantRoot", "method"]) {
+        const value = params[key];
+        if (typeof value === "string" && value.trim())
+            return textPreview(value);
+    }
+    return undefined;
+}
+function userInputRequestDetail(request) {
+    for (const key of ["prompt", "message", "question", "title"]) {
+        const value = request[key];
+        if (typeof value === "string" && value.trim())
+            return textPreview(value);
+    }
+    return undefined;
+}
+function textPreview(value) {
+    const normalized = value.replace(/\s+/g, " ").trim();
+    return normalized.length > 120 ? `${normalized.slice(0, 117)}...` : normalized;
+}
+function errorMessage(error) {
+    return error instanceof Error ? error.message : String(error);
+}
+function isInvalidParamsError(error) {
+    return /\binvalid params\b/i.test(errorMessage(error));
+}
+/**
+ * OpenCode ACP 对图片仅接受标准 base64 data，不兼容本地 uri 参数。
+ * 本地附件路径仍会通过 Job Worker 拼入文本提示，供角色使用工具读取。
+ */
+function promptBlocksToOpenCodeAcpContent(prompt, blocks) {
+    const inputBlocks = blocks?.length ? blocks : [{ type: "text", text: prompt }];
+    return inputBlocks.map((block) => {
+        if (block.type === "image") {
+            return { type: "image", data: block.data, mimeType: block.mimeType };
+        }
+        return { type: "text", text: block.text };
+    });
+}
+function readOpenCodeDefaultModel() {
+    return process.env.ACA_OPENCODE_DEFAULT_MODEL || "";
+}
+function openCodeModelValue(model) {
+    const normalized = String(model || readOpenCodeDefaultModel()).trim();
+    return normalized === "default" || normalized === "opencode-default" ? "" : normalized;
+}
+function readOpenCodePromptTimeoutMs() {
+    const parsed = Number.parseInt(process.env.ACA_OPENCODE_PROMPT_TIMEOUT_MS ?? process.env.ACA_ACP_PROMPT_TIMEOUT_MS ?? "", 10);
+    return Number.isInteger(parsed) && parsed >= 30_000 ? parsed : 6 * 60 * 60 * 1000;
+}

package/dist/acp/providers/registry.js

@@ -0,0 +1,23 @@
+import { NativeCodexProvider } from "./codex/provider.js";
+import { CodexAcpProvider } from "./codex-acp/provider.js";
+import { MimoCodeProvider } from "./mimo/provider.js";
+import { OpenCodeProvider } from "./opencode/provider.js";
+export function createAgentProvider(input) {
+    const agentType = normalizeProviderKey(input.agentType || "codex");
+    const cliType = normalizeProviderKey(input.cliType || "builtin");
+    if (cliType !== "builtin") {
+        throw new Error(`Unsupported ACP cliType: ${input.cliType ?? ""}`);
+    }
+    if (agentType === "codex" || agentType === "codexacp" || agentType === "codexstandard")
+        return new CodexAcpProvider();
+    if (agentType === "nativecodex" || agentType === "codexnative")
+        return new NativeCodexProvider();
+    if (agentType === "mimo" || agentType === "mimocode" || agentType === "mimocodeprovider")
+        return new MimoCodeProvider();
+    if (agentType === "opencode" || agentType === "opencodeprovider")
+        return new OpenCodeProvider();
+    throw new Error(`Unsupported ACP agentType: ${input.agentType ?? ""}`);
+}
+function normalizeProviderKey(value) {
+    return value.toLowerCase().replace(/[^a-z0-9]+/g, "");
+}

package/dist/acp/standard-events.js

@@ -0,0 +1,167 @@
+export const STANDARD_AGENT_EVENT_TYPES = new Set([
+    "agent_message_chunk",
+    "agent_progress_chunk",
+    "agent_thought_chunk",
+    "tool_call",
+    "tool_call_update",
+    "plan",
+    "plan_update",
+    "plan_removed",
+    "usage_update",
+    "session_info_update",
+    "available_commands_update",
+    "current_mode_update",
+    "config_option_update"
+]);
+export function createAgentMessageChunk(input) {
+    return createTextEvent("agent_message_chunk", "message", input);
+}
+export function createAgentProgressChunk(input) {
+    return createTextEvent("agent_progress_chunk", "progress", input);
+}
+export function createAgentThoughtChunk(input) {
+    return createTextEvent("agent_thought_chunk", "thought", input);
+}
+export function createToolCall(input) {
+    return createToolEvent({ ...input, sessionUpdate: "tool_call", status: input.status || "in_progress" });
+}
+export function createToolCallUpdate(input) {
+    return createToolEvent({ ...input, sessionUpdate: "tool_call_update" });
+}
+export function normalizeToolKind(value) {
+    const normalized = String(value || "").toLowerCase().replace(/[^a-z0-9]+/g, "_");
+    if (["read", "view", "open", "list", "ls", "glob"].some((item) => normalized.includes(item)))
+        return "read";
+    if (["edit", "write", "patch", "update", "create"].some((item) => normalized.includes(item)))
+        return "edit";
+    if (normalized.includes("delete") || normalized.includes("remove"))
+        return "delete";
+    if (normalized.includes("move") || normalized.includes("rename"))
+        return "move";
+    if (["search", "grep", "find", "ripgrep", "rg"].some((item) => normalized.includes(item)))
+        return "search";
+    if (["bash", "shell", "execute", "exec", "terminal", "command", "run"].some((item) => normalized.includes(item)))
+        return "execute";
+    if (normalized.includes("think") || normalized.includes("reason"))
+        return "think";
+    if (["fetch", "web", "http", "url"].some((item) => normalized.includes(item)))
+        return "fetch";
+    if (normalized.includes("switch_mode") || normalized.includes("switchmode"))
+        return "switch_mode";
+    return "other";
+}
+export function normalizeToolStatus(value) {
+    const normalized = String(value || "").toLowerCase().replace(/[^a-z0-9]+/g, "_");
+    if (["pending", "queued"].includes(normalized))
+        return "pending";
+    if (["running", "started", "in_progress", "inprogress", "working"].includes(normalized))
+        return "in_progress";
+    if (["error", "failed", "failure"].includes(normalized))
+        return "failed";
+    if (["cancelled", "canceled"].includes(normalized))
+        return "cancelled";
+    return "completed";
+}
+export function createTextChunkUpdate(sessionUpdate, text) {
+    return {
+        sessionUpdate,
+        content: {
+            type: "text",
+            text
+        }
+    };
+}
+export function assertStandardAgentEvent(event) {
+    if (!STANDARD_AGENT_EVENT_TYPES.has(event.type)) {
+        throw new Error(`Provider 输出了非标准事件类型: ${event.type}`);
+    }
+    const update = standardUpdateRecord(event);
+    if (event.type === "agent_message_chunk" || event.type === "agent_progress_chunk" || event.type === "agent_thought_chunk") {
+        if (update.sessionUpdate !== event.type)
+            throw new Error(`${event.type} 缺少匹配的 raw.update.sessionUpdate`);
+        return;
+    }
+    if (event.type === "tool_call" || event.type === "tool_call_update") {
+        if (update.sessionUpdate !== event.type)
+            throw new Error(`${event.type} 缺少匹配的 raw.update.sessionUpdate`);
+        assertNonEmptyString(update.toolCallId, `${event.type}.raw.update.toolCallId`);
+        assertNonEmptyString(update.kind, `${event.type}.raw.update.kind`);
+        assertNonEmptyString(update.status, `${event.type}.raw.update.status`);
+    }
+}
+export function standardUpdateRecord(event) {
+    const raw = event.raw;
+    if (!raw || typeof raw !== "object" || Array.isArray(raw))
+        throw new Error(`${event.type} 缺少 raw 对象`);
+    const update = raw.update;
+    if (!update || typeof update !== "object" || Array.isArray(update))
+        throw new Error(`${event.type} 缺少 raw.update 对象`);
+    return update;
+}
+export function firstString(...values) {
+    for (const value of values) {
+        if (typeof value === "string" && value.trim())
+            return value.trim();
+    }
+    return undefined;
+}
+export function removeUndefined(value) {
+    for (const key of Object.keys(value)) {
+        if (value[key] === undefined)
+            delete value[key];
+    }
+    return value;
+}
+function createTextEvent(type, label, input) {
+    return {
+        type,
+        label,
+        ...(input.text ? { text: input.text } : {}),
+        raw: {
+            method: input.method,
+            params: input.params,
+            update: createTextChunkUpdate(type, input.text)
+        },
+        atMs: input.atMs ?? Date.now()
+    };
+}
+function createToolEvent(input) {
+    const sessionUpdate = input.sessionUpdate ?? "tool_call_update";
+    const kind = normalizeToolKind(input.kind);
+    const status = normalizeToolStatus(input.status);
+    const update = removeUndefined({
+        sessionUpdate,
+        toolCallId: input.toolCallId,
+        kind,
+        title: input.title,
+        status,
+        rawInput: input.rawInput,
+        rawOutput: input.rawOutput,
+        content: input.content,
+        locations: input.locations,
+        _meta: input.meta
+    });
+    return {
+        type: sessionUpdate,
+        label: sessionUpdate === "tool_call" ? "tool call" : "tool update",
+        status,
+        toolCallId: input.toolCallId,
+        raw: {
+            method: input.method,
+            params: input.params,
+            tool: removeUndefined({
+                id: input.toolCallId,
+                kind,
+                title: input.title,
+                rawInput: input.rawInput,
+                rawOutput: input.rawOutput
+            }),
+            update
+        },
+        atMs: input.atMs ?? Date.now()
+    };
+}
+function assertNonEmptyString(value, field) {
+    if (typeof value !== "string" || !value.trim())
+        throw new Error(`Provider 标准事件字段无效: ${field}`);
+}