@merit-systems/echo-react-sdk 1.0.39-test.95844400.0 → 1.0.39-test.e7bb7c63.0

package/dist/index.js

@@ -13460,7 +13460,7 @@ var webSearch_20250305 = (args = {}) => {
 function isWebSearchTool(tool2) {
   return typeof tool2 === "object" && tool2 !== null && "type" in tool2 && tool2.type === "web_search_20250305";
 }
-function prepareTools$2({
+function prepareTools$3({
   tools,
   toolChoice,
   disableParallelToolUse
@@ -14318,7 +14318,7 @@ var AnthropicMessagesLanguageModel = class {
       toolChoice: anthropicToolChoice,
       toolWarnings,
       betas: toolsBetas
-    } = prepareTools$2(
+    } = prepareTools$3(
       jsonResponseTool != null ? {
         tools: [jsonResponseTool],
         toolChoice: { type: "tool", toolName: jsonResponseTool.name },
@@ -15858,7 +15858,7 @@ var googleGenerativeAIProviderOptions = object({
    */
   labels: record(string$1(), string$1()).optional()
 });
-function prepareTools$1({
+function prepareTools$2({
   tools,
   toolChoice,
   modelId
@@ -16124,7 +16124,7 @@ var GoogleGenerativeAILanguageModel = class {
       tools: googleTools2,
       toolConfig: googleToolConfig,
       toolWarnings
-    } = prepareTools$1({
+    } = prepareTools$2({
       tools,
       toolChoice,
       modelId: this.modelId
@@ -16602,7 +16602,7 @@ var safetyRatingSchema = object({
   severityScore: number$1().nullish(),
   blocked: boolean$1().nullish()
 });
-var usageSchema$1 = object({
+var usageSchema$2 = object({
   cachedContentTokenCount: number$1().nullish(),
   thoughtsTokenCount: number$1().nullish(),
   promptTokenCount: number$1().nullish(),
@@ -16619,7 +16619,7 @@ var responseSchema = object({
       urlContextMetadata: urlContextMetadataSchema.nullish()
     })
   ),
-  usageMetadata: usageSchema$1.nullish()
+  usageMetadata: usageSchema$2.nullish()
 });
 var chunkSchema = object({
   candidates: array(
@@ -16631,7 +16631,7 @@ var chunkSchema = object({
       urlContextMetadata: urlContextMetadataSchema.nullish()
     })
   ).nullish(),
-  usageMetadata: usageSchema$1.nullish()
+  usageMetadata: usageSchema$2.nullish()
 });
 var codeExecution = createProviderDefinedToolFactoryWithOutputSchema({
   id: "google.code_execution",
@@ -17484,7 +17484,7 @@ function convertToGroqChatMessages(prompt) {
   }
   return messages;
 }
-function getResponseMetadata$1({
+function getResponseMetadata$2({
   id: id2,
   model,
   created
@@ -17543,7 +17543,7 @@ function isBrowserSearchSupportedModel(modelId) {
 function getSupportedModelsString() {
   return BROWSER_SEARCH_SUPPORTED_MODELS.join(", ");
 }
-function prepareTools({
+function prepareTools$1({
   tools,
   toolChoice,
   modelId
@@ -17678,7 +17678,7 @@ var GroqChatLanguageModel = class {
       tools: groqTools2,
       toolChoice: groqToolChoice,
       toolWarnings
-    } = prepareTools({ tools, toolChoice, modelId: this.modelId });
+    } = prepareTools$1({ tools, toolChoice, modelId: this.modelId });
     return {
       args: {
         // model id:
@@ -17773,7 +17773,7 @@ var GroqChatLanguageModel = class {
         totalTokens: (_g = (_f = response.usage) == null ? void 0 : _f.total_tokens) != null ? _g : void 0
       },
       response: {
-        ...getResponseMetadata$1(response),
+        ...getResponseMetadata$2(response),
         headers: responseHeaders,
         body: rawResponse
       },
@@ -17835,7 +17835,7 @@ var GroqChatLanguageModel = class {
               isFirstChunk = false;
               controller.enqueue({
                 type: "response-metadata",
-                ...getResponseMetadata$1(value)
+                ...getResponseMetadata$2(value)
               });
             }
             if (((_a10 = value.x_groq) == null ? void 0 : _a10.usage) != null) {
@@ -17966,18 +17966,1077 @@ var GroqChatLanguageModel = class {
             }
           },
           flush(controller) {
-            if (isActiveReasoning) {
-              controller.enqueue({ type: "reasoning-end", id: "reasoning-0" });
-            }
-            if (isActiveText) {
-              controller.enqueue({ type: "text-end", id: "txt-0" });
+            if (isActiveReasoning) {
+              controller.enqueue({ type: "reasoning-end", id: "reasoning-0" });
+            }
+            if (isActiveText) {
+              controller.enqueue({ type: "text-end", id: "txt-0" });
+            }
+            controller.enqueue({
+              type: "finish",
+              finishReason,
+              usage,
+              ...{}
+            });
+          }
+        })
+      ),
+      request: { body },
+      response: { headers: responseHeaders }
+    };
+  }
+};
+var groqChatResponseSchema = object({
+  id: string$1().nullish(),
+  created: number$1().nullish(),
+  model: string$1().nullish(),
+  choices: array(
+    object({
+      message: object({
+        content: string$1().nullish(),
+        reasoning: string$1().nullish(),
+        tool_calls: array(
+          object({
+            id: string$1().nullish(),
+            type: literal("function"),
+            function: object({
+              name: string$1(),
+              arguments: string$1()
+            })
+          })
+        ).nullish()
+      }),
+      index: number$1(),
+      finish_reason: string$1().nullish()
+    })
+  ),
+  usage: object({
+    prompt_tokens: number$1().nullish(),
+    completion_tokens: number$1().nullish(),
+    total_tokens: number$1().nullish()
+  }).nullish()
+});
+var groqChatChunkSchema = union([
+  object({
+    id: string$1().nullish(),
+    created: number$1().nullish(),
+    model: string$1().nullish(),
+    choices: array(
+      object({
+        delta: object({
+          content: string$1().nullish(),
+          reasoning: string$1().nullish(),
+          tool_calls: array(
+            object({
+              index: number$1(),
+              id: string$1().nullish(),
+              type: literal("function").optional(),
+              function: object({
+                name: string$1().nullish(),
+                arguments: string$1().nullish()
+              })
+            })
+          ).nullish()
+        }).nullish(),
+        finish_reason: string$1().nullable().optional(),
+        index: number$1()
+      })
+    ),
+    x_groq: object({
+      usage: object({
+        prompt_tokens: number$1().nullish(),
+        completion_tokens: number$1().nullish(),
+        total_tokens: number$1().nullish()
+      }).nullish()
+    }).nullish()
+  }),
+  groqErrorDataSchema
+]);
+var groqProviderOptionsSchema = object({
+  language: string$1().nullish(),
+  prompt: string$1().nullish(),
+  responseFormat: string$1().nullish(),
+  temperature: number$1().min(0).max(1).nullish(),
+  timestampGranularities: array(string$1()).nullish()
+});
+var GroqTranscriptionModel = class {
+  constructor(modelId, config2) {
+    this.modelId = modelId;
+    this.config = config2;
+    this.specificationVersion = "v2";
+  }
+  get provider() {
+    return this.config.provider;
+  }
+  async getArgs({
+    audio,
+    mediaType,
+    providerOptions
+  }) {
+    var _a10, _b, _c, _d, _e;
+    const warnings = [];
+    const groqOptions = await parseProviderOptions({
+      provider: "groq",
+      providerOptions,
+      schema: groqProviderOptionsSchema
+    });
+    const formData = new FormData();
+    const blob = audio instanceof Uint8Array ? new Blob([audio]) : new Blob([convertBase64ToUint8Array(audio)]);
+    formData.append("model", this.modelId);
+    const fileExtension = mediaTypeToExtension(mediaType);
+    formData.append(
+      "file",
+      new File([blob], "audio", { type: mediaType }),
+      `audio.${fileExtension}`
+    );
+    if (groqOptions) {
+      const transcriptionModelOptions = {
+        language: (_a10 = groqOptions.language) != null ? _a10 : void 0,
+        prompt: (_b = groqOptions.prompt) != null ? _b : void 0,
+        response_format: (_c = groqOptions.responseFormat) != null ? _c : void 0,
+        temperature: (_d = groqOptions.temperature) != null ? _d : void 0,
+        timestamp_granularities: (_e = groqOptions.timestampGranularities) != null ? _e : void 0
+      };
+      for (const key in transcriptionModelOptions) {
+        const value = transcriptionModelOptions[key];
+        if (value !== void 0) {
+          formData.append(key, String(value));
+        }
+      }
+    }
+    return {
+      formData,
+      warnings
+    };
+  }
+  async doGenerate(options) {
+    var _a10, _b, _c, _d, _e, _f, _g;
+    const currentDate = (_c = (_b = (_a10 = this.config._internal) == null ? void 0 : _a10.currentDate) == null ? void 0 : _b.call(_a10)) != null ? _c : /* @__PURE__ */ new Date();
+    const { formData, warnings } = await this.getArgs(options);
+    const {
+      value: response,
+      responseHeaders,
+      rawValue: rawResponse
+    } = await postFormDataToApi({
+      url: this.config.url({
+        path: "/audio/transcriptions",
+        modelId: this.modelId
+      }),
+      headers: combineHeaders$1(this.config.headers(), options.headers),
+      formData,
+      failedResponseHandler: groqFailedResponseHandler,
+      successfulResponseHandler: createJsonResponseHandler$1(
+        groqTranscriptionResponseSchema
+      ),
+      abortSignal: options.abortSignal,
+      fetch: this.config.fetch
+    });
+    return {
+      text: response.text,
+      segments: (_e = (_d = response.segments) == null ? void 0 : _d.map((segment) => ({
+        text: segment.text,
+        startSecond: segment.start,
+        endSecond: segment.end
+      }))) != null ? _e : [],
+      language: (_f = response.language) != null ? _f : void 0,
+      durationInSeconds: (_g = response.duration) != null ? _g : void 0,
+      warnings,
+      response: {
+        timestamp: currentDate,
+        modelId: this.modelId,
+        headers: responseHeaders,
+        body: rawResponse
+      }
+    };
+  }
+};
+var groqTranscriptionResponseSchema = object({
+  text: string$1(),
+  x_groq: object({
+    id: string$1()
+  }),
+  // additional properties are returned when `response_format: 'verbose_json'` is
+  task: string$1().nullish(),
+  language: string$1().nullish(),
+  duration: number$1().nullish(),
+  segments: array(
+    object({
+      id: number$1(),
+      seek: number$1(),
+      start: number$1(),
+      end: number$1(),
+      text: string$1(),
+      tokens: array(number$1()),
+      temperature: number$1(),
+      avg_logprob: number$1(),
+      compression_ratio: number$1(),
+      no_speech_prob: number$1()
+    })
+  ).nullish()
+});
+var browserSearch = createProviderDefinedToolFactory({
+  id: "groq.browser_search",
+  name: "browser_search",
+  inputSchema: object({})
+});
+var groqTools = {
+  browserSearch
+};
+function createGroq(options = {}) {
+  var _a10;
+  const baseURL = (_a10 = withoutTrailingSlash$1(options.baseURL)) != null ? _a10 : "https://api.groq.com/openai/v1";
+  const getHeaders = () => ({
+    Authorization: `Bearer ${loadApiKey$1({
+      apiKey: options.apiKey,
+      environmentVariableName: "GROQ_API_KEY",
+      description: "Groq"
+    })}`,
+    ...options.headers
+  });
+  const createChatModel = (modelId) => new GroqChatLanguageModel(modelId, {
+    provider: "groq.chat",
+    url: ({ path }) => `${baseURL}${path}`,
+    headers: getHeaders,
+    fetch: options.fetch
+  });
+  const createLanguageModel = (modelId) => {
+    if (new.target) {
+      throw new Error(
+        "The Groq model function cannot be called with the new keyword."
+      );
+    }
+    return createChatModel(modelId);
+  };
+  const createTranscriptionModel = (modelId) => {
+    return new GroqTranscriptionModel(modelId, {
+      provider: "groq.transcription",
+      url: ({ path }) => `${baseURL}${path}`,
+      headers: getHeaders,
+      fetch: options.fetch
+    });
+  };
+  const provider = function(modelId) {
+    return createLanguageModel(modelId);
+  };
+  provider.languageModel = createLanguageModel;
+  provider.chat = createChatModel;
+  provider.textEmbeddingModel = (modelId) => {
+    throw new NoSuchModelError({ modelId, modelType: "textEmbeddingModel" });
+  };
+  provider.imageModel = (modelId) => {
+    throw new NoSuchModelError({ modelId, modelType: "imageModel" });
+  };
+  provider.transcription = createTranscriptionModel;
+  provider.transcriptionModel = createTranscriptionModel;
+  provider.tools = groqTools;
+  return provider;
+}
+createGroq();
+object({
+  /**
+   * A unique identifier representing your end-user, which can help the provider to
+   * monitor and detect abuse.
+   */
+  user: string$1().optional(),
+  /**
+   * Reasoning effort for reasoning models. Defaults to `medium`.
+   */
+  reasoningEffort: string$1().optional()
+});
+var openaiCompatibleErrorDataSchema = object({
+  error: object({
+    message: string$1(),
+    // The additional information below is handled loosely to support
+    // OpenAI-compatible providers that have slightly different error
+    // responses:
+    type: string$1().nullish(),
+    param: any().nullish(),
+    code: union([string$1(), number$1()]).nullish()
+  })
+});
+var defaultOpenAICompatibleErrorStructure = {
+  errorSchema: openaiCompatibleErrorDataSchema,
+  errorToMessage: (data) => data.error.message
+};
+var openaiCompatibleTokenUsageSchema = object({
+  prompt_tokens: number$1().nullish(),
+  completion_tokens: number$1().nullish(),
+  total_tokens: number$1().nullish(),
+  prompt_tokens_details: object({
+    cached_tokens: number$1().nullish()
+  }).nullish(),
+  completion_tokens_details: object({
+    reasoning_tokens: number$1().nullish(),
+    accepted_prediction_tokens: number$1().nullish(),
+    rejected_prediction_tokens: number$1().nullish()
+  }).nullish()
+}).nullish();
+object({
+  id: string$1().nullish(),
+  created: number$1().nullish(),
+  model: string$1().nullish(),
+  choices: array(
+    object({
+      message: object({
+        role: literal("assistant").nullish(),
+        content: string$1().nullish(),
+        reasoning_content: string$1().nullish(),
+        reasoning: string$1().nullish(),
+        tool_calls: array(
+          object({
+            id: string$1().nullish(),
+            function: object({
+              name: string$1(),
+              arguments: string$1()
+            })
+          })
+        ).nullish()
+      }),
+      finish_reason: string$1().nullish()
+    })
+  ),
+  usage: openaiCompatibleTokenUsageSchema
+});
+object({
+  /**
+   * Echo back the prompt in addition to the completion.
+   */
+  echo: boolean$1().optional(),
+  /**
+   * Modify the likelihood of specified tokens appearing in the completion.
+   *
+   * Accepts a JSON object that maps tokens (specified by their token ID in
+   * the GPT tokenizer) to an associated bias value from -100 to 100.
+   */
+  logitBias: record(string$1(), number$1()).optional(),
+  /**
+   * The suffix that comes after a completion of inserted text.
+   */
+  suffix: string$1().optional(),
+  /**
+   * A unique identifier representing your end-user, which can help providers to
+   * monitor and detect abuse.
+   */
+  user: string$1().optional()
+});
+var usageSchema$1 = object({
+  prompt_tokens: number$1(),
+  completion_tokens: number$1(),
+  total_tokens: number$1()
+});
+object({
+  id: string$1().nullish(),
+  created: number$1().nullish(),
+  model: string$1().nullish(),
+  choices: array(
+    object({
+      text: string$1(),
+      finish_reason: string$1()
+    })
+  ),
+  usage: usageSchema$1.nullish()
+});
+object({
+  /**
+   * The number of dimensions the resulting output embeddings should have.
+   * Only supported in text-embedding-3 and later models.
+   */
+  dimensions: number$1().optional(),
+  /**
+   * A unique identifier representing your end-user, which can help providers to
+   * monitor and detect abuse.
+   */
+  user: string$1().optional()
+});
+object({
+  data: array(object({ embedding: array(number$1()) })),
+  usage: object({ prompt_tokens: number$1() }).nullish(),
+  providerMetadata: record(string$1(), record(string$1(), any())).optional()
+});
+var OpenAICompatibleImageModel = class {
+  constructor(modelId, config2) {
+    this.modelId = modelId;
+    this.config = config2;
+    this.specificationVersion = "v2";
+    this.maxImagesPerCall = 10;
+  }
+  get provider() {
+    return this.config.provider;
+  }
+  async doGenerate({
+    prompt,
+    n,
+    size,
+    aspectRatio,
+    seed,
+    providerOptions,
+    headers,
+    abortSignal
+  }) {
+    var _a10, _b, _c, _d, _e;
+    const warnings = [];
+    if (aspectRatio != null) {
+      warnings.push({
+        type: "unsupported-setting",
+        setting: "aspectRatio",
+        details: "This model does not support aspect ratio. Use `size` instead."
+      });
+    }
+    if (seed != null) {
+      warnings.push({ type: "unsupported-setting", setting: "seed" });
+    }
+    const currentDate = (_c = (_b = (_a10 = this.config._internal) == null ? void 0 : _a10.currentDate) == null ? void 0 : _b.call(_a10)) != null ? _c : /* @__PURE__ */ new Date();
+    const { value: response, responseHeaders } = await postJsonToApi$1({
+      url: this.config.url({
+        path: "/images/generations",
+        modelId: this.modelId
+      }),
+      headers: combineHeaders$1(this.config.headers(), headers),
+      body: {
+        model: this.modelId,
+        prompt,
+        n,
+        size,
+        ...(_d = providerOptions.openai) != null ? _d : {},
+        response_format: "b64_json"
+      },
+      failedResponseHandler: createJsonErrorResponseHandler$1(
+        (_e = this.config.errorStructure) != null ? _e : defaultOpenAICompatibleErrorStructure
+      ),
+      successfulResponseHandler: createJsonResponseHandler$1(
+        openaiCompatibleImageResponseSchema
+      ),
+      abortSignal,
+      fetch: this.config.fetch
+    });
+    return {
+      images: response.data.map((item) => item.b64_json),
+      warnings,
+      response: {
+        timestamp: currentDate,
+        modelId: this.modelId,
+        headers: responseHeaders
+      }
+    };
+  }
+};
+var openaiCompatibleImageResponseSchema = object({
+  data: array(object({ b64_json: string$1() }))
+});
+function convertToXaiChatMessages(prompt) {
+  const messages = [];
+  const warnings = [];
+  for (const { role, content } of prompt) {
+    switch (role) {
+      case "system": {
+        messages.push({ role: "system", content });
+        break;
+      }
+      case "user": {
+        if (content.length === 1 && content[0].type === "text") {
+          messages.push({ role: "user", content: content[0].text });
+          break;
+        }
+        messages.push({
+          role: "user",
+          content: content.map((part) => {
+            switch (part.type) {
+              case "text": {
+                return { type: "text", text: part.text };
+              }
+              case "file": {
+                if (part.mediaType.startsWith("image/")) {
+                  const mediaType = part.mediaType === "image/*" ? "image/jpeg" : part.mediaType;
+                  return {
+                    type: "image_url",
+                    image_url: {
+                      url: part.data instanceof URL ? part.data.toString() : `data:${mediaType};base64,${convertToBase64(part.data)}`
+                    }
+                  };
+                } else {
+                  throw new UnsupportedFunctionalityError$1({
+                    functionality: `file part media type ${part.mediaType}`
+                  });
+                }
+              }
+            }
+          })
+        });
+        break;
+      }
+      case "assistant": {
+        let text2 = "";
+        const toolCalls = [];
+        for (const part of content) {
+          switch (part.type) {
+            case "text": {
+              text2 += part.text;
+              break;
+            }
+            case "tool-call": {
+              toolCalls.push({
+                id: part.toolCallId,
+                type: "function",
+                function: {
+                  name: part.toolName,
+                  arguments: JSON.stringify(part.input)
+                }
+              });
+              break;
+            }
+          }
+        }
+        messages.push({
+          role: "assistant",
+          content: text2,
+          tool_calls: toolCalls.length > 0 ? toolCalls : void 0
+        });
+        break;
+      }
+      case "tool": {
+        for (const toolResponse of content) {
+          const output = toolResponse.output;
+          let contentValue;
+          switch (output.type) {
+            case "text":
+            case "error-text":
+              contentValue = output.value;
+              break;
+            case "content":
+            case "json":
+            case "error-json":
+              contentValue = JSON.stringify(output.value);
+              break;
+          }
+          messages.push({
+            role: "tool",
+            tool_call_id: toolResponse.toolCallId,
+            content: contentValue
+          });
+        }
+        break;
+      }
+      default: {
+        const _exhaustiveCheck = role;
+        throw new Error(`Unsupported role: ${_exhaustiveCheck}`);
+      }
+    }
+  }
+  return { messages, warnings };
+}
+function getResponseMetadata$1({
+  id: id2,
+  model,
+  created
+}) {
+  return {
+    id: id2 != null ? id2 : void 0,
+    modelId: model != null ? model : void 0,
+    timestamp: created != null ? new Date(created * 1e3) : void 0
+  };
+}
+function mapXaiFinishReason(finishReason) {
+  switch (finishReason) {
+    case "stop":
+      return "stop";
+    case "length":
+      return "length";
+    case "tool_calls":
+    case "function_call":
+      return "tool-calls";
+    case "content_filter":
+      return "content-filter";
+    default:
+      return "unknown";
+  }
+}
+var webSourceSchema = object({
+  type: literal("web"),
+  country: string$1().length(2).optional(),
+  excludedWebsites: array(string$1()).max(5).optional(),
+  allowedWebsites: array(string$1()).max(5).optional(),
+  safeSearch: boolean$1().optional()
+});
+var xSourceSchema = object({
+  type: literal("x"),
+  xHandles: array(string$1()).optional()
+});
+var newsSourceSchema = object({
+  type: literal("news"),
+  country: string$1().length(2).optional(),
+  excludedWebsites: array(string$1()).max(5).optional(),
+  safeSearch: boolean$1().optional()
+});
+var rssSourceSchema = object({
+  type: literal("rss"),
+  links: array(string$1().url()).max(1)
+  // currently only supports one RSS link
+});
+var searchSourceSchema = discriminatedUnion("type", [
+  webSourceSchema,
+  xSourceSchema,
+  newsSourceSchema,
+  rssSourceSchema
+]);
+var xaiProviderOptions = object({
+  /**
+   * reasoning effort for reasoning models
+   * only supported by grok-3-mini and grok-3-mini-fast models
+   */
+  reasoningEffort: _enum(["low", "high"]).optional(),
+  searchParameters: object({
+    /**
+     * search mode preference
+     * - "off": disables search completely
+     * - "auto": model decides whether to search (default)
+     * - "on": always enables search
+     */
+    mode: _enum(["off", "auto", "on"]),
+    /**
+     * whether to return citations in the response
+     * defaults to true
+     */
+    returnCitations: boolean$1().optional(),
+    /**
+     * start date for search data (ISO8601 format: YYYY-MM-DD)
+     */
+    fromDate: string$1().optional(),
+    /**
+     * end date for search data (ISO8601 format: YYYY-MM-DD)
+     */
+    toDate: string$1().optional(),
+    /**
+     * maximum number of search results to consider
+     * defaults to 20
+     */
+    maxSearchResults: number$1().min(1).max(50).optional(),
+    /**
+     * data sources to search from
+     * defaults to ["web", "x"] if not specified
+     */
+    sources: array(searchSourceSchema).optional()
+  }).optional()
+});
+var xaiErrorDataSchema = object({
+  error: object({
+    message: string$1(),
+    type: string$1().nullish(),
+    param: any().nullish(),
+    code: union([string$1(), number$1()]).nullish()
+  })
+});
+var xaiFailedResponseHandler = createJsonErrorResponseHandler$1({
+  errorSchema: xaiErrorDataSchema,
+  errorToMessage: (data) => data.error.message
+});
+function prepareTools({
+  tools,
+  toolChoice
+}) {
+  tools = (tools == null ? void 0 : tools.length) ? tools : void 0;
+  const toolWarnings = [];
+  if (tools == null) {
+    return { tools: void 0, toolChoice: void 0, toolWarnings };
+  }
+  const xaiTools = [];
+  for (const tool2 of tools) {
+    if (tool2.type === "provider-defined") {
+      toolWarnings.push({ type: "unsupported-tool", tool: tool2 });
+    } else {
+      xaiTools.push({
+        type: "function",
+        function: {
+          name: tool2.name,
+          description: tool2.description,
+          parameters: tool2.inputSchema
+        }
+      });
+    }
+  }
+  if (toolChoice == null) {
+    return { tools: xaiTools, toolChoice: void 0, toolWarnings };
+  }
+  const type = toolChoice.type;
+  switch (type) {
+    case "auto":
+    case "none":
+      return { tools: xaiTools, toolChoice: type, toolWarnings };
+    case "required":
+      return { tools: xaiTools, toolChoice: "required", toolWarnings };
+    case "tool":
+      return {
+        tools: xaiTools,
+        toolChoice: {
+          type: "function",
+          function: { name: toolChoice.toolName }
+        },
+        toolWarnings
+      };
+    default: {
+      const _exhaustiveCheck = type;
+      throw new UnsupportedFunctionalityError$1({
+        functionality: `tool choice type: ${_exhaustiveCheck}`
+      });
+    }
+  }
+}
+var XaiChatLanguageModel = class {
+  constructor(modelId, config2) {
+    this.specificationVersion = "v2";
+    this.supportedUrls = {
+      "image/*": [/^https?:\/\/.*$/]
+    };
+    this.modelId = modelId;
+    this.config = config2;
+  }
+  get provider() {
+    return this.config.provider;
+  }
+  async getArgs({
+    prompt,
+    maxOutputTokens,
+    temperature,
+    topP,
+    topK,
+    frequencyPenalty,
+    presencePenalty,
+    stopSequences,
+    seed,
+    responseFormat,
+    providerOptions,
+    tools,
+    toolChoice
+  }) {
+    var _a10, _b, _c;
+    const warnings = [];
+    const options = (_a10 = await parseProviderOptions({
+      provider: "xai",
+      providerOptions,
+      schema: xaiProviderOptions
+    })) != null ? _a10 : {};
+    if (topK != null) {
+      warnings.push({
+        type: "unsupported-setting",
+        setting: "topK"
+      });
+    }
+    if (frequencyPenalty != null) {
+      warnings.push({
+        type: "unsupported-setting",
+        setting: "frequencyPenalty"
+      });
+    }
+    if (presencePenalty != null) {
+      warnings.push({
+        type: "unsupported-setting",
+        setting: "presencePenalty"
+      });
+    }
+    if (stopSequences != null) {
+      warnings.push({
+        type: "unsupported-setting",
+        setting: "stopSequences"
+      });
+    }
+    if (responseFormat != null && responseFormat.type === "json" && responseFormat.schema != null) {
+      warnings.push({
+        type: "unsupported-setting",
+        setting: "responseFormat",
+        details: "JSON response format schema is not supported"
+      });
+    }
+    const { messages, warnings: messageWarnings } = convertToXaiChatMessages(prompt);
+    warnings.push(...messageWarnings);
+    const {
+      tools: xaiTools,
+      toolChoice: xaiToolChoice,
+      toolWarnings
+    } = prepareTools({
+      tools,
+      toolChoice
+    });
+    warnings.push(...toolWarnings);
+    const baseArgs = {
+      // model id
+      model: this.modelId,
+      // standard generation settings
+      max_tokens: maxOutputTokens,
+      temperature,
+      top_p: topP,
+      seed,
+      reasoning_effort: options.reasoningEffort,
+      // response format
+      response_format: (responseFormat == null ? void 0 : responseFormat.type) === "json" ? responseFormat.schema != null ? {
+        type: "json_schema",
+        json_schema: {
+          name: (_b = responseFormat.name) != null ? _b : "response",
+          schema: responseFormat.schema,
+          strict: true
+        }
+      } : { type: "json_object" } : void 0,
+      // search parameters
+      search_parameters: options.searchParameters ? {
+        mode: options.searchParameters.mode,
+        return_citations: options.searchParameters.returnCitations,
+        from_date: options.searchParameters.fromDate,
+        to_date: options.searchParameters.toDate,
+        max_search_results: options.searchParameters.maxSearchResults,
+        sources: (_c = options.searchParameters.sources) == null ? void 0 : _c.map((source) => ({
+          type: source.type,
+          ...source.type === "web" && {
+            country: source.country,
+            excluded_websites: source.excludedWebsites,
+            allowed_websites: source.allowedWebsites,
+            safe_search: source.safeSearch
+          },
+          ...source.type === "x" && {
+            x_handles: source.xHandles
+          },
+          ...source.type === "news" && {
+            country: source.country,
+            excluded_websites: source.excludedWebsites,
+            safe_search: source.safeSearch
+          },
+          ...source.type === "rss" && {
+            links: source.links
+          }
+        }))
+      } : void 0,
+      // messages in xai format
+      messages,
+      // tools in xai format
+      tools: xaiTools,
+      tool_choice: xaiToolChoice
+    };
+    return {
+      args: baseArgs,
+      warnings
+    };
+  }
+  async doGenerate(options) {
+    var _a10, _b, _c;
+    const { args: body, warnings } = await this.getArgs(options);
+    const {
+      responseHeaders,
+      value: response,
+      rawValue: rawResponse
+    } = await postJsonToApi$1({
+      url: `${(_a10 = this.config.baseURL) != null ? _a10 : "https://api.x.ai/v1"}/chat/completions`,
+      headers: combineHeaders$1(this.config.headers(), options.headers),
+      body,
+      failedResponseHandler: xaiFailedResponseHandler,
+      successfulResponseHandler: createJsonResponseHandler$1(
+        xaiChatResponseSchema
+      ),
+      abortSignal: options.abortSignal,
+      fetch: this.config.fetch
+    });
+    const choice = response.choices[0];
+    const content = [];
+    if (choice.message.content != null && choice.message.content.length > 0) {
+      let text2 = choice.message.content;
+      const lastMessage = body.messages[body.messages.length - 1];
+      if ((lastMessage == null ? void 0 : lastMessage.role) === "assistant" && text2 === lastMessage.content) {
+        text2 = "";
+      }
+      if (text2.length > 0) {
+        content.push({ type: "text", text: text2 });
+      }
+    }
+    if (choice.message.reasoning_content != null && choice.message.reasoning_content.length > 0) {
+      content.push({
+        type: "reasoning",
+        text: choice.message.reasoning_content
+      });
+    }
+    if (choice.message.tool_calls != null) {
+      for (const toolCall of choice.message.tool_calls) {
+        content.push({
+          type: "tool-call",
+          toolCallId: toolCall.id,
+          toolName: toolCall.function.name,
+          input: toolCall.function.arguments
+        });
+      }
+    }
+    if (response.citations != null) {
+      for (const url2 of response.citations) {
+        content.push({
+          type: "source",
+          sourceType: "url",
+          id: this.config.generateId(),
+          url: url2
+        });
+      }
+    }
+    return {
+      content,
+      finishReason: mapXaiFinishReason(choice.finish_reason),
+      usage: {
+        inputTokens: response.usage.prompt_tokens,
+        outputTokens: response.usage.completion_tokens,
+        totalTokens: response.usage.total_tokens,
+        reasoningTokens: (_c = (_b = response.usage.completion_tokens_details) == null ? void 0 : _b.reasoning_tokens) != null ? _c : void 0
+      },
+      request: { body },
+      response: {
+        ...getResponseMetadata$1(response),
+        headers: responseHeaders,
+        body: rawResponse
+      },
+      warnings
+    };
+  }
+  async doStream(options) {
+    var _a10;
+    const { args, warnings } = await this.getArgs(options);
+    const body = {
+      ...args,
+      stream: true,
+      stream_options: {
+        include_usage: true
+      }
+    };
+    const { responseHeaders, value: response } = await postJsonToApi$1({
+      url: `${(_a10 = this.config.baseURL) != null ? _a10 : "https://api.x.ai/v1"}/chat/completions`,
+      headers: combineHeaders$1(this.config.headers(), options.headers),
+      body,
+      failedResponseHandler: xaiFailedResponseHandler,
+      successfulResponseHandler: createEventSourceResponseHandler$1(xaiChatChunkSchema),
+      abortSignal: options.abortSignal,
+      fetch: this.config.fetch
+    });
+    let finishReason = "unknown";
+    const usage = {
+      inputTokens: void 0,
+      outputTokens: void 0,
+      totalTokens: void 0
+    };
+    let isFirstChunk = true;
+    const contentBlocks = {};
+    const lastReasoningDeltas = {};
+    const self = this;
+    return {
+      stream: response.pipeThrough(
+        new TransformStream({
+          start(controller) {
+            controller.enqueue({ type: "stream-start", warnings });
+          },
+          transform(chunk, controller) {
+            var _a22, _b;
+            if (options.includeRawChunks) {
+              controller.enqueue({ type: "raw", rawValue: chunk.rawValue });
+            }
+            if (!chunk.success) {
+              controller.enqueue({ type: "error", error: chunk.error });
+              return;
+            }
+            const value = chunk.value;
+            if (isFirstChunk) {
+              controller.enqueue({
+                type: "response-metadata",
+                ...getResponseMetadata$1(value)
+              });
+              isFirstChunk = false;
+            }
+            if (value.citations != null) {
+              for (const url2 of value.citations) {
+                controller.enqueue({
+                  type: "source",
+                  sourceType: "url",
+                  id: self.config.generateId(),
+                  url: url2
+                });
+              }
+            }
+            if (value.usage != null) {
+              usage.inputTokens = value.usage.prompt_tokens;
+              usage.outputTokens = value.usage.completion_tokens;
+              usage.totalTokens = value.usage.total_tokens;
+              usage.reasoningTokens = (_b = (_a22 = value.usage.completion_tokens_details) == null ? void 0 : _a22.reasoning_tokens) != null ? _b : void 0;
+            }
+            const choice = value.choices[0];
+            if ((choice == null ? void 0 : choice.finish_reason) != null) {
+              finishReason = mapXaiFinishReason(choice.finish_reason);
+            }
+            if ((choice == null ? void 0 : choice.delta) == null) {
+              return;
+            }
+            const delta = choice.delta;
+            const choiceIndex = choice.index;
+            if (delta.content != null && delta.content.length > 0) {
+              const textContent = delta.content;
+              const lastMessage = body.messages[body.messages.length - 1];
+              if ((lastMessage == null ? void 0 : lastMessage.role) === "assistant" && textContent === lastMessage.content) {
+                return;
+              }
+              const blockId = `text-${value.id || choiceIndex}`;
+              if (contentBlocks[blockId] == null) {
+                contentBlocks[blockId] = { type: "text" };
+                controller.enqueue({
+                  type: "text-start",
+                  id: blockId
+                });
+              }
+              controller.enqueue({
+                type: "text-delta",
+                id: blockId,
+                delta: textContent
+              });
+            }
+            if (delta.reasoning_content != null && delta.reasoning_content.length > 0) {
+              const blockId = `reasoning-${value.id || choiceIndex}`;
+              if (lastReasoningDeltas[blockId] === delta.reasoning_content) {
+                return;
+              }
+              lastReasoningDeltas[blockId] = delta.reasoning_content;
+              if (contentBlocks[blockId] == null) {
+                contentBlocks[blockId] = { type: "reasoning" };
+                controller.enqueue({
+                  type: "reasoning-start",
+                  id: blockId
+                });
+              }
+              controller.enqueue({
+                type: "reasoning-delta",
+                id: blockId,
+                delta: delta.reasoning_content
+              });
+            }
+            if (delta.tool_calls != null) {
+              for (const toolCall of delta.tool_calls) {
+                const toolCallId = toolCall.id;
+                controller.enqueue({
+                  type: "tool-input-start",
+                  id: toolCallId,
+                  toolName: toolCall.function.name
+                });
+                controller.enqueue({
+                  type: "tool-input-delta",
+                  id: toolCallId,
+                  delta: toolCall.function.arguments
+                });
+                controller.enqueue({
+                  type: "tool-input-end",
+                  id: toolCallId
+                });
+                controller.enqueue({
+                  type: "tool-call",
+                  toolCallId,
+                  toolName: toolCall.function.name,
+                  input: toolCall.function.arguments
+                });
+              }
+            }
+          },
+          flush(controller) {
+            for (const [blockId, block] of Object.entries(contentBlocks)) {
+              controller.enqueue({
+                type: block.type === "text" ? "text-end" : "reasoning-end",
+                id: blockId
+              });
             }
-            controller.enqueue({
-              type: "finish",
-              finishReason,
-              usage,
-              ...{}
-            });
+            controller.enqueue({ type: "finish", finishReason, usage });
           }
         })
       ),
@@ -17986,18 +19045,27 @@ var GroqChatLanguageModel = class {
     };
   }
 };
-var groqChatResponseSchema = object({
+var xaiUsageSchema = object({
+  prompt_tokens: number$1(),
+  completion_tokens: number$1(),
+  total_tokens: number$1(),
+  completion_tokens_details: object({
+    reasoning_tokens: number$1().nullish()
+  }).nullish()
+});
+var xaiChatResponseSchema = object({
   id: string$1().nullish(),
   created: number$1().nullish(),
   model: string$1().nullish(),
   choices: array(
     object({
       message: object({
+        role: literal("assistant"),
         content: string$1().nullish(),
-        reasoning: string$1().nullish(),
+        reasoning_content: string$1().nullish(),
         tool_calls: array(
           object({
-            id: string$1().nullish(),
+            id: string$1(),
             type: literal("function"),
             function: object({
               name: string$1(),
@@ -18010,228 +19078,84 @@ var groqChatResponseSchema = object({
       finish_reason: string$1().nullish()
     })
   ),
-  usage: object({
-    prompt_tokens: number$1().nullish(),
-    completion_tokens: number$1().nullish(),
-    total_tokens: number$1().nullish()
-  }).nullish()
+  object: literal("chat.completion"),
+  usage: xaiUsageSchema,
+  citations: array(string$1().url()).nullish()
 });
-var groqChatChunkSchema = union([
-  object({
-    id: string$1().nullish(),
-    created: number$1().nullish(),
-    model: string$1().nullish(),
-    choices: array(
-      object({
-        delta: object({
-          content: string$1().nullish(),
-          reasoning: string$1().nullish(),
-          tool_calls: array(
-            object({
-              index: number$1(),
-              id: string$1().nullish(),
-              type: literal("function").optional(),
-              function: object({
-                name: string$1().nullish(),
-                arguments: string$1().nullish()
-              })
+var xaiChatChunkSchema = object({
+  id: string$1().nullish(),
+  created: number$1().nullish(),
+  model: string$1().nullish(),
+  choices: array(
+    object({
+      delta: object({
+        role: _enum(["assistant"]).optional(),
+        content: string$1().nullish(),
+        reasoning_content: string$1().nullish(),
+        tool_calls: array(
+          object({
+            id: string$1(),
+            type: literal("function"),
+            function: object({
+              name: string$1(),
+              arguments: string$1()
             })
-          ).nullish()
-        }).nullish(),
-        finish_reason: string$1().nullable().optional(),
-        index: number$1()
-      })
-    ),
-    x_groq: object({
-      usage: object({
-        prompt_tokens: number$1().nullish(),
-        completion_tokens: number$1().nullish(),
-        total_tokens: number$1().nullish()
-      }).nullish()
-    }).nullish()
-  }),
-  groqErrorDataSchema
-]);
-var groqProviderOptionsSchema = object({
-  language: string$1().nullish(),
-  prompt: string$1().nullish(),
-  responseFormat: string$1().nullish(),
-  temperature: number$1().min(0).max(1).nullish(),
-  timestampGranularities: array(string$1()).nullish()
-});
-var GroqTranscriptionModel = class {
-  constructor(modelId, config2) {
-    this.modelId = modelId;
-    this.config = config2;
-    this.specificationVersion = "v2";
-  }
-  get provider() {
-    return this.config.provider;
-  }
-  async getArgs({
-    audio,
-    mediaType,
-    providerOptions
-  }) {
-    var _a10, _b, _c, _d, _e;
-    const warnings = [];
-    const groqOptions = await parseProviderOptions({
-      provider: "groq",
-      providerOptions,
-      schema: groqProviderOptionsSchema
-    });
-    const formData = new FormData();
-    const blob = audio instanceof Uint8Array ? new Blob([audio]) : new Blob([convertBase64ToUint8Array(audio)]);
-    formData.append("model", this.modelId);
-    const fileExtension = mediaTypeToExtension(mediaType);
-    formData.append(
-      "file",
-      new File([blob], "audio", { type: mediaType }),
-      `audio.${fileExtension}`
-    );
-    if (groqOptions) {
-      const transcriptionModelOptions = {
-        language: (_a10 = groqOptions.language) != null ? _a10 : void 0,
-        prompt: (_b = groqOptions.prompt) != null ? _b : void 0,
-        response_format: (_c = groqOptions.responseFormat) != null ? _c : void 0,
-        temperature: (_d = groqOptions.temperature) != null ? _d : void 0,
-        timestamp_granularities: (_e = groqOptions.timestampGranularities) != null ? _e : void 0
-      };
-      for (const key in transcriptionModelOptions) {
-        const value = transcriptionModelOptions[key];
-        if (value !== void 0) {
-          formData.append(key, String(value));
-        }
-      }
-    }
-    return {
-      formData,
-      warnings
-    };
-  }
-  async doGenerate(options) {
-    var _a10, _b, _c, _d, _e, _f, _g;
-    const currentDate = (_c = (_b = (_a10 = this.config._internal) == null ? void 0 : _a10.currentDate) == null ? void 0 : _b.call(_a10)) != null ? _c : /* @__PURE__ */ new Date();
-    const { formData, warnings } = await this.getArgs(options);
-    const {
-      value: response,
-      responseHeaders,
-      rawValue: rawResponse
-    } = await postFormDataToApi({
-      url: this.config.url({
-        path: "/audio/transcriptions",
-        modelId: this.modelId
+          })
+        ).nullish()
       }),
-      headers: combineHeaders$1(this.config.headers(), options.headers),
-      formData,
-      failedResponseHandler: groqFailedResponseHandler,
-      successfulResponseHandler: createJsonResponseHandler$1(
-        groqTranscriptionResponseSchema
-      ),
-      abortSignal: options.abortSignal,
-      fetch: this.config.fetch
-    });
-    return {
-      text: response.text,
-      segments: (_e = (_d = response.segments) == null ? void 0 : _d.map((segment) => ({
-        text: segment.text,
-        startSecond: segment.start,
-        endSecond: segment.end
-      }))) != null ? _e : [],
-      language: (_f = response.language) != null ? _f : void 0,
-      durationInSeconds: (_g = response.duration) != null ? _g : void 0,
-      warnings,
-      response: {
-        timestamp: currentDate,
-        modelId: this.modelId,
-        headers: responseHeaders,
-        body: rawResponse
-      }
-    };
-  }
-};
-var groqTranscriptionResponseSchema = object({
-  text: string$1(),
-  x_groq: object({
-    id: string$1()
-  }),
-  // additional properties are returned when `response_format: 'verbose_json'` is
-  task: string$1().nullish(),
-  language: string$1().nullish(),
-  duration: number$1().nullish(),
-  segments: array(
-    object({
-      id: number$1(),
-      seek: number$1(),
-      start: number$1(),
-      end: number$1(),
-      text: string$1(),
-      tokens: array(number$1()),
-      temperature: number$1(),
-      avg_logprob: number$1(),
-      compression_ratio: number$1(),
-      no_speech_prob: number$1()
+      finish_reason: string$1().nullish(),
+      index: number$1()
     })
-  ).nullish()
-});
-var browserSearch = createProviderDefinedToolFactory({
-  id: "groq.browser_search",
-  name: "browser_search",
-  inputSchema: object({})
+  ),
+  usage: xaiUsageSchema.nullish(),
+  citations: array(string$1().url()).nullish()
 });
-var groqTools = {
-  browserSearch
+var xaiErrorStructure = {
+  errorSchema: xaiErrorDataSchema,
+  errorToMessage: (data) => data.error.message
 };
-function createGroq(options = {}) {
+function createXai(options = {}) {
   var _a10;
-  const baseURL = (_a10 = withoutTrailingSlash$1(options.baseURL)) != null ? _a10 : "https://api.groq.com/openai/v1";
+  const baseURL = withoutTrailingSlash$1(
+    (_a10 = options.baseURL) != null ? _a10 : "https://api.x.ai/v1"
+  );
   const getHeaders = () => ({
     Authorization: `Bearer ${loadApiKey$1({
       apiKey: options.apiKey,
-      environmentVariableName: "GROQ_API_KEY",
-      description: "Groq"
+      environmentVariableName: "XAI_API_KEY",
+      description: "xAI API key"
     })}`,
     ...options.headers
   });
-  const createChatModel = (modelId) => new GroqChatLanguageModel(modelId, {
-    provider: "groq.chat",
-    url: ({ path }) => `${baseURL}${path}`,
-    headers: getHeaders,
-    fetch: options.fetch
-  });
   const createLanguageModel = (modelId) => {
-    if (new.target) {
-      throw new Error(
-        "The Groq model function cannot be called with the new keyword."
-      );
-    }
-    return createChatModel(modelId);
-  };
-  const createTranscriptionModel = (modelId) => {
-    return new GroqTranscriptionModel(modelId, {
-      provider: "groq.transcription",
-      url: ({ path }) => `${baseURL}${path}`,
+    return new XaiChatLanguageModel(modelId, {
+      provider: "xai.chat",
+      baseURL,
       headers: getHeaders,
+      generateId: generateId$1,
       fetch: options.fetch
     });
   };
-  const provider = function(modelId) {
-    return createLanguageModel(modelId);
+  const createImageModel = (modelId) => {
+    return new OpenAICompatibleImageModel(modelId, {
+      provider: "xai.image",
+      url: ({ path }) => `${baseURL}${path}`,
+      headers: getHeaders,
+      fetch: options.fetch,
+      errorStructure: xaiErrorStructure
+    });
   };
+  const provider = (modelId) => createLanguageModel(modelId);
   provider.languageModel = createLanguageModel;
-  provider.chat = createChatModel;
+  provider.chat = createLanguageModel;
   provider.textEmbeddingModel = (modelId) => {
     throw new NoSuchModelError({ modelId, modelType: "textEmbeddingModel" });
   };
-  provider.imageModel = (modelId) => {
-    throw new NoSuchModelError({ modelId, modelType: "imageModel" });
-  };
-  provider.transcription = createTranscriptionModel;
-  provider.transcriptionModel = createTranscriptionModel;
-  provider.tools = groqTools;
+  provider.imageModel = createImageModel;
+  provider.image = createImageModel;
   return provider;
 }
-createGroq();
+createXai();
 var openaiErrorDataSchema = object({
   error: object({
     message: string$1(),
@@ -26957,6 +27881,18 @@ function createEchoGroq({ appId, baseRouterUrl = ROUTER_BASE_URL }, getTokenFn,
     )
   });
 }
+function createEchoXAI({ appId, baseRouterUrl = ROUTER_BASE_URL }, getTokenFn, onInsufficientFunds) {
+  validateAppId(appId, "createEchoXAI");
+  return createXai({
+    baseURL: baseRouterUrl,
+    apiKey: "placeholder_replaced_by_echoFetch",
+    fetch: echoFetch(
+      fetch,
+      async () => await getTokenFn(appId),
+      onInsufficientFunds
+    )
+  });
+}
 function createEchoOpenAI({ appId, baseRouterUrl = ROUTER_BASE_URL }, getTokenFn, onInsufficientFunds) {
   validateAppId(appId, "createEchoOpenAI");
   return createOpenAI({
@@ -30000,7 +30936,8 @@ const useEchoModelProviders = () => {
         getToken,
         onInsufficientFunds
       ),
-      groq: createEchoGroq(baseConfig, getToken, onInsufficientFunds)
+      groq: createEchoGroq(baseConfig, getToken, onInsufficientFunds),
+      xai: createEchoXAI(baseConfig, getToken, onInsufficientFunds)
     };
   }, [getToken, config2.appId, config2.baseRouterUrl, setIsInsufficientFunds]);
 };