@ai-sdk-tool/proxy 0.0.0

package/dist/index.cjs

@@ -0,0 +1,927 @@
+"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 __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 src_exports = {};
+__export(src_exports, {
+  OpenAIProxyServer: () => OpenAIProxyServer,
+  convertAISDKResultToOpenAI: () => convertAISDKResultToOpenAI,
+  convertAISDKStreamChunkToOpenAI: () => convertAISDKStreamChunkToOpenAI,
+  convertAISDKToolCallsToOpenAI: () => convertAISDKToolCallsToOpenAI,
+  convertOpenAIRequestToAISDK: () => convertOpenAIRequestToAISDK,
+  createOpenAIStreamConverter: () => createOpenAIStreamConverter,
+  createSSEResponse: () => createSSEResponse,
+  generateResponseId: () => generateResponseId,
+  getCurrentTimestamp: () => getCurrentTimestamp
+});
+module.exports = __toCommonJS(src_exports);
+
+// src/openai-request-converter.ts
+var import_zod = require("zod");
+function createZodSchema(prop) {
+  if (prop.type === "string") {
+    return prop.enum ? import_zod.z.enum(prop.enum) : import_zod.z.string();
+  }
+  if (prop.type === "number") {
+    return import_zod.z.number();
+  }
+  if (prop.type === "boolean") {
+    return import_zod.z.boolean();
+  }
+  if (prop.type === "array") {
+    return import_zod.z.array(import_zod.z.any());
+  }
+  if (prop.type === "object") {
+    return import_zod.z.object({});
+  }
+  return import_zod.z.any();
+}
+function convertOpenAIToolToZod(parameters) {
+  if (!parameters) {
+    return import_zod.z.object({});
+  }
+  const params = parameters;
+  if (!params.properties) {
+    return import_zod.z.object({});
+  }
+  const schemaShape = {};
+  for (const [key, prop] of Object.entries(params.properties)) {
+    schemaShape[key] = createZodSchema(prop);
+  }
+  return import_zod.z.object(schemaShape);
+}
+function convertOpenAITools(openaiTools) {
+  const aisdkTools = {};
+  if (!openaiTools) {
+    return aisdkTools;
+  }
+  for (const openaiTool of openaiTools) {
+    const toolName = openaiTool.function.name;
+    aisdkTools[toolName] = {
+      description: openaiTool.function.description || "",
+      inputSchema: convertOpenAIToolToZod(openaiTool.function.parameters)
+    };
+  }
+  return aisdkTools;
+}
+function convertStopToSequences(stop) {
+  if (!stop) {
+    return;
+  }
+  return Array.isArray(stop) ? stop : [stop];
+}
+function normalizeMessageContent(content) {
+  if (typeof content === "string") {
+    return content ? [{ type: "text", text: content }] : [];
+  }
+  if (Array.isArray(content)) {
+    const parts = content;
+    return parts.map((part) => {
+      if (typeof part === "string") {
+        return part;
+      }
+      if (part && typeof part === "object" && "text" in part) {
+        const textValue = part.text;
+        if (typeof textValue === "string") {
+          return textValue;
+        }
+        if (textValue !== void 0) {
+          return JSON.stringify(textValue);
+        }
+      }
+      return JSON.stringify(part);
+    }).filter((text) => Boolean(text)).map((text) => ({ type: "text", text }));
+  }
+  if (content === null || content === void 0) {
+    return [];
+  }
+  if (typeof content === "object") {
+    return [{ type: "text", text: JSON.stringify(content) }];
+  }
+  return [{ type: "text", text: String(content) }];
+}
+function buildToolCallParts(toolCalls) {
+  return toolCalls.map((toolCall) => {
+    let parsedArgs = toolCall.function.arguments;
+    if (typeof toolCall.function.arguments === "string") {
+      try {
+        parsedArgs = JSON.parse(toolCall.function.arguments || "{}");
+      } catch (e) {
+        parsedArgs = toolCall.function.arguments;
+      }
+    }
+    return {
+      type: "tool-call",
+      toolCallId: toolCall.id,
+      toolName: toolCall.function.name,
+      input: parsedArgs
+    };
+  });
+}
+function buildAssistantContent(message) {
+  var _a;
+  const textParts = normalizeMessageContent(message.content);
+  const toolCallParts = ((_a = message.tool_calls) == null ? void 0 : _a.length) ? buildToolCallParts(message.tool_calls) : [];
+  if (toolCallParts.length === 0) {
+    if (textParts.length === 0) {
+      return "";
+    }
+    if (textParts.length === 1) {
+      return textParts[0].text;
+    }
+    return textParts;
+  }
+  return [...textParts, ...toolCallParts];
+}
+function isJsonValue(value) {
+  if (value === null || typeof value === "string" || typeof value === "number" || typeof value === "boolean") {
+    return true;
+  }
+  if (Array.isArray(value)) {
+    return value.every(isJsonValue);
+  }
+  if (typeof value === "object") {
+    return Object.values(value).every(isJsonValue);
+  }
+  return false;
+}
+function buildToolOutput(rawValue) {
+  if (!rawValue) {
+    return { type: "text", value: "" };
+  }
+  try {
+    const parsed = JSON.parse(rawValue);
+    if (isJsonValue(parsed)) {
+      return { type: "json", value: parsed };
+    }
+  } catch (e) {
+  }
+  return { type: "text", value: rawValue };
+}
+function buildToolContent(message, toolNameLookup) {
+  var _a, _b;
+  const textParts = normalizeMessageContent(message.content);
+  const combined = textParts.map((part) => part.text).join("\n");
+  const toolCallId = (_a = message.tool_call_id) != null ? _a : "";
+  const toolName = toolCallId ? (_b = toolNameLookup.get(toolCallId)) != null ? _b : toolCallId : "";
+  return [
+    {
+      type: "tool-result",
+      toolCallId,
+      toolName,
+      output: buildToolOutput(combined)
+    }
+  ];
+}
+function convertMessageToModelMessage(message, toolNameLookup) {
+  var _a;
+  if (message.role === "assistant") {
+    if ((_a = message.tool_calls) == null ? void 0 : _a.length) {
+      for (const toolCall of message.tool_calls) {
+        toolNameLookup.set(toolCall.id, toolCall.function.name);
+      }
+    }
+    return {
+      role: "assistant",
+      content: buildAssistantContent(
+        message
+      )
+    };
+  }
+  if (message.role === "tool") {
+    return {
+      role: "tool",
+      content: buildToolContent(
+        message,
+        toolNameLookup
+      )
+    };
+  }
+  if (message.role === "system") {
+    const text = normalizeMessageContent(message.content).map((part) => part.text).join("\n");
+    return {
+      role: "system",
+      content: text
+    };
+  }
+  const userParts = normalizeMessageContent(message.content);
+  if (userParts.length === 0) {
+    return {
+      role: "user",
+      content: ""
+    };
+  }
+  if (userParts.length === 1) {
+    return {
+      role: "user",
+      content: userParts[0].text
+    };
+  }
+  return {
+    role: "user",
+    content: userParts
+  };
+}
+function convertOpenAIRequestToAISDK(openaiRequest, proxyConfig) {
+  const {
+    messages,
+    tools: openaiTools,
+    temperature,
+    max_tokens,
+    stop,
+    tool_choice
+  } = openaiRequest;
+  const toolNameLookup = /* @__PURE__ */ new Map();
+  const aiMessages = messages.map(
+    (message) => convertMessageToModelMessage(message, toolNameLookup)
+  );
+  const aisdkTools = convertOpenAITools(openaiTools);
+  const providerOptions = (proxyConfig == null ? void 0 : proxyConfig.parserDebug) ? {
+    toolCallMiddleware: {
+      debugLevel: proxyConfig.parserDebug.level,
+      logErrors: proxyConfig.parserDebug.logErrors,
+      captureSummary: proxyConfig.parserDebug.captureSummary
+    }
+  } : void 0;
+  return {
+    messages: aiMessages,
+    tools: aisdkTools,
+    temperature,
+    maxOutputTokens: max_tokens,
+    stopSequences: convertStopToSequences(stop),
+    toolChoice: mapOpenAIToolChoice(tool_choice),
+    ...providerOptions ? { providerOptions } : {}
+  };
+}
+function mapOpenAIToolChoice(choice) {
+  if (!choice) {
+    return;
+  }
+  if (choice === "auto" || choice === "none") {
+    return choice;
+  }
+  if (typeof choice === "object" && choice.type === "function") {
+    return { type: "tool", toolName: choice.function.name };
+  }
+  return;
+}
+function convertAISDKToolCallsToOpenAI(toolCalls) {
+  return toolCalls.map((call) => ({
+    id: `call_${Date.now()}_${Math.random().toString(36).substr(2, 9)}`,
+    type: "function",
+    function: {
+      name: call.toolName,
+      arguments: JSON.stringify(call.args)
+    }
+  }));
+}
+
+// src/response-utils.ts
+function generateResponseId() {
+  return `chatcmpl-${Date.now()}-${Math.random().toString(36).substr(2, 9)}`;
+}
+function getCurrentTimestamp() {
+  return Math.floor(Date.now() / 1e3);
+}
+
+// src/response-converter.ts
+function convertAISDKResultToOpenAI(aisdkResult, model, stream = false) {
+  var _a;
+  const choices = [];
+  if (aisdkResult.text) {
+    const choice = {
+      index: 0,
+      finish_reason: aisdkResult.finishReason || "stop"
+    };
+    if (stream) {
+      choice.delta = {
+        role: "assistant",
+        content: aisdkResult.text
+      };
+    } else {
+      choice.message = {
+        role: "assistant",
+        content: aisdkResult.text
+      };
+    }
+    choices.push(choice);
+  }
+  if (aisdkResult.toolCalls && aisdkResult.toolCalls.length > 0) {
+    const choice = {
+      index: 0,
+      finish_reason: "tool_calls"
+    };
+    const openAIToolCalls = (_a = aisdkResult.toolCalls) == null ? void 0 : _a.map(
+      (call) => ({
+        id: `call_${Date.now()}_${Math.random().toString(36).substr(2, 9)}`,
+        type: "function",
+        function: {
+          name: call.toolName,
+          arguments: JSON.stringify(call.args)
+        }
+      })
+    );
+    if (stream) {
+      choice.delta = {
+        role: "assistant",
+        tool_calls: openAIToolCalls
+      };
+    } else {
+      choice.message = {
+        role: "assistant",
+        content: null,
+        tool_calls: openAIToolCalls
+      };
+    }
+    choices.push(choice);
+  }
+  const response = {
+    id: generateResponseId(),
+    object: stream ? "chat.completion.chunk" : "chat.completion",
+    created: getCurrentTimestamp(),
+    model,
+    choices
+  };
+  if (aisdkResult.usage) {
+    response.usage = {
+      prompt_tokens: aisdkResult.usage.promptTokens || 0,
+      completion_tokens: aisdkResult.usage.completionTokens || 0,
+      total_tokens: aisdkResult.usage.totalTokens || 0
+    };
+  }
+  return response;
+}
+function createFinishResponse(model, finishReason, responseId) {
+  let validFinishReason;
+  if (finishReason === "tool_calls" || finishReason === "tool-calls") {
+    validFinishReason = "tool_calls";
+  } else if (finishReason === "stop") {
+    validFinishReason = "stop";
+  } else if (finishReason === "length") {
+    validFinishReason = "length";
+  } else if (finishReason === "content_filter") {
+    validFinishReason = "content_filter";
+  } else {
+    validFinishReason = "stop";
+  }
+  return {
+    id: responseId,
+    object: "chat.completion.chunk",
+    created: getCurrentTimestamp(),
+    model,
+    choices: [
+      {
+        index: 0,
+        delta: {},
+        finish_reason: validFinishReason
+      }
+    ]
+  };
+}
+function createContentResponse(model, content, responseId, isReasoning = false) {
+  const delta = { role: "assistant" };
+  if (isReasoning) {
+    delta.reasoning_content = content;
+  } else {
+    delta.content = content;
+  }
+  return {
+    id: responseId,
+    object: "chat.completion.chunk",
+    created: getCurrentTimestamp(),
+    model,
+    choices: [
+      {
+        index: 0,
+        delta
+      }
+    ]
+  };
+}
+function createToolCallResponse(model, toolCall, responseId, includeRole = false) {
+  var _a, _b;
+  return {
+    id: responseId,
+    object: "chat.completion.chunk",
+    created: getCurrentTimestamp(),
+    model,
+    choices: [
+      {
+        index: 0,
+        delta: {
+          ...includeRole ? { role: "assistant" } : {},
+          tool_calls: [
+            {
+              index: toolCall.index || 0,
+              type: "function",
+              function: {
+                name: ((_a = toolCall.function) == null ? void 0 : _a.name) || "",
+                arguments: ((_b = toolCall.function) == null ? void 0 : _b.arguments) || ""
+              }
+            }
+          ]
+        }
+      }
+    ]
+  };
+}
+function createOpenAIStreamConverter(model, options) {
+  let streamHasToolCalls = false;
+  let streamFinishSent = false;
+  let streamResponseId = generateResponseId();
+  const logChunk = (options == null ? void 0 : options.logChunks) === false ? void 0 : (chunk) => {
+    const logType = process.env.USE_MIDDLEWARE === "true" ? "middleware" : "native";
+    console.log(
+      `\u{1F50D} AI SDK Chunk [${logType}]:`,
+      JSON.stringify(chunk, null, 2)
+    );
+  };
+  const handlers = {
+    start: () => [],
+    "reasoning-delta": (chunk) => {
+      if (!chunk.text) {
+        return [];
+      }
+      return [
+        {
+          data: JSON.stringify(
+            createContentResponse(model, chunk.text, streamResponseId, true)
+          )
+        }
+      ];
+    },
+    "text-delta": (chunk) => {
+      if (!chunk.text) {
+        return [];
+      }
+      return [
+        {
+          data: JSON.stringify(
+            createContentResponse(model, chunk.text, streamResponseId, false)
+          )
+        }
+      ];
+    },
+    "tool-call": (chunk) => {
+      var _a;
+      const toolCallId = chunk.toolCallId || `call_${generateResponseId()}`;
+      const toolName = chunk.toolName || "";
+      const argsString = typeof chunk.input === "string" ? chunk.input : JSON.stringify((_a = chunk.input) != null ? _a : {});
+      const toolCallDelta = {
+        index: 0,
+        id: toolCallId,
+        type: "function",
+        function: { name: toolName, arguments: argsString }
+      };
+      const response = createToolCallResponse(
+        model,
+        toolCallDelta,
+        streamResponseId,
+        true
+      );
+      return [{ data: JSON.stringify(response) }];
+    },
+    "reasoning-end": () => [],
+    "text-end": () => [],
+    "finish-step": (chunk) => {
+      if (streamFinishSent) {
+        return [];
+      }
+      const hadToolCalls = streamHasToolCalls;
+      let finishReason = chunk.finishReason || "stop";
+      if (finishReason === "tool_calls" || finishReason === "tool-calls") {
+        finishReason = "tool_calls";
+      }
+      const resolvedReason = hadToolCalls ? "tool_calls" : finishReason;
+      streamFinishSent = true;
+      streamHasToolCalls = false;
+      return [
+        {
+          data: JSON.stringify(
+            createFinishResponse(model, resolvedReason, streamResponseId)
+          )
+        }
+      ];
+    },
+    "tool-call-delta": (chunk) => {
+      const toolCall = {
+        index: chunk.toolCallId ? Number(chunk.toolCallId) : 0,
+        type: "function",
+        function: {
+          name: chunk.toolName || "",
+          arguments: chunk.args || ""
+        }
+      };
+      return [
+        {
+          data: JSON.stringify(
+            createToolCallResponse(model, toolCall, streamResponseId)
+          )
+        }
+      ];
+    },
+    "tool-result": (chunk) => {
+      const resultText = `
+[Tool: ${chunk.toolName} returned ${JSON.stringify(chunk.output)}]
+`;
+      return [
+        {
+          data: JSON.stringify(
+            createContentResponse(model, resultText, streamResponseId, false)
+          )
+        }
+      ];
+    },
+    finish: (chunk) => {
+      if (streamFinishSent) {
+        return [];
+      }
+      const hadToolCalls = streamHasToolCalls;
+      let finishReason = chunk.finishReason || "stop";
+      if (finishReason === "tool_calls" || finishReason === "tool-calls") {
+        finishReason = "tool_calls";
+      }
+      const resolvedReason = hadToolCalls ? "tool_calls" : finishReason;
+      streamFinishSent = true;
+      streamHasToolCalls = false;
+      return [
+        {
+          data: JSON.stringify(
+            createFinishResponse(model, resolvedReason, streamResponseId)
+          )
+        }
+      ];
+    }
+  };
+  return (chunk) => {
+    var _a;
+    const out = [];
+    logChunk == null ? void 0 : logChunk(chunk);
+    if (chunk.type === "start") {
+      streamHasToolCalls = false;
+      streamFinishSent = false;
+      streamResponseId = (_a = chunk.id) != null ? _a : generateResponseId();
+    }
+    const handler = handlers[chunk.type];
+    if (handler) {
+      const result = handler(chunk, model);
+      if (chunk.type === "tool-call" || chunk.type === "tool-call-delta") {
+        streamHasToolCalls = true;
+      }
+      out.push(...result);
+    } else {
+      console.warn(`\u26A0\uFE0F Unknown AI SDK chunk type: ${chunk.type}`, chunk);
+    }
+    if (chunk.type === "finish-step" || chunk.type === "finish") {
+      streamHasToolCalls = false;
+    }
+    return out.filter((resultChunk) => {
+      var _a2, _b, _c, _d;
+      try {
+        const parsed = JSON.parse(resultChunk.data);
+        const delta = (_b = (_a2 = parsed.choices) == null ? void 0 : _a2[0]) == null ? void 0 : _b.delta;
+        return delta && (delta.role || delta.content || delta.reasoning_content || delta.tool_calls && delta.tool_calls.length > 0 || ((_d = (_c = parsed.choices) == null ? void 0 : _c[0]) == null ? void 0 : _d.finish_reason));
+      } catch (e) {
+        return true;
+      }
+    });
+  };
+}
+function convertAISDKStreamChunkToOpenAI(chunk, model) {
+  const convert = createOpenAIStreamConverter(model);
+  return convert(chunk);
+}
+function createSSEResponse(chunks) {
+  return chunks.map((chunk) => `data: ${chunk.data}
+
+`).join("");
+}
+
+// src/server.ts
+var import_provider_utils = require("@ai-sdk/provider-utils");
+var import_cors = __toESM(require("@fastify/cors"), 1);
+var import_ai = require("ai");
+var import_fastify = __toESM(require("fastify"), 1);
+var import_zod2 = require("zod");
+function serializeZodSchema(schema) {
+  if (!schema) {
+    return null;
+  }
+  const jsonSchema = (0, import_zod2.toJSONSchema)(schema, {
+    unrepresentable: "any"
+  });
+  if (typeof jsonSchema === "object" && jsonSchema !== null) {
+    const { $schema, ...rest } = jsonSchema;
+    return rest;
+  }
+  return jsonSchema;
+}
+function serializeMessages(messages) {
+  return messages.map((message, index) => ({
+    index,
+    role: message.role,
+    content: message.content,
+    toolCalls: message.tool_calls
+  }));
+}
+function logIncomingRequest(openaiRequest, enabled) {
+  var _a;
+  if (!enabled) {
+    return;
+  }
+  const toolNames = ((_a = openaiRequest.tools) != null ? _a : []).map((tool) => {
+    var _a2;
+    return "function" in tool ? (_a2 = tool.function) == null ? void 0 : _a2.name : void 0;
+  }).filter((name) => Boolean(name));
+  console.log(
+    "[proxy] Incoming OpenAI request",
+    JSON.stringify(
+      {
+        model: openaiRequest.model,
+        stream: Boolean(openaiRequest.stream),
+        temperature: openaiRequest.temperature,
+        maxTokens: openaiRequest.max_tokens,
+        toolNames,
+        toolChoice: openaiRequest.tool_choice,
+        messages: serializeMessages(openaiRequest.messages),
+        tools: openaiRequest.tools
+      },
+      null,
+      2
+    )
+  );
+}
+function serializeAISDKMessages(messages) {
+  return messages == null ? void 0 : messages.map((message, index) => ({
+    index,
+    role: message.role,
+    content: message.content
+  }));
+}
+function logRequestConversion(openaiRequest, aisdkParams, enabled) {
+  var _a, _b;
+  if (!enabled) {
+    return;
+  }
+  const messages = (_a = aisdkParams.messages) != null ? _a : [];
+  console.log(
+    "[proxy] Converted AI SDK params",
+    JSON.stringify(
+      {
+        model: openaiRequest.model,
+        hasSystemMessage: messages.some((message) => message.role === "system"),
+        messages: serializeAISDKMessages(messages),
+        tools: Object.entries((_b = aisdkParams.tools) != null ? _b : {}).map(([name, tool]) => ({
+          name,
+          description: tool.description,
+          inputSchema: serializeZodSchema(tool.inputSchema)
+        })),
+        temperature: aisdkParams.temperature,
+        maxOutputTokens: aisdkParams.maxOutputTokens,
+        stopSequences: aisdkParams.stopSequences
+      },
+      null,
+      2
+    )
+  );
+}
+var OpenAIProxyServer = class {
+  constructor(config) {
+    var _a;
+    this.config = {
+      port: 3e3,
+      host: "localhost",
+      cors: true,
+      ...config
+    };
+    this.logger = (_a = config.logger) != null ? _a : console;
+    this.fastify = (0, import_fastify.default)();
+    if (this.config.cors) {
+      this.fastify.register(import_cors.default);
+    }
+    this.setupRoutes();
+  }
+  setupRoutes() {
+    this.fastify.get(
+      "/health",
+      async (_request, _reply) => ({
+        status: "ok",
+        timestamp: (/* @__PURE__ */ new Date()).toISOString()
+      })
+    );
+    this.fastify.post(
+      "/v1/chat/completions",
+      (request, reply) => {
+        var _a, _b, _c, _d;
+        try {
+          const openaiRequest = request.body;
+          if (!(openaiRequest.messages && Array.isArray(openaiRequest.messages))) {
+            return reply.code(400).send({
+              error: {
+                message: "Messages array is required",
+                type: "invalid_request_error"
+              }
+            });
+          }
+          logIncomingRequest(
+            openaiRequest,
+            (_b = (_a = this.config.logging) == null ? void 0 : _a.requests) != null ? _b : true
+          );
+          const aisdkParams = convertOpenAIRequestToAISDK(openaiRequest, {
+            parserDebug: this.config.parserDebug
+          });
+          logRequestConversion(
+            openaiRequest,
+            aisdkParams,
+            (_d = (_c = this.config.logging) == null ? void 0 : _c.conversions) != null ? _d : true
+          );
+          if (openaiRequest.stream) {
+            return this.handleStreamingRequest(
+              aisdkParams,
+              openaiRequest,
+              reply
+            );
+          }
+          return this.handleNonStreamingRequest(
+            aisdkParams,
+            openaiRequest,
+            reply
+          );
+        } catch (error) {
+          this.logger.error("Request handling error:", error);
+          return reply.code(500).send({
+            error: {
+              message: "Internal server error",
+              type: "server_error"
+            }
+          });
+        }
+      }
+    );
+    this.fastify.get("/v1/models", async () => ({
+      object: "list",
+      data: [
+        {
+          id: "wrapped-model",
+          object: "model",
+          created: Math.floor(Date.now() / 1e3),
+          owned_by: "ai-sdk-tool-proxy"
+        }
+      ]
+    }));
+  }
+  // Merge server-defined tools (with execute) and request-defined tools (schema-only)
+  // Server tools take precedence when names overlap.
+  mergeTools(serverTools, requestTools) {
+    const toProviderTool = (tool) => {
+      if (!tool) {
+        return;
+      }
+      return {
+        description: tool.description,
+        inputSchema: (0, import_provider_utils.zodSchema)(tool.inputSchema),
+        ...tool.execute ? { execute: tool.execute } : {}
+      };
+    };
+    const merged = {};
+    for (const [name, t] of Object.entries(requestTools != null ? requestTools : {})) {
+      const pt = toProviderTool(t);
+      if (pt) {
+        merged[name] = pt;
+      }
+    }
+    for (const [name, t] of Object.entries(serverTools != null ? serverTools : {})) {
+      const pt = toProviderTool(t);
+      if (pt) {
+        merged[name] = pt;
+      }
+    }
+    return Object.keys(merged).length > 0 ? merged : void 0;
+  }
+  async handleStreamingRequest(aisdkParams, openaiRequest, reply) {
+    var _a, _b;
+    reply.raw.writeHead(200, {
+      "Content-Type": "text/event-stream",
+      "Cache-Control": "no-cache",
+      Connection: "keep-alive",
+      "Access-Control-Allow-Origin": "*"
+    });
+    try {
+      const mergedTools = this.mergeTools(this.config.tools, aisdkParams.tools);
+      const result = await (0, import_ai.streamText)({
+        model: this.config.model,
+        ...aisdkParams,
+        ...mergedTools ? { tools: mergedTools } : {}
+      });
+      const convert = createOpenAIStreamConverter(openaiRequest.model, {
+        logChunks: (_b = (_a = this.config.logging) == null ? void 0 : _a.streamChunks) != null ? _b : true
+      });
+      for await (const chunk of result.fullStream) {
+        const openaiChunks = convert(chunk);
+        for (const openaiChunk of openaiChunks) {
+          reply.raw.write(`data: ${openaiChunk.data}
+
+`);
+        }
+      }
+      reply.raw.write("data: [DONE]\n\n");
+      reply.raw.end();
+    } catch (error) {
+      this.logger.error("Streaming error:", error);
+      reply.raw.write('data: {"error": {"message": "Streaming error"}}\n\n');
+      reply.raw.end();
+    }
+    return reply;
+  }
+  async handleNonStreamingRequest(aisdkParams, openaiRequest, reply) {
+    try {
+      const mergedTools = this.mergeTools(this.config.tools, aisdkParams.tools);
+      const result = await (0, import_ai.generateText)({
+        model: this.config.model,
+        ...aisdkParams,
+        ...mergedTools ? { tools: mergedTools } : {}
+      });
+      const openaiResponse = convertAISDKResultToOpenAI(
+        result,
+        openaiRequest.model,
+        false
+      );
+      reply.send(openaiResponse);
+    } catch (error) {
+      this.logger.error("Generation error:", error);
+      return reply.code(500).send({
+        error: {
+          message: "Generation failed",
+          type: "generation_error"
+        }
+      });
+    }
+  }
+  async start() {
+    try {
+      await this.fastify.listen({
+        port: this.config.port || 3e3,
+        host: this.config.host || "localhost"
+      });
+      this.logger.info(
+        `\u{1F680} OpenAI Proxy Server running on http://${this.config.host}:${this.config.port}`
+      );
+      this.logger.info(
+        `\u{1F4E1} Endpoint: http://${this.config.host}:${this.config.port}/v1/chat/completions`
+      );
+      this.logger.info(
+        `\u{1F3E5} Health: http://${this.config.host}:${this.config.port}/health`
+      );
+    } catch (error) {
+      this.logger.error("Failed to start server:", error);
+      process.exit(1);
+    }
+  }
+  async stop() {
+    try {
+      await this.fastify.close();
+      this.logger.info("\u{1F6D1} Server stopped");
+    } catch (error) {
+      this.logger.error("Error stopping server:", error);
+    }
+  }
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  OpenAIProxyServer,
+  convertAISDKResultToOpenAI,
+  convertAISDKStreamChunkToOpenAI,
+  convertAISDKToolCallsToOpenAI,
+  convertOpenAIRequestToAISDK,
+  createOpenAIStreamConverter,
+  createSSEResponse,
+  generateResponseId,
+  getCurrentTimestamp
+});
+//# sourceMappingURL=index.cjs.map