Skip to content

A desktop coding agent with free access to frontier models.

TypeScript
8.7 KB
Raw Blame
import { omnirushCloudMcpConnectionActionSchema } from "@omnirush/types/den/mcp-connection-action"
import { connectionActionPayloadSchema, type ConnectionActionPayload } from "@omnirush/types/connection-action-app"

export type ToolErrorAttribution = {
  label: string
  confidence: "Confirmed" | "Inferred"
  description: string
}

export type ChatToolReconnectAction = {
  connectionId: string
  connectionName: string
  label: string
}

export type ChatToolReconnectProgress =
  | { phase: "opening" }
  | { phase: "authorization_opened"; authorizeUrl: string }
export type ChatToolReconnectResult = "connected"

const OMNIRUSH_CLOUD_CAPABILITY_TOOLS = new Set([
  "omnirush-cloud_search_capabilities",
  "omnirush-cloud_execute_capability",
  "omnirush-cloud_connection_action",
])

const MAX_PARSED_RESULT_LENGTH = 64 * 1_024

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

function parseResultRecord(result: unknown): Record<string, unknown> | null {
  if (isRecord(result)) return result
  if (typeof result !== "string") return null
  if (result.length > MAX_PARSED_RESULT_LENGTH) return null

  const trimmed = result.trim()
  const jsonStart = trimmed.indexOf("{")
  const jsonEnd = trimmed.lastIndexOf("}")
  const candidates = [
    trimmed,
    ...(jsonStart > 0 ? [trimmed.slice(jsonStart)] : []),
    ...(jsonStart >= 0 && jsonEnd > jsonStart ? [trimmed.slice(jsonStart, jsonEnd + 1)] : []),
  ]

  for (const candidate of candidates) {
    try {
      const parsed: unknown = JSON.parse(candidate)
      if (isRecord(parsed)) return parsed
    } catch {
      // The engine may wrap the MCP JSON in a plain error message.
    }
  }
  return null
}

function diagnosticFromError(errorText: string): Record<string, unknown> | null {
  const parsed = parseResultRecord(errorText)
  if (!parsed) return null
  return isRecord(parsed.diagnostic) ? parsed.diagnostic : parsed
}

function stringValue(record: Record<string, unknown> | null, key: string): string | undefined {
  const value = record?.[key]
  return typeof value === "string" && value.trim() ? value : undefined
}

function numberValue(record: Record<string, unknown> | null, key: string): number | undefined {
  const value = record?.[key]
  return typeof value === "number" && Number.isFinite(value) ? value : undefined
}

function confirmed(label: string, description: string): ToolErrorAttribution {
  return { label, confidence: "Confirmed", description }
}

/** Normalize the gateway's search, execution, and status-probe card payloads. */
export function connectionCardPayloadFromChatToolResult(
  toolName: string,
  result: unknown,
  input?: unknown,
): ConnectionActionPayload | null {
  if (!OMNIRUSH_CLOUD_CAPABILITY_TOOLS.has(toolName)) return null
  if (toolName === "omnirush-cloud_search_capabilities" && (!isRecord(input) || input.intent !== "connect")) return null
  const parsed = parseResultRecord(result)
  if (!parsed) return null
  const candidates = [parsed, parsed.connectionAction, parsed.connectionStatus,
    ...(Array.isArray(parsed.matches) ? parsed.matches.filter(isRecord).map(match => match.connectionStatus) : []),
  ]
  const targets = new Map<string, ConnectionActionPayload>()
  for (const candidate of candidates) {
    const payload = connectionActionPayloadSchema.safeParse(
      isRecord(candidate) && omnirushCloudMcpConnectionActionSchema.safeParse(candidate).success
        ? { ...candidate, schemaVersion: "1" }
        : candidate,
    )
    if (payload.success) targets.set(payload.data.connectionId, payload.data)
  }
  if (targets.size !== 1) return null
  const [payload] = targets.values()
  return payload
}

export function reconnectActionFromChatToolResult(
  toolName: string,
  result: unknown,
  input?: unknown,
): ChatToolReconnectAction | null {
  // Only canonical omnirush.ai Cloud tools may produce a native connection action.
  // Discovery may offer authorization only for an explicit setup request;
  // finding an unavailable connection is not itself a reason to prompt.
  if (!OMNIRUSH_CLOUD_CAPABILITY_TOOLS.has(toolName)) return null
  if (toolName === "omnirush-cloud_search_capabilities" && (!isRecord(input) || input.intent !== "connect")) return null

  const parsed = parseResultRecord(result)
  if (!parsed) return null

  const candidates = [
    ...(isRecord(parsed.connectionStatus) ? [parsed.connectionStatus] : []),
    ...(Array.isArray(parsed.matches)
      ? parsed.matches
        .filter(isRecord)
        .map((match) => match.connectionStatus)
        .filter(isRecord)
      : []),
  ]
  if (candidates.length === 0) {
    const payload = connectionCardPayloadFromChatToolResult(toolName, parsed, input)
    if (!payload || payload.actor !== "member" || payload.action?.surface !== "omnirush_your_connections"
      || !((payload.state === "needs_connection" && payload.action.type === "connect")
        || (payload.state === "reauth_required" && payload.action.type === "reconnect"))) return null
    // The portable probe omits credential metadata. The signed-in desktop
    // handler rechecks membership, OAuth, and per-member ownership before auth.
    return { connectionId: payload.connectionId, connectionName: payload.connectionName,
      label: payload.state === "needs_connection" ? "Connect" : "Reconnect" }
  }
  const reconnectTargets = new Map<string, ChatToolReconnectAction>()
  for (const connectionStatus of candidates) {
    const parsedStatus = omnirushCloudMcpConnectionActionSchema.safeParse(connectionStatus)
    if (!parsedStatus.success) continue
    const status = parsedStatus.data
    if (status.authType !== "oauth" || status.credentialMode !== "per_member" || status.actor !== "member"
      || status.action.surface !== "omnirush_your_connections"
      || !((status.state === "needs_connection" && status.action.type === "connect")
        || (status.state === "reauth_required" && status.action.type === "reconnect"))) continue
    const { connectionId, connectionName } = status
    reconnectTargets.set(connectionId, { connectionId, connectionName, label: status.state === "needs_connection" ? "Connect" : "Reconnect" })
  }

  // One tool row should never guess which of several connections the user
  // intended to authorize. Multi-connection search results remain descriptive.
  if (reconnectTargets.size !== 1) return null
  const [action] = reconnectTargets.values()

  // Keep the chat action concise and derived from the trusted connection
  // identity. Diagnostic operator guidance can be much longer than a button
  // label, and tool output must never get to inject arbitrary action copy.
  return action
}

export function attributeChatToolError(errorText: string): ToolErrorAttribution | null {
  if (errorText.length > MAX_PARSED_RESULT_LENGTH) return null
  const diagnostic = diagnosticFromError(errorText)
  const code = stringValue(diagnostic, "code")
  const category = stringValue(diagnostic, "category")
  const phase = stringValue(diagnostic, "phase")
  const httpStatus = numberValue(diagnostic, "httpStatus")
  const providerStatus = numberValue(diagnostic, "providerStatus")
  const providerCode = stringValue(diagnostic, "providerCode")

  if (
    errorText.includes("omnirush.ai stopped waiting after")
    || /The capability call exceeded \d+(?:\.\d+)?s\b/.test(errorText)
    || code === "MCP_LIFECYCLE_DEADLINE"
    || code === "MCP_REQUEST_TIMEOUT"
    || category === "lifecycle_deadline"
  ) {
    return confirmed(
      "omnirush.ai timeout",
      "omnirush.ai created this deadline. The external operation may still have completed, so verify its state before retrying.",
    )
  }

  if (
    category === "security_blocked"
    || code === "MCP_URL_BLOCKED"
    || code === "MCP_FETCH_FORBIDDEN_PORT"
  ) {
    return confirmed("Blocked by omnirush.ai", "omnirush.ai blocked the request before it was sent.")
  }

  if (httpStatus !== undefined && (httpStatus < 200 || httpStatus >= 300)) {
    return confirmed(
      `Remote MCP · HTTP ${httpStatus}`,
      `The remote MCP returned HTTP ${httpStatus}.`,
    )
  }

  if (
    phase?.startsWith("PROVIDER_")
    || category?.startsWith("provider_")
    || providerStatus !== undefined
    || providerCode !== undefined
  ) {
    return confirmed(
      "Provider error",
      providerStatus === undefined
        ? "The remote MCP responded, but the downstream provider or tool rejected the operation."
        : `The remote MCP responded, but the downstream provider returned status ${providerStatus}.`,
    )
  }

  if (/\b(?:timed out|timeout|deadline exceeded)\b/i.test(errorText)) {
    return {
      label: "Timeout · source unclear",
      confidence: "Inferred",
      description: "A timeout was reported, but the client did not receive structured evidence identifying which boundary created it.",
    }
  }

  return null
}