@superblocksteam/clark 2.0.0-SNAPSHOT.a1e14d6b7a1bcd87

package/dist/clark-language-model.js

@@ -0,0 +1,862 @@
+import { EmptyResponseBodyError, JSONParseError, } from "@ai-sdk/provider";
+import { combineHeaders, extractResponseHeaders, postJsonToApi, } from "@ai-sdk/provider-utils";
+import { EventSourceParserStream, } from "eventsource-parser/stream";
+import { clarkFailedResponseHandler } from "./clark-error-handler.js";
+import { serializeToolInput, unwrapToolInputDelta, } from "./content-block-utils.js";
+function toFinishReason(rawFinishReason) {
+    const normalized = rawFinishReason === "stop" ||
+        rawFinishReason === "length" ||
+        rawFinishReason === "content-filter" ||
+        rawFinishReason === "tool-calls" ||
+        rawFinishReason === "error" ||
+        rawFinishReason === "other"
+        ? rawFinishReason
+        : "other";
+    return { unified: normalized, raw: rawFinishReason };
+}
+function toUsage(usageData) {
+    const inputTotal = usageData?.inputTokens ?? usageData?.promptTokens;
+    const cacheRead = usageData?.inputTokenDetails?.cacheReadTokens ??
+        usageData?.cachedInputTokens;
+    const cacheWrite = usageData?.inputTokenDetails?.cacheWriteTokens;
+    const noCacheInput = usageData?.inputTokenDetails?.noCacheTokens ??
+        (inputTotal !== undefined
+            ? Math.max(0, inputTotal - (cacheRead ?? 0) - (cacheWrite ?? 0))
+            : undefined);
+    const outputTotal = usageData?.outputTokens ?? usageData?.completionTokens;
+    return {
+        inputTokens: {
+            total: inputTotal,
+            noCache: noCacheInput,
+            cacheRead: cacheRead,
+            cacheWrite: cacheWrite,
+        },
+        outputTokens: {
+            total: outputTotal,
+            text: outputTotal,
+            reasoning: undefined,
+        },
+    };
+}
+function asRecord(value) {
+    if (typeof value === "object" && value !== null) {
+        return value;
+    }
+    return undefined;
+}
+function asProviderMetadata(value) {
+    const record = asRecord(value);
+    if (record == null) {
+        return undefined;
+    }
+    return record;
+}
+function getUnifiedRoutingOptions(providerOptions) {
+    const unifiedOptions = asRecord(providerOptions?.unified);
+    if (!unifiedOptions) {
+        return undefined;
+    }
+    const routingOptions = {
+        ...(typeof unifiedOptions.coreModel === "string" && {
+            coreModel: unifiedOptions.coreModel,
+        }),
+        ...(typeof unifiedOptions.forceProvider === "string" && {
+            forceProvider: unifiedOptions.forceProvider,
+        }),
+    };
+    return Object.keys(routingOptions).length > 0 ? routingOptions : undefined;
+}
+function sanitizeProviderOptions(providerOptions) {
+    if (!providerOptions || !("unified" in providerOptions)) {
+        return providerOptions;
+    }
+    const { unified: _unified, ...rest } = providerOptions;
+    const unifiedOptions = getUnifiedRoutingOptions(providerOptions);
+    return unifiedOptions
+        ? { ...rest, unified: unifiedOptions }
+        : rest;
+}
+function asString(value) {
+    return typeof value === "string" ? value : undefined;
+}
+function headerValue(headers, name) {
+    if (!headers) {
+        return undefined;
+    }
+    const normalizedName = name.toLowerCase();
+    if (headers instanceof Headers) {
+        return headers.get(normalizedName) ?? undefined;
+    }
+    if (Array.isArray(headers)) {
+        return headers.find(([key]) => key.toLowerCase() === normalizedName)?.[1];
+    }
+    return Object.entries(headers).find(([key]) => key.toLowerCase() === normalizedName)?.[1];
+}
+function requestFailure(error, abortSignalAborted) {
+    if (error instanceof Error) {
+        return {
+            name: error.name,
+            message: error.message,
+            abortSignalAborted,
+        };
+    }
+    return {
+        message: String(error),
+        abortSignalAborted,
+    };
+}
+function asWarnings(value) {
+    if (!Array.isArray(value)) {
+        return undefined;
+    }
+    return value;
+}
+function asUsage(value) {
+    const record = asRecord(value);
+    if (!record) {
+        return undefined;
+    }
+    return {
+        inputTokens: typeof record.inputTokens === "number" ? record.inputTokens : undefined,
+        outputTokens: typeof record.outputTokens === "number" ? record.outputTokens : undefined,
+        totalTokens: typeof record.totalTokens === "number" ? record.totalTokens : undefined,
+        promptTokens: typeof record.promptTokens === "number" ? record.promptTokens : undefined,
+        completionTokens: typeof record.completionTokens === "number"
+            ? record.completionTokens
+            : undefined,
+        cachedInputTokens: typeof record.cachedInputTokens === "number"
+            ? record.cachedInputTokens
+            : undefined,
+        inputTokenDetails: asRecord(record.inputTokenDetails)
+            ? {
+                noCacheTokens: typeof asRecord(record.inputTokenDetails)?.noCacheTokens ===
+                    "number"
+                    ? asRecord(record.inputTokenDetails)?.noCacheTokens
+                    : undefined,
+                cacheReadTokens: typeof asRecord(record.inputTokenDetails)?.cacheReadTokens ===
+                    "number"
+                    ? asRecord(record.inputTokenDetails)?.cacheReadTokens
+                    : undefined,
+                cacheWriteTokens: typeof asRecord(record.inputTokenDetails)?.cacheWriteTokens ===
+                    "number"
+                    ? asRecord(record.inputTokenDetails)?.cacheWriteTokens
+                    : undefined,
+            }
+            : undefined,
+    };
+}
+/**
+ * Wrap the debug hooks so a buggy sink that throws can never break streaming.
+ * Each hook swallows its own errors so the stream keeps flowing no matter what.
+ */
+function guardTelemetryScope(scope) {
+    return {
+        rawParsed() {
+            try {
+                scope.rawParsed();
+            }
+            catch {
+                // logging must never break streaming
+            }
+        },
+        unknownChunk(chunkType) {
+            try {
+                scope.unknownChunk(chunkType);
+            }
+            catch {
+                // logging must never break streaming
+            }
+        },
+        parseError(dataLength) {
+            try {
+                scope.parseError(dataLength);
+            }
+            catch {
+                // logging must never break streaming
+            }
+        },
+        errorChunk(detail) {
+            try {
+                scope.errorChunk(detail);
+            }
+            catch {
+                // logging must never break streaming
+            }
+        },
+        requestFailed(detail) {
+            try {
+                scope.requestFailed?.(detail);
+            }
+            catch {
+                // logging must never break streaming
+            }
+        },
+        streamFailed(detail) {
+            try {
+                scope.streamFailed?.(detail);
+            }
+            catch {
+                // logging must never break streaming
+            }
+        },
+    };
+}
+function reportStreamReadFailures(source, telemetryScope, abortSignal) {
+    const reader = source.getReader();
+    return new ReadableStream({
+        async pull(controller) {
+            try {
+                const result = await reader.read();
+                if (result.done) {
+                    controller.close();
+                    return;
+                }
+                controller.enqueue(result.value);
+            }
+            catch (error) {
+                telemetryScope?.streamFailed?.(requestFailure(error, abortSignal?.aborted === true));
+                controller.error(error);
+            }
+        },
+        async cancel(reason) {
+            await reader.cancel(reason);
+        },
+    });
+}
+function forwardAsActivity(controller, value) {
+    // We can't turn this message into normal content, but it still proves the
+    // stream is alive. Pass it through as "raw" so the client's stall timer
+    // doesn't wrongly decide the stream went dead, and so we never show the
+    // unparseable message as content.
+    controller.enqueue({ type: "raw", rawValue: value });
+}
+class DefaultClarkRequestBuilder {
+    async build({ prompt, maxOutputTokens, temperature, topP, topK, frequencyPenalty, presencePenalty, stopSequences, responseFormat, seed, tools, toolChoice, providerOptions, }, modelId) {
+        const warnings = [];
+        if (topP != null) {
+            warnings.push({
+                type: "unsupported",
+                feature: "topP",
+            });
+        }
+        if (topK != null) {
+            warnings.push({
+                type: "unsupported",
+                feature: "topK",
+            });
+        }
+        if (frequencyPenalty != null) {
+            warnings.push({
+                type: "unsupported",
+                feature: "frequencyPenalty",
+            });
+        }
+        if (presencePenalty != null) {
+            warnings.push({
+                type: "unsupported",
+                feature: "presencePenalty",
+            });
+        }
+        if (stopSequences != null) {
+            warnings.push({
+                type: "unsupported",
+                feature: "stopSequences",
+            });
+        }
+        let outputSchema = undefined;
+        if (responseFormat != null) {
+            if (responseFormat.type === "json" && responseFormat.schema) {
+                outputSchema = responseFormat.schema;
+            }
+            else {
+                warnings.push({
+                    type: "unsupported",
+                    feature: "responseFormat",
+                    details: "Only JSON response format with schema is supported",
+                });
+            }
+        }
+        if (seed != null) {
+            warnings.push({
+                type: "unsupported",
+                feature: "seed",
+            });
+        }
+        const providerOptionsForRequest = sanitizeProviderOptions(providerOptions);
+        const unifiedOptions = getUnifiedRoutingOptions(providerOptionsForRequest);
+        const baseArgs = {
+            model: modelId,
+            max_tokens: maxOutputTokens,
+            messages: prompt,
+            temperature: temperature,
+            providerOptions: providerOptionsForRequest,
+            ...(unifiedOptions?.forceProvider && {
+                forceProvider: unifiedOptions.forceProvider,
+            }),
+            ...(unifiedOptions?.coreModel && { coreModel: unifiedOptions.coreModel }),
+        };
+        const finalArgs = {
+            ...baseArgs,
+            tools,
+            toolChoice,
+        };
+        if (outputSchema !== undefined) {
+            finalArgs.outputSchema = outputSchema;
+        }
+        return {
+            args: finalArgs,
+            warnings,
+        };
+    }
+}
+class DefaultClarkTransport {
+    async postJson({ url, headers, body, failedResponseHandler, successfulResponseHandler, abortSignal, fetch, }) {
+        const result = await postJsonToApi({
+            url,
+            headers,
+            body,
+            failedResponseHandler,
+            successfulResponseHandler,
+            abortSignal,
+            fetch,
+        });
+        return {
+            responseHeaders: result.responseHeaders ?? {},
+            value: result.value,
+        };
+    }
+}
+function mergeWarnings(localWarnings, responseWarnings) {
+    const mergedWarnings = [...localWarnings];
+    const warningKeys = new Set(localWarnings.map((warning) => JSON.stringify(warning)));
+    for (const warning of responseWarnings ?? []) {
+        const warningKey = JSON.stringify(warning);
+        if (warningKeys.has(warningKey)) {
+            continue;
+        }
+        warningKeys.add(warningKey);
+        mergedWarnings.push(warning);
+    }
+    return mergedWarnings;
+}
+export class ClarkChatLanguageModel {
+    specificationVersion = "v3";
+    defaultObjectGenerationMode = "json";
+    supportsImageUrls = false;
+    // The AI SDK matches this map by media type (or '*'), not by URL scheme.
+    // Using '*' stops the SDK from downloading URLs itself so the Clark server
+    // can fetch them instead.
+    supportedUrls = { "*": [/^https:/] };
+    modelId;
+    config;
+    requestBuilder;
+    transport;
+    constructor(modelId, config, dependencies = {}) {
+        this.modelId = modelId;
+        this.config = config;
+        this.requestBuilder =
+            dependencies.requestBuilder ?? new DefaultClarkRequestBuilder();
+        this.transport = dependencies.transport ?? new DefaultClarkTransport();
+    }
+    get provider() {
+        return this.config.provider;
+    }
+    supportsUrl(url) {
+        return url.protocol === "https:";
+    }
+    /**
+     * Start the debug hooks for one stream, copying this call's IDs in so every
+     * log line from the stream can be tied back to this run.
+     *
+     * Everything is wrapped so a sink that throws can't break streaming. (`?.`
+     * alone only guards a missing sink, not one that throws.)
+     */
+    openTelemetryScope(attributes, headers, fallbackHeaders) {
+        const telemetry = this.config.telemetry;
+        if (!telemetry) {
+            return undefined;
+        }
+        try {
+            const scope = telemetry.forStream({
+                provider: this.config.provider,
+                clarkModel: this.modelId,
+                coreModel: attributes?.model,
+                sessionId: attributes?.session_id,
+                promptId: attributes?.prompt_id,
+                applicationId: attributes?.application_id,
+                chatMessageId: attributes?.chatmessage_id,
+                streamId: headerValue(headers, "x-superblocks-stream-id") ??
+                    headerValue(fallbackHeaders, "x-superblocks-stream-id"),
+                streamAttempt: headerValue(headers, "x-superblocks-stream-attempt") ??
+                    headerValue(fallbackHeaders, "x-superblocks-stream-attempt"),
+            });
+            return scope ? guardTelemetryScope(scope) : undefined;
+        }
+        catch {
+            return undefined;
+        }
+    }
+    async doGenerate(options) {
+        const { args, warnings } = await this.requestBuilder.build(options, this.modelId);
+        const optionsWithMetadata = options;
+        const { value } = await this.transport.postJson({
+            url: `${this.config.baseURL}/generate`,
+            headers: combineHeaders(this.config.headers(), options.headers),
+            body: {
+                ...args,
+                attributes: optionsWithMetadata.attributes,
+            },
+            failedResponseHandler: clarkFailedResponseHandler,
+            successfulResponseHandler: clarkJsonResponseHandler,
+            abortSignal: options.abortSignal,
+            fetch: this.config.fetch,
+        });
+        const content = [];
+        if (value.text != null && value.text !== "") {
+            content.push({ type: "text", text: value.text });
+        }
+        else if (value.object != null) {
+            content.push({ type: "text", text: JSON.stringify(value.object) });
+        }
+        if (Array.isArray(value.files)) {
+            for (const file of value.files) {
+                content.push({
+                    type: "file",
+                    mediaType: file.mimeType ?? "application/octet-stream",
+                    data: file.base64,
+                });
+            }
+        }
+        if (Array.isArray(value.toolCalls)) {
+            for (const toolCall of value.toolCalls) {
+                content.push({
+                    type: "tool-call",
+                    toolCallId: toolCall.toolCallId,
+                    toolName: toolCall.toolName,
+                    input: serializeToolInput(toolCall.args),
+                });
+            }
+        }
+        if (Array.isArray(value.sources)) {
+            for (const source of value.sources) {
+                const sourceRecord = asRecord(source);
+                if (sourceRecord == null) {
+                    continue;
+                }
+                content.push({
+                    ...sourceRecord,
+                    type: "source",
+                });
+            }
+        }
+        // Strip undefined values to satisfy provider metadata JSON shape.
+        const sanitizedProviderMetadata = value.providerMetadata
+            ? JSON.parse(JSON.stringify(value.providerMetadata))
+            : undefined;
+        return {
+            content,
+            finishReason: toFinishReason(value.finishReason),
+            usage: toUsage(value.usage),
+            providerMetadata: sanitizedProviderMetadata,
+            response: {
+                headers: value.response?.headers,
+            },
+            request: {
+                body: JSON.stringify(args),
+            },
+            warnings: mergeWarnings(warnings, value.warnings),
+        };
+    }
+    async doStream(options) {
+        const { args, warnings } = await this.requestBuilder.build(options, this.modelId);
+        const optionsWithMetadata = options;
+        const headers = combineHeaders(this.config.headers(), options.headers);
+        const telemetryScope = this.openTelemetryScope(optionsWithMetadata.attributes, options.headers, headers);
+        const body = {
+            ...args,
+            stream: true,
+            attributes: optionsWithMetadata.attributes,
+        };
+        let responseHeaders;
+        let response;
+        try {
+            ({ responseHeaders, value: response } = await this.transport.postJson({
+                url: `${this.config.baseURL}/stream`,
+                headers,
+                body,
+                failedResponseHandler: clarkFailedResponseHandler,
+                successfulResponseHandler: makeClarkStreamResponseHandler(telemetryScope),
+                abortSignal: options.abortSignal,
+                fetch: this.config.fetch,
+            }));
+        }
+        catch (error) {
+            telemetryScope?.requestFailed?.(requestFailure(error, options.abortSignal?.aborted === true));
+            throw error;
+        }
+        let finishReason;
+        let providerMetadata;
+        let usage = toUsage();
+        let streamStartEnqueued = false;
+        return {
+            stream: reportStreamReadFailures(response, telemetryScope, options.abortSignal).pipeThrough(new TransformStream({
+                transform(chunk, controller) {
+                    if (chunk.success) {
+                        const value = chunk.value;
+                        if (!streamStartEnqueued &&
+                            value.type !== "stream-start" &&
+                            warnings.length > 0) {
+                            controller.enqueue({
+                                type: "stream-start",
+                                warnings,
+                            });
+                            streamStartEnqueued = true;
+                        }
+                        switch (value.type) {
+                            case "stream-start": {
+                                if (streamStartEnqueued) {
+                                    // Only one stream-start is allowed downstream and we already
+                                    // sent it. Later ones still count as activity, so pass them
+                                    // through.
+                                    forwardAsActivity(controller, value);
+                                    break;
+                                }
+                                const mergedWarnings = mergeWarnings(warnings, asWarnings(value.warnings));
+                                if (mergedWarnings.length > 0) {
+                                    controller.enqueue({
+                                        type: "stream-start",
+                                        warnings: mergedWarnings,
+                                    });
+                                    streamStartEnqueued = true;
+                                }
+                                else {
+                                    // Keep streamStartEnqueued=false so a later stream-start
+                                    // that carries warnings can still surface that metadata.
+                                    forwardAsActivity(controller, value);
+                                }
+                                break;
+                            }
+                            case "start":
+                            case "start-step": {
+                                // AI SDK v5 stream framing: `start` marks the stream begin
+                                // and `start-step` each step begin. They carry no content,
+                                // so there is nothing to map — forward as raw activity to
+                                // keep the client stall timer happy. Handled explicitly (not
+                                // via `default`) so they are NOT logged as
+                                // `clark_sse.unknown_chunk`: they are expected framing, not a
+                                // type we silently dropped and need to investigate.
+                                forwardAsActivity(controller, value);
+                                break;
+                            }
+                            case "text-start": {
+                                const id = asString(value.id);
+                                if (id == null) {
+                                    forwardAsActivity(controller, value);
+                                    break;
+                                }
+                                const providerMetadata = asProviderMetadata(value.providerMetadata);
+                                controller.enqueue({
+                                    type: "text-start",
+                                    id,
+                                    ...(providerMetadata && { providerMetadata }),
+                                });
+                                break;
+                            }
+                            case "text-delta": {
+                                const id = asString(value.id);
+                                const delta = asString(value.text);
+                                if (id == null || delta == null) {
+                                    forwardAsActivity(controller, value);
+                                    break;
+                                }
+                                controller.enqueue({
+                                    type: "text-delta",
+                                    id,
+                                    delta,
+                                });
+                                break;
+                            }
+                            case "reasoning-start": {
+                                const id = asString(value.id);
+                                if (id == null) {
+                                    forwardAsActivity(controller, value);
+                                    break;
+                                }
+                                controller.enqueue({
+                                    type: "reasoning-start",
+                                    id,
+                                    providerMetadata: asProviderMetadata(value.providerMetadata),
+                                });
+                                break;
+                            }
+                            case "reasoning-delta": {
+                                const id = asString(value.id);
+                                if (id == null) {
+                                    forwardAsActivity(controller, value);
+                                    break;
+                                }
+                                controller.enqueue({
+                                    type: "reasoning-delta",
+                                    id,
+                                    delta: asString(value.text) ?? "",
+                                    providerMetadata: asProviderMetadata(value.providerMetadata),
+                                });
+                                break;
+                            }
+                            case "reasoning-end": {
+                                const id = asString(value.id);
+                                if (id == null) {
+                                    forwardAsActivity(controller, value);
+                                    break;
+                                }
+                                controller.enqueue({
+                                    type: "reasoning-end",
+                                    id,
+                                    providerMetadata: asProviderMetadata(value.providerMetadata),
+                                });
+                                break;
+                            }
+                            case "tool-input-start": {
+                                const id = asString(value.toolCallId) ?? asString(value.id);
+                                const toolName = asString(value.toolName);
+                                if (id == null || toolName == null) {
+                                    forwardAsActivity(controller, value);
+                                    break;
+                                }
+                                controller.enqueue({
+                                    type: "tool-input-start",
+                                    id,
+                                    toolName,
+                                });
+                                break;
+                            }
+                            case "tool-input-delta": {
+                                const id = asString(value.toolCallId) ?? asString(value.id);
+                                const delta = asString(value.delta);
+                                if (id == null || delta == null) {
+                                    forwardAsActivity(controller, value);
+                                    break;
+                                }
+                                controller.enqueue({
+                                    type: "tool-input-delta",
+                                    id,
+                                    delta: unwrapToolInputDelta(delta),
+                                });
+                                break;
+                            }
+                            case "tool-input-end": {
+                                const id = asString(value.toolCallId) ?? asString(value.id);
+                                if (id == null) {
+                                    forwardAsActivity(controller, value);
+                                    break;
+                                }
+                                controller.enqueue({
+                                    type: "tool-input-end",
+                                    id,
+                                });
+                                break;
+                            }
+                            case "tool-call": {
+                                const toolCallId = asString(value.toolCallId);
+                                const toolName = asString(value.toolName);
+                                if (toolCallId == null || toolName == null) {
+                                    forwardAsActivity(controller, value);
+                                    break;
+                                }
+                                controller.enqueue({
+                                    type: "tool-call",
+                                    toolCallId,
+                                    toolName,
+                                    input: serializeToolInput(value.input),
+                                });
+                                break;
+                            }
+                            case "file": {
+                                const data = asString(value.base64);
+                                if (data == null) {
+                                    forwardAsActivity(controller, value);
+                                    break;
+                                }
+                                controller.enqueue({
+                                    type: "file",
+                                    mediaType: asString(value.mimeType) ?? "application/octet-stream",
+                                    data,
+                                });
+                                break;
+                            }
+                            case "source": {
+                                const source = asRecord(value.source);
+                                if (source == null) {
+                                    forwardAsActivity(controller, value);
+                                    break;
+                                }
+                                controller.enqueue({
+                                    type: "source",
+                                    ...source,
+                                });
+                                break;
+                            }
+                            case "text-end": {
+                                const id = asString(value.id);
+                                if (id == null) {
+                                    forwardAsActivity(controller, value);
+                                    break;
+                                }
+                                controller.enqueue({
+                                    type: "text-end",
+                                    id,
+                                });
+                                break;
+                            }
+                            // Finish reason and usage are replaced each time, not added up.
+                            // The final "finish" total wins. Compaction provider metadata
+                            // can arrive on "finish-step" first, so retain the latest
+                            // non-empty value for the synthesized finish event.
+                            case "finish":
+                            case "finish-step": {
+                                finishReason = asString(value.finishReason);
+                                const usageData = asUsage(value.usage ?? value.totalUsage);
+                                usage = toUsage(usageData);
+                                const nextProviderMetadata = asProviderMetadata(value.providerMetadata);
+                                if (nextProviderMetadata != null &&
+                                    Object.keys(nextProviderMetadata).length > 0) {
+                                    providerMetadata = nextProviderMetadata;
+                                }
+                                if (value.type === "finish-step") {
+                                    forwardAsActivity(controller, value);
+                                }
+                                break;
+                            }
+                            case "error": {
+                                // Record that an error message came through, and whether it
+                                // actually carried an error payload, so a malformed error can
+                                // be told apart from a normal one.
+                                telemetryScope?.errorChunk({ hasError: value.error != null });
+                                controller.enqueue({
+                                    type: "error",
+                                    error: value.error,
+                                });
+                                break;
+                            }
+                            case "raw": {
+                                // Keep-alive "still here" pings, sent while the model is
+                                // thinking and producing nothing. These are the AI proxy's own
+                                // 30s heartbeat (the proxy relay no longer asks the provider
+                                // SDK for raw chunks, so provider pings do not reach here).
+                                // They carry no content; forwarding them stops the client's
+                                // stall timer from firing by mistake. Recording rawParsed
+                                // proves these reached this step: if the server sent pings but
+                                // none show up here, the data was lost between the server and
+                                // Clark.
+                                telemetryScope?.rawParsed();
+                                controller.enqueue({
+                                    type: "raw",
+                                    rawValue: value.rawValue ?? value,
+                                });
+                                break;
+                            }
+                            case "object": {
+                                const id = asString(value.id);
+                                if (id == null) {
+                                    forwardAsActivity(controller, value);
+                                    break;
+                                }
+                                controller.enqueue({
+                                    type: "text-delta",
+                                    id,
+                                    delta: JSON.stringify(value.object),
+                                });
+                                break;
+                            }
+                            case "tool-result": {
+                                // this might not work properly if we have server side tool results, we'll probably need to filter out specifically ones that are expected to run client side
+                                // right now we keep the empty server result out of content, but still surface it as activity.
+                                forwardAsActivity(controller, value);
+                                break;
+                            }
+                            default: {
+                                // A message type we don't handle: pass it through as raw so
+                                // the client's stall timer stays happy, and log it so a type
+                                // we silently dropped is still visible.
+                                telemetryScope?.unknownChunk(value.type);
+                                forwardAsActivity(controller, value);
+                                break;
+                            }
+                        }
+                    }
+                    else {
+                        controller.enqueue({ type: "error", error: chunk.error });
+                    }
+                },
+                flush(controller) {
+                    if (!streamStartEnqueued && warnings.length > 0) {
+                        controller.enqueue({
+                            type: "stream-start",
+                            warnings,
+                        });
+                    }
+                    controller.enqueue({
+                        type: "finish",
+                        finishReason: toFinishReason(finishReason),
+                        usage,
+                        ...(providerMetadata && { providerMetadata }),
+                    });
+                },
+            })),
+            response: { headers: responseHeaders },
+            request: { body: JSON.stringify(body) },
+        };
+    }
+}
+const clarkJsonResponseHandler = async ({ response }) => {
+    const responseHeaders = extractResponseHeaders(response);
+    const body = (await response.json());
+    return {
+        responseHeaders,
+        value: body,
+        rawValue: body,
+    };
+};
+function makeClarkStreamResponseHandler(telemetryScope) {
+    return async ({ response }) => {
+        const responseHeaders = extractResponseHeaders(response);
+        if (response.body == null) {
+            throw new EmptyResponseBodyError({});
+        }
+        return {
+            responseHeaders,
+            value: response.body
+                .pipeThrough(new TextDecoderStream())
+                .pipeThrough(new EventSourceParserStream())
+                .pipeThrough(new TransformStream({
+                async transform({ data }, controller) {
+                    try {
+                        const json = JSON.parse(data);
+                        controller.enqueue({
+                            success: true,
+                            value: json,
+                            rawValue: json,
+                        });
+                    }
+                    catch (error) {
+                        // A streamed line we couldn't parse as JSON. Log the failure
+                        // (length only, never the data itself) so a parse problem here
+                        // is visible instead of quietly turning into an error later.
+                        telemetryScope?.parseError(data.length);
+                        controller.enqueue({
+                            success: false,
+                            error: JSONParseError.isInstance(error)
+                                ? error
+                                : new JSONParseError({
+                                    text: data,
+                                    cause: error,
+                                }),
+                            rawValue: data,
+                        });
+                    }
+                },
+            })),
+        };
+    };
+}
+//# sourceMappingURL=clark-language-model.js.map