@wrongstack/cli 1.0.19 → 1.0.26

package/dist/chunk-LKPEBZBE.js

@@ -0,0 +1,143 @@
+
+// src/boot/stream-json.ts
+function parseOutputFormat(value) {
+  if (value === void 0) return void 0;
+  if (value === "text" || value === "json" || value === "stream-json") return value;
+  throw new Error(
+    `--output-format must be text, json or stream-json (got ${value === true ? "nothing" : `"${value}"`})`
+  );
+}
+var LEADER = "leader";
+function isLeader(agentId) {
+  return agentId === void 0 || agentId === LEADER;
+}
+function simplifyBlocks(content) {
+  const out = [];
+  for (const block of content ?? []) {
+    if (block.type === "text") out.push({ type: "text", text: block.text });
+    else if (block.type === "tool_use") {
+      out.push({ type: "tool_use", id: block.id, name: block.name, input: block.input });
+    }
+  }
+  return out;
+}
+function startStreamJson(opts) {
+  const emit = (payload) => {
+    opts.write(`${JSON.stringify(payload)}
+`);
+  };
+  const offs = [];
+  if (opts.includePartialMessages) {
+    offs.push(
+      opts.events.on("provider.text_delta", (e) => {
+        if (isLeader(e.ctx?.agentId)) emit({ type: "text_delta", text: e.text });
+      })
+    );
+  }
+  offs.push(
+    opts.events.on("provider.response", (e) => {
+      if (!isLeader(e.ctx?.agentId)) return;
+      emit({
+        type: "assistant",
+        model: e.model,
+        content: simplifyBlocks(e.content),
+        stopReason: e.stopReason,
+        usage: e.usage
+      });
+    })
+  );
+  offs.push(
+    opts.events.on("tool.executed", (e) => {
+      if (!isLeader(e.agentId)) return;
+      emit({
+        type: "tool_result",
+        id: e.id ?? null,
+        name: e.name,
+        ok: e.ok,
+        durationMs: e.durationMs,
+        output: e.output ?? null,
+        outputBytes: e.outputBytes ?? null
+      });
+    })
+  );
+  return () => {
+    for (const off of offs) off();
+  };
+}
+function streamJsonInit(info) {
+  return `${JSON.stringify({ type: "init", ...info })}
+`;
+}
+
+// src/boot/structured-output.ts
+import * as fs from "node:fs/promises";
+import * as path from "node:path";
+import { validateAgainstSchema } from "@wrongstack/core/utils";
+async function resolveJsonSchemaFlag(value, cwd) {
+  if (value === void 0) return void 0;
+  if (typeof value !== "string" || !value.trim()) {
+    throw new Error("--json-schema needs a JSON Schema file path or an inline JSON object");
+  }
+  const trimmed = value.trim();
+  let text = trimmed;
+  let source = "inline JSON";
+  if (!trimmed.startsWith("{")) {
+    const file = path.resolve(cwd, trimmed);
+    source = file;
+    try {
+      text = await fs.readFile(file, "utf8");
+    } catch (err) {
+      const reason = err.code ?? String(err);
+      throw new Error(`--json-schema: cannot read ${file} (${reason})`);
+    }
+  }
+  let schema;
+  try {
+    schema = JSON.parse(text);
+  } catch (err) {
+    throw new Error(`--json-schema: ${source} is not valid JSON (${err.message})`);
+  }
+  if (typeof schema !== "object" || schema === null || Array.isArray(schema)) {
+    throw new Error(`--json-schema: ${source} must be a JSON Schema object`);
+  }
+  return schema;
+}
+function withSchemaInstruction(query, schema) {
+  return `${query}
+
+When you are done, reply with ONLY a JSON value that validates against this JSON Schema \u2014 no prose, no code fence:
+${JSON.stringify(schema)}`;
+}
+function checkStructuredAnswer(text, schema) {
+  if (!text?.trim()) return { ok: false, errors: ["the answer was empty"] };
+  const fenced = text.trim().match(/^```(?:json)?\s*\n([\s\S]*?)\n?```$/);
+  const body = (fenced?.[1] ?? text).trim();
+  let value;
+  try {
+    value = JSON.parse(body);
+  } catch (err) {
+    return { ok: false, errors: [`not valid JSON (${err.message})`] };
+  }
+  const result = validateAgainstSchema(value, schema);
+  if (result.ok) return { ok: true, value };
+  return {
+    ok: false,
+    errors: result.errors.map((e) => `${e.path || "(root)"}: ${e.message}`)
+  };
+}
+function repairPrompt(errors) {
+  return `Your last answer did not validate against the JSON Schema:
+${errors.map((e) => `- ${e}`).join("\n")}
+Reply with ONLY the corrected JSON value.`;
+}
+
+export {
+  parseOutputFormat,
+  startStreamJson,
+  streamJsonInit,
+  resolveJsonSchemaFlag,
+  withSchemaInstruction,
+  checkStructuredAnswer,
+  repairPrompt
+};
+//# sourceMappingURL=chunk-LKPEBZBE.js.map

package/dist/chunk-LUMETJFO.js

@@ -0,0 +1,171 @@
+
+// src/provider-config-utils.ts
+import { FsError } from "@wrongstack/core/types";
+import { expectDefined } from "@wrongstack/core/utils";
+import * as fs from "node:fs/promises";
+import * as path from "node:path";
+import {
+  decryptConfigSecrets,
+  decryptConfigSecretsForRewrite,
+  encryptConfigSecrets
+} from "@wrongstack/core/security";
+import { atomicWrite, backupConfigFile, color, withFileLock } from "@wrongstack/core/utils";
+import {
+  clearStaleProviderDefaults,
+  removeProviderFallbackReferences,
+  validateProviderConfigShape
+} from "@wrongstack/providers";
+import { clearStaleProviderDefaults as clearStaleProviderDefaults2 } from "@wrongstack/providers";
+import { nowIso } from "@wrongstack/primitives";
+function normalizeKeys(cfg) {
+  if (Array.isArray(cfg.apiKeys) && cfg.apiKeys.length > 0) {
+    return cfg.apiKeys.map((k) => ({ ...k }));
+  }
+  if (typeof cfg.apiKey === "string" && cfg.apiKey.length > 0) {
+    return [{ label: "default", apiKey: cfg.apiKey, createdAt: "" }];
+  }
+  return [];
+}
+function writeKeysBack(cfg, keys) {
+  if (keys.length === 0) {
+    delete cfg.apiKeys;
+    delete cfg.apiKey;
+    delete cfg.activeKey;
+    return;
+  }
+  cfg.apiKeys = keys;
+  const active = keys.find((k) => k.label === cfg.activeKey) ?? expectDefined(keys[0]);
+  delete cfg.apiKey;
+  if (!cfg.activeKey || !keys.some((k) => k.label === cfg.activeKey)) {
+    cfg.activeKey = active.label;
+  }
+}
+function resolveActiveApiKey(cfg) {
+  if (Array.isArray(cfg.apiKeys) && cfg.apiKeys.length > 0) {
+    const active = cfg.activeKey ? cfg.apiKeys.find((k) => k.label === cfg.activeKey) : void 0;
+    return (active ?? cfg.apiKeys[0])?.apiKey;
+  }
+  return cfg.apiKey && cfg.apiKey.length > 0 ? cfg.apiKey : void 0;
+}
+function activeLabel(cfg, keys) {
+  if (cfg.activeKey && keys.some((k) => k.label === cfg.activeKey)) return cfg.activeKey;
+  return keys[0]?.label;
+}
+function maskedKey(key) {
+  if (!key) return color.dim("\u2014");
+  if (key.length <= 8) return color.dim("\u2022".repeat(key.length));
+  const head = key.slice(0, 4);
+  const tail = key.slice(-4);
+  return `${color.dim(head + "\u2026")}${tail}`;
+}
+async function loadConfigProviders(configPath, vault, opts) {
+  const warn = opts?.warn;
+  const targetPath = opts?.profileConfigPath ?? configPath;
+  let raw;
+  try {
+    raw = await fs.readFile(targetPath, "utf8");
+  } catch (err) {
+    if (err.code !== "ENOENT") {
+      warn?.(`Could not read ${targetPath}: ${err.message}. Treating as empty.`);
+    }
+    return {};
+  }
+  let parsed;
+  try {
+    parsed = JSON.parse(raw);
+    validateProviderConfigShape(parsed);
+  } catch (err) {
+    warn?.(`Config at ${targetPath} is not valid JSON: ${err.message}`);
+    return {};
+  }
+  const decrypted = decryptConfigSecrets(parsed, vault);
+  return decrypted.providers ?? {};
+}
+var configMutationChain = Promise.resolve();
+function globalRootForConfigPath(configPath) {
+  const configDir = path.dirname(configPath);
+  const profilesDir = path.dirname(configDir);
+  return path.basename(profilesDir) === "profiles" ? path.dirname(profilesDir) : configDir;
+}
+function queueConfigMutation(mutate) {
+  const run = configMutationChain.then(mutate, mutate);
+  configMutationChain = run.then(
+    () => void 0,
+    () => void 0
+  );
+  return run;
+}
+async function mutateConfigProviders(configPath, vault, mutator, profileConfigPath) {
+  await queueConfigMutation(
+    () => withFileLock(profileConfigPath ?? configPath, async () => {
+      const targetPath = profileConfigPath ?? configPath;
+      let raw;
+      let fileExists = true;
+      try {
+        raw = await fs.readFile(targetPath, "utf8");
+      } catch (err) {
+        if (err.code !== "ENOENT") {
+          throw new FsError({
+            message: `Refusing to mutate ${configPath}: ${err.message}`,
+            code: "FS_READ_FAILED",
+            path: targetPath,
+            context: { operation: "mutateConfigProviders", phase: "read" },
+            cause: err
+          });
+        }
+        fileExists = false;
+        raw = "{}";
+      }
+      let parsed;
+      try {
+        parsed = JSON.parse(raw);
+        validateProviderConfigShape(parsed);
+      } catch (err) {
+        if (fileExists) {
+          throw new FsError({
+            message: `Refusing to overwrite corrupt config at ${targetPath} (${err.message}). Fix or move the file aside before retrying.`,
+            code: "FS_READ_FAILED",
+            path: targetPath,
+            context: { operation: "mutateConfigProviders", phase: "parse" },
+            cause: err
+          });
+        }
+        parsed = {};
+      }
+      const decrypted = decryptConfigSecretsForRewrite(parsed, vault);
+      const providers = decrypted.providers ?? {};
+      const previousProviderIds = Object.keys(providers);
+      const primaryBefore = JSON.stringify([
+        decrypted["provider"],
+        decrypted["model"],
+        typeof decrypted["provider"] === "string" ? providers[decrypted["provider"]] : void 0
+      ]);
+      mutator(providers, decrypted);
+      for (const id of previousProviderIds) {
+        if (!Object.hasOwn(providers, id)) removeProviderFallbackReferences(decrypted, id);
+      }
+      decrypted.providers = providers;
+      const primaryAfter = JSON.stringify([
+        decrypted["provider"],
+        decrypted["model"],
+        typeof decrypted["provider"] === "string" ? providers[decrypted["provider"]] : void 0
+      ]);
+      clearStaleProviderDefaults(decrypted, { preservePrimary: primaryBefore === primaryAfter });
+      const encrypted = encryptConfigSecrets(decrypted, vault);
+      await backupConfigFile(targetPath, { globalRoot: globalRootForConfigPath(targetPath) });
+      await atomicWrite(targetPath, JSON.stringify(encrypted, null, 2), { mode: 384 });
+    })
+  );
+}
+
+export {
+  normalizeKeys,
+  writeKeysBack,
+  resolveActiveApiKey,
+  activeLabel,
+  maskedKey,
+  loadConfigProviders,
+  mutateConfigProviders,
+  nowIso
+};
+//# sourceMappingURL=chunk-LUMETJFO.js.map

package/dist/{chunk-KK2LB3ZS.js → chunk-OAVBM55Q.js}

@@ -641,6 +641,7 @@ import * as path6 from "node:path";
 import * as fs2 from "node:fs";
 import { createRequire } from "node:module";
 import * as path2 from "node:path";
+import { wrongstackPackageJsonPath } from "@wrongstack/core/utils";
 var requireFromHere = createRequire(import.meta.url);
 var MIME = {
   ".html": "text/html; charset=utf-8",
@@ -660,7 +661,10 @@ var cachedDistDir;
 function resolveHqDistDir() {
   if (cachedDistDir !== void 0) return cachedDistDir;
   try {
-    const pkgJson = requireFromHere.resolve("@wrongstack/webui-hq/package.json");
+    const pkgJson = wrongstackPackageJsonPath(
+      "@wrongstack/webui-hq",
+      (id) => requireFromHere.resolve(id)
+    );
     const dist = path2.join(path2.dirname(pkgJson), "dist");
     if (fs2.existsSync(path2.join(dist, "index.html"))) {
       cachedDistDir = dist;
@@ -687,7 +691,7 @@ function resolveHqDistDir() {
 }
 function isInsideDist(filePath, distDir) {
   const rel = path2.relative(distDir, filePath);
-  return rel !== "" && !rel.startsWith("..") && !path2.isAbsolute(rel);
+  return rel !== "" && rel !== ".." && !rel.startsWith(`..${path2.sep}`) && !path2.isAbsolute(rel);
 }
 function isMissingPath(error) {
   const code = error.code;
@@ -2843,8 +2847,8 @@ async function handleApiAgentMessages(req, res, match, agentMessages) {
 // src/hq-server/routes/system-handlers.ts
 async function handleApiSystemUpdate(res) {
   const [{ checkForUpdate }, { detectUpdatePackageName }] = await Promise.all([
-    import("./update-check-BS3DHTSI.js"),
-    import("./update-5DPB4YD4.js")
+    import("./update-check-J5ZVKS73.js"),
+    import("./update-TDZX4IL2.js")
   ]);
   const packageName = detectUpdatePackageName();
   const info = await checkForUpdate({ packageName });
@@ -5146,4 +5150,4 @@ export {
   startHqServer,
   HqInsecureExposureError2 as HqInsecureExposureError
 };
-//# sourceMappingURL=chunk-KK2LB3ZS.js.map
+//# sourceMappingURL=chunk-OAVBM55Q.js.map

package/dist/chunk-PZQBGUVZ.js

@@ -0,0 +1,18 @@
+
+// src/boot/ascii-mode.ts
+import { installAsciiOutput, isAsciiMode } from "@wrongstack/core/utils";
+var installed = false;
+function applyAsciiMode(flags, env = process.env, streams = [process.stdout, process.stderr]) {
+  if (flags["ascii"] === true) env["WRONGSTACK_TUI_ICON_STYLE"] = "ascii";
+  if (!isAsciiMode(env)) return false;
+  if (!installed) {
+    installed = true;
+    for (const stream of streams) installAsciiOutput(stream);
+  }
+  return true;
+}
+
+export {
+  applyAsciiMode
+};
+//# sourceMappingURL=chunk-PZQBGUVZ.js.map

package/dist/{chunk-C3Z4N6A6.js → chunk-Q4INH2DG.js}

@@ -20,6 +20,34 @@ var BOOLEAN_FLAGS = /* @__PURE__ */ new Set([
   // Both are boolean so they cannot swallow the next positional token.
   "no-recovery",
   "recover",
+  // `--continue` / `-c`: resume the most recent session (same pick as a bare
+  // `--resume`). Boolean so `wstack -c "next step"` keeps the prompt.
+  "continue",
+  // `--fork-session` (with --resume/--continue/--recover): branch instead of reopening.
+  "fork-session",
+  // `--strict-mcp-config`: start only the `--mcp-config` servers.
+  "strict-mcp-config",
+  // `--include-partial-messages`: add text_delta events to stream-json output.
+  "include-partial-messages",
+  // `--safe-mode`: start with plugins/hooks/MCP/skills/instruction overrides off.
+  "safe-mode",
+  // `--restricted`: no code-running/network tools, project-root lock, no YOLO.
+  "restricted",
+  // `--record` is read as `=== true`; as a value flag it swallowed the task
+  // (`wstack --record "fix it"` recorded nothing and ran nothing).
+  "record",
+  // Same class: switches read only as `=== true` that would otherwise take the
+  // next token (`--vector-sync "task"`, `typesafe lint-conventions --staged x`).
+  "vector-sync",
+  "allow-all",
+  "no-llm",
+  "staged",
+  "sweep",
+  "n",
+  // `wstack import-claude-code` switches.
+  "apply",
+  "overwrite",
+  "enable-project-servers",
   "output-json",
   "metrics",
   "webui",
@@ -28,6 +56,8 @@ var BOOLEAN_FLAGS = /* @__PURE__ */ new Set([
   "full-auto",
   "desktop",
   "open",
+  // `wstack remote --keep`: leave the remote host running after disconnecting.
+  "keep",
   "webui-require-token",
   "require-token",
   "no-check",
@@ -39,6 +69,7 @@ var BOOLEAN_FLAGS = /* @__PURE__ */ new Set([
   "skip",
   "skip-index",
   "mouse",
+  "ascii",
   "no-interactive",
   "token-saving-mode",
   "system-lite",
@@ -139,7 +170,13 @@ function parseArgs(argv) {
       }
     } else if (a.startsWith("-") && a.length === 2) {
       const short = a.slice(1);
-      const expand = { v: "verbose", y: "yes", h: "help" };
+      const expand = {
+        v: "verbose",
+        y: "yes",
+        h: "help",
+        c: "continue",
+        r: "resume"
+      };
       const name = expand[short] ?? short;
       if (!BOOLEAN_FLAGS.has(name) && i + 1 < argv.length && !(argv[i + 1] ?? "").startsWith("-")) {
         flags[name] = argv[++i] ?? "";
@@ -151,6 +188,13 @@ function parseArgs(argv) {
     }
   }
   normalizeSurfaceAliases(flags, positional);
+  for (const [camel, kebab] of [
+    ["disallowedTools", "disallowed-tools"],
+    ["allowedTools", "allowed-tools"]
+  ]) {
+    if (flags[camel] !== void 0 && flags[kebab] === void 0) flags[kebab] = flags[camel];
+    delete flags[camel];
+  }
   return { flags, positional };
 }
 function normalizeSurfaceAliases(flags, positional) {
@@ -185,7 +229,11 @@ function parseAuthFlags(args) {
       key = a.slice(0, eq);
       inlineVal = a.slice(eq + 1);
     }
-    if (key === "--label") {
+    if (key === "--alias") {
+      const next = args[i + 1];
+      const v = inlineVal !== void 0 ? inlineVal : next !== void 0 && !next.startsWith("-") ? args[++i] : "";
+      out.alias = v ?? "";
+    } else if (key === "--label") {
       const v = inlineVal !== void 0 ? inlineVal : args[++i];
       if (v) out.label = v;
     } else if (key === "--family") {
@@ -258,4 +306,4 @@ export {
   parseAuthFlags,
   parseSpawnFlags
 };
-//# sourceMappingURL=chunk-C3Z4N6A6.js.map
+//# sourceMappingURL=chunk-Q4INH2DG.js.map

package/dist/chunk-R4QGL6GB.js

@@ -0,0 +1,10 @@
+
+// src/webui-server/kanban-supervisor.ts
+import {
+  createKanbanSupervisor
+} from "@wrongstack/webui-server";
+
+export {
+  createKanbanSupervisor
+};
+//# sourceMappingURL=chunk-R4QGL6GB.js.map

package/dist/{chunk-YLQEGYV4.js → chunk-RZ4ZDRYA.js}

@@ -1,3 +1,6 @@
+import {
+  CLI_VERSION
+} from "./chunk-F5DCFAKI.js";
 
 // src/update-check.ts
 import * as fs from "node:fs/promises";
@@ -5,7 +8,12 @@ import { createRequire } from "node:module";
 import * as os from "node:os";
 import * as path from "node:path";
 import { FetchError } from "@wrongstack/core/types";
-import { atomicWrite, ensureDir, resolveWstackPaths } from "@wrongstack/core/utils";
+import {
+  atomicWrite,
+  ensureDir,
+  isStandaloneBinary,
+  resolveWstackPaths
+} from "@wrongstack/core/utils";
 var defaultHomeDir = () => os.homedir();
 function npmRegistryUrl(packageName) {
   return `https://registry.npmjs.org/${encodeURIComponent(packageName)}/latest`;
@@ -16,6 +24,7 @@ function cachePath(homeFn = defaultHomeDir) {
 }
 var CACHE_TTL_MS = 24 * 60 * 60 * 1e3;
 function currentVersion() {
+  if (isStandaloneBinary()) return CLI_VERSION;
   const req = createRequire(import.meta.url);
   const candidates = ["../package.json", "../../package.json"];
   for (const rel of candidates) {
@@ -118,7 +127,8 @@ async function checkForUpdate(signalOrOptions, legacyHomeFn) {
   const options = signalOrOptions instanceof AbortSignal ? { signal: signalOrOptions, homeFn: legacyHomeFn } : signalOrOptions ?? { homeFn: legacyHomeFn };
   const current = currentVersion();
   const signal = options.signal;
-  const packageName = options.packageName ?? "wrongstack";
+  const standalone = isStandaloneBinary();
+  const packageName = standalone ? "standalone-binary" : options.packageName ?? "wrongstack";
   const aborted = () => signal?.aborted ?? false;
   const hf = options.homeFn ?? defaultHomeDir;
   if (aborted()) {
@@ -134,7 +144,7 @@ async function checkForUpdate(signalOrOptions, legacyHomeFn) {
     };
   }
   try {
-    const latest = await fetchLatestFromNpm(packageName, 3e3, signal);
+    const latest = packageName === "standalone-binary" ? await (await import("./standalone-update-LZO3MNLH.js")).fetchLatestStandaloneVersion(3e3, signal) : await fetchLatestFromNpm(packageName, 3e3, signal);
     await writeCache({ timestamp: Date.now(), latestVersion: latest, packageName }, hf);
     return {
       current,
@@ -173,4 +183,4 @@ export {
   checkForUpdate,
   getUpdateNotification
 };
-//# sourceMappingURL=chunk-YLQEGYV4.js.map
+//# sourceMappingURL=chunk-RZ4ZDRYA.js.map

package/dist/chunk-S4FFHDJG.js

@@ -0,0 +1,93 @@
+
+// src/wiring/provider-runtime.ts
+import {
+  getProxyConfig,
+  isProxyEligible,
+  rewriteBaseUrl,
+  sanitizeUrlForLog,
+  shouldRewriteFor
+} from "@wrongstack/core/wiring/proxy-rewrite";
+import { makeProviderFromConfig } from "@wrongstack/providers";
+function resolveRawProviderConnection(config, providerId) {
+  const savedCfg = config.providers?.[providerId];
+  const isAccountAlias = savedCfg?.type !== void 0 && savedCfg.type !== providerId;
+  const inheritsPrimary = !isAccountAlias && (config.provider === void 0 || config.provider === providerId);
+  return {
+    apiKey: savedCfg?.apiKey ?? (inheritsPrimary ? config.apiKey : void 0),
+    baseUrl: savedCfg?.baseUrl ?? (inheritsPrimary ? config.baseUrl : void 0)
+  };
+}
+function resolveProviderCfg(config, providerId, opts) {
+  const savedCfg = config.providers?.[providerId];
+  const proxyProviderType = savedCfg?.family === "openai-codex" ? "openai-codex" : savedCfg?.type ?? providerId;
+  const connection = resolveRawProviderConnection(config, providerId);
+  const rawBaseUrl = connection.baseUrl;
+  let rewriteReason = "no-base-url";
+  let baseUrl = rawBaseUrl;
+  if (rawBaseUrl && shouldRewriteFor(proxyProviderType)) {
+    const rewritten = rewriteBaseUrl(rawBaseUrl, currentProxyBaseUrl());
+    if (rewritten !== rawBaseUrl) {
+      rewriteReason = "applied";
+      baseUrl = rewritten;
+    } else {
+      rewriteReason = passthroughReason(rawBaseUrl);
+    }
+  } else if (rawBaseUrl) {
+    rewriteReason = proxySkipReason(proxyProviderType);
+  }
+  opts?.logger?.info(
+    `WrongProxy rewrite ${rewriteReason} for provider '${providerId}': ${sanitizeUrlForLog(rawBaseUrl) || "<none>"} -> ${sanitizeUrlForLog(baseUrl) || "<none>"}`
+  );
+  const cfg = {
+    ...savedCfg,
+    apiKey: connection.apiKey,
+    baseUrl,
+    type: providerId
+  };
+  const factoryType = savedCfg?.type ?? providerId;
+  return { cfg, factoryType };
+}
+function passthroughReason(rawBaseUrl) {
+  if (!rawBaseUrl.includes("://")) return "no-scheme";
+  const proxyRoot = currentProxyBaseUrl().replace(/\/+$/, "");
+  if (proxyRoot && rawBaseUrl.startsWith(`${proxyRoot}/proxy/`)) {
+    return "already-rewritten";
+  }
+  try {
+    const parsed = new URL(rawBaseUrl);
+    const host = parsed.hostname;
+    const isLoopback = host === "localhost" || host === "127.0.0.1" || host === "[::1]";
+    if (isLoopback && parsed.port !== "") return "loopback";
+  } catch {
+  }
+  return "ineligible";
+}
+function proxySkipReason(providerId) {
+  const cfg = getProxyConfig();
+  if (!cfg.enabled) return "disabled";
+  if (!cfg.url) return "no-proxy-url";
+  if (!cfg.active) return "inactive";
+  if (!isProxyEligible(providerId)) return "excluded";
+  return "unknown";
+}
+function currentProxyBaseUrl() {
+  return getProxyConfig().url;
+}
+function resolveProviderCfgWithProxy(config, providerId, opts) {
+  return resolveProviderCfg(config, providerId, opts);
+}
+function buildProviderForId(args, providerId) {
+  const { cfg, factoryType } = resolveProviderCfg(args.config, providerId, {
+    logger: args.logger
+  });
+  const useRegistry = !!args.config.features.modelsRegistry && args.providerRegistry.has(factoryType);
+  return useRegistry ? args.providerRegistry.create(cfg, factoryType) : makeProviderFromConfig(providerId, { ...cfg, type: factoryType });
+}
+
+export {
+  resolveRawProviderConnection,
+  resolveProviderCfg,
+  resolveProviderCfgWithProxy,
+  buildProviderForId
+};
+//# sourceMappingURL=chunk-S4FFHDJG.js.map