Skip to content

A desktop coding agent with free access to frontier models.

TypeScript
8.4 KB
Raw Blame
import type { DenTypeId } from "@omnirush-ee/utils/typeid"
import type { Hono } from "hono"
import { listNativeProviderUsableEntries, type NativeProviderConnectionEntry } from "../capability-sources/native-provider-connections.js"
import type { McpPrincipal } from "./auth.js"
import type { AgentToolContentPart } from "./tool-content.js"
import {
  getJsonRequestBodySchema,
  getParameters,
  getQueryParameterSchema,
  hasJsonRequestBody,
  pathParameterNamesFromTemplate,
  type McpToolOperation,
} from "./catalog.js"
import { buildExternalConnectionStatus, type ExternalCapabilityMatch, type McpMemberIdentity } from "./external-capabilities.js"
import { invokeMcpOperation, normalizeToolBody, normalizeToolRecord } from "./invoke.js"
import { compareCapabilityMatches, scoreText, tokenize, type CapabilityMatch } from "./search.js"
import {
  codemodeScriptPath,
  resolveCodemodeConnectionNamespaceContext,
  type CodemodeConnectionNamespaceContext,
} from "./codemode-namespaces.js"

export const NATIVE_CAPABILITY_PREFIX = "native:"

export function buildNativeCapabilityName(connectionId: string, toolName: string): string {
  return `${NATIVE_CAPABILITY_PREFIX}${connectionId}:${toolName}`
}

export function parseNativeCapabilityName(name: string): { connectionId: string; toolName: string } | null {
  if (!name.startsWith(NATIVE_CAPABILITY_PREFIX)) return null
  const rest = name.slice(NATIVE_CAPABILITY_PREFIX.length)
  const separatorIndex = rest.indexOf(":")
  if (separatorIndex <= 0) return null
  return {
    connectionId: rest.slice(0, separatorIndex),
    toolName: rest.slice(separatorIndex + 1),
  }
}

export type NativeCapabilityMatch = CapabilityMatch & {
  kind?: ExternalCapabilityMatch["kind"]
  status?: ExternalCapabilityMatch["status"]
  hint?: string
  connectionStatus?: ExternalCapabilityMatch["connectionStatus"]
}

function operationSummary(operation: McpToolOperation): string {
  return operation.operation.summary ?? operation.operation.description ?? `${operation.method} ${operation.path}`
}

function operationNameTokens(connectionName: string, operationName: string): string[] {
  const words = operationName.replace(/([a-z0-9])([A-Z])/g, "$1 $2")
  return tokenize(`${connectionName} ${words}`)
}

function operationScore(connection: NativeProviderConnectionEntry, operation: McpToolOperation, queryTokens: string[]): number {
  return scoreText(
    operationNameTokens(connection.name, operation.name),
    tokenize(`${connection.name} ${operationSummary(operation)}`),
    queryTokens,
    tokenize(operation.path),
  )
}

export function nativeOperations(catalog: readonly McpToolOperation[], nativeProviderKey: string): McpToolOperation[] {
  const pathPrefix = `/v1/capabilities/${nativeProviderKey}/`
  return catalog.filter((operation) => operation.path.startsWith(pathPrefix))
}

function capabilityMatch(
  connection: NativeProviderConnectionEntry,
  operation: McpToolOperation,
  score: number,
  scriptNamespace?: string,
): NativeCapabilityMatch {
  const bodySchema = getJsonRequestBodySchema(operation.operation)
  const querySchema = getQueryParameterSchema(operation.operation)
  return {
    name: buildNativeCapabilityName(connection.id, operation.name),
    method: operation.method,
    path: operation.path,
    score,
    summary: `[${connection.name}] ${operationSummary(operation)}`,
    pathParams: pathParameterNamesFromTemplate(operation.path),
    queryParams: getParameters(operation.operation, "query")
      .flatMap((parameter) => typeof parameter.name === "string" ? [parameter.name] : []),
    hasBody: hasJsonRequestBody(operation.operation),
    ...(bodySchema === undefined ? {} : { bodySchema }),
    ...(querySchema === undefined ? {} : { querySchema }),
    ...(scriptNamespace ? { scriptPath: codemodeScriptPath(scriptNamespace, operation.name) } : {}),
  }
}

function connectionStatusMatch(
  connection: NativeProviderConnectionEntry,
  score: number,
): NativeCapabilityMatch {
  const message = `You haven't connected your ${connection.name} account yet.`
  return {
    name: buildNativeCapabilityName(connection.id, "*"),
    method: "NATIVE",
    path: connection.url,
    score,
    summary: `[${connection.name}] Available to you, but you haven't connected your ${connection.name} account yet.`,
    pathParams: [],
    queryParams: [],
    hasBody: false,
    kind: "connection_status",
    status: "needs_connection",
    hint: `Ask the user to open OmniRush.ai Cloud -> Your Connections and click Connect on "${connection.name}", then search again.`,
    connectionStatus: buildExternalConnectionStatus({
      connection,
      state: "needs_connection",
      errorCode: "not_connected",
      message,
    }),
  }
}

export async function searchNativeCapabilities(input: {
  organizationId: DenTypeId<"organization">
  member: McpMemberIdentity | null
  query: string
  catalog: readonly McpToolOperation[]
  limit: number
  namespaceContext?: CodemodeConnectionNamespaceContext
}): Promise<NativeCapabilityMatch[]> {
  if (!input.member) return []
  const namespaceContext = input.namespaceContext ?? await resolveCodemodeConnectionNamespaceContext({
    organizationId: input.organizationId,
    member: input.member,
  })
  const connections = namespaceContext?.nativeProviderEntries ?? await listNativeProviderUsableEntries({
    organizationId: input.organizationId,
    orgMembershipId: input.member.orgMembershipId,
    teamIds: input.member.teamIds,
  })
  const queryTokens = tokenize(input.query)
  const matches: NativeCapabilityMatch[] = []
  for (const connection of connections) {
    const operations = nativeOperations(input.catalog, connection.nativeProviderKey)
    if (!connection.connectedForMe) {
      const score = Math.max(0, ...operations.map((operation) => operationScore(connection, operation, queryTokens)))
      if (score > 0) matches.push(connectionStatusMatch(connection, score))
      continue
    }
    for (const operation of operations) {
      const score = operationScore(connection, operation, queryTokens)
      if (score > 0) matches.push(capabilityMatch(
        connection,
        operation,
        score,
        namespaceContext?.namespaces.native.get(connection.id),
      ))
    }
  }
  const boundedLimit = Math.max(1, Math.min(20, Math.trunc(input.limit) || 5))
  return matches.sort(compareCapabilityMatches).slice(0, boundedLimit)
}

async function resolveNativeCapability(input: {
  organizationId: DenTypeId<"organization">
  member: McpMemberIdentity | null
  connectionId: string
  toolName: string
  catalog: readonly McpToolOperation[]
}): Promise<{ connection: NativeProviderConnectionEntry; operation: McpToolOperation } | null> {
  if (!input.member) return null
  const connections = await listNativeProviderUsableEntries({
    organizationId: input.organizationId,
    orgMembershipId: input.member.orgMembershipId,
    teamIds: input.member.teamIds,
  })
  const connection = connections.find((candidate) => candidate.id === input.connectionId)
  if (!connection) return null
  const operation = nativeOperations(input.catalog, connection.nativeProviderKey)
    .find((candidate) => candidate.name === input.toolName)
  return operation ? { connection, operation } : null
}

type NativeCapabilityToolResult = {
  isError?: boolean
  content: AgentToolContentPart[]
}

export async function executeNativeCapability(input: {
  app: Hono
  env: unknown
  name: string
  organizationId: DenTypeId<"organization">
  member: McpMemberIdentity | null
  catalog: readonly McpToolOperation[]
  principal: McpPrincipal
  path?: unknown
  query?: unknown
  body?: unknown
}): Promise<NativeCapabilityToolResult | null> {
  const parsed = parseNativeCapabilityName(input.name)
  if (!parsed) return null
  const resolved = await resolveNativeCapability({
    organizationId: input.organizationId,
    member: input.member,
    connectionId: parsed.connectionId,
    toolName: parsed.toolName,
    catalog: input.catalog,
  })
  if (!resolved) {
    return {
      isError: true,
      content: [{
        type: "text",
        text: JSON.stringify({
          error: "unknown_capability",
          message: `No capability named "${input.name}". Call search_capabilities to find a valid name.`,
        }),
      }],
    }
  }
  return invokeMcpOperation({
    app: input.app,
    env: input.env,
    operation: resolved.operation,
    principal: input.principal,
    nativeConnectionId: resolved.connection.id,
    toolInput: {
      path: normalizeToolRecord(input.path),
      query: normalizeToolRecord(input.query),
      body: normalizeToolBody(input.body),
    },
  })
}