@camerontaylor/paseo-server 0.8.0-fork.1

package/dist/server/server/agent/providers/opencode/side-question.js

@@ -0,0 +1,172 @@
+import { withTimeout } from "../../../../utils/promise-timeout.js";
+import { toDiagnosticErrorMessage } from "../diagnostic-utils.js";
+const SIDE_QUESTION_POLL_INTERVAL_MS = 25;
+// Backstop for callers that pass no signal. The manager races its own 30s timeout and aborts,
+// so this only has to stop the poll from outliving the daemon.
+const SIDE_QUESTION_WAIT_TIMEOUT_MS = 60000;
+// The fork is persisted on disk, so cleanup must not be skipped on abort -- only bounded.
+const SIDE_QUESTION_CLEANUP_TIMEOUT_MS = 5000;
+const SIDE_QUESTION_TIMED_OUT = { status: "timed_out", threading: "threaded" };
+const SIDE_QUESTION_TOOLS = {
+    "*": false,
+    bash: false,
+    edit: false,
+    write: false,
+    patch: false,
+    read: false,
+    grep: false,
+    glob: false,
+    list: false,
+    task: false,
+    todowrite: false,
+    todoread: false,
+    webfetch: false,
+    websearch: false,
+    codesearch: false,
+    skill: false,
+    question: false,
+};
+function formatSideQuestion(question, history) {
+    if (history.length === 0)
+        return question;
+    const prior = history
+        .map((exchange, index) => `Earlier side exchange ${index + 1}:\nQuestion: ${exchange.question}\nAnswer: ${exchange.answer}`)
+        .join("\n\n");
+    return `${prior}\n\nCurrent side question:\n${question}`;
+}
+function readAnswer(messages, parentMessageId) {
+    const message = messages.find((candidate) => candidate.info.role === "assistant" &&
+        "parentID" in candidate.info &&
+        candidate.info.parentID === parentMessageId);
+    if (!message || message.info.time.completed === undefined)
+        return null;
+    if (message.info.error) {
+        return {
+            status: "failed",
+            error: toDiagnosticErrorMessage(message.info.error),
+            threading: "threaded",
+        };
+    }
+    const textParts = message.parts.filter((part) => part.type === "text" && !part.ignored);
+    const content = textParts
+        .map((part) => part.text)
+        .join("")
+        .trim();
+    if (!content) {
+        return {
+            status: "failed",
+            error: "OpenCode completed the side question without an answer",
+            threading: "threaded",
+        };
+    }
+    return {
+        status: "answered",
+        content,
+        synthetic: textParts.every((part) => part.synthetic === true),
+        threading: "threaded",
+    };
+}
+/** Sleeps until the delay elapses or the signal aborts, without leaving a timer pending. */
+function waitForNextPoll(delayMs, signal) {
+    if (signal?.aborted)
+        return Promise.resolve();
+    let timer;
+    let onAbort;
+    return new Promise((resolve) => {
+        timer = setTimeout(resolve, delayMs);
+        timer.unref();
+        if (!signal)
+            return;
+        onAbort = () => resolve();
+        signal.addEventListener("abort", onAbort, { once: true });
+    }).finally(() => {
+        if (timer)
+            clearTimeout(timer);
+        if (onAbort)
+            signal?.removeEventListener("abort", onAbort);
+    });
+}
+async function waitForAnswer(input) {
+    const deadline = Date.now() + (input.timeoutMs ?? SIDE_QUESTION_WAIT_TIMEOUT_MS);
+    for (;;) {
+        // Checked before the request too: each poll refetches the whole forked conversation, so a
+        // doomed poll should not start. The signal passed below cancels one already in flight.
+        if (input.signal?.aborted || Date.now() >= deadline)
+            return SIDE_QUESTION_TIMED_OUT;
+        const response = await input.client.session.messages({
+            sessionID: input.sessionId,
+            directory: input.cwd,
+        }, input.signal ? { signal: input.signal } : undefined);
+        if (response.error) {
+            // An aborted refetch is the caller calling the question off, so it settles the same
+            // way the loop-top check does -- not as a failed answer with the SDK's AbortError.
+            if (input.signal?.aborted)
+                return SIDE_QUESTION_TIMED_OUT;
+            throw new Error(toDiagnosticErrorMessage(response.error));
+        }
+        const answer = readAnswer(response.data ?? [], input.messageId);
+        if (answer)
+            return answer;
+        const remainingMs = deadline - Date.now();
+        if (remainingMs <= 0)
+            return SIDE_QUESTION_TIMED_OUT;
+        await waitForNextPoll(Math.min(SIDE_QUESTION_POLL_INTERVAL_MS, remainingMs), input.signal);
+    }
+}
+export async function askOpenCodeSideQuestion(input) {
+    const forkResponse = await input.client.session.fork({
+        sessionID: input.parentSessionId,
+        directory: input.cwd,
+    });
+    if (forkResponse.error || !forkResponse.data?.id) {
+        throw new Error(toDiagnosticErrorMessage(forkResponse.error ?? "missing fork session id"));
+    }
+    const forkSessionId = forkResponse.data.id;
+    input.onForkCreated?.(forkSessionId);
+    input.logger.debug({ forkSessionId, parentSessionId: input.parentSessionId }, "Created persisted OpenCode side-question fork; daemon exit before cleanup may leave it behind");
+    try {
+        const promptResponse = await input.client.session.promptAsync({
+            sessionID: forkSessionId,
+            directory: input.cwd,
+            messageID: input.messageId,
+            parts: [{ type: "text", text: formatSideQuestion(input.question, input.history) }],
+            tools: SIDE_QUESTION_TOOLS,
+            system: "Answer the user's side question directly. Do not call or request any tools. Treat earlier side exchanges as context only.",
+            ...(input.model ? { model: input.model } : {}),
+            ...(input.agent ? { agent: input.agent } : {}),
+            ...(input.variant ? { variant: input.variant } : {}),
+        });
+        if (promptResponse.error)
+            throw new Error(toDiagnosticErrorMessage(promptResponse.error));
+        return await waitForAnswer({
+            client: input.client,
+            sessionId: forkSessionId,
+            cwd: input.cwd,
+            messageId: input.messageId,
+            signal: input.signal,
+            timeoutMs: input.timeoutMs,
+        });
+    }
+    finally {
+        let cleanupError;
+        try {
+            // Deliberately not gated on input.signal: an aborted wait still has a fork to delete.
+            const deleteResponse = await withTimeout(input.client.session.delete({ sessionID: forkSessionId, directory: input.cwd }), SIDE_QUESTION_CLEANUP_TIMEOUT_MS, "Timed out deleting OpenCode side-question fork");
+            cleanupError = deleteResponse.error;
+        }
+        catch (error) {
+            cleanupError = error;
+        }
+        // Released after the delete: events for the fork can still arrive while it is being torn
+        // down, and they must stay off the parent's track too.
+        input.onForkReleased?.(forkSessionId);
+        if (cleanupError !== undefined) {
+            input.logger.warn({
+                err: cleanupError,
+                leakedSessionId: forkSessionId,
+                parentSessionId: input.parentSessionId,
+            }, "Failed to delete persisted OpenCode side-question fork");
+        }
+    }
+}
+//# sourceMappingURL=side-question.js.map

package/dist/server/server/agent/providers/opencode/subagent-presentation.d.ts

@@ -0,0 +1,36 @@
+export interface OpenCodeSubagentPresentationFacts {
+    /** OpenCode agent name running the child, e.g. "general", "explore". */
+    agentName?: string;
+    /** Raw model id, e.g. "claude-sonnet-5". OpenCode has no label table at translation time. */
+    modelId?: string;
+    /** Thinking level, e.g. "high", "max". */
+    variant?: string;
+    /** Latest assistant message token sum (input+output+reasoning+cache). */
+    totalTokens?: number;
+}
+/**
+ * Per-child presentation tracking: raw facts plus the last subtitle emitted, so
+ * repeated folds of the same facts never re-emit an identical upsert.
+ */
+export interface OpenCodeSubagentPresentationState {
+    facts: OpenCodeSubagentPresentationFacts;
+    lastSubtitle?: string;
+    /** A descriptor title has been emitted from detection, linking, or assistant facts. */
+    titleEmitted?: boolean;
+    /** Set once the parent `task` tool call has been linked to this child. */
+    linkedToolCallId?: string;
+    /** The link upsert carried a title (subAgentType); detection must not overwrite it. */
+    titleFromLink?: boolean;
+    /** The link upsert carried a description (task input); detection must not overwrite it. */
+    descriptionFromLink?: boolean;
+}
+/** Claim the assistant/session agent as the descriptor title when no stronger title exists. */
+export declare function claimOpenCodeSubagentFallbackTitle(state: OpenCodeSubagentPresentationState, agentName: string | undefined): string | undefined;
+/** Build the complete compact subtitle OpenCode exposes to provider-neutral clients. */
+export declare function buildOpenCodeSubagentSubtitle(facts: OpenCodeSubagentPresentationFacts): string | undefined;
+/**
+ * Merge observed facts into the tracked state and return the folded subtitle only
+ * when it differs from the last one emitted; otherwise return undefined.
+ */
+export declare function foldOpenCodeSubagentPresentation(state: OpenCodeSubagentPresentationState, patch: OpenCodeSubagentPresentationFacts): string | undefined;
+//# sourceMappingURL=subagent-presentation.d.ts.map

package/dist/server/server/agent/providers/opencode/subagent-presentation.js

@@ -0,0 +1,62 @@
+/** Claim the assistant/session agent as the descriptor title when no stronger title exists. */
+export function claimOpenCodeSubagentFallbackTitle(state, agentName) {
+    const title = readPart(agentName);
+    if (!title || state.titleFromLink || state.titleEmitted)
+        return undefined;
+    // Title means subagent type, so claim it once rather than refreshing on a mid-session handoff.
+    state.titleEmitted = true;
+    return title;
+}
+/** Build the complete compact subtitle OpenCode exposes to provider-neutral clients. */
+export function buildOpenCodeSubagentSubtitle(facts) {
+    const parts = [
+        readPart(facts.agentName),
+        readPart(facts.modelId),
+        formatVariant(facts.variant),
+        formatTokens(facts.totalTokens),
+    ].filter((part) => part !== undefined);
+    return parts.length > 0 ? parts.join(" · ") : undefined;
+}
+/**
+ * Merge observed facts into the tracked state and return the folded subtitle only
+ * when it differs from the last one emitted; otherwise return undefined.
+ */
+export function foldOpenCodeSubagentPresentation(state, patch) {
+    if (patch.agentName !== undefined)
+        state.facts.agentName = patch.agentName;
+    if (patch.modelId !== undefined)
+        state.facts.modelId = patch.modelId;
+    if (patch.variant !== undefined)
+        state.facts.variant = patch.variant;
+    if (patch.totalTokens !== undefined)
+        state.facts.totalTokens = patch.totalTokens;
+    const subtitle = buildOpenCodeSubagentSubtitle(state.facts);
+    if (!subtitle || subtitle === state.lastSubtitle)
+        return undefined;
+    state.lastSubtitle = subtitle;
+    return subtitle;
+}
+function readPart(value) {
+    const trimmed = value?.trim();
+    return trimmed ? trimmed : undefined;
+}
+function formatVariant(variant) {
+    const normalized = readPart(variant);
+    if (!normalized)
+        return undefined;
+    if (normalized === "xhigh")
+        return "Extra High";
+    return normalized
+        .split(/[-_\s]+/)
+        .filter(Boolean)
+        .map((part) => part.charAt(0).toUpperCase() + part.slice(1))
+        .join(" ");
+}
+function formatTokens(totalTokens) {
+    if (typeof totalTokens !== "number" || totalTokens <= 0)
+        return undefined;
+    if (totalTokens < 1000)
+        return `${Math.round(totalTokens)} tokens`;
+    return `${Math.round(totalTokens / 100) / 10}k tokens`;
+}
+//# sourceMappingURL=subagent-presentation.js.map

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

@@ -0,0 +1,22 @@
+import type { OpenCodeServerAcquisition, OpenCodeServerManagerLike } from "./server-manager.js";
+export interface TestOpenCodeServerAcquisition {
+    kind: "current" | "new" | "dedicated" | "existing";
+    env?: Record<string, string>;
+    url?: string;
+    released: boolean;
+}
+export declare class TestOpenCodeServerManager implements OpenCodeServerManagerLike {
+    readonly acquisitions: TestOpenCodeServerAcquisition[];
+    readonly server: {
+        port: number;
+        url: string;
+    };
+    acquireCurrent(): Promise<OpenCodeServerAcquisition>;
+    acquireNew(): Promise<OpenCodeServerAcquisition>;
+    acquireDedicated(env: Record<string, string>): Promise<OpenCodeServerAcquisition>;
+    acquireExisting(url: string): OpenCodeServerAcquisition | null;
+    private recordAcquisition;
+    shutdown(): Promise<void>;
+}
+export declare function createTestOpenCodeServerManager(): TestOpenCodeServerManager;
+//# sourceMappingURL=test-server-manager.d.ts.map

package/dist/server/server/agent/providers/opencode/test-server-manager.js

@@ -0,0 +1,43 @@
+const events = {
+    ready: async () => undefined,
+    subscribe: () => () => undefined,
+};
+export class TestOpenCodeServerManager {
+    constructor() {
+        this.acquisitions = [];
+        this.server = { port: 1234, url: "http://127.0.0.1:1234" };
+    }
+    async acquireCurrent() {
+        return this.recordAcquisition({ kind: "current" });
+    }
+    async acquireNew() {
+        return this.recordAcquisition({ kind: "new" });
+    }
+    async acquireDedicated(env) {
+        return this.recordAcquisition({ kind: "dedicated", env });
+    }
+    acquireExisting(url) {
+        return url === this.server.url ? this.recordAcquisition({ kind: "existing", url }) : null;
+    }
+    recordAcquisition(input) {
+        const acquisition = {
+            kind: input.kind,
+            released: false,
+            ...(input.env ? { env: input.env } : {}),
+            ...(input.url ? { url: input.url } : {}),
+        };
+        this.acquisitions.push(acquisition);
+        return {
+            server: this.server,
+            events,
+            release: async () => {
+                acquisition.released = true;
+            },
+        };
+    }
+    async shutdown() { }
+}
+export function createTestOpenCodeServerManager() {
+    return new TestOpenCodeServerManager();
+}
+//# sourceMappingURL=test-server-manager.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, metadata?: Record<string, 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, metadata) {
+    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 = normalizeSubAgentText(metadata?.sessionId) ?? 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, metadata) {
+    if (toolName.trim().toLowerCase() === "task") {
+        const taskDetail = deriveOpencodeTaskDetail(input, output, error, metadata);
+        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, raw.metadata);
+    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