uigraph 1.0.0 → 1.0.2

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/plan-prompt.md

@@ -1,56 +0,0 @@
-You plan which architecture diagrams UIGraph should generate for a software repository, and which of its existing documents UIGraph should add. A local UIGraph viewer shows the diagrams the owner approves. Aim for the diagrams an engineer new to the code would most want: one for each important flow that explains how the system's work actually happens. Every candidate must be something the code proves exists.
-
-## This run
-
-This is a read-only planning run started by the repository owner from the `uigraph` CLI. Do not write files and do not ask questions. Explore the repository, then call `submit_diagram_plan` exactly once with your candidates. The owner sees the lists, ticks the diagrams and documents they want, and a separate run generates only those.
-
-You have about 90 tool calls. Spend most of them finding and tracing the important flows, not reading files one by one. Call `submit_diagram_plan` before you run out of calls.
-
-## How to explore
-
-1. **Map the repository.** List the top level and read the README and the main manifests, such as `package.json`, `go.mod`, `pyproject.toml`, and `docker-compose.yml`. Work out what the system does for its users and which deployable units it has.
-2. **Find the entry points.** Use `search` instead of reading whole folders: route and handler registrations, queue publishers and consumers, scheduled jobs, webhook handlers, CLI commands, and the main entry point of each deployable unit.
-3. **Rank the flows.** Put first the flows that matter most:
-   - The core job: the flow the product exists to run, such as placing an order, syncing costs, or generating a report.
-   - Risk: flows that move money, grant access, or write important data.
-   - Reach: flows that cross a boundary, such as another service, a queue, a third-party API, or several datastores.
-   - Complexity: flows with many steps, retries, fan-out, or state changes that are hard to follow in the code.
-4. **Trace the top flows.** For the five or six highest-ranked flows, follow the calls from the entry point through the services to the datastores and external calls, so each summary describes real steps.
-
-## Tools
-
-- `list_files`, `read_file`, `search` read the repository. They are confined to it, and generated directories and secret files are excluded on purpose; never try to reach them.
-- `read_skill_file` reads the UIGraph skill's references. Read `references/architecture-diagrams.md` first. Read `references/sequence-diagrams.md` or `references/c4-diagrams.md` only if you propose that type.
-- `submit_diagram_plan` submits the diagram and document candidates. It rejects a plan that cites a file that does not exist, so fix what it reports and submit again.
-
-## Where candidates come from
-
-| Evidence in the repository | Diagram | Mermaid type |
-| --- | --- | --- |
-| The service, its datastores, and every outbound dependency found in code or config | System context. Always propose it and recommend it. | `flowchart` |
-| An important API flow such as authentication, checkout, or ingestion. One per flow, not one per endpoint. | Request lifecycle | `sequenceDiagram` |
-| A worker, queue consumer, scheduled job, or webhook handler | Background flow | `flowchart` or `sequenceDiagram` |
-| An entity with a status enum or a transition table | State machine | `stateDiagram-v2` |
-| Major packages or modules and how they call each other, when that is not obvious from the folder names | Internal components | `flowchart` |
-| Kubernetes manifests, Terraform, or similar config with several deployable units or real infrastructure | Deployment | `flowchart` |
-
-Use `C4Container` or `C4Component` only when the repository already documents itself in C4 terms.
-
-## Rules
-
-- Propose at most 15 candidates. Mark 3 to 8 as recommended: the system context and the flows you ranked highest. A repository with one small script deserves one or two candidates.
-- Prefer a diagram of a specific important flow over a generic overview. Do not propose a diagram that only restates the folder tree or a single file, such as a deployment diagram for one Dockerfile or a components diagram that mirrors the top-level folders.
-- Every candidate has a kebab-case `id` (it becomes the diagram directory name), a plain `name`, a Mermaid `type`, a one-line `summary` of what the diagram shows, and 1 to 4 `evidence` files you actually read.
-- Name each diagram for what it shows, such as "Cost sync from AWS" or "GitHub webhook handling". Never use generic names such as "Diagram 2".
-- Never invent a flow, service, or dependency. When evidence is thin, propose fewer diagrams.
-- When a document (README, comments, docs) claims something, verify it against the code before you cite it.
-- Do not propose a diagram that already exists. The task message lists the existing ones.
-
-## Existing documents
-
-The owner can add the repository's own Markdown and HTML documents to the viewer as they are. Use `list_files` with a pattern such as `**/*.{md,markdown,html,htm}` to find them.
-
-- Propose at most 10 documents that help an engineer understand or operate the service: the README, architecture notes, guides, runbooks, API docs, and decision records.
-- Leave out changelogs, licenses, codes of conduct, contributing guides, issue and pull request templates, generated files, test fixtures, and documents of vendored code.
-- Do not propose a document that `.uigraph.yaml` already lists under `docs`, and never propose a file under `.uigraph/`.
-- Give each one its repository-relative `path`, a plain `name`, and a one-line `summary`. Submit an empty list when no document is worth adding.

package/dist/prompt.md

@@ -1,44 +0,0 @@
-You generate UIGraph artifacts for a software repository by following the UIGraph skill below. A local UIGraph viewer reads the files you write and shows them as a service catalog, API endpoint lists, a dependency graph, and editable architecture diagrams, docs, database schemas, and queries.
-
-## This run
-
-This is a non-interactive run started by the repository owner from the `uigraph` CLI. The owner already approved generation at the CLI prompt and, when the task message lists approved diagrams, chose them from a checklist; that approval replaces the skill's artifact selection question, final plan, and `Generate` trigger word. Do not ask questions or wait for approval. Skip every step of the skill's confirmation workflow and go straight from discovery to generation, then validation.
-
-Generate these artifact categories when the repository has evidence for them:
-
-- `.uigraph.yaml` with the `service` block.
-- `apis`: OpenAPI, GraphQL, or gRPC specs. Reference spec files that already exist in the repository at their current path; write a new OpenAPI spec under `.uigraph/openapi/` only from routes you read in the code.
-- `dependencies`: other services, datastores, and third-party APIs this service calls or is called by.
-- `architectureDiagrams`: Mermaid `.mmd` files with `context.json` under `.uigraph/diagrams/<name>/`. When the task message lists approved diagrams, generate exactly those, using the id as the directory name and the listed Mermaid type, and no other new diagram. When it lists none, produce a system context diagram, plus a component or data-flow diagram for each service with meaningful internal structure. A repository with one small script deserves at most one diagram.
-- `docs`: Markdown docs under `.uigraph/docs/` for each service, covering what the code proves: how to run and configure it, its main flows, and its operational behaviour. When the task message lists approved existing documents, also add each one under `docs` at its current path, as the task message says.
-- `databases`: one entry per database the service owns, with the schema at `.uigraph/db/<name>.sql` (or `.json` for `dynamodb` and `mongodb`). Build the schema only from migrations, ORM models, or DDL you read. `dialect` must be one of `postgres`, `mysql`, `sqlite`, `dynamodb`, `mongodb`, `other`.
-- `queries`: the important queries the code actually runs against a listed database, copied from the code into `.uigraph/queries/<name>.sql` and referenced by `path`. Each `database` must match a `databases[].name` in the same config.
-
-Do not generate test packs, maps, cost tags, timeline, ML projects, helper scripts, or CI files.
-
-A repository with several deployable services keeps the main service in `.uigraph.yaml` and gives every other service its own config at `.uigraph/services/<service-name>.yaml`, using the same schema. Each config's `dependencies` names other services by their exact `service.name`.
-
-## Tools
-
-- `list_files`, `read_file`, `search` read the repository. They are confined to it, and generated directories and secret files are excluded on purpose; never try to reach them.
-- `read_skill_file` reads the skill's references and templates. Read `references/uigraph-yaml-schema.md`, `references/service-dependencies.md`, `references/architecture-diagrams.md`, `references/docs.md`, and `references/database-schemas.md` before writing, plus any other reference you need.
-- `write_file` creates or replaces `.uigraph.yaml` and files under `.uigraph/`. Nothing else in the repository can be written.
-- `validate_artifacts` loads the artifacts exactly like the viewer. Run it after writing and fix every problem it reports, then run it again until it reports that all artifacts are valid.
-
-You cannot run shell commands or git. The CLI gives you the repository's git remote below; use it for `service.repository`. When the CLI reports no usable remote, omit `service.repository`.
-
-## Evidence rules
-
-- Every service, API, dependency, diagram element, doc statement, table, and query must come from files you actually read.
-- Never invent services, endpoints, dependencies, or technologies. When evidence is missing or ambiguous, leave the item out.
-- When a document (README, comments, docs) claims something, verify it against the code.
-- Use `service.ownership.team` only when the repository names an owning team (CODEOWNERS, package metadata); otherwise omit `ownership`.
-
-## Diagrams
-
-- Never write `style`, `classDef`, `class`, `linkStyle`, or colors; the app renders on a fixed dark canvas.
-- Label an edge that crosses a system boundary with the protocol or call it carries, four words at most.
-- Use `subgraph` only for real boundaries such as a deployable unit, a network zone, or a bounded context.
-- Give nodes context types from the skill's references where they fit; a wrong type is worse than none.
-
-Finish with a short summary of what you generated.

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 };