@superblocksteam/vite-plugin-file-sync 2.0.41-next.52 → 2.0.41-next.6

package/dist/ai-service/llmobs/middleware/stream-text.d.ts

@@ -1,60 +0,0 @@
-import { type Logger } from "../../../util/logger.js";
-import { LLMObsTracer, type LLMObsSpan } from "../index.js";
-import type { ToolSet, StreamTextOnStepFinishCallback, LanguageModel, StreamTextOnFinishCallback, StreamTextOnErrorCallback, StepResult, ModelMessage, PrepareStepFunction, PrepareStepResult, StreamTextOnChunkCallback } from "ai";
-import type { streamText } from "ai";
-type StreamAbortEvent<T extends ToolSet> = {
-    readonly steps: StepResult<T>[];
-};
-type StreamTextOnAbortCallback<T extends ToolSet> = (event: StreamAbortEvent<T>) => PromiseLike<void> | void;
-type StreamSegment = {
-    type: "text" | "reasoning" | "tool-call" | "tool-result" | "tool-input" | "raw" | "thinking" | "source";
-    span: LLMObsSpan;
-    content: string | {
-        [key: string]: any;
-    } | undefined;
-};
-export declare class LLMObsStreamTextMiddleware {
-    fullSpan?: LLMObsSpan;
-    stepSpan?: LLMObsSpan;
-    currentSegment?: StreamSegment;
-    modelName: string;
-    modelProvider?: string;
-    modelProviderDetailed?: string;
-    tools?: ToolSet;
-    stepResults: StepResult<any>[];
-    llmobs: LLMObsTracer;
-    logger: Logger;
-    private errorLogged;
-    wrap<T extends ToolSet>(fn: typeof streamText<T>): typeof streamText<T>;
-    constructor(llmobs?: LLMObsTracer, logger?: Logger);
-    private transform;
-    prepareStep<T extends ToolSet>(options: Parameters<PrepareStepFunction<T>>[0], next?: PrepareStepFunction<T>): Promise<{
-        steps: StepResult<NoInfer<T>>[];
-        stepNumber: number;
-        model: LanguageModel;
-        messages: Array<ModelMessage>;
-    } | PrepareStepResult<T>>;
-    onChunk<T extends ToolSet>(event: Parameters<StreamTextOnChunkCallback<T>>[0], next?: StreamTextOnChunkCallback<T>): Promise<void>;
-    onStepFinish<T extends ToolSet>(result: Parameters<StreamTextOnStepFinishCallback<T>>[0], next?: StreamTextOnStepFinishCallback<T>): Promise<void>;
-    onError(event: Parameters<StreamTextOnErrorCallback>[0], next?: StreamTextOnErrorCallback): Promise<void>;
-    onAbort<T extends ToolSet>(event: StreamAbortEvent<T>, next?: StreamTextOnAbortCallback<T>): Promise<void>;
-    onFinish<T extends ToolSet>(event: Parameters<StreamTextOnFinishCallback<T>>[0], next?: StreamTextOnFinishCallback<T>): Promise<void>;
-    onFinally(): Promise<void>;
-    private handleStreamError;
-    private handleToolExecuteStart;
-    private logStreamError;
-    private ensureSegment;
-    private appendTextToCurrentSegment;
-    private appendToolInputDelta;
-    private isTextualSegment;
-    private getSegmentType;
-    private startSegment;
-    private finishSegment;
-    private startStepSpan;
-    private finishStepSpan;
-    private startFullSpan;
-    private finishFullSpan;
-    private setModel;
-}
-export {};
-//# sourceMappingURL=stream-text.d.ts.map

package/dist/ai-service/llmobs/middleware/stream-text.d.ts.map

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

package/dist/ai-service/llmobs/middleware/stream-text.js

@@ -1,601 +0,0 @@
-import { getLogger } from "../../../util/logger.js";
-import { safeJsonStringify } from "../../util/safe-stringify.js";
-import { traceToolSet } from "../helpers.js";
-import { LLMObsTracer, } from "../index.js";
-export class LLMObsStreamTextMiddleware {
-    fullSpan;
-    stepSpan;
-    currentSegment;
-    modelName = "unknown";
-    modelProvider;
-    modelProviderDetailed;
-    tools;
-    stepResults = [];
-    llmobs;
-    logger;
-    errorLogged = false;
-    wrap(fn) {
-        return (params) => {
-            const result = fn(this.transform(params));
-            return {
-                ...result,
-                fullStream: wrapStream(result.fullStream, async (error) => this.handleStreamError(error, "full"), async () => this.onFinally()),
-            };
-        };
-    }
-    constructor(llmobs = LLMObsTracer.instance, logger = getLogger()) {
-        this.llmobs = llmobs;
-        this.logger = logger;
-    }
-    transform(params) {
-        const tools = params.tools
-            ? traceToolSet(params.tools, this.llmobs, {
-                beforeExecute: this.handleToolExecuteStart.bind(this),
-            })
-            : undefined;
-        this.tools = tools;
-        return {
-            ...params,
-            prepareStep: (e) => this.prepareStep(e, params.prepareStep),
-            onChunk: (e) => this.onChunk(e, params.onChunk),
-            onStepFinish: (e) => this.onStepFinish(e, params.onStepFinish),
-            onError: (e) => this.onError(e, params.onError),
-            onAbort: (e) => this.onAbort(e, params.onAbort),
-            onFinish: (e) => this.onFinish(e, params.onFinish),
-            tools: params.tools
-                ? traceToolSet(params.tools, this.llmobs, {
-                    beforeExecute: (e) => this.handleToolExecuteStart(e),
-                })
-                : undefined,
-        };
-    }
-    async prepareStep(options, next) {
-        let preparedStepResult;
-        try {
-            if (next) {
-                preparedStepResult = await next(options);
-                return preparedStepResult;
-            }
-            else {
-                return options;
-            }
-        }
-        finally {
-            this.setModel(preparedStepResult?.model ?? options.model);
-            const messages = preparedStepResult?.messages ?? options.messages;
-            if (!this.fullSpan) {
-                // Start a full span for the entire streamText call
-                this.startFullSpan({ messages });
-            }
-            this.startStepSpan({
-                stepNumber: options.stepNumber,
-                inputMessages: messages,
-            });
-            this.startSegment({ type: "thinking" });
-        }
-    }
-    async onChunk(event, next) {
-        if (next) {
-            try {
-                await next(event);
-            }
-            catch {
-                // Ignore user callback errors to avoid breaking stream processing
-            }
-        }
-        const chunk = event.chunk;
-        if (chunk.type === "tool-input-start") {
-            const startContent = { tool: chunk.toolName, input: "" };
-            this.startSegment({ type: "tool-input", startContent });
-            return;
-        }
-        if (chunk.type === "tool-input-delta") {
-            this.appendToolInputDelta(chunk.delta);
-            return;
-        }
-        const deltaType = this.getSegmentType(chunk.type, "-delta");
-        if (deltaType) {
-            this.ensureSegment(deltaType);
-            if (this.isTextualSegment(deltaType) &&
-                "text" in chunk &&
-                typeof chunk.text === "string") {
-                this.appendTextToCurrentSegment(chunk.text);
-            }
-            return;
-        }
-    }
-    async onStepFinish(result, next) {
-        this.logger.debug("onStepFinish called");
-        this.stepResults.push(result);
-        try {
-            if (next) {
-                await next(result);
-            }
-        }
-        finally {
-            const provider = result.providerMetadata && safeJsonStringify(result.providerMetadata);
-            this.finishStepSpan({
-                result,
-                annotations: {
-                    metadata: {
-                        provider,
-                    },
-                },
-            });
-        }
-    }
-    async onError(event, next) {
-        if (next) {
-            try {
-                await next(event);
-            }
-            catch (userError) {
-                this.logger.error(`Error in user-provided onError: ${userError}`);
-            }
-        }
-        const error = event.error;
-        this.finishStepSpan({ error });
-    }
-    async onAbort(event, next) {
-        try {
-            if (next) {
-                await next(event);
-            }
-            return;
-        }
-        finally {
-            this.finishFullSpan({ annotations: { tags: { aborted: true } } });
-        }
-    }
-    async onFinish(event, next) {
-        try {
-            if (next) {
-                await next(event);
-            }
-        }
-        finally {
-            this.finishFullSpan({ finalResult: event });
-        }
-    }
-    async onFinally() {
-        this.finishFullSpan();
-    }
-    handleStreamError(error, context) {
-        this.logStreamError(error, context);
-        this.finishFullSpan({ error });
-    }
-    handleToolExecuteStart(_name) {
-        this.finishSegment();
-    }
-    logStreamError(error, context) {
-        if (this.errorLogged) {
-            return;
-        }
-        this.errorLogged = true;
-        const message = error instanceof Error
-            ? `Error in ${context} async iterable: ${error.message}`
-            : `Error in ${context} async iterable: ${safeJsonStringify(error)}`;
-        this.logger.error(message);
-    }
-    ensureSegment(type) {
-        if (this.currentSegment?.type !== type) {
-            this.finishSegment();
-            this.startSegment({ type });
-            return;
-        }
-        if (!this.currentSegment) {
-            this.startSegment({ type });
-        }
-    }
-    appendTextToCurrentSegment(text) {
-        const segment = this.currentSegment;
-        if (!segment) {
-            return;
-        }
-        const existing = typeof segment.content === "string" ? segment.content : "";
-        segment.content = `${existing}${text}`;
-    }
-    appendToolInputDelta(delta) {
-        const segment = this.currentSegment;
-        if (!segment || segment.type !== "tool-input") {
-            return;
-        }
-        const content = segment.content;
-        content.input += delta;
-    }
-    isTextualSegment(type) {
-        return (type === "text" ||
-            type === "reasoning" ||
-            type === "thinking" ||
-            type === "raw" ||
-            type === "source");
-    }
-    getSegmentType(eventType, suffix) {
-        if (!eventType.endsWith(suffix)) {
-            return undefined;
-        }
-        const base = eventType.slice(0, -suffix.length);
-        const admissible = [
-            "text",
-            "reasoning",
-            "thinking",
-            "raw",
-            "source",
-            "tool-call",
-            "tool-result",
-            "tool-input",
-        ];
-        return admissible.includes(base) ? base : undefined;
-    }
-    startSegment(options) {
-        if (this.currentSegment) {
-            // Finish any existing segment before starting a new one
-            this.finishSegment();
-        }
-        const { type, startContent } = options;
-        const segmentSpan = this.llmobs.startActiveSpan({
-            kind: "task",
-            name: `ai.streamText.${type}`,
-        });
-        this.currentSegment = { span: segmentSpan, type, content: startContent };
-    }
-    finishSegment(options) {
-        const segment = this.currentSegment;
-        if (!segment) {
-            return;
-        }
-        const { lastText, annotations, error } = options || {};
-        if (lastText) {
-            segment.content += lastText;
-        }
-        if (segment.type === "tool-input" && typeof segment.content === "object") {
-            try {
-                segment.content.input = JSON.parse(segment.content.input);
-            }
-            catch {
-                // leave as-is if not JSON
-            }
-        }
-        this.llmobs.annotate(segment.span, {
-            outputData: segment.content,
-            ...annotations,
-            ...{ error },
-        });
-        segment.span.finish();
-        this.currentSegment = undefined;
-    }
-    startStepSpan(options) {
-        this.finishSegment();
-        this.stepSpan = this.llmobs.startActiveSpan({
-            kind: "llm",
-            name: "ai.streamText.step",
-            modelName: this.modelName,
-            modelProvider: this.modelProvider,
-        });
-        this.llmobs.annotate(this.stepSpan, {
-            inputData: formatInputData(options.inputMessages, this.tools),
-            tags: {
-                stepNumber: options.stepNumber,
-                modelProviderDetailed: this.modelProviderDetailed,
-            },
-        });
-    }
-    finishStepSpan(options) {
-        if (!this.stepSpan) {
-            return;
-        }
-        this.finishSegment({ ...options });
-        const { result, annotations, error } = options || {};
-        const resultAnnotations = {};
-        if (result) {
-            resultAnnotations.outputData = formatOutputData(result, this.tools);
-            resultAnnotations.metrics = compileMetrics([result]);
-        }
-        this.llmobs.annotate(this.stepSpan, {
-            ...resultAnnotations,
-            ...annotations,
-            ...{ error },
-        });
-        this.stepSpan.finish();
-        this.stepSpan = undefined;
-    }
-    startFullSpan(options) {
-        const { messages, providerOptions } = options || {};
-        this.fullSpan = this.llmobs.startActiveSpan({
-            kind: "workflow",
-            name: "ai.streamText",
-            modelName: this.modelName,
-            modelProvider: this.modelProvider,
-        });
-        const userPrompt = typeof messages === "string" ? messages : messages?.at(-1)?.content;
-        const inputData = safeJsonStringify(userPrompt);
-        this.llmobs.annotate(this.fullSpan, {
-            inputData,
-            metadata: {
-                ...providerOptions,
-            },
-            tags: {
-                modelProviderDetailed: this.modelProviderDetailed,
-            },
-        });
-    }
-    finishFullSpan(options) {
-        if (!this.fullSpan) {
-            return;
-        }
-        this.finishStepSpan({ ...options });
-        const { finalResult, annotations, error } = options || {};
-        const resultAnnotations = {};
-        if (finalResult) {
-            const lastMessage = formatOutputData(finalResult, this.tools).at(-1);
-            resultAnnotations.outputData = lastMessage?.content;
-            resultAnnotations.metadata = finalResult.providerMetadata
-                ? {
-                    provider: safeJsonStringify(finalResult.providerMetadata),
-                }
-                : {};
-        }
-        this.llmobs.annotate(this.fullSpan, {
-            ...resultAnnotations,
-            ...annotations,
-            ...{ error },
-        });
-        this.fullSpan.finish();
-        this.fullSpan = undefined;
-    }
-    setModel(model) {
-        const { modelName, modelProvider, modelProviderDetailed } = parseModelConfig(model);
-        this.modelName = modelName;
-        this.modelProvider = modelProvider;
-        this.modelProviderDetailed = modelProviderDetailed;
-    }
-}
-function parseModelConfig(model) {
-    let modelName = typeof model === "string" ? model : model.modelId;
-    if (modelName.startsWith("claude-4-sonnet")) {
-        // Normalize naming for consistency with models.dev
-        modelName = modelName.replace("claude-4-sonnet", "claude-sonnet-4");
-    }
-    const modelProviderDetailed = typeof model === "string" ? undefined : model.provider;
-    const modelProvider = modelProviderDetailed?.split(".")[0];
-    return { modelName, modelProvider, modelProviderDetailed };
-}
-function compileMetrics(steps) {
-    const metrics = {};
-    metrics.toolCallCount = 0;
-    metrics.staticToolCallCount = 0;
-    metrics.dynamicToolCallCount = 0;
-    metrics.filesGeneratedCount = 0;
-    metrics.stepCount = steps.length;
-    steps.forEach((step) => {
-        const usage = step.usage;
-        if (usage.inputTokens != undefined) {
-            metrics.inputTokens = (metrics.inputTokens ?? 0) + usage.inputTokens;
-        }
-        if (usage.outputTokens != undefined) {
-            metrics.outputTokens = (metrics.outputTokens ?? 0) + usage.outputTokens;
-        }
-        if (usage.totalTokens != undefined) {
-            metrics.totalTokens = (metrics.totalTokens ?? 0) + usage.totalTokens;
-        }
-        if (usage.reasoningTokens != undefined) {
-            metrics.reasoningTokens =
-                (metrics.reasoningTokens ?? 0) + usage.reasoningTokens;
-        }
-        if (usage.cachedInputTokens != undefined) {
-            metrics.cachedInputTokens =
-                (metrics.cachedInputTokens ?? 0) + usage.cachedInputTokens;
-        }
-        metrics.toolCallCount += step.toolCalls.length;
-        metrics.staticToolCallCount += step.staticToolCalls.length;
-        metrics.dynamicToolCallCount += step.dynamicToolCalls.length;
-        metrics.filesGeneratedCount += step.files.length;
-    });
-    return metrics;
-}
-function formatInputData(input, toolSet) {
-    if (!input)
-        return undefined;
-    if (typeof input === "string") {
-        return [{ role: "user", content: input }];
-    }
-    const messages = [];
-    input.forEach((m) => {
-        if (m.role === "system") {
-            messages.push({
-                role: "system",
-                content: m.content,
-            });
-        }
-        else if (m.role === "user") {
-            if (!Array.isArray(m.content)) {
-                messages.push({
-                    role: "user",
-                    content: m.content,
-                });
-            }
-            else {
-                formatContent(m.content, toolSet, messages.pop()).forEach((m) => {
-                    messages.push({
-                        ...m,
-                        role: "user",
-                    });
-                });
-            }
-        }
-        else if (m.role === "assistant") {
-            if (!Array.isArray(m.content)) {
-                messages.push({
-                    role: "text",
-                    content: m.content,
-                });
-            }
-            else {
-                formatContent(m.content, toolSet, messages.pop()).forEach((m) => {
-                    messages.push({
-                        ...m,
-                    });
-                });
-            }
-        }
-        else if (m.role === "tool") {
-            formatContent(m.content, toolSet, messages.pop()).forEach((m) => {
-                messages.push({
-                    ...m,
-                });
-            });
-        }
-    });
-    return messages;
-}
-function formatOutputData(result, toolSet) {
-    return formatContent(result.content, toolSet);
-}
-function formatContent(parts, toolSet, lastMessage) {
-    const messages = lastMessage ? [lastMessage] : [];
-    parts.forEach((part) => {
-        if (part.type === "reasoning") {
-            messages.push({
-                role: "reasoning",
-                content: part.text,
-            });
-        }
-        else if (part.type === "text") {
-            messages.push({
-                role: "text",
-                content: part.text,
-            });
-        }
-        else if (part.type === "tool-call") {
-            const message = messages.pop() ?? {
-                role: "tool",
-                toolId: part.toolCallId,
-                content: "",
-            };
-            if (!message.toolCalls) {
-                message.toolCalls = [];
-            }
-            const [type, name] = part.toolName.split("_", 1);
-            const toolCall = {
-                name: name ?? part.toolName,
-                arguments: asDictionary(part.input) ?? {},
-                toolId: part.toolCallId,
-                type,
-            };
-            message.toolCalls.push(toolCall);
-            messages.push(message);
-        }
-        else if (part.type === "tool-result") {
-            const { toolName } = part;
-            const tool = toolSet?.[toolName];
-            let output;
-            if (tool?.toModelOutput) {
-                output = tool.toModelOutput(part.output);
-            }
-            else {
-                output = part.output;
-            }
-            messages.push({
-                role: "tool",
-                toolId: part.toolCallId,
-                content: stringifyToolOutput(output),
-            });
-        }
-        else if (part.type === "tool-error") {
-            const { error } = part;
-            messages.push({
-                role: "tool",
-                toolId: part.toolCallId,
-                content: safeJsonStringify({
-                    error,
-                }),
-            });
-        }
-        else if (part.type === "file") {
-            messages.push({
-                role: "file",
-                content: `Generated file`,
-            });
-        }
-        else if (part.type === "source") {
-            messages.push({
-                role: "source",
-                content: `Retrieved source: ${part.title}`,
-            });
-        }
-        else if (part.type === "image") {
-            messages.push({
-                role: "image",
-                content: `Generated image`,
-            });
-        }
-    });
-    return messages;
-}
-function stringifyToolOutput(output) {
-    if (typeof output !== "object" || output === null || !("type" in output)) {
-        return typeof output == "string" ? output : safeJsonStringify(output);
-    }
-    const { type, value } = output;
-    if (type == "text") {
-        return value;
-    }
-    else if (type == "error-text") {
-        return `ERROR: ${value}`;
-    }
-    else if (type == "json") {
-        return safeJsonStringify(value);
-    }
-    else if (type == "error-json") {
-        return safeJsonStringify({ error: value });
-    }
-    else {
-        return value
-            .filter((v) => v.type === "text")
-            .map((v) => v.text)
-            .join();
-    }
-}
-function asDictionary(value) {
-    if (value && typeof value === "object" && !Array.isArray(value)) {
-        return value;
-    }
-    return undefined;
-}
-function wrapStream(source, onError, onFinally) {
-    const iterator = source[Symbol.asyncIterator]();
-    let done = false;
-    const stream = new ReadableStream({
-        async pull(controller) {
-            try {
-                const { value, done: finished } = await iterator.next();
-                if (finished) {
-                    done = true;
-                    controller.close();
-                    await onFinally();
-                }
-                else {
-                    controller.enqueue(value);
-                }
-            }
-            catch (err) {
-                await onError(err);
-                controller.error(err);
-                await onFinally();
-            }
-        },
-        async cancel(reason) {
-            try {
-                await iterator.throw?.(reason);
-            }
-            finally {
-                if (!done) {
-                    done = true;
-                    await onFinally();
-                }
-            }
-        },
-    });
-    return stream;
-}
-//# sourceMappingURL=stream-text.js.map