@od-oneapp/ai-platform 0.1.0

package/dist/errors-CQ8tF4dP.mjs

@@ -0,0 +1,985 @@
+import { $ as generateObject, Mt as streamObject, l as NoObjectGeneratedError, u as Output } from "./ai-runtime-CDzQztTt.mjs";
+import { z } from "zod";
+import { logInfo, logWarn } from "@od-oneapp/shared/logs";
+
+//#region src/output/factories.ts
+/**
+* @fileoverview Output API factories for structured output generation.
+* @module @od-oneapp/ai-platform/output
+*/
+/**
+* Creates a typed object output configuration.
+*
+* @param schema - Zod schema for the output
+* @returns Output configuration for use with streamText/generateText
+*
+* @example
+* ```ts
+* const PersonOutput = createObjectOutput(z.object({
+*   name: z.string(),
+*   age: z.number(),
+* }));
+*
+* const result = await streamText({
+*   model,
+*   prompt: 'Extract person info',
+*   output: PersonOutput,
+* });
+* ```
+*/
+function createObjectOutput(schema) {
+	return Output.object({ schema });
+}
+/**
+* Creates a typed array output configuration with element streaming.
+*
+* @param schema - Zod schema for array elements
+* @returns Output configuration for array streaming
+*
+* @example
+* ```ts
+* const TodosOutput = createArrayOutput(z.object({
+*   task: z.string(),
+*   done: z.boolean(),
+* }));
+*
+* const result = await streamText({
+*   model,
+*   prompt: 'List todos',
+*   output: TodosOutput,
+* });
+*
+* // Stream individual elements
+* for await (const todo of result.output.elementStream) {
+*   console.log('Got todo:', todo);
+* }
+* ```
+*/
+function createArrayOutput(schema) {
+	return Output.array({ element: schema });
+}
+/**
+* Creates a choice output for classification tasks using Zod enum.
+*
+* @param values - Array of valid choices
+* @returns Zod enum schema for use with generateObject
+*
+* @example
+* ```ts
+* const SentimentSchema = createChoiceSchema(['positive', 'negative', 'neutral'] as const);
+*
+* const { object } = await generateObject({
+*   model,
+*   schema: z.object({ sentiment: SentimentSchema }),
+*   prompt: 'Classify sentiment: "I love this!"',
+* });
+* // object.sentiment === 'positive'
+* ```
+*/
+function createChoiceSchema(values) {
+	return z.enum(values);
+}
+/**
+* Structured output helper that generates a single object.
+*
+* @param model - Language model to use
+* @param schema - Zod schema for output
+* @param prompt - Generation prompt
+* @returns Generated object matching schema
+*/
+async function generateStructuredObject(model, schema, prompt) {
+	const { object } = await generateObject({
+		model,
+		schema,
+		prompt
+	});
+	return object;
+}
+/**
+* Structured output helper that streams an object.
+*
+* @param model - Language model to use
+* @param schema - Zod schema for output
+* @param prompt - Generation prompt
+* @returns Stream result with partial object stream
+*/
+function streamStructuredObject(model, schema, prompt) {
+	return streamObject({
+		model,
+		schema,
+		prompt
+	});
+}
+/**
+* Schema builder utilities for common patterns.
+*/
+const SchemaBuilders = {
+	listWithMeta(itemSchema) {
+		return z.object({
+			items: z.array(itemSchema),
+			total: z.number(),
+			hasMore: z.boolean().optional()
+		});
+	},
+	resultOrError(successSchema) {
+		return z.discriminatedUnion("success", [z.object({
+			success: z.literal(true),
+			data: successSchema
+		}), z.object({
+			success: z.literal(false),
+			error: z.string()
+		})]);
+	},
+	classificationWithConfidence(categories) {
+		return z.object({
+			category: z.enum(categories),
+			confidence: z.number().min(0).max(1),
+			reasoning: z.string().optional()
+		});
+	},
+	entities(entitySchemas) {
+		return z.object({
+			entities: z.object(entitySchemas),
+			raw: z.string().optional()
+		});
+	},
+	plan() {
+		return z.object({
+			steps: z.array(z.object({
+				step: z.number(),
+				action: z.string(),
+				reasoning: z.string().optional(),
+				dependencies: z.array(z.number()).optional()
+			})),
+			summary: z.string()
+		});
+	}
+};
+/**
+* Safe structured object generation with NoObjectGeneratedError handling.
+* Returns a result object instead of throwing.
+*
+* @example
+* ```typescript
+* const result = await safeGenerateObject({
+*   model,
+*   schema: z.object({ name: z.string() }),
+*   prompt: 'Extract name from: Hello!',
+* });
+*
+* if (result.success) {
+*   console.log(result.object.name);
+* } else {
+*   console.log('Failed:', result.error?.message);
+*   console.log('Raw text:', result.text);
+* }
+* ```
+*/
+async function safeGenerateObject(options) {
+	try {
+		const { object, usage } = await generateObject(options);
+		const usageRecord = usage ?? {};
+		return {
+			success: true,
+			object,
+			usage: {
+				promptTokens: usageRecord.promptTokens ?? 0,
+				completionTokens: usageRecord.completionTokens ?? 0,
+				totalTokens: usageRecord.totalTokens ?? 0
+			}
+		};
+	} catch (error) {
+		if (error instanceof NoObjectGeneratedError) {
+			logWarn(`[safeGenerateObject] No object generated: ${error.message}`);
+			const errorUsage = error.usage;
+			const possiblePartial = error.partialObject;
+			const partialObject = typeof possiblePartial === "object" && possiblePartial !== null ? possiblePartial : extractPartialFromError(error) ?? void 0;
+			return {
+				success: false,
+				error,
+				text: error.text,
+				partialObject,
+				usage: errorUsage ? {
+					promptTokens: errorUsage.promptTokens ?? 0,
+					completionTokens: errorUsage.completionTokens ?? 0,
+					totalTokens: errorUsage.totalTokens ?? 0
+				} : void 0
+			};
+		}
+		return {
+			success: false,
+			error: error instanceof Error ? error : new Error(String(error))
+		};
+	}
+}
+/**
+* Generate object with fallback value on failure.
+*
+* @example
+* ```typescript
+* const person = await generateObjectWithFallback({
+*   model,
+*   schema: z.object({ name: z.string(), age: z.number() }),
+*   prompt: 'Extract person info',
+*   fallback: { name: 'Unknown', age: 0 },
+* });
+* ```
+*/
+async function generateObjectWithFallback(options) {
+	const { fallback, ...generateOptions } = options;
+	const result = await safeGenerateObject(generateOptions);
+	if (result.success && result.object !== void 0) return result.object;
+	logWarn(`[generateObjectWithFallback] Using fallback value`);
+	return fallback;
+}
+/**
+* Generate object with retry on failure.
+*
+* @example
+* ```typescript
+* const person = await generateObjectWithRetry({
+*   model,
+*   schema: z.object({ name: z.string() }),
+*   prompt: 'Extract name',
+*   maxRetries: 3,
+*   onRetry: (attempt, error) => console.log(`Retry ${attempt}:`, error.message),
+* });
+* ```
+*/
+async function generateObjectWithRetry(options) {
+	const { maxRetries = 3, retryDelay = 1e3, onRetry, ...generateOptions } = options;
+	let lastError;
+	for (let attempt = 0; attempt <= maxRetries; attempt++) {
+		const result = await safeGenerateObject(generateOptions);
+		if (result.success && result.object !== void 0) return result.object;
+		lastError = result.error ?? /* @__PURE__ */ new Error("Unknown error");
+		if (attempt < maxRetries) {
+			onRetry?.(attempt + 1, lastError);
+			await new Promise((resolve) => setTimeout(resolve, retryDelay * (attempt + 1)));
+		}
+	}
+	throw lastError ?? /* @__PURE__ */ new Error("Failed to generate object after retries");
+}
+/**
+* Extract partial data from NoObjectGeneratedError.
+* Attempts to parse partial JSON from the raw text.
+*/
+function extractPartialFromError(error) {
+	const { text } = error;
+	if (!text) return null;
+	const jsonMatch = text.match(/\{[\s\S]*\}/);
+	if (!jsonMatch) return null;
+	try {
+		return JSON.parse(jsonMatch[0]);
+	} catch {
+		return null;
+	}
+}
+
+//#endregion
+//#region src/output/element-stream.ts
+/**
+* Element Stream Module
+*
+* SDK v6 pattern for streaming array elements in real-time.
+* Uses streamObject with output: 'array' and elementStream for
+* progressive rendering of list items.
+*
+* @module output/element-stream
+*/
+/**
+* Stream array elements in real-time using SDK v6 elementStream pattern.
+*
+* @example
+* ```typescript
+* const taskSchema = z.object({
+*   title: z.string(),
+*   priority: z.enum(['low', 'medium', 'high']),
+*   estimate: z.string(),
+* });
+*
+* const { stream, elements } = streamElements({
+*   model: anthropic('claude-sonnet'),
+*   elementSchema: taskSchema,
+*   prompt: 'Break down building a web app into tasks',
+*   onElement: (task, index) => {
+*     console.log(`Task ${index + 1}: ${task.title}`);
+*   },
+* });
+*
+* // Or iterate over the stream
+* for await (const event of stream) {
+*   if (event.type === 'element' && event.isComplete) {
+*     renderTask(event.element);
+*   }
+* }
+* ```
+*/
+function streamElements(options) {
+	const { model, elementSchema, system, prompt, abortSignal, maxTokens, temperature, onPartialElement, onElement, onError, onComplete } = options;
+	let resolveElements;
+	let rejectElements;
+	let resolveUsage;
+	let rejectUsage;
+	const elementsPromise = new Promise((resolve, reject) => {
+		resolveElements = resolve;
+		rejectElements = reject;
+	});
+	const usagePromise = new Promise((resolve, reject) => {
+		resolveUsage = resolve;
+		rejectUsage = reject;
+	});
+	async function* createStream() {
+		const allElements = [];
+		try {
+			const result = streamObject({
+				model,
+				output: "array",
+				schema: elementSchema,
+				system,
+				prompt,
+				abortSignal,
+				temperature
+			});
+			let currentIndex = 0;
+			for await (const element of result.elementStream) {
+				allElements.push(element);
+				onElement?.(element, currentIndex);
+				yield {
+					type: "element",
+					index: currentIndex,
+					element,
+					isComplete: true,
+					totalElements: allElements.length
+				};
+				currentIndex++;
+			}
+			const usageObj = await result.usage;
+			resolveUsage({
+				promptTokens: usageObj.promptTokens ?? 0,
+				completionTokens: usageObj.completionTokens ?? 0,
+				totalTokens: usageObj.totalTokens ?? 0
+			});
+			onComplete?.(allElements);
+			resolveElements(allElements);
+			yield {
+				type: "complete",
+				totalElements: allElements.length
+			};
+		} catch (error) {
+			const err = error instanceof Error ? error : new Error(String(error));
+			onError?.(err);
+			rejectElements(err);
+			rejectUsage(err);
+			yield {
+				type: "error",
+				error: err,
+				totalElements: allElements.length
+			};
+		}
+	}
+	return {
+		stream: createStream(),
+		elements: elementsPromise,
+		usage: usagePromise
+	};
+}
+/**
+* Stream array elements with partial progress updates.
+* Useful for showing "typing" indicators for each element.
+*
+* @example
+* ```typescript
+* const { stream } = streamElementsWithProgress({
+*   model,
+*   elementSchema: taskSchema,
+*   prompt: 'Generate 5 tasks',
+*   updateInterval: 100,
+* });
+*
+* for await (const event of stream) {
+*   if (event.type === 'partial') {
+*     // Show partial element with loading indicator
+*     updateUI(event.element, { loading: true });
+*   } else if (event.type === 'element') {
+*     // Show complete element
+*     updateUI(event.element, { loading: false });
+*   }
+* }
+* ```
+*/
+function streamElementsWithProgress(options) {
+	const { updateInterval = 50, onPartialElement, ...rest } = options;
+	const baseResult = streamElements(rest);
+	async function* createPartialStream() {
+		for await (const event of baseResult.stream) if (event.type === "element") yield {
+			type: "element",
+			index: event.index,
+			element: event.element,
+			isComplete: true,
+			totalElements: event.totalElements
+		};
+		else yield event;
+	}
+	return {
+		...baseResult,
+		partialStream: createPartialStream()
+	};
+}
+/**
+* Stream elements in batches for better performance.
+*
+* @example
+* ```typescript
+* const { batches } = streamElementsInBatches({
+*   model,
+*   elementSchema: taskSchema,
+*   prompt: 'Generate 20 tasks',
+*   batchSize: 5,
+*   batchTimeout: 1000,
+* });
+*
+* for await (const batch of batches) {
+*   // Process 5 elements at once
+*   renderTaskBatch(batch);
+* }
+* ```
+*/
+function streamElementsInBatches(options) {
+	const { batchSize, batchTimeout = 1e3, ...rest } = options;
+	const baseResult = streamElements(rest);
+	async function* createBatchStream() {
+		let batch = [];
+		let timeoutId = null;
+		const flushBatch = () => {
+			if (batch.length === 0) return null;
+			const result = [...batch];
+			batch = [];
+			if (timeoutId) {
+				clearTimeout(timeoutId);
+				timeoutId = null;
+			}
+			return result;
+		};
+		for await (const event of baseResult.stream) if (event.type === "element" && event.element) {
+			batch.push(event.element);
+			if (batch.length >= batchSize) {
+				const flushed = flushBatch();
+				if (flushed) yield flushed;
+			} else if (!timeoutId) timeoutId = setTimeout(() => {
+				timeoutId = null;
+			}, batchTimeout);
+		} else if (event.type === "complete") {
+			const flushed = flushBatch();
+			if (flushed) yield flushed;
+		}
+		const final = flushBatch();
+		if (final) yield final;
+	}
+	return {
+		...baseResult,
+		batches: createBatchStream()
+	};
+}
+/**
+* Create an element streamer for a specific schema.
+* Useful for reusing the same schema across multiple prompts.
+*
+* @example
+* ```typescript
+* const streamTasks = createElementStreamer({
+*   model: anthropic('claude-sonnet'),
+*   elementSchema: taskSchema,
+* });
+*
+* // Use multiple times
+* const webAppTasks = await streamTasks('Break down building a web app');
+* const apiTasks = await streamTasks('Break down building an API');
+* ```
+*/
+function createElementStreamer(config) {
+	return async function stream(prompt, options) {
+		return collectElements({
+			...config,
+			prompt,
+			...options
+		});
+	};
+}
+/**
+* Create a collected element stream that returns all elements at once.
+* Simpler API when you don't need real-time updates.
+*
+* @example
+* ```typescript
+* const tasks = await collectElements({
+*   model,
+*   elementSchema: taskSchema,
+*   prompt: 'Generate 5 tasks',
+* });
+*
+* console.log(`Got ${tasks.length} tasks`);
+* ```
+*/
+async function collectElements(options) {
+	const { stream, elements } = streamElements(options);
+	for await (const _ of stream);
+	return elements;
+}
+/**
+* Composable wrapper for streaming array elements from experimental_output.
+*
+* This wraps a streamText result that uses experimental_output with Output.array(),
+* providing callbacks, transformations, and buffering capabilities.
+*
+* @param streamResult - Result from streamText with experimental_output
+* @param config - Configuration for element streaming
+* @returns Async generator yielding elements (potentially transformed/buffered)
+*
+* @example
+* ```typescript
+* import { streamText, Output } from 'ai';
+* import { withElementStream } from '@od-oneapp/ai-platform/output';
+* import { z } from 'zod';
+*
+* const TodoSchema = z.object({
+*   task: z.string(),
+*   priority: z.enum(['low', 'medium', 'high']),
+* });
+*
+* const result = streamText({
+*   model,
+*   prompt: 'List 10 todos',
+*   experimental_output: Output.array({ element: TodoSchema }),
+* });
+*
+* // Basic iteration with callback
+* const todos: z.infer<typeof TodoSchema>[] = [];
+* for await (const todo of withElementStream(result, {
+*   onElement: (t, i) => console.log(`Got todo ${i}: ${t.task}`),
+* })) {
+*   todos.push(todo);
+* }
+*
+* // With transformation
+* for await (const todo of withElementStream(result, {
+*   transform: (t) => ({ ...t, task: t.task.toUpperCase() }),
+* })) {
+*   console.log(todo.task); // UPPERCASE
+* }
+*
+* // With buffering (yields in batches)
+* for await (const todoBatch of withElementStream(result, {
+*   bufferSize: 5,
+*   onElement: (t, i) => console.log(`Buffered todo ${i}`),
+* })) {
+*   // todoBatch is an array of 5 todos (or fewer at the end)
+*   processBatch(todoBatch);
+* }
+* ```
+*/
+async function* withElementStream(streamResult, config) {
+	const { onElement, bufferSize, transform, onComplete, onError } = config ?? {};
+	const elementStream = streamResult.experimental_output?.elementStream;
+	if (!elementStream) {
+		const objectPromise = streamResult.experimental_output?.object;
+		if (objectPromise) try {
+			const elements = await objectPromise;
+			let index = 0;
+			if (bufferSize && bufferSize > 1) {
+				let buffer = [];
+				for (const element of elements) {
+					const transformed = transform ? transform(element) : element;
+					onElement?.(transformed, index);
+					buffer.push(transformed);
+					index++;
+					if (buffer.length >= bufferSize) {
+						yield buffer;
+						buffer = [];
+					}
+				}
+				if (buffer.length > 0) yield buffer;
+			} else for (const element of elements) {
+				const transformed = transform ? transform(element) : element;
+				onElement?.(transformed, index);
+				yield transformed;
+				index++;
+			}
+			const finalElements = transform ? elements.map(transform) : elements;
+			onComplete?.(finalElements, finalElements.length);
+		} catch (error) {
+			const err = error instanceof Error ? error : new Error(String(error));
+			onError?.(err);
+			throw err;
+		}
+		return;
+	}
+	try {
+		const allElements = [];
+		let index = 0;
+		let buffer = [];
+		for await (const element of elementStream) {
+			const transformed = transform ? transform(element) : element;
+			allElements.push(transformed);
+			onElement?.(transformed, index);
+			index++;
+			if (bufferSize && bufferSize > 1) {
+				buffer.push(transformed);
+				if (buffer.length >= bufferSize) {
+					yield buffer;
+					buffer = [];
+				}
+			} else yield transformed;
+		}
+		if (bufferSize && bufferSize > 1 && buffer.length > 0) yield buffer;
+		onComplete?.(allElements, allElements.length);
+	} catch (error) {
+		const err = error instanceof Error ? error : new Error(String(error));
+		onError?.(err);
+		throw err;
+	}
+}
+/**
+* Collect all elements from withElementStream into an array.
+* Convenience function for when you want all elements at once.
+*
+* @param streamResult - Result from streamText with experimental_output
+* @param config - Configuration for element streaming
+* @returns Promise resolving to array of all elements
+*
+* @example
+* ```typescript
+* const todos = await collectFromElementStream(result, {
+*   onElement: (t, i) => console.log(`Processing ${i}`),
+*   transform: (t) => ({ ...t, processed: true }),
+* });
+* ```
+*/
+async function collectFromElementStream(streamResult, config) {
+	const elements = [];
+	for await (const element of withElementStream(streamResult, config)) elements.push(element);
+	return elements;
+}
+
+//#endregion
+//#region src/output/validator.ts
+/**
+* @fileoverview Output Validator Module
+*
+* Provides schema-based validation for AI model outputs with configurable
+* error handling strategies including throw, partial recovery, and retry.
+*
+* @module @od-oneapp/ai-platform/output/validator
+*
+* @example
+* ```typescript
+* import { createOutputValidator } from '@od-oneapp/ai-platform/output';
+* import { z } from 'zod';
+*
+* const PersonSchema = z.object({
+*   name: z.string(),
+*   age: z.number(),
+*   email: z.string().email(),
+* });
+*
+* // Simple validation with throw strategy
+* const strictValidator = createOutputValidator({
+*   schema: PersonSchema,
+*   onValidationError: 'throw',
+* });
+*
+* try {
+*   const person = strictValidator.validate(rawOutput);
+* } catch (error) {
+*   console.error('Validation failed:', error);
+* }
+*
+* // Partial recovery strategy
+* const lenientValidator = createOutputValidator({
+*   schema: PersonSchema,
+*   onValidationError: 'partial',
+* });
+*
+* const result = lenientValidator.validate(rawOutput);
+* if (result.success) {
+*   console.log('Valid:', result.data);
+* } else {
+*   console.log('Partial:', result.partial, 'Errors:', result.errors);
+* }
+*
+* // Retry strategy with model
+* const retryValidator = createOutputValidator({
+*   schema: PersonSchema,
+*   onValidationError: 'retry',
+*   maxRetries: 2,
+* });
+*
+* const validated = await retryValidator.validateAsync(rawOutput, {
+*   model: openai('gpt-4'),
+*   prompt: 'Extract person info from: John, 30 years old',
+* });
+* ```
+*/
+/**
+* Custom error for validation failures with context.
+*/
+var OutputValidationError = class extends Error {
+	zodError;
+	strategy;
+	attempts;
+	constructor(message, zodError, strategy, attempts = 1) {
+		super(message);
+		this.name = "OutputValidationError";
+		this.zodError = zodError;
+		this.strategy = strategy;
+		this.attempts = attempts;
+	}
+};
+/**
+* Extract partial data from validation errors.
+* Attempts to keep valid fields while noting invalid ones.
+*/
+function extractPartialData(output, zodError) {
+	if (typeof output !== "object" || output === null) return;
+	const result = { ...output };
+	const invalidPaths = /* @__PURE__ */ new Set();
+	for (const issue of zodError.issues) if (issue.path.length > 0) invalidPaths.add(String(issue.path[0]));
+	for (const path of invalidPaths) delete result[path];
+	return Object.keys(result).length > 0 ? result : void 0;
+}
+/**
+* Build error message with custom prefix if provided.
+*/
+function buildErrorMessage(zodError, customPrefix) {
+	const issueMessages = zodError.issues.map((issue) => {
+		return `${issue.path.length > 0 ? issue.path.join(".") : "root"}: ${issue.message}`;
+	}).join("; ");
+	return customPrefix ? `${customPrefix}: ${issueMessages}` : `Validation failed: ${issueMessages}`;
+}
+/**
+* Delay helper for retries.
+*/
+function delay(ms) {
+	return new Promise((resolve) => setTimeout(resolve, ms));
+}
+/**
+* Create an output validator with configurable error handling.
+*
+* @param config - Validator configuration
+* @returns Output validator instance
+*
+* @example
+* ```typescript
+* // Throw strategy (strict validation)
+* const strictValidator = createOutputValidator({
+*   schema: UserSchema,
+*   onValidationError: 'throw',
+* });
+*
+* // Partial strategy (lenient validation with error details)
+* const lenientValidator = createOutputValidator({
+*   schema: UserSchema,
+*   onValidationError: 'partial',
+* });
+*
+* // Retry strategy (regenerate with model on failure)
+* const retryValidator = createOutputValidator({
+*   schema: UserSchema,
+*   onValidationError: 'retry',
+*   maxRetries: 3,
+*   retryDelay: 500,
+* });
+* ```
+*/
+function createOutputValidator(config) {
+	const { schema, onValidationError, maxRetries = 2, retryDelay = 1e3, errorMessage, onError } = config;
+	/**
+	* Synchronous validation.
+	*/
+	function validate(output) {
+		const result = schema.safeParse(output);
+		if (result.success) return result.data;
+		const zodError = result.error;
+		onError?.(zodError, 1);
+		switch (onValidationError) {
+			case "throw": throw new OutputValidationError(buildErrorMessage(zodError, errorMessage), zodError, "throw", 1);
+			case "partial": return {
+				success: false,
+				partial: extractPartialData(output, zodError),
+				errors: zodError.issues,
+				rawError: zodError
+			};
+			case "retry": throw new OutputValidationError(`${buildErrorMessage(zodError, errorMessage)} (use validateAsync for retry support)`, zodError, "retry", 1);
+		}
+	}
+	/**
+	* Asynchronous validation with retry support.
+	*/
+	async function validateAsync(output, retryContext) {
+		let currentOutput = output;
+		let lastError;
+		for (let attempt = 1; attempt <= maxRetries + 1; attempt++) {
+			const result = schema.safeParse(currentOutput);
+			if (result.success) {
+				if (attempt > 1) logInfo(`[OutputValidator] Validation succeeded on attempt ${attempt}`);
+				return result.data;
+			}
+			lastError = result.error;
+			onError?.(lastError, attempt);
+			if (onValidationError === "partial") return {
+				success: false,
+				partial: extractPartialData(currentOutput, lastError),
+				errors: lastError.issues,
+				rawError: lastError
+			};
+			if (onValidationError === "throw") throw new OutputValidationError(buildErrorMessage(lastError, errorMessage), lastError, "throw", attempt);
+			if (attempt <= maxRetries) {
+				if (!retryContext) throw new OutputValidationError("Retry strategy requires retryContext with model and prompt", lastError, "retry", attempt);
+				logWarn(`[OutputValidator] Validation failed on attempt ${attempt}/${maxRetries + 1}. Errors: ${lastError.issues.map((i) => i.message).join(", ")}. Retrying...`);
+				await delay(retryDelay * attempt);
+				try {
+					const { object } = await generateObject({
+						model: retryContext.model,
+						schema,
+						prompt: retryContext.prompt,
+						system: retryContext.system,
+						temperature: retryContext.temperature
+					});
+					currentOutput = object;
+				} catch (genError) {
+					logWarn(`[OutputValidator] Regeneration failed on attempt ${attempt}: ${genError instanceof Error ? genError.message : String(genError)}`);
+				}
+			}
+		}
+		if (lastError) throw new OutputValidationError(`${buildErrorMessage(lastError, errorMessage)} (exhausted ${maxRetries + 1} attempts)`, lastError, "retry", maxRetries + 1);
+		throw new Error("Validation failed with unknown error");
+	}
+	return {
+		validate,
+		validateAsync,
+		getSchema: () => schema,
+		getStrategy: () => onValidationError
+	};
+}
+/**
+* Check if an error is an OutputValidationError.
+*
+* @param error - Error to check
+* @returns True if error is OutputValidationError
+*/
+function isOutputValidationError(error) {
+	return error instanceof OutputValidationError;
+}
+/**
+* Create a simple validator that always throws on error.
+* Shorthand for createOutputValidator with 'throw' strategy.
+*
+* @param schema - Zod schema for validation
+* @returns Validator function
+*
+* @example
+* ```typescript
+* const validateUser = createStrictValidator(UserSchema);
+* const user = validateUser(rawData); // throws if invalid
+* ```
+*/
+function createStrictValidator(schema) {
+	const validator = createOutputValidator({
+		schema,
+		onValidationError: "throw"
+	});
+	return (output) => {
+		return validator.validate(output);
+	};
+}
+/**
+* Create a validator that returns partial data on error.
+* Shorthand for createOutputValidator with 'partial' strategy.
+*
+* @param schema - Zod schema for validation
+* @returns Validator function returning PartialValidationResult
+*
+* @example
+* ```typescript
+* const validateUser = createPartialValidator(UserSchema);
+* const result = validateUser(rawData);
+* if (!result.success) {
+*   console.log('Partial data:', result.partial);
+* }
+* ```
+*/
+function createPartialValidator(schema) {
+	const validator = createOutputValidator({
+		schema,
+		onValidationError: "partial"
+	});
+	return (output) => {
+		const result = validator.validate(output);
+		if (!result || typeof result !== "object" || !("success" in result)) return {
+			success: true,
+			data: result
+		};
+		return result;
+	};
+}
+
+//#endregion
+//#region src/output/errors.ts
+/**
+* NoObjectGeneratedError helpers and recovery strategies.
+*/
+const ErrorRecoveryStrategies = {
+	fallback: (fallback) => ({ fallback }),
+	ignore: () => ({})
+};
+function isNoObjectGeneratedError(error) {
+	return NoObjectGeneratedError.isInstance(error);
+}
+function handleNoObjectGenerated(error, options = {}) {
+	const info = {
+		cause: "no-object",
+		message: error.message,
+		text: error.text,
+		usage: error.usage
+	};
+	options.onError?.(info);
+	if (options.fallback !== void 0) return {
+		handled: true,
+		result: typeof options.fallback === "function" ? options.fallback(info) : options.fallback,
+		info
+	};
+	return {
+		handled: false,
+		error
+	};
+}
+function createNoObjectHandler(config = {}) {
+	return (error) => {
+		if (!isNoObjectGeneratedError(error)) return {
+			handled: false,
+			error: error instanceof Error ? error : new Error(String(error))
+		};
+		const result = handleNoObjectGenerated(error, config);
+		if (!result.handled && config.throwOnUnhandled) throw error;
+		return result;
+	};
+}
+function createStreamErrorHandler(options = {}) {
+	return (error) => {
+		if (isNoObjectGeneratedError(error)) {
+			const info = {
+				cause: "no-object",
+				message: error.message,
+				text: error.text,
+				usage: error.usage
+			};
+			options.onError?.(info);
+			return options.fallbackText ?? error.text ?? "";
+		}
+		return options.fallbackText ?? "";
+	};
+}
+
+//#endregion
+export { generateObjectWithRetry as C, streamStructuredObject as E, generateObjectWithFallback as S, safeGenerateObject as T, withElementStream as _, isNoObjectGeneratedError as a, createChoiceSchema as b, createPartialValidator as c, collectElements as d, collectFromElementStream as f, streamElementsWithProgress as g, streamElementsInBatches as h, handleNoObjectGenerated as i, createStrictValidator as l, streamElements as m, createNoObjectHandler as n, OutputValidationError as o, createElementStreamer as p, createStreamErrorHandler as r, createOutputValidator as s, ErrorRecoveryStrategies as t, isOutputValidationError as u, SchemaBuilders as v, generateStructuredObject as w, createObjectOutput as x, createArrayOutput as y };
+//# sourceMappingURL=errors-CQ8tF4dP.mjs.map