@superblocksteam/vite-plugin-file-sync 1.99.99-next.2 → 2.0.0-SNAPSHOT.2143e2e95d0107ab

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

@@ -0,0 +1 @@
+{"version":3,"file":"vercel.d.ts","sourceRoot":"","sources":["../../../../../src/ai-service/llm/interaction/adapters/vercel.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;GAWG;AAKH,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,gCAAgC,CAAC;AAE3D,OAAO,KAAK,EACV,kBAAkB,EAClB,iBAAiB,EACjB,gBAAgB,EACjB,MAAM,gBAAgB,CAAC;AAOxB;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACH,qBAAa,uBAAwB,YAAW,kBAAkB;IAChE;;;;;OAKG;IACG,UAAU,CACd,KAAK,SAAS,MAAM,CAAC,MAAM,EAAE,IAAI,CAAC,GAAG,MAAM,CAAC,MAAM,EAAE,IAAI,CAAC,EACzD,MAAM,GAAG,OAAO,EAEhB,OAAO,EAAE,iBAAiB,CAAC,KAAK,EAAE,MAAM,CAAC,GACxC,OAAO,CAAC,gBAAgB,CAAC,KAAK,CAAC,CAAC;CAyKpC;AAED;;;;;;;;;;;;;;;;;;GAkBG;AACH,wBAAgB,oBAAoB,IAAI,kBAAkB,CAEzD"}

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

@@ -0,0 +1,190 @@
+/**
+ * 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 { Output, streamText } from "ai";
+import { getErrorMeta, getLogger } from "../../../../util/logger.js";
+import { logToolContextIntegrityIssues } from "../../tool-context-integrity.js";
+import { withStreamLifecycle } from "../stream-lifecycle.js";
+const passThroughDownload = async (requestedDownloads) => requestedDownloads.map(() => null);
+/**
+ * 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;
+        // Wrap the output schema in the Vercel SDK's Output.object (which accepts a
+        // Zod/flexible schema directly) so the model receives the JSON response
+        // format. Final parsing/validation is owned by the caller (see
+        // LLMClient.generateObject), which drains the text stream and validates.
+        //
+        // The cast bridges a @ai-sdk/provider-utils version skew: our
+        // FlexibleSchema is typed against the top-level copy, while Output.object
+        // expects the copy bundled inside `ai`. The runtime value (the schema) is
+        // identical; only the nominal type identity differs.
+        const sdkOutput = rest.experimental_output
+            ? Output.object({
+                schema: rest.experimental_output,
+            })
+            : undefined;
+        const normalizeError = (error) => error instanceof Error ? error : new Error(String(error));
+        const handleOnError = async (error) => {
+            if (!rest.onError)
+                return;
+            await rest.onError(normalizeError(error));
+        };
+        // 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");
+        }
+        // Capture the messages for debugging purposes
+        const messagesForLLM = rest.messages || (user ? [user] : []);
+        const logProviderMessages = (messages) => {
+            if (!messages) {
+                return;
+            }
+            logToolContextIntegrityIssues(getLogger(), "provider.streamText", messages);
+        };
+        logProviderMessages(messagesForLLM);
+        const originalPrepareStep = rest.prepareStep;
+        const prepareStep = (async (step) => {
+            // If prepareStep makes no override, the provider-bound payload remains
+            // the incoming step, so diagnostics should inspect that same message set.
+            const preparedStep = await originalPrepareStep?.(step);
+            logProviderMessages(preparedStep?.messages ?? step.messages);
+            return preparedStep;
+        });
+        // Call Vercel SDK's streamText. TOOLS is fixed by our method signature;
+        // the structured-output generic is inferred from `experimental_output`
+        // (the SDK Output spec built above), defaulting to plain text when absent.
+        const rawResult = streamText({
+            model: rest.model,
+            messages: messagesForLLM,
+            system: rest.system,
+            tools: rest.tools,
+            ...(rest.maxSteps !== undefined && { maxSteps: rest.maxSteps }),
+            ...(rest.maxOutputTokens !== undefined && {
+                maxOutputTokens: rest.maxOutputTokens,
+            }),
+            abortSignal: rest.abortSignal,
+            headers: rest.headers,
+            providerOptions: rest.providerOptions,
+            stopWhen: rest.stopWhen,
+            experimental_transform: rest.experimental_transform,
+            experimental_output: sdkOutput,
+            // Always pass URL parts through untouched. The downstream Clark/server
+            // pipeline is responsible for lease refresh and media materialization.
+            experimental_download: passThroughDownload,
+            // Surface low-level provider events (Anthropic `ping` keep-alives, Bedrock
+            // message metadata, etc.) as `{type:"raw"}` chunks. During Claude extended
+            // thinking the provider can go 30-90s without emitting a reasoning-delta,
+            // and without these ticks our IdleMonitor would stall the stream mid-
+            // thinking and retry. Raw chunks flow through managed-stream.ts → reset
+            // the idle timer. Observers that don't care about raw chunks ignore them.
+            // See APPS-3460.
+            includeRawChunks: true,
+            prepareStep,
+            onChunk: rest.onChunk,
+            onStepFinish: rest.onStepFinish,
+            onFinish: rest.onFinish,
+            onError: rest.onError ? (event) => handleOnError(event.error) : undefined,
+            onAbort: rest.onAbort,
+        });
+        // Suppress unhandled rejections - prevents SIGABRT when tools throw errors
+        // When a tool execution fails, the Vercel AI SDK rejects these promises.
+        // The onError callback at line 94 already handles error reporting, but we need
+        // to suppress the rejections here to prevent Node.js from triggering SIGABRT.
+        // Attach catch handlers to suppress unhandled rejections
+        // These handlers prevent SIGABRT but don't change the promise behavior
+        const observeRejection = (promiseLike, label) => {
+            Promise.resolve(promiseLike).catch((error) => {
+                getLogger().debug(label, getErrorMeta(error));
+            });
+        };
+        const stepsPromise = Promise.resolve(rawResult.steps);
+        observeRejection(stepsPromise, "Stream steps promise rejected");
+        observeRejection(rawResult.files, "Stream files promise rejected");
+        observeRejection(rawResult.sources, "Stream sources promise rejected");
+        observeRejection(rawResult.toolCalls, "Stream toolCalls promise rejected");
+        observeRejection(rawResult.staticToolCalls, "Stream staticToolCalls promise rejected");
+        observeRejection(rawResult.dynamicToolCalls, "Stream dynamicToolCalls promise rejected");
+        observeRejection(rawResult.staticToolResults, "Stream staticToolResults promise rejected");
+        observeRejection(rawResult.dynamicToolResults, "Stream dynamicToolResults promise rejected");
+        observeRejection(rawResult.toolResults, "Stream toolResults promise rejected");
+        observeRejection(rawResult.text, "Stream text promise rejected");
+        observeRejection(rawResult.finishReason, "Stream finishReason promise rejected");
+        observeRejection(rawResult.rawFinishReason, "Stream rawFinishReason promise rejected");
+        observeRejection(rawResult.usage, "Stream usage promise rejected");
+        observeRejection(rawResult.totalUsage, "Stream totalUsage promise rejected");
+        observeRejection(rawResult.warnings, "Stream warnings promise rejected");
+        observeRejection(rawResult.request, "Stream request promise rejected");
+        observeRejection(rawResult.providerMetadata, "Stream providerMetadata promise rejected");
+        // Create our StreamTextResult (extracts only what we need) FIRST
+        // Return the original promises - rejections are now handled by the catch handlers above
+        const result = {
+            textStream: rawResult.textStream,
+            fullStream: rawResult.fullStream,
+            steps: stepsPromise, // Use a real Promise - rejection is now suppressed
+        };
+        // Then apply onFinally lifecycle hook if provided
+        return onFinally ? withStreamLifecycle(result, onFinally) : result;
+    }
+}
+/**
+ * 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":"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"}

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

@@ -0,0 +1,4 @@
+export type { StreamTextProvider, StreamTextOptions, StreamTextResult, StepParameters, StreamChunk, StepResult, FinalResult, } from "./provider.js";
+export { withStreamLifecycle } from "./stream-lifecycle.js";
+export { VercelStreamTextAdapter, createVercelProvider, } from "./adapters/vercel.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":"AACA,YAAY,EACV,kBAAkB,EAClB,iBAAiB,EACjB,gBAAgB,EAChB,cAAc,EACd,WAAW,EACX,UAAU,EACV,WAAW,GACZ,MAAM,eAAe,CAAC;AAGvB,OAAO,EAAE,mBAAmB,EAAE,MAAM,uBAAuB,CAAC;AAG5D,OAAO,EACL,uBAAuB,EACvB,oBAAoB,GACrB,MAAM,sBAAsB,CAAC"}

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

@@ -0,0 +1,5 @@
+// Stream lifecycle utilities
+export { withStreamLifecycle } from "./stream-lifecycle.js";
+// Vercel SDK adapter
+export { VercelStreamTextAdapter, createVercelProvider, } from "./adapters/vercel.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":"AAWA,6BAA6B;AAC7B,OAAO,EAAE,mBAAmB,EAAE,MAAM,uBAAuB,CAAC;AAE5D,qBAAqB;AACrB,OAAO,EACL,uBAAuB,EACvB,oBAAoB,GACrB,MAAM,sBAAsB,CAAC"}

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

@@ -0,0 +1,189 @@
+/**
+ * High-level provider interface for LLM streaming interactions.
+ *
+ * This interface defines a complete, SDK-agnostic contract for multi-step
+ * LLM streaming, including all lifecycle hooks. Concrete implementations
+ * (adapters) bridge this interface to specific SDKs (Vercel AI, Anthropic, etc.).
+ *
+ * Key features:
+ * - Complete lifecycle: prepareStep → onChunk → onStepFinish → onFinish → onFinally
+ * - onFinally: Guaranteed to run after stream consumption (our addition!)
+ * - SDK-agnostic: Could be implemented with any LLM SDK
+ * - Testable: Easy to mock for testing
+ */
+import type { LanguageModelV3 } from "@ai-sdk/provider";
+import type { FlexibleSchema, ProviderOptions } from "@ai-sdk/provider-utils";
+import type { TextStreamPart, LanguageModelUsage, ModelMessage, UserModelMessage, ToolChoice } from "ai";
+import type { Tool } from "../../agent/tools2/types.js";
+import type { StopCondition } from "../../util/stop-condition.js";
+/**
+ * Provider interface for LLM streaming interactions.
+ *
+ * Implementations of this interface wrap specific SDKs and provide
+ * a consistent, high-level API with complete lifecycle management.
+ */
+export interface StreamTextProvider {
+    /**
+     * Streams text from an LLM with multi-step tool calling support.
+     *
+     * @param options - Configuration and lifecycle hooks
+     * @returns Promise resolving to stream result with text/full streams
+     */
+    streamText<TOOLS extends Record<string, Tool> = Record<string, Tool>, OUTPUT = unknown>(options: StreamTextOptions<TOOLS, OUTPUT>): Promise<StreamTextResult<TOOLS>>;
+}
+/**
+ * Options for a streamText call.
+ *
+ * Includes model configuration, messages, tools, and comprehensive
+ * lifecycle hooks including onFinally (runs after stream consumption).
+ *
+ * @template TOOLS - Record of available tools
+ * @template OUTPUT - Type of structured output (when using experimental_output)
+ */
+export interface StreamTextOptions<TOOLS extends Record<string, Tool>, OUTPUT = unknown> {
+    /** The language model to use */
+    model: LanguageModelV3;
+    /**
+     * Conversation messages.
+     * Note: When using context middleware, this will be populated automatically
+     * from context history. You typically provide user instead.
+     */
+    messages?: ModelMessage[];
+    /**
+     * User message for this interaction.
+     * When using context middleware, this is added to the conversation history
+     * and messages are populated automatically from context.
+     */
+    user?: UserModelMessage;
+    /** Available tools the model can call */
+    tools?: TOOLS;
+    /**
+     * System prompt.
+     * When using context middleware, this is set on the context.
+     */
+    system?: string;
+    /** Maximum number of automatic tool call steps */
+    maxSteps?: number;
+    /** Maximum number of tokens to generate */
+    maxOutputTokens?: number;
+    /** Abort signal for cancellation */
+    abortSignal?: AbortSignal;
+    /** Custom headers for the request */
+    headers?: Record<string, string | undefined>;
+    /** Provider-specific options */
+    providerOptions?: ProviderOptions;
+    /**
+     * Vercel AI SDK specific: Condition to stop generation early.
+     * Pass through to the underlying SDK.
+     */
+    stopWhen?: StopCondition<any> | StopCondition<any>[];
+    /**
+     * Vercel AI SDK specific: Transformation stream for the output.
+     * Pass through to the underlying SDK.
+     */
+    experimental_transform?: any;
+    /**
+     * Schema for structured (JSON) output. When provided, the adapter wraps it
+     * in the underlying SDK's structured-output spec (e.g. the Vercel SDK's
+     * `Output.object`, which accepts a Zod/flexible schema directly) so the
+     * model is instructed to emit conforming JSON. The Vercel adapter does not
+     * surface a parsed value on `StreamTextResult` — it only supports
+     * partial/streaming output — so higher-level helpers (e.g.
+     * `LLMClient.generateObject`) drain the streamed text and validate it
+     * against this schema themselves.
+     */
+    experimental_output?: FlexibleSchema<OUTPUT>;
+    /**
+     * Called before each LLM step.
+     * Can transform the step parameters before execution.
+     */
+    prepareStep?: (step: StepParameters<TOOLS>) => Promise<StepParameters<TOOLS>> | StepParameters<TOOLS>;
+    /**
+     * Called for each chunk in the stream during generation.
+     */
+    onChunk?: (event: {
+        chunk: StreamChunk;
+    }) => Promise<void> | void;
+    /**
+     * Called after each step completes (after tool execution).
+     */
+    onStepFinish?: (step: StepResult<TOOLS>) => Promise<void> | void;
+    /**
+     * Called when the entire multi-step interaction finishes.
+     * This fires after generation completes, before stream consumption.
+     */
+    onFinish?: (result: FinalResult<TOOLS>) => Promise<void> | void;
+    /**
+     * Called after stream consumption completes.
+     *
+     * This is the key lifecycle hook for cleanup operations:
+     * - Releasing locks (context handles)
+     * - Finishing tracing spans
+     * - Closing database connections
+     * - Saving final artifacts
+     *
+     * Guarantees:
+     * - Runs exactly once, even if multiple stream accessors are used
+     * - Runs after the stream is fully consumed OR abandoned
+     * - Runs in error cases as well (usage may be partial)
+     * - Idempotent and safe to call multiple times
+     *
+     */
+    onFinally?: () => Promise<void> | void;
+    /**
+     * Called if an error occurs during generation or consumption.
+     */
+    onError?: (error: Error) => Promise<void> | void;
+    /**
+     * Called if the operation is aborted via the abortSignal.
+     */
+    onAbort?: () => Promise<void> | void;
+}
+/**
+ * Parameters for a single LLM step.
+ */
+export interface StepParameters<TOOLS extends Record<string, Tool>> {
+    messages: ModelMessage[];
+    stepNumber: number;
+    toolChoice?: ToolChoice<TOOLS>;
+    activeTools?: string[];
+}
+/**
+ * A chunk from the streaming response.
+ * This is a direct re-export of Vercel AI SDK's TextStreamPart.
+ */
+export type StreamChunk = TextStreamPart<Record<string, Tool>>;
+import type { StepResult as VercelStepResult } from "ai";
+/**
+ * Result of a single LLM step.
+ * Re-exported from Vercel AI SDK to avoid type incompatibilities.
+ */
+export type StepResult<TOOLS extends Record<string, Tool>> = VercelStepResult<TOOLS>;
+/**
+ * Final result of the entire multi-step interaction.
+ * This is the result passed to onFinish callback.
+ * Re-exported from Vercel AI SDK's internal type.
+ */
+export type FinalResult<TOOLS extends Record<string, Tool>> = StepResult<TOOLS> & {
+    readonly steps: StepResult<TOOLS>[];
+    readonly totalUsage: LanguageModelUsage;
+};
+import type { AsyncIterableStream } from "ai";
+/**
+ * Result of a streamText call.
+ *
+ * This type defines only the properties we actually use from the Vercel AI SDK's
+ * StreamTextResult. Adapters must use `createStreamResult()` to build this type
+ * from raw SDK results, ensuring all properties are plain enumerable values.
+ */
+export type StreamTextResult<TOOLS extends Record<string, Tool> = Record<string, Tool>> = {
+    /** Stream of text deltas */
+    textStream: AsyncIterableStream<string>;
+    /** Stream of all events (text, tool calls, etc.) */
+    fullStream: AsyncIterableStream<TextStreamPart<TOOLS>>;
+    /** Promise resolving to step results after stream consumption */
+    steps: Promise<StepResult<TOOLS>[]>;
+    /** Promise resolving to the final result after stream consumption */
+    response?: Promise<FinalResult<TOOLS>>;
+};
+//# sourceMappingURL=provider.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"provider.d.ts","sourceRoot":"","sources":["../../../../src/ai-service/llm/interaction/provider.ts"],"names":[],"mappings":"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"}

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

@@ -0,0 +1,15 @@
+/**
+ * High-level provider interface for LLM streaming interactions.
+ *
+ * This interface defines a complete, SDK-agnostic contract for multi-step
+ * LLM streaming, including all lifecycle hooks. Concrete implementations
+ * (adapters) bridge this interface to specific SDKs (Vercel AI, Anthropic, etc.).
+ *
+ * Key features:
+ * - Complete lifecycle: prepareStep → onChunk → onStepFinish → onFinish → onFinally
+ * - onFinally: Guaranteed to run after stream consumption (our addition!)
+ * - SDK-agnostic: Could be implemented with any LLM SDK
+ * - Testable: Easy to mock for testing
+ */
+export {};
+//# sourceMappingURL=provider.js.map

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

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

package/dist/ai-service/llm/interaction/stream-lifecycle.d.ts

@@ -0,0 +1,48 @@
+/**
+ * Stream lifecycle management utilities.
+ *
+ * Provides utilities for wrapping streams with lifecycle hooks, particularly
+ * `onFinally` which runs after stream consumption completes.
+ *
+ * Key challenge: The `streamText()` function returns immediately, but the
+ * streams are consumed asynchronously later. We need to track when consumption
+ * actually completes to run cleanup logic.
+ *
+ * Solution: Wrap streams with `TransformStream` that tracks consumption via
+ * the `flush()` method, which runs when the input stream closes.
+ */
+import type { Tool } from "../../agent/tools2/types.js";
+import type { StreamTextResult } from "./provider.js";
+/**
+ * Wraps a StreamTextResult to add onFinally lifecycle hook.
+ *
+ * The onFinally callback runs after stream consumption completes, handling:
+ * - Normal completion (stream exhausted)
+ * - Errors during consumption
+ * - Stream cancellation/abandonment
+ *
+ * Guarantees:
+ * - Runs exactly once, even if multiple stream accessors are used
+ * - Idempotent (safe to call multiple times)
+ * - Works with all consumption patterns (iteration, promises, piping)
+ *
+ * @param result - The stream result to wrap
+ * @param onFinally - Callback to run after consumption
+ * @returns Wrapped result with lifecycle tracking
+ *
+ * @example
+ * ```typescript
+ * const result = await streamText({ model, messages });
+ * const wrapped = withStreamLifecycle(result, async () => {
+ *   console.log('Stream consumed!');
+ *   await cleanup();
+ * });
+ *
+ * for await (const text of wrapped.textStream) {
+ *   console.log(text);
+ * }
+ * // onFinally runs here ^
+ * ```
+ */
+export declare function withStreamLifecycle<TOOLS extends Record<string, Tool> = Record<string, Tool>>(result: StreamTextResult<TOOLS>, onFinally: () => Promise<void> | void): StreamTextResult<TOOLS>;
+//# sourceMappingURL=stream-lifecycle.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"stream-lifecycle.d.ts","sourceRoot":"","sources":["../../../../src/ai-service/llm/interaction/stream-lifecycle.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;GAYG;AAKH,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,6BAA6B,CAAC;AAExD,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,eAAe,CAAC;AAEtD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA8BG;AACH,wBAAgB,mBAAmB,CACjC,KAAK,SAAS,MAAM,CAAC,MAAM,EAAE,IAAI,CAAC,GAAG,MAAM,CAAC,MAAM,EAAE,IAAI,CAAC,EAEzD,MAAM,EAAE,gBAAgB,CAAC,KAAK,CAAC,EAC/B,SAAS,EAAE,MAAM,OAAO,CAAC,IAAI,CAAC,GAAG,IAAI,GACpC,gBAAgB,CAAC,KAAK,CAAC,CAqCzB"}

package/dist/ai-service/llm/interaction/stream-lifecycle.js

@@ -0,0 +1,147 @@
+/**
+ * Stream lifecycle management utilities.
+ *
+ * Provides utilities for wrapping streams with lifecycle hooks, particularly
+ * `onFinally` which runs after stream consumption completes.
+ *
+ * Key challenge: The `streamText()` function returns immediately, but the
+ * streams are consumed asynchronously later. We need to track when consumption
+ * actually completes to run cleanup logic.
+ *
+ * Solution: Wrap streams with `TransformStream` that tracks consumption via
+ * the `flush()` method, which runs when the input stream closes.
+ */
+import { getErrorMeta, getLogger } from "../../../util/logger.js";
+import { isNoOutputError } from "../error.js";
+/**
+ * Wraps a StreamTextResult to add onFinally lifecycle hook.
+ *
+ * The onFinally callback runs after stream consumption completes, handling:
+ * - Normal completion (stream exhausted)
+ * - Errors during consumption
+ * - Stream cancellation/abandonment
+ *
+ * Guarantees:
+ * - Runs exactly once, even if multiple stream accessors are used
+ * - Idempotent (safe to call multiple times)
+ * - Works with all consumption patterns (iteration, promises, piping)
+ *
+ * @param result - The stream result to wrap
+ * @param onFinally - Callback to run after consumption
+ * @returns Wrapped result with lifecycle tracking
+ *
+ * @example
+ * ```typescript
+ * const result = await streamText({ model, messages });
+ * const wrapped = withStreamLifecycle(result, async () => {
+ *   console.log('Stream consumed!');
+ *   await cleanup();
+ * });
+ *
+ * for await (const text of wrapped.textStream) {
+ *   console.log(text);
+ * }
+ * // onFinally runs here ^
+ * ```
+ */
+export function withStreamLifecycle(result, onFinally) {
+    // Track whether finalization has run
+    let finalized = false;
+    /**
+     * Ensures onFinally runs exactly once.
+     * Safe to call multiple times (idempotent).
+     */
+    const ensureFinally = async () => {
+        if (finalized)
+            return;
+        finalized = true;
+        try {
+            await onFinally();
+        }
+        catch (error) {
+            // Log but don't throw - we're in cleanup, don't break the stream
+            // This catch is in ensureFinally, which is called from flush()
+            getLogger().error("Error in stream lifecycle ensureFinally", getErrorMeta(error));
+        }
+    };
+    // Wrap textStream to track consumption
+    const wrappedTextStream = wrapAsyncIterable(result.textStream, ensureFinally);
+    // Wrap fullStream to track consumption
+    const wrappedFullStream = wrapAsyncIterable(result.fullStream, ensureFinally);
+    // Return result with wrapped streams
+    // Spread works because adapter materialized getters into enumerable properties
+    return {
+        ...result,
+        textStream: wrappedTextStream,
+        fullStream: wrappedFullStream,
+    };
+}
+/**
+ * Wraps an async iterable with a finalization callback.
+ *
+ * Uses TransformStream to intercept the stream lifecycle:
+ * - `transform()`: Passes chunks through unchanged
+ * - `flush()`: Called when input stream closes (after all chunks processed)
+ * - `cancel()`: Called if stream is cancelled/abandoned
+ *
+ * The finalization callback runs in both flush() and cancel() to ensure
+ * cleanup happens whether the stream completes normally or is abandoned.
+ *
+ * @param source - The async iterable to wrap
+ * @param onFinalize - Callback to run after consumption
+ * @returns Wrapped async iterable
+ */
+function wrapAsyncIterable(source, onFinalize) {
+    // Convert async iterable to ReadableStream if needed
+    let sourceStream;
+    if (source instanceof ReadableStream) {
+        sourceStream = source;
+    }
+    else {
+        // Manually convert async iterable to ReadableStream
+        sourceStream = new ReadableStream({
+            async start(controller) {
+                try {
+                    for await (const chunk of source) {
+                        controller.enqueue(chunk);
+                    }
+                    controller.close();
+                }
+                catch (error) {
+                    controller.error(error);
+                }
+            },
+        });
+    }
+    // Create transform stream that tracks lifecycle
+    const lifecycleTransform = new TransformStream({
+        // Pass through all chunks unchanged
+        transform(chunk, controller) {
+            controller.enqueue(chunk);
+        },
+        // Called when input stream closes (after all chunks processed)
+        async flush(controller) {
+            try {
+                await onFinalize();
+            }
+            catch (error) {
+                // Handle errors in onFinally, including AI_NoOutputGeneratedError from Vercel AI SDK
+                // This can happen when the stream completes without generating output
+                // We don't want to propagate these errors as unhandled rejections
+                if (isNoOutputError(error)) {
+                    getLogger().warn(`AI stream completed without output (this may be expected): ${error instanceof Error ? error.message : String(error)}`);
+                }
+                else {
+                    // For other errors, log and rethrow so they can be handled upstream
+                    getLogger().error("Error in stream lifecycle onFinally", getErrorMeta(error));
+                    controller.error(error);
+                }
+            }
+        },
+    });
+    // Pipe source through lifecycle tracker
+    const wrappedStream = sourceStream.pipeThrough(lifecycleTransform);
+    // Return as AsyncIterableStream (has both stream and iterable interfaces)
+    return wrappedStream;
+}
+//# sourceMappingURL=stream-lifecycle.js.map

package/dist/ai-service/llm/interaction/stream-lifecycle.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"stream-lifecycle.js","sourceRoot":"","sources":["../../../../src/ai-service/llm/interaction/stream-lifecycle.ts"],"names":[],"mappings":"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"}

package/dist/ai-service/llm/provider.d.ts

@@ -0,0 +1,10 @@
+import { type Span } from "@opentelemetry/api";
+import type { LLMProviderConfig, AiAttributes } from "@superblocksteam/library-shared/types";
+import type { LLMProvider, LLMProviderSettings } from "./types.js";
+/** Record an error on a span and set its status to ERROR. */
+export declare const setSpanError: (span: Span, error: unknown) => void;
+export declare const createLLMProvider: (settings: LLMProviderSettings, getJwt?: () => string | undefined, llmConfig?: LLMProviderConfig, getAttributes?: () => AiAttributes | undefined, traceHeaders?: {
+    traceparent?: string;
+    tracestate?: string;
+}) => LLMProvider;
+//# sourceMappingURL=provider.d.ts.map