steward-cli 0.22.0 → 0.23.0

package/dist/cli.js

@@ -43610,6 +43610,7 @@ async function startOAuthCallbackServer(options) {
   let settled = false;
   let resolvePromise;
   let rejectPromise;
+  let abortHandler;
   const promise = new Promise((res, rej) => {
     resolvePromise = res;
     rejectPromise = rej;
@@ -43619,7 +43620,11 @@ async function startOAuthCallbackServer(options) {
       const s = server;
       server = null;
       await new Promise((res) => {
-        s.close(() => res());
+        try {
+          s.close(() => res());
+        } catch {
+          res();
+        }
       });
     }
   };
@@ -43628,6 +43633,9 @@ async function startOAuthCallbackServer(options) {
       return;
     settled = true;
     clearTimeout(timer);
+    if (signal && abortHandler) {
+      signal.removeEventListener("abort", abortHandler);
+    }
     await closeServer();
     if (error) {
       rejectPromise(error);
@@ -43643,9 +43651,10 @@ async function startOAuthCallbackServer(options) {
       clearTimeout(timer);
       throw new AIError("OAuth login was cancelled.", { code: "aborted" });
     }
-    signal.addEventListener("abort", () => {
+    abortHandler = () => {
       finish(undefined, new AIError("OAuth login was cancelled.", { code: "aborted" }));
-    });
+    };
+    signal.addEventListener("abort", abortHandler, { once: true });
   }
   server = http.createServer((req, res) => {
     try {
@@ -43694,32 +43703,43 @@ async function startOAuthCallbackServer(options) {
       }));
     }
   });
-  await new Promise((resolve, reject) => {
-    server.on("error", (err) => {
-      clearTimeout(timer);
-      if (err.code === "EADDRINUSE") {
-        reject(new AIError(`Port ${port} is already in use. Cannot start OAuth callback server.`, {
-          code: "oauth",
-          cause: err
-        }));
-      } else {
-        reject(new AIError(`Failed to bind OAuth callback server: ${err.message}`, {
-          code: "oauth",
-          cause: err
-        }));
-      }
-    });
-    server.listen(port, host, () => {
-      resolve();
+  try {
+    await new Promise((resolve, reject) => {
+      server.on("error", async (err) => {
+        clearTimeout(timer);
+        if (signal && abortHandler) {
+          signal.removeEventListener("abort", abortHandler);
+        }
+        await closeServer();
+        if (err.code === "EADDRINUSE") {
+          reject(new AIError(`Port ${port} is already in use. Cannot start OAuth callback server.`, {
+            code: "oauth",
+            cause: err
+          }));
+        } else {
+          reject(new AIError(`Failed to bind OAuth callback server: ${err.message}`, {
+            code: "oauth",
+            cause: err
+          }));
+        }
+      });
+      server.listen(port, host, () => {
+        resolve();
+      });
     });
-  });
+  } catch (listenErr) {
+    await closeServer();
+    throw listenErr;
+  }
   return {
     redirectUri,
     wait: () => promise,
     cancel: () => {
       finish(undefined, new AIError("OAuth callback cancelled.", { code: "aborted" }));
     },
-    close: closeServer
+    close: async () => {
+      await finish(undefined, new AIError("OAuth callback server closed.", { code: "aborted" }));
+    }
   };
 }
 
@@ -43774,8 +43794,7 @@ async function exchangeAuthorizationCode(code, state, verifier, signal) {
     signal
   });
   if (!response.ok) {
-    const errText = await response.text().catch(() => "");
-    throw new AIError(`Anthropic OAuth token exchange failed (HTTP ${response.status}): ${errText}`, {
+    throw new AIError(`Anthropic OAuth token exchange failed with HTTP status ${response.status}`, {
       code: "oauth",
       provider: "anthropic",
       status: response.status
@@ -43878,8 +43897,7 @@ async function refreshAnthropic(credential, signal) {
     signal
   });
   if (!response.ok) {
-    const errText = await response.text().catch(() => "");
-    throw new AIError(`Anthropic OAuth token refresh failed (HTTP ${response.status}): ${errText}`, {
+    throw new AIError(`Anthropic OAuth token refresh failed with HTTP status ${response.status}`, {
       code: "oauth",
       provider: "anthropic",
       status: response.status
@@ -43939,8 +43957,7 @@ async function exchangeAuthorizationCode2(code, verifier, signal) {
     signal
   });
   if (!response.ok) {
-    const errText = await response.text().catch(() => "");
-    throw new AIError(`OpenRouter OAuth key exchange failed (HTTP ${response.status}): ${errText}`, {
+    throw new AIError(`OpenRouter OAuth key exchange failed with HTTP status ${response.status}`, {
       code: "oauth",
       provider: "openrouter",
       status: response.status
@@ -44040,14 +44057,16 @@ var SLOW_DOWN_INCREMENT_MS = 5000;
 function abortableSleep(ms, signal) {
   return new Promise((resolve, reject) => {
     if (signal.aborted) {
-      reject(new Error("Login cancelled"));
+      reject(new AIError("Login cancelled", { code: "aborted" }));
       return;
     }
+    let timeout;
     const onAbort = () => {
-      clearTimeout(timeout);
-      reject(new Error("Login cancelled"));
+      if (timeout)
+        clearTimeout(timeout);
+      reject(new AIError("Login cancelled", { code: "aborted" }));
     };
-    const timeout = setTimeout(() => {
+    timeout = setTimeout(() => {
       signal.removeEventListener("abort", onAbort);
       resolve();
     }, ms);
@@ -44065,14 +44084,14 @@ async function pollOAuthDeviceCodeFlow(options) {
   }
   while (Date.now() < deadline) {
     if (options.signal.aborted) {
-      throw new Error("Login cancelled");
+      throw new AIError("Login cancelled", { code: "aborted" });
     }
     const result = await options.poll();
     if (result.status === "complete") {
       return result.value;
     }
     if (result.status === "failed") {
-      throw new Error(result.message);
+      throw new AIError(result.message, { code: "oauth" });
     }
     if (result.status === "slow_down") {
       intervalMs = typeof result.intervalSeconds === "number" && result.intervalSeconds > 0 ? Math.max(MINIMUM_INTERVAL_MS, Math.floor(result.intervalSeconds * 1000)) : Math.max(MINIMUM_INTERVAL_MS, intervalMs + SLOW_DOWN_INCREMENT_MS);
@@ -44082,7 +44101,7 @@ async function pollOAuthDeviceCodeFlow(options) {
       break;
     await abortableSleep(Math.min(intervalMs, remaining), options.signal);
   }
-  throw new Error("Device authorization flow timed out.");
+  throw new AIError("Device authorization flow timed out.", { code: "oauth" });
 }
 
 // src/packages/ai/src/auth/oauth/github-copilot.ts
@@ -44203,8 +44222,7 @@ async function refreshGitHubCopilotToken(githubAccessToken, signal) {
     });
   }
   if (!res.ok) {
-    const text = await res.text().catch(() => "");
-    throw new AIError(`GitHub Copilot token exchange failed (HTTP ${res.status}): ${text}`, {
+    throw new AIError(`GitHub Copilot token exchange failed with HTTP status ${res.status}`, {
       code: "oauth",
       provider: "github-copilot",
       status: res.status
@@ -44239,6 +44257,23 @@ function toGitHubCopilotAuth(credential) {
 }
 
 // src/packages/ai/src/auth/resolver.ts
+var OAUTH_ADAPTERS = {
+  anthropic: {
+    login: loginAnthropic,
+    refresh: refreshAnthropic,
+    toResolvedAuth: toAnthropicAuth
+  },
+  openrouter: {
+    login: loginOpenRouter,
+    refresh: refreshOpenRouter,
+    toResolvedAuth: toOpenRouterAuth
+  },
+  "github-copilot": {
+    login: loginGitHubCopilot,
+    refresh: refreshGitHubCopilot,
+    toResolvedAuth: toGitHubCopilotAuth
+  }
+};
 var DEFAULT_REFRESH_MARGIN_MS = 5 * 60 * 1000;
 
 class AuthResolver {
@@ -44286,32 +44321,21 @@ class AuthResolver {
     return;
   }
   async performRefresh(provider, credential, signal) {
-    if (provider === "anthropic") {
-      return await refreshAnthropic(credential, signal);
-    }
-    if (provider === "openrouter") {
-      return await refreshOpenRouter(credential, signal);
-    }
-    if (provider === "github-copilot") {
-      return await refreshGitHubCopilot(credential, signal);
+    const adapter = OAUTH_ADAPTERS[provider];
+    if (adapter) {
+      return await adapter.refresh(credential, signal);
     }
     return credential;
   }
   formatOAuth(provider, credential) {
-    if (provider === "anthropic") {
-      return toAnthropicAuth(credential);
-    }
-    if (provider === "openrouter") {
-      return toOpenRouterAuth(credential);
-    }
-    if (provider === "github-copilot") {
-      return toGitHubCopilotAuth(credential);
+    const adapter = OAUTH_ADAPTERS[provider];
+    if (adapter) {
+      return adapter.toResolvedAuth(credential);
     }
-    return {
-      type: "oauth",
-      token: credential.accessToken,
-      source: "oauth"
-    };
+    throw new AIError(`Unsupported OAuth provider: "${provider}"`, {
+      code: "oauth",
+      provider
+    });
   }
 }
 
@@ -44319,35 +44343,96 @@ class AuthResolver {
 import * as fs from "node:fs/promises";
 import * as path from "node:path";
 import * as os2 from "node:os";
+var fileMutexes = new Map;
+function validateAuthStorage(data) {
+  if (!data || typeof data !== "object" || Array.isArray(data)) {
+    return false;
+  }
+  const root = data;
+  if (root.version !== 1) {
+    return false;
+  }
+  if (!root.credentials || typeof root.credentials !== "object" || Array.isArray(root.credentials)) {
+    return false;
+  }
+  const credentials = root.credentials;
+  for (const [_, cred] of Object.entries(credentials)) {
+    if (!cred || typeof cred !== "object" || Array.isArray(cred)) {
+      return false;
+    }
+    const c = cred;
+    if (c.type !== "oauth") {
+      return false;
+    }
+    if (typeof c.accessToken !== "string") {
+      return false;
+    }
+    if (c.refreshToken !== undefined && c.refreshToken !== null && typeof c.refreshToken !== "string") {
+      return false;
+    }
+    if (c.expiresAt !== undefined && c.expiresAt !== null && typeof c.expiresAt !== "number") {
+      return false;
+    }
+  }
+  return true;
+}
+
 class FileCredentialStore {
   dirPath;
   filePath;
-  mutex = Promise.resolve();
+  canonicalPath;
   constructor(options) {
     this.dirPath = options?.storageDir ?? path.join(os2.homedir(), ".steward");
     this.filePath = options?.filePath ?? path.join(this.dirPath, "auth.json");
+    this.canonicalPath = path.resolve(this.filePath);
   }
   async ensureDirectory() {
     try {
       await fs.mkdir(this.dirPath, { recursive: true, mode: 448 });
       await fs.chmod(this.dirPath, 448).catch(() => {});
-    } catch {}
+    } catch (err) {
+      const isExist = err?.code === "EEXIST";
+      if (!isExist) {
+        throw new AIError(`Failed to create directory "${this.dirPath}": ${err instanceof Error ? err.message : String(err)}`, {
+          code: "auth",
+          cause: err
+        });
+      }
+    }
   }
   async loadData() {
     try {
       const content = await fs.readFile(this.filePath, "utf-8");
-      const parsed = JSON.parse(content);
-      if (!parsed || typeof parsed !== "object" || parsed.version !== 1 || !parsed.credentials) {
+      let parsed;
+      try {
+        parsed = JSON.parse(content);
+      } catch (jsonErr) {
+        throw new AIError("Invalid or corrupt auth.json schema.", {
+          code: "auth",
+          cause: jsonErr
+        });
+      }
+      if (!validateAuthStorage(parsed)) {
         throw new AIError("Invalid or corrupt auth.json schema.", { code: "auth" });
       }
+      for (const cred of Object.values(parsed.credentials)) {
+        if (cred) {
+          if (cred.expiresAt === null) {
+            delete cred.expiresAt;
+          }
+          if (cred.refreshToken === null) {
+            delete cred.refreshToken;
+          }
+        }
+      }
       return parsed;
     } catch (err) {
-      if (err.code === "ENOENT") {
+      if (err?.code === "ENOENT") {
         return { version: 1, credentials: {} };
       }
       if (err instanceof AIError)
         throw err;
-      throw new AIError(`Failed to read auth store: ${err.message}`, {
+      throw new AIError(`Failed to read auth store: ${err instanceof Error ? err.message : String(err)}`, {
         code: "auth",
         cause: err
       });
@@ -44364,7 +44449,7 @@ class FileCredentialStore {
       await fs.chmod(this.filePath, 384).catch(() => {});
     } catch (err) {
       await fs.unlink(tempFile).catch(() => {});
-      throw new AIError(`Failed to atomically save auth store: ${err.message}`, {
+      throw new AIError(`Failed to atomically save auth store: ${err instanceof Error ? err.message : String(err)}`, {
         code: "auth",
         cause: err
       });
@@ -44389,24 +44474,21 @@ class FileCredentialStore {
     return list;
   }
   async modify(provider, fn) {
-    return new Promise((resolve, reject) => {
-      this.mutex = this.mutex.then(async () => {
-        try {
-          const data = await this.loadData();
-          const current = data.credentials[provider];
-          const updated = await fn(current);
-          if (updated) {
-            data.credentials[provider] = updated;
-          } else {
-            delete data.credentials[provider];
-          }
-          await this.saveData(data);
-          resolve(updated);
-        } catch (err) {
-          reject(err);
-        }
-      });
+    const currentMutex = fileMutexes.get(this.canonicalPath) ?? Promise.resolve();
+    const nextMutex = currentMutex.then(async () => {
+      const data = await this.loadData();
+      const current = data.credentials[provider];
+      const updated = await fn(current);
+      if (updated) {
+        data.credentials[provider] = updated;
+      } else {
+        delete data.credentials[provider];
+      }
+      await this.saveData(data);
+      return updated;
     });
+    fileMutexes.set(this.canonicalPath, nextMutex.catch(() => {}));
+    return await nextMutex;
   }
   async delete(provider) {
     await this.modify(provider, async () => {
@@ -44465,19 +44547,14 @@ class DefaultAuthManager {
     return await this.resolver.resolve(provider, signal);
   }
   async login(provider, interaction) {
-    let credential;
-    if (provider === "anthropic") {
-      credential = await loginAnthropic(interaction);
-    } else if (provider === "openrouter") {
-      credential = await loginOpenRouter(interaction);
-    } else if (provider === "github-copilot") {
-      credential = await loginGitHubCopilot(interaction);
-    } else {
+    const adapter = OAUTH_ADAPTERS[provider];
+    if (!adapter) {
       throw new AIError(`No browser OAuth login is available for "${provider}".`, {
         code: "oauth",
         provider
       });
     }
+    const credential = await adapter.login(interaction);
     await this.store.modify(provider, async () => credential);
     return credential;
   }
@@ -44606,6 +44683,13 @@ var PROVIDER_REGISTRY = {
     envVar: "CUSTOM_API_URL / CUSTOM_API_KEY"
   }
 };
+function getProviderDescriptor(provider) {
+  const descriptor = PROVIDER_REGISTRY[provider];
+  if (!descriptor) {
+    throw new Error(`Unsupported provider: "${provider}"`);
+  }
+  return descriptor;
+}
 
 // src/packages/ai/src/models/selection.ts
 var CANONICAL_DEFAULT_EFFORT = "medium";
@@ -44623,26 +44707,36 @@ var PROVIDER_SELECTION_PRIORITY = [
   "custom"
 ];
 function inferProviderFromModelId(modelId) {
-  const lower = modelId.toLowerCase();
-  if (/^[a-z0-9-_.]+\/[a-z0-9-_.]+$/.test(lower))
+  const lower = modelId.trim().toLowerCase();
+  if (!lower)
+    return null;
+  if (/^[a-z0-9-_.]+\/[a-z0-9-_.]+$/.test(lower)) {
     return "openrouter";
-  if (lower.startsWith("copilot/") || lower.startsWith("github-copilot/"))
+  }
+  if (lower.startsWith("copilot/") || lower.startsWith("github-copilot/")) {
     return "github-copilot";
-  if (lower.startsWith("gemini-") || lower.startsWith("gemma-"))
+  }
+  if (lower.startsWith("gemini-") || lower.startsWith("gemma-")) {
     return "gemini";
-  if (lower.startsWith("claude-"))
+  }
+  if (lower.startsWith("claude-")) {
     return "anthropic";
-  if (lower.startsWith("gpt-") || lower.startsWith("o1") || lower.startsWith("o3") || lower.startsWith("chatgpt-")) {
+  }
+  if (lower.startsWith("gpt-") || lower.startsWith("chatgpt-") || /^o[1-9]($|-)/.test(lower)) {
     return "openai";
   }
-  if (lower.startsWith("deepseek-"))
+  if (lower.startsWith("deepseek-")) {
     return "deepseek";
-  if (lower.startsWith("grok-"))
+  }
+  if (lower.startsWith("grok-")) {
     return "xai";
-  if (lower.startsWith("codestral") || lower.startsWith("mistral") || lower.startsWith("pixtral") || lower.startsWith("ministral"))
+  }
+  if (lower.startsWith("codestral") || lower.startsWith("mistral") || lower.startsWith("pixtral") || lower.startsWith("ministral")) {
     return "mistral";
-  if (lower.includes(":latest") || lower.startsWith("ollama/"))
+  }
+  if (lower.startsWith("ollama/") || /^[a-z0-9_.-]+:[a-z0-9_.-]+$/.test(lower)) {
     return "ollama";
+  }
   return null;
 }
 async function resolveModelSelection(requested, context) {
@@ -44807,6 +44901,9 @@ function parseSSEEvent(raw) {
 }
 
 // src/packages/ai/src/json.ts
+function sanitizeSurrogates(text) {
+  return text.replace(/[\uD800-\uDBFF](?![\uDC00-\uDFFF])|(?<![\uD800-\uDBFF])[\uDC00-\uDFFF]/g, "");
+}
 function parseStreamingJson(partial) {
   const trimmed = partial.trim();
   if (!trimmed) {
@@ -44876,82 +44973,78 @@ function parseStreamingJson(partial) {
 }
 
 // src/packages/ai/src/providers/openai-compatible.ts
+var STATIC_PROFILES = {
+  openrouter: {
+    provider: "openrouter",
+    baseUrl: "https://openrouter.ai/api/v1",
+    supportsReasoning: true,
+    reasoningFormat: "openrouter",
+    apiPath: "/chat/completions",
+    requiresApiKey: true
+  },
+  deepseek: {
+    provider: "deepseek",
+    baseUrl: "https://api.deepseek.com",
+    supportsReasoning: true,
+    reasoningFormat: "deepseek",
+    apiPath: "/chat/completions",
+    requiresApiKey: true
+  },
+  "github-copilot": {
+    provider: "github-copilot",
+    baseUrl: "https://api.individual.githubcopilot.com",
+    supportsReasoning: true,
+    reasoningFormat: "openai",
+    apiPath: "/chat/completions",
+    requiresApiKey: true
+  },
+  groq: {
+    provider: "groq",
+    baseUrl: "https://api.groq.com/openai/v1",
+    supportsReasoning: true,
+    reasoningFormat: "deepseek",
+    apiPath: "/chat/completions",
+    requiresApiKey: true
+  },
+  xai: {
+    provider: "xai",
+    baseUrl: "https://api.x.ai/v1",
+    supportsReasoning: true,
+    reasoningFormat: "openai",
+    apiPath: "/chat/completions",
+    requiresApiKey: true
+  },
+  mistral: {
+    provider: "mistral",
+    baseUrl: "https://api.mistral.ai/v1",
+    supportsReasoning: false,
+    reasoningFormat: "none",
+    apiPath: "/chat/completions",
+    requiresApiKey: true
+  }
+};
 function getProfile(provider, customBaseUrl) {
-  switch (provider) {
-    case "openrouter":
-      return {
-        provider: "openrouter",
-        baseUrl: "https://openrouter.ai/api/v1",
-        supportsReasoning: true,
-        reasoningFormat: "openrouter",
-        apiPath: "/chat/completions",
-        requiresApiKey: true
-      };
-    case "deepseek":
-      return {
-        provider: "deepseek",
-        baseUrl: "https://api.deepseek.com",
-        supportsReasoning: true,
-        reasoningFormat: "deepseek",
-        apiPath: "/chat/completions",
-        requiresApiKey: true
-      };
-    case "github-copilot":
-      return {
-        provider: "github-copilot",
-        baseUrl: "https://api.individual.githubcopilot.com",
-        supportsReasoning: true,
-        reasoningFormat: "openai",
-        apiPath: "/chat/completions",
-        requiresApiKey: true
-      };
-    case "groq":
-      return {
-        provider: "groq",
-        baseUrl: "https://api.groq.com/openai/v1",
-        supportsReasoning: true,
-        reasoningFormat: "deepseek",
-        apiPath: "/chat/completions",
-        requiresApiKey: true
-      };
-    case "xai":
-      return {
-        provider: "xai",
-        baseUrl: "https://api.x.ai/v1",
-        supportsReasoning: true,
-        reasoningFormat: "openai",
-        apiPath: "/chat/completions",
-        requiresApiKey: true
-      };
-    case "mistral":
-      return {
-        provider: "mistral",
-        baseUrl: "https://api.mistral.ai/v1",
-        supportsReasoning: false,
-        reasoningFormat: "none",
-        apiPath: "/chat/completions",
-        requiresApiKey: true
-      };
-    case "ollama":
-      return {
-        provider: "ollama",
-        baseUrl: customBaseUrl || process.env.OLLAMA_BASE_URL || "http://localhost:11434/v1",
-        supportsReasoning: true,
-        reasoningFormat: "deepseek",
-        apiPath: "/chat/completions",
-        requiresApiKey: false
-      };
-    case "custom":
-    default:
-      return {
-        provider: "custom",
-        baseUrl: customBaseUrl || process.env.CUSTOM_API_URL || "http://localhost:11434/v1",
-        supportsReasoning: true,
-        reasoningFormat: "openai",
-        apiPath: "/chat/completions",
-        requiresApiKey: false
-      };
+  if (provider in STATIC_PROFILES) {
+    return STATIC_PROFILES[provider];
   }
+  if (provider === "ollama") {
+    return {
+      provider: "ollama",
+      baseUrl: customBaseUrl || process.env.OLLAMA_BASE_URL || "http://localhost:11434/v1",
+      supportsReasoning: true,
+      reasoningFormat: "deepseek",
+      apiPath: "/chat/completions",
+      requiresApiKey: false
+    };
+  }
+  return {
+    provider: "custom",
+    baseUrl: customBaseUrl || process.env.CUSTOM_API_URL || "http://localhost:11434/v1",
+    supportsReasoning: true,
+    reasoningFormat: "openai",
+    apiPath: "/chat/completions",
+    requiresApiKey: false
+  };
 }
 function mapEffort(effort, format) {
   if (effort === "none")
@@ -44974,13 +45067,13 @@ function convertMessages(messages) {
   const converted = [];
   for (const msg of messages) {
     if (msg.role === "system") {
-      converted.push({ role: "system", content: msg.content });
+      converted.push({ role: "system", content: sanitizeSurrogates(msg.content) });
       continue;
     }
     if (msg.role === "user") {
       const text = typeof msg.content === "string" ? msg.content : msg.content.map((c) => c.text).join(`
 `);
-      converted.push({ role: "user", content: text });
+      converted.push({ role: "user", content: sanitizeSurrogates(text) });
       continue;
     }
     if (msg.role === "assistant") {
@@ -45005,9 +45098,9 @@ function convertMessages(messages) {
       }
       const item = { role: "assistant" };
       if (text)
-        item.content = text;
+        item.content = sanitizeSurrogates(text);
       if (reasoning_content)
-        item.reasoning_content = reasoning_content;
+        item.reasoning_content = sanitizeSurrogates(reasoning_content);
       if (tool_calls.length > 0)
         item.tool_calls = tool_calls;
       converted.push(item);
@@ -45015,10 +45108,11 @@ function convertMessages(messages) {
     }
     if (msg.role === "tool") {
       for (const res of msg.content) {
+        const outStr = typeof res.output === "string" ? res.output : JSON.stringify(res.output);
         converted.push({
           role: "tool",
           tool_call_id: res.toolCallId,
-          content: typeof res.output === "string" ? res.output : JSON.stringify(res.output)
+          content: sanitizeSurrogates(outStr)
         });
       }
     }
@@ -45074,7 +45168,7 @@ function streamOpenAICompatible(options) {
       });
     } catch (err) {
       const isAbort = request.abortSignal?.aborted;
-      const error = new AIError(isAbort ? "Inference request aborted." : `Network request to ${profile.provider} failed: ${err.message}`, {
+      const error = new AIError(isAbort ? "Inference request aborted." : `Network request to ${profile.provider} failed: ${err instanceof Error ? err.message : String(err)}`, {
         code: isAbort ? "aborted" : "network",
         provider: request.model.provider,
         cause: err
@@ -45084,10 +45178,9 @@ function streamOpenAICompatible(options) {
       return;
     }
     if (!response.ok) {
-      const errBody = await response.text().catch(() => "");
       const isRateLimit = response.status === 429;
       const isAuth = response.status === 401 || response.status === 403;
-      const error = new AIError(`${profile.provider} error (HTTP ${response.status}): ${errBody}`, {
+      const error = new AIError(`${profile.provider} request failed with HTTP status ${response.status}`, {
         code: isAuth ? auth?.type === "oauth" ? "oauth" : "auth" : isRateLimit ? "rate-limit" : "provider",
         provider: request.model.provider,
         status: response.status
@@ -45105,8 +45198,7 @@ function streamOpenAICompatible(options) {
       yield { type: "error", error };
       return;
     }
-    let textContent = "";
-    let reasoningContent = "";
+    const assistantContent = [];
     const toolCallBuffers = new Map;
     const usage = {
       inputTokens: 0,
@@ -45124,19 +45216,24 @@ function streamOpenAICompatible(options) {
         } catch {
           continue;
         }
-        if (eventData.usage) {
+        if (eventData.usage && typeof eventData.usage === "object") {
           const u = eventData.usage;
-          usage.inputTokens = u.prompt_tokens ?? usage.inputTokens;
-          usage.outputTokens = u.completion_tokens ?? usage.outputTokens;
-          usage.totalTokens = u.total_tokens ?? usage.totalTokens;
-          if (u.completion_tokens_details?.reasoning_tokens) {
-            usage.reasoningTokens = u.completion_tokens_details.reasoning_tokens;
+          if (typeof u.prompt_tokens === "number")
+            usage.inputTokens = u.prompt_tokens;
+          if (typeof u.completion_tokens === "number")
+            usage.outputTokens = u.completion_tokens;
+          if (typeof u.total_tokens === "number")
+            usage.totalTokens = u.total_tokens;
+          const details = u.completion_tokens_details;
+          if (typeof details?.reasoning_tokens === "number") {
+            usage.reasoningTokens = details.reasoning_tokens;
           }
         }
-        const choice = eventData.choices?.[0];
+        const choices = eventData.choices;
+        const choice = choices?.[0];
         if (!choice)
           continue;
-        if (choice.finish_reason) {
+        if (choice.finish_reason && typeof choice.finish_reason === "string") {
           const fr = choice.finish_reason;
           if (fr === "stop")
             finishReason = "stop";
@@ -45148,70 +45245,86 @@ function streamOpenAICompatible(options) {
         const delta = choice.delta;
         if (!delta)
           continue;
-        const reasoningDelta = delta.reasoning_content || delta.reasoning || delta.reasoning_text || delta.reasoning_details?.text;
+        const reasoningDetails = delta.reasoning_details;
+        const reasoningDelta = typeof delta.reasoning_content === "string" && delta.reasoning_content || typeof delta.reasoning === "string" && delta.reasoning || typeof delta.reasoning_text === "string" && delta.reasoning_text || typeof reasoningDetails?.text === "string" && reasoningDetails.text || "";
         if (reasoningDelta) {
-          reasoningContent += reasoningDelta;
+          const lastBlock = assistantContent[assistantContent.length - 1];
+          if (lastBlock && lastBlock.type === "thinking") {
+            lastBlock.thinking += reasoningDelta;
+          } else {
+            assistantContent.push({
+              type: "thinking",
+              thinking: reasoningDelta
+            });
+          }
           yield { type: "reasoning-delta", delta: reasoningDelta };
         }
-        if (delta.content) {
-          textContent += delta.content;
-          yield { type: "text-delta", delta: delta.content };
+        if (typeof delta.content === "string" && delta.content) {
+          const textDelta = delta.content;
+          const lastBlock = assistantContent[assistantContent.length - 1];
+          if (lastBlock && lastBlock.type === "text") {
+            lastBlock.text += textDelta;
+          } else {
+            assistantContent.push({
+              type: "text",
+              text: textDelta
+            });
+          }
+          yield { type: "text-delta", delta: textDelta };
         }
-        if (delta.tool_calls && Array.isArray(delta.tool_calls)) {
+        if (Array.isArray(delta.tool_calls)) {
           for (const tc of delta.tool_calls) {
-            const idx = tc.index ?? 0;
-            let buffer = toolCallBuffers.get(idx);
-            if (!buffer) {
-              buffer = {
-                id: tc.id || `call_${Date.now()}_${idx}`,
-                name: tc.function?.name || "",
+            const idx = typeof tc.index === "number" ? tc.index : 0;
+            const fn = tc.function;
+            const tcId = typeof tc.id === "string" ? tc.id : undefined;
+            const fnName = typeof fn?.name === "string" ? fn.name : undefined;
+            const fnArgs = typeof fn?.arguments === "string" ? fn.arguments : undefined;
+            let entry = toolCallBuffers.get(idx);
+            if (!entry) {
+              const buffer = {
+                id: tcId || `call_${idx}`,
+                name: fnName || "",
                 rawArgs: ""
               };
-              toolCallBuffers.set(idx, buffer);
+              const slot = {
+                type: "tool-call",
+                id: buffer.id,
+                name: buffer.name,
+                arguments: {}
+              };
+              assistantContent.push(slot);
+              entry = { buffer, slot };
+              toolCallBuffers.set(idx, entry);
               if (buffer.name) {
                 yield { type: "tool-call-start", id: buffer.id, name: buffer.name };
               }
             } else {
-              if (!buffer.name && tc.function?.name) {
-                buffer.name = tc.function.name;
-                yield { type: "tool-call-start", id: buffer.id, name: buffer.name };
+              if (tcId && entry.buffer.id !== tcId) {
+                entry.buffer.id = tcId;
+                entry.slot.id = tcId;
+              }
+              if (!entry.buffer.name && fnName) {
+                entry.buffer.name = fnName;
+                entry.slot.name = fnName;
+                yield { type: "tool-call-start", id: entry.buffer.id, name: entry.buffer.name };
               }
             }
-            if (tc.function?.arguments) {
-              buffer.rawArgs += tc.function.arguments;
+            if (fnArgs) {
+              entry.buffer.rawArgs += fnArgs;
               yield {
                 type: "tool-call-delta",
-                id: buffer.id,
-                delta: tc.function.arguments
+                id: entry.buffer.id,
+                delta: fnArgs
               };
             }
           }
         }
       }
-      const assistantContent = [];
-      if (reasoningContent) {
-        assistantContent.push({
-          type: "thinking",
-          thinking: reasoningContent
-        });
-      }
-      if (textContent) {
-        assistantContent.push({
-          type: "text",
-          text: textContent
-        });
-      }
-      for (const [_, buffer] of toolCallBuffers.entries()) {
-        const parsedArgs = parseStreamingJson(buffer.rawArgs);
-        const toolCall = {
-          type: "tool-call",
-          id: buffer.id,
-          name: buffer.name,
-          arguments: parsedArgs
-        };
-        assistantContent.push(toolCall);
+      for (const entry of toolCallBuffers.values()) {
+        const parsedArgs = parseStreamingJson(entry.buffer.rawArgs);
+        entry.slot.arguments = parsedArgs;
         finishReason = "tool-use";
-        yield { type: "tool-call-end", toolCall };
+        yield { type: "tool-call-end", toolCall: entry.slot };
       }
       usage.totalTokens = usage.totalTokens || usage.inputTokens + usage.outputTokens;
       const finalMessage = {
@@ -45231,7 +45344,7 @@ function streamOpenAICompatible(options) {
       };
     } catch (err) {
       const isAbort = request.abortSignal?.aborted;
-      const error = new AIError(isAbort ? "Inference request aborted." : `${profile.provider} stream reading failed: ${err.message}`, {
+      const error = new AIError(isAbort ? "Inference request aborted." : `${profile.provider} stream reading failed: ${err instanceof Error ? err.message : String(err)}`, {
         code: isAbort ? "aborted" : "provider",
         provider: request.model.provider,
         cause: err
@@ -45265,7 +45378,7 @@ function streamOpenAI(options) {
     request,
     auth,
     profile: {
-      provider: "custom",
+      provider: "openai",
       baseUrl: "https://api.openai.com/v1",
       supportsReasoning: true,
       reasoningFormat: "openai",
@@ -45302,11 +45415,11 @@ ${msg.content}` : msg.content;
     }
     if (msg.role === "user") {
       if (typeof msg.content === "string") {
-        anthropicMessages.push({ role: "user", content: msg.content });
+        anthropicMessages.push({ role: "user", content: sanitizeSurrogates(msg.content) });
       } else {
         const text = msg.content.map((c) => c.text).join(`
 `);
-        anthropicMessages.push({ role: "user", content: text });
+        anthropicMessages.push({ role: "user", content: sanitizeSurrogates(text) });
       }
       continue;
     }
@@ -45314,11 +45427,11 @@ ${msg.content}` : msg.content;
       const content = [];
       for (const block of msg.content) {
         if (block.type === "text") {
-          content.push({ type: "text", text: block.text });
+          content.push({ type: "text", text: sanitizeSurrogates(block.text) });
         } else if (block.type === "thinking") {
           content.push({
             type: "thinking",
-            thinking: block.thinking,
+            thinking: sanitizeSurrogates(block.thinking),
             signature: block.thinkingSignature
           });
         } else if (block.type === "tool-call") {
@@ -45336,10 +45449,11 @@ ${msg.content}` : msg.content;
     if (msg.role === "tool") {
       const content = [];
       for (const res of msg.content) {
+        const outStr = typeof res.output === "string" ? res.output : JSON.stringify(res.output);
         content.push({
           type: "tool_result",
           tool_use_id: res.toolCallId,
-          content: typeof res.output === "string" ? res.output : JSON.stringify(res.output),
+          content: sanitizeSurrogates(outStr),
           is_error: res.isError
         });
       }
@@ -45352,10 +45466,11 @@ function streamAnthropic(options) {
   const { request, auth } = options;
   const thinkingConfig = mapAnthropicEffort(request.model.effort);
   const { system, anthropicMessages } = convertMessages2(request.messages);
-  const tools = request.tools?.map((t) => ({
+  const tools = request.tools?.map((t, idx, arr) => ({
     name: t.name,
     description: t.description,
-    input_schema: t.inputSchema
+    input_schema: t.inputSchema,
+    ...idx === arr.length - 1 ? { cache_control: { type: "ephemeral" } } : {}
   }));
   const body = {
     model: request.model.modelId,
@@ -45364,7 +45479,13 @@ function streamAnthropic(options) {
     stream: true
   };
   if (system) {
-    body.system = system;
+    body.system = [
+      {
+        type: "text",
+        text: sanitizeSurrogates(system),
+        cache_control: { type: "ephemeral" }
+      }
+    ];
   }
   if (tools && tools.length > 0) {
     body.tools = tools;
@@ -45379,7 +45500,7 @@ function streamAnthropic(options) {
     "Content-Type": "application/json",
     Accept: "text/event-stream",
     "anthropic-version": "2023-06-01",
-    ...auth.headers
+    ...auth.headers || {}
   };
   if (auth.type === "api-key") {
     headers["x-api-key"] = auth.token;
@@ -45399,7 +45520,7 @@ function streamAnthropic(options) {
       });
     } catch (err) {
       const isAbort = request.abortSignal?.aborted;
-      const error = new AIError(isAbort ? "Inference request aborted." : `Network request to Anthropic failed: ${err.message}`, {
+      const error = new AIError(isAbort ? "Inference request aborted." : `Network request to Anthropic failed: ${err instanceof Error ? err.message : String(err)}`, {
         code: isAbort ? "aborted" : "network",
         provider: "anthropic",
         cause: err
@@ -45409,10 +45530,9 @@ function streamAnthropic(options) {
       return;
     }
     if (!response.ok) {
-      const errBody = await response.text().catch(() => "");
       const isRateLimit = response.status === 429;
       const isAuth = response.status === 401 || response.status === 403;
-      const error = new AIError(`Anthropic error (HTTP ${response.status}): ${errBody}`, {
+      const error = new AIError(`Anthropic request failed with HTTP status ${response.status}`, {
         code: isAuth ? auth.type === "oauth" ? "oauth" : "auth" : isRateLimit ? "rate-limit" : "provider",
         provider: "anthropic",
         status: response.status
@@ -45449,69 +45569,91 @@ function streamAnthropic(options) {
         } catch {
           continue;
         }
-        const eventType = sse.event || eventData.type;
+        const eventType = typeof sse.event === "string" && sse.event || typeof eventData.type === "string" && eventData.type || "";
         switch (eventType) {
           case "message_start": {
-            if (eventData.message?.usage) {
-              const u = eventData.message.usage;
-              usage.inputTokens = u.input_tokens ?? 0;
-              usage.cacheReadTokens = u.cache_read_input_tokens ?? 0;
-              usage.cacheWriteTokens = u.cache_creation_input_tokens ?? 0;
+            const msg = eventData.message;
+            if (msg?.usage && typeof msg.usage === "object") {
+              const u = msg.usage;
+              if (typeof u.input_tokens === "number")
+                usage.inputTokens = u.input_tokens;
+              if (typeof u.cache_read_input_tokens === "number")
+                usage.cacheReadTokens = u.cache_read_input_tokens;
+              if (typeof u.cache_creation_input_tokens === "number")
+                usage.cacheWriteTokens = u.cache_creation_input_tokens;
             }
             break;
           }
           case "content_block_start": {
             const block = eventData.content_block;
+            if (!block || typeof block !== "object" || typeof block.type !== "string") {
+              const error = new AIError("Malformed Anthropic content_block_start event", {
+                code: "parse",
+                provider: "anthropic"
+              });
+              errorResult = error;
+              yield { type: "error", error };
+              return;
+            }
             if (block.type === "text") {
-              currentBlock = { type: "text", text: block.text || "" };
-              if (block.text) {
-                yield { type: "text-delta", delta: block.text };
+              const blockText = typeof block.text === "string" ? block.text : "";
+              currentBlock = { type: "text", text: blockText };
+              if (blockText) {
+                yield { type: "text-delta", delta: blockText };
               }
             } else if (block.type === "thinking") {
+              const blockThinking = typeof block.thinking === "string" ? block.thinking : "";
+              const blockSig = typeof block.signature === "string" ? block.signature : undefined;
               currentBlock = {
                 type: "thinking",
-                thinking: block.thinking || "",
-                signature: block.signature
+                thinking: blockThinking,
+                signature: blockSig
               };
-              if (block.thinking) {
-                yield { type: "reasoning-delta", delta: block.thinking };
+              if (blockThinking) {
+                yield { type: "reasoning-delta", delta: blockThinking };
               }
             } else if (block.type === "tool_use") {
+              const blockId = typeof block.id === "string" ? block.id : "";
+              const blockName = typeof block.name === "string" ? block.name : "";
               currentBlock = {
                 type: "tool-call",
-                id: block.id,
-                name: block.name,
+                id: blockId,
+                name: blockName,
                 rawArgs: ""
               };
-              yield { type: "tool-call-start", id: block.id, name: block.name };
+              yield { type: "tool-call-start", id: blockId, name: blockName };
             }
             break;
           }
           case "content_block_delta": {
             const delta = eventData.delta;
-            if (!delta)
+            if (!delta || typeof delta.type !== "string")
               break;
             if (delta.type === "text_delta") {
+              const deltaText = typeof delta.text === "string" ? delta.text : "";
               if (currentBlock && currentBlock.type === "text") {
-                currentBlock.text += delta.text;
+                currentBlock.text += deltaText;
               }
-              yield { type: "text-delta", delta: delta.text };
+              yield { type: "text-delta", delta: deltaText };
             } else if (delta.type === "thinking_delta") {
+              const deltaThinking = typeof delta.thinking === "string" ? delta.thinking : "";
               if (currentBlock && currentBlock.type === "thinking") {
-                currentBlock.thinking += delta.thinking;
+                currentBlock.thinking += deltaThinking;
               }
-              yield { type: "reasoning-delta", delta: delta.thinking };
+              yield { type: "reasoning-delta", delta: deltaThinking };
             } else if (delta.type === "signature_delta") {
+              const deltaSig = typeof delta.signature === "string" ? delta.signature : "";
               if (currentBlock && currentBlock.type === "thinking") {
-                currentBlock.signature = (currentBlock.signature || "") + delta.signature;
+                currentBlock.signature = (currentBlock.signature || "") + deltaSig;
               }
             } else if (delta.type === "input_json_delta") {
+              const partialJson = typeof delta.partial_json === "string" ? delta.partial_json : "";
               if (currentBlock && currentBlock.type === "tool-call") {
-                currentBlock.rawArgs += delta.partial_json;
+                currentBlock.rawArgs += partialJson;
                 yield {
                   type: "tool-call-delta",
                   id: currentBlock.id,
-                  delta: delta.partial_json
+                  delta: partialJson
                 };
               }
             }
@@ -45546,8 +45688,9 @@ function streamAnthropic(options) {
             break;
           }
           case "message_delta": {
-            if (eventData.delta?.stop_reason) {
-              const sr = eventData.delta.stop_reason;
+            const delta = eventData.delta;
+            if (delta && typeof delta.stop_reason === "string") {
+              const sr = delta.stop_reason;
               if (sr === "end_turn" || sr === "stop_sequence")
                 finishReason = "stop";
               else if (sr === "max_tokens")
@@ -45555,8 +45698,9 @@ function streamAnthropic(options) {
               else if (sr === "tool_use")
                 finishReason = "tool-use";
             }
-            if (eventData.usage?.output_tokens) {
-              usage.outputTokens = eventData.usage.output_tokens;
+            const u = eventData.usage;
+            if (typeof u?.output_tokens === "number") {
+              usage.outputTokens = u.output_tokens;
             }
             break;
           }
@@ -45566,7 +45710,8 @@ function streamAnthropic(options) {
           }
           case "error": {
             const err = eventData.error;
-            const error = new AIError(`Anthropic stream error: ${err?.message || JSON.stringify(err)}`, {
+            const errMsg = typeof err?.message === "string" ? err.message : "Unknown provider error";
+            const error = new AIError(`Anthropic stream error: ${errMsg}`, {
               code: "provider",
               provider: "anthropic"
             });
@@ -45603,7 +45748,7 @@ function streamAnthropic(options) {
       };
     } catch (err) {
       const isAbort = request.abortSignal?.aborted;
-      const error = new AIError(isAbort ? "Inference request aborted." : `Stream reading failed: ${err.message}`, {
+      const error = new AIError(isAbort ? "Inference request aborted." : `Stream reading failed: ${err instanceof Error ? err.message : String(err)}`, {
         code: isAbort ? "aborted" : "provider",
         provider: "anthropic",
         cause: err
@@ -45661,7 +45806,7 @@ function sanitizeSchema(schema) {
 function mapGeminiEffort(effort) {
   switch (effort) {
     case "none":
-      return { thinkingBudget: 0 };
+      return;
     case "low":
       return { thinkingBudget: 2048 };
     case "medium":
@@ -45677,13 +45822,14 @@ function convertMessages3(messages) {
   const contents = [];
   for (const msg of messages) {
     if (msg.role === "system") {
+      const sanitized = sanitizeSurrogates(msg.content);
       systemText = systemText ? `${systemText}
 
-${msg.content}` : msg.content;
+${sanitized}` : sanitized;
       continue;
     }
     if (msg.role === "user") {
-      const text = typeof msg.content === "string" ? msg.content : msg.content.map((c) => c.text).join(`
+      const text = typeof msg.content === "string" ? sanitizeSurrogates(msg.content) : msg.content.map((c) => sanitizeSurrogates(c.text)).join(`
 `);
       contents.push({
         role: "user",
@@ -45695,19 +45841,19 @@ ${msg.content}` : msg.content;
       const parts = [];
       for (const block of msg.content) {
         if (block.type === "text") {
-          if (!block.text && !block.thoughtSignature)
+          if (!block.text && !block.textSignature)
             continue;
           parts.push({
-            text: block.text || "",
-            ...block.thoughtSignature ? { thoughtSignature: block.thoughtSignature } : {}
+            text: sanitizeSurrogates(block.text || ""),
+            ...block.textSignature ? { thoughtSignature: block.textSignature } : {}
           });
         } else if (block.type === "thinking") {
-          if (!block.thinking && !block.thoughtSignature)
+          if (!block.thinking && !block.thinkingSignature)
             continue;
           parts.push({
             thought: true,
-            text: block.thinking || "",
-            ...block.thoughtSignature ? { thoughtSignature: block.thoughtSignature } : {}
+            text: sanitizeSurrogates(block.thinking || ""),
+            ...block.thinkingSignature ? { thoughtSignature: block.thinkingSignature } : {}
           });
         } else if (block.type === "tool-call") {
           parts.push({
@@ -45734,7 +45880,7 @@ ${msg.content}` : msg.content;
           functionResponse: {
             name: res.toolName,
             response: {
-              result: res.output
+              result: sanitizeSurrogates(res.output)
             }
           }
         });
@@ -45783,7 +45929,15 @@ function streamGemini(options) {
     body.tools = tools;
   }
   const modelId = request.model.modelId.replace(/^models\//, "");
-  const url = `https://generativelanguage.googleapis.com/v1beta/models/${modelId}:streamGenerateContent?alt=sse&key=${auth.token}`;
+  const url = `https://generativelanguage.googleapis.com/v1beta/models/${modelId}:streamGenerateContent?alt=sse`;
+  const headers = {
+    "Content-Type": "application/json",
+    Accept: "text/event-stream",
+    ...auth.headers || {}
+  };
+  if (auth.token && auth.token !== "none") {
+    headers["x-goog-api-key"] = auth.token;
+  }
   let finalResult;
   let errorResult;
   async function* eventGenerator() {
@@ -45791,16 +45945,13 @@ function streamGemini(options) {
     try {
       response = await fetch(url, {
         method: "POST",
-        headers: {
-          "Content-Type": "application/json",
-          Accept: "text/event-stream"
-        },
+        headers,
         body: JSON.stringify(body),
         signal: request.abortSignal
       });
     } catch (err) {
       const isAbort = request.abortSignal?.aborted;
-      const error = new AIError(isAbort ? "Inference request aborted." : `Network request to Gemini failed: ${err.message}`, {
+      const error = new AIError(isAbort ? "Inference request aborted." : `Network request to Gemini failed: ${err instanceof Error ? err.message : String(err)}`, {
         code: isAbort ? "aborted" : "network",
         provider: "gemini",
         cause: err
@@ -45810,10 +45961,9 @@ function streamGemini(options) {
       return;
     }
     if (!response.ok) {
-      const errBody = await response.text().catch(() => "");
       const isRateLimit = response.status === 429;
       const isAuth = response.status === 401 || response.status === 403;
-      const error = new AIError(`Gemini error (HTTP ${response.status}): ${errBody}`, {
+      const error = new AIError(`Gemini request failed with HTTP status ${response.status}`, {
         code: isAuth ? "auth" : isRateLimit ? "rate-limit" : "provider",
         provider: "gemini",
         status: response.status
@@ -45849,15 +45999,19 @@ function streamGemini(options) {
         } catch {
           continue;
         }
-        if (eventData.usageMetadata) {
+        if (eventData.usageMetadata && typeof eventData.usageMetadata === "object") {
           const u = eventData.usageMetadata;
-          usage.inputTokens = u.promptTokenCount ?? usage.inputTokens;
-          usage.outputTokens = u.candidatesTokenCount ?? usage.outputTokens;
-          usage.totalTokens = u.totalTokenCount ?? usage.totalTokens;
-        }
-        const candidate = eventData.candidates?.[0];
+          if (typeof u.promptTokenCount === "number")
+            usage.inputTokens = u.promptTokenCount;
+          if (typeof u.candidatesTokenCount === "number")
+            usage.outputTokens = u.candidatesTokenCount;
+          if (typeof u.totalTokenCount === "number")
+            usage.totalTokens = u.totalTokenCount;
+        }
+        const candidates = eventData.candidates;
+        const candidate = candidates?.[0];
         if (candidate) {
-          if (candidate.finishReason) {
+          if (typeof candidate.finishReason === "string") {
             const fr = candidate.finishReason;
             if (fr === "STOP")
               finishReason = "stop";
@@ -45866,21 +46020,25 @@ function streamGemini(options) {
             else if (fr === "SAFETY")
               finishReason = "error";
           }
-          if (candidate.content?.parts) {
-            for (const part of candidate.content.parts) {
+          const content = candidate.content;
+          if (Array.isArray(content?.parts)) {
+            for (const rawPart of content.parts) {
+              const part = rawPart;
+              const thoughtSig = typeof part.thoughtSignature === "string" ? part.thoughtSignature : undefined;
               if (part.thought) {
-                const thoughtDelta = part.text || "";
-                if (thoughtDelta || part.thoughtSignature) {
-                  const existing = assistantContent.find((c) => c.type === "thinking");
-                  if (existing) {
-                    existing.thinking += thoughtDelta;
-                    if (part.thoughtSignature)
-                      existing.thoughtSignature = part.thoughtSignature;
+                const thoughtDelta = typeof part.text === "string" ? part.text : "";
+                if (thoughtDelta || thoughtSig) {
+                  const lastBlock = assistantContent[assistantContent.length - 1];
+                  if (lastBlock && lastBlock.type === "thinking") {
+                    lastBlock.thinking += thoughtDelta;
+                    if (thoughtSig) {
+                      lastBlock.thinkingSignature = thoughtSig;
+                    }
                   } else {
                     assistantContent.push({
                       type: "thinking",
                       thinking: thoughtDelta,
-                      thoughtSignature: part.thoughtSignature
+                      ...thoughtSig ? { thinkingSignature: thoughtSig } : {}
                     });
                   }
                   if (thoughtDelta) {
@@ -45888,33 +46046,37 @@ function streamGemini(options) {
                   }
                 }
               } else if (part.text !== undefined) {
-                const textDelta = part.text || "";
-                if (textDelta || part.thoughtSignature) {
-                  const existing = assistantContent.find((c) => c.type === "text");
-                  if (existing) {
-                    existing.text += textDelta;
-                    if (part.thoughtSignature)
-                      existing.thoughtSignature = part.thoughtSignature;
+                const textDelta = typeof part.text === "string" ? part.text : "";
+                if (textDelta || thoughtSig) {
+                  const lastBlock = assistantContent[assistantContent.length - 1];
+                  if (lastBlock && lastBlock.type === "text") {
+                    lastBlock.text += textDelta;
+                    if (thoughtSig) {
+                      lastBlock.textSignature = thoughtSig;
+                    }
                   } else {
                     assistantContent.push({
                       type: "text",
                       text: textDelta,
-                      thoughtSignature: part.thoughtSignature
+                      ...thoughtSig ? { textSignature: thoughtSig } : {}
                     });
                   }
                   if (textDelta) {
                     yield { type: "text-delta", delta: textDelta };
                   }
                 }
-              } else if (part.functionCall) {
+              } else if (part.functionCall && typeof part.functionCall === "object") {
+                const fc = part.functionCall;
                 toolCallIdx++;
-                const toolId = `call_${Date.now()}_${toolCallIdx}`;
+                const toolId = `call_${toolCallIdx}`;
+                const fnName = typeof fc.name === "string" ? fc.name : "";
+                const fnArgs = typeof fc.args === "object" && fc.args !== null ? fc.args : {};
                 const toolCall = {
                   type: "tool-call",
                   id: toolId,
-                  name: part.functionCall.name,
-                  arguments: part.functionCall.args || {},
-                  thoughtSignature: part.thoughtSignature
+                  name: fnName,
+                  arguments: fnArgs,
+                  ...thoughtSig ? { thoughtSignature: thoughtSig } : {}
                 };
                 assistantContent.push(toolCall);
                 finishReason = "tool-use";
@@ -45947,7 +46109,7 @@ function streamGemini(options) {
       };
     } catch (err) {
       const isAbort = request.abortSignal?.aborted;
-      const error = new AIError(isAbort ? "Inference request aborted." : `Gemini stream reading failed: ${err.message}`, {
+      const error = new AIError(isAbort ? "Inference request aborted." : `Gemini stream reading failed: ${err instanceof Error ? err.message : String(err)}`, {
         code: isAbort ? "aborted" : "provider",
         provider: "gemini",
         cause: err
@@ -45977,8 +46139,16 @@ function streamGemini(options) {
 // src/packages/ai/src/inference.ts
 function streamInference(request, authManager = createAuthManager(), customBaseUrl) {
   const provider = request.model.provider;
-  let streamPromise = null;
   const getStream = async () => {
+    let descriptor;
+    try {
+      descriptor = getProviderDescriptor(provider);
+    } catch {
+      throw new AIError(`Unsupported provider: "${provider}"`, {
+        code: "invalid-request",
+        provider
+      });
+    }
     const resolvedAuth = await authManager.resolve(provider, request.abortSignal);
     if (!resolvedAuth && provider !== "custom" && provider !== "ollama") {
       throw new AIError(`No credentials configured for provider: ${provider}`, {
@@ -45991,30 +46161,28 @@ function streamInference(request, authManager = createAuthManager(), customBaseU
       token: "none",
       source: "custom"
     };
-    switch (provider) {
-      case "anthropic":
+    switch (descriptor.protocol) {
+      case "anthropic-messages":
         return streamAnthropic({ request, auth });
       case "gemini":
         return streamGemini({ request, auth });
-      case "openai":
+      case "openai-chat":
         return streamOpenAI({ request, auth });
-      case "deepseek":
-      case "openrouter":
-      case "github-copilot":
-      case "groq":
-      case "xai":
-      case "mistral":
-      case "ollama":
-      case "custom":
+      case "openai-compatible":
         return streamOpenAICompatible({ request, auth, customBaseUrl });
+      case "openai-responses":
+        throw new AIError(`Protocol "openai-responses" is not yet implemented for provider "${provider}"`, {
+          code: "invalid-request",
+          provider
+        });
       default:
-        throw new AIError(`Unsupported provider: "${provider}"`, {
+        throw new AIError(`Unsupported protocol "${descriptor.protocol}" for provider "${provider}"`, {
           code: "invalid-request",
           provider
         });
     }
   };
-  streamPromise = getStream();
+  const streamPromise = getStream();
   return {
     async* [Symbol.asyncIterator]() {
       const activeStream = await streamPromise;
@@ -46058,85 +46226,91 @@ function createAIEngine(options) {
 // src/packages/ai/src/models/discovery.ts
 var NON_CHAT_MODEL_KEYWORDS = /(embed|similarity|search-document|dall-e|imagen|veo|whisper|tts|transcribe|speech|voice|audio|image|video|moderation|rerank|robotics|live|aqa|babbage|davinci|lyria|chirp)/i;
 var DEFAULT_FETCH_TIMEOUT_MS = 1e4;
-async function fetchOpenAIModels(apiKey, timeoutMs = DEFAULT_FETCH_TIMEOUT_MS) {
-  const response = await fetch("https://api.openai.com/v1/models", {
+async function fetchStandardModelsList(options) {
+  const { provider, url, headers, timeoutMs, transformId, filterItem } = options;
+  const response = await fetch(url, {
     method: "GET",
-    headers: {
-      Authorization: `Bearer ${apiKey}`
-    },
+    headers,
     signal: AbortSignal.timeout(timeoutMs)
   });
   if (!response.ok) {
-    throw new Error(`OpenAI API request failed: HTTP ${response.status} (${response.statusText})`);
+    throw new Error(`${provider} API request failed: HTTP ${response.status} (${response.statusText})`);
   }
   const payload = await response.json();
   if (!Array.isArray(payload.data)) {
     return [];
   }
-  return payload.data.filter((item) => typeof item.id === "string" && !NON_CHAT_MODEL_KEYWORDS.test(item.id)).map((item) => ({
+  const models = [];
+  for (const item of payload.data) {
+    if (!item || typeof item.id !== "string")
+      continue;
+    if (filterItem && !filterItem(item))
+      continue;
+    const finalId = transformId ? transformId(item.id) : item.id;
+    if (!finalId || NON_CHAT_MODEL_KEYWORDS.test(finalId))
+      continue;
+    models.push({
+      provider,
+      modelId: finalId
+    });
+  }
+  return models.sort((a, b) => a.modelId.localeCompare(b.modelId));
+}
+async function fetchOpenAIModels(apiKey, timeoutMs = DEFAULT_FETCH_TIMEOUT_MS) {
+  return await fetchStandardModelsList({
     provider: "openai",
-    modelId: item.id
-  })).sort((a, b) => a.modelId.localeCompare(b.modelId));
+    url: "https://api.openai.com/v1/models",
+    headers: { Authorization: `Bearer ${apiKey}` },
+    timeoutMs
+  });
 }
 async function fetchGeminiModels(apiKey, timeoutMs = DEFAULT_FETCH_TIMEOUT_MS) {
-  const response = await fetch("https://generativelanguage.googleapis.com/v1beta/openai/models", {
-    method: "GET",
-    headers: {
-      Authorization: `Bearer ${apiKey}`
-    },
-    signal: AbortSignal.timeout(timeoutMs)
-  });
-  if (!response.ok) {
-    throw new Error(`Gemini API request failed: HTTP ${response.status} (${response.statusText})`);
-  }
-  const payload = await response.json();
-  if (!Array.isArray(payload.data)) {
-    return [];
-  }
-  return payload.data.map((item) => typeof item.id === "string" ? item.id.replace(/^models\//, "") : "").filter((id) => id && !NON_CHAT_MODEL_KEYWORDS.test(id)).map((id) => ({
+  return await fetchStandardModelsList({
     provider: "gemini",
-    modelId: id
-  })).sort((a, b) => a.modelId.localeCompare(b.modelId));
+    url: "https://generativelanguage.googleapis.com/v1beta/openai/models",
+    headers: { Authorization: `Bearer ${apiKey}` },
+    timeoutMs,
+    transformId: (id) => id.replace(/^models\//, "")
+  });
 }
 async function fetchAnthropicModels(apiKey, timeoutMs = DEFAULT_FETCH_TIMEOUT_MS) {
-  const response = await fetch("https://api.anthropic.com/v1/models", {
-    method: "GET",
+  return await fetchStandardModelsList({
+    provider: "anthropic",
+    url: "https://api.anthropic.com/v1/models",
     headers: {
       "x-api-key": apiKey,
       "anthropic-version": "2023-06-01"
     },
-    signal: AbortSignal.timeout(timeoutMs)
+    timeoutMs
   });
-  if (!response.ok) {
-    throw new Error(`Anthropic API request failed: HTTP ${response.status} (${response.statusText})`);
-  }
-  const payload = await response.json();
-  if (!Array.isArray(payload.data)) {
-    return [];
-  }
-  return payload.data.filter((item) => typeof item.id === "string" && !NON_CHAT_MODEL_KEYWORDS.test(item.id)).map((item) => ({
-    provider: "anthropic",
-    modelId: item.id
-  })).sort((a, b) => a.modelId.localeCompare(b.modelId));
 }
 async function fetchDeepSeekModels(apiKey, timeoutMs = DEFAULT_FETCH_TIMEOUT_MS) {
-  const response = await fetch("https://api.deepseek.com/models", {
-    method: "GET",
+  return await fetchStandardModelsList({
+    provider: "deepseek",
+    url: "https://api.deepseek.com/models",
     headers: { Authorization: `Bearer ${apiKey}` },
-    signal: AbortSignal.timeout(timeoutMs)
+    timeoutMs
   });
-  if (!response.ok) {
-    throw new Error(`DeepSeek API request failed: HTTP ${response.status} (${response.statusText})`);
+}
+function isValidOpenRouterNextUrl(rawUrl) {
+  try {
+    const parsed = new URL(rawUrl, "https://openrouter.ai");
+    return parsed.protocol === "https:" && parsed.origin === "https://openrouter.ai" && parsed.pathname.startsWith("/api/v1/models");
+  } catch {
+    return false;
   }
-  const payload = await response.json();
-  if (!Array.isArray(payload.data))
-    return [];
-  return payload.data.filter((item) => typeof item.id === "string" && !NON_CHAT_MODEL_KEYWORDS.test(item.id)).map((item) => ({ provider: "deepseek", modelId: item.id })).sort((a, b) => a.modelId.localeCompare(b.modelId));
 }
 async function fetchOpenRouterModels(apiKey, timeoutMs = DEFAULT_FETCH_TIMEOUT_MS) {
   const results = [];
   let url = "https://openrouter.ai/api/v1/models";
-  while (url) {
+  const seenUrls = new Set;
+  const MAX_PAGES = 20;
+  let pageCount = 0;
+  while (url && pageCount < MAX_PAGES) {
+    if (seenUrls.has(url))
+      break;
+    seenUrls.add(url);
+    pageCount++;
     const response = await fetch(url, {
       method: "GET",
       headers: { Authorization: `Bearer ${apiKey}` },
@@ -46148,7 +46322,7 @@ async function fetchOpenRouterModels(apiKey, timeoutMs = DEFAULT_FETCH_TIMEOUT_M
     const payload = await response.json();
     if (Array.isArray(payload.data)) {
       for (const item of payload.data) {
-        if (typeof item.id !== "string")
+        if (!item || typeof item.id !== "string")
           continue;
         const hasTextModality = item.architecture?.output_modalities?.includes("text");
         if (hasTextModality === false)
@@ -46158,70 +46332,51 @@ async function fetchOpenRouterModels(apiKey, timeoutMs = DEFAULT_FETCH_TIMEOUT_M
         }
       }
     }
-    const next = payload.links?.next ?? null;
-    url = next ? new URL(next, "https://openrouter.ai").toString() : null;
+    const next = payload.links?.next;
+    if (typeof next === "string" && next.trim() && isValidOpenRouterNextUrl(next)) {
+      url = new URL(next, "https://openrouter.ai").toString();
+    } else {
+      url = null;
+    }
   }
   return results.sort((a, b) => a.modelId.localeCompare(b.modelId));
 }
 async function fetchGroqModels(apiKey, timeoutMs = DEFAULT_FETCH_TIMEOUT_MS) {
-  const response = await fetch("https://api.groq.com/openai/v1/models", {
-    method: "GET",
+  return await fetchStandardModelsList({
+    provider: "groq",
+    url: "https://api.groq.com/openai/v1/models",
     headers: { Authorization: `Bearer ${apiKey}` },
-    signal: AbortSignal.timeout(timeoutMs)
+    timeoutMs
   });
-  if (!response.ok) {
-    throw new Error(`Groq API request failed: HTTP ${response.status} (${response.statusText})`);
-  }
-  const payload = await response.json();
-  if (!Array.isArray(payload.data))
-    return [];
-  return payload.data.filter((item) => typeof item.id === "string" && !NON_CHAT_MODEL_KEYWORDS.test(item.id)).map((item) => ({ provider: "groq", modelId: item.id })).sort((a, b) => a.modelId.localeCompare(b.modelId));
 }
 async function fetchXAIModels(apiKey, timeoutMs = DEFAULT_FETCH_TIMEOUT_MS) {
-  const response = await fetch("https://api.x.ai/v1/models", {
-    method: "GET",
+  return await fetchStandardModelsList({
+    provider: "xai",
+    url: "https://api.x.ai/v1/models",
     headers: { Authorization: `Bearer ${apiKey}` },
-    signal: AbortSignal.timeout(timeoutMs)
+    timeoutMs
   });
-  if (!response.ok) {
-    throw new Error(`xAI API request failed: HTTP ${response.status} (${response.statusText})`);
-  }
-  const payload = await response.json();
-  if (!Array.isArray(payload.data))
-    return [];
-  return payload.data.filter((item) => typeof item.id === "string" && !NON_CHAT_MODEL_KEYWORDS.test(item.id)).map((item) => ({ provider: "xai", modelId: item.id })).sort((a, b) => a.modelId.localeCompare(b.modelId));
 }
 async function fetchMistralModels(apiKey, timeoutMs = DEFAULT_FETCH_TIMEOUT_MS) {
-  const response = await fetch("https://api.mistral.ai/v1/models", {
-    method: "GET",
+  return await fetchStandardModelsList({
+    provider: "mistral",
+    url: "https://api.mistral.ai/v1/models",
     headers: { Authorization: `Bearer ${apiKey}` },
-    signal: AbortSignal.timeout(timeoutMs)
+    timeoutMs
   });
-  if (!response.ok) {
-    throw new Error(`Mistral API request failed: HTTP ${response.status} (${response.statusText})`);
-  }
-  const payload = await response.json();
-  if (!Array.isArray(payload.data))
-    return [];
-  return payload.data.filter((item) => typeof item.id === "string" && !NON_CHAT_MODEL_KEYWORDS.test(item.id)).map((item) => ({ provider: "mistral", modelId: item.id })).sort((a, b) => a.modelId.localeCompare(b.modelId));
 }
 async function fetchOllamaModels(baseUrl = "http://localhost:11434/v1", timeoutMs = 3000) {
-  const endpoint = baseUrl.replace(/\/+$/, "") + "/models";
-  const response = await fetch(endpoint, {
-    method: "GET",
-    signal: AbortSignal.timeout(timeoutMs)
+  const endpoint = `${baseUrl.replace(/\/+$/, "")}/models`;
+  return await fetchStandardModelsList({
+    provider: "ollama",
+    url: endpoint,
+    timeoutMs
   });
-  if (!response.ok) {
-    throw new Error(`Ollama API request failed: HTTP ${response.status} (${response.statusText})`);
-  }
-  const payload = await response.json();
-  if (!Array.isArray(payload.data))
-    return [];
-  return payload.data.filter((item) => typeof item.id === "string" && !NON_CHAT_MODEL_KEYWORDS.test(item.id)).map((item) => ({ provider: "ollama", modelId: item.id })).sort((a, b) => a.modelId.localeCompare(b.modelId));
 }
 async function fetchGitHubCopilotModels(apiKey, timeoutMs = DEFAULT_FETCH_TIMEOUT_MS) {
-  const response = await fetch("https://api.individual.githubcopilot.com/models", {
-    method: "GET",
+  return await fetchStandardModelsList({
+    provider: "github-copilot",
+    url: "https://api.individual.githubcopilot.com/models",
     headers: {
       Accept: "application/json",
       Authorization: `Bearer ${apiKey}`,
@@ -46231,16 +46386,21 @@ async function fetchGitHubCopilotModels(apiKey, timeoutMs = DEFAULT_FETCH_TIMEOU
       "Copilot-Integration-Id": "vscode-chat",
       "X-GitHub-Api-Version": "2026-06-01"
     },
-    signal: AbortSignal.timeout(timeoutMs)
+    timeoutMs,
+    filterItem: (item) => item.capabilities?.supports?.tool_calls !== false
   });
-  if (!response.ok) {
-    throw new Error(`GitHub Copilot API request failed: HTTP ${response.status} (${response.statusText})`);
-  }
-  const payload = await response.json();
-  if (!Array.isArray(payload.data))
-    return [];
-  return payload.data.filter((item) => typeof item.id === "string" && !NON_CHAT_MODEL_KEYWORDS.test(item.id) && item.capabilities?.supports?.tool_calls !== false).map((item) => ({ provider: "github-copilot", modelId: item.id })).sort((a, b) => a.modelId.localeCompare(b.modelId));
 }
+var API_KEY_FETCHERS = {
+  openai: fetchOpenAIModels,
+  gemini: fetchGeminiModels,
+  anthropic: fetchAnthropicModels,
+  deepseek: fetchDeepSeekModels,
+  openrouter: fetchOpenRouterModels,
+  "github-copilot": fetchGitHubCopilotModels,
+  groq: fetchGroqModels,
+  xai: fetchXAIModels,
+  mistral: fetchMistralModels
+};
 async function fetchAvailableModels(authCtx, timeoutMs = DEFAULT_FETCH_TIMEOUT_MS) {
   const result = {
     models: [],
@@ -46259,152 +46419,30 @@ async function fetchAvailableModels(authCtx, timeoutMs = DEFAULT_FETCH_TIMEOUT_M
     }
   };
   const tasks = [];
-  const openaiKey = await authCtx.getApiKey("openai");
-  if (openaiKey) {
-    tasks.push(fetchOpenAIModels(openaiKey, timeoutMs).then((models) => {
-      result.models.push(...models);
-      result.providers.openai = {
-        status: "available",
-        modelCount: models.length
-      };
-    }).catch((err) => {
-      result.providers.openai = {
-        status: "error",
-        modelCount: 0,
-        error: err instanceof Error ? err.message : String(err)
-      };
-    }));
-  }
-  const geminiKey = await authCtx.getApiKey("gemini");
-  if (geminiKey) {
-    tasks.push(fetchGeminiModels(geminiKey, timeoutMs).then((models) => {
-      result.models.push(...models);
-      result.providers.gemini = {
-        status: "available",
-        modelCount: models.length
-      };
-    }).catch((err) => {
-      result.providers.gemini = {
-        status: "error",
-        modelCount: 0,
-        error: err instanceof Error ? err.message : String(err)
-      };
-    }));
-  }
-  const anthropicKey = await authCtx.getApiKey("anthropic");
-  if (anthropicKey) {
-    tasks.push(fetchAnthropicModels(anthropicKey, timeoutMs).then((models) => {
-      result.models.push(...models);
-      result.providers.anthropic = {
-        status: "available",
-        modelCount: models.length
-      };
-    }).catch((err) => {
-      result.providers.anthropic = {
-        status: "error",
-        modelCount: 0,
-        error: err instanceof Error ? err.message : String(err)
-      };
-    }));
-  }
-  const deepseekKey = await authCtx.getApiKey("deepseek");
-  if (deepseekKey) {
-    tasks.push(fetchDeepSeekModels(deepseekKey, timeoutMs).then((models) => {
-      result.models.push(...models);
-      result.providers.deepseek = {
-        status: "available",
-        modelCount: models.length
-      };
-    }).catch((err) => {
-      result.providers.deepseek = {
-        status: "error",
-        modelCount: 0,
-        error: err instanceof Error ? err.message : String(err)
-      };
-    }));
-  }
-  const openrouterKey = await authCtx.getApiKey("openrouter");
-  if (openrouterKey) {
-    tasks.push(fetchOpenRouterModels(openrouterKey, timeoutMs).then((models) => {
-      result.models.push(...models);
-      result.providers.openrouter = {
-        status: "available",
-        modelCount: models.length
-      };
-    }).catch((err) => {
-      result.providers.openrouter = {
-        status: "error",
-        modelCount: 0,
-        error: err instanceof Error ? err.message : String(err)
-      };
-    }));
-  }
-  const copilotKey = await authCtx.getApiKey("github-copilot");
-  if (copilotKey) {
-    tasks.push(fetchGitHubCopilotModels(copilotKey, timeoutMs).then((models) => {
-      result.models.push(...models);
-      result.providers["github-copilot"] = {
-        status: "available",
-        modelCount: models.length
-      };
-    }).catch((err) => {
-      result.providers["github-copilot"] = {
-        status: "error",
-        modelCount: 0,
-        error: err instanceof Error ? err.message : String(err)
-      };
-    }));
-  }
-  const groqKey = await authCtx.getApiKey("groq");
-  if (groqKey) {
-    tasks.push(fetchGroqModels(groqKey, timeoutMs).then((models) => {
-      result.models.push(...models);
-      result.providers.groq = {
-        status: "available",
-        modelCount: models.length
-      };
-    }).catch((err) => {
-      result.providers.groq = {
-        status: "error",
-        modelCount: 0,
-        error: err instanceof Error ? err.message : String(err)
-      };
-    }));
-  }
-  const xaiKey = await authCtx.getApiKey("xai");
-  if (xaiKey) {
-    tasks.push(fetchXAIModels(xaiKey, timeoutMs).then((models) => {
-      result.models.push(...models);
-      result.providers.xai = {
-        status: "available",
-        modelCount: models.length
-      };
-    }).catch((err) => {
-      result.providers.xai = {
-        status: "error",
-        modelCount: 0,
-        error: err instanceof Error ? err.message : String(err)
-      };
-    }));
-  }
-  const mistralKey = await authCtx.getApiKey("mistral");
-  if (mistralKey) {
-    tasks.push(fetchMistralModels(mistralKey, timeoutMs).then((models) => {
-      result.models.push(...models);
-      result.providers.mistral = {
-        status: "available",
-        modelCount: models.length
-      };
-    }).catch((err) => {
-      result.providers.mistral = {
-        status: "error",
-        modelCount: 0,
-        error: err instanceof Error ? err.message : String(err)
-      };
-    }));
+  for (const [providerKey, fetcher] of Object.entries(API_KEY_FETCHERS)) {
+    const provider = providerKey;
+    if (!fetcher)
+      continue;
+    const apiKey = await authCtx.getApiKey(provider);
+    if (apiKey) {
+      tasks.push(fetcher(apiKey, timeoutMs).then((models) => {
+        result.models.push(...models);
+        result.providers[provider] = {
+          status: "available",
+          modelCount: models.length
+        };
+      }).catch((err) => {
+        result.providers[provider] = {
+          status: "error",
+          modelCount: 0,
+          error: err instanceof Error ? err.message : String(err)
+        };
+      }));
+    }
   }
   const ollamaUrl = authCtx.getOllamaEndpoint?.() || "http://localhost:11434/v1";
-  tasks.push(fetchOllamaModels(ollamaUrl, 2000).then((models) => {
+  const ollamaTimeout = Math.min(timeoutMs, 3000);
+  tasks.push(fetchOllamaModels(ollamaUrl, ollamaTimeout).then((models) => {
     if (models.length > 0) {
       result.models.push(...models);
       result.providers.ollama = {
@@ -53893,15 +53931,15 @@ var defaultToolCatalog = new ToolCatalog;
 
 // src/packages/agents/src/tools/read-file/index.ts
 import { existsSync as existsSync4, lstatSync, readFileSync as readFileSync3, realpathSync } from "node:fs";
-import { isAbsolute, resolve, sep } from "node:path";
+import { isAbsolute, resolve as resolve2, sep } from "node:path";
 var readFileInputSchema = object({
   path: string2().describe("The path of the file to read (relative to current working directory or absolute)."),
   offset: number2().int().min(1).optional().describe("The line number to start reading from (1-indexed). Defaults to 1."),
   limit: number2().int().min(1).max(2000).optional().describe("The maximum number of lines to read. Defaults to 200.")
 });
 function isPathInside(targetPath, basePath) {
-  const normTarget = resolve(targetPath);
-  const normBase = resolve(basePath);
+  const normTarget = resolve2(targetPath);
+  const normBase = resolve2(basePath);
   if (normTarget === normBase) {
     return true;
   }
@@ -53913,7 +53951,7 @@ function resolveSafeReadPath(cwd, filePath) {
     throw new Error("File path cannot be empty.");
   }
   const trimmed = filePath.trim();
-  const resolved = isAbsolute(trimmed) ? resolve(trimmed) : resolve(cwd, trimmed);
+  const resolved = isAbsolute(trimmed) ? resolve2(trimmed) : resolve2(cwd, trimmed);
   if (!isPathInside(resolved, cwd)) {
     throw new Error(`Access denied: path "${filePath}" resolves outside the trusted workspace root ("${cwd}").`);
   }
@@ -54014,12 +54052,12 @@ import { existsSync as existsSync8, readFileSync as readFileSync5, statSync } fr
 // src/packages/services/src/checkpoint/path.ts
 import { createHash } from "node:crypto";
 import { existsSync as existsSync6, lstatSync as lstatSync2, realpathSync as realpathSync3 } from "node:fs";
-import { dirname as dirname4, isAbsolute as isAbsolute2, relative, resolve as resolve3, sep as sep3 } from "node:path";
+import { dirname as dirname4, isAbsolute as isAbsolute2, relative, resolve as resolve4, sep as sep3 } from "node:path";
 
 // src/packages/services/src/config/settings.ts
 import { existsSync as existsSync5, mkdirSync as mkdirSync4, readFileSync as readFileSync4, realpathSync as realpathSync2, writeFileSync as writeFileSync3 } from "node:fs";
 import { homedir as homedir4 } from "node:os";
-import { join as join6, resolve as resolve2, sep as sep2 } from "node:path";
+import { join as join6, resolve as resolve3, sep as sep2 } from "node:path";
 function getSettingsDir() {
   if (process.env.STEWARD_SETTINGS_DIR) {
     return process.env.STEWARD_SETTINGS_DIR;
@@ -54073,7 +54111,7 @@ function saveThemeSelection(name) {
   });
 }
 function normalizeFolderPath(inputPath) {
-  let absolute = resolve2(inputPath);
+  let absolute = resolve3(inputPath);
   try {
     absolute = realpathSync2(absolute);
   } catch {}
@@ -54145,7 +54183,7 @@ function resolveDirectMutationPath(cwd, filePath) {
   }
   const trimmed = filePath.trim();
   const workspaceRoot = normalizeFolderPath(cwd);
-  const resolved = isAbsolute2(trimmed) ? resolve3(trimmed) : resolve3(cwd, trimmed);
+  const resolved = isAbsolute2(trimmed) ? resolve4(trimmed) : resolve4(cwd, trimmed);
   if (!isPathInside2(resolved, workspaceRoot)) {
     throw new Error(`Access denied: path "${filePath}" resolves outside the trusted workspace root ("${cwd}").`);
   }
@@ -54732,7 +54770,7 @@ var editFileTool = {
 
 // src/packages/agents/src/tools/glob/index.ts
 import { readdirSync as readdirSync2 } from "node:fs";
-import { isAbsolute as isAbsolute3, join as join8, relative as relative2, resolve as resolve4 } from "node:path";
+import { isAbsolute as isAbsolute3, join as join8, relative as relative2, resolve as resolve5 } from "node:path";
 var globInputSchema = object({
   pattern: string2().describe('Glob pattern to match files against (e.g. "**/*.ts", "src/*.json").'),
   path: string2().optional().describe("Starting directory path. Defaults to workspace root."),
@@ -54785,9 +54823,9 @@ var globTool = {
   },
   execute: async (args, context) => {
     const startTime = Date.now();
-    const searchRoot = args.path ? isAbsolute3(args.path) ? resolve4(args.path) : resolve4(context.cwd, args.path) : context.cwd;
-    const normCwd = resolve4(context.cwd);
-    const normTarget = resolve4(searchRoot);
+    const searchRoot = args.path ? isAbsolute3(args.path) ? resolve5(args.path) : resolve5(context.cwd, args.path) : context.cwd;
+    const normCwd = resolve5(context.cwd);
+    const normTarget = resolve5(searchRoot);
     const prefix = normCwd.endsWith("/") ? normCwd : `${normCwd}/`;
     if (normTarget !== normCwd && !normTarget.startsWith(prefix)) {
       throw new Error(`Access denied: path "${args.path}" resolves outside the trusted workspace root ("${context.cwd}").`);
@@ -54814,7 +54852,7 @@ var globTool = {
 
 // src/packages/agents/src/tools/grep/index.ts
 import { readFileSync as readFileSync7, readdirSync as readdirSync3 } from "node:fs";
-import { isAbsolute as isAbsolute4, join as join9, relative as relative3, resolve as resolve5 } from "node:path";
+import { isAbsolute as isAbsolute4, join as join9, relative as relative3, resolve as resolve6 } from "node:path";
 var grepInputSchema = object({
   pattern: string2().describe("The regex or text pattern to search for across files."),
   path: string2().optional().describe("Target directory or file path to search. Defaults to current directory."),
@@ -54890,9 +54928,9 @@ var grepTool = {
   },
   execute: async (args, context) => {
     const startTime = Date.now();
-    const searchRoot = args.path ? isAbsolute4(args.path) ? resolve5(args.path) : resolve5(context.cwd, args.path) : context.cwd;
-    const normCwd = resolve5(context.cwd);
-    const normTarget = resolve5(searchRoot);
+    const searchRoot = args.path ? isAbsolute4(args.path) ? resolve6(args.path) : resolve6(context.cwd, args.path) : context.cwd;
+    const normCwd = resolve6(context.cwd);
+    const normTarget = resolve6(searchRoot);
     const prefix = normCwd.endsWith("/") ? normCwd : `${normCwd}/`;
     if (normTarget !== normCwd && !normTarget.startsWith(prefix)) {
       throw new Error(`Access denied: path "${args.path}" resolves outside the trusted workspace root ("${context.cwd}").`);
@@ -54951,7 +54989,7 @@ var grepTool = {
 
 // src/packages/agents/src/tools/list-dir/index.ts
 import { readdirSync as readdirSync4, statSync as statSync3 } from "node:fs";
-import { isAbsolute as isAbsolute5, join as join10, resolve as resolve6 } from "node:path";
+import { isAbsolute as isAbsolute5, join as join10, resolve as resolve7 } from "node:path";
 var listDirInputSchema = object({
   path: string2().optional().describe("Directory path to list. Defaults to current working directory."),
   recursive: boolean2().optional().describe("If true, lists files recursively (depth 2). Defaults to false.")
@@ -54969,9 +55007,9 @@ var listDirTool = {
     return `Listed ${files} file${files === 1 ? "" : "s"}, ${dirs} director${dirs === 1 ? "y" : "ies"}`;
   },
   execute: async (args, context) => {
-    const targetPath = args.path ? isAbsolute5(args.path) ? resolve6(args.path) : resolve6(context.cwd, args.path) : context.cwd;
-    const normCwd = resolve6(context.cwd);
-    const normTarget = resolve6(targetPath);
+    const targetPath = args.path ? isAbsolute5(args.path) ? resolve7(args.path) : resolve7(context.cwd, args.path) : context.cwd;
+    const normCwd = resolve7(context.cwd);
+    const normTarget = resolve7(targetPath);
     const prefix = normCwd.endsWith("/") ? normCwd : `${normCwd}/`;
     if (normTarget !== normCwd && !normTarget.startsWith(prefix)) {
       throw new Error(`Access denied: path "${args.path}" resolves outside the trusted workspace root ("${context.cwd}").`);
@@ -55407,18 +55445,18 @@ Process error: ${err.message}
 // src/packages/agents/src/tools/bash/command-policy.ts
 import { existsSync as existsSync10, realpathSync as realpathSync4 } from "node:fs";
 import { homedir as homedir6 } from "node:os";
-import { isAbsolute as isAbsolute6, resolve as resolve7, sep as sep4 } from "node:path";
+import { isAbsolute as isAbsolute6, resolve as resolve8, sep as sep4 } from "node:path";
 function expandHome(filepath) {
   if (filepath === "~") {
     return homedir6();
   }
   if (filepath.startsWith("~/") || filepath.startsWith("~\\")) {
-    return resolve7(homedir6(), filepath.slice(2));
+    return resolve8(homedir6(), filepath.slice(2));
   }
   return filepath;
 }
 function normalizeRoot(inputPath) {
-  let absolute = resolve7(inputPath);
+  let absolute = resolve8(inputPath);
   try {
     absolute = realpathSync4(absolute);
   } catch {}
@@ -55553,7 +55591,7 @@ function arePathTokensInsideWorkspace(tokens, startIndex, cwd) {
       continue;
     }
     const expanded = expandHome(tok);
-    const resolved = isAbsolute6(expanded) ? resolve7(expanded) : resolve7(cwd, expanded);
+    const resolved = isAbsolute6(expanded) ? resolve8(expanded) : resolve8(cwd, expanded);
     if (!isContainedInWorkspace(resolved, cwd)) {
       return false;
     }
@@ -55941,8 +55979,8 @@ import { isIP } from "node:net";
 // package.json
 var package_default = {
   name: "steward-cli",
-  version: "0.22.0",
-  description: "Interactive AI engineering assistant for the terminal with human-in-the-loop control across local and frontier models.",
+  version: "0.23.0",
+  description: "Interactive AI engineering assistant for the terminal.",
   author: "sapirrior",
   license: "MIT",
   files: [
@@ -56296,7 +56334,7 @@ var webSearchTool = {
 // src/packages/agents/src/skills/discovery.ts
 import { existsSync as existsSync11, readdirSync as readdirSync5, readFileSync as readFileSync8, statSync as statSync4 } from "node:fs";
 import { homedir as homedir7 } from "node:os";
-import { isAbsolute as isAbsolute7, join as join12, normalize, resolve as resolve8, sep as sep5 } from "node:path";
+import { isAbsolute as isAbsolute7, join as join12, normalize, resolve as resolve9, sep as sep5 } from "node:path";
 var MAX_SKILL_FILE_SIZE = 64 * 1024;
 function parseSkillFrontmatter(content) {
   const match = content.match(/^---\r?\n([\s\S]*?)\r?\n---/);
@@ -56411,8 +56449,8 @@ function readSkillResource(name, relativePath, cwd = process.cwd(), maxBytes = M
     if (normalizedRelative.startsWith("..") || normalizedRelative.includes(`${sep5}..`)) {
       throw new Error(`Invalid skill resource path: directory traversal ("..") is forbidden (${trimmedPath})`);
     }
-    targetFilePath = resolve8(skill.dirPath, normalizedRelative);
-    const resolvedDir = resolve8(skill.dirPath);
+    targetFilePath = resolve9(skill.dirPath, normalizedRelative);
+    const resolvedDir = resolve9(skill.dirPath);
     if (!targetFilePath.startsWith(resolvedDir + sep5) && targetFilePath !== resolvedDir) {
       throw new Error(`Resource "${trimmedPath}" resolves outside skill directory`);
     }
@@ -57646,7 +57684,7 @@ import {
   unlinkSync as unlinkSync5,
   writeSync as writeSync5
 } from "node:fs";
-import { dirname as dirname6, join as join15, resolve as resolve9 } from "node:path";
+import { dirname as dirname6, join as join15, resolve as resolve10 } from "node:path";
 import { randomUUID as randomUUID5 } from "node:crypto";
 function getFileStateOnDisk(absPath) {
   if (!existsSync15(absPath)) {
@@ -57744,7 +57782,7 @@ async function executeRewind(options) {
       if (!fileCp.mutationCommitted)
         continue;
       const relPath = fileCp.relativePath;
-      const absPath = resolve9(workspaceRoot, relPath);
+      const absPath = resolve10(workspaceRoot, relPath);
       if (!fileOperationsMap.has(relPath)) {
         fileOperationsMap.set(relPath, {
           relativePath: relPath,
@@ -57895,7 +57933,7 @@ async function recoverPendingCheckpoint(workspaceRoot, sessionId) {
     if (journal.phase === "files-restored" || journal.phase === "files-pending") {
       for (const file of journal.files) {
         if (file.post) {
-          const absPath = resolve9(workspaceRoot, file.relativePath);
+          const absPath = resolve10(workspaceRoot, file.relativePath);
           try {
             restoreFileStateToDisk(workspaceHash, absPath, file.post);
           } catch {}
@@ -58669,35 +58707,7 @@ function getDiscoveryAuthContext() {
       const resolved = await authManager.resolve(provider).catch(() => {
         return;
       });
-      if (resolved?.token && resolved.token !== "none") {
-        return resolved.token;
-      }
-      switch (provider) {
-        case "openai":
-          return config.openaiApiKey;
-        case "gemini":
-          return config.geminiApiKey;
-        case "anthropic":
-          return config.anthropicApiKey;
-        case "deepseek":
-          return config.deepseekApiKey;
-        case "openrouter":
-          return config.openrouterApiKey;
-        case "github-copilot":
-          return config.copilotGithubToken;
-        case "groq":
-          return config.groqApiKey;
-        case "xai":
-          return config.xaiApiKey;
-        case "mistral":
-          return config.mistralApiKey;
-        case "ollama":
-          return "none";
-        case "custom":
-          return config.custom.apiKey || "none";
-        default:
-          return;
-      }
+      return resolved?.token && resolved.token !== "none" ? resolved.token : undefined;
     },
     getCustomEndpoint: () => config.custom,
     getOllamaEndpoint: () => config.ollamaBaseUrl