@voltro/ai 0.33.0 → 0.34.0

package/dist/workflow.d.ts

@@ -12,6 +12,10 @@ import { StepRetryPolicy } from '@voltro/workflow';
  *  same rules — see `decideInferenceFailure`. */
 export declare const AI_STEP_RETRY: StepRetryPolicy;
 
+export declare class AiBudgetMisuseError extends Error {
+    constructor(stepName: string);
+}
+
 /** Provider-specific knobs forwarded verbatim to the Vercel AI SDK's
  *  `providerOptions` on generateText / streamText / generateObject. The outer
  *  key is the provider id, the inner record its options. The headline use is
@@ -80,7 +84,17 @@ export declare interface AiStepBaseOptions {
      *  the offloaded call's row, so it has to be stable across a replay — which
      *  it is, being a literal in the body. */
     readonly name: string;
-    readonly prompt: string;
+    /**
+     * The prompt: either a bare string, or a `definePrompt(...).render(vars)`
+     * result.
+     *
+     * The rendered form is what buys provenance — the step row, the spend ledger
+     * row and `_voltro_prompts` all end up carrying the same `promptId` + content
+     * digest, so "which prompt version produced this run" is a lookup rather than
+     * an archaeology exercise across deploys.
+     */
+    readonly prompt: string | RenderedPrompt;
+    /** Overrides a rendered prompt's own system message for this call. */
     readonly system?: string;
     readonly provider?: ProviderConfig;
     readonly fallbacks?: ProviderFallbacks;
@@ -109,6 +123,61 @@ export declare interface AiStepBaseOptions {
     readonly offload?: boolean;
     /** End-to-end ceiling on an offloaded call. Default one hour. */
     readonly offloadTimeoutMs?: number;
+    /**
+     * Hold this call to a per-tenant USD ceiling, checked BEFORE anything is
+     * spent. Requires `store` (the counter and the hold both live in tables).
+     *
+     * See {@link AiStepBudget} — `onExceeded: 'suspend'` is the mode that stops
+     * spending without destroying the run.
+     */
+    readonly budget?: AiStepBudget;
+}
+
+/**
+ * A per-step USD ceiling, and what happens at it.
+ *
+ * `onExceeded` is the whole point of this option existing. The framework had
+ * two behaviours and neither is a budget CONTROL:
+ *
+ *   - `'fail'` is `requireAiBudget`'s: the call fails with the typed
+ *     `AiBudgetExceeded` and the whole durable run dies with it, nine steps of
+ *     work included. Correct for a hard cap you genuinely want enforced by
+ *     destruction, and the reason budgets get set high.
+ *   - observation-only (`defineCostBudget`) never stops anything at all.
+ *
+ * `'suspend'` is the third: the run PARKS on a durable hold, frees its worker,
+ * and resumes when the window rolls over or an operator lifts it — then
+ * re-checks and continues from where it stopped. Nothing is spent while held,
+ * and nothing is lost.
+ */
+export declare interface AiStepBudget {
+    /** Stable budget name — what a hold row records and an operator lifts.
+     *  Default `'ai-usd'`. */
+    readonly name?: string;
+    /** The per-tenant ceiling in USD. */
+    readonly limitUsd: number;
+    /** Rolling-window start; folds into the reservation counter's bucket key, so
+     *  a new window reserves against a fresh counter. */
+    readonly since?: Date;
+    /**
+     * What THIS call is expected to cost, RESERVED atomically before the provider
+     * is contacted.
+     *
+     * Omitting it makes the gate a read: the ceiling still holds against spend
+     * that WAS reserved, but N concurrent runs can each observe headroom and then
+     * each spend. Pass an estimate for a real cap — that is the difference between
+     * a ceiling and a speed bump, and it is the same argument
+     * `requireAiBudget`'s CAS-reservation makes against a check-then-act SUM.
+     */
+    readonly estimateUsd?: number;
+    /** Default `'fail'` — the existing behaviour stays the default, because
+     *  suspending is a change in what a run DOES and should be asked for. */
+    readonly onExceeded?: 'fail' | 'suspend';
+    /** Ceiling on how long a hold may park, across every re-park. Default 7 days. */
+    readonly holdTimeoutMs?: number;
+    /** How often a held run wakes to re-read the counter. Default 15 minutes —
+     *  a tumbling window rolls over on a clock nothing notifies us about. */
+    readonly recheckEveryMs?: number;
 }
 
 export declare interface AiStepOptions extends AiStepBaseOptions {
@@ -126,6 +195,10 @@ export declare interface AiStepResult {
 
 declare type AnthropicModel = 'claude-opus-4-8' | 'claude-sonnet-4-6' | 'claude-haiku-4-5-20251001' | (string & {});
 
+/** The name a hold is scoped to when the caller does not choose one. Operators
+ *  lift by this string, so it has to be stable and sayable. */
+export declare const DEFAULT_AI_BUDGET_NAME = "ai-usd";
+
 /** Default ceiling on an offloaded call, end to end — one hour. Generous
  *  because the wait itself is free (no worker is held), and a run that gives up
  *  on a slow provider at ten minutes is a run somebody has to re-drive by hand. */
@@ -199,8 +272,38 @@ declare interface MockTurn {
 
 declare type OpenAIModel = 'gpt-5.5' | 'gpt-4o' | 'gpt-4o-mini' | (string & {});
 
-/** The digest form. A prefix, not the whole hash: this is a correlation handle,
- *  and a full sha256 in a dashboard cell is a wall of hex nobody reads. */
+declare interface PromptDefinition {
+    /**
+     * Stable identity across revisions. Dotted, like a descriptor tag
+     * (`support.triage`) — the same vocabulary the rest of the framework uses for
+     * "the name of a thing an app owns".
+     */
+    readonly id: string;
+    /**
+     * The template, with `{{name}}` placeholders. A STRING, not a function, and
+     * that is the design: a function has no stable content to hash, so a
+     * function-built prompt could be versioned only by hashing its output — which
+     * would make every distinct customer message a new "version". Compose in the
+     * variables instead.
+     */
+    readonly template: string;
+    /** Optional system message. Part of the digest — changing it IS a new
+     *  version, because it changes the model's behaviour as surely as the
+     *  template does. */
+    readonly system?: string;
+    /** Optional human label for this revision (`'shorter-system'`). Metadata:
+     *  deliberately NOT part of the digest, so relabelling does not fork a
+     *  version. */
+    readonly label?: string;
+}
+
+/** The digest form: a prefix, not the whole hash. This is a correlation handle,
+ *  and a full sha256 in a dashboard cell is a wall of hex nobody reads.
+ *
+ *  Lives here rather than in `inferStep.ts` (where it started) because it is now
+ *  the identity of a versioned artefact, and `inferStep` imports
+ *  `@voltro/workflow` — a prompt registry has no business needing the workflow
+ *  engine to compute a hash. `inferStep` re-exports it. */
 export declare const promptDigest: (prompt: string) => string;
 
 /**
@@ -210,8 +313,15 @@ export declare const promptDigest: (prompt: string) => string;
  * be assertable on its own: "the raw prompt is not in the recorded input" is a
  * property about a string, and testing it through a live model call would test
  * the mock instead.
+ *
+ * `stamp` is the PROVENANCE half and is recorded in EVERY mode, `'none'`
+ * included. That is deliberate and it is the point of the split: the reason to
+ * record nothing about a prompt is that its TEXT is sensitive, and a prompt id
+ * plus a content digest is neither the text nor derivable from it. Dropping the
+ * provenance along with the content would mean the most privacy-conscious
+ * setting is also the one where you cannot tell which prompt version ran.
  */
-export declare const promptRecordFor: (prompt: string, system: string | undefined, mode: PromptRecording) => Record<string, unknown>;
+export declare const promptRecordFor: (prompt: string, system: string | undefined, mode: PromptRecording, stamp?: PromptStamp) => Record<string, unknown>;
 
 /**
  * How the prompt is written to the step row the dashboard renders.
@@ -228,6 +338,21 @@ export declare const promptRecordFor: (prompt: string, system: string | undefine
  */
 export declare type PromptRecording = 'digest' | 'full' | 'none';
 
+/** A prompt's identity, as it is stamped onto a step row and a usage row. */
+declare interface PromptStamp {
+    /** The author-chosen stable id, e.g. `support.triage`. */
+    readonly promptId: string;
+    /** Content digest of the template (+ system). CHANGES when the template does
+     *  — that is the version. */
+    readonly digest: string;
+    /** The monotonic revision `recordPromptVersion` assigned, once it has been
+     *  registered. Absent before first registration; the digest is the identity
+     *  either way. */
+    readonly revision?: number;
+    /** Optional human label the author gave this revision. */
+    readonly label?: string;
+}
+
 /**
  * A resolved provider choice — a DISCRIMINATED UNION on `name`. Each provider
  * only carries the fields that apply to it: the mock-only `mockText` / `script`
@@ -301,4 +426,30 @@ declare type ProviderConfig = {
  */
 declare type ProviderFallbacks = ReadonlyArray<ProviderConfig>;
 
+/** What `.render(vars)` produces — a stamp plus the text to send. */
+declare interface RenderedPrompt extends PromptStamp {
+    readonly prompt: string;
+    readonly system?: string;
+    /** The artefact this was rendered from. Carried along so a consumer that
+     *  receives only the rendered value (`aiStep`) can REGISTER the version
+     *  without the app having to remember a separate boot-time call. It is the
+     *  template — code, not data — so carrying it costs nothing a repository
+     *  checkout does not already cost. */
+    readonly definition: PromptDefinition;
+}
+
+/**
+ * Split a step's `prompt` option into the text to send, the system message, and
+ * the provenance stamp (if it came from a `definePrompt`).
+ *
+ * `system` on the step wins over the prompt definition's, so a caller can
+ * override for one call without forking a prompt version — the digest still
+ * describes the ARTEFACT, and the override is visible in the step row.
+ */
+export declare const resolveStepPrompt: (options: Pick<AiStepBaseOptions, "prompt" | "system">) => {
+    readonly text: string;
+    readonly system: string | undefined;
+    readonly rendered: RenderedPrompt | undefined;
+};
+
 export { }

package/dist/workflow.js

@@ -1,153 +1,228 @@
 import { r as e } from "./provider-BOC5wBxx.js";
-import { O as t, f as n, g as r, h as i, j as a, o, s, t as c } from "./inferenceQueue-B25RTJZ4.js";
-import { Effect as l, Schema as u } from "effect";
-import { eq as d } from "@voltro/database";
-import { createHash as f } from "node:crypto";
-import { CurrentWorkflowExecutionId as p, awaitSignalSuspending as m, step as h } from "@voltro/workflow";
+import { C as t, D as n, E as r, H as i, U as a, m as o, o as s, p as c, s as l, t as u, y as d, z as f } from "./inferenceQueue-uj2kKyqp.js";
+import { Effect as p, Schema as m } from "effect";
+import { eq as h } from "@voltro/database";
+import { CurrentWorkflowExecutionId as g, awaitSignalSuspending as _, step as v, suspendForBudget as y } from "@voltro/workflow";
 //#region src/inferStep.ts
-var g = {
+var b = {
 	maxAttempts: 4,
 	strategy: "exponential",
 	baseDelay: "1 second",
 	maxDelay: "30 seconds",
 	jitter: !0,
 	respectRetryAfter: !0
-}, _ = 60 * 6e4, v = (e) => `sha256:${f("sha256").update(e).digest("hex").slice(0, 16)}`, y = (e, t, n) => n === "none" ? {} : n === "full" ? {
-	prompt: e,
-	...t === void 0 ? {} : { system: t }
+}, x = 60 * 6e4, S = "ai-usd", C = (e, t, n, r) => {
+	let i = r === void 0 ? {} : {
+		promptId: r.promptId,
+		promptVersion: r.digest,
+		...r.revision === void 0 ? {} : { promptRevision: r.revision },
+		...r.label === void 0 ? {} : { promptLabel: r.label }
+	};
+	return n === "none" ? i : n === "full" ? {
+		...i,
+		prompt: e,
+		...t === void 0 ? {} : { system: t }
+	} : {
+		...i,
+		promptDigest: o(e),
+		promptChars: e.length,
+		...t === void 0 ? {} : {
+			systemDigest: o(t),
+			systemChars: t.length
+		}
+	};
+}, w = (e) => c(e.prompt) ? {
+	text: e.prompt.prompt,
+	system: e.system ?? e.prompt.system,
+	rendered: e.prompt
 } : {
-	promptDigest: v(e),
-	promptChars: e.length,
-	...t === void 0 ? {} : {
-		systemDigest: v(t),
-		systemChars: t.length
-	}
-}, b = (e) => ({
+	text: e.prompt,
+	system: e.system,
+	rendered: void 0
+}, T = (e) => ({
 	provider: String(e.provider ?? "unknown"),
 	model: String(e.model ?? "unknown")
-}), x = (e, n, r, i) => {
+}), E = (e, t, n, r, a) => {
 	let o = e.store;
-	if (o === void 0) return l.void;
-	let { provider: s, model: c } = b(n), u = t(i.providerMetadata);
-	return a(o, {
+	if (o === void 0) return p.void;
+	let { provider: s, model: c } = T(t), l = f(r.providerMetadata);
+	return i(o, {
 		provider: s,
 		model: c,
-		operation: r,
+		operation: n,
 		agent: e.name,
-		usage: i.usage,
+		usage: r.usage,
 		...e.tenantId === void 0 ? {} : { tenantId: e.tenantId },
-		...u === void 0 ? {} : { actualCostUsd: u }
-	}).pipe(l.asVoid, l.catchAllCause(() => l.void));
-}, S = u.Struct({
-	text: u.String,
-	inputTokens: u.NullOr(u.Number),
-	outputTokens: u.NullOr(u.Number),
-	totalTokens: u.NullOr(u.Number)
-}), C = (e) => typeof e == "object" && !!e && e.__voltro_ai_error === !0, w = class extends Error {
+		...l === void 0 ? {} : { actualCostUsd: l },
+		...a === void 0 ? {} : { prompt: a }
+	}).pipe(p.asVoid, p.catchAllCause(() => p.void));
+}, D = (e, t) => {
+	let n = e.store;
+	return n === void 0 || t === void 0 ? p.void : d(n, {
+		...t.definition,
+		digest: t.digest
+	}).pipe(p.asVoid, p.catchAllCause(() => p.void));
+}, O = m.Struct({
+	text: m.String,
+	inputTokens: m.NullOr(m.Number),
+	outputTokens: m.NullOr(m.Number),
+	totalTokens: m.NullOr(m.Number)
+}), k = (e) => typeof e == "object" && !!e && e.__voltro_ai_error === !0, A = class extends Error {
 	attempts;
 	constructor(e, t, n) {
 		super(`aiStep('${e}'): the offloaded model call gave up after ${n} attempt(s): ${t}. The queued call is in _voltro_ai_inferences with status 'failed' — the Flow tab shows it with the provider's own message.`), this.name = "AiOffloadError", this.attempts = n;
 	}
-}, T = class extends Error {
+}, j = class extends Error {
 	constructor(e) {
 		super(`aiStep('${e}'): offload: true needs \`store\` — the queued call lives in a table and the dispatcher reads it from there. Pass ctx.store.`), this.name = "AiOffloadMisuseError";
 	}
-}, E = (e, t, n, r) => l.gen(function* () {
-	let i = e.store;
-	if (i === void 0) return yield* l.die(new T(e.name));
-	let a = yield* p;
-	if (a === void 0) return yield* l.die(/* @__PURE__ */ Error(`aiStep('${e.name}'): offload: true is only valid inside a workflow body — there is no execution to suspend here.`));
-	let { provider: u, model: f } = b(t), m = s(a, e.name), h = yield* l.promise(() => i.query({
+}, M = (e, t, n, r, i) => p.gen(function* () {
+	let a = e.store;
+	if (a === void 0) return yield* p.die(new j(e.name));
+	let o = yield* g;
+	if (o === void 0) return yield* p.die(/* @__PURE__ */ Error(`aiStep('${e.name}'): offload: true is only valid inside a workflow body — there is no execution to suspend here.`));
+	let { provider: c, model: d } = T(t), f = l(o, e.name), m = yield* p.promise(() => a.query({
 		table: "_voltro_workflow_runs",
-		predicate: d("executionId", a),
+		predicate: h("executionId", o),
 		order: [],
 		take: 1,
 		skip: void 0,
 		projection: void 0
-	})), g = String(h[0]?.tag ?? ""), _ = h[0]?.id;
-	return yield* l.promise(() => i.insertIgnore(c, {
-		id: m,
+	})), _ = String(m[0]?.tag ?? ""), v = m[0]?.id;
+	return yield* p.promise(() => a.insertIgnore(u, {
+		id: f,
 		tenantId: e.tenantId ?? null,
-		executionId: a,
-		workflowName: g,
-		runId: typeof _ == "string" ? _ : null,
-		signalName: o(m),
+		executionId: o,
+		workflowName: _,
+		runId: typeof v == "string" ? v : null,
+		signalName: s(f),
 		stepName: e.name,
 		status: "pending",
 		kind: n,
-		provider: u,
-		model: f,
-		prompt: e.prompt,
-		system: e.system ?? null,
+		provider: c,
+		model: d,
+		prompt: i.text,
+		system: i.system ?? null,
+		promptId: i.rendered?.promptId ?? null,
+		promptDigest: i.rendered?.digest ?? null,
+		promptRevision: i.rendered?.revision ?? null,
 		maxTokens: e.maxTokens ?? null,
 		providerOptions: e.providerOptions ?? null,
 		jsonSchema: r,
 		attempts: 0,
 		enqueuedAt: /* @__PURE__ */ new Date()
-	}, { conflictColumns: ["id"] })), m;
-}), D = (e, t, n, r, i) => l.gen(function* () {
-	let a = yield* h({
+	}, { conflictColumns: ["id"] })), f;
+}), N = (e, t, n, r, i, a) => p.gen(function* () {
+	let o = yield* v({
 		name: `${e.name}:enqueue`,
-		success: u.String,
+		success: m.String,
 		input: i,
-		execute: E(e, t, n, r)
-	}), s = yield* m({ store: e.store }, {
-		name: o(a),
-		schema: u.Unknown,
+		execute: M(e, t, n, r, a)
+	});
+	yield* D(e, a.rendered);
+	let c = yield* _({ store: e.store }, {
+		name: s(o),
+		schema: m.Unknown,
 		timeoutMs: e.offloadTimeoutMs ?? 36e5
 	});
-	return C(s) ? yield* l.die(new w(e.name, s.message, s.attempts)) : s;
-}), O = (t) => {
-	let n = t.provider ?? e(), r = {
-		...b(n),
+	return k(c) ? yield* p.die(new A(e.name, c.message, c.attempts)) : c;
+}), P = class extends Error {
+	constructor(e) {
+		super(`aiStep('${e}'): budget needs \`store\` — the reservation counter and the hold both live in tables. Pass ctx.store.`), this.name = "AiBudgetMisuseError";
+	}
+}, F = (e) => p.gen(function* () {
+	let t = e.budget;
+	if (t === void 0) return;
+	let n = e.store;
+	if (n === void 0) return yield* p.die(new P(e.name));
+	let r = e.tenantId ?? null, i = t.name ?? "ai-usd", o = () => a(n, {
+		tenantId: r,
+		limitUsd: t.limitUsd,
+		addUsd: 0,
+		...t.since === void 0 ? {} : { since: t.since }
+	}).pipe(p.as(null), p.catchTag("AiBudgetExceeded", (e) => p.succeed(e))), s = () => t.estimateUsd === void 0 ? p.void : a(n, {
+		tenantId: r,
+		limitUsd: t.limitUsd,
+		addUsd: t.estimateUsd,
+		...t.since === void 0 ? {} : { since: t.since }
+	}), c = yield* o();
+	if (c === null) return yield* s();
+	if ((t.onExceeded ?? "fail") !== "suspend") return yield* p.fail(c);
+	let l = yield* g;
+	return l === void 0 ? yield* p.fail(c) : (yield* y({
+		store: n,
+		budget: i,
+		tenantId: r,
+		executionId: l,
+		workflowName: yield* I(n, l),
+		stepName: e.name,
+		spentMicroUsd: Math.round(c.spentUsd * 1e6),
+		limitMicroUsd: Math.round(t.limitUsd * 1e6),
+		hasHeadroom: o().pipe(p.map((e) => e === null)),
+		...t.holdTimeoutMs === void 0 ? {} : { timeoutMs: t.holdTimeoutMs },
+		...t.recheckEveryMs === void 0 ? {} : { recheckEveryMs: t.recheckEveryMs }
+	}).pipe(p.catchAll((e) => p.die(e))), yield* s());
+}), I = (e, t) => p.promise(async () => {
+	let n = await e.query({
+		table: "_voltro_workflow_runs",
+		predicate: h("executionId", t),
+		order: [],
+		take: 1,
+		skip: void 0,
+		projection: void 0
+	});
+	return String(n[0]?.tag ?? "");
+}), L = (t) => {
+	let n = t.provider ?? e(), i = w(t), a = {
+		...T(n),
 		operation: "generateText",
 		offloaded: t.offload === !0,
-		...y(t.prompt, t.system, t.recordPrompt ?? "digest")
-	};
-	return t.offload === !0 ? D(t, n, "text", null, r) : h({
+		...C(i.text, i.system, t.recordPrompt ?? "digest", i.rendered)
+	}, o = (e) => t.budget === void 0 ? e : p.zipRight(F(t), e);
+	return t.offload === !0 ? o(N(t, n, "text", null, a, i)) : o(v({
 		name: t.name,
-		success: S,
-		input: r,
-		retry: t.retry ?? g,
-		execute: i({
-			prompt: t.prompt,
+		success: O,
+		input: a,
+		retry: t.retry ?? b,
+		execute: r({
+			prompt: i.text,
 			provider: n,
-			...t.system === void 0 ? {} : { system: t.system },
+			...i.system === void 0 ? {} : { system: i.system },
 			...t.fallbacks === void 0 ? {} : { fallbacks: t.fallbacks },
 			...t.maxTokens === void 0 ? {} : { maxTokens: t.maxTokens },
 			...t.providerOptions === void 0 ? {} : { providerOptions: t.providerOptions }
-		}).pipe(l.tap((e) => x(t, n, "generateText", e)), l.map((e) => ({
+		}).pipe(p.tap((e) => E(t, n, "generateText", e, i.rendered)), p.tap(() => D(t, i.rendered)), p.map((e) => ({
 			text: e.text,
 			inputTokens: e.usage.inputTokens ?? null,
 			outputTokens: e.usage.outputTokens ?? null,
 			totalTokens: e.usage.totalTokens ?? null
 		})))
-	});
-}, k = (t) => {
-	let i = t.provider ?? e(), a = {
-		...b(i),
+	}));
+}, R = (r) => {
+	let i = r.provider ?? e(), a = w(r), o = {
+		...T(i),
 		operation: "generateObject",
-		offloaded: t.offload === !0,
-		...y(t.prompt, t.system, t.recordPrompt ?? "digest")
-	};
-	return t.offload === !0 ? l.gen(function* () {
-		let e = yield* r(t.schema, "aiObjectStep"), n = yield* D(t, i, "object", e, a);
-		return yield* u.decodeUnknown(t.schema)(n);
-	}) : h({
-		name: t.name,
-		success: t.schema,
-		input: a,
-		retry: t.retry ?? g,
-		execute: n({
-			prompt: t.prompt,
-			schema: t.schema,
+		offloaded: r.offload === !0,
+		...C(a.text, a.system, r.recordPrompt ?? "digest", a.rendered)
+	}, s = (e) => r.budget === void 0 ? e : p.zipRight(F(r), e);
+	return r.offload === !0 ? s(p.gen(function* () {
+		let e = yield* n(r.schema, "aiObjectStep"), t = yield* N(r, i, "object", e, o, a);
+		return yield* m.decodeUnknown(r.schema)(t);
+	})) : s(v({
+		name: r.name,
+		success: r.schema,
+		input: o,
+		retry: r.retry ?? b,
+		execute: t({
+			prompt: a.text,
+			schema: r.schema,
 			provider: i,
-			...t.system === void 0 ? {} : { system: t.system },
-			...t.fallbacks === void 0 ? {} : { fallbacks: t.fallbacks },
-			...t.maxTokens === void 0 ? {} : { maxTokens: t.maxTokens },
-			...t.providerOptions === void 0 ? {} : { providerOptions: t.providerOptions }
-		}).pipe(l.tap((e) => x(t, i, "generateObject", e)), l.map((e) => e.object))
-	});
+			...a.system === void 0 ? {} : { system: a.system },
+			...r.fallbacks === void 0 ? {} : { fallbacks: r.fallbacks },
+			...r.maxTokens === void 0 ? {} : { maxTokens: r.maxTokens },
+			...r.providerOptions === void 0 ? {} : { providerOptions: r.providerOptions }
+		}).pipe(p.tap((e) => E(r, i, "generateObject", e, a.rendered)), p.tap(() => D(r, a.rendered)), p.map((e) => e.object))
+	}));
 };
 //#endregion
-export { g as AI_STEP_RETRY, w as AiOffloadError, T as AiOffloadMisuseError, _ as DEFAULT_OFFLOAD_TIMEOUT_MS, k as aiObjectStep, O as aiStep, v as promptDigest, y as promptRecordFor };
+export { b as AI_STEP_RETRY, P as AiBudgetMisuseError, A as AiOffloadError, j as AiOffloadMisuseError, S as DEFAULT_AI_BUDGET_NAME, x as DEFAULT_OFFLOAD_TIMEOUT_MS, R as aiObjectStep, L as aiStep, o as promptDigest, C as promptRecordFor, w as resolveStepPrompt };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@voltro/ai",
-  "version": "0.33.0",
+  "version": "0.34.0",
   "description": "Effect-native AI primitives — generateText / generateObject / streamText, tools, agents, media generation, cost tracking + budgets, and provider fallback.",
   "keywords": [
     "voltro",
@@ -57,10 +57,10 @@
     "@ai-sdk/gateway": "^4.0.30",
     "@ai-sdk/openai": "^4.0.22",
     "@ai-sdk/provider": "^4.0.4",
-    "@voltro/cache": "0.33.0",
-    "@voltro/database": "0.33.0",
-    "@voltro/protocol": "0.33.0",
-    "@voltro/workflow": "0.33.0",
+    "@voltro/cache": "0.34.0",
+    "@voltro/database": "0.34.0",
+    "@voltro/protocol": "0.34.0",
+    "@voltro/workflow": "0.34.0",
     "ai": "^7.0.40"
   },
   "peerDependencies": {