@pi-unipi/unipi 2.4.2 → 2.6.0

package/packages/mcp/src/bridge/translator.ts

@@ -5,15 +5,19 @@
  * Naming convention: {serverName}__{toolName}
  */
 
-import { MCP_DEFAULTS } from "@pi-unipi/core";
+import { MCP_DEFAULTS, boundModelOutput } from "@pi-unipi/core";
 import type { McpTool, McpToolResult } from "../types.js";
 import type { McpClient } from "./client.js";
 
-/** Pi-compatible tool parameter schema */
+/** Client operation needed by translated tools. */
+export type ToolCallClient = Pick<McpClient, "callTool">;
+
+/** JSON object used as a Pi-compatible tool parameter schema. */
 interface ToolParameters {
+  [key: string]: unknown;
   type: "object";
   properties: Record<string, unknown>;
-  required?: string[];
+  required: unknown;
 }
 
 /** Content block returned by a pi tool */
@@ -31,6 +35,7 @@ interface PiToolResult {
 /** Pi-compatible external tool */
 export interface PiExternalTool {
   name: string;
+  label: string;
   description: string;
   parameters: ToolParameters;
   execute: (
@@ -41,6 +46,66 @@ export interface PiExternalTool {
   ) => Promise<PiToolResult>;
 }
 
+/**
+ * Compare strings by JavaScript/Unicode UTF-16 code units.
+ *
+ * Unlike localeCompare(), this ordering does not depend on the host locale.
+ */
+export function compareCodeUnits(left: string, right: string): number {
+  return left < right ? -1 : left > right ? 1 : 0;
+}
+
+function isObject(value: unknown): value is Record<string, unknown> {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+
+const LITERAL_VALUE_KEYWORDS = new Set(["const", "default", "enum", "examples"]);
+
+function canonicalizeValue(
+  value: unknown,
+  key?: string,
+  normalizeSchemaKeywords = true,
+): unknown {
+  if (Array.isArray(value)) {
+    if (
+      normalizeSchemaKeywords &&
+      key === "required" &&
+      value.every((item) => typeof item === "string")
+    ) {
+      return [...new Set(value as string[])].sort(compareCodeUnits);
+    }
+    return value.map((item) => canonicalizeValue(item, undefined, normalizeSchemaKeywords));
+  }
+
+  if (!isObject(value)) return value;
+
+  const canonical: Record<string, unknown> = {};
+  for (const objectKey of Object.keys(value).sort(compareCodeUnits)) {
+    // Values under these JSON Schema keywords are literal application data,
+    // not nested schemas. A property named `required` inside that data must
+    // retain array order (for example under `const`).
+    const childNormalizesSchemaKeywords =
+      normalizeSchemaKeywords && !LITERAL_VALUE_KEYWORDS.has(objectKey);
+    canonical[objectKey] = canonicalizeValue(
+      value[objectKey],
+      objectKey,
+      childNormalizesSchemaKeywords,
+    );
+  }
+  return canonical;
+}
+
+/**
+ * Recursively clone and canonicalize a JSON Schema value.
+ *
+ * Object keys use locale-independent code-unit order. Arrays retain their
+ * original order, except valid `required` arrays (arrays containing only
+ * strings), which are sorted and deduplicated.
+ */
+export function canonicalizeJsonSchema(schema: unknown): unknown {
+  return canonicalizeValue(schema);
+}
+
 /**
  * Translate an MCP tool definition to a pi-compatible external tool.
  *
@@ -52,19 +117,21 @@ export interface PiExternalTool {
 export function translateMcpTool(
   mcpTool: McpTool,
   serverName: string,
-  client: McpClient,
+  client: ToolCallClient,
 ): PiExternalTool {
   const separator = MCP_DEFAULTS.TOOL_NAME_SEPARATOR;
   const toolName = `${serverName}${separator}${mcpTool.name}`;
 
-  // Ensure inputSchema is a valid JSON Schema object
-  const inputSchema = mcpTool.inputSchema ?? {};
-  const parameters: ToolParameters = {
+  // Preserve the existing Pi-facing top-level shape while cloning and
+  // canonicalizing all nested property schemas. Forwarding additional MCP
+  // top-level keywords is a separate provider-compatibility decision.
+  const inputSchema = isObject(mcpTool.inputSchema) ? mcpTool.inputSchema : {};
+  const normalizedSchema: Record<string, unknown> = {
     type: "object",
-    properties:
-      (inputSchema.properties as Record<string, unknown>) ?? {},
-    required: inputSchema.required as string[] | undefined,
+    properties: isObject(inputSchema.properties) ? inputSchema.properties : {},
+    required: Array.isArray(inputSchema.required) ? inputSchema.required : [],
   };
+  const parameters = canonicalizeJsonSchema(normalizedSchema) as ToolParameters;
 
   const description = [
     mcpTool.description || `MCP tool: ${mcpTool.name}`,
@@ -103,21 +170,28 @@ export function translateMcpTool(
         }
       }
 
-      if (result.isError) {
-        const errorText = blocks.map((b) => b.text).join("\n") || "Unknown error";
-        return {
-          content: [{ type: "text", text: `MCP tool error from ${serverName}: ${errorText}` }],
-          details: { error: true, server: serverName, tool: mcpTool.name },
-        };
-      }
-
       if (blocks.length === 0) {
-        blocks.push({ type: "text", text: "(no output)" });
+        blocks.push({ type: "text", text: result.isError ? "Unknown error" : "(no output)" });
       }
 
+      const rawText = blocks.map((block) => block.text).join("\n");
+      const wrapper = result.isError ? `MCP tool error from ${serverName}: ` : "";
+      const output = boundModelOutput(rawText, {
+        maxBytes: Math.max(1024, MCP_DEFAULTS.MAX_MODEL_OUTPUT_BYTES - Buffer.byteLength(wrapper, "utf8")),
+        artifactPrefix: `mcp-${serverName}-${mcpTool.name}`,
+      });
+      const visibleText = `${wrapper}${output.text}`;
+
       return {
-        content: blocks,
-        details: { server: serverName, tool: mcpTool.name },
+        content: [{ type: "text", text: visibleText }],
+        details: {
+          error: result.isError || undefined,
+          server: serverName,
+          tool: mcpTool.name,
+          truncated: output.truncated,
+          originalBytes: output.originalBytes,
+          artifactPath: output.artifactPath,
+        },
       };
     } catch (err) {
       const message = err instanceof Error ? err.message : String(err);
@@ -137,6 +211,7 @@ export function translateMcpTool(
 
   return {
     name: toolName,
+    label: toolName,
     description,
     parameters,
     execute,

package/packages/mcp/src/index.ts

@@ -18,6 +18,7 @@ import type { ResolvedServer } from "./types.js";
 import { loadAndResolve, getGlobalConfigDir } from "./config/manager.js";
 import { syncCatalog, loadCatalog } from "./config/sync.js";
 import { ServerRegistry } from "./bridge/registry.js";
+import { compareCodeUnits } from "./bridge/translator.js";
 import { renderMcpAddOverlay } from "./tui/add-overlay.js";
 import { renderMcpSettingsOverlay } from "./tui/settings-overlay.js";
 
@@ -42,24 +43,32 @@ export default function (pi: ExtensionAPI) {
   // Session start — load configs, start servers
   pi.on("session_start", async (_event, ctx) => {
     // Create registry with pi integration callbacks
+    const toolApi = pi as ExtensionAPI & {
+      registerExternalTool?: (tool: unknown) => void;
+      unregisterTool?: (toolName: string) => void;
+      unregisterExternalTool?: (toolName: string) => void;
+    };
+    const registerTool = typeof toolApi.registerTool === "function"
+      ? (tool: unknown) => toolApi.registerTool(tool as Parameters<typeof toolApi.registerTool>[0])
+      : typeof toolApi.registerExternalTool === "function"
+        ? (tool: unknown) => toolApi.registerExternalTool!(tool)
+        : () => {
+            throw new Error("Pi does not expose a supported MCP tool registration API");
+          };
+    const canUnregisterTools =
+      typeof toolApi.unregisterTool === "function" ||
+      typeof toolApi.unregisterExternalTool === "function";
+    const unregisterTool = typeof toolApi.unregisterTool === "function"
+      ? (toolName: string) => toolApi.unregisterTool!(toolName)
+      : typeof toolApi.unregisterExternalTool === "function"
+        ? (toolName: string) => toolApi.unregisterExternalTool!(toolName)
+        : () => {};
+
     registry = new ServerRegistry({
       emitEvent: (event, payload) => emitEvent(pi, event, payload),
-      registerTool: (tool) => {
-        try {
-          (pi as any).registerTool?.(tool) ??
-            (pi as any).registerExternalTool?.(tool);
-        } catch {
-          // Tool registration may not be available in all contexts
-        }
-      },
-      unregisterTool: (toolName) => {
-        try {
-          (pi as any).unregisterTool?.(toolName) ??
-            (pi as any).unregisterExternalTool?.(toolName);
-        } catch {
-          // Ignore
-        }
-      },
+      registerTool,
+      unregisterTool,
+      canUnregisterTools,
     });
 
     // Load and resolve server configs
@@ -73,21 +82,13 @@ export default function (pi: ExtensionAPI) {
       // Config load failure — servers will be empty, visible via /unipi:mcp-status.
     }
 
-    // Start enabled servers (parallel, non-blocking errors)
-    const startPromises = servers
-      .filter((s) => s.enabled)
-      .map(async (server) => {
-        try {
-          await registry!.startServer(server);
-          // Removed console.log — startup logs cause layout shift in TUI.
-          // Server status visible via /unipi:mcp-status or info screen.
-        } catch (err) {
-          // Removed console.error — errors surfaced via info-screen MCP group.
-          // Server failure tracked in registry state.
-        }
-      });
-
-    await Promise.allSettled(startPromises);
+    // Connect/discover in parallel, then register the successful combined set
+    // after a barrier so tool order is stable across runs.
+    try {
+      await registry.startServers(servers.filter((server) => server.enabled));
+    } catch (_err) {
+      // Errors are tracked in registry state and surfaced by the info screen.
+    }
 
     // Register info-screen group
     const infoRegistry = getInfoRegistry();
@@ -153,16 +154,17 @@ export default function (pi: ExtensionAPI) {
         `unipi:${MCP_COMMANDS.STATUS}`,
         `unipi:${MCP_COMMANDS.RELOAD}`,
       ],
-      tools: activeServers.flatMap((s) =>
-        registry?.getEntry(s.name)?.toolNames ?? [],
-      ),
+      tools: activeServers
+        .flatMap((server) => registry?.getEntry(server.name)?.toolNames ?? [])
+        .sort(compareCodeUnits),
     });
   });
 
-  // Session shutdown — stop all servers
+  // Session shutdown tears down clients. Pi tears down this extension's tool
+  // registry itself, so do not claim per-tool unregistration here.
   pi.on("session_shutdown", async (_event, _ctx) => {
     if (registry) {
-      await registry.stopAll();
+      await registry.disconnectAll();
       registry = null;
     }
   });
@@ -305,38 +307,12 @@ export default function (pi: ExtensionAPI) {
 
   // /unipi:mcp-reload — restart all MCP servers
   pi.registerCommand(`unipi:${MCP_COMMANDS.RELOAD}`, {
-    description: "Reload all MCP servers (restart with current config)",
+    description: "Explain how to reload MCP servers safely",
     handler: async (_args: string, ctx: ExtensionCommandContext) => {
-      const reg = getRegistry();
-      if (!reg) {
-        ctx.ui.notify("MCP extension not initialized", "warning");
-        return;
-      }
-
-      const all = reg.getAll();
-      if (all.length === 0) {
-        ctx.ui.notify("No MCP servers configured. Use /unipi:mcp-add to add one.", "info");
-        return;
-      }
-
-      ctx.ui.notify(`Reloading ${all.length} MCP server(s)...`, "info");
-
-      let restarted = 0;
-      let failed = 0;
-      for (const state of all) {
-        try {
-          await reg.restartServer(state.name);
-          restarted++;
-        } catch (_err) {
-          failed++;
-          // Silently ignore — restart failure tracked in failed count.
-        }
-      }
-
-      const msg = failed > 0
-        ? `Reloaded: ${restarted} ok, ${failed} failed`
-        : `Reloaded ${restarted} MCP server(s) successfully`;
-      ctx.ui.notify(msg, failed > 0 ? "warning" : "info");
+      // Pi 0.80 does not expose dynamic tool removal. Restarting in place can
+      // leave stale schemas in the provider-visible tool list, so require a
+      // process/extension restart to establish a clean cache epoch.
+      ctx.ui.notify("Restart Pi to reload MCP servers and tool schemas safely.", "info");
     },
   });
 }

package/packages/mcp/src/tui/settings-overlay.ts

@@ -141,15 +141,9 @@ export function renderMcpSettingsOverlay(params?: {
         };
         saveMetadata(configDir, meta);
 
-        // Try to stop if disabling
-        if (!newEnabled && registry) {
-          try {
-            await registry.stopServer(server.name);
-          } catch {
-            // Ignore stop errors
-          }
-        }
-
+        // Pi 0.80 cannot remove a registered tool definition at runtime.
+        // Persist the setting now; the next Pi restart applies the new set as
+        // one deterministic cache epoch.
         refreshServers();
         refresh();
       } catch (err) {

package/packages/memory/README.md

@@ -2,7 +2,7 @@
 
 Persistent memory that survives across sessions. Stores facts, preferences, and decisions with semantic vector search, so the agent remembers what you told it last week.
 
-**Primary backend: [MemPalace](https://github.com/mempalace/mempalace)** — auto-installed via `uv` on first load, with one-way auto-migration of any existing legacy memories. If MemPalace or `uv` is unavailable, the package transparently falls back to the bundled SQLite + sqlite-vec store, so memory never hard-fails.
+**Primary backend: [MemPalace](https://github.com/mempalace/mempalace)** — auto-installed via `uv` on first load, with verified, resumable migration of existing legacy memories. If MemPalace or `uv` is unavailable, the package transparently falls back to the bundled SQLite + sqlite-vec store, so memory never hard-fails.
 
 Two storage tiers: MemPalace (or SQLite) for vector similarity search, markdown files for a durable human-readable copy you can edit by hand. Project-scoped memories stay separate per codebase, global memories are accessible everywhere.
 
@@ -76,7 +76,7 @@ Memory has no configuration file. Storage paths are fixed:
 ```
 ~/.unipi/memory/                 # UniPi memory root (legacy + markdown tier)
 ├── .mempalace-install           # Cached MemPalace venv detection
-├── .mempalace-migrated          # One-way migration completion flag
+├── .mempalace-migrated          # Versioned migration verification state
 ├── global/
 │   ├── memory.db              # Global vector DB (SQLite fallback)
 │   └── *.md                   # Global memory files
@@ -94,14 +94,18 @@ On first load, the memory package:
    `uv tool install mempalace` once (caches the venv python path in
    `~/.unipi/memory/.mempalace-install`).
 2. Pings the bridge to confirm the palace is usable.
-3. If `~/.unipi/memory/.mempalace-migrated` is absent, performs a one-way
-   read-only migration of every legacy memory (SQLite rows + markdown files
-   across all projects) into MemPalace drawers, then writes the flag.
-   Migration is idempotent (deterministic drawer IDs) and never deletes or
-   mutates legacy files.
-
-Each memory operation invokes a bundled Python bridge
-(`bridge/mempalace_bridge.py`) once via `spawnSync` (~0.5s per call). The
+3. Fingerprints the durable SQLite and markdown sources. If they differ from
+   the verified state in `~/.unipi/memory/.mempalace-migrated`, performs an
+   idempotent read-only migration into MemPalace drawers. Unchanged drawers are
+   skipped, new or changed memories are upserted, and the versioned state is
+   written only after every discovered record is verified in MemPalace.
+   Failed or partial migrations remain unmarked and retry on a later session.
+   Legacy files are never deleted or mutated.
+
+Each memory operation invokes the packaged Python bridge
+(`bridge/mempalace_bridge.py`) once via `spawnSync` (~0.5s per call). Both the
+standalone memory package and the all-in-one umbrella tarball ship and resolve
+this bridge. The
 first MemPalace use on a machine also downloads the default ONNX embedding
 model (~80MB, cached at `~/.cache/chroma/onnx_models/`).
 
@@ -109,7 +113,7 @@ model (~80MB, cached at `~/.cache/chroma/onnx_models/`).
 
 ```bash
 rm ~/.unipi/memory/.mempalace-install    # re-detect MemPalace next session
-rm ~/.unipi/memory/.mempalace-migrated   # re-run one-way migration next session
+rm ~/.unipi/memory/.mempalace-migrated   # force a full verified migration pass next session
 ```
 
 ### Backend override