A desktop coding agent with free access to frontier models.
TypeScript
import { Client } from "@modelcontextprotocol/sdk/client/index.js"
import { InMemoryTransport } from "@modelcontextprotocol/sdk/inMemory.js"
import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js"
import type { CapabilityMatch } from "./search.js"
import { scoreText, tokenize } from "./search.js"
import { DEN_ADMIN_MCP_VERSION, registerAdminMcpTools } from "./admin-tools.js"
import { normalizeToolRecord } from "./invoke.js"
export const ADMIN_CAPABILITY_PREFIX = "admin:"
const ADMIN_ARGUMENT_INVOCATION: NonNullable<CapabilityMatch["invocation"]> = { argumentsField: "body" }
type AdminToolResult = {
isError?: boolean
content: { type: "text"; text: string }[]
}
async function withAdminClient<T>(run: (client: Client) => Promise<T>): Promise<T> {
const server = new McpServer({ name: "den-admin-agent-bridge", version: DEN_ADMIN_MCP_VERSION })
registerAdminMcpTools(server)
const client = new Client({ name: "omnirush-agent", version: "1.0.0" })
const [clientTransport, serverTransport] = InMemoryTransport.createLinkedPair()
await server.connect(serverTransport)
await client.connect(clientTransport)
try {
return await run(client)
} finally {
await client.close().catch(() => undefined)
await server.close().catch(() => undefined)
}
}
export function parseAdminCapabilityName(name: string): string | null {
if (!name.startsWith(ADMIN_CAPABILITY_PREFIX)) return null
const toolName = name.slice(ADMIN_CAPABILITY_PREFIX.length)
return toolName.length > 0 ? toolName : null
}
async function listAdminCapabilityMatches(query?: string): Promise<CapabilityMatch[]> {
const queryTokens = query === undefined ? undefined : tokenize(query)
const { tools } = await withAdminClient((client) => client.listTools())
return tools
.map((tool) => {
const hasBody = Object.keys(tool.inputSchema.properties ?? {}).length > 0
return {
name: `${ADMIN_CAPABILITY_PREFIX}${tool.name}`,
method: "MCP",
path: "/mcp/admin",
score: queryTokens
? scoreText(
tokenize(tool.name),
tokenize(tool.description ?? ""),
queryTokens,
["admin", "platform"],
)
: 1,
summary: `[OmniRush.ai Admin] ${tool.description ?? tool.name}`,
pathParams: [],
queryParams: [],
hasBody,
...(hasBody ? { argumentsSchema: tool.inputSchema, invocation: ADMIN_ARGUMENT_INVOCATION } : {}),
}
})
.filter((match) => queryTokens === undefined || match.score > 0)
.sort((a, b) => (b.score - a.score) || a.name.localeCompare(b.name))
}
export async function listAvailableAdminCapabilities(platformAdmin: boolean): Promise<CapabilityMatch[]> {
return platformAdmin ? listAdminCapabilityMatches() : []
}
export async function searchAdminCapabilities(query: string, limit = 5): Promise<CapabilityMatch[]> {
const boundedLimit = Math.max(1, Math.min(20, Math.trunc(limit) || 5))
return (await listAdminCapabilityMatches(query))
.slice(0, boundedLimit)
}
export async function searchAvailableAdminCapabilities(
platformAdmin: boolean,
query: string,
limit = 5,
): Promise<CapabilityMatch[]> {
return platformAdmin ? searchAdminCapabilities(query, limit) : []
}
function isTextContent(value: unknown): value is { type: "text"; text: string } {
return typeof value === "object"
&& value !== null
&& "type" in value
&& value.type === "text"
&& "text" in value
&& typeof value.text === "string"
}
function resultTextContent(result: unknown): { type: "text"; text: string }[] {
if (typeof result !== "object" || result === null || !("content" in result) || !Array.isArray(result.content)) {
return []
}
return result.content.filter(isTextContent)
}
function resultIsError(result: unknown): boolean {
return typeof result === "object" && result !== null && "isError" in result && result.isError === true
}
export async function executeAdminCapability(name: string, body: unknown): Promise<AdminToolResult | null> {
const toolName = parseAdminCapabilityName(name)
if (!toolName) return null
return withAdminClient(async (client) => {
const result = await client.callTool({ name: toolName, arguments: normalizeToolRecord(body) ?? {} })
const content = resultTextContent(result)
return {
...(resultIsError(result) ? { isError: true } : {}),
content: content.length > 0 ? content : [{ type: "text", text: JSON.stringify(result) }],
}
})
}
export async function executeAvailableAdminCapability(
platformAdmin: boolean,
name: string,
body: unknown,
): Promise<AdminToolResult | null> {
if (!parseAdminCapabilityName(name)) return null
if (!platformAdmin) {
return {
isError: true,
content: [{
type: "text",
text: JSON.stringify({
error: "unknown_capability",
message: `No capability named "${name}". Call search_capabilities to find a valid name.`,
}),
}],
}
}
return executeAdminCapability(name, body)
}