@polpo-ai/channels 0.15.63

package/dist/runtime.js

@@ -0,0 +1,806 @@
+import { MemoryStateAdapter } from "@chat-adapter/state-memory";
+import { Chat, } from "chat";
+import { createOfficialChannelAdapter } from "./providers.js";
+import { segmentChannelText } from "./response.js";
+const DEFAULT_CONCURRENCY = {
+    debounceMs: 1_000,
+    maxQueueSize: 20,
+    onQueueFull: "drop-oldest",
+    queueEntryTtlMs: 120_000,
+    strategy: "burst",
+};
+const DEFAULT_DEDUPE_TTL_MS = 10 * 60_000;
+export class ChannelRuntime {
+    entries = new Map();
+    pendingInstallations = new Map();
+    pendingTurns = new Map();
+    options;
+    constructor(options) {
+        if (!options.handleEvent && !options.handleTurn) {
+            throw new Error("ChannelRuntime requires handleEvent or handleTurn");
+        }
+        this.options = {
+            ...options,
+            idleTtlMs: options.idleTtlMs ?? 15 * 60_000,
+            maxInstances: options.maxInstances ?? 100,
+        };
+    }
+    async handleWebhook(installation, request, options) {
+        await this.emit({
+            installationId: installation.id,
+            name: "webhook.received",
+            provider: installation.provider,
+        });
+        const entry = await this.getOrCreate(installation);
+        entry.lastUsedAt = Date.now();
+        const webhook = entry.chat.webhooks[installation.provider];
+        if (!webhook) {
+            throw new Error(`Missing Chat SDK webhook for ${installation.provider}`);
+        }
+        return webhook(request, options);
+    }
+    async post(installation, threadId, result) {
+        const entry = await this.getOrCreate(installation);
+        entry.lastUsedAt = Date.now();
+        const thread = entry.chat.thread(threadId);
+        await this.deliver(installation, {
+            channelId: thread.channelId,
+            postable: thread,
+            threadId: thread.id,
+        }, typeof result === "string" ? { text: result } : result);
+    }
+    async invalidate(installationId) {
+        const matching = [...this.entries.values()].filter((entry) => entry.installation.id === installationId);
+        await Promise.all(matching.map((entry) => this.evict(entry)));
+    }
+    async shutdown() {
+        const entries = [...this.entries.values()];
+        await Promise.all(entries.map((entry) => this.evict(entry)));
+    }
+    get size() {
+        return this.entries.size;
+    }
+    async getOrCreate(installation) {
+        await this.prune();
+        const key = runtimeKey(installation, this.options.concurrency);
+        const cached = this.entries.get(key);
+        if (cached)
+            return cached;
+        const pending = this.pendingInstallations.get(installation.id);
+        if (pending) {
+            await pending;
+            return this.getOrCreate(installation);
+        }
+        const creating = this.createEntry(installation);
+        this.pendingInstallations.set(installation.id, creating);
+        try {
+            return await creating;
+        }
+        finally {
+            if (this.pendingInstallations.get(installation.id) === creating) {
+                this.pendingInstallations.delete(installation.id);
+            }
+        }
+    }
+    async createEntry(installation) {
+        const key = runtimeKey(installation, this.options.concurrency);
+        await this.invalidate(installation.id);
+        const adapter = (this.options.adapterFactory ?? createOfficialChannelAdapter)(installation);
+        const state = await (this.options.stateFactory?.(installation)
+            ?? Promise.resolve(new MemoryStateAdapter()));
+        const chat = new Chat({
+            adapters: { [installation.provider]: adapter },
+            concurrency: installation.concurrency
+                ?? this.options.concurrency
+                ?? DEFAULT_CONCURRENCY,
+            dedupeTtlMs: this.options.dedupeTtlMs,
+            fallbackStreamingPlaceholderText: this.options.fallbackStreamingPlaceholderText ?? null,
+            state,
+            streamingUpdateIntervalMs: this.options.streamingUpdateIntervalMs,
+            threadHistory: { maxMessages: 30, ttlMs: 24 * 60 * 60_000 },
+            userName: installation.userName ?? "polpo",
+        });
+        const handler = (thread, message, context) => this.handleMessage(installation, thread, message, context);
+        chat.onDirectMessage((thread, message, _channel, context) => this.handleMessage(installation, thread, message, context));
+        chat.onNewMention(handler);
+        chat.onNewMessage(/[\s\S]*/, handler);
+        chat.onSubscribedMessage(handler);
+        chat.onSlashCommand((event) => this.handleSlashCommand(installation, state, event));
+        if (this.options.handleEvent) {
+            chat.onAction((event) => this.handleAction(installation, state, event));
+            chat.onReaction((event) => this.handleReaction(installation, state, event));
+            chat.onModalSubmit((event) => this.handleModalSubmit(installation, state, event));
+            chat.onModalClose((event) => this.handleModalClose(installation, state, event));
+            chat.onOptionsLoad((event) => this.handleOptionsLoad(installation, event));
+        }
+        const entry = {
+            chat: chat,
+            installation,
+            key,
+            lastUsedAt: Date.now(),
+        };
+        this.entries.set(key, entry);
+        await this.emit({
+            installationId: installation.id,
+            name: "runtime.created",
+            provider: installation.provider,
+        });
+        return entry;
+    }
+    async handleMessage(installation, thread, message, context) {
+        await thread.subscribe();
+        const messages = await Promise.all([...(context?.skipped ?? []), message].map(mapMessage));
+        const messageIds = messages.map((item) => item.id);
+        const concurrency = installation.concurrency
+            ?? this.options.concurrency
+            ?? DEFAULT_CONCURRENCY;
+        const turn = {
+            channelId: thread.channelId,
+            coordination: {
+                grouped: messages.length > 1,
+                messageCount: messages.length,
+                messageIds,
+                primaryMessageId: message.id,
+                strategy: concurrency.strategy,
+            },
+            credentialRevision: installation.credentialRevision,
+            installationId: installation.id,
+            isDirectMessage: thread.isDM,
+            messages,
+            provider: installation.provider,
+            providerEventId: message.id,
+            threadId: thread.id,
+        };
+        await this.executeTurn(installation, {
+            channelId: thread.channelId,
+            postable: thread,
+            threadId: thread.id,
+        }, turn);
+    }
+    async handleSlashCommand(installation, state, event) {
+        const providerEventId = providerEventIdFor(event.raw, [
+            event.command,
+            event.text,
+            event.channel.id,
+            event.user.userId,
+        ]);
+        const accepted = await state.setIfNotExists(`polpo:slash-command:${installation.provider}:${installation.id}:${providerEventId}`, true, this.options.dedupeTtlMs ?? DEFAULT_DEDUPE_TTL_MS);
+        if (!accepted)
+            return;
+        if (this.options.handleEvent) {
+            const normalized = {
+                channelId: event.channel.id,
+                command: event.command,
+                credentialRevision: installation.credentialRevision,
+                installationId: installation.id,
+                openModal: event.openModal,
+                provider: installation.provider,
+                providerEventId,
+                raw: event.raw,
+                text: event.text,
+                threadId: event.channel.id,
+                type: "slash_command",
+                user: mapAuthor(event.user),
+            };
+            await this.executeEvent(installation, {
+                channelId: event.channel.id,
+                postable: event.channel,
+                threadId: event.channel.id,
+            }, normalized);
+            return;
+        }
+        const text = [event.command, event.text].filter(Boolean).join(" ").trim();
+        const concurrency = installation.concurrency
+            ?? this.options.concurrency
+            ?? DEFAULT_CONCURRENCY;
+        const turn = {
+            channelId: event.channel.id,
+            coordination: {
+                grouped: false,
+                messageCount: 1,
+                messageIds: [providerEventId],
+                primaryMessageId: providerEventId,
+                strategy: concurrency.strategy,
+            },
+            credentialRevision: installation.credentialRevision,
+            installationId: installation.id,
+            isDirectMessage: event.channel.isDM,
+            messages: [{
+                    attachments: [],
+                    author: mapAuthor(event.user),
+                    edited: false,
+                    formatted: markdownAst(text),
+                    id: providerEventId,
+                    isMention: true,
+                    links: [],
+                    raw: event.raw,
+                    text,
+                    timestamp: providerTimestamp(event.raw),
+                }],
+            provider: installation.provider,
+            providerEventId,
+            threadId: event.channel.id,
+        };
+        await this.executeTurn(installation, {
+            channelId: event.channel.id,
+            postable: event.channel,
+            threadId: event.channel.id,
+        }, turn);
+    }
+    async handleAction(installation, state, event) {
+        const providerEventId = providerEventIdFor(event.raw, [
+            event.actionId,
+            event.messageId,
+            event.threadId,
+            event.user.userId,
+            event.value ?? "",
+        ]);
+        if (!await this.acceptEvent(state, installation, "action", providerEventId))
+            return;
+        await this.executeEvent(installation, event.thread
+            ? { channelId: event.thread.channelId, postable: event.thread, threadId: event.thread.id }
+            : undefined, {
+            actionId: event.actionId,
+            channelId: event.thread?.channelId,
+            credentialRevision: installation.credentialRevision,
+            installationId: installation.id,
+            messageId: event.messageId,
+            openModal: event.openModal,
+            provider: installation.provider,
+            providerEventId,
+            raw: event.raw,
+            threadId: event.threadId,
+            triggerId: event.triggerId,
+            type: "action",
+            user: mapAuthor(event.user),
+            value: event.value,
+        });
+    }
+    async handleReaction(installation, state, event) {
+        const providerEventId = providerEventIdFor(event.raw, [
+            event.messageId,
+            event.threadId,
+            event.user.userId,
+            event.emoji.name,
+            String(event.added),
+        ]);
+        if (!await this.acceptEvent(state, installation, "reaction", providerEventId))
+            return;
+        await this.executeEvent(installation, {
+            channelId: event.thread.channelId,
+            postable: event.thread,
+            threadId: event.thread.id,
+        }, {
+            added: event.added,
+            channelId: event.thread.channelId,
+            credentialRevision: installation.credentialRevision,
+            emoji: event.emoji.name,
+            installationId: installation.id,
+            messageId: event.messageId,
+            provider: installation.provider,
+            providerEventId,
+            raw: event.raw,
+            rawEmoji: event.rawEmoji,
+            threadId: event.threadId,
+            type: "reaction",
+            user: mapAuthor(event.user),
+        });
+    }
+    async handleModalSubmit(installation, state, event) {
+        const providerEventId = providerEventIdFor(event.raw, [
+            event.callbackId,
+            event.viewId,
+            event.user.userId,
+            JSON.stringify(event.values),
+        ]);
+        if (!await this.acceptEvent(state, installation, "modal.submit", providerEventId)) {
+            return undefined;
+        }
+        const result = await this.executeEvent(installation, eventTarget(event.relatedThread, event.relatedChannel), {
+            callbackId: event.callbackId,
+            channelId: event.relatedThread?.channelId ?? event.relatedChannel?.id,
+            credentialRevision: installation.credentialRevision,
+            installationId: installation.id,
+            messageId: event.relatedMessage?.id,
+            privateMetadata: event.privateMetadata,
+            provider: installation.provider,
+            providerEventId,
+            raw: event.raw,
+            threadId: event.relatedThread?.id,
+            type: "modal.submit",
+            user: mapAuthor(event.user),
+            values: event.values,
+            viewId: event.viewId,
+        }, false);
+        return result?.modalResponse;
+    }
+    async handleModalClose(installation, state, event) {
+        const providerEventId = providerEventIdFor(event.raw, [
+            event.callbackId,
+            event.viewId,
+            event.user.userId,
+        ]);
+        if (!await this.acceptEvent(state, installation, "modal.close", providerEventId))
+            return;
+        await this.executeEvent(installation, eventTarget(event.relatedThread, event.relatedChannel), {
+            callbackId: event.callbackId,
+            channelId: event.relatedThread?.channelId ?? event.relatedChannel?.id,
+            credentialRevision: installation.credentialRevision,
+            installationId: installation.id,
+            messageId: event.relatedMessage?.id,
+            privateMetadata: event.privateMetadata,
+            provider: installation.provider,
+            providerEventId,
+            raw: event.raw,
+            threadId: event.relatedThread?.id,
+            type: "modal.close",
+            user: mapAuthor(event.user),
+            viewId: event.viewId,
+        }, false);
+    }
+    async handleOptionsLoad(installation, event) {
+        const result = await this.options.handleEvent?.({
+            actionId: event.actionId,
+            credentialRevision: installation.credentialRevision,
+            installationId: installation.id,
+            provider: installation.provider,
+            providerEventId: providerEventIdFor(event.raw, [
+                event.actionId,
+                event.user.userId,
+                event.query,
+            ]),
+            query: event.query,
+            raw: event.raw,
+            type: "options.load",
+            user: mapAuthor(event.user),
+        });
+        return result?.options;
+    }
+    async acceptEvent(state, installation, type, providerEventId) {
+        return state.setIfNotExists(`polpo:event:${installation.provider}:${installation.id}:${type}:${providerEventId}`, true, this.options.dedupeTtlMs ?? DEFAULT_DEDUPE_TTL_MS);
+    }
+    async executeTurn(installation, target, turn) {
+        const messageId = turn.providerEventId;
+        const event = { ...turn, type: "message" };
+        const execute = async () => {
+            await this.emit({
+                channelId: target.channelId,
+                installationId: installation.id,
+                messageId,
+                name: "turn.started",
+                provider: installation.provider,
+                threadId: target.threadId,
+            });
+            try {
+                if (installation.typingEnabled !== false
+                    && await (this.options.shouldStartTyping?.(turn) ?? true)) {
+                    try {
+                        await target.postable.startTyping();
+                    }
+                    catch (error) {
+                        await this.emit({
+                            channelId: target.channelId,
+                            error: errorMessage(error),
+                            installationId: installation.id,
+                            messageId,
+                            name: "typing.failed",
+                            provider: installation.provider,
+                            threadId: target.threadId,
+                        });
+                    }
+                }
+                const result = this.options.handleEvent
+                    ? await this.options.handleEvent(event)
+                    : await this.options.handleTurn(turn);
+                if (result)
+                    await this.deliver(installation, target, result, messageId);
+                await this.emit({
+                    channelId: target.channelId,
+                    installationId: installation.id,
+                    messageId,
+                    name: "turn.completed",
+                    provider: installation.provider,
+                    threadId: target.threadId,
+                });
+            }
+            catch (error) {
+                await this.emit({
+                    channelId: target.channelId,
+                    error: errorMessage(error),
+                    installationId: installation.id,
+                    messageId,
+                    name: "turn.failed",
+                    provider: installation.provider,
+                    threadId: target.threadId,
+                });
+                throw error;
+            }
+        };
+        if (this.options.handleEvent && this.options.coordinateEvent) {
+            const disposition = await coordinateWithDisposition(this.options.coordinateEvent, event, execute);
+            if (disposition && disposition !== "executed") {
+                await this.emit({
+                    channelId: turn.channelId,
+                    installationId: installation.id,
+                    messageId,
+                    name: `event.${disposition}`,
+                    provider: installation.provider,
+                    threadId: turn.threadId,
+                });
+            }
+            return;
+        }
+        if (this.options.coordinateTurn) {
+            await this.options.coordinateTurn(turn, execute);
+            return;
+        }
+        await this.coordinateLocally(turn, execute);
+    }
+    async executeEvent(installation, target, event, coordinate = true) {
+        if (!this.options.handleEvent) {
+            await this.emit({
+                channelId: event.channelId,
+                installationId: installation.id,
+                messageId: event.providerEventId,
+                name: "event.unhandled",
+                provider: installation.provider,
+                threadId: event.threadId,
+            });
+            return;
+        }
+        let result = undefined;
+        const execute = async () => {
+            await this.emit({
+                channelId: event.channelId,
+                installationId: installation.id,
+                messageId: event.providerEventId,
+                name: "turn.started",
+                provider: installation.provider,
+                threadId: event.threadId,
+            });
+            try {
+                result = await this.options.handleEvent(event);
+                if (result && target && hasDeliverableOutput(result)) {
+                    await this.deliver(installation, target, result, event.providerEventId);
+                }
+                await this.emit({
+                    channelId: event.channelId,
+                    installationId: installation.id,
+                    messageId: event.providerEventId,
+                    name: "turn.completed",
+                    provider: installation.provider,
+                    threadId: event.threadId,
+                });
+            }
+            catch (error) {
+                await this.emit({
+                    channelId: event.channelId,
+                    error: errorMessage(error),
+                    installationId: installation.id,
+                    messageId: event.providerEventId,
+                    name: "turn.failed",
+                    provider: installation.provider,
+                    threadId: event.threadId,
+                });
+                throw error;
+            }
+        };
+        if (coordinate && this.options.coordinateEvent) {
+            const disposition = await coordinateWithDisposition(this.options.coordinateEvent, event, execute);
+            if (disposition && disposition !== "executed") {
+                await this.emit({
+                    channelId: event.channelId,
+                    installationId: installation.id,
+                    messageId: event.providerEventId,
+                    name: `event.${disposition}`,
+                    provider: installation.provider,
+                    threadId: event.threadId,
+                });
+            }
+        }
+        else if (coordinate) {
+            await this.coordinateEventLocally(event, execute);
+        }
+        else {
+            await execute();
+        }
+        return result;
+    }
+    async coordinateEventLocally(event, execute) {
+        const key = `${event.provider}:${event.installationId}:${event.threadId ?? event.providerEventId}`;
+        const previous = this.pendingTurns.get(key) ?? Promise.resolve();
+        const current = previous.catch(() => { }).then(execute);
+        this.pendingTurns.set(key, current);
+        try {
+            await current;
+        }
+        finally {
+            if (this.pendingTurns.get(key) === current)
+                this.pendingTurns.delete(key);
+        }
+    }
+    async coordinateLocally(turn, execute) {
+        const key = `${turn.provider}:${turn.installationId}:${turn.threadId}`;
+        const previous = this.pendingTurns.get(key) ?? Promise.resolve();
+        const current = previous.catch(() => { }).then(execute);
+        this.pendingTurns.set(key, current);
+        try {
+            await current;
+        }
+        finally {
+            if (this.pendingTurns.get(key) === current) {
+                this.pendingTurns.delete(key);
+            }
+        }
+    }
+    async deliver(installation, target, result, sourceMessageId) {
+        try {
+            validateTurnResult(result);
+            if (result.posts?.length) {
+                for (const post of result.posts)
+                    await target.postable.post(post);
+            }
+            else if (result.stream && !result.files?.length && !result.text) {
+                await target.postable.post(result.stream);
+            }
+            else {
+                const streamedText = result.stream
+                    ? await collectText(result.stream)
+                    : "";
+                const segments = segmentChannelText(installation.provider, [result.text, streamedText].filter(Boolean).join(""), installation.responseDelivery);
+                const files = result.files?.map((file) => ({
+                    data: file.data,
+                    filename: file.filename,
+                    mimeType: file.mimeType,
+                }));
+                const attachments = result.files
+                    ?.filter((file) => file.type)
+                    .map((file) => ({
+                    data: file.data instanceof ArrayBuffer
+                        ? new Blob([file.data])
+                        : file.data,
+                    mimeType: file.mimeType,
+                    name: file.filename,
+                    type: file.type,
+                }));
+                const genericFiles = result.files?.some((file) => file.type)
+                    ? files?.filter((_file, index) => !result.files?.[index]?.type)
+                    : files;
+                if (segments.length === 0 && files?.length) {
+                    await target.postable.post({
+                        attachments,
+                        files: genericFiles,
+                        markdown: "",
+                    });
+                }
+                else {
+                    for (const [index, text] of segments.entries()) {
+                        if (index === 0 && files?.length) {
+                            await target.postable.post({
+                                attachments,
+                                files: genericFiles,
+                                markdown: text,
+                            });
+                        }
+                        else {
+                            await target.postable.post(text);
+                        }
+                    }
+                }
+            }
+            await this.emit({
+                channelId: target.channelId,
+                installationId: installation.id,
+                messageId: sourceMessageId,
+                name: "delivery.completed",
+                provider: installation.provider,
+                threadId: target.threadId,
+            });
+        }
+        catch (error) {
+            await this.emit({
+                channelId: target.channelId,
+                error: errorMessage(error),
+                installationId: installation.id,
+                messageId: sourceMessageId,
+                name: "delivery.failed",
+                provider: installation.provider,
+                threadId: target.threadId,
+            });
+            throw error;
+        }
+    }
+    async prune() {
+        const now = Date.now();
+        const expired = [...this.entries.values()].filter((entry) => now - entry.lastUsedAt >= this.options.idleTtlMs);
+        await Promise.all(expired.map((entry) => this.evict(entry)));
+        const overflow = this.entries.size - this.options.maxInstances + 1;
+        if (overflow > 0) {
+            const oldest = [...this.entries.values()]
+                .sort((a, b) => a.lastUsedAt - b.lastUsedAt)
+                .slice(0, overflow);
+            await Promise.all(oldest.map((entry) => this.evict(entry)));
+        }
+    }
+    async evict(entry) {
+        if (!this.entries.delete(entry.key))
+            return;
+        await entry.chat.shutdown();
+        await this.emit({
+            installationId: entry.installation.id,
+            name: "runtime.evicted",
+            provider: entry.installation.provider,
+        });
+    }
+    async emit(event) {
+        await this.options.onEvent?.(event);
+    }
+}
+function runtimeKey(installation, defaultConcurrency) {
+    const typing = installation.typingEnabled === false ? "silent" : "typing";
+    const concurrency = JSON.stringify(installation.concurrency ?? defaultConcurrency ?? DEFAULT_CONCURRENCY);
+    const responseDelivery = JSON.stringify(installation.responseDelivery ?? null);
+    return `${installation.provider}:${installation.id}:${installation.credentialRevision}:${typing}:${concurrency}:${responseDelivery}`;
+}
+async function coordinateWithDisposition(coordinator, event, execute) {
+    let executions = 0;
+    const executeOnce = async () => {
+        executions += 1;
+        if (executions > 1) {
+            throw new Error("Channel event coordinator attempted to execute an event more than once");
+        }
+        await execute();
+    };
+    const disposition = await coordinator(event, executeOnce);
+    if (disposition === "executed" && executions !== 1) {
+        throw new Error('Channel event coordinator returned "executed" without executing the event');
+    }
+    if (disposition
+        && disposition !== "executed"
+        && executions !== 0) {
+        throw new Error(`Channel event coordinator returned "${disposition}" after executing the event`);
+    }
+    if (!disposition && executions === 0) {
+        throw new Error("Channel event coordinator returned no disposition and did not execute the event");
+    }
+    return disposition;
+}
+async function mapMessage(message) {
+    const subject = await message.subject.catch(() => null);
+    return {
+        attachments: message.attachments.map((attachment) => ({
+            data: attachment.data,
+            fetchData: attachment.fetchData,
+            fetchMetadata: attachment.fetchMetadata,
+            height: attachment.height,
+            mimeType: attachment.mimeType,
+            name: attachment.name,
+            size: attachment.size,
+            type: attachment.type,
+            url: attachment.url,
+            width: attachment.width,
+        })),
+        author: mapAuthor(message.author),
+        edited: message.metadata.edited,
+        editedAt: message.metadata.editedAt,
+        formatted: message.formatted,
+        id: message.id,
+        isMention: message.isMention ?? false,
+        links: message.links,
+        raw: message.raw,
+        subject: subject ?? undefined,
+        text: message.text,
+        timestamp: message.metadata.dateSent,
+    };
+}
+function providerEventIdFor(raw, fallback) {
+    const record = asRecord(raw);
+    for (const key of ["id", "event_id", "trigger_id"]) {
+        const value = record?.[key];
+        if (typeof value === "string" && value.trim())
+            return value;
+        if (typeof value === "number" && Number.isFinite(value))
+            return String(value);
+    }
+    return `derived-${stableHash(`${stableSerialize(raw)}|${fallback.join("|")}`)}`;
+}
+function providerTimestamp(raw) {
+    const record = asRecord(raw);
+    for (const key of ["timestamp", "event_ts", "event_time"]) {
+        const value = record?.[key];
+        if (typeof value === "number" && Number.isFinite(value)) {
+            const milliseconds = value < 10_000_000_000 ? value * 1_000 : value;
+            const date = new Date(milliseconds);
+            if (!Number.isNaN(date.getTime()))
+                return date;
+        }
+        if (typeof value === "string" && value.trim()) {
+            const numeric = Number(value);
+            const date = Number.isFinite(numeric)
+                ? new Date(numeric < 10_000_000_000 ? numeric * 1_000 : numeric)
+                : new Date(value);
+            if (!Number.isNaN(date.getTime()))
+                return date;
+        }
+    }
+    return new Date();
+}
+function asRecord(value) {
+    return value !== null && typeof value === "object"
+        ? value
+        : null;
+}
+function errorMessage(error) {
+    return error instanceof Error ? error.message : String(error);
+}
+async function collectText(stream) {
+    let text = "";
+    for await (const chunk of stream) {
+        if (typeof chunk === "string") {
+            text += chunk;
+        }
+        else if (chunk.type === "text-delta" && "textDelta" in chunk) {
+            text += chunk.textDelta;
+        }
+        else if (chunk.type === "markdown_text" && "text" in chunk) {
+            text += chunk.text;
+        }
+        else if (chunk.type === "finish-step") {
+            text += "\n\n";
+        }
+    }
+    return text;
+}
+function mapAuthor(author) {
+    return {
+        email: author.email,
+        fullName: author.fullName,
+        isBot: author.isBot,
+        userId: author.userId,
+        userName: author.userName,
+    };
+}
+function markdownAst(text) {
+    return {
+        type: "root",
+        children: [{
+                type: "paragraph",
+                children: [{ type: "text", value: text }],
+            }],
+    };
+}
+function eventTarget(thread, channel) {
+    const postable = thread ?? channel;
+    if (!postable)
+        return undefined;
+    return {
+        channelId: thread?.channelId ?? postable.id,
+        postable,
+        threadId: thread?.id ?? postable.id,
+    };
+}
+function hasDeliverableOutput(result) {
+    return Boolean(result.posts?.length || result.stream || result.files?.length || result.text);
+}
+function validateTurnResult(result) {
+    if (result.posts?.length && (result.text || result.stream || result.files?.length)) {
+        throw new Error("Native posts cannot be combined with text, stream, or files");
+    }
+}
+function stableSerialize(value) {
+    if (value === null || typeof value !== "object")
+        return JSON.stringify(value);
+    if (Array.isArray(value))
+        return `[${value.map(stableSerialize).join(",")}]`;
+    const record = value;
+    return `{${Object.keys(record).sort().map((key) => `${JSON.stringify(key)}:${stableSerialize(record[key])}`).join(",")}}`;
+}
+function stableHash(value) {
+    let hash = 0x811c9dc5;
+    for (let index = 0; index < value.length; index += 1) {
+        hash ^= value.charCodeAt(index);
+        hash = Math.imul(hash, 0x01000193);
+    }
+    return (hash >>> 0).toString(36);
+}
+//# sourceMappingURL=runtime.js.map