offrouter-mcp 0.2.1 → 0.3.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "offrouter-mcp",
-  "version": "0.2.1",
+  "version": "0.3.0",
   "type": "module",
   "main": "./dist/index.js",
   "types": "./dist/index.d.ts",
@@ -12,8 +12,13 @@
     "test": "vitest run --root ../.. packages/mcp/src/server.test.ts"
   },
   "dependencies": {
-    "offrouter-core": "0.2.1",
+    "offrouter-core": "0.3.0",
     "@modelcontextprotocol/sdk": "^1.29.0",
     "zod": "^3.23.0"
-  }
+  },
+  "files": [
+    "dist",
+    "README.md",
+    "LICENSE"
+  ]
 }

package/src/index.ts

@@ -1,108 +0,0 @@
-#!/usr/bin/env node
-/**
- * offrouter-mcp — stdio MCP server surface for OffRouter.
- */
-import { realpathSync } from "node:fs";
-import { fileURLToPath } from "node:url";
-import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
-import type { Transport } from "@modelcontextprotocol/sdk/shared/transport.js";
-import {
-  createOffRouterMcpServer,
-  loadOffRouterMcpContext,
-  type OffRouterMcpContext,
-} from "./server.js";
-
-export {
-  createOffRouterMcpContext,
-  createOffRouterMcpServer,
-  loadOffRouterMcpContext,
-  newTaskId,
-  type LoadOffRouterMcpContextOptions,
-  type OffRouterMcpContext,
-  type OffRouterMcpContextOptions,
-} from "./server.js";
-
-export const MCP_PACKAGE = "offrouter-mcp" as const;
-
-export interface McpIoStream {
-  write(chunk: string): boolean | void;
-}
-
-export interface RunMcpCliOptions {
-  cwd?: string;
-  env?: NodeJS.ProcessEnv;
-  stdout?: McpIoStream;
-  stderr?: McpIoStream;
-  transport?: Transport;
-  context?: OffRouterMcpContext;
-}
-
-const HELP = `OffRouter MCP stdio server
-
-Usage: offrouter-mcp [--help]
-
-Starts the OffRouter MCP server over stdio. Tools exposed:
-  offrouter_route
-  offrouter_delegate
-  offrouter_status
-  offrouter_explain_decision
-  offrouter_cancel
-
-V1 background tasks live only while this MCP server process remains alive.
-`;
-
-function defaultStream(stream: NodeJS.WriteStream): McpIoStream {
-  return {
-    write(chunk: string) {
-      return stream.write(chunk);
-    },
-  };
-}
-
-export async function runMcpCli(
-  argv: string[] = process.argv.slice(2),
-  options: RunMcpCliOptions = {},
-): Promise<number> {
-  const stdout = options.stdout ?? defaultStream(process.stdout);
-  const stderr = options.stderr ?? defaultStream(process.stderr);
-
-  if (argv.includes("--help") || argv.includes("-h")) {
-    stdout.write(HELP);
-    return 0;
-  }
-
-  if (argv.length > 0) {
-    stderr.write(`Unknown arguments: ${argv.join(" ")}\n\n${HELP}`);
-    return 1;
-  }
-
-  const context =
-    options.context ??
-    (await loadOffRouterMcpContext({
-      cwd: options.cwd ?? process.cwd(),
-      env: options.env ?? process.env,
-    }));
-  const server = createOffRouterMcpServer(context);
-  await server.connect(options.transport ?? new StdioServerTransport());
-  return 0;
-}
-
-function isEntrypoint(): boolean {
-  if (!process.argv[1]) {
-    return false;
-  }
-  try {
-    return (
-      realpathSync(process.argv[1]) ===
-      realpathSync(fileURLToPath(import.meta.url))
-    );
-  } catch {
-    return false;
-  }
-}
-
-if (isEntrypoint()) {
-  void runMcpCli(process.argv.slice(2)).then((code) => {
-    process.exitCode = code;
-  });
-}

package/src/server.test.ts

@@ -1,538 +0,0 @@
-import { mkdir, mkdtemp, writeFile } from "node:fs/promises";
-import { tmpdir } from "node:os";
-import { join } from "node:path";
-import { Client } from "@modelcontextprotocol/sdk/client/index.js";
-import { InMemoryTransport } from "@modelcontextprotocol/sdk/inMemory.js";
-import type { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
-import {
-  createFakeProvider,
-  type PolicyConfig,
-  type ProviderAdapter,
-  type ProviderCandidate,
-  type RouteDecision,
-  type RouteRequest,
-} from "offrouter-core";
-import { afterEach, describe, expect, it } from "vitest";
-import { runMcpCli } from "./index.js";
-import {
-  createOffRouterMcpContext,
-  createOffRouterMcpServer,
-  loadOffRouterMcpContext,
-  type OffRouterMcpContext,
-} from "./server.js";
-
-const policy: PolicyConfig = {
-  allowlistedProfiles: ["claude-personal", "codex-personal", "gemini-personal"],
-  deniedProfilePatterns: ["*-work"],
-};
-
-function candidate(
-  partial: Partial<ProviderCandidate> &
-    Pick<ProviderCandidate, "providerId" | "modelId" | "authTier">,
-): ProviderCandidate {
-  return {
-    authScope: "third-party",
-    health: "healthy",
-    supportsTools: true,
-    supportsStreaming: true,
-    supportsJson: true,
-    supportsImages: false,
-    estimatedCostUsd: 0,
-    ...partial,
-  };
-}
-
-function route(
-  overrides: Partial<RouteRequest> & {
-    harness?: Partial<RouteRequest["harness"]>;
-    task?: Partial<RouteRequest["task"]>;
-    workspace?: Partial<RouteRequest["workspace"]>;
-    constraints?: Partial<RouteRequest["constraints"]>;
-  } = {},
-): RouteRequest {
-  return {
-    protocolVersion: "offrouter.route.v1",
-    requestId: overrides.requestId ?? "req_mcp_1",
-    harness: {
-      kind: "claude",
-      profile: "claude-personal",
-      ...overrides.harness,
-    },
-    task: {
-      promptPreview: "explain this repository",
-      promptDigest: "sha256:mcp-test",
-      kind: "explain",
-      risk: "low",
-      ...overrides.task,
-    },
-    workspace: {
-      cwd: "/tmp/offrouter",
-      trusted: true,
-      ...overrides.workspace,
-    },
-    constraints: {
-      subscriptionFirst: true,
-      allowApiKeyFallback: true,
-      ...overrides.constraints,
-    },
-  };
-}
-
-async function connectClient(context: OffRouterMcpContext): Promise<{
-  client: Client;
-  server: McpServer;
-}> {
-  const server = createOffRouterMcpServer(context);
-  const client = new Client({ name: "offrouter-mcp-test", version: "0.0.0" });
-  const [clientTransport, serverTransport] =
-    InMemoryTransport.createLinkedPair();
-
-  await Promise.all([
-    server.connect(serverTransport),
-    client.connect(clientTransport),
-  ]);
-
-  return { client, server };
-}
-
-function structured<T>(result: Awaited<ReturnType<Client["callTool"]>>): T {
-  expect(result.isError).not.toBe(true);
-  expect(result.structuredContent).toBeTypeOf("object");
-  return result.structuredContent as T;
-}
-
-describe("OffRouter MCP server", () => {
-  const clients: Client[] = [];
-  const servers: McpServer[] = [];
-
-  afterEach(async () => {
-    await Promise.all(clients.splice(0).map((client) => client.close()));
-    await Promise.all(servers.splice(0).map((server) => server.close()));
-  });
-
-  it("registers offrouter tools and returns a route decision", async () => {
-    const context = createOffRouterMcpContext({
-      policy,
-      candidates: [
-        candidate({
-          providerId: "fake",
-          modelId: "fake-coder",
-          authTier: "api-key",
-        }),
-      ],
-      adapters: {
-        fake: createFakeProvider({ id: "fake" }),
-      },
-      configuredProfiles: ["claude-personal"],
-      configuredProviders: ["fake"],
-    });
-    const connected = await connectClient(context);
-    clients.push(connected.client);
-    servers.push(connected.server);
-
-    const tools = await connected.client.listTools();
-    expect(tools.tools.map((tool) => tool.name)).toEqual(
-      expect.arrayContaining([
-        "offrouter_route",
-        "offrouter_delegate",
-        "offrouter_status",
-        "offrouter_explain_decision",
-        "offrouter_cancel",
-      ]),
-    );
-
-    const result = await connected.client.callTool({
-      name: "offrouter_route",
-      arguments: { route: route() },
-    });
-
-    const body = structured<{ decision: RouteDecision }>(result);
-    expect(body.decision.route).toMatchObject({
-      provider: "fake",
-      model: "fake-coder",
-      authTier: "api-key",
-    });
-  });
-
-  it("delegates to the fake provider and returns generated text", async () => {
-    const context = createOffRouterMcpContext({
-      policy,
-      candidates: [
-        candidate({
-          providerId: "fake",
-          modelId: "fake-coder",
-          authTier: "api-key",
-        }),
-      ],
-      adapters: {
-        fake: createFakeProvider({
-          id: "fake",
-          responseText: "delegated by fake provider",
-        }),
-      },
-      configuredProfiles: ["claude-personal"],
-      configuredProviders: ["fake"],
-    });
-    const connected = await connectClient(context);
-    clients.push(connected.client);
-    servers.push(connected.server);
-
-    const result = await connected.client.callTool({
-      name: "offrouter_delegate",
-      arguments: {
-        prompt: "Full prompt used only after routing allows fake.",
-        route: route({ requestId: "req_delegate_mcp" }),
-        mode: "oneshot",
-        output: "text",
-      },
-    });
-
-    const body = structured<{
-      result: { status: string; text?: string };
-      decision: RouteDecision;
-    }>(result);
-    expect(body.result.status).toBe("completed");
-    expect(body.result.text).toBe("delegated by fake provider");
-    expect(body.decision.route?.provider).toBe("fake");
-  });
-
-  it("aggregates stream mode events without dropping text deltas", async () => {
-    const context = createOffRouterMcpContext({
-      policy,
-      candidates: [
-        candidate({
-          providerId: "fake",
-          modelId: "fake-coder",
-          authTier: "api-key",
-        }),
-      ],
-      adapters: {
-        fake: createFakeProvider({
-          id: "fake",
-          streamChunks: ["streamed ", "delegate"],
-        }),
-      },
-      configuredProfiles: ["claude-personal"],
-      configuredProviders: ["fake"],
-    });
-    const connected = await connectClient(context);
-    clients.push(connected.client);
-    servers.push(connected.server);
-
-    const result = await connected.client.callTool({
-      name: "offrouter_delegate",
-      arguments: {
-        prompt: "Stream this prompt after policy approval.",
-        route: route({ requestId: "req_stream_mcp" }),
-        mode: "stream",
-        output: "text",
-      },
-    });
-
-    const body = structured<{
-      result: {
-        status: string;
-        text?: string;
-        events: Array<{ type: string; text?: string }>;
-      };
-    }>(result);
-    expect(body.result.status).toBe("completed");
-    expect(body.result.text).toBe("streamed delegate");
-    expect(
-      body.result.events.filter((event) => event.type === "text-delta"),
-    ).toEqual([
-      expect.objectContaining({ text: "streamed " }),
-      expect.objectContaining({ text: "delegate" }),
-    ]);
-  });
-
-  it("reports configured profiles, providers, and active task count", async () => {
-    const context = createOffRouterMcpContext({
-      policy,
-      candidates: [
-        candidate({
-          providerId: "fake",
-          modelId: "fake-coder",
-          authTier: "api-key",
-        }),
-      ],
-      adapters: {
-        fake: createFakeProvider({ id: "fake" }),
-      },
-      configuredProfiles: ["claude-personal", "codex-personal"],
-      configuredProviders: ["fake"],
-    });
-    const connected = await connectClient(context);
-    clients.push(connected.client);
-    servers.push(connected.server);
-
-    const result = await connected.client.callTool({
-      name: "offrouter_status",
-      arguments: {},
-    });
-
-    const body = structured<{
-      status: {
-        configuredProfiles: string[];
-        configuredProviders: string[];
-        registeredAdapters: string[];
-        invokableProviders: string[];
-        configuredButNotInvokableProviders: string[];
-        activeTasks: number;
-      };
-    }>(result);
-    expect(body.status.configuredProfiles).toEqual([
-      "claude-personal",
-      "codex-personal",
-    ]);
-    expect(body.status.configuredProviders).toEqual(["fake"]);
-    expect(body.status.registeredAdapters).toEqual(["fake"]);
-    expect(body.status.invokableProviders).toEqual(["fake"]);
-    expect(body.status.configuredButNotInvokableProviders).toEqual([]);
-    expect(body.status.activeTasks).toBe(0);
-  });
-
-  it("default config context does not claim uninvokable providers", async () => {
-    const home = await mkdtemp(join(tmpdir(), "offrouter-mcp-home-"));
-    await mkdir(join(home, "profiles"));
-    await writeFile(
-      join(home, "config.toml"),
-      [
-        'allowlisted_profiles = ["claude-personal"]',
-        "",
-        "[providers.openai]",
-        "enabled = true",
-        "",
-      ].join("\n"),
-      "utf8",
-    );
-
-    const context = await loadOffRouterMcpContext({
-      env: {
-        OFFROUTER_HOME: home,
-      },
-      homedir: () => home,
-    });
-    const connected = await connectClient(context);
-    clients.push(connected.client);
-    servers.push(connected.server);
-
-    expect(context.candidates).toEqual([]);
-    expect(context.adapters).toEqual({});
-
-    const status = await connected.client.callTool({
-      name: "offrouter_status",
-      arguments: {},
-    });
-    const statusBody = structured<{
-      status: {
-        configuredProviders: string[];
-        registeredAdapters: string[];
-        invokableProviders: string[];
-        configuredButNotInvokableProviders: string[];
-      };
-    }>(status);
-    expect(statusBody.status.configuredProviders).toEqual(["openai"]);
-    expect(statusBody.status.registeredAdapters).toEqual([]);
-    expect(statusBody.status.invokableProviders).toEqual([]);
-    expect(statusBody.status.configuredButNotInvokableProviders).toEqual([
-      "openai",
-    ]);
-
-    const result = await connected.client.callTool({
-      name: "offrouter_route",
-      arguments: { route: route() },
-    });
-
-    const body = structured<{ decision: RouteDecision }>(result);
-    expect(body.decision.needsConfiguration).toBe(true);
-    expect(body.decision.route).toBeNull();
-  });
-
-  it("blocks work profiles through route policy", async () => {
-    const context = createOffRouterMcpContext({
-      policy,
-      candidates: [
-        candidate({
-          providerId: "fake",
-          modelId: "fake-coder",
-          authTier: "api-key",
-        }),
-      ],
-      adapters: {
-        fake: createFakeProvider({ id: "fake" }),
-      },
-      configuredProfiles: ["claude-personal"],
-      configuredProviders: ["fake"],
-    });
-    const connected = await connectClient(context);
-    clients.push(connected.client);
-    servers.push(connected.server);
-
-    const result = await connected.client.callTool({
-      name: "offrouter_route",
-      arguments: {
-        route: route({
-          requestId: "req_work_profile",
-          harness: { profile: "claude-work" },
-        }),
-      },
-    });
-
-    const body = structured<{ decision: RouteDecision }>(result);
-    expect(body.decision.blocked).toBe(true);
-    expect(body.decision.policyDenials?.map((d) => d.code)).toContain(
-      "work_profile_denied",
-    );
-  });
-
-  it("does not invoke an adapter when delegate is blocked by work-profile policy", async () => {
-    const base = createFakeProvider({ id: "fake" });
-    let invokeCount = 0;
-    const adapter: ProviderAdapter = {
-      id: base.id,
-      listModels: () => base.listModels(),
-      checkAuth: () => base.checkAuth(),
-      queryLimits: (authTier) => base.queryLimits(authTier),
-      estimate: (request, model, authTier) =>
-        base.estimate(request, model, authTier),
-      async *invoke(request) {
-        invokeCount += 1;
-        yield* base.invoke(request);
-      },
-      cancel: (callId) => base.cancel(callId),
-    };
-    const context = createOffRouterMcpContext({
-      policy,
-      candidates: [
-        candidate({
-          providerId: "fake",
-          modelId: "fake-coder",
-          authTier: "api-key",
-        }),
-      ],
-      adapters: { fake: adapter },
-      configuredProfiles: ["claude-personal"],
-      configuredProviders: ["fake"],
-    });
-    const connected = await connectClient(context);
-    clients.push(connected.client);
-    servers.push(connected.server);
-
-    const result = await connected.client.callTool({
-      name: "offrouter_delegate",
-      arguments: {
-        prompt: "This prompt must not reach the fake adapter.",
-        route: route({
-          requestId: "req_delegate_work_profile",
-          harness: { profile: "claude-work" },
-        }),
-        mode: "oneshot",
-        output: "text",
-      },
-    });
-
-    const body = structured<{
-      result: { status: string; error?: string };
-      decision: RouteDecision;
-    }>(result);
-    expect(body.result.status).toBe("failed");
-    expect(body.decision.blocked).toBe(true);
-    expect(invokeCount).toBe(0);
-  });
-
-  it("returns a structured reason when cancelling an unknown task", async () => {
-    const context = createOffRouterMcpContext({
-      policy,
-      candidates: [],
-      adapters: {},
-      configuredProfiles: ["claude-personal"],
-      configuredProviders: [],
-    });
-    const connected = await connectClient(context);
-    clients.push(connected.client);
-    servers.push(connected.server);
-
-    const result = await connected.client.callTool({
-      name: "offrouter_cancel",
-      arguments: { taskId: "missing_task" },
-    });
-
-    const body = structured<{
-      cancelled: boolean;
-      error: { code: string; message: string };
-    }>(result);
-    expect(body.cancelled).toBe(false);
-    expect(body.error).toEqual({
-      code: "unknown_task",
-      message: "No active task found for missing_task.",
-    });
-  });
-
-  it("cancels an active same-process background delegation task", async () => {
-    const context = createOffRouterMcpContext({
-      policy,
-      candidates: [
-        candidate({
-          providerId: "fake",
-          modelId: "fake-coder",
-          authTier: "api-key",
-        }),
-      ],
-      adapters: {
-        fake: createFakeProvider({ id: "fake", hangUntilCancel: true }),
-      },
-      configuredProfiles: ["claude-personal"],
-      configuredProviders: ["fake"],
-    });
-    const connected = await connectClient(context);
-    clients.push(connected.client);
-    servers.push(connected.server);
-
-    const start = await connected.client.callTool({
-      name: "offrouter_delegate",
-      arguments: {
-        taskId: "task_mcp_cancel",
-        prompt: "Start and then cancel this task.",
-        route: route({ requestId: "req_cancel_mcp" }),
-        mode: "background",
-        output: "text",
-      },
-    });
-    const started = structured<{ task: { taskId: string; status: string } }>(
-      start,
-    );
-    expect(started.task.status).toBe("running");
-
-    const cancel = await connected.client.callTool({
-      name: "offrouter_cancel",
-      arguments: { taskId: started.task.taskId },
-    });
-
-    const cancelled = structured<{
-      task: { taskId: string; status: string };
-      cancelled: boolean;
-    }>(cancel);
-    expect(cancelled.cancelled).toBe(true);
-    expect(cancelled.task).toMatchObject({
-      taskId: "task_mcp_cancel",
-      status: "cancelled",
-    });
-  });
-
-  it("prints help for the stdio entrypoint", async () => {
-    const chunks: string[] = [];
-
-    const code = await runMcpCli(["--help"], {
-      stdout: {
-        write(chunk) {
-          chunks.push(chunk);
-        },
-      },
-    });
-
-    expect(code).toBe(0);
-    expect(chunks.join("")).toContain("Usage: offrouter-mcp [--help]");
-    expect(chunks.join("")).toContain("MCP stdio server");
-  });
-});

package/src/server.ts

@@ -1,126 +0,0 @@
-/**
- * OffRouter MCP server — route/delegate/status tools over an in-process runtime.
- *
- * V1 background tasks live only inside the active MCP server process.
- * Harness adapters stay out of this package; core policy + delegation only.
- */
-import { randomBytes } from "node:crypto";
-import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
-import {
-  DelegationRuntime,
-  loadConfig,
-  type DelegationRuntimeOptions,
-  type LoadConfigOptions,
-  type PolicyConfig,
-  type ProviderAdapter,
-  type ProviderCandidate,
-} from "offrouter-core";
-import { registerCancelTool } from "./tools/cancel.js";
-import { registerDelegateTool } from "./tools/delegate.js";
-import { registerExplainDecisionTool } from "./tools/explain.js";
-import { registerRouteTool } from "./tools/route.js";
-import { registerStatusTool } from "./tools/status.js";
-
-export interface OffRouterMcpContextOptions {
-  policy: PolicyConfig;
-  candidates: ProviderCandidate[];
-  adapters: Record<string, ProviderAdapter>;
-  configuredProfiles: string[];
-  configuredProviders: string[];
-  /** Optional overrides for delegation (tests). */
-  delegation?: Partial<
-    Pick<DelegationRuntimeOptions, "audit" | "now" | "includePromptPreview">
-  >;
-}
-
-export interface OffRouterMcpContext {
-  policy: PolicyConfig;
-  candidates: ProviderCandidate[];
-  adapters: Record<string, ProviderAdapter>;
-  configuredProfiles: string[];
-  configuredProviders: string[];
-  /** In-process delegation runtime for this MCP server instance. */
-  runtime: DelegationRuntime;
-}
-
-export interface LoadOffRouterMcpContextOptions extends Pick<
-  LoadConfigOptions,
-  "env" | "homedir" | "workspaceTrusted"
-> {
-  cwd?: string;
-}
-
-function uniqueSorted(values: string[]): string[] {
-  return [...new Set(values)].sort((a, b) => a.localeCompare(b));
-}
-
-export function createOffRouterMcpContext(
-  options: OffRouterMcpContextOptions,
-): OffRouterMcpContext {
-  const runtime = new DelegationRuntime({
-    adapters: options.adapters,
-    candidates: options.candidates,
-    policy: options.policy,
-    ...options.delegation,
-  });
-
-  return {
-    policy: options.policy,
-    candidates: options.candidates,
-    adapters: options.adapters,
-    configuredProfiles: [...options.configuredProfiles],
-    configuredProviders: [...options.configuredProviders],
-    runtime,
-  };
-}
-
-export async function loadOffRouterMcpContext(
-  options: LoadOffRouterMcpContextOptions = {},
-): Promise<OffRouterMcpContext> {
-  const cwd = options.cwd ?? process.cwd();
-  const config = await loadConfig({
-    env: options.env,
-    homedir: options.homedir,
-    workspaceDir: cwd,
-    workspaceTrusted: options.workspaceTrusted ?? false,
-  });
-
-  return createOffRouterMcpContext({
-    policy: config.policy,
-    // Provider discovery supplies candidates/adapters in later phases. The
-    // default stdio server should not claim a route it cannot invoke.
-    candidates: [],
-    adapters: {},
-    configuredProfiles: uniqueSorted([
-      ...config.policy.allowlistedProfiles,
-      ...Object.keys(config.profiles),
-    ]),
-    configuredProviders: uniqueSorted(
-      Object.values(config.providers)
-        .filter((provider) => provider.enabled)
-        .map((provider) => provider.id),
-    ),
-  });
-}
-
-export function createOffRouterMcpServer(
-  context: OffRouterMcpContext,
-): McpServer {
-  const server = new McpServer({
-    name: "offrouter",
-    version: "0.0.0",
-  });
-
-  registerRouteTool(server, context);
-  registerDelegateTool(server, context);
-  registerStatusTool(server, context);
-  registerExplainDecisionTool(server, context);
-  registerCancelTool(server, context);
-
-  return server;
-}
-
-/** Stable-ish task id generator for callers that omit taskId. */
-export function newTaskId(prefix = "task"): string {
-  return `${prefix}_${randomBytes(8).toString("hex")}`;
-}

package/src/tools/cancel.ts

@@ -1,73 +0,0 @@
-import type { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
-import { z } from "zod";
-import type { OffRouterMcpContext } from "../server.js";
-
-const inputSchema = {
-  taskId: z.string().min(1),
-};
-
-const outputSchema = {
-  cancelled: z.boolean(),
-  task: z.record(z.unknown()).optional(),
-  error: z
-    .object({
-      code: z.string(),
-      message: z.string(),
-    })
-    .optional(),
-};
-
-/**
- * Cancel a same-process background delegation task started by this MCP server.
- */
-export function registerCancelTool(
-  server: McpServer,
-  context: OffRouterMcpContext,
-): void {
-  server.registerTool(
-    "offrouter_cancel",
-    {
-      title: "OffRouter cancel",
-      description:
-        "Cancel an active background delegation task that lives in this MCP server process only.",
-      inputSchema,
-      outputSchema,
-    },
-    async (args) => {
-      const task = await context.runtime.cancel(args.taskId);
-      if (!task) {
-        const structuredContent = {
-          cancelled: false,
-          task: undefined,
-          error: {
-            code: "unknown_task",
-            message: `No active task found for ${args.taskId}.`,
-          },
-        };
-        return {
-          content: [
-            {
-              type: "text" as const,
-              text: JSON.stringify(structuredContent, null, 2),
-            },
-          ],
-          structuredContent,
-        };
-      }
-
-      const structuredContent = {
-        cancelled: task.status === "cancelled",
-        task,
-      };
-      return {
-        content: [
-          {
-            type: "text" as const,
-            text: JSON.stringify(structuredContent, null, 2),
-          },
-        ],
-        structuredContent,
-      };
-    },
-  );
-}

package/src/tools/delegate.ts

@@ -1,225 +0,0 @@
-import type { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
-import {
-  DelegationPolicyError,
-  RouteRequestSchema,
-  type DelegationMode,
-  type DelegationEvent,
-  type DelegationOutput,
-  type DelegationRequest,
-} from "offrouter-core";
-import { z } from "zod";
-import { newTaskId, type OffRouterMcpContext } from "../server.js";
-
-const ModeSchema = z.enum(["oneshot", "stream", "background"]);
-const OutputSchema = z.enum(["text", "json", "patch"]);
-
-const inputSchema = {
-  prompt: z.string().min(1),
-  route: RouteRequestSchema,
-  mode: ModeSchema.default("oneshot"),
-  output: OutputSchema.default("text"),
-  taskId: z.string().min(1).optional(),
-  model: z.string().min(1).optional(),
-  providerId: z.string().min(1).optional(),
-  maxOutputTokens: z.number().int().positive().optional(),
-  temperature: z.number().optional(),
-};
-
-const outputSchema = {
-  result: z.record(z.unknown()).optional(),
-  decision: z.record(z.unknown()).optional(),
-  task: z.record(z.unknown()).optional(),
-};
-
-function toDelegationRequest(args: {
-  prompt: string;
-  route: DelegationRequest["route"];
-  mode: DelegationMode;
-  output: DelegationOutput;
-  taskId?: string;
-  model?: string;
-  providerId?: string;
-  maxOutputTokens?: number;
-  temperature?: number;
-}): DelegationRequest {
-  return {
-    taskId: args.taskId ?? newTaskId(),
-    mode: args.mode,
-    output: args.output,
-    prompt: args.prompt,
-    route: args.route,
-    model: args.model,
-    providerId: args.providerId,
-    maxOutputTokens: args.maxOutputTokens,
-    temperature: args.temperature,
-  };
-}
-
-export function registerDelegateTool(
-  server: McpServer,
-  context: OffRouterMcpContext,
-): void {
-  server.registerTool(
-    "offrouter_delegate",
-    {
-      title: "OffRouter delegate",
-      description:
-        "Route then invoke an allowed provider. Full prompt is only sent after policy allows. Background tasks run only in this MCP process.",
-      inputSchema,
-      outputSchema,
-    },
-    async (args) => {
-      const mode = (args.mode ?? "oneshot") as DelegationMode;
-      const output = (args.output ?? "text") as DelegationOutput;
-      const request = toDelegationRequest({
-        prompt: args.prompt,
-        route: args.route,
-        mode,
-        output,
-        taskId: args.taskId,
-        model: args.model,
-        providerId: args.providerId,
-        maxOutputTokens: args.maxOutputTokens,
-        temperature: args.temperature,
-      });
-
-      if (mode === "background") {
-        try {
-          const task = await context.runtime.startBackground(request);
-          const structuredContent = { task };
-          return {
-            content: [
-              {
-                type: "text" as const,
-                text: JSON.stringify(structuredContent, null, 2),
-              },
-            ],
-            structuredContent,
-          };
-        } catch (err) {
-          if (err instanceof DelegationPolicyError) {
-            const structuredContent = {
-              task: {
-                taskId: request.taskId,
-                status: "failed",
-              },
-              decision: err.decision,
-              result: {
-                status: "failed",
-                error: err.message,
-              },
-            };
-            return {
-              content: [
-                {
-                  type: "text" as const,
-                  text: JSON.stringify(structuredContent, null, 2),
-                },
-              ],
-              structuredContent,
-            };
-          }
-          throw err;
-        }
-      }
-
-      if (mode === "stream") {
-        try {
-          const events: DelegationEvent[] = [];
-          for await (const event of context.runtime.stream(request)) {
-            events.push(event);
-          }
-          const task = context.runtime.getTask(request.taskId);
-          const structuredContent = {
-            result: {
-              status: task?.status ?? "failed",
-              text: task?.text,
-              error: task?.error,
-              taskId: request.taskId,
-              events,
-            },
-            decision: task?.decision,
-          };
-          return {
-            content: [
-              {
-                type: "text" as const,
-                text: JSON.stringify(structuredContent, null, 2),
-              },
-            ],
-            structuredContent,
-          };
-        } catch (err) {
-          if (err instanceof DelegationPolicyError) {
-            const structuredContent = {
-              result: {
-                status: "failed",
-                error: err.message,
-                taskId: request.taskId,
-                events: context.runtime.getTask(request.taskId)?.events ?? [],
-              },
-              decision: err.decision,
-            };
-            return {
-              content: [
-                {
-                  type: "text" as const,
-                  text: JSON.stringify(structuredContent, null, 2),
-                },
-              ],
-              structuredContent,
-            };
-          }
-          throw err;
-        }
-      }
-
-      // oneshot
-      try {
-        const result = await context.runtime.delegate({
-          ...request,
-          mode: "oneshot",
-        });
-        const structuredContent = {
-          result: {
-            status: result.status,
-            text: result.text,
-            error: result.error,
-            taskId: result.taskId,
-          },
-          decision: result.decision,
-        };
-        return {
-          content: [
-            {
-              type: "text" as const,
-              text: JSON.stringify(structuredContent, null, 2),
-            },
-          ],
-          structuredContent,
-        };
-      } catch (err) {
-        if (err instanceof DelegationPolicyError) {
-          const structuredContent = {
-            result: {
-              status: "failed",
-              error: err.message,
-              taskId: request.taskId,
-            },
-            decision: err.decision,
-          };
-          return {
-            content: [
-              {
-                type: "text" as const,
-                text: JSON.stringify(structuredContent, null, 2),
-              },
-            ],
-            structuredContent,
-          };
-        }
-        throw err;
-      }
-    },
-  );
-}

package/src/tools/explain.ts

@@ -1,57 +0,0 @@
-import type { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
-import {
-  RouteRequestSchema,
-  routeRequest,
-  type RouteDecision,
-} from "offrouter-core";
-import { z } from "zod";
-import type { OffRouterMcpContext } from "../server.js";
-
-const inputSchema = {
-  route: RouteRequestSchema,
-};
-
-const outputSchema = {
-  decision: z.record(z.unknown()),
-  explanation: z.string(),
-};
-
-/**
- * offrouter_explain_decision — same scoring path as route, named for harness
- * agents that want an explicit explain call.
- */
-export function registerExplainDecisionTool(
-  server: McpServer,
-  context: OffRouterMcpContext,
-): void {
-  server.registerTool(
-    "offrouter_explain_decision",
-    {
-      title: "OffRouter explain decision",
-      description:
-        "Explain why OffRouter would choose (or block) a route for the given request.",
-      inputSchema,
-      outputSchema,
-    },
-    async (args) => {
-      const decision: RouteDecision = routeRequest(
-        args.route,
-        context.candidates,
-        context.policy,
-      );
-      const structuredContent = {
-        decision,
-        explanation: decision.explanation,
-      };
-      return {
-        content: [
-          {
-            type: "text" as const,
-            text: JSON.stringify(structuredContent, null, 2),
-          },
-        ],
-        structuredContent,
-      };
-    },
-  );
-}

package/src/tools/route.ts

@@ -1,49 +0,0 @@
-import type { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
-import {
-  RouteRequestSchema,
-  routeRequest,
-  type RouteDecision,
-} from "offrouter-core";
-import { z } from "zod";
-import type { OffRouterMcpContext } from "../server.js";
-
-const inputSchema = {
-  route: RouteRequestSchema,
-};
-
-const outputSchema = {
-  decision: z.record(z.unknown()),
-};
-
-export function registerRouteTool(
-  server: McpServer,
-  context: OffRouterMcpContext,
-): void {
-  server.registerTool(
-    "offrouter_route",
-    {
-      title: "OffRouter route",
-      description:
-        "Select a model route for a request using OffRouter policy and ranking. Uses prompt digest/preview only.",
-      inputSchema,
-      outputSchema,
-    },
-    async (args) => {
-      const decision: RouteDecision = routeRequest(
-        args.route,
-        context.candidates,
-        context.policy,
-      );
-      const structuredContent = { decision };
-      return {
-        content: [
-          {
-            type: "text" as const,
-            text: JSON.stringify(structuredContent, null, 2),
-          },
-        ],
-        structuredContent,
-      };
-    },
-  );
-}

package/src/tools/status.ts

@@ -1,74 +0,0 @@
-import type { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
-import { z } from "zod";
-import type { OffRouterMcpContext } from "../server.js";
-
-const inputSchema = {};
-
-const outputSchema = {
-  status: z.object({
-    configuredProfiles: z.array(z.string()),
-    configuredProviders: z.array(z.string()),
-    registeredAdapters: z.array(z.string()),
-    invokableProviders: z.array(z.string()),
-    configuredButNotInvokableProviders: z.array(z.string()),
-    candidateCount: z.number().int().nonnegative(),
-    activeTasks: z.number().int().nonnegative(),
-  }),
-};
-
-export function registerStatusTool(
-  server: McpServer,
-  context: OffRouterMcpContext,
-): void {
-  server.registerTool(
-    "offrouter_status",
-    {
-      title: "OffRouter status",
-      description:
-        "Report configured profiles/providers and active in-process delegation task count for this MCP server.",
-      inputSchema,
-      outputSchema,
-    },
-    async () => {
-      const activeTasks = context.runtime
-        .listTasks()
-        .filter((t) => t.status === "running" || t.status === "queued").length;
-      const registeredAdapters = Object.keys(context.adapters).sort((a, b) =>
-        a.localeCompare(b),
-      );
-      const candidateProviders = new Set(
-        context.candidates.map((candidate) => candidate.providerId),
-      );
-      const invokableProviders = registeredAdapters.filter((providerId) =>
-        candidateProviders.has(providerId),
-      );
-      const invokable = new Set(invokableProviders);
-      const configuredButNotInvokableProviders =
-        context.configuredProviders.filter(
-          (providerId) => !invokable.has(providerId),
-        );
-
-      const structuredContent = {
-        status: {
-          configuredProfiles: [...context.configuredProfiles],
-          configuredProviders: [...context.configuredProviders],
-          registeredAdapters,
-          invokableProviders,
-          configuredButNotInvokableProviders,
-          candidateCount: context.candidates.length,
-          activeTasks,
-        },
-      };
-
-      return {
-        content: [
-          {
-            type: "text" as const,
-            text: JSON.stringify(structuredContent, null, 2),
-          },
-        ],
-        structuredContent,
-      };
-    },
-  );
-}

package/tsconfig.json

@@ -1,10 +0,0 @@
-{
-  "extends": "../../tsconfig.base.json",
-  "compilerOptions": {
-    "rootDir": "src",
-    "outDir": "dist"
-  },
-  "include": ["src/**/*.ts"],
-  "exclude": ["src/**/*.test.ts"],
-  "references": [{ "path": "../core" }]
-}