@hyperdrive.bot/paseo-server 0.2.6

package/dist/server/server/agent/providers/opencode/test-utils/test-opencode-harness.d.ts

@@ -0,0 +1,92 @@
+import type { OpencodeClient } from "@opencode-ai/sdk/v2/client";
+import type { OpenCodeServerAcquisition, OpenCodeServerManagerLike } from "../server-manager.js";
+interface OpenCodeResponse {
+    data?: unknown;
+    error?: unknown;
+}
+export declare class TestOpenCodeHarness implements OpenCodeServerManagerLike {
+    readonly acquisitions: Array<{
+        kind: "current" | "new" | "dedicated";
+        env?: Record<string, string>;
+        releaseCount: number;
+    }>;
+    readonly clientCreations: Array<{
+        baseUrl: string;
+        directory: string;
+    }>;
+    private readonly clients;
+    server: {
+        port: number;
+        url: string;
+    };
+    enqueueClient(client: TestOpenCodeClient): void;
+    acquireCurrent(): Promise<OpenCodeServerAcquisition>;
+    acquireNew(): Promise<OpenCodeServerAcquisition>;
+    acquireDedicated(env: Record<string, string>): Promise<OpenCodeServerAcquisition>;
+    private recordAcquisition;
+    ensureRunning(): Promise<{
+        port: number;
+        url: string;
+    }>;
+    readonly createClient: (options: {
+        baseUrl: string;
+        directory: string;
+    }) => OpencodeClient;
+    shutdown(): Promise<void>;
+}
+export declare class TestOpenCodeClient {
+    readonly calls: {
+        appAgents: unknown[];
+        commandList: unknown[];
+        eventSubscribe: unknown[];
+        experimentalSessionList: unknown[];
+        globalEvent: unknown[];
+        mcpAdd: unknown[];
+        mcpConnect: unknown[];
+        permissionReply: unknown[];
+        providerList: unknown[];
+        questionReject: unknown[];
+        questionReply: unknown[];
+        sessionAbort: unknown[];
+        sessionCommand: unknown[];
+        sessionCreate: unknown[];
+        sessionDelete: unknown[];
+        sessionGet: unknown[];
+        sessionMessages: unknown[];
+        sessionPromptAsync: unknown[];
+        sessionSummarize: unknown[];
+        sessionUpdate: unknown[];
+    };
+    appAgentsResponse: OpenCodeResponse;
+    commandListResponse: OpenCodeResponse;
+    eventStream: AsyncIterable<unknown>;
+    experimentalSessionListResponse: OpenCodeResponse;
+    mcpAddResponse: OpenCodeResponse;
+    mcpConnectResponse: OpenCodeResponse;
+    permissionReplyResponse: OpenCodeResponse;
+    providerListResponse: OpenCodeResponse;
+    providerListImplementation: (() => Promise<OpenCodeResponse>) | null;
+    questionRejectResponse: OpenCodeResponse;
+    questionReplyResponse: OpenCodeResponse;
+    sessionAbortResponse: OpenCodeResponse;
+    sessionCommandError: unknown;
+    sessionCommandEvents: unknown[];
+    sessionCommandResponse: OpenCodeResponse;
+    sessionCreateResponse: OpenCodeResponse;
+    sessionDeleteResponse: OpenCodeResponse;
+    sessionGetResponse: OpenCodeResponse;
+    sessionMessagesResponse: OpenCodeResponse;
+    sessionPromptAsyncEvents: unknown[];
+    sessionPromptAsyncResponse: OpenCodeResponse;
+    sessionSummarizeEvents: unknown[];
+    sessionSummarizeResponse: OpenCodeResponse;
+    sessionUpdateResponse: OpenCodeResponse;
+    private readonly queuedEventStream;
+    constructor();
+    emitEvent(event: unknown): void;
+    asSdkClient(): OpencodeClient;
+}
+export declare function createEventStream(events: unknown[]): AsyncGenerator<unknown>;
+export declare function idleEvent(): unknown;
+export {};
+//# sourceMappingURL=test-opencode-harness.d.ts.map

package/dist/server/server/agent/providers/opencode/test-utils/test-opencode-harness.js

@@ -0,0 +1,268 @@
+export class TestOpenCodeHarness {
+    constructor() {
+        this.acquisitions = [];
+        this.clientCreations = [];
+        this.clients = [];
+        this.server = { port: 1234, url: "http://127.0.0.1:1234" };
+        this.createClient = (options) => {
+            this.clientCreations.push(options);
+            const client = this.clients.shift() ?? new TestOpenCodeClient();
+            return client.asSdkClient();
+        };
+    }
+    enqueueClient(client) {
+        this.clients.push(client);
+    }
+    async acquireCurrent() {
+        return this.recordAcquisition({ kind: "current" });
+    }
+    async acquireNew() {
+        return this.recordAcquisition({ kind: "new" });
+    }
+    async acquireDedicated(env) {
+        return this.recordAcquisition({ kind: "dedicated", env });
+    }
+    recordAcquisition(input) {
+        const acquisition = {
+            kind: input.kind,
+            releaseCount: 0,
+            ...(input.env ? { env: input.env } : {}),
+        };
+        this.acquisitions.push(acquisition);
+        return {
+            server: this.server,
+            release: () => {
+                acquisition.releaseCount += 1;
+            },
+        };
+    }
+    async ensureRunning() {
+        return this.server;
+    }
+    async shutdown() { }
+}
+export class TestOpenCodeClient {
+    constructor() {
+        this.calls = {
+            appAgents: [],
+            commandList: [],
+            eventSubscribe: [],
+            experimentalSessionList: [],
+            globalEvent: [],
+            mcpAdd: [],
+            mcpConnect: [],
+            permissionReply: [],
+            providerList: [],
+            questionReject: [],
+            questionReply: [],
+            sessionAbort: [],
+            sessionCommand: [],
+            sessionCreate: [],
+            sessionDelete: [],
+            sessionGet: [],
+            sessionMessages: [],
+            sessionPromptAsync: [],
+            sessionSummarize: [],
+            sessionUpdate: [],
+        };
+        this.appAgentsResponse = { data: [] };
+        this.commandListResponse = { data: [] };
+        this.experimentalSessionListResponse = { data: [] };
+        this.mcpAddResponse = {};
+        this.mcpConnectResponse = {};
+        this.permissionReplyResponse = {};
+        this.providerListResponse = { data: { connected: [], all: [] } };
+        this.providerListImplementation = null;
+        this.questionRejectResponse = {};
+        this.questionReplyResponse = {};
+        this.sessionAbortResponse = {};
+        this.sessionCommandError = null;
+        this.sessionCommandEvents = [idleEvent()];
+        this.sessionCommandResponse = {};
+        this.sessionCreateResponse = { data: { id: "session-1" } };
+        this.sessionDeleteResponse = {};
+        this.sessionGetResponse = {
+            data: { id: "session-1", directory: "/workspace/repo", title: null },
+        };
+        this.sessionMessagesResponse = { data: [] };
+        this.sessionPromptAsyncEvents = [idleEvent()];
+        this.sessionPromptAsyncResponse = {};
+        this.sessionSummarizeEvents = [idleEvent()];
+        this.sessionSummarizeResponse = { data: {} };
+        this.sessionUpdateResponse = {};
+        this.queuedEventStream = createQueuedEventStream();
+        this.eventStream = this.queuedEventStream.stream;
+    }
+    emitEvent(event) {
+        this.queuedEventStream.emit(event);
+    }
+    asSdkClient() {
+        return {
+            app: {
+                agents: async (parameters) => {
+                    this.calls.appAgents.push(parameters);
+                    return this.appAgentsResponse;
+                },
+            },
+            command: {
+                list: async (parameters) => {
+                    this.calls.commandList.push(parameters);
+                    return this.commandListResponse;
+                },
+            },
+            event: {
+                subscribe: async (parameters, options) => {
+                    this.calls.eventSubscribe.push({ parameters, options });
+                    return { stream: this.eventStream };
+                },
+            },
+            experimental: {
+                session: {
+                    list: async (parameters) => {
+                        this.calls.experimentalSessionList.push(parameters);
+                        return this.experimentalSessionListResponse;
+                    },
+                },
+            },
+            global: {
+                event: async (options) => {
+                    this.calls.globalEvent.push(options);
+                    return { stream: this.eventStream };
+                },
+            },
+            mcp: {
+                add: async (parameters) => {
+                    this.calls.mcpAdd.push(parameters);
+                    return this.mcpAddResponse;
+                },
+                connect: async (parameters) => {
+                    this.calls.mcpConnect.push(parameters);
+                    return this.mcpConnectResponse;
+                },
+            },
+            permission: {
+                reply: async (parameters) => {
+                    this.calls.permissionReply.push(parameters);
+                    return this.permissionReplyResponse;
+                },
+            },
+            provider: {
+                list: async (parameters) => {
+                    this.calls.providerList.push(parameters);
+                    return this.providerListImplementation
+                        ? await this.providerListImplementation()
+                        : this.providerListResponse;
+                },
+            },
+            question: {
+                reject: async (parameters) => {
+                    this.calls.questionReject.push(parameters);
+                    return this.questionRejectResponse;
+                },
+                reply: async (parameters) => {
+                    this.calls.questionReply.push(parameters);
+                    return this.questionReplyResponse;
+                },
+            },
+            session: {
+                // SDK 1.2 moved Session.list out of the experimental namespace into the
+                // top-level Session class. Production code calls client.session.list(...).
+                // Mirror the experimentalSessionListResponse setter so existing tests
+                // that configure it via the legacy field keep working.
+                list: async (parameters) => {
+                    this.calls.experimentalSessionList.push(parameters);
+                    return this.experimentalSessionListResponse;
+                },
+                abort: async (parameters) => {
+                    this.calls.sessionAbort.push(parameters);
+                    return this.sessionAbortResponse;
+                },
+                command: async (parameters) => {
+                    this.calls.sessionCommand.push(parameters);
+                    if (this.sessionCommandError) {
+                        throw this.sessionCommandError;
+                    }
+                    for (const event of this.sessionCommandEvents) {
+                        this.emitEvent(event);
+                    }
+                    return this.sessionCommandResponse;
+                },
+                create: async (parameters) => {
+                    this.calls.sessionCreate.push(parameters);
+                    return this.sessionCreateResponse;
+                },
+                delete: async (parameters) => {
+                    this.calls.sessionDelete.push(parameters);
+                    return this.sessionDeleteResponse;
+                },
+                get: async (parameters) => {
+                    this.calls.sessionGet.push(parameters);
+                    return this.sessionGetResponse;
+                },
+                messages: async (parameters) => {
+                    this.calls.sessionMessages.push(parameters);
+                    return this.sessionMessagesResponse;
+                },
+                promptAsync: async (parameters) => {
+                    this.calls.sessionPromptAsync.push(parameters);
+                    for (const event of this.sessionPromptAsyncEvents) {
+                        this.emitEvent(event);
+                    }
+                    return this.sessionPromptAsyncResponse;
+                },
+                summarize: async (parameters) => {
+                    this.calls.sessionSummarize.push(parameters);
+                    for (const event of this.sessionSummarizeEvents) {
+                        this.emitEvent(event);
+                    }
+                    return this.sessionSummarizeResponse;
+                },
+                update: async (parameters) => {
+                    this.calls.sessionUpdate.push(parameters);
+                    return this.sessionUpdateResponse;
+                },
+            },
+        };
+    }
+}
+export function createEventStream(events) {
+    return (async function* () {
+        for (const event of events) {
+            yield event;
+        }
+    })();
+}
+function createQueuedEventStream() {
+    const queue = [];
+    const waiters = [];
+    return {
+        stream: {
+            [Symbol.asyncIterator]: () => ({
+                next: () => {
+                    const event = queue.shift();
+                    if (event !== undefined) {
+                        return Promise.resolve({ done: false, value: event });
+                    }
+                    return new Promise((resolve) => {
+                        waiters.push(resolve);
+                    });
+                },
+            }),
+        },
+        emit: (event) => {
+            const waiter = waiters.shift();
+            if (waiter) {
+                waiter({ done: false, value: event });
+                return;
+            }
+            queue.push(event);
+        },
+    };
+}
+export function idleEvent() {
+    return {
+        type: "session.idle",
+        properties: { sessionID: "session-1" },
+    };
+}
+//# sourceMappingURL=test-opencode-harness.js.map

package/dist/server/server/agent/providers/opencode/tool-call-detail-parser.d.ts

@@ -0,0 +1,3 @@
+import type { ToolCallDetail } from "../../agent-sdk-types.js";
+export declare function deriveOpencodeToolDetail(toolName: string, input: unknown, output: unknown, error?: unknown): ToolCallDetail;
+//# sourceMappingURL=tool-call-detail-parser.d.ts.map

package/dist/server/server/agent/providers/opencode/tool-call-detail-parser.js

@@ -0,0 +1,256 @@
+import { z } from "zod";
+import { nonEmptyString, truncateDiffText } from "../tool-call-mapper-utils.js";
+import { ToolEditInputSchema, ToolEditOutputSchema, ToolGrepOutputSchema, ToolGlobOutputSchema, ToolReadInputSchema, ToolReadOutputSchema, ToolSearchInputSchema, ToolShellInputSchema, ToolShellOutputSchema, ToolWriteInputSchema, ToolWriteOutputSchema, toEditToolDetail, toReadToolDetail, toSearchToolDetail, toShellToolDetail, toWriteToolDetail, toolDetailBranchByToolName, } from "../tool-call-detail-primitives.js";
+function isRecord(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function normalizeSubAgentText(value) {
+    return nonEmptyString(value)?.trim().replace(/\s+/g, " ");
+}
+function readOutputText(value) {
+    if (typeof value === "string") {
+        return nonEmptyString(value.trim());
+    }
+    if (!isRecord(value)) {
+        return undefined;
+    }
+    const directText = readOutputText(value.output) ??
+        readOutputText(value.text) ??
+        readOutputText(value.content) ??
+        readOutputText(value.result);
+    if (directText) {
+        return directText;
+    }
+    return undefined;
+}
+function parseApplyPatchDirective(line) {
+    const trimmed = line.trim();
+    if (trimmed.startsWith("*** Add File:")) {
+        return { kind: "add", path: trimmed.replace("*** Add File:", "").trim() };
+    }
+    if (trimmed.startsWith("*** Update File:")) {
+        return { kind: "update", path: trimmed.replace("*** Update File:", "").trim() };
+    }
+    if (trimmed.startsWith("*** Delete File:")) {
+        return { kind: "delete", path: trimmed.replace("*** Delete File:", "").trim() };
+    }
+    return null;
+}
+function extractApplyPatchPrimaryFilePath(patchText) {
+    for (const line of patchText.split(/\r?\n/)) {
+        const directive = parseApplyPatchDirective(line);
+        if (directive?.path) {
+            return directive.path;
+        }
+    }
+    return undefined;
+}
+function normalizeDiffHeaderPath(rawPath) {
+    return rawPath.trim().replace(/^["']+|["']+$/g, "");
+}
+function applyPatchToUnifiedDiff(patchText) {
+    const lines = patchText.replace(/\r\n/g, "\n").split("\n");
+    const output = [];
+    let sawDiffContent = false;
+    for (const line of lines) {
+        const directive = parseApplyPatchDirective(line);
+        if (directive) {
+            const filePath = normalizeDiffHeaderPath(directive.path);
+            if (filePath.length > 0) {
+                if (output.length > 0 && output[output.length - 1] !== "") {
+                    output.push("");
+                }
+                const left = directive.kind === "add" ? "/dev/null" : `a/${filePath}`;
+                const right = directive.kind === "delete" ? "/dev/null" : `b/${filePath}`;
+                output.push(`diff --git a/${filePath} b/${filePath}`);
+                output.push(`--- ${left}`);
+                output.push(`+++ ${right}`);
+                sawDiffContent = true;
+            }
+            continue;
+        }
+        const trimmed = line.trim();
+        if (trimmed === "*** Begin Patch" ||
+            trimmed === "*** End Patch" ||
+            trimmed === "*** End of File" ||
+            trimmed.startsWith("*** Move to:")) {
+            continue;
+        }
+        if (line.startsWith("@@") ||
+            line.startsWith("+") ||
+            line.startsWith("-") ||
+            line.startsWith(" ") ||
+            line.startsWith("\")) {
+            output.push(line);
+            sawDiffContent = true;
+        }
+    }
+    if (!sawDiffContent) {
+        return patchText;
+    }
+    const normalized = output.join("\n").trim();
+    return normalized.length > 0 ? normalized : patchText;
+}
+const OpencodeApplyPatchTextInputSchema = z
+    .object({ patchText: z.string() })
+    .passthrough()
+    .transform((value) => {
+    const filePath = extractApplyPatchPrimaryFilePath(value.patchText);
+    return {
+        filePath: filePath ?? "",
+        oldString: undefined,
+        newString: undefined,
+        unifiedDiff: truncateDiffText(applyPatchToUnifiedDiff(value.patchText)),
+    };
+});
+const OpencodeGrepOutputSchema = z
+    .union([
+    ToolGrepOutputSchema,
+    z.string().transform((output) => ({ numFiles: 0, filenames: [], content: output })),
+])
+    .nullable();
+function formatLogEntry(value) {
+    const outputText = readOutputText(value);
+    if (outputText) {
+        return outputText;
+    }
+    if (value === null || value === undefined) {
+        return undefined;
+    }
+    try {
+        return JSON.stringify(value, null, 2);
+    }
+    catch {
+        return String(value);
+    }
+}
+function extractOpenCodeTaskSessionId(value) {
+    const text = readOutputText(value);
+    if (text) {
+        const match = text.match(/\btask_id:\s*(ses_[A-Za-z0-9]+)/i);
+        if (match?.[1]) {
+            return match[1];
+        }
+    }
+    if (!isRecord(value)) {
+        return undefined;
+    }
+    return (normalizeSubAgentText(value.task_id) ??
+        normalizeSubAgentText(value.taskId) ??
+        normalizeSubAgentText(value.sessionID) ??
+        normalizeSubAgentText(value.sessionId) ??
+        extractOpenCodeTaskSessionId(value.output) ??
+        extractOpenCodeTaskSessionId(value.text) ??
+        extractOpenCodeTaskSessionId(value.content) ??
+        extractOpenCodeTaskSessionId(value.result));
+}
+function deriveOpencodeTaskDetail(input, output, error) {
+    if (!isRecord(input)) {
+        return null;
+    }
+    const subAgentType = normalizeSubAgentText(input.subagent_type ?? input.subAgentType);
+    const description = normalizeSubAgentText(input.description);
+    if (!subAgentType && !description) {
+        return null;
+    }
+    const log = [formatLogEntry(output), formatLogEntry(error)].filter((entry) => entry).join("\n");
+    const childSessionId = extractOpenCodeTaskSessionId(output);
+    return {
+        type: "sub_agent",
+        ...(subAgentType ? { subAgentType } : {}),
+        ...(description ? { description } : {}),
+        ...(childSessionId ? { childSessionId } : {}),
+        log,
+        actions: [],
+    };
+}
+const OpencodeEditInputSchema = z.union([
+    z
+        .object({
+        filePath: z.string(),
+        oldString: z.string().optional(),
+        newString: z.string().optional(),
+    })
+        .passthrough()
+        .transform((value) => ({
+        filePath: value.filePath,
+        oldString: nonEmptyString(value.oldString),
+        newString: nonEmptyString(value.newString),
+        unifiedDiff: undefined,
+    })),
+    ToolEditInputSchema,
+]);
+const OpencodeEditOutputSchema = z.union([z.string().transform(() => null), ToolEditOutputSchema]);
+const OpencodeKnownToolDetailSchema = z.union([
+    toolDetailBranchByToolName("shell", ToolShellInputSchema, ToolShellOutputSchema, toShellToolDetail),
+    toolDetailBranchByToolName("bash", ToolShellInputSchema, ToolShellOutputSchema, toShellToolDetail),
+    toolDetailBranchByToolName("exec_command", ToolShellInputSchema, ToolShellOutputSchema, toShellToolDetail),
+    toolDetailBranchByToolName("read", ToolReadInputSchema, z.unknown(), (input, output) => {
+        const parsedOutput = ToolReadOutputSchema.safeParse(output);
+        return toReadToolDetail(input, parsedOutput.success ? parsedOutput.data : null);
+    }),
+    toolDetailBranchByToolName("read_file", ToolReadInputSchema, z.unknown(), (input, output) => {
+        const parsedOutput = ToolReadOutputSchema.safeParse(output);
+        return toReadToolDetail(input, parsedOutput.success ? parsedOutput.data : null);
+    }),
+    toolDetailBranchByToolName("write", ToolWriteInputSchema, ToolWriteOutputSchema, toWriteToolDetail),
+    toolDetailBranchByToolName("write_file", ToolWriteInputSchema, ToolWriteOutputSchema, toWriteToolDetail),
+    toolDetailBranchByToolName("create_file", ToolWriteInputSchema, ToolWriteOutputSchema, toWriteToolDetail),
+    toolDetailBranchByToolName("edit", OpencodeEditInputSchema, OpencodeEditOutputSchema, toEditToolDetail),
+    toolDetailBranchByToolName("apply_patch", OpencodeEditInputSchema, OpencodeEditOutputSchema, toEditToolDetail),
+    toolDetailBranchByToolName("apply_patch", OpencodeApplyPatchTextInputSchema, z.unknown(), (input) => toEditToolDetail(input, null)),
+    toolDetailBranchByToolName("apply_diff", OpencodeEditInputSchema, OpencodeEditOutputSchema, toEditToolDetail),
+    toolDetailBranchByToolName("search", ToolSearchInputSchema, z.unknown(), (input) => toSearchToolDetail({ input, toolName: "search" })),
+    toolDetailBranchByToolName("grep", ToolSearchInputSchema, OpencodeGrepOutputSchema, (input, output) => toSearchToolDetail({ input, output, toolName: "grep" })),
+    toolDetailBranchByToolName("glob", ToolSearchInputSchema, z.unknown(), (input, output) => {
+        const parsedOutput = ToolGlobOutputSchema.safeParse(output);
+        return toSearchToolDetail({
+            input,
+            output: parsedOutput.success ? parsedOutput.data : null,
+            toolName: "glob",
+        });
+    }),
+    toolDetailBranchByToolName("web_search", ToolSearchInputSchema, z.unknown(), (input) => toSearchToolDetail({ input, toolName: "web_search" })),
+    toolDetailBranchByToolName("skill", z.object({ name: z.string() }).passthrough(), z
+        .union([
+        z
+            .object({ output: z.string() })
+            .passthrough()
+            .transform((value) => value.output),
+        z.string(),
+    ])
+        .nullable(), (input, output) => {
+        const skillName = input?.name.trim();
+        if (!skillName) {
+            return undefined;
+        }
+        return {
+            type: "plain_text",
+            label: skillName,
+            icon: "sparkles",
+            ...(output ? { text: output } : {}),
+        };
+    }),
+]);
+export function deriveOpencodeToolDetail(toolName, input, output, error = null) {
+    if (toolName.trim().toLowerCase() === "task") {
+        const taskDetail = deriveOpencodeTaskDetail(input, output, error);
+        if (taskDetail) {
+            return taskDetail;
+        }
+    }
+    const parsed = OpencodeKnownToolDetailSchema.safeParse({
+        toolName,
+        input,
+        output,
+    });
+    if (parsed.success && parsed.data) {
+        return parsed.data;
+    }
+    return {
+        type: "unknown",
+        input: input ?? null,
+        output: output ?? null,
+    };
+}
+//# sourceMappingURL=tool-call-detail-parser.js.map

package/dist/server/server/agent/providers/opencode/tool-call-mapper.d.ts

@@ -0,0 +1,13 @@
+import type { ToolCallTimelineItem } from "../../agent-sdk-types.js";
+interface OpencodeToolCallParams {
+    toolName: string;
+    callId?: string | null;
+    status?: unknown;
+    input?: unknown;
+    output?: unknown;
+    error?: unknown;
+    metadata?: Record<string, unknown>;
+}
+export declare function mapOpencodeToolCall(params: OpencodeToolCallParams): ToolCallTimelineItem | null;
+export {};
+//# sourceMappingURL=tool-call-mapper.d.ts.map

package/dist/server/server/agent/providers/opencode/tool-call-mapper.js

@@ -0,0 +1,53 @@
+import { z } from "zod";
+import { normalizeToolCallStatus } from "../tool-call-mapper-utils.js";
+import { deriveOpencodeToolDetail } from "./tool-call-detail-parser.js";
+const OpencodeRawToolCallSchema = z
+    .object({
+    toolName: z.string().min(1),
+    callId: z.string().optional().nullable(),
+    status: z.unknown().optional(),
+    input: z.unknown().optional(),
+    output: z.unknown().optional(),
+    error: z.unknown().optional(),
+    metadata: z.record(z.string(), z.unknown()).optional(),
+})
+    .passthrough();
+export function mapOpencodeToolCall(params) {
+    const parsed = OpencodeRawToolCallSchema.safeParse(params);
+    if (!parsed.success) {
+        return null;
+    }
+    const raw = parsed.data;
+    const callId = typeof raw.callId === "string" && raw.callId.trim().length > 0 ? raw.callId.trim() : null;
+    if (callId === null) {
+        return null;
+    }
+    const name = raw.toolName.trim();
+    const input = raw.input ?? null;
+    const output = raw.output ?? null;
+    const error = raw.error ?? null;
+    const rawStatus = typeof raw.status === "string" ? raw.status : undefined;
+    const status = normalizeToolCallStatus(rawStatus, error, output);
+    const detail = deriveOpencodeToolDetail(name, input, output, error);
+    if (status === "failed") {
+        return {
+            type: "tool_call",
+            callId,
+            name,
+            status: "failed",
+            detail,
+            error: error ?? { message: "Tool call failed" },
+            ...(raw.metadata ? { metadata: raw.metadata } : {}),
+        };
+    }
+    return {
+        type: "tool_call",
+        callId,
+        name,
+        status,
+        detail,
+        error: null,
+        ...(raw.metadata ? { metadata: raw.metadata } : {}),
+    };
+}
+//# sourceMappingURL=tool-call-mapper.js.map