pi-codemcp 1.4.0 → 1.5.1

package/sidecar/gateway.py

@@ -11,7 +11,7 @@ from contextlib import AsyncExitStack, asynccontextmanager, suppress
 from typing import TYPE_CHECKING, Literal, NamedTuple, Protocol, cast
 
 import pydantic_monty
-from fastmcp import Client, FastMCP
+from fastmcp import Client, Context, FastMCP
 from fastmcp.mcp_config import RemoteMCPServer, StdioMCPServer
 from pydantic_core import to_json
 from rapidfuzz import fuzz, process
@@ -33,6 +33,7 @@ from .executor import (
     ExecutionFailureInfo,
     ExecutionResponse,
     MontyExecutor,
+    ProgressReporter,
 )
 from .mcp_config import NormalizedConfig, load_mcp_json, normalize_mcp_config
 from .models import (
@@ -601,15 +602,17 @@ class GatewayRuntime:
         code: str,
         trace_id: str,
         input_ref: str | None = None,
+        progress: ProgressReporter | None = None,
     ) -> ExecutionResponse:
         async with self._execute_lock:
-            return await self._execute(code, trace_id, input_ref)
+            return await self._execute(code, trace_id, input_ref, progress)
 
     async def edit_execute(
         self,
         old_text: str,
         new_text: str,
         trace_id: str,
+        progress: ProgressReporter | None = None,
     ) -> ExecutionResponse:
         async with self._execute_lock:
             previous = self._last_execution
@@ -625,13 +628,14 @@ class GatewayRuntime:
                     f"old_text must match the previous code exactly once; found {matches} matches"
                 )
             code = previous.code.replace(old_text, new_text, 1)
-            return await self._execute(code, trace_id, previous.input_ref)
+            return await self._execute(code, trace_id, previous.input_ref, progress)
 
     async def _execute(
         self,
         code: str,
         trace_id: str,
         input_ref: str | None,
+        progress: ProgressReporter | None = None,
     ) -> ExecutionResponse:
         self._last_execution = None
         started = time.perf_counter()
@@ -682,6 +686,7 @@ class GatewayRuntime:
                 self._dispatch,
                 input_value=input_value,
                 retain_result=self.refinement_cache.retain,
+                progress=progress,
             )
         except BaseException as error:
             cancelled = isinstance(error, asyncio.CancelledError)
@@ -1615,6 +1620,13 @@ def _require_runtime() -> GatewayRuntime:
     return _runtime_state.runtime
 
 
+def _progress_reporter(ctx: Context) -> ProgressReporter:
+    async def report(total_calls: int, message: str) -> None:
+        await ctx.report_progress(progress=float(total_calls), message=message)
+
+    return report
+
+
 def configure_runtime_paths(paths: RuntimePaths | None) -> None:
     _runtime_state.paths = paths
 
@@ -1714,10 +1726,16 @@ async def set_chain_enabled(
 async def execute(
     trace_id: str,
     code: str,
+    ctx: Context,
     input_ref: str | None = None,
 ) -> ExecutionResponse:
     """Type-check and run one sandboxed Python MCP SDK chain."""
-    return await _require_runtime().execute(code, trace_id, input_ref)
+    return await _require_runtime().execute(
+        code,
+        trace_id,
+        input_ref,
+        _progress_reporter(ctx),
+    )
 
 
 @mcp.tool
@@ -1725,9 +1743,15 @@ async def edit_execute(
     trace_id: str,
     old_text: str,
     new_text: str,
+    ctx: Context,
 ) -> ExecutionResponse:
     """Patch and rerun the last sandbox execution."""
-    return await _require_runtime().edit_execute(old_text, new_text, trace_id)
+    return await _require_runtime().edit_execute(
+        old_text,
+        new_text,
+        trace_id,
+        _progress_reporter(ctx),
+    )
 
 
 @mcp.tool

package/sidecar/settings.py

@@ -26,6 +26,7 @@ class CodeMcpSettings(BaseModel):
     )
 
     version: Literal[2] = 2
+    jev_enabled: bool = False
     background_warmup: bool = True
     cache_ttl_hours: int = Field(default=24, ge=0, le=720)
     execution_timeout_seconds: int = Field(default=30, ge=1, le=300)
@@ -60,4 +61,10 @@ def load_settings(path: Path) -> CodeMcpSettings:
     if isinstance(value, dict) and value.get("version", 1) == 1:
         value = {key: item for key, item in value.items() if key != "outputLineLimit"}
         value["version"] = 2
+    if isinstance(value, dict) and "discoveryMode" in value:
+        mode = value.pop("discoveryMode")
+        if not isinstance(mode, str) or mode not in {"search", "jev"}:
+            value["discoveryMode"] = mode
+        else:
+            value.setdefault("jevEnabled", mode == "jev")
     return CodeMcpSettings.model_validate(value)

package/src/execution-rendering.ts

@@ -16,6 +16,12 @@ interface RenderResult {
   details?: unknown;
 }
 
+/** Details sent with partial updates while an execution is running. */
+export interface ExecutionProgressDetails {
+  callsMade: number;
+  currentCall?: string;
+}
+
 interface ExecutionRendererOptions {
   partialText?: string;
   expandDescription?: string;
@@ -28,6 +34,16 @@ export function renderExecutionResult(
   options: ExecutionRendererOptions = {},
 ): Text {
   if (state.isPartial) {
+    const progress = result.details as ExecutionProgressDetails | undefined;
+    if (typeof progress?.callsMade === "number") {
+      const calls = progress.callsMade;
+      const current = progress.currentCall ? ` · ${progress.currentCall}` : "";
+      return new Text(
+        `\n${theme.fg("warning", `Executing · ${calls} MCP ${calls === 1 ? "call" : "calls"}${current}...`)}`,
+        0,
+        0,
+      );
+    }
     return new Text(
       `\n${theme.fg("warning", options.partialText ?? "Preflight check, then execution...")}`,
       0,

package/src/jev-router.ts

@@ -0,0 +1,323 @@
+import { randomUUID } from "node:crypto";
+import { choice, noul, type Questions, type TypeSafeClient } from "@typesafe-ai/sdk";
+import type { CodeMcpLifecycle } from "./lifecycle.js";
+
+const TOOL_RELEVANCE_THRESHOLD = 0.65;
+const NOUL_THRESHOLD = 0.5;
+// ponytail: bound injected schemas; raise only if routing evals show recall loss.
+const MAX_SELECTED_TOOLS = 8;
+const CATALOG_PAGE_SIZE = 20;
+const JEV_CHUNK_SIZE = 40;
+
+type ToolRole = "source" | "enrichment" | "sink" | "standalone" | "unspecified";
+const TOOL_ROLE_BY_CHOICE: Readonly<Record<string, ToolRole>> = {
+  source: "source",
+  enrichment: "enrichment",
+  sink: "sink",
+  standalone: "standalone",
+  irrelevant: "unspecified",
+};
+type WorkflowShape = "single_call" | "parallel" | "pipeline" | "mixed";
+
+interface CatalogTool {
+  call: string;
+  description?: string;
+}
+
+interface IndexedTool {
+  index: number;
+  tool: CatalogTool;
+}
+
+interface ChunkResult {
+  tools: JevSelectedTool[];
+  needsAnyTool?: number;
+  needsCheckpoint?: number;
+}
+
+export interface JevSelectedTool extends CatalogTool {
+  relevance: number;
+  role: ToolRole;
+}
+
+export interface JevRoute {
+  prompt: string;
+  selected: JevSelectedTool[];
+  needsAnyTool: number;
+  workflowShape: WorkflowShape;
+  needsCheckpoint: number;
+}
+
+export class JevRouter {
+  constructor(
+    private readonly lifecycle: Pick<CodeMcpLifecycle, "request">,
+    private readonly client: TypeSafeClient,
+  ) {}
+
+  async route(task: string, recentContext = "", signal?: AbortSignal): Promise<JevRoute> {
+    const catalog = await this.loadCatalog(signal);
+    if (catalog.length === 0) return emptyRoute();
+
+    const chunks = chunk(
+      catalog.map((tool, index) => ({ tool, index })),
+      JEV_CHUNK_SIZE,
+    );
+    const results = await Promise.all(
+      chunks.map((tools, index) =>
+        this.evaluateChunk(task, recentContext, tools, index === 0, signal),
+      ),
+    );
+    const needsAnyTool = results[0]?.needsAnyTool ?? 0;
+    const needsCheckpoint = results[0]?.needsCheckpoint ?? 0;
+    const ranked = results
+      .flatMap((result) => result.tools)
+      .sort(
+        (left, right) => right.relevance - left.relevance || left.call.localeCompare(right.call),
+      );
+    const selected =
+      needsAnyTool >= NOUL_THRESHOLD
+        ? ranked
+            .filter((tool) => tool.relevance >= TOOL_RELEVANCE_THRESHOLD)
+            .slice(0, MAX_SELECTED_TOOLS)
+        : [];
+    const workflowShape = workflowShapeFor(selected);
+    if (selected.length === 0) {
+      return { ...emptyRoute(), needsAnyTool, needsCheckpoint, workflowShape };
+    }
+
+    const inspection = await this.lifecycle.request(
+      "inspect",
+      {
+        calls: selected.map((tool) => tool.call),
+        trace_id: `jev-${randomUUID()}`,
+      },
+      signal,
+    );
+    const prelude = typeof inspection.prelude === "string" ? inspection.prelude : "";
+    const stubs = Array.isArray(inspection.results)
+      ? inspection.results.flatMap((item) => {
+          if (!isRecord(item) || typeof item.stub !== "string") return [];
+          return [item.stub];
+        })
+      : [];
+    if (stubs.length !== selected.length) {
+      throw new Error("CodeMCP inspect returned incomplete Jev-selected contracts");
+    }
+
+    return {
+      prompt: jevPrompt(
+        selected,
+        workflowShape,
+        needsCheckpoint,
+        [prelude, ...stubs].filter(Boolean).join("\n\n"),
+      ),
+      selected,
+      needsAnyTool,
+      workflowShape,
+      needsCheckpoint,
+    };
+  }
+
+  private async evaluateChunk(
+    task: string,
+    recentContext: string,
+    tools: IndexedTool[],
+    includeTaskQuestions: boolean,
+    signal?: AbortSignal,
+  ): Promise<ChunkResult> {
+    const questions: Questions = {};
+    if (includeTaskQuestions) {
+      questions.needs_any_tool = noul(
+        "Does the current task (the agent's routing intent) require at least one configured external-service or saved-workflow tool? Use the original user request as context, not as a requirement that every step be explicitly named.",
+        {
+          true: "The request needs current, private, or external state, or asks for an external action.",
+          false: "Explanation, reasoning, or local coding tools can fully satisfy the request.",
+        },
+      );
+      questions.needs_checkpoint = noul(
+        "For the current task, must the agent inspect an intermediate result, make a semantic decision, or obtain user approval before the next external call?",
+        {
+          true: "A model or user decision is required between tool stages.",
+          false: "One deterministic CodeMCP program can safely run the complete workflow.",
+        },
+      );
+    }
+    for (const { index, tool } of tools) {
+      const toolDescription = {
+        call: tool.call,
+        description: tool.description ?? tool.call,
+      };
+      questions[`tool_${index}`] = noul(
+        {
+          question:
+            "Is this tool needed for the current task (the agent's routing intent), including prerequisite discovery or diagnostic calls? The user need not explicitly name each step.",
+          tool: toolDescription,
+        },
+        {
+          true: "The task needs this capability directly or as a prerequisite, such as finding a datasource before querying logs.",
+          false: "The tool is unrelated, redundant, optional, or merely adjacent.",
+        },
+      );
+      questions[`role_${index}`] = choice(
+        {
+          question: "What role should this tool have in the minimal workflow for the current task?",
+          tool: toolDescription,
+        },
+        {
+          source: "Retrieves initial data.",
+          enrichment: "Retrieves data using an earlier result.",
+          sink: "Performs a downstream action using earlier results.",
+          standalone: "Independently completes one requested action.",
+          irrelevant: "Should not be used for this task.",
+        },
+      );
+    }
+
+    const response = await this.client.systemOne(
+      {
+        state: {
+          task,
+          ...(recentContext ? { recent_context: recentContext } : {}),
+        },
+        questions,
+      },
+      signal ? { signal } : undefined,
+    );
+    return {
+      tools: tools.map(({ index, tool }) => ({
+        ...tool,
+        relevance: noulValue(response.answers[`tool_${index}`]),
+        role: toolRoleValue(response.answers[`role_${index}`]),
+      })),
+      ...(includeTaskQuestions
+        ? {
+            needsAnyTool: noulValue(response.answers.needs_any_tool),
+            needsCheckpoint: noulValue(response.answers.needs_checkpoint),
+          }
+        : {}),
+    };
+  }
+
+  private async loadCatalog(signal?: AbortSignal): Promise<CatalogTool[]> {
+    const tools: CatalogTool[] = [];
+    let cursor = 0;
+    while (true) {
+      const page = await this.lifecycle.request(
+        "search",
+        {
+          mode: "inventory",
+          detail: "names",
+          limit: CATALOG_PAGE_SIZE,
+          cursor,
+          trace_id: `jev-${randomUUID()}`,
+        },
+        signal,
+      );
+      if (Array.isArray(page.results)) {
+        for (const item of page.results) {
+          if (!isRecord(item) || typeof item.call !== "string") continue;
+          tools.push({
+            call: item.call,
+            ...(typeof item.description === "string" ? { description: item.description } : {}),
+          });
+        }
+      }
+      if (typeof page.next_cursor !== "number") break;
+      if (page.next_cursor <= cursor) throw new Error("CodeMCP inventory cursor did not advance");
+      cursor = page.next_cursor;
+    }
+    return tools;
+  }
+}
+
+function emptyRoute(): JevRoute {
+  return {
+    prompt: "Jev found no configured MCP tool relevant to this request.",
+    selected: [],
+    needsAnyTool: 0,
+    workflowShape: "single_call",
+    needsCheckpoint: 0,
+  };
+}
+
+function workflowShapeFor(selected: JevSelectedTool[]): WorkflowShape {
+  if (selected.length <= 1) return "single_call";
+  const independent = selected.filter(
+    (tool) => tool.role === "source" || tool.role === "standalone",
+  ).length;
+  const downstream = selected.some((tool) => tool.role === "enrichment" || tool.role === "sink");
+  if (!downstream) return "parallel";
+  return independent > 1 ? "mixed" : "pipeline";
+}
+
+function jevPrompt(
+  selected: JevSelectedTool[],
+  workflowShape: WorkflowShape,
+  needsCheckpoint: number,
+  contracts: string,
+): string {
+  const roles = selected.map((tool) => `- ${tool.call}: ${tool.role}`).join("\n");
+  const execution =
+    needsCheckpoint >= NOUL_THRESHOLD
+      ? "Run only the first stage in codemcp_execute, return compact decision data, then preserve a model/user checkpoint before downstream calls."
+      : workflowInstruction(workflowShape);
+  return [
+    `Jev selected these MCP calls:\n${roles}`,
+    `Composition: ${workflowShape}.`,
+    `Execution recommendation: ${execution}`,
+    "Use these exact typed SDK contracts:",
+    "```python",
+    contracts,
+    "```",
+  ].join("\n\n");
+}
+
+function workflowInstruction(shape: WorkflowShape): string {
+  switch (shape) {
+    case "single_call":
+      return "Write and run one minimal codemcp_execute program using the selected call.";
+    case "parallel":
+      return "Write and run one codemcp_execute program using asyncio.gather for independent calls, then combine their results locally.";
+    case "pipeline":
+      return "Write and run one codemcp_execute program that passes earlier outputs into dependent calls.";
+    case "mixed":
+      return "Write and run one codemcp_execute program that gathers independent source calls, then feeds their results into downstream calls.";
+  }
+}
+
+function toolRoleValue(answer: unknown): ToolRole {
+  const role = TOOL_ROLE_BY_CHOICE[choiceValue(answer)];
+  if (!role) throw new Error("TypeSafe returned an invalid Jev tool role");
+  return role;
+}
+
+function choiceValue(answer: unknown): string {
+  if (!isRecord(answer) || answer.type !== "choice" || typeof answer.choice !== "string") {
+    throw new Error("TypeSafe returned an invalid Jev routing choice");
+  }
+  return answer.choice;
+}
+
+function noulValue(answer: unknown): number {
+  if (
+    !isRecord(answer) ||
+    answer.type !== "noul" ||
+    typeof answer.noul !== "number" ||
+    !Number.isFinite(answer.noul)
+  ) {
+    throw new Error("TypeSafe returned an invalid Jev routing answer");
+  }
+  return answer.noul;
+}
+
+function chunk<T>(values: T[], size: number): T[][] {
+  const chunks: T[][] = [];
+  for (let index = 0; index < values.length; index += size) {
+    chunks.push(values.slice(index, index + size));
+  }
+  return chunks;
+}
+
+function isRecord(value: unknown): value is Record<string, unknown> {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}

package/src/lifecycle.ts

@@ -1,4 +1,9 @@
-import { SidecarClient, type SidecarClientOptions, type SidecarToolName } from "./mcp-client.js";
+import {
+  SidecarClient,
+  type SidecarClientOptions,
+  type SidecarProgressCallback,
+  type SidecarToolName,
+} from "./mcp-client.js";
 import { type CodeMcpSettings, loadCodeMcpSettings } from "./settings.js";
 
 export class CodeMcpLifecycle {
@@ -37,9 +42,10 @@ export class CodeMcpLifecycle {
     name: SidecarToolName,
     args: Record<string, unknown>,
     signal?: AbortSignal,
+    onProgress?: SidecarProgressCallback,
   ): Promise<Record<string, unknown>> {
     await this.reloadBarrier;
-    return this.sidecar.call(name, args, signal);
+    return this.sidecar.call(name, args, signal, onProgress);
   }
 
   async warmup(): Promise<void> {

package/src/mcp-client.ts

@@ -66,6 +66,14 @@ export function sidecarToolTimeoutMs(
   return DEFAULT_TOOL_TIMEOUT_MS;
 }
 
+export interface SidecarProgress {
+  progress: number;
+  total?: number | undefined;
+  message?: string | undefined;
+}
+
+export type SidecarProgressCallback = (progress: SidecarProgress) => void;
+
 export interface SidecarClientOptions {
   packageRoot?: string;
   agentDir?: string;
@@ -153,7 +161,12 @@ export class SidecarClient {
     return this.client !== undefined && this.transport?.pid !== null;
   }
 
-  async call(name: SidecarToolName, args: JsonObject, signal?: AbortSignal): Promise<JsonObject> {
+  async call(
+    name: SidecarToolName,
+    args: JsonObject,
+    signal?: AbortSignal,
+    onProgress?: SidecarProgressCallback,
+  ): Promise<JsonObject> {
     await this.ensureStarted(signal);
     const client = this.client;
     if (!client) throw new Error("Sidecar client failed to initialize");
@@ -165,6 +178,7 @@ export class SidecarClient {
     const result = await client.callTool({ name, arguments: args }, undefined, {
       timeout,
       ...(signal === undefined ? {} : { signal }),
+      ...(onProgress === undefined ? {} : { onprogress: onProgress }),
     });
 
     if (result.isError) {

package/src/modal.ts

@@ -13,7 +13,12 @@ import {
 } from "@earendil-works/pi-tui";
 import type { ChainScope, SavedChainView } from "./chains.js";
 import { summarizeError } from "./errors.js";
-import type { CodeMcpSettings, EditableSettingKey, EditableSettingValue } from "./settings.js";
+import {
+  type CodeMcpSettings,
+  type EditableSettingKey,
+  type EditableSettingValue,
+  setEditableSetting,
+} from "./settings.js";
 
 export interface ToolModalState {
   name: string;
@@ -136,13 +141,22 @@ const OVERLAY_OPTIONS = {
   minWidth: 72,
   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: "jevEnabled",
+    label: "Enable Jev",
+    description:
+      "Let the agent call Jev on demand to select and compose relevant MCP contracts instead of local search. Requires TYPESAFE_API_KEY and sends routed tasks and enabled tool descriptions to TypeSafe.",
+    choices: [
+      { value: false, label: "false" },
+      { value: true, label: "true" },
+    ],
+  },
   {
     key: "backgroundWarmup",
     label: "Background warmup",
@@ -327,6 +341,7 @@ class ServerManagerModal implements Component, Focusable {
   private selectedToolIndex = 0;
   private selectedChainIndex = 0;
   private selectedSettingIndex = 0;
+  private settingBusy = false;
   private settingsError: string | undefined;
   private _focused = false;
 
@@ -1005,8 +1020,9 @@ class ServerManagerModal implements Component, Focusable {
 
   private cycleSelectedSetting(direction: -1 | 1): void {
     const definition = SETTING_DEFINITIONS[this.selectedSettingIndex];
-    if (!definition) return;
-    const current = this.options.settings[definition.key];
+    if (!definition || this.settingBusy) return;
+    const previous = this.options.settings;
+    const current = previous[definition.key];
     const currentIndex = Math.max(
       0,
       definition.choices.findIndex((choice) => choice.value === current),
@@ -1014,16 +1030,23 @@ class ServerManagerModal implements Component, Focusable {
     const choice =
       definition.choices[cycleIndex(currentIndex, direction, definition.choices.length)];
     if (!choice) return;
+    this.settingBusy = true;
     this.settingsError = undefined;
+    this.options.settings = setEditableSetting(previous, definition.key, choice.value);
+    this.requestRender();
     void this.options
       .onSetSetting(definition.key, choice.value)
       .then((settings) => {
         this.options.settings = settings;
       })
       .catch((error: unknown) => {
+        this.options.settings = previous;
         this.settingsError = summarizeError(error);
       })
-      .finally(() => this.requestRender());
+      .finally(() => {
+        this.settingBusy = false;
+        this.requestRender();
+      });
   }
 
   private focusProblemReport(): void {