krisspy-ai 1.1.17

package/dist/index.js

@@ -0,0 +1,3099 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __reExport = (target, mod, secondTarget) => (__copyProps(target, mod, "default"), secondTarget && __copyProps(secondTarget, mod, "default"));
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  AzureDalleService: () => AzureDalleService,
+  AzureProvider: () => AzureProvider,
+  AzureSoraService: () => AzureSoraService,
+  AzureTTSService: () => AzureTTSService,
+  AzureTranscriptionService: () => AzureTranscriptionService,
+  BaseGenerativeService: () => BaseGenerativeService,
+  BaseImageService: () => BaseImageService,
+  BaseProvider: () => BaseProvider,
+  BaseTTSService: () => BaseTTSService,
+  BaseTranscriptionService: () => BaseTranscriptionService,
+  BaseVideoService: () => BaseVideoService,
+  BedrockProvider: () => BedrockProvider,
+  GeminiProvider: () => GeminiProvider,
+  KrisspyProvider: () => KrisspyProvider,
+  OpenAIImageService: () => OpenAIImageService,
+  OpenAIProvider: () => OpenAIProvider,
+  OpenAISoraService: () => OpenAISoraService,
+  OpenAITTSService: () => OpenAITTSService,
+  OpenAITranscriptionService: () => OpenAITranscriptionService,
+  ZAIProvider: () => ZAIProvider,
+  cleanup: () => cleanup,
+  generateImage: () => generateImage,
+  generateVideo: () => generateVideo,
+  getAvailableImageServices: () => getAvailableImageServices,
+  getAvailableProviders: () => getAvailableProviders,
+  getAvailableTTSServices: () => getAvailableTTSServices,
+  getAvailableTranscriptionServices: () => getAvailableTranscriptionServices,
+  getAvailableVideoServices: () => getAvailableVideoServices,
+  getImageService: () => getImageService,
+  getProvider: () => getProvider,
+  getTTSService: () => getTTSService,
+  getTranscriptionService: () => getTranscriptionService,
+  getVideoService: () => getVideoService,
+  query: () => query,
+  registerImageService: () => registerImageService,
+  registerProvider: () => registerProvider,
+  registerTTSService: () => registerTTSService,
+  registerTranscriptionService: () => registerTranscriptionService,
+  registerVideoService: () => registerVideoService,
+  synthesize: () => synthesize,
+  transcribe: () => transcribe
+});
+module.exports = __toCommonJS(index_exports);
+var import_claude_agent_sdk = require("@anthropic-ai/claude-agent-sdk");
+var import_node_fetch13 = __toESM(require("node-fetch"));
+var import_form_data6 = __toESM(require("form-data"));
+var import_http = require("http");
+
+// src/providers/base.ts
+var BaseProvider = class {
+  constructor(config = {}) {
+    this.config = config;
+  }
+};
+
+// src/providers/openai.ts
+var OpenAIProvider = class extends BaseProvider {
+  constructor(config = {}) {
+    super(config);
+    this.baseUrl = config.baseUrl || "https://api.openai.com/v1";
+    this.apiKey = config.apiKey || "";
+    this.defaultModel = config.defaultModel || "gpt-4o";
+    this.modelMap = {
+      "claude-3-5-haiku-20241022": "gpt-4o-mini",
+      "claude-3-5-haiku-latest": "gpt-4o-mini",
+      "claude-haiku-4-5-20251001": "gpt-4o-mini",
+      "claude-3-5-sonnet-20241022": "gpt-5",
+      "claude-sonnet-4-20250514": "gpt-5",
+      "claude-opus-4-20250514": "gpt-5.2",
+      "claude-opus-4-5-20250514": "gpt-5.2",
+      "claude-opus-4-5-20251101": "gpt-5.2"
+    };
+  }
+  getName() {
+    return "openai";
+  }
+  mapModel(anthropicModel) {
+    return this.modelMap[anthropicModel] || this.defaultModel;
+  }
+  convertMessages(anthropicMessages) {
+    const openaiMessages = [];
+    for (const msg of anthropicMessages) {
+      if (typeof msg.content === "string") {
+        openaiMessages.push({
+          role: msg.role === "assistant" ? "assistant" : "user",
+          content: msg.content
+        });
+      } else if (Array.isArray(msg.content)) {
+        const contentParts = [];
+        const toolCalls = [];
+        let hasImages = false;
+        for (const block of msg.content) {
+          if (block.type === "text") {
+            contentParts.push({ type: "text", text: block.text });
+          } else if (block.type === "image") {
+            hasImages = true;
+            if (block.source?.type === "url") {
+              contentParts.push({
+                type: "image_url",
+                image_url: { url: block.source.url }
+              });
+            } else if (block.source?.type === "base64") {
+              contentParts.push({
+                type: "image_url",
+                image_url: {
+                  url: `data:${block.source.media_type};base64,${block.source.data}`
+                }
+              });
+            }
+          } else if (block.type === "document") {
+            hasImages = true;
+            const source = block.source;
+            const data = source?.data;
+            contentParts.push({
+              type: "file",
+              file: {
+                filename: "document.pdf",
+                file_data: `data:application/pdf;base64,${data}`
+              }
+            });
+          } else if (block.type === "tool_result") {
+            openaiMessages.push({
+              role: "tool",
+              tool_call_id: block.tool_use_id,
+              content: typeof block.content === "string" ? block.content : JSON.stringify(block.content)
+            });
+          } else if (block.type === "tool_use") {
+            toolCalls.push({
+              id: block.id,
+              type: "function",
+              function: {
+                name: block.name,
+                arguments: JSON.stringify(block.input)
+              }
+            });
+          }
+        }
+        if (msg.role === "assistant" && toolCalls.length > 0) {
+          const textContent = contentParts.filter((p) => p.type === "text").map((p) => p.text).join("");
+          openaiMessages.push({
+            role: "assistant",
+            content: textContent || null,
+            tool_calls: toolCalls
+          });
+        } else if (contentParts.length > 0) {
+          if (hasImages) {
+            openaiMessages.push({
+              role: msg.role === "assistant" ? "assistant" : "user",
+              content: contentParts
+            });
+          } else {
+            const textContent = contentParts.map((p) => p.text).join("");
+            if (textContent) {
+              openaiMessages.push({
+                role: msg.role === "assistant" ? "assistant" : "user",
+                content: textContent
+              });
+            }
+          }
+        }
+      }
+    }
+    return openaiMessages;
+  }
+  convertTools(anthropicTools) {
+    if (!anthropicTools || anthropicTools.length === 0) return void 0;
+    return anthropicTools.map((tool) => {
+      const params = tool.input_schema || { type: "object", properties: {} };
+      return {
+        type: "function",
+        function: {
+          name: tool.name,
+          description: tool.description || "",
+          parameters: params
+        }
+      };
+    });
+  }
+  buildRequest(anthropicRequest) {
+    const { model, messages, max_tokens, system, tools, tool_choice } = anthropicRequest;
+    const mappedModel = this.mapModel(model);
+    const openaiMessages = [];
+    if (system) {
+      let systemContent;
+      if (typeof system === "string") {
+        systemContent = system;
+      } else if (Array.isArray(system)) {
+        systemContent = system.map((s) => s.text || s).join("\n");
+      } else {
+        systemContent = "";
+      }
+      openaiMessages.push({ role: "system", content: systemContent });
+    }
+    openaiMessages.push(...this.convertMessages(messages));
+    const openaiRequest = {
+      model: mappedModel,
+      messages: openaiMessages,
+      stream: true,
+      stream_options: { include_usage: true }
+    };
+    if (max_tokens) {
+      if (mappedModel.startsWith("o1") || mappedModel.startsWith("o3") || mappedModel.startsWith("gpt-5")) {
+        openaiRequest.max_completion_tokens = max_tokens;
+      } else {
+        openaiRequest.max_tokens = max_tokens;
+      }
+    }
+    const openaiTools = this.convertTools(tools);
+    if (openaiTools && openaiTools.length > 0) {
+      openaiRequest.tools = openaiTools;
+      if (tool_choice) {
+        if (tool_choice.type === "auto") {
+          openaiRequest.tool_choice = "auto";
+        } else if (tool_choice.type === "any") {
+          openaiRequest.tool_choice = "required";
+        } else if (tool_choice.type === "tool" && tool_choice.name) {
+          openaiRequest.tool_choice = {
+            type: "function",
+            function: { name: tool_choice.name }
+          };
+        }
+      }
+    }
+    return openaiRequest;
+  }
+  getEndpoint() {
+    return `${this.baseUrl}/chat/completions`;
+  }
+  getHeaders() {
+    return {
+      "Content-Type": "application/json",
+      Authorization: `Bearer ${this.apiKey}`
+    };
+  }
+  async handleStreamingResponse(providerResponse, res, messageId, requestedModel) {
+    res.setHeader("Content-Type", "text/event-stream");
+    res.setHeader("Cache-Control", "no-cache");
+    res.setHeader("Connection", "keep-alive");
+    res.setHeader("X-Accel-Buffering", "no");
+    res.flushHeaders();
+    let contentBlockIndex = 0;
+    let outputTokens = 0;
+    const toolCallsBuffer = {};
+    const writeAndFlush = (data) => {
+      res.write(data);
+      if (res.flush) res.flush();
+    };
+    const messageStart = {
+      type: "message_start",
+      message: {
+        id: messageId,
+        type: "message",
+        role: "assistant",
+        content: [],
+        model: requestedModel,
+        stop_reason: null,
+        stop_sequence: null,
+        usage: { input_tokens: 0, output_tokens: 0 }
+      }
+    };
+    writeAndFlush(`event: message_start
+data: ${JSON.stringify(messageStart)}
+
+`);
+    writeAndFlush(
+      `event: content_block_start
+data: ${JSON.stringify({
+        type: "content_block_start",
+        index: contentBlockIndex,
+        content_block: { type: "text", text: "" }
+      })}
+
+`
+    );
+    const reader = providerResponse.body;
+    let buffer = "";
+    return new Promise((resolve, reject) => {
+      reader.on("data", (chunk) => {
+        buffer += chunk.toString();
+        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]") {
+              writeAndFlush(
+                `event: content_block_stop
+data: ${JSON.stringify({
+                  type: "content_block_stop",
+                  index: contentBlockIndex
+                })}
+
+`
+              );
+              const toolCalls = Object.values(toolCallsBuffer);
+              if (toolCalls.length > 0) {
+                for (const tc of toolCalls) {
+                  contentBlockIndex++;
+                  writeAndFlush(
+                    `event: content_block_start
+data: ${JSON.stringify({
+                      type: "content_block_start",
+                      index: contentBlockIndex,
+                      content_block: {
+                        type: "tool_use",
+                        id: tc.id,
+                        name: tc.name,
+                        input: {}
+                      }
+                    })}
+
+`
+                  );
+                  if (tc.arguments) {
+                    writeAndFlush(
+                      `event: content_block_delta
+data: ${JSON.stringify({
+                        type: "content_block_delta",
+                        index: contentBlockIndex,
+                        delta: { type: "input_json_delta", partial_json: tc.arguments }
+                      })}
+
+`
+                    );
+                  }
+                  writeAndFlush(
+                    `event: content_block_stop
+data: ${JSON.stringify({
+                      type: "content_block_stop",
+                      index: contentBlockIndex
+                    })}
+
+`
+                  );
+                }
+              }
+              const stopReason = toolCalls.length > 0 ? "tool_use" : "end_turn";
+              writeAndFlush(
+                `event: message_delta
+data: ${JSON.stringify({
+                  type: "message_delta",
+                  delta: { stop_reason: stopReason, stop_sequence: null },
+                  usage: { output_tokens: outputTokens }
+                })}
+
+`
+              );
+              writeAndFlush(
+                `event: message_stop
+data: ${JSON.stringify({ type: "message_stop" })}
+
+`
+              );
+              resolve();
+              return;
+            }
+            try {
+              const parsed = JSON.parse(data);
+              const choice = parsed.choices?.[0];
+              const textContent = choice?.delta?.content;
+              if (textContent) {
+                outputTokens++;
+                writeAndFlush(
+                  `event: content_block_delta
+data: ${JSON.stringify({
+                    type: "content_block_delta",
+                    index: contentBlockIndex,
+                    delta: { type: "text_delta", text: textContent }
+                  })}
+
+`
+                );
+              }
+              if (choice?.delta?.tool_calls) {
+                for (const toolCall of choice.delta.tool_calls) {
+                  const idx = toolCall.index;
+                  if (!toolCallsBuffer[idx]) {
+                    toolCallsBuffer[idx] = {
+                      id: toolCall.id || `toolu_${Date.now()}_${idx}`,
+                      name: "",
+                      arguments: ""
+                    };
+                  }
+                  if (toolCall.id) {
+                    toolCallsBuffer[idx].id = toolCall.id;
+                  }
+                  if (toolCall.function?.name) {
+                    toolCallsBuffer[idx].name = toolCall.function.name;
+                  }
+                  if (toolCall.function?.arguments) {
+                    toolCallsBuffer[idx].arguments += toolCall.function.arguments;
+                  }
+                }
+              }
+              if (parsed.usage) {
+                outputTokens = parsed.usage.completion_tokens || 0;
+              }
+            } catch {
+            }
+          }
+        }
+      });
+      reader.on("end", () => resolve());
+      reader.on("error", reject);
+    });
+  }
+  convertResponse(providerData, messageId, requestedModel) {
+    const data = providerData;
+    const content = [];
+    if (data.choices[0].message.content) {
+      content.push({ type: "text", text: data.choices[0].message.content });
+    }
+    if (data.choices[0].message.tool_calls) {
+      for (const tc of data.choices[0].message.tool_calls) {
+        let parsedInput = {};
+        try {
+          parsedInput = JSON.parse(tc.function.arguments);
+        } catch {
+          parsedInput = {};
+        }
+        content.push({
+          type: "tool_use",
+          id: tc.id,
+          name: tc.function.name,
+          input: parsedInput
+        });
+      }
+    }
+    const stopReason = data.choices[0].message.tool_calls ? "tool_use" : "end_turn";
+    return {
+      id: messageId,
+      type: "message",
+      role: "assistant",
+      content,
+      model: requestedModel,
+      stop_reason: stopReason,
+      stop_sequence: null,
+      usage: {
+        input_tokens: data.usage?.prompt_tokens || 0,
+        output_tokens: data.usage?.completion_tokens || 0
+      }
+    };
+  }
+};
+
+// src/providers/zai.ts
+var ZAIProvider = class extends BaseProvider {
+  constructor(config = {}) {
+    super(config);
+    this.baseUrl = config.baseUrl || "https://api.z.ai/api/coding/paas/v4";
+    this.apiKey = config.apiKey || "";
+    this.defaultModel = config.defaultModel || "glm-4.7";
+    this.modelMap = {
+      "claude-3-5-haiku-20241022": "glm-4.7",
+      "claude-3-5-haiku-latest": "glm-4.7",
+      "claude-haiku-4-5-20251001": "glm-4.7",
+      "claude-3-5-sonnet-20241022": "glm-4.7",
+      "claude-sonnet-4-20250514": "glm-4.7",
+      "claude-opus-4-20250514": "glm-4.7",
+      "claude-opus-4-5-20250514": "glm-4.7",
+      "claude-opus-4-5-20251101": "glm-4.7"
+    };
+  }
+  getName() {
+    return "zai";
+  }
+  mapModel(anthropicModel) {
+    return this.modelMap[anthropicModel] || this.defaultModel;
+  }
+  convertMessages(anthropicMessages) {
+    const openaiMessages = [];
+    for (const msg of anthropicMessages) {
+      if (typeof msg.content === "string") {
+        openaiMessages.push({
+          role: msg.role === "assistant" ? "assistant" : "user",
+          content: msg.content
+        });
+      } else if (Array.isArray(msg.content)) {
+        const contentParts = [];
+        const toolCalls = [];
+        let hasMultimodal = false;
+        for (const block of msg.content) {
+          if (block.type === "text") {
+            contentParts.push({ type: "text", text: block.text });
+          } else if (block.type === "image") {
+            hasMultimodal = true;
+            if (block.source?.type === "url") {
+              contentParts.push({
+                type: "image_url",
+                image_url: { url: block.source.url }
+              });
+            } else if (block.source?.type === "base64") {
+              contentParts.push({
+                type: "image_url",
+                image_url: {
+                  url: `data:${block.source.media_type};base64,${block.source.data}`
+                }
+              });
+            }
+          } else if (block.type === "document") {
+            hasMultimodal = true;
+            const source = block.source;
+            const data = source?.data;
+            contentParts.push({
+              type: "file",
+              file: {
+                filename: "document.pdf",
+                file_data: `data:application/pdf;base64,${data}`
+              }
+            });
+          } else if (block.type === "tool_result") {
+            openaiMessages.push({
+              role: "tool",
+              tool_call_id: block.tool_use_id,
+              content: typeof block.content === "string" ? block.content : JSON.stringify(block.content)
+            });
+          } else if (block.type === "tool_use") {
+            toolCalls.push({
+              id: block.id,
+              type: "function",
+              function: {
+                name: block.name,
+                arguments: JSON.stringify(block.input)
+              }
+            });
+          }
+        }
+        if (msg.role === "assistant" && toolCalls.length > 0) {
+          const textContent = contentParts.filter((p) => p.type === "text").map((p) => p.text).join("");
+          openaiMessages.push({
+            role: "assistant",
+            content: textContent || null,
+            tool_calls: toolCalls
+          });
+        } else if (contentParts.length > 0) {
+          if (hasMultimodal) {
+            openaiMessages.push({
+              role: msg.role === "assistant" ? "assistant" : "user",
+              content: contentParts
+            });
+          } else {
+            const textContent = contentParts.map((p) => p.text).join("");
+            if (textContent) {
+              openaiMessages.push({
+                role: msg.role === "assistant" ? "assistant" : "user",
+                content: textContent
+              });
+            }
+          }
+        }
+      }
+    }
+    return openaiMessages;
+  }
+  convertTools(anthropicTools) {
+    if (!anthropicTools) return void 0;
+    return anthropicTools.map((tool) => ({
+      type: "function",
+      function: {
+        name: tool.name,
+        description: tool.description,
+        parameters: tool.input_schema
+      }
+    }));
+  }
+  buildRequest(anthropicRequest) {
+    const { model, messages, max_tokens, system, tools } = anthropicRequest;
+    const mappedModel = this.mapModel(model);
+    const openaiMessages = [];
+    if (system) {
+      const systemContent = typeof system === "string" ? system : system.map((s) => s.text).join("\n");
+      openaiMessages.push({ role: "system", content: systemContent });
+    }
+    openaiMessages.push(...this.convertMessages(messages));
+    const openaiRequest = {
+      model: mappedModel,
+      messages: openaiMessages,
+      max_tokens: max_tokens || 4096,
+      stream: true,
+      temperature: 0.7
+    };
+    const openaiTools = this.convertTools(tools);
+    if (openaiTools) {
+      openaiRequest.tools = openaiTools;
+    }
+    return openaiRequest;
+  }
+  getEndpoint() {
+    return `${this.baseUrl}/chat/completions`;
+  }
+  getHeaders() {
+    return {
+      "Content-Type": "application/json",
+      Authorization: `Bearer ${this.apiKey}`,
+      "Accept-Language": "en-US,en"
+    };
+  }
+  async handleStreamingResponse(providerResponse, res, messageId, requestedModel) {
+    res.setHeader("Content-Type", "text/event-stream");
+    res.setHeader("Cache-Control", "no-cache");
+    res.setHeader("Connection", "keep-alive");
+    res.setHeader("X-Accel-Buffering", "no");
+    res.flushHeaders();
+    let contentBlockIndex = 0;
+    let outputTokens = 0;
+    const toolCallsBuffer = {};
+    const writeAndFlush = (data) => {
+      res.write(data);
+      if (res.flush) res.flush();
+    };
+    const messageStart = {
+      type: "message_start",
+      message: {
+        id: messageId,
+        type: "message",
+        role: "assistant",
+        content: [],
+        model: requestedModel,
+        stop_reason: null,
+        stop_sequence: null,
+        usage: { input_tokens: 0, output_tokens: 0 }
+      }
+    };
+    writeAndFlush(`event: message_start
+data: ${JSON.stringify(messageStart)}
+
+`);
+    writeAndFlush(
+      `event: content_block_start
+data: ${JSON.stringify({
+        type: "content_block_start",
+        index: contentBlockIndex,
+        content_block: { type: "text", text: "" }
+      })}
+
+`
+    );
+    const reader = providerResponse.body;
+    let buffer = "";
+    return new Promise((resolve, reject) => {
+      reader.on("data", (chunk) => {
+        buffer += chunk.toString();
+        const lines = buffer.split("\n");
+        buffer = lines.pop() || "";
+        for (const line of lines) {
+          if (line.startsWith("data: ")) {
+            const data = line.slice(6);
+            if (data === "[DONE]") {
+              writeAndFlush(
+                `event: content_block_stop
+data: ${JSON.stringify({
+                  type: "content_block_stop",
+                  index: contentBlockIndex
+                })}
+
+`
+              );
+              writeAndFlush(
+                `event: message_delta
+data: ${JSON.stringify({
+                  type: "message_delta",
+                  delta: { stop_reason: "end_turn", stop_sequence: null },
+                  usage: { output_tokens: outputTokens }
+                })}
+
+`
+              );
+              writeAndFlush(
+                `event: message_stop
+data: ${JSON.stringify({ type: "message_stop" })}
+
+`
+              );
+              resolve();
+              return;
+            }
+            try {
+              const parsed = JSON.parse(data);
+              const choice = parsed.choices?.[0];
+              const textContent = choice?.delta?.content || choice?.delta?.reasoning_content;
+              if (textContent) {
+                outputTokens++;
+                writeAndFlush(
+                  `event: content_block_delta
+data: ${JSON.stringify({
+                    type: "content_block_delta",
+                    index: contentBlockIndex,
+                    delta: { type: "text_delta", text: textContent }
+                  })}
+
+`
+                );
+              }
+              if (choice?.delta?.tool_calls) {
+                for (const toolCall of choice.delta.tool_calls) {
+                  const idx = toolCall.index;
+                  if (!toolCallsBuffer[idx]) {
+                    toolCallsBuffer[idx] = {
+                      id: toolCall.id || `tool_${idx}`,
+                      name: "",
+                      arguments: ""
+                    };
+                  }
+                  if (toolCall.function?.name) {
+                    toolCallsBuffer[idx].name = toolCall.function.name;
+                  }
+                  if (toolCall.function?.arguments) {
+                    toolCallsBuffer[idx].arguments += toolCall.function.arguments;
+                  }
+                }
+              }
+              if (parsed.usage) {
+                outputTokens = parsed.usage.completion_tokens || 0;
+              }
+            } catch {
+            }
+          }
+        }
+      });
+      reader.on("end", () => {
+        const toolCalls = Object.values(toolCallsBuffer);
+        if (toolCalls.length > 0) {
+          for (const tc of toolCalls) {
+            contentBlockIndex++;
+            writeAndFlush(
+              `event: content_block_start
+data: ${JSON.stringify({
+                type: "content_block_start",
+                index: contentBlockIndex,
+                content_block: {
+                  type: "tool_use",
+                  id: tc.id,
+                  name: tc.name,
+                  input: {}
+                }
+              })}
+
+`
+            );
+            if (tc.arguments) {
+              writeAndFlush(
+                `event: content_block_delta
+data: ${JSON.stringify({
+                  type: "content_block_delta",
+                  index: contentBlockIndex,
+                  delta: { type: "input_json_delta", partial_json: tc.arguments }
+                })}
+
+`
+              );
+            }
+            writeAndFlush(
+              `event: content_block_stop
+data: ${JSON.stringify({
+                type: "content_block_stop",
+                index: contentBlockIndex
+              })}
+
+`
+            );
+          }
+        }
+        resolve();
+      });
+      reader.on("error", reject);
+    });
+  }
+  convertResponse(providerData, messageId, requestedModel) {
+    const data = providerData;
+    return {
+      id: messageId,
+      type: "message",
+      role: "assistant",
+      content: [{ type: "text", text: data.choices[0].message.content || "" }],
+      model: requestedModel,
+      stop_reason: "end_turn",
+      stop_sequence: null,
+      usage: {
+        input_tokens: data.usage?.prompt_tokens || 0,
+        output_tokens: data.usage?.completion_tokens || 0
+      }
+    };
+  }
+};
+
+// src/providers/gemini.ts
+var GeminiProvider = class extends OpenAIProvider {
+  constructor(config = {}) {
+    super(config);
+    this.baseUrl = config.baseUrl || "https://generativelanguage.googleapis.com/v1beta/openai";
+    this.apiKey = config.apiKey || "";
+    this.defaultModel = config.defaultModel || "gemini-2.5-flash";
+    this.modelMap = {
+      "claude-3-5-haiku-20241022": "gemini-2.5-flash",
+      "claude-3-5-haiku-latest": "gemini-2.5-flash",
+      "claude-haiku-4-5-20251001": "gemini-2.5-flash",
+      "claude-3-5-sonnet-20241022": "gemini-2.5-pro",
+      "claude-sonnet-4-20250514": "gemini-2.5-pro",
+      "claude-opus-4-20250514": "gemini-2.5-pro",
+      "claude-opus-4-5-20250514": "gemini-2.5-pro",
+      "claude-opus-4-5-20251101": "gemini-2.5-pro"
+    };
+  }
+  getName() {
+    return "gemini";
+  }
+  buildRequest(anthropicRequest) {
+    const request = super.buildRequest(anthropicRequest);
+    if (request.max_completion_tokens) {
+      request.max_tokens = request.max_completion_tokens;
+      delete request.max_completion_tokens;
+    }
+    return request;
+  }
+  getHeaders() {
+    return {
+      "Content-Type": "application/json",
+      Authorization: `Bearer ${this.apiKey}`
+    };
+  }
+};
+
+// src/providers/bedrock.ts
+var crypto = __toESM(require("crypto"));
+var BedrockProvider = class extends BaseProvider {
+  // Track model for current request
+  constructor(config = {}) {
+    super(config);
+    this.region = config.region || "us-west-2";
+    this.accessKeyId = config.accessKeyId || config.apiKey || "";
+    this.secretAccessKey = config.secretAccessKey || "";
+    this.defaultModel = config.defaultModel || "anthropic.claude-3-5-sonnet-20241022-v2:0";
+    this.modelMap = {
+      "claude-3-5-haiku-20241022": "anthropic.claude-3-5-haiku-20241022-v1:0",
+      "claude-3-5-haiku-latest": "anthropic.claude-3-5-haiku-20241022-v1:0",
+      "claude-haiku-4-5-20251001": "anthropic.claude-3-5-haiku-20241022-v1:0",
+      "claude-3-5-sonnet-20241022": "anthropic.claude-3-5-sonnet-20241022-v2:0",
+      "claude-3-5-sonnet-latest": "anthropic.claude-3-5-sonnet-20241022-v2:0",
+      // Claude 4 models - these require inference profiles, fallback to 3.5 for on-demand
+      "claude-sonnet-4-20250514": "anthropic.claude-3-5-sonnet-20241022-v2:0",
+      "claude-sonnet-4-5-20250514": "anthropic.claude-3-5-sonnet-20241022-v2:0",
+      "claude-sonnet-4-5": "anthropic.claude-3-5-sonnet-20241022-v2:0",
+      "claude-opus-4-20250514": "anthropic.claude-3-5-sonnet-20241022-v2:0",
+      "claude-opus-4-5-20250514": "anthropic.claude-3-5-sonnet-20241022-v2:0",
+      "claude-opus-4-5-20251101": "anthropic.claude-3-5-sonnet-20241022-v2:0",
+      // Short aliases
+      "sonnet": "anthropic.claude-3-5-sonnet-20241022-v2:0",
+      "haiku": "anthropic.claude-3-5-haiku-20241022-v1:0",
+      "opus": "anthropic.claude-3-5-sonnet-20241022-v2:0"
+    };
+    this.currentModel = this.defaultModel;
+  }
+  getName() {
+    return "bedrock";
+  }
+  mapModel(anthropicModel) {
+    return this.modelMap[anthropicModel] || this.defaultModel;
+  }
+  // Bedrock uses native Anthropic format - pass through
+  convertMessages(anthropicMessages) {
+    return anthropicMessages;
+  }
+  // Bedrock uses native Anthropic format - pass through
+  convertTools(anthropicTools) {
+    return anthropicTools;
+  }
+  // AWS Signature V4 signing
+  sign(key, msg) {
+    return crypto.createHmac("sha256", key).update(msg, "utf8").digest();
+  }
+  getSignatureKey(key, dateStamp, region, service) {
+    const kDate = this.sign(Buffer.from("AWS4" + key, "utf8"), dateStamp);
+    const kRegion = this.sign(kDate, region);
+    const kService = this.sign(kRegion, service);
+    const kSigning = this.sign(kService, "aws4_request");
+    return kSigning;
+  }
+  createAuthHeaders(method, host, uri, queryString, payload, amzDate, dateStamp) {
+    const service = "bedrock";
+    const algorithm = "AWS4-HMAC-SHA256";
+    const contentType = "application/json";
+    const payloadHash = crypto.createHash("sha256").update(payload, "utf8").digest("hex");
+    const canonicalHeaders = `content-type:${contentType}
+host:${host}
+x-amz-date:${amzDate}
+`;
+    const signedHeaders = "content-type;host;x-amz-date";
+    const canonicalRequest = [
+      method,
+      uri,
+      queryString,
+      canonicalHeaders,
+      signedHeaders,
+      payloadHash
+    ].join("\n");
+    const credentialScope = `${dateStamp}/${this.region}/${service}/aws4_request`;
+    const stringToSign = [
+      algorithm,
+      amzDate,
+      credentialScope,
+      crypto.createHash("sha256").update(canonicalRequest, "utf8").digest("hex")
+    ].join("\n");
+    const signingKey = this.getSignatureKey(this.secretAccessKey, dateStamp, this.region, service);
+    const signature = crypto.createHmac("sha256", signingKey).update(stringToSign, "utf8").digest("hex");
+    const authorizationHeader = `${algorithm} Credential=${this.accessKeyId}/${credentialScope}, SignedHeaders=${signedHeaders}, Signature=${signature}`;
+    return {
+      "Content-Type": contentType,
+      "X-Amz-Date": amzDate,
+      "Authorization": authorizationHeader
+    };
+  }
+  buildRequest(anthropicRequest) {
+    const { model, messages, max_tokens, system, tools, tool_choice } = anthropicRequest;
+    this.currentModel = this.mapModel(model);
+    const bedrockRequest = {
+      anthropic_version: "bedrock-2023-05-31",
+      model: "",
+      // Will be removed below
+      messages,
+      max_tokens: max_tokens || 4096
+    };
+    if (system) {
+      bedrockRequest.system = system;
+    }
+    if (tools && tools.length > 0) {
+      bedrockRequest.tools = tools;
+      if (tool_choice) {
+        bedrockRequest.tool_choice = tool_choice;
+      }
+    }
+    delete bedrockRequest.model;
+    return bedrockRequest;
+  }
+  getEndpoint() {
+    const modelId = this.currentModel || this.defaultModel;
+    return `https://bedrock-runtime.${this.region}.amazonaws.com/model/${modelId}/invoke-with-response-stream`;
+  }
+  getHeaders() {
+    const now = /* @__PURE__ */ new Date();
+    const amzDate = now.toISOString().replace(/[:-]|\.\d{3}/g, "");
+    const host = `bedrock-runtime.${this.region}.amazonaws.com`;
+    return {
+      "Content-Type": "application/json",
+      "X-Amz-Date": amzDate,
+      "Host": host
+    };
+  }
+  // Custom method to get signed headers with payload
+  getSignedHeaders(payload) {
+    const now = /* @__PURE__ */ new Date();
+    const amzDate = now.toISOString().replace(/[:-]|\.\d{3}/g, "");
+    const dateStamp = amzDate.slice(0, 8);
+    const host = `bedrock-runtime.${this.region}.amazonaws.com`;
+    const modelId = this.currentModel || this.defaultModel;
+    const encodedModelId = modelId.replace(/:/g, "%3A");
+    const uri = `/model/${encodedModelId}/invoke-with-response-stream`;
+    return this.createAuthHeaders("POST", host, uri, "", payload, amzDate, dateStamp);
+  }
+  async handleStreamingResponse(providerResponse, res, messageId, requestedModel) {
+    res.setHeader("Content-Type", "text/event-stream");
+    res.setHeader("Cache-Control", "no-cache");
+    res.setHeader("Connection", "keep-alive");
+    res.setHeader("X-Accel-Buffering", "no");
+    res.flushHeaders();
+    let contentBlockIndex = 0;
+    let outputTokens = 0;
+    const writeAndFlush = (data) => {
+      res.write(data);
+      if (res.flush) res.flush();
+    };
+    const messageStart = {
+      type: "message_start",
+      message: {
+        id: messageId,
+        type: "message",
+        role: "assistant",
+        content: [],
+        model: requestedModel,
+        stop_reason: null,
+        stop_sequence: null,
+        usage: { input_tokens: 0, output_tokens: 0 }
+      }
+    };
+    writeAndFlush(`event: message_start
+data: ${JSON.stringify(messageStart)}
+
+`);
+    writeAndFlush(
+      `event: content_block_start
+data: ${JSON.stringify({
+        type: "content_block_start",
+        index: contentBlockIndex,
+        content_block: { type: "text", text: "" }
+      })}
+
+`
+    );
+    const reader = providerResponse.body;
+    let buffer = Buffer.alloc(0);
+    let hasStartedContent = false;
+    const parseEventStreamMessage = (data) => {
+      if (data.length < 16) return null;
+      const totalLength = data.readUInt32BE(0);
+      const headersLength = data.readUInt32BE(4);
+      if (data.length < totalLength) return null;
+      const headersStart = 12;
+      const headersEnd = headersStart + headersLength;
+      const payloadStart = headersEnd;
+      const payloadEnd = totalLength - 4;
+      let eventType = "";
+      let pos = headersStart;
+      while (pos < headersEnd && pos < data.length) {
+        const nameLen = data.readUInt8(pos);
+        pos++;
+        if (pos + nameLen > data.length) break;
+        const name = data.slice(pos, pos + nameLen).toString("utf8");
+        pos += nameLen;
+        if (pos >= data.length) break;
+        const headerType = data.readUInt8(pos);
+        pos++;
+        if (headerType === 7) {
+          if (pos + 2 > data.length) break;
+          const valueLen = data.readUInt16BE(pos);
+          pos += 2;
+          if (pos + valueLen > data.length) break;
+          const value = data.slice(pos, pos + valueLen).toString("utf8");
+          pos += valueLen;
+          if (name === ":event-type") eventType = value;
+        }
+      }
+      const payload = data.slice(payloadStart, payloadEnd).toString("utf8");
+      return { eventType, payload };
+    };
+    return new Promise((resolve, reject) => {
+      let chunkCount = 0;
+      reader.on("data", (chunk) => {
+        buffer = Buffer.concat([buffer, chunk]);
+        chunkCount++;
+        while (buffer.length >= 16) {
+          const totalLength = buffer.readUInt32BE(0);
+          if (buffer.length < totalLength) break;
+          const message = buffer.slice(0, totalLength);
+          buffer = buffer.slice(totalLength);
+          const event = parseEventStreamMessage(message);
+          if (!event || !event.payload) continue;
+          const jsonStart = event.payload.indexOf("{");
+          if (jsonStart === -1) continue;
+          try {
+            const jsonStr = event.payload.slice(jsonStart);
+            const wrapper = JSON.parse(jsonStr);
+            let parsed;
+            if (wrapper.bytes) {
+              const decodedPayload = Buffer.from(wrapper.bytes, "base64").toString("utf8");
+              parsed = JSON.parse(decodedPayload);
+              if (process.env.DEBUG_BEDROCK) {
+                console.log(`[Bedrock] Decoded: ${decodedPayload.substring(0, 100)}`);
+              }
+            } else {
+              parsed = wrapper;
+            }
+            if (parsed.type === "content_block_delta" && parsed.delta?.text) {
+              hasStartedContent = true;
+              outputTokens++;
+              writeAndFlush(
+                `event: content_block_delta
+data: ${JSON.stringify({
+                  type: "content_block_delta",
+                  index: contentBlockIndex,
+                  delta: { type: "text_delta", text: parsed.delta.text }
+                })}
+
+`
+              );
+            }
+            if (parsed.type === "message_delta" && parsed.usage) {
+              outputTokens = parsed.usage.output_tokens || outputTokens;
+            }
+            if (parsed.type === "message_stop") {
+              writeAndFlush(
+                `event: content_block_stop
+data: ${JSON.stringify({
+                  type: "content_block_stop",
+                  index: contentBlockIndex
+                })}
+
+`
+              );
+              writeAndFlush(
+                `event: message_delta
+data: ${JSON.stringify({
+                  type: "message_delta",
+                  delta: { stop_reason: "end_turn", stop_sequence: null },
+                  usage: { output_tokens: outputTokens }
+                })}
+
+`
+              );
+              writeAndFlush(
+                `event: message_stop
+data: ${JSON.stringify({ type: "message_stop" })}
+
+`
+              );
+            }
+          } catch {
+          }
+        }
+      });
+      reader.on("end", () => {
+        if (process.env.DEBUG_BEDROCK) {
+          console.log(`[Bedrock] Stream ended. Chunks: ${chunkCount}, hasContent: ${hasStartedContent}`);
+        }
+        if (hasStartedContent) {
+          writeAndFlush(
+            `event: content_block_stop
+data: ${JSON.stringify({
+              type: "content_block_stop",
+              index: contentBlockIndex
+            })}
+
+`
+          );
+        }
+        writeAndFlush(
+          `event: message_delta
+data: ${JSON.stringify({
+            type: "message_delta",
+            delta: { stop_reason: "end_turn", stop_sequence: null },
+            usage: { output_tokens: outputTokens }
+          })}
+
+`
+        );
+        writeAndFlush(
+          `event: message_stop
+data: ${JSON.stringify({ type: "message_stop" })}
+
+`
+        );
+        resolve();
+      });
+      reader.on("error", reject);
+    });
+  }
+  convertResponse(providerData, messageId, requestedModel) {
+    const data = providerData;
+    return {
+      id: messageId,
+      type: "message",
+      role: "assistant",
+      content: data.content,
+      model: requestedModel,
+      stop_reason: data.stop_reason || "end_turn",
+      stop_sequence: null,
+      usage: {
+        input_tokens: data.usage?.input_tokens || 0,
+        output_tokens: data.usage?.output_tokens || 0
+      }
+    };
+  }
+};
+
+// src/providers/azure.ts
+var AzureProvider = class extends OpenAIProvider {
+  constructor(config = {}) {
+    super(config);
+    this.baseUrl = config.baseUrl || "";
+    this.apiKey = config.apiKey || "";
+    this.deploymentName = config.deploymentName || config.defaultModel || "gpt-4o";
+    this.apiVersion = config.apiVersion || "2024-10-21";
+    this.defaultModel = this.deploymentName;
+    this.modelMap = {
+      "claude-3-5-haiku-20241022": "gpt-4o-mini",
+      "claude-3-5-haiku-latest": "gpt-4o-mini",
+      "claude-haiku-4-5-20251001": "gpt-4o-mini",
+      "claude-3-5-sonnet-20241022": "gpt-4o",
+      "claude-sonnet-4-20250514": "gpt-4o",
+      "claude-opus-4-20250514": "gpt-4o",
+      "claude-opus-4-5-20250514": "gpt-4o",
+      "claude-opus-4-5-20251101": "gpt-4o",
+      "sonnet": "gpt-4o",
+      "haiku": "gpt-4o-mini",
+      "opus": "gpt-4o"
+    };
+  }
+  getName() {
+    return "azure";
+  }
+  mapModel(anthropicModel) {
+    if (this.deploymentName && this.deploymentName !== "gpt-4o") {
+      return this.deploymentName;
+    }
+    return this.modelMap[anthropicModel] || this.defaultModel;
+  }
+  buildRequest(anthropicRequest) {
+    const request = super.buildRequest(anthropicRequest);
+    return request;
+  }
+  getEndpoint() {
+    const deployment = this.mapModel(this.defaultModel);
+    return `${this.baseUrl}/openai/deployments/${deployment}/chat/completions?api-version=${this.apiVersion}`;
+  }
+  getHeaders() {
+    return {
+      "Content-Type": "application/json",
+      "api-key": this.apiKey
+    };
+  }
+};
+
+// src/providers/krisspy.ts
+var KrisspyProvider = class extends BaseProvider {
+  constructor(config) {
+    super(config);
+    this.krisspyConfig = config;
+  }
+  getName() {
+    return "krisspy";
+  }
+  /**
+   * Pass through model names as-is
+   * Krisspy backend will handle model name mapping
+   */
+  mapModel(model) {
+    return model;
+  }
+  /**
+   * Pass through Anthropic messages as-is
+   * Krisspy backend expects Anthropic format
+   */
+  convertMessages(messages) {
+    return messages;
+  }
+  /**
+   * Pass through Anthropic tools as-is
+   */
+  convertTools(tools) {
+    return tools;
+  }
+  /**
+   * Build request - pass through as Anthropic format
+   * Add Krisspy-specific headers/metadata
+   */
+  buildRequest(request) {
+    return {
+      ...request,
+      model: this.mapModel(request.model)
+    };
+  }
+  /**
+   * Get Krisspy AI proxy endpoint
+   * Uses /messages endpoint for transparent LLM proxying (agent runs client-side)
+   */
+  getEndpoint() {
+    const baseUrl = this.krisspyConfig.baseUrl || "https://api.krisspy.ai";
+    return `${baseUrl}/api/v1/ai/messages`;
+  }
+  /**
+   * Get headers with Krisspy API key
+   */
+  getHeaders() {
+    if (!this.krisspyConfig.apiKey) {
+      throw new Error("Krisspy API key is required");
+    }
+    const headers = {
+      "Content-Type": "application/json",
+      "Authorization": `Bearer ${this.krisspyConfig.apiKey}`,
+      "X-Krisspy-Provider": "krisspy-ai-sdk"
+    };
+    if (this.krisspyConfig.appId) {
+      headers["X-Krisspy-App-Id"] = this.krisspyConfig.appId;
+    }
+    if (this.krisspyConfig.userId) {
+      headers["X-Krisspy-User-Id"] = this.krisspyConfig.userId;
+    }
+    return headers;
+  }
+  /**
+   * Handle streaming response from Krisspy backend
+   * The backend streams krisspy-ai events as SSE, so we parse and pass through
+   */
+  async handleStreamingResponse(providerResponse, res, messageId, requestedModel) {
+    res.setHeader("Content-Type", "text/event-stream");
+    res.setHeader("Cache-Control", "no-cache");
+    res.setHeader("Connection", "keep-alive");
+    res.flushHeaders();
+    const stream = providerResponse.body;
+    let buffer = "";
+    return new Promise((resolve, reject) => {
+      stream.on("data", (chunk) => {
+        buffer += chunk.toString();
+        const lines = buffer.split("\n");
+        buffer = lines.pop() || "";
+        for (const line of lines) {
+          if (line.startsWith("data: ")) {
+            const data = line.slice(6).trim();
+            res.write(`data: ${data}
+
+`);
+            if (res.flush) {
+              res.flush();
+            }
+          }
+        }
+      });
+      stream.on("end", () => {
+        resolve();
+      });
+      stream.on("error", (err) => {
+        console.error("[krisspy provider] Stream error:", err);
+        reject(err);
+      });
+    });
+  }
+  /**
+   * Convert non-streaming response
+   * Krisspy backend returns Anthropic format, so minimal conversion needed
+   */
+  convertResponse(data, messageId, requestedModel) {
+    const response = data;
+    return {
+      id: response.id || messageId,
+      type: "message",
+      role: "assistant",
+      content: response.content || [],
+      model: response.model || requestedModel,
+      stop_reason: response.stop_reason || null,
+      stop_sequence: response.stop_sequence || null,
+      usage: response.usage || { input_tokens: 0, output_tokens: 0 }
+    };
+  }
+};
+
+// src/providers/index.ts
+var providers = {
+  openai: OpenAIProvider,
+  zai: ZAIProvider,
+  gemini: GeminiProvider,
+  bedrock: BedrockProvider,
+  azure: AzureProvider,
+  krisspy: KrisspyProvider
+};
+function getProvider(name, config = {}) {
+  const ProviderClass = providers[name.toLowerCase()];
+  if (!ProviderClass) {
+    throw new Error(`Unknown provider: ${name}. Available: ${Object.keys(providers).join(", ")}`);
+  }
+  return new ProviderClass(config);
+}
+function registerProvider(name, ProviderClass) {
+  providers[name.toLowerCase()] = ProviderClass;
+}
+function getAvailableProviders() {
+  return Object.keys(providers);
+}
+
+// src/index.ts
+__reExport(index_exports, require("@anthropic-ai/claude-agent-sdk"), module.exports);
+
+// src/services/image/azure-dalle.ts
+var import_node_fetch = __toESM(require("node-fetch"));
+
+// src/services/base.ts
+var BaseGenerativeService = class {
+  constructor(config = {}) {
+    this.config = config;
+  }
+};
+
+// src/services/image/base.ts
+var BaseImageService = class extends BaseGenerativeService {
+  constructor(config = {}) {
+    super(config);
+  }
+  getServiceType() {
+    return "image";
+  }
+};
+
+// src/services/image/azure-dalle.ts
+var AzureDalleService = class extends BaseImageService {
+  constructor(config = {}) {
+    super(config);
+    this.baseUrl = config.baseUrl || "";
+    this.apiKey = config.apiKey || "";
+    this.deploymentName = config.deploymentName || "dall-e-3";
+    this.apiVersion = config.apiVersion || "2024-10-21";
+  }
+  getName() {
+    return "azure-dalle";
+  }
+  async generate(options) {
+    if (!this.baseUrl) {
+      throw new Error("[krisspy-ai] Azure baseUrl is required for image generation");
+    }
+    if (!this.apiKey) {
+      throw new Error("[krisspy-ai] Azure apiKey is required for image generation");
+    }
+    const endpoint = `${this.baseUrl}/openai/deployments/${this.deploymentName}/images/generations?api-version=${this.apiVersion}`;
+    const isGptImage = this.deploymentName.toLowerCase().includes("gpt-image");
+    const body = {
+      prompt: options.prompt,
+      n: options.n || 1,
+      size: options.size || "1024x1024"
+    };
+    if (!isGptImage) {
+      if (options.quality) body.quality = options.quality;
+      if (options.style) body.style = options.style;
+      if (options.responseFormat) body.response_format = options.responseFormat;
+      if (options.user) body.user = options.user;
+    }
+    console.log(`[krisspy-ai] Generating image with Azure DALL-E (deployment: ${this.deploymentName})...`);
+    const response = await (0, import_node_fetch.default)(endpoint, {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json",
+        "api-key": this.apiKey
+      },
+      body: JSON.stringify(body)
+    });
+    if (!response.ok) {
+      const errorText = await response.text();
+      let errorMessage = errorText;
+      try {
+        const parsed = JSON.parse(errorText);
+        errorMessage = parsed.error?.message || errorText;
+      } catch {
+      }
+      throw new Error(`[krisspy-ai] Azure DALL-E generation failed: ${response.status} - ${errorMessage}`);
+    }
+    const data = await response.json();
+    console.log(`[krisspy-ai] Image generation complete. Generated ${data.data.length} image(s).`);
+    return {
+      created: data.created,
+      data: data.data.map((img) => ({
+        url: img.url,
+        b64_json: img.b64_json,
+        revisedPrompt: img.revised_prompt
+      }))
+    };
+  }
+};
+
+// src/services/image/openai-image.ts
+var import_node_fetch2 = __toESM(require("node-fetch"));
+var OpenAIImageService = class extends BaseImageService {
+  constructor(config = {}) {
+    super(config);
+    this.apiKey = config.apiKey || "";
+    this.baseUrl = config.baseUrl || "https://api.openai.com/v1";
+    this.model = config.deploymentName || "gpt-image-1";
+  }
+  getName() {
+    return "openai-image";
+  }
+  async generate(options) {
+    if (!this.apiKey) {
+      throw new Error("[krisspy-ai] OpenAI apiKey is required for image generation");
+    }
+    const endpoint = `${this.baseUrl}/images/generations`;
+    const body = {
+      model: this.model,
+      prompt: options.prompt,
+      n: options.n || 1,
+      size: options.size || "1024x1024"
+    };
+    if (options.quality) body.quality = options.quality;
+    if (options.responseFormat && !this.model.includes("gpt-image")) {
+      body.response_format = options.responseFormat;
+    }
+    if (options.user) body.user = options.user;
+    console.log(`[krisspy-ai] Generating image with OpenAI (model: ${this.model})...`);
+    const response = await (0, import_node_fetch2.default)(endpoint, {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json",
+        "Authorization": `Bearer ${this.apiKey}`
+      },
+      body: JSON.stringify(body)
+    });
+    if (!response.ok) {
+      const errorText = await response.text();
+      let errorMessage = errorText;
+      try {
+        const parsed = JSON.parse(errorText);
+        errorMessage = parsed.error?.message || errorText;
+      } catch {
+      }
+      throw new Error(`[krisspy-ai] OpenAI image generation failed: ${response.status} - ${errorMessage}`);
+    }
+    const data = await response.json();
+    console.log(`[krisspy-ai] Image generation complete. Generated ${data.data.length} image(s).`);
+    return {
+      created: data.created,
+      data: data.data.map((img) => ({
+        url: img.url,
+        b64_json: img.b64_json,
+        revisedPrompt: img.revised_prompt
+      }))
+    };
+  }
+};
+
+// src/services/image/krisspy-image.ts
+var import_node_fetch3 = __toESM(require("node-fetch"));
+var KrisspyImageService = class extends BaseImageService {
+  getName() {
+    return "krisspy";
+  }
+  async generate(options) {
+    const { prompt, size = "1024x1024" } = options;
+    const baseUrl = this.config.baseUrl || "https://api.krisspy.ai";
+    const apiKey = this.config.apiKey;
+    if (!apiKey) {
+      throw new Error("API key is required for Krisspy image service");
+    }
+    const response = await (0, import_node_fetch3.default)(`${baseUrl}/api/v1/ai/image`, {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json",
+        "Authorization": `Bearer ${apiKey}`
+      },
+      body: JSON.stringify({ prompt, size })
+    });
+    if (!response.ok) {
+      const error = await response.json();
+      throw new Error(error.message || `Image generation failed: ${response.statusText}`);
+    }
+    const data = await response.json();
+    return {
+      created: Math.floor(Date.now() / 1e3),
+      data: [{
+        b64_json: data.image,
+        url: void 0,
+        revisedPrompt: data.revisedPrompt
+      }]
+    };
+  }
+};
+
+// src/services/video/azure-sora.ts
+var import_node_fetch4 = __toESM(require("node-fetch"));
+var import_form_data = __toESM(require("form-data"));
+
+// src/services/video/base.ts
+var BaseVideoService = class extends BaseGenerativeService {
+  constructor(config = {}) {
+    super(config);
+  }
+  getServiceType() {
+    return "video";
+  }
+  /**
+   * Convenience generator that submits a job and polls until completion.
+   * Yields status updates and returns the final result.
+   *
+   * @param options - Video generation options
+   * @param pollInterval - Time between status checks in ms (default: 5000)
+   * @param timeout - Max wait time in ms (default: 600000 = 10 minutes)
+   */
+  async *generateAndWait(options, pollInterval = 5e3, timeout = 6e5) {
+    const submission = await this.submitJob(options);
+    const startTime = Date.now();
+    let status;
+    console.log(`[krisspy-ai] Video job submitted: ${submission.jobId}`);
+    do {
+      await new Promise((resolve) => setTimeout(resolve, pollInterval));
+      status = await this.getJobStatus(submission.jobId);
+      console.log(`[krisspy-ai] Job ${submission.jobId} status: ${status.status}`);
+      yield status;
+      if (Date.now() - startTime > timeout) {
+        throw new Error(`[krisspy-ai] Video generation timed out after ${timeout}ms`);
+      }
+    } while (status.status === "pending" || status.status === "running");
+    if (status.status === "failed") {
+      throw new Error(`[krisspy-ai] Video generation failed: ${status.error || "Unknown error"}`);
+    }
+    if (status.status === "canceled") {
+      throw new Error(`[krisspy-ai] Video generation was canceled`);
+    }
+    return await this.getResult(submission.jobId);
+  }
+};
+
+// src/services/video/azure-sora.ts
+var AzureSoraService = class extends BaseVideoService {
+  constructor(config = {}) {
+    super(config);
+    this.baseUrl = config.baseUrl || "";
+    this.apiKey = config.apiKey || "";
+    this.deploymentName = config.deploymentName || "sora-2";
+    this.apiVersion = config.apiVersion || "preview";
+  }
+  getName() {
+    return "azure-sora";
+  }
+  mapStatus(azureStatus) {
+    switch (azureStatus) {
+      // Azure Sora uses lowercase snake_case status values
+      case "pending":
+      case "queued":
+        return "pending";
+      case "in_progress":
+        return "running";
+      case "completed":
+        return "succeeded";
+      case "failed":
+        return "failed";
+      case "canceled":
+        return "canceled";
+      default:
+        console.log(`[krisspy-ai] Unknown status: ${azureStatus}`);
+        return "pending";
+    }
+  }
+  async submitJob(options) {
+    if (!this.baseUrl) {
+      throw new Error("[krisspy-ai] Azure baseUrl is required for video generation");
+    }
+    if (!this.apiKey) {
+      throw new Error("[krisspy-ai] Azure apiKey is required for video generation");
+    }
+    const endpoint = `${this.baseUrl}/openai/v1/videos`;
+    const validSizes = ["720x1280", "1280x720", "1024x1792", "1792x1024"];
+    const requestedSize = options.width && options.height ? `${options.width}x${options.height}` : "1280x720";
+    const size = validSizes.includes(requestedSize) ? requestedSize : "1280x720";
+    const requestedDuration = options.duration || 4;
+    const validDurations = [4, 8, 12];
+    const seconds = validDurations.includes(requestedDuration) ? requestedDuration : validDurations.reduce(
+      (prev, curr) => Math.abs(curr - requestedDuration) < Math.abs(prev - requestedDuration) ? curr : prev
+    );
+    console.log(`[krisspy-ai] Submitting video job to Azure Sora (deployment: ${this.deploymentName})...`);
+    let response;
+    if (options.referenceImage) {
+      const formData = new import_form_data.default();
+      formData.append("model", this.deploymentName);
+      formData.append("prompt", options.prompt);
+      formData.append("size", size);
+      formData.append("seconds", String(seconds));
+      if (options.nVariants && options.nVariants > 1) {
+        formData.append("n_variants", String(options.nVariants));
+      }
+      const isUrl = options.referenceImage.startsWith("http://") || options.referenceImage.startsWith("https://");
+      if (isUrl) {
+        const imageResponse = await (0, import_node_fetch4.default)(options.referenceImage);
+        const imageBuffer = await imageResponse.buffer();
+        formData.append("input_reference", imageBuffer, { filename: "reference.png", contentType: "image/png" });
+      } else {
+        const base64Data = options.referenceImage.startsWith("data:") ? options.referenceImage.split(",")[1] : options.referenceImage;
+        const imageBuffer = Buffer.from(base64Data, "base64");
+        formData.append("input_reference", imageBuffer, { filename: "reference.png", contentType: "image/png" });
+      }
+      console.log(`[krisspy-ai] Using reference image for video generation (multipart form-data)`);
+      response = await (0, import_node_fetch4.default)(endpoint, {
+        method: "POST",
+        headers: {
+          "Authorization": `Bearer ${this.apiKey}`,
+          ...formData.getHeaders()
+        },
+        body: formData
+      });
+    } else {
+      const body = {
+        prompt: options.prompt,
+        seconds: String(seconds),
+        size,
+        model: this.deploymentName
+      };
+      if (options.nVariants && options.nVariants > 1) {
+        body.n_variants = String(options.nVariants);
+      }
+      response = await (0, import_node_fetch4.default)(endpoint, {
+        method: "POST",
+        headers: {
+          "Content-Type": "application/json",
+          "Authorization": `Bearer ${this.apiKey}`
+        },
+        body: JSON.stringify(body)
+      });
+    }
+    if (!response.ok) {
+      const errorText = await response.text();
+      let errorMessage = errorText;
+      try {
+        const parsed = JSON.parse(errorText);
+        errorMessage = parsed.error?.message || errorText;
+      } catch {
+      }
+      throw new Error(`[krisspy-ai] Azure Sora job submission failed: ${response.status} - ${errorMessage}`);
+    }
+    const data = await response.json();
+    return {
+      jobId: data.id,
+      status: this.mapStatus(data.status),
+      createdAt: new Date(data.created_at * 1e3).toISOString()
+    };
+  }
+  async getJobStatus(jobId) {
+    const endpoint = `${this.baseUrl}/openai/v1/videos/${jobId}`;
+    const response = await (0, import_node_fetch4.default)(endpoint, {
+      method: "GET",
+      headers: {
+        "Authorization": `Bearer ${this.apiKey}`
+      }
+    });
+    if (!response.ok) {
+      const errorText = await response.text();
+      throw new Error(`[krisspy-ai] Failed to get job status: ${response.status} - ${errorText}`);
+    }
+    const data = await response.json();
+    if (data.status === "failed" && data.error) {
+      console.log(`[krisspy-ai] Job failed: ${data.error.code} - ${data.error.message}`);
+    }
+    return {
+      jobId: data.id,
+      status: this.mapStatus(data.status),
+      progress: data.progress,
+      error: data.error?.message,
+      createdAt: new Date(data.created_at * 1e3).toISOString(),
+      expiresAt: data.expires_at ? new Date(data.expires_at * 1e3).toISOString() : void 0
+    };
+  }
+  async getResult(jobId) {
+    const endpoint = `${this.baseUrl}/openai/v1/videos/${jobId}`;
+    const response = await (0, import_node_fetch4.default)(endpoint, {
+      method: "GET",
+      headers: {
+        "Authorization": `Bearer ${this.apiKey}`
+      }
+    });
+    if (!response.ok) {
+      const errorText = await response.text();
+      throw new Error(`[krisspy-ai] Failed to get job result: ${response.status} - ${errorText}`);
+    }
+    const data = await response.json();
+    if (data.status !== "completed") {
+      throw new Error(`[krisspy-ai] Job ${jobId} not complete. Status: ${data.status}`);
+    }
+    const generations = [{ id: data.id }];
+    console.log(`[krisspy-ai] Video generation complete. ${generations.length} video(s) generated.`);
+    return {
+      jobId: data.id,
+      status: "succeeded",
+      generations,
+      createdAt: new Date(data.created_at * 1e3).toISOString()
+    };
+  }
+  async downloadVideo(generationId) {
+    const endpoint = `${this.baseUrl}/openai/v1/videos/${generationId}/content`;
+    console.log(`[krisspy-ai] Downloading video ${generationId}...`);
+    const response = await (0, import_node_fetch4.default)(endpoint, {
+      method: "GET",
+      headers: {
+        "Authorization": `Bearer ${this.apiKey}`
+      }
+    });
+    if (!response.ok) {
+      const errorText = await response.text();
+      throw new Error(`[krisspy-ai] Failed to download video: ${response.status} - ${errorText}`);
+    }
+    const buffer = await response.buffer();
+    console.log(`[krisspy-ai] Video downloaded: ${buffer.length} bytes`);
+    return buffer;
+  }
+};
+
+// src/services/video/openai-sora.ts
+var import_node_fetch5 = __toESM(require("node-fetch"));
+var import_form_data2 = __toESM(require("form-data"));
+var OpenAISoraService = class extends BaseVideoService {
+  constructor(config = {}) {
+    super(config);
+    this.baseUrl = config.baseUrl || "https://api.openai.com/v1";
+    this.apiKey = config.apiKey || "";
+    this.model = config.deploymentName || "sora-2";
+  }
+  getName() {
+    return "openai-sora";
+  }
+  mapStatus(openaiStatus) {
+    switch (openaiStatus) {
+      case "pending":
+      case "queued":
+        return "pending";
+      case "in_progress":
+        return "running";
+      case "completed":
+        return "succeeded";
+      case "failed":
+        return "failed";
+      case "canceled":
+        return "canceled";
+      default:
+        console.log(`[krisspy-ai] Unknown status: ${openaiStatus}`);
+        return "pending";
+    }
+  }
+  async submitJob(options) {
+    if (!this.apiKey) {
+      throw new Error("[krisspy-ai] OpenAI apiKey is required for video generation");
+    }
+    const endpoint = `${this.baseUrl}/videos/generations`;
+    const validSizes = ["720x1280", "1280x720", "1024x1792", "1792x1024"];
+    const requestedSize = options.width && options.height ? `${options.width}x${options.height}` : "1280x720";
+    const size = validSizes.includes(requestedSize) ? requestedSize : "1280x720";
+    const requestedDuration = options.duration || 5;
+    const validDurations = [5, 10, 15, 20];
+    const seconds = validDurations.includes(requestedDuration) ? requestedDuration : validDurations.reduce(
+      (prev, curr) => Math.abs(curr - requestedDuration) < Math.abs(prev - requestedDuration) ? curr : prev
+    );
+    console.log(`[krisspy-ai] Submitting video job to OpenAI Sora (model: ${this.model})...`);
+    let response;
+    if (options.referenceImage) {
+      const formData = new import_form_data2.default();
+      formData.append("model", this.model);
+      formData.append("prompt", options.prompt);
+      formData.append("size", size);
+      formData.append("duration", String(seconds));
+      if (options.nVariants && options.nVariants > 1) {
+        formData.append("n", String(options.nVariants));
+      }
+      const isUrl = options.referenceImage.startsWith("http://") || options.referenceImage.startsWith("https://");
+      if (isUrl) {
+        const imageResponse = await (0, import_node_fetch5.default)(options.referenceImage);
+        const imageBuffer = await imageResponse.buffer();
+        formData.append("image", imageBuffer, { filename: "reference.png", contentType: "image/png" });
+      } else {
+        const base64Data = options.referenceImage.startsWith("data:") ? options.referenceImage.split(",")[1] : options.referenceImage;
+        const imageBuffer = Buffer.from(base64Data, "base64");
+        formData.append("image", imageBuffer, { filename: "reference.png", contentType: "image/png" });
+      }
+      console.log(`[krisspy-ai] Using reference image for video generation (multipart form-data)`);
+      response = await (0, import_node_fetch5.default)(endpoint, {
+        method: "POST",
+        headers: {
+          "Authorization": `Bearer ${this.apiKey}`,
+          ...formData.getHeaders()
+        },
+        body: formData
+      });
+    } else {
+      const body = {
+        model: this.model,
+        prompt: options.prompt,
+        duration: seconds,
+        size
+      };
+      if (options.nVariants && options.nVariants > 1) {
+        body.n = options.nVariants;
+      }
+      response = await (0, import_node_fetch5.default)(endpoint, {
+        method: "POST",
+        headers: {
+          "Content-Type": "application/json",
+          "Authorization": `Bearer ${this.apiKey}`
+        },
+        body: JSON.stringify(body)
+      });
+    }
+    if (!response.ok) {
+      const errorText = await response.text();
+      let errorMessage = errorText;
+      try {
+        const parsed = JSON.parse(errorText);
+        errorMessage = parsed.error?.message || errorText;
+      } catch {
+      }
+      throw new Error(`[krisspy-ai] OpenAI Sora job submission failed: ${response.status} - ${errorMessage}`);
+    }
+    const data = await response.json();
+    return {
+      jobId: data.id,
+      status: this.mapStatus(data.status),
+      createdAt: new Date(data.created_at * 1e3).toISOString()
+    };
+  }
+  async getJobStatus(jobId) {
+    const endpoint = `${this.baseUrl}/videos/generations/${jobId}`;
+    const response = await (0, import_node_fetch5.default)(endpoint, {
+      method: "GET",
+      headers: {
+        "Authorization": `Bearer ${this.apiKey}`
+      }
+    });
+    if (!response.ok) {
+      const errorText = await response.text();
+      throw new Error(`[krisspy-ai] Failed to get job status: ${response.status} - ${errorText}`);
+    }
+    const data = await response.json();
+    if (data.status === "failed" && data.error) {
+      console.log(`[krisspy-ai] Job failed: ${data.error.code} - ${data.error.message}`);
+    }
+    return {
+      jobId: data.id,
+      status: this.mapStatus(data.status),
+      progress: data.progress,
+      error: data.error?.message,
+      createdAt: new Date(data.created_at * 1e3).toISOString(),
+      expiresAt: data.expires_at ? new Date(data.expires_at * 1e3).toISOString() : void 0
+    };
+  }
+  async getResult(jobId) {
+    const endpoint = `${this.baseUrl}/videos/generations/${jobId}`;
+    const response = await (0, import_node_fetch5.default)(endpoint, {
+      method: "GET",
+      headers: {
+        "Authorization": `Bearer ${this.apiKey}`
+      }
+    });
+    if (!response.ok) {
+      const errorText = await response.text();
+      throw new Error(`[krisspy-ai] Failed to get job result: ${response.status} - ${errorText}`);
+    }
+    const data = await response.json();
+    if (data.status !== "completed") {
+      throw new Error(`[krisspy-ai] Job ${jobId} not complete. Status: ${data.status}`);
+    }
+    const generations = [{ id: data.id }];
+    console.log(`[krisspy-ai] Video generation complete. ${generations.length} video(s) generated.`);
+    return {
+      jobId: data.id,
+      status: "succeeded",
+      generations,
+      createdAt: new Date(data.created_at * 1e3).toISOString()
+    };
+  }
+  async downloadVideo(generationId) {
+    const endpoint = `${this.baseUrl}/videos/generations/${generationId}/content`;
+    console.log(`[krisspy-ai] Downloading video ${generationId}...`);
+    const response = await (0, import_node_fetch5.default)(endpoint, {
+      method: "GET",
+      headers: {
+        "Authorization": `Bearer ${this.apiKey}`
+      }
+    });
+    if (!response.ok) {
+      const errorText = await response.text();
+      throw new Error(`[krisspy-ai] Failed to download video: ${response.status} - ${errorText}`);
+    }
+    const buffer = await response.buffer();
+    console.log(`[krisspy-ai] Video downloaded: ${buffer.length} bytes`);
+    return buffer;
+  }
+};
+
+// src/services/video/krisspy-sora.ts
+var import_node_fetch6 = __toESM(require("node-fetch"));
+var KrisspySoraService = class extends BaseVideoService {
+  constructor() {
+    super(...arguments);
+    this.cachedVideo = null;
+  }
+  getName() {
+    return "krisspy";
+  }
+  async submitJob(options) {
+    const { prompt, duration = 5 } = options;
+    const baseUrl = this.config.baseUrl || "https://api.krisspy.ai";
+    const apiKey = this.config.apiKey;
+    if (!apiKey) {
+      throw new Error("API key is required for Krisspy video service");
+    }
+    const response = await (0, import_node_fetch6.default)(`${baseUrl}/api/v1/ai/video`, {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json",
+        "Authorization": `Bearer ${apiKey}`
+      },
+      body: JSON.stringify({ prompt, duration })
+    });
+    if (!response.ok) {
+      const error = await response.json();
+      throw new Error(error.message || `Video generation failed: ${response.statusText}`);
+    }
+    const data = await response.json();
+    this.cachedVideo = data.video;
+    return {
+      jobId: data.jobId,
+      status: "succeeded",
+      createdAt: (/* @__PURE__ */ new Date()).toISOString()
+    };
+  }
+  async getJobStatus(jobId) {
+    const baseUrl = this.config.baseUrl || "https://api.krisspy.ai";
+    const apiKey = this.config.apiKey;
+    if (!apiKey) {
+      throw new Error("API key is required for Krisspy video service");
+    }
+    const response = await (0, import_node_fetch6.default)(`${baseUrl}/ai/video/status/${jobId}`, {
+      method: "GET",
+      headers: {
+        "Authorization": `Bearer ${apiKey}`
+      }
+    });
+    if (!response.ok) {
+      const error = await response.json();
+      throw new Error(error.message || `Failed to get video status: ${response.statusText}`);
+    }
+    const data = await response.json();
+    return data;
+  }
+  async getResult(jobId) {
+    const baseUrl = this.config.baseUrl || "https://api.krisspy.ai";
+    const apiKey = this.config.apiKey;
+    if (!apiKey) {
+      throw new Error("API key is required for Krisspy video service");
+    }
+    const response = await (0, import_node_fetch6.default)(`${baseUrl}/ai/video/result/${jobId}`, {
+      method: "GET",
+      headers: {
+        "Authorization": `Bearer ${apiKey}`
+      }
+    });
+    if (!response.ok) {
+      const error = await response.json();
+      throw new Error(error.message || `Failed to get video result: ${response.statusText}`);
+    }
+    const data = await response.json();
+    return data;
+  }
+  async downloadVideo(jobId) {
+    if (this.cachedVideo) {
+      const buffer = Buffer.from(this.cachedVideo, "base64");
+      this.cachedVideo = null;
+      return buffer;
+    }
+    throw new Error("No video available. Call submitJob first.");
+  }
+};
+
+// src/services/audio/azure-transcription.ts
+var import_node_fetch7 = __toESM(require("node-fetch"));
+var import_form_data3 = __toESM(require("form-data"));
+
+// src/services/audio/base.ts
+var BaseTranscriptionService = class extends BaseGenerativeService {
+  constructor(config = {}) {
+    super(config);
+  }
+  getServiceType() {
+    return "transcription";
+  }
+};
+var BaseTTSService = class extends BaseGenerativeService {
+  constructor(config = {}) {
+    super(config);
+  }
+  getServiceType() {
+    return "tts";
+  }
+};
+
+// src/services/audio/azure-transcription.ts
+var AzureTranscriptionService = class extends BaseTranscriptionService {
+  constructor(config = {}) {
+    super(config);
+    this.baseUrl = config.baseUrl || "";
+    this.apiKey = config.apiKey || "";
+    this.deploymentName = config.deploymentName || "whisper";
+    this.apiVersion = config.apiVersion || "2024-10-21";
+  }
+  getName() {
+    return "azure-transcription";
+  }
+  async transcribe(options) {
+    if (!this.baseUrl) {
+      throw new Error("[krisspy-ai] Azure baseUrl is required for transcription");
+    }
+    if (!this.apiKey) {
+      throw new Error("[krisspy-ai] Azure apiKey is required for transcription");
+    }
+    const endpoint = `${this.baseUrl}/openai/deployments/${this.deploymentName}/audio/transcriptions?api-version=${this.apiVersion}`;
+    const formData = new import_form_data3.default();
+    if (Buffer.isBuffer(options.audio)) {
+      formData.append("file", options.audio, { filename: "audio.mp3", contentType: "audio/mpeg" });
+    } else if (typeof options.audio === "string") {
+      const fs = await import("fs");
+      const buffer = fs.readFileSync(options.audio);
+      const filename = options.audio.split("/").pop() || "audio.mp3";
+      formData.append("file", buffer, { filename });
+    }
+    if (options.language) {
+      formData.append("language", options.language);
+    }
+    if (options.prompt) {
+      formData.append("prompt", options.prompt);
+    }
+    if (options.responseFormat) {
+      formData.append("response_format", options.responseFormat);
+    }
+    if (options.temperature !== void 0) {
+      formData.append("temperature", String(options.temperature));
+    }
+    if (options.timestampGranularities && options.timestampGranularities.length > 0) {
+      for (const granularity of options.timestampGranularities) {
+        formData.append("timestamp_granularities[]", granularity);
+      }
+    }
+    console.log(`[krisspy-ai] Transcribing audio with Azure (deployment: ${this.deploymentName})...`);
+    const response = await (0, import_node_fetch7.default)(endpoint, {
+      method: "POST",
+      headers: {
+        "api-key": this.apiKey,
+        ...formData.getHeaders()
+      },
+      body: formData
+    });
+    if (!response.ok) {
+      const errorText = await response.text();
+      let errorMessage = errorText;
+      try {
+        const parsed = JSON.parse(errorText);
+        errorMessage = parsed.error?.message || errorText;
+      } catch {
+      }
+      throw new Error(`[krisspy-ai] Azure transcription failed: ${response.status} - ${errorMessage}`);
+    }
+    if (options.responseFormat === "text") {
+      const text = await response.text();
+      return { text };
+    }
+    if (options.responseFormat === "srt" || options.responseFormat === "vtt") {
+      const text = await response.text();
+      return { text };
+    }
+    const data = await response.json();
+    console.log(`[krisspy-ai] Transcription complete. Duration: ${data.duration || "unknown"}s`);
+    return {
+      text: data.text,
+      language: data.language,
+      duration: data.duration,
+      words: data.words,
+      segments: data.segments
+    };
+  }
+};
+
+// src/services/audio/openai-transcription.ts
+var import_node_fetch8 = __toESM(require("node-fetch"));
+var import_form_data4 = __toESM(require("form-data"));
+var OpenAITranscriptionService = class extends BaseTranscriptionService {
+  constructor(config = {}) {
+    super(config);
+    this.baseUrl = config.baseUrl || "https://api.openai.com/v1";
+    this.apiKey = config.apiKey || "";
+    let modelName = config.deploymentName || "whisper-1";
+    if (modelName === "whisper") modelName = "whisper-1";
+    this.model = modelName;
+  }
+  getName() {
+    return "openai-transcription";
+  }
+  async transcribe(options) {
+    if (!this.apiKey) {
+      throw new Error("[krisspy-ai] OpenAI apiKey is required for transcription");
+    }
+    const endpoint = `${this.baseUrl}/audio/transcriptions`;
+    const formData = new import_form_data4.default();
+    formData.append("model", this.model);
+    if (Buffer.isBuffer(options.audio)) {
+      formData.append("file", options.audio, { filename: "audio.mp3", contentType: "audio/mpeg" });
+    } else if (typeof options.audio === "string") {
+      const fs = await import("fs");
+      const buffer = fs.readFileSync(options.audio);
+      const filename = options.audio.split("/").pop() || "audio.mp3";
+      formData.append("file", buffer, { filename });
+    }
+    if (options.language) {
+      formData.append("language", options.language);
+    }
+    if (options.prompt) {
+      formData.append("prompt", options.prompt);
+    }
+    if (options.responseFormat) {
+      formData.append("response_format", options.responseFormat);
+    }
+    if (options.temperature !== void 0) {
+      formData.append("temperature", String(options.temperature));
+    }
+    if (options.timestampGranularities && options.timestampGranularities.length > 0) {
+      for (const granularity of options.timestampGranularities) {
+        formData.append("timestamp_granularities[]", granularity);
+      }
+    }
+    console.log(`[krisspy-ai] Transcribing audio with OpenAI (model: ${this.model})...`);
+    const response = await (0, import_node_fetch8.default)(endpoint, {
+      method: "POST",
+      headers: {
+        "Authorization": `Bearer ${this.apiKey}`,
+        ...formData.getHeaders()
+      },
+      body: formData
+    });
+    if (!response.ok) {
+      const errorText = await response.text();
+      let errorMessage = errorText;
+      try {
+        const parsed = JSON.parse(errorText);
+        errorMessage = parsed.error?.message || errorText;
+      } catch {
+      }
+      throw new Error(`[krisspy-ai] OpenAI transcription failed: ${response.status} - ${errorMessage}`);
+    }
+    if (options.responseFormat === "text") {
+      const text = await response.text();
+      return { text };
+    }
+    if (options.responseFormat === "srt" || options.responseFormat === "vtt") {
+      const text = await response.text();
+      return { text };
+    }
+    const data = await response.json();
+    console.log(`[krisspy-ai] Transcription complete. Duration: ${data.duration || "unknown"}s`);
+    const result = {
+      text: data.text,
+      language: data.language,
+      duration: data.duration,
+      words: data.words,
+      segments: data.segments
+    };
+    if (data.utterances) {
+      result.utterances = data.utterances;
+      console.log(`[krisspy-ai] Diarization: ${data.utterances.length} utterances from ${new Set(data.utterances.map((u) => u.speaker)).size} speakers`);
+    }
+    return result;
+  }
+};
+
+// src/services/audio/krisspy-transcription.ts
+var import_node_fetch9 = __toESM(require("node-fetch"));
+var import_form_data5 = __toESM(require("form-data"));
+var KrisspyTranscriptionService = class extends BaseTranscriptionService {
+  getName() {
+    return "krisspy";
+  }
+  async transcribe(options) {
+    const { audio, language, responseFormat = "verbose_json", timestampGranularities } = options;
+    const baseUrl = this.config.baseUrl || "https://api.krisspy.ai";
+    const apiKey = this.config.apiKey;
+    if (!apiKey) {
+      throw new Error("API key is required for Krisspy transcription service");
+    }
+    const form = new import_form_data5.default();
+    form.append("audio", audio, { filename: "audio.mp3" });
+    if (language) form.append("language", language);
+    if (responseFormat) form.append("response_format", responseFormat);
+    if (timestampGranularities) {
+      form.append("timestamp_granularities", JSON.stringify(timestampGranularities));
+    }
+    const response = await (0, import_node_fetch9.default)(`${baseUrl}/api/v1/ai/transcribe`, {
+      method: "POST",
+      headers: {
+        "Authorization": `Bearer ${apiKey}`,
+        ...form.getHeaders()
+      },
+      body: form
+    });
+    if (!response.ok) {
+      const error = await response.json();
+      throw new Error(error.message || `Transcription failed: ${response.statusText}`);
+    }
+    const data = await response.json();
+    return data;
+  }
+};
+
+// src/services/audio/azure-tts.ts
+var import_node_fetch10 = __toESM(require("node-fetch"));
+var AzureTTSService = class extends BaseTTSService {
+  constructor(config = {}) {
+    super(config);
+    this.baseUrl = config.baseUrl || "";
+    this.apiKey = config.apiKey || "";
+    this.deploymentName = config.deploymentName || "tts";
+    this.apiVersion = config.apiVersion || "2025-03-01-preview";
+  }
+  getName() {
+    return "azure-tts";
+  }
+  async synthesize(options) {
+    if (!this.baseUrl) {
+      throw new Error("[krisspy-ai] Azure baseUrl is required for TTS");
+    }
+    if (!this.apiKey) {
+      throw new Error("[krisspy-ai] Azure apiKey is required for TTS");
+    }
+    const endpoint = `${this.baseUrl}/openai/deployments/${this.deploymentName}/audio/speech?api-version=${this.apiVersion}`;
+    const body = {
+      model: this.deploymentName,
+      input: options.input,
+      voice: options.voice || "alloy"
+    };
+    if (options.responseFormat) {
+      body.response_format = options.responseFormat;
+    }
+    if (options.speed !== void 0) {
+      body.speed = options.speed;
+    }
+    console.log(`[krisspy-ai] Synthesizing speech with Azure TTS (deployment: ${this.deploymentName})...`);
+    console.log(`[krisspy-ai] Azure TTS endpoint: ${endpoint}`);
+    const response = await (0, import_node_fetch10.default)(endpoint, {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json",
+        "api-key": this.apiKey
+      },
+      body: JSON.stringify(body)
+    });
+    if (!response.ok) {
+      const errorText = await response.text();
+      let errorMessage = errorText;
+      try {
+        const parsed = JSON.parse(errorText);
+        errorMessage = parsed.error?.message || errorText;
+      } catch {
+      }
+      throw new Error(`[krisspy-ai] Azure TTS failed: ${response.status} - ${errorMessage}`);
+    }
+    const buffer = await response.buffer();
+    const format = options.responseFormat || "mp3";
+    console.log(`[krisspy-ai] Speech synthesis complete: ${buffer.length} bytes (${format})`);
+    return {
+      audio: buffer,
+      format
+    };
+  }
+};
+
+// src/services/audio/openai-tts.ts
+var import_node_fetch11 = __toESM(require("node-fetch"));
+var OpenAITTSService = class extends BaseTTSService {
+  constructor(config = {}) {
+    super(config);
+    this.baseUrl = config.baseUrl || "https://api.openai.com/v1";
+    this.apiKey = config.apiKey || "";
+    let modelName = config.deploymentName || "tts-1";
+    if (modelName === "tts") modelName = "tts-1";
+    if (modelName === "tts-hd") modelName = "tts-1-hd";
+    this.model = modelName;
+  }
+  getName() {
+    return "openai-tts";
+  }
+  async synthesize(options) {
+    if (!this.apiKey) {
+      throw new Error("[krisspy-ai] OpenAI apiKey is required for TTS");
+    }
+    const endpoint = `${this.baseUrl}/audio/speech`;
+    const body = {
+      model: this.model,
+      input: options.input,
+      voice: options.voice || "alloy"
+    };
+    if (options.responseFormat) {
+      body.response_format = options.responseFormat;
+    }
+    if (options.speed !== void 0) {
+      body.speed = options.speed;
+    }
+    if (options.instructions && this.model.includes("gpt-4o")) {
+      body.instructions = options.instructions;
+    }
+    console.log(`[krisspy-ai] Synthesizing speech with OpenAI TTS (model: ${this.model})...`);
+    const response = await (0, import_node_fetch11.default)(endpoint, {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json",
+        "Authorization": `Bearer ${this.apiKey}`
+      },
+      body: JSON.stringify(body)
+    });
+    if (!response.ok) {
+      const errorText = await response.text();
+      let errorMessage = errorText;
+      try {
+        const parsed = JSON.parse(errorText);
+        errorMessage = parsed.error?.message || errorText;
+      } catch {
+      }
+      throw new Error(`[krisspy-ai] OpenAI TTS failed: ${response.status} - ${errorMessage}`);
+    }
+    const buffer = await response.buffer();
+    const format = options.responseFormat || "mp3";
+    console.log(`[krisspy-ai] Speech synthesis complete: ${buffer.length} bytes (${format})`);
+    return {
+      audio: buffer,
+      format
+    };
+  }
+};
+
+// src/services/audio/krisspy-tts.ts
+var import_node_fetch12 = __toESM(require("node-fetch"));
+var KrisspyTTSService = class extends BaseTTSService {
+  getName() {
+    return "krisspy";
+  }
+  async synthesize(options) {
+    const { input, voice = "nova", speed = 1, instructions, responseFormat = "mp3" } = options;
+    const baseUrl = this.config.baseUrl || "https://api.krisspy.ai";
+    const apiKey = this.config.apiKey;
+    if (!apiKey) {
+      throw new Error("API key is required for Krisspy TTS service");
+    }
+    const response = await (0, import_node_fetch12.default)(`${baseUrl}/api/v1/ai/tts`, {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json",
+        "Authorization": `Bearer ${apiKey}`
+      },
+      body: JSON.stringify({
+        text: input,
+        voice,
+        speed,
+        instructions,
+        response_format: responseFormat
+      })
+    });
+    if (!response.ok) {
+      const error = await response.json();
+      throw new Error(error.message || `TTS failed: ${response.statusText}`);
+    }
+    const data = await response.json();
+    const audioBuffer = Buffer.from(data.audio, "base64");
+    return {
+      audio: audioBuffer,
+      format: data.format || responseFormat
+    };
+  }
+};
+
+// src/services/index.ts
+var imageServices = {
+  // Krisspy AI (proxy to backend)
+  "krisspy": KrisspyImageService,
+  // Azure OpenAI
+  "azure-dalle": AzureDalleService,
+  "azure": AzureDalleService,
+  "azure-gpt-image": AzureDalleService,
+  // OpenAI direct
+  "openai": OpenAIImageService,
+  "openai-image": OpenAIImageService,
+  "gpt-image": OpenAIImageService
+};
+var videoServices = {
+  // Krisspy AI (proxy to backend)
+  "krisspy": KrisspySoraService,
+  // Azure OpenAI
+  "azure-sora": AzureSoraService,
+  "azure": AzureSoraService,
+  // OpenAI direct
+  "openai": OpenAISoraService,
+  "openai-sora": OpenAISoraService,
+  "sora": OpenAISoraService
+};
+var transcriptionServices = {
+  // Krisspy AI (proxy to backend)
+  "krisspy": KrisspyTranscriptionService,
+  // Azure OpenAI
+  "azure": AzureTranscriptionService,
+  "azure-whisper": AzureTranscriptionService,
+  "azure-transcription": AzureTranscriptionService,
+  // OpenAI direct
+  "openai": OpenAITranscriptionService,
+  "openai-whisper": OpenAITranscriptionService,
+  "whisper": OpenAITranscriptionService,
+  "gpt-4o-transcribe": OpenAITranscriptionService,
+  "gpt-4o-transcribe-diarize": OpenAITranscriptionService
+};
+var ttsServices = {
+  // Krisspy AI (proxy to backend)
+  "krisspy": KrisspyTTSService,
+  // Azure OpenAI
+  "azure": AzureTTSService,
+  "azure-tts": AzureTTSService,
+  // OpenAI direct
+  "openai": OpenAITTSService,
+  "openai-tts": OpenAITTSService,
+  "tts": OpenAITTSService,
+  "tts-hd": OpenAITTSService,
+  "gpt-4o-mini-tts": OpenAITTSService
+};
+function getImageService(name, config = {}) {
+  const ServiceClass = imageServices[name.toLowerCase()];
+  if (!ServiceClass) {
+    throw new Error(
+      `[krisspy-ai] Unknown image service: ${name}. Available: ${Object.keys(imageServices).join(", ")}`
+    );
+  }
+  return new ServiceClass(config);
+}
+function getVideoService(name, config = {}) {
+  const ServiceClass = videoServices[name.toLowerCase()];
+  if (!ServiceClass) {
+    throw new Error(
+      `[krisspy-ai] Unknown video service: ${name}. Available: ${Object.keys(videoServices).join(", ")}`
+    );
+  }
+  return new ServiceClass(config);
+}
+function getTranscriptionService(name, config = {}) {
+  const ServiceClass = transcriptionServices[name.toLowerCase()];
+  if (!ServiceClass) {
+    throw new Error(
+      `[krisspy-ai] Unknown transcription service: ${name}. Available: ${Object.keys(transcriptionServices).join(", ")}`
+    );
+  }
+  return new ServiceClass(config);
+}
+function getTTSService(name, config = {}) {
+  const ServiceClass = ttsServices[name.toLowerCase()];
+  if (!ServiceClass) {
+    throw new Error(
+      `[krisspy-ai] Unknown TTS service: ${name}. Available: ${Object.keys(ttsServices).join(", ")}`
+    );
+  }
+  return new ServiceClass(config);
+}
+function registerImageService(name, ServiceClass) {
+  imageServices[name.toLowerCase()] = ServiceClass;
+}
+function registerVideoService(name, ServiceClass) {
+  videoServices[name.toLowerCase()] = ServiceClass;
+}
+function registerTranscriptionService(name, ServiceClass) {
+  transcriptionServices[name.toLowerCase()] = ServiceClass;
+}
+function registerTTSService(name, ServiceClass) {
+  ttsServices[name.toLowerCase()] = ServiceClass;
+}
+function getAvailableImageServices() {
+  return Object.keys(imageServices);
+}
+function getAvailableVideoServices() {
+  return Object.keys(videoServices);
+}
+function getAvailableTranscriptionServices() {
+  return Object.keys(transcriptionServices);
+}
+function getAvailableTTSServices() {
+  return Object.keys(ttsServices);
+}
+
+// src/index.ts
+var PROVIDER_DEFAULTS = {
+  anthropic: {
+    baseUrl: "https://api.anthropic.com",
+    model: "sonnet"
+  },
+  openai: {
+    baseUrl: "https://api.openai.com/v1",
+    model: "gpt-5.2"
+  },
+  gemini: {
+    baseUrl: "https://generativelanguage.googleapis.com/v1beta/openai",
+    model: "gemini-2.5-flash"
+  },
+  zai: {
+    baseUrl: "https://api.z.ai/api/coding/paas/v4",
+    model: "glm-4.7"
+  },
+  zai_direct: {
+    baseUrl: "https://api.z.ai/v1",
+    // Anthropic-compatible endpoint
+    model: "sonnet"
+  },
+  bedrock: {
+    baseUrl: "",
+    // Constructed from region
+    model: "sonnet"
+    // Will be mapped to anthropic.claude-sonnet-4-20250514-v1:0
+  },
+  azure: {
+    baseUrl: "",
+    // Must be provided (e.g., https://your-resource.openai.azure.com)
+    model: "gpt-5.2"
+  },
+  claude_cli: {
+    baseUrl: "",
+    // Not needed - uses CLI subscription
+    model: "sonnet"
+  },
+  krisspy: {
+    baseUrl: "https://api.krisspy.ai",
+    // Krisspy AI proxy with credit billing
+    model: "sonnet"
+  }
+};
+var proxyServer = null;
+var proxyPort = 0;
+var currentProxyProvider = null;
+var currentProviderConfig = null;
+var lastProxyError = null;
+async function uploadFileToFilesAPI(fileData, apiKey, baseUrl = "https://api.anthropic.com") {
+  const form = new import_form_data6.default();
+  const buffer = Buffer.from(fileData.data, "base64");
+  let filename = "document";
+  if (fileData.media_type?.includes("pdf")) filename = "document.pdf";
+  else if (fileData.media_type?.includes("spreadsheet") || fileData.type === "xlsx") filename = "document.xlsx";
+  else if (fileData.media_type?.includes("wordprocessing") || fileData.type === "docx") filename = "document.docx";
+  else if (fileData.media_type?.includes("presentation") || fileData.type === "pptx") filename = "document.pptx";
+  else if (fileData.type === "csv") filename = "document.csv";
+  form.append("file", buffer, { filename, contentType: fileData.media_type || "application/octet-stream" });
+  const response = await (0, import_node_fetch13.default)(`${baseUrl}/v1/files`, {
+    method: "POST",
+    headers: {
+      "x-api-key": apiKey,
+      "anthropic-version": "2023-06-01",
+      "anthropic-beta": "files-api-2025-04-14",
+      ...form.getHeaders()
+    },
+    body: form
+  });
+  if (!response.ok) {
+    const errorText = await response.text();
+    throw new Error(`Files API upload failed: ${response.status} - ${errorText}`);
+  }
+  const result = await response.json();
+  return result.id;
+}
+async function startProxyServer(providerName, config) {
+  if (proxyServer && currentProxyProvider?.getName() === providerName) {
+    const sameConfig = currentProviderConfig?.apiKey === config.apiKey && currentProviderConfig?.baseUrl === config.baseUrl;
+    if (sameConfig) {
+      return proxyPort;
+    }
+  }
+  if (proxyServer) {
+    await stopProxyServer();
+  }
+  currentProxyProvider = getProvider(providerName, config);
+  currentProviderConfig = config;
+  return new Promise((resolve, reject) => {
+    proxyServer = (0, import_http.createServer)(async (req, res) => {
+      if (req.method !== "POST" || !req.url?.includes("/v1/messages")) {
+        res.writeHead(404);
+        res.end("Not found");
+        return;
+      }
+      let body = "";
+      req.on("data", (chunk) => {
+        body += chunk;
+      });
+      req.on("end", async () => {
+        try {
+          const anthropicRequest = JSON.parse(body);
+          const providerRequest = currentProxyProvider.buildRequest(anthropicRequest);
+          const requestBody = JSON.stringify(providerRequest);
+          const headers = currentProxyProvider.getName() === "bedrock" ? currentProxyProvider.getSignedHeaders(requestBody) : currentProxyProvider.getHeaders();
+          const endpoint = currentProxyProvider.getEndpoint();
+          console.log(`[krisspy-ai] Proxy forwarding to: ${endpoint}`);
+          console.log(`[krisspy-ai] Headers:`, JSON.stringify(headers, null, 2));
+          console.log(`[krisspy-ai] Body preview:`, requestBody.substring(0, 200));
+          const response = await (0, import_node_fetch13.default)(endpoint, {
+            method: "POST",
+            headers,
+            body: requestBody
+          });
+          console.log(`[krisspy-ai] Response status: ${response.status}`);
+          if (!response.ok) {
+            const errorText = await response.text();
+            let errorMessage = errorText;
+            try {
+              const parsed = JSON.parse(errorText);
+              errorMessage = parsed.error?.message || errorText;
+            } catch {
+            }
+            if (lastProxyError !== errorMessage) {
+              lastProxyError = errorMessage;
+              console.error(`[krisspy-ai] Proxy error: ${errorMessage}`);
+            }
+            const errorType = response.status === 401 ? "authentication_error" : response.status === 403 ? "permission_error" : response.status === 404 ? "not_found_error" : response.status === 429 ? "rate_limit_error" : "api_error";
+            res.writeHead(response.status, { "Content-Type": "application/json" });
+            res.end(JSON.stringify({
+              type: "error",
+              error: { type: errorType, message: errorMessage }
+            }));
+            return;
+          }
+          const messageId = `msg_${Date.now()}`;
+          const stream = anthropicRequest.stream !== false;
+          if (stream && response.body) {
+            await currentProxyProvider.handleStreamingResponse(
+              response,
+              res,
+              messageId,
+              anthropicRequest.model
+            );
+            res.end();
+          } else {
+            const data = await response.json();
+            const anthropicResponse = currentProxyProvider.convertResponse(data, messageId, anthropicRequest.model);
+            res.writeHead(200, { "Content-Type": "application/json" });
+            res.end(JSON.stringify(anthropicResponse));
+          }
+        } catch (error) {
+          const errorMessage = error.message;
+          lastProxyError = errorMessage;
+          console.error(`[krisspy-ai] Proxy error: ${errorMessage}`);
+          res.writeHead(500, { "Content-Type": "application/json" });
+          res.end(JSON.stringify({
+            type: "error",
+            error: { type: "api_error", message: errorMessage }
+          }));
+        }
+      });
+    });
+    proxyServer.listen(0, "127.0.0.1", () => {
+      const addr = proxyServer.address();
+      proxyPort = typeof addr === "object" && addr ? addr.port : 0;
+      console.log(`[krisspy-ai] Proxy started on port ${proxyPort} for ${providerName}`);
+      resolve(proxyPort);
+    });
+    proxyServer.on("error", reject);
+  });
+}
+async function stopProxyServer() {
+  if (proxyServer) {
+    return new Promise((resolve) => {
+      proxyServer.close(() => {
+        proxyServer = null;
+        currentProxyProvider = null;
+        currentProviderConfig = null;
+        proxyPort = 0;
+        resolve();
+      });
+    });
+  }
+}
+async function* query(params) {
+  const { prompt, options = {} } = params;
+  const {
+    attachments,
+    provider: explicitProvider,
+    apiKey,
+    baseUrl,
+    model: explicitModel,
+    maxThinkingTokens,
+    ...claudeOptions
+  } = options;
+  const provider = (explicitProvider || "claude_cli").toLowerCase();
+  const images = attachments?.images || [];
+  const files = attachments?.files || [];
+  const defaults = PROVIDER_DEFAULTS[provider] || PROVIDER_DEFAULTS.claude_cli;
+  const finalBaseUrl = baseUrl || defaults.baseUrl;
+  const finalModel = explicitModel || defaults.model;
+  const needsProxy = ["openai", "zai", "gemini", "azure"].includes(provider);
+  const providerConfig = {
+    apiKey,
+    baseUrl: finalBaseUrl,
+    defaultModel: finalModel,
+    // AWS Bedrock specific
+    accessKeyId: options.accessKeyId,
+    secretAccessKey: options.secretAccessKey,
+    region: options.region || "us-west-2",
+    // Azure specific
+    deploymentName: options.deploymentName,
+    apiVersion: options.apiVersion
+  };
+  if (provider === "bedrock") {
+    if (!providerConfig.accessKeyId || !providerConfig.secretAccessKey) {
+      throw new Error(`[krisspy-ai] AWS credentials required for Bedrock. Pass accessKeyId and secretAccessKey via options.`);
+    }
+  }
+  let port = 0;
+  if (needsProxy) {
+    if (provider === "azure") {
+      if (!apiKey) {
+        throw new Error(`[krisspy-ai] API key required for Azure. Pass it via options.apiKey`);
+      }
+      if (!finalBaseUrl) {
+        throw new Error(`[krisspy-ai] Base URL required for Azure. Pass it via options.baseUrl (e.g., https://your-resource.openai.azure.com)`);
+      }
+    } else if (!apiKey) {
+      throw new Error(`[krisspy-ai] API key required for provider '${provider}'. Pass it via options.apiKey`);
+    }
+    port = await startProxyServer(provider, providerConfig);
+  }
+  const systemEnvKeys = ["PATH", "HOME", "USER", "SHELL", "TERM", "LANG", "LC_ALL", "TMPDIR", "TMP", "TEMP"];
+  const cleanSystemEnv = {};
+  for (const key of systemEnvKeys) {
+    if (process.env[key]) {
+      cleanSystemEnv[key] = process.env[key];
+    }
+  }
+  const providerEnv = {};
+  if (provider === "anthropic") {
+    if (apiKey) providerEnv.ANTHROPIC_API_KEY = apiKey;
+    providerEnv.ANTHROPIC_BASE_URL = finalBaseUrl;
+  } else if (provider === "zai_direct") {
+    if (apiKey) providerEnv.ANTHROPIC_API_KEY = apiKey;
+    providerEnv.ANTHROPIC_BASE_URL = finalBaseUrl;
+  } else if (provider === "krisspy") {
+    if (!apiKey) {
+      throw new Error(`[krisspy-ai] Krisspy API key required. Pass it via options.apiKey`);
+    }
+    providerEnv.ANTHROPIC_API_KEY = apiKey;
+    const baseUrlWithoutTrailingSlash = finalBaseUrl.replace(/\/$/, "");
+    providerEnv.ANTHROPIC_BASE_URL = `${baseUrlWithoutTrailingSlash}/api/v1/ai`;
+    console.log(`[krisspy-ai] Using Krisspy provider with base URL ${providerEnv.ANTHROPIC_BASE_URL}`);
+  } else if (provider === "bedrock") {
+    providerEnv.AWS_ACCESS_KEY_ID = providerConfig.accessKeyId;
+    providerEnv.AWS_SECRET_ACCESS_KEY = providerConfig.secretAccessKey;
+    providerEnv.AWS_DEFAULT_REGION = providerConfig.region || "us-west-2";
+    const bedrockModelMap = {
+      // Haiku aliases -> Haiku 4.5 (global endpoint)
+      "haiku": "global.anthropic.claude-haiku-4-5-20251001-v1:0",
+      "haiku-4.5": "global.anthropic.claude-haiku-4-5-20251001-v1:0",
+      // Sonnet aliases -> Sonnet 4 (global endpoint)
+      "sonnet": "global.anthropic.claude-sonnet-4-20250514-v1:0",
+      "sonnet-4": "global.anthropic.claude-sonnet-4-20250514-v1:0",
+      "sonnet-4.5": "us.anthropic.claude-sonnet-4-5-20250929-v1:0",
+      // Opus aliases -> Opus 4 / 4.5 (global endpoint)
+      "opus": "global.anthropic.claude-opus-4-5-20251101-v1:0",
+      "opus-4": "global.anthropic.claude-opus-4-20250514-v1:0",
+      "opus-4.5": "global.anthropic.claude-opus-4-5-20251101-v1:0"
+      // Also support full model IDs passed directly
+    };
+    const mappedModel = bedrockModelMap[finalModel] || finalModel;
+    providerEnv.ANTHROPIC_MODEL = mappedModel;
+    console.log(`[krisspy-ai] Bedrock native mode: model=${mappedModel}, region=${providerConfig.region}`);
+  } else if (needsProxy) {
+    providerEnv.ANTHROPIC_API_KEY = apiKey || "proxy-key";
+    providerEnv.ANTHROPIC_BASE_URL = `http://127.0.0.1:${port}`;
+  }
+  const hasOfficeFiles = files.some((f) => ["xlsx", "docx", "pptx"].includes(f.type));
+  const useSkills = hasOfficeFiles && !needsProxy;
+  const queryOptions = {
+    allowedTools: ["Read", "Edit", "Bash", "Glob", "Grep", "WebFetch", "WebSearch"],
+    permissionMode: "acceptEdits",
+    includePartialMessages: true,
+    systemPrompt: { type: "preset", preset: "claude_code" },
+    model: finalModel,
+    // Use resolved model with default
+    ...claudeOptions,
+    env: {
+      ...cleanSystemEnv,
+      // Only system vars (PATH, HOME, etc.)
+      ...providerEnv,
+      // Our explicit provider config
+      ...claudeOptions.env || {}
+    }
+  };
+  if (useSkills) {
+    console.log("[krisspy-ai] Enabling Skills betas for Office files...");
+    const existingBetas = queryOptions.betas || [];
+    const skillsBetas = ["code-execution-2025-08-25", "skills-2025-10-02"];
+    queryOptions.betas = [.../* @__PURE__ */ new Set([...existingBetas, ...skillsBetas])];
+  }
+  if (maxThinkingTokens !== void 0 && maxThinkingTokens > 0) {
+    queryOptions.maxThinkingTokens = maxThinkingTokens;
+  }
+  let finalPrompt;
+  if (typeof prompt === "string" && (images.length > 0 || files.length > 0)) {
+    const content = [];
+    for (const img of images) {
+      if (img.type === "url") {
+        content.push({ type: "image", source: { type: "url", url: img.url } });
+      } else if (img.type === "base64") {
+        content.push({
+          type: "image",
+          source: { type: "base64", media_type: img.media_type || "image/jpeg", data: img.data }
+        });
+      }
+    }
+    const officeFiles = [];
+    for (const file of files) {
+      if (file.type === "pdf") {
+        content.push({
+          type: "document",
+          source: { type: "base64", media_type: "application/pdf", data: file.data }
+        });
+      } else if (["xlsx", "docx", "pptx", "csv"].includes(file.type)) {
+        officeFiles.push(file);
+      } else {
+        content.push({
+          type: "text",
+          text: `[Note: A ${file.type?.toUpperCase() || "unknown"} file was attached but this format is not supported.]`
+        });
+      }
+    }
+    if (officeFiles.length > 0 && !needsProxy) {
+      const filesApiKey = apiKey || "";
+      const filesBaseUrl = baseUrl || "https://api.anthropic.com";
+      if (filesApiKey && !filesBaseUrl.includes("127.0.0.1") && !filesBaseUrl.includes("localhost")) {
+        for (const file of officeFiles) {
+          try {
+            console.log(`[krisspy-ai] Uploading ${file.type.toUpperCase()} via Files API...`);
+            const fileId = await uploadFileToFilesAPI(file, filesApiKey, filesBaseUrl);
+            console.log(`[krisspy-ai] File uploaded: ${fileId}`);
+            content.push({ type: "document", source: { type: "file", file_id: fileId } });
+          } catch (err) {
+            console.error(`[krisspy-ai] Failed to upload ${file.type}:`, err.message);
+            content.push({
+              type: "text",
+              text: `[Note: Failed to upload ${file.type.toUpperCase()} file: ${err.message}]`
+            });
+          }
+        }
+      }
+    } else if (officeFiles.length > 0) {
+      for (const file of officeFiles) {
+        content.push({
+          type: "document",
+          source: { type: "base64", media_type: file.media_type, data: file.data }
+        });
+      }
+    }
+    content.push({ type: "text", text: prompt });
+    finalPrompt = (async function* () {
+      yield { type: "user", message: { role: "user", content } };
+    })();
+  } else {
+    finalPrompt = prompt;
+  }
+  console.log(`[krisspy-ai] Using provider: ${provider}${needsProxy ? ` (proxy on port ${port})` : ""}`);
+  lastProxyError = null;
+  try {
+    for await (const event of (0, import_claude_agent_sdk.query)({ prompt: finalPrompt, options: queryOptions })) {
+      if (lastProxyError) {
+        yield {
+          type: "result",
+          subtype: "error",
+          is_error: true,
+          errors: [lastProxyError]
+        };
+        lastProxyError = null;
+        return;
+      }
+      yield event;
+    }
+  } catch (error) {
+    const errorMessage = lastProxyError || error.message;
+    lastProxyError = null;
+    yield {
+      type: "result",
+      subtype: "error",
+      is_error: true,
+      errors: [errorMessage]
+    };
+  }
+}
+async function cleanup() {
+  await stopProxyServer();
+}
+async function generateImage(options) {
+  const service = getImageService(options.service || "azure", {
+    apiKey: options.apiKey,
+    baseUrl: options.baseUrl,
+    deploymentName: options.deploymentName,
+    apiVersion: options.apiVersion
+  });
+  return service.generate({
+    prompt: options.prompt,
+    n: options.n,
+    size: options.size,
+    quality: options.quality,
+    style: options.style,
+    responseFormat: options.responseFormat,
+    user: options.user
+  });
+}
+async function* generateVideo(options) {
+  const service = getVideoService(options.service || "azure", {
+    apiKey: options.apiKey,
+    baseUrl: options.baseUrl,
+    deploymentName: options.deploymentName,
+    apiVersion: options.apiVersion
+  });
+  const generator = service.generateAndWait(
+    {
+      prompt: options.prompt,
+      duration: options.duration,
+      width: options.width,
+      height: options.height,
+      nVariants: options.nVariants,
+      user: options.user,
+      referenceImage: options.referenceImage,
+      referenceImageFormat: options.referenceImageFormat
+    },
+    options.pollInterval,
+    options.timeout
+  );
+  let result;
+  while (!(result = await generator.next()).done) {
+    yield { type: "status", status: result.value };
+  }
+  yield { type: "result", data: result.value };
+}
+async function transcribe(options) {
+  const service = getTranscriptionService(options.service || "openai", {
+    apiKey: options.apiKey,
+    baseUrl: options.baseUrl,
+    deploymentName: options.deploymentName,
+    apiVersion: options.apiVersion
+  });
+  return service.transcribe({
+    audio: options.audio,
+    language: options.language,
+    prompt: options.prompt,
+    responseFormat: options.responseFormat,
+    temperature: options.temperature,
+    timestampGranularities: options.timestampGranularities
+  });
+}
+async function synthesize(options) {
+  const service = getTTSService(options.service || "openai", {
+    apiKey: options.apiKey,
+    baseUrl: options.baseUrl,
+    deploymentName: options.deploymentName,
+    apiVersion: options.apiVersion
+  });
+  return service.synthesize({
+    input: options.input,
+    voice: options.voice,
+    responseFormat: options.responseFormat,
+    speed: options.speed,
+    instructions: options.instructions
+  });
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  AzureDalleService,
+  AzureProvider,
+  AzureSoraService,
+  AzureTTSService,
+  AzureTranscriptionService,
+  BaseGenerativeService,
+  BaseImageService,
+  BaseProvider,
+  BaseTTSService,
+  BaseTranscriptionService,
+  BaseVideoService,
+  BedrockProvider,
+  GeminiProvider,
+  KrisspyProvider,
+  OpenAIImageService,
+  OpenAIProvider,
+  OpenAISoraService,
+  OpenAITTSService,
+  OpenAITranscriptionService,
+  ZAIProvider,
+  cleanup,
+  generateImage,
+  generateVideo,
+  getAvailableImageServices,
+  getAvailableProviders,
+  getAvailableTTSServices,
+  getAvailableTranscriptionServices,
+  getAvailableVideoServices,
+  getImageService,
+  getProvider,
+  getTTSService,
+  getTranscriptionService,
+  getVideoService,
+  query,
+  registerImageService,
+  registerProvider,
+  registerTTSService,
+  registerTranscriptionService,
+  registerVideoService,
+  synthesize,
+  transcribe,
+  ...require("@anthropic-ai/claude-agent-sdk")
+});
+//# sourceMappingURL=index.js.map