pi-mcp-adapter 3.1.0 → 3.3.0

package/init.ts

@@ -3,7 +3,7 @@ import type { McpExtensionState } from "./state.ts";
 import { formatToolName, isServerDisabled, resolveToolPrefix, type McpAdapterOptions, type PromptMetadata, type ToolMetadata, type ToolSelectorCandidateIndex } from "./types.ts";
 import { existsSync } from "node:fs";
 import { cloneMcpConfig, loadMcpConfig, resolveConfiguredClaudePluginMcp } from "./config.ts";
-import { applyProjectServerTrustToConfig, describeProjectServerBlock } from "./project-server-trust.ts";
+import { applyProjectServerTrustToConfig, describeProjectServerBlock, excludeProjectServersAtLoadTime } from "./project-server-trust.ts";
 import { ConsentManager } from "./consent-manager.ts";
 import { McpLifecycleManager } from "./lifecycle.ts";
 import {
@@ -104,6 +104,8 @@ type McpInitializationOptions = McpAdapterOptions & {
   oauthRuntime?: McpOAuthRuntime;
   statusEvents?: McpExtensionState["statusEvents"];
   onProjectTrustResolved?: () => void;
+  /** Load-time runs have no Pi context, so project trust is unknown; session_start decides later. */
+  excludeProjectServers?: boolean;
 };
 
 export async function initializeMcp(
@@ -142,7 +144,9 @@ export async function initializeMcp(
   const runtimeSignal = combineAbortSignals(owner.signal, initialSignal);
   const trustResult = options.config !== undefined
     ? { config: resolveConfiguredClaudePluginMcp(cloneMcpConfig(options.config), cwd), blockedServers: new Map() }
-    : await applyProjectServerTrustToConfig(loadMcpConfig(configPath, cwd), ctx);
+    : options.excludeProjectServers
+      ? { config: excludeProjectServersAtLoadTime(loadMcpConfig(configPath, cwd)), blockedServers: new Map() }
+      : await applyProjectServerTrustToConfig(loadMcpConfig(configPath, cwd), ctx);
   options.onProjectTrustResolved?.();
   const config = trustResult.config;
   const authStorageOptions = getAuthStorageOptions(config.settings?.oauthDir, cwd, config.settings?.oauthCredentialStore);
@@ -593,6 +597,7 @@ export function updateMetadataCache(
   if (!definition || isServerDisabled(definition)) return;
 
   const configHash = computeServerHash(definition);
+  if (connection.definition && computeServerHash(connection.definition) !== configHash) return;
   const existing = loadMetadataCache();
   const existingEntry = existing?.servers?.[serverName];
 
@@ -602,13 +607,13 @@ export function updateMetadataCache(
     ? existingEntry?.configHash === configHash ? existingEntry.prompts : undefined
     : serializePrompts(connection.prompts ?? []);
 
-  if (
-    definition.exposeResources !== false &&
-    connection.resourceDiscoveryFailed === true &&
-    existingEntry?.resources?.length &&
-    isServerCacheValid(existingEntry, definition)
-  ) {
-    resources = existingEntry.resources;
+  if (definition.exposeResources !== false && connection.resourceDiscoveryFailed === true) {
+    const sessionEntry = state.sessionMetadata?.get(serverName);
+    if (sessionEntry?.configHash === configHash) {
+      resources = sessionEntry.resources ?? [];
+    } else if (existingEntry?.resources?.length && isServerCacheValid(existingEntry, definition)) {
+      resources = existingEntry.resources;
+    }
   }
 
   const entry: ServerCacheEntry = {
@@ -622,6 +627,7 @@ export function updateMetadataCache(
     cachedAt: Date.now(),
   };
 
+  (state.sessionMetadata ??= new Map()).set(serverName, entry);
   saveMetadataCache({ version: 1, servers: { [serverName]: entry } });
 }
 

package/jev-client.ts

@@ -2,7 +2,7 @@ import { TypeSafeClient } from "@typesafe-ai/sdk";
 import type { McpExtensionState } from "./state.ts";
 import { isServerDisabled } from "./types.ts";
 import { combineAbortSignals } from "./runtime-owner.ts";
-import { JEV_SDK_PATH, resolveJevCredential, resolveJevEndpoint, type JevCredentialResolution, type ResolvedJevEndpoint } from "./jev-key-store.ts";
+import { JEV_SDK_PATH, OPENROUTER_ORIGIN, resolveJevCredential, resolveJevEndpoint, type JevCredentialResolution, type ResolvedJevEndpoint } from "./jev-key-store.ts";
 import type { JevAnswer, JevBudget, JevEvaluateInput, JevEvaluationData, JevEvaluationEnvelope, JevJson, JevQuestion, ResolvedJevSettings } from "./jev-contracts.ts";
 
 export type { ResolvedJevSettings } from "./jev-contracts.ts";
@@ -15,6 +15,8 @@ const DEFAULTS: ResolvedJevSettings = {
   semanticMinProbability: 0.2,
 };
 const DANGEROUS_KEYS = new Set(["__proto__", "constructor", "prototype"]);
+/** OpenRouter's name for Jev, used there when `settings.jev.model` is not configured. */
+const OPENROUTER_DEFAULT_MODEL = "typesafe/jev-1.13";
 
 type JevSettingsInput = Partial<ResolvedJevSettings>;
 type Host = { endpoint: ResolvedJevEndpoint; client: TypeSafeClient };
@@ -192,8 +194,8 @@ function sameKeys(actual: Record<string, unknown>, expected: string[]): boolean
   return keys.length === expected.length && expected.every(key => Object.hasOwn(actual, key));
 }
 function validateResponse(value: unknown, input: JevEvaluateInput): JevEvaluationData {
+  // Providers may add metadata such as `id`, `provider`, or `usage.cost`; only the fields validated here are kept.
   const response = record(value, "response");
-  exactKeys(response, ["model", "answers", "usage"], "response");
   const answers = record(response.answers, "response answers");
   const questionNames = Object.keys(input.questions);
   if (!sameKeys(answers, questionNames)) throw new Error("Response answer keys do not match questions");
@@ -224,7 +226,6 @@ function validateResponse(value: unknown, input: JevEvaluateInput): JevEvaluatio
   }
   if (typeof response.model !== "string" || response.model.length === 0 || response.model.length > 128) throw new Error("Invalid response model");
   const usage = record(response.usage, "response usage");
-  if (!sameKeys(usage, ["input_tokens", "output_tokens"])) throw new Error("Invalid response usage");
   return { answers: validated, model: response.model, usage: { inputTokens: safeNumber(usage.input_tokens, "input tokens", true), outputTokens: safeNumber(usage.output_tokens, "output tokens", true) } };
 }
 
@@ -291,7 +292,9 @@ export async function evaluateJev(state: McpExtensionState, value: JevEvaluateIn
   const timer = setTimeout(() => { timedOut = true; deadline.abort(new Error("Jev evaluation deadline exceeded")); }, settings.requestTimeoutMs);
   const signal = combineAbortSignals(options.signal, state.owner.signal, deadline.signal);
   try {
-    const request = { state: input.state, questions: input.questions, model: settings.model };
+    const configured = state.config.settings?.jev;
+    const model = resolved.endpoint.origin === OPENROUTER_ORIGIN && (!configured || configured.model === undefined) ? OPENROUTER_DEFAULT_MODEL : settings.model;
+    const request = { state: input.state, questions: input.questions, model };
     const raw = await resolved.client.systemOne(request as Parameters<TypeSafeClient["systemOne"]>[0], { ...(signal ? { signal } : {}), timeout: settings.requestTimeoutMs, retry: { maxRetries: settings.maxRetries } });
     try { return { ok: true, data: validateResponse(raw, input) }; }
     catch { return { ok: false, error: { code: "invalid_response", message: "Jev returned an invalid response." } }; }

package/jev-key-store.ts

@@ -6,6 +6,9 @@ const SYSTEMONE_ENDPOINT_ENV = "SYSTEMONE_ENDPOINT";
 const SYSTEMONE_API_KEY_ENV = "SYSTEMONE_API_KEY";
 /** TypeSafe-issued key: honored only for the default endpoint and never sent anywhere else. */
 const LEGACY_TYPESAFE_API_KEY_ENV = "TYPESAFE_API_KEY";
+/** OpenRouter's general-purpose key: honored only for an OpenRouter endpoint and never sent anywhere else. */
+const OPENROUTER_API_KEY_ENV = "OPENROUTER_API_KEY";
+export const OPENROUTER_ORIGIN = "https://openrouter.ai";
 /** Origin recorded in version 1 credential records. */
 export const TYPESAFE_API_ORIGIN = "https://api.typesafe.ai";
 /** Version 1 credential account, still read for the default endpoint. */
@@ -158,6 +161,10 @@ export function resolveJevCredential(
     try { return { status: "present", source: "environment", apiKey: validateApiKey(env[LEGACY_TYPESAFE_API_KEY_ENV]) }; }
     catch { return { status: "unavailable", message: `${LEGACY_TYPESAFE_API_KEY_ENV} is present but invalid.` }; }
   }
+  if (target.origin === OPENROUTER_ORIGIN && Object.hasOwn(env, OPENROUTER_API_KEY_ENV)) {
+    try { return { status: "present", source: "environment", apiKey: validateApiKey(env[OPENROUTER_API_KEY_ENV]) }; }
+    catch { return { status: "unavailable", message: `${OPENROUTER_API_KEY_ENV} is present but invalid.` }; }
+  }
   let stored: string | undefined;
   try { stored = readStoredKey(secretStore, target); }
   catch (error) {

package/mcp-callback-server.ts

@@ -8,6 +8,7 @@
 import { createServer, type Server, type IncomingMessage, type ServerResponse } from "http"
 import { getAppName } from "./agent-dir.ts"
 import {
+  DEFAULT_OAUTH_CALLBACK_HOST,
   DEFAULT_OAUTH_CALLBACK_PATH,
   getConfiguredOAuthCallbackPort,
   getOAuthCallbackPath,
@@ -197,7 +198,6 @@ interface EnsureCallbackServerOptions {
   reserveState?: boolean
 }
 
-const DEFAULT_OAUTH_CALLBACK_HOST = "localhost"
 let callbackServerHost = DEFAULT_OAUTH_CALLBACK_HOST
 
 /**

package/mcp-code.ts

@@ -3,7 +3,7 @@ import { formatWithOptions } from "node:util";
 import { Worker } from "node:worker_threads";
 import { throwIfAborted } from "./abort.ts";
 import { guardMcpOutput, guardedMcpDetails, resolveMcpOutputGuardOptions } from "./mcp-output-guard.ts";
-import { loadMcpScriptWasm } from "./mcp-script-wasm.ts";
+import { loadMcpScriptWasm, resolveMcpScriptQuickJsUrl } from "./mcp-script-wasm.ts";
 import { evaluateJev, validateJevSettings } from "./jev-client.ts";
 import type { JevErrorCode, JevEvaluateInput, JevEvaluationEnvelope } from "./jev-contracts.ts";
 import { executeCall } from "./proxy-modes.ts";
@@ -14,6 +14,7 @@ import { isServerInActiveFailureBackoff } from "./failure-backoff.ts";
 import type { McpExtensionState } from "./state.ts";
 import { findToolByName, formatSchema, hasSchemaDescriptions } from "./tool-metadata.ts";
 import { renderTsShape } from "./ts-shape.ts";
+import { getObservedOutput, renderOutputShape } from "./output-shape.ts";
 import type { ContentBlock } from "./types.ts";
 
 export const DEFAULT_MCP_SCRIPT_TIMEOUT_MS = 30_000;
@@ -338,6 +339,7 @@ export async function runMcpScript(
         if (!tool) continue;
         const inputShape = tool.inputSchema ? renderTsShape(tool.inputSchema) : null;
         const inputTypeScript = inputShape ?? (tool.inputSchema ? formatSchema(tool.inputSchema) : null);
+        const observed = tool.resourceUri ? undefined : getObservedOutput(state, server, tool);
         return {
           path: tool.name,
           name: tool.originalName,
@@ -350,6 +352,14 @@ export async function runMcpScript(
             outputSchemaTarget: "data.structuredContent",
             outputSchema: tool.outputSchema,
           } : {}),
+          ...(tool.annotations ? { annotations: tool.annotations } : {}),
+          ...(observed ? {
+            observedOutput: {
+              target: observed.source === "structuredContent" ? "data.structuredContent" : "JSON.parse(data.content[0].text)",
+              typeScript: renderOutputShape(observed.shape),
+              calls: observed.calls,
+            },
+          } : {}),
         };
       }
       const suggestions = path ? rankSuggestions(state, path, 5) : [];
@@ -408,7 +418,7 @@ export async function runMcpScript(
   try {
     const wasm = await Promise.race([loadMcpScriptWasm(), timeout, aborted]);
     worker = new Worker(new URL("./mcp-script-worker.mjs", import.meta.url), {
-      workerData: { code, wasm, interrupt, outputMaxBytes: MCP_SCRIPT_OUTPUT_MAX_BYTES },
+      workerData: { code, wasm, quickjsUrl: resolveMcpScriptQuickJsUrl(), interrupt, outputMaxBytes: MCP_SCRIPT_OUTPUT_MAX_BYTES },
       env: {},
       // The sandbox cannot open files, and the host always terminates this worker.
       // Disable Node's unmanaged FD bookkeeping, which emits false warnings when

package/mcp-oauth-provider.ts

@@ -89,6 +89,9 @@ function toOAuthTokens(tokens: StoredTokens): IssuerBoundTokens {
 }
 
 // Callback server configuration
+// RFC 8252 section 7.3: use the loopback IP literal, not "localhost". The
+// callback listener binds this same host so the advertised redirect reaches it.
+const DEFAULT_OAUTH_CALLBACK_HOST = "127.0.0.1"
 const DEFAULT_OAUTH_CALLBACK_PORT = 19876
 const DEFAULT_OAUTH_CALLBACK_PATH = "/callback"
 
@@ -287,7 +290,7 @@ export class McpOAuthProvider implements OAuthClientProvider {
     this.flowState = initialState
     this.redirectUrlSnapshot = config.grantType === "client_credentials"
       ? undefined
-      : config.redirectUri ?? `http://localhost:${getOAuthCallbackPort()}${getOAuthCallbackPath()}`
+      : config.redirectUri ?? `http://${DEFAULT_OAUTH_CALLBACK_HOST}:${getOAuthCallbackPort()}${getOAuthCallbackPath()}`
   }
 
   setAuthFetch(fetchFn: OAuthFetch): void {
@@ -816,4 +819,4 @@ export class McpOAuthProvider implements OAuthClientProvider {
   }
 }
 
-export { DEFAULT_OAUTH_CALLBACK_PORT, DEFAULT_OAUTH_CALLBACK_PATH }
+export { DEFAULT_OAUTH_CALLBACK_HOST, DEFAULT_OAUTH_CALLBACK_PORT, DEFAULT_OAUTH_CALLBACK_PATH }

package/mcp-script-wasm.ts

@@ -1,12 +1,29 @@
 import { readFile } from "node:fs/promises";
 import { createRequire } from "node:module";
+import { pathToFileURL } from "node:url";
 
 export type McpScriptWasmModule = object;
 
 const cached = new Map<string, Promise<McpScriptWasmModule>>();
 
+function resolveQuickJsWasmPath(): string {
+  return createRequire(import.meta.url).resolve("quickjs-wasi/quickjs.wasm");
+}
+
+/**
+ * Resolve the quickjs-wasi entry on the host thread. The worker imports this
+ * file URL because Bun-compiled executables cannot resolve bare package names
+ * from a worker file loaded from disk.
+ * Those executables also fail to resolve the bare `quickjs-wasi` root on the
+ * host thread, while package subpaths resolve. So the entry is located next to
+ * the wasm file, which is how quickjs-wasi's `"."` export lays it out.
+ */
+export function resolveMcpScriptQuickJsUrl(): string {
+  return new URL("./dist/index.js", pathToFileURL(resolveQuickJsWasmPath())).href;
+}
+
 /** Load and compile the packaged QuickJS runtime once per host process. */
-export function loadMcpScriptWasm(path = createRequire(import.meta.url).resolve("quickjs-wasi/quickjs.wasm")): Promise<McpScriptWasmModule> {
+export function loadMcpScriptWasm(path = resolveQuickJsWasmPath()): Promise<McpScriptWasmModule> {
   let module = cached.get(path);
   if (!module) {
     const webAssembly = (globalThis as unknown as {

package/mcp-script-worker.mjs

@@ -1,16 +1,18 @@
 import { parentPort, workerData } from "node:worker_threads";
-import { JSException, MAX_STACK_SIZE, QuickJS } from "quickjs-wasi";
 
 const MEMORY_LIMIT_BYTES = 64 * 1024 * 1024;
 const ERROR_MAX_BYTES = 64 * 1024;
 const ERROR_TRUNCATION_MARKER = "\n...[mcpScript error truncated]";
 
+// Set once main() imports quickjs-wasi from the host-resolved file URL.
+let JSException;
+
 function post(message) {
   parentPort?.postMessage(message);
 }
 
 function errorText(error) {
-  if (error instanceof JSException) {
+  if (JSException && error instanceof JSException) {
     const head = error.message ? `${error.name}: ${error.message}` : error.name;
     return error.stack ? `${head}\n${error.stack}` : head;
   }
@@ -172,6 +174,11 @@ const PRELUDE_SOURCE = `(function (bridge) {
 })`;
 
 async function main() {
+  // Bun-compiled executables cannot resolve bare package names from this
+  // worker file, so import quickjs-wasi from the URL the host resolved.
+  const quickjs = await import(workerData.quickjsUrl);
+  JSException = quickjs.JSException;
+  const { MAX_STACK_SIZE, QuickJS } = quickjs;
   const interrupt = new Int32Array(workerData.interrupt);
   let outputBytes = 0;
   let outputExceeded = false;

package/metadata-cache.ts

@@ -23,6 +23,7 @@ import type {
 import { createToolSelectorCandidateIndex, formatPromptCommandName, formatToolName, getToolNameCandidates, isServerDisabled, isToolAllowed, resolveToolPrefix, resolveUniqueNameOwnership, type ToolPrefix, type ToolSelectorCandidateIndex } from "./types.ts";
 import { resourceNameToToolName } from "./resource-tools.ts";
 import {
+  extractToolAnnotations,
   extractToolUiStreamMode,
   interpolateEnvRecord,
   interpolateEnvVars,
@@ -225,6 +226,7 @@ export function reconstructToolMetadata(
     }
 
     const name = formatToolName(tool.name, serverName, effectivePrefix);
+    const annotations = extractToolAnnotations(tool.annotations);
     metadata.push({
       name,
       originalName: tool.name,
@@ -234,6 +236,7 @@ export function reconstructToolMetadata(
       ...(tool.uiResourceUri !== undefined ? { uiResourceUri: tool.uiResourceUri } : {}),
       ...(tool.uiVisibility !== undefined ? { uiVisibility: tool.uiVisibility } : {}),
       ...(tool.uiStreamMode !== undefined ? { uiStreamMode: tool.uiStreamMode } : {}),
+      ...(annotations !== undefined ? { annotations } : {}),
     });
   }
 
@@ -289,6 +292,7 @@ export function serializeTools(tools: McpTool[]): CachedTool[] {
       const uiResourceUri = tryGetToolUiResourceUri(t);
       const uiVisibility = extractUiToolVisibility(t._meta);
       const uiStreamMode = extractToolUiStreamMode(t._meta);
+      const annotations = extractToolAnnotations(t.annotations);
       return {
         name: t.name,
         ...(t.description !== undefined ? { description: t.description } : {}),
@@ -297,6 +301,7 @@ export function serializeTools(tools: McpTool[]): CachedTool[] {
         ...(uiResourceUri !== undefined ? { uiResourceUri } : {}),
         ...(uiVisibility !== undefined ? { uiVisibility } : {}),
         ...(uiStreamMode !== undefined ? { uiStreamMode } : {}),
+        ...(annotations !== undefined ? { annotations } : {}),
       };
     });
 }

package/namespace-tools.ts

@@ -190,6 +190,10 @@ export interface SyncNamespaceProxyToolsInput {
   activeDirectNames?: ReadonlySet<string>;
   existingNamespaceNames: Set<string>;
   unavailableServers?: ReadonlySet<string>;
+  // Names the adapter removed from Pi's active tools because Pi could not
+  // unregister them. Pi does not re-activate a name it already knows, so a
+  // later re-registration must add the name back.
+  fallbackDeactivatedNames?: Set<string>;
   pi: ExtensionAPI;
   getState: GetState;
   getInitPromise: GetInitPromise;
@@ -265,10 +269,19 @@ function registerNamespaceProxyTool(
     ),
   });
   input.guardReentrant?.();
+  if (input.fallbackDeactivatedNames?.delete(spec.toolName)) {
+    // Only undo a fallback deactivation the adapter still owns.
+    input.guardReentrant?.();
+    const activeTools = getActiveToolsIfReady(input.pi);
+    input.guardReentrant?.();
+    if (activeTools && !activeTools.includes(spec.toolName)) {
+      input.pi.setActiveTools([...activeTools, spec.toolName]);
+      input.guardReentrant?.();
+    }
+  }
 }
 
-function getActiveToolsForStaleCleanup(pi: ExtensionAPI, staleNames: string[]): string[] | undefined {
-  if (staleNames.length === 0) return undefined;
+function getActiveToolsIfReady(pi: ExtensionAPI): string[] | undefined {
   try {
     return pi.getActiveTools?.();
   } catch (error) {
@@ -277,6 +290,11 @@ function getActiveToolsForStaleCleanup(pi: ExtensionAPI, staleNames: string[]):
   }
 }
 
+function getActiveToolsForStaleCleanup(pi: ExtensionAPI, staleNames: string[]): string[] | undefined {
+  if (staleNames.length === 0) return undefined;
+  return getActiveToolsIfReady(pi);
+}
+
 function deactivateStaleNamespaceTools(input: SyncNamespaceProxyToolsInput, nextNames: Set<string>): string[] {
   const activeDirectNames = input.activeDirectNames ?? new Set<string>();
   const staleNames = [...input.existingNamespaceNames].filter(
@@ -298,12 +316,14 @@ function deactivateStaleNamespaceTools(input: SyncNamespaceProxyToolsInput, next
   if (!activeTools) return deactivated;
 
   const stale = new Set(staleNames);
+  const fallbackRemoved = staleNames.filter((name) => !deactivated.includes(name) && activeTools.includes(name));
   const nextActiveTools = activeTools.filter((name) => !stale.has(name));
   if (nextActiveTools.length === activeTools.length) return deactivated;
 
   input.guardReentrant?.();
   input.pi.setActiveTools(nextActiveTools);
   input.guardReentrant?.();
+  for (const name of fallbackRemoved) input.fallbackDeactivatedNames?.add(name);
   for (const name of staleNames) {
     if (!deactivated.includes(name)) deactivated.push(name);
   }

package/output-shape.ts

@@ -0,0 +1,209 @@
+import type { McpExtensionState } from "./state.ts";
+import { formatPropertyName } from "./ts-shape.ts";
+import type { ToolMetadata } from "./types.ts";
+
+/**
+ * Session-only output shapes for tools that declare no outputSchema.
+ * Field names and broad JSON types only, never values; every dimension is
+ * bounded because inference runs on arbitrary upstream payloads after each call.
+ */
+export interface OutputShape {
+  type?: "null" | "boolean" | "number" | "string" | "object" | "array";
+  properties?: Record<string, OutputShape>;
+  required?: string[];
+  items?: OutputShape;
+  additionalProperties?: OutputShape;
+  anyOf?: OutputShape[];
+}
+
+export interface ObservedOutput {
+  source: "structuredContent" | "jsonText";
+  shape: OutputShape;
+  calls: number;
+}
+
+const MAX_DEPTH = 6;
+const MAX_ARRAY_SAMPLE = 5;
+// Objects wider than this, or with any key that does not look like a field name, are treated as maps
+// keyed by data (ids, emails, dates), so their keys are not kept.
+const MAX_OBJECT_KEYS = 40;
+const FIELD_NAME = /^[A-Za-z_$][A-Za-z0-9_$]{0,39}$/;
+const MAX_UNION = 4;
+const MAX_NODES_PER_CALL = 1000;
+// Sizes count UTF-16 code units (string length), not bytes.
+const MAX_SHAPE_CHARS = 4 * 1024;
+const MAX_JSON_TEXT_CHARS = 256 * 1024;
+
+export function recordObservedOutput(
+  state: McpExtensionState,
+  serverName: string,
+  toolName: string,
+  result: Record<string, unknown>,
+): void {
+  if (findTool(state, serverName, toolName)?.outputSchema !== undefined) return;
+  const observed = readResultValue(result);
+  if (!observed) return;
+  const definition = state.config.mcpServers[serverName];
+  if (!definition) return;
+  const shape = inferShape(observed.value, 0, { nodes: MAX_NODES_PER_CALL });
+  const observedOutputs = state.observedOutputs ??= new WeakMap();
+  let byTool = observedOutputs.get(definition);
+  if (!byTool) observedOutputs.set(definition, byTool = new Map());
+  const previous = byTool.get(toolName);
+  byTool.set(toolName, previous?.source === observed.source
+    ? { source: observed.source, shape: fitShape(mergeShapes(previous.shape, shape)), calls: previous.calls + 1 }
+    : { source: observed.source, shape: fitShape(shape), calls: 1 });
+}
+
+export function getObservedOutput(
+  state: McpExtensionState,
+  serverName: string,
+  tool: Pick<ToolMetadata, "originalName" | "outputSchema">,
+): ObservedOutput | undefined {
+  if (tool.outputSchema !== undefined) return undefined;
+  const definition = state.config.mcpServers[serverName];
+  const observed = definition && state.observedOutputs?.get(definition)?.get(tool.originalName);
+  return observed && !isUnknown(observed.shape) ? observed : undefined;
+}
+
+export function renderOutputShape(shape: OutputShape): string {
+  if (shape.anyOf) return shape.anyOf.map(renderOutputShape).join(" | ");
+  switch (shape.type) {
+    case undefined:
+      return "unknown";
+    case "object": {
+      if (shape.additionalProperties) return `Record<string, ${renderOutputShape(shape.additionalProperties)}>`;
+      const required = new Set(shape.required);
+      const properties = Object.entries(shape.properties ?? {})
+        .map(([name, property]) => `${formatPropertyName(name)}${required.has(name) ? "" : "?"}: ${renderOutputShape(property)};`);
+      return properties.length === 0 ? "{}" : `{ ${properties.join(" ")} }`;
+    }
+    case "array": {
+      if (!shape.items) return "unknown[]";
+      const item = renderOutputShape(shape.items);
+      return item.includes(" | ") ? `(${item})[]` : `${item}[]`;
+    }
+    default:
+      return shape.type;
+  }
+}
+
+function findTool(state: McpExtensionState, serverName: string, toolName: string): ToolMetadata | undefined {
+  return state.toolMetadata.get(serverName)?.find(tool => tool.originalName === toolName && !tool.resourceUri);
+}
+
+function readResultValue(result: Record<string, unknown>): { source: ObservedOutput["source"]; value: unknown } | undefined {
+  const structured = result.structuredContent;
+  if (typeof structured === "object" && structured !== null) return { source: "structuredContent", value: structured };
+  const content = result.content;
+  if (!Array.isArray(content) || content.length !== 1) return undefined;
+  const block = content[0] as { type?: unknown; text?: unknown };
+  if (block.type !== "text" || typeof block.text !== "string" || block.text.length > MAX_JSON_TEXT_CHARS) return undefined;
+  const text = block.text.trim();
+  if (!text.startsWith("{") && !text.startsWith("[")) return undefined;
+  try {
+    return { source: "jsonText", value: JSON.parse(text) };
+  } catch {
+    return undefined;
+  }
+}
+
+function inferShape(value: unknown, depth: number, budget: { nodes: number }): OutputShape {
+  if (--budget.nodes < 0) return {};
+  if (value === null) return { type: "null" };
+  if (typeof value === "boolean" || typeof value === "number" || typeof value === "string") return { type: typeof value as "boolean" | "number" | "string" };
+  if (typeof value !== "object" || depth >= MAX_DEPTH) return {};
+  if (Array.isArray(value)) {
+    const items = value.slice(0, MAX_ARRAY_SAMPLE).map(item => inferShape(item, depth + 1, budget));
+    return items.length === 0 ? { type: "array" } : { type: "array", items: items.reduce(mergeShapes) };
+  }
+  const record = value as Record<string, unknown>;
+  const keys: string[] = [];
+  let isMap = false;
+  // Stops at the first key that makes this a map, so a huge object costs O(MAX_OBJECT_KEYS) here.
+  for (const key in record) {
+    if (!Object.hasOwn(record, key)) continue;
+    keys.push(key);
+    // An own "__proto__" key would set the prototype of the shape's properties object instead of adding a field.
+    if (keys.length > MAX_OBJECT_KEYS || !FIELD_NAME.test(key) || /\d{4}/.test(key) || key === "__proto__") {
+      isMap = true;
+      break;
+    }
+  }
+  if (isMap) {
+    const values = keys.slice(0, MAX_ARRAY_SAMPLE).map(key => inferShape(record[key], depth + 1, budget));
+    return { type: "object", additionalProperties: values.reduce(mergeShapes) };
+  }
+  const properties: Record<string, OutputShape> = {};
+  for (const key of keys) properties[key] = inferShape(record[key], depth + 1, budget);
+  return { type: "object", properties, required: keys };
+}
+
+function isUnknown(shape: OutputShape): boolean {
+  return shape.type === undefined && shape.anyOf === undefined;
+}
+
+function mergeShapes(left: OutputShape, right: OutputShape): OutputShape {
+  if (isUnknown(left) || isUnknown(right)) return {};
+  const variants = [...(left.anyOf ?? [left])];
+  for (const variant of right.anyOf ?? [right]) {
+    const index = variants.findIndex(existing => existing.type === variant.type);
+    if (index === -1) variants.push(variant);
+    else variants[index] = mergeSameType(variants[index]!, variant);
+  }
+  if (variants.length > MAX_UNION) return {};
+  return variants.length === 1 ? variants[0]! : { anyOf: variants };
+}
+
+function mergeSameType(left: OutputShape, right: OutputShape): OutputShape {
+  if (left.type === "array") {
+    const items = left.items && right.items ? mergeShapes(left.items, right.items) : left.items ?? right.items;
+    return items ? { type: "array", items } : { type: "array" };
+  }
+  if (left.type !== "object") return left;
+  const keys = new Set([...Object.keys(left.properties ?? {}), ...Object.keys(right.properties ?? {})]);
+  if (left.additionalProperties || right.additionalProperties || keys.size > MAX_OBJECT_KEYS) {
+    const values = [
+      left.additionalProperties,
+      right.additionalProperties,
+      ...Object.values(left.properties ?? {}),
+      ...Object.values(right.properties ?? {}),
+    ].filter((shape): shape is OutputShape => shape !== undefined);
+    return { type: "object", additionalProperties: values.reduce(mergeShapes) };
+  }
+  const properties: Record<string, OutputShape> = {};
+  for (const key of keys) {
+    const leftProperty = left.properties?.[key];
+    const rightProperty = right.properties?.[key];
+    properties[key] = leftProperty && rightProperty ? mergeShapes(leftProperty, rightProperty) : (leftProperty ?? rightProperty)!;
+  }
+  const rightRequired = new Set(right.required);
+  return { type: "object", properties, required: (left.required ?? []).filter(key => rightRequired.has(key)) };
+}
+
+/** Drops nesting from the deepest level up until the stored shape fits the size bound. */
+function fitShape(shape: OutputShape): OutputShape {
+  for (let depth = MAX_DEPTH; depth > 0; depth--) {
+    const pruned = pruneShape(shape, depth);
+    if (JSON.stringify(pruned).length <= MAX_SHAPE_CHARS) return pruned;
+  }
+  return {};
+}
+
+function pruneShape(shape: OutputShape, depth: number): OutputShape {
+  if (shape.anyOf) {
+    const variants = shape.anyOf.map(variant => pruneShape(variant, depth));
+    return variants.some(isUnknown) ? {} : { anyOf: variants };
+  }
+  if (shape.type !== "object" && shape.type !== "array") return shape;
+  if (depth === 0) return {};
+  const prune = (child: OutputShape) => pruneShape(child, depth - 1);
+  return {
+    ...shape,
+    ...(shape.properties
+      ? { properties: Object.fromEntries(Object.entries(shape.properties).map(([key, child]) => [key, prune(child)])) }
+      : {}),
+    ...(shape.items ? { items: prune(shape.items) } : {}),
+    ...(shape.additionalProperties ? { additionalProperties: prune(shape.additionalProperties) } : {}),
+  };
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pi-mcp-adapter",
-  "version": "3.1.0",
+  "version": "3.3.0",
   "description": "MCP (Model Context Protocol) adapter extension for Pi coding agent",
   "type": "module",
   "types": "./index.ts",
@@ -20,6 +20,11 @@
       "import": "./oauth.ts",
       "default": "./oauth.ts"
     },
+    "./host-managed": {
+      "types": "./host-managed.ts",
+      "import": "./host-managed.ts",
+      "default": "./host-managed.ts"
+    },
     "./config": {
       "types": "./dist/config.d.ts",
       "import": "./dist/config.js",
@@ -84,8 +89,11 @@
     "runtime-owner.ts",
     "tool-metadata.ts",
     "ts-shape.ts",
+    "output-shape.ts",
     "search-ranking.ts",
     "tool-approval.ts",
+    "tool-parameters.ts",
+    "host-managed.ts",
     "session-approvals.ts",
     "project-server-trust.ts",
     "init.ts",
@@ -173,7 +181,6 @@
   "dependencies": {
     "@modelcontextprotocol/client": "2.0.0",
     "@modelcontextprotocol/core": "2.0.0",
-    "@modelcontextprotocol/ext-apps": "^1.2.2",
     "@modelcontextprotocol/ext-tasks": "^0.1.0",
     "@napi-rs/keyring": "^2.1.0",
     "@typesafe-ai/sdk": "0.6.0",