@ilya-lesikov/pi-pi 0.4.0 → 0.6.0

package/extensions/orchestrator/exa.test.ts

@@ -0,0 +1,46 @@
+import { describe, it, expect, vi, afterEach } from "vitest";
+import { callExa } from "./exa.js";
+
+function mockFetchText(text: string, init: { ok?: boolean; status?: number } = {}) {
+  return vi.spyOn(globalThis, "fetch").mockResolvedValue({
+    ok: init.ok ?? true,
+    status: init.status ?? 200,
+    text: async () => text,
+  } as Response);
+}
+
+afterEach(() => {
+  vi.restoreAllMocks();
+});
+
+describe("callExa error handling", () => {
+  it("throws on an SSE error payload even when the message lacks the word 'error'", async () => {
+    mockFetchText(`data: ${JSON.stringify({ error: { message: "rate limit exceeded" } })}\n`);
+    await expect(callExa("web_search_exa", {})).rejects.toThrow("rate limit exceeded");
+  });
+
+  it("returns text from a normal SSE success response", async () => {
+    mockFetchText(`data: ${JSON.stringify({ result: { content: [{ text: "hello world" }] } })}\n`);
+    await expect(callExa("web_search_exa", {})).resolves.toBe("hello world");
+  });
+
+  it("returns text from a non-SSE JSON success response", async () => {
+    mockFetchText(JSON.stringify({ result: { content: [{ text: "plain json" }] } }));
+    await expect(callExa("web_search_exa", {})).resolves.toBe("plain json");
+  });
+
+  it("throws on a non-SSE JSON error payload lacking the word 'error'", async () => {
+    mockFetchText(JSON.stringify({ error: { message: "quota reached" } }));
+    await expect(callExa("web_search_exa", {})).rejects.toThrow("quota reached");
+  });
+
+  it("falls through and returns the raw body for a non-JSON OK response", async () => {
+    mockFetchText("not json at all", { ok: true, status: 200 });
+    await expect(callExa("web_search_exa", {})).resolves.toBe("not json at all");
+  });
+
+  it("throws on a non-JSON body when the HTTP response is not ok", async () => {
+    mockFetchText("rate limited", { ok: false, status: 429 });
+    await expect(callExa("web_search_exa", {})).rejects.toThrow("Exa HTTP 429");
+  });
+});

package/extensions/orchestrator/exa.ts

@@ -3,7 +3,7 @@ import { Type } from "@sinclair/typebox";
 
 const EXA_MCP_URL = "https://mcp.exa.ai/mcp";
 
-async function callExa(toolName: string, args: Record<string, unknown>): Promise<string> {
+export async function callExa(toolName: string, args: Record<string, unknown>): Promise<string> {
   const body = JSON.stringify({
     jsonrpc: "2.0",
     id: 1,
@@ -25,23 +25,29 @@ async function callExa(toolName: string, args: Record<string, unknown>): Promise
 
   for (const line of raw.split("\n")) {
     if (!line.startsWith("data:")) continue;
+    let json: any;
     try {
-      const json = JSON.parse(line.slice(5).trim());
-      if (json.error) throw new Error(json.error.message);
-      const text = json.result?.content?.[0]?.text;
-      if (text) return text;
-    } catch (e: any) {
-      if (e.message?.includes("error")) throw e;
+      json = JSON.parse(line.slice(5).trim());
+    } catch {
+      continue;
     }
+    if (json.error) throw new Error(json.error.message ?? JSON.stringify(json.error));
+    const text = json.result?.content?.[0]?.text;
+    if (text) return text;
   }
 
+  let json: any;
   try {
-    const json = JSON.parse(raw);
-    if (json.error) throw new Error(json.error.message);
-    return json.result?.content?.[0]?.text ?? raw;
+    json = JSON.parse(raw);
   } catch {
+    if (!res.ok) throw new Error(`Exa HTTP ${res.status}: ${raw.slice(0, 200)}`);
     return raw;
   }
+  if (json.error) throw new Error(json.error.message ?? JSON.stringify(json.error));
+  const text = json.result?.content?.[0]?.text;
+  if (text != null) return text;
+  if (!res.ok) throw new Error(`Exa HTTP ${res.status}: ${raw.slice(0, 200)}`);
+  return raw;
 }
 
 function ok(text: string) {

package/extensions/orchestrator/flant-infra.test.ts

@@ -0,0 +1,224 @@
+import { existsSync, mkdirSync, mkdtempSync, rmSync, writeFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { afterEach, describe, expect, it, vi } from "vitest";
+
+const tempDirs: string[] = [];
+
+function makeTempDir(): string {
+  const dir = mkdtempSync(join(tmpdir(), "pi-pi-flant-infra-"));
+  tempDirs.push(dir);
+  return dir;
+}
+
+async function loadFlantInfraModule(agentDir: string) {
+  process.env.PI_CODING_AGENT_DIR = agentDir;
+  vi.resetModules();
+  return import("./flant-infra.js");
+}
+
+function collectModelSpecs(value: unknown): string[] {
+  if (!value || typeof value !== "object") return [];
+  const out: string[] = [];
+  const walk = (node: any) => {
+    if (!node || typeof node !== "object") return;
+    if (typeof node.model === "string") out.push(node.model);
+    for (const nested of Object.values(node)) {
+      walk(nested);
+    }
+  };
+  walk(value);
+  return out;
+}
+
+afterEach(() => {
+  delete process.env.PI_CODING_AGENT_DIR;
+  for (const dir of tempDirs.splice(0)) {
+    rmSync(dir, { recursive: true, force: true });
+  }
+});
+
+describe("flant-infra", () => {
+  it("registerFlantProviders is idempotent across repeated calls", async () => {
+    const dir = makeTempDir();
+    const mod = await loadFlantInfraModule(dir);
+
+    const registered = new Map<string, unknown>();
+    const pi = {
+      registerProvider: vi.fn((name: string, config: unknown) => registered.set(name, config)),
+      unregisterProvider: vi.fn((name: string) => registered.delete(name)),
+    } as any;
+
+    const models = ["claude-opus-4-6", "gpt-5"];
+    mod.registerFlantProviders(pi, models, {});
+    mod.registerFlantProviders(pi, models, {});
+
+    expect(registered.size).toBe(2);
+    expect([...registered.keys()].sort()).toEqual(["pp-flant-anthropic", "pp-flant-openai"]);
+  });
+
+  it("generateDisplayName formats model ids", async () => {
+    const dir = makeTempDir();
+    const mod = await loadFlantInfraModule(dir);
+
+    expect(mod.generateDisplayName("claude-opus-4-6")).toBe("Claude Opus 4.6");
+    expect(mod.generateDisplayName("gpt-5-4-mini")).toBe("GPT 5.4 Mini");
+    expect(mod.generateDisplayName("o3-mini")).toBe("O3 Mini");
+    expect(mod.generateDisplayName("qwen-3-coder")).toBe("Qwen 3 Coder");
+    expect(mod.generateDisplayName("api-ai-2")).toBe("API AI 2");
+  });
+
+  it("generateFlantConfig creates config with mapped model specs", async () => {
+    const dir = makeTempDir();
+    const mod = await loadFlantInfraModule(dir);
+
+    const config = mod.generateFlantConfig([
+      "claude-opus-4-6",
+      "gpt-5-4",
+      "gpt-5-4-mini",
+      "gemini-3-1-pro",
+      "gemini-3-1-flash",
+      "deepseek-v3",
+      "grok-4",
+    ]) as any;
+
+    expect(config.agents.orchestrators.implement.model).toBe("pp-flant-anthropic/claude-opus-4-6");
+    expect(config.agents.orchestrators.plan.model).toBe("pp-flant-anthropic/claude-opus-4-6");
+    expect(config.agents.orchestrators.debug.model).toBe("pp-flant-openai/gpt-5-4");
+    expect(config.agents.orchestrators.brainstorm.model).toBe("pp-flant-anthropic/claude-opus-4-6");
+    expect(config.agents.orchestrators.review.model).toBe("pp-flant-anthropic/claude-opus-4-6");
+    expect(config.agents.subagents.simple.explore.model).toBe("pp-flant-openai/gemini-3-1-flash");
+    expect(config.agents.subagents.simple.librarian.model).toBe("pp-flant-openai/gemini-3-1-flash");
+    expect(config.agents.subagents.presetGroups.planners.presets.regular.agents.opus.model).toBe("pp-flant-anthropic/claude-opus-4-6");
+    expect(config.agents.subagents.presetGroups.planners.presets.regular.agents.gpt.model).toBe("pp-flant-openai/gpt-5-4");
+    expect(config.agents.subagents.presetGroups.planners.presets.regular.agents.gemini.model).toBe("pp-flant-openai/gemini-3-1-pro");
+  });
+
+  it("generateFlantConfig returns empty object for empty models", async () => {
+    const dir = makeTempDir();
+    const mod = await loadFlantInfraModule(dir);
+
+    expect(mod.generateFlantConfig([])).toEqual({});
+  });
+
+  it("generateFlantConfig with anthropic-only models uses anthropic specs", async () => {
+    const dir = makeTempDir();
+    const mod = await loadFlantInfraModule(dir);
+
+    const config = mod.generateFlantConfig(["claude-opus-4-6", "claude-sonnet-4-6", "claude-haiku-3-5"]);
+    const specs = collectModelSpecs(config);
+
+    expect(specs.length).toBeGreaterThan(0);
+    expect(specs.every((spec) => spec.startsWith("pp-flant-anthropic/"))).toBe(true);
+    expect(specs.some((spec) => spec.startsWith("pp-flant-openai/"))).toBe(false);
+  });
+
+  it("generateFlantConfig picks latest models per family", async () => {
+    const dir = makeTempDir();
+    const mod = await loadFlantInfraModule(dir);
+
+    const config = mod.generateFlantConfig([
+      "claude-opus-4-5",
+      "claude-opus-4-7",
+      "gpt-5-3",
+      "gpt-5-4",
+      "gemini-3-0-pro",
+      "gemini-3-1-pro",
+      "gemini-3-1-flash",
+      "gemini-3-1-flash-lite",
+    ]) as any;
+
+    expect(config.agents.orchestrators.implement.model).toBe("pp-flant-anthropic/claude-opus-4-7");
+    expect(config.agents.orchestrators.plan.model).toBe("pp-flant-anthropic/claude-opus-4-7");
+    expect(config.agents.orchestrators.debug.model).toBe("pp-flant-openai/gpt-5-4");
+    expect(config.agents.subagents.presetGroups.planners.presets.regular.agents.gemini.model).toBe("pp-flant-openai/gemini-3-1-pro");
+    expect(config.agents.subagents.simple.explore.model).toBe("pp-flant-openai/gemini-3-1-flash-lite");
+  });
+
+  it("loadFlantSettings returns defaults when file is missing", async () => {
+    const dir = makeTempDir();
+    const mod = await loadFlantInfraModule(dir);
+
+    expect(mod.loadFlantSettings()).toEqual({
+      enabled: false,
+      autoUpdate: true,
+      cacheTTLDays: 7,
+      lastUpdated: null,
+      cachedFlantModels: null,
+      cachedOpenRouterData: null,
+    });
+  });
+
+  it("loadFlantSettings parses valid settings file", async () => {
+    const dir = makeTempDir();
+    const mod = await loadFlantInfraModule(dir);
+    const settingsDir = join(dir, "extensions", "pp", "cache");
+    const settingsPath = join(settingsDir, "flant-models.json");
+    mkdirSync(settingsDir, { recursive: true });
+    writeFileSync(
+      settingsPath,
+      JSON.stringify({
+        enabled: true,
+        autoUpdate: false,
+        cacheTTLDays: "3",
+        lastUpdated: "2026-01-02T03:04:05.000Z",
+        cachedFlantModels: ["gpt-5-4", 123, "claude-opus-4-6"],
+        cachedOpenRouterData: {
+          "gpt-5-4": {
+            name: "GPT 5.4",
+            context_length: 123,
+            max_completion_tokens: 45,
+            pricing: { prompt: 1, completion: 2, cacheRead: 3, cacheWrite: 4 },
+            modality: "text",
+          },
+        },
+      }),
+      "utf-8",
+    );
+
+    expect(mod.loadFlantSettings()).toEqual({
+      enabled: true,
+      autoUpdate: false,
+      cacheTTLDays: 3,
+      lastUpdated: "2026-01-02T03:04:05.000Z",
+      cachedFlantModels: ["gpt-5-4", "claude-opus-4-6"],
+      cachedOpenRouterData: {
+        "gpt-5-4": {
+          name: "GPT 5.4",
+          context_length: 123,
+          max_completion_tokens: 45,
+          pricing: { prompt: 1, completion: 2, cacheRead: 3, cacheWrite: 4 },
+          modality: "text",
+        },
+      },
+    });
+  });
+
+  it("saveFlantSettings and loadFlantSettings round-trip", async () => {
+    const dir = makeTempDir();
+    const mod = await loadFlantInfraModule(dir);
+
+    const settings = {
+      enabled: true,
+      autoUpdate: true,
+      cacheTTLDays: 14,
+      lastUpdated: "2026-02-01T00:00:00.000Z",
+      cachedFlantModels: ["claude-opus-4-6", "gpt-5-4"],
+      cachedOpenRouterData: {
+        "claude-opus-4-6": {
+          name: "Claude Opus 4.6",
+          context_length: 200000,
+          max_completion_tokens: 32000,
+          pricing: { prompt: 0.01, completion: 0.02, cacheRead: 0.003, cacheWrite: 0.004 },
+          modality: "text",
+        },
+      },
+    };
+
+    mod.saveFlantSettings(settings);
+
+    const loaded = mod.loadFlantSettings();
+    expect(loaded).toEqual(settings);
+    expect(existsSync(join(dir, "extensions", "pp", "cache", "flant-models.json"))).toBe(true);
+  });
+});

package/extensions/orchestrator/flant-infra.ts

@@ -1,8 +1,12 @@
 import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
 import { homedir } from "node:os";
 import { join } from "node:path";
+import lockfile from "proper-lockfile";
 import type { ExtensionAPI, ProviderModelConfig } from "@earendil-works/pi-coding-agent";
 import type { PiPiConfig } from "./config.js";
+import { updateRegistryFromAvailableModels } from "./model-registry.js";
+import { compareModelVersion } from "./model-version.js";
+import { getLogger } from "./log.js";
 
 export interface OpenRouterModelData {
   name: string;
@@ -117,7 +121,13 @@ export function loadFlantSettings(): FlantSettings {
 
 export function saveFlantSettings(settings: FlantSettings): void {
   ensureSettingsDir();
-  writeFileSync(SETTINGS_PATH, JSON.stringify(settings, null, 2) + "\n", "utf-8");
+  if (!existsSync(SETTINGS_PATH)) writeFileSync(SETTINGS_PATH, "{}\n", "utf-8");
+  const release = lockfile.lockSync(SETTINGS_PATH, { stale: 10000 });
+  try {
+    writeFileSync(SETTINGS_PATH, JSON.stringify(settings, null, 2) + "\n", "utf-8");
+  } finally {
+    release();
+  }
 }
 
 function toTitleCase(token: string): string {
@@ -284,9 +294,13 @@ export function registerFlantProviders(
   models: string[],
   metadata: Record<string, OpenRouterModelData>,
 ): void {
+  const log = getLogger();
   const uniqueModels = [...new Set(models)];
   const anthropicModels = uniqueModels.filter((m) => m.startsWith("claude-"));
   const openaiModels = uniqueModels.filter((m) => !m.startsWith("claude-"));
+  log.debug({ s: "flant", total: uniqueModels.length, anthropic: anthropicModels.length, openai: openaiModels.length }, "registering flant providers");
+
+  unregisterFlantProviders(pi);
 
   pi.registerProvider("pp-flant-anthropic", {
     api: "anthropic-messages",
@@ -301,18 +315,11 @@ export function registerFlantProviders(
     apiKey: "$FLANT_API_KEY",
     models: openaiModels.map((m) => buildProviderModelConfig(m, metadata)),
   });
-}
 
-function compareModelVersion(a: string, b: string): number {
-  const aParts = (a.match(/\d+/g) ?? []).map(Number);
-  const bParts = (b.match(/\d+/g) ?? []).map(Number);
-  const len = Math.max(aParts.length, bParts.length);
-  for (let i = 0; i < len; i++) {
-    const ai = aParts[i] ?? 0;
-    const bi = bParts[i] ?? 0;
-    if (ai !== bi) return ai - bi;
-  }
-  return a.localeCompare(b);
+  updateRegistryFromAvailableModels([
+    ...anthropicModels.map((id) => `pp-flant-anthropic/${id}`),
+    ...openaiModels.map((id) => `pp-flant-openai/${id}`),
+  ]);
 }
 
 function pickLatest(models: string[]): string | null {
@@ -337,6 +344,22 @@ function makeVariant(modelId: string | null, fallbackModelId: string): { enabled
   return { enabled: true, model: modelSpec(modelId), thinking: "high" };
 }
 
+function makeVariantWithThinking(
+  modelId: string | null,
+  fallbackModelId: string,
+  thinking: string,
+): { enabled: boolean; model: string; thinking: string } {
+  if (!modelId) return { enabled: false, model: modelSpec(fallbackModelId), thinking };
+  return { enabled: true, model: modelSpec(modelId), thinking };
+}
+
+function buildPresetGroup(
+  presets: Record<string, { enabled?: boolean; agents: Record<string, { enabled: boolean; model: string; thinking: string }> }>,
+  defaultPreset = "regular",
+): { default: string; presets: typeof presets } {
+  return { default: defaultPreset, presets };
+}
+
 export function generateFlantConfig(models: string[]): Partial<PiPiConfig> {
   const uniqueModels = [...new Set(models)];
   if (uniqueModels.length === 0) return {};
@@ -358,36 +381,80 @@ export function generateFlantConfig(models: string[]): Partial<PiPiConfig> {
   const fastModel = fastest ?? debugModel;
 
   return {
-    mainModel: {
-      implement: { model: modelSpec(implementModel), thinking: "high" },
-      debug: { model: modelSpec(debugModel), thinking: "high" },
-      brainstorm: { model: modelSpec(brainstormModel), thinking: "high" },
-      review: { model: modelSpec(implementModel), thinking: "high" },
-    },
-    planners: {
-      opus: makeVariant(latestOpus, fallback),
-      gpt: makeVariant(latestGpt, fallback),
-      gemini: makeVariant(latestGeminiPro, fallback),
-    },
-    planReviewers: {
-      opus: makeVariant(latestOpus, fallback),
-      gpt: makeVariant(latestGpt, fallback),
-      gemini: makeVariant(latestGeminiPro, fallback),
-    },
-    codeReviewers: {
-      opus: makeVariant(latestOpus, fallback),
-      gpt: makeVariant(latestGpt, fallback),
-      gemini: makeVariant(latestGeminiPro, fallback),
-    },
-    brainstormReviewers: {
-      opus: makeVariant(latestOpus, fallback),
-      gpt: makeVariant(latestGpt, fallback),
-      gemini: makeVariant(latestGeminiPro, fallback),
-    },
     agents: {
-      explore: { model: modelSpec(fastModel), thinking: "low" },
-      librarian: { model: modelSpec(fastModel), thinking: "medium" },
-      task: { model: modelSpec(taskModel), thinking: "medium" },
+      orchestrators: {
+        implement: { model: modelSpec(implementModel), thinking: "high" },
+        plan: { model: modelSpec(implementModel), thinking: "high" },
+        debug: { model: modelSpec(debugModel), thinking: "high" },
+        brainstorm: { model: modelSpec(brainstormModel), thinking: "high" },
+        review: { model: modelSpec(implementModel), thinking: "high" },
+      },
+      subagents: {
+        simple: {
+          explore: { model: modelSpec(fastModel), thinking: "low" },
+          librarian: { model: modelSpec(fastModel), thinking: "medium" },
+          task: { model: modelSpec(taskModel), thinking: "medium" },
+        },
+        presetGroups: {
+          planners: buildPresetGroup({
+            regular: {
+              agents: {
+                opus: makeVariant(latestOpus, fallback),
+                gpt: makeVariant(latestGpt, fallback),
+                gemini: makeVariant(latestGeminiPro, fallback),
+              },
+            },
+          }),
+          planReviewers: buildPresetGroup({
+            regular: {
+              agents: {
+                opus: makeVariant(latestOpus, fallback),
+                gpt: makeVariant(latestGpt, fallback),
+                gemini: makeVariantWithThinking(latestGeminiPro, fallback, "xhigh"),
+              },
+            },
+            deep: {
+              agents: {
+                opus: makeVariantWithThinking(latestOpus, fallback, "xhigh"),
+                gpt: makeVariantWithThinking(latestGpt, fallback, "xhigh"),
+                gemini: makeVariantWithThinking(latestGeminiPro, fallback, "xhigh"),
+              },
+            },
+          }),
+          codeReviewers: buildPresetGroup({
+            regular: {
+              agents: {
+                opus: makeVariant(latestOpus, fallback),
+                gpt: makeVariant(latestGpt, fallback),
+                gemini: makeVariantWithThinking(latestGeminiPro, fallback, "xhigh"),
+              },
+            },
+            deep: {
+              agents: {
+                opus: makeVariantWithThinking(latestOpus, fallback, "xhigh"),
+                gpt: makeVariantWithThinking(latestGpt, fallback, "xhigh"),
+                gemini: makeVariantWithThinking(latestGeminiPro, fallback, "xhigh"),
+              },
+            },
+          }),
+          brainstormReviewers: buildPresetGroup({
+            regular: {
+              agents: {
+                opus: makeVariant(latestOpus, fallback),
+                gpt: makeVariant(latestGpt, fallback),
+                gemini: makeVariantWithThinking(latestGeminiPro, fallback, "xhigh"),
+              },
+            },
+            deep: {
+              agents: {
+                opus: makeVariantWithThinking(latestOpus, fallback, "xhigh"),
+                gpt: makeVariantWithThinking(latestGpt, fallback, "xhigh"),
+                gemini: makeVariantWithThinking(latestGeminiPro, fallback, "xhigh"),
+              },
+            },
+          }),
+        },
+      },
     },
   };
 }
@@ -469,7 +536,9 @@ export async function updateFlantInfra(
 export function initFlantSync(pi: ExtensionAPI): void {
   setPI(pi);
   const settings = loadFlantSettings();
+  const log = getLogger();
   if (!settings.enabled) {
+    log.debug({ s: "flant" }, "flant disabled");
     generatedFlantConfig = null;
     return;
   }

package/extensions/orchestrator/index.ts

@@ -11,15 +11,22 @@ import { validatePlan, validateArtifact } from "./validate-artifacts.js";
 import { initFlantSync } from "./flant-infra.js";
 
 const ORCHESTRATOR_KEY = Symbol.for("pi-pi:orchestrator-initialized");
+const ORCHESTRATOR_CWD_KEY = Symbol.for("pi-pi:orchestrator-cwd");
+// Shared with 3p/pi-subagents/src/agent-runner.ts: the value is a { depth: number }
+// marking that this process runs as a subagent. The orchestrator only reads it for
+// truthiness ("am I a subagent?"); agent-runner uses depth for nesting.
 export const SUBAGENT_SESSION_KEY = Symbol.for("pi-pi:subagent-session");
 
 export default function (pi: ExtensionAPI) {
   if ((globalThis as any)[ORCHESTRATOR_KEY]) {
-    (globalThis as any)[SUBAGENT_SESSION_KEY] = true;
+    if (!(globalThis as any)[SUBAGENT_SESSION_KEY]) {
+      (globalThis as any)[SUBAGENT_SESSION_KEY] = { depth: 1 };
+    }
     registerSubagentTools(pi);
     return;
   }
   (globalThis as any)[ORCHESTRATOR_KEY] = true;
+  (globalThis as any)[ORCHESTRATOR_CWD_KEY] = process.cwd();
 
   initFlantSync(pi);
 
@@ -29,7 +36,11 @@ export default function (pi: ExtensionAPI) {
 }
 
 function registerSubagentTools(pi: ExtensionAPI): void {
-  const cwd = process.cwd();
+  // Subagents run in-process; bind cbm/ast-search and plan validation to the
+  // orchestrator's project root (seeded to process.cwd() at init, then refreshed
+  // to ctx.cwd on session_start) rather than a raw process.cwd() captured here,
+  // which is the launch dir and wrong for worktree-isolated tasks.
+  const cwd = (globalThis as any)[ORCHESTRATOR_CWD_KEY] ?? process.cwd();
   registerCbmTools(pi, cwd);
   registerExaTools(pi);
   registerAstSearchTool(pi, cwd);