@xiaoso/dsh-tool-plus 0.1.0-beta.2 → 0.1.0-beta.4

package/lib/azure-openai-responses-CNkHiLUh.mjs

@@ -0,0 +1,274 @@
+import { installBunShim as __installBunShim } from "./bun-shim.mjs";
+__installBunShim();
+import { r as __exportAll } from "./fs-promises-shim-B-9cMxz5.mjs";
+import { P as $env } from "./src-DTid0g4K.mjs";
+import { B as OpenAIHttpError, g as MissingApiKeyError, l as finalize, n as StreamTimeoutError, s as ProviderResponseError, t as ConfigurationError, v as AbortError } from "./error-B3bevhrs.mjs";
+import { L as sanitizeSchemaForOpenAIResponses, k as toolWireSchema, s as resolveCacheRetention } from "./utils-2Wq2eATG.mjs";
+import { C as applyResponsesReasoningParams, D as buildResponsesInput, K as getOpenAIPromptCacheKey, N as createInitialResponsesAssistantMessage, Q as isOpenAIResponsesProgressEvent, g as applyCommonResponsesSamplingParams, it as parseAzureDeploymentNameMap, n as getEnvApiKey, ot as processResponsesStream, yt as mapToOpenAIResponsesToolChoice } from "./stream-C_RAoxJC.mjs";
+import { t as createAbortSourceTracker } from "./abort-B7izMMna.mjs";
+import { t as AssistantMessageEventStream } from "./event-stream-BDPi64mK.mjs";
+import { n as getOpenAIStreamFirstEventTimeoutMs, o as iterateWithIdleTimeout, r as getOpenAIStreamIdleTimeoutMs } from "./idle-iterator-C6XbWcuB.mjs";
+import { c as postOpenAIStream, r as createOpenAIReasoningEffortFallbackKey, s as resolveOpenAIReasoningEffortFallback, t as applyOpenAIReasoningEffortFallback } from "./openai-reasoning-fallback-DGVVLgd1.mjs";
+//#region node_modules/.pnpm/@oh-my-pi+pi-ai@17.3.5/node_modules/@oh-my-pi/pi-ai/src/providers/azure-openai-responses.ts
+var azure_openai_responses_exports = /* @__PURE__ */ __exportAll({ streamAzureOpenAIResponses: () => streamAzureOpenAIResponses });
+const DEFAULT_AZURE_API_VERSION = "v1";
+const AZURE_OPENAI_RESPONSES_FIRST_EVENT_TIMEOUT_MESSAGE = "Azure OpenAI responses stream timed out while waiting for the first event";
+function resolveDeploymentName(model, options) {
+	if (options?.azureDeploymentName) return options.azureDeploymentName;
+	return parseAzureDeploymentNameMap($env.AZURE_OPENAI_DEPLOYMENT_NAME_MAP).get(model.id) ?? model.id;
+}
+/**
+* Generate function for Azure OpenAI Responses API
+*/
+const streamAzureOpenAIResponses = (model, context, options) => {
+	if (options?.promptCache?.mode === "explicit" && resolveCacheRetention(options.cacheRetention) !== "none") throw new ConfigurationError(`OpenAI explicit prompt caching is unsupported for ${model.provider}/${model.id}; Azure Responses does not emit explicit cache controls.`);
+	const stream = new AssistantMessageEventStream();
+	(async () => {
+		const startTime = performance.now();
+		let firstTokenTime;
+		const deploymentName = resolveDeploymentName(model, options);
+		const output = createInitialResponsesAssistantMessage("azure-openai-responses", model.provider, model.id);
+		let rawRequestDump;
+		const abortTracker = createAbortSourceTracker(options?.signal);
+		const firstEventTimeoutAbortError = new StreamTimeoutError(AZURE_OPENAI_RESPONSES_FIRST_EVENT_TIMEOUT_MESSAGE);
+		const { requestAbortController, requestSignal } = abortTracker;
+		const onSseEvent = options?.onSseEvent;
+		const rawSseObserver = onSseEvent ? (event) => {
+			if (!event.event && event.data && event.data !== "[DONE]") try {
+				const parsed = JSON.parse(event.data);
+				const resolvedEvent = typeof parsed.type === "string" ? parsed.type : typeof parsed.object === "string" ? parsed.object : null;
+				if (resolvedEvent) {
+					event.event = resolvedEvent;
+					event.raw = [`event: ${resolvedEvent}`, ...event.raw];
+				}
+			} catch {}
+			onSseEvent(event, model);
+		} : void 0;
+		try {
+			const { url, headers, baseUrl } = buildAzureResponsesRequest(model, options?.apiKey || getEnvApiKey(model.provider) || "", options);
+			const requestModel = modelForAzureEndpoint(model, baseUrl);
+			let params = buildParams(requestModel, context, options, deploymentName);
+			const replacementPayload = await options?.onPayload?.(params, requestModel);
+			if (replacementPayload !== void 0) params = replacementPayload;
+			const idleTimeoutMs = options?.streamIdleTimeoutMs ?? getOpenAIStreamIdleTimeoutMs();
+			const firstEventTimeoutMs = options?.streamFirstEventTimeoutMs ?? getOpenAIStreamFirstEventTimeoutMs(idleTimeoutMs);
+			const requestTimeoutMs = firstEventTimeoutMs !== void 0 && firstEventTimeoutMs > 0 ? firstEventTimeoutMs : void 0;
+			rawRequestDump = {
+				provider: model.provider,
+				api: output.api,
+				model: model.id,
+				method: "POST",
+				url,
+				body: params
+			};
+			const reasoningEffortFallbackKey = createOpenAIReasoningEffortFallbackKey("azure-responses", url, typeof params.model === "string" ? params.model : model.id);
+			const attemptedReasoningEffortFallbacks = /* @__PURE__ */ new Set();
+			let openaiStream;
+			while (true) {
+				let requestTimeout;
+				if (requestTimeoutMs !== void 0) requestTimeout = setTimeout(() => abortTracker.abortLocally(firstEventTimeoutAbortError), requestTimeoutMs);
+				try {
+					const headersWithTimeout = { ...headers };
+					if (requestTimeoutMs !== void 0) headersWithTimeout["X-Stainless-Timeout"] = Math.floor(requestTimeoutMs / 1e3).toString();
+					openaiStream = (await postOpenAIStream({
+						url,
+						headers: headersWithTimeout,
+						body: params,
+						signal: requestSignal,
+						fetch: options?.fetch,
+						onSseEvent: rawSseObserver
+					})).events;
+					break;
+				} catch (error) {
+					const capturedErrorResponse = error instanceof OpenAIHttpError ? error.captured : void 0;
+					const reasoningEffortFallback = !requestSignal.aborted ? resolveOpenAIReasoningEffortFallback(error, capturedErrorResponse, params) : void 0;
+					if (reasoningEffortFallback === void 0) throw error;
+					const retryMarker = `${reasoningEffortFallbackKey}:${String(reasoningEffortFallback)}`;
+					if (attemptedReasoningEffortFallbacks.has(retryMarker)) throw error;
+					attemptedReasoningEffortFallbacks.add(retryMarker);
+					applyOpenAIReasoningEffortFallback(params, reasoningEffortFallback);
+					rawRequestDump.body = params;
+				} finally {
+					if (requestTimeout !== void 0) clearTimeout(requestTimeout);
+				}
+			}
+			stream.push({
+				type: "start",
+				partial: output
+			});
+			const timedOpenaiStream = iterateWithIdleTimeout(openaiStream, {
+				idleTimeoutMs,
+				firstItemTimeoutMs: firstEventTimeoutMs,
+				firstItemErrorMessage: AZURE_OPENAI_RESPONSES_FIRST_EVENT_TIMEOUT_MESSAGE,
+				errorMessage: "Azure OpenAI responses stream stalled while waiting for the next event",
+				onIdle: () => requestAbortController.abort(),
+				onFirstItemTimeout: () => abortTracker.abortLocally(firstEventTimeoutAbortError),
+				abortSignal: options?.signal,
+				isProgressItem: isOpenAIResponsesProgressEvent
+			});
+			let sawTerminalResponseEvent = false;
+			await processResponsesStream(timedOpenaiStream, output, stream, model, {
+				onFirstToken: () => {
+					if (!firstTokenTime) firstTokenTime = performance.now();
+				},
+				onCompleted: () => {
+					sawTerminalResponseEvent = true;
+				}
+			});
+			const firstEventTimeoutError = abortTracker.getLocalAbortReason();
+			if (firstEventTimeoutError) throw firstEventTimeoutError;
+			if (abortTracker.wasCallerAbort()) throw new AbortError();
+			if (!sawTerminalResponseEvent) throw new ProviderResponseError("Azure OpenAI responses stream closed before a terminal response event was received", {
+				provider: model.provider,
+				kind: "incomplete-stream"
+			});
+			if (output.stopReason === "aborted" || output.stopReason === "error") throw new ProviderResponseError(output.errorMessage ?? "An unknown error occurred", {
+				provider: model.provider,
+				kind: "output"
+			});
+			output.duration = performance.now() - startTime;
+			if (firstTokenTime) output.ttft = firstTokenTime - startTime;
+			stream.push({
+				type: "done",
+				reason: output.stopReason,
+				message: output
+			});
+			stream.end();
+		} catch (error) {
+			const result = await finalize(error, {
+				api: model.api,
+				abortTracker,
+				rawRequestDump
+			});
+			output.stopReason = result.stopReason;
+			output.errorStatus = result.status;
+			output.errorId = result.id;
+			output.errorMessage = result.message;
+			output.duration = performance.now() - startTime;
+			if (firstTokenTime) output.ttft = firstTokenTime - startTime;
+			stream.push({
+				type: "error",
+				reason: output.stopReason,
+				error: output
+			});
+			stream.end();
+		}
+	})();
+	return stream;
+};
+function resolveAzureConfig(model, options) {
+	const apiVersion = options?.azureApiVersion || $env.AZURE_OPENAI_API_VERSION || DEFAULT_AZURE_API_VERSION;
+	const baseUrl = options?.azureBaseUrl?.trim() || $env.AZURE_OPENAI_BASE_URL?.trim() || void 0;
+	const resourceName = options?.azureResourceName || $env.AZURE_OPENAI_RESOURCE_NAME;
+	let resolvedBaseUrl = baseUrl;
+	if (!resolvedBaseUrl && resourceName) resolvedBaseUrl = `https://${resourceName}.openai.azure.com/openai/v1`;
+	if (!resolvedBaseUrl && model.baseUrl) resolvedBaseUrl = model.baseUrl;
+	if (!resolvedBaseUrl) throw new ConfigurationError("Azure OpenAI base URL is required. Set AZURE_OPENAI_BASE_URL or AZURE_OPENAI_RESOURCE_NAME, or pass azureBaseUrl, azureResourceName, or model.baseUrl.");
+	return {
+		baseUrl: resolvedBaseUrl.replace(/\/+$/, ""),
+		apiVersion
+	};
+}
+function modelForAzureEndpoint(model, baseUrl) {
+	if (model.supportsComputerUseConfig !== void 0 || model.supportsComputerUse !== true) return model;
+	try {
+		const url = new URL(baseUrl);
+		if (url.protocol === "https:" && (url.hostname.endsWith(".openai.azure.com") || url.hostname === "models.inference.ai.azure.com")) return model;
+	} catch {}
+	return {
+		...model,
+		supportsComputerUse: false
+	};
+}
+/**
+* Replicates the `AzureOpenAI` SDK client's request shape for `/responses`:
+* a string api key becomes a single `api-key` header (azure.mjs `authHeaders`;
+* never `Authorization: Bearer`), `api-version` rides as a query parameter
+* (azure.mjs constructor `defaultQuery`), and `/responses` is not a
+* deployment-scoped path, so no `/deployments/{model}` URL rewriting applies.
+* Custom model/options headers may override the auth header, matching the SDK's
+* `buildHeaders` precedence.
+*/
+function buildAzureResponsesRequest(model, apiKey, options) {
+	if (!apiKey) {
+		const envKey = $env.AZURE_OPENAI_API_KEY;
+		if (!envKey) throw new MissingApiKeyError(void 0, "Azure OpenAI API key is required. Set AZURE_OPENAI_API_KEY environment variable or pass it as an argument.");
+		apiKey = envKey;
+	}
+	const headers = {
+		"api-key": apiKey,
+		...model.headers ?? {}
+	};
+	if (options?.headers) Object.assign(headers, options.headers);
+	const { baseUrl, apiVersion } = resolveAzureConfig(model, options);
+	return {
+		url: `${baseUrl}/responses?api-version=${encodeURIComponent(apiVersion)}`,
+		headers,
+		baseUrl
+	};
+}
+function buildParams(model, context, options, deploymentName) {
+	const systemRole = model.reasoning && model.compat.supportsDeveloperRole ? "developer" : "system";
+	const params = {
+		model: deploymentName,
+		input: buildResponsesInput({
+			model,
+			context,
+			strictResponsesPairing: true,
+			supportsImageDetailOriginal: model.compat.supportsImageDetailOriginal,
+			systemRole,
+			nativeHistory: {
+				replay: true,
+				filterReasoning: false
+			},
+			includeThinkingSignatures: true,
+			developerStringContent: true,
+			preserveAssistantMessageIds: true
+		}),
+		stream: true,
+		prompt_cache_key: getOpenAIPromptCacheKey(options),
+		store: false
+	};
+	applyCommonResponsesSamplingParams(params, options, model);
+	if (options?.include?.length) params.include = Array.from(new Set(options.include));
+	if (context.tools) {
+		const serializedTools = [];
+		for (const tool of context.tools) {
+			if (tool.native?.type === "computer") {
+				if (model.supportsComputerUse === true) {
+					serializedTools.push({ type: "computer" });
+					continue;
+				}
+			} else if (tool.native !== void 0) continue;
+			serializedTools.push({
+				type: "function",
+				name: tool.name,
+				description: tool.description || "",
+				parameters: sanitizeSchemaForOpenAIResponses(toolWireSchema(tool)),
+				strict: false
+			});
+		}
+		if (serializedTools.length > 0) {
+			params.tools = serializedTools;
+			if (options?.toolChoice) {
+				let toolChoice = mapToOpenAIResponsesToolChoice(options.toolChoice);
+				const hasComputerTool = serializedTools.some((tool) => tool.type === "computer");
+				if (toolChoice && typeof toolChoice !== "string" && toolChoice.type === "computer" && !hasComputerTool) {
+					const computer = context.tools.find((tool) => tool.native?.type === "computer");
+					if (computer && serializedTools.some((tool) => tool.type === "function" && tool.name === computer.name)) toolChoice = {
+						type: "function",
+						name: computer.name
+					};
+				}
+				if (toolChoice && typeof toolChoice !== "string" && toolChoice.type === "function" && hasComputerTool) {
+					if (context.tools.find((tool) => tool.native?.type === "computer")?.name === toolChoice.name) toolChoice = { type: "computer" };
+				}
+				if (toolChoice && (typeof toolChoice === "string" || toolChoice.type === "computer" && hasComputerTool || toolChoice.type === "function" && serializedTools.some((tool) => tool.type === "function" && tool.name === toolChoice.name))) params.tool_choice = toolChoice;
+			}
+		}
+	}
+	applyResponsesReasoningParams(params, model, options);
+	return params;
+}
+//#endregion
+export { azure_openai_responses_exports as t };

package/lib/azure-openai-responses-Cgmc-rbL.mjs

@@ -0,0 +1,274 @@
+import { installBunShim as __installBunShim } from "./bun-shim.mjs";
+__installBunShim();
+import { r as __exportAll } from "./fs-promises-shim-B-9cMxz5.mjs";
+import { P as $env } from "./src-lDmkSRbm.mjs";
+import { B as OpenAIHttpError, g as MissingApiKeyError, l as finalize, n as StreamTimeoutError, s as ProviderResponseError, t as ConfigurationError, v as AbortError } from "./error-yCSG0mGC.mjs";
+import { L as sanitizeSchemaForOpenAIResponses, k as toolWireSchema, s as resolveCacheRetention } from "./utils-Bw139LTz.mjs";
+import { C as applyResponsesReasoningParams, D as buildResponsesInput, K as getOpenAIPromptCacheKey, N as createInitialResponsesAssistantMessage, Q as isOpenAIResponsesProgressEvent, g as applyCommonResponsesSamplingParams, it as parseAzureDeploymentNameMap, n as getEnvApiKey, ot as processResponsesStream, yt as mapToOpenAIResponsesToolChoice } from "./stream-BlldLkVq.mjs";
+import { t as createAbortSourceTracker } from "./abort-D1_Z5Ut5.mjs";
+import { t as AssistantMessageEventStream } from "./event-stream-loUa0s1T.mjs";
+import { n as getOpenAIStreamFirstEventTimeoutMs, o as iterateWithIdleTimeout, r as getOpenAIStreamIdleTimeoutMs } from "./idle-iterator-Baoyn3Hp.mjs";
+import { c as postOpenAIStream, r as createOpenAIReasoningEffortFallbackKey, s as resolveOpenAIReasoningEffortFallback, t as applyOpenAIReasoningEffortFallback } from "./openai-reasoning-fallback-OdJREP1o.mjs";
+//#region node_modules/.pnpm/@oh-my-pi+pi-ai@17.3.5/node_modules/@oh-my-pi/pi-ai/src/providers/azure-openai-responses.ts
+var azure_openai_responses_exports = /* @__PURE__ */ __exportAll({ streamAzureOpenAIResponses: () => streamAzureOpenAIResponses });
+const DEFAULT_AZURE_API_VERSION = "v1";
+const AZURE_OPENAI_RESPONSES_FIRST_EVENT_TIMEOUT_MESSAGE = "Azure OpenAI responses stream timed out while waiting for the first event";
+function resolveDeploymentName(model, options) {
+	if (options?.azureDeploymentName) return options.azureDeploymentName;
+	return parseAzureDeploymentNameMap($env.AZURE_OPENAI_DEPLOYMENT_NAME_MAP).get(model.id) ?? model.id;
+}
+/**
+* Generate function for Azure OpenAI Responses API
+*/
+const streamAzureOpenAIResponses = (model, context, options) => {
+	if (options?.promptCache?.mode === "explicit" && resolveCacheRetention(options.cacheRetention) !== "none") throw new ConfigurationError(`OpenAI explicit prompt caching is unsupported for ${model.provider}/${model.id}; Azure Responses does not emit explicit cache controls.`);
+	const stream = new AssistantMessageEventStream();
+	(async () => {
+		const startTime = performance.now();
+		let firstTokenTime;
+		const deploymentName = resolveDeploymentName(model, options);
+		const output = createInitialResponsesAssistantMessage("azure-openai-responses", model.provider, model.id);
+		let rawRequestDump;
+		const abortTracker = createAbortSourceTracker(options?.signal);
+		const firstEventTimeoutAbortError = new StreamTimeoutError(AZURE_OPENAI_RESPONSES_FIRST_EVENT_TIMEOUT_MESSAGE);
+		const { requestAbortController, requestSignal } = abortTracker;
+		const onSseEvent = options?.onSseEvent;
+		const rawSseObserver = onSseEvent ? (event) => {
+			if (!event.event && event.data && event.data !== "[DONE]") try {
+				const parsed = JSON.parse(event.data);
+				const resolvedEvent = typeof parsed.type === "string" ? parsed.type : typeof parsed.object === "string" ? parsed.object : null;
+				if (resolvedEvent) {
+					event.event = resolvedEvent;
+					event.raw = [`event: ${resolvedEvent}`, ...event.raw];
+				}
+			} catch {}
+			onSseEvent(event, model);
+		} : void 0;
+		try {
+			const { url, headers, baseUrl } = buildAzureResponsesRequest(model, options?.apiKey || getEnvApiKey(model.provider) || "", options);
+			const requestModel = modelForAzureEndpoint(model, baseUrl);
+			let params = buildParams(requestModel, context, options, deploymentName);
+			const replacementPayload = await options?.onPayload?.(params, requestModel);
+			if (replacementPayload !== void 0) params = replacementPayload;
+			const idleTimeoutMs = options?.streamIdleTimeoutMs ?? getOpenAIStreamIdleTimeoutMs();
+			const firstEventTimeoutMs = options?.streamFirstEventTimeoutMs ?? getOpenAIStreamFirstEventTimeoutMs(idleTimeoutMs);
+			const requestTimeoutMs = firstEventTimeoutMs !== void 0 && firstEventTimeoutMs > 0 ? firstEventTimeoutMs : void 0;
+			rawRequestDump = {
+				provider: model.provider,
+				api: output.api,
+				model: model.id,
+				method: "POST",
+				url,
+				body: params
+			};
+			const reasoningEffortFallbackKey = createOpenAIReasoningEffortFallbackKey("azure-responses", url, typeof params.model === "string" ? params.model : model.id);
+			const attemptedReasoningEffortFallbacks = /* @__PURE__ */ new Set();
+			let openaiStream;
+			while (true) {
+				let requestTimeout;
+				if (requestTimeoutMs !== void 0) requestTimeout = setTimeout(() => abortTracker.abortLocally(firstEventTimeoutAbortError), requestTimeoutMs);
+				try {
+					const headersWithTimeout = { ...headers };
+					if (requestTimeoutMs !== void 0) headersWithTimeout["X-Stainless-Timeout"] = Math.floor(requestTimeoutMs / 1e3).toString();
+					openaiStream = (await postOpenAIStream({
+						url,
+						headers: headersWithTimeout,
+						body: params,
+						signal: requestSignal,
+						fetch: options?.fetch,
+						onSseEvent: rawSseObserver
+					})).events;
+					break;
+				} catch (error) {
+					const capturedErrorResponse = error instanceof OpenAIHttpError ? error.captured : void 0;
+					const reasoningEffortFallback = !requestSignal.aborted ? resolveOpenAIReasoningEffortFallback(error, capturedErrorResponse, params) : void 0;
+					if (reasoningEffortFallback === void 0) throw error;
+					const retryMarker = `${reasoningEffortFallbackKey}:${String(reasoningEffortFallback)}`;
+					if (attemptedReasoningEffortFallbacks.has(retryMarker)) throw error;
+					attemptedReasoningEffortFallbacks.add(retryMarker);
+					applyOpenAIReasoningEffortFallback(params, reasoningEffortFallback);
+					rawRequestDump.body = params;
+				} finally {
+					if (requestTimeout !== void 0) clearTimeout(requestTimeout);
+				}
+			}
+			stream.push({
+				type: "start",
+				partial: output
+			});
+			const timedOpenaiStream = iterateWithIdleTimeout(openaiStream, {
+				idleTimeoutMs,
+				firstItemTimeoutMs: firstEventTimeoutMs,
+				firstItemErrorMessage: AZURE_OPENAI_RESPONSES_FIRST_EVENT_TIMEOUT_MESSAGE,
+				errorMessage: "Azure OpenAI responses stream stalled while waiting for the next event",
+				onIdle: () => requestAbortController.abort(),
+				onFirstItemTimeout: () => abortTracker.abortLocally(firstEventTimeoutAbortError),
+				abortSignal: options?.signal,
+				isProgressItem: isOpenAIResponsesProgressEvent
+			});
+			let sawTerminalResponseEvent = false;
+			await processResponsesStream(timedOpenaiStream, output, stream, model, {
+				onFirstToken: () => {
+					if (!firstTokenTime) firstTokenTime = performance.now();
+				},
+				onCompleted: () => {
+					sawTerminalResponseEvent = true;
+				}
+			});
+			const firstEventTimeoutError = abortTracker.getLocalAbortReason();
+			if (firstEventTimeoutError) throw firstEventTimeoutError;
+			if (abortTracker.wasCallerAbort()) throw new AbortError();
+			if (!sawTerminalResponseEvent) throw new ProviderResponseError("Azure OpenAI responses stream closed before a terminal response event was received", {
+				provider: model.provider,
+				kind: "incomplete-stream"
+			});
+			if (output.stopReason === "aborted" || output.stopReason === "error") throw new ProviderResponseError(output.errorMessage ?? "An unknown error occurred", {
+				provider: model.provider,
+				kind: "output"
+			});
+			output.duration = performance.now() - startTime;
+			if (firstTokenTime) output.ttft = firstTokenTime - startTime;
+			stream.push({
+				type: "done",
+				reason: output.stopReason,
+				message: output
+			});
+			stream.end();
+		} catch (error) {
+			const result = await finalize(error, {
+				api: model.api,
+				abortTracker,
+				rawRequestDump
+			});
+			output.stopReason = result.stopReason;
+			output.errorStatus = result.status;
+			output.errorId = result.id;
+			output.errorMessage = result.message;
+			output.duration = performance.now() - startTime;
+			if (firstTokenTime) output.ttft = firstTokenTime - startTime;
+			stream.push({
+				type: "error",
+				reason: output.stopReason,
+				error: output
+			});
+			stream.end();
+		}
+	})();
+	return stream;
+};
+function resolveAzureConfig(model, options) {
+	const apiVersion = options?.azureApiVersion || $env.AZURE_OPENAI_API_VERSION || DEFAULT_AZURE_API_VERSION;
+	const baseUrl = options?.azureBaseUrl?.trim() || $env.AZURE_OPENAI_BASE_URL?.trim() || void 0;
+	const resourceName = options?.azureResourceName || $env.AZURE_OPENAI_RESOURCE_NAME;
+	let resolvedBaseUrl = baseUrl;
+	if (!resolvedBaseUrl && resourceName) resolvedBaseUrl = `https://${resourceName}.openai.azure.com/openai/v1`;
+	if (!resolvedBaseUrl && model.baseUrl) resolvedBaseUrl = model.baseUrl;
+	if (!resolvedBaseUrl) throw new ConfigurationError("Azure OpenAI base URL is required. Set AZURE_OPENAI_BASE_URL or AZURE_OPENAI_RESOURCE_NAME, or pass azureBaseUrl, azureResourceName, or model.baseUrl.");
+	return {
+		baseUrl: resolvedBaseUrl.replace(/\/+$/, ""),
+		apiVersion
+	};
+}
+function modelForAzureEndpoint(model, baseUrl) {
+	if (model.supportsComputerUseConfig !== void 0 || model.supportsComputerUse !== true) return model;
+	try {
+		const url = new URL(baseUrl);
+		if (url.protocol === "https:" && (url.hostname.endsWith(".openai.azure.com") || url.hostname === "models.inference.ai.azure.com")) return model;
+	} catch {}
+	return {
+		...model,
+		supportsComputerUse: false
+	};
+}
+/**
+* Replicates the `AzureOpenAI` SDK client's request shape for `/responses`:
+* a string api key becomes a single `api-key` header (azure.mjs `authHeaders`;
+* never `Authorization: Bearer`), `api-version` rides as a query parameter
+* (azure.mjs constructor `defaultQuery`), and `/responses` is not a
+* deployment-scoped path, so no `/deployments/{model}` URL rewriting applies.
+* Custom model/options headers may override the auth header, matching the SDK's
+* `buildHeaders` precedence.
+*/
+function buildAzureResponsesRequest(model, apiKey, options) {
+	if (!apiKey) {
+		const envKey = $env.AZURE_OPENAI_API_KEY;
+		if (!envKey) throw new MissingApiKeyError(void 0, "Azure OpenAI API key is required. Set AZURE_OPENAI_API_KEY environment variable or pass it as an argument.");
+		apiKey = envKey;
+	}
+	const headers = {
+		"api-key": apiKey,
+		...model.headers ?? {}
+	};
+	if (options?.headers) Object.assign(headers, options.headers);
+	const { baseUrl, apiVersion } = resolveAzureConfig(model, options);
+	return {
+		url: `${baseUrl}/responses?api-version=${encodeURIComponent(apiVersion)}`,
+		headers,
+		baseUrl
+	};
+}
+function buildParams(model, context, options, deploymentName) {
+	const systemRole = model.reasoning && model.compat.supportsDeveloperRole ? "developer" : "system";
+	const params = {
+		model: deploymentName,
+		input: buildResponsesInput({
+			model,
+			context,
+			strictResponsesPairing: true,
+			supportsImageDetailOriginal: model.compat.supportsImageDetailOriginal,
+			systemRole,
+			nativeHistory: {
+				replay: true,
+				filterReasoning: false
+			},
+			includeThinkingSignatures: true,
+			developerStringContent: true,
+			preserveAssistantMessageIds: true
+		}),
+		stream: true,
+		prompt_cache_key: getOpenAIPromptCacheKey(options),
+		store: false
+	};
+	applyCommonResponsesSamplingParams(params, options, model);
+	if (options?.include?.length) params.include = Array.from(new Set(options.include));
+	if (context.tools) {
+		const serializedTools = [];
+		for (const tool of context.tools) {
+			if (tool.native?.type === "computer") {
+				if (model.supportsComputerUse === true) {
+					serializedTools.push({ type: "computer" });
+					continue;
+				}
+			} else if (tool.native !== void 0) continue;
+			serializedTools.push({
+				type: "function",
+				name: tool.name,
+				description: tool.description || "",
+				parameters: sanitizeSchemaForOpenAIResponses(toolWireSchema(tool)),
+				strict: false
+			});
+		}
+		if (serializedTools.length > 0) {
+			params.tools = serializedTools;
+			if (options?.toolChoice) {
+				let toolChoice = mapToOpenAIResponsesToolChoice(options.toolChoice);
+				const hasComputerTool = serializedTools.some((tool) => tool.type === "computer");
+				if (toolChoice && typeof toolChoice !== "string" && toolChoice.type === "computer" && !hasComputerTool) {
+					const computer = context.tools.find((tool) => tool.native?.type === "computer");
+					if (computer && serializedTools.some((tool) => tool.type === "function" && tool.name === computer.name)) toolChoice = {
+						type: "function",
+						name: computer.name
+					};
+				}
+				if (toolChoice && typeof toolChoice !== "string" && toolChoice.type === "function" && hasComputerTool) {
+					if (context.tools.find((tool) => tool.native?.type === "computer")?.name === toolChoice.name) toolChoice = { type: "computer" };
+				}
+				if (toolChoice && (typeof toolChoice === "string" || toolChoice.type === "computer" && hasComputerTool || toolChoice.type === "function" && serializedTools.some((tool) => tool.type === "function" && tool.name === toolChoice.name))) params.tool_choice = toolChoice;
+			}
+		}
+	}
+	applyResponsesReasoningParams(params, model, options);
+	return params;
+}
+//#endregion
+export { azure_openai_responses_exports as t };