@within-7/minto 0.4.1 → 0.4.3

package/dist/services/llm/openaiProvider.js

@@ -1,622 +0,0 @@
-import { randomUUID } from "crypto";
-import { nanoid } from "nanoid";
-import { getToolDescriptionAsync } from "../../Tool.js";
-import {
-  getGlobalConfig
-} from "../../utils/config.js";
-import { isGPT5ModelName as isGPT5Model } from "../../utils/config.js";
-import {
-  createAssistantAPIErrorMessage,
-  normalizeContentFromAPI
-} from "../../utils/messages.js";
-import {
-  debug as debugLogger,
-  getCurrentRequest,
-  logLLMInteraction,
-  logSystemPromptConstruction
-} from "../../utils/debugLogger.js";
-import { getModelManager } from "../../utils/model.js";
-import { zodToJsonSchema } from "zod-to-json-schema";
-import { ModelAdapterFactory } from "../modelAdapterFactory.js";
-import { getCLISyspromptPrefix } from "../../constants/prompts/index.js";
-import { setStreamingState } from "../../utils/streamingState.js";
-import {
-  getCompletionWithProfile,
-  getGPT5CompletionWithProfile
-} from "../openai.js";
-import { getReasoningEffort } from "../../utils/thinking.js";
-import { addRetryEventToTranscript } from "../../utils/agentTranscripts.js";
-import { generateMintoContext } from "./mintoContext.js";
-import { splitSysPromptPrefix } from "./anthropicProvider.js";
-import {
-  API_ERROR_MESSAGE_PREFIX,
-  PROMPT_TOO_LONG_ERROR_MESSAGE,
-  CREDIT_BALANCE_TOO_LOW_ERROR_MESSAGE,
-  INVALID_API_KEY_ERROR_MESSAGE,
-  PROMPT_CACHING_ENABLED,
-  MAIN_QUERY_TEMPERATURE,
-  SONNET_COST_PER_MILLION_INPUT_TOKENS,
-  SONNET_COST_PER_MILLION_OUTPUT_TOKENS,
-  withRetry,
-  getMaxTokensFromProfile,
-  getModelInputTokenCostUSD,
-  getModelOutputTokenCostUSD,
-  addToTotalCost,
-  recordTokenUsage,
-  logError
-} from "./types.js";
-function convertAnthropicMessagesToOpenAIMessages(messages) {
-  const openaiMessages = [];
-  const toolResults = {};
-  for (const message of messages) {
-    let contentBlocks = [];
-    if (typeof message.message.content === "string") {
-      contentBlocks = [
-        {
-          type: "text",
-          text: message.message.content
-        }
-      ];
-    } else if (!Array.isArray(message.message.content)) {
-      contentBlocks = [message.message.content];
-    } else {
-      contentBlocks = message.message.content;
-    }
-    for (const block of contentBlocks) {
-      if (block.type === "text") {
-        openaiMessages.push({
-          role: message.message.role,
-          content: block.text
-        });
-      } else if (block.type === "tool_use") {
-        openaiMessages.push({
-          role: "assistant",
-          content: void 0,
-          tool_calls: [
-            {
-              type: "function",
-              function: {
-                name: block.name,
-                arguments: JSON.stringify(block.input)
-              },
-              id: block.id
-            }
-          ]
-        });
-      } else if (block.type === "tool_result") {
-        let toolContent = block.content;
-        if (typeof toolContent !== "string") {
-          toolContent = JSON.stringify(toolContent);
-        }
-        toolResults[block.tool_use_id] = {
-          role: "tool",
-          content: toolContent,
-          tool_call_id: block.tool_use_id
-        };
-      }
-    }
-  }
-  const finalMessages = [];
-  for (const message of openaiMessages) {
-    finalMessages.push(message);
-    if ("tool_calls" in message && message.tool_calls) {
-      for (const toolCall of message.tool_calls) {
-        if (toolResults[toolCall.id]) {
-          finalMessages.push(toolResults[toolCall.id]);
-        }
-      }
-    }
-  }
-  return finalMessages;
-}
-function messageReducer(previous, item) {
-  const reduce = (acc, delta) => {
-    acc = { ...acc };
-    for (const [key, value] of Object.entries(delta)) {
-      if (acc[key] === void 0 || acc[key] === null) {
-        acc[key] = value;
-        if (Array.isArray(acc[key])) {
-          for (const arr of acc[key]) {
-            delete arr.index;
-          }
-        }
-      } else if (typeof acc[key] === "string" && typeof value === "string") {
-        acc[key] += value;
-      } else if (typeof acc[key] === "number" && typeof value === "number") {
-        acc[key] = value;
-      } else if (Array.isArray(acc[key]) && Array.isArray(value)) {
-        const accArray = acc[key];
-        for (let i = 0; i < value.length; i++) {
-          const { index: rawIndex, ...chunkTool } = value[i];
-          const index = rawIndex ?? 0;
-          if (index - accArray.length > 1) {
-            throw new Error(
-              `Error: An array has an empty value when tool_calls are constructed. tool_calls: ${accArray}; tool: ${value}`
-            );
-          }
-          accArray[index] = reduce(accArray[index], chunkTool);
-        }
-      } else if (typeof acc[key] === "object" && typeof value === "object") {
-        acc[key] = reduce(acc[key], value);
-      }
-    }
-    return acc;
-  };
-  const choice = item.choices?.[0];
-  if (!choice) {
-    return previous;
-  }
-  return reduce(previous, choice.delta);
-}
-async function handleMessageStream(stream, signal) {
-  const streamStartTime = Date.now();
-  let ttftMs;
-  let chunkCount = 0;
-  let errorCount = 0;
-  debugLogger.api("OPENAI_STREAM_START", {
-    streamStartTime: String(streamStartTime)
-  });
-  let message = {};
-  let id, model, created, object, usage;
-  try {
-    for await (const chunk of stream) {
-      if (signal?.aborted) {
-        debugLogger.flow("OPENAI_STREAM_ABORTED", {
-          chunkCount,
-          timestamp: Date.now()
-        });
-        throw new Error("Request was cancelled");
-      }
-      chunkCount++;
-      try {
-        if (!id) {
-          id = chunk.id;
-          debugLogger.api("OPENAI_STREAM_ID_RECEIVED", {
-            id,
-            chunkNumber: String(chunkCount)
-          });
-        }
-        if (!model) {
-          model = chunk.model;
-          debugLogger.api("OPENAI_STREAM_MODEL_RECEIVED", {
-            model,
-            chunkNumber: String(chunkCount)
-          });
-        }
-        if (!created) {
-          created = chunk.created;
-        }
-        if (!object) {
-          object = chunk.object;
-        }
-        if (!usage && chunk.usage) {
-          usage = chunk.usage;
-          setStreamingState({
-            inputTokens: chunk.usage.prompt_tokens,
-            outputTokens: chunk.usage.completion_tokens
-          });
-        }
-        message = messageReducer(message, chunk);
-        if (chunk?.choices?.[0]?.delta?.content) {
-          if (!ttftMs) {
-            ttftMs = Date.now() - streamStartTime;
-            debugLogger.api("OPENAI_STREAM_FIRST_TOKEN", {
-              ttftMs: String(ttftMs),
-              chunkNumber: String(chunkCount)
-            });
-          }
-        }
-      } catch (chunkError) {
-        errorCount++;
-        debugLogger.error("OPENAI_STREAM_CHUNK_ERROR", {
-          chunkNumber: String(chunkCount),
-          errorMessage: chunkError instanceof Error ? chunkError.message : String(chunkError),
-          errorType: chunkError instanceof Error ? chunkError.constructor.name : typeof chunkError
-        });
-      }
-    }
-    debugLogger.api("OPENAI_STREAM_COMPLETE", {
-      totalChunks: String(chunkCount),
-      errorCount: String(errorCount),
-      totalDuration: String(Date.now() - streamStartTime),
-      ttftMs: String(ttftMs || 0),
-      finalMessageId: id || "undefined"
-    });
-  } catch (streamError) {
-    debugLogger.error("OPENAI_STREAM_FATAL_ERROR", {
-      totalChunks: String(chunkCount),
-      errorCount: String(errorCount),
-      errorMessage: streamError instanceof Error ? streamError.message : String(streamError),
-      errorType: streamError instanceof Error ? streamError.constructor.name : typeof streamError
-    });
-    throw streamError;
-  }
-  return {
-    id,
-    created,
-    model,
-    object,
-    choices: [
-      {
-        index: 0,
-        message,
-        finish_reason: "stop",
-        logprobs: void 0
-      }
-    ],
-    usage
-  };
-}
-function convertOpenAIResponseToAnthropic(response, _tools) {
-  let contentBlocks = [];
-  const message = response.choices?.[0]?.message;
-  if (!message) {
-    return {
-      role: "assistant",
-      content: [],
-      stop_reason: response.choices?.[0]?.finish_reason,
-      type: "message",
-      usage: response.usage
-    };
-  }
-  if (message?.tool_calls) {
-    for (const toolCall of message.tool_calls) {
-      const tool = toolCall.function;
-      const toolName = tool?.name;
-      let toolArgs = {};
-      let parseError = null;
-      try {
-        toolArgs = tool?.arguments ? JSON.parse(tool.arguments) : {};
-      } catch (e) {
-        parseError = e instanceof Error ? e.message : String(e);
-        debugLogger.warn("TOOL_ARGUMENTS_PARSE_ERROR", {
-          toolName,
-          rawArguments: tool?.arguments?.substring(0, 200),
-          errorMessage: parseError
-        });
-      }
-      if (parseError && Object.keys(toolArgs).length === 0) {
-        debugLogger.error("TOOL_CALL_EMPTY_ARGUMENTS", {
-          toolName,
-          parseError,
-          suggestion: "Model may have sent malformed JSON. The tool call will likely fail validation."
-        });
-      }
-      contentBlocks.push({
-        type: "tool_use",
-        input: toolArgs,
-        name: toolName,
-        id: toolCall.id?.length > 0 ? toolCall.id : nanoid()
-      });
-    }
-  }
-  if (message.reasoning) {
-    contentBlocks.push({
-      type: "thinking",
-      thinking: message.reasoning,
-      signature: ""
-    });
-  }
-  if (message.reasoning_content) {
-    contentBlocks.push({
-      type: "thinking",
-      thinking: message.reasoning_content,
-      signature: ""
-    });
-  }
-  if (message.content) {
-    contentBlocks.push({
-      type: "text",
-      text: message?.content,
-      citations: []
-    });
-  }
-  const finalMessage = {
-    role: "assistant",
-    content: contentBlocks,
-    stop_reason: response.choices?.[0]?.finish_reason,
-    type: "message",
-    usage: response.usage
-  };
-  return finalMessage;
-}
-function getAssistantMessageFromError(error) {
-  if (error instanceof Error && error.message.includes("prompt is too long")) {
-    return createAssistantAPIErrorMessage(PROMPT_TOO_LONG_ERROR_MESSAGE);
-  }
-  if (error instanceof Error && error.message.includes("Your credit balance is too low")) {
-    return createAssistantAPIErrorMessage(CREDIT_BALANCE_TOO_LOW_ERROR_MESSAGE);
-  }
-  if (error instanceof Error && error.message.toLowerCase().includes("x-api-key")) {
-    return createAssistantAPIErrorMessage(INVALID_API_KEY_ERROR_MESSAGE);
-  }
-  if (error instanceof Error) {
-    if (process.env.NODE_ENV === "development") {
-      debugLogger.error("OPENAI_API_ERROR", {
-        message: error.message,
-        stack: error.stack
-      });
-    }
-    return createAssistantAPIErrorMessage(
-      `${API_ERROR_MESSAGE_PREFIX}: ${error.message}`
-    );
-  }
-  return createAssistantAPIErrorMessage(API_ERROR_MESSAGE_PREFIX);
-}
-async function queryOpenAI(messages, systemPrompt, maxThinkingTokens, tools, signal, options) {
-  const config = getGlobalConfig();
-  const modelManager = getModelManager();
-  const toolUseContext = options?.toolUseContext;
-  const modelProfile = options?.modelProfile || modelManager.getModel("main");
-  let model;
-  const currentRequest = getCurrentRequest();
-  debugLogger.api("MODEL_CONFIG_OPENAI", {
-    modelProfileFound: !!modelProfile,
-    modelProfileId: modelProfile?.modelName,
-    modelProfileName: modelProfile?.name,
-    modelProfileModelName: modelProfile?.modelName,
-    modelProfileProvider: modelProfile?.provider,
-    modelProfileBaseURL: modelProfile?.baseURL,
-    modelProfileApiKeyExists: !!modelProfile?.apiKey,
-    optionsModel: options?.model,
-    requestId: getCurrentRequest()?.id
-  });
-  if (modelProfile) {
-    model = modelProfile.modelName;
-  } else {
-    model = options?.model || modelProfile?.modelName || "";
-  }
-  if (options?.prependCLISysprompt) {
-    const [firstSyspromptBlock] = splitSysPromptPrefix(systemPrompt);
-    systemPrompt = [getCLISyspromptPrefix(), ...systemPrompt];
-  }
-  const system = splitSysPromptPrefix(systemPrompt).map(
-    (_) => ({
-      ...PROMPT_CACHING_ENABLED ? { cache_control: { type: "ephemeral" } } : {},
-      text: _,
-      type: "text"
-    })
-  );
-  const toolSchemas = await Promise.all(
-    tools.map(
-      async (_) => ({
-        type: "function",
-        function: {
-          name: _.name,
-          description: await getToolDescriptionAsync(_),
-          parameters: "inputJSONSchema" in _ && _.inputJSONSchema ? _.inputJSONSchema : zodToJsonSchema(_.inputSchema)
-        }
-      })
-    )
-  );
-  const openaiSystem = system.map(
-    (s) => ({
-      role: "system",
-      content: s.text
-    })
-  );
-  const openaiMessages = convertAnthropicMessagesToOpenAIMessages(messages);
-  const startIncludingRetries = Date.now();
-  logSystemPromptConstruction({
-    basePrompt: systemPrompt.join("\n"),
-    mintoContext: generateMintoContext() || "",
-    reminders: [],
-    finalPrompt: systemPrompt.join("\n")
-  });
-  let start = Date.now();
-  let attemptNumber = 0;
-  let response;
-  try {
-    response = await withRetry(
-      async (attempt) => {
-        attemptNumber = attempt;
-        start = Date.now();
-        const maxTokens = getMaxTokensFromProfile(modelProfile);
-        const isGPT5 = isGPT5Model(model);
-        const isReasoningModel = isGPT5 || model.startsWith("o3") || model.startsWith("o4-mini") || model === "o1" || model === "o1-mini" || model === "o1-preview";
-        const opts = {
-          model,
-          ...isGPT5 ? { max_completion_tokens: maxTokens } : { max_tokens: maxTokens },
-          messages: [...openaiSystem, ...openaiMessages],
-          // Reasoning models (GPT-5, o3, o4-mini) require temperature to be omitted
-          ...!isReasoningModel && { temperature: MAIN_QUERY_TEMPERATURE }
-        };
-        if (config.stream) {
-          ;
-          opts.stream = true;
-          opts.stream_options = {
-            include_usage: true
-          };
-        }
-        if (toolSchemas.length > 0) {
-          opts.tools = toolSchemas;
-          opts.tool_choice = "auto";
-        }
-        const reasoningEffort = await getReasoningEffort(modelProfile, messages);
-        if (reasoningEffort) {
-          opts.reasoning_effort = reasoningEffort;
-        }
-        if (modelProfile && modelProfile.modelName) {
-          debugLogger.api("USING_MODEL_PROFILE_PATH", {
-            modelProfileName: modelProfile.modelName,
-            modelName: modelProfile.modelName,
-            provider: modelProfile.provider,
-            baseURL: modelProfile.baseURL,
-            apiKeyExists: !!modelProfile.apiKey,
-            requestId: getCurrentRequest()?.id
-          });
-          const USE_NEW_ADAPTER_SYSTEM = process.env.USE_NEW_ADAPTERS !== "false";
-          if (USE_NEW_ADAPTER_SYSTEM) {
-            const adapter = ModelAdapterFactory.createAdapter(modelProfile);
-            const unifiedParams = {
-              messages: openaiMessages,
-              systemPrompt: openaiSystem.map((s) => s.content),
-              tools,
-              maxTokens: getMaxTokensFromProfile(modelProfile),
-              stream: config.stream,
-              reasoningEffort,
-              temperature: isGPT5Model(model) || model.startsWith("o3") || model.startsWith("o4-mini") ? void 0 : MAIN_QUERY_TEMPERATURE,
-              previousResponseId: toolUseContext?.responseState?.previousResponseId,
-              verbosity: "high"
-              // High verbosity for coding tasks
-            };
-            const request = adapter.createRequest(unifiedParams);
-            if (ModelAdapterFactory.shouldUseResponsesAPI(modelProfile)) {
-              const { callGPT5ResponsesAPI } = await import("../openai.js");
-              const response2 = await callGPT5ResponsesAPI(
-                modelProfile,
-                request,
-                signal
-              );
-              const unifiedResponse = adapter.parseResponse(response2);
-              const apiMessage = {
-                role: "assistant",
-                content: unifiedResponse.content,
-                tool_calls: unifiedResponse.toolCalls,
-                usage: {
-                  prompt_tokens: unifiedResponse.usage.promptTokens,
-                  completion_tokens: unifiedResponse.usage.completionTokens
-                }
-              };
-              const assistantMsg = {
-                type: "assistant",
-                message: apiMessage,
-                costUSD: 0,
-                // Will be calculated later
-                durationMs: Date.now() - start,
-                uuid: `${Date.now()}-${Math.random().toString(36).substr(2, 9)}`,
-                responseId: unifiedResponse.responseId
-                // For state management
-              };
-              return assistantMsg;
-            } else {
-              const s = await getCompletionWithProfile(
-                modelProfile,
-                request,
-                0,
-                10,
-                signal
-              );
-              let finalResponse;
-              if (config.stream) {
-                finalResponse = await handleMessageStream(
-                  s,
-                  signal
-                );
-              } else {
-                finalResponse = s;
-              }
-              const r = convertOpenAIResponseToAnthropic(finalResponse, tools);
-              return r;
-            }
-          } else {
-            const completionFunction = isGPT5Model(modelProfile.modelName) ? getGPT5CompletionWithProfile : getCompletionWithProfile;
-            const s = await completionFunction(
-              modelProfile,
-              opts,
-              0,
-              10,
-              signal
-            );
-            let finalResponse;
-            if (opts.stream) {
-              finalResponse = await handleMessageStream(
-                s,
-                signal
-              );
-            } else {
-              finalResponse = s;
-            }
-            const r = convertOpenAIResponseToAnthropic(finalResponse, tools);
-            return r;
-          }
-        } else {
-          const errorDetails = {
-            modelProfileExists: !!modelProfile,
-            modelProfileId: modelProfile?.modelName,
-            modelNameExists: !!modelProfile?.modelName,
-            requestedModel: model,
-            requestId: getCurrentRequest()?.id
-          };
-          debugLogger.error("NO_VALID_MODEL_PROFILE", errorDetails);
-          throw new Error(
-            `No valid ModelProfile available for model: ${model}. Please configure model through /model command. Debug: ${JSON.stringify(errorDetails)}`
-          );
-        }
-      },
-      {
-        signal,
-        onRetry: toolUseContext?.agentId ? ({ attempt, maxRetries, error, delayMs }) => {
-          addRetryEventToTranscript(toolUseContext.agentId, {
-            attempt,
-            maxRetries,
-            errorMessage: error.message,
-            delayMs
-          });
-        } : void 0
-      }
-    );
-  } catch (error) {
-    logError(error);
-    return getAssistantMessageFromError(error);
-  }
-  const durationMs = Date.now() - start;
-  const durationMsIncludingRetries = Date.now() - startIncludingRetries;
-  const inputTokens = response.usage?.prompt_tokens ?? 0;
-  const outputTokens = response.usage?.completion_tokens ?? 0;
-  const cacheReadInputTokens = response.usage?.prompt_token_details?.cached_tokens ?? 0;
-  const cacheCreationInputTokens = response.usage?.prompt_token_details?.cached_tokens ?? 0;
-  const inputCostPerMillion = getModelInputTokenCostUSD(model) * 1e6;
-  const outputCostPerMillion = getModelOutputTokenCostUSD(model) * 1e6;
-  const costUSD = inputTokens / 1e6 * (inputCostPerMillion || SONNET_COST_PER_MILLION_INPUT_TOKENS) + outputTokens / 1e6 * (outputCostPerMillion || SONNET_COST_PER_MILLION_OUTPUT_TOKENS) + cacheReadInputTokens / 1e6 * (inputCostPerMillion || SONNET_COST_PER_MILLION_INPUT_TOKENS) * 0.1 + cacheCreationInputTokens / 1e6 * (inputCostPerMillion || SONNET_COST_PER_MILLION_INPUT_TOKENS);
-  addToTotalCost(costUSD, durationMsIncludingRetries);
-  recordTokenUsage(
-    {
-      inputTokens,
-      outputTokens,
-      cacheCreationTokens: cacheCreationInputTokens,
-      cacheReadTokens: cacheReadInputTokens
-    },
-    costUSD,
-    model,
-    toolUseContext ? {
-      agentId: toolUseContext.agentId,
-      toolUseId: toolUseContext.toolUseId,
-      model
-    } : void 0
-  );
-  logLLMInteraction({
-    systemPrompt: systemPrompt.join("\n"),
-    messages: [...openaiSystem, ...openaiMessages],
-    response,
-    usage: {
-      inputTokens,
-      outputTokens
-    },
-    timing: {
-      start,
-      end: Date.now()
-    },
-    apiFormat: "openai"
-  });
-  return {
-    message: {
-      ...response,
-      content: normalizeContentFromAPI(response.content),
-      usage: {
-        input_tokens: inputTokens,
-        output_tokens: outputTokens,
-        cache_read_input_tokens: cacheReadInputTokens,
-        cache_creation_input_tokens: 0
-      }
-    },
-    costUSD,
-    durationMs,
-    type: "assistant",
-    uuid: randomUUID()
-  };
-}
-export {
-  queryOpenAI
-};
-//# sourceMappingURL=openaiProvider.js.map