import { AzureOpenAI } from "openai";

import type { ResponseCreateParamsStreaming } from "openai/resources/responses/responses.js";

import { getEnvApiKey } from "../env-api-keys.js";

import { clampThinkingLevel } from "../model-utils.js";

import type {

Api,

AssistantMessage,

Context,

Model,

SimpleStreamOptions,

StreamFunction,

StreamOptions,

} from "../types.js";

import { AssistantMessageEventStream } from "../utils/event-stream.js";

import { headersToRecord } from "../utils/headers.js";

import { resolveAzureDeploymentNameFromMap } from "./azure-deployment-map.js";

import { clampOpenAIPromptCacheKey } from "./openai-prompt-cache.js";

import {

applyCommonResponsesParams,

convertResponsesMessages,

convertResponsesTools,

processResponsesStream,

createResponsesAssistantOutput,

resolveResponsesReasoningEffort,

runResponsesStreamLifecycle,

} from "./openai-responses-shared.js";

import { buildBaseOptions } from "./simple-options.js";

options?: AzureOpenAIResponsesOptions,

) => {

const stream = new AssistantMessageEventStream();

const output = createResponsesAssistantOutput(model, "azure-openai-responses");

// Start async processing

void (async () => {

const deploymentName = resolveDeploymentName(model, options);

const output: AssistantMessage = {

role: "assistant",

content: [],

api: "azure-openai-responses" as Api,

provider: model.provider,

model: model.id,

usage: {

input: 0,

output: 0,

cacheRead: 0,

cacheWrite: 0,

totalTokens: 0,

cost: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0, total: 0 },

},

stopReason: "stop",

timestamp: Date.now(),

};

try {

// Create Azure OpenAI client

void runResponsesStreamLifecycle({

stream,

model,

output,

options,

createClient: () => {

const apiKey = options?.apiKey || getEnvApiKey(model.provider) || "";

const client = createClient(model, apiKey, options);

let params = buildParams(model, context, options, deploymentName);

const nextParams = await options?.onPayload?.(params, model);

if (nextParams !== undefined) {

params = nextParams as ResponseCreateParamsStreaming;

}

const requestOptions = {

...(options?.signal ? { signal: options.signal } : {}),

...(options?.timeoutMs !== undefined ? { timeout: options.timeoutMs } : {}),

...(options?.maxRetries !== undefined ? { maxRetries: options.maxRetries } : {}),

};

const { data: openaiStream, response } = await client.responses

.create(params, requestOptions)

.withResponse();

await options?.onResponse?.(

{ status: response.status, headers: headersToRecord(response.headers) },

model,

);

stream.push({ type: "start", partial: output });

await processResponsesStream(openaiStream, output, stream, model);

if (options?.signal?.aborted) {

throw new Error("Request was aborted");

}

if (output.stopReason === "aborted" || output.stopReason === "error") {

throw new Error("An unknown error occurred");

}

stream.push({ type: "done", reason: output.stopReason, message: output });

stream.end();

} catch (error) {

for (const block of output.content) {

delete (block as { index?: number }).index;

// partialJson is only a streaming scratch buffer; never persist it.

delete (block as { partialJson?: string }).partialJson;

}

output.stopReason = options?.signal?.aborted ? "aborted" : "error";

output.errorMessage = formatAzureOpenAIError(error);

stream.push({ type: "error", reason: output.stopReason, error: output });

stream.end();

}

})();

return createClient(model, apiKey, options);

},

buildParams: () => buildParams(model, context, options, resolveDeploymentName(model, options)),

formatError: formatAzureOpenAIError,

});

return stream;

};

}

const base = buildBaseOptions(model, options, apiKey);

const clampedReasoning = options?.reasoning

? clampThinkingLevel(model, options.reasoning)

: undefined;

const reasoningEffort =

clampedReasoning === "off"

? undefined

: clampedReasoning === "max"

? "xhigh"

: clampedReasoning;

return streamAzureOpenAIResponses(model, context, {

...base,

reasoningEffort,

reasoningEffort: resolveResponsesReasoningEffort(model, options?.reasoning),

} satisfies AzureOpenAIResponsesOptions);

};

: clampOpenAIPromptCacheKey(options?.promptCacheKey ?? options?.sessionId),

};

if (options?.maxTokens) {

params.max_output_tokens = options?.maxTokens;

}

if (options?.temperature !== undefined) {

params.temperature = options?.temperature;

}

if (context.tools && context.tools.length > 0) {

params.tools = convertResponsesTools(context.tools, { model });

}

if (model.reasoning) {

if (options?.reasoningEffort || options?.reasoningSummary) {

const effort = options?.reasoningEffort

? (model.thinkingLevelMap?.[options.reasoningEffort] ?? options.reasoningEffort)

: "medium";

params.reasoning = {

effort: effort as NonNullable<typeof params.reasoning>["effort"],

summary: options?.reasoningSummary || "auto",

};

params.include = ["reasoning.encrypted_content"];

} else if (model.thinkingLevelMap?.off !== null) {

params.reasoning = {

effort: (model.thinkingLevelMap?.off ?? "none") as NonNullable<

typeof params.reasoning

>["effort"],

};

}

}

applyCommonResponsesParams(params, model, context, options);

return params;

}