@vedmalex/ai-connect 0.2.0 → 0.4.0

package/dist/bun/index.js

@@ -219,11 +219,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,
@@ -236,13 +232,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 ? {
@@ -254,11 +259,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";
@@ -279,7 +286,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()
@@ -287,9 +294,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 {
@@ -1730,6 +1783,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 };
@@ -2175,6 +2247,7 @@ function normalizeResult(route, output, attempts) {
     attempts,
     ...output.toolCalls ? { toolCalls: output.toolCalls } : {},
     ...output.text !== void 0 ? { text: output.text } : {},
+    ...output.reasoning !== void 0 ? { reasoning: output.reasoning } : {},
     ...output.data !== void 0 ? { data: output.data } : {},
     ...output.usage !== void 0 ? { usage: output.usage } : {}
   };
@@ -4725,18 +4798,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) {
@@ -5551,6 +5625,9 @@ function extractText(value) {
         return [part];
       }
       if (part && typeof part === "object") {
+        if (part.thought === true) {
+          return [];
+        }
         const candidate = part.text;
         if (typeof candidate === "string") {
           return [candidate];
@@ -5561,6 +5638,22 @@ function extractText(value) {
   }
   return "";
 }
+function extractThoughts(value) {
+  if (!Array.isArray(value)) {
+    return void 0;
+  }
+  const thoughts = value.flatMap((part) => {
+    if (part && typeof part === "object" && part.thought === true) {
+      const candidate = part.text;
+      if (typeof candidate === "string") {
+        return [candidate];
+      }
+    }
+    return [];
+  });
+  const joined = thoughts.join("\n").trim();
+  return joined.length > 0 ? joined : void 0;
+}
 function imageAttachmentsFromPayload(payload, ...sources) {
   return extractImagePayloads(payload, ...sources).map(
     (item) => preparePortableFile(item)
@@ -6103,8 +6196,11 @@ async function runGemini(fetchImpl, context) {
     throw classifyApiError(provider, response, payload);
   }
   const data = payload;
+  const geminiThoughts = extractThoughts(data.candidates?.[0]?.content?.parts);
   return {
     text: extractText(data.candidates?.[0]?.content?.parts),
+    // The model's `{ thought: true }` parts, separated from the answer (consumers route this to a thinking UI).
+    ...geminiThoughts ? { reasoning: geminiThoughts } : {},
     data,
     ...geminiToolCallsFromPayload(data).length > 0 ? { toolCalls: geminiToolCallsFromPayload(data) } : {},
     ...(() => {
@@ -7943,6 +8039,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();
@@ -8884,14 +8984,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);
@@ -9000,6 +9112,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;
@@ -9037,6 +9185,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();
@@ -9084,7 +9235,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) {
@@ -9105,6 +9256,70 @@ function parseGenericJsonlCli(stdout, parser) {
     data: entries
   };
 }
+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 (!text) {
+    throw new AiConnectError(
+      "temporary_unavailable",
+      "CLI text parser produced no output."
+    );
+  }
+  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 {
+    modelId,
+    name,
+    ...description ? { description } : {},
+    ...contextLength !== void 0 ? { contextLength } : {}
+  };
+}
+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 (!selector) {
+    throw new AiConnectError(
+      "validation_error",
+      `CLI ${parser.kind} discovery parser requires a models selector with idPath.`
+    );
+  }
+  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);
+    }
+  }
+  return models;
+}
 function parseGeminiCli(stdout) {
   const payload = JSON.parse(stdout);
   if (typeof payload.error === "string") {
@@ -9176,8 +9391,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) {
@@ -9235,7 +9449,14 @@ 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":
@@ -9338,6 +9559,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 = [];
@@ -9857,17 +10160,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 {