Method createMessage

src/api/client.ts:64–206

(
    systemPrompt: string,
    messages: OpenAI.Chat.ChatCompletionMessageParam[],
    tools: OpenAI.Chat.ChatCompletionTool[],
    abortSignal?: AbortSignal,
  )

  }

  async *createMessage(
    systemPrompt: string,
    messages: OpenAI.Chat.ChatCompletionMessageParam[],
    tools: OpenAI.Chat.ChatCompletionTool[],
    abortSignal?: AbortSignal,
  ): AsyncGenerator<ApiStreamChunk> {
    const model = getModel(this.options.modelId);

    const requestOptions: OpenAI.Chat.Completions.ChatCompletionCreateParamsStreaming =
      {
        model: model.id,
        temperature: 0.2,
        messages: [
          { role: "system", content: systemPrompt },
          ...stripReasoningDetails(messages),
        ],
        stream: true,
        stream_options: { include_usage: true },
        max_tokens: model.maxOutputTokens,
      };
    if (tools.length > 0) {
      requestOptions.tools = tools;
      requestOptions.tool_choice = "auto";
      requestOptions.parallel_tool_calls = true;
    }

    const stream = await this.client.chat.completions.create(requestOptions, {
      headers: this.requestHeaders(),
      signal: abortSignal,
    });

    let lastUsage: CompletionUsage | undefined;
    let inferenceProvider: string | undefined;
    let fullContent = "";
    let isThinking = false;

    for await (const chunk of stream) {
      // The gateway may return an error object instead of throwing.
      if ("error" in chunk) {
        const error = (chunk as { error?: { message?: string; code?: number } })
          .error;
        const err = new Error(
          `Axon API Error ${error?.code ?? ""}: ${error?.message ?? "unknown error"}`,
        );
        (err as { status?: number }).status = error?.code;
        throw err;
      }

      if (
        "provider" in chunk &&
        typeof (chunk as { provider?: string }).provider === "string"
      ) {
        inferenceProvider = (chunk as { provider?: string }).provider;
      }

      if (chunk.usage) {
        lastUsage = chunk.usage as CompletionUsage;
      }