@voltro/ai 0.84.0 → 0.86.0

package/THIRD-PARTY-NOTICES.md

@@ -1,11 +1,11 @@
 # Third-Party Notices — @voltro/ai
 
-This package depends on the open-source software listed below. Each is the
+This package uses the open-source software listed below. Each is the
 property of its respective copyright holders and is used under the terms of
 its license. This file is provided for attribution; it grants no rights in
 @voltro/ai itself, which is proprietary (see LICENSE).
 
-Generated from the resolved runtime dependency closure (37 packages).
+Generated from the resolved runtime dependency closure (31 packages).
 
 ---
 
@@ -75,118 +75,6 @@ License: Apache-2.0
 
 _(no bundled license text found in the package; see its npm page.)_
 
-## @effect/cluster@0.60.2
-
-License: MIT
-
-```
-MIT License
-
-Copyright (c) 2023-present The Contributors
-
-Permission is hereby granted, free of charge, to any person obtaining a copy
-of this software and associated documentation files (the "Software"), to deal
-in the Software without restriction, including without limitation the rights
-to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-copies of the Software, and to permit persons to whom the Software is
-furnished to do so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in all
-copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-SOFTWARE.
-```
-
-## @effect/experimental@0.61.1
-
-License: MIT
-
-```
-MIT License
-
-Copyright (c) 2023-present The Contributors
-
-Permission is hereby granted, free of charge, to any person obtaining a copy
-of this software and associated documentation files (the "Software"), to deal
-in the Software without restriction, including without limitation the rights
-to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-copies of the Software, and to permit persons to whom the Software is
-furnished to do so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in all
-copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-SOFTWARE.
-```
-
-## @effect/sql@0.52.1
-
-License: MIT
-
-```
-MIT License
-
-Copyright (c) 2023-present The Contributors
-
-Permission is hereby granted, free of charge, to any person obtaining a copy
-of this software and associated documentation files (the "Software"), to deal
-in the Software without restriction, including without limitation the rights
-to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-copies of the Software, and to permit persons to whom the Software is
-furnished to do so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in all
-copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-SOFTWARE.
-```
-
-## @effect/workflow@0.19.1
-
-License: MIT
-
-```
-MIT License
-
-Copyright (c) 2023-present The Contributors
-
-Permission is hereby granted, free of charge, to any person obtaining a copy
-of this software and associated documentation files (the "Software"), to deal
-in the Software without restriction, including without limitation the rights
-to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-copies of the Software, and to permit persons to whom the Software is
-furnished to do so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in all
-copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-SOFTWARE.
-```
-
 ## @ioredis/commands@1.10.0
 
 License: MIT
@@ -971,40 +859,6 @@ OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
 SOFTWARE.
 ```
 
-## kubernetes-types@1.30.0
-
-License: Apache-2.0
-
-_(no bundled license text found in the package; see its npm page.)_
-
-## layerr@3.0.0
-
-License: MIT
-
-```
-MIT License
-
-Copyright (c) 2020 Perry Mitchell
-
-Permission is hereby granted, free of charge, to any person obtaining a copy
-of this software and associated documentation files (the "Software"), to deal
-in the Software without restriction, including without limitation the rights
-to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-copies of the Software, and to permit persons to whom the Software is
-furnished to do so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in all
-copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-SOFTWARE.
-```
-
 ## ms@2.1.3
 
 License: MIT
@@ -1354,14 +1208,14 @@ Apache License
    limitations under the License.
 ```
 
-## ulidx@2.4.1
+## ulid@3.0.2
 
 License: MIT
 
 ```
-MIT License
+The MIT License (MIT)
 
-Copyright (c) 2021 Perry Mitchell
+Copyright (c) 2017 Alizain Feerasta
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal

package/dist/agent.d.ts

@@ -2,6 +2,7 @@ import { ActionProcedureDescriptor } from '@voltro/protocol';
 import { Guards } from '@voltro/protocol';
 import { QueryProcedureDescriptor } from '@voltro/protocol';
 import { Schema } from 'effect';
+import { YieldableError } from 'effect/Cause';
 
 declare const AGENT_DESCRIPTOR_BRAND: "@voltro/ai/AgentDescriptor";
 
@@ -30,7 +31,7 @@ export declare interface AgentAccessOptions {
     readonly openAccess?: string;
 }
 
-export declare interface AgentDescriptor<S extends Schema.Schema.Any = DefaultAgentInputSchema> {
+export declare interface AgentDescriptor<S extends Schema.Top = DefaultAgentInputSchema> {
     readonly _brand: typeof AGENT_DESCRIPTOR_BRAND;
     /** Wire id → rpc tags `<name>.send` / `<name>.messages`. */
     readonly name: string;
@@ -43,25 +44,22 @@ export declare interface AgentDescriptor<S extends Schema.Schema.Any = DefaultAg
 }
 
 /** The decoded input an agent's executor sees, derived from its schema. */
-export declare type AgentInput<S extends Schema.Schema.Any> = Schema.Schema.Type<S>;
+export declare type AgentInput<S extends Schema.Top> = Schema.Schema.Type<S>;
 
 /** The agent's input schema (default `{ prompt: string }`). */
-export declare const agentInputSchema: (desc: AnyAgentDescriptor) => Schema.Schema.Any;
+export declare const agentInputSchema: (desc: AnyAgentDescriptor) => Schema.Top;
 
 export declare const agentMessageSchema: Schema.Struct<{
-    id: typeof Schema.String;
-    threadId: typeof Schema.String;
-    role: typeof Schema.String;
-    content: typeof Schema.String;
-    streaming: typeof Schema.Boolean;
-    order: typeof Schema.Number;
-    stepOrder: typeof Schema.Number;
-    parts: Schema.Array$<Schema.TypeLiteral<{
-        type: typeof Schema.String;
-    }, readonly [{
-        readonly key: typeof Schema.String;
-        readonly value: typeof Schema.Unknown;
-    }]>>;
+    readonly id: Schema.String;
+    readonly threadId: Schema.String;
+    readonly role: Schema.String;
+    readonly content: Schema.String;
+    readonly streaming: Schema.Boolean;
+    readonly order: Schema.Number;
+    readonly stepOrder: Schema.Number;
+    readonly parts: Schema.$Array<Schema.StructWithRest<Schema.Struct<{
+        readonly type: Schema.String;
+    }>, readonly [Schema.$Record<Schema.String, Schema.Unknown>]>>;
 }>;
 
 /**
@@ -70,25 +68,22 @@ export declare const agentMessageSchema: Schema.Struct<{
  * so "what the server serves" and "what the client is typed for" can't drift.
  */
 export declare const agentRouteDescriptors: (desc: AnyAgentDescriptor) => {
-    send: ActionProcedureDescriptor<`${string}.send`, Schema.Schema.Any, Schema.Struct<{
-        text: typeof Schema.String;
+    send: ActionProcedureDescriptor<`${string}.send`, Schema.Top, Schema.Struct<{
+        readonly text: Schema.String;
     }>, typeof AgentThreadAccessDenied>;
     messages: QueryProcedureDescriptor<`${string}.messages`, Schema.Struct<{
-        threadId: typeof Schema.String;
-    }>, Schema.Array$<Schema.Struct<{
-        id: typeof Schema.String;
-        threadId: typeof Schema.String;
-        role: typeof Schema.String;
-        content: typeof Schema.String;
-        streaming: typeof Schema.Boolean;
-        order: typeof Schema.Number;
-        stepOrder: typeof Schema.Number;
-        parts: Schema.Array$<Schema.TypeLiteral<{
-            type: typeof Schema.String;
-        }, readonly [{
-            readonly key: typeof Schema.String;
-            readonly value: typeof Schema.Unknown;
-        }]>>;
+        readonly threadId: Schema.String;
+    }>, Schema.$Array<Schema.Struct<{
+        readonly id: Schema.String;
+        readonly threadId: Schema.String;
+        readonly role: Schema.String;
+        readonly content: Schema.String;
+        readonly streaming: Schema.Boolean;
+        readonly order: Schema.Number;
+        readonly stepOrder: Schema.Number;
+        readonly parts: Schema.$Array<Schema.StructWithRest<Schema.Struct<{
+            readonly type: Schema.String;
+        }>, readonly [Schema.$Record<Schema.String, Schema.Unknown>]>>;
     }>>, typeof AgentThreadAccessDenied>;
 };
 
@@ -108,17 +103,15 @@ export declare class AgentThreadAccessDenied extends AgentThreadAccessDenied_bas
     get message(): string;
 }
 
-declare const AgentThreadAccessDenied_base: Schema.TaggedErrorClass<AgentThreadAccessDenied, "AgentThreadAccessDenied", {
-    readonly _tag: Schema.tag<"AgentThreadAccessDenied">;
-} & {
-    threadId: typeof Schema.String;
-}>;
+declare const AgentThreadAccessDenied_base: Schema.Class<AgentThreadAccessDenied, Schema.TaggedStruct<"AgentThreadAccessDenied", {
+    readonly threadId: Schema.String;
+}>, YieldableError>;
 
 /** A descriptor of any input shape — for the type-erased runtime helpers. */
-export declare type AnyAgentDescriptor = AgentDescriptor<Schema.Schema.Any>;
+export declare type AnyAgentDescriptor = AgentDescriptor<Schema.Top>;
 
 declare const DEFAULT_INPUT: Schema.Struct<{
-    prompt: typeof Schema.String;
+    readonly prompt: Schema.String;
 }>;
 
 /** Default input schema type when `input` is omitted (`{ prompt: string }`). */
@@ -138,7 +131,7 @@ export declare type DefaultAgentInputSchema = typeof DEFAULT_INPUT;
  * })
  * ```
  */
-export declare const defineAgent: <S extends Schema.Schema.Any = DefaultAgentInputSchema>(config: {
+export declare const defineAgent: <S extends Schema.Top = DefaultAgentInputSchema>(config: {
     readonly name: string;
     readonly input?: S;
 } & AgentAccessOptions) => AgentDescriptor<S>;

package/dist/agent.js

@@ -1,2 +1,64 @@
-import { a as e, i as t, n, o as r, r as i, t as a } from "./agentDescriptor-DuxvWGDi.js";
-export { a as AgentThreadAccessDenied, n as agentInputSchema, i as agentMessageSchema, t as agentRouteDescriptors, e as defineAgent, r as isAgentDescriptor };
+import { AGENT_MESSAGES_TABLE as e } from "./agentConstants.js";
+import { Schema as t } from "effect";
+import { defineAction as n, defineQuery as r } from "@voltro/protocol";
+//#region src/agentDescriptor.ts
+var i = t.Struct({ prompt: t.String }), a = "@voltro/ai/AgentDescriptor", o = class extends t.TaggedError()("AgentThreadAccessDenied", { threadId: t.String }) {
+	get message() {
+		return `agent thread '${this.threadId}' belongs to another subject`;
+	}
+}, s = (e) => {
+	if (e.guards !== void 0 && e.guards.length === 0) throw Error(`defineAgent("${e.name}"): \`guards: []\` is empty, so it enforces nothing —\n  but it reads at the call site as if the agent were protected. Omit the field
+  and decide with \`openAccess\`, or list the scopes that may talk to it.`);
+	if (e.openAccess !== void 0 && e.guards !== void 0 && e.guards.length > 0) throw Error(`defineAgent("${e.name}"): \`openAccess\` and \`guards\` are two different access\n  decisions, so declaring both says the agent is protected AND open. Keep the
+  guards if a caller must hold a scope; drop them if anyone may talk to it.`);
+	return {
+		_brand: a,
+		name: e.name,
+		...e.input === void 0 ? {} : { input: e.input },
+		...e.guards === void 0 ? {} : { guards: e.guards },
+		...e.openAccess === void 0 ? {} : { openAccess: e.openAccess }
+	};
+}, c = (e) => typeof e == "object" && !!e && e._brand === a, l = (e) => e.input ?? i, u = t.StructWithRest(t.Struct({ type: t.String }), [t.Record(t.String, t.Unknown)]), d = t.Struct({
+	id: t.String,
+	threadId: t.String,
+	role: t.String,
+	content: t.String,
+	streaming: t.Boolean,
+	order: t.Number,
+	stepOrder: t.Number,
+	parts: t.Array(u)
+}), f = (e) => {
+	let n = l(e), r = t.Struct({
+		threadId: t.String,
+		order: t.Number
+	});
+	try {
+		return t.Struct({
+			...n.fields,
+			...r.fields
+		});
+	} catch {
+		return r;
+	}
+}, p = (i) => {
+	let a = {};
+	return i.openAccess === void 0 ? i.guards !== void 0 && (a.guards = i.guards) : a.openAccess = i.openAccess, {
+		send: n({
+			name: `${i.name}.send`,
+			input: f(i),
+			output: t.Struct({ text: t.String }),
+			error: o,
+			...a
+		}),
+		messages: r({
+			name: `${i.name}.messages`,
+			input: t.Struct({ threadId: t.String }),
+			output: t.Array(d),
+			source: e,
+			error: o,
+			...a
+		})
+	};
+};
+//#endregion
+export { o as AgentThreadAccessDenied, l as agentInputSchema, d as agentMessageSchema, p as agentRouteDescriptors, s as defineAgent, c as isAgentDescriptor };

package/dist/agentConstants.js

@@ -0,0 +1,4 @@
+//#region src/agentConstants.ts
+var e = "_voltro_agent_threads", t = "_voltro_agent_messages";
+//#endregion
+export { t as AGENT_MESSAGES_TABLE, e as AGENT_THREADS_TABLE };

package/dist/agentExecutor.js

@@ -0,0 +1,51 @@
+import { AgentThreadAccessDenied as e } from "./agent.js";
+import { appendMessage as t, ensureThreadOwned as n, getMessages as r, getThread as i } from "./threads.js";
+import { historyToModelMessages as a, runAssistant as o } from "./runAndPersist.js";
+import { Effect as s } from "effect";
+//#region src/agentExecutor.ts
+var c = "@voltro/ai/AgentExecutor", l = (e, t) => ({
+	_brand: c,
+	descriptor: e,
+	config: t
+}), u = (e) => typeof e == "object" && !!e && e._brand === c, d = (e, t) => {
+	let n = e.config.system;
+	if (n !== void 0) return typeof n == "function" ? n(t) : n;
+}, f = (e, t) => {
+	let n = e.config.model;
+	return typeof n == "function" ? n(t) : n;
+}, p = (e, i, c) => s.gen(function* () {
+	yield* n(i, {
+		threadId: c.threadId,
+		subjectId: c.subjectId ?? null,
+		tenantId: c.tenantId ?? null
+	});
+	let s = c.promptOf ? c.promptOf(c.input) : String(c.input?.prompt ?? ""), l = d(e, c.input), u = f(e, c.input);
+	yield* t(i, {
+		threadId: c.threadId,
+		role: "user",
+		content: s,
+		tenantId: c.tenantId ?? null,
+		order: c.order
+	});
+	let p = yield* r(i, c.threadId), m = a(p);
+	return yield* o(i, {
+		threadId: c.threadId,
+		tenantId: c.tenantId ?? null,
+		prompt: s,
+		...m.length > 0 ? { messages: m } : {},
+		...l === void 0 ? {} : { system: l },
+		...e.config.tools === void 0 ? {} : { tools: e.config.tools },
+		...u === void 0 ? {} : { provider: u },
+		...e.config.maxSteps === void 0 ? {} : { maxSteps: e.config.maxSteps },
+		...e.config.providerOptions === void 0 ? {} : { providerOptions: e.config.providerOptions },
+		...c.toolContext === void 0 ? {} : { toolContext: c.toolContext },
+		order: c.order + 1,
+		...c.throttleMs === void 0 ? {} : { throttleMs: c.throttleMs },
+		agent: e.descriptor.name
+	});
+}), m = (t, n, a = null) => s.gen(function* () {
+	let o = yield* i(t, n);
+	return o !== null && o.subjectId !== null && o.subjectId !== a ? yield* s.fail(new e({ threadId: n })) : yield* r(t, n);
+});
+//#endregion
+export { l as defineAgentExecutor, u as isAgentExecutor, m as loadAgentMessages, f as resolveAgentModel, d as resolveSystem, p as runAgentTurn };

package/dist/api.js

@@ -0,0 +1,199 @@
+import { providerFromEnv as e, resolveModel as t } from "./provider.js";
+import { buildSdkTools as n } from "./tools.js";
+import { aiCallAttributes as r, withAiCallSpan as i } from "./observe.js";
+import { validatedOutputSchema as a } from "./jsonOutputValidation.js";
+import { AiCallEvidenceSchema as o, normalizeAiCallEvidence as s } from "./callEvidence.js";
+import { captureStructuredEvidence as c } from "./structuredEvidence.js";
+import { NoObjectGeneratedError as l, Output as u, generateObject as d, generateText as f, jsonSchema as p, stepCountIs as m } from "ai";
+import { Context as h, Effect as g, Schema as _ } from "effect";
+import { jsonSchemaOf as v } from "@voltro/protocol";
+//#region src/api.ts
+var y = class extends _.TaggedError()("AiError", {
+	reason: _.Literals(["generation", "decode"]),
+	message: _.String,
+	evidence: _.optional(o)
+}) {}, b = (e, t = {}) => {
+	let n = String(e?.message ?? e), r = x(e), i = new y({
+		reason: "generation",
+		message: `${t.prefix === void 0 ? "" : `${t.prefix}: `}${n}${r.length > 0 ? ` (${r.join(" <- ")})` : ""}`,
+		...t.evidence === void 0 ? {} : { evidence: t.evidence }
+	});
+	return Object.defineProperty(i, "cause", {
+		value: e,
+		enumerable: !1,
+		configurable: !0,
+		writable: !0
+	}), i;
+}, x = (e) => {
+	let t = [], n = e;
+	for (let e = 0; e < 8 && typeof n == "object" && n; e++) {
+		let e = n;
+		typeof e.code == "string" && e.code.length > 0 && !t.includes(e.code) && t.push(e.code), n = typeof e.lastError == "object" && e.lastError !== null ? e.lastError : e.cause;
+	}
+	return t;
+}, S = (e, t, n) => {
+	let r = [e, ...t ?? []], i = (e) => n(r[e]).pipe(g.catchTag("AiError", (t) => t.reason === "generation" && e + 1 < r.length ? i(e + 1) : g.fail(t)));
+	return i(0);
+}, C = (a) => g.gen(function* () {
+	let o = a.messages === void 0 ? a.prompt === void 0 ? void 0 : { prompt: a.prompt } : { messages: [...a.messages] };
+	if (o === void 0 || a.prompt !== void 0 && a.messages !== void 0) return yield* g.fail(new y({
+		reason: "generation",
+		message: "generateText: supply exactly one of prompt or messages"
+	}));
+	let s = a.tools === void 0 ? void 0 : yield* g.context(), c = a.tools === void 0 || s === void 0 ? void 0 : n(a.tools, {
+		store: void 0,
+		...a.toolContext,
+		...a.abortSignal === void 0 ? {} : { abortSignal: a.abortSignal },
+		runtime: s
+	});
+	return yield* S(a.provider ?? e(), a.fallbacks, (e) => i(r(e, "generateText"), (e) => e.usage, g.tryPromise({
+		try: async () => {
+			let n = t(e), r = await f({
+				model: n,
+				...o,
+				...a.abortSignal === void 0 ? {} : { abortSignal: a.abortSignal },
+				...c === void 0 ? {} : {
+					tools: c,
+					stopWhen: m(a.maxSteps ?? 8)
+				},
+				...a.system === void 0 ? {} : { system: a.system },
+				...a.maxTokens === void 0 ? {} : { maxOutputTokens: a.maxTokens },
+				...a.temperature === void 0 ? {} : { temperature: a.temperature },
+				...a.providerOptions === void 0 ? {} : { providerOptions: a.providerOptions }
+			}), i = c !== void 0 && r.totalUsage !== void 0 ? r.totalUsage : r.usage;
+			return {
+				text: r.text,
+				sources: r.sources,
+				usage: {
+					inputTokens: i.inputTokens,
+					outputTokens: i.outputTokens,
+					totalTokens: i.totalTokens
+				},
+				providerMetadata: r.providerMetadata
+			};
+		},
+		catch: (e) => b(e)
+	})));
+}), w = (e, t) => g.gen(function* () {
+	let n = v(e);
+	if (n?.type !== "object") {
+		let e = n?.anyOf === void 0 ? `type:${JSON.stringify(n?.type ?? null)}` : "anyOf (e.g. Schema.Struct({}) or a union)";
+		return yield* g.fail(new y({
+			reason: "generation",
+			message: `${t}: the output schema must render as a top-level JSON object (type:"object"), but got ${e}. Use a Schema.Struct({ ... }) as the output schema — wrap arrays/scalars in a field (e.g. Schema.Struct({ items: Schema.Array(...) })).`
+		}));
+	}
+	return n;
+}), T = (e, t) => w(e, t), E = (n) => S(n.provider ?? e(), n.fallbacks, (e) => i(r(e, "generateObject"), (e) => e.usage, g.gen(function* () {
+	let r = yield* g.try({
+		try: () => a(n.jsonSchema),
+		catch: () => new y({
+			reason: "decode",
+			message: "generateObjectJson: invalid or unsupported output JSON Schema; no provider call was made"
+		})
+	}), i = c(e.name, t(e)), o = i.model, u = yield* g.tryPromise({
+		try: () => d({
+			model: o,
+			schema: r,
+			prompt: n.prompt,
+			...n.system === void 0 ? {} : { system: n.system },
+			...n.maxTokens === void 0 ? {} : { maxOutputTokens: n.maxTokens },
+			...n.temperature === void 0 ? {} : { temperature: n.temperature },
+			...n.providerOptions === void 0 ? {} : { providerOptions: n.providerOptions }
+		}),
+		catch: (t) => l.isInstance(t) ? new y({
+			reason: "decode",
+			message: "model output failed JSON Schema validation",
+			evidence: i.evidence(t.usage)
+		}) : b(t, {
+			prefix: "structured provider call failed",
+			evidence: s(e.name, o.modelId, void 0)
+		})
+	});
+	return {
+		object: u.object,
+		evidence: s(e.name, o.modelId, u.usage, u.providerMetadata),
+		usage: {
+			inputTokens: u.usage.inputTokens,
+			outputTokens: u.usage.outputTokens,
+			totalTokens: u.usage.totalTokens
+		},
+		providerMetadata: u.providerMetadata
+	};
+}))), D = (e) => g.gen(function* () {
+	let t = yield* E({
+		jsonSchema: yield* w(e.schema, "generateObject"),
+		prompt: e.prompt,
+		...e.system === void 0 ? {} : { system: e.system },
+		...e.provider === void 0 ? {} : { provider: e.provider },
+		...e.fallbacks === void 0 ? {} : { fallbacks: e.fallbacks },
+		...e.maxTokens === void 0 ? {} : { maxTokens: e.maxTokens },
+		...e.temperature === void 0 ? {} : { temperature: e.temperature },
+		...e.providerOptions === void 0 ? {} : { providerOptions: e.providerOptions }
+	}), n = yield* _.decodeUnknownEffect(e.schema)(t.object).pipe(g.mapError(() => new y({
+		reason: "decode",
+		message: "model output failed schema decode",
+		evidence: t.evidence
+	})));
+	return {
+		...t,
+		object: n
+	};
+}), O = (a) => g.gen(function* () {
+	let o = yield* g.context(), d = yield* w(a.schema, "generateObjectWithTools"), h = {
+		store: void 0,
+		...a.toolContext,
+		...a.abortSignal === void 0 ? {} : { abortSignal: a.abortSignal },
+		runtime: o
+	}, v = n(a.tools, h);
+	return yield* S(a.provider ?? e(), a.fallbacks, (e) => i(r(e, "generateObjectWithTools"), (e) => e.usage, g.gen(function* () {
+		let n = c(e.name, t(e)), r = n.model, i = yield* g.tryPromise({
+			try: () => f({
+				model: r,
+				prompt: a.prompt,
+				tools: v,
+				...a.abortSignal === void 0 ? {} : { abortSignal: a.abortSignal },
+				stopWhen: m(a.maxSteps ?? 8),
+				output: u.object({ schema: p(d) }),
+				...a.system === void 0 ? {} : { system: a.system },
+				...a.maxTokens === void 0 ? {} : { maxOutputTokens: a.maxTokens },
+				...a.temperature === void 0 ? {} : { temperature: a.temperature },
+				...a.providerOptions === void 0 ? {} : { providerOptions: a.providerOptions }
+			}),
+			catch: (t) => l.isInstance(t) ? new y({
+				reason: "decode",
+				message: "model output failed structured decode",
+				evidence: n.evidence(t.usage)
+			}) : b(t, {
+				prefix: "structured provider call failed",
+				evidence: s(e.name, r.modelId, void 0)
+			})
+		}), o = i.totalUsage, h = n.evidence(o), x = yield* g.try({
+			try: () => i.output,
+			catch: () => new y({
+				reason: "decode",
+				message: "model output failed structured decode",
+				evidence: h
+			})
+		});
+		return {
+			object: yield* _.decodeUnknownEffect(a.schema)(x).pipe(g.mapError(() => new y({
+				reason: "decode",
+				message: "model output failed schema decode",
+				evidence: h
+			}))),
+			evidence: h,
+			usage: {
+				inputTokens: o.inputTokens,
+				outputTokens: o.outputTokens,
+				totalTokens: o.totalTokens
+			},
+			providerMetadata: i.providerMetadata
+		};
+	})));
+}), k = class extends h.Service()("@voltro/AiService") {}, A = {
+	generateText: (e) => C(e),
+	generateObject: (e) => D(e)
+};
+//#endregion
+export { y as AiError, k as AiService, b as aiGenerationError, A as defaultAiService, D as generateObject, E as generateObjectJson, O as generateObjectWithTools, C as generateText, T as outputJsonSchema };