@revojs/ai 0.1.58

package/dist/index.d.ts

@@ -0,0 +1,617 @@
+import { type Scope, type Source, type SourceScope, type SourceValue } from "revojs";
+import type { JSONObject, JSONValue, JsonSchema } from "revojs/shared";
+export type SharedWarning = {
+    type: "unsupported" | "compatibility";
+    feature: string;
+    details?: string;
+} | {
+    type: "deprecated";
+    setting: string;
+    message: string;
+} | {
+    type: "other";
+    message: string;
+};
+export type SharedFileData = SharedFileDataData | SharedFileDataUrl | SharedFileDataReference | SharedFileDataText;
+export type LanguageModelMessage = ({
+    role: "system";
+    content: string;
+} | {
+    role: "user";
+    content: Array<LanguageModelTextPart | LanguageModelFilePart>;
+} | {
+    role: "assistant";
+    content: Array<LanguageModelTextPart | LanguageModelFilePart | LanguageModelCustomPart | LanguageModelReasoningPart | LanguageModelReasoningFilePart | LanguageModelToolCallPart | LanguageModelToolResultPart>;
+} | {
+    role: "tool";
+    content: Array<LanguageModelToolResultPart | LanguageModelToolApprovalResponsePart>;
+}) & {
+    providerOptions?: Record<string, JSONObject>;
+};
+export type LanguageModelContent = LanguageModelText | LanguageModelReasoning | LanguageModelCustomContent | LanguageModelReasoningFile | LanguageModelFile | LanguageModelToolApprovalRequest | LanguageModelSource | LanguageModelToolCall | LanguageModelToolResult;
+export interface LanguageModelText {
+    type: "text";
+    text: string;
+    providerMetadata?: Record<string, JSONObject>;
+}
+export interface LanguageModelReasoning {
+    type: "reasoning";
+    text: string;
+    providerMetadata?: Record<string, JSONObject>;
+}
+export interface LanguageModelCustomContent {
+    type: "custom";
+    kind: `${string}.${string}`;
+    providerMetadata?: Record<string, JSONObject>;
+}
+export interface LanguageModelReasoningFile {
+    type: "reasoning-file";
+    mediaType: string;
+    data: SharedFileDataData | SharedFileDataUrl;
+    providerMetadata?: Record<string, JSONObject>;
+}
+export interface LanguageModelFile {
+    type: "file";
+    mediaType: string;
+    data: SharedFileDataData | SharedFileDataUrl;
+    providerMetadata?: Record<string, JSONObject>;
+}
+export interface LanguageModelToolApprovalRequest {
+    type: "tool-approval-request";
+    approvalId: string;
+    toolCallId: string;
+    providerMetadata?: Record<string, JSONObject>;
+}
+export type LanguageModelSource = {
+    type: "source";
+    sourceType: "url";
+    id: string;
+    url: string;
+    title?: string;
+    providerMetadata?: Record<string, JSONObject>;
+} | {
+    type: "source";
+    sourceType: "document";
+    id: string;
+    mediaType: string;
+    title: string;
+    fileName?: string;
+    providerMetadata?: Record<string, JSONObject>;
+};
+export interface LanguageModelToolCall {
+    type: "tool-call";
+    toolCallId: string;
+    toolName: string;
+    input: string;
+    providerExecuted?: boolean;
+    dynamic?: boolean;
+    providerMetadata?: Record<string, JSONObject>;
+}
+export interface LanguageModelToolResult {
+    type: "tool-result";
+    toolCallId: string;
+    toolName: string;
+    result: NonNullable<JSONValue>;
+    isError?: boolean;
+    preliminary?: boolean;
+    dynamic?: boolean;
+    providerMetadata?: Record<string, JSONObject>;
+}
+export interface LanguageModelFunctionTool {
+    type: "function";
+    name: string;
+    description?: string;
+    inputSchema: JsonSchema;
+    inputExamples?: Array<{
+        input: JSONObject;
+    }>;
+    strict?: boolean;
+    providerOptions?: Record<string, JSONObject>;
+}
+export interface LanguageModelProviderTool {
+    type: "provider";
+    id: `${string}.${string}`;
+    name: string;
+    args: JSONObject;
+}
+export type LanguageModelToolChoice = {
+    type: "auto";
+} | {
+    type: "none";
+} | {
+    type: "required";
+} | {
+    type: "tool";
+    toolName: string;
+};
+export interface LanguageModelCallOptions<TModel extends string = string> {
+    model: TModel;
+    prompt: Array<LanguageModelMessage>;
+    maxOutputTokens?: number;
+    temperature?: number;
+    stopSequences?: Array<string>;
+    topP?: number;
+    topK?: number;
+    presencePenalty?: number;
+    frequencyPenalty?: number;
+    responseFormat?: {
+        type: "text";
+    } | {
+        type: "json";
+        schema?: JsonSchema;
+        name?: string;
+        description?: string;
+    };
+    seed?: number;
+    tools?: Array<LanguageModelFunctionTool | LanguageModelProviderTool>;
+    toolChoice?: LanguageModelToolChoice;
+    includeRawChunks?: boolean;
+    abortSignal?: AbortSignal;
+    headers?: Record<string, string | undefined>;
+    reasoning?: "provider-default" | "none" | "minimal" | "low" | "medium" | "high" | "xhigh";
+    providerOptions?: Record<string, JSONObject>;
+}
+export interface LanguageModelGenerateResult {
+    content: Array<LanguageModelContent>;
+    finishReason: LanguageModelFinishReason;
+    usage: LanguageModelUsage;
+    providerMetadata?: Record<string, JSONObject>;
+    request?: {
+        body?: unknown;
+    };
+    response?: LanguageModelResponseMetadata & {
+        headers?: Record<string, string>;
+        body?: unknown;
+    };
+    warnings: Array<SharedWarning>;
+}
+export interface LanguageModelStreamResult {
+    stream: ReadableStream<LanguageModelStreamPart>;
+    request?: {
+        body?: unknown;
+    };
+    response?: {
+        headers?: Record<string, string>;
+    };
+}
+export interface LanguageModelFinishReason {
+    unified: "stop" | "length" | "content-filter" | "tool-calls" | "error" | "other";
+    raw: string | undefined;
+}
+export interface LanguageModelUsage {
+    inputTokens: {
+        total: number | undefined;
+        noCache: number | undefined;
+        cacheRead: number | undefined;
+        cacheWrite: number | undefined;
+    };
+    outputTokens: {
+        total: number | undefined;
+        text: number | undefined;
+        reasoning: number | undefined;
+    };
+    raw?: JSONObject;
+}
+export type LanguageModelToolResultOutput = {
+    type: "text";
+    value: string;
+    providerOptions?: Record<string, JSONObject>;
+} | {
+    type: "json";
+    value: JSONValue;
+    providerOptions?: Record<string, JSONObject>;
+} | {
+    type: "execution-denied";
+    reason?: string;
+    providerOptions?: Record<string, JSONObject>;
+} | {
+    type: "error-text";
+    value: string;
+    providerOptions?: Record<string, JSONObject>;
+} | {
+    type: "error-json";
+    value: JSONValue;
+    providerOptions?: Record<string, JSONObject>;
+} | {
+    type: "content";
+    value: Array<LanguageModelTextPart | LanguageModelFilePart | {
+        type: "custom";
+        providerOptions?: Record<string, JSONObject>;
+    }>;
+};
+export type LanguageModelStreamPart = {
+    type: "text-start";
+    providerMetadata?: Record<string, JSONObject>;
+    id: string;
+} | {
+    type: "text-delta";
+    id: string;
+    providerMetadata?: Record<string, JSONObject>;
+    delta: string;
+} | {
+    type: "text-end";
+    providerMetadata?: Record<string, JSONObject>;
+    id: string;
+} | {
+    type: "reasoning-start";
+    providerMetadata?: Record<string, JSONObject>;
+    id: string;
+} | {
+    type: "reasoning-delta";
+    id: string;
+    providerMetadata?: Record<string, JSONObject>;
+    delta: string;
+} | {
+    type: "reasoning-end";
+    id: string;
+    providerMetadata?: Record<string, JSONObject>;
+} | {
+    type: "tool-input-start";
+    id: string;
+    toolName: string;
+    providerMetadata?: Record<string, JSONObject>;
+    providerExecuted?: boolean;
+    dynamic?: boolean;
+    title?: string;
+} | {
+    type: "tool-input-delta";
+    id: string;
+    delta: string;
+    providerMetadata?: Record<string, JSONObject>;
+} | {
+    type: "tool-input-end";
+    id: string;
+    providerMetadata?: Record<string, JSONObject>;
+} | LanguageModelToolApprovalRequest | LanguageModelToolCall | LanguageModelToolResult | LanguageModelCustomContent | LanguageModelFile | LanguageModelReasoningFile | LanguageModelSource | {
+    type: "stream-start";
+    warnings: Array<SharedWarning>;
+} | ({
+    type: "response-metadata";
+} & LanguageModelResponseMetadata) | {
+    type: "finish";
+    usage: LanguageModelUsage;
+    finishReason: LanguageModelFinishReason;
+    providerMetadata?: Record<string, JSONObject>;
+} | {
+    type: "raw";
+    rawValue: unknown;
+} | {
+    type: "error";
+    error: unknown;
+};
+export interface EmbeddingModelCallOptions<TModel extends string = string> {
+    model: TModel;
+    values: Array<string>;
+    abortSignal?: AbortSignal;
+    providerOptions?: Record<string, JSONObject>;
+    headers?: Record<string, string>;
+}
+export interface EmbeddingModelResult {
+    embeddings: Array<Array<number>>;
+    usage?: {
+        tokens: number;
+    };
+    providerMetadata?: Record<string, JSONObject>;
+    response?: {
+        headers?: Record<string, string>;
+        body?: unknown;
+    };
+    warnings: Array<SharedWarning>;
+}
+export type ImageModelFile = {
+    type: "file";
+    mediaType: string;
+    data: string | Uint8Array;
+    providerOptions?: Record<string, JSONObject>;
+} | {
+    type: "url";
+    url: string;
+    providerOptions?: Record<string, JSONObject>;
+};
+export interface ImageModelCallOptions<TModel extends string = string> {
+    model: TModel;
+    prompt: string | undefined;
+    n: number;
+    size: `${number}x${number}` | undefined;
+    aspectRatio: `${number}:${number}` | undefined;
+    seed: number | undefined;
+    files: Array<ImageModelFile> | undefined;
+    mask: ImageModelFile | undefined;
+    providerOptions: Record<string, JSONObject>;
+    abortSignal?: AbortSignal;
+    headers?: Record<string, string | undefined>;
+}
+export interface ImageModelResult {
+    images: Array<string> | Array<Uint8Array>;
+    warnings: Array<SharedWarning>;
+    providerMetadata?: Record<string, {
+        images: Array<JSONValue>;
+    } & JSONValue>;
+    response: {
+        timestamp: Date;
+        modelId: string;
+        headers: Record<string, string> | undefined;
+    };
+    usage?: {
+        inputTokens: number | undefined;
+        outputTokens: number | undefined;
+        totalTokens: number | undefined;
+    };
+}
+export interface RerankingModelCallOptions<TModel extends string = string> {
+    model: TModel;
+    documents: {
+        type: "text";
+        values: Array<string>;
+    } | {
+        type: "object";
+        values: Array<JSONObject>;
+    };
+    query: string;
+    topN?: number;
+    abortSignal?: AbortSignal;
+    providerOptions?: Record<string, JSONObject>;
+    headers?: Record<string, string>;
+}
+export interface RerankingModelResult {
+    ranking: Array<{
+        index: number;
+        relevanceScore: number;
+    }>;
+    providerMetadata?: Record<string, JSONObject>;
+    warnings?: Array<SharedWarning>;
+    response?: {
+        id?: string;
+        timestamp?: Date;
+        modelId?: string;
+        headers?: Record<string, string>;
+        body?: unknown;
+    };
+}
+export interface SpeechModelCallOptions<TModel extends string = string> {
+    model: TModel;
+    text: string;
+    voice?: string;
+    outputFormat?: string;
+    instructions?: string;
+    speed?: number;
+    language?: string;
+    providerOptions?: Record<string, JSONObject>;
+    abortSignal?: AbortSignal;
+    headers?: Record<string, string | undefined>;
+}
+export interface SpeechModelResult {
+    audio: string | Uint8Array;
+    warnings: Array<SharedWarning>;
+    request?: {
+        body?: unknown;
+    };
+    response: {
+        timestamp: Date;
+        modelId: string;
+        headers?: Record<string, string>;
+        body?: unknown;
+    };
+    providerMetadata?: Record<string, JSONObject>;
+}
+export interface TranscriptionModelCallOptions<TModel extends string = string> {
+    model: TModel;
+    audio: Uint8Array | string;
+    mediaType: string;
+    providerOptions?: Record<string, JSONObject>;
+    abortSignal?: AbortSignal;
+    headers?: Record<string, string | undefined>;
+}
+export interface TranscriptionModelResult {
+    text: string;
+    segments: Array<{
+        text: string;
+        startSecond: number;
+        endSecond: number;
+    }>;
+    language: string | undefined;
+    durationInSeconds: number | undefined;
+    warnings: Array<SharedWarning>;
+    request?: {
+        body?: string;
+    };
+    response: {
+        timestamp: Date;
+        modelId: string;
+        headers?: Record<string, string>;
+        body?: unknown;
+    };
+    providerMetadata?: Record<string, JSONObject>;
+}
+export interface TranscriptionModelStreamOptions<TModel extends string = string> {
+    model: TModel;
+    audio: ReadableStream<Uint8Array | string>;
+    inputAudioFormat: {
+        type: string;
+        rate?: number;
+    };
+    providerOptions?: Record<string, JSONObject>;
+    abortSignal?: AbortSignal;
+    headers?: Record<string, string | undefined>;
+    includeRawChunks?: boolean;
+}
+export type TranscriptionModelStreamPart = {
+    type: "stream-start";
+    warnings: Array<SharedWarning>;
+} | {
+    type: "transcript-delta";
+    id?: string;
+    delta: string;
+    providerMetadata?: Record<string, JSONObject>;
+} | {
+    type: "transcript-partial";
+    id?: string;
+    text: string;
+    startSecond?: number;
+    durationInSeconds?: number;
+    channelIndex?: number;
+    providerMetadata?: Record<string, JSONObject>;
+} | {
+    type: "transcript-final";
+    id?: string;
+    text: string;
+    startSecond?: number;
+    endSecond?: number;
+    channelIndex?: number;
+    providerMetadata?: Record<string, JSONObject>;
+} | {
+    type: "response-metadata";
+    timestamp?: Date;
+    modelId?: string;
+    headers?: Record<string, string>;
+    body?: unknown;
+} | {
+    type: "finish";
+    text: string;
+    segments: Array<{
+        text: string;
+        startSecond: number;
+        endSecond: number;
+    }>;
+    language?: string;
+    durationInSeconds?: number;
+    providerMetadata?: Record<string, JSONObject>;
+} | {
+    type: "raw";
+    rawValue: unknown;
+} | {
+    type: "error";
+    error: unknown;
+};
+export interface TranscriptionModelStreamResult {
+    stream: ReadableStream<TranscriptionModelStreamPart>;
+    request?: {
+        body?: unknown;
+    };
+    response?: {
+        timestamp?: Date;
+        modelId?: string;
+        headers?: Record<string, string>;
+        body?: unknown;
+    };
+}
+export interface FilesUploadFileCallOptions {
+    data: SharedFileDataData | SharedFileDataText;
+    mediaType: string;
+    fileName?: string;
+    providerOptions?: Record<string, JSONObject>;
+}
+export interface FilesUploadFileResult {
+    providerReference: Record<string, string>;
+    mediaType?: string;
+    fileName?: string;
+    providerMetadata?: Record<string, JSONObject>;
+    warnings: Array<SharedWarning>;
+}
+export type LanguageModelTextPart = Omit<LanguageModelText, "providerMetadata"> & {
+    providerOptions?: Record<string, JSONObject>;
+};
+export type LanguageModelReasoningPart = Omit<LanguageModelReasoning, "providerMetadata"> & {
+    providerOptions?: Record<string, JSONObject>;
+};
+export type LanguageModelReasoningFilePart = Omit<LanguageModelReasoningFile, "providerMetadata"> & {
+    providerOptions?: Record<string, JSONObject>;
+};
+export type LanguageModelCustomPart = Omit<LanguageModelCustomContent, "providerMetadata"> & {
+    providerOptions?: Record<string, JSONObject>;
+};
+export type LanguageModelFilePart = Omit<LanguageModelFile, "providerMetadata" | "data"> & {
+    data: SharedFileData;
+    fileName?: string;
+    providerOptions?: Record<string, JSONObject>;
+};
+export type Protocol<TOptions, TResult> = (options: TOptions) => PromiseLike<TResult>;
+export interface ProviderConnection {
+    textGenerate?: Record<string, Protocol<LanguageModelCallOptions, LanguageModelGenerateResult>>;
+    textStream?: Record<string, Protocol<LanguageModelCallOptions, LanguageModelStreamResult>>;
+    embed?: Record<string, Protocol<EmbeddingModelCallOptions, EmbeddingModelResult>>;
+    imageGenerate?: Record<string, Protocol<ImageModelCallOptions, ImageModelResult>>;
+    transcribe?: Record<string, Protocol<TranscriptionModelCallOptions, TranscriptionModelResult>>;
+    transcribeStream?: Record<string, Protocol<TranscriptionModelStreamOptions, TranscriptionModelStreamResult>>;
+    speechGenerate?: Record<string, Protocol<SpeechModelCallOptions, SpeechModelResult>>;
+    rerank?: Record<string, Protocol<RerankingModelCallOptions, RerankingModelResult>>;
+    uploadFile?: (options: FilesUploadFileCallOptions) => PromiseLike<FilesUploadFileResult>;
+    uploadSkill?: (options: SkillsUploadSkillCallOptions) => PromiseLike<SkillsUploadSkillResult>;
+}
+export type AiConnection<TConnection extends ProviderConnection> = {
+    [TKey in keyof TConnection & string]: NonNullable<TConnection[TKey]> extends Record<string, Protocol<infer TOptions, infer TResult>> ? (options: TOptions) => Promise<TResult> : TConnection[TKey];
+};
+export type AiConnections<TSource extends Source<Provider>> = {
+    [TPackage in SourceScope<TSource>]: {
+        [TProvider in SourceValue<TSource, TPackage>]: AiConnection<Awaited<ReturnType<Awaited<ReturnType<TSource[TPackage][TProvider]>>["setup"]>>>;
+    };
+}[SourceScope<TSource>];
+export interface SharedFileDataData {
+    type: "data";
+    data: Uint8Array | string;
+}
+export interface SharedFileDataUrl {
+    type: "url";
+    url: URL;
+}
+export interface SharedFileDataReference {
+    type: "reference";
+    reference: Record<string, string>;
+}
+export interface SharedFileDataText {
+    type: "text";
+    text: string;
+}
+export interface LanguageModelResponseMetadata {
+    id?: string;
+    timestamp?: Date;
+    modelId?: string;
+}
+export interface LanguageModelToolCallPart {
+    type: "tool-call";
+    toolCallId: string;
+    toolName: string;
+    input: unknown;
+    providerExecuted?: boolean;
+    providerOptions?: Record<string, JSONObject>;
+}
+export interface LanguageModelToolResultPart {
+    type: "tool-result";
+    toolCallId: string;
+    toolName: string;
+    output: LanguageModelToolResultOutput;
+    providerOptions?: Record<string, JSONObject>;
+}
+export interface LanguageModelToolApprovalResponsePart {
+    type: "tool-approval-response";
+    approvalId: string;
+    approved: boolean;
+    reason?: string;
+    providerOptions?: Record<string, JSONObject>;
+}
+export interface SkillsFile {
+    path: string;
+    data: SharedFileDataData | SharedFileDataText;
+}
+export interface SkillsUploadSkillCallOptions {
+    files: Array<SkillsFile>;
+    displayTitle?: string;
+    providerOptions?: Record<string, JSONObject>;
+}
+export interface SkillsUploadSkillResult {
+    providerReference: Record<string, string>;
+    displayTitle?: string;
+    name?: string;
+    description?: string;
+    latestVersion?: string;
+    providerMetadata?: Record<string, JSONObject>;
+    warnings: Array<SharedWarning>;
+}
+export interface Provider {
+    setup: (scope: Scope) => ProviderConnection;
+}
+export declare function defineProvider<TProvider extends Provider>(provider: TProvider): TProvider;
+export declare function useAi<TSource extends Source<Provider> = typeof import("#providers").default>(scope: Scope): AiConnections<TSource>;
+export declare function mergeHeaders(...headers: Array<Record<string, string | undefined> | undefined>): Record<string, string>;
+export declare function readDataFrames(response: Response): AsyncGenerator<string>;
+export declare function toStream<T>(read: () => AsyncGenerator<T>): ReadableStream<T>;

package/dist/index.js

@@ -0,0 +1,76 @@
+import providers from "#providers";
+import "revojs";
+//#region src/index.ts
+function defineProvider(provider) {
+	return provider;
+}
+function useAi(scope) {
+	const names = [...new Set(Object.values(providers).flatMap((entries) => Object.keys(entries)))].sort();
+	const connect = async (name) => {
+		const resolves = Object.values(providers).map((entries) => entries[name]).filter((resolve) => resolve !== void 0);
+		if (resolves.length === 0) throw new Error(`Unknown AI provider "${name}". Built-in providers: ${names.join(", ")}. Add ./providers/${name}.ts for custom ones.`);
+		return resolves[0]().then((provider) => provider.setup(scope));
+	};
+	const invoke = async (name, capability, options) => {
+		const models = (await connect(name))[capability];
+		if (models === void 0) throw new Error(`AI provider "${name}" does not support "${capability}".`);
+		if (typeof models === "function") return models(options);
+		const { model } = options;
+		const protocol = models[model];
+		if (protocol === void 0) throw new Error(`Unknown AI model "${model}". Available models: ${Object.keys(models).sort().join(", ")}.`);
+		return protocol(options);
+	};
+	const provide = (name) => ({
+		textGenerate: (options) => invoke(name, "textGenerate", options),
+		textStream: (options) => invoke(name, "textStream", options),
+		embed: (options) => invoke(name, "embed", options),
+		imageGenerate: (options) => invoke(name, "imageGenerate", options),
+		transcribe: (options) => invoke(name, "transcribe", options),
+		transcribeStream: (options) => invoke(name, "transcribeStream", options),
+		speechGenerate: (options) => invoke(name, "speechGenerate", options),
+		rerank: (options) => invoke(name, "rerank", options),
+		uploadFile: (options) => invoke(name, "uploadFile", options),
+		uploadSkill: (options) => invoke(name, "uploadSkill", options)
+	});
+	return Object.fromEntries(names.map((name) => [name, provide(name)]));
+}
+function mergeHeaders(...headers) {
+	const merged = {};
+	for (const record of headers) for (const [name, value] of Object.entries(record ?? {})) if (value !== void 0) merged[name] = value;
+	return merged;
+}
+async function* readDataFrames(response) {
+	const body = response.body;
+	if (!body) throw new Error("AI provider response has no body");
+	const decoder = new TextDecoder();
+	let buffer = "";
+	for await (const chunk of body) {
+		buffer += decoder.decode(chunk, { stream: true });
+		const frames = buffer.split(/\r?\n\r?\n/);
+		buffer = frames.pop() ?? "";
+		for (const frame of frames) for (const line of frame.split(/\r?\n/)) if (line.startsWith("data:")) yield line.slice(5).trim();
+	}
+}
+function toStream(read) {
+	const iterator = read();
+	let cancelled = false;
+	return new ReadableStream({
+		async pull(controller) {
+			try {
+				const result = await iterator.next();
+				if (!cancelled && !result.done) controller.enqueue(result.value);
+				else if (!cancelled) controller.close();
+			} catch (error) {
+				if (!cancelled) controller.error(error);
+			}
+		},
+		async cancel() {
+			cancelled = true;
+			try {
+				await iterator.return?.(void 0);
+			} catch {}
+		}
+	});
+}
+//#endregion
+export { defineProvider, mergeHeaders, readDataFrames, toStream, useAi };

package/dist/module/index.d.ts

@@ -0,0 +1,3 @@
+export type AiConfig = Record<string, never>;
+declare const _default: import("revojs/module").Module<"ai", AiConfig, []>;
+export default _default;