@od-oneapp/ai-platform 0.1.0

package/dist/controller-BOy3-xbC.mjs

@@ -0,0 +1,501 @@
+import { logWarn } from "@od-oneapp/shared/logs";
+
+//#region src/streaming/control/step-limit.ts
+/**
+* Creates a step counter for tracking agent execution steps.
+*
+* @param config - Step limit configuration.
+* @returns StepCounter instance for tracking and controlling steps.
+*
+* @remarks
+* The step counter tracks how many steps an agent has executed and
+* provides methods to check whether execution should stop or warn.
+*
+* Strategies:
+* - 'stop': shouldStop() returns true when limit is reached
+* - 'warn': shouldWarn() returns true, shouldStop() returns false
+* - 'continue': Both return false (only onLimitReached is called)
+*
+* @example
+* ```ts
+* const counter = createStepCounter({
+*   maxSteps: 5,
+*   strategy: 'warn',
+*   onLimitReached: (count) => {
+*     sendTelemetry({ event: 'step_limit_reached', count });
+*   }
+* });
+*
+* // In agent loop
+* while (hasMoreWork) {
+*   counter.increment();
+*
+*   if (counter.shouldWarn()) {
+*     console.warn('Step limit approaching');
+*   }
+*
+*   if (counter.shouldStop()) {
+*     break;
+*   }
+*
+*   await executeStep();
+* }
+* ```
+*/
+function createStepCounter(config) {
+	let count = 0;
+	const { maxSteps, onLimitReached, strategy = "stop" } = config;
+	let limitReachedCalled = false;
+	return {
+		increment() {
+			count += 1;
+			if (count >= maxSteps && !limitReachedCalled) {
+				limitReachedCalled = true;
+				onLimitReached?.(count);
+			}
+			return count;
+		},
+		getCount() {
+			return count;
+		},
+		shouldStop() {
+			if (strategy !== "stop") return false;
+			return count >= maxSteps;
+		},
+		shouldWarn() {
+			if (strategy !== "warn") return false;
+			return count >= maxSteps;
+		},
+		reset() {
+			count = 0;
+			limitReachedCalled = false;
+		}
+	};
+}
+/**
+* Creates a stopWhen condition function for AI SDK.
+* Returns true when the step count reaches the limit.
+*
+* @param maxSteps - Maximum number of steps before stopping.
+* @returns Function that takes step count and returns whether to stop.
+*
+* @remarks
+* This function returns a predicate that can be used with AI SDK's
+* stopWhen configuration to automatically stop agent loops.
+*
+* @example
+* ```ts
+* import { generateText } from 'ai';
+*
+* const result = await generateText({
+*   model: myModel,
+*   prompt: 'Complete this task',
+*   maxSteps: 10,
+*   stopWhen: createStepLimitCondition(10)
+* });
+* ```
+*/
+function createStepLimitCondition(maxSteps) {
+	return (state) => {
+		return state.steps >= maxSteps;
+	};
+}
+/**
+* Creates a step limiter that wraps an async function with step counting.
+*
+* @param config - Step limit configuration.
+* @param fn - Async function to wrap with step limiting.
+* @returns Wrapped function that increments counter before each call.
+*
+* @example
+* ```ts
+* const executeStep = async () => {
+*   // ... perform step logic
+* };
+*
+* const limitedExecuteStep = withStepLimit(
+*   { maxSteps: 5, strategy: 'stop' },
+*   executeStep
+* );
+*
+* // Will throw after 5 calls when strategy is 'stop'
+* await limitedExecuteStep();
+* ```
+*/
+function withStepLimit(config, fn) {
+	const counter = createStepCounter(config);
+	return async (...args) => {
+		if (counter.shouldStop()) throw new StepLimitExceededError(counter.getCount(), config.maxSteps);
+		counter.increment();
+		return fn(...args);
+	};
+}
+/**
+* Error thrown when step limit is exceeded with 'stop' strategy.
+*/
+var StepLimitExceededError = class extends Error {
+	/** Current step count when error was thrown. */
+	stepCount;
+	/** Maximum steps that were configured. */
+	maxSteps;
+	constructor(stepCount, maxSteps) {
+		super(`Step limit exceeded: ${stepCount}/${maxSteps} steps`);
+		this.name = "StepLimitExceededError";
+		this.stepCount = stepCount;
+		this.maxSteps = maxSteps;
+	}
+};
+
+//#endregion
+//#region src/streaming/control/smoothing.ts
+/** Default delay in milliseconds between chunks. */
+const DEFAULT_DELAY_MS = 10;
+/** Default chunking strategy. */
+const DEFAULT_CHUNKING = "word";
+/**
+* Creates a smooth stream transform configuration for AI SDK.
+*
+* @param config - Optional smooth stream configuration.
+* @returns Transform configuration compatible with AI SDK's smoothStream.
+*
+* @remarks
+* Stream smoothing helps create a more natural reading experience by:
+* - Adding small delays between chunks to simulate typing
+* - Chunking text at natural boundaries (words, lines, sentences)
+* - Preventing overwhelming the UI with rapid updates
+*
+* Chunking strategies:
+* - 'word': Emit at word boundaries (recommended for most cases)
+* - 'line': Emit at line breaks
+* - 'sentence': Emit at sentence boundaries
+*
+* @example
+* ```ts
+* // Default configuration (10ms delay, word chunking)
+* const defaultTransform = createSmoothStreamTransform();
+*
+* // Custom configuration
+* const customTransform = createSmoothStreamTransform({
+*   delayInMs: 30,
+*   chunking: 'sentence'
+* });
+* ```
+*/
+function createSmoothStreamTransform(config) {
+	const chunking = config?.chunking ?? DEFAULT_CHUNKING;
+	return {
+		delayInMs: config?.delayInMs ?? DEFAULT_DELAY_MS,
+		chunking
+	};
+}
+/**
+* Regex patterns for different chunking strategies.
+* Used to split text into chunks at natural boundaries.
+* @internal
+*/
+const CHUNKING_PATTERNS = {
+	word: /\s+/,
+	line: /\n/,
+	sentence: /(?<=[.!?])\s+/
+};
+/**
+* Splits text into chunks based on the configured strategy.
+*
+* @param text - Text to split into chunks.
+* @param chunking - Chunking strategy to use.
+* @param minChunkSize - Minimum chunk size before emitting.
+* @returns Array of text chunks.
+*
+* @example
+* ```ts
+* const chunks = splitIntoChunks('Hello world. How are you?', 'sentence');
+* // chunks = ['Hello world. ', 'How are you?']
+* ```
+*/
+function splitIntoChunks(text, chunking = "word", minChunkSize = 1) {
+	const pattern = CHUNKING_PATTERNS[chunking];
+	const parts = text.split(pattern);
+	if (minChunkSize <= 1) return parts.filter(Boolean);
+	const chunks = [];
+	let buffer = "";
+	for (const part of parts) {
+		buffer += part;
+		if (buffer.length >= minChunkSize) {
+			chunks.push(buffer);
+			buffer = "";
+		} else if (chunking !== "word") buffer += chunking === "line" ? "\n" : " ";
+		else buffer += " ";
+	}
+	if (buffer.trim()) chunks.push(buffer.trim());
+	return chunks;
+}
+/**
+* Creates an async generator that yields text chunks with delays.
+*
+* @param text - Text to stream.
+* @param config - Smooth stream configuration.
+* @yields Text chunks with configured delays.
+*
+* @example
+* ```ts
+* for await (const chunk of smoothTextGenerator('Hello world!', { delayInMs: 50 })) {
+*   process.stdout.write(chunk);
+* }
+* ```
+*/
+async function* smoothTextGenerator(text, config) {
+	const delay = config?.delayInMs ?? DEFAULT_DELAY_MS;
+	const chunks = splitIntoChunks(text, config?.chunking ?? DEFAULT_CHUNKING, config?.minChunkSize ?? 1);
+	for (const chunk of chunks) {
+		yield chunk;
+		if (delay > 0) await new Promise((resolve) => setTimeout(resolve, delay));
+	}
+}
+/**
+* Wraps an async iterable to add smooth streaming delays.
+*
+* @param source - Source async iterable of text chunks.
+* @param config - Smooth stream configuration.
+* @yields Text chunks with configured delays.
+*
+* @example
+* ```ts
+* const source = getStreamFromModel();
+* const smoothed = withSmoothStream(source, { delayInMs: 20 });
+*
+* for await (const chunk of smoothed) {
+*   // Chunks arrive with smooth delays
+* }
+* ```
+*/
+async function* withSmoothStream(source, config) {
+	const delay = config?.delayInMs ?? DEFAULT_DELAY_MS;
+	for await (const chunk of source) {
+		yield chunk;
+		if (delay > 0) await new Promise((resolve) => setTimeout(resolve, delay));
+	}
+}
+
+//#endregion
+//#region src/streaming/control/controller.ts
+/**
+* @fileoverview Stream controller for fluent composition.
+* @module @od-oneapp/ai-platform/streaming-control
+*
+* Provides a fluent API for composing streaming control configurations:
+* - Budget guards for token and cost limits
+* - Step limits for agent loop control
+* - Stream smoothing for improved UX
+*
+* @example
+* ```ts
+* import { createStreamController } from '@od-oneapp/ai-platform/streaming-control';
+*
+* const controller = createStreamController()
+*   .withBudgetGuard({
+*     maxTokens: 100_000,
+*     maxCost: 10.00,
+*     onBudgetExceeded: (usage, limit) => {
+*       console.error(`Budget exceeded: ${limit.type}`);
+*     }
+*   })
+*   .withStepLimit({
+*     maxSteps: 10,
+*     strategy: 'stop',
+*     onLimitReached: (count) => {
+*       console.log(`Reached ${count} steps`);
+*     }
+*   })
+*   .withSmoothStream({
+*     delayInMs: 20,
+*     chunking: 'word'
+*   });
+*
+* const config = controller.getConfig();
+* ```
+*/
+/**
+* Internal implementation of StreamController.
+* @internal
+*/
+var StreamControllerImpl = class StreamControllerImpl {
+	config;
+	constructor(initialConfig = {}) {
+		this.config = { ...initialConfig };
+	}
+	/**
+	* Adds budget guard configuration.
+	* Merges with existing budget guard config if present.
+	*/
+	withBudgetGuard(budgetConfig) {
+		return new StreamControllerImpl({
+			...this.config,
+			budgetGuard: {
+				...this.config.budgetGuard,
+				...budgetConfig,
+				costTable: {
+					...this.config.budgetGuard?.costTable,
+					...budgetConfig.costTable
+				}
+			}
+		});
+	}
+	/**
+	* Adds step limit configuration.
+	* Replaces existing step limit config if present.
+	*/
+	withStepLimit(stepConfig) {
+		return new StreamControllerImpl({
+			...this.config,
+			stepLimit: stepConfig
+		});
+	}
+	/**
+	* Adds smooth stream configuration.
+	* Merges with existing smooth stream config if present.
+	*/
+	withSmoothStream(smoothConfig) {
+		return new StreamControllerImpl({
+			...this.config,
+			smoothStream: {
+				...this.config.smoothStream,
+				...smoothConfig
+			}
+		});
+	}
+	/**
+	* Gets the combined configuration.
+	*/
+	getConfig() {
+		return { ...this.config };
+	}
+};
+/**
+* Creates a new stream controller for fluent composition.
+*
+* @param initialConfig - Optional initial configuration.
+* @returns StreamController instance for chaining.
+*
+* @remarks
+* The stream controller provides a fluent API for building
+* streaming control configurations. Each method returns a new
+* controller instance, making the configuration immutable.
+*
+* @example
+* ```ts
+* // Basic usage
+* const controller = createStreamController()
+*   .withBudgetGuard({ maxTokens: 50_000 })
+*   .withStepLimit({ maxSteps: 5 });
+*
+* // With initial config
+* const controller2 = createStreamController({
+*   smoothStream: { delayInMs: 10 }
+* }).withBudgetGuard({ maxCost: 5.00 });
+*
+* // Get final config
+* const config = controller.getConfig();
+* // config = {
+* //   budgetGuard: { maxTokens: 50_000 },
+* //   stepLimit: { maxSteps: 5 }
+* // }
+* ```
+*/
+function createStreamController(initialConfig) {
+	return new StreamControllerImpl(initialConfig);
+}
+/**
+* Merges multiple stream controller configs into one.
+*
+* @param configs - Array of configs to merge.
+* @returns Merged StreamControllerConfig.
+*
+* @example
+* ```ts
+* const budgetConfig = createStreamController()
+*   .withBudgetGuard({ maxTokens: 100_000 })
+*   .getConfig();
+*
+* const stepConfig = createStreamController()
+*   .withStepLimit({ maxSteps: 10 })
+*   .getConfig();
+*
+* const merged = mergeStreamConfigs([budgetConfig, stepConfig]);
+* ```
+*/
+function mergeStreamConfigs(configs) {
+	let result = createStreamController();
+	for (const config of configs) {
+		if (config.budgetGuard) result = result.withBudgetGuard(config.budgetGuard);
+		if (config.stepLimit) result = result.withStepLimit(config.stepLimit);
+		if (config.smoothStream) result = result.withSmoothStream(config.smoothStream);
+	}
+	return result.getConfig();
+}
+/**
+* Creates a preset configuration for development/testing.
+* Higher limits and verbose callbacks.
+*
+* @returns StreamController with development presets.
+*
+* @example
+* ```ts
+* const devController = createDevStreamController();
+* const config = devController.getConfig();
+* ```
+*/
+function createDevStreamController() {
+	return createStreamController().withBudgetGuard({
+		maxTokens: 5e5,
+		maxCost: 50,
+		onBudgetExceeded: (usage, limit) => {
+			logWarn("[DEV] Budget exceeded", {
+				usage,
+				limit
+			});
+		}
+	}).withStepLimit({
+		maxSteps: 20,
+		strategy: "warn",
+		onLimitReached: (count) => {
+			logWarn("[DEV] Step limit reached", { count });
+		}
+	}).withSmoothStream({
+		delayInMs: 5,
+		chunking: "word"
+	});
+}
+/**
+* Creates a preset configuration for production.
+* Conservative limits and minimal overhead.
+*
+* @param options - Production configuration options.
+* @returns StreamController with production presets.
+*
+* @example
+* ```ts
+* const prodController = createProdStreamController({
+*   maxTokens: 100_000,
+*   maxCost: 10.00,
+*   maxSteps: 10
+* });
+* ```
+*/
+function createProdStreamController(options) {
+	return createStreamController().withBudgetGuard({
+		maxTokens: options?.maxTokens ?? 1e5,
+		maxCost: options?.maxCost ?? 10,
+		onBudgetExceeded: options?.onBudgetExceeded
+	}).withStepLimit({
+		maxSteps: options?.maxSteps ?? 10,
+		strategy: "stop",
+		onLimitReached: options?.onStepLimitReached
+	}).withSmoothStream({
+		delayInMs: 10,
+		chunking: "word"
+	});
+}
+
+//#endregion
+export { createSmoothStreamTransform as a, withSmoothStream as c, createStepLimitCondition as d, withStepLimit as f, mergeStreamConfigs as i, StepLimitExceededError as l, createProdStreamController as n, smoothTextGenerator as o, createStreamController as r, splitIntoChunks as s, createDevStreamController as t, createStepCounter as u };
+//# sourceMappingURL=controller-BOy3-xbC.mjs.map

package/dist/controller-BOy3-xbC.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"controller-BOy3-xbC.mjs","names":[],"sources":["../src/streaming/control/step-limit.ts","../src/streaming/control/smoothing.ts","../src/streaming/control/controller.ts"],"sourcesContent":["/**\n * @fileoverview Step limit utilities for agent loop control.\n * @module @od-oneapp/ai-platform/streaming-control\n *\n * Provides functions for controlling agent execution steps:\n * - Step counter with configurable strategies\n * - Stop condition generators for AI SDK integration\n *\n * @example\n * ```ts\n * import { createStepCounter, createStepLimitCondition } from '@od-oneapp/ai-platform/streaming-control';\n *\n * const counter = createStepCounter({\n *   maxSteps: 10,\n *   strategy: 'stop',\n *   onLimitReached: (count) => console.log(`Reached ${count} steps`)\n * });\n *\n * counter.increment();\n * if (counter.shouldStop()) {\n *   // Stop agent execution\n * }\n * ```\n */\n\nimport { type StepCounter, type StepLimitConfig } from './types';\n\n/**\n * Creates a step counter for tracking agent execution steps.\n *\n * @param config - Step limit configuration.\n * @returns StepCounter instance for tracking and controlling steps.\n *\n * @remarks\n * The step counter tracks how many steps an agent has executed and\n * provides methods to check whether execution should stop or warn.\n *\n * Strategies:\n * - 'stop': shouldStop() returns true when limit is reached\n * - 'warn': shouldWarn() returns true, shouldStop() returns false\n * - 'continue': Both return false (only onLimitReached is called)\n *\n * @example\n * ```ts\n * const counter = createStepCounter({\n *   maxSteps: 5,\n *   strategy: 'warn',\n *   onLimitReached: (count) => {\n *     sendTelemetry({ event: 'step_limit_reached', count });\n *   }\n * });\n *\n * // In agent loop\n * while (hasMoreWork) {\n *   counter.increment();\n *\n *   if (counter.shouldWarn()) {\n *     console.warn('Step limit approaching');\n *   }\n *\n *   if (counter.shouldStop()) {\n *     break;\n *   }\n *\n *   await executeStep();\n * }\n * ```\n */\nexport function createStepCounter(config: StepLimitConfig): StepCounter {\n  let count = 0;\n  const { maxSteps, onLimitReached, strategy = 'stop' } = config;\n  let limitReachedCalled = false;\n\n  return {\n    /**\n     * Increments the step counter.\n     * Calls onLimitReached when limit is first reached.\n     * @returns The new step count.\n     */\n    increment(): number {\n      count += 1;\n\n      if (count >= maxSteps && !limitReachedCalled) {\n        limitReachedCalled = true;\n        onLimitReached?.(count);\n      }\n\n      return count;\n    },\n\n    /**\n     * Gets the current step count.\n     * @returns Current number of steps executed.\n     */\n    getCount(): number {\n      return count;\n    },\n\n    /**\n     * Checks if agent should stop based on strategy.\n     * @returns true if strategy is 'stop' and limit is reached.\n     */\n    shouldStop(): boolean {\n      if (strategy !== 'stop') {\n        return false;\n      }\n      return count >= maxSteps;\n    },\n\n    /**\n     * Checks if a warning should be emitted.\n     * @returns true if strategy is 'warn' and limit is reached.\n     */\n    shouldWarn(): boolean {\n      if (strategy !== 'warn') {\n        return false;\n      }\n      return count >= maxSteps;\n    },\n\n    /**\n     * Resets the counter to zero.\n     */\n    reset(): void {\n      count = 0;\n      limitReachedCalled = false;\n    },\n  };\n}\n\n/**\n * Creates a stopWhen condition function for AI SDK.\n * Returns true when the step count reaches the limit.\n *\n * @param maxSteps - Maximum number of steps before stopping.\n * @returns Function that takes step count and returns whether to stop.\n *\n * @remarks\n * This function returns a predicate that can be used with AI SDK's\n * stopWhen configuration to automatically stop agent loops.\n *\n * @example\n * ```ts\n * import { generateText } from 'ai';\n *\n * const result = await generateText({\n *   model: myModel,\n *   prompt: 'Complete this task',\n *   maxSteps: 10,\n *   stopWhen: createStepLimitCondition(10)\n * });\n * ```\n */\nexport function createStepLimitCondition(maxSteps: number): (state: { steps: number }) => boolean {\n  return (state: { steps: number }): boolean => {\n    return state.steps >= maxSteps;\n  };\n}\n\n/**\n * Creates a step limiter that wraps an async function with step counting.\n *\n * @param config - Step limit configuration.\n * @param fn - Async function to wrap with step limiting.\n * @returns Wrapped function that increments counter before each call.\n *\n * @example\n * ```ts\n * const executeStep = async () => {\n *   // ... perform step logic\n * };\n *\n * const limitedExecuteStep = withStepLimit(\n *   { maxSteps: 5, strategy: 'stop' },\n *   executeStep\n * );\n *\n * // Will throw after 5 calls when strategy is 'stop'\n * await limitedExecuteStep();\n * ```\n */\nexport function withStepLimit<TArgs extends unknown[], TResult>(\n  config: StepLimitConfig,\n  fn: (...args: TArgs) => Promise<TResult>,\n): (...args: TArgs) => Promise<TResult> {\n  const counter = createStepCounter(config);\n\n  return async (...args: TArgs): Promise<TResult> => {\n    // Check if we've already reached the limit before executing\n    if (counter.shouldStop()) {\n      throw new StepLimitExceededError(counter.getCount(), config.maxSteps);\n    }\n\n    counter.increment();\n\n    return fn(...args);\n  };\n}\n\n/**\n * Error thrown when step limit is exceeded with 'stop' strategy.\n */\nexport class StepLimitExceededError extends Error {\n  /** Current step count when error was thrown. */\n  readonly stepCount: number;\n  /** Maximum steps that were configured. */\n  readonly maxSteps: number;\n\n  constructor(stepCount: number, maxSteps: number) {\n    super(`Step limit exceeded: ${stepCount}/${maxSteps} steps`);\n    this.name = 'StepLimitExceededError';\n    this.stepCount = stepCount;\n    this.maxSteps = maxSteps;\n  }\n}\n","/**\n * @fileoverview Stream smoothing utilities for improved UX.\n * @module @od-oneapp/ai-platform/streaming-control\n *\n * Provides utilities for smoothing streaming responses:\n * - Transform configuration for AI SDK's smoothStream option\n * - Chunking strategies (word, line, sentence)\n * - Configurable delay between chunks\n *\n * @example\n * ```ts\n * import { createSmoothStreamTransform } from '@od-oneapp/ai-platform/streaming-control';\n * import { streamText, smoothStream } from 'ai';\n *\n * const transform = createSmoothStreamTransform({\n *   delayInMs: 20,\n *   chunking: 'word'\n * });\n *\n * const result = await streamText({\n *   model: myModel,\n *   prompt: 'Hello',\n *   experimental_transform: smoothStream(transform)\n * });\n * ```\n */\n\nimport { type SmoothStreamConfig, type SmoothStreamTransform } from './types';\n\n/** Default delay in milliseconds between chunks. */\nconst DEFAULT_DELAY_MS = 10;\n\n/** Default chunking strategy. */\nconst DEFAULT_CHUNKING = 'word' as const;\n\n/**\n * Creates a smooth stream transform configuration for AI SDK.\n *\n * @param config - Optional smooth stream configuration.\n * @returns Transform configuration compatible with AI SDK's smoothStream.\n *\n * @remarks\n * Stream smoothing helps create a more natural reading experience by:\n * - Adding small delays between chunks to simulate typing\n * - Chunking text at natural boundaries (words, lines, sentences)\n * - Preventing overwhelming the UI with rapid updates\n *\n * Chunking strategies:\n * - 'word': Emit at word boundaries (recommended for most cases)\n * - 'line': Emit at line breaks\n * - 'sentence': Emit at sentence boundaries\n *\n * @example\n * ```ts\n * // Default configuration (10ms delay, word chunking)\n * const defaultTransform = createSmoothStreamTransform();\n *\n * // Custom configuration\n * const customTransform = createSmoothStreamTransform({\n *   delayInMs: 30,\n *   chunking: 'sentence'\n * });\n * ```\n */\nexport function createSmoothStreamTransform(config?: SmoothStreamConfig): SmoothStreamTransform {\n  const chunking: 'word' | 'line' | 'sentence' = config?.chunking ?? DEFAULT_CHUNKING;\n  return {\n    delayInMs: config?.delayInMs ?? DEFAULT_DELAY_MS,\n    chunking,\n  };\n}\n\n/**\n * Regex patterns for different chunking strategies.\n * Used to split text into chunks at natural boundaries.\n * @internal\n */\nconst CHUNKING_PATTERNS: Record<NonNullable<SmoothStreamConfig['chunking']>, RegExp> = {\n  word: /\\s+/,\n  line: /\\n/,\n  sentence: /(?<=[.!?])\\s+/,\n};\n\n/**\n * Splits text into chunks based on the configured strategy.\n *\n * @param text - Text to split into chunks.\n * @param chunking - Chunking strategy to use.\n * @param minChunkSize - Minimum chunk size before emitting.\n * @returns Array of text chunks.\n *\n * @example\n * ```ts\n * const chunks = splitIntoChunks('Hello world. How are you?', 'sentence');\n * // chunks = ['Hello world. ', 'How are you?']\n * ```\n */\nexport function splitIntoChunks(\n  text: string,\n  chunking: NonNullable<SmoothStreamConfig['chunking']> = 'word',\n  minChunkSize = 1,\n): string[] {\n  const pattern = CHUNKING_PATTERNS[chunking];\n  const parts = text.split(pattern);\n\n  if (minChunkSize <= 1) {\n    return parts.filter(Boolean);\n  }\n\n  // Combine small chunks to meet minimum size\n  const chunks: string[] = [];\n  let buffer = '';\n\n  for (const part of parts) {\n    buffer += part;\n\n    if (buffer.length >= minChunkSize) {\n      chunks.push(buffer);\n      buffer = '';\n    } else {\n      // Add back the delimiter for non-word chunking\n      if (chunking !== 'word') {\n        buffer += chunking === 'line' ? '\\n' : ' ';\n      } else {\n        buffer += ' ';\n      }\n    }\n  }\n\n  // Push any remaining buffer\n  if (buffer.trim()) {\n    chunks.push(buffer.trim());\n  }\n\n  return chunks;\n}\n\n/**\n * Creates an async generator that yields text chunks with delays.\n *\n * @param text - Text to stream.\n * @param config - Smooth stream configuration.\n * @yields Text chunks with configured delays.\n *\n * @example\n * ```ts\n * for await (const chunk of smoothTextGenerator('Hello world!', { delayInMs: 50 })) {\n *   process.stdout.write(chunk);\n * }\n * ```\n */\nexport async function* smoothTextGenerator(\n  text: string,\n  config?: SmoothStreamConfig,\n): AsyncGenerator<string> {\n  const delay = config?.delayInMs ?? DEFAULT_DELAY_MS;\n  const chunking = config?.chunking ?? DEFAULT_CHUNKING;\n  const minChunkSize = config?.minChunkSize ?? 1;\n\n  const chunks = splitIntoChunks(text, chunking, minChunkSize);\n\n  for (const chunk of chunks) {\n    yield chunk;\n\n    if (delay > 0) {\n      await new Promise(resolve => setTimeout(resolve, delay));\n    }\n  }\n}\n\n/**\n * Wraps an async iterable to add smooth streaming delays.\n *\n * @param source - Source async iterable of text chunks.\n * @param config - Smooth stream configuration.\n * @yields Text chunks with configured delays.\n *\n * @example\n * ```ts\n * const source = getStreamFromModel();\n * const smoothed = withSmoothStream(source, { delayInMs: 20 });\n *\n * for await (const chunk of smoothed) {\n *   // Chunks arrive with smooth delays\n * }\n * ```\n */\nexport async function* withSmoothStream(\n  source: AsyncIterable<string>,\n  config?: SmoothStreamConfig,\n): AsyncGenerator<string> {\n  const delay = config?.delayInMs ?? DEFAULT_DELAY_MS;\n\n  for await (const chunk of source) {\n    yield chunk;\n\n    if (delay > 0) {\n      await new Promise(resolve => setTimeout(resolve, delay));\n    }\n  }\n}\n","/**\n * @fileoverview Stream controller for fluent composition.\n * @module @od-oneapp/ai-platform/streaming-control\n *\n * Provides a fluent API for composing streaming control configurations:\n * - Budget guards for token and cost limits\n * - Step limits for agent loop control\n * - Stream smoothing for improved UX\n *\n * @example\n * ```ts\n * import { createStreamController } from '@od-oneapp/ai-platform/streaming-control';\n *\n * const controller = createStreamController()\n *   .withBudgetGuard({\n *     maxTokens: 100_000,\n *     maxCost: 10.00,\n *     onBudgetExceeded: (usage, limit) => {\n *       console.error(`Budget exceeded: ${limit.type}`);\n *     }\n *   })\n *   .withStepLimit({\n *     maxSteps: 10,\n *     strategy: 'stop',\n *     onLimitReached: (count) => {\n *       console.log(`Reached ${count} steps`);\n *     }\n *   })\n *   .withSmoothStream({\n *     delayInMs: 20,\n *     chunking: 'word'\n *   });\n *\n * const config = controller.getConfig();\n * ```\n */\n\nimport { logWarn } from '@repo/shared/logs';\n\nimport {\n  type BudgetGuardConfig,\n  type SmoothStreamConfig,\n  type StepLimitConfig,\n  type StreamController,\n  type StreamControllerConfig,\n} from './types';\n\n/**\n * Internal implementation of StreamController.\n * @internal\n */\nclass StreamControllerImpl implements StreamController {\n  private config: StreamControllerConfig;\n\n  constructor(initialConfig: StreamControllerConfig = {}) {\n    this.config = { ...initialConfig };\n  }\n\n  /**\n   * Adds budget guard configuration.\n   * Merges with existing budget guard config if present.\n   */\n  withBudgetGuard(budgetConfig: BudgetGuardConfig): StreamController {\n    return new StreamControllerImpl({\n      ...this.config,\n      budgetGuard: {\n        ...this.config.budgetGuard,\n        ...budgetConfig,\n        // Merge cost tables if both exist\n        costTable: {\n          ...this.config.budgetGuard?.costTable,\n          ...budgetConfig.costTable,\n        },\n      },\n    });\n  }\n\n  /**\n   * Adds step limit configuration.\n   * Replaces existing step limit config if present.\n   */\n  withStepLimit(stepConfig: StepLimitConfig): StreamController {\n    return new StreamControllerImpl({\n      ...this.config,\n      stepLimit: stepConfig,\n    });\n  }\n\n  /**\n   * Adds smooth stream configuration.\n   * Merges with existing smooth stream config if present.\n   */\n  withSmoothStream(smoothConfig: SmoothStreamConfig): StreamController {\n    return new StreamControllerImpl({\n      ...this.config,\n      smoothStream: {\n        ...this.config.smoothStream,\n        ...smoothConfig,\n      },\n    });\n  }\n\n  /**\n   * Gets the combined configuration.\n   */\n  getConfig(): StreamControllerConfig {\n    return { ...this.config };\n  }\n}\n\n/**\n * Creates a new stream controller for fluent composition.\n *\n * @param initialConfig - Optional initial configuration.\n * @returns StreamController instance for chaining.\n *\n * @remarks\n * The stream controller provides a fluent API for building\n * streaming control configurations. Each method returns a new\n * controller instance, making the configuration immutable.\n *\n * @example\n * ```ts\n * // Basic usage\n * const controller = createStreamController()\n *   .withBudgetGuard({ maxTokens: 50_000 })\n *   .withStepLimit({ maxSteps: 5 });\n *\n * // With initial config\n * const controller2 = createStreamController({\n *   smoothStream: { delayInMs: 10 }\n * }).withBudgetGuard({ maxCost: 5.00 });\n *\n * // Get final config\n * const config = controller.getConfig();\n * // config = {\n * //   budgetGuard: { maxTokens: 50_000 },\n * //   stepLimit: { maxSteps: 5 }\n * // }\n * ```\n */\nexport function createStreamController(initialConfig?: StreamControllerConfig): StreamController {\n  return new StreamControllerImpl(initialConfig);\n}\n\n/**\n * Merges multiple stream controller configs into one.\n *\n * @param configs - Array of configs to merge.\n * @returns Merged StreamControllerConfig.\n *\n * @example\n * ```ts\n * const budgetConfig = createStreamController()\n *   .withBudgetGuard({ maxTokens: 100_000 })\n *   .getConfig();\n *\n * const stepConfig = createStreamController()\n *   .withStepLimit({ maxSteps: 10 })\n *   .getConfig();\n *\n * const merged = mergeStreamConfigs([budgetConfig, stepConfig]);\n * ```\n */\nexport function mergeStreamConfigs(configs: StreamControllerConfig[]): StreamControllerConfig {\n  let result = createStreamController();\n\n  for (const config of configs) {\n    if (config.budgetGuard) {\n      result = result.withBudgetGuard(config.budgetGuard);\n    }\n    if (config.stepLimit) {\n      result = result.withStepLimit(config.stepLimit);\n    }\n    if (config.smoothStream) {\n      result = result.withSmoothStream(config.smoothStream);\n    }\n  }\n\n  return result.getConfig();\n}\n\n/**\n * Creates a preset configuration for development/testing.\n * Higher limits and verbose callbacks.\n *\n * @returns StreamController with development presets.\n *\n * @example\n * ```ts\n * const devController = createDevStreamController();\n * const config = devController.getConfig();\n * ```\n */\nexport function createDevStreamController(): StreamController {\n  return createStreamController()\n    .withBudgetGuard({\n      maxTokens: 500_000,\n      maxCost: 50.0,\n      onBudgetExceeded: (usage, limit) => {\n        logWarn('[DEV] Budget exceeded', { usage, limit });\n      },\n    })\n    .withStepLimit({\n      maxSteps: 20,\n      strategy: 'warn',\n      onLimitReached: count => {\n        logWarn('[DEV] Step limit reached', { count });\n      },\n    })\n    .withSmoothStream({\n      delayInMs: 5,\n      chunking: 'word',\n    });\n}\n\n/**\n * Creates a preset configuration for production.\n * Conservative limits and minimal overhead.\n *\n * @param options - Production configuration options.\n * @returns StreamController with production presets.\n *\n * @example\n * ```ts\n * const prodController = createProdStreamController({\n *   maxTokens: 100_000,\n *   maxCost: 10.00,\n *   maxSteps: 10\n * });\n * ```\n */\nexport function createProdStreamController(options?: {\n  maxTokens?: number;\n  maxCost?: number;\n  maxSteps?: number;\n  onBudgetExceeded?: BudgetGuardConfig['onBudgetExceeded'];\n  onStepLimitReached?: StepLimitConfig['onLimitReached'];\n}): StreamController {\n  return createStreamController()\n    .withBudgetGuard({\n      maxTokens: options?.maxTokens ?? 100_000,\n      maxCost: options?.maxCost ?? 10.0,\n      onBudgetExceeded: options?.onBudgetExceeded,\n    })\n    .withStepLimit({\n      maxSteps: options?.maxSteps ?? 10,\n      strategy: 'stop',\n      onLimitReached: options?.onStepLimitReached,\n    })\n    .withSmoothStream({\n      delayInMs: 10,\n      chunking: 'word',\n    });\n}\n"],"mappings":"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"}

package/dist/controller-Y0NGosbJ.d.mts

@@ -0,0 +1,104 @@
+//#region src/streaming/control/types.d.ts
+interface TokenUsage {
+  readonly promptTokens: number;
+  readonly completionTokens: number;
+  readonly totalTokens: number;
+}
+interface BudgetLimit {
+  readonly type: 'tokens' | 'cost';
+  readonly limit: number;
+  readonly actual: number;
+}
+interface CostEntry {
+  readonly input: number;
+  readonly output: number;
+}
+interface BudgetGuardConfig {
+  readonly maxTokens?: number;
+  readonly maxCost?: number;
+  readonly costTable?: Record<string, CostEntry>;
+  readonly onBudgetExceeded?: (usage: TokenUsage, limit: BudgetLimit) => void;
+}
+interface StepLimitConfig {
+  readonly maxSteps: number;
+  readonly onLimitReached?: (stepCount: number) => void;
+  readonly strategy?: 'stop' | 'warn' | 'continue';
+}
+interface SmoothStreamConfig {
+  readonly delayInMs?: number;
+  readonly chunking?: 'word' | 'line' | 'sentence';
+  readonly minChunkSize?: number;
+}
+interface StreamControllerConfig {
+  readonly budgetGuard?: BudgetGuardConfig;
+  readonly stepLimit?: StepLimitConfig;
+  readonly smoothStream?: SmoothStreamConfig;
+}
+interface StreamController {
+  withBudgetGuard(config: BudgetGuardConfig): StreamController;
+  withStepLimit(config: StepLimitConfig): StreamController;
+  withSmoothStream(config: SmoothStreamConfig): StreamController;
+  getConfig(): StreamControllerConfig;
+}
+interface BudgetCheckResult {
+  readonly exceeded: boolean;
+  readonly limit?: BudgetLimit;
+}
+interface StepCounter {
+  increment(): number;
+  getCount(): number;
+  shouldStop(): boolean;
+  shouldWarn(): boolean;
+  reset(): void;
+}
+interface SmoothStreamTransform {
+  readonly delayInMs: number;
+  readonly chunking: 'word' | 'line' | 'sentence';
+}
+//#endregion
+//#region src/streaming/control/budget-guard.d.ts
+declare const DEFAULT_COST_TABLE: Record<string, CostEntry>;
+declare function calculateCost(usage: TokenUsage, modelId: string, costTable?: Record<string, CostEntry>): number;
+declare function createBudgetChecker(config: BudgetGuardConfig): (usage: TokenUsage, modelId: string) => BudgetCheckResult;
+interface OnFinishResult {
+  usage?: {
+    promptTokens: number;
+    completionTokens: number;
+    totalTokens?: number;
+  };
+}
+declare function createBudgetGuardedOnFinish(config: BudgetGuardConfig, modelId: string): (result: OnFinishResult) => void;
+declare function estimateCost(estimatedPromptTokens: number, estimatedCompletionTokens: number, modelId: string, costTable?: Record<string, CostEntry>): number;
+//#endregion
+//#region src/streaming/control/step-limit.d.ts
+declare function createStepCounter(config: StepLimitConfig): StepCounter;
+declare function createStepLimitCondition(maxSteps: number): (state: {
+  steps: number;
+}) => boolean;
+declare function withStepLimit<TArgs extends unknown[], TResult>(config: StepLimitConfig, fn: (...args: TArgs) => Promise<TResult>): (...args: TArgs) => Promise<TResult>;
+declare class StepLimitExceededError extends Error {
+  readonly stepCount: number;
+  readonly maxSteps: number;
+  constructor(stepCount: number, maxSteps: number);
+}
+//#endregion
+//#region src/streaming/control/smoothing.d.ts
+declare function createSmoothStreamTransform(config?: SmoothStreamConfig): SmoothStreamTransform;
+declare function splitIntoChunks(text: string, chunking?: NonNullable<SmoothStreamConfig['chunking']>, minChunkSize?: number): string[];
+declare function smoothTextGenerator(text: string, config?: SmoothStreamConfig): AsyncGenerator<string>;
+declare function withSmoothStream(source: AsyncIterable<string>, config?: SmoothStreamConfig): AsyncGenerator<string>;
+//#endregion
+//#region src/streaming/control/controller.d.ts
+declare function createStreamController(initialConfig?: StreamControllerConfig): StreamController;
+declare function mergeStreamConfigs(configs: StreamControllerConfig[]): StreamControllerConfig;
+declare function createDevStreamController(): StreamController;
+declare function createProdStreamController(options?: {
+  maxTokens?: number;
+  maxCost?: number;
+  maxSteps?: number;
+  onBudgetExceeded?: BudgetGuardConfig['onBudgetExceeded'];
+  onStepLimitReached?: StepLimitConfig['onLimitReached'];
+}): StreamController;
+//#endregion
+export { SmoothStreamConfig as C, StreamController as D, StepLimitConfig as E, StreamControllerConfig as O, CostEntry as S, StepCounter as T, createBudgetGuardedOnFinish as _, createSmoothStreamTransform as a, BudgetGuardConfig as b, withSmoothStream as c, createStepLimitCondition as d, withStepLimit as f, createBudgetChecker as g, calculateCost as h, mergeStreamConfigs as i, TokenUsage as k, StepLimitExceededError as l, OnFinishResult as m, createProdStreamController as n, smoothTextGenerator as o, DEFAULT_COST_TABLE as p, createStreamController as r, splitIntoChunks as s, createDevStreamController as t, createStepCounter as u, estimateCost as v, SmoothStreamTransform as w, BudgetLimit as x, BudgetCheckResult as y };
+//# sourceMappingURL=controller-Y0NGosbJ.d.mts.map

package/dist/controller-Y0NGosbJ.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"controller-Y0NGosbJ.d.mts","names":[],"sources":["../src/streaming/control/types.ts","../src/streaming/control/budget-guard.ts","../src/streaming/control/step-limit.ts","../src/streaming/control/smoothing.ts","../src/streaming/control/controller.ts"],"mappings":"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"}