uigraph 1.0.0 → 1.0.1

package/dist/pi-messages-B5ietIBq.mjs

@@ -1,306 +0,0 @@
-import { t as getProviderEnvValue } from "./provider-env-BJhgA66g.mjs";
-import { a as AssistantMessageEventStream, n as createAssistantMessageDiagnostic, t as appendAssistantMessageDiagnostic } from "./diagnostics-xdSgQR8t.mjs";
-import { n as providerHeadersToRecord, t as headersToRecord } from "./headers-GhQHLk-3.mjs";
-import { n as parseStreamingJson } from "./json-parse-B2mHg7o7.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/pi-messages.js
-/**
-* pi-messages API implementation.
-*
-* Streams pi's own message protocol directly to a backend: the request is a
-* single POST of `{ model, context, options }` to `<baseUrl>/messages`, the
-* response is an SSE stream of serialized assistant-message events plus a
-* terminal `done`/`error` event. This is the wire protocol spoken by the
-* Radius gateway, but any backend implementing it can be used, e.g. via a
-* models.json custom provider with `"api": "pi-messages"`.
-*/
-var PiMessagesResponseError = class extends Error {
-	code;
-	diagnosticDetails;
-	constructor(message, code, diagnosticDetails) {
-		super(message);
-		this.name = "PiMessagesResponseError";
-		this.code = code;
-		this.diagnosticDetails = diagnosticDetails;
-	}
-};
-function parsePiMessagesErrorBody(body) {
-	try {
-		const parsed = JSON.parse(body);
-		const error = parsed?.error;
-		return parsed && typeof error === "object" && error !== null && !Array.isArray(error) ? parsed : void 0;
-	} catch {
-		return;
-	}
-}
-function truncateDiagnosticString(value) {
-	const maxLength = 8192;
-	return value.length > maxLength ? `${value.slice(0, maxLength)}…` : value;
-}
-function formatPiMessagesResponseError(response, body, errorBody) {
-	const message = typeof errorBody?.error?.message === "string" ? errorBody.error.message : void 0;
-	const code = typeof errorBody?.error?.code === "string" ? errorBody.error.code : void 0;
-	const suffix = message ?? body;
-	const codeSuffix = code ? ` (${code})` : "";
-	return `${response.status} ${response.statusText}: ${suffix}${codeSuffix}`;
-}
-function createPiMessagesResponseError(model, url, response, body) {
-	const errorBody = parsePiMessagesErrorBody(body);
-	const code = typeof errorBody?.error?.code === "string" ? errorBody.error.code : void 0;
-	return new PiMessagesResponseError(formatPiMessagesResponseError(response, body, errorBody), code, {
-		version: 1,
-		provider: model.provider,
-		model: model.id,
-		url: url.toString(),
-		status: response.status,
-		statusText: response.statusText,
-		...errorBody?.error === void 0 ? {} : { error: errorBody.error },
-		...errorBody ? {} : { body: truncateDiagnosticString(body) },
-		timestampMs: Date.now()
-	});
-}
-function createEmptyUsage() {
-	return {
-		input: 0,
-		output: 0,
-		cacheRead: 0,
-		cacheWrite: 0,
-		totalTokens: 0,
-		cost: {
-			input: 0,
-			output: 0,
-			cacheRead: 0,
-			cacheWrite: 0,
-			total: 0
-		}
-	};
-}
-function appendRewriteDiagnostic(message, rewrite) {
-	if (!rewrite) return;
-	appendAssistantMessageDiagnostic(message, {
-		type: "pi_messages_rewrite",
-		timestamp: Date.now(),
-		details: { ...rewrite }
-	});
-}
-function createEventConverter(model) {
-	const partial = {
-		role: "assistant",
-		content: [],
-		api: model.api,
-		provider: model.provider,
-		model: model.id,
-		usage: createEmptyUsage(),
-		stopReason: "pending",
-		timestamp: Date.now()
-	};
-	const toolJson = /* @__PURE__ */ new Map();
-	return (event) => {
-		switch (event.type) {
-			case "done":
-				Object.assign(partial, {
-					stopReason: event.reason,
-					usage: event.usage,
-					responseId: event.responseId
-				});
-				if (event.providerThinkingLevel !== void 0) partial.providerThinkingLevel = event.providerThinkingLevel;
-				appendRewriteDiagnostic(partial, event.rewrite);
-				return {
-					type: "done",
-					reason: event.reason,
-					message: partial
-				};
-			case "error":
-				Object.assign(partial, {
-					stopReason: event.reason,
-					usage: event.usage,
-					errorMessage: event.errorMessage,
-					responseId: event.responseId
-				});
-				if (event.providerThinkingLevel !== void 0) partial.providerThinkingLevel = event.providerThinkingLevel;
-				appendRewriteDiagnostic(partial, event.rewrite);
-				return {
-					type: "error",
-					reason: event.reason,
-					error: partial
-				};
-			case "start": break;
-			case "text_start":
-				partial.content[event.contentIndex] = {
-					type: "text",
-					text: ""
-				};
-				break;
-			case "text_delta":
-				partial.content[event.contentIndex].text += event.delta;
-				break;
-			case "text_end":
-				Object.assign(partial.content[event.contentIndex], {
-					text: event.content,
-					textSignature: event.contentSignature
-				});
-				break;
-			case "thinking_start":
-				partial.content[event.contentIndex] = {
-					type: "thinking",
-					thinking: ""
-				};
-				break;
-			case "thinking_delta":
-				partial.content[event.contentIndex].thinking += event.delta;
-				break;
-			case "thinking_end":
-				Object.assign(partial.content[event.contentIndex], {
-					thinking: event.content,
-					thinkingSignature: event.contentSignature,
-					redacted: event.redacted
-				});
-				break;
-			case "toolcall_start":
-				partial.content[event.contentIndex] = {
-					type: "toolCall",
-					id: event.id,
-					name: event.toolName,
-					arguments: {}
-				};
-				toolJson.set(event.contentIndex, "");
-				break;
-			case "toolcall_delta": {
-				const json = `${toolJson.get(event.contentIndex) ?? ""}${event.delta}`;
-				toolJson.set(event.contentIndex, json);
-				partial.content[event.contentIndex].arguments = parseStreamingJson(json);
-				break;
-			}
-			case "toolcall_end":
-				Object.assign(partial.content[event.contentIndex], event.toolCall);
-				toolJson.delete(event.contentIndex);
-				return {
-					type: "toolcall_end",
-					contentIndex: event.contentIndex,
-					toolCall: partial.content[event.contentIndex],
-					partial
-				};
-		}
-		return {
-			...event,
-			partial
-		};
-	};
-}
-async function* readPiMessagesEvents(stream) {
-	const decoder = new TextDecoder();
-	const reader = stream.getReader();
-	let buffer = "";
-	try {
-		while (true) {
-			const { done, value } = await reader.read();
-			buffer += done ? decoder.decode() : decoder.decode(value, { stream: true });
-			buffer = buffer.replace(/\r\n/g, "\n");
-			let split = buffer.indexOf("\n\n");
-			while (split !== -1) {
-				const event = parsePiMessagesEvent(buffer.slice(0, split));
-				if (event) yield event;
-				buffer = buffer.slice(split + 2);
-				split = buffer.indexOf("\n\n");
-			}
-			if (done) break;
-		}
-		if (buffer.trim()) {
-			const event = parsePiMessagesEvent(buffer);
-			if (event) yield event;
-		}
-	} finally {
-		reader.releaseLock();
-	}
-}
-function parsePiMessagesEvent(raw) {
-	const data = raw.split("\n").find((line) => line.startsWith("data:"))?.slice(5).trim();
-	return data && data !== "[DONE]" ? JSON.parse(data) : void 0;
-}
-function createErrorEvent(model, error, aborted) {
-	const reason = aborted ? "aborted" : "error";
-	const assistantMessage = {
-		role: "assistant",
-		content: [],
-		api: model.api,
-		provider: model.provider,
-		model: model.id,
-		usage: createEmptyUsage(),
-		stopReason: reason,
-		errorMessage: error instanceof Error ? error.message : String(error),
-		timestamp: Date.now()
-	};
-	if (!aborted && error instanceof PiMessagesResponseError) appendAssistantMessageDiagnostic(assistantMessage, createAssistantMessageDiagnostic("pi_messages_response_failure", error, error.diagnosticDetails));
-	return {
-		type: "error",
-		reason,
-		error: assistantMessage
-	};
-}
-function resolveCacheRetention(cacheRetention, env) {
-	if (cacheRetention) return cacheRetention;
-	return getProviderEnvValue("PI_CACHE_RETENTION", env) === "long" ? "long" : void 0;
-}
-const stream = (model, context, options) => {
-	const eventStream = new AssistantMessageEventStream();
-	const convertEvent = createEventConverter(model);
-	(async () => {
-		try {
-			const apiKey = options?.apiKey;
-			if (!apiKey) throw new Error(`No API key provided for provider "${model.provider}"`);
-			const url = new URL(`${model.baseUrl.replace(/\/+$/u, "")}/messages`);
-			if (options?.debug) url.searchParams.set("debug", "1");
-			let payload = {
-				model: model.id,
-				context,
-				options: {
-					temperature: options?.temperature,
-					maxTokens: options?.maxTokens,
-					reasoning: options?.reasoning,
-					cacheRetention: resolveCacheRetention(options?.cacheRetention, options?.env),
-					sessionId: options?.sessionId,
-					toolChoice: options?.toolChoice
-				}
-			};
-			const nextPayload = await options?.onPayload?.(payload, model);
-			if (nextPayload !== void 0) payload = nextPayload;
-			const response = await (options?.fetch ?? globalThis.fetch)(url, {
-				method: "POST",
-				headers: {
-					authorization: `Bearer ${apiKey}`,
-					accept: "text/event-stream",
-					"content-type": "application/json",
-					...providerHeadersToRecord(options?.headers)
-				},
-				body: JSON.stringify(payload),
-				signal: options?.signal
-			});
-			await options?.onResponse?.({
-				status: response.status,
-				headers: headersToRecord(response.headers)
-			}, model);
-			if (!response.ok) throw createPiMessagesResponseError(model, url, response, await response.text());
-			if (!response.body) throw new Error(`${model.provider} response has no body`);
-			for await (const piEvent of readPiMessagesEvents(response.body)) {
-				await options?.onProviderStreamEvent?.(piEvent, model);
-				const event = convertEvent(piEvent);
-				eventStream.push(event);
-				if (event.type === "done" || event.type === "error") return;
-			}
-			throw new Error(`${model.provider} stream ended without a terminal event`);
-		} catch (error) {
-			eventStream.push(createErrorEvent(model, error, options?.signal?.aborted ?? false));
-		}
-	})();
-	return eventStream;
-};
-const streamSimple = (model, context, options) => {
-	const extra = options;
-	return stream(model, context, {
-		...options,
-		reasoning: options?.reasoning,
-		toolChoice: options?.toolChoice,
-		debug: extra?.debug
-	});
-};
-//#endregion
-export { PiMessagesResponseError, stream, streamSimple };

package/dist/provider-env-BJhgA66g.mjs

@@ -1,37 +0,0 @@
-import { i as __require } from "./bin.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/utils/provider-env.js
-let procEnvCache = null;
-/**
-* Fallback for https://github.com/oven-sh/bun/issues/27802.
-* Bun compiled binaries can expose an empty process.env inside Linux sandboxes
-* even though /proc/self/environ contains the environment.
-*
-* This intentionally duplicates restoreSandboxEnv() in
-* packages/coding-agent/src/bun/restore-sandbox-env.ts. The ai package can be
-* used directly, without going through that entrypoint, so provider env lookup
-* must not depend on process.env having been patched.
-*/
-function getBunSandboxEnvValue(name) {
-	if (typeof process === "undefined" || !process.versions?.bun || Object.keys(process.env).length > 0) return;
-	if (procEnvCache === null) {
-		procEnvCache = /* @__PURE__ */ new Map();
-		try {
-			const { readFileSync } = __require("node:fs");
-			const data = readFileSync("/proc/self/environ", "utf-8");
-			for (const entry of data.split("\0")) {
-				const idx = entry.indexOf("=");
-				if (idx > 0) procEnvCache.set(entry.slice(0, idx), entry.slice(idx + 1));
-			}
-		} catch {}
-	}
-	return procEnvCache.get(name);
-}
-/**
-* Resolve a provider env value from scoped overrides, normal process.env, then
-* the duplicated Bun sandbox fallback for direct pi-ai consumers.
-*/
-function getProviderEnvValue(name, env) {
-	return env?.[name] || (typeof process !== "undefined" ? process.env[name] : void 0) || getBunSandboxEnvValue(name) || void 0;
-}
-//#endregion
-export { getProviderEnvValue as t };

package/dist/provider-retry-DXYM7rVE.mjs

@@ -1,79 +0,0 @@
-//#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/utils/provider-retry.js
-const DEFAULT_MAX_RETRY_DELAY_MS = 6e4;
-function isProviderError(error) {
-	if (!(error instanceof Error) || !("status" in error) || !("headers" in error)) return false;
-	return (error.status === void 0 || typeof error.status === "number") && (error.headers === void 0 || error.headers instanceof Headers);
-}
-/** Mirrors the pinned OpenAI/Anthropic SDK retry policy; review when either SDK is upgraded. */
-function isRetryableProviderError(error) {
-	const shouldRetry = error.headers?.get("x-should-retry");
-	if (shouldRetry === "true") return true;
-	if (shouldRetry === "false") return false;
-	if (error.status === void 0) return true;
-	return error.status === 408 || error.status === 409 || error.status === 429 || typeof error.status === "number" && error.status >= 500;
-}
-function validateServerRetryDelayMs(delayMs, maxRetryDelayMs, providerErrorMessage) {
-	const maxDelayMs = maxRetryDelayMs ?? DEFAULT_MAX_RETRY_DELAY_MS;
-	if (maxDelayMs > 0 && delayMs > maxDelayMs) throw new Error(`Server requested ${Math.ceil(delayMs / 1e3)}s retry delay (max: ${Math.ceil(maxDelayMs / 1e3)}s). ${providerErrorMessage}`);
-	return delayMs;
-}
-function getRetryDelayMs(error, retryIndex, maxRetryDelayMs) {
-	const retryAfterMs = error.headers?.get("retry-after-ms");
-	if (retryAfterMs) {
-		const value = Number.parseFloat(retryAfterMs);
-		if (Number.isFinite(value)) return validateServerRetryDelayMs(value, maxRetryDelayMs, error.message);
-	}
-	const retryAfter = error.headers?.get("retry-after");
-	if (retryAfter) {
-		const seconds = Number.parseFloat(retryAfter);
-		const delayMs = Number.isNaN(seconds) ? Date.parse(retryAfter) - Date.now() : seconds * 1e3;
-		if (Number.isFinite(delayMs)) return validateServerRetryDelayMs(delayMs, maxRetryDelayMs, error.message);
-	}
-	return Math.min(.5 * 2 ** retryIndex, 8) * 1e3 * (1 - Math.random() * .25);
-}
-function createAbortError() {
-	const error = /* @__PURE__ */ new Error("Request aborted");
-	error.name = "AbortError";
-	return error;
-}
-function abortableSleep(ms, signal) {
-	return new Promise((resolve, reject) => {
-		if (signal?.aborted) {
-			reject(createAbortError());
-			return;
-		}
-		const onAbort = () => {
-			clearTimeout(timeout);
-			reject(createAbortError());
-		};
-		const timeout = setTimeout(() => {
-			signal?.removeEventListener("abort", onAbort);
-			resolve();
-		}, Math.max(0, ms));
-		signal?.addEventListener("abort", onAbort, { once: true });
-	});
-}
-/**
-* Reproduce the retry behavior used by the OpenAI and Anthropic SDKs while making
-* their backoff sleep interruptible. Their built-in retry timers ignore the
-* request AbortSignal, so callers must invoke the SDK with `maxRetries: 0` and
-* wrap the request with this helper. Provider-requested delays above
-* `maxRetryDelayMs` fail immediately (60 seconds by default); set it to zero to
-* disable the limit.
-*/
-async function retryProviderRequest(request, options = {}) {
-	const maxRetries = options.maxRetries ?? 0;
-	let retriesRemaining = maxRetries;
-	for (;;) try {
-		return await request();
-	} catch (error) {
-		if (options.signal?.aborted) throw createAbortError();
-		if (retriesRemaining <= 0 || !isProviderError(error) || !isRetryableProviderError(error)) throw error;
-		if (error.status !== void 0 && options.noRetryStatuses?.includes(error.status)) throw error;
-		const retryIndex = maxRetries - retriesRemaining;
-		retriesRemaining--;
-		await abortableSleep(getRetryDelayMs(error, retryIndex, options.maxRetryDelayMs), options.signal);
-	}
-}
-//#endregion
-export { retryProviderRequest as t };