@swifty.js/swifty 0.0.21 → 0.0.22

package/dist/lib/chunk-RR2CZ6CY.js

@@ -0,0 +1,598 @@
+import {
+  getMaxOutputTokens,
+  resolveAPIKey
+} from "./chunk-6GOWRPYS.js";
+import {
+  AuthenticationError,
+  ContextTooLongError,
+  LLMError,
+  NetworkError,
+  RateLimitError,
+  ensureToolPairing
+} from "./chunk-UMFNTXKA.js";
+import {
+  DANGEROUSLY_JSON,
+  asRecord,
+  asString,
+  contentToText,
+  createChildLogger,
+  isRecord,
+  strArg
+} from "./chunk-EJLGB2EJ.js";
+
+// src/llm/openai.ts
+import OpenAI from "openai";
+var log = createChildLogger({ module: "llm" });
+var OpenAIClient = class {
+  client;
+  model;
+  systemPrompt;
+  maxOutputTokens;
+  constructor(config, systemPrompt) {
+    const apiKey = resolveAPIKey(config);
+    if (!apiKey) {
+      throw new AuthenticationError(
+        "OpenAI API key not found, set OPENAI_API_KEY in .swifty/config.y(a)ml, or via OPENAI_API_KEY env variable."
+      );
+    }
+    this.client = new OpenAI({
+      apiKey,
+      baseURL: config.base_url
+    });
+    this.model = config.model;
+    this.systemPrompt = systemPrompt;
+    this.maxOutputTokens = getMaxOutputTokens(config);
+  }
+  async *stream(conversation, toolSchemas, abortSignal) {
+    const messages = buildOpenAIInput(ensureToolPairing(conversation.getMessages()));
+    const input = [];
+    input.push({
+      role: "system",
+      content: this.systemPrompt
+    });
+    for (const message of messages) {
+      input.push(message);
+    }
+    const tools = toolSchemas.map((s) => {
+      const schema = s.input_schema;
+      return {
+        type: "function",
+        name: s.name,
+        description: s.description,
+        parameters: schema,
+        strict: false
+      };
+    });
+    const params = {
+      model: this.model,
+      input,
+      stream: true,
+      max_output_tokens: this.maxOutputTokens,
+      ...tools.length > 0 ? { tools } : {}
+    };
+    let inputTokens = 0;
+    let outputTokens = 0;
+    let cacheReadInputTokens = 0;
+    const cacheCreationInputTokens = 0;
+    try {
+      const stream = await this.client.responses.create(params, {
+        ...abortSignal ? { signal: abortSignal } : {}
+      });
+      let currentToolName = "";
+      let currentToolId = "";
+      let jsonAccumulate = "";
+      let reasoningId = "";
+      let reasoningText = "";
+      for await (const event of stream) {
+        if (event.type === "response.output_text.delta") {
+          yield {
+            type: "text_delta",
+            text: event.delta
+          };
+        } else if (event.type === "response.reasoning_summary_text.delta") {
+          reasoningText += event.delta;
+          yield { type: "thinking_delta", text: event.delta };
+        } else if (event.type === "response.reasoning_summary_text.done") {
+          yield {
+            type: "thinking_complete",
+            thinking: reasoningText,
+            signature: reasoningId
+          };
+        } else if (event.type === "response.function_call_arguments.delta") {
+          jsonAccumulate += event.delta;
+          yield {
+            type: "tool_call_delta",
+            text: event.delta
+          };
+        } else if (event.type === "response.output_item.added") {
+          if (event.item.type === "function_call") {
+            currentToolName = event.item.name;
+            currentToolId = event.item.call_id;
+            jsonAccumulate = "";
+            yield {
+              type: "tool_call_start",
+              toolName: currentToolName,
+              toolId: currentToolId
+            };
+          } else if (event.item.type === "reasoning") {
+            reasoningId = event.item.id ?? "";
+            reasoningText = "";
+          }
+        } else if (event.type === "response.output_item.done") {
+          if (event.item.type === "function_call" && currentToolName) {
+            let args = {};
+            if (jsonAccumulate) {
+              try {
+                const parsed = JSON.parse(jsonAccumulate);
+                args = isRecord(parsed) ? asRecord(parsed) : { [DANGEROUSLY_JSON]: jsonAccumulate };
+              } catch (err) {
+                log.error({ err }, "llm operation failed");
+                args = {
+                  [DANGEROUSLY_JSON]: jsonAccumulate
+                };
+              }
+            }
+            yield {
+              type: "tool_call_complete",
+              toolId: currentToolId,
+              toolName: currentToolName,
+              arguments: args
+            };
+            currentToolName = "";
+            currentToolId = "";
+            jsonAccumulate = "";
+          }
+        } else if (event.type === "response.completed") {
+          const usage = event.response.usage;
+          if (usage) {
+            outputTokens = usage.output_tokens;
+            cacheReadInputTokens = usage.input_tokens_details.cached_tokens;
+            inputTokens = Math.max(0, usage.input_tokens - cacheReadInputTokens);
+          }
+          let stopReason = "end_turn";
+          const resp = event.response;
+          if (resp.status === "incomplete") {
+            const details = resp.incomplete_details;
+            if (details?.reason === "max_output_tokens") {
+              stopReason = "max_tokens";
+            }
+          }
+          yield {
+            type: "stream_end",
+            stopReason,
+            usage: {
+              inputTokens,
+              outputTokens,
+              cacheReadInputTokens,
+              cacheCreationInputTokens
+              // 0
+            }
+          };
+        }
+      }
+    } catch (err) {
+      log.error({ err }, "llm operation failed");
+      throw classifyOpenAIError(err);
+    }
+  }
+  setSystemPrompt(prompt) {
+    this.systemPrompt = prompt;
+  }
+  setMaxOutputTokens(maxTokens) {
+    this.maxOutputTokens = maxTokens;
+  }
+};
+function imageDataUrl(block) {
+  if (block.type !== "image") {
+    return null;
+  }
+  const source = block.source;
+  if (!isRecord(source) || source.type !== "base64") {
+    return null;
+  }
+  const mediaType = strArg(source, "media_type");
+  const data = strArg(source, "data");
+  if (!mediaType || !data) {
+    return null;
+  }
+  return `data:${mediaType};base64,${data}`;
+}
+function collectImageContents(tr) {
+  const { toolUseId, content } = tr;
+  if (typeof content === "string") {
+    return [];
+  }
+  const images = [];
+  for (const block of content) {
+    const url = imageDataUrl(block);
+    if (url) {
+      images.push({
+        type: "input_image",
+        image_url: url,
+        detail: "auto"
+      });
+    }
+  }
+  if (images.length === 0) {
+    return [];
+  }
+  return [
+    {
+      type: "input_text",
+      text: `[Image(s) returned by tool call ${toolUseId}]`
+    },
+    ...images
+  ];
+}
+function collectImageParts(tr) {
+  const { toolUseId, content } = tr;
+  if (typeof content === "string") {
+    return [];
+  }
+  const images = [];
+  for (const block of content) {
+    const url = imageDataUrl(block);
+    if (url) {
+      images.push({
+        type: "image_url",
+        image_url: { url }
+      });
+    }
+  }
+  if (images.length === 0) {
+    return [];
+  }
+  return [
+    {
+      type: "text",
+      text: `[Image(s) returned by tool call ${toolUseId}]`
+    },
+    ...images
+  ];
+}
+function userContentsFor(content) {
+  if (typeof content === "string") {
+    return content;
+  }
+  const parts = [];
+  for (const block of content) {
+    if (block.type === "text") {
+      parts.push({ type: "input_text", text: strArg(block, "text") });
+    } else {
+      const url = imageDataUrl(block);
+      if (url) {
+        parts.push({ type: "input_image", image_url: url, detail: "auto" });
+      }
+    }
+  }
+  return parts;
+}
+function userPartsFor(content) {
+  if (typeof content === "string") {
+    return content;
+  }
+  const parts = [];
+  for (const block of content) {
+    if (block.type === "text") {
+      parts.push({ type: "text", text: strArg(block, "text") });
+    } else {
+      const url = imageDataUrl(block);
+      if (url) {
+        parts.push({ type: "image_url", image_url: { url } });
+      }
+    }
+  }
+  return parts;
+}
+function buildOpenAIInput(messages) {
+  const result = [];
+  for (const m of messages) {
+    if (m.thinkingBlocks) {
+      for (const tb of m.thinkingBlocks) {
+        result.push({
+          type: "reasoning",
+          id: tb.signature,
+          summary: [{ type: "summary_text", text: tb.thinking }]
+        });
+      }
+    }
+    if (m.toolUses && m.toolUses.length > 0) {
+      const assistantText = typeof m.content === "string" ? m.content : contentToText(m.content);
+      if (assistantText) {
+        result.push({
+          role: "assistant",
+          content: assistantText
+        });
+      }
+      for (const tu of m.toolUses) {
+        result.push({
+          type: "function_call",
+          name: tu.toolName,
+          call_id: tu.toolUseId,
+          arguments: JSON.stringify(tu.arguments)
+        });
+      }
+    } else if (m.toolResults && m.toolResults.length > 0) {
+      const pendingImageContents = [];
+      for (const tr of m.toolResults) {
+        result.push({
+          type: "function_call_output",
+          call_id: tr.toolUseId,
+          output: contentToText(tr.content)
+        });
+        pendingImageContents.push(...collectImageContents(tr));
+      }
+      if (pendingImageContents.length > 0) {
+        result.push({
+          role: "user",
+          content: pendingImageContents
+        });
+      }
+    } else if (m.role === "assistant") {
+      result.push({
+        role: "assistant",
+        content: typeof m.content === "string" ? m.content : contentToText(m.content)
+      });
+    } else {
+      result.push({
+        role: m.role,
+        content: userContentsFor(m.content)
+      });
+    }
+  }
+  return result;
+}
+function containsContextLengthError(msg) {
+  return /context_length_exceeded/i.test(msg) || /maximum\scontext\slength/i.test(msg) || /prompts?\s+too\s+long/i.test(msg);
+}
+var OpenAICompatClient = class {
+  client;
+  model;
+  systemPrompt;
+  maxOutputTokens;
+  constructor(config, systemPrompt) {
+    const apiKey = resolveAPIKey(config);
+    if (!apiKey) {
+      throw new AuthenticationError(
+        "OpenAI API key not found. Set OPENAI_API_KEY in .swifty/config.y(a)ml, or via OPENAI_API_KEY env variable."
+      );
+    }
+    this.client = new OpenAI({ apiKey, baseURL: config.base_url });
+    this.model = config.model;
+    this.systemPrompt = systemPrompt;
+    this.maxOutputTokens = getMaxOutputTokens(config);
+  }
+  setSystemPrompt(prompt) {
+    this.systemPrompt = prompt;
+  }
+  setMaxOutputTokens(maxTokens) {
+    this.maxOutputTokens = maxTokens;
+  }
+  async *stream(conversation, toolSchemas, abortSignal) {
+    const messages = [
+      {
+        role: "system",
+        content: this.systemPrompt
+      },
+      ...buildChatCompletionMessages(ensureToolPairing(conversation.getMessages()))
+    ];
+    const tools = toolSchemas.map((ts) => ({
+      // name: ts.name,
+      // description: ts.description,
+      type: "function",
+      function: {
+        name: ts.name,
+        description: ts.description,
+        parameters: ts.input_schema,
+        strict: false
+      }
+    }));
+    const params = {
+      model: this.model,
+      messages,
+      stream: true,
+      stream_options: { include_usage: true },
+      max_tokens: this.maxOutputTokens,
+      ...tools.length > 0 ? { tools } : {}
+    };
+    let inputTokens = 0;
+    let outputTokens = 0;
+    let cacheReadInputTokens = 0;
+    const cacheCreationInputTokens = 0;
+    try {
+      const stream = await this.client.chat.completions.create(params, {
+        ...abortSignal ? { signal: abortSignal } : {}
+      });
+      const toolCalls = /* @__PURE__ */ new Map();
+      let finishReason = null;
+      let reasoningAccumulate = "";
+      for await (const chunk of stream) {
+        if (chunk.usage) {
+          outputTokens = chunk.usage.completion_tokens ?? 0;
+          cacheReadInputTokens = chunk.usage.prompt_tokens_details?.cached_tokens ?? 0;
+          inputTokens = Math.max(0, (chunk.usage.prompt_tokens ?? 0) - cacheReadInputTokens);
+        }
+        if (chunk.choices.length === 0) {
+          continue;
+        }
+        const delta = chunk.choices[0].delta;
+        if (delta.content) {
+          yield { type: "text_delta", text: delta.content };
+        }
+        const reasoningContent = strArg(asRecord(delta), "reasoning_content");
+        if (reasoningContent) {
+          reasoningAccumulate += reasoningContent;
+          yield { type: "thinking_delta", text: reasoningContent };
+        }
+        if (delta.tool_calls) {
+          for (const tc of delta.tool_calls) {
+            if (!toolCalls.has(tc.index)) {
+              toolCalls.set(tc.index, {
+                id: tc.id ?? "",
+                name: tc.function?.name ?? "",
+                args: ""
+              });
+              if (tc.id) {
+                yield {
+                  type: "tool_call_start",
+                  toolName: tc.function?.name ?? "",
+                  toolId: tc.id ?? ""
+                };
+              }
+            }
+            const existing = toolCalls.get(tc.index);
+            if (existing) {
+              if (tc.id) {
+                existing.id = tc.id;
+              }
+              if (tc.function?.name) {
+                existing.name = tc.function.name;
+              }
+              if (tc.function?.arguments) {
+                existing.args += tc.function.arguments;
+                yield {
+                  type: "tool_call_delta",
+                  text: tc.function.arguments
+                };
+              }
+            }
+          }
+        }
+        if (chunk.choices[0].finish_reason) {
+          finishReason = chunk.choices[0].finish_reason;
+          if (reasoningAccumulate) {
+            yield {
+              type: "thinking_complete",
+              thinking: reasoningAccumulate,
+              signature: ""
+            };
+            reasoningAccumulate = "";
+          }
+          for (const tu of toolCalls.values()) {
+            let args = {};
+            const jsonArgs = tu.args;
+            if (jsonArgs) {
+              try {
+                const parsed = JSON.parse(jsonArgs);
+                args = isRecord(parsed) ? asRecord(parsed) : { [DANGEROUSLY_JSON]: jsonArgs };
+              } catch (err) {
+                log.error({ err }, "llm operation failed");
+                args = {
+                  [DANGEROUSLY_JSON]: jsonArgs
+                };
+              }
+              yield {
+                type: "tool_call_complete",
+                toolName: tu.name,
+                toolId: tu.id,
+                arguments: args
+              };
+            }
+          }
+        }
+      }
+      let stopReason;
+      if (finishReason === "length") {
+        stopReason = "max_tokens";
+      } else if (finishReason === "tool_calls" || toolCalls.size > 0) {
+        stopReason = "tool_use";
+      } else {
+        stopReason = "end_turn";
+      }
+      yield {
+        type: "stream_end",
+        stopReason,
+        usage: {
+          inputTokens,
+          outputTokens,
+          cacheReadInputTokens,
+          cacheCreationInputTokens
+        }
+      };
+    } catch (err) {
+      log.error({ err }, "llm operation failed");
+      throw classifyOpenAIError(err);
+    }
+  }
+};
+function classifyOpenAIError(err) {
+  if (err instanceof OpenAI.APIError) {
+    if (err.status === 413 /* PromptTooLong */ || err.status === 400 /* BadRequest */ && containsContextLengthError(err.message)) {
+      return new ContextTooLongError(`Context Too Long: ${err.message}`);
+    }
+    if (err.status === 401 /* InvalidAPIKey */) {
+      return new AuthenticationError(`Invalid API key: ${err.message}`);
+    }
+    if (err.status === 429 /* RateLimitError */) {
+      return new RateLimitError(`Rate limit error, please wait.`);
+    }
+    return new LLMError(`OpenAI API error (${asString(err.status)}): ${err.message}`);
+  }
+  return new NetworkError(`Network error: ${err instanceof Error ? err.message : asString(err)}`);
+}
+function buildChatCompletionMessages(messages) {
+  const params = [];
+  for (const m of messages) {
+    const reasoning = m.thinkingBlocks?.map((tb) => tb.thinking).join("") ?? "";
+    const assistantText = typeof m.content === "string" ? m.content : contentToText(m.content);
+    if (m.toolUses && m.toolUses.length > 0) {
+      params.push({
+        role: "assistant",
+        content: assistantText || null,
+        tool_calls: m.toolUses.map((tu) => ({
+          id: tu.toolUseId,
+          type: "function",
+          function: {
+            name: tu.toolName,
+            arguments: JSON.stringify(tu.arguments)
+          },
+          ...reasoning ? {
+            reasoning_content: reasoning
+          } : {}
+        }))
+      });
+    } else if (m.toolResults && m.toolResults.length > 0) {
+      const pendingImageParts = [];
+      for (const tr of m.toolResults) {
+        params.push({
+          role: "tool",
+          tool_call_id: tr.toolUseId,
+          content: contentToText(tr.content)
+        });
+        pendingImageParts.push(...collectImageParts(tr));
+      }
+      if (pendingImageParts.length > 0) {
+        params.push({
+          role: "user",
+          content: pendingImageParts
+        });
+      }
+    } else if (m.role === "assistant") {
+      params.push({
+        role: "assistant",
+        content: assistantText,
+        ...reasoning ? {
+          reasoning_content: reasoning
+        } : {}
+      });
+    } else if (m.role === "system") {
+      params.push({
+        role: "system",
+        content: typeof m.content === "string" ? m.content : contentToText(m.content)
+      });
+    } else {
+      params.push({
+        role: "user",
+        content: userPartsFor(m.content)
+      });
+    }
+  }
+  return params;
+}
+
+export {
+  OpenAIClient,
+  buildOpenAIInput,
+  OpenAICompatClient,
+  buildChatCompletionMessages
+};