@superblocksteam/vite-plugin-file-sync 2.0.59-next.1 → 2.0.59-next.3

package/dist/ai-service/llm/interaction/adapters/vercel.js

@@ -0,0 +1,110 @@
+/**
+ * Vercel AI SDK adapter for StreamTextProvider.
+ *
+ * This adapter bridges our high-level StreamTextProvider interface
+ * to the Vercel AI SDK's streamText function. It handles:
+ * - Mapping our options to SDK options
+ * - Adding onFinally support via stream wrapping
+ * - Translating SDK results to our interface
+ *
+ * This is the only place that depends on Vercel AI SDK internals.
+ * All other code (middlewares, etc.) depends only on our interface.
+ */
+import { streamText } from "ai";
+import { withStreamLifecycle } from "../stream-lifecycle.js";
+/**
+ * Adapter that implements StreamTextProvider using Vercel AI SDK.
+ *
+ * This class wraps Vercel's streamText function and adds our custom
+ * lifecycle management (particularly onFinally support).
+ *
+ * @example
+ * ```typescript
+ * const provider = new VercelStreamTextAdapter();
+ * const result = await provider.streamText({
+ *   model: anthropic('claude-3-5-sonnet-20241022'),
+ *   messages: [{ role: 'user', content: 'Hello!' }],
+ *   onFinally: async () => {
+ *     console.log('Stream consumed!');
+ *   }
+ * });
+ *
+ * for await (const text of result.textStream) {
+ *   console.log(text);
+ * }
+ * // onFinally runs here
+ * ```
+ */
+export class VercelStreamTextAdapter {
+    /**
+     * Streams text using Vercel AI SDK with lifecycle management.
+     *
+     * @param options - Stream options including onFinally hook
+     * @returns Promise resolving to stream result
+     */
+    async streamText(options) {
+        // Extract our custom options that SDK doesn't support
+        const { onFinally, user, ...rest } = options;
+        // Validate that messages are provided (either directly or via user)
+        if (!rest.messages && !user) {
+            throw new Error("Either messages or user must be provided to streamText");
+        }
+        // Call Vercel SDK's streamText with proper generic types
+        // TOOLS: The tools type parameter from our method signature
+        // any, any: OUTPUT and PARTIAL_OUTPUT (we don't use structured outputs)
+        const result = streamText({
+            model: rest.model,
+            messages: rest.messages || (user ? [user] : []),
+            system: rest.system,
+            tools: rest.tools,
+            ...(rest.maxSteps !== undefined && { maxSteps: rest.maxSteps }),
+            abortSignal: rest.abortSignal,
+            headers: rest.headers,
+            providerOptions: rest.providerOptions,
+            stopWhen: rest.stopWhen,
+            experimental_transform: rest.experimental_transform,
+            prepareStep: rest.prepareStep,
+            onChunk: rest.onChunk,
+            onStepFinish: rest.onStepFinish,
+            onFinish: rest.onFinish,
+            onError: rest.onError
+                ? (event) => {
+                    const error = event.error instanceof Error
+                        ? event.error
+                        : new Error(String(event.error));
+                    return rest.onError(error);
+                }
+                : undefined,
+            onAbort: rest.onAbort,
+        });
+        // If no onFinally hook, return result as-is
+        if (!onFinally) {
+            return result;
+        }
+        // Wrap streams to add onFinally lifecycle tracking
+        return withStreamLifecycle(result, onFinally);
+    }
+}
+/**
+ * Creates a StreamTextProvider using Vercel AI SDK.
+ *
+ * Convenience function for creating the adapter.
+ *
+ * @returns A new Vercel SDK adapter instance
+ *
+ * @example
+ * ```typescript
+ * const provider = createVercelProvider();
+ *
+ * // Use with middlewares
+ * const wrapped = applyMiddleware(
+ *   provider,
+ *   contextMiddleware,
+ *   loggingMiddleware
+ * );
+ * ```
+ */
+export function createVercelProvider() {
+    return new VercelStreamTextAdapter();
+}
+//# sourceMappingURL=vercel.js.map

package/dist/ai-service/llm/interaction/adapters/vercel.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"vercel.js","sourceRoot":"","sources":["../../../../../src/ai-service/llm/interaction/adapters/vercel.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;GAWG;AAEH,OAAO,EAAE,UAAU,EAAE,MAAM,IAAI,CAAC;AAChC,OAAO,EAAE,mBAAmB,EAAE,MAAM,wBAAwB,CAAC;AAQ7D;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACH,MAAM,OAAO,uBAAuB;IAClC;;;;;OAKG;IACH,KAAK,CAAC,UAAU,CACd,OAAiC;QAEjC,sDAAsD;QACtD,MAAM,EAAE,SAAS,EAAE,IAAI,EAAE,GAAG,IAAI,EAAE,GAAG,OAAO,CAAC;QAE7C,oEAAoE;QACpE,IAAI,CAAC,IAAI,CAAC,QAAQ,IAAI,CAAC,IAAI,EAAE,CAAC;YAC5B,MAAM,IAAI,KAAK,CAAC,wDAAwD,CAAC,CAAC;QAC5E,CAAC;QAED,yDAAyD;QACzD,4DAA4D;QAC5D,wEAAwE;QACxE,MAAM,MAAM,GAAG,UAAU,CAAkB;YACzC,KAAK,EAAE,IAAI,CAAC,KAAK;YACjB,QAAQ,EAAE,IAAI,CAAC,QAAQ,IAAI,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC,EAAE,CAAC;YAC/C,MAAM,EAAE,IAAI,CAAC,MAAM;YACnB,KAAK,EAAE,IAAI,CAAC,KAA0B;YACtC,GAAG,CAAC,IAAI,CAAC,QAAQ,KAAK,SAAS,IAAI,EAAE,QAAQ,EAAE,IAAI,CAAC,QAAQ,EAAE,CAAC;YAC/D,WAAW,EAAE,IAAI,CAAC,WAAW;YAC7B,OAAO,EAAE,IAAI,CAAC,OAAO;YACrB,eAAe,EAAE,IAAI,CAAC,eAAe;YACrC,QAAQ,EAAE,IAAI,CAAC,QAAQ;YACvB,sBAAsB,EAAE,IAAI,CAAC,sBAAsB;YACnD,WAAW,EAAE,IAAI,CAAC,WAAW;YAC7B,OAAO,EAAE,IAAI,CAAC,OAAO;YACrB,YAAY,EAAE,IAAI,CAAC,YAAY;YAC/B,QAAQ,EAAE,IAAI,CAAC,QAAQ;YACvB,OAAO,EAAE,IAAI,CAAC,OAAO;gBACnB,CAAC,CAAC,CAAC,KAAK,EAAE,EAAE;oBACR,MAAM,KAAK,GACT,KAAK,CAAC,KAAK,YAAY,KAAK;wBAC1B,CAAC,CAAC,KAAK,CAAC,KAAK;wBACb,CAAC,CAAC,IAAI,KAAK,CAAC,MAAM,CAAC,KAAK,CAAC,KAAK,CAAC,CAAC,CAAC;oBACrC,OAAO,IAAI,CAAC,OAAQ,CAAC,KAAK,CAAC,CAAC;gBAC9B,CAAC;gBACH,CAAC,CAAC,SAAS;YACb,OAAO,EAAE,IAAI,CAAC,OAAO;SACtB,CAAC,CAAC;QAEH,4CAA4C;QAC5C,IAAI,CAAC,SAAS,EAAE,CAAC;YACf,OAAO,MAAM,CAAC;QAChB,CAAC;QAED,mDAAmD;QACnD,OAAO,mBAAmB,CAAQ,MAAM,EAAE,SAAS,CAAC,CAAC;IACvD,CAAC;CACF;AAED;;;;;;;;;;;;;;;;;;GAkBG;AACH,MAAM,UAAU,oBAAoB;IAClC,OAAO,IAAI,uBAAuB,EAAE,CAAC;AACvC,CAAC"}

package/dist/ai-service/llm/interaction/compose.d.ts

@@ -0,0 +1,71 @@
+/**
+ * Composition utilities for StreamTextProvider middlewares.
+ *
+ * Provides functions to compose multiple middlewares into a single
+ * execution chain, similar to Express.js middleware composition.
+ */
+import type { StreamTextProvider, StreamTextMiddleware } from "./middleware.js";
+/**
+ * Composes multiple middlewares into a single middleware.
+ *
+ * Middlewares are applied from left to right (first middleware wraps second,
+ * second wraps third, etc.). This means the first middleware in the array
+ * is the outermost layer and executes first.
+ *
+ * @param middlewares - The middlewares to compose
+ * @returns A single composed middleware
+ *
+ * @example
+ * const combined = compose(loggingMiddleware, authMiddleware, rateLimitMiddleware);
+ * // Execution order:
+ * // 1. loggingMiddleware (outermost)
+ * // 2. authMiddleware
+ * // 3. rateLimitMiddleware (innermost)
+ * // 4. actual provider.streamText() call
+ */
+export declare function compose(...middlewares: StreamTextMiddleware[]): StreamTextMiddleware;
+/**
+ * Applies middlewares to a base StreamTextProvider.
+ *
+ * This is a convenience function that composes the middlewares and
+ * applies them to the base provider in one step.
+ *
+ * @param baseProvider - The base provider to wrap
+ * @param middlewares - The middlewares to apply
+ * @returns The wrapped provider with all middlewares applied
+ *
+ * @example
+ * const provider = applyMiddleware(
+ *   createVercelProvider(),
+ *   contextMiddleware,
+ *   loggingMiddleware,
+ *   profilerMiddleware
+ * );
+ *
+ * // Use the wrapped provider:
+ * const result = await provider.streamText({ model, messages, tools });
+ */
+export declare function applyMiddleware(baseProvider: StreamTextProvider, ...middlewares: StreamTextMiddleware[]): StreamTextProvider;
+/**
+ * Creates a middleware from a simple wrapper function.
+ *
+ * This is a helper for creating middlewares without implementing
+ * the full interface. Useful for simple transformations.
+ *
+ * @param wrapperFn - A function that wraps the provider
+ * @returns A StreamTextMiddleware
+ *
+ * @example
+ * const timingMiddleware = createMiddleware((provider) => {
+ *   return {
+ *     async streamText(options) {
+ *       const start = Date.now();
+ *       const result = await provider.streamText(options);
+ *       console.log(`Took ${Date.now() - start}ms`);
+ *       return result;
+ *     }
+ *   };
+ * });
+ */
+export declare function createMiddleware(wrapperFn: (provider: StreamTextProvider) => StreamTextProvider): StreamTextMiddleware;
+//# sourceMappingURL=compose.d.ts.map

package/dist/ai-service/llm/interaction/compose.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"compose.d.ts","sourceRoot":"","sources":["../../../../src/ai-service/llm/interaction/compose.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH,OAAO,KAAK,EAAE,kBAAkB,EAAE,oBAAoB,EAAE,MAAM,iBAAiB,CAAC;AAEhF;;;;;;;;;;;;;;;;;GAiBG;AACH,wBAAgB,OAAO,CACrB,GAAG,WAAW,EAAE,oBAAoB,EAAE,GACrC,oBAAoB,CAWtB;AAED;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,wBAAgB,eAAe,CAC7B,YAAY,EAAE,kBAAkB,EAChC,GAAG,WAAW,EAAE,oBAAoB,EAAE,GACrC,kBAAkB,CAOpB;AAED;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,wBAAgB,gBAAgB,CAC9B,SAAS,EAAE,CAAC,QAAQ,EAAE,kBAAkB,KAAK,kBAAkB,GAC9D,oBAAoB,CAItB"}

package/dist/ai-service/llm/interaction/compose.js

@@ -0,0 +1,88 @@
+/**
+ * Composition utilities for StreamTextProvider middlewares.
+ *
+ * Provides functions to compose multiple middlewares into a single
+ * execution chain, similar to Express.js middleware composition.
+ */
+/**
+ * Composes multiple middlewares into a single middleware.
+ *
+ * Middlewares are applied from left to right (first middleware wraps second,
+ * second wraps third, etc.). This means the first middleware in the array
+ * is the outermost layer and executes first.
+ *
+ * @param middlewares - The middlewares to compose
+ * @returns A single composed middleware
+ *
+ * @example
+ * const combined = compose(loggingMiddleware, authMiddleware, rateLimitMiddleware);
+ * // Execution order:
+ * // 1. loggingMiddleware (outermost)
+ * // 2. authMiddleware
+ * // 3. rateLimitMiddleware (innermost)
+ * // 4. actual provider.streamText() call
+ */
+export function compose(...middlewares) {
+    return {
+        wrap(provider) {
+            // Apply middlewares from right to left (innermost to outermost)
+            // so that the first middleware in the array becomes the outermost wrapper
+            return middlewares.reduceRight((wrappedProvider, middleware) => middleware.wrap(wrappedProvider), provider);
+        },
+    };
+}
+/**
+ * Applies middlewares to a base StreamTextProvider.
+ *
+ * This is a convenience function that composes the middlewares and
+ * applies them to the base provider in one step.
+ *
+ * @param baseProvider - The base provider to wrap
+ * @param middlewares - The middlewares to apply
+ * @returns The wrapped provider with all middlewares applied
+ *
+ * @example
+ * const provider = applyMiddleware(
+ *   createVercelProvider(),
+ *   contextMiddleware,
+ *   loggingMiddleware,
+ *   profilerMiddleware
+ * );
+ *
+ * // Use the wrapped provider:
+ * const result = await provider.streamText({ model, messages, tools });
+ */
+export function applyMiddleware(baseProvider, ...middlewares) {
+    if (middlewares.length === 0) {
+        return baseProvider;
+    }
+    const composed = compose(...middlewares);
+    return composed.wrap(baseProvider);
+}
+/**
+ * Creates a middleware from a simple wrapper function.
+ *
+ * This is a helper for creating middlewares without implementing
+ * the full interface. Useful for simple transformations.
+ *
+ * @param wrapperFn - A function that wraps the provider
+ * @returns A StreamTextMiddleware
+ *
+ * @example
+ * const timingMiddleware = createMiddleware((provider) => {
+ *   return {
+ *     async streamText(options) {
+ *       const start = Date.now();
+ *       const result = await provider.streamText(options);
+ *       console.log(`Took ${Date.now() - start}ms`);
+ *       return result;
+ *     }
+ *   };
+ * });
+ */
+export function createMiddleware(wrapperFn) {
+    return {
+        wrap: wrapperFn,
+    };
+}
+//# sourceMappingURL=compose.js.map

package/dist/ai-service/llm/interaction/compose.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"compose.js","sourceRoot":"","sources":["../../../../src/ai-service/llm/interaction/compose.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAIH;;;;;;;;;;;;;;;;;GAiBG;AACH,MAAM,UAAU,OAAO,CACrB,GAAG,WAAmC;IAEtC,OAAO;QACL,IAAI,CAAC,QAA4B;YAC/B,gEAAgE;YAChE,0EAA0E;YAC1E,OAAO,WAAW,CAAC,WAAW,CAC5B,CAAC,eAAe,EAAE,UAAU,EAAE,EAAE,CAAC,UAAU,CAAC,IAAI,CAAC,eAAe,CAAC,EACjE,QAAQ,CACT,CAAC;QACJ,CAAC;KACF,CAAC;AACJ,CAAC;AAED;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,MAAM,UAAU,eAAe,CAC7B,YAAgC,EAChC,GAAG,WAAmC;IAEtC,IAAI,WAAW,CAAC,MAAM,KAAK,CAAC,EAAE,CAAC;QAC7B,OAAO,YAAY,CAAC;IACtB,CAAC;IAED,MAAM,QAAQ,GAAG,OAAO,CAAC,GAAG,WAAW,CAAC,CAAC;IACzC,OAAO,QAAQ,CAAC,IAAI,CAAC,YAAY,CAAC,CAAC;AACrC,CAAC;AAED;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,MAAM,UAAU,gBAAgB,CAC9B,SAA+D;IAE/D,OAAO;QACL,IAAI,EAAE,SAAS;KAChB,CAAC;AACJ,CAAC"}

package/dist/ai-service/llm/interaction/index.d.ts

@@ -0,0 +1,68 @@
+/**
+ * Multi-step LLM interaction system with provider interface and middleware.
+ *
+ * This module provides a clean, SDK-agnostic interface for LLM streaming
+ * with composable middleware. Key features:
+ * - Provider interface abstracts away SDK details
+ * - onFinally lifecycle hook for cleanup after stream consumption
+ * - Composable middlewares for cross-cutting concerns
+ * - Adapter pattern for SDK flexibility
+ *
+ * ## Architecture
+ *
+ * ```
+ * Middlewares (Context, Logging, Profiler, LLMObs)
+ *     ↓
+ * StreamTextProvider Interface (with onFinally)
+ *     ↓
+ * VercelStreamTextAdapter
+ *     ↓
+ * Vercel AI SDK
+ * ```
+ *
+ * ## Usage
+ *
+ * ```typescript
+ * import {
+ *   createVercelProvider,
+ *   applyMiddleware,
+ *   createContextMiddleware,
+ *   createLoggingMiddleware,
+ * } from "./interaction";
+ *
+ * // Create base provider
+ * const baseProvider = createVercelProvider();
+ *
+ * // Apply middlewares
+ * const provider = applyMiddleware(
+ *   baseProvider,
+ *   createContextMiddleware({ ... }),
+ *   createLoggingMiddleware({ ... })
+ * );
+ *
+ * // Use the provider
+ * const result = await provider.streamText({
+ *   model,
+ *   messages,
+ *   tools,
+ *   onFinally: async () => {
+ *     // Cleanup after stream consumption
+ *   }
+ * });
+ *
+ * for await (const chunk of result.fullStream) {
+ *   // Process chunks
+ * }
+ * // onFinally runs here ^
+ * ```
+ */
+export type { StreamTextProvider, StreamTextOptions, StreamTextResult, StepParameters, StreamChunk, StepResult, FinalResult, } from "./provider.js";
+export type { StreamTextMiddleware } from "./middleware.js";
+export { compose, applyMiddleware, createMiddleware } from "./compose.js";
+export { withStreamLifecycle } from "./stream-lifecycle.js";
+export { VercelStreamTextAdapter, createVercelProvider, } from "./adapters/vercel.js";
+export { createLoggingMiddleware, type LoggingMiddlewareOptions, type LogRef, } from "./middlewares/logging.js";
+export { createProfilerMiddleware, type ProfilerMiddlewareOptions, } from "./middlewares/profiler.js";
+export { createLLMObsMiddleware, type LLMObsMiddlewareOptions, } from "./middlewares/llmobs.js";
+export { createStreamRetryMiddleware, type StreamRetryOptions, } from "./middlewares/stream-retry.js";
+//# sourceMappingURL=index.d.ts.map

package/dist/ai-service/llm/interaction/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/ai-service/llm/interaction/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAyDG;AAGH,YAAY,EACV,kBAAkB,EAClB,iBAAiB,EACjB,gBAAgB,EAChB,cAAc,EACd,WAAW,EACX,UAAU,EACV,WAAW,GACZ,MAAM,eAAe,CAAC;AAGvB,YAAY,EAAE,oBAAoB,EAAE,MAAM,iBAAiB,CAAC;AAG5D,OAAO,EAAE,OAAO,EAAE,eAAe,EAAE,gBAAgB,EAAE,MAAM,cAAc,CAAC;AAG1E,OAAO,EAAE,mBAAmB,EAAE,MAAM,uBAAuB,CAAC;AAG5D,OAAO,EACL,uBAAuB,EACvB,oBAAoB,GACrB,MAAM,sBAAsB,CAAC;AAG9B,OAAO,EACL,uBAAuB,EACvB,KAAK,wBAAwB,EAC7B,KAAK,MAAM,GACZ,MAAM,0BAA0B,CAAC;AAElC,OAAO,EACL,wBAAwB,EACxB,KAAK,yBAAyB,GAC/B,MAAM,2BAA2B,CAAC;AAEnC,OAAO,EACL,sBAAsB,EACtB,KAAK,uBAAuB,GAC7B,MAAM,yBAAyB,CAAC;AAEjC,OAAO,EACL,2BAA2B,EAC3B,KAAK,kBAAkB,GACxB,MAAM,+BAA+B,CAAC"}

package/dist/ai-service/llm/interaction/index.js

@@ -0,0 +1,70 @@
+/**
+ * Multi-step LLM interaction system with provider interface and middleware.
+ *
+ * This module provides a clean, SDK-agnostic interface for LLM streaming
+ * with composable middleware. Key features:
+ * - Provider interface abstracts away SDK details
+ * - onFinally lifecycle hook for cleanup after stream consumption
+ * - Composable middlewares for cross-cutting concerns
+ * - Adapter pattern for SDK flexibility
+ *
+ * ## Architecture
+ *
+ * ```
+ * Middlewares (Context, Logging, Profiler, LLMObs)
+ *     ↓
+ * StreamTextProvider Interface (with onFinally)
+ *     ↓
+ * VercelStreamTextAdapter
+ *     ↓
+ * Vercel AI SDK
+ * ```
+ *
+ * ## Usage
+ *
+ * ```typescript
+ * import {
+ *   createVercelProvider,
+ *   applyMiddleware,
+ *   createContextMiddleware,
+ *   createLoggingMiddleware,
+ * } from "./interaction";
+ *
+ * // Create base provider
+ * const baseProvider = createVercelProvider();
+ *
+ * // Apply middlewares
+ * const provider = applyMiddleware(
+ *   baseProvider,
+ *   createContextMiddleware({ ... }),
+ *   createLoggingMiddleware({ ... })
+ * );
+ *
+ * // Use the provider
+ * const result = await provider.streamText({
+ *   model,
+ *   messages,
+ *   tools,
+ *   onFinally: async () => {
+ *     // Cleanup after stream consumption
+ *   }
+ * });
+ *
+ * for await (const chunk of result.fullStream) {
+ *   // Process chunks
+ * }
+ * // onFinally runs here ^
+ * ```
+ */
+// Composition utilities
+export { compose, applyMiddleware, createMiddleware } from "./compose.js";
+// Stream lifecycle utilities
+export { withStreamLifecycle } from "./stream-lifecycle.js";
+// Vercel SDK adapter
+export { VercelStreamTextAdapter, createVercelProvider, } from "./adapters/vercel.js";
+// Built-in middlewares
+export { createLoggingMiddleware, } from "./middlewares/logging.js";
+export { createProfilerMiddleware, } from "./middlewares/profiler.js";
+export { createLLMObsMiddleware, } from "./middlewares/llmobs.js";
+export { createStreamRetryMiddleware, } from "./middlewares/stream-retry.js";
+//# sourceMappingURL=index.js.map

package/dist/ai-service/llm/interaction/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../../src/ai-service/llm/interaction/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAyDG;AAgBH,wBAAwB;AACxB,OAAO,EAAE,OAAO,EAAE,eAAe,EAAE,gBAAgB,EAAE,MAAM,cAAc,CAAC;AAE1E,6BAA6B;AAC7B,OAAO,EAAE,mBAAmB,EAAE,MAAM,uBAAuB,CAAC;AAE5D,qBAAqB;AACrB,OAAO,EACL,uBAAuB,EACvB,oBAAoB,GACrB,MAAM,sBAAsB,CAAC;AAE9B,uBAAuB;AACvB,OAAO,EACL,uBAAuB,GAGxB,MAAM,0BAA0B,CAAC;AAElC,OAAO,EACL,wBAAwB,GAEzB,MAAM,2BAA2B,CAAC;AAEnC,OAAO,EACL,sBAAsB,GAEvB,MAAM,yBAAyB,CAAC;AAEjC,OAAO,EACL,2BAA2B,GAE5B,MAAM,+BAA+B,CAAC"}

package/dist/ai-service/llm/interaction/middleware.d.ts

@@ -0,0 +1,52 @@
+/**
+ * Middleware interface for multi-step LLM interactions.
+ *
+ * Provides a composable wrap pattern for intercepting and transforming
+ * StreamTextProvider calls. Each middleware can:
+ * - Transform input options before execution
+ * - Add lifecycle hooks (onFinally, etc.)
+ * - Wrap and transform output streams
+ * - Handle errors and control flow
+ * - Short-circuit execution if needed
+ *
+ * Middlewares operate on the high-level StreamTextProvider interface,
+ * not on SDK-specific details. This makes them portable across different
+ * LLM SDKs (Vercel, Anthropic, OpenAI, etc.).
+ */
+import type { StreamTextProvider } from "./provider.js";
+/**
+ * Middleware interface using the wrap pattern.
+ *
+ * Each middleware wraps a StreamTextProvider, allowing it to:
+ * - Intercept and transform streamText() calls
+ * - Execute logic before/after the call
+ * - Transform or wrap the options and results
+ * - Handle errors and control flow
+ *
+ * @example
+ * ```typescript
+ * const loggingMiddleware: StreamTextMiddleware = {
+ *   wrap(provider) {
+ *     return {
+ *       async streamText(options) {
+ *         console.log('Starting streamText call');
+ *         const result = await provider.streamText(options);
+ *         console.log('Call complete');
+ *         return result;
+ *       }
+ *     };
+ *   }
+ * };
+ * ```
+ */
+export interface StreamTextMiddleware {
+    /**
+     * Wraps a StreamTextProvider with middleware behavior.
+     *
+     * @param provider - The provider to wrap
+     * @returns A wrapped provider with the middleware's behavior
+     */
+    wrap(provider: StreamTextProvider): StreamTextProvider;
+}
+export type { StreamTextProvider, StreamTextOptions, StreamTextResult, StepParameters, StreamChunk, StepResult, FinalResult, } from "./provider.js";
+//# sourceMappingURL=middleware.d.ts.map

package/dist/ai-service/llm/interaction/middleware.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"middleware.d.ts","sourceRoot":"","sources":["../../../../src/ai-service/llm/interaction/middleware.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;GAcG;AAEH,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,eAAe,CAAC;AAExD;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AACH,MAAM,WAAW,oBAAoB;IACnC;;;;;OAKG;IACH,IAAI,CAAC,QAAQ,EAAE,kBAAkB,GAAG,kBAAkB,CAAC;CACxD;AAGD,YAAY,EACV,kBAAkB,EAClB,iBAAiB,EACjB,gBAAgB,EAChB,cAAc,EACd,WAAW,EACX,UAAU,EACV,WAAW,GACZ,MAAM,eAAe,CAAC"}

package/dist/ai-service/llm/interaction/middleware.js

@@ -0,0 +1,17 @@
+/**
+ * Middleware interface for multi-step LLM interactions.
+ *
+ * Provides a composable wrap pattern for intercepting and transforming
+ * StreamTextProvider calls. Each middleware can:
+ * - Transform input options before execution
+ * - Add lifecycle hooks (onFinally, etc.)
+ * - Wrap and transform output streams
+ * - Handle errors and control flow
+ * - Short-circuit execution if needed
+ *
+ * Middlewares operate on the high-level StreamTextProvider interface,
+ * not on SDK-specific details. This makes them portable across different
+ * LLM SDKs (Vercel, Anthropic, OpenAI, etc.).
+ */
+export {};
+//# sourceMappingURL=middleware.js.map

package/dist/ai-service/llm/interaction/middleware.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"middleware.js","sourceRoot":"","sources":["../../../../src/ai-service/llm/interaction/middleware.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;GAcG"}

package/dist/ai-service/llm/interaction/middlewares/llmobs.d.ts

@@ -0,0 +1,45 @@
+/**
+ * LLMObs middleware adapter.
+ *
+ * This middleware wraps the existing LLMObsStreamTextMiddleware to work
+ * with the new provider-based middleware interface. It provides observability
+ * tracing for LLM interactions.
+ */
+import type { Logger } from "../../../../util/logger.js";
+import type { LLMObsTracer } from "../../../llmobs/index.js";
+import type { StreamTextMiddleware } from "../middleware.js";
+/**
+ * Options for configuring the LLMObs middleware.
+ */
+export interface LLMObsMiddlewareOptions {
+    /** LLMObs tracer instance */
+    tracer?: LLMObsTracer;
+    /** Logger instance */
+    logger?: Logger;
+}
+/**
+ * Creates a middleware that adds LLMObs observability tracing.
+ *
+ * This middleware wraps the existing LLMObsStreamTextMiddleware to provide:
+ * - Workflow and LLM span hierarchy
+ * - Token usage tracking
+ * - Tool call tracing
+ * - Segment-level tracking (thinking, text, tool-input)
+ * - Error and abort handling
+ *
+ * @param options - Configuration for the middleware
+ * @returns A StreamTextMiddleware
+ *
+ * @example
+ * ```typescript
+ * const middleware = createLLMObsMiddleware({
+ *   tracer: LLMObsTracer.instance,
+ *   logger: getLogger()
+ * });
+ *
+ * const streamText = applyMiddleware(baseStreamText, middleware);
+ * const result = await streamText({ model, messages, tools });
+ * ```
+ */
+export declare function createLLMObsMiddleware(options?: LLMObsMiddlewareOptions): StreamTextMiddleware;
+//# sourceMappingURL=llmobs.d.ts.map

package/dist/ai-service/llm/interaction/middlewares/llmobs.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"llmobs.d.ts","sourceRoot":"","sources":["../../../../../src/ai-service/llm/interaction/middlewares/llmobs.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAMH,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,4BAA4B,CAAC;AAEzD,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,0BAA0B,CAAC;AAC7D,OAAO,KAAK,EACV,oBAAoB,EAIrB,MAAM,kBAAkB,CAAC;AAE1B;;GAEG;AACH,MAAM,WAAW,uBAAuB;IACtC,6BAA6B;IAC7B,MAAM,CAAC,EAAE,YAAY,CAAC;IAEtB,sBAAsB;IACtB,MAAM,CAAC,EAAE,MAAM,CAAC;CACjB;AAED;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AACH,wBAAgB,sBAAsB,CACpC,OAAO,GAAE,uBAA4B,GACpC,oBAAoB,CAwEtB"}

package/dist/ai-service/llm/interaction/middlewares/llmobs.js

@@ -0,0 +1,85 @@
+/**
+ * LLMObs middleware adapter.
+ *
+ * This middleware wraps the existing LLMObsStreamTextMiddleware to work
+ * with the new provider-based middleware interface. It provides observability
+ * tracing for LLM interactions.
+ */
+import { LLMObsStreamTextMiddleware, wrapStream, } from "../../../llmobs/middleware/stream-text.js";
+/**
+ * Creates a middleware that adds LLMObs observability tracing.
+ *
+ * This middleware wraps the existing LLMObsStreamTextMiddleware to provide:
+ * - Workflow and LLM span hierarchy
+ * - Token usage tracking
+ * - Tool call tracing
+ * - Segment-level tracking (thinking, text, tool-input)
+ * - Error and abort handling
+ *
+ * @param options - Configuration for the middleware
+ * @returns A StreamTextMiddleware
+ *
+ * @example
+ * ```typescript
+ * const middleware = createLLMObsMiddleware({
+ *   tracer: LLMObsTracer.instance,
+ *   logger: getLogger()
+ * });
+ *
+ * const streamText = applyMiddleware(baseStreamText, middleware);
+ * const result = await streamText({ model, messages, tools });
+ * ```
+ */
+export function createLLMObsMiddleware(options = {}) {
+    const { tracer, logger } = options;
+    return {
+        wrap(provider) {
+            return {
+                async streamText(streamOptions) {
+                    // Create LLMObs middleware instance
+                    const llmobs = new LLMObsStreamTextMiddleware(streamOptions.model, streamOptions.tools, tracer, logger);
+                    try {
+                        // Call provider with wrapped callbacks and tools
+                        const result = await provider.streamText({
+                            ...streamOptions,
+                            tools: streamOptions.tools
+                                ? llmobs.wrapTools(streamOptions.tools)
+                                : undefined,
+                            prepareStep: async (step) => {
+                                return await llmobs.prepareStep(step, streamOptions.model, streamOptions.prepareStep);
+                            },
+                            onChunk: async (event) => {
+                                await llmobs.onChunk(event.chunk, streamOptions.onChunk);
+                            },
+                            onStepFinish: async (step) => {
+                                await llmobs.onStepFinish(step, streamOptions.onStepFinish);
+                            },
+                            onFinish: async (result) => {
+                                await llmobs.onFinish(result, streamOptions.onFinish);
+                            },
+                            onError: async (error) => {
+                                await llmobs.onError(error, streamOptions.onError);
+                            },
+                            onAbort: async () => {
+                                await llmobs.onAbort(streamOptions.onAbort);
+                            },
+                        });
+                        // Wrap result streams with error/finally handlers using the wrapStream utility
+                        // from stream-text.ts which properly creates AsyncIterableStream
+                        return {
+                            ...result,
+                            textStream: wrapStream(result.textStream, async (error) => llmobs.handleStreamError(error), async () => llmobs.onFinally()),
+                            fullStream: wrapStream(result.fullStream, async (error) => llmobs.handleStreamError(error), async () => llmobs.onFinally()),
+                        };
+                    }
+                    catch (error) {
+                        // Clean up spans if error occurs before streams are created
+                        llmobs.handleStreamError(error);
+                        throw error;
+                    }
+                },
+            };
+        },
+    };
+}
+//# sourceMappingURL=llmobs.js.map

package/dist/ai-service/llm/interaction/middlewares/llmobs.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"llmobs.js","sourceRoot":"","sources":["../../../../../src/ai-service/llm/interaction/middlewares/llmobs.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAEH,OAAO,EACL,0BAA0B,EAC1B,UAAU,GACX,MAAM,2CAA2C,CAAC;AAsBnD;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AACH,MAAM,UAAU,sBAAsB,CACpC,UAAmC,EAAE;IAErC,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,GAAG,OAAO,CAAC;IAEnC,OAAO;QACL,IAAI,CAAC,QAA4B;YAC/B,OAAO;gBACL,KAAK,CAAC,UAAU,CACd,aAAuC;oBAEvC,oCAAoC;oBACpC,MAAM,MAAM,GAAG,IAAI,0BAA0B,CAC3C,aAAa,CAAC,KAAK,EACnB,aAAa,CAAC,KAAK,EACnB,MAAM,EACN,MAAM,CACP,CAAC;oBAEF,IAAI,CAAC;wBACH,iDAAiD;wBACjD,MAAM,MAAM,GAAG,MAAM,QAAQ,CAAC,UAAU,CAAQ;4BAC9C,GAAG,aAAa;4BAChB,KAAK,EAAE,aAAa,CAAC,KAAK;gCACxB,CAAC,CAAC,MAAM,CAAC,SAAS,CAAC,aAAa,CAAC,KAAK,CAAC;gCACvC,CAAC,CAAC,SAAS;4BACb,WAAW,EAAE,KAAK,EAAE,IAAI,EAAE,EAAE;gCAC1B,OAAO,MAAM,MAAM,CAAC,WAAW,CAC7B,IAAI,EACJ,aAAa,CAAC,KAAK,EACnB,aAAa,CAAC,WAAW,CAC1B,CAAC;4BACJ,CAAC;4BACD,OAAO,EAAE,KAAK,EAAE,KAAK,EAAE,EAAE;gCACvB,MAAM,MAAM,CAAC,OAAO,CAAC,KAAK,CAAC,KAAK,EAAE,aAAa,CAAC,OAAO,CAAC,CAAC;4BAC3D,CAAC;4BACD,YAAY,EAAE,KAAK,EAAE,IAAI,EAAE,EAAE;gCAC3B,MAAM,MAAM,CAAC,YAAY,CAAC,IAAI,EAAE,aAAa,CAAC,YAAY,CAAC,CAAC;4BAC9D,CAAC;4BACD,QAAQ,EAAE,KAAK,EAAE,MAAM,EAAE,EAAE;gCACzB,MAAM,MAAM,CAAC,QAAQ,CAAC,MAAM,EAAE,aAAa,CAAC,QAAQ,CAAC,CAAC;4BACxD,CAAC;4BACD,OAAO,EAAE,KAAK,EAAE,KAAK,EAAE,EAAE;gCACvB,MAAM,MAAM,CAAC,OAAO,CAAC,KAAK,EAAE,aAAa,CAAC,OAAO,CAAC,CAAC;4BACrD,CAAC;4BACD,OAAO,EAAE,KAAK,IAAI,EAAE;gCAClB,MAAM,MAAM,CAAC,OAAO,CAAC,aAAa,CAAC,OAAO,CAAC,CAAC;4BAC9C,CAAC;yBACF,CAAC,CAAC;wBAEH,+EAA+E;wBAC/E,iEAAiE;wBACjE,OAAO;4BACL,GAAG,MAAM;4BACT,UAAU,EAAE,UAAU,CACpB,MAAM,CAAC,UAAU,EACjB,KAAK,EAAE,KAAK,EAAE,EAAE,CAAC,MAAM,CAAC,iBAAiB,CAAC,KAAK,CAAC,EAChD,KAAK,IAAI,EAAE,CAAC,MAAM,CAAC,SAAS,EAAE,CAC/B;4BACD,UAAU,EAAE,UAAU,CACpB,MAAM,CAAC,UAAU,EACjB,KAAK,EAAE,KAAK,EAAE,EAAE,CAAC,MAAM,CAAC,iBAAiB,CAAC,KAAK,CAAC,EAChD,KAAK,IAAI,EAAE,CAAC,MAAM,CAAC,SAAS,EAAE,CAC/B;yBACF,CAAC;oBACJ,CAAC;oBAAC,OAAO,KAAK,EAAE,CAAC;wBACf,4DAA4D;wBAC5D,MAAM,CAAC,iBAAiB,CAAC,KAAK,CAAC,CAAC;wBAChC,MAAM,KAAK,CAAC;oBACd,CAAC;gBACH,CAAC;aACF,CAAC;QACJ,CAAC;KACF,CAAC;AACJ,CAAC"}