pi-codemcp 1.1.2 → 1.2.1

package/README.md

@@ -148,7 +148,7 @@ The Python sidecar enforces catalog cache TTL, execution timeout, per-tool timeo
 
 ## Search and execute flow
 
-The agent searches for a capability, inspects the selected exact stub when needed, and executes a compact plan:
+The agent searches for a capability, inspects the selected exact stub when needed, and executes a compact plan. Unscoped searches discover stale or missing server catalogs independently: available servers still return results, while `discovery_failures` explicitly reports unavailable servers. Server-scoped searches remain fail-fast.
 
 ```python
 issues = await linear.list_issues({"assignee": "me", "limit": 50})

package/extensions/index.ts

@@ -45,7 +45,7 @@ export function createCodeMcpExtension(options: SidecarClientOptions = {}) {
             return;
           }
 
-          await showServerManagerModal(ctx, {
+          const managerResult = await showServerManagerModal(ctx, {
             servers,
             chains: chainStatesFromViews(savedChains),
             settings,
@@ -74,6 +74,7 @@ export function createCodeMcpExtension(options: SidecarClientOptions = {}) {
             onDeleteChain: async (chain) =>
               chainStatesFromViews(await chains.delete(chain.name, chain.scope)),
           });
+          if (managerResult === "report-problem") await promptForProblemReport(pi, ctx);
         } catch (error) {
           ctx.ui.notify(summarizeError(error), "error");
         }
@@ -163,6 +164,23 @@ export async function saveManagerChanges(
 
 export default createCodeMcpExtension();
 
+export async function promptForProblemReport(
+  pi: Pick<ExtensionAPI, "sendUserMessage">,
+  ctx: Pick<ExtensionCommandContext, "ui">,
+): Promise<void> {
+  const description = await ctx.ui.editor("What went wrong?", "");
+  if (description?.trim()) pi.sendUserMessage(formatProblemReportPrompt(description.trim()));
+}
+
+export function formatProblemReportPrompt(description: string): string {
+  return `Something went wrong with pi-codemcp.
+
+User's description:
+${description}
+
+Investigate the problem in current pi setup. Inspect the available pi-codemcp configuration, environment, and installed package as needed. Determine the likely cause, then prepare a GitHub issue for https://github.com/yolonir/pi-codemcp. Do not include any personal or sensitive information in the issue. Do not autosumbit issue without clear approval.`;
+}
+
 function requireServerStatus(
   status: Record<string, unknown>,
   serverName: string,

package/package.json

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

package/sidecar/executor.py

@@ -298,6 +298,7 @@ class MontyExecutor:
         type_stubs = catalog.type_stubs_for(referenced, include=spec.name)
         async with self._execution_lock:
             await self._type_check(wrapped, catalog, type_stubs)
+            await self._compile_runtime(code, catalog, has_input=True)
 
     def _new_context(
         self,
@@ -351,6 +352,9 @@ class MontyExecutor:
         except pydantic_monty.MontySyntaxError as error:
             context.metrics.typecheck_ms += _elapsed_ms(typecheck_started)
             return self._failure(context, "preflight", error.display("type-msg").strip())
+        except pydantic_monty.MontyRuntimeError as error:
+            context.metrics.typecheck_ms += _elapsed_ms(typecheck_started)
+            return self._failure(context, "preflight", error.display("type-msg").strip())
         except RuntimeError as error:
             context.metrics.typecheck_ms += _elapsed_ms(typecheck_started)
             return self._failure(
@@ -360,18 +364,22 @@ class MontyExecutor:
             )
         context.metrics.typecheck_ms += _elapsed_ms(typecheck_started)
 
-        runtime_wrapped = _wrap_code(code, typed=False, has_input=has_input)
-        runtime_code = _rewrite_sdk_calls(runtime_wrapped, context.catalog)
         try:
-            monty = await pydantic_monty.Monty.acreate(
-                runtime_code,
-                script_name="codemcp_execute.py",
+            monty = await self._compile_runtime(
+                code,
+                context.catalog,
+                has_input=has_input,
             )
-        except (pydantic_monty.MontySyntaxError, RuntimeError) as error:
+        except (
+            pydantic_monty.MontySyntaxError,
+            pydantic_monty.MontyRuntimeError,
+            RuntimeError,
+            NotImplementedError,
+        ) as error:
             return self._failure(
                 context,
                 "preflight",
-                f"SDK facade compilation failed: {error}",
+                f"Sandbox compilation failed: {error}",
             )
 
         async def dispatch_wrapper(name: str, arguments: JsonObject) -> JsonValue:
@@ -530,6 +538,20 @@ class MontyExecutor:
         response.metrics = context.metrics.model_copy()
         return response
 
+    @staticmethod
+    async def _compile_runtime(
+        code: str,
+        catalog: ToolCatalog,
+        *,
+        has_input: bool,
+    ) -> pydantic_monty.Monty:
+        runtime_wrapped = _wrap_code(code, typed=False, has_input=has_input)
+        runtime_code = _rewrite_sdk_calls(runtime_wrapped, catalog)
+        return await pydantic_monty.Monty.acreate(
+            runtime_code,
+            script_name="codemcp_execute.py",
+        )
+
     async def _type_check(
         self,
         wrapped_code: str,

package/sidecar/gateway.py

@@ -36,6 +36,7 @@ from .models import (
     SearchDetail,
     SearchMode,
     SearchResponse,
+    ServerDiscoveryFailure,
     ServerToolSummary,
     StatusResponse,
     UpstreamStatus,
@@ -377,7 +378,11 @@ class GatewayRuntime:
             discovery_servers = ()
         else:
             discovery_servers = (server,)
-        await self._ensure_servers_discovered(discovery_servers)
+        if server is None:
+            discovery_failures = await self._discover_servers_for_unscoped_search(discovery_servers)
+        else:
+            await self._ensure_servers_discovered(discovery_servers)
+            discovery_failures = []
         self.stats_store.record_phase("discovery", _elapsed_ms(discovery_started))
         bounded_limit = min(max(limit, 1), 20)
         bounded_cursor = max(cursor, 0)
@@ -439,6 +444,7 @@ class GatewayRuntime:
             has_more=next_cursor is not None,
             project_scope_available=self.chain_store.project_store is not None,
             execution_limits=self._execution_limits_view(),
+            discovery_failures=discovery_failures,
             prelude=self.catalog.stub_prelude if include_prelude else None,
             results=results,
         )
@@ -727,11 +733,22 @@ class GatewayRuntime:
         spec = candidate_catalog.tools[candidate.public_name]
         try:
             await self.executor.validate_saved_chain(code, candidate_catalog, spec)
-        except (pydantic_monty.MontyTypingError, pydantic_monty.MontySyntaxError) as error:
+        except (
+            pydantic_monty.MontyTypingError,
+            pydantic_monty.MontySyntaxError,
+            pydantic_monty.MontyRuntimeError,
+            NotImplementedError,
+            RuntimeError,
+        ) as error:
             if isinstance(error, pydantic_monty.MontyTypingError):
                 message = error.display("concise", color=False).strip()
-            else:
+            elif isinstance(
+                error,
+                (pydantic_monty.MontySyntaxError, pydantic_monty.MontyRuntimeError),
+            ):
                 message = error.display("type-msg").strip()
+            else:
+                message = f"Sandbox compilation failed: {error}"
             raise ValueError(_saved_chain_preflight_error(message, output_schema)) from error
         dependencies = self._chain_dependencies(code, candidate_catalog)
         saved = ChainStore.build(
@@ -790,11 +807,22 @@ class GatewayRuntime:
         spec = candidate_catalog.tools[current.public_name]
         try:
             await self.executor.validate_saved_chain(current.code, candidate_catalog, spec)
-        except (pydantic_monty.MontyTypingError, pydantic_monty.MontySyntaxError) as error:
+        except (
+            pydantic_monty.MontyTypingError,
+            pydantic_monty.MontySyntaxError,
+            pydantic_monty.MontyRuntimeError,
+            NotImplementedError,
+            RuntimeError,
+        ) as error:
             if isinstance(error, pydantic_monty.MontyTypingError):
                 message = error.display("concise", color=False).strip()
-            else:
+            elif isinstance(
+                error,
+                (pydantic_monty.MontySyntaxError, pydantic_monty.MontyRuntimeError),
+            ):
                 message = error.display("type-msg").strip()
+            else:
+                message = f"Sandbox compilation failed: {error}"
             raise ValueError(
                 _saved_chain_preflight_error(message, current.output_schema)
             ) from error
@@ -959,6 +987,36 @@ class GatewayRuntime:
     async def _ensure_catalog_complete(self) -> None:
         await self._ensure_servers_discovered(self.handles.keys())
 
+    async def _discover_servers_for_unscoped_search(
+        self,
+        server_names: Iterable[str],
+    ) -> list[ServerDiscoveryFailure]:
+        requested = set(server_names)
+        missing = [
+            (name, handle)
+            for name, handle in self.handles.items()
+            if name in requested and handle.tools is None
+        ]
+        if not missing:
+            return []
+        results = await asyncio.gather(
+            *(handle.discover() for _, handle in missing),
+            return_exceptions=True,
+        )
+        failures: list[ServerDiscoveryFailure] = []
+        for (name, _handle), result in zip(missing, results, strict=True):
+            if isinstance(result, Exception):
+                failures.append(
+                    ServerDiscoveryFailure(
+                        server=name,
+                        error=_discovery_error_message(result),
+                    )
+                )
+            elif isinstance(result, BaseException):
+                raise result
+        await self._rebuild_catalog()
+        return failures
+
     async def _ensure_servers_discovered(self, server_names: Iterable[str]) -> None:
         requested = set(server_names)
         missing = [
@@ -1148,6 +1206,10 @@ def _elapsed_ms(started: float) -> float:
     return (time.perf_counter() - started) * 1_000
 
 
+def _discovery_error_message(error: Exception) -> str:
+    return str(error).strip() or type(error).__name__
+
+
 def _parse_code(code: str) -> ast.AST | None:
     normalized = textwrap.dedent(code).strip("\n")
     wrapped = f"async def __codemcp_main():\n{textwrap.indent(normalized, '    ')}\n"

package/sidecar/models.py

@@ -63,6 +63,13 @@ class ServerToolSummary(BaseModel):
     tool_count: int
 
 
+class ServerDiscoveryFailure(BaseModel):
+    model_config = ConfigDict(extra="forbid", strict=True)
+
+    server: str
+    error: str
+
+
 class ExecutionLimitsView(BaseModel):
     model_config = ConfigDict(extra="forbid", strict=True)
 
@@ -85,6 +92,7 @@ class SearchResponse(BaseModel):
     has_more: bool = False
     project_scope_available: bool
     execution_limits: ExecutionLimitsView
+    discovery_failures: list[ServerDiscoveryFailure] = Field(default_factory=list)
     prelude: str | None = None
     results: list[ToolSchemaView]
 

package/src/modal.ts

@@ -124,6 +124,7 @@ interface ManagerSaveResult {
 }
 
 type UnsavedAction = "save" | "discard" | "cancel";
+export type ServerManagerResult = "report-problem" | undefined;
 
 interface ServerManagerOptions {
   servers: ServerModalState[];
@@ -159,6 +160,11 @@ const OVERLAY_OPTIONS = {
   maxHeight: "85%",
 } as const;
 
+const PROBLEM_REPORT_LABEL = "Extension is broken!";
+const PROBLEM_REPORT_DESCRIPTION =
+  "Well, that sucks. With this button you can ask the agent to describe the problem and prepare a GitHub issue for review. The goal is to make pi-codemcp usable for everyone, don't be lazy - submit an issue. Don't worry, you will see all prompts, this is a transparent process.";
+const PROBLEM_REPORT_SHORTCUT = "Report issue: R";
+
 const SETTING_DEFINITIONS: SettingDefinition[] = [
   {
     key: "backgroundWarmup",
@@ -214,18 +220,18 @@ const SETTING_DEFINITIONS: SettingDefinition[] = [
 export async function showServerManagerModal(
   ctx: ExtensionCommandContext,
   options: ServerManagerOptions,
-): Promise<void> {
+): Promise<ServerManagerResult> {
   if (ctx.mode !== "tui") {
     throw new Error("CodeMCP server manager requires interactive mode");
   }
 
-  await ctx.ui.custom<void>(
+  return ctx.ui.custom<ServerManagerResult>(
     (tui, theme, keybindings, done) =>
       new ServerManagerModal(
         options,
         theme,
         keybindings,
-        () => done(undefined),
+        (result) => done(result),
         () => tui.requestRender(),
       ),
     { overlay: true, overlayOptions: OVERLAY_OPTIONS },
@@ -352,7 +358,7 @@ class ServerManagerModal implements Component, Focusable {
     private readonly options: ServerManagerOptions,
     private readonly theme: Theme,
     private readonly keybindings: Keybindings,
-    private readonly close: () => void,
+    private readonly close: (result?: ServerManagerResult) => void,
     private readonly requestRender: () => void,
   ) {
     this.savedSettings = cloneSettings(options.settings);
@@ -400,6 +406,11 @@ class ServerManagerModal implements Component, Focusable {
       return;
     }
     if (this.settingsBusy || this.closePromptBusy) return;
+    if (data === "R") {
+      this.focusProblemReport();
+      this.requestRender();
+      return;
+    }
     if (this.keybindings.matches(data, "tui.select.cancel") || matchesKey(data, Key.escape)) {
       if (this.activeTab !== "settings" && this.search.getValue()) {
         this.search.setValue("");
@@ -504,7 +515,7 @@ class ServerManagerModal implements Component, Focusable {
       this.selectedSettingIndex = cycleIndex(
         this.selectedSettingIndex,
         -1,
-        SETTING_DEFINITIONS.length,
+        SETTING_DEFINITIONS.length + 1,
       );
       return;
     }
@@ -512,10 +523,14 @@ class ServerManagerModal implements Component, Focusable {
       this.selectedSettingIndex = cycleIndex(
         this.selectedSettingIndex,
         1,
-        SETTING_DEFINITIONS.length,
+        SETTING_DEFINITIONS.length + 1,
       );
       return;
     }
+    if (this.selectedSettingIndex === SETTING_DEFINITIONS.length) {
+      if (matchesKey(data, Key.enter) || data === " ") this.openProblemReport();
+      return;
+    }
     if (matchesKey(data, Key.left)) this.cycleSelectedSetting(-1);
     else if (matchesKey(data, Key.right) || matchesKey(data, Key.enter) || data === " ") {
       this.cycleSelectedSetting(1);
@@ -820,27 +835,50 @@ class ServerManagerModal implements Component, Focusable {
         ),
       );
     }
+    const problemReportSelected = this.selectedSettingIndex === SETTING_DEFINITIONS.length;
+    const problemReportPrefix = problemReportSelected ? this.theme.fg("accent", "→") : " ";
+    left.push(
+      "",
+      truncateToWidth(
+        `${problemReportPrefix} ${
+          problemReportSelected
+            ? this.theme.fg("accent", PROBLEM_REPORT_LABEL)
+            : PROBLEM_REPORT_LABEL
+        }`,
+        leftWidth,
+      ),
+    );
     const definition = SETTING_DEFINITIONS[this.selectedSettingIndex];
-    const right = definition
+    const right = problemReportSelected
       ? [
-          this.theme.fg("accent", this.theme.bold(definition.label)),
-          this.theme.fg("muted", settingLabel(definition, this.draftSettings[definition.key])),
+          this.theme.fg("accent", this.theme.bold(PROBLEM_REPORT_LABEL)),
           "",
-          ...wrapPlainText(definition.description, rightWidth).map((line) =>
+          ...wrapPlainText(PROBLEM_REPORT_DESCRIPTION, rightWidth).map((line) =>
             this.theme.fg("muted", line),
           ),
           "",
-          this.theme.fg("dim", "←/→ change · enter next · ctrl+s save"),
-          ...(this.settingsBusy
-            ? ["", this.theme.fg("warning", "Saving staged changes…")]
-            : this.hasUnsavedChanges()
-              ? ["", this.theme.fg("warning", "Unsaved changes")]
-              : []),
-          ...(this.settingsError
-            ? ["", this.theme.fg("warning", `Error: ${this.settingsError}`)]
-            : []),
+          this.theme.fg("dim", "enter describe the problem"),
         ]
-      : [];
+      : definition
+        ? [
+            this.theme.fg("accent", this.theme.bold(definition.label)),
+            this.theme.fg("muted", settingLabel(definition, this.draftSettings[definition.key])),
+            "",
+            ...wrapPlainText(definition.description, rightWidth).map((line) =>
+              this.theme.fg("muted", line),
+            ),
+            "",
+            this.theme.fg("dim", "←/→ change · enter next · ctrl+s save"),
+            ...(this.settingsBusy
+              ? ["", this.theme.fg("warning", "Saving staged changes…")]
+              : this.hasUnsavedChanges()
+                ? ["", this.theme.fg("warning", "Unsaved changes")]
+                : []),
+            ...(this.settingsError
+              ? ["", this.theme.fg("warning", `Error: ${this.settingsError}`)]
+              : []),
+          ]
+        : [];
     const lines: string[] = [];
     for (let index = 0; index < splitHeight; index += 1) {
       lines.push(
@@ -852,16 +890,17 @@ class ServerManagerModal implements Component, Focusable {
 
   private footer(): string {
     const pending = this.hasUnsavedChanges() ? " · * unsaved · ctrl+s save" : "";
+    const report = ` · ${PROBLEM_REPORT_SHORTCUT}`;
     if (this.activeTab === "settings") {
-      return `tab servers · ↑/↓ navigate · ←/→/enter change · ctrl+s save · esc close${pending}`;
+      return `tab servers · ↑/↓ navigate · ←/→ change · enter select · ctrl+s save · esc close${pending}${report}`;
     }
     if (this.activeTab === "chains") {
-      return `tab stats · ↑/↓ navigate · space toggle · r revalidate · del delete · esc close${pending}`;
+      return `tab stats · ↑/↓ navigate · space toggle · r revalidate · del delete · esc close${pending}${report}`;
     }
     if (this.activeTab === "stats") {
-      return `tab settings · bounded local rollups · esc close${pending}`;
+      return `tab settings · bounded local rollups · esc close${pending}${report}`;
     }
-    return `tab chains · ←/→ pane · ↑/↓ navigate · space toggle · d discover · esc close${pending}`;
+    return `tab chains · ←/→ pane · ↑/↓ navigate · space toggle · d discover · esc close${pending}${report}`;
   }
 
   private moveSelection(direction: -1 | 1): void {
@@ -1053,17 +1092,29 @@ class ServerManagerModal implements Component, Focusable {
     }
   }
 
-  private resolveUnsavedClose(): void {
+  private focusProblemReport(): void {
+    this.activeTab = "settings";
+    this.selectedSettingIndex = SETTING_DEFINITIONS.length;
+    this.search.setValue("");
+    this.search.focused = false;
+  }
+
+  private openProblemReport(): void {
+    if (this.hasUnsavedChanges()) this.resolveUnsavedClose("report-problem");
+    else this.close("report-problem");
+  }
+
+  private resolveUnsavedClose(result?: ServerManagerResult): void {
     if (this.closePromptBusy || this.settingsBusy) return;
     this.closePromptBusy = true;
     void this.options
       .onResolveUnsaved()
       .then(async (action) => {
         if (action === "discard") {
-          this.close();
+          this.close(result);
           return;
         }
-        if (action === "save" && (await this.persistDraft())) this.close();
+        if (action === "save" && (await this.persistDraft())) this.close(result);
       })
       .catch((error: unknown) => {
         this.settingsError = summarizeError(error);

package/src/prompts.ts

@@ -11,11 +11,12 @@ export const EXECUTE_PROMPT_GUIDELINES = [
   "Use programmatic execution for a bounded workflow when code can deterministically filter, join, aggregate, deduplicate, validate, or reduce intermediate results.",
   "Keep a model turn between calls when an intermediate result changes the semantic decision or user approval is required.",
   "Return the smallest result that answers the request; oversized results fail explicitly with bounded structural inspection data.",
-  "SDK facades returned by search are prebound globals and must not be imported; use a normal import statement such as `import asyncio` before `asyncio.gather`, because `__import__` is unavailable.",
+  "SDK facades are prebound globals and must not be imported. Import supported stdlib normally (for example, `import asyncio`); class declarations and `__import__` are unsupported.",
 ] as const;
 
 export const SAVE_CHAIN_PROMPT_GUIDELINES = [
   "Save only after the user explicitly asks or accepts, and only after the same code has executed successfully.",
+  "Use generated result item types for nested schema collections; do not declare TypedDict classes.",
   "Use project scope when available unless the user explicitly requests global scope; make schemas describe the exact parameterized contract.",
 ] as const;
 

package/src/tools.ts

@@ -30,6 +30,7 @@ interface SearchRenderDetails extends CodeMcpOutputDetails {
   nextCursor?: number;
   detail: string;
   preview: string[];
+  discoveryFailures: string[];
 }
 
 const SearchParameters = Type.Object({
@@ -154,7 +155,7 @@ export function registerCodeMcpTools(
     name: "codemcp_search",
     label: "MCP Search",
     description:
-      "Search configured MCP capabilities or page through compact inventory. Default signature search includes exact stubs for up to three top matches plus compact alternatives; codemcp_inspect loads other selected stubs. Returns ranking evidence, pagination, scope, and execution limits; invalid server names fail with suggestions.",
+      "Search configured MCP capabilities or page through compact inventory. Default signature search includes exact stubs for up to three top matches plus compact alternatives; codemcp_inspect loads other selected stubs. Unscoped searches return available results plus explicit discovery failures; scoped searches remain fail-fast. Returns ranking evidence, pagination, scope, and execution limits; invalid server names fail with suggestions.",
     promptSnippet: "Discover compact MCP capabilities or inventory",
     promptGuidelines: [...SEARCH_PROMPT_GUIDELINES],
     parameters: SearchParameters,
@@ -186,6 +187,11 @@ export function registerCodeMcpTools(
             return [`${String(item.name)} ${String(item.tool_count ?? 0)}`];
           })
         : [];
+      const discoveryFailures = Array.isArray(result.discovery_failures)
+        ? result.discovery_failures.flatMap((item) =>
+            isRecord(item) && typeof item.server === "string" ? [item.server] : [],
+          )
+        : [];
       return {
         content: [{ type: "text", text: output.text }],
         details: {
@@ -197,6 +203,7 @@ export function registerCodeMcpTools(
           nextCursor: typeof result.next_cursor === "number" ? result.next_cursor : undefined,
           detail: typeof result.detail === "string" ? result.detail : "signatures",
           preview,
+          discoveryFailures,
         },
       };
     },
@@ -212,13 +219,18 @@ export function registerCodeMcpTools(
       if (isPartial) return new Text(theme.fg("warning", "Searching catalog..."), 0, 0);
       if (expanded) return renderExpandedJson(result.content);
       const details = result.details as SearchRenderDetails | undefined;
+      const discoveryFailures = details?.discoveryFailures ?? [];
+      const unavailable = discoveryFailures.length;
       let text = theme.fg(
-        "success",
-        `${details?.matchCount ?? 0} matches · ${details?.detail ?? "signatures"} · ${details?.totalToolCount ?? 0} tools · ${details?.serverCount ?? 0} servers`,
+        unavailable > 0 ? "warning" : "success",
+        `${details?.matchCount ?? 0} matches · ${details?.detail ?? "signatures"} · ${details?.totalToolCount ?? 0} tools · ${details?.serverCount ?? 0} servers${unavailable > 0 ? ` · ${unavailable} unavailable` : ""}`,
       );
       for (const name of details?.preview ?? []) {
         text += `\n${theme.fg("dim", `  ${name}`)}`;
       }
+      for (const server of discoveryFailures) {
+        text += `\n${theme.fg("warning", `  unavailable: ${server}`)}`;
+      }
       if (details?.hasMore) {
         text += `\n${theme.fg("muted", `  more at cursor ${details.nextCursor ?? "?"}`)}`;
       }