@compose-market/core 0.1.0 → 0.1.2

package/dist/stream/index.js

@@ -0,0 +1,1257 @@
+const EOL = /\r\n|\r|\n/;
+function lines(buffer) {
+    const parts = buffer.split(EOL);
+    const rest = parts.pop() ?? "";
+    return { lines: parts, rest };
+}
+export async function* parseSSEStream(stream, options = {}) {
+    const reader = stream.getReader();
+    const decoder = new TextDecoder("utf-8");
+    let buffer = "";
+    let event = "message";
+    let data = [];
+    let id;
+    const abort = () => {
+        try {
+            reader.cancel();
+        }
+        catch { /* best effort */ }
+    };
+    options.signal?.addEventListener("abort", abort);
+    try {
+        while (true) {
+            const { value, done } = await reader.read();
+            if (done)
+                break;
+            buffer += decoder.decode(value, { stream: true });
+            const split = lines(buffer);
+            buffer = split.rest;
+            for (const line of split.lines) {
+                if (line === "") {
+                    if (data.length > 0) {
+                        yield { event, data: data.join("\n"), ...(id ? { id } : {}) };
+                    }
+                    event = "message";
+                    data = [];
+                    id = undefined;
+                    continue;
+                }
+                if (line.startsWith(":"))
+                    continue;
+                const colon = line.indexOf(":");
+                const field = colon === -1 ? line : line.slice(0, colon);
+                let value = colon === -1 ? "" : line.slice(colon + 1);
+                if (value.startsWith(" "))
+                    value = value.slice(1);
+                if (field === "event")
+                    event = value || "message";
+                else if (field === "data")
+                    data.push(value);
+                else if (field === "id")
+                    id = value;
+            }
+        }
+        buffer += decoder.decode();
+        if (buffer.length > 0) {
+            const split = lines(`${buffer}\n`);
+            for (const line of split.lines) {
+                if (line === "")
+                    break;
+                if (line.startsWith(":"))
+                    continue;
+                const colon = line.indexOf(":");
+                const field = colon === -1 ? line : line.slice(0, colon);
+                let value = colon === -1 ? "" : line.slice(colon + 1);
+                if (value.startsWith(" "))
+                    value = value.slice(1);
+                if (field === "event")
+                    event = value || "message";
+                else if (field === "data")
+                    data.push(value);
+                else if (field === "id")
+                    id = value;
+            }
+        }
+        if (data.length > 0) {
+            yield { event, data: data.join("\n"), ...(id ? { id } : {}) };
+        }
+    }
+    finally {
+        options.signal?.removeEventListener("abort", abort);
+        try {
+            reader.releaseLock();
+        }
+        catch { /* best effort */ }
+    }
+}
+export function encode(event) {
+    return `data: ${JSON.stringify(event)}\n\n`;
+}
+export function createStreamTree() {
+    return {
+        roots: [],
+        nodes: {},
+        seen: {},
+        text: "",
+        reasoning: "",
+        artifacts: [],
+        receipts: [],
+        errors: [],
+    };
+}
+export function reduce(tree, event) {
+    const next = {
+        roots: tree.roots.slice(),
+        nodes: { ...tree.nodes },
+        seen: { ...tree.seen },
+        text: tree.text,
+        reasoning: tree.reasoning,
+        artifacts: tree.artifacts.slice(),
+        receipts: tree.receipts.slice(),
+        errors: tree.errors.slice(),
+    };
+    if (!event.delta) {
+        const serial = stable(event);
+        if (next.seen[event.id] !== undefined && next.seen[event.id] === serial) {
+            return next;
+        }
+        next.seen[event.id] = serial;
+    }
+    const current = next.nodes[event.id];
+    const previousParentId = current?.parentId;
+    const node = {
+        id: event.id,
+        kind: event.kind,
+        source: event.source,
+        ...(event.parentId ? { parentId: event.parentId } : current?.parentId ? { parentId: current.parentId } : {}),
+        ...(event.rootId ? { rootId: event.rootId } : current?.rootId ? { rootId: current.rootId } : {}),
+        ...(event.runId ? { runId: event.runId } : current?.runId ? { runId: current.runId } : {}),
+        status: event.status ?? current?.status ?? "running",
+        path: event.path ?? current?.path ?? [],
+        display: { ...(current?.display ?? {}), ...(event.display ?? {}) },
+        payload: merge(current?.payload, event.payload),
+        ...(event.raw !== undefined ? { raw: event.raw } : current?.raw !== undefined ? { raw: current.raw } : {}),
+        text: current?.text ?? "",
+        children: current?.children.slice() ?? [],
+        updatedAt: event.ts ?? Date.now(),
+        events: (current?.events ?? 0) + 1,
+    };
+    if (event.delta) {
+        node.text += event.delta;
+        if (event.kind === "text")
+            next.text += event.delta;
+        if (event.kind === "reasoning")
+            next.reasoning += event.delta;
+    }
+    next.nodes[event.id] = node;
+    if (previousParentId && previousParentId !== node.parentId) {
+        const previousParent = next.nodes[previousParentId];
+        if (previousParent) {
+            next.nodes[previousParentId] = {
+                ...previousParent,
+                children: previousParent.children.filter((idValue) => idValue !== node.id),
+            };
+        }
+    }
+    if (node.parentId) {
+        const parent = next.nodes[node.parentId] ?? placeholder(node.parentId, event);
+        if (!parent.children.includes(node.id))
+            parent.children.push(node.id);
+        next.nodes[parent.id] = parent;
+        next.roots = next.roots.filter((idValue) => idValue !== node.id);
+        if (!parent.parentId && !next.roots.includes(parent.id)) {
+            next.roots.push(parent.id);
+        }
+    }
+    else if (!next.roots.includes(node.id)) {
+        next.roots.push(node.id);
+    }
+    if (event.kind === "artifact" && !next.artifacts.some((item) => item.id === event.id)) {
+        next.artifacts.push(event);
+    }
+    if ((event.kind === "receipt" || event.kind === "payment") && !next.receipts.some((item) => item.id === event.id)) {
+        next.receipts.push(event);
+    }
+    if (event.kind === "error" && !next.errors.some((item) => item.id === event.id)) {
+        next.errors.push(event);
+    }
+    return next;
+}
+export function decode(input, options = {}) {
+    const raw = framePayload(input);
+    if (raw === "[DONE]") {
+        const source = options.source ?? "stream";
+        const targetId = terminalId(options, source);
+        return event({
+            id: targetId,
+            kind: terminalKind(targetId),
+            source,
+            status: "completed",
+            display: { summary: "Done" },
+            raw,
+        }, options);
+    }
+    if (!raw)
+        return null;
+    if (isRecord(raw) && raw.type === "stream") {
+        const decoded = raw;
+        if (!decoded.id || !decoded.kind || !decoded.source)
+            return null;
+        return decoded;
+    }
+    if (typeof raw === "string") {
+        return event({
+            id: id("text", options.runId),
+            kind: "text",
+            source: options.source ?? "stream",
+            status: "running",
+            delta: raw,
+            raw,
+        }, options);
+    }
+    if (!isRecord(raw))
+        return null;
+    return decodeRecord(raw, options);
+}
+function decodeRecord(raw, options) {
+    const type = string(raw.type) ?? string(raw.eventName) ?? string(raw.event) ?? "";
+    const runId = string(raw.composeRunId) ?? string(raw.runId) ?? options.runId;
+    const rootId = string(raw.rootComposeRunId) ?? options.rootId ?? runId;
+    const source = options.source ?? sourceOf(type, raw);
+    const base = { ...options, runId, rootId, source };
+    if (type === "text-delta") {
+        const delta = string(raw.delta) ?? string(raw.text) ?? string(raw.content) ?? "";
+        return delta ? event({
+            id: id("text", runId),
+            kind: "text",
+            source,
+            status: "running",
+            delta,
+            display: { title: "Response" },
+            raw,
+        }, base) : null;
+    }
+    if (type === "reasoning-delta" || type === "reasoning_delta" || type === "thinking" || type === "thinking-delta" || type === "thinking_delta") {
+        const delta = string(raw.delta) ?? string(raw.text) ?? string(raw.thinking) ?? string(raw.content) ?? "";
+        return delta ? event({
+            id: id("reasoning", runId),
+            kind: "reasoning",
+            source,
+            status: "running",
+            delta,
+            display: { title: "Reasoning" },
+            raw,
+        }, base) : null;
+    }
+    if (type === "warning" || type === "response.warning") {
+        const warning = isRecord(raw.warning) ? raw.warning : raw;
+        return event({
+            id: id("warning", string(warning.code), string(warning.message), runId),
+            kind: "debug",
+            source,
+            status: "info",
+            display: { title: "Warning", summary: string(warning.message) ?? string(raw.message) },
+            payload: { warning },
+            raw,
+        }, base);
+    }
+    if (type === "citation" || type === "response.citation") {
+        const citation = isRecord(raw.citation) ? raw.citation : raw;
+        return event({
+            id: id("citation", string(citation.url), string(citation.title), string(citation.marker), runId),
+            kind: "catalog",
+            source,
+            parentId: modelParent(base, string(raw.response_id)),
+            status: "completed",
+            display: {
+                title: string(citation.title) ?? "Citation",
+                summary: string(citation.snippet),
+                target: string(citation.url) ?? string(citation.marker),
+            },
+            payload: { citation },
+            raw,
+        }, base);
+    }
+    if (type === "thinking-start" || type === "thinking_start" || type === "thinking-end" || type === "thinking_end") {
+        return event({
+            id: id("debug", type, runId),
+            kind: "debug",
+            source,
+            status: type.endsWith("end") ? "completed" : "running",
+            display: { title: "Runtime status", summary: string(raw.message) ?? type },
+            payload: raw,
+            raw,
+        }, base);
+    }
+    if (type === "stopped") {
+        return event({
+            id: id("stopped", runId),
+            kind: "run",
+            source,
+            status: "cancelled",
+            display: { title: "Stopped", summary: string(raw.reason) },
+            payload: raw,
+            raw,
+        }, base);
+    }
+    if (type === "tool-args-delta") {
+        return event({
+            id: id("tool", string(raw.id) ?? string(raw.toolName), runId),
+            kind: "tool",
+            source,
+            status: "running",
+            display: { title: string(raw.toolName) ?? "Tool" },
+            payload: { arguments: string(raw.argsDelta) },
+            raw,
+        }, base);
+    }
+    if (type === "tool-start")
+        raw.type = "tool_start";
+    if (type === "tool-end")
+        raw.type = "tool_end";
+    if (Array.isArray(raw.choices)) {
+        const choice = raw.choices[0];
+        const delta = isRecord(choice) && isRecord(choice.delta) ? choice.delta : null;
+        const reasoning = string(delta?.reasoning_content);
+        if (reasoning) {
+            return event({
+                id: id("reasoning", runId),
+                kind: "reasoning",
+                source,
+                parentId: modelParent(base, string(raw.id)),
+                status: "running",
+                delta: reasoning,
+                display: { title: "Reasoning" },
+                raw,
+            }, base);
+        }
+        const text = string(delta?.content);
+        if (text) {
+            return event({
+                id: id("text", runId),
+                kind: "text",
+                source,
+                parentId: modelParent(base, string(raw.id)),
+                status: "running",
+                delta: text,
+                display: { title: "Response" },
+                raw,
+            }, base);
+        }
+        if (raw.usage) {
+            return event({
+                id: id("model", string(raw.id) ?? runId),
+                kind: "model",
+                source,
+                status: "completed",
+                display: { title: string(raw.model) ?? "Model", summary: "Usage", target: string(raw.id) },
+                payload: { usage: raw.usage },
+                raw,
+            }, base);
+        }
+        const finish = isRecord(choice) ? string(choice.finish_reason) : undefined;
+        if (finish) {
+            return event({
+                id: id("model", string(raw.id) ?? runId),
+                kind: "model",
+                source,
+                status: "completed",
+                display: { title: string(raw.model) ?? "Model", summary: finish, target: string(raw.id) },
+                payload: { finishReason: finish, usage: raw.usage },
+                raw,
+            }, base);
+        }
+        return null;
+    }
+    if (Array.isArray(raw.candidates)) {
+        const candidate = isRecord(raw.candidates[0]) ? raw.candidates[0] : null;
+        const content = isRecord(candidate?.content) ? candidate.content : {};
+        const parts = Array.isArray(content.parts) ? content.parts : [];
+        const part = parts.find(isRecord);
+        if (part) {
+            const text = string(part.text);
+            if (text) {
+                const reasoning = part.thought === true;
+                return event({
+                    id: id(reasoning ? "reasoning" : "text", runId),
+                    kind: reasoning ? "reasoning" : "text",
+                    source,
+                    parentId: modelParent(base, string(raw.response_id)),
+                    status: "running",
+                    delta: text,
+                    display: { title: reasoning ? "Reasoning" : "Response" },
+                    raw,
+                }, base);
+            }
+            const inline = isRecord(part.inlineData) ? part.inlineData : isRecord(part.inline_data) ? part.inline_data : null;
+            const data = string(inline?.data);
+            if (data) {
+                return event({
+                    id: id("artifact", string(raw.response_id) ?? runId, number(raw.index), data),
+                    kind: "artifact",
+                    source,
+                    parentId: modelParent(base, string(raw.response_id)),
+                    status: "running",
+                    display: { title: "Media", target: string(raw.model) },
+                    payload: {
+                        artifactType: mediaKind(string(inline?.mimeType) ?? string(inline?.mime_type)),
+                        responseId: string(raw.response_id),
+                        mimeType: string(inline?.mimeType) ?? string(inline?.mime_type),
+                        inline: true,
+                        base64: data,
+                    },
+                    raw,
+                }, base);
+            }
+            const call = isRecord(part.functionCall) ? part.functionCall : isRecord(part.function_call) ? part.function_call : null;
+            if (call) {
+                return event({
+                    id: id("tool", string(call.id) ?? string(call.name), runId),
+                    kind: "tool",
+                    source,
+                    parentId: modelParent(base, string(raw.response_id)),
+                    status: "completed",
+                    display: { title: string(call.name) ?? "Tool" },
+                    payload: {
+                        name: string(call.name),
+                        arguments: JSON.stringify(call.args ?? {}),
+                    },
+                    raw,
+                }, base);
+            }
+        }
+        if (raw.usageMetadata) {
+            return event({
+                id: id("model", string(raw.response_id) ?? runId),
+                kind: "model",
+                source,
+                parentId: modelParent(base, string(raw.response_id)),
+                status: "info",
+                display: { title: string(raw.model) ?? "Model", summary: "Usage" },
+                payload: { usage: raw.usageMetadata },
+                raw,
+            }, base);
+        }
+    }
+    if (type === "response.created") {
+        const response = isRecord(raw.response) ? raw.response : {};
+        const responseId = string(response.id) ?? string(raw.response_id) ?? runId;
+        return event({
+            id: id("model", responseId),
+            kind: "model",
+            source,
+            status: "running",
+            display: { title: string(response.model) ?? string(raw.model) ?? "Model", target: responseId },
+            payload: { response },
+            raw,
+        }, base);
+    }
+    if (type === "response.output_text.delta") {
+        const delta = string(raw.delta) ?? "";
+        return delta ? event({
+            id: id("text", string(raw.response_id) ?? runId),
+            kind: "text",
+            source,
+            parentId: modelParent(base, string(raw.response_id)),
+            status: "running",
+            delta,
+            display: { title: "Response", target: string(raw.model) },
+            raw,
+        }, base) : null;
+    }
+    if (type === "response.reasoning.delta" || type === "response.reasoning_text.delta" || type === "response.reasoning_summary_text.delta") {
+        const delta = string(raw.delta) ?? "";
+        return delta ? event({
+            id: id("reasoning", string(raw.response_id) ?? runId),
+            kind: "reasoning",
+            source,
+            parentId: modelParent(base, string(raw.response_id)),
+            status: "running",
+            delta,
+            display: { title: "Reasoning", target: string(raw.model) },
+            raw,
+        }, base) : null;
+    }
+    if (type === "content_block_start") {
+        const block = isRecord(raw.content_block) ? raw.content_block : {};
+        if (string(block.type) === "tool_use") {
+            return event({
+                id: id("tool", string(block.id), string(block.name), runId),
+                kind: "tool",
+                source,
+                parentId: modelParent(base, string(raw.message_id)),
+                status: "running",
+                display: { title: string(block.name) ?? "Tool" },
+                payload: { name: string(block.name), input: block.input, index: number(raw.index) },
+                raw,
+            }, base);
+        }
+    }
+    if (type === "message_delta") {
+        const delta = isRecord(raw.delta) ? raw.delta : {};
+        return event({
+            id: id("model", string(raw.message_id) ?? runId),
+            kind: "model",
+            source,
+            status: "info",
+            display: { title: string(raw.model) ?? "Model", summary: string(delta.stop_reason) },
+            payload: { usage: raw.usage, stopReason: string(delta.stop_reason) },
+            raw,
+        }, base);
+    }
+    if (type === "content_block_delta") {
+        const delta = isRecord(raw.delta) ? raw.delta : {};
+        const deltaType = string(delta.type);
+        const text = string(delta.text) ?? string(delta.thinking);
+        if (!text)
+            return null;
+        const reasoning = deltaType === "thinking_delta" || string(delta.thinking) !== undefined;
+        return event({
+            id: id(reasoning ? "reasoning" : "text", string(raw.message_id) ?? runId),
+            kind: reasoning ? "reasoning" : "text",
+            source,
+            parentId: modelParent(base, string(raw.message_id)),
+            status: "running",
+            delta: text,
+            display: { title: reasoning ? "Reasoning" : "Response" },
+            raw,
+        }, base);
+    }
+    if (type === "response.audio.delta" || type === "response.output_audio.delta") {
+        const delta = string(raw.delta) ?? "";
+        return event({
+            id: id("audio", string(raw.response_id) ?? runId),
+            kind: "artifact",
+            source,
+            parentId: modelParent(base, string(raw.response_id)),
+            status: "running",
+            display: { title: "Audio", target: string(raw.model) },
+            payload: {
+                artifactType: "audio",
+                responseId: string(raw.response_id),
+                mimeType: string(raw.mime_type),
+                inline: true,
+                base64: delta,
+            },
+            raw,
+        }, base);
+    }
+    if (type === "audio-chunk") {
+        const chunk = raw.chunk;
+        const base64 = typeof chunk === "string"
+            ? chunk
+            : isRecord(chunk) && typeof chunk.base64 === "string"
+                ? chunk.base64
+                : undefined;
+        return event({
+            id: id("audio", string(raw.response_id) ?? runId, number(raw.sequenceIndex)),
+            kind: "artifact",
+            source,
+            parentId: modelParent(base, string(raw.response_id)),
+            status: "running",
+            display: { title: "Audio", target: string(raw.model) },
+            payload: {
+                artifactType: "audio",
+                responseId: string(raw.response_id),
+                sequenceIndex: number(raw.sequenceIndex),
+                mimeType: string(raw.mime_type) ?? string(raw.mimeType),
+                inline: true,
+                base64,
+            },
+            raw,
+        }, base);
+    }
+    if (type === "subtitle" || type === "response.output_audio.subtitle") {
+        const subtitle = isRecord(raw.subtitle) ? raw.subtitle : raw;
+        return event({
+            id: id("subtitle", string(raw.response_id), number(subtitle.start), number(subtitle.end), runId),
+            kind: "artifact",
+            source,
+            parentId: modelParent(base, string(raw.response_id)),
+            status: "running",
+            display: { title: "Subtitle", summary: string(subtitle.text), target: string(raw.model) },
+            payload: {
+                artifactType: "text",
+                responseId: string(raw.response_id),
+                subtitle,
+            },
+            raw,
+        }, base);
+    }
+    if (type === "response.text.delta") {
+        const delta = string(raw.delta) ?? "";
+        return delta ? event({
+            id: id("text", string(raw.response_id) ?? runId),
+            kind: "text",
+            source,
+            parentId: modelParent(base, string(raw.response_id)),
+            status: "running",
+            delta,
+            display: { title: "Response", target: string(raw.model) },
+            raw,
+        }, base) : null;
+    }
+    if (type === "response.image_generation_call.partial_image" || type === "response.image_generation_call.completed") {
+        const complete = type.endsWith(".completed");
+        return event({
+            id: id("artifact", string(raw.response_id), number(raw.partial_image_index)),
+            kind: "artifact",
+            source,
+            parentId: modelParent(base, string(raw.response_id)),
+            status: complete ? "completed" : "running",
+            display: {
+                title: complete ? "Image complete" : "Image partial",
+                target: string(raw.model),
+                summary: string(raw.revised_prompt),
+            },
+            payload: {
+                artifactType: "image",
+                responseId: string(raw.response_id),
+                mimeType: string(raw.mime_type) ?? "image/png",
+                inline: true,
+                partial: !complete,
+                base64: string(raw.partial_image_b64) ?? string(raw.image_b64),
+                usage: raw.usage,
+            },
+            raw,
+        }, base);
+    }
+    if (type === "image-partial" || type === "image-complete") {
+        const image = isRecord(raw.image) ? raw.image : raw;
+        const complete = type === "image-complete";
+        return event({
+            id: id("artifact", string(raw.response_id) ?? runId, number(image.index), string(image.url), string(image.base64)),
+            kind: "artifact",
+            source,
+            parentId: modelParent(base, string(raw.response_id)),
+            status: complete ? "completed" : "running",
+            display: {
+                title: complete ? "Image complete" : "Image partial",
+                target: string(raw.model),
+                summary: string(image.revisedPrompt),
+            },
+            payload: {
+                artifactType: "image",
+                responseId: string(raw.response_id),
+                mimeType: string(image.mediaType) ?? string(image.mimeType) ?? "image/png",
+                url: string(image.url),
+                inline: string(image.base64) !== undefined,
+                partial: !complete,
+                base64: string(image.base64),
+                usage: raw.usage,
+            },
+            raw,
+        }, base);
+    }
+    if (type === "response.output_item.completed") {
+        const item = isRecord(raw.item) ? raw.item : {};
+        const itemType = string(item.type);
+        if (itemType === "output_text") {
+            const text = string(item.text) ?? "";
+            return text ? event({
+                id: id("text", string(raw.response_id) ?? runId),
+                kind: "text",
+                source,
+                parentId: modelParent(base, string(raw.response_id)),
+                status: "completed",
+                delta: text,
+                display: { title: "Response", target: string(raw.model) },
+                raw,
+            }, base) : null;
+        }
+        const asset = media(item);
+        if (asset) {
+            return event({
+                id: id("artifact", string(raw.response_id), number(raw.output_index), asset.url ?? asset.base64),
+                kind: "artifact",
+                source,
+                parentId: modelParent(base, string(raw.response_id)),
+                status: "completed",
+                display: {
+                    title: asset.kind,
+                    target: string(raw.model),
+                    summary: string(item.text) ?? string(item.status),
+                },
+                payload: {
+                    artifactType: asset.kind,
+                    responseId: string(raw.response_id),
+                    mimeType: string(item.mime_type),
+                    url: asset.url,
+                    inline: asset.base64 !== undefined,
+                    base64: asset.base64,
+                    status: string(item.status),
+                    jobId: string(item.job_id),
+                },
+                raw,
+            }, base);
+        }
+    }
+    if (type === "response.output_video.status" || type === "compose.video.status" || type === "status") {
+        return event({
+            id: id("video", string(raw.job_id) ?? string(raw.jobId) ?? string(raw.response_id)),
+            kind: "artifact",
+            source,
+            parentId: modelParent(base, string(raw.response_id)),
+            status: raw.status === "failed" ? "failed" : raw.status === "completed" ? "completed" : "running",
+            display: {
+                title: "Video",
+                target: string(raw.model),
+                summary: string(raw.status),
+            },
+            payload: {
+                artifactType: "video",
+                responseId: string(raw.response_id),
+                jobId: string(raw.job_id) ?? string(raw.jobId),
+                status: string(raw.status),
+                progress: number(raw.progress),
+                url: string(raw.url),
+                error: string(raw.error),
+            },
+            raw,
+        }, base);
+    }
+    if (type === "video-complete") {
+        const video = isRecord(raw.video) ? raw.video : raw;
+        return event({
+            id: id("video", string(video.jobId), string(video.url), string(raw.response_id), runId),
+            kind: "artifact",
+            source,
+            parentId: modelParent(base, string(raw.response_id)),
+            status: "completed",
+            display: { title: "Video", target: string(raw.model), summary: string(video.status) },
+            payload: {
+                artifactType: "video",
+                responseId: string(raw.response_id),
+                jobId: string(video.jobId),
+                status: string(video.status) ?? "completed",
+                progress: number(video.progress),
+                url: string(video.url),
+                mimeType: string(video.mediaType) ?? string(video.mimeType),
+                inline: string(video.base64) !== undefined,
+                base64: string(video.base64),
+            },
+            raw,
+        }, base);
+    }
+    if (type === "start" || type === "step" || type === "agent" || type === "progress" || type === "complete") {
+        const kind = type === "agent" ? "agent" : type === "progress" || type === "step" ? "action" : "run";
+        return event({
+            id: id(kind, string(raw.stepName) ?? string(raw.agentName) ?? type, runId),
+            kind,
+            source,
+            status: type === "complete" ? "completed" : "running",
+            display: {
+                title: string(raw.agentName) ?? string(raw.stepName) ?? type,
+                summary: string(raw.message),
+            },
+            payload: raw,
+            raw,
+        }, base);
+    }
+    if (type === "result") {
+        const output = raw.output;
+        const outputRecord = isRecord(output) ? output : {};
+        const mediaOutput = media(outputRecord);
+        if (mediaOutput) {
+            return event({
+                id: id("artifact", mediaOutput.url ?? mediaOutput.base64, runId),
+                kind: "artifact",
+                source,
+                status: "completed",
+                display: { title: mediaOutput.kind, summary: string(outputRecord.status) },
+                payload: {
+                    artifactType: mediaOutput.kind,
+                    url: mediaOutput.url,
+                    inline: mediaOutput.base64 !== undefined,
+                    base64: mediaOutput.base64,
+                    mimeType: string(outputRecord.mimeType) ?? string(outputRecord.mime_type),
+                },
+                raw,
+            }, base);
+        }
+        const text = string(output) ?? (isRecord(output) ? JSON.stringify(output) : undefined);
+        return text ? event({
+            id: id("text", runId),
+            kind: "text",
+            source,
+            status: "completed",
+            delta: text,
+            display: { title: "Result" },
+            payload: raw,
+            raw,
+        }, base) : null;
+    }
+    if (type === "tool-call-start" || type === "tool-call" || type === "tool-call-delta" || type === "response.tool_call" || type === "response.tool_call.delta" || type === "tool_args_delta") {
+        const call = isRecord(raw.tool_call) ? raw.tool_call : raw;
+        const delta = isRecord(raw.delta) ? raw.delta : raw;
+        return event({
+            id: id("tool", string(call.id) ?? string(delta.id) ?? string(call.name) ?? string(raw.toolName), runId),
+            kind: "tool",
+            source,
+            parentId: modelParent(base, string(raw.response_id)),
+            status: type.endsWith(".delta") || type === "tool_args_delta" || type === "tool-call-delta" || type === "tool-call-start" ? "running" : "completed",
+            display: { title: string(call.name) ?? string(delta.name) ?? string(raw.toolName) ?? "Tool" },
+            payload: {
+                name: string(call.name) ?? string(delta.name) ?? string(raw.toolName),
+                arguments: string(call.arguments) ?? string(delta.arguments) ?? string(raw.argumentsDelta) ?? string(raw.argsDelta),
+                index: number(raw.index),
+            },
+            raw,
+        }, base);
+    }
+    if (type === "tool_start" || type === "tool-start") {
+        const display = displayOf(raw);
+        return event({
+            id: id("tool", string(raw.toolName) ?? display.target, runId),
+            kind: displayKind(display, "tool"),
+            source,
+            parentId: agentParent(base),
+            status: "running",
+            display: { title: display.title ?? string(raw.toolName) ?? "Tool", summary: string(raw.content) ?? display.summary, target: display.target, kind: display.kind, metadata: display.metadata },
+            raw,
+        }, base);
+    }
+    if (type === "tool_end" || type === "tool-end") {
+        const display = displayOf(raw);
+        const failed = Boolean(raw.failed) || Boolean(string(raw.error));
+        return event({
+            id: id("tool", string(raw.toolName) ?? display.target, runId),
+            kind: displayKind(display, "tool"),
+            source,
+            parentId: agentParent(base),
+            status: failed ? "failed" : "completed",
+            display: { title: display.title ?? string(raw.toolName) ?? "Tool", summary: string(raw.message) ?? display.summary, target: display.target, kind: display.kind, metadata: display.metadata },
+            payload: { output: raw.output, error: string(raw.error) },
+            raw,
+        }, base);
+    }
+    if (type === "harness_plan_proposed" || type === "harness_plan_decided") {
+        const decided = type === "harness_plan_decided";
+        return event({
+            id: id("approval", string(raw.proposalId), string(raw.version)),
+            kind: "approval",
+            source,
+            parentId: agentParent(base),
+            status: decided ? "completed" : "pending",
+            display: {
+                title: decided ? "Plan decision" : "Plan review",
+                summary: string(raw.state),
+                target: string(raw.composeRunId),
+            },
+            payload: {
+                proposalId: string(raw.proposalId),
+                version: number(raw.version),
+                state: string(raw.state),
+                decision: string(raw.decision),
+                proposal: raw.proposal,
+                markdown: string(raw.markdown),
+                approver: string(raw.approver),
+                reason: string(raw.reason),
+                feedback: string(raw.feedback),
+            },
+            raw,
+        }, base);
+    }
+    if (type.startsWith("swarm_child_") || type === "child") {
+        return childEvent(raw, type, base);
+    }
+    if (type === "artifact") {
+        const runKey = string(raw.runKey);
+        const parentRunId = string(raw.parentRunId) ?? runId;
+        return event({
+            id: id("artifact", string(raw.responseId), string(raw.jobId), string(raw.runKey)),
+            kind: "artifact",
+            source,
+            parentId: runKey ? id("agent", runKey, parentRunId) : agentParent(base),
+            status: raw.status === "failed" ? "failed" : raw.status === "completed" ? "completed" : "running",
+            display: { title: string(raw.artifactType) ?? "Artifact", summary: string(raw.status) },
+            payload: raw,
+            raw,
+        }, base);
+    }
+    if (type === "trace") {
+        const display = displayOf(raw);
+        return event({
+            id: id("debug", string(raw.source), string(raw.stage), string(raw.action), display.target ?? display.summary ?? display.title),
+            kind: "debug",
+            source,
+            parentId: agentParent(base),
+            status: "info",
+            display,
+            payload: { stage: string(raw.stage), action: string(raw.action), message: string(raw.message), details: raw.details },
+            raw,
+        }, base);
+    }
+    if (type === "conclave") {
+        const key = string(raw.key);
+        return event({
+            id: id("conclave", string(raw.action), key, runId),
+            kind: "conclave",
+            source,
+            parentId: agentParent(base),
+            status: raw.success === false ? "failed" : "completed",
+            display: { title: "Conclave", summary: string(raw.action), target: key },
+            payload: raw,
+            raw,
+        }, base);
+    }
+    if (type === "compose.receipt") {
+        return receipt(raw, base);
+    }
+    if (type === "session-active" || type === "session-expired" || type === "session-lease") {
+        return event({
+            id: id("session", type, string(raw.userAddress), string(raw.chainId)),
+            kind: "session",
+            source,
+            status: type === "session-active" ? "running" : "info",
+            display: { title: "Session", summary: type },
+            payload: raw,
+            raw,
+        }, base);
+    }
+    if (type === "error" || type === "compose.error" || type === "response.error") {
+        const err = isRecord(raw.error) ? raw.error : raw;
+        return event({
+            id: id("error", string(err.code), string(err.message) ?? string(raw.message), runId),
+            kind: "error",
+            source,
+            status: "failed",
+            display: { title: "Error", summary: string(err.message) ?? string(raw.message) ?? string(raw.content) },
+            payload: { ...raw, error: err },
+            raw,
+        }, base);
+    }
+    if (type === "done" || type === "finish" || type === "message-stop" || type === "message_stop" || type === "response.completed") {
+        if (type === "response.completed") {
+            const responseId = string(raw.response_id) ?? runId;
+            return event({
+                id: id("model", responseId),
+                kind: "model",
+                source,
+                status: "completed",
+                display: { title: string(raw.model) ?? "Model", summary: string(raw.finish_reason), target: responseId },
+                payload: raw,
+                raw,
+            }, base);
+        }
+        const targetId = terminalId(base, source, string(raw.response_id));
+        return event({
+            id: targetId,
+            kind: terminalKind(targetId),
+            source,
+            status: "completed",
+            display: { summary: string(raw.finish_reason) ?? string(raw.finishReason) ?? "Done" },
+            payload: raw,
+            raw,
+        }, base);
+    }
+    const content = string(raw.content) ?? string(raw.text);
+    if (content) {
+        return event({
+            id: id("text", runId),
+            kind: "text",
+            source,
+            status: "running",
+            delta: content,
+            display: { title: "Response" },
+            raw,
+        }, base);
+    }
+    return null;
+}
+function childEvent(raw, type, options) {
+    const eventType = type === "child" ? string(raw.event) ?? "" : type.replace(/^swarm_child_/, "");
+    const runKey = string(raw.runKey);
+    const parentRunId = string(raw.parentRunId) ?? options.runId;
+    const agentId = id("agent", runKey ?? string(raw.agentWallet), parentRunId);
+    const parentRun = parentRunId ? id("agent", parentRunId) : options.parentId;
+    if (eventType === "start") {
+        return event({
+            id: agentId,
+            kind: "agent",
+            source: options.source ?? "agent",
+            parentId: parentRun,
+            status: "running",
+            path: array(raw.runKeyChain),
+            display: { title: string(raw.agentWallet) ?? "Agent", target: runKey },
+            payload: raw,
+            raw,
+        }, options);
+    }
+    if (eventType === "delta") {
+        const delta = string(raw.delta) ?? "";
+        return delta ? event({
+            id: id("text", runKey),
+            kind: "text",
+            source: options.source ?? "agent",
+            parentId: agentId,
+            status: "running",
+            path: array(raw.runKeyChain),
+            delta,
+            display: { title: "Agent response" },
+            raw,
+        }, options) : null;
+    }
+    if (eventType === "tool-start" || eventType === "tool_start") {
+        return event({
+            id: id("tool", runKey, string(raw.toolName)),
+            kind: "tool",
+            source: options.source ?? "agent",
+            parentId: agentId,
+            status: "running",
+            path: array(raw.runKeyChain),
+            display: { title: string(raw.toolName) ?? "Tool" },
+            payload: { input: raw.input },
+            raw,
+        }, options);
+    }
+    if (eventType === "tool-end" || eventType === "tool_end") {
+        return event({
+            id: id("tool", runKey, string(raw.toolName)),
+            kind: "tool",
+            source: options.source ?? "agent",
+            parentId: agentId,
+            status: raw.failed === true ? "failed" : "completed",
+            path: array(raw.runKeyChain),
+            display: { title: string(raw.toolName) ?? "Tool" },
+            payload: { output: raw.output, error: string(raw.error) },
+            raw,
+        }, options);
+    }
+    if (eventType === "done" || eventType === "error") {
+        return event({
+            id: agentId,
+            kind: "agent",
+            source: options.source ?? "agent",
+            parentId: parentRun,
+            status: eventType === "error" ? "failed" : "completed",
+            path: array(raw.runKeyChain),
+            display: { title: string(raw.agentWallet) ?? "Agent", summary: string(raw.stopReason) ?? string(raw.error), target: runKey },
+            payload: raw,
+            raw,
+        }, options);
+    }
+    return null;
+}
+function receipt(raw, options) {
+    return event({
+        id: id("receipt", string(raw.id), string(raw.runId), string(raw.txHash), string(raw.settleTxHash)),
+        kind: "receipt",
+        source: options.source ?? "payment",
+        status: "completed",
+        display: { title: "Receipt", summary: string(raw.settlementStatus), target: string(raw.txHash) ?? string(raw.settleTxHash) },
+        payload: raw,
+        raw,
+    }, options);
+}
+function event(input, options) {
+    return {
+        type: "stream",
+        ...input,
+        ...(input.rootId || options.rootId ? { rootId: input.rootId ?? options.rootId } : {}),
+        ...(input.runId || options.runId ? { runId: input.runId ?? options.runId } : {}),
+        ...(input.parentId || options.parentId ? { parentId: input.parentId ?? options.parentId } : {}),
+        ts: input.ts ?? Date.now(),
+    };
+}
+function framePayload(input) {
+    if (isRecord(input) && typeof input.data === "string" && typeof input.event === "string") {
+        if (input.data === "[DONE]")
+            return "[DONE]";
+        if (input.event !== "message") {
+            try {
+                const parsed = JSON.parse(input.data);
+                return isRecord(parsed) ? { ...parsed, type: input.event } : parsed;
+            }
+            catch {
+                return { type: input.event, message: input.data };
+            }
+        }
+        try {
+            return JSON.parse(input.data);
+        }
+        catch {
+            return input.data;
+        }
+    }
+    return input;
+}
+function displayOf(raw) {
+    const display = isRecord(raw.display) ? raw.display : {};
+    const kind = streamKind(string(display.kind));
+    const details = isRecord(display.details) ? display.details : isRecord(raw.details) ? raw.details : undefined;
+    const metadata = kind || details ? { ...(details ?? {}), ...(kind ? { kind } : {}) } : undefined;
+    return {
+        title: string(display.name) ?? string(raw.source) ?? string(raw.toolName),
+        label: string(display.label),
+        summary: string(display.summary) ?? string(raw.message),
+        target: string(display.target) ?? string(display.id),
+        ...(kind ? { kind } : {}),
+        ...(metadata ? { metadata } : {}),
+    };
+}
+function displayKind(display, fallback) {
+    const kind = display.kind ?? (display.metadata && typeof display.metadata.kind === "string" ? streamKind(display.metadata.kind) : undefined);
+    if (kind === "model" || kind === "connector" || kind === "agent" || kind === "harness" || kind === "conclave" || kind === "catalog")
+        return kind;
+    return fallback;
+}
+function streamKind(value) {
+    switch (value) {
+        case "run":
+        case "agent":
+        case "text":
+        case "reasoning":
+        case "action":
+        case "tool":
+        case "catalog":
+        case "model":
+        case "connector":
+        case "harness":
+        case "conclave":
+        case "approval":
+        case "artifact":
+        case "receipt":
+        case "payment":
+        case "session":
+        case "error":
+        case "debug":
+            return value;
+        case "search":
+            return "catalog";
+        default:
+            return undefined;
+    }
+}
+function agentParent(options) {
+    return options.runId ? id("agent", options.runId) : options.parentId;
+}
+function modelParent(options, responseId) {
+    const value = responseId ?? options.runId;
+    return value ? id("model", value) : options.parentId;
+}
+function terminalId(options, source, responseId) {
+    const value = responseId ?? options.runId;
+    if ((source === "inference" || responseId) && value)
+        return id("model", value);
+    if (value)
+        return id("agent", value);
+    return options.parentId ?? "done";
+}
+function terminalKind(idValue) {
+    if (idValue.startsWith("agent:"))
+        return "agent";
+    if (idValue.startsWith("model:"))
+        return "model";
+    return "run";
+}
+function sourceOf(type, raw) {
+    const source = string(raw.source);
+    if (source)
+        return source;
+    if (type.startsWith("response."))
+        return "inference";
+    if (type.startsWith("swarm_child_"))
+        return "agent";
+    if (type.startsWith("harness_"))
+        return "harness";
+    if (type.startsWith("session-"))
+        return "session";
+    return "stream";
+}
+function id(...parts) {
+    const clean = parts
+        .filter((part) => part !== undefined && part !== null && String(part).trim().length > 0)
+        .map((part) => String(part).trim().replace(/\s+/g, "_"));
+    return clean.length > 0 ? clean.join(":") : "stream";
+}
+function placeholder(idValue, eventValue) {
+    const kind = idValue.startsWith("agent:")
+        ? "agent"
+        : idValue.startsWith("model:")
+            ? "model"
+            : "run";
+    return {
+        id: idValue,
+        kind,
+        source: eventValue.source,
+        status: "running",
+        path: [],
+        display: { title: kind === "agent" ? "Agent" : kind === "model" ? "Model" : idValue, target: idValue },
+        text: "",
+        children: [],
+        updatedAt: eventValue.ts ?? Date.now(),
+        events: 0,
+    };
+}
+function stable(eventValue) {
+    let hash = 5381;
+    const text = JSON.stringify({
+        id: eventValue.id,
+        kind: eventValue.kind,
+        status: eventValue.status,
+        delta: eventValue.delta,
+        display: eventValue.display,
+        payload: eventValue.payload,
+    });
+    for (let i = 0; i < text.length; i += 1) {
+        hash = ((hash << 5) + hash) ^ text.charCodeAt(i);
+    }
+    return hash >>> 0;
+}
+function merge(a, b) {
+    if (!a && !b)
+        return undefined;
+    return { ...(a ?? {}), ...(b ?? {}) };
+}
+function isRecord(value) {
+    return value !== null && typeof value === "object" && !Array.isArray(value);
+}
+function string(value) {
+    return typeof value === "string" && value.length > 0 ? value : undefined;
+}
+function number(value) {
+    return typeof value === "number" && Number.isFinite(value) ? value : undefined;
+}
+function array(value) {
+    return Array.isArray(value) && value.every((item) => typeof item === "string") ? value : undefined;
+}
+function media(value) {
+    const type = string(value.type) ?? string(value.kind);
+    const normalized = type === "output_image" || type === "image"
+        ? "image"
+        : type === "output_audio" || type === "audio"
+            ? "audio"
+            : type === "output_video" || type === "video"
+                ? "video"
+                : type === "output_embedding" || type === "embedding"
+                    ? "embedding"
+                    : type === "file" || type === "artifact"
+                        ? "file"
+                        : undefined;
+    if (!normalized)
+        return null;
+    const url = string(value.url)
+        ?? string(value.image_url)
+        ?? string(value.imageUrl)
+        ?? string(value.audio_url)
+        ?? string(value.audioUrl)
+        ?? string(value.video_url)
+        ?? string(value.videoUrl);
+    const base64 = string(value.base64)
+        ?? string(value.b64_json)
+        ?? string(value.data);
+    return { kind: normalized, ...(url ? { url } : {}), ...(base64 ? { base64 } : {}) };
+}
+function mediaKind(mimeType) {
+    if (!mimeType)
+        return "file";
+    if (mimeType.startsWith("image/"))
+        return "image";
+    if (mimeType.startsWith("audio/"))
+        return "audio";
+    if (mimeType.startsWith("video/"))
+        return "video";
+    return "file";
+}
+//# sourceMappingURL=index.js.map