Skip to content

A desktop coding agent with free access to frontier models.

TypeScript
7.6 KB
Raw Blame
import type { DynamicToolUIPart, JSONValue, ProviderMetadata, TextUIPart } from "ai";
import type { ToolPart } from "@opencode-ai/sdk/v2/client";
import {
  connectionActionAppSchemaVersion,
  connectionActionPayloadSchema,
} from "@omnirush/types/connection-action-app";

import { safeStringify } from "@/app/utils";
import { normalizeErrorText } from "@/lib/error-text";
import { COMMAND_OUTPUT_METADATA_CHARS } from "@/lib/command-output";

export const STRUCTURED_OUTPUT_TOOL = "StructuredOutput";

function isRecord(value: unknown): value is Record<string, unknown> {
  return typeof value === "object" && value !== null && !Array.isArray(value);
}

function isJsonValue(value: unknown, depth = 0): value is JSONValue {
  if (depth > 32) return false;
  if (value === null || typeof value === "string" || typeof value === "number" || typeof value === "boolean") return true;
  if (Array.isArray(value)) return value.length <= 4_096 && value.every((entry) => isJsonValue(entry, depth + 1));
  if (!isRecord(value)) return false;
  const entries = Object.values(value);
  return entries.length <= 4_096 && entries.every((entry) => isJsonValue(entry, depth + 1));
}

function connectionActionMcpResultFromError(error: string): JSONValue | null {
  let parsed: unknown;
  try {
    parsed = JSON.parse(error);
  } catch {
    return null;
  }
  if (!isRecord(parsed) || !isRecord(parsed.connectionStatus)) return null;
  const status = parsed.connectionStatus;
  const action = isRecord(status.action) ? status.action : null;
  const payload = connectionActionPayloadSchema.safeParse({
    schemaVersion: connectionActionAppSchemaVersion,
    connectionId: status.connectionId,
    connectionName: status.connectionName,
    state: status.state,
    actor: status.actor,
    message: status.message,
    action: action
      ? {
          type: action.type,
          label: action.label,
          surface: action.surface,
          ...(typeof action.url === "string" ? { url: action.url } : {}),
        }
      : null,
  });
  if (!payload.success) return null;
  return {
    content: [{ type: "text", text: error }],
    structuredContent: payload.data,
  };
}

function toolCallProviderMetadata(part: ToolPart): ProviderMetadata {
  const stateMetadata = "metadata" in part.state && isRecord(part.state.metadata) ? part.state.metadata : {};
  const persistedMcpResult = isJsonValue(stateMetadata.omnirushMcpResult)
    ? stateMetadata.omnirushMcpResult
    : isJsonValue(stateMetadata.omnirushMcpApp)
      ? stateMetadata.omnirushMcpApp
      : null;
  const mcpResult = persistedMcpResult
    ?? (part.state.status === "error" ? connectionActionMcpResultFromError(part.state.error) : null);
  // The engine's task tool reports the sub-agent's session id in state
  // metadata. Forward it so the transcript card can open that child session.
  const childSessionId = part.tool === "task" && typeof stateMetadata.sessionId === "string" && stateMetadata.sessionId.trim()
    ? stateMetadata.sessionId.trim()
    : null;
  // A finished task names the model its sub-agent ran on (the swarm plugin
  // corrects the engine's start-time guess) and a fallback to the main model.
  const finishedTask = part.tool === "task" && part.state.status === "completed";
  const subagentModel = finishedTask && isRecord(stateMetadata.model) && typeof stateMetadata.model.modelID === "string" && stateMetadata.model.modelID.trim()
    ? stateMetadata.model.modelID.trim().slice(0, 128)
    : null;
  const fallback = finishedTask && isRecord(stateMetadata.omnirushModelFallback) ? stateMetadata.omnirushModelFallback : null;
  const subagentModelFallback = fallback && typeof fallback.requested === "string" && typeof fallback.used === "string"
    ? { requested: fallback.requested.slice(0, 128), used: fallback.used.slice(0, 128), reason: typeof fallback.reason === "string" ? fallback.reason.slice(0, 64) : "unavailable" }
    : null;
  const command = part.tool === "bash" ? commandMetadata(part, stateMetadata) : null;
  const omnirush = {
    ...(command ? { command } : {}),
    ...(mcpResult ? { mcpResult } : {}),
    ...(childSessionId ? { childSessionId } : {}),
    ...(subagentModel ? { subagentModel } : {}),
    ...(subagentModelFallback ? { subagentModelFallback } : {}),
    ...(part.metadata?.omnirushV2CodeMode === true ? {
      codeMode: {
        calls: Array.isArray(stateMetadata.toolCalls) && isJsonValue(stateMetadata.toolCalls) ? stateMetadata.toolCalls : [],
      },
    } : {}),
  };
  return {
    opencode: { partId: part.id },
    ...(Object.keys(omnirush).length > 0 ? { omnirush } : {}),
  };
}

/**
 * A terminal command's live output (state metadata, updated while it runs)
 * and exit code. A finished call's full output is `state.output`, so only
 * running and failed calls carry the text here.
 */
function commandMetadata(part: ToolPart, stateMetadata: Record<string, unknown>) {
  const exit = typeof stateMetadata.exit === "number" && Number.isFinite(stateMetadata.exit) ? stateMetadata.exit : null;
  const rawOutput = part.state.status !== "completed" && typeof stateMetadata.output === "string" ? stateMetadata.output : null;
  const output = rawOutput !== null && rawOutput.length > COMMAND_OUTPUT_METADATA_CHARS
    ? rawOutput.slice(rawOutput.length - COMMAND_OUTPUT_METADATA_CHARS)
    : rawOutput;
  if (exit === null && output === null) return null;
  return {
    ...(output !== null ? { output } : {}),
    ...(exit !== null ? { exit } : {}),
  };
}

function shouldDeferInProgressTool(part: ToolPart) {
  if (part.state.status === "completed" || part.state.status === "error") {
    return false;
  }

  return Object.keys(part.state.input).length === 0;
}

export function parseStructuredOutputUIPart(part: ToolPart): TextUIPart | null {
  if (part.state.status === "error") {
    return null;
  }

  const text = safeStringify(part.state.input);

  if (text === "{}" && part.state.status !== "completed") {
    return null;
  }

  return {
    type: "text",
    text,
    state: part.state.status === "completed" ? "done" : "streaming",
    providerMetadata: { opencode: { partId: `structured-output-${part.callID}`, toolPartId: part.id } },
  };
}

export function parseDynamicToolUIPart(part: ToolPart): DynamicToolUIPart | null {
  if (part.tool === STRUCTURED_OUTPUT_TOOL) {
    return null;
  }

  if (part.state.status === "error") {
    return {
      type: "dynamic-tool",
      toolName: part.tool,
      toolCallId: part.callID,
      state: "output-error",
      input: part.state.input,
      errorText: normalizeErrorText(part.state.error).display,
      callProviderMetadata: toolCallProviderMetadata(part),
    };
  }

  if (part.state.status === "completed") {
    if (part.metadata?.omnirushV2CodeMode === true && part.state.metadata.error === true) {
      return {
        type: "dynamic-tool", toolName: part.tool, toolCallId: part.callID,
        state: "output-error", input: part.state.input,
        errorText: normalizeErrorText(part.state.output).display,
        callProviderMetadata: toolCallProviderMetadata(part),
      };
    }
    return {
      type: "dynamic-tool",
      toolName: part.tool,
      toolCallId: part.callID,
      state: "output-available",
      input: part.state.input,
      output: part.state.output,
      callProviderMetadata: toolCallProviderMetadata(part),
    };
  }

  // OpenCode emits pending/running tool parts with `{}` input before args
  // (e.g. filePath) are filled in. Skip UI until the next part.updated.
  if (shouldDeferInProgressTool(part)) {
    return null;
  }

  return {
    type: "dynamic-tool",
    toolName: part.tool,
    toolCallId: part.callID,
    state: "input-streaming",
    input: part.state.input,
    callProviderMetadata: toolCallProviderMetadata(part),
  };
}