uigraph 1.0.0 → 1.0.1

package/dist/azure-openai-config-BbeCSg4y.mjs

@@ -1,55 +0,0 @@
-import { t as getProviderEnvValue } from "./provider-env-BJhgA66g.mjs";
-//#region node_modules/.pnpm/@earendil-works+pi-ai@1.2.0_@aws-sdk+credential-provider-node@3.972.86_@modelcontextpro_dcf109e705e96235bfb9a180457030de/node_modules/@earendil-works/pi-ai/dist/api/azure-openai-config.js
-const DEFAULT_AZURE_API_VERSION = "v1";
-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 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") || url.hostname.endsWith(".ai.azure.com");
-	const normalizedPath = url.pathname.replace(/\/+$/, "");
-	if (isAzureHost && (normalizedPath === "" || normalizedPath === "/" || normalizedPath === "/openai" || normalizedPath === "/openai/v1/responses")) {
-		url.pathname = "/openai/v1";
-		url.search = "";
-	}
-	return url.toString().replace(/\/+$/, "");
-}
-function buildDefaultBaseUrl(resourceName) {
-	return `https://${resourceName}.openai.azure.com/openai/v1`;
-}
-function resolveAzureBaseUrl(model, options) {
-	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 normalizeAzureBaseUrl(resolvedBaseUrl);
-}
-function resolveAzureConfig(model, options) {
-	return {
-		baseUrl: resolveAzureBaseUrl(model, options),
-		apiVersion: options?.azureApiVersion || getProviderEnvValue("AZURE_OPENAI_API_VERSION", options?.env) || DEFAULT_AZURE_API_VERSION
-	};
-}
-//#endregion
-export { resolveAzureConfig as n, resolveDeploymentName as r, resolveAzureBaseUrl as t };

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

@@ -1,182 +0,0 @@
-import { a as AssistantMessageEventStream } from "./diagnostics-xdSgQR8t.mjs";
-import { b as resolveTranscript, m as getDeclaredTools, n as clampThinkingLevel, x as resolveTranscriptTools } from "./models-DBdii9gQ.mjs";
-import { t as headersToRecord } from "./headers-GhQHLk-3.mjs";
-import { l as createGrammarToolInputProperties, m as getPiUserAgent, o as resolveSamplingParams, r as buildBaseOptions } from "./transform-messages-BClk99Vn.mjs";
-import { t as retryProviderRequest } from "./provider-retry-DXYM7rVE.mjs";
-import { t as AzureOpenAI } from "./openai-I3_AqKDX.mjs";
-import { n as normalizeProviderError, t as formatProviderError } from "./error-body-FhmCtR7m.mjs";
-import { n as resolveAzureConfig, r as resolveDeploymentName } from "./azure-openai-config-BbeCSg4y.mjs";
-import { t as clampOpenAIPromptCacheKey } from "./openai-prompt-cache-Bc6qNWt0.mjs";
-import { n as convertResponsesTools, r as processResponsesStream, t as convertResponsesMessages } from "./openai-responses-shared-CDs_PBiH.mjs";
-//#region node_modules/.pnpm/@earendil-works+pi-ai@1.2.0_@aws-sdk+credential-provider-node@3.972.86_@modelcontextpro_dcf109e705e96235bfb9a180457030de/node_modules/@earendil-works/pi-ai/dist/api/azure-openai-responses.js
-const AZURE_TOOL_CALL_PROVIDERS = /* @__PURE__ */ new Set([
-	"openai",
-	"openai-codex",
-	"opencode",
-	"azure"
-]);
-const OPENAI_RESPONSES_MIN_OUTPUT_TOKENS = 16;
-function formatAzureOpenAIError(error) {
-	return formatProviderError(normalizeProviderError(error), "Azure OpenAI API error");
-}
-/**
-* Generate function for Azure OpenAI Responses API
-*/
-const stream = (model, context, options) => {
-	const stream = new AssistantMessageEventStream();
-	const normalizedContext = resolveTranscript(context, model.compat?.supportsMidConvoSystemMessages);
-	(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: "pending",
-			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);
-			const grammarToolInputProperties = createGrammarToolInputProperties(getDeclaredTools(normalizedContext.messages), model.compat?.supportsOpenAIGrammarTools ?? false);
-			let params = buildParams(model, normalizedContext, options, deploymentName, grammarToolInputProperties);
-			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: 0
-			};
-			const { data: openaiStream, response } = await retryProviderRequest(() => client.responses.create(params, requestOptions).withResponse(), {
-				maxRetries: options?.maxRetries,
-				maxRetryDelayMs: options?.maxRetryDelayMs,
-				signal: options?.signal
-			});
-			await options?.onResponse?.({
-				status: response.status,
-				headers: headersToRecord(response.headers)
-			}, model);
-			stream.push({
-				type: "start",
-				partial: output
-			});
-			await processResponsesStream(openaiStream, output, stream, model, {
-				onProviderStreamEvent: options?.onProviderStreamEvent,
-				grammarToolInputProperties
-			});
-			if (options?.signal?.aborted) throw new Error("Request was aborted");
-			if (output.stopReason === "pending") throw new Error("Azure OpenAI Responses stream ended without a stop reason");
-			if (output.stopReason === "aborted" || output.stopReason === "error") throw new Error(output.errorMessage || "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;
-				delete block.customInput;
-			}
-			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 streamSimple = (model, context, options) => {
-	const apiKey = options?.apiKey;
-	if (!apiKey) throw new Error(`No API key for provider: ${model.provider}`);
-	const base = {
-		...buildBaseOptions(model, context, options, apiKey),
-		toolChoice: options?.toolChoice
-	};
-	const clampedReasoning = options?.reasoning ? clampThinkingLevel(model, options.reasoning) : void 0;
-	const reasoningEffort = clampedReasoning === "off" ? void 0 : clampedReasoning;
-	return stream(model, context, {
-		...base,
-		reasoningEffort
-	});
-};
-function createClient(model, apiKey, options) {
-	const headers = {
-		"User-Agent": getPiUserAgent(),
-		...model.headers
-	};
-	if (options?.headers) Object.assign(headers, options.headers);
-	const { baseUrl, apiVersion } = resolveAzureConfig(model, options);
-	return new AzureOpenAI({
-		apiKey,
-		apiVersion,
-		dangerouslyAllowBrowser: true,
-		fetch: options?.fetch,
-		defaultHeaders: headers,
-		baseURL: baseUrl
-	});
-}
-function buildParams(model, context, options, deploymentName, grammarToolInputProperties = createGrammarToolInputProperties(getDeclaredTools(context.messages), model.compat?.supportsOpenAIGrammarTools ?? false)) {
-	const supportsAdditionalTools = model.compat?.supportsAdditionalTools ?? false;
-	const supportsToolSearch = model.compat?.supportsToolSearch ?? false;
-	const transcriptTools = resolveTranscriptTools(context.messages, supportsAdditionalTools || supportsToolSearch);
-	const params = {
-		model: deploymentName,
-		input: convertResponsesMessages(model, context, AZURE_TOOL_CALL_PROVIDERS, {
-			grammarToolInputProperties,
-			supportsMidConvoSystemMessages: model.compat?.supportsMidConvoSystemMessages ?? false,
-			supportsAdditionalTools,
-			supportsToolSearch,
-			toolOptions: {
-				supportsStrictMode: model.compat?.supportsStrictMode ?? true,
-				supportsOpenAIGrammarTools: model.compat?.supportsOpenAIGrammarTools ?? false
-			}
-		}),
-		stream: true,
-		prompt_cache_key: clampOpenAIPromptCacheKey(options?.sessionId),
-		store: false
-	};
-	if (options?.maxTokens) params.max_output_tokens = Math.max(options.maxTokens, OPENAI_RESPONSES_MIN_OUTPUT_TOKENS);
-	if (options?.temperature !== void 0) params.temperature = options?.temperature;
-	if (transcriptTools.requestTools.length > 0) params.tools = convertResponsesTools(transcriptTools.requestTools, {
-		supportsStrictMode: model.compat?.supportsStrictMode ?? true,
-		supportsOpenAIGrammarTools: model.compat?.supportsOpenAIGrammarTools ?? false
-	});
-	if (options?.toolChoice !== void 0) params.tool_choice = options.toolChoice;
-	const reasoningEffort = options?.reasoningEffort ?? (options?.reasoningSummary ? "medium" : void 0);
-	if (model.reasoning) {
-		if (reasoningEffort) {
-			params.reasoning = {
-				effort: options?.reasoningEffort ? model.thinkingLevelMap?.[options.reasoningEffort] ?? options.reasoningEffort : reasoningEffort,
-				summary: options?.reasoningSummary || "auto"
-			};
-			params.include = ["reasoning.encrypted_content"];
-		} else if (model.thinkingLevelMap?.off !== null) params.reasoning = { effort: model.thinkingLevelMap?.off ?? "none" };
-	}
-	const samplingParams = resolveSamplingParams(model, reasoningEffort ?? "off", options?.samplingParams);
-	if (samplingParams) Object.assign(params, samplingParams);
-	return params;
-}
-//#endregion
-export { stream, streamSimple };

package/dist/classifier-shared-DBUHiTGw.mjs

@@ -1,105 +0,0 @@
-import { t as calculateCost } from "./models-DBdii9gQ.mjs";
-import { n as providerHeadersToRecord, t as headersToRecord } from "./headers-GhQHLk-3.mjs";
-import { t as retryProviderRequest } from "./provider-retry-DXYM7rVE.mjs";
-//#region node_modules/.pnpm/@earendil-works+pi-ai@1.2.0_@aws-sdk+credential-provider-node@3.972.86_@modelcontextpro_dcf109e705e96235bfb9a180457030de/node_modules/@earendil-works/pi-ai/dist/api/classifier-shared.js
-function httpError(label, response, body) {
-	const error = /* @__PURE__ */ new Error(`${label} returned ${response.status}`);
-	error.status = response.status;
-	error.headers = response.headers;
-	error.body = body;
-	return error;
-}
-function timeoutError(timeoutMs) {
-	const error = /* @__PURE__ */ new Error(`Request timed out after ${timeoutMs}ms`);
-	error.name = "TimeoutError";
-	error.status = void 0;
-	error.headers = void 0;
-	error.body = "";
-	return error;
-}
-function isRecord(value) {
-	return typeof value === "object" && value !== null && !Array.isArray(value);
-}
-function requiredNumber(label, value, field) {
-	if (typeof value !== "number" || !Number.isFinite(value)) throw new Error(`${label} returned an invalid ${field}`);
-	return value;
-}
-function requestHeaders(model, apiKey, optionsHeaders) {
-	return providerHeadersToRecord({
-		authorization: `Bearer ${apiKey}`,
-		"content-type": "application/json"
-	}, model.headers, optionsHeaders) ?? {};
-}
-/**
-* Posts one JSON classifier request with bearer auth, `onPayload`/`onResponse` hooks, a fresh
-* timeout per attempt, and provider retries. Returns the parsed response body; throws on failure.
-* `noRetryStatuses` lists HTTP statuses that fail at once although they are normally retried.
-*/
-async function postClassifierRequest(label, url, model, body, options, noRetryStatuses) {
-	if (!options?.apiKey) throw new Error(`No API key for provider: ${model.provider}`);
-	const apiKey = options.apiKey;
-	let payload = body;
-	const transformed = await options.onPayload?.(payload, model);
-	if (transformed !== void 0) payload = transformed;
-	const requestFetch = options.fetch ?? globalThis.fetch;
-	const { response, json } = await retryProviderRequest(async () => {
-		const timeoutSignal = options.timeoutMs !== void 0 ? AbortSignal.timeout(options.timeoutMs) : void 0;
-		const signal = options.signal && timeoutSignal ? AbortSignal.any([options.signal, timeoutSignal]) : options.signal ?? timeoutSignal;
-		try {
-			const next = await requestFetch(url, {
-				method: "POST",
-				headers: requestHeaders(model, apiKey, options.headers),
-				body: JSON.stringify(payload),
-				signal
-			});
-			if (!next.ok) throw httpError(label, next, await next.text());
-			return {
-				response: next,
-				json: await next.json()
-			};
-		} catch (error) {
-			if (timeoutSignal?.aborted && !options.signal?.aborted) throw timeoutError(options.timeoutMs);
-			throw error;
-		}
-	}, {
-		maxRetries: options.maxRetries ?? 2,
-		maxRetryDelayMs: options.maxRetryDelayMs,
-		signal: options.signal,
-		noRetryStatuses
-	});
-	await options.onResponse?.({
-		status: response.status,
-		headers: headersToRecord(response.headers)
-	}, model);
-	return json;
-}
-function tokenCount(value) {
-	return typeof value === "number" && Number.isFinite(value) && value > 0 ? value : 0;
-}
-/**
-* Usage from a `{ input_tokens, output_tokens }` object, priced from the model catalog like chat
-* usage. A missing or malformed usage object leaves the result without usage instead of failing it.
-*/
-function parseClassifierUsage(value, model) {
-	if (!isRecord(value) || value.input_tokens === void 0 && value.output_tokens === void 0) return void 0;
-	const input = tokenCount(value.input_tokens);
-	const output = tokenCount(value.output_tokens);
-	const usage = {
-		input,
-		output,
-		cacheRead: 0,
-		cacheWrite: 0,
-		totalTokens: input + output,
-		cost: {
-			input: 0,
-			output: 0,
-			cacheRead: 0,
-			cacheWrite: 0,
-			total: 0
-		}
-	};
-	calculateCost(model, usage);
-	return usage;
-}
-//#endregion
-export { requiredNumber as i, parseClassifierUsage as n, postClassifierRequest as r, isRecord as t };