uigraph 1.0.0 → 1.0.1

package/dist/openai-decisions-Du8y4mQG.mjs

@@ -1,142 +0,0 @@
-import { n as normalizeProviderError, t as formatProviderError } from "./error-body-FhmCtR7m.mjs";
-import { i as requiredNumber, n as parseClassifierUsage, r as postClassifierRequest, t as isRecord } from "./classifier-shared-DBUHiTGw.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/openai-decisions.js
-/**
-* OpenAI's Decisions API: `POST /v1/decisions` with `{ model, input, questions }`.
-* https://developers.openai.com/api/docs/guides/decisions
-*
-* The state is sent as JSON text. With images, the input becomes one user message with the state
-* as `input_text` followed by `input_image` data URLs. Questions map to Decisions types:
-* `choice` to `choice`, `score` to `score`, and `bool` to `predicate`. Predicates have no
-* criteria field, so the meanings of true and false are appended to the instructions.
-*
-* Only OpenAI API keys work: Sign in with ChatGPT tokens are rejected on this route.
-*/
-const LABEL = "OpenAI Decisions";
-/** The endpoint accepts at most this many image parts per request. */
-const MAX_IMAGES = 128;
-function predicateInstructions(question) {
-	const meanings = [question.criteria.true ? `True means: ${question.criteria.true}` : "", question.criteria.false ? `False means: ${question.criteria.false}` : ""].filter(Boolean);
-	return meanings.length > 0 ? `${question.instructions}\n\n${meanings.join("\n")}` : question.instructions;
-}
-function wireQuestion(name, question) {
-	if (question.type === "choice") return {
-		type: "choice",
-		name,
-		instructions: question.instructions,
-		choices: Object.entries(question.criteria).map(([value, description]) => description ? {
-			value,
-			description
-		} : { value })
-	};
-	if (question.type === "score") return {
-		type: "score",
-		name,
-		instructions: question.instructions,
-		levels: question.criteria.map((label) => ({ label }))
-	};
-	return {
-		type: "predicate",
-		name,
-		instructions: predicateInstructions(question)
-	};
-}
-function wireInput(context) {
-	const state = JSON.stringify(context.state);
-	const images = context.images ?? [];
-	if (images.length === 0) return state;
-	if (images.length > MAX_IMAGES) throw new Error(`${LABEL} accepts at most ${MAX_IMAGES} images, got ${images.length}`);
-	return [{
-		role: "user",
-		content: [{
-			type: "input_text",
-			text: state
-		}, ...images.map((image) => ({
-			type: "input_image",
-			image_url: `data:${image.mimeType};base64,${image.data}`
-		}))]
-	}];
-}
-function choiceProbabilities(value, id) {
-	if (!Array.isArray(value)) throw new Error(`${LABEL} returned invalid probabilities for ${id}`);
-	return Object.fromEntries(value.map((entry) => {
-		if (!isRecord(entry) || typeof entry.value !== "string") throw new Error(`${LABEL} returned invalid probabilities for ${id}`);
-		return [entry.value, requiredNumber(LABEL, entry.probability, `probability for ${id}.${entry.value}`)];
-	}));
-}
-function parseAnswer(id, question, answer) {
-	if (answer.type === "refusal") throw new Error(`${LABEL} refused to answer ${id}`);
-	if (question.type === "choice") {
-		if (answer.type !== "choice" || typeof answer.choice !== "string") throw new Error(`${LABEL} did not return a choice answer for ${id}`);
-		return {
-			type: "choice",
-			choice: answer.choice,
-			probabilities: choiceProbabilities(answer.probabilities, id),
-			confidence: requiredNumber(LABEL, answer.confidence, `confidence for ${id}`)
-		};
-	}
-	if (question.type === "score") {
-		if (answer.type !== "score") throw new Error(`${LABEL} did not return a score answer for ${id}`);
-		return {
-			type: "score",
-			score: requiredNumber(LABEL, answer.score, `score for ${id}`),
-			confidence: requiredNumber(LABEL, answer.confidence, `confidence for ${id}`)
-		};
-	}
-	if (answer.type !== "predicate") throw new Error(`${LABEL} did not return a predicate answer for ${id}`);
-	return {
-		type: "bool",
-		probability: requiredNumber(LABEL, answer.probability, `probability for ${id}`)
-	};
-}
-function parseAnswers(value, context) {
-	if (!Array.isArray(value)) throw new Error(`${LABEL} returned an unexpected response`);
-	const byName = /* @__PURE__ */ new Map();
-	for (const answer of value) if (isRecord(answer) && typeof answer.name === "string") byName.set(answer.name, answer);
-	return Object.fromEntries(Object.entries(context.questions).map(([id, question]) => {
-		const answer = byName.get(id);
-		if (!answer) throw new Error(`${LABEL} did not return an answer for ${id}`);
-		return [id, parseAnswer(id, question, answer)];
-	}));
-}
-/**
-* Cloudflare in front of api.openai.com answers 504 with an HTML page when a request runs longer
-* than about five seconds. Large inputs, currently above roughly 600K tokens, hit this limit, and
-* retrying the same input runs into it again, so 504 is not retried.
-*/
-const NO_RETRY_STATUSES = [504];
-function errorMessage(error) {
-	if (error.status === 504) return `${LABEL} error (504): the request timed out at the gateway. Very large inputs (above roughly 600K tokens) currently exceed its time limit.`;
-	return formatProviderError(normalizeProviderError(error), `${LABEL} error`);
-}
-/** Classification through OpenAI's Decisions API. */
-const classify = async (model, context, options) => {
-	const output = {
-		api: model.api,
-		provider: model.provider,
-		model: model.id,
-		answers: {},
-		stopReason: "stop",
-		timestamp: Date.now()
-	};
-	try {
-		if (model.api !== "openai-decisions") throw new Error(`Unsupported classifier API: ${model.api}`);
-		const body = await postClassifierRequest(LABEL, new URL("decisions", `${model.baseUrl.replace(/\/+$/u, "")}/`), model, {
-			model: model.id,
-			input: wireInput(context),
-			questions: Object.entries(context.questions).map(([id, question]) => wireQuestion(id, question))
-		}, options, NO_RETRY_STATUSES);
-		if (!isRecord(body)) throw new Error(`${LABEL} returned an unexpected response`);
-		const usage = parseClassifierUsage(body.usage, model);
-		if (usage) output.usage = usage;
-		output.answers = parseAnswers(body.answers, context);
-		return output;
-	} catch (error) {
-		output.answers = {};
-		output.stopReason = options?.signal?.aborted ? "aborted" : "error";
-		output.errorMessage = errorMessage(error);
-		return output;
-	}
-};
-//#endregion
-export { classify };

package/dist/openai-prompt-cache-Bc6qNWt0.mjs

@@ -1,8 +0,0 @@
-function clampOpenAIPromptCacheKey(key) {
-	if (key === void 0) return void 0;
-	const chars = Array.from(key);
-	if (chars.length <= 64) return key;
-	return chars.slice(0, 64).join("");
-}
-//#endregion
-export { clampOpenAIPromptCacheKey as t };

package/dist/openai-responses-a9lV_U7O.mjs

@@ -1,270 +0,0 @@
-import { t as getProviderEnvValue } from "./provider-env-BJhgA66g.mjs";
-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 { n as hasCopilotVisionInput, t as buildCopilotDynamicHeaders } from "./github-copilot-headers-DWcTgoXr.mjs";
-import { n as OpenAI } from "./openai-I3_AqKDX.mjs";
-import { n as normalizeProviderError, t as formatProviderError } from "./error-body-FhmCtR7m.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/openai-responses.js
-const OPENAI_TOOL_CALL_PROVIDERS = /* @__PURE__ */ new Set([
-	"openai",
-	"openai-codex",
-	"opencode"
-]);
-const OPENAI_RESPONSES_MIN_OUTPUT_TOKENS = 16;
-const CHATGPT_USAGE_URL = "https://chatgpt.com/settings/usage";
-/**
-* OpenAI API keys start with `sk-`; a different credential sent directly to OpenAI
-* is a Sign in with ChatGPT access token.
-*/
-function isChatGPTSignIn(model, apiKey) {
-	return model.provider === "openai" && model.baseUrl === "https://api.openai.com/v1" && apiKey !== void 0 && !apiKey.startsWith("sk-");
-}
-function hasHeader(headers, name) {
-	if (!headers) return false;
-	const expected = name.toLowerCase();
-	for (const [key, value] of Object.entries(headers)) if (key.toLowerCase() === expected && value !== null && value.trim().length > 0) return true;
-	return false;
-}
-function getClientApiKey(provider, apiKey, headers) {
-	if (apiKey) return apiKey;
-	if (hasHeader(headers, "authorization") || hasHeader(headers, "cf-aig-authorization")) return "unused";
-	throw new Error(`No API key for provider: ${provider}`);
-}
-function detectSessionAffinityFormat(model) {
-	return model.provider === "openrouter" || model.baseUrl.includes("openrouter.ai") ? "openrouter" : "openai";
-}
-/**
-* Resolve cache retention preference.
-* Defaults to "short" and uses PI_CACHE_RETENTION for backward compatibility.
-*/
-function resolveCacheRetention(cacheRetention, env) {
-	if (cacheRetention) return cacheRetention;
-	if (getProviderEnvValue("PI_CACHE_RETENTION", env) === "long") return "long";
-	return "short";
-}
-function getCompat(model) {
-	return {
-		supportsDeveloperRole: model.compat?.supportsDeveloperRole ?? true,
-		supportsMidConvoSystemMessages: model.compat?.supportsMidConvoSystemMessages ?? false,
-		sessionAffinityFormat: model.compat?.sessionAffinityFormat ?? detectSessionAffinityFormat(model),
-		supportsLongCacheRetention: model.compat?.supportsLongCacheRetention ?? true,
-		supportsStrictMode: model.compat?.supportsStrictMode ?? false,
-		supportsOpenAIGrammarTools: model.compat?.supportsOpenAIGrammarTools ?? false,
-		supportsAdditionalTools: model.compat?.supportsAdditionalTools ?? false,
-		supportsToolSearch: model.compat?.supportsToolSearch ?? false,
-		supportsExplicitPromptCacheMode: model.compat?.supportsExplicitPromptCacheMode ?? false,
-		supportsMaxOutputTokens: model.compat?.supportsMaxOutputTokens ?? true
-	};
-}
-function getPromptCacheRetention(compat, cacheRetention) {
-	return cacheRetention === "long" && compat.supportsLongCacheRetention && !compat.supportsExplicitPromptCacheMode ? "24h" : void 0;
-}
-function getPromptCacheOptions(compat, cacheRetention) {
-	if (!compat.supportsExplicitPromptCacheMode) return void 0;
-	if (cacheRetention === "none") return { mode: "explicit" };
-	if (cacheRetention === "long" && compat.supportsLongCacheRetention) return { ttl: "30m" };
-}
-/**
-* Generate function for OpenAI Responses API
-*/
-const stream = (model, context, options) => {
-	const stream = new AssistantMessageEventStream();
-	const normalizedContext = resolveTranscript(context, getCompat(model).supportsMidConvoSystemMessages);
-	(async () => {
-		const output = {
-			role: "assistant",
-			content: [],
-			api: model.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: "pending",
-			timestamp: Date.now()
-		};
-		try {
-			const apiKey = getClientApiKey(model.provider, options?.apiKey, options?.headers);
-			const cacheSessionId = resolveCacheRetention(options?.cacheRetention, options?.env) === "none" ? void 0 : options?.sessionId;
-			const compat = getCompat(model);
-			const grammarToolInputProperties = createGrammarToolInputProperties(getDeclaredTools(normalizedContext.messages), compat.supportsOpenAIGrammarTools);
-			const client = createClient(model, normalizedContext, apiKey, options?.headers, options?.fetch, cacheSessionId);
-			let params = buildParams(model, normalizedContext, options, compat, 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,
-				serviceTier: options?.serviceTier,
-				grammarToolInputProperties,
-				applyServiceTierPricing: (usage, serviceTier) => applyServiceTierPricing(usage, serviceTier, model)
-			});
-			if (options?.signal?.aborted) throw new Error("Request was aborted");
-			if (output.stopReason === "pending") throw new Error("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";
-			const errorMessage = formatProviderError(normalizeProviderError(error), `${model.provider === "openai" ? "OpenAI" : model.provider} API error`);
-			output.errorMessage = errorMessage.includes("subscription_sharing_usage_limit_exceeded") ? `${errorMessage}\nCheck your ChatGPT usage: ${CHATGPT_USAGE_URL}` : errorMessage;
-			stream.push({
-				type: "error",
-				reason: output.stopReason,
-				error: output
-			});
-			stream.end();
-		}
-	})();
-	return stream;
-};
-const streamSimple = (model, context, options) => {
-	getClientApiKey(model.provider, options?.apiKey, options?.headers);
-	const base = {
-		...buildBaseOptions(model, context, options, 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, context, apiKey, optionsHeaders, fetch, sessionId) {
-	const compat = getCompat(model);
-	const headers = {
-		"User-Agent": getPiUserAgent(),
-		...model.headers
-	};
-	if (model.provider === "github-copilot") {
-		const hasImages = hasCopilotVisionInput(context.messages);
-		const copilotHeaders = buildCopilotDynamicHeaders({
-			messages: context.messages,
-			hasImages
-		});
-		Object.assign(headers, copilotHeaders);
-	}
-	if (sessionId) {
-		if (compat.sessionAffinityFormat === "openrouter") headers["x-session-id"] = sessionId;
-		else {
-			if (compat.sessionAffinityFormat === "openai") headers.session_id = sessionId;
-			headers["x-client-request-id"] = sessionId;
-		}
-	}
-	if (optionsHeaders) Object.assign(headers, optionsHeaders);
-	return new OpenAI({
-		apiKey,
-		baseURL: model.baseUrl,
-		dangerouslyAllowBrowser: true,
-		fetch,
-		defaultHeaders: headers
-	});
-}
-function buildParams(model, context, options, compat = getCompat(model), grammarToolInputProperties = createGrammarToolInputProperties(getDeclaredTools(context.messages), compat.supportsOpenAIGrammarTools)) {
-	const transcriptTools = resolveTranscriptTools(context.messages, compat.supportsAdditionalTools || compat.supportsToolSearch);
-	const messages = convertResponsesMessages(model, context, OPENAI_TOOL_CALL_PROVIDERS, {
-		grammarToolInputProperties,
-		supportsMidConvoSystemMessages: compat.supportsMidConvoSystemMessages,
-		supportsAdditionalTools: compat.supportsAdditionalTools,
-		supportsToolSearch: compat.supportsToolSearch,
-		toolOptions: {
-			supportsStrictMode: compat.supportsStrictMode,
-			supportsOpenAIGrammarTools: compat.supportsOpenAIGrammarTools
-		}
-	});
-	const cacheRetention = resolveCacheRetention(options?.cacheRetention, options?.env);
-	const omitUnsupportedFields = isChatGPTSignIn(model, options?.apiKey);
-	const params = {
-		model: model.id,
-		input: messages,
-		stream: true,
-		prompt_cache_key: cacheRetention === "none" ? void 0 : clampOpenAIPromptCacheKey(options?.sessionId),
-		prompt_cache_retention: omitUnsupportedFields ? void 0 : getPromptCacheRetention(compat, cacheRetention),
-		prompt_cache_options: omitUnsupportedFields ? void 0 : getPromptCacheOptions(compat, cacheRetention),
-		store: false
-	};
-	if (options?.maxTokens && compat.supportsMaxOutputTokens && !omitUnsupportedFields) params.max_output_tokens = Math.max(options.maxTokens, OPENAI_RESPONSES_MIN_OUTPUT_TOKENS);
-	if (options?.temperature !== void 0 && !omitUnsupportedFields) params.temperature = options?.temperature;
-	if (options?.serviceTier !== void 0) params.service_tier = options.serviceTier;
-	if (transcriptTools.requestTools.length > 0) params.tools = convertResponsesTools(transcriptTools.requestTools, {
-		supportsStrictMode: compat.supportsStrictMode,
-		supportsOpenAIGrammarTools: compat.supportsOpenAIGrammarTools
-	});
-	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.provider !== "github-copilot" && model.thinkingLevelMap?.off !== null) params.reasoning = { effort: model.thinkingLevelMap?.off ?? "none" };
-		if (model.provider === "xai") params.include = ["reasoning.encrypted_content"];
-	}
-	const samplingParams = resolveSamplingParams(model, reasoningEffort ?? "off", options?.samplingParams);
-	if (samplingParams) Object.assign(params, samplingParams);
-	return params;
-}
-function getServiceTierCostMultiplier(model, serviceTier) {
-	switch (serviceTier) {
-		case "flex": return .5;
-		case "priority":
-		case "fast": return model.id === "gpt-5.5" ? 2.5 : 2;
-		default: return 1;
-	}
-}
-function applyServiceTierPricing(usage, serviceTier, model) {
-	const multiplier = getServiceTierCostMultiplier(model, serviceTier);
-	if (multiplier === 1) return;
-	usage.cost.input *= multiplier;
-	usage.cost.output *= multiplier;
-	usage.cost.cacheRead *= multiplier;
-	usage.cost.cacheWrite *= multiplier;
-	usage.cost.total = usage.cost.input + usage.cost.output + usage.cost.cacheRead + usage.cost.cacheWrite;
-}
-//#endregion
-export { stream, streamSimple };