@voltro/ai 0.1.0

package/dist/provider-BOC5wBxx.js

@@ -0,0 +1,294 @@
+import { anthropic as e, createAnthropic as t } from "@ai-sdk/anthropic";
+import { createOpenAI as n, openai as r } from "@ai-sdk/openai";
+import { createGateway as i, gateway as a } from "@ai-sdk/gateway";
+import { defaultSettingsMiddleware as o, extractReasoningMiddleware as s, simulateStreamingMiddleware as c, wrapLanguageModel as l } from "ai";
+//#region src/middleware.ts
+var u = [], d = (...e) => {
+	let t = u;
+	return u = e, t;
+}, f = () => u, p = () => {
+	u = [];
+}, m = (e, t) => {
+	let n = t === void 0 ? [] : Array.isArray(t) ? t : [t], r = [...u, ...n];
+	return r.length === 0 ? e : l({
+		model: e,
+		middleware: r
+	});
+}, h = (e) => {
+	let t = e?.log ?? ((e) => console.log(`[ai] ${e.phase} model=${e.model}`, e.usage ?? ""));
+	return {
+		wrapGenerate: async ({ doGenerate: e, model: n }) => {
+			let r = await e();
+			return t({
+				phase: "generate",
+				model: n.modelId,
+				usage: r.usage
+			}), r;
+		},
+		wrapStream: async ({ doStream: e, model: n }) => (t({
+			phase: "stream",
+			model: n.modelId
+		}), e())
+	};
+}, g = {
+	inputTokens: {
+		total: 0,
+		noCache: 0,
+		cacheRead: 0,
+		cacheWrite: 0
+	},
+	outputTokens: {
+		total: 0,
+		text: 0,
+		reasoning: 0
+	}
+}, _ = (e) => ({
+	unified: e,
+	raw: void 0
+}), v = class {
+	turns;
+	cursor = 0;
+	calls = [];
+	constructor(e) {
+		this.turns = e.length > 0 ? e : [{ text: "" }];
+	}
+	record(e, t) {
+		this.calls.push({
+			prompt: e,
+			tools: t
+		});
+	}
+	next() {
+		let e = this.turns[Math.min(this.cursor, this.turns.length - 1)];
+		return this.cursor += 1, e;
+	}
+	reset() {
+		this.cursor = 0, this.calls.length = 0;
+	}
+}, y = (e) => (e.toolCalls ?? []).map((e, t) => ({
+	type: "tool-call",
+	toolCallId: `mock_tool_${t}`,
+	toolName: e.name,
+	input: JSON.stringify(e.input ?? {})
+})), b = (e) => (e.sources ?? []).map((e, t) => e.sourceType === "document" ? {
+	type: "source",
+	sourceType: "document",
+	id: e.id ?? `mock_src_${t}`,
+	mediaType: e.mediaType ?? "application/pdf",
+	title: e.title ?? "document",
+	...e.filename === void 0 ? {} : { filename: e.filename }
+} : {
+	type: "source",
+	sourceType: "url",
+	id: e.id ?? `mock_src_${t}`,
+	url: e.url ?? "https://example.com",
+	...e.title === void 0 ? {} : { title: e.title }
+}), x = (e) => (e.files ?? []).map((e) => ({
+	type: "file",
+	mediaType: e.mediaType,
+	data: {
+		type: "data",
+		data: e.data
+	}
+})), S = (e) => [
+	{
+		type: "text-start",
+		id: "0"
+	},
+	...e.split(/(\s+)/).filter((e) => e.length > 0).map((e) => ({
+		type: "text-delta",
+		id: "0",
+		delta: e
+	})),
+	{
+		type: "text-end",
+		id: "0"
+	}
+], C = (e) => e.length === 0 ? [] : [
+	{
+		type: "reasoning-start",
+		id: "r0"
+	},
+	{
+		type: "reasoning-delta",
+		id: "r0",
+		delta: e
+	},
+	{
+		type: "reasoning-end",
+		id: "r0"
+	}
+], w = (e, t, n, r) => ({
+	specificationVersion: "v4",
+	provider: "mock",
+	modelId: e,
+	supportedUrls: {},
+	doGenerate: async ({ prompt: i, tools: a }) => {
+		n?.record(i, (a ?? []).map((e) => e.name ?? ""));
+		let o = n?.next();
+		if (o?.error) throw Error(o.error.message);
+		let s = JSON.stringify(i).slice(0, 80), c = o?.toolCalls ?? [];
+		return c.length > 0 ? {
+			content: c.map((e, t) => ({
+				type: "tool-call",
+				toolCallId: `mock_tool_${t}`,
+				toolName: e.name,
+				input: JSON.stringify(e.input ?? {})
+			})),
+			finishReason: _("tool-calls"),
+			usage: g,
+			warnings: []
+		} : {
+			content: [{
+				type: "text",
+				text: o?.text ?? t ?? `[mock(${e})] ${s}`
+			}],
+			finishReason: _("stop"),
+			usage: g,
+			warnings: [],
+			...r === void 0 ? {} : { providerMetadata: r }
+		};
+	},
+	doStream: async ({ prompt: e, tools: r }) => {
+		n?.record(e, (r ?? []).map((e) => e.name ?? ""));
+		let i = n?.next(), a = (i?.toolCalls?.length ?? 0) > 0, o = i?.text ?? (n ? "" : t ?? "[mock] streamed response"), s = [{
+			type: "stream-start",
+			warnings: []
+		}];
+		return i?.error ? (s.push({
+			type: "error",
+			error: Error(i.error.message)
+		}), s.push({
+			type: "finish",
+			finishReason: _("error"),
+			usage: g
+		})) : (s.push(...C(i?.reasoning ?? "")), o.length > 0 && s.push(...S(o)), s.push(...b(i ?? {})), s.push(...x(i ?? {})), s.push(...y(i ?? {})), s.push({
+			type: "finish",
+			finishReason: _(a ? "tool-calls" : "stop"),
+			usage: g
+		})), { stream: new ReadableStream({ start(e) {
+			for (let t of s) e.enqueue(t);
+			e.close();
+		} }) };
+	}
+}), T = "iVBORw0KGgo=", E = "SUQzBAAAAAAAAA==", D = "video/mp4", O = (e, t) => ({
+	specificationVersion: "v4",
+	provider: "mock",
+	modelId: e,
+	maxImagesPerCall: 8,
+	doGenerate: async ({ n }) => ({
+		images: Array.from({ length: Math.max(1, n) }, () => t),
+		warnings: [],
+		response: {
+			timestamp: /* @__PURE__ */ new Date(),
+			modelId: e,
+			headers: void 0
+		},
+		usage: {
+			inputTokens: 0,
+			outputTokens: 0,
+			totalTokens: 0
+		}
+	})
+}), k = (e, t, n) => ({
+	specificationVersion: "v4",
+	provider: "mock",
+	modelId: e,
+	doGenerate: async () => ({
+		audio: t,
+		warnings: [],
+		response: {
+			timestamp: /* @__PURE__ */ new Date(),
+			modelId: e
+		},
+		...n === void 0 ? {} : { providerMetadata: n }
+	})
+}), A = (e, t, n) => ({
+	specificationVersion: "v4",
+	provider: "mock",
+	modelId: e,
+	maxVideosPerCall: 1,
+	doGenerate: async () => ({
+		videos: [t],
+		warnings: [],
+		response: {
+			timestamp: /* @__PURE__ */ new Date(),
+			modelId: e,
+			headers: void 0
+		},
+		...n === void 0 ? {} : { providerMetadata: n }
+	})
+}), j = (e) => e.apiKey !== void 0 || e.baseURL !== void 0, M = (e) => ({
+	...e.apiKey === void 0 ? {} : { apiKey: e.apiKey },
+	...e.baseURL === void 0 ? {} : { baseURL: e.baseURL }
+}), N = (o, s) => m((() => {
+	switch (o.name) {
+		case "mock": return w(o.model ?? "mock", o.mockText, o.script, o.providerMetadata);
+		case "anthropic": return j(o) ? t(M(o))(o.model) : e(o.model);
+		case "openai": return j(o) ? n(M(o))(o.model) : r(o.model);
+		case "gateway": return j(o) ? i(M(o))(o.model) : a(o.model);
+	}
+})(), s), P = (e) => {
+	switch (e.name) {
+		case "mock": return O(e.model ?? "mock", e.mockMedia?.imageBase64 ?? T);
+		case "openai": return j(e) ? n(M(e)).image(e.model) : r.image(e.model);
+		case "gateway": return j(e) ? i(M(e)).image(e.model) : a.image(e.model);
+		case "anthropic": throw Error("Provider 'anthropic' does not support image generation. Use 'openai' or 'gateway'.");
+	}
+}, F = (e) => {
+	switch (e.name) {
+		case "mock": return k(e.model ?? "mock", e.mockMedia?.audioBase64 ?? E, e.providerMetadata);
+		case "openai": return j(e) ? n(M(e)).speech(e.model) : r.speech(e.model);
+		case "gateway": return j(e) ? i(M(e)).speech(e.model) : a.speech(e.model);
+		case "anthropic": throw Error("Provider 'anthropic' does not support speech generation. Use 'openai' or 'gateway'.");
+	}
+}, I = (e) => {
+	switch (e.name) {
+		case "mock": {
+			let t = e.mockMedia, n = t?.videoBase64 === void 0 ? {
+				type: "url",
+				url: t?.videoUrl ?? `https://mock.local/${e.model ?? "mock"}.mp4`,
+				mediaType: D
+			} : {
+				type: "base64",
+				data: t.videoBase64,
+				mediaType: D
+			};
+			return A(e.model ?? "mock", n, e.providerMetadata);
+		}
+		case "gateway": return j(e) ? i(M(e)).video(e.model) : a.video(e.model);
+		case "openai": throw Error("Provider 'openai' does not support video generation. Use 'gateway'.");
+		case "anthropic": throw Error("Provider 'anthropic' does not support video generation. Use 'gateway'.");
+	}
+}, L = null, R = (e) => {
+	let t = L;
+	return L = e, t;
+}, z = () => L, B = (e = process.env) => {
+	if (L) return L;
+	let t = (e.AI_PROVIDER ?? "mock").toLowerCase(), n = e.AI_MODEL;
+	switch (t) {
+		case "mock": return {
+			name: "mock",
+			model: n ?? "mock"
+		};
+		case "anthropic": return {
+			name: "anthropic",
+			model: n ?? "claude-opus-4-8"
+		};
+		case "openai": return {
+			name: "openai",
+			model: n ?? "gpt-5.5"
+		};
+		case "gateway": {
+			let e = n === void 0 ? -1 : n.indexOf("/");
+			if (n === void 0 || e <= 0 || e === n.length - 1) throw Error("AI_PROVIDER=gateway requires AI_MODEL set to a 'creator/model' id, e.g. 'openai/gpt-5.5'");
+			return {
+				name: "gateway",
+				model: n
+			};
+		}
+		default: throw Error(`Unknown AI_PROVIDER '${t}'. Expected one of: mock, anthropic, openai, gateway.`);
+	}
+};
+//#endregion
+export { N as a, R as c, o as d, s as f, c as g, d as h, P as i, m as l, h as m, z as n, F as o, f as p, B as r, I as s, v as t, p as u };

package/dist/test.d.ts

@@ -0,0 +1,125 @@
+/** A `MockAi` — the optional injected interface `makeTestContext` accepts.
+ *  Structurally compatible with `@voltro/testing`'s `MockAi` (no hard dep
+ *  in either direction). */
+export declare interface MockAi {
+    readonly generate?: (...args: ReadonlyArray<unknown>) => unknown;
+    readonly generateObject?: (...args: ReadonlyArray<unknown>) => unknown;
+    /** Recorded model calls (prompt + tool names), for assertions. */
+    readonly calls: ReadonlyArray<{
+        readonly prompt: unknown;
+        readonly tools: ReadonlyArray<string>;
+    }>;
+    /** Restore the previous provider override. */
+    reset(): void;
+}
+
+/**
+ * Build a `MockAi` value AND install the provider override, so
+ * `makeTestContext({ ai: mockAi({...}) })` covers both the injected `ctx.ai`
+ * path and the free-function (`generateText`/`streamText`) path.
+ */
+export declare const mockAi: (fixture?: MockAiFixture) => MockAi;
+
+/** The fixture shape `useMockAi` / `mockAi` accept. Every field is optional;
+ *  supply only what the test under exercise needs. */
+export declare interface MockAiFixture {
+    /** Canned `generateText` / `ctx.ai.generate` output. */
+    readonly generate?: {
+        readonly text: string;
+    };
+    /** Canned `generateObject` / `ctx.ai.generateObject` output. */
+    readonly generateObject?: {
+        readonly object: unknown;
+    };
+    /** `streamText` word/chunk sequence (drives token deltas + the free
+     *  `generateText` mock text on the first turn). */
+    readonly stream?: ReadonlyArray<string>;
+    /** Scripted tool-call → text turns for the SDK tool loop. Each turn is one
+     *  `doStream`/`doGenerate` call. Takes precedence over `stream`. */
+    readonly turns?: ReadonlyArray<MockTurn>;
+    /** Mock model id reported on the override. Default `'mock'`. */
+    readonly model?: string;
+}
+
+/** A scripted inline file the mock model emits on a turn (usually an image).
+ *  `data` is base64 (a short ascii string works for assertions). */
+declare interface MockFile {
+    readonly mediaType: string;
+    readonly data: string;
+}
+
+/** A consumable sequence of model turns, plus a recorder for asserting on
+ *  what the model was asked. Each `doGenerate`/`doStream` advances the
+ *  cursor by one turn; running past the end repeats the last turn's text
+ *  (or empties) so a loop that over-steps doesn't hang. */
+declare class MockScript {
+    private readonly turns;
+    private cursor;
+    readonly calls: Array<{
+        readonly prompt: unknown;
+        readonly tools: ReadonlyArray<string>;
+    }>;
+    constructor(turns: ReadonlyArray<MockTurn>);
+    record(prompt: unknown, tools: ReadonlyArray<string>): void;
+    next(): MockTurn;
+    reset(): void;
+}
+
+/** A scripted citation the mock model emits on a turn (RAG grounding). */
+declare interface MockSource {
+    readonly sourceType?: 'url' | 'document';
+    readonly id?: string;
+    readonly url?: string;
+    readonly title?: string;
+    readonly mediaType?: string;
+    readonly filename?: string;
+}
+
+/** A scripted tool call the mock model emits on a turn. */
+declare interface MockToolCall {
+    readonly name: string;
+    readonly input: unknown;
+}
+
+/** One model turn. A turn can carry text (streamed word-by-word), scripted
+ *  tool calls (which trigger the SDK's tool loop), cited sources, inline files,
+ *  or an error. A turn with tool calls + no text drives one LLM↔tool
+ *  round-trip. */
+declare interface MockTurn {
+    readonly text?: string;
+    /** Reasoning ("thinking") the mock streams before the answer text. */
+    readonly reasoning?: string;
+    readonly toolCalls?: ReadonlyArray<MockToolCall>;
+    readonly sources?: ReadonlyArray<MockSource>;
+    readonly files?: ReadonlyArray<MockFile>;
+    readonly error?: {
+        readonly message: string;
+    };
+}
+
+/**
+ * A test helper: a function that throws the first `n` times it's called, then
+ * returns `value`. For exercising retry paths (`Effect.retry`, the SDK's
+ * tool-output retry) deterministically.
+ *
+ * ```ts
+ * const flaky = throwNTimes(2, 'ok')
+ * flaky() // throws
+ * flaky() // throws
+ * flaky() // 'ok'
+ * ```
+ */
+export declare const throwNTimes: <T>(n: number, value: T, error?: (attempt: number) => unknown) => (() => T);
+
+/**
+ * Install a mock provider override for the duration of a test. Returns the
+ * recorded `calls` array (model prompt + tool names) + a `reset()` that
+ * restores the previous override. Use in `beforeEach` + `reset()` in
+ * `afterEach`.
+ */
+export declare const useMockAi: (fixture: MockAiFixture) => {
+    readonly calls: MockScript["calls"];
+    reset(): void;
+};
+
+export { }

package/dist/test.js

@@ -0,0 +1,40 @@
+import { c as e, t } from "./provider-BOC5wBxx.js";
+//#region src/test/index.ts
+var n = (e) => e.turns && e.turns.length > 0 ? e.turns : e.stream && e.stream.length > 0 ? [{ text: e.stream.join("") }] : e.generate ? [{ text: e.generate.text }] : [{ text: "" }], r = (e) => {
+	let r = new t(n(e));
+	return {
+		config: {
+			name: "mock",
+			model: e.model ?? "mock",
+			script: r,
+			...e.generate ? { mockText: e.generate.text } : {}
+		},
+		script: r
+	};
+}, i = (t) => {
+	let { config: n, script: i } = r(t), a = e(n);
+	return {
+		calls: i.calls,
+		reset: () => {
+			e(a);
+		}
+	};
+}, a = (t = {}) => {
+	let { config: n, script: i } = r(t), a = e(n);
+	return {
+		...t.generate ? { generate: () => ({ text: t.generate.text }) } : {},
+		...t.generateObject ? { generateObject: () => t.generateObject.object } : {},
+		calls: i.calls,
+		reset: () => {
+			e(a);
+		}
+	};
+}, o = (e, t, n = (t) => /* @__PURE__ */ Error(`throwNTimes: attempt ${t} of ${e}`)) => {
+	let r = 0;
+	return () => {
+		if (r += 1, r <= e) throw n(r);
+		return t;
+	};
+};
+//#endregion
+export { a as mockAi, o as throwNTimes, i as useMockAi };

package/package.json

@@ -0,0 +1,64 @@
+{
+  "name": "@voltro/ai",
+  "version": "0.1.0",
+  "description": "Effect-native AI primitives — generateText / generateObject / streamText, tools, agents, media generation, cost tracking + budgets, and provider fallback.",
+  "keywords": [
+    "voltro",
+    "typescript",
+    "framework"
+  ],
+  "license": "SEE LICENSE IN LICENSE",
+  "homepage": "https://voltro.dev",
+  "bugs": {
+    "email": "support@voltro.dev"
+  },
+  "author": {
+    "name": "Voltro UG",
+    "url": "https://voltro.dev"
+  },
+  "type": "module",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js",
+      "default": "./dist/index.js"
+    },
+    "./agent": {
+      "types": "./dist/agent.d.ts",
+      "import": "./dist/agent.js",
+      "default": "./dist/agent.js"
+    },
+    "./events": {
+      "types": "./dist/events.d.ts",
+      "import": "./dist/events.js",
+      "default": "./dist/events.js"
+    },
+    "./test": {
+      "types": "./dist/test.d.ts",
+      "import": "./dist/test.js",
+      "default": "./dist/test.js"
+    }
+  },
+  "main": "./dist/index.js",
+  "module": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "sideEffects": false,
+  "engines": {
+    "node": ">=24.0.0"
+  },
+  "dependencies": {
+    "@ai-sdk/anthropic": "^4.0.12",
+    "@ai-sdk/gateway": "^4.0.16",
+    "@ai-sdk/openai": "^4.0.11",
+    "@ai-sdk/provider": "^4.0.3",
+    "@voltro/database": "0.1.0",
+    "@voltro/protocol": "0.1.0",
+    "ai": "^7.0.22"
+  },
+  "peerDependencies": {
+    "effect": "^3.21.4"
+  },
+  "publishConfig": {
+    "access": "public"
+  }
+}