A desktop coding agent with free access to frontier models.
TypeScript
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
}