octaflow 0.14.0

package/dist/ai/index.js

@@ -0,0 +1,466 @@
+import { S as ok, b as noopLogger, f as defineStep, l as buildWorkflow, x as err } from "../core-ERYGlYsS.js";
+import { wrapEmbeddingModel, wrapLanguageModel } from "ai";
+//#region src/ai/instrumented-model.ts
+function createUsageAccumulator() {
+	const total = {
+		inputTokens: 0,
+		outputTokens: 0,
+		cacheReadTokens: 0,
+		cacheWriteTokens: 0,
+		modelId: ""
+	};
+	let hasAny = false;
+	return {
+		record(usage) {
+			total.inputTokens += usage.inputTokens;
+			total.outputTokens += usage.outputTokens;
+			total.cacheReadTokens += usage.cacheReadTokens;
+			total.cacheWriteTokens += usage.cacheWriteTokens;
+			if (usage.modelId) total.modelId = usage.modelId;
+			hasAny = true;
+		},
+		get() {
+			return { ...total };
+		},
+		hasUsage() {
+			return hasAny;
+		}
+	};
+}
+/**
+* Wrap a language model with usage-tracking middleware. The accumulator collects
+* token usage from every doGenerate/doStream call routed through the wrapped model.
+*/
+function createInstrumentedModel(model, accumulator) {
+	return wrapLanguageModel({
+		model,
+		middleware: {
+			specificationVersion: "v4",
+			wrapGenerate: async ({ doGenerate }) => {
+				const result = await doGenerate();
+				const usage = result.usage;
+				if (usage) accumulator.record({
+					inputTokens: usage.inputTokens?.total ?? 0,
+					outputTokens: usage.outputTokens?.total ?? 0,
+					cacheReadTokens: usage.inputTokens?.cacheRead ?? 0,
+					cacheWriteTokens: usage.inputTokens?.cacheWrite ?? 0,
+					modelId: model.modelId
+				});
+				return result;
+			},
+			wrapStream: async ({ doStream }) => {
+				const result = await doStream();
+				const wrappedStream = result.stream.pipeThrough(new TransformStream({ transform(chunk, controller) {
+					controller.enqueue(chunk);
+					if (chunk.type === "finish" && chunk.usage) {
+						const u = chunk.usage;
+						accumulator.record({
+							inputTokens: u.inputTokens?.total ?? 0,
+							outputTokens: u.outputTokens?.total ?? 0,
+							cacheReadTokens: u.inputTokens?.cacheRead ?? 0,
+							cacheWriteTokens: u.inputTokens?.cacheWrite ?? 0,
+							modelId: model.modelId
+						});
+					}
+				} }));
+				return {
+					...result,
+					stream: wrappedStream
+				};
+			}
+		}
+	});
+}
+//#endregion
+//#region src/ai/instrumented-embedding-model.ts
+function createEmbeddingUsageAccumulator() {
+	let inputTokens = 0;
+	let callCount = 0;
+	let modelId = "";
+	return {
+		record(tokens, recordedModelId) {
+			inputTokens += tokens;
+			callCount += 1;
+			if (recordedModelId) modelId = recordedModelId;
+		},
+		get() {
+			return {
+				inputTokens,
+				callCount,
+				modelId
+			};
+		},
+		hasUsage() {
+			return callCount > 0;
+		},
+		reset() {
+			inputTokens = 0;
+			callCount = 0;
+			modelId = "";
+		}
+	};
+}
+/**
+* Wrap an embedding model with usage-tracking middleware. The accumulator collects
+* token usage from every doEmbed call routed through the wrapped model — both
+* `embed()` (single value) and `embedMany()` (batched values) invoke doEmbed one or
+* more times, and each invocation is recorded.
+*/
+function createInstrumentedEmbeddingModel(model, accumulator) {
+	return wrapEmbeddingModel({
+		model,
+		middleware: {
+			specificationVersion: "v4",
+			wrapEmbed: async ({ doEmbed }) => {
+				const result = await doEmbed();
+				accumulator.record(result.usage?.tokens ?? 0, model.modelId);
+				return result;
+			}
+		}
+	});
+}
+//#endregion
+//#region src/ai/cost.ts
+/** Default pricing (USD per million tokens), as of 2026-04. */
+const DEFAULT_MODEL_PRICING = {
+	"text-embedding-3-small": {
+		inputPerMillion: .02,
+		outputPerMillion: 0,
+		cacheReadPerMillion: 0,
+		cacheWritePerMillion: 0
+	},
+	"text-embedding-3-large": {
+		inputPerMillion: .13,
+		outputPerMillion: 0,
+		cacheReadPerMillion: 0,
+		cacheWritePerMillion: 0
+	},
+	"claude-opus-4-7": {
+		inputPerMillion: 5,
+		outputPerMillion: 25,
+		cacheReadPerMillion: .5,
+		cacheWritePerMillion: 6.25
+	},
+	"claude-opus-4-6": {
+		inputPerMillion: 15,
+		outputPerMillion: 75,
+		cacheReadPerMillion: 1.5,
+		cacheWritePerMillion: 18.75
+	},
+	"claude-sonnet-4-6": {
+		inputPerMillion: 3,
+		outputPerMillion: 15,
+		cacheReadPerMillion: .3,
+		cacheWritePerMillion: 3.75
+	},
+	"claude-sonnet-4-5-20250929": {
+		inputPerMillion: 3,
+		outputPerMillion: 15,
+		cacheReadPerMillion: .3,
+		cacheWritePerMillion: 3.75
+	},
+	"claude-haiku-4-5-20251001": {
+		inputPerMillion: .8,
+		outputPerMillion: 4,
+		cacheReadPerMillion: .08,
+		cacheWritePerMillion: 1
+	}
+};
+function priciest(pricing) {
+	let best;
+	for (const p of Object.values(pricing)) if (!best || p.outputPerMillion > best.outputPerMillion) best = p;
+	return best ?? {
+		inputPerMillion: 0,
+		outputPerMillion: 0,
+		cacheReadPerMillion: 0,
+		cacheWritePerMillion: 0
+	};
+}
+/** Build a cost estimator returning microdollars. */
+function createCostEstimator(options = {}) {
+	const pricing = options.pricing ?? DEFAULT_MODEL_PRICING;
+	const fallback = options.fallback ?? priciest(pricing);
+	return (usage, modelId) => {
+		const p = pricing[modelId] ?? fallback;
+		const input = usage.inputTokens / 1e6 * p.inputPerMillion;
+		const output = usage.outputTokens / 1e6 * p.outputPerMillion;
+		const cacheRead = usage.cacheReadTokens / 1e6 * p.cacheReadPerMillion;
+		const cacheWrite = usage.cacheWriteTokens / 1e6 * p.cacheWritePerMillion;
+		return Math.round((input + output + cacheRead + cacheWrite) * 1e6);
+	};
+}
+/** Convenience estimator using the default pricing table. */
+const estimateCostMicros = createCostEstimator();
+//#endregion
+//#region src/ai/define-ai-step.ts
+/**
+* Define a type-safe AI workflow step. Identical to flow-core's `defineStep`
+* except the handler context is fixed to `AiContext<THost>`, so handlers get a
+* ready-to-use `ctx.context.model` (instrumented) and `ctx.context.host`.
+*/
+function defineAiStep(config) {
+	return defineStep(config);
+}
+/** Build a typed AI workflow from `defineAiStep` definitions. */
+function buildAiWorkflow(config) {
+	return buildWorkflow(config);
+}
+//#endregion
+//#region src/ai/hooks.ts
+/**
+* Wire the AI behaviors (model instrumentation, token/cost capture, quota,
+* usage rollups) into a set of flow-core lifecycle hooks. Pass the result as the
+* engine's `hooks`. flow-core stays AI-free; everything AI lives here.
+*/
+function createAiWorkflowHooks(deps) {
+	const estimate = deps.costEstimator ?? createCostEstimator();
+	const now = deps.now ?? (() => /* @__PURE__ */ new Date());
+	return {
+		async onBeforeStart() {
+			if (deps.quotaPolicy) {
+				const q = await deps.quotaPolicy.checkQuota();
+				if (!q.ok) return q;
+			}
+			let metadata;
+			if (deps.modelResolver.resolveKeySource) metadata = { keySource: await deps.modelResolver.resolveKeySource() };
+			return {
+				ok: true,
+				value: { metadata }
+			};
+		},
+		async buildStepContext(args) {
+			const base = await deps.modelResolver.resolveModel(args);
+			const usage = createUsageAccumulator();
+			return {
+				model: createInstrumentedModel(base, usage),
+				host: deps.modelResolver.resolveHost ? await deps.modelResolver.resolveHost(args) : void 0,
+				usage
+			};
+		},
+		async onAfterStep({ workflowId, stepId, context }) {
+			const acc = context.usage;
+			if (!acc.hasUsage()) return;
+			const usage = acc.get();
+			const costMicros = estimate(usage, usage.modelId);
+			await deps.usageRecorder.recordStepUsage({
+				workflowId,
+				stepId,
+				usage,
+				costMicros
+			});
+			await deps.usageRecorder.incrementWorkflowUsage({
+				workflowId,
+				usage,
+				costMicros
+			});
+		},
+		async onWorkflowCompleted({ workflowId, workflow }) {
+			if (!deps.usageRecorder.recordWorkflowDaily) return;
+			const keySource = workflow.metadata?.keySource ?? "platform";
+			const date = now().toISOString().split("T")[0];
+			await deps.usageRecorder.recordWorkflowDaily({
+				workflowId,
+				workflowType: workflow.type,
+				keySource,
+				date
+			});
+		}
+	};
+}
+//#endregion
+//#region src/ai/usage-window.ts
+/**
+* Calendar-window helpers shared by the quota and usage-aggregation engines.
+* All windows are computed in **UTC**, matching flow's existing rollup date
+* derivation (`now().toISOString().split('T')[0]`).
+*/
+/** Format a `Date` as a `YYYY-MM-DD` calendar date in UTC. */
+function toIsoDate(date) {
+	return date.toISOString().split("T")[0];
+}
+/** First day (`YYYY-MM-01`) of the calendar month containing the given `YYYY-MM-DD` date. */
+function monthStartOf(isoDate) {
+	return isoDate.slice(0, 7) + "-01";
+}
+//#endregion
+//#region src/ai/quota.ts
+/**
+* Convenience defaults a consumer can spread over partial per-scope limits.
+* flow does **not** apply these automatically — resolution policy lives in the
+* injected {@link AiQuotaConfigResolver}.
+*/
+const DEFAULT_AI_QUOTA = {
+	maxConcurrentWorkflows: 3,
+	maxWorkflowsPerDay: 50,
+	maxWorkflowsPerMonth: 500
+};
+/**
+* Build a store-agnostic AI quota service. Enforcement order is concurrent →
+* day → month; the first tripped window short-circuits with its error.
+*/
+function createAiQuotaService(deps) {
+	const now = deps.now ?? (() => /* @__PURE__ */ new Date());
+	async function checkQuota(partitionKey) {
+		const config = await deps.getQuota(partitionKey);
+		if (!config) return ok(void 0);
+		const running = await deps.store.countRunningWorkflows(partitionKey);
+		if (config.maxConcurrentWorkflows !== null && running >= config.maxConcurrentWorkflows) return err({
+			key: "ai_quota_exceeded",
+			reason: "concurrent_limit",
+			message: `Maximum concurrent AI workflows reached (${config.maxConcurrentWorkflows}). Please wait for running workflows to complete.`,
+			limit: config.maxConcurrentWorkflows,
+			current: running
+		});
+		const today = toIsoDate(now());
+		if (config.maxWorkflowsPerDay !== null) {
+			const todayCount = await deps.store.sumWorkflowCount({
+				partitionKey,
+				startDate: today,
+				endDate: today
+			}) + running;
+			if (todayCount >= config.maxWorkflowsPerDay) return err({
+				key: "ai_quota_exceeded",
+				reason: "daily_limit",
+				message: `Daily AI workflow limit reached (${config.maxWorkflowsPerDay}). Try again tomorrow.`,
+				limit: config.maxWorkflowsPerDay,
+				current: todayCount
+			});
+		}
+		if (config.maxWorkflowsPerMonth !== null) {
+			const monthStart = monthStartOf(today);
+			const monthCount = await deps.store.sumWorkflowCount({
+				partitionKey,
+				startDate: monthStart,
+				endDate: today
+			}) + running;
+			if (monthCount >= config.maxWorkflowsPerMonth) return err({
+				key: "ai_quota_exceeded",
+				reason: "monthly_limit",
+				message: `Monthly AI workflow limit reached (${config.maxWorkflowsPerMonth}). Contact support to increase your limit.`,
+				limit: config.maxWorkflowsPerMonth,
+				current: monthCount
+			});
+		}
+		return ok(void 0);
+	}
+	return { checkQuota };
+}
+//#endregion
+//#region src/ai/usage-aggregation.ts
+function messageOf(error, fallback) {
+	return error instanceof Error ? error.message : fallback;
+}
+/** Build a store-agnostic AI usage-aggregation service. */
+function createAiUsageAggregationService(deps) {
+	const { store } = deps;
+	const now = deps.now ?? (() => /* @__PURE__ */ new Date());
+	const logger = deps.logger ?? noopLogger;
+	async function recordWorkflowCompletion(data) {
+		try {
+			await store.addDailyUsage({
+				partitionKey: data.partitionKey,
+				date: data.date,
+				workflowType: data.workflowType,
+				keySource: data.keySource,
+				workflowCount: 1,
+				usage: data.usage,
+				estimatedCostMicros: data.estimatedCostMicros
+			});
+			return ok(void 0);
+		} catch (error) {
+			const message = messageOf(error, "Unknown aggregation error");
+			logger.error("Failed to record workflow completion", error instanceof Error ? error : new Error(message));
+			return err({
+				key: "ai_usage_error",
+				message
+			});
+		}
+	}
+	async function recordEmbeddingUsage(data) {
+		try {
+			await store.addDailyUsage({
+				partitionKey: data.partitionKey,
+				date: data.date,
+				workflowType: data.workflowType,
+				keySource: data.keySource,
+				workflowCount: 1,
+				usage: {
+					inputTokens: data.inputTokens,
+					outputTokens: 0,
+					cacheReadTokens: 0,
+					cacheWriteTokens: 0
+				},
+				estimatedCostMicros: data.estimatedCostMicros
+			});
+			return ok(void 0);
+		} catch (error) {
+			const message = messageOf(error, "Unknown aggregation error");
+			logger.error("Failed to record embedding usage", error instanceof Error ? error : new Error(message));
+			return err({
+				key: "ai_usage_error",
+				message
+			});
+		}
+	}
+	async function getUsageSummary(params) {
+		try {
+			return ok(await store.aggregateByDate(params));
+		} catch (error) {
+			return err({
+				key: "ai_usage_error",
+				message: messageOf(error, "Unknown query error")
+			});
+		}
+	}
+	async function getUsageByWorkflowType(params) {
+		try {
+			return ok(await store.aggregateByWorkflowType(params));
+		} catch (error) {
+			return err({
+				key: "ai_usage_error",
+				message: messageOf(error, "Unknown query error")
+			});
+		}
+	}
+	async function getCurrentQuotaUsage(params) {
+		try {
+			const today = toIsoDate(now());
+			const monthStart = monthStartOf(today);
+			const { partitionKey } = params;
+			const dayQuery = {
+				partitionKey,
+				startDate: today,
+				endDate: today
+			};
+			const monthQuery = {
+				partitionKey,
+				startDate: monthStart,
+				endDate: today
+			};
+			const [todayCount, monthCount, runningCount] = await Promise.all([
+				store.sumWorkflowCount(dayQuery),
+				store.sumWorkflowCount(monthQuery),
+				store.countRunningWorkflows(partitionKey)
+			]);
+			return ok({
+				today: { workflowCount: todayCount },
+				thisMonth: { workflowCount: monthCount },
+				running: { count: runningCount }
+			});
+		} catch (error) {
+			return err({
+				key: "ai_usage_error",
+				message: messageOf(error, "Unknown query error")
+			});
+		}
+	}
+	return {
+		recordWorkflowCompletion,
+		recordEmbeddingUsage,
+		getUsageSummary,
+		getUsageByWorkflowType,
+		getCurrentQuotaUsage
+	};
+}
+//#endregion
+export { DEFAULT_AI_QUOTA, DEFAULT_MODEL_PRICING, buildAiWorkflow, createAiQuotaService, createAiUsageAggregationService, createAiWorkflowHooks, createCostEstimator, createEmbeddingUsageAccumulator, createInstrumentedEmbeddingModel, createInstrumentedModel, createUsageAccumulator, defineAiStep, estimateCostMicros };