nuabase 2.3.0 → 2.3.1

package/dist/esm/index.mjs

@@ -1,6 +1,6 @@
 import require$$0 from 'ajv';
-import require$$1 from 'ajv/dist/2019';
-import require$$2 from 'ajv/dist/2020';
+import require$$1 from 'ajv/dist/2019.js';
+import require$$2 from 'ajv/dist/2020.js';
 import require$$3 from 'ajv/dist/refs/json-schema-draft-07.json';
 import require$$4 from 'ajv/dist/refs/json-schema-draft-06.json';
 import { z } from 'zod';
@@ -274,8 +274,8 @@ function requireAjvInstances() {
   Object.defineProperty(ajvInstances, "__esModule", { value: true });
   ajvInstances.ajvInstances = void 0;
   const ajv_1 = __importDefault(require$$0);
-  const _2019_1 = __importDefault(require$$1);
-  const _2020_1 = __importDefault(require$$2);
+  const _2019_js_1 = __importDefault(require$$1);
+  const _2020_js_1 = __importDefault(require$$2);
   const json_schema_draft_07_json_1 = __importDefault(require$$3);
   const json_schema_draft_06_json_1 = __importDefault(require$$4);
   const ajvOptions = {
@@ -288,10 +288,10 @@ function requireAjvInstances() {
   class AjvInstances {
     constructor() {
       this.draft07 = new ajv_1.default(ajvOptions);
-      this.draft2019 = new _2019_1.default(ajvOptions);
+      this.draft2019 = new _2019_js_1.default(ajvOptions);
       this.draft2019.addMetaSchema(json_schema_draft_07_json_1.default);
       this.draft2019.addMetaSchema(json_schema_draft_06_json_1.default);
-      this.draft2020 = new _2020_1.default(ajvOptions);
+      this.draft2020 = new _2020_js_1.default(ajvOptions);
     }
     getInstanceForSchema(schema) {
       const schemaVersion = schema.$schema;
@@ -355,17 +355,15 @@ function requireModelInfo() {
     exports$1.parseCanonicalModelName = parseCanonicalModelName;
     exports$1.CANONICAL_MODELS = [
       "qwen3-30b-a3b-instruct-2507",
-      "claude-sonnet-4-5",
+      "claude-sonnet-4-6",
       "qwen3-vl-235b-a22b-instruct",
       "qwen3-max",
       "gpt-5",
-      "gemini-2.5-flash-lite-preview-09-2025",
+      "gemini-2.5-flash-lite",
+      "gemini-2.5-flash",
       "qwen3-coder-flash",
       "gpt-oss-120b",
-      "llama-3.3-70b-versatile",
-      "gpt-4o",
-      "llama-3.3-70b",
-      "gemini-2.0-flash"
+      "kimi-k2.5"
     ];
     const CANONICAL_SET = new Set(exports$1.CANONICAL_MODELS);
     exports$1.SUPPORTED_MODELS = {
@@ -374,6 +372,10 @@ function requireModelInfo() {
           provider: "cerebras",
           providerModelName: "gpt-oss-120b"
         },
+        {
+          provider: "groq",
+          providerModelName: "openai/gpt-oss-120b"
+        },
         {
           provider: "openrouter",
           providerModelName: "openai/gpt-oss-120b"
@@ -385,10 +387,10 @@ function requireModelInfo() {
           providerModelName: "qwen/qwen3-30b-a3b-instruct-2507"
         }
       ],
-      "claude-sonnet-4-5": [
+      "claude-sonnet-4-6": [
         {
           provider: "openrouter",
-          providerModelName: "anthropic/claude-sonnet-4.5"
+          providerModelName: "anthropic/claude-sonnet-4.6"
         }
       ],
       "qwen3-vl-235b-a22b-instruct": [
@@ -409,40 +411,36 @@ function requireModelInfo() {
           providerModelName: "openai/gpt-5"
         }
       ],
-      "gemini-2.5-flash-lite-preview-09-2025": [
+      "gemini-2.5-flash-lite": [
         {
-          provider: "openrouter",
-          providerModelName: "google/gemini-2.5-flash-lite-preview-09-2025"
-        }
-      ],
-      "qwen3-coder-flash": [
+          provider: "gemini",
+          providerModelName: "gemini-2.5-flash-lite"
+        },
         {
           provider: "openrouter",
-          providerModelName: "qwen/qwen3-coder-flash"
+          providerModelName: "google/gemini-2.5-flash-lite"
         }
       ],
-      "llama-3.3-70b-versatile": [
+      "gemini-2.5-flash": [
         {
-          provider: "groq",
-          providerModelName: "llama-3.3-70b-versatile"
-        }
-      ],
-      "gpt-4o": [
+          provider: "gemini",
+          providerModelName: "gemini-2.5-flash"
+        },
         {
           provider: "openrouter",
-          providerModelName: "openai/gpt-4o"
+          providerModelName: "google/gemini-2.5-flash"
         }
       ],
-      "llama-3.3-70b": [
+      "qwen3-coder-flash": [
         {
-          provider: "cerebras",
-          providerModelName: "llama-3.3-70b"
+          provider: "openrouter",
+          providerModelName: "qwen/qwen3-coder-flash"
         }
       ],
-      "gemini-2.0-flash": [
+      "kimi-k2.5": [
         {
-          provider: "gemini",
-          providerModelName: "gemini-2.0-flash"
+          provider: "openrouter",
+          providerModelName: "moonshotai/kimi-k2.5"
         }
       ]
     };
@@ -455,11 +453,14 @@ function requireModelInfo() {
         case "fast":
           m2 = "gpt-oss-120b";
           break;
+        case "gemini":
+          m2 = "gemini-2.5-flash";
+          break;
         case "qwen":
           m2 = "qwen3-vl-235b-a22b-instruct";
           break;
         case "sonnet":
-          m2 = "claude-sonnet-4-5";
+          m2 = "claude-sonnet-4-6";
           break;
         case "gpt":
           m2 = "gpt-5";
@@ -484,7 +485,7 @@ function requireProviderConfig() {
   hasRequiredProviderConfig = 1;
   (function(exports$1) {
     Object.defineProperty(exports$1, "__esModule", { value: true });
-    exports$1.providerConfigs = exports$1.normalizedUsageZero = void 0;
+    exports$1.providerConfigs = exports$1.extractOpenAiMessageText = exports$1.normalizeGeminiUsage = exports$1.normalizeOpenAiUsage = exports$1.normalizedUsageZero = void 0;
     exports$1.normalizedUsageZero = {
       promptTokens: 0,
       completionTokens: 0,
@@ -503,6 +504,7 @@ function requireProviderConfig() {
         totalTokens: usage.total_tokens
       };
     };
+    exports$1.normalizeOpenAiUsage = normalizeOpenAiUsage;
     const normalizeGeminiUsage = (usage) => {
       if (!usage) {
         return exports$1.normalizedUsageZero;
@@ -516,6 +518,7 @@ function requireProviderConfig() {
         totalTokens: usage.totalTokenCount
       };
     };
+    exports$1.normalizeGeminiUsage = normalizeGeminiUsage;
     const buildOpenAiStyleRequest = (baseUrl) => ({ prompt, model, maxTokens, assistantPrefillPrompt }, apiKey) => {
       const messages = [];
       messages.push({ role: "user", content: prompt });
@@ -550,11 +553,11 @@ function requireProviderConfig() {
     const parseOpenAiStyleResponse = (errorLabel) => async (response) => {
       if (response.status === 200) {
         const responseBody = await response.json();
-        const responseText = responseBody.choices?.[0]?.message?.content;
+        const responseText = (0, exports$1.extractOpenAiMessageText)(responseBody.choices?.[0]?.message);
         if (responseText) {
           return {
             text: responseText,
-            usage: normalizeOpenAiUsage(responseBody.usage)
+            usage: (0, exports$1.normalizeOpenAiUsage)(responseBody.usage)
           };
         }
         throw new Error(`${errorLabel} API error: Could not extract text from response. Body: ${JSON.stringify(responseBody)}`);
@@ -568,22 +571,28 @@ function requireProviderConfig() {
         throw new Error(`${errorLabel} API error: ${response.status} - ${errorBody}`);
       }
     };
+    const normalizeOpenAiText = (value) => {
+      if (typeof value !== "string") {
+        return void 0;
+      }
+      const trimmed = value.trim();
+      return trimmed.length > 0 ? trimmed : void 0;
+    };
+    const extractOpenAiMessageText = (message) => {
+      if (!message) {
+        return void 0;
+      }
+      return normalizeOpenAiText(message.content) ?? normalizeOpenAiText(message.reasoning) ?? normalizeOpenAiText(message.reasoning_details?.map((detail) => typeof detail === "object" && detail !== null ? "summary" in detail ? detail.summary : void 0 : void 0).find((summary) => summary !== void 0));
+    };
+    exports$1.extractOpenAiMessageText = extractOpenAiMessageText;
     const parseOpenAiGPT5ThinkingStyleResponse = (errorLabel) => async (response) => {
-      const normalize = (value) => {
-        if (typeof value !== "string") {
-          return void 0;
-        }
-        const trimmed = value.trim();
-        return trimmed.length > 0 ? trimmed : void 0;
-      };
       if (response.status === 200) {
         const responseBody = await response.json();
-        const message = responseBody.choices?.[0]?.message;
-        const content = normalize(message?.content) ?? normalize(message?.reasoning) ?? normalize(message?.reasoning_details?.map((detail) => typeof detail === "object" && detail !== null ? "summary" in detail ? detail.summary : void 0 : void 0).find((summary) => summary !== void 0));
+        const content = (0, exports$1.extractOpenAiMessageText)(responseBody.choices?.[0]?.message);
         if (content) {
           return {
             text: content,
-            usage: normalizeOpenAiUsage(responseBody.usage)
+            usage: (0, exports$1.normalizeOpenAiUsage)(responseBody.usage)
           };
         }
         throw new Error(`${errorLabel} API error: Could not extract text from thinking response. Body: ${JSON.stringify(responseBody)}`);
@@ -631,7 +640,7 @@ function requireProviderConfig() {
         if (responseText) {
           return {
             text: responseText,
-            usage: normalizeGeminiUsage(responseBody.usageMetadata)
+            usage: (0, exports$1.normalizeGeminiUsage)(responseBody.usageMetadata)
           };
         }
         throw new Error(`Gemini API error: Could not extract text from response. Body: ${JSON.stringify(responseBody)}`);
@@ -679,6 +688,496 @@ function requireProviderConfig() {
   return providerConfig;
 }
 
+var providerFormatters = {};
+
+var sseParser = {};
+
+var hasRequiredSseParser;
+function requireSseParser() {
+  if (hasRequiredSseParser) return sseParser;
+  hasRequiredSseParser = 1;
+  Object.defineProperty(sseParser, "__esModule", { value: true });
+  sseParser.parseSSEStream = parseSSEStream;
+  async function* parseSSEStream(stream) {
+    const reader = stream.getReader();
+    const decoder = new TextDecoder();
+    let buffer = "";
+    try {
+      while (true) {
+        const { done, value } = await reader.read();
+        if (done)
+          break;
+        buffer += decoder.decode(value, { stream: true });
+        const parts = buffer.split(/\r?\n\r?\n/);
+        buffer = parts.pop();
+        for (const part of parts) {
+          for (const line of part.split(/\r?\n/)) {
+            if (line.startsWith("data: ")) {
+              const data = line.slice(6);
+              if (data === "[DONE]") {
+                return;
+              }
+              yield data;
+            }
+          }
+        }
+      }
+      if (buffer.trim()) {
+        for (const line of buffer.split(/\r?\n/)) {
+          if (line.startsWith("data: ")) {
+            const data = line.slice(6);
+            if (data === "[DONE]") {
+              return;
+            }
+            yield data;
+          }
+        }
+      }
+    } finally {
+      reader.releaseLock();
+    }
+  }
+  return sseParser;
+}
+
+var hasRequiredProviderFormatters;
+function requireProviderFormatters() {
+  if (hasRequiredProviderFormatters) return providerFormatters;
+  hasRequiredProviderFormatters = 1;
+  Object.defineProperty(providerFormatters, "__esModule", { value: true });
+  providerFormatters.buildOpenAiAgenticRequest = buildOpenAiAgenticRequest;
+  providerFormatters.parseOpenAiAgenticResponse = parseOpenAiAgenticResponse;
+  providerFormatters.buildGeminiAgenticRequest = buildGeminiAgenticRequest;
+  providerFormatters.parseGeminiAgenticResponse = parseGeminiAgenticResponse;
+  providerFormatters.streamOpenAiAgenticResponse = streamOpenAiAgenticResponse;
+  providerFormatters.streamGeminiAgenticResponse = streamGeminiAgenticResponse;
+  const provider_config_1 = requireProviderConfig();
+  const sse_parser_1 = requireSseParser();
+  function convertMessagesToOpenAi(messages, systemPrompt) {
+    const result = [];
+    if (systemPrompt) {
+      result.push({ role: "system", content: systemPrompt });
+    }
+    for (const msg of messages) {
+      switch (msg.role) {
+        case "user":
+          result.push({ role: "user", content: msg.content });
+          break;
+        case "assistant": {
+          const textParts = msg.content.filter((c) => c.type === "text").map((c) => c.text).join("");
+          const toolCalls = msg.content.filter((c) => c.type === "toolCall").map((c) => ({
+            id: c.id,
+            type: "function",
+            function: {
+              name: c.name,
+              arguments: JSON.stringify(c.arguments)
+            }
+          }));
+          const openAiMsg = {
+            role: "assistant",
+            content: textParts || null,
+            ...toolCalls.length > 0 ? { tool_calls: toolCalls } : {}
+          };
+          result.push(openAiMsg);
+          break;
+        }
+        case "toolResult":
+          result.push({
+            role: "tool",
+            tool_call_id: msg.toolCallId,
+            content: msg.content
+          });
+          break;
+      }
+    }
+    return result;
+  }
+  function convertToolsToOpenAi(tools) {
+    return tools.map((t) => ({
+      type: "function",
+      function: {
+        name: t.name,
+        description: t.description,
+        parameters: t.parameters
+      }
+    }));
+  }
+  function buildOpenAiAgenticRequest(options, baseUrl, apiKey) {
+    const messages = convertMessagesToOpenAi(options.messages, options.systemPrompt);
+    const tools = convertToolsToOpenAi(options.tools);
+    const body = {
+      messages,
+      tools: tools.length > 0 ? tools : void 0,
+      model: options.model,
+      max_completion_tokens: options.maxTokens,
+      stream: options.stream ?? false
+    };
+    if (options.stream) {
+      body.stream_options = { include_usage: true };
+    }
+    const headers = {
+      "Content-Type": "application/json",
+      Authorization: `Bearer ${apiKey}`
+    };
+    return {
+      url: baseUrl,
+      method: "POST",
+      headers,
+      body,
+      loggableHeaders: {
+        ...headers,
+        Authorization: "Bearer [REDACTED]"
+      },
+      loggableBody: body
+    };
+  }
+  function parseOpenAiToolArguments(rawArguments, toolName, errorLabel) {
+    if (!rawArguments.trim()) {
+      return {};
+    }
+    let parsed;
+    try {
+      parsed = JSON.parse(rawArguments);
+    } catch {
+      const preview = rawArguments.length > 500 ? rawArguments.slice(0, 500) + "..." : rawArguments;
+      throw new Error(`${errorLabel} API error: Invalid JSON arguments for tool "${toolName}": ${preview}`);
+    }
+    if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) {
+      throw new Error(`${errorLabel} API error: Tool "${toolName}" arguments must be a JSON object`);
+    }
+    return parsed;
+  }
+  async function parseOpenAiAgenticResponse(response, errorLabel) {
+    if (response.status !== 200) {
+      const errorBody = await response.text();
+      try {
+        const parsed = JSON.parse(errorBody);
+        const message = parsed?.error?.message || errorBody;
+        throw new Error(`${errorLabel} API error: ${response.status} - ${message}`);
+      } catch (e) {
+        if (e instanceof Error && e.message.startsWith(`${errorLabel} API error:`))
+          throw e;
+        throw new Error(`${errorLabel} API error: ${response.status} - ${errorBody}`);
+      }
+    }
+    const responseBody = await response.json();
+    const choice = responseBody.choices?.[0];
+    if (!choice?.message) {
+      throw new Error(`${errorLabel} API error: No message in response. Body: ${JSON.stringify(responseBody)}`);
+    }
+    const contentBlocks = [];
+    const assistantText = (0, provider_config_1.extractOpenAiMessageText)(choice.message);
+    if (assistantText) {
+      contentBlocks.push({
+        type: "text",
+        text: assistantText
+      });
+    }
+    if (choice.message.tool_calls) {
+      for (const tc of choice.message.tool_calls) {
+        contentBlocks.push({
+          type: "toolCall",
+          id: tc.id,
+          name: tc.function.name,
+          arguments: parseOpenAiToolArguments(tc.function.arguments, tc.function.name, errorLabel)
+        });
+      }
+    }
+    const usage = (0, provider_config_1.normalizeOpenAiUsage)(responseBody.usage);
+    const stopReason = choice.finish_reason === "tool_calls" || choice.finish_reason === "stop" ? choice.finish_reason === "tool_calls" ? "tool_use" : "stop" : choice.message.tool_calls && choice.message.tool_calls.length > 0 ? "tool_use" : "stop";
+    return {
+      message: {
+        role: "assistant",
+        content: contentBlocks
+      },
+      usage,
+      stopReason
+    };
+  }
+  function convertMessagesToGemini(messages) {
+    const result = [];
+    for (const msg of messages) {
+      switch (msg.role) {
+        case "user":
+          result.push({
+            role: "user",
+            parts: [{ text: msg.content }]
+          });
+          break;
+        case "assistant": {
+          const parts = [];
+          for (const block of msg.content) {
+            if (block.type === "text") {
+              parts.push({ text: block.text });
+            } else if (block.type === "toolCall") {
+              parts.push({
+                functionCall: {
+                  name: block.name,
+                  args: block.arguments
+                }
+              });
+            }
+          }
+          result.push({ role: "model", parts });
+          break;
+        }
+        case "toolResult": {
+          result.push({
+            role: "user",
+            parts: [
+              {
+                functionResponse: {
+                  name: msg.toolName,
+                  response: { content: msg.content }
+                }
+              }
+            ]
+          });
+          break;
+        }
+      }
+    }
+    return result;
+  }
+  function convertToolsToGemini(tools) {
+    if (tools.length === 0)
+      return [];
+    return [
+      {
+        functionDeclarations: tools.map((t) => ({
+          name: t.name,
+          description: t.description,
+          parameters: t.parameters
+        }))
+      }
+    ];
+  }
+  function buildGeminiAgenticRequest(options, apiKey) {
+    const contents = convertMessagesToGemini(options.messages);
+    const tools = convertToolsToGemini(options.tools);
+    const body = {
+      contents,
+      generationConfig: {
+        maxOutputTokens: options.maxTokens
+      }
+    };
+    if (tools.length > 0) {
+      body.tools = tools;
+    }
+    if (options.systemPrompt) {
+      body.systemInstruction = {
+        parts: [{ text: options.systemPrompt }]
+      };
+    }
+    const action = options.stream ? "streamGenerateContent" : "generateContent";
+    const altParam = options.stream ? "&alt=sse" : "";
+    const url = `https://generativelanguage.googleapis.com/v1beta/models/${options.model}:${action}?key=${apiKey}${altParam}`;
+    return {
+      url,
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json"
+      },
+      body,
+      loggableUrl: url.replace(/key=[^&]+/, "key=[REDACTED]"),
+      loggableBody: body
+    };
+  }
+  async function parseGeminiAgenticResponse(response) {
+    if (response.status !== 200) {
+      const errorBody = await response.text();
+      try {
+        const parsed = JSON.parse(errorBody);
+        const message = parsed?.error?.message || errorBody;
+        throw new Error(`Gemini API error: ${response.status} - ${message}`);
+      } catch (e) {
+        if (e instanceof Error && e.message.startsWith("Gemini API error:"))
+          throw e;
+        throw new Error(`Gemini API error: ${response.status} - ${errorBody}`);
+      }
+    }
+    const responseBody = await response.json();
+    const candidate = responseBody.candidates?.[0];
+    if (!candidate?.content?.parts) {
+      throw new Error(`Gemini API error: No content in response. Body: ${JSON.stringify(responseBody)}`);
+    }
+    const contentBlocks = [];
+    let hasToolCalls = false;
+    for (const part of candidate.content.parts) {
+      if (part.text) {
+        contentBlocks.push({ type: "text", text: part.text });
+      }
+      if (part.functionCall) {
+        hasToolCalls = true;
+        contentBlocks.push({
+          type: "toolCall",
+          id: crypto.randomUUID(),
+          name: part.functionCall.name,
+          arguments: part.functionCall.args
+        });
+      }
+    }
+    const usage = (0, provider_config_1.normalizeGeminiUsage)(responseBody.usageMetadata);
+    const stopReason = hasToolCalls ? "tool_use" : "stop";
+    return {
+      message: {
+        role: "assistant",
+        content: contentBlocks
+      },
+      usage,
+      stopReason
+    };
+  }
+  function safeEmit(onEvent, event) {
+    if (!onEvent)
+      return;
+    try {
+      onEvent(event);
+    } catch {
+    }
+  }
+  async function streamOpenAiAgenticResponse(response, errorLabel, onEvent) {
+    if (response.status !== 200) {
+      const errorBody = await response.text();
+      try {
+        const parsed = JSON.parse(errorBody);
+        const message = parsed?.error?.message || errorBody;
+        throw new Error(`${errorLabel} API error: ${response.status} - ${message}`);
+      } catch (e) {
+        if (e instanceof Error && e.message.startsWith(`${errorLabel} API error:`))
+          throw e;
+        throw new Error(`${errorLabel} API error: ${response.status} - ${errorBody}`);
+      }
+    }
+    if (!response.body) {
+      throw new Error(`${errorLabel} API error: Response body is null`);
+    }
+    let textContent = "";
+    const toolCallAccumulators = /* @__PURE__ */ new Map();
+    let finishReason = null;
+    let usage = { ...provider_config_1.normalizedUsageZero };
+    for await (const data of (0, sse_parser_1.parseSSEStream)(response.body)) {
+      let chunk;
+      try {
+        chunk = JSON.parse(data);
+      } catch {
+        continue;
+      }
+      if (chunk.usage) {
+        usage = (0, provider_config_1.normalizeOpenAiUsage)(chunk.usage);
+      }
+      const choice = chunk.choices?.[0];
+      if (!choice)
+        continue;
+      if (choice.finish_reason) {
+        finishReason = choice.finish_reason;
+      }
+      const delta = choice.delta;
+      if (!delta)
+        continue;
+      if (delta.content) {
+        textContent += delta.content;
+        safeEmit(onEvent, { type: "text_delta", text: delta.content });
+      }
+      if (delta.tool_calls) {
+        for (const tc of delta.tool_calls) {
+          const existing = toolCallAccumulators.get(tc.index);
+          if (existing) {
+            if (tc.function?.arguments) {
+              existing.arguments += tc.function.arguments;
+            }
+          } else {
+            toolCallAccumulators.set(tc.index, {
+              id: tc.id ?? "",
+              name: tc.function?.name ?? "",
+              arguments: tc.function?.arguments ?? ""
+            });
+          }
+        }
+      }
+    }
+    const contentBlocks = [];
+    if (textContent) {
+      contentBlocks.push({ type: "text", text: textContent });
+    }
+    const sortedToolCalls = [...toolCallAccumulators.entries()].sort(([a], [b]) => a - b);
+    for (const [, tc] of sortedToolCalls) {
+      contentBlocks.push({
+        type: "toolCall",
+        id: tc.id,
+        name: tc.name,
+        arguments: parseOpenAiToolArguments(tc.arguments, tc.name, errorLabel)
+      });
+    }
+    const stopReason2 = finishReason === "tool_calls" || sortedToolCalls.length > 0 ? "tool_use" : "stop";
+    return {
+      message: { role: "assistant", content: contentBlocks },
+      usage,
+      stopReason: stopReason2
+    };
+  }
+  async function streamGeminiAgenticResponse(response, onEvent) {
+    if (response.status !== 200) {
+      const errorBody = await response.text();
+      try {
+        const parsed = JSON.parse(errorBody);
+        const message = parsed?.error?.message || errorBody;
+        throw new Error(`Gemini API error: ${response.status} - ${message}`);
+      } catch (e) {
+        if (e instanceof Error && e.message.startsWith("Gemini API error:"))
+          throw e;
+        throw new Error(`Gemini API error: ${response.status} - ${errorBody}`);
+      }
+    }
+    if (!response.body) {
+      throw new Error("Gemini API error: Response body is null");
+    }
+    const contentBlocks = [];
+    let hasToolCalls2 = false;
+    let textContent2 = "";
+    let usage2 = { ...provider_config_1.normalizedUsageZero };
+    for await (const data of (0, sse_parser_1.parseSSEStream)(response.body)) {
+      let chunk;
+      try {
+        chunk = JSON.parse(data);
+      } catch {
+        continue;
+      }
+      if (chunk.usageMetadata) {
+        usage2 = (0, provider_config_1.normalizeGeminiUsage)(chunk.usageMetadata);
+      }
+      const candidate = chunk.candidates?.[0];
+      if (!candidate?.content?.parts)
+        continue;
+      for (const part of candidate.content.parts) {
+        if (part.text) {
+          textContent2 += part.text;
+          safeEmit(onEvent, { type: "text_delta", text: part.text });
+        }
+        if (part.functionCall) {
+          hasToolCalls2 = true;
+          contentBlocks.push({
+            type: "toolCall",
+            id: crypto.randomUUID(),
+            name: part.functionCall.name,
+            arguments: part.functionCall.args
+          });
+        }
+      }
+    }
+    if (textContent2) {
+      contentBlocks.unshift({ type: "text", text: textContent2 });
+    }
+    const stopReason3 = hasToolCalls2 ? "tool_use" : "stop";
+    return {
+      message: { role: "assistant", content: contentBlocks },
+      usage: usage2,
+      stopReason: stopReason3
+    };
+  }
+  return providerFormatters;
+}
+
 var hasRequiredHttpLlmClient;
 function requireHttpLlmClient() {
   if (hasRequiredHttpLlmClient) return httpLlmClient;
@@ -688,6 +1187,7 @@ function requireHttpLlmClient() {
   const model_info_1 = requireModelInfo();
   const logger_1 = requireLogger();
   const provider_config_1 = requireProviderConfig();
+  const provider_formatters_1 = requireProviderFormatters();
   class HttpLlmClient {
     constructor(providerId, apiKey, logger) {
       this.providerId = providerId;
@@ -695,51 +1195,133 @@ function requireHttpLlmClient() {
       this.logger = logger;
     }
     async sendRequest(prompt, model, maxTokens, assistantPrefillPrompt) {
+      const provider = this.getProviderConfig();
+      const providerModelName = this.getProviderModelName(model);
+      const requestOptions = provider.buildRequest({
+        prompt,
+        model: providerModelName,
+        maxTokens,
+        assistantPrefillPrompt
+      }, this.apiKey);
+      return this.executeProviderCall({
+        provider,
+        model,
+        maxTokens,
+        apiOperation: provider.apiOperation,
+        requestOptions,
+        parseResponse: provider.parseResponse,
+        getResponsePreview: (parsedResponse) => parsedResponse.text,
+        getUsage: (parsedResponse) => parsedResponse.usage
+      });
+    }
+    async sendAgenticRequest(messages, tools, model, maxTokens, systemPrompt, onEvent) {
+      const provider = this.getProviderConfig();
+      const providerModelName = this.getProviderModelName(model);
+      const codec = this.getAgenticProviderCodec(provider.errorLabel);
+      const requestOptions = codec.buildRequest({
+        messages,
+        tools,
+        model: providerModelName,
+        maxTokens,
+        systemPrompt,
+        stream: !!onEvent
+      });
+      const parseResponse = onEvent ? (response) => codec.parseStreamingResponse(response, onEvent) : codec.parseResponse;
+      return this.executeProviderCall({
+        provider,
+        model,
+        maxTokens,
+        apiOperation: "agentic",
+        requestOptions,
+        parseResponse,
+        getResponsePreview: (parsedResponse) => parsedResponse.message.content.filter((content) => content.type === "text").map((content) => content.text).join(""),
+        getUsage: (parsedResponse) => parsedResponse.usage
+      });
+    }
+    getProviderConfig() {
       const provider = provider_config_1.providerConfigs[this.providerId];
       if (!provider) {
         throw new Error(`Unknown LLM provider: ${this.providerId}`);
       }
+      return provider;
+    }
+    getProviderModelName(model) {
       const providerSpecificModelName = model_info_1.SUPPORTED_MODELS[model].find((pm) => pm.provider === this.providerId);
       if (!providerSpecificModelName) {
         throw new Error(`LLM Provider ${this.providerId} does not support model ${model}. If this is an error and the provider does support this model, please contact us to fix it`);
       }
-      const requestOptions = provider.buildRequest({
-        prompt,
-        model: providerSpecificModelName.providerModelName,
-        maxTokens,
-        assistantPrefillPrompt
-      }, this.apiKey);
-      const method = requestOptions.method ?? "POST";
-      const headers = requestOptions.headers ?? {};
-      const bodyPayload = requestOptions.body;
-      const body = typeof bodyPayload === "string" ? bodyPayload : bodyPayload !== void 0 ? JSON.stringify(bodyPayload) : void 0;
+      return providerSpecificModelName.providerModelName;
+    }
+    async executeProviderCall(params) {
+      const method = params.requestOptions.method ?? "POST";
+      const headers = params.requestOptions.headers ?? {};
+      const body = this.toFetchableBody(params.requestOptions.body);
       const spanId = (0, logger_1.generateSpanId)();
       const startTime = Date.now();
-      (0, logger_1.logLlmCallStart)(this.logger, spanId, provider.providerId, provider.apiOperation, {
-        url: requestOptions.loggableUrl ?? requestOptions.url,
+      (0, logger_1.logLlmCallStart)(this.logger, spanId, params.provider.providerId, params.apiOperation, {
+        url: params.requestOptions.loggableUrl ?? params.requestOptions.url,
         httpMethod: method,
-        model,
-        maxTokens
+        model: params.model,
+        maxTokens: params.maxTokens
       });
       try {
-        const response = await fetch(requestOptions.url, {
+        const response = await fetch(params.requestOptions.url, {
           method,
           headers,
           body
         });
-        const parsedResponse = await provider.parseResponse(response);
+        const parsedResponse = await params.parseResponse(response);
         const duration = Date.now() - startTime;
-        (0, logger_1.logLlmCallComplete)(this.logger, spanId, provider.providerId, provider.apiOperation, {
+        (0, logger_1.logLlmCallComplete)(this.logger, spanId, params.provider.providerId, params.apiOperation, {
           status: response.status,
-          responseText: parsedResponse.text,
+          responseText: params.getResponsePreview(parsedResponse),
           headers: Object.fromEntries(response.headers.entries()),
-          usage: parsedResponse.usage
+          usage: params.getUsage(parsedResponse)
         }, duration);
         return parsedResponse;
       } catch (error) {
         const duration = Date.now() - startTime;
-        (0, logger_1.logLlmCallError)(this.logger, spanId, provider.providerId, provider.apiOperation, error, duration);
-        throw new Error(`${provider.errorLabel} API request failed: ${error instanceof Error ? error.message : "Unknown error"}`);
+        (0, logger_1.logLlmCallError)(this.logger, spanId, params.provider.providerId, params.apiOperation, error, duration);
+        throw new Error(`${params.provider.errorLabel} API request failed: ${error instanceof Error ? error.message : "Unknown error"}`);
+      }
+    }
+    toFetchableBody(bodyPayload) {
+      if (typeof bodyPayload === "string") {
+        return bodyPayload;
+      }
+      if (bodyPayload === void 0) {
+        return void 0;
+      }
+      return JSON.stringify(bodyPayload);
+    }
+    getAgenticProviderCodec(errorLabel) {
+      switch (this.providerId) {
+        case "groq":
+          return {
+            buildRequest: (options) => (0, provider_formatters_1.buildOpenAiAgenticRequest)(options, "https://api.groq.com/openai/v1/chat/completions", this.apiKey),
+            parseResponse: (response) => (0, provider_formatters_1.parseOpenAiAgenticResponse)(response, errorLabel),
+            parseStreamingResponse: (response, onEvent) => (0, provider_formatters_1.streamOpenAiAgenticResponse)(response, errorLabel, onEvent)
+          };
+        case "cerebras":
+          return {
+            buildRequest: (options) => (0, provider_formatters_1.buildOpenAiAgenticRequest)(options, "https://api.cerebras.ai/v1/chat/completions", this.apiKey),
+            parseResponse: (response) => (0, provider_formatters_1.parseOpenAiAgenticResponse)(response, errorLabel),
+            parseStreamingResponse: (response, onEvent) => (0, provider_formatters_1.streamOpenAiAgenticResponse)(response, errorLabel, onEvent)
+          };
+        case "openrouter":
+          return {
+            buildRequest: (options) => (0, provider_formatters_1.buildOpenAiAgenticRequest)(options, "https://openrouter.ai/api/v1/chat/completions", this.apiKey),
+            parseResponse: (response) => (0, provider_formatters_1.parseOpenAiAgenticResponse)(response, errorLabel),
+            parseStreamingResponse: (response, onEvent) => (0, provider_formatters_1.streamOpenAiAgenticResponse)(response, errorLabel, onEvent)
+          };
+        case "gemini":
+          return {
+            buildRequest: (options) => (0, provider_formatters_1.buildGeminiAgenticRequest)(options, this.apiKey),
+            parseResponse: provider_formatters_1.parseGeminiAgenticResponse,
+            parseStreamingResponse: (response, onEvent) => (0, provider_formatters_1.streamGeminiAgenticResponse)(response, onEvent)
+          };
+        default:
+          throw new Error(`Unsupported provider for agentic requests: ${this.providerId}`);
       }
     }
   }
@@ -827,7 +1409,8 @@ function requireCastPromptBuilder() {
       `Your entire response should be just the value of '${(0, prompt_template_utils_1.templateVarName)("OUTPUT_TYPE_NAME")}', as valid JSON.`,
       `And it should not be wrapped in any wrapper object -- return exactly what the JSON schema is expecting.`,
       `We will validate the result with the AJV Node library, using ajv.parse, against the given schema, and we expect`,
-      `it to validate correctly.`
+      `it to validate correctly.`,
+      `IMPORTANT: Output raw JSON only. No markdown code fences, no explanation, no commentary, no extra fields beyond the schema. Do not correct yourself -- produce the right answer on the first try.`
     ].join(" ");
     const buildSystemPrompt = (reqParams) => {
       let a = BASE_SYSTEM_PROMPT_WHEN_OUTPUT_TYPE_NAME_PROVIDED;
@@ -879,6 +1462,145 @@ function requireNuaErrors() {
   return nuaErrors;
 }
 
+var agentLoop = {};
+
+var hasRequiredAgentLoop;
+function requireAgentLoop() {
+  if (hasRequiredAgentLoop) return agentLoop;
+  hasRequiredAgentLoop = 1;
+  Object.defineProperty(agentLoop, "__esModule", { value: true });
+  agentLoop.runAgentLoop = runAgentLoop;
+  const provider_config_1 = requireProviderConfig();
+  function safeEmit(onEvent, event) {
+    if (!onEvent)
+      return;
+    try {
+      onEvent(event);
+    } catch {
+    }
+  }
+  async function runAgentLoop(params) {
+    const messages = [...params.messages];
+    let totalUsage = { ...provider_config_1.normalizedUsageZero };
+    const toolsByName = new Map(params.tools.map((tool) => [tool.name, tool]));
+    let completionReason = "max_turns";
+    const onEvent = params.onEvent;
+    for (let turn = 0; turn < params.maxTurns; turn++) {
+      safeEmit(onEvent, { type: "turn_start", turn });
+      let response;
+      try {
+        response = await params.sendRequest(messages, params.tools, params.systemPrompt);
+      } catch (error) {
+        const errorMessage = error instanceof Error ? error.message : "Unknown error";
+        safeEmit(onEvent, { type: "error", error: errorMessage });
+        return buildAgentResult(messages, totalUsage, "error", errorMessage);
+      }
+      messages.push(response.message);
+      totalUsage = addUsage(totalUsage, response.usage);
+      safeEmit(onEvent, {
+        type: "response_complete",
+        message: response.message,
+        usage: response.usage,
+        stopReason: response.stopReason
+      });
+      const toolCalls = response.message.content.filter((c) => c.type === "toolCall");
+      if (toolCalls.length === 0 || response.stopReason === "stop") {
+        completionReason = "stop";
+        return buildAgentResult(messages, totalUsage, completionReason);
+      }
+      for (const toolCall of toolCalls) {
+        safeEmit(onEvent, {
+          type: "tool_start",
+          toolCallId: toolCall.id,
+          toolName: toolCall.name,
+          arguments: toolCall.arguments
+        });
+        const tool = toolsByName.get(toolCall.name);
+        if (!tool) {
+          const result = {
+            content: `Tool "${toolCall.name}" not found`,
+            isError: true
+          };
+          messages.push({
+            role: "toolResult",
+            toolCallId: toolCall.id,
+            toolName: toolCall.name,
+            content: result.content,
+            isError: true
+          });
+          safeEmit(onEvent, {
+            type: "tool_complete",
+            toolCallId: toolCall.id,
+            toolName: toolCall.name,
+            result
+          });
+          continue;
+        }
+        try {
+          const result = await tool.execute(toolCall.arguments);
+          messages.push({
+            role: "toolResult",
+            toolCallId: toolCall.id,
+            toolName: toolCall.name,
+            content: result.content,
+            isError: result.isError ?? false
+          });
+          safeEmit(onEvent, {
+            type: "tool_complete",
+            toolCallId: toolCall.id,
+            toolName: toolCall.name,
+            result
+          });
+        } catch (error) {
+          const errorContent = `Tool execution error: ${error instanceof Error ? error.message : "Unknown error"}`;
+          const result = { content: errorContent, isError: true };
+          messages.push({
+            role: "toolResult",
+            toolCallId: toolCall.id,
+            toolName: toolCall.name,
+            content: errorContent,
+            isError: true
+          });
+          safeEmit(onEvent, {
+            type: "tool_complete",
+            toolCallId: toolCall.id,
+            toolName: toolCall.name,
+            result
+          });
+        }
+      }
+    }
+    return buildAgentResult(messages, totalUsage, completionReason, `Reached maxTurns limit (${params.maxTurns}) before receiving a final response`);
+  }
+  function addUsage(a, b) {
+    return {
+      promptTokens: a.promptTokens + b.promptTokens,
+      completionTokens: a.completionTokens + b.completionTokens,
+      totalTokens: a.totalTokens + b.totalTokens
+    };
+  }
+  function extractLastAssistantText(messages) {
+    const lastAssistant = [...messages].reverse().find((m) => m.role === "assistant");
+    if (lastAssistant?.role !== "assistant") {
+      return void 0;
+    }
+    const text = lastAssistant.content.filter((c) => c.type === "text").map((c) => c.text).join("");
+    return text || void 0;
+  }
+  function buildAgentResult(messages, usage, completionReason, error) {
+    const success = completionReason === "stop" && !error;
+    return {
+      success,
+      completionReason,
+      messages,
+      textResponse: extractLastAssistantText(messages),
+      usage,
+      error
+    };
+  }
+  return agentLoop;
+}
+
 var hasRequiredNuaLlmClient;
 function requireNuaLlmClient() {
   if (hasRequiredNuaLlmClient) return nuaLlmClient;
@@ -893,10 +1615,12 @@ function requireNuaLlmClient() {
   const call_llm_service_1 = requireCallLlmService();
   const nua_json_schema_value_validation_1 = requireNuaJsonSchemaValueValidation();
   const http_llm_client_1 = requireHttpLlmClient();
+  const provider_config_1 = requireProviderConfig();
   const model_info_1 = requireModelInfo();
   const cast_array_prompt_builder_1 = __importDefault(requireCastArrayPromptBuilder());
   const cast_prompt_builder_1 = __importDefault(requireCastPromptBuilder());
   const nua_errors_1 = requireNuaErrors();
+  const agent_loop_1 = requireAgentLoop();
   class NuaLlmClient {
     constructor(config) {
       this.logger = config.logger || new logger_1.ConsoleLogger();
@@ -986,6 +1710,30 @@ function requireNuaLlmClient() {
         };
       }
     }
+    async runAgent(params) {
+      try {
+        const model = this.resolveModel(params.model);
+        const client = this.getClientForModel(model);
+        const maxTokens = params.maxTokens ?? 4096;
+        const maxTurns = params.maxTurns ?? 10;
+        return (0, agent_loop_1.runAgentLoop)({
+          messages: params.messages,
+          tools: params.tools,
+          systemPrompt: params.systemPrompt,
+          maxTurns,
+          onEvent: params.onEvent,
+          sendRequest: (messages, tools, systemPrompt) => client.sendAgenticRequest(messages, tools, model, maxTokens, systemPrompt, params.onEvent)
+        });
+      } catch (e) {
+        return {
+          success: false,
+          completionReason: "error",
+          messages: params.messages,
+          usage: provider_config_1.normalizedUsageZero,
+          error: e instanceof Error ? e.message : String(e)
+        };
+      }
+    }
   }
   nuaLlmClient.NuaLlmClient = NuaLlmClient;
   return nuaLlmClient;
@@ -1159,7 +1907,7 @@ function requireDist() {
       return mod && mod.__esModule ? mod : { "default": mod };
     };
     Object.defineProperty(exports$1, "__esModule", { value: true });
-    exports$1.stableStringify = exports$1.validateJsonSchema = exports$1.providerConfigs = exports$1.normalizedUsageZero = exports$1.castArrayPromptBuilder = exports$1.castPromptBuilder = void 0;
+    exports$1.runAgentLoop = exports$1.stableStringify = exports$1.validateJsonSchema = exports$1.providerConfigs = exports$1.normalizedUsageZero = exports$1.castArrayPromptBuilder = exports$1.castPromptBuilder = void 0;
     __exportStar(requireNuaLlmClient(), exports$1);
     __exportStar(requireLogger(), exports$1);
     __exportStar(requireTypes(), exports$1);
@@ -1189,6 +1937,10 @@ function requireDist() {
     } });
     __exportStar(requireModelInfo(), exports$1);
     __exportStar(requireSchemaUtils(), exports$1);
+    var agent_loop_1 = requireAgentLoop();
+    Object.defineProperty(exports$1, "runAgentLoop", { enumerable: true, get: function() {
+      return agent_loop_1.runAgentLoop;
+    } });
   })(dist);
   return dist;
 }
@@ -1280,12 +2032,16 @@ function resolveConfigValue(config, key, envVar) {
 }
 
 const isBrowserEnvironment = () => typeof window !== "undefined" && !!window.document;
-const isLocalhost = () => {
-  if (typeof window === "undefined" || !window.location) {
-    return false;
-  }
+const isDevelopmentLikeBrowserEnvironment = () => {
+  if (typeof window === "undefined") return false;
   const host = window.location.hostname;
-  return host === "localhost" || host === "127.0.0.1";
+  if (host === "localhost" || host === "127.0.0.1") return true;
+  if (typeof process !== "undefined") {
+    if (process.env?.NODE_ENV === "development") {
+      return true;
+    }
+  }
+  return false;
 };
 class AuthTokenManager {
   constructor(config) {
@@ -1300,12 +2056,10 @@ class AuthTokenManager {
       );
     }
     if (this.apiKey && isBrowserEnvironment()) {
-      const allowedLocally = config.dangerouslyAllowBrowserApiKeyInLocalhost && isLocalhost();
-      if (!allowedLocally) {
+      if (!(config.dangerouslyAllowBrowserApiKeyInLocalhost && isDevelopmentLikeBrowserEnvironment()))
         throw new Error(
           "found config.apiKey. It is a private secret that must only be used in server environments."
         );
-      }
     }
   }
   async getToken() {
@@ -1413,7 +2167,7 @@ class GatewayBackend {
       success: true,
       data: apiResponse.data,
       usage,
-      model: apiResponse.model ?? "unknown",
+      model: apiResponse.model,
       latencyMs,
       source: "gateway",
       meta: {
@@ -1445,7 +2199,7 @@ class GatewayBackend {
       success: true,
       data: apiResponse.data,
       usage,
-      model: apiResponse.model ?? "unknown",
+      model: apiResponse.model,
       latencyMs,
       source: "gateway",
       meta: {