@revojs/ai 0.2.64 → 0.3.0

package/dist/index.d.ts

@@ -821,6 +821,13 @@ export interface ProviderOptions {
 export interface Provider {
     setup: (scope: Scope, options?: ProviderOptions) => Awaitable<ProviderConnection>;
 }
+export declare class ProviderError extends Error {
+    readonly status: number;
+    readonly body: string;
+    readonly retryAfter: number | undefined;
+    constructor(status: number, body: string, retryAfter?: number);
+    get detail(): string;
+}
 export declare class ModelContextProtocolError extends Error {
     readonly code: number;
     readonly data?: JSONValue;
@@ -878,11 +885,26 @@ export declare function mergeHeaders(...headers: Array<Record<string, string | u
 export declare function postJson(url: string, body: unknown, options?: {
     headers?: Record<string, string | undefined>;
     signal?: AbortSignal;
+    retries?: number;
 }): Promise<Response>;
+export declare function toRetryAfter(value: string | null): number | undefined;
+export declare function toolResult(value: JSONValue | object): CallToolResult;
+export declare function toolError(message: string, details?: JSONObject): CallToolResult;
+export declare function generateText(scope: Scope, options: LanguageModelCallOptions & {
+    provider: string;
+    providerOptions?: ProviderOptions;
+}): Promise<{
+    text: string;
+    result: LanguageModelGenerateResult;
+}>;
 export declare function readDataFrames(response: Response): AsyncGenerator<string>;
 export declare function toStream<T>(read: () => AsyncGenerator<T>): ReadableStream<T>;
 export declare const MODEL_CONTEXT_PROTOCOL_VERSIONS: string[];
 export declare const MODEL_CONTEXT_PROTOCOL_TIMEOUT = 60000;
+export declare const PROVIDER_RETRIES = 2;
+export declare const PROVIDER_RETRY_DELAY = 1000;
+export declare const PROVIDER_RETRY_MAX_DELAY = 30000;
+export declare const RETRYABLE_PROVIDER_STATUSES: Set<number>;
 export declare const ModelContextProtocolErrorCode: {
     readonly ParseError: -32700;
     readonly InvalidRequest: -32600;

package/dist/index.js

@@ -6,6 +6,29 @@ import { SERVER_CONTEXT, createServerScope, isResponse, requireSameOrigin, useSe
 import { useVariables } from "revojs";
 import { toJsonSchema } from "revojs/shared";
 //#region src/index.ts
+var ProviderError = class extends Error {
+	status;
+	body;
+	retryAfter;
+	constructor(status, body, retryAfter) {
+		super(`AI provider responded with ${status}: ${body}`);
+		this.name = "ProviderError";
+		this.status = status;
+		this.body = body;
+		this.retryAfter = retryAfter;
+	}
+	get detail() {
+		try {
+			const value = JSON.parse(this.body);
+			if (typeof value === "object" && value !== null) {
+				const nested = "error" in value ? value.error : value;
+				if (typeof nested === "string") return nested;
+				if (typeof nested === "object" && nested !== null && "message" in nested) return String(nested.message);
+			}
+		} catch {}
+		return this.body.replace(/\s+/g, " ").trim();
+	}
+};
 var ModelContextProtocolError = class extends Error {
 	code;
 	data;
@@ -652,14 +675,83 @@ function mergeHeaders(...headers) {
 	return merged;
 }
 async function postJson(url, body, options) {
-	const response = await globalThis.fetch(url, {
-		method: "POST",
-		headers: mergeHeaders({ "Content-Type": "application/json" }, options?.headers),
-		body: JSON.stringify(body),
-		signal: options?.signal
-	});
-	if (!response.ok) throw new Error(`AI provider responded with ${response.status}: ${(await response.text()).slice(0, 500)}`);
-	return response;
+	const retries = options?.retries ?? 2;
+	for (let attempt = 0;; attempt += 1) {
+		const response = await globalThis.fetch(url, {
+			method: "POST",
+			headers: mergeHeaders({ "Content-Type": "application/json" }, options?.headers),
+			body: JSON.stringify(body),
+			signal: options?.signal
+		});
+		if (response.ok) return response;
+		const error = new ProviderError(response.status, (await response.text()).slice(0, 500), toRetryAfter(response.headers.get("Retry-After")));
+		if (attempt >= retries || !RETRYABLE_PROVIDER_STATUSES.has(response.status)) throw error;
+		const retryDelay = Math.min(PROVIDER_RETRY_MAX_DELAY, error.retryAfter ?? 1e3 * 2 ** attempt);
+		if (error.retryAfter !== void 0 && error.retryAfter > 3e4) throw error;
+		const waiting = Promise.withResolvers();
+		const timer = setTimeout(waiting.resolve, retryDelay);
+		options?.signal?.addEventListener("abort", () => {
+			clearTimeout(timer);
+			waiting.reject(options.signal?.reason);
+		}, { once: true });
+		await waiting.promise;
+	}
+}
+function toRetryAfter(value) {
+	if (value === null) return;
+	const seconds = Number(value);
+	if (Number.isFinite(seconds)) return Math.max(0, seconds * 1e3);
+	const date = Date.parse(value);
+	if (Number.isFinite(date)) return Math.max(0, date - Date.now());
+}
+function toolResult(value) {
+	const text = JSON.stringify(value);
+	if (typeof value === "object" && value !== null && !Array.isArray(value)) return {
+		content: [{
+			type: "text",
+			text
+		}],
+		structuredContent: value
+	};
+	return { content: [{
+		type: "text",
+		text
+	}] };
+}
+function toolError(message, details) {
+	if (details) return {
+		content: [{
+			type: "text",
+			text: JSON.stringify({
+				error: message,
+				...details
+			})
+		}],
+		structuredContent: {
+			error: message,
+			...details
+		},
+		isError: true
+	};
+	return {
+		content: [{
+			type: "text",
+			text: message
+		}],
+		isError: true
+	};
+}
+async function generateText(scope, options) {
+	const { provider, providerOptions, ...call } = options;
+	const connection = useAi(scope, { [provider]: providerOptions })[provider];
+	if (connection?.textGenerate === void 0) throw new Error(`Unknown AI provider "${provider}".`);
+	const result = await connection.textGenerate(call);
+	let text = "";
+	for (const part of result.content) if (part.type === "text") text += part.text;
+	return {
+		text: text.trim(),
+		result
+	};
 }
 async function* readDataFrames(response) {
 	const body = response.body;
@@ -719,6 +811,17 @@ var MODEL_CONTEXT_PROTOCOL_VERSIONS = [
 	"2024-11-05"
 ];
 var MODEL_CONTEXT_PROTOCOL_TIMEOUT = 6e4;
+var PROVIDER_RETRIES = 2;
+var PROVIDER_RETRY_DELAY = 1e3;
+var PROVIDER_RETRY_MAX_DELAY = 3e4;
+var RETRYABLE_PROVIDER_STATUSES = /* @__PURE__ */ new Set([
+	429,
+	500,
+	502,
+	503,
+	504,
+	529
+]);
 var ModelContextProtocolErrorCode = {
 	ParseError: -32700,
 	InvalidRequest: -32600,
@@ -735,4 +838,4 @@ var JSON_SCHEMA_DRAFTS = {
 	"http://json-schema.org/draft-04/schema#": "4"
 };
 //#endregion
-export { MODEL_CONTEXT_PROTOCOL_TIMEOUT, MODEL_CONTEXT_PROTOCOL_VERSIONS, ModelContextProtocolClient, ModelContextProtocolConnection, ModelContextProtocolError, ModelContextProtocolErrorCode, defineProvider, defineTool, handleModelContextProtocol, mergeHeaders, modelsDevProtocol, postJson, readDataFrames, toStream, toToolInput, toToolParameters, useAi, useModelContextProtocol, useModelsDev, useTools };
+export { MODEL_CONTEXT_PROTOCOL_TIMEOUT, MODEL_CONTEXT_PROTOCOL_VERSIONS, ModelContextProtocolClient, ModelContextProtocolConnection, ModelContextProtocolError, ModelContextProtocolErrorCode, PROVIDER_RETRIES, PROVIDER_RETRY_DELAY, PROVIDER_RETRY_MAX_DELAY, ProviderError, RETRYABLE_PROVIDER_STATUSES, defineProvider, defineTool, generateText, handleModelContextProtocol, mergeHeaders, modelsDevProtocol, postJson, readDataFrames, toRetryAfter, toStream, toToolInput, toToolParameters, toolError, toolResult, useAi, useModelContextProtocol, useModelsDev, useTools };

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@revojs/ai",
-    "version": "0.2.64",
+    "version": "0.3.0",
     "license": "MIT",
     "repository": {
         "type": "git",
@@ -30,10 +30,10 @@
     },
     "dependencies": {
         "@cfworker/json-schema": "^4.1.1",
-        "@revojs/server": "*",
-        "revojs": "*"
+        "@revojs/server": "0.3.0",
+        "revojs": "0.3.0"
     },
     "devDependencies": {
-        "@revojs/tsconfig": "*"
+        "@revojs/tsconfig": "0.3.0"
     }
 }