@vedmalex/ai-connect 0.2.1 → 0.5.0

package/dist/node/local.js

@@ -220,11 +220,7 @@ function normalizeTransport(providerId, input) {
         ...selector.whereEquals !== void 0 ? { whereEquals: selector.whereEquals } : {}
       };
     };
-    const parser = (() => {
-      if (!descriptor.cli?.parser) {
-        return void 0;
-      }
-      const cliParser = descriptor.cli.parser;
+    const normalizeCliParser = (cliParser) => {
       if (cliParser.kind === "json") {
         assert(
           cliParser.textPath.trim().length > 0,
@@ -237,13 +233,22 @@ function normalizeTransport(providerId, input) {
           ...cliParser.usagePath?.trim() ? { usagePath: cliParser.usagePath.trim() } : {}
         };
       }
+      if (cliParser.kind === "text") {
+        return {
+          kind: "text",
+          // Default trim=true, stripAnsi=false; only persist explicit overrides.
+          ...cliParser.trim === false ? { trim: false } : {},
+          ...cliParser.stripAnsi === true ? { stripAnsi: true } : {}
+        };
+      }
       return {
         kind: "jsonl",
         text: normalizeSelector(cliParser.text, "text"),
         ...cliParser.error ? { error: normalizeSelector(cliParser.error, "error") } : {},
         ...cliParser.usage ? { usage: normalizeSelector(cliParser.usage, "usage") } : {}
       };
-    })();
+    };
+    const parser = descriptor.cli?.parser ? normalizeCliParser(descriptor.cli.parser) : void 0;
     const normalized = {
       ...descriptor.cli.preset ? { preset: descriptor.cli.preset } : {},
       ...descriptor.cli.argsTemplate ? {
@@ -255,11 +260,13 @@ function normalizeTransport(providerId, input) {
       if (!descriptor.cli?.discovery) {
         return void 0;
       }
-      const via = descriptor.cli.discovery.via ?? "none";
-      assert(
-        via === "none" || via === "acp",
-        `Unsupported CLI discovery mode "${String(via)}" for provider "${providerId}".`
-      );
+      const explicitVia = descriptor.cli.discovery.via;
+      if (explicitVia !== void 0) {
+        assert(
+          explicitVia === "none" || explicitVia === "acp" || explicitVia === "command" || explicitVia === "static",
+          `Unsupported CLI discovery mode "${String(explicitVia)}" for provider "${providerId}".`
+        );
+      }
       const launch = descriptor.cli.discovery.acp?.launch ? (() => {
         const contextMode = descriptor.cli.discovery?.acp?.launch?.contextMode ?? "workspace";
         const skillsMode = descriptor.cli.discovery?.acp?.launch?.skillsMode ?? "default";
@@ -280,7 +287,7 @@ function normalizeTransport(providerId, input) {
         methodId: descriptor.cli.discovery.acp.auth.methodId.trim(),
         params: descriptor.cli.discovery.acp.auth.params ?? {}
       } : void 0;
-      const acp = via === "acp" ? {
+      const acp = descriptor.cli.discovery.acp ? {
         ...descriptor.cli.discovery.acp?.providerId?.trim() ? { providerId: descriptor.cli.discovery.acp.providerId.trim() } : {},
         ...descriptor.cli.discovery.acp?.transportId?.trim() ? {
           transportId: descriptor.cli.discovery.acp.transportId.trim()
@@ -288,9 +295,55 @@ function normalizeTransport(providerId, input) {
         ...auth ? { auth } : {},
         ...launch ? { launch } : {}
       } : void 0;
+      const commandInput = descriptor.cli.discovery.command;
+      const command = commandInput ? (() => {
+        assert(
+          Array.isArray(commandInput.argsTemplate) && commandInput.argsTemplate.length > 0,
+          `CLI discovery command.argsTemplate must be a non-empty array for provider "${providerId}".`
+        );
+        const cmdParserInput = commandInput.parser ?? { kind: "text" };
+        const cmdParser = cmdParserInput.kind === "text" ? {
+          kind: "text",
+          ...cmdParserInput.trim === false ? { trim: false } : {},
+          ...cmdParserInput.stripAnsi === true ? { stripAnsi: true } : {}
+        } : { kind: cmdParserInput.kind };
+        if (cmdParser.kind !== "text") {
+          assert(
+            Boolean(commandInput.models?.idPath?.trim()),
+            `CLI discovery command.models.idPath is required for a ${cmdParser.kind} parser for provider "${providerId}".`
+          );
+        }
+        const m = commandInput.models;
+        const models = m?.idPath?.trim() ? {
+          ...m.path?.trim() ? { path: m.path.trim() } : {},
+          idPath: m.idPath.trim(),
+          ...m.namePath?.trim() ? { namePath: m.namePath.trim() } : {},
+          ...m.descriptionPath?.trim() ? { descriptionPath: m.descriptionPath.trim() } : {},
+          ...m.contextLengthPath?.trim() ? { contextLengthPath: m.contextLengthPath.trim() } : {}
+        } : void 0;
+        return {
+          ...commandInput.command?.trim() ? { command: commandInput.command.trim() } : {},
+          argsTemplate: commandInput.argsTemplate.map((part) => String(part)),
+          parser: cmdParser,
+          ...models ? { models } : {}
+        };
+      })() : void 0;
+      assert(
+        explicitVia !== "command" || command !== void 0,
+        `CLI discovery via:"command" requires a discovery.command block for provider "${providerId}".`
+      );
+      const fallback = descriptor.cli.discovery.fallback;
+      if (fallback !== void 0) {
+        assert(
+          fallback === "static" || fallback === "none",
+          `Unsupported CLI discovery fallback "${String(fallback)}" for provider "${providerId}".`
+        );
+      }
       return {
-        via,
-        ...acp ? { acp } : {}
+        ...explicitVia !== void 0 ? { via: explicitVia } : {},
+        ...acp ? { acp } : {},
+        ...command ? { command } : {},
+        ...fallback !== void 0 ? { fallback } : {}
       };
     })();
     return {
@@ -331,7 +384,7 @@ function normalizeTransport(providerId, input) {
     };
   }
   if (descriptor.kind === "cli") {
-    const inferredId2 = providerId === "anthropic" ? "claude-cli" : providerId === "openclaude" ? "openclaude-cli" : providerId === "openai" ? "codex-cli" : providerId === "gemini" ? "gemini-cli" : providerId === "qwen" ? "qwen-cli" : "cli";
+    const inferredId2 = providerId === "anthropic" ? "claude-cli" : providerId === "openclaude" ? "openclaude-cli" : providerId === "openai" ? "codex-cli" : providerId === "pi" ? "pi-cli" : "cli";
     return {
       kind: "cli",
       id: descriptor.id?.trim() || inferredId2,
@@ -348,7 +401,7 @@ function normalizeTransport(providerId, input) {
       ...descriptor.baseUrl?.trim() ? { baseUrl: descriptor.baseUrl.trim() } : {}
     };
   }
-  const inferredId = providerId === "anthropic" ? "claude-code-acp" : providerId === "openai" ? "codex-acp" : providerId === "gemini" ? "gemini-acp" : "acp";
+  const inferredId = providerId === "anthropic" ? "claude-code-acp" : providerId === "openai" ? "codex-acp" : "acp";
   const normalizedLaunch = descriptor.launch ? (() => {
     const contextMode = descriptor.launch?.contextMode ?? "workspace";
     const skillsMode = descriptor.launch?.skillsMode ?? "default";
@@ -1576,18 +1629,14 @@ var MODEL_REFERENCE = {
     key: "gemini-3.1-flash-lite",
     contextLength: 1048576
   },
+  "gemini-3.1-pro": { key: "gemini-3.1-pro", contextLength: 1048576 },
   "gemini-3-pro": { key: "gemini-3-pro", contextLength: 2097152 },
   "auto-gemini-3": { key: "auto-gemini-3", contextLength: 1048576 },
   "gemini-2.5-flash": { key: "gemini-2.5-flash", contextLength: 1048576 },
   "gemini-2.5-pro": { key: "gemini-2.5-pro", contextLength: 2097152 },
   "gemini-2.0-flash": { key: "gemini-2.0-flash", contextLength: 1048576 },
   "gemini-1.5-flash": { key: "gemini-1.5-flash", contextLength: 1048576 },
-  "gemini-1.5-pro": { key: "gemini-1.5-pro", contextLength: 2097152 },
-  // --- Qwen (catalog: qwen3-coder-plus) ---
-  "qwen3-coder-plus": { key: "qwen3-coder-plus", contextLength: 1048576 },
-  "qwen3-coder": { key: "qwen3-coder", contextLength: 262144 },
-  "qwen-max": { key: "qwen-max", contextLength: 32768 },
-  "qwen-plus": { key: "qwen-plus", contextLength: 131072 }
+  "gemini-1.5-pro": { key: "gemini-1.5-pro", contextLength: 2097152 }
 };
 function normalizeModelKey(model) {
   let key = model.trim().toLowerCase();
@@ -1721,6 +1770,25 @@ function resolveModelContextWindow(input) {
   const fallback = isUsableContextLength(input.defaultContextWindow) ? input.defaultContextWindow : DEFAULT_CONTEXT_WINDOW;
   return { contextWindow: fallback, source: "default" };
 }
+function fillConfiguredContextLength(route, models) {
+  if (!isUsableContextLength(route.contextWindow)) {
+    return models;
+  }
+  const configured = route.contextWindow;
+  return models.map((entry) => {
+    if (isUsableContextLength(entry.contextLength)) {
+      return entry;
+    }
+    if (route.model !== void 0 && entry.modelId !== route.model) {
+      return entry;
+    }
+    return {
+      ...entry,
+      contextLength: configured,
+      metadata: { ...entry.metadata ?? {}, contextWindowSource: "configured" }
+    };
+  });
+}
 function modelContextCacheKey(input) {
   if (typeof input === "string") {
     return { key: `::${input}`, model: input };
@@ -4696,18 +4764,19 @@ function canonicalGeminiImageModelId(modelId) {
 }
 function buildModelCatalog(route, availableModels, currentModelId) {
   const requestedModelId = route.model;
-  const requestedModelAdvertised = availableModels.some(
+  const filledModels = fillConfiguredContextLength(route, availableModels);
+  const requestedModelAdvertised = filledModels.some(
     (model) => model.modelId === requestedModelId
   );
   const canonicalModelId = route.provider === "gemini" ? canonicalGeminiImageModelId(requestedModelId) : void 0;
-  const resolvedModelId = requestedModelAdvertised ? requestedModelId : canonicalModelId && availableModels.some((model) => model.modelId === canonicalModelId) ? canonicalModelId : void 0;
+  const resolvedModelId = requestedModelAdvertised ? requestedModelId : canonicalModelId && filledModels.some((model) => model.modelId === canonicalModelId) ? canonicalModelId : void 0;
   return {
     requestedModelId,
     requestedModelAdvertised,
     ...canonicalModelId ? { canonicalModelId } : {},
     ...resolvedModelId ? { resolvedModelId } : {},
     ...currentModelId ? { currentModelId } : {},
-    availableModels
+    availableModels: filledModels
   };
 }
 function parseOpenAiModelCatalog(route, payload) {
@@ -6247,8 +6316,6 @@ import { pathToFileURL } from "node:url";
 var AI_CONNECT_DEFAULT_ACP_COMMANDS = {
   "anthropic:claude-code-acp": "npx -y @agentclientprotocol/claude-agent-acp@^0.25.0",
   "openai:codex-acp": "npx @zed-industries/codex-acp@^0.11.1",
-  "gemini:gemini-acp": "gemini --acp",
-  "qwen:qwen-acp": "qwen --acp",
   "opencode:opencode-acp": "opencode acp"
 };
 
@@ -6329,15 +6396,6 @@ function resolveHomeDir(env) {
 function resolveXdgConfigHome(env) {
   return env.XDG_CONFIG_HOME ?? path.join(resolveHomeDir(env), ".config");
 }
-function resolveGeminiCliHome(env) {
-  return env.GEMINI_CLI_HOME ?? resolveHomeDir(env);
-}
-function resolveGeminiDir(env) {
-  return path.join(resolveGeminiCliHome(env), ".gemini");
-}
-function resolveQwenDir(env) {
-  return path.join(resolveHomeDir(env), ".qwen");
-}
 function resolveCodexHome(env) {
   return env.CODEX_HOME ?? path.join(resolveHomeDir(env), ".codex");
 }
@@ -6383,118 +6441,6 @@ async function removeIfExists(targetPath) {
     }
   });
 }
-async function readJsonFile(filePath) {
-  try {
-    const raw = await fs.readFile(filePath, "utf8");
-    const parsed = JSON.parse(raw);
-    return isRecord2(parsed) ? parsed : void 0;
-  } catch (error) {
-    if (error instanceof SyntaxError || error.code === "ENOENT") {
-      return void 0;
-    }
-    throw error;
-  }
-}
-function mergeRecordValues(current, next) {
-  const merged = { ...current };
-  for (const [key, value] of Object.entries(next)) {
-    const existing = merged[key];
-    if (isRecord2(existing) && isRecord2(value)) {
-      merged[key] = mergeRecordValues(existing, value);
-      continue;
-    }
-    merged[key] = value;
-  }
-  return merged;
-}
-async function writeJsonFile(filePath, value) {
-  await fs.mkdir(path.dirname(filePath), { recursive: true });
-  await fs.writeFile(filePath, `${JSON.stringify(value, null, 2)}
-`, "utf8");
-}
-async function prepareGeminiLaunchRuntime(base, launch) {
-  if (launch.contextMode === "workspace" && launch.skillsMode === "default") {
-    return {
-      ...base,
-      launch
-    };
-  }
-  const sandbox = await createSandboxPaths("ai-connect-gemini-acp-");
-  const originalGeminiDir = resolveGeminiDir(base.env);
-  const sandboxGeminiDir = path.join(sandbox.root, ".gemini");
-  const settingsPath = path.join(sandboxGeminiDir, "settings.json");
-  const systemSettingsPath = path.join(sandbox.config, "gemini-settings.json");
-  const systemDefaultsPath = path.join(
-    sandbox.config,
-    "gemini-system-defaults.json"
-  );
-  const isolatedCwd = launch.contextMode === "clean" || launch.skillsMode === "disabled" ? sandbox.root : base.cwd;
-  await Promise.all(
-    [
-      "oauth_creds.json",
-      "google_accounts.json",
-      "mcp-oauth-tokens.json",
-      "a2a-oauth-tokens.json",
-      "installation_id"
-    ].map(
-      (fileName) => maybeCopyFile(
-        path.join(originalGeminiDir, fileName),
-        path.join(sandboxGeminiDir, fileName)
-      )
-    )
-  );
-  const settings = mergeRecordValues(
-    await readJsonFile(settingsPath) ?? {},
-    {
-      context: {
-        fileName: "AI_CONNECT_CONTEXT_DISABLED.md",
-        includeDirectoryTree: false,
-        memoryBoundaryMarkers: [],
-        includeDirectories: [],
-        loadMemoryFromIncludeDirectories: false,
-        discoveryMaxDirs: 0
-      },
-      admin: {
-        mcp: {
-          enabled: false,
-          config: {},
-          requiredConfig: {}
-        },
-        ...launch.skillsMode === "disabled" ? {
-          skills: {
-            enabled: false
-          }
-        } : {}
-      },
-      ...launch.skillsMode === "disabled" ? {
-        skills: {
-          enabled: false,
-          disabled: []
-        }
-      } : {}
-    }
-  );
-  await Promise.all([
-    writeJsonFile(settingsPath, settings),
-    writeJsonFile(systemSettingsPath, {}),
-    writeJsonFile(systemDefaultsPath, {})
-  ]);
-  return {
-    commandLine: base.commandLine,
-    cwd: isolatedCwd,
-    env: {
-      ...base.env,
-      HOME: sandbox.root,
-      GEMINI_CLI_HOME: sandbox.root,
-      GEMINI_CLI_SYSTEM_SETTINGS_PATH: systemSettingsPath,
-      GEMINI_CLI_SYSTEM_DEFAULTS_PATH: systemDefaultsPath
-    },
-    launch,
-    cleanup: async () => {
-      await removeIfExists(sandbox.root);
-    }
-  };
-}
 async function prepareOpenCodeLaunchRuntime(base, launch) {
   if (launch.contextMode === "workspace" && launch.skillsMode === "default") {
     return {
@@ -6543,70 +6489,6 @@ async function prepareOpenCodeLaunchRuntime(base, launch) {
     }
   };
 }
-async function prepareQwenLaunchRuntime(base, launch) {
-  if (launch.contextMode === "workspace" && launch.skillsMode === "default") {
-    return {
-      ...base,
-      launch
-    };
-  }
-  const sandbox = await createSandboxPaths("ai-connect-qwen-acp-");
-  const originalQwenDir = resolveQwenDir(base.env);
-  const sandboxQwenDir = path.join(sandbox.home, ".qwen");
-  const settingsPath = path.join(sandboxQwenDir, "settings.json");
-  const systemSettingsPath = path.join(sandbox.config, "qwen-settings.json");
-  const systemDefaultsPath = path.join(
-    sandbox.config,
-    "qwen-system-defaults.json"
-  );
-  await Promise.all(
-    [
-      "oauth_creds.json",
-      "mcp-oauth-tokens.json",
-      "installation_id",
-      ".env",
-      "settings.json"
-    ].map(
-      (fileName) => maybeCopyFile(
-        path.join(originalQwenDir, fileName),
-        path.join(sandboxQwenDir, fileName)
-      )
-    )
-  );
-  const settings = mergeRecordValues(
-    await readJsonFile(settingsPath) ?? {},
-    {
-      context: {
-        fileName: ["AI_CONNECT_CONTEXT_DISABLED.md"],
-        includeDirectories: [],
-        loadFromIncludeDirectories: false
-      },
-      model: {
-        skipStartupContext: true
-      }
-    }
-  );
-  await Promise.all([
-    writeJsonFile(settingsPath, settings),
-    writeJsonFile(systemSettingsPath, {}),
-    writeJsonFile(systemDefaultsPath, {})
-  ]);
-  const isolatedCwd = launch.contextMode === "clean" || launch.skillsMode === "disabled" ? sandbox.root : base.cwd;
-  return {
-    commandLine: base.commandLine,
-    cwd: isolatedCwd,
-    env: {
-      ...base.env,
-      HOME: sandbox.home,
-      QWEN_CODE_SYSTEM_SETTINGS_PATH: systemSettingsPath,
-      QWEN_CODE_SYSTEM_DEFAULTS_PATH: systemDefaultsPath
-    },
-    launch,
-    cleanup: async () => {
-      await removeIfExists(sandbox.root);
-    }
-  };
-}
 async function prepareCodexLaunchRuntime(base, launch) {
   if (launch.contextMode === "workspace" && launch.skillsMode === "default") {
     return {
@@ -6724,15 +6606,9 @@ async function prepareAcpLaunchRuntime(route, options, commandLine, cwdOverride)
       ...options?.env ?? {}
     }
   };
-  if (route.transport.id === "gemini-acp") {
-    return prepareGeminiLaunchRuntime(base, launch);
-  }
   if (route.transport.id === "opencode-acp") {
     return prepareOpenCodeLaunchRuntime(base, launch);
   }
-  if (route.transport.id === "qwen-acp") {
-    return prepareQwenLaunchRuntime(base, launch);
-  }
   if (route.transport.id === "codex-acp") {
     return prepareCodexLaunchRuntime(base, launch);
   }
@@ -7313,10 +7189,6 @@ function buildAcpLifecycle(route, authRequest, mode) {
     steps.push("authenticate");
   }
   steps.push("session/new");
-  if (mode === "prompt" && route.transport.id === "gemini-acp") {
-    steps.push("session/set_model");
-    keys.push("session/set_model.modelId");
-  }
   if (mode === "prompt") {
     steps.push("session/prompt");
   }
@@ -7452,16 +7324,6 @@ var AcpConnection = class {
         );
       }
       const sessionId = session.sessionId;
-      if (context.route.transport.id === "gemini-acp") {
-        await measurePhase(
-          transport.phases ?? [],
-          "session/set_model",
-          async () => this.request("session/set_model", {
-            sessionId,
-            modelId: context.route.model
-          })
-        );
-      }
       this.activePrompt = {
         sessionId,
         text: "",
@@ -7553,6 +7415,10 @@ var AcpConnection = class {
             `ACP route "${context.route.id}" did not return an ACP model catalog in session/new.`
           );
         }
+        catalog.availableModels = fillConfiguredContextLength(
+          context.route,
+          catalog.availableModels
+        );
         return catalog;
       } finally {
         this.bumpIdleTimer();
@@ -7970,9 +7836,6 @@ var AcpConnection = class {
     });
   }
 };
-function isGeminiAcpFallbackCandidate(route, commandLine) {
-  return route.transport.id === "gemini-acp" && commandLine.includes("--acp") && !commandLine.includes("--experimental-acp");
-}
 function cacheKeyForConnection(route, runtime, options) {
   const envEntries = Object.entries(options.env).sort(([left], [right]) => left.localeCompare(right)).map(([key, value]) => `${key}=${value}`).join("
");
   return [
@@ -8219,18 +8082,7 @@ function createAcpTransportManager(options) {
   }
   async function drivePrompt(context, onDelta) {
     const commandLine = resolveAcpCommand(context.route, options);
-    try {
-      return await runWithCommand(context, commandLine, onDelta);
-    } catch (error) {
-      if (!isGeminiAcpFallbackCandidate(context.route, commandLine)) {
-        throw error;
-      }
-      return await runWithCommand(
-        context,
-        commandLine.replace("--acp", "--experimental-acp"),
-        onDelta
-      );
-    }
+    return await runWithCommand(context, commandLine, onDelta);
   }
   return {
     async runPrompt(context) {
@@ -8299,17 +8151,7 @@ function createAcpTransportManager(options) {
     },
     async discoverModels(context) {
       const commandLine = resolveAcpCommand(context.route, options);
-      try {
-        return await discoverWithCommand(context, commandLine);
-      } catch (error) {
-        if (!isGeminiAcpFallbackCandidate(context.route, commandLine)) {
-          throw error;
-        }
-        return await discoverWithCommand(
-          context,
-          commandLine.replace("--acp", "--experimental-acp")
-        );
-      }
+      return await discoverWithCommand(context, commandLine);
     },
     async dispose() {
       const values = [...connectionPools.values()].flat();
@@ -8336,47 +8178,21 @@ import path2 from "node:path";
 
 // src/cli-presets.ts
 var AI_CONNECT_DEFAULT_CLI_PRESETS = {
-  gemini: {
-    id: "gemini",
-    label: "Gemini CLI",
-    command: "gemini",
-    transportId: "gemini-cli",
-    options: {
-      preset: "gemini",
-      argsTemplate: ["-p", "{prompt}", "--output-format", "json", "--model", "{model}"],
-      discovery: {
-        via: "acp",
-        acp: {
-          transportId: "gemini-acp"
-        }
-      },
-      parser: {
-        kind: "json",
-        textPath: "response",
-        usagePath: "stats",
-        errorPath: "error"
-      }
-    }
-  },
-  qwen: {
-    id: "qwen",
-    label: "Qwen CLI",
-    command: "qwen",
-    transportId: "qwen-cli",
+  pi: {
+    id: "pi",
+    label: "pi (coding agent)",
+    command: "pi",
+    transportId: "pi-cli",
     options: {
-      preset: "qwen",
-      argsTemplate: ["-p", "{prompt}", "--output-format", "json", "--model", "{model}"],
+      preset: "pi",
+      // pi print mode emits the answer as plain text on stdout (no JSON wrapper),
+      // and has no ACP mode — so it uses the raw `text` parser and no discovery sidecar.
+      argsTemplate: ["--print", "--model", "{model}", "{prompt}"],
       discovery: {
-        via: "acp",
-        acp: {
-          transportId: "qwen-acp"
-        }
+        via: "none"
       },
       parser: {
-        kind: "json",
-        textPath: "__preset__:qwen.result",
-        usagePath: "__preset__:qwen.stats",
-        errorPath: "__preset__:qwen.error"
+        kind: "text"
       }
     }
   },
@@ -8460,8 +8276,7 @@ var AI_CONNECT_DEFAULT_CLI_COMMANDS = {
   "anthropic:openclaude-cli": AI_CONNECT_DEFAULT_CLI_PRESETS.openclaude.command,
   "openclaude:openclaude-cli": AI_CONNECT_DEFAULT_CLI_PRESETS.openclaude.command,
   "openai:codex-cli": AI_CONNECT_DEFAULT_CLI_PRESETS.codex.command,
-  "gemini:gemini-cli": AI_CONNECT_DEFAULT_CLI_PRESETS.gemini.command,
-  "qwen:qwen-cli": AI_CONNECT_DEFAULT_CLI_PRESETS.qwen.command
+  "pi:pi-cli": AI_CONNECT_DEFAULT_CLI_PRESETS.pi.command
 };
 function getCliTransportPreset(presetId) {
   return AI_CONNECT_DEFAULT_CLI_PRESETS[presetId];
@@ -8469,14 +8284,6 @@ function getCliTransportPreset(presetId) {
 
 // src/cli.ts
 var CLI_PRESET_ACP_DISCOVERY_DEFAULTS = {
-  gemini: {
-    transportId: "gemini-acp",
-    providerId: "gemini"
-  },
-  qwen: {
-    transportId: "qwen-acp",
-    providerId: "qwen"
-  },
   claude: {
     transportId: "claude-code-acp",
     providerId: "anthropic"
@@ -8583,10 +8390,8 @@ function buildCliCwd(context, options) {
 }
 function defaultCliPresetIdForRoute(route) {
   switch (route.transport.id) {
-    case "gemini-cli":
-      return "gemini";
-    case "qwen-cli":
-      return "qwen";
+    case "pi-cli":
+      return "pi";
     case "claude-cli":
       return "claude";
     case "openclaude-cli":
@@ -8629,14 +8434,26 @@ function normalizeCliDiscoveryAcpSource(route, discovery) {
   };
 }
 function resolveCliDiscoverySource(route) {
-  const via = route.transport.cli?.discovery?.via ?? (defaultCliDiscoveryTransportIdForRoute(route) ? "acp" : "none");
-  if (via === "none") {
-    return { via: "none" };
+  const discovery = route.transport.cli?.discovery;
+  const hasModels = (route.advertisedModels?.length ?? 0) > 0;
+  const hasAcpDefault = Boolean(defaultCliDiscoveryTransportIdForRoute(route));
+  const via = discovery?.via ?? (discovery?.command ? "command" : hasAcpDefault ? "acp" : hasModels ? "static" : "none");
+  switch (via) {
+    case "none":
+      return { via: "none" };
+    case "static":
+      return { via: "static" };
+    case "command": {
+      const command = discovery?.command;
+      if (!command) {
+        return { via: "none" };
+      }
+      const fallback = discovery?.fallback ?? (hasModels ? "static" : "none");
+      return { via: "command", command, fallback };
+    }
+    default:
+      return normalizeCliDiscoveryAcpSource(route, discovery?.acp);
   }
-  return normalizeCliDiscoveryAcpSource(
-    route,
-    route.transport.cli?.discovery?.acp
-  );
 }
 function createCliDiscoveryAcpRoute(route) {
   const discovery = resolveCliDiscoverySource(route);
@@ -8745,6 +8562,42 @@ async function buildCliInvocation(context, options) {
     parameterKeys
   };
 }
+function buildCliDiscoveryInvocation(route, command, options) {
+  const commandLine = command.command?.trim() ? command.command : resolveCliCommand(route, options);
+  const resolved = splitCommandLine2(commandLine);
+  const parameterKeys = [];
+  const args = [
+    ...resolved.args,
+    ...command.argsTemplate.map((part) => {
+      if (part === "{model}") {
+        parameterKeys.push("model");
+        return route.model;
+      }
+      if (part.startsWith("--")) {
+        parameterKeys.push(part);
+      }
+      return part;
+    })
+  ];
+  return {
+    command: resolved.command,
+    args,
+    cwd: path2.resolve(options?.cwd ?? process.cwd()),
+    env: buildCliEnvironment(options),
+    parameterKeys
+  };
+}
+function buildStaticCliCatalog(route) {
+  const models = route.advertisedModels.map((id) => ({
+    modelId: id,
+    name: id
+  }));
+  return buildModelCatalog(
+    route,
+    models,
+    currentModelIdForRoute(route, route.advertisedModels)
+  );
+}
 function statsToUsage(stats) {
   if (!stats || typeof stats !== "object") {
     return void 0;
@@ -8782,6 +8635,9 @@ function getValueByPath(value, dotPath) {
   }
   return current;
 }
+function splitJsonlLines(stdout) {
+  return stdout.split(/\r?\n/).map((line) => line.trim()).filter(Boolean).map((line) => JSON.parse(line));
+}
 function normalizeErrorMessage(value) {
   if (typeof value === "string" && value.trim()) {
     return value.trim();
@@ -8829,7 +8685,7 @@ function parseGenericJsonCli(stdout, parser) {
   };
 }
 function parseGenericJsonlCli(stdout, parser) {
-  const entries = stdout.split(/\r?\n/).map((line) => line.trim()).filter(Boolean).map((line) => JSON.parse(line));
+  const entries = splitJsonlLines(stdout);
   const errorValue = parser.error ? findJsonlSelection(entries, parser.error) : void 0;
   const errorMessage = normalizeErrorMessage(errorValue);
   if (errorMessage) {
@@ -8850,59 +8706,69 @@ function parseGenericJsonlCli(stdout, parser) {
     data: entries
   };
 }
-function parseGeminiCli(stdout) {
-  const payload = JSON.parse(stdout);
-  if (typeof payload.error === "string") {
-    throw new AiConnectError("temporary_unavailable", payload.error);
+var ANSI_ESCAPE_PATTERN = /\[[0-?]*[ -/]*[@-~]/g;
+function parseTextCli(stdout, parser) {
+  let text = stdout;
+  if (parser.stripAnsi) {
+    text = text.replace(ANSI_ESCAPE_PATTERN, "");
+  }
+  if (parser.trim !== false) {
+    text = text.trim();
   }
-  if (typeof payload.response !== "string") {
+  if (!text) {
     throw new AiConnectError(
       "temporary_unavailable",
-      "Gemini CLI JSON output did not include response text."
+      "CLI text parser produced no output."
     );
   }
-  const usage = payload.stats ? statsToUsage(payload.stats) : void 0;
+  return { text, data: stdout };
+}
+function modelInfoFromRecord(record, selector) {
+  const rawId = getValueByPath(record, selector.idPath);
+  const modelId = typeof rawId === "string" ? rawId.trim() : "";
+  if (!modelId) {
+    return void 0;
+  }
+  const rawName = selector.namePath ? getValueByPath(record, selector.namePath) : void 0;
+  const name = typeof rawName === "string" && rawName.trim().length > 0 ? rawName : modelId;
+  const rawDescription = selector.descriptionPath ? getValueByPath(record, selector.descriptionPath) : void 0;
+  const description = typeof rawDescription === "string" && rawDescription.trim().length > 0 ? rawDescription : void 0;
+  const rawContext = selector.contextLengthPath ? getValueByPath(record, selector.contextLengthPath) : void 0;
+  const contextLength = typeof rawContext === "number" && Number.isFinite(rawContext) && rawContext > 0 ? Math.floor(rawContext) : void 0;
   return {
-    text: payload.response,
-    ...usage ? { usage } : {},
-    data: payload
+    modelId,
+    name,
+    ...description ? { description } : {},
+    ...contextLength !== void 0 ? { contextLength } : {}
   };
 }
-function parseQwenCli(stdout) {
-  const payload = JSON.parse(stdout);
-  if (!Array.isArray(payload)) {
-    throw new AiConnectError(
-      "temporary_unavailable",
-      "Qwen CLI JSON output did not return a message array."
-    );
-  }
-  const resultMessage = payload.find(
-    (entry) => entry && typeof entry === "object" && entry.type === "result"
-  );
-  if (!resultMessage) {
-    throw new AiConnectError(
-      "temporary_unavailable",
-      "Qwen CLI JSON output did not contain a result message."
-    );
+function parseCliModelList(stdout, parser, selector) {
+  if (parser.kind === "text") {
+    let text = stdout;
+    if (parser.stripAnsi) {
+      text = text.replace(ANSI_ESCAPE_PATTERN, "");
+    }
+    return text.split(/\r?\n/).map((line) => line.trim()).filter(Boolean).map((line) => ({ modelId: line, name: line }));
   }
-  if (resultMessage.is_error === true) {
+  if (!selector) {
     throw new AiConnectError(
-      "temporary_unavailable",
-      typeof resultMessage.result === "string" ? resultMessage.result : "Qwen CLI returned an error result."
+      "validation_error",
+      `CLI ${parser.kind} discovery parser requires a models selector with idPath.`
     );
   }
-  if (typeof resultMessage.result !== "string") {
-    throw new AiConnectError(
-      "temporary_unavailable",
-      "Qwen CLI result message did not contain text output."
-    );
+  const records = parser.kind === "jsonl" ? splitJsonlLines(stdout) : (() => {
+    const payload = JSON.parse(stdout);
+    const arr = selector.path ? getValueByPath(payload, selector.path) : payload;
+    return Array.isArray(arr) ? arr : [];
+  })();
+  const models = [];
+  for (const record of records) {
+    const info = modelInfoFromRecord(record, selector);
+    if (info) {
+      models.push(info);
+    }
   }
-  const usage = resultMessage.stats ? statsToUsage(resultMessage.stats) : void 0;
-  return {
-    text: resultMessage.result,
-    ...usage ? { usage } : {},
-    data: payload
-  };
+  return models;
 }
 function parseClaudeCli(stdout) {
   const payload = JSON.parse(stdout);
@@ -8921,8 +8787,7 @@ function parseClaudeCli(stdout) {
   };
 }
 function parseCodexCli(stdout, outputFileContent) {
-  const lines = stdout.split(/\r?\n/).map((line) => line.trim()).filter(Boolean);
-  const events = lines.map((line) => JSON.parse(line));
+  const events = splitJsonlLines(stdout);
   let text = outputFileContent?.trim() || void 0;
   let usage;
   for (const event of events) {
@@ -8980,13 +8845,18 @@ function parseCliResult(route, result, outputFileContent) {
         `CLI route "${route.id}" declared a parser override but normalization did not preserve it.`
       );
     }
-    return parser.kind === "json" ? parseGenericJsonCli(stdout, parser) : parseGenericJsonlCli(stdout, parser);
+    switch (parser.kind) {
+      case "text":
+        return parseTextCli(result.stdout, parser);
+      case "json":
+        return parseGenericJsonCli(stdout, parser);
+      default:
+        return parseGenericJsonlCli(stdout, parser);
+    }
   }
   switch (cliOptions.preset) {
-    case "gemini":
-      return parseGeminiCli(stdout);
-    case "qwen":
-      return parseQwenCli(stdout);
+    case "pi":
+      return parseTextCli(stdout, { kind: "text" });
     case "claude":
     case "openclaude":
       return parseClaudeCli(stdout);
@@ -9083,6 +8953,88 @@ async function cleanupCliInvocation(invocation) {
 }
 function createCliTransportManager(options) {
   return {
+    async discoverModels(context) {
+      const source = resolveCliDiscoverySource(context.route);
+      if (source.via === "none") {
+        throw new AiConnectError(
+          "not_supported",
+          `CLI transport "${context.route.transport.id}" does not support model discovery (no list command, no ACP sidecar, and no configured models[]).`
+        );
+      }
+      if (source.via === "acp") {
+        throw new AiConnectError(
+          "not_supported",
+          `CLI route "${context.route.id}" resolves discovery via acp; dispatch to the acp discovery route instead.`
+        );
+      }
+      if (source.via === "static") {
+        return buildStaticCliCatalog(context.route);
+      }
+      const phases = [];
+      const invocation = buildCliDiscoveryInvocation(
+        context.route,
+        source.command,
+        options
+      );
+      context.telemetry?.captureTransport({
+        protocol: "cli",
+        endpoint: invocation.command,
+        method: "process",
+        bodyKeys: ["argv"],
+        parameterKeys: invocation.parameterKeys,
+        phases,
+        stream: false
+      });
+      try {
+        let models;
+        try {
+          const execution = await executeCliInvocation(
+            invocation,
+            options?.timeoutMs ?? 6e4,
+            phases,
+            context.abort.signal
+          );
+          if (execution.exitCode !== 0 || !execution.stdout.trim()) {
+            throw new AiConnectError(
+              "temporary_unavailable",
+              execution.stderr.trim() || `CLI discovery command for "${context.route.transport.id}" exited with code ${execution.exitCode ?? "null"}.`
+            );
+          }
+          models = parseCliModelList(
+            execution.stdout,
+            source.command.parser,
+            source.command.models
+          );
+        } catch (error) {
+          if (error instanceof AiConnectError && error.code === "aborted") {
+            throw error;
+          }
+          if (source.fallback === "static") {
+            return buildStaticCliCatalog(context.route);
+          }
+          throw error;
+        }
+        if (models.length === 0) {
+          if (source.fallback === "static") {
+            return buildStaticCliCatalog(context.route);
+          }
+          throw new AiConnectError(
+            "temporary_unavailable",
+            `CLI discovery command for "${context.route.transport.id}" returned no models.`
+          );
+        }
+        return buildModelCatalog(
+          context.route,
+          models,
+          currentModelIdForRoute(
+            context.route,
+            models.map((model) => model.modelId)
+          )
+        );
+      } finally {
+        await cleanupCliInvocation(invocation);
+      }
+    },
     async runPrompt(context) {
       const invocation = await buildCliInvocation(context, options);
       const phases = [];
@@ -9617,17 +9569,21 @@ function createLocalRouteHandlers(options = {}) {
           return cliTransport.runPrompt(context);
         },
         async discoverModels(context) {
-          const discoveryRoute = createCliDiscoveryAcpRoute(context.route);
-          if (!discoveryRoute) {
-            throw new AiConnectError(
-              "not_supported",
-              `CLI route "${context.route.id}" does not define a model discovery backend.`
-            );
+          const source = resolveCliDiscoverySource(context.route);
+          if (source.via === "acp") {
+            const discoveryRoute = createCliDiscoveryAcpRoute(context.route);
+            if (!discoveryRoute) {
+              throw new AiConnectError(
+                "not_supported",
+                `CLI route "${context.route.id}" does not define a model discovery backend.`
+              );
+            }
+            return acpTransport.discoverModels({
+              ...context,
+              route: discoveryRoute
+            });
           }
-          return acpTransport.discoverModels({
-            ...context,
-            route: discoveryRoute
-          });
+          return cliTransport.discoverModels(context);
         },
         async verify({ route, runtime }) {
           try {