@iinm/plain-agent 1.8.3 → 1.8.4

package/src/providers/openai.mjs

@@ -1,544 +0,0 @@
-/**
- * @import { ModelInput, Message, AssistantMessage, ModelOutput, PartialMessageContent } from "../model"
- * @import { OpenAIFunctionToolCall, OpenAIInputImage, OpenAIInputItem, OpenAIModelConfig, OpenAIOutputItem, OpenAIOutputMessage, OpenAIReasoning, OpenAIRequest, OpenAIStreamEvent, OpenAIToolFunction } from "./openai"
- * @import { ToolDefinition } from "../tool"
- */
-
-import { styleText } from "node:util";
-import { noThrow } from "../utils/noThrow.mjs";
-import { getAzureAccessToken } from "./platform/azure.mjs";
-
-/**
- * @param {import("../modelDefinition").PlatformConfig} platformConfig
- * @param {OpenAIModelConfig} modelConfig
- * @param {ModelInput} input
- * @param {number} retryCount
- * @returns {Promise<ModelOutput | Error>}
- */
-export async function callOpenAIModel(
-  platformConfig,
-  modelConfig,
-  input,
-  retryCount = 0,
-) {
-  return await noThrow(async () => {
-    const messages = convertGenericMessageToOpenAIFormat(input.messages);
-    const tools = convertGenericeToolDefinitionToOpenAIFormat(
-      input.tools || [],
-    );
-
-    const { model, ...baseModelConfig } = modelConfig;
-
-    /** @type {OpenAIRequest} */
-    const request = {
-      ...baseModelConfig,
-      model: model,
-      input: messages,
-      tools: tools.length ? tools : undefined,
-      stream: true,
-    };
-
-    const apiKey = await (async () => {
-      switch (platformConfig.name) {
-        case "openai":
-        case "openai-compatible":
-          return platformConfig.apiKey;
-        case "azure":
-          return getAzureAccessToken(
-            platformConfig.azureConfigDir
-              ? {
-                  azureConfigDir: platformConfig.azureConfigDir,
-                }
-              : undefined,
-          );
-        default:
-          throw new Error(`Unsupported platform: ${platformConfig.name}`);
-      }
-    })();
-
-    const response = await fetch(`${platformConfig.baseURL}/v1/responses`, {
-      method: "POST",
-      headers: {
-        ...platformConfig.customHeaders,
-        "Content-Type": "application/json",
-        Authorization: `Bearer ${apiKey}`,
-      },
-      body: JSON.stringify(request),
-      signal: AbortSignal.timeout(8 * 60 * 1000),
-    });
-
-    const retryInterval = Math.min(2 * 2 ** retryCount, 16);
-    if (response.status === 429 || response.status >= 500) {
-      console.error(
-        styleText(
-          "yellow",
-          `OpenAI rate limit exceeded. Retry in ${retryInterval} seconds...`,
-        ),
-      );
-      await new Promise((resolve) => setTimeout(resolve, retryInterval * 1000));
-      return callOpenAIModel(
-        platformConfig,
-        modelConfig,
-        input,
-        retryCount + 1,
-      );
-    }
-
-    if (response.status !== 200) {
-      throw new Error(
-        `Failed to call OpenAI model: status=${response.status}, body=${await response.text()}`,
-      );
-    }
-
-    if (!response.body) {
-      throw new Error("Response body is empty");
-    }
-
-    const reader = response.body.getReader();
-
-    /** @type {OpenAIStreamEvent[]} */
-    const streamEvents = [];
-    for await (const streamEvent of readOpenAIStreamData(reader)) {
-      streamEvents.push(streamEvent);
-      const partialContent =
-        convertOpenAIStreamDataToAgentPartialContent(streamEvent);
-      if (input.onPartialMessageContent && partialContent) {
-        input.onPartialMessageContent(partialContent);
-      }
-    }
-
-    const lastEvent = streamEvents.at(-1);
-    if (lastEvent?.type !== "response.completed") {
-      const lastEventTrimmed =
-        lastEvent?.type === "response.failed"
-          ? {
-              type: lastEvent.type,
-              response: { error: lastEvent.response.error },
-            }
-          : lastEvent;
-      console.error(
-        styleText(
-          "yellow",
-          `OpenAI stream did not complete: ${JSON.stringify(lastEventTrimmed)}. Retry in ${retryInterval} seconds...`,
-        ),
-      );
-      await new Promise((resolve) => setTimeout(resolve, retryInterval * 1000));
-      return callOpenAIModel(
-        platformConfig,
-        modelConfig,
-        input,
-        retryCount + 1,
-      );
-    }
-
-    return {
-      message: convertOpenAIAssistantMessageToGenericFormat(
-        lastEvent.response.output,
-      ),
-      providerTokenUsage: lastEvent.response.usage,
-    };
-  });
-}
-
-/**
- * @param {Message[]} genericMessages
- * @returns {OpenAIInputItem[]}
- */
-function convertGenericMessageToOpenAIFormat(genericMessages) {
-  /** @type {OpenAIInputItem[]} */
-  const openAIInputItems = [];
-  for (const genericMessage of genericMessages) {
-    switch (genericMessage.role) {
-      case "system": {
-        openAIInputItems.push({
-          role: "system",
-          content: genericMessage.content.map((part) => ({
-            type: "input_text",
-            text: part.text,
-          })),
-        });
-        break;
-      }
-      case "user": {
-        const toolResults = genericMessage.content.filter(
-          (part) => part.type === "tool_result",
-        );
-        const userContentParts = genericMessage.content.filter(
-          (part) => part.type === "text" || part.type === "image",
-        );
-
-        // Tool Results
-        let imageIndex = 0;
-        for (const result of toolResults) {
-          const toolResultContentString = result.content
-            .map((part) => {
-              switch (part.type) {
-                case "text":
-                  return part.text;
-                case "image":
-                  imageIndex += 1;
-                  return `(Image [${imageIndex}] omitted. See next message from user.)`;
-                default:
-                  throw new Error(
-                    `Unsupported content part: ${JSON.stringify(part)}`,
-                  );
-              }
-            })
-            .join("\n\n");
-          openAIInputItems.push({
-            type: "function_call_output",
-            call_id: result.toolUseId,
-            output: toolResultContentString,
-          });
-        }
-
-        /** @type {OpenAIInputImage[]} */
-        const imageInputs = [];
-        for (const result of toolResults) {
-          for (const part of result.content) {
-            if (part.type === "image") {
-              imageInputs.push({
-                type: "input_image",
-                image_url: `data:${part.mimeType};base64,${part.data}`,
-                detail: "auto",
-              });
-            }
-          }
-        }
-
-        if (imageInputs.length) {
-          openAIInputItems.push({
-            role: "user",
-            content: imageInputs,
-          });
-        }
-
-        // User Input Parts
-        if (userContentParts.length) {
-          openAIInputItems.push({
-            role: "user",
-            content: userContentParts.map((part) => {
-              if (part.type === "text") {
-                return { type: "input_text", text: part.text };
-              }
-              if (part.type === "image") {
-                return {
-                  type: "input_image",
-                  image_url: `data:${part.mimeType};base64,${part.data}`,
-                };
-              }
-              throw new Error(
-                `Unsupported content part: ${JSON.stringify(part)}`,
-              );
-            }),
-          });
-        }
-
-        break;
-      }
-      case "assistant": {
-        // if (!genericMessage.provider?.source) {
-        //   throw new Error(
-        //     "Original message is required for assistant role but not provided.",
-        //   );
-        // }
-        // const source = /** @type {OpenAIOutputItem[]} */ (
-        //   genericMessage.provider.source
-        // );
-        // openAIInputItems.push(...source);
-
-        for (const part of genericMessage.content) {
-          if (part.type === "thinking") {
-            openAIInputItems.push(
-              /** @type {OpenAIReasoning} */ ({
-                type: "reasoning",
-                ...part.provider?.fields,
-              }),
-            );
-          }
-          if (part.type === "tool_use") {
-            openAIInputItems.push(
-              /** @type {OpenAIFunctionToolCall} */ ({
-                type: "function_call",
-                name: part.toolName,
-                arguments: JSON.stringify(part.input),
-                call_id: part.toolUseId,
-                ...part.provider?.fields,
-              }),
-            );
-          }
-          if (part.type === "text") {
-            const itemId = /** @type {string | undefined} */ (
-              part.provider?.fields?.id
-            );
-            const item = /** @type {OpenAIOutputMessage | undefined} */ (
-              openAIInputItems.find(
-                (item) =>
-                  "id" in item && item.id === itemId && item.type === "message",
-              )
-            );
-
-            if (item) {
-              item.content.push({
-                type: "output_text",
-                text: part.text,
-              });
-            } else {
-              openAIInputItems.push(
-                /** @type {OpenAIOutputMessage} */ ({
-                  type: "message",
-                  role: "assistant",
-                  content: [
-                    {
-                      type: "output_text",
-                      text: part.text,
-                    },
-                  ],
-                  ...part.provider?.fields,
-                }),
-              );
-            }
-          }
-        }
-      }
-    }
-  }
-
-  return openAIInputItems;
-}
-
-/**
- * @param {ToolDefinition[]} genericToolDefs
- * @returns {OpenAIToolFunction[]}
- */
-function convertGenericeToolDefinitionToOpenAIFormat(genericToolDefs) {
-  /** @type {OpenAIToolFunction[]} */
-  const openAIToolDefs = [];
-  for (const toolDef of genericToolDefs) {
-    openAIToolDefs.push({
-      type: "function",
-      name: toolDef.name,
-      description: toolDef.description,
-      parameters: toolDef.inputSchema,
-    });
-  }
-
-  return openAIToolDefs;
-}
-
-/**
- * @param {OpenAIOutputItem[]} openAIOutputItems
- * @returns {AssistantMessage}
- */
-function convertOpenAIAssistantMessageToGenericFormat(openAIOutputItems) {
-  /** @type {AssistantMessage["content"]} */
-  const content = [];
-  for (const item of openAIOutputItems) {
-    if (item.type === "reasoning") {
-      content.push({
-        type: "thinking",
-        thinking: item.summary.at(0)?.text ?? "",
-        provider: {
-          fields: {
-            id: item.id,
-            encrypted_content: item.encrypted_content,
-            summary: item.summary,
-          },
-        },
-      });
-    }
-
-    if (item.type === "message") {
-      for (const part of item.content) {
-        if (part.type === "output_text") {
-          content.push({
-            type: "text",
-            text: part.text,
-            provider: {
-              fields: {
-                id: item.id,
-              },
-            },
-          });
-        }
-      }
-    }
-
-    if (item.type === "function_call") {
-      content.push({
-        type: "tool_use",
-        toolUseId: item.call_id,
-        toolName: item.name,
-        input: JSON.parse(item.arguments),
-        provider: {
-          fields: {
-            id: item.id,
-          },
-        },
-      });
-    }
-  }
-
-  return {
-    role: "assistant",
-    content,
-
-    // provider: {
-    //   source: openAIOutputItems,
-    // },
-  };
-}
-
-/**
- * @param {OpenAIStreamEvent} streamEvent
- * @returns {PartialMessageContent | undefined}
- */
-function convertOpenAIStreamDataToAgentPartialContent(streamEvent) {
-  // thinking
-  if (streamEvent.type === "response.output_item.added") {
-    if (streamEvent.item.type === "reasoning") {
-      return {
-        type: "thinking",
-        position: "start",
-      };
-    }
-  }
-
-  if (streamEvent.type === "response.reasoning_summary_part.added") {
-    return {
-      type: "thinking",
-      position: "delta",
-      content: streamEvent.part.text,
-    };
-  }
-
-  if (streamEvent.type === "response.reasoning_summary_text.delta") {
-    return {
-      type: "thinking",
-      position: "delta",
-      content: streamEvent.delta,
-    };
-  }
-
-  if (streamEvent.type === "response.output_item.done") {
-    if (streamEvent.item.type === "reasoning") {
-      return {
-        type: "thinking",
-        position: "stop",
-      };
-    }
-  }
-
-  // text
-  if (streamEvent.type === "response.content_part.added") {
-    if (streamEvent.part.type === "output_text") {
-      return {
-        type: "text",
-        position: "start",
-        content: streamEvent.part.text,
-      };
-    }
-    if (streamEvent.part.type === "refusal") {
-      return {
-        type: "refusal",
-        position: "start",
-        content: streamEvent.part.refusal,
-      };
-    }
-  }
-
-  if (streamEvent.type === "response.output_text.delta") {
-    return {
-      type: "text",
-      position: "delta",
-      content: streamEvent.delta,
-    };
-  }
-
-  if (streamEvent.type === "response.content_part.done") {
-    if (streamEvent.part.type === "output_text") {
-      return {
-        type: "text",
-        position: "stop",
-      };
-    }
-    if (streamEvent.part.type === "refusal") {
-      return {
-        type: "refusal",
-        position: "stop",
-      };
-    }
-  }
-
-  // tool use
-  if (streamEvent.type === "response.output_item.added") {
-    if (streamEvent.item.type === "function_call") {
-      return {
-        type: "tool_use",
-        position: "start",
-        content: streamEvent.item.arguments,
-      };
-    }
-  }
-
-  if (streamEvent.type === "response.function_call_arguments.delta") {
-    return {
-      type: "tool_use",
-      position: "delta",
-      content: streamEvent.delta,
-    };
-  }
-
-  if (streamEvent.type === "response.output_item.done") {
-    if (streamEvent.item.type === "function_call") {
-      return {
-        type: "tool_use",
-        position: "stop",
-      };
-    }
-  }
-}
-
-/**
- * @param {ReadableStreamDefaultReader<Uint8Array>} reader
- */
-async function* readOpenAIStreamData(reader) {
-  let buffer = new Uint8Array();
-
-  while (true) {
-    const { done, value } = await reader.read();
-    if (done) {
-      break;
-    }
-
-    const nextBuffer = new Uint8Array(buffer.length + value.length);
-    nextBuffer.set(buffer);
-    nextBuffer.set(value, buffer.length);
-    buffer = nextBuffer;
-
-    const lineFeed = "\n".charCodeAt(0);
-    const dataEndIndices = [];
-    for (let i = 0; i < buffer.length - 1; i++) {
-      if (buffer[i] === lineFeed && buffer[i + 1] === lineFeed) {
-        dataEndIndices.push(i);
-      }
-    }
-
-    for (let i = 0; i < dataEndIndices.length; i++) {
-      const dataStartIndex = i === 0 ? 0 : dataEndIndices[i - 1] + 2;
-      const dataEndIndex = dataEndIndices[i];
-      const data = buffer.slice(dataStartIndex, dataEndIndex);
-      const decodedData = new TextDecoder().decode(data);
-      if (decodedData.startsWith("event: ")) {
-        const eventDate = decodedData.split("\n").slice(1).join("\n");
-        /** @type {OpenAIStreamEvent} */
-        const parsedData = JSON.parse(eventDate.slice("data: ".length));
-        yield parsedData;
-      }
-    }
-
-    if (dataEndIndices.length) {
-      buffer = buffer.slice(dataEndIndices[dataEndIndices.length - 1] + 2);
-    }
-  }
-}

package/src/providers/openaiCompatible.d.ts

@@ -1,147 +0,0 @@
-/* Model */
-export type OpenAICompatibleModelConfig =
-  | {
-      model: string;
-      temperature?: number;
-    }
-  | {
-      model: string;
-      reasoning_effort?: "low" | "medium" | "high";
-    };
-
-/* Request */
-export type OpenAIChatCompletionRequest = {
-  model?: string;
-  messages: OpenAIMessage[];
-  tools?: OpenAIToolDefinition[];
-  stream?: boolean;
-  temperature?: number;
-  reasoning_effort?: "low" | "medium" | "high";
-  stream_options?: {
-    include_usage: boolean;
-  };
-};
-
-/* Output */
-export type OpenAIChatCompletion = {
-  id: string;
-  object: string;
-  created: number;
-  model: string;
-  choices: OpenIAChatCompletionChoice[];
-  usage: OpenAIChatCompletionUsage;
-};
-
-export type OpenIAChatCompletionChoice = {
-  index: number;
-  message: OpenAIAssistantMessage;
-  finish_reason: string;
-};
-
-/* Message */
-export type OpenAIMessage =
-  | OpenAISystemMessage
-  | OpenAIUserMessage
-  | OpenAIAssistantMessage
-  | OpenAIToolMessage;
-
-export type OpenAISystemMessage = {
-  role: "system";
-  content: OpenAIMessageContentText[];
-};
-
-export type OpenAIUserMessage = {
-  role: "user";
-  content: (OpenAIMessageContentText | OpenAIMessageContentImage)[];
-};
-
-export type OpenAIAssistantMessage = {
-  role: "assistant";
-  reasoning_content?: string;
-  content?: string;
-  tool_calls?: OpenAIMessageToolCall[];
-};
-
-export type OpenAIToolMessage = {
-  role: "tool";
-  content: string;
-  tool_call_id: string;
-};
-
-export type OpenAIMessageContentText = {
-  type: "text";
-  text: string;
-};
-
-export type OpenAIMessageContentImage = {
-  type: "image_url";
-  image_url: {
-    url: string;
-  };
-};
-
-export type OpenAIMessageToolCall = {
-  id: string;
-  type: "function";
-  function: OpenAIToolCallFunction;
-};
-
-export type OpenAIToolCallFunction = {
-  name: string;
-  arguments: string;
-};
-
-/* Usage */
-export type OpenAIChatCompletionUsage = {
-  prompt_tokens: number;
-  completion_tokens: number;
-  total_tokens: number;
-  prompt_tokens_details: Record<string, number>;
-  completion_tokens_details: Record<string, number>;
-};
-
-/* Tool */
-export type OpenAIToolDefinition = {
-  type: "function";
-  function: {
-    name: string;
-    description: string;
-    parameters: Record<string, unknown>;
-  };
-};
-
-/* Streaming Data */
-export type OpenAIStreamData = {
-  id: string;
-  object: string;
-  created: number;
-  model: string;
-  service_tier?: string;
-  system_fingerprint?: string;
-  choices: OpenAIStreamDataChoice[];
-  usage?: OpenAIChatCompletionUsage;
-};
-
-export type OpenAIStreamDataChoice = {
-  index: number;
-  delta: OpenAIStreamDataDelta;
-  finish_reason: string;
-};
-
-export type OpenAIStreamDataDelta = {
-  role?: "assistant";
-  reasoning_content?: string;
-  content?: string;
-  refusal?: unknown;
-  tool_calls?: OpenAIStreamDataToolCall[];
-};
-
-export type OpenAIStreamDataToolCall = {
-  index: number;
-  id?: string;
-  type?: string;
-  function?: {
-    name?: string;
-    arguments: string;
-  };
-};