@within-7/minto 0.3.10 → 0.4.1

package/dist/services/llm/openaiProvider.js

@@ -0,0 +1,622 @@
+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