@threaded/ai 1.0.7 → 1.0.9

package/dist/index.cjs

@@ -41,6 +41,7 @@ __export(index_exports, {
   everyNMessages: () => everyNMessages,
   everyNTokens: () => everyNTokens,
   generateApprovalToken: () => generateApprovalToken,
+  generateImage: () => generateImage,
   getKey: () => getKey,
   getOrCreateThread: () => getOrCreateThread,
   isStandardSchema: () => isStandardSchema,
@@ -258,7 +259,133 @@ var embed = async (model2, text, config) => {
   }
 };
 
+// src/image.ts
+var providerKeyEnvVars = {
+  openai: "OPENAI_API_KEY",
+  xai: "XAI_API_KEY",
+  google: "GEMINI_API_KEY"
+};
+var getApiKey = (provider) => {
+  try {
+    return getKey(provider);
+  } catch {
+    const envVar = providerKeyEnvVars[provider];
+    const key = envVar ? process.env[envVar] || "" : "";
+    if (!key) throw new Error(`No API key found for provider: ${provider}`);
+    return key;
+  }
+};
+var generateOpenAICompatible = async (endpoint, modelName, prompt, apiKey, config) => {
+  const isGptImage = modelName.startsWith("gpt-image");
+  const body = {
+    model: modelName,
+    prompt
+  };
+  if (!isGptImage) {
+    body.response_format = config?.responseFormat || "b64_json";
+  }
+  if (config?.n) body.n = config.n;
+  if (config?.size) body.size = config.size;
+  if (config?.quality) body.quality = config.quality;
+  if (config?.style && !isGptImage) body.style = config.style;
+  if (isGptImage) {
+    if (config?.outputFormat) body.output_format = config.outputFormat;
+    if (config?.outputCompression != null) body.output_compression = config.outputCompression;
+    if (config?.background) body.background = config.background;
+  }
+  const response = await fetch(endpoint, {
+    method: "POST",
+    headers: {
+      "Content-Type": "application/json",
+      Authorization: `Bearer ${apiKey}`
+    },
+    body: JSON.stringify(body)
+  });
+  if (!response.ok) {
+    const error = await response.text();
+    throw new Error(`API error: ${error}`);
+  }
+  const data = await response.json();
+  const image = data.data[0];
+  return {
+    data: image.b64_json || image.url,
+    revisedPrompt: image.revised_prompt
+  };
+};
+var generateGoogle = async (modelName, prompt, apiKey, config) => {
+  const endpoint = `https://generativelanguage.googleapis.com/v1beta/models/${modelName}:generateContent`;
+  const body = {
+    contents: [{ parts: [{ text: prompt }] }],
+    generationConfig: {
+      responseModalities: ["TEXT", "IMAGE"]
+    }
+  };
+  if (config?.aspectRatio) {
+    body.generationConfig.aspectRatio = config.aspectRatio;
+  }
+  const response = await fetch(endpoint, {
+    method: "POST",
+    headers: {
+      "Content-Type": "application/json",
+      "x-goog-api-key": apiKey
+    },
+    body: JSON.stringify(body)
+  });
+  if (!response.ok) {
+    const error = await response.text();
+    throw new Error(`Google API error: ${error}`);
+  }
+  const data = await response.json();
+  const parts = data.candidates?.[0]?.content?.parts || [];
+  const imagePart = parts.find((p) => p.inlineData);
+  const textPart = parts.find((p) => p.text);
+  if (!imagePart?.inlineData?.data) {
+    throw new Error("No image data in response");
+  }
+  return {
+    data: imagePart.inlineData.data,
+    revisedPrompt: textPart?.text
+  };
+};
+var generateImage = async (model2, prompt, config) => {
+  const { provider, model: modelName } = parseModelName(model2);
+  const providerLower = provider.toLowerCase();
+  const apiKey = getApiKey(providerLower);
+  switch (providerLower) {
+    case "openai":
+      return generateOpenAICompatible(
+        "https://api.openai.com/v1/images/generations",
+        modelName,
+        prompt,
+        apiKey,
+        config
+      );
+    case "xai":
+      return generateOpenAICompatible(
+        "https://api.x.ai/v1/images/generations",
+        modelName,
+        prompt,
+        apiKey,
+        config
+      );
+    case "google":
+      return generateGoogle(modelName, prompt, apiKey, config);
+    default:
+      throw new Error(`Unsupported image generation provider: ${provider}`);
+  }
+};
+
 // src/providers/openai.ts
+var getApiKey2 = (configApiKey) => {
+  if (configApiKey) return configApiKey;
+  try {
+    return getKey("openai");
+  } catch {
+    const key = process.env.OPENAI_API_KEY || "";
+    if (!key) throw new Error("OpenAI API key not found");
+    return key;
+  }
+};
 var appendToolCalls = (toolCalls, tcchunklist) => {
   for (const tcchunk of tcchunklist) {
     while (toolCalls.length <= tcchunk.index) {
@@ -277,10 +404,7 @@ var appendToolCalls = (toolCalls, tcchunklist) => {
 };
 var callOpenAI = async (config, ctx) => {
   const { model: model2, instructions, schema, apiKey: configApiKey } = config;
-  const apiKey = configApiKey || getKey("openai") || process.env.OPENAI_API_KEY;
-  if (!apiKey) {
-    throw new Error("OpenAI API key not found");
-  }
+  const apiKey = getApiKey2(configApiKey);
   const messages = [];
   if (instructions) {
     messages.push({ role: "system", content: instructions });
@@ -393,6 +517,16 @@ var handleOpenAIStream = async (response, ctx) => {
 };
 
 // src/providers/anthropic.ts
+var getApiKey3 = (configApiKey) => {
+  if (configApiKey) return configApiKey;
+  try {
+    return getKey("anthropic");
+  } catch {
+    const key = process.env.ANTHROPIC_API_KEY || "";
+    if (!key) throw new Error("Anthropic API key not found");
+    return key;
+  }
+};
 var convertToAnthropicFormat = (messages) => {
   const result = [];
   let i = 0;
@@ -444,10 +578,7 @@ var convertToAnthropicFormat = (messages) => {
 };
 var callAnthropic = async (config, ctx) => {
   const { model: model2, instructions, schema, apiKey: configApiKey } = config;
-  const apiKey = configApiKey || getKey("anthropic") || process.env.ANTHROPIC_API_KEY;
-  if (!apiKey) {
-    throw new Error("Anthropic API key not found");
-  }
+  const apiKey = getApiKey3(configApiKey);
   let system = instructions;
   if (ctx.history[0]?.role === "system") {
     system = ctx.history[0].content;
@@ -592,12 +723,19 @@ var handleAnthropicStream = async (response, ctx) => {
 };
 
 // src/providers/google.ts
+var getApiKey4 = (configApiKey) => {
+  if (configApiKey) return configApiKey;
+  try {
+    return getKey("google");
+  } catch {
+    const key = process.env.GEMINI_API_KEY || process.env.GOOGLE_AI_API_KEY || "";
+    if (!key) throw new Error("Google API key not found");
+    return key;
+  }
+};
 var callGoogle = async (config, ctx) => {
   const { model: model2, instructions, apiKey: configApiKey } = config;
-  const apiKey = configApiKey || getKey("google") || process.env.GOOGLE_AI_API_KEY;
-  if (!apiKey) {
-    throw new Error("Google API key not found");
-  }
+  const apiKey = getApiKey4(configApiKey);
   const contents = [];
   if (instructions) {
     contents.push({
@@ -743,6 +881,147 @@ var callHuggingFace = async (config, ctx) => {
   );
 };
 
+// src/providers/xai.ts
+var appendToolCalls2 = (toolCalls, tcchunklist) => {
+  for (const tcchunk of tcchunklist) {
+    while (toolCalls.length <= tcchunk.index) {
+      toolCalls.push({
+        id: "",
+        type: "function",
+        function: { name: "", arguments: "" }
+      });
+    }
+    const tc = toolCalls[tcchunk.index];
+    tc.id += tcchunk.id || "";
+    tc.function.name += tcchunk.function?.name || "";
+    tc.function.arguments += tcchunk.function?.arguments || "";
+  }
+  return toolCalls;
+};
+var getApiKey5 = (configApiKey) => {
+  if (configApiKey) return configApiKey;
+  try {
+    return getKey("xai");
+  } catch {
+    const key = process.env.XAI_API_KEY || "";
+    if (!key) throw new Error("xAI API key not found");
+    return key;
+  }
+};
+var callXAI = async (config, ctx) => {
+  const { model: model2, instructions, schema, apiKey: configApiKey } = config;
+  const apiKey = getApiKey5(configApiKey);
+  const messages = [];
+  if (instructions) {
+    messages.push({ role: "system", content: instructions });
+  }
+  messages.push(...ctx.history);
+  const body = {
+    model: model2,
+    messages,
+    stream: !!ctx.stream
+  };
+  if (schema) {
+    body.response_format = {
+      type: "json_schema",
+      json_schema: {
+        name: schema.name,
+        schema: { ...schema.schema, additionalProperties: false },
+        strict: true
+      }
+    };
+  }
+  if (ctx.tools && ctx.tools.length > 0) {
+    body.tools = ctx.tools;
+    body.tool_choice = "auto";
+  }
+  const response = await fetch("https://api.x.ai/v1/chat/completions", {
+    method: "POST",
+    headers: {
+      "Content-Type": "application/json",
+      Authorization: `Bearer ${apiKey}`
+    },
+    body: JSON.stringify(body),
+    signal: ctx.abortSignal
+  });
+  if (!response.ok) {
+    const error = await response.text();
+    throw new Error(`xAI API error: ${error}`);
+  }
+  if (ctx.stream) {
+    return handleXAIStream(response, ctx);
+  }
+  const data = await response.json();
+  const choice = data.choices[0];
+  const { message } = choice;
+  const msg = {
+    role: "assistant",
+    content: message.content || ""
+  };
+  if (message.tool_calls) {
+    msg.tool_calls = message.tool_calls;
+  }
+  return {
+    ...ctx,
+    lastResponse: msg,
+    history: [...ctx.history, msg]
+  };
+};
+var handleXAIStream = async (response, ctx) => {
+  const reader = response.body.getReader();
+  const decoder = new TextDecoder();
+  let fullContent = "";
+  let toolCalls = [];
+  let buffer = "";
+  try {
+    while (true) {
+      if (ctx.abortSignal?.aborted) {
+        break;
+      }
+      const { done, value } = await reader.read();
+      if (done) break;
+      buffer += decoder.decode(value, { stream: true });
+      const lines = buffer.split("\n");
+      buffer = lines.pop() || "";
+      for (const line of lines) {
+        if (line.startsWith("data: ")) {
+          const data = line.slice(6).trim();
+          if (data === "[DONE]") continue;
+          if (!data) continue;
+          try {
+            const parsed = JSON.parse(data);
+            const delta = parsed.choices?.[0]?.delta;
+            if (delta?.content) {
+              fullContent += delta.content;
+              if (ctx.stream) {
+                ctx.stream({ type: "content", content: delta.content });
+              }
+            }
+            if (delta?.tool_calls) {
+              toolCalls = appendToolCalls2(toolCalls, delta.tool_calls);
+            }
+          } catch (e) {
+          }
+        }
+      }
+    }
+  } finally {
+    reader.releaseLock();
+  }
+  const msg = {
+    role: "assistant",
+    content: fullContent
+  };
+  if (toolCalls.length > 0) {
+    msg.tool_calls = toolCalls;
+  }
+  return {
+    ...ctx,
+    lastResponse: msg,
+    history: [...ctx.history, msg]
+  };
+};
+
 // src/providers/index.ts
 var callProvider = async (config, ctx) => {
   const { provider, model: model2 } = parseModelName(config.model);
@@ -754,6 +1033,8 @@ var callProvider = async (config, ctx) => {
       return callAnthropic(providerConfig, ctx);
     case "google":
       return callGoogle(providerConfig, ctx);
+    case "xai":
+      return callXAI(providerConfig, ctx);
     case "huggingface":
     default:
       return callHuggingFace(providerConfig, ctx);
@@ -1365,6 +1646,7 @@ var rateLimited = (config) => (fn) => {
   everyNMessages,
   everyNTokens,
   generateApprovalToken,
+  generateImage,
   getKey,
   getOrCreateThread,
   isStandardSchema,