@agenite/openai/dist/index.cjs

OpenAI provider for Agenite

'use strict';

var OpenAI = require('openai');
var llm = require('@agenite/llm');

function _interopDefault (e) { return e && e.__esModule ? e : { default: e }; }

var OpenAI__default = /*#__PURE__*/_interopDefault(OpenAI);

// src/provider.ts
function mapStopReason(finishReason) {
  if (!finishReason) return void 0;
  const stopReasonMap = {
    stop: "endTurn",
    length: "maxTokens",
    tool_calls: "toolUse"
  };
  return stopReasonMap[finishReason] || void 0;
}
function mapContent(content, toolCalls) {
  const blocks = [];
  if (content) {
    blocks.push({ type: "text", text: content });
  }
  if (toolCalls) {
    toolCalls.forEach((toolCall) => {
      blocks.push({
        type: "toolUse",
        id: toolCall.id,
        name: toolCall.function.name,
        input: JSON.parse(toolCall.function.arguments)
      });
    });
  }
  return blocks;
}
function convertMessages(messages) {
  return messages.map((msg) => {
    const content = msg.content.map((block) => {
      if (block.type === "text") return block.text;
      return "";
    }).filter(Boolean).join("\n");
    return {
      role: msg.role,
      content
    };
  });
}
var OpenAIProvider = class extends llm.BaseLLMProvider {
  client;
  model;
  name = "OpenAI";
  version = "1.0";
  constructor(config) {
    super();
    this.client = new OpenAI__default.default({
      apiKey: config.apiKey
    });
    this.model = config.model ?? "gpt-4-turbo-preview";
  }
  async generate(input, options) {
    try {
      const messageArray = llm.convertStringToMessages(input);
      const transformedMessages = convertMessages(messageArray);
      if (options?.systemPrompt) {
        transformedMessages.unshift({
          role: "system",
          content: options.systemPrompt
        });
      }
      const response = await this.client.chat.completions.create({
        model: this.model,
        messages: transformedMessages,
        temperature: options?.temperature,
        max_tokens: options?.maxTokens,
        stop: options?.stopSequences,
        tools: options?.tools?.map((tool) => ({
          type: "function",
          function: {
            name: tool.name,
            description: tool.description,
            parameters: tool.inputSchema
          }
        }))
      });
      const choice = response.choices[0];
      if (!choice) throw new Error("No completion choice returned");
      return {
        content: mapContent(choice.message.content, choice.message.tool_calls),
        stopReason: mapStopReason(choice.finish_reason),
        tokenUsage: {
          model: response.model,
          inputTokens: response.usage?.prompt_tokens ?? 0,
          outputTokens: response.usage?.completion_tokens ?? 0,
          inputCost: 0,
          outputCost: 0
        }
      };
    } catch (error) {
      console.error("OpenAI generation failed:", error);
      throw error instanceof Error ? new Error(`OpenAI generation failed: ${error.message}`) : new Error("OpenAI generation failed with unknown error");
    }
  }
  async *stream(input, options) {
    try {
      const messageArray = llm.convertStringToMessages(input);
      const transformedMessages = convertMessages(messageArray);
      if (options?.systemPrompt) {
        transformedMessages.unshift({
          role: "system",
          content: options.systemPrompt
        });
      }
      const streamResponse = await this.client.chat.completions.create({
        model: this.model,
        messages: transformedMessages,
        temperature: options?.temperature,
        max_tokens: options?.maxTokens,
        stop: options?.stopSequences,
        tools: options?.tools?.map((tool) => ({
          type: "function",
          function: {
            name: tool.name,
            description: tool.description,
            parameters: tool.inputSchema
          }
        })),
        stream: true
      });
      let buffer = "";
      for await (const chunk of streamResponse) {
        const content = chunk.choices[0]?.delta?.content;
        if (content) {
          buffer += content;
          if (buffer.length > 10) {
            yield {
              type: "text",
              text: buffer
            };
            buffer = "";
          }
        }
      }
      if (buffer.length > 0) {
        yield {
          type: "text",
          text: buffer
        };
      }
      const completion = await this.client.chat.completions.create({
        model: this.model,
        messages: transformedMessages,
        temperature: options?.temperature,
        max_tokens: options?.maxTokens,
        stop: options?.stopSequences,
        tools: options?.tools?.map((tool) => ({
          type: "function",
          function: {
            name: tool.name,
            description: tool.description,
            parameters: tool.inputSchema
          }
        }))
      });
      const choice = completion.choices[0];
      if (!choice) throw new Error("No completion choice returned");
      return {
        content: mapContent(choice.message.content, choice.message.tool_calls),
        stopReason: mapStopReason(choice.finish_reason),
        tokenUsage: {
          model: completion.model,
          inputTokens: completion.usage?.prompt_tokens ?? 0,
          outputTokens: completion.usage?.completion_tokens ?? 0,
          inputCost: 0,
          outputCost: 0
        }
      };
    } catch (error) {
      console.error("OpenAI generation failed:", error);
      throw error instanceof Error ? new Error(`OpenAI generation failed: ${error.message}`) : new Error("OpenAI generation failed with unknown error");
    }
  }
};

exports.OpenAIProvider = OpenAIProvider;
//# sourceMappingURL=index.cjs.map
//# sourceMappingURL=index.cjs.map