@fitchmultz/pi-mcp-adapter 6.0.0 → 7.1.0

package/resource-tools.ts

@@ -1,52 +0,0 @@
-import type { McpExtensionState } from "./state.ts";
-import { isServerDisabled, isToolAllowed, resolveToolPrefix, type McpOperationContext, type McpToolCallIdentity } from "./types.ts";
-import { executeCall, prepareMcpConnection } from "./proxy-modes.ts";
-import { paginate } from "./search-ranking.ts";
-import { throwIfAborted } from "./abort.ts";
-import { combineAbortSignals } from "./runtime-owner.ts";
-
-export async function executeResourceList(state: McpExtensionState, server: string, limit = 12, offset = 0, signal?: AbortSignal) {
-  throwIfAborted(combineAbortSignals(state.owner?.signal, signal));
-  const definition = state.config.mcpServers[server];
-  if (!definition || isServerDisabled(definition)) {
-    return { content: [{ type: "text" as const, text: `Server "${server}" is ${definition ? "disabled" : "not configured"}.` }], details: { mode: "resources", server, error: definition ? "server_disabled" : "server_not_found" } };
-  }
-  if (!state.toolMetadata.has(server) || state.manager.getConnection(server)?.status === "connected") {
-    const prepared = await prepareMcpConnection(state, server, signal);
-    if (prepared.error) return prepared.error;
-  }
-  const prefix = resolveToolPrefix(definition, state.config.settings?.toolPrefix);
-  const page = paginate((state.toolMetadata.get(server) ?? [])
-    .filter(tool => tool.resourceUri !== undefined && definition.exposeResources !== false
-      && isToolAllowed(tool.originalName, server, prefix, definition.includeTools, definition.excludeTools))
-    .map(tool => tool.resourceDescriptor ?? { uri: tool.resourceUri!, description: tool.description }), offset, limit);
-  return { content: [{ type: "text" as const, text: JSON.stringify({ server, ...page }, null, 2) }], details: { mode: "resources", server, ...page } };
-}
-
-export async function executeResourceRead(
-  state: McpExtensionState,
-  server: string,
-  uri: string,
-  signal?: AbortSignal,
-  identity: McpToolCallIdentity = {},
-  beforeDispatch?: (signal: AbortSignal | undefined, operation: McpOperationContext) => Promise<void>,
-  raw = false,
-) {
-  return executeCall(state, uri, {}, server, undefined, signal, identity, beforeDispatch, { resourceUri: uri, raw });
-}
-
-export function resourceNameToToolName(name: string): string {
-  let result = name
-    .replace(/[^a-zA-Z0-9]/g, "_")
-    .replace(/_+/g, "_")
-    .replace(/^_+/, "")  // Remove leading underscores
-    .replace(/_+$/, "")  // Remove trailing underscores
-    .toLowerCase();
-  
-  // Ensure we have a valid name
-  if (!result || /^\d/.test(result)) {
-    result = "resource" + (result ? "_" + result : "");
-  }
-  
-  return result;
-}

package/runtime-owner.ts

@@ -1,123 +0,0 @@
-import type { McpCheckpointEvent } from "./checkpoint.ts";
-import type { ExtensionUIContext } from "@earendil-works/pi-coding-agent";
-import { formatTerminalError } from "./utils.ts";
-
-export interface McpRuntimeOwner {
-  readonly signal: AbortSignal;
-  isActive(): boolean;
-  addCleanup(cleanup: () => void | Promise<void>): void;
-  stop(reason?: string): Promise<void>;
-  throwIfInactive(): void;
-  beforeActivity(): void;
-  holdCheckpoint(event: McpCheckpointEvent): () => void;
-  runCallback<T>(kind: "beforeExecute" | "onToolCall", run: () => Promise<T>): Promise<T>;
-  getCheckpointBlocker(): string | undefined;
-}
-
-export function createMcpRuntimeOwner(): McpRuntimeOwner {
-  const controller = new AbortController();
-  const cleanups: Array<() => void | Promise<void>> = [];
-  let stopPromise: Promise<void> | undefined;
-  let checkpoint: McpCheckpointEvent | undefined;
-  const beforeActivity = () => checkpoint?.invalidate();
-  // These two host hooks can outlive abortable() at their call sites. Count their underlying
-  // promises through settlement, without cancelling, serializing, or replaying callback work.
-  const callbacks = { beforeExecute: 0, onToolCall: 0 };
-  const getCheckpointBlocker = () => {
-    if (callbacks.beforeExecute) return "MCP beforeExecute callback is pending";
-    if (callbacks.onToolCall) return "MCP onToolCall callback is pending";
-    return undefined;
-  };
-
-  const reportCleanupFailure = (error: unknown, late: boolean) => {
-    console.error(`MCP: ${late ? "late " : ""}runtime cleanup failed: ${formatTerminalError(error)}`);
-  };
-
-  return {
-    signal: controller.signal,
-    beforeActivity,
-    getCheckpointBlocker,
-    runCallback: async (kind, run) => {
-      beforeActivity();
-      // Invocation/cancellation policy stays at the call site. In particular, an accepted
-      // tool's outcome callback may still need to persist its result during shutdown.
-      callbacks[kind]++;
-      try { return await run(); } finally { callbacks[kind]--; }
-    },
-    holdCheckpoint: event => {
-      if (checkpoint) throw new Error("MCP checkpoint is already held");
-      checkpoint = event;
-      return () => { if (checkpoint === event) checkpoint = undefined; };
-    },
-    isActive: () => !controller.signal.aborted,
-    addCleanup: cleanup => {
-      if (controller.signal.aborted) {
-        void Promise.resolve().then(cleanup).catch(error => reportCleanupFailure(error, true));
-        return;
-      }
-      cleanups.push(cleanup);
-    },
-    stop: (reason = "MCP extension runtime stopped") => {
-      if (stopPromise) return stopPromise;
-      beforeActivity();
-      controller.abort(new Error(reason));
-      const pendingCleanups = cleanups.splice(0).reverse().map(cleanup =>
-        Promise.resolve().then(cleanup),
-      );
-      stopPromise = Promise.allSettled(pendingCleanups).then(results => {
-        const failures = results.flatMap(result => result.status === "rejected" ? [result.reason] : []);
-        const pendingCallback = getCheckpointBlocker();
-        if (pendingCallback) failures.push(new Error(pendingCallback));
-        if (failures.length > 0) {
-          const aggregate = new AggregateError(failures, "MCP runtime cleanup failed");
-          console.error(`MCP: runtime cleanup failed: ${formatTerminalError(aggregate)}`);
-          throw aggregate;
-        }
-      });
-      return stopPromise;
-    },
-    throwIfInactive: () => { beforeActivity(); controller.signal.throwIfAborted(); },
-  };
-}
-
-export function combineAbortSignals(...signals: Array<AbortSignal | undefined>): AbortSignal | undefined {
-  const active = signals.filter((signal): signal is AbortSignal => signal !== undefined);
-  if (active.length === 0) return undefined;
-  if (active.length === 1) return active[0];
-  return AbortSignal.any(active);
-}
-
-/** Fence session-bound UI calls after the owning extension runtime stops. */
-export function createOwnedUi(ui: ExtensionUIContext, owner: McpRuntimeOwner): ExtensionUIContext {
-  const proxies = new WeakMap<object, object>();
-  const wrap = (value: unknown): unknown => {
-    if ((typeof value !== "object" || value === null) && typeof value !== "function") {
-      return value;
-    }
-    const object = value as object;
-    const existing = proxies.get(object);
-    if (existing) return existing;
-
-    const proxy = new Proxy(object, {
-      get(target, property, receiver) {
-        if (!owner.isActive()) return undefined;
-        const member = Reflect.get(target, property, receiver);
-        if (typeof member === "function") {
-          return (...args: unknown[]) => {
-            if (!owner.isActive()) return undefined;
-            return Reflect.apply(member, target, args);
-          };
-        }
-        return owner.isActive() ? wrap(member) : undefined;
-      },
-    });
-    proxies.set(object, proxy);
-    return proxy;
-  };
-  return wrap(ui) as ExtensionUIContext;
-}
-
-export function isAbortError(error: unknown, signal?: AbortSignal): boolean {
-  if (signal?.aborted) return true;
-  return error instanceof Error && (error.name === "AbortError" || error.message === "MCP extension runtime stopped");
-}

package/sampling-handler.ts

@@ -1,276 +0,0 @@
-import type { Api, AssistantMessage, Message, Model, TextContent } from "@earendil-works/pi-ai";
-import { truncateAtWord } from "./utils.ts";
-import { throwIfAborted } from "./abort.ts";
-import type { ExtensionUIContext, ModelRegistry } from "@earendil-works/pi-coding-agent";
-import type { Client } from "@modelcontextprotocol/client";
-import {
-  type CreateMessageRequest,
-  type CreateMessageResult,
-  type ModelPreferences,
-  type SamplingMessage,
-  type SamplingMessageContentBlock,
-} from "@modelcontextprotocol/client";
-
-export interface SamplingHandlerOptions {
-  serverName: string;
-  autoApprove: boolean;
-  ui?: ExtensionUIContext;
-  modelRegistry: ModelRegistry;
-  getCurrentModel: () => Model<Api> | undefined;
-  getSignal: () => AbortSignal | undefined;
-}
-
-export type ServerSamplingConfig = Omit<SamplingHandlerOptions, "serverName">;
-
-export function registerSamplingHandler(
-  client: Client,
-  options: SamplingHandlerOptions,
-  own: (run: () => Promise<CreateMessageResult>) => Promise<CreateMessageResult> = run => run(),
-): void {
-  // Own the handler's real promise, not the SDK caller's cancellable response facade.
-  client.setRequestHandler("sampling/createMessage", request => own(() => handleSamplingRequest(options, request)));
-}
-
-export async function handleSamplingRequest(
-  options: SamplingHandlerOptions,
-  request: CreateMessageRequest,
-): Promise<CreateMessageResult> {
-  const params = request.params;
-  const signal = options.getSignal();
-  throwIfAborted(signal);
-
-  if ("task" in params && params.task) {
-    throw new Error("MCP sampling tasks are not supported");
-  }
-  if (params.includeContext && params.includeContext !== "none") {
-    throw new Error("MCP sampling context inclusion is not supported");
-  }
-  if (params.tools?.length) {
-    throw new Error("MCP sampling tool use is not supported");
-  }
-  if (params.toolChoice) {
-    throw new Error("MCP sampling tool choice is not supported");
-  }
-  if (params.stopSequences?.length) {
-    throw new Error("MCP sampling stop sequences are not supported");
-  }
-
-  const messages = params.messages.map(convertSamplingMessage);
-  const model = await resolveSamplingModel(options, params.modelPreferences);
-  throwIfAborted(signal);
-  await confirmSampling(
-    options,
-    "Approve MCP sampling request",
-    formatRequestApproval(options.serverName, `${model.provider}/${model.id}`, params.systemPrompt, messages),
-  );
-  throwIfAborted(signal);
-
-  const supportsTemperature = model.compat && "supportsTemperature" in model.compat
-    ? model.compat.supportsTemperature !== false
-    : !(model.id === "gpt-6-astra" && (model.api === "openai-responses" || model.api === "openai-codex-responses"));
-  const result = await options.modelRegistry.complete(
-    model,
-    {
-      ...(params.systemPrompt !== undefined ? { systemPrompt: params.systemPrompt } : {}),
-      messages,
-    },
-    {
-      maxTokens: params.maxTokens,
-      ...(supportsTemperature && params.temperature !== undefined ? { temperature: params.temperature } : {}),
-      ...(params.metadata !== undefined ? { metadata: params.metadata as Record<string, unknown> } : {}),
-      ...(signal ? { signal } : {}),
-    },
-  );
-
-  const converted = convertAssistantResult(result);
-  throwIfAborted(signal);
-  await confirmSampling(
-    options,
-    "Return MCP sampling response",
-    formatResponseApproval(options.serverName, converted),
-  );
-  return converted;
-}
-
-function formatRequestApproval(
-  serverName: string,
-  modelName: string,
-  systemPrompt: string | undefined,
-  messages: Message[],
-): string {
-  const lines = [`${serverName} wants to sample ${messages.length} message${messages.length === 1 ? "" : "s"} with ${modelName}.`];
-  if (systemPrompt) {
-    lines.push(`System: ${truncateAtWord(systemPrompt, 400)}`);
-  }
-  for (const [index, message] of messages.entries()) {
-    lines.push(`${index + 1}. ${message.role}: ${truncateAtWord(messageText(message), 400)}`);
-  }
-  return lines.join("\n\n");
-}
-
-function formatResponseApproval(serverName: string, response: CreateMessageResult): string {
-  const text = response.content.type === "text" ? response.content.text : `[${response.content.type} content]`;
-  return `${serverName} will receive this response from ${response.model}:\n\n${truncateAtWord(text, 1000)}`;
-}
-
-function messageText(message: Message): string {
-  if (typeof message.content === "string") return message.content;
-  return message.content.map((block) => {
-    if (block.type === "text") return block.text;
-    if (block.type === "image") return `[image: ${block.mimeType}]`;
-    if (block.type === "thinking") return "[thinking]";
-    if (block.type === "toolCall") return `[tool call: ${block.name}]`;
-    return "[content]";
-  }).join("\n");
-}
-
-async function resolveSamplingModel(
-  options: SamplingHandlerOptions,
-  modelPreferences: ModelPreferences | undefined,
-): Promise<Model<Api>> {
-  const candidates: Model<Api>[] = [];
-  const availableModels = options.modelRegistry.getAvailable();
-
-  for (const hint of modelPreferences?.hints ?? []) {
-    const normalizedHint = hint.name?.trim().toLowerCase();
-    if (!normalizedHint) continue;
-    for (const model of availableModels) {
-      const searchableNames = [`${model.provider}/${model.id}`, model.id, model.name];
-      if (searchableNames.some((name) => name.toLowerCase().includes(normalizedHint))) {
-        addSamplingCandidate(candidates, model);
-      }
-    }
-  }
-
-  const currentModel = options.getCurrentModel();
-  if (currentModel) addSamplingCandidate(candidates, currentModel);
-
-  for (const model of availableModels) {
-    addSamplingCandidate(candidates, model);
-  }
-
-  const errors: string[] = [];
-  const signal = options.getSignal();
-  for (const model of candidates) {
-    throwIfAborted(signal);
-    const auth = await options.modelRegistry.getApiKeyAndHeaders(model);
-    throwIfAborted(signal);
-    if (auth.ok === false) {
-      errors.push(`${model.provider}/${model.id}: ${auth.error}`);
-      continue;
-    }
-    return model;
-  }
-
-  if (errors.length > 0) {
-    throw new Error(`No configured auth for MCP sampling model. ${errors.join("; ")}`);
-  }
-  throw new Error("No Pi model is available for MCP sampling");
-}
-
-function addSamplingCandidate(candidates: Model<Api>[], model: Model<Api>): void {
-  if (!candidates.some((candidate) => candidate.provider === model.provider && candidate.id === model.id)) {
-    candidates.push(model);
-  }
-}
-
-async function confirmSampling(options: SamplingHandlerOptions, title: string, message: string): Promise<void> {
-  if (options.autoApprove) return;
-  if (!options.ui) {
-    throw new Error("MCP sampling requires interactive approval. Set settings.samplingAutoApprove to true to allow it without UI.");
-  }
-  const approved = await options.ui.confirm(title, message);
-  if (!approved) {
-    throw new Error("MCP sampling request was declined");
-  }
-}
-
-function convertSamplingMessage(message: SamplingMessage): Message {
-  const blocks = Array.isArray(message.content) ? message.content : [message.content];
-  if (message.role === "user") {
-    return {
-      role: "user",
-      content: blocks.map(convertUserContent),
-      timestamp: Date.now(),
-    };
-  }
-
-  return {
-    role: "assistant",
-    content: blocks.map(convertAssistantContent),
-    api: "mcp-sampling",
-    provider: "mcp",
-    model: "sampling-request",
-    usage: zeroUsage(),
-    stopReason: "stop",
-    timestamp: Date.now(),
-  };
-}
-
-function convertUserContent(block: SamplingMessageContentBlock): TextContent {
-  if (block.type === "text") {
-    return { type: "text", text: block.text };
-  }
-  throw new Error(`MCP sampling ${block.type} content is not supported`);
-}
-
-function convertAssistantContent(block: SamplingMessageContentBlock): TextContent {
-  if (block.type === "text") {
-    return { type: "text", text: block.text };
-  }
-  throw new Error(`MCP sampling assistant ${block.type} content is not supported`);
-}
-
-function convertAssistantResult(message: AssistantMessage): CreateMessageResult {
-  if (message.stopReason === "error") {
-    throw new Error(message.errorMessage ?? "MCP sampling model call failed");
-  }
-  if (message.stopReason === "aborted") {
-    throw new Error(message.errorMessage ?? "MCP sampling model call was aborted");
-  }
-
-  const text = message.content
-    .map((block) => {
-      if (block.type === "text") return block.text;
-      if (block.type === "thinking") return undefined;
-      throw new Error(`MCP sampling result ${block.type} content is not supported`);
-    })
-    .filter((value): value is string => value !== undefined)
-    .join("\n\n")
-    .trim();
-
-  if (!text) {
-    throw new Error("MCP sampling result did not contain text content");
-  }
-
-  return {
-    role: "assistant",
-    content: { type: "text", text },
-    model: `${message.provider}/${message.model}`,
-    stopReason: mapStopReason(message.stopReason),
-  };
-}
-
-function mapStopReason(reason: AssistantMessage["stopReason"]): CreateMessageResult["stopReason"] {
-  if (reason === "stop") return "endTurn";
-  if (reason === "length") return "maxTokens";
-  if (reason === "toolUse") return "toolUse";
-  return reason;
-}
-
-function zeroUsage(): AssistantMessage["usage"] {
-  return {
-    input: 0,
-    output: 0,
-    cacheRead: 0,
-    cacheWrite: 0,
-    totalTokens: 0,
-    cost: {
-      input: 0,
-      output: 0,
-      cacheRead: 0,
-      cacheWrite: 0,
-      total: 0,
-    },
-  };
-}

package/scripts/build-app-bridge.mjs

@@ -1,15 +0,0 @@
-#!/usr/bin/env node
-import { build } from "esbuild";
-
-await build({
-  stdin: {
-    contents: 'export { AppBridge, PostMessageTransport } from "@modelcontextprotocol/ext-apps/app-bridge";',
-    resolveDir: process.cwd(),
-  },
-  bundle: true,
-  platform: "browser",
-  format: "esm",
-  target: "es2022",
-  minify: true,
-  outfile: process.argv[2] ?? "app-bridge.bundle.js",
-});

package/scripts/build.mjs

@@ -1,132 +0,0 @@
-#!/usr/bin/env node
-/**
- * Purpose: Produce the compiled runtime files that the Pi extension manifest loads.
- * Responsibilities: Run TypeScript emit and bundle the browser bridge into staging, copy runtime assets
- * that modules resolve as dist-relative siblings, then atomically swap it into dist/
- * so a failed TypeScript emit never destroys a previously working dist.
- * Usage: `npm run build`; also invoked by scripts/prepare.mjs during install lifecycles.
- * Invariants/Assumptions: `node_modules` provides `typescript`; deleting `dist/` is safe generated output.
- */
-
-import { execFile as execFileCallback } from "node:child_process";
-import { existsSync } from "node:fs";
-import { copyFile, readdir, rename, rm } from "node:fs/promises";
-import { join } from "node:path";
-import process from "node:process";
-import { setTimeout as delay } from "node:timers/promises";
-import { promisify } from "node:util";
-
-const execFile = promisify(execFileCallback);
-const RM_OPTIONS = { force: true, maxRetries: 5, recursive: true, retryDelay: 100 };
-const RENAME_RETRY_LIMIT = 50;
-const RENAME_RETRY_MS = 50;
-// Run tsc's JS entrypoint directly through the current node binary: no .cmd shim,
-// no shell, safe for install paths containing spaces on every platform.
-const tscPath = join(process.cwd(), "node_modules", "typescript", "bin", "tsc");
-// Runtime siblings resolved relative to the compiled module directory
-// (mcp-auth.ts, mcp-code.ts, ui-server.ts).
-const RUNTIME_ASSETS = ["mcp-keyring-helper.cjs", "mcp-script-worker.mjs"];
-
-async function discardStaging(path) {
-	try {
-		await rm(path, RM_OPTIONS);
-	} catch (error) {
-		// Cleanup is always best-effort: it must not turn a successful race loss
-		// into failure or replace the compiler/publish error that matters.
-		console.warn(`could not remove staging ${path}: ${error?.message ?? error}`);
-	}
-}
-
-function isOwnerGone(pid) {
-	try {
-		process.kill(pid, 0);
-		return false;
-	} catch (error) {
-		return error?.code === "ESRCH";
-	}
-}
-
-async function hasPublishedDist(path) {
-	try {
-		return (await readdir(path)).length > 0;
-	} catch {
-		return false;
-	}
-}
-
-async function reapStrandedStaging(cwd) {
-	// Signal 0 proves only that the owner was gone at probe time. Pid reuse
-	// between this probe and removal is inherent to pid-based reaping.
-	for (const entry of await readdir(cwd, { withFileTypes: true })) {
-		const match = /^dist\.staging\.(\d+)$/.exec(entry.name);
-		if (!match || !entry.isDirectory()) continue;
-		const ownerPid = Number(match[1]);
-		if (ownerPid === process.pid || !isOwnerGone(ownerPid)) continue;
-		await discardStaging(join(cwd, entry.name));
-	}
-}
-
-async function compileToStaging(cwd, stagingDir) {
-	try {
-		const { stderr, stdout } = await execFile(
-			process.execPath,
-			[tscPath, "-p", "tsconfig.build.json", "--outDir", stagingDir],
-			{ cwd, maxBuffer: 10 * 1024 * 1024 },
-		);
-		if (stdout) process.stdout.write(stdout);
-		if (stderr) process.stderr.write(stderr);
-		await execFile(process.execPath, [join(cwd, "scripts", "build-app-bridge.mjs"), join(stagingDir, "app-bridge.bundle.js")], { cwd });
-		for (const asset of RUNTIME_ASSETS) await copyFile(join(cwd, asset), join(stagingDir, asset));
-	} catch (error) {
-		if (error?.stdout) process.stdout.write(error.stdout);
-		if (error?.stderr) process.stderr.write(error.stderr);
-		await discardStaging(stagingDir);
-		throw error;
-	}
-}
-
-async function publishStaging(stagingDir, distDir) {
-	try {
-		// A failed dist removal must fail loudly; keep it outside the retry loop.
-		// Remove dist exactly once so retries never delete a concurrent winner.
-		await rm(distDir, RM_OPTIONS);
-		for (let retry = 0; ; retry++) {
-			try {
-				await rename(stagingDir, distDir);
-				return;
-			} catch (error) {
-				// A completed staged build is non-empty; a bare directory is not proof
-				// that a concurrent publisher won the race.
-				if (await hasPublishedDist(distDir)) {
-					console.warn("dist/ was published by a concurrent build; discarding this build's staging tree.");
-					return;
-				}
-				// At most 50 retries (~2.5s) keep persistent filesystem errors bounded.
-				if (existsSync(stagingDir) && retry < RENAME_RETRY_LIMIT) {
-					await delay(RENAME_RETRY_MS);
-					continue;
-				}
-				throw error;
-			}
-		}
-	} finally {
-		// Safe after success too: rename moved stagingDir, so force makes this a no-op.
-		await discardStaging(stagingDir);
-	}
-}
-
-async function main() {
-	const cwd = process.cwd();
-	if (!existsSync(tscPath)) throw new Error(`typescript is not installed at ${tscPath}; run npm install first.`);
-	await reapStrandedStaging(cwd);
-	// Pid-scoped staging isolates concurrent emits; only a complete tree publishes.
-	const stagingDir = join(cwd, `dist.staging.${process.pid}`);
-	await rm(stagingDir, RM_OPTIONS);
-	await compileToStaging(cwd, stagingDir);
-	await publishStaging(stagingDir, join(cwd, "dist"));
-}
-
-main().catch((error) => {
-	console.error(error instanceof Error ? error.message : String(error));
-	process.exitCode = 1;
-});