pi-codemcp 1.2.1 → 1.3.0

package/README.md

@@ -36,7 +36,8 @@ I built this because I care a lot about software that is genuinely fast, efficie
 pi-codemcp is deliberately opinionated about operational quality:
 
 - Pi startup does not wait for Python or MCP servers.
-- Each upstream connection is lazy and independent.
+- Each upstream connection is lazy and independent. A dead connection is evicted after the original call fails; that call is never replayed, and the next explicit call reconnects.
+- Upstream failures include stable `kind`, `server`, `tool`, `retryable`, `status`, and `message` fields.
 - Tool catalogs are cached per server and invalidated independently.
 - Agent-written code is type-checked before execution.
 - Time, memory, call count, and output size are bounded.
@@ -172,7 +173,9 @@ return {"number": number["value"], "identifier": saved["identifier"]}
 '
 ```
 
-Incomplete upstream schemas become recursive `JsonValue`, not `Any`; unknown values must be narrowed explicitly before typed use. For unfamiliar outputs, `inspect_json(value, samples=2, max_depth=3)` returns a byte-bounded structural summary, cardinality, field sizes, and samples. Preflight type errors happen before any upstream call is made, and oversized final results fail explicitly with the same actionable inspection data.
+Incomplete upstream schemas become recursive `JsonValue`, not `Any`; use the prebound `expect_object`, `expect_list`, `expect_string`, and `expect_integer` helpers to narrow unknown values explicitly. For unfamiliar outputs, `inspect_json(value, samples=2, max_depth=3)` returns a byte-bounded structural summary, cardinality, field sizes, and samples; `samples` is limited to 1–3 and `max_depth` to 1–6 during preflight. The generated prelude documents the sandbox surface: use `import asyncio` with `asyncio.gather`; unavailable host or stdlib APIs are rejected. Preflight type errors happen before any upstream call is made, and oversized final results fail explicitly with the same actionable inspection data.
+
+When an oversized value fits the bounded in-memory refinement cache, the failure also returns an opaque `result_ref` and expiry. Pass that reference back as `inputRef` on one follow-up `codemcp_execute`; the retained JSON is exposed as `input`, so code can filter or aggregate it without repeating upstream calls. References expire after five minutes, are valid only in the originating sidecar, and are never persisted.
 
 ## Saved-chain CLI flow
 
@@ -211,7 +214,7 @@ Rendered Pi output is separately truncated by `outputLimitKiB`; the full oversiz
 
 FastMCP owns MCP transports, runtime validation, and OAuth. [Pydantic Monty](https://github.com/pydantic/monty) type-checks and executes agent-written Python without host filesystem, environment, network, or subprocess access. Code Mode can only call the typed MCP tool and saved-chain facades exposed in the generated stubs.
 
-`/codemcp` configures servers, saved chains, per-tool policy, timeouts, call limits, output limits, cache TTL, and warmup, and shows bounded lifetime/recent telemetry in its Stats tab. Server, chain, tool-policy, and setting toggles stay local and instantaneous until one `Ctrl+S` batch save/reload. Discovery, revalidation, and deletion remain explicit immediate actions. The sandbox also has a fixed memory ceiling; executions are serialized per Pi session. There are no automatic retries or cross-service rollback.
+`/codemcp` configures servers, saved chains, per-tool policy, timeouts, call limits, output limits, cache TTL, and warmup, and shows bounded lifetime/recent telemetry in its Stats tab. Server, chain, tool-policy, and setting changes are persisted immediately. Discovery, revalidation, and deletion remain explicit immediate actions. The sandbox also has a fixed memory ceiling; executions are serialized per Pi session. There are no automatic retries or cross-service rollback.
 
 Enabled tools retain their upstream permissions. Saved chains never bypass server or per-tool policy and are checked against the current enabled catalog whenever they run. Preflight safety does not make upstream tools transactional: if a later call fails after earlier calls succeeded, pi-codemcp does not roll those upstream side effects back.
 

package/extensions/index.ts

@@ -4,22 +4,24 @@ import {
   type ExtensionAPI,
   type ExtensionCommandContext,
 } from "@earendil-works/pi-coding-agent";
-import { SavedChainManager } from "../src/chains.js";
-import { setMcpServersEnabled } from "../src/config.js";
+import { newCodeMcpTraceId, SavedChainManager } from "../src/chains.js";
+import { setMcpServerEnabled } from "../src/config.js";
 import { summarizeError } from "../src/errors.js";
 import { CodeMcpLifecycle } from "../src/lifecycle.js";
 import type { SidecarClientOptions } from "../src/mcp-client.js";
 import {
-  type ChainModalState,
   chainStatesFromViews,
-  type ChainEnabledChange as ModalChainEnabledChange,
-  type ServerEnabledChange,
   type ServerModalState,
   serverStatesFromStatus,
   showServerManagerModal,
   statsStateFromSnapshot,
 } from "../src/modal.js";
-import { type CodeMcpSettings, saveCodeMcpSettings } from "../src/settings.js";
+import {
+  type CodeMcpSettings,
+  saveCodeMcpSettings,
+  setEditableSetting,
+  setToolEnabled,
+} from "../src/settings.js";
 import { registerCodeMcpTools } from "../src/tools.js";
 
 export function createCodeMcpExtension(options: SidecarClientOptions = {}) {
@@ -35,7 +37,7 @@ export function createCodeMcpExtension(options: SidecarClientOptions = {}) {
           bindProjectChainScope(ctx, lifecycle, chains);
           const [status, savedChains, settings, stats] = await Promise.all([
             lifecycle.request("status", {}),
-            chains.list(),
+            chains.list(newCodeMcpTraceId("manager")),
             Promise.resolve(lifecycle.loadSettings()),
             lifecycle.request("stats", {}),
           ]);
@@ -50,29 +52,42 @@ export function createCodeMcpExtension(options: SidecarClientOptions = {}) {
             chains: chainStatesFromViews(savedChains),
             settings,
             stats: statsStateFromSnapshot(stats),
-            onDiscover: async (server) =>
-              requireServerStatus(
-                await lifecycle.request("discover", { server: server.name }),
+            onSetServerEnabled: (server, enabled) =>
+              setServerEnabledFromManager(lifecycle, server, enabled),
+            onDiscover: (server) => discoverServerFromManager(lifecycle, server),
+            onSetToolEnabled: async (server, tool, enabled) => {
+              const updated = setToolEnabled(
+                lifecycle.loadSettings(),
+                server.name,
+                tool.name,
+                enabled,
+              );
+              saveCodeMcpSettings(lifecycle.settingsPath, updated);
+              return requireServerStatus(
+                await lifecycle.request("reload_settings", {}),
                 server.name,
-              ),
-            onSaveChanges: (updated, serverChanges, chainChanges) =>
-              saveManagerChanges(lifecycle, chains, updated, serverChanges, chainChanges),
-            onResolveUnsaved: async () => {
-              const choice = await ctx.ui.select("Unsaved CodeMCP changes", [
-                "Save",
-                "Discard",
-                "Cancel",
-              ]);
-              if (choice === "Save") return "save";
-              if (choice === "Discard") return "discard";
-              return "cancel";
+              );
+            },
+            onSetSetting: async (key, value) => {
+              const updated = setEditableSetting(lifecycle.loadSettings(), key, value);
+              saveCodeMcpSettings(lifecycle.settingsPath, updated);
+              await lifecycle.request("reload_settings", {});
+              return updated;
+            },
+            onSetChainEnabled: async (chain, enabled) => {
+              const traceId = newCodeMcpTraceId("manager");
+              await chains.setEnabled(chain.name, chain.scope, enabled, traceId);
+              return chainStatesFromViews(await chains.list(traceId));
             },
             onRevalidateChain: async (chain) => {
-              await chains.revalidate(chain.name, chain.scope);
-              return chainStatesFromViews(await chains.list());
+              const traceId = newCodeMcpTraceId("manager");
+              await chains.revalidate(chain.name, chain.scope, traceId);
+              return chainStatesFromViews(await chains.list(traceId));
+            },
+            onDeleteChain: async (chain) => {
+              const traceId = newCodeMcpTraceId("manager");
+              return chainStatesFromViews(await chains.delete(chain.name, chain.scope, traceId));
             },
-            onDeleteChain: async (chain) =>
-              chainStatesFromViews(await chains.delete(chain.name, chain.scope)),
           });
           if (managerResult === "report-problem") await promptForProblemReport(pi, ctx);
         } catch (error) {
@@ -104,61 +119,36 @@ export function createCodeMcpExtension(options: SidecarClientOptions = {}) {
   };
 }
 
-export async function saveManagerChanges(
-  lifecycle: Pick<CodeMcpLifecycle, "configPath" | "settingsPath" | "loadSettings" | "reload">,
-  chains: Pick<SavedChainManager, "applyEnabled">,
-  updated: CodeMcpSettings,
-  serverChanges: readonly ServerEnabledChange[],
-  chainChanges: readonly ModalChainEnabledChange[],
-): Promise<{
-  settings: CodeMcpSettings;
-  servers: ServerModalState[];
-  chains: ChainModalState[];
-}> {
-  const previousSettings = lifecycle.loadSettings();
-  let serverConfigChanged = false;
+export async function discoverServerFromManager(
+  lifecycle: Pick<CodeMcpLifecycle, "configPath" | "reload" | "request">,
+  server: ServerModalState,
+): Promise<ServerModalState> {
+  if (!server.enabled) return setServerEnabledFromManager(lifecycle, server, true);
+  return requireServerStatus(
+    await lifecycle.request("discover", { server: server.name }),
+    server.name,
+  );
+}
+
+export async function setServerEnabledFromManager(
+  lifecycle: Pick<CodeMcpLifecycle, "configPath" | "reload" | "request">,
+  previous: ServerModalState,
+  enabled: boolean,
+): Promise<ServerModalState> {
+  setMcpServerEnabled(lifecycle.configPath, previous.name, enabled);
+  await lifecycle.reload();
   try {
-    saveCodeMcpSettings(lifecycle.settingsPath, updated);
-    if (serverChanges.length > 0) {
-      setMcpServersEnabled(
-        lifecycle.configPath,
-        serverChanges.map((change) => ({ name: change.name, enabled: change.enabled })),
-      );
-      serverConfigChanged = true;
-      await lifecycle.reload();
-    }
-    const applied = await chains.applyEnabled(
-      chainChanges.map((change) => ({
-        name: change.name,
-        scope: change.scope,
-        enabled: change.enabled,
-      })),
-    );
-    return {
-      settings: lifecycle.loadSettings(),
-      servers: serverStatesFromStatus(applied.status),
-      chains: chainStatesFromViews(applied.chains),
-    };
+    const status = enabled
+      ? await lifecycle.request("discover", { server: previous.name })
+      : await lifecycle.request("status", {});
+    return requireServerStatus(status, previous.name);
   } catch (error) {
-    saveCodeMcpSettings(lifecycle.settingsPath, previousSettings);
-    if (serverConfigChanged) {
-      setMcpServersEnabled(
-        lifecycle.configPath,
-        serverChanges.map((change) => ({
-          name: change.name,
-          enabled: change.previousEnabled,
-        })),
-      );
-    }
     try {
-      await lifecycle.reload();
-    } catch (rollbackError) {
-      throw new AggregateError(
-        [error, rollbackError],
-        "CodeMCP save failed and runtime rollback also failed",
-      );
+      const current = requireServerStatus(await lifecycle.request("status", {}), previous.name);
+      return { ...current, error: summarizeError(error) };
+    } catch {
+      throw error;
     }
-    throw error;
   }
 }
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pi-codemcp",
-  "version": "1.2.1",
+  "version": "1.3.0",
   "description": "Typed, sandboxed Code Mode access to configured MCP servers for Pi",
   "type": "module",
   "packageManager": "bun@1.3.10",

package/sidecar/chains.py

@@ -5,18 +5,15 @@ import json
 import os
 import re
 import time
-from contextlib import contextmanager, suppress
+from contextlib import suppress
 from pathlib import Path
-from typing import TYPE_CHECKING, Literal, NamedTuple
+from typing import Literal, NamedTuple
 from uuid import uuid4
 
 from pydantic import BaseModel, ConfigDict, Field, field_validator
 
 from .json_types import JSON_OBJECT_ADAPTER, JsonObject
 
-if TYPE_CHECKING:
-    from collections.abc import Iterator
-
 CHAIN_NAME_PATTERN = r"^[a-z][a-z0-9_]{0,63}$"
 CHAIN_STORE_VERSION: Literal[1] = 1
 type ChainScope = Literal["global", "project"]
@@ -76,14 +73,6 @@ class SavedChainManifest(BaseModel):
         return f"mcp_chain_{self.name}"
 
 
-class ChainEnabledChange(BaseModel):
-    model_config = ConfigDict(extra="forbid", strict=True)
-
-    name: str = Field(pattern=CHAIN_NAME_PATTERN)
-    scope: ChainScope
-    enabled: bool
-
-
 class ChainStatusView(BaseModel):
     model_config = ConfigDict(extra="forbid", strict=True)
 
@@ -187,6 +176,12 @@ class ChainStore:
         temporary.chmod(0o600)
         temporary.replace(path)
 
+    def set_enabled(self, name: str, enabled: bool) -> SavedChainManifest:
+        current = self.get(name)
+        updated = current.model_copy(update={"enabled": enabled, "updated_at": time.time()})
+        self.save(updated)
+        return updated
+
     def delete(self, name: str) -> None:
         self._validate_name(name)
         try:
@@ -256,38 +251,16 @@ class ScopedChainStore:
     def save(self, scope: ChainScope, chain: SavedChainManifest) -> None:
         self._store(scope).save(chain)
 
-    @contextmanager
-    def enabled_transaction(self, changes: list[ChainEnabledChange]) -> Iterator[None]:
-        keys = [(change.scope, change.name) for change in changes]
-        if len(keys) != len(set(keys)):
-            raise ValueError("Duplicate scoped saved-chain enable change")
-        previous = [self.get(change.name, change.scope) for change in changes]
-        applied: list[ScopedChain] = []
-        try:
-            self._apply_enabled_changes(changes, previous, applied)
-            yield
-        except BaseException:
-            self._restore(applied)
-            raise
-
-    def _apply_enabled_changes(
+    def set_enabled(
         self,
-        changes: list[ChainEnabledChange],
-        previous: list[ScopedChain],
-        applied: list[ScopedChain],
-    ) -> None:
-        for change, current in zip(changes, previous, strict=True):
-            if current.chain.enabled == change.enabled:
-                continue
-            updated = current.chain.model_copy(
-                update={"enabled": change.enabled, "updated_at": time.time()}
-            )
-            self.save(change.scope, updated)
-            applied.append(current)
-
-    def _restore(self, chains: list[ScopedChain]) -> None:
-        for item in reversed(chains):
-            self.save(item.scope, item.chain)
+        scope: ChainScope,
+        name: str,
+        enabled: bool,
+    ) -> ScopedChain:
+        return ScopedChain(
+            scope=scope,
+            chain=self._store(scope).set_enabled(name, enabled),
+        )
 
     def delete(self, scope: ChainScope, name: str) -> None:
         self._store(scope).delete(name)

package/sidecar/cli.py

@@ -66,6 +66,10 @@ def build_parser() -> argparse.ArgumentParser:
         help="Type-check and execute one sandboxed Python MCP call graph.",
     )
     _add_runtime_path_args(execute)
+    execute.add_argument(
+        "--input-ref",
+        help="Opaque retained-result reference to expose as input.",
+    )
     _add_text_input_args(execute, "code", "Sandboxed Python body to execute.")
 
     chain = subcommands.add_parser("chain", help="Manage and run saved MCP chains.")
@@ -152,27 +156,42 @@ async def _dispatch_runtime_command(
     args: argparse.Namespace,
     runtime: gateway.GatewayRuntime,
 ) -> BaseModel:
+    trace_id = gateway.new_trace_id("cli")
     if args.command == "status":
         return runtime.status()
     if args.command == "discover":
         return await runtime.discover(args.server)
     if args.command == "search":
-        return await runtime.search(args.query, args.limit, args.server)
+        return await runtime.search(
+            args.query,
+            args.limit,
+            args.server,
+            trace_id=trace_id,
+        )
     if args.command == "execute":
-        return await runtime.execute(_read_text_input(args, "code"))
+        return await runtime.execute(
+            _read_text_input(args, "code"),
+            trace_id,
+            args.input_ref,
+        )
     if args.command == "chain":
-        return await _dispatch_chain_command(args, runtime)
+        return await _dispatch_chain_command(args, runtime, trace_id)
     raise ValueError(f"unknown command: {args.command}")
 
 
 async def _dispatch_chain_command(
     args: argparse.Namespace,
     runtime: gateway.GatewayRuntime,
+    trace_id: str,
 ) -> BaseModel:
     if args.chain_command == "list":
-        return runtime.chains.list()
+        return runtime.chains.list(trace_id)
     if args.chain_command == "run":
-        return await runtime.chains.execute(args.name, _read_json_object_input(args, "input"))
+        return await runtime.chains.execute(
+            args.name,
+            _read_json_object_input(args, "input"),
+            trace_id,
+        )
     if args.chain_command == "save":
         return await runtime.chains.save(
             scope=args.scope,
@@ -181,11 +200,12 @@ async def _dispatch_chain_command(
             code=_read_text_input(args, "code"),
             input_schema=_read_json_object_input(args, "input_schema"),
             output_schema=_read_json_object_input(args, "output_schema"),
+            trace_id=trace_id,
         )
     if args.chain_command == "revalidate":
-        return await runtime.chains.revalidate(args.name, args.scope)
+        return await runtime.chains.revalidate(args.name, args.scope, trace_id)
     if args.chain_command == "delete":
-        return await runtime.chains.delete(args.name, args.scope)
+        return await runtime.chains.delete(args.name, args.scope, trace_id)
     raise ValueError(f"unknown chain command: {args.chain_command}")