@bastani/atomic 0.9.16-alpha.2 → 0.9.16-alpha.4

package/dist/builtin/mcp/startup-warmup.ts

@@ -1,110 +0,0 @@
-import type { SubagentChildPolicy } from "@bastani/atomic";
-import type { McpExtensionState } from "./state.js";
-import { getMissingConfiguredDirectToolServers } from "./direct-tools.ts";
-import { loadMetadataCache } from "./metadata-cache.js";
-import { buildToolMetadata } from "./tool-metadata.js";
-import { parallelLimit } from "./utils.js";
-import { logger } from "./logger.ts";
-import { updateMetadataCache, updateStatusBar } from "./init.js";
-
-export interface McpStartupWarmupOptions {
-	/** Typed child selection issued during in-process admission. */
-	subagentPolicy?: SubagentChildPolicy;
-	shouldContinue?: () => boolean;
-	onDirectToolsChanged?: () => void | Promise<void>;
-	onSettled?: () => void;
-}
-
-export interface McpStartupWarmupHandle {
-  readonly promise: Promise<void>;
-  cancel(): void;
-}
-
-export interface McpDirectToolsSelection {
-  readonly disabled: boolean;
-  readonly tools?: readonly string[];
-}
-
-/** Resolve direct-tool selection exclusively from typed admission policy. */
-export function resolveMcpDirectToolsSelection(subagentPolicy?: SubagentChildPolicy): McpDirectToolsSelection {
-	const tools = subagentPolicy?.mcpDirectTools;
-	return { disabled: tools !== undefined && tools.length === 0, ...(tools === undefined ? {} : { tools: [...tools] }) };
-}
-
-function deferToMacrotask(): Promise<void> {
-  return new Promise((resolve) => setImmediate(resolve));
-}
-
-export function scheduleMcpStartupWarmup(
-  state: McpExtensionState,
-  options: McpStartupWarmupOptions = {},
-): McpStartupWarmupHandle {
-  let cancelled = false;
-  const shouldContinue = (): boolean => !cancelled && (options.shouldContinue?.() ?? true);
-
-  const promise = (async () => {
-    await deferToMacrotask();
-    if (!shouldContinue()) return;
-    const selection = resolveMcpDirectToolsSelection(options.subagentPolicy);
-    if (selection.disabled) return;
-
-    const missingCacheServers = getMissingConfiguredDirectToolServers(state.config, loadMetadataCache(), selection.tools)
-      .filter((name) => state.manager.getConnection(name)?.status !== "connected");
-    if (missingCacheServers.length === 0) return;
-
-    const prefix = state.config.settings?.toolPrefix ?? "server";
-    const results = await parallelLimit(missingCacheServers, 10, async (name) => {
-      if (!shouldContinue()) return { name, ok: false };
-      const definition = state.config.mcpServers[name];
-      if (!definition) return { name, ok: false };
-      try {
-        const connection = await state.manager.connect(name, definition);
-        if (!shouldContinue()) {
-          if (state.manager.getConnection(name) === connection) {
-            await state.manager.close(name);
-          }
-          return { name, ok: false };
-        }
-        if (connection.status === "needs-auth") return { name, ok: false };
-        const { metadata } = buildToolMetadata(connection.tools, connection.resources, definition, name, prefix);
-        state.toolMetadata.set(name, metadata);
-        updateMetadataCache(state, name);
-        return { name, ok: true };
-      } catch (error) {
-        const message = error instanceof Error ? error.message : String(error);
-        logger.debug(`MCP: background direct-tools warmup failed for ${name}: ${message}`);
-        return { name, ok: false };
-      }
-    });
-
-    if (!shouldContinue()) return;
-    const warmed = results.filter((result) => result.ok).map((result) => result.name);
-    if (warmed.length === 0) return;
-    updateStatusBar(state);
-    if (!shouldContinue()) return;
-    await options.onDirectToolsChanged?.();
-    if (!shouldContinue()) return;
-    if (state.ui) {
-      state.ui.notify(`MCP: direct tools for ${warmed.join(", ")} are now available`, "info");
-    }
-  })()
-    .catch((error) => {
-      const message = error instanceof Error ? error.message : String(error);
-      logger.debug(`MCP: background startup warmup failed: ${message}`);
-    })
-    .finally(() => {
-      try {
-        options.onSettled?.();
-      } catch (error) {
-        const message = error instanceof Error ? error.message : String(error);
-        logger.debug(`MCP: background startup warmup settled callback failed: ${message}`);
-      }
-    });
-
-  return {
-    promise,
-    cancel() {
-      cancelled = true;
-    },
-  };
-}

package/dist/builtin/mcp/state-lease.ts

@@ -1,12 +0,0 @@
-export type AssertMcpStateLease = () => void;
-
-export class McpStateChangedError extends Error {
-  constructor() {
-    super("MCP session changed during execution");
-    this.name = "McpStateChangedError";
-  }
-}
-
-export function assertMcpStateLease(assertActive?: AssertMcpStateLease): void {
-  assertActive?.();
-}

package/dist/builtin/mcp/state.ts

@@ -1,41 +0,0 @@
-import type { ExtensionContext } from "@bastani/atomic";
-import type { ConsentManager } from "./consent-manager.js";
-import type { McpLifecycleManager } from "./lifecycle.ts";
-import type { McpServerManager } from "./server-manager.ts";
-import type { ToolMetadata, McpConfig, UiSessionMessages, UiStreamSummary } from "./types.ts";
-import type { UiResourceHandler } from "./ui-resource-handler.ts";
-import type { UiServerHandle } from "./ui-server.ts";
-
-export interface CompletedUiSession {
-  serverName: string;
-  toolName: string;
-  completedAt: Date;
-  reason: string;
-  messages: UiSessionMessages;
-  stream?: UiStreamSummary;
-}
-
-export type SendMessageFn = (
-  message: {
-    customType: string;
-    content: Array<{ type: "text"; text: string }>;
-    display?: string;
-    details?: unknown;
-  },
-  options?: { triggerTurn?: boolean }
-) => void;
-
-export interface McpExtensionState {
-  manager: McpServerManager;
-  lifecycle: McpLifecycleManager;
-  toolMetadata: Map<string, ToolMetadata[]>;
-  config: McpConfig;
-  failureTracker: Map<string, number>;
-  uiResourceHandler: UiResourceHandler;
-  consentManager: ConsentManager;
-  uiServer: UiServerHandle | null;
-  completedUiSessions: CompletedUiSession[];
-  openBrowser: (url: string) => Promise<void>;
-  ui?: ExtensionContext["ui"];
-  sendMessage?: SendMessageFn;
-}

package/dist/builtin/mcp/tool-call-timeout.ts

@@ -1,101 +0,0 @@
-import type { Client } from "@modelcontextprotocol/sdk/client/index.js";
-import type { RequestOptions } from "@modelcontextprotocol/sdk/shared/protocol.js";
-import {
-  CallToolResultSchema,
-  ErrorCode,
-  McpError,
-  type CallToolRequest,
-} from "@modelcontextprotocol/sdk/types.js";
-import type { ServerEntry } from "./types.ts";
-
-export const MCP_TIMEOUT_MS_CONFIG_ERROR =
-  "timeoutMs must be a finite number greater than 0 milliseconds";
-
-export class McpTimeoutConfigError extends Error {
-  constructor(serverName: string, value: unknown) {
-    const rendered = typeof value === "string" ? JSON.stringify(value) : String(value);
-    super(
-      `Invalid MCP configuration for server "${serverName}": ${MCP_TIMEOUT_MS_CONFIG_ERROR}; received ${rendered}.`,
-    );
-    this.name = "McpTimeoutConfigError";
-  }
-}
-
-export class McpToolCallTimeoutError extends Error {
-  constructor(serverName: string, timeoutMs: number, cause?: unknown) {
-    super(`MCP tool call to server "${serverName}" timed out after ${timeoutMs} ms of inactivity.`, {
-      cause,
-    });
-    this.name = "McpToolCallTimeoutError";
-  }
-}
-
-export function validateMcpServerTimeouts(
-  servers: Record<string, unknown>,
-): Record<string, ServerEntry> {
-  for (const [serverName, rawEntry] of Object.entries(servers)) {
-    if (!rawEntry || typeof rawEntry !== "object" || Array.isArray(rawEntry)) continue;
-    const timeoutMs = (rawEntry as Record<string, unknown>).timeoutMs;
-    if (timeoutMs === undefined) continue;
-    if (typeof timeoutMs !== "number" || !Number.isFinite(timeoutMs) || timeoutMs <= 0) {
-      throw new McpTimeoutConfigError(serverName, timeoutMs);
-    }
-  }
-  return servers as Record<string, ServerEntry>;
-}
-
-export function createToolCallRequestOptions(
-  definition: Pick<ServerEntry, "timeoutMs">,
-  signal?: AbortSignal,
-): RequestOptions | undefined {
-  if (definition.timeoutMs === undefined) {
-    return signal ? { signal } : undefined;
-  }
-  return {
-    signal,
-    timeout: definition.timeoutMs,
-    resetTimeoutOnProgress: true,
-    // The SDK only issues a progress token (and therefore only delivers the progress
-    // notifications that reset this timeout) when an onprogress handler is registered,
-    // so an empty handler is required for resetTimeoutOnProgress to ever fire.
-    onprogress: () => {},
-  };
-}
-
-export async function callToolWithConfiguredTimeout(
-  client: Client,
-  params: CallToolRequest["params"],
-  definition: Pick<ServerEntry, "timeoutMs">,
-  serverName: string,
-  signal?: AbortSignal,
-) {
-  try {
-    return await client.callTool(
-      params,
-      CallToolResultSchema,
-      createToolCallRequestOptions(definition, signal),
-    );
-  } catch (error) {
-    if (definition.timeoutMs !== undefined && isMcpToolCallTimeout(error)) {
-      throw new McpToolCallTimeoutError(serverName, definition.timeoutMs, error);
-    }
-    throw error;
-  }
-}
-
-export function isMcpToolCallTimeout(error: unknown): error is McpError {
-  return error instanceof McpError && error.code === ErrorCode.RequestTimeout;
-}
-
-export function formatMcpToolCallFailure(
-  error: unknown,
-  serverName: string,
-  timeoutMs?: number,
-): string {
-  if (error instanceof McpToolCallTimeoutError) return error.message;
-  if (timeoutMs !== undefined && isMcpToolCallTimeout(error)) {
-    return new McpToolCallTimeoutError(serverName, timeoutMs).message;
-  }
-  const message = error instanceof Error ? error.message : String(error);
-  return `Failed to call tool: ${message}`;
-}

package/dist/builtin/mcp/tool-metadata.ts

@@ -1,152 +0,0 @@
-import { getToolUiResourceUri } from "@modelcontextprotocol/ext-apps/app-bridge";
-import type { McpExtensionState } from "./state.js";
-import type { ToolMetadata, McpTool, McpResource, ServerEntry } from "./types.ts";
-import { formatToolName, isToolExcluded } from "./types.ts";
-import { resourceNameToToolName } from "./resource-tools.ts";
-import { extractToolUiStreamMode } from "./utils.js";
-
-export function buildToolMetadata(
-  tools: McpTool[],
-  resources: McpResource[],
-  definition: ServerEntry,
-  serverName: string,
-  prefix: "server" | "none" | "short"
-): { metadata: ToolMetadata[]; failedTools: string[] } {
-  const metadata: ToolMetadata[] = [];
-  const failedTools: string[] = [];
-
-  for (const tool of tools) {
-    if (!tool?.name) {
-      failedTools.push("(unnamed)");
-      continue;
-    }
-    if (isToolExcluded(tool.name, serverName, prefix, definition.excludeTools)) {
-      continue;
-    }
-
-    let uiResourceUri: string | undefined;
-    try {
-      uiResourceUri = getToolUiResourceUri({ _meta: tool._meta });
-    } catch {
-      failedTools.push(tool.name);
-    }
-    metadata.push({
-      name: formatToolName(tool.name, serverName, prefix),
-      originalName: tool.name,
-      description: tool.description ?? "",
-      inputSchema: tool.inputSchema,
-      uiResourceUri,
-      uiStreamMode: extractToolUiStreamMode(tool._meta),
-    });
-  }
-
-  if (definition.exposeResources !== false) {
-    for (const resource of resources) {
-      const baseName = `get_${resourceNameToToolName(resource.name)}`;
-      if (isToolExcluded(baseName, serverName, prefix, definition.excludeTools)) {
-        continue;
-      }
-
-      metadata.push({
-        name: formatToolName(baseName, serverName, prefix),
-        originalName: baseName,
-        description: resource.description ?? `Read resource: ${resource.uri}`,
-        resourceUri: resource.uri,
-      });
-    }
-  }
-
-  return { metadata, failedTools };
-}
-
-export function getToolNames(state: McpExtensionState, serverName: string): string[] {
-  return state.toolMetadata.get(serverName)?.map(m => m.name) ?? [];
-}
-
-export function totalToolCount(state: McpExtensionState): number {
-  let count = 0;
-  for (const metadata of state.toolMetadata.values()) {
-    count += metadata.length;
-  }
-  return count;
-}
-
-export function findToolByName(metadata: ToolMetadata[] | undefined, toolName: string): ToolMetadata | undefined {
-  if (!metadata) return undefined;
-  const exact = metadata.find(m => m.name === toolName);
-  if (exact) return exact;
-  const normalized = toolName.replace(/-/g, "_");
-  return metadata.find(m => m.name.replace(/-/g, "_") === normalized);
-}
-
-export function formatSchema(schema: unknown, indent = "  "): string {
-  if (!schema || typeof schema !== "object") {
-    return `${indent}(no schema)`;
-  }
-
-  const s = schema as Record<string, unknown>;
-
-  if (s.type === "object" && s.properties && typeof s.properties === "object") {
-    const props = s.properties as Record<string, unknown>;
-    const required = Array.isArray(s.required) ? s.required as string[] : [];
-
-    if (Object.keys(props).length === 0) {
-      return `${indent}(no parameters)`;
-    }
-
-    const lines: string[] = [];
-    for (const [name, propSchema] of Object.entries(props)) {
-      const isRequired = required.includes(name);
-      const propLine = formatProperty(name, propSchema, isRequired, indent);
-      lines.push(propLine);
-    }
-    return lines.join("\n");
-  }
-
-  if (s.type) {
-    return `${indent}(${s.type})`;
-  }
-
-  return `${indent}(complex schema)`;
-}
-
-function formatProperty(name: string, schema: unknown, required: boolean, indent: string): string {
-  if (!schema || typeof schema !== "object") {
-    return `${indent}${name}${required ? " *required*" : ""}`;
-  }
-
-  const s = schema as Record<string, unknown>;
-  const parts: string[] = [];
-
-  let typeStr = "";
-  if (s.type) {
-    if (Array.isArray(s.type)) {
-      typeStr = s.type.join(" | ");
-    } else {
-      typeStr = String(s.type);
-    }
-  } else if (s.enum) {
-    typeStr = "enum";
-  } else if (s.anyOf || s.oneOf) {
-    typeStr = "union";
-  }
-
-  if (Array.isArray(s.enum)) {
-    const enumVals = s.enum.map(v => JSON.stringify(v)).join(", ");
-    typeStr = `enum: ${enumVals}`;
-  }
-
-  parts.push(`${indent}${name}`);
-  if (typeStr) parts.push(`(${typeStr})`);
-  if (required) parts.push("*required*");
-
-  if (s.description && typeof s.description === "string") {
-    parts.push(`- ${s.description}`);
-  }
-
-  if (s.default !== undefined) {
-    parts.push(`[default: ${JSON.stringify(s.default)}]`);
-  }
-
-  return parts.join(" ");
-}

package/dist/builtin/mcp/tool-registrar.ts

@@ -1,46 +0,0 @@
-// tool-registrar.ts - MCP content transformation
-// NOTE: Tools are NOT registered with Pi - only the unified `mcp` proxy tool is registered.
-// This keeps the LLM context small (1 tool instead of 100s).
-
-import type { McpContent, ContentBlock } from "./types.ts";
-
-/**
- * Transform MCP content types to Pi content blocks.
- */
-export function transformMcpContent(content: McpContent[]): ContentBlock[] {
-  return content.map(c => {
-    if (c.type === "text") {
-      return { type: "text" as const, text: c.text ?? "" };
-    }
-    if (c.type === "image") {
-      return {
-        type: "image" as const,
-        data: c.data ?? "",
-        mimeType: c.mimeType ?? "image/png",
-      };
-    }
-    if (c.type === "resource") {
-      const resourceUri = c.resource?.uri ?? "(no URI)";
-      const resourceContent = c.resource?.text ?? (c.resource ? JSON.stringify(c.resource) : "(no content)");
-      return {
-        type: "text" as const,
-        text: `[Resource: ${resourceUri}]\n${resourceContent}`,
-      };
-    }
-    if (c.type === "resource_link") {
-      const linkName = c.name ?? c.uri ?? "unknown";
-      const linkUri = c.uri ?? "(no URI)";
-      return {
-        type: "text" as const,
-        text: `[Resource Link: ${linkName}]\nURI: ${linkUri}`,
-      };
-    }
-    if (c.type === "audio") {
-      return {
-        type: "text" as const,
-        text: `[Audio content: ${c.mimeType ?? "audio/*"}]`,
-      };
-    }
-    return { type: "text" as const, text: JSON.stringify(c) };
-  });
-}

package/dist/builtin/mcp/tool-result-renderer.ts

@@ -1,66 +0,0 @@
-import { keyText, type AgentToolResult, type ToolRenderResultOptions } from "@bastani/atomic";
-import { Text } from "@earendil-works/pi-tui";
-
-export type McpToolResultDetails = Record<string, unknown> & { error?: unknown };
-type McpToolContentBlock = AgentToolResult<McpToolResultDetails>["content"][number];
-
-interface RenderTheme {
-  fg: (name: string, text: string) => string;
-}
-
-interface McpToolRenderContext {
-  isError: boolean;
-}
-
-export interface McpToolResultDisplay {
-  lines: string[];
-  truncated: boolean;
-}
-
-function blockToLines(block: McpToolContentBlock): string[] {
-  if (block.type === "text") {
-    return block.text.split("\n");
-  }
-  return [`[image: ${block.mimeType}]`];
-}
-
-export function formatMcpToolResultLines(
-  result: Pick<AgentToolResult<McpToolResultDetails>, "content">,
-  expanded: boolean,
-  maxCollapsedLines = 3,
-): McpToolResultDisplay {
-  const allLines = result.content.flatMap(blockToLines);
-  const lines = allLines.length > 0 ? allLines : ["(empty result)"];
-
-  if (expanded || lines.length <= maxCollapsedLines) {
-    return { lines, truncated: false };
-  }
-
-  return {
-    lines: [...lines.slice(0, maxCollapsedLines), "…"],
-    truncated: true,
-  };
-}
-
-export function renderMcpToolResult(
-  result: AgentToolResult<McpToolResultDetails>,
-  options: ToolRenderResultOptions,
-  theme: RenderTheme,
-  context?: McpToolRenderContext,
-) {
-  if (options.isPartial) {
-    return new Text(theme.fg("warning", "Running MCP tool..."), 0, 0);
-  }
-
-  const hasErrorDetails = Boolean(result.details.error);
-  const display = formatMcpToolResultLines(result, options.expanded || context?.isError === true || hasErrorDetails);
-  const output = display.lines
-    .map((line) => line === "…" ? theme.fg("muted", line) : theme.fg("toolOutput", line))
-    .join("\n");
-  const expandKey = keyText("app.tools.expand");
-  const hint = display.truncated && !options.expanded && expandKey
-    ? `\n${theme.fg("muted", `(${expandKey} Expand)`)}`
-    : "";
-
-  return new Text(`${output}${hint}`, 0, 0);
-}