@deslop/workbench 0.0.360 → 0.0.381

package/dist/azure-openai-responses-CUFLNwdy.mjs

@@ -0,0 +1,207 @@
+#!/usr/bin/env -S node --max-old-space-size=16384 --heapsnapshot-near-heap-limit=3 --report-on-fatalerror
+import { Lr as clampThinkingLevel, Rr as getProviderEnvValue, Vr as registerApiProvider, zr as AssistantMessageEventStream } from "./server.js";
+import { t as headersToRecord } from "./headers-m19bM8_9.mjs";
+import { r as buildBaseOptions } from "./transform-messages-CUKh2_5w.mjs";
+import { t as AzureOpenAI } from "./openai-CUH8rb7p.mjs";
+import { t as clampOpenAIPromptCacheKey } from "./openai-prompt-cache-6hf3xB_x.mjs";
+import { n as convertResponsesTools, r as processResponsesStream, t as convertResponsesMessages } from "./openai-responses-shared-BAoGGIxP.mjs";
+//#region ../../node_modules/.pnpm/@earendil-works+pi-ai@0.79.8_@modelcontextprotocol+sdk@1.29.0_zod@4.4.3__ws@8.21.0_zod@4.4.3/node_modules/@earendil-works/pi-ai/dist/providers/azure-openai-responses.js
+const DEFAULT_AZURE_API_VERSION = "v1";
+const AZURE_TOOL_CALL_PROVIDERS = new Set([
+	"openai",
+	"openai-codex",
+	"opencode",
+	"azure-openai-responses"
+]);
+function parseDeploymentNameMap(value) {
+	const map = /* @__PURE__ */ new Map();
+	if (!value) return map;
+	for (const entry of value.split(",")) {
+		const trimmed = entry.trim();
+		if (!trimmed) continue;
+		const [modelId, deploymentName] = trimmed.split("=", 2);
+		if (!modelId || !deploymentName) continue;
+		map.set(modelId.trim(), deploymentName.trim());
+	}
+	return map;
+}
+function resolveDeploymentName(model, options) {
+	if (options?.azureDeploymentName) return options.azureDeploymentName;
+	return parseDeploymentNameMap(getProviderEnvValue("AZURE_OPENAI_DEPLOYMENT_NAME_MAP", options?.env)).get(model.id) || model.id;
+}
+function formatAzureOpenAIError(error) {
+	if (error instanceof Error) {
+		const status = error.status;
+		const statusCode = typeof status === "number" ? status : void 0;
+		if (statusCode !== void 0) return `Azure OpenAI API error (${statusCode}): ${error.message}`;
+		return error.message;
+	}
+	try {
+		return JSON.stringify(error);
+	} catch {
+		return String(error);
+	}
+}
+/**
+* Generate function for Azure OpenAI Responses API
+*/
+const streamAzureOpenAIResponses = (model, context, options) => {
+	const stream = new AssistantMessageEventStream();
+	(async () => {
+		const deploymentName = resolveDeploymentName(model, options);
+		const output = {
+			role: "assistant",
+			content: [],
+			api: "azure-openai-responses",
+			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 {
+			const apiKey = options?.apiKey;
+			if (!apiKey) throw new Error(`No API key for provider: ${model.provider}`);
+			const client = createClient(model, apiKey, options);
+			let params = buildParams(model, context, options, deploymentName);
+			const nextParams = await options?.onPayload?.(params, model);
+			if (nextParams !== void 0) params = nextParams;
+			const requestOptions = {
+				...options?.signal ? { signal: options.signal } : {},
+				...options?.timeoutMs !== void 0 ? { timeout: options.timeoutMs } : {},
+				maxRetries: options?.maxRetries ?? 0
+			};
+			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.index;
+				delete block.partialJson;
+			}
+			output.stopReason = options?.signal?.aborted ? "aborted" : "error";
+			output.errorMessage = formatAzureOpenAIError(error);
+			stream.push({
+				type: "error",
+				reason: output.stopReason,
+				error: output
+			});
+			stream.end();
+		}
+	})();
+	return stream;
+};
+const streamSimpleAzureOpenAIResponses = (model, context, options) => {
+	const apiKey = options?.apiKey;
+	if (!apiKey) throw new Error(`No API key for provider: ${model.provider}`);
+	const base = buildBaseOptions(model, options, apiKey);
+	const clampedReasoning = options?.reasoning ? clampThinkingLevel(model, options.reasoning) : void 0;
+	const reasoningEffort = clampedReasoning === "off" ? void 0 : clampedReasoning;
+	return streamAzureOpenAIResponses(model, context, {
+		...base,
+		reasoningEffort
+	});
+};
+function register() {
+	registerApiProvider({
+		api: "azure-openai-responses",
+		stream: streamAzureOpenAIResponses,
+		streamSimple: streamSimpleAzureOpenAIResponses
+	});
+}
+function normalizeAzureBaseUrl(baseUrl) {
+	const trimmed = baseUrl.trim().replace(/\/+$/, "");
+	let url;
+	try {
+		url = new URL(trimmed);
+	} catch {
+		throw new Error(`Invalid Azure OpenAI base URL: ${baseUrl}`);
+	}
+	const isAzureHost = url.hostname.endsWith(".openai.azure.com") || url.hostname.endsWith(".cognitiveservices.azure.com");
+	const normalizedPath = url.pathname.replace(/\/+$/, "");
+	if (isAzureHost && (normalizedPath === "" || normalizedPath === "/" || normalizedPath === "/openai")) {
+		url.pathname = "/openai/v1";
+		url.search = "";
+	}
+	return url.toString().replace(/\/+$/, "");
+}
+function buildDefaultBaseUrl(resourceName) {
+	return `https://${resourceName}.openai.azure.com/openai/v1`;
+}
+function resolveAzureConfig(model, options) {
+	const apiVersion = options?.azureApiVersion || getProviderEnvValue("AZURE_OPENAI_API_VERSION", options?.env) || DEFAULT_AZURE_API_VERSION;
+	const baseUrl = options?.azureBaseUrl?.trim() || getProviderEnvValue("AZURE_OPENAI_BASE_URL", options?.env)?.trim() || void 0;
+	const resourceName = options?.azureResourceName || getProviderEnvValue("AZURE_OPENAI_RESOURCE_NAME", options?.env);
+	let resolvedBaseUrl = baseUrl;
+	if (!resolvedBaseUrl && resourceName) resolvedBaseUrl = buildDefaultBaseUrl(resourceName);
+	if (!resolvedBaseUrl && model.baseUrl) resolvedBaseUrl = model.baseUrl;
+	if (!resolvedBaseUrl) throw new Error("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: normalizeAzureBaseUrl(resolvedBaseUrl),
+		apiVersion
+	};
+}
+function createClient(model, apiKey, options) {
+	const headers = { ...model.headers };
+	if (options?.headers) Object.assign(headers, options.headers);
+	const { baseUrl, apiVersion } = resolveAzureConfig(model, options);
+	return new AzureOpenAI({
+		apiKey,
+		apiVersion,
+		dangerouslyAllowBrowser: true,
+		defaultHeaders: headers,
+		baseURL: baseUrl
+	});
+}
+function buildParams(model, context, options, deploymentName) {
+	const params = {
+		model: deploymentName,
+		input: convertResponsesMessages(model, context, AZURE_TOOL_CALL_PROVIDERS),
+		stream: true,
+		prompt_cache_key: clampOpenAIPromptCacheKey(options?.sessionId),
+		store: false
+	};
+	if (options?.maxTokens) params.max_output_tokens = options?.maxTokens;
+	if (options?.temperature !== void 0) params.temperature = options?.temperature;
+	if (context.tools && context.tools.length > 0) params.tools = convertResponsesTools(context.tools);
+	if (model.reasoning) {
+		if (options?.reasoningEffort || options?.reasoningSummary) {
+			params.reasoning = {
+				effort: options?.reasoningEffort ? model.thinkingLevelMap?.[options.reasoningEffort] ?? options.reasoningEffort : "medium",
+				summary: options?.reasoningSummary || "auto"
+			};
+			params.include = ["reasoning.encrypted_content"];
+		} else if (model.thinkingLevelMap?.off !== null) params.reasoning = { effort: model.thinkingLevelMap?.off ?? "none" };
+	}
+	return params;
+}
+//#endregion
+export { register, streamAzureOpenAIResponses, streamSimpleAzureOpenAIResponses };

package/dist/client/assets/{(home)-DVKAaI4b.js → (home)-BL3S5BVq.js}

@@ -1 +1 @@
-import{n as e,t}from"./compiler-runtime-rGeCHUuX.js";var n=t(),r=e();function i(){let e=(0,n.c)(1),t;return e[0]===Symbol.for(`react.memo_cache_sentinel`)?(t=(0,r.jsx)(`div`,{className:`text-muted-foreground flex h-full items-center justify-center`,children:`Select a worktree from the sidebar.`}),e[0]=t):t=e[0],t}export{i as component};
+import{n as e,t}from"./compiler-runtime-CLAvuQ-D.js";var n=t(),r=e();function i(){let e=(0,n.c)(1),t;return e[0]===Symbol.for(`react.memo_cache_sentinel`)?(t=(0,r.jsx)(`div`,{className:`text-muted-foreground flex h-full items-center justify-center`,children:`Select a worktree from the sidebar.`}),e[0]=t):t=e[0],t}export{i as component};