@easynet/agent-llm 1.0.15 → 1.0.25

package/dist/{chunk-AZDHRCIM.js → chunk-H4UQIDGT.js}

@@ -153,205 +153,29 @@ function loadLlmConfig(filePath, options = {}) {
   }
 }
 
-// src/providers/openai.ts
-import OpenAI from "openai";
-function getApiKey(config) {
-  const key = config.apiKey ?? process.env.OPENAI_API_KEY ?? "";
-  if (!key) throw new Error("OpenAI-compatible apiKey required (config.apiKey or OPENAI_API_KEY)");
-  return key;
-}
-function createOpenAIClientOptions(config) {
-  const opts = { apiKey: getApiKey(config) };
-  if (typeof config.baseURL === "string" && config.baseURL) opts.baseURL = config.baseURL;
-  return opts;
-}
-function serializeMessage(m) {
-  if (m.role === "tool")
-    return { role: "tool", content: m.content, tool_call_id: m.tool_call_id };
-  if (m.role === "assistant" && "tool_calls" in m && m.tool_calls?.length) {
-    return {
-      role: "assistant",
-      content: m.content ?? null,
-      tool_calls: m.tool_calls.map((tc) => ({
-        id: tc.id,
-        type: "function",
-        function: { name: tc.function.name, arguments: tc.function.arguments }
-      }))
-    };
-  }
-  return { role: m.role, content: m.content };
-}
-function createOpenAIChatClient(config) {
-  const client = new OpenAI(createOpenAIClientOptions(config));
-  const model = config.model ?? process.env.OPENAI_MODEL ?? "gpt-4o-mini";
-  const temperature = config.temperature ?? 0;
-  return {
-    id: config.id,
-    type: "chat",
-    async chat(messages) {
-      const resp = await client.chat.completions.create({
-        model,
-        temperature,
-        messages: messages.map((m) => ({ role: m.role, content: m.content }))
-      });
-      const content = resp.choices[0]?.message?.content ?? "";
-      const usage = resp.usage ? { promptTokens: resp.usage.prompt_tokens, completionTokens: resp.usage.completion_tokens } : void 0;
-      return { content, usage };
-    },
-    async *chatStream(messages) {
-      const stream = await client.chat.completions.create({
-        model,
-        temperature,
-        messages: messages.map((m) => ({ role: m.role, content: m.content })),
-        stream: true
-      });
-      let usage;
-      for await (const chunk of stream) {
-        const delta = chunk.choices[0]?.delta;
-        const content = delta?.content ?? "";
-        const finishReason = chunk.choices[0]?.finish_reason;
-        if (chunk.usage) {
-          usage = {
-            promptTokens: chunk.usage.prompt_tokens,
-            completionTokens: chunk.usage.completion_tokens
-          };
-        }
-        yield {
-          content,
-          done: finishReason !== null && finishReason !== void 0,
-          usage
-        };
-      }
-    },
-    async chatWithTools(messages, tools, _options) {
-      const resp = await client.chat.completions.create({
-        model,
-        temperature,
-        messages: messages.map(serializeMessage),
-        tools: tools.map((t) => ({
-          type: "function",
-          function: {
-            name: t.function.name,
-            description: t.function.description,
-            parameters: t.function.parameters ?? void 0
-          }
-        }))
-      });
-      const msg = resp.choices[0]?.message;
-      const usage = resp.usage ? { promptTokens: resp.usage.prompt_tokens, completionTokens: resp.usage.completion_tokens } : void 0;
-      return {
-        message: {
-          role: "assistant",
-          content: msg?.content ?? null,
-          tool_calls: msg?.tool_calls?.map((tc) => ({
-            id: tc.id,
-            type: "function",
-            function: {
-              name: tc.function?.name ?? "",
-              arguments: tc.function?.arguments ?? ""
-            }
-          }))
-        },
-        usage
-      };
-    },
-    async *chatWithToolsStream(messages, tools, _options) {
-      const stream = await client.chat.completions.create({
-        model,
-        temperature,
-        messages: messages.map(serializeMessage),
-        tools: tools.map((t) => ({
-          type: "function",
-          function: {
-            name: t.function.name,
-            description: t.function.description,
-            parameters: t.function.parameters ?? void 0
-          }
-        })),
-        stream: true,
-        stream_options: { include_usage: true }
-      });
-      let usage;
-      for await (const chunk of stream) {
-        const delta = chunk.choices[0]?.delta;
-        const finishReason = chunk.choices[0]?.finish_reason;
-        if (chunk.usage) {
-          usage = {
-            promptTokens: chunk.usage.prompt_tokens,
-            completionTokens: chunk.usage.completion_tokens
-          };
-        }
-        const toolCalls = delta?.tool_calls?.map((tc) => ({
-          index: tc.index,
-          id: tc.id,
-          type: tc.type,
-          function: tc.function ? {
-            name: tc.function.name,
-            arguments: tc.function.arguments
-          } : void 0
-        }));
-        yield {
-          delta: {
-            role: delta?.role,
-            content: delta?.content ?? null,
-            tool_calls: toolCalls
-          },
-          done: finishReason !== null && finishReason !== void 0,
-          usage
-        };
-      }
-    }
-  };
-}
-function createOpenAIImageClient(config) {
-  const client = new OpenAI(createOpenAIClientOptions(config));
-  const model = config.model ?? "dall-e-3";
-  return {
-    id: config.id,
-    type: "image",
-    async chat() {
-      throw new Error("OpenAI image model does not support chat; use generateImage()");
-    },
-    async generateImage(options) {
-      const resp = await client.images.generate({
-        model,
-        prompt: options.prompt,
-        size: options.size ?? "1024x1024",
-        n: options.n ?? 1,
-        response_format: "url"
-      });
-      const url = resp.data?.[0]?.url ?? void 0;
-      return { url };
-    }
-  };
-}
-function createOpenAIClient(config) {
-  if (config.type === "image") return createOpenAIImageClient(config);
-  return createOpenAIChatClient(config);
-}
-
-// src/providers/index.ts
-var OPENAI_COMPATIBLE = "openai-compatible";
-function createOpenAICompat(config) {
-  return createOpenAIClient(config);
-}
-var PROVIDERS = {
-  openai: createOpenAICompat,
-  [OPENAI_COMPATIBLE]: createOpenAICompat
-};
-function createClient(config) {
-  const p = (config.provider ?? "").toLowerCase();
-  const fn = PROVIDERS[p];
-  if (!fn) {
-    const supported = [.../* @__PURE__ */ new Set([...Object.keys(PROVIDERS), "extension providers"])].sort().join(", ");
-    throw new Error(
-      `Unsupported LLM provider: ${config.provider}. Supported: ${supported}.`
-    );
-  }
-  return fn(config);
-}
-function registerProvider(name, factory) {
-  PROVIDERS[name.toLowerCase()] = factory;
+// src/langchain/openai-compatible.ts
+import { ChatOpenAI } from "@langchain/openai";
+function createChatOpenAI(options) {
+  const {
+    baseURL,
+    model,
+    temperature = 0,
+    apiKey,
+    defaultHeaders,
+    defaultQuery,
+    httpAgent
+  } = options;
+  const config = {};
+  if (baseURL) config.baseURL = baseURL;
+  if (defaultHeaders) config.defaultHeaders = defaultHeaders;
+  if (defaultQuery) config.defaultQuery = defaultQuery;
+  if (httpAgent) config.httpAgent = httpAgent;
+  return new ChatOpenAI({
+    model,
+    temperature,
+    ...apiKey ? { apiKey } : {},
+    ...Object.keys(config).length > 0 ? { configuration: config } : {}
+  });
 }
 
 // src/registry/chat-model.ts
@@ -363,14 +187,13 @@ function getChatModelFactory(providerName) {
   return CHAT_MODEL_FACTORIES.get(providerName.toLowerCase());
 }
 
-// src/langchain/adapter.ts
-import { ChatOpenAI } from "@langchain/openai";
+// src/langchain/index.ts
 var DEFAULT_MODEL = "gpt-4o-mini";
-function normalizeAgentLlMError(e, context) {
+function normalizeError(e, context) {
   if (e instanceof Error) return new Error(`${context}: ${e.message}`, { cause: e });
   return new Error(`${context}: ${String(e)}`);
 }
-function createChatModelFromLlmConfig(options) {
+function createChatModelFromLlmConfig(options = {}) {
   const { llmSection, modelEnv, apiKeyEnv } = options;
   let defaultId;
   let configs;
@@ -379,61 +202,62 @@ function createChatModelFromLlmConfig(options) {
     defaultId = parsed.defaultId;
     configs = parsed.configs;
   } catch (e) {
-    throw normalizeAgentLlMError(e, "agent-llm: failed to parse llm section");
+    throw normalizeError(e, "Failed to parse llm section");
   }
-  const defaultConfig = configs.find((c) => c.id === defaultId) ?? configs[0];
-  if (!defaultConfig) {
+  const config = configs.find((c) => c.id === defaultId) ?? configs[0];
+  if (!config) {
     const model2 = modelEnv ?? process.env.OPENAI_MODEL ?? DEFAULT_MODEL;
     const apiKey2 = apiKeyEnv ?? process.env.OPENAI_API_KEY;
-    try {
-      return new ChatOpenAI({
-        model: model2,
-        temperature: 0,
-        ...apiKey2 ? { apiKey: apiKey2 } : {}
-      });
-    } catch (e) {
-      throw normalizeAgentLlMError(e, "agent-llm: failed to create default ChatOpenAI");
-    }
+    return createChatOpenAI({
+      model: model2,
+      temperature: 0,
+      ...apiKey2 ? { apiKey: apiKey2 } : {}
+    });
   }
-  const provider = defaultConfig.provider ?? "openai";
-  const chatModelFactory = getChatModelFactory(provider);
-  if (chatModelFactory) {
-    const config = {
-      ...defaultConfig,
-      model: modelEnv ?? defaultConfig.model,
-      temperature: typeof defaultConfig.temperature === "number" ? defaultConfig.temperature : 0
-    };
+  const provider = config.provider ?? "openai";
+  const factory = getChatModelFactory(provider);
+  if (factory) {
     try {
-      return chatModelFactory(config);
+      return factory({
+        ...config,
+        model: modelEnv ?? config.model ?? DEFAULT_MODEL,
+        temperature: typeof config.temperature === "number" ? config.temperature : 0
+      });
     } catch (e) {
-      throw normalizeAgentLlMError(e, `agent-llm: failed to create ChatModel for provider "${provider}"`);
+      throw normalizeError(e, `Failed to create ChatModel for provider "${provider}"`);
     }
   }
-  const model = modelEnv ?? defaultConfig?.model ?? process.env.OPENAI_MODEL ?? DEFAULT_MODEL;
-  let apiKey = apiKeyEnv ?? defaultConfig?.apiKey ?? process.env.OPENAI_API_KEY;
-  let baseURL = defaultConfig?.baseURL;
+  const model = modelEnv ?? config.model ?? process.env.OPENAI_MODEL ?? DEFAULT_MODEL;
+  let apiKey = apiKeyEnv ?? config.apiKey ?? process.env.OPENAI_API_KEY;
+  let baseURL = config.baseURL;
   if (baseURL && !baseURL.replace(/\/$/, "").endsWith("/v1")) {
     baseURL = baseURL.replace(/\/$/, "") + "/v1";
   }
-  if (baseURL && apiKey === void 0) {
-    apiKey = "ollama";
+  if (baseURL && !apiKey) {
+    apiKey = "not-needed";
   }
-  const temperature = typeof defaultConfig?.temperature === "number" ? defaultConfig.temperature : 0;
-  const constructorOptions = {
+  const temperature = typeof config.temperature === "number" ? config.temperature : 0;
+  const opts = config.options;
+  const defaultHeaders = opts?.defaultHeaders;
+  const defaultQuery = opts?.defaultQuery;
+  const httpAgent = opts?.httpAgent;
+  return createChatOpenAI({
     model,
     temperature,
-    ...apiKey ? { apiKey } : {},
-    ...baseURL ? { configuration: { baseURL } } : {}
-  };
-  try {
-    return new ChatOpenAI(constructorOptions);
-  } catch (e) {
-    throw normalizeAgentLlMError(e, "agent-llm: failed to create ChatOpenAI from config");
-  }
+    baseURL,
+    apiKey,
+    defaultHeaders,
+    defaultQuery,
+    httpAgent
+  });
 }
 
+// src/types.ts
+var AGENT_LLM_PROVIDER_FIELD = "agentLlmProvider";
+
 // src/extensions/loader.ts
 import { readdirSync, readFileSync as readFileSync2, existsSync as existsSync2 } from "fs";
+import { createRequire } from "module";
 import { join } from "path";
 import { pathToFileURL } from "url";
 var loadedPackages = /* @__PURE__ */ new Set();
@@ -442,12 +266,11 @@ function isLLMExtension(m) {
   const e = m;
   if (typeof e.providerName !== "string") return false;
   const hasRegister = typeof e.register === "function";
-  const hasFactories = typeof e.createClient === "function" && typeof e.createChatModel === "function";
-  return hasRegister || hasFactories;
+  const hasChatModel = typeof e.createChatModel === "function";
+  return hasRegister || hasChatModel;
 }
 function registerExtension(ext) {
-  if (typeof ext.createClient === "function" && typeof ext.createChatModel === "function") {
-    registerProvider(ext.providerName, ext.createClient);
+  if (typeof ext.createChatModel === "function") {
     registerChatModelProvider(ext.providerName, ext.createChatModel);
     return;
   }
@@ -476,7 +299,7 @@ function readPackageProviderName(pkgPath) {
   try {
     const raw = readFileSync2(pkgPath, "utf-8");
     const pkg = JSON.parse(raw);
-    const declared = pkg.agentLlmProvider === true || Array.isArray(pkg.keywords) && pkg.keywords.includes("agent-llm-provider");
+    const declared = pkg[AGENT_LLM_PROVIDER_FIELD] === true || Array.isArray(pkg.keywords) && pkg.keywords.includes("agent-llm-provider");
     return declared && typeof pkg.name === "string" ? pkg.name : null;
   } catch {
     return null;
@@ -532,6 +355,17 @@ async function loadModuleFromPath(pkgDir) {
     entryUrl
   );
 }
+function resolvePackageEntryFromCwd(pkg, cwd) {
+  const pkgDir = join(cwd, "node_modules", pkg);
+  const pkgJsonPath = join(pkgDir, "package.json");
+  if (!existsSync2(pkgJsonPath)) return null;
+  try {
+    const req = createRequire(pkgJsonPath);
+    return req.resolve(pkg);
+  } catch {
+    return null;
+  }
+}
 async function loadLLMExtensions(extensionPackages, options) {
   const packages = Array.isArray(extensionPackages) ? extensionPackages.filter((p) => typeof p === "string" && String(p).trim().length > 0) : [];
   const cwd = options?.cwd ?? process.cwd();
@@ -568,6 +402,26 @@ async function loadLLMExtensions(extensionPackages, options) {
       }
     }
     if (loaded) continue;
+    const resolvedEntry = resolvePackageEntryFromCwd(pkg, cwd);
+    if (resolvedEntry) {
+      try {
+        const entryUrl = pathToFileURL(resolvedEntry).href;
+        const m = await import(
+          /* @vite-ignore */
+          entryUrl
+        );
+        const ext = getExtensionFromModule(m);
+        if (ext) {
+          registerExtension(ext);
+          continue;
+        }
+        if (typeof m.registerLLMExtension === "function") {
+          m.registerLLMExtension();
+          continue;
+        }
+      } catch {
+      }
+    }
     try {
       const m = await import(
         /* @vite-ignore */
@@ -599,7 +453,7 @@ async function loadDiscoveredExtensions(cwd = process.cwd()) {
 // src/extensions/npm-protocol.ts
 import { execFileSync } from "child_process";
 import { readFileSync as readFileSync3 } from "fs";
-import { createRequire } from "module";
+import { createRequire as createRequire2 } from "module";
 var NPM_PROTOCOL_PREFIX = "npm:";
 var VERSION_LATEST = "latest";
 async function getLatestVersion(packageName, options = {}) {
@@ -615,12 +469,12 @@ async function getLatestVersion(packageName, options = {}) {
     return version;
   } catch (e) {
     const msg = e instanceof Error ? e.message : String(e);
-    throw new Error(`agent-llm: failed to get latest version for "${packageName}": ${msg}`, { cause: e });
+    throw new Error(`Failed to get latest version for "${packageName}": ${msg}`, { cause: e });
   }
 }
 function getInstalledVersion(packageName, options = {}) {
   const cwd = options.cwd ?? process.cwd();
-  const require2 = createRequire(import.meta.url);
+  const require2 = createRequire2(import.meta.url);
   try {
     const p = require2.resolve(`${packageName}/package.json`, { paths: [cwd] });
     const j = JSON.parse(readFileSync3(p, "utf-8"));
@@ -649,60 +503,36 @@ function isModuleNotFoundError(err) {
   return msg.includes("Cannot find module") || msg.includes("Cannot find package") || msg.includes("MODULE_NOT_FOUND") || msg.includes("ERR_MODULE_NOT_FOUND") || msg.includes("Failed to load url") || msg.includes("Does the file exist");
 }
 async function resolveInstallVersion(packageName, version, cwd) {
-  if (version === void 0 || version === "" || version === VERSION_LATEST) {
+  const isLatestOrEmpty = version === void 0 || version === "" || typeof version === "string" && version.toLowerCase() === VERSION_LATEST;
+  if (isLatestOrEmpty) {
     return getLatestVersion(packageName, { cwd });
   }
   return version;
 }
 async function ensureNpmPackageInstalled(packageName, options = {}) {
   if (typeof packageName !== "string" || packageName.trim().length === 0) {
-    throw new Error("agent-llm: ensureNpmPackageInstalled requires a non-empty package name");
+    throw new Error("ensureNpmPackageInstalled requires a non-empty package name");
   }
   const cwd = options.cwd ?? process.cwd();
-  const requestedVersion = options.version;
-  const resolvedVersion = await resolveInstallVersion(packageName, requestedVersion, cwd);
-  try {
-    await import(
-      /* @vite-ignore */
-      packageName
-    );
-    const askedForLatest = requestedVersion === void 0 || requestedVersion === "" || requestedVersion === VERSION_LATEST;
-    if (askedForLatest && resolvedVersion !== void 0) {
-      const installed = getInstalledVersion(packageName, { cwd });
-      if (installed !== null && installed !== resolvedVersion) {
-        const installSpec2 = `${packageName}@${resolvedVersion}`;
-        try {
-          execFileSync("npm", ["install", installSpec2], {
-            cwd,
-            stdio: "inherit",
-            encoding: "utf-8"
-          });
-        } catch (e) {
-          const msg = e instanceof Error ? e.message : String(e);
-          throw new Error(`agent-llm: npm install failed for ${installSpec2}: ${msg}`, { cause: e });
-        }
-      }
+  const resolvedVersion = await resolveInstallVersion(packageName, options.version, cwd);
+  const installedVersion = getInstalledVersion(packageName, { cwd });
+  if (installedVersion !== resolvedVersion) {
+    const installSpec = `${packageName}@${resolvedVersion}`;
+    if (installedVersion === null) {
+      console.info(`[agent-llm] Installing provider: ${installSpec}`);
+    } else {
+      console.info(`[agent-llm] Updating provider: ${packageName} ${installedVersion} \u2192 ${resolvedVersion}`);
+    }
+    try {
+      execFileSync("npm", ["install", installSpec], { cwd, stdio: "inherit", encoding: "utf-8" });
+    } catch (e) {
+      const msg = e instanceof Error ? e.message : String(e);
+      throw new Error(`npm install failed for ${installSpec}: ${msg}`, { cause: e });
     }
-    return;
-  } catch (err) {
-    if (!isModuleNotFoundError(err)) throw err;
-  }
-  const installSpec = resolvedVersion ? `${packageName}@${resolvedVersion}` : packageName;
-  try {
-    execFileSync("npm", ["install", installSpec], {
-      cwd,
-      stdio: "inherit",
-      encoding: "utf-8"
-    });
-  } catch (e) {
-    const msg = e instanceof Error ? e.message : String(e);
-    throw new Error(`agent-llm: npm install failed for ${installSpec}: ${msg}`, { cause: e });
   }
 }
-function normalizeAgentLlMError2(e, context) {
-  if (e instanceof Error) {
-    return new Error(`${context}: ${e.message}`, { cause: e });
-  }
+function normalizeError2(e, context) {
+  if (e instanceof Error) return new Error(`${context}: ${e.message}`, { cause: e });
   return new Error(`${context}: ${String(e)}`);
 }
 async function resolveNpmProvider(spec, options = {}) {
@@ -715,6 +545,9 @@ async function resolveNpmProvider(spec, options = {}) {
   const load = async () => {
     await loadLLMExtensions([packageName], { cwd });
   };
+  if (installNpmIfMissing) {
+    await ensureNpmPackageInstalled(packageName, { version, cwd });
+  }
   try {
     await load();
   } catch (err) {
@@ -723,21 +556,19 @@ async function resolveNpmProvider(spec, options = {}) {
         await ensureNpmPackageInstalled(packageName, { version, cwd });
         await load();
       } catch (installErr) {
-        throw normalizeAgentLlMError2(installErr, `agent-llm: failed to install or load npm provider "${packageName}"`);
+        throw normalizeError2(installErr, `Failed to install or load npm provider "${packageName}"`);
       }
     } else {
-      throw normalizeAgentLlMError2(err, `agent-llm: failed to load npm provider "${packageName}"`);
+      throw normalizeError2(err, `Failed to load npm provider "${packageName}"`);
     }
   }
-  if (fragmentProvider && installNpmIfMissing && !getChatModelFactory(fragmentProvider)) {
-    try {
+  if (fragmentProvider && !getChatModelFactory(fragmentProvider)) {
+    if (installNpmIfMissing) {
       await ensureNpmPackageInstalled(packageName, { version, cwd });
       await load();
-    } catch (installErr) {
-      throw normalizeAgentLlMError2(installErr, `agent-llm: failed to install or load npm provider "${packageName}" (provider "${fragmentProvider}" not registered)`);
     }
     if (!getChatModelFactory(fragmentProvider)) {
-      throw new Error(`agent-llm: package "${packageName}" was installed but did not register provider "${fragmentProvider}". Check that the package exports getLLMExtension() or registerLLMExtension().`);
+      throw new Error(`Package "${packageName}" was installed but did not register provider "${fragmentProvider}". Check that the package exports getLLMExtension() or registerLLMExtension().`);
     }
   }
   if (fragmentProvider) return fragmentProvider;
@@ -763,7 +594,7 @@ async function resolveLlmSectionWithNpm(llmSection, options = {}) {
       try {
         out.push(await resolveLlmSectionWithNpm(llmSection[i], options));
       } catch (e) {
-        throw normalizeAgentLlMError2(e, `agent-llm: failed to resolve llm section at index ${i}`);
+        throw normalizeError2(e, `Failed to resolve llm section at index ${i}`);
       }
     }
     return out;
@@ -776,21 +607,21 @@ async function resolveLlmSectionWithNpm(llmSection, options = {}) {
           const resolved = await resolveNpmProvider(v, options);
           out[k] = resolved ?? v;
         } catch (e) {
-          throw normalizeAgentLlMError2(e, `agent-llm: failed to resolve provider "${String(v)}"`);
+          throw normalizeError2(e, `Failed to resolve provider "${String(v)}"`);
         }
         continue;
       }
       try {
         out[k] = await resolveLlmSectionWithNpm(v, options);
       } catch (e) {
-        throw normalizeAgentLlMError2(e, `agent-llm: failed to resolve llm section key "${k}"`);
+        throw normalizeError2(e, `Failed to resolve llm section key "${k}"`);
       }
     }
     return out;
   }
   return llmSection;
 }
-async function createChatModelFromLlmConfigWithNpm(options) {
+async function createChatModelWithNpm(options = {}) {
   try {
     const { installNpmIfMissing, cwd, ...rest } = options;
     const resolvedSection = await resolveLlmSectionWithNpm(options.llmSection ?? null, {
@@ -802,7 +633,7 @@ async function createChatModelFromLlmConfigWithNpm(options) {
       llmSection: resolvedSection
     });
   } catch (e) {
-    throw normalizeAgentLlMError2(e, "agent-llm: createChatModelFromLlmConfigWithNpm failed");
+    throw normalizeError2(e, "createChatModelWithNpm failed");
   }
 }
 
@@ -827,7 +658,7 @@ function resolveProbeRequest(baseURL, endpointOptions) {
   const searchParams = new URLSearchParams(urlObj.search);
   if (endpointOptions?.bypassAuth === true) searchParams.set("bypass_auth", "true");
   urlObj.search = searchParams.toString();
-  return { url: urlObj.toString(), hostHeader, searchParams };
+  return { url: urlObj.toString(), hostHeader };
 }
 function checkWithHttps(url, hostHeader, options) {
   return new Promise((resolve) => {
@@ -843,10 +674,7 @@ function checkWithHttps(url, hostHeader, options) {
     if (hostHeader) reqOpts.headers = { ...reqOpts.headers, Host: hostHeader };
     const timeoutId = setTimeout(() => {
       req.destroy();
-      resolve({
-        reachable: false,
-        message: "Connection timed out"
-      });
+      resolve({ reachable: false, message: "Connection timed out" });
     }, options.timeoutMs);
     const req = https.request(reqOpts, (res) => {
       clearTimeout(timeoutId);
@@ -858,10 +686,7 @@ function checkWithHttps(url, hostHeader, options) {
     });
     req.on("error", (err) => {
       clearTimeout(timeoutId);
-      resolve({
-        reachable: false,
-        message: err.message || "Connection failed"
-      });
+      resolve({ reachable: false, message: err.message || "Connection failed" });
     });
     req.end();
   });
@@ -926,25 +751,23 @@ function buildEndpointConnectivityOptions(config) {
   if (resolveHost == null && host == null) return void 0;
   const verifySSL = opts?.verifySSL === true;
   const bypassAuth = opts?.bypassAuth !== false;
-  const featureKey = typeof opts?.featureKey === "string" ? opts.featureKey : void 0;
   return {
     resolveHost,
     host,
     verifySSL: resolveHost != null ? false : verifySSL ? true : void 0,
     bypassAuth: bypassAuth ? true : void 0,
-    featureKey
+    featureKey: typeof opts?.featureKey === "string" ? opts.featureKey : void 0
   };
 }
 function resolveDefaultConfigPath() {
-  const cwd = process.cwd();
-  return join2(cwd, "llm.yaml");
+  return join2(process.cwd(), "llm.yaml");
 }
-function normalizeCreateOptions(configPathOrOptions) {
+function normalizeOptions(configPathOrOptions) {
   if (configPathOrOptions == null) return {};
   if (typeof configPathOrOptions === "string") return { configPath: configPathOrOptions };
   return configPathOrOptions;
 }
-function normalizeAgentLlMError3(e, context) {
+function normalizeError3(e, context) {
   if (e instanceof Error) return new Error(`${context}: ${e.message}`, { cause: e });
   return new Error(`${context}: ${String(e)}`);
 }
@@ -953,16 +776,14 @@ async function ensureConnectivity(resolvedLlmSection, options) {
   try {
     const parsed = parseLlmSection(resolvedLlmSection ?? null);
     configs = parsed.configs.filter(
-      (c) => typeof c.baseURL === "string" && c.baseURL.length > 0
+      (c) => typeof c.baseURL === "string" && c.baseURL.length > 0 && (c.baseURL.startsWith("http://") || c.baseURL.startsWith("https://")) && !c.baseURL.includes("${")
     );
   } catch {
     return;
   }
   const shouldCheck = options.checkConnectivity !== false && configs.length > 0;
   if (!shouldCheck) return;
-  const report = (status) => {
-    options.onConnectionStatus?.(status);
-  };
+  const report = (status) => options.onConnectionStatus?.(status);
   const timeoutMs = options.connectivityTimeoutMs ?? 8e3;
   for (const config of configs) {
     const { id, baseURL } = config;
@@ -970,7 +791,7 @@ async function ensureConnectivity(resolvedLlmSection, options) {
       phase: "checking",
       endpointId: id,
       baseURL,
-      message: "Checking CIS connection..."
+      message: "Checking connection..."
     });
     const endpointOpts = buildEndpointConnectivityOptions(config);
     const result = await checkEndpointConnectivity(baseURL, {
@@ -991,19 +812,19 @@ async function ensureConnectivity(resolvedLlmSection, options) {
         baseURL,
         message: result.message ?? "Unreachable"
       });
-      throw new Error(
-        buildUnreachableError(id, baseURL, result.message)
-      );
+      throw new Error(buildUnreachableError(id, baseURL, result.message));
     }
   }
 }
 async function createAgentLlM(configPathOrOptions) {
   try {
-    const options = normalizeCreateOptions(configPathOrOptions);
+    const options = normalizeOptions(configPathOrOptions);
     const configPath = options.configPath ?? resolveDefaultConfigPath();
     const llmSection = loadLlmConfig(configPath);
     if (llmSection == null) {
-      throw new Error(`No LLM config at ${configPath}. Add llm.yaml in the current directory, or pass configPath.`);
+      throw new Error(
+        `No LLM config at ${configPath}. Add llm.yaml in the current directory, or pass configPath.`
+      );
     }
     const resolvedSection = await resolveLlmSectionWithNpm(llmSection, {
       installNpmIfMissing: options.installNpmIfMissing !== false,
@@ -1017,9 +838,22 @@ async function createAgentLlM(configPathOrOptions) {
     return createChatModelFromLlmConfig({ llmSection: resolvedSection });
   } catch (e) {
     if (e instanceof Error && e.message.includes("No LLM config")) throw e;
-    if (e instanceof Error && e.message.includes("Cannot connect to CIS")) throw e;
-    throw normalizeAgentLlMError3(e, "agent-llm: createAgentLlM failed");
+    if (e instanceof Error && e.message.includes("Cannot connect to")) throw e;
+    throw normalizeError3(e, "createAgentLlM failed");
+  }
+}
+
+// src/cli/utils.ts
+function messageContentToString(content) {
+  if (typeof content === "string") return content;
+  if (Array.isArray(content)) {
+    return content.map((c) => "text" in c && c.text ? c.text : "").join("");
   }
+  return String(content ?? "");
+}
+function exitWithError(err, code = 1) {
+  console.error("Error:", err instanceof Error ? err.message : String(err));
+  process.exit(code);
 }
 
 export {
@@ -1027,14 +861,11 @@ export {
   substituteEnv,
   parseLlmYaml,
   loadLlmConfig,
-  createOpenAIChatClient,
-  createOpenAIImageClient,
-  createOpenAIClient,
-  createClient,
-  registerProvider,
+  createChatOpenAI,
   registerChatModelProvider,
   getChatModelFactory,
   createChatModelFromLlmConfig,
+  AGENT_LLM_PROVIDER_FIELD,
   resolveLLMExtensionPackages,
   discoverLLMExtensions,
   loadLLMExtensions,
@@ -1047,10 +878,12 @@ export {
   ensureNpmPackageInstalled,
   resolveNpmProvider,
   resolveLlmSectionWithNpm,
-  createChatModelFromLlmConfigWithNpm,
+  createChatModelWithNpm,
   checkEndpointConnectivity,
   CIS_UNREACHABLE_REMINDER,
   buildUnreachableError,
-  createAgentLlM
+  createAgentLlM,
+  messageContentToString,
+  exitWithError
 };
-//# sourceMappingURL=chunk-AZDHRCIM.js.map
+//# sourceMappingURL=chunk-H4UQIDGT.js.map