@swirls/looms 0.0.2 → 0.2.0

package/dist/agent/agent-session.js

@@ -0,0 +1,270 @@
+import { Predicate } from 'effect';
+import { cancel, createWaitId, deterministicThreadId, emit, spawn, wait, } from '@swirls/looms/core';
+import { agentModule } from './scope.js';
+function objectPayload(event) {
+    return Predicate.isObject(event.payload) ? event.payload : {};
+}
+function messageFrom(value) {
+    const payload = Predicate.isObject(value) ? value : {};
+    return Predicate.isString(payload.messageId) && Predicate.isString(payload.text)
+        ? {
+            messageId: payload.messageId,
+            text: payload.text,
+            delivery: payload.delivery === 'steer' ||
+                payload.delivery === 'followUp' ||
+                payload.delivery === 'nextTurn'
+                ? payload.delivery
+                : undefined,
+        }
+        : null;
+}
+function consumedIds(event) {
+    const payload = objectPayload(event);
+    const embedded = Predicate.isObject(payload.event) ? payload.event : {};
+    const embeddedPayload = Predicate.isObject(embedded.payload) ? embedded.payload : {};
+    const output = Predicate.isObject(embeddedPayload.output) ? embeddedPayload.output : {};
+    const ids = output.consumedSteerMessageIds;
+    return Array.isArray(ids) ? ids.filter(Predicate.isString) : [];
+}
+function closureStatus(event) {
+    const payload = objectPayload(event);
+    const embedded = Predicate.isObject(payload.event) ? payload.event : {};
+    const embeddedPayload = Predicate.isObject(embedded.payload) ? embedded.payload : {};
+    const status = embedded.type === 'runtime.thread.completed'
+        ? 'completed'
+        : embedded.type === 'runtime.thread.cancelled'
+            ? 'cancelled'
+            : 'failed';
+    const error = Predicate.isString(embeddedPayload.error) ? embeddedPayload.error : undefined;
+    return { status, error };
+}
+function close(messageId, status, error) {
+    return error === undefined ? { messageId, status } : { messageId, status, error };
+}
+export function createAgentSessionThread(definitions) {
+    return agentModule.thread({
+        kind: 'agent-session',
+        initialState: (ctx) => {
+            const definition = definitions.get(ctx.definitionName, ctx.definitionVersion);
+            return {
+                definitionName: ctx.definitionName,
+                definitionVersion: ctx.definitionVersion,
+                pendingMessages: [],
+                nextTurnMessages: [],
+                processedMessageIds: [],
+                activeTurn: null,
+                pendingSteerDeliveries: [],
+                pendingClosures: [],
+                lastSequence: 0,
+                idleTimeoutMs: definition?.idleTimeoutMs ?? 0,
+                idleDeadlineAt: null,
+                parked: false,
+                cancelling: false,
+            };
+        },
+        step(state, event) {
+            switch (event.type) {
+                case 'runtime.thread.started': {
+                    const initial = messageFrom(objectPayload(event).input);
+                    const idleDeadlineAt = state.idleTimeoutMs > 0 ? event.ts + state.idleTimeoutMs : null;
+                    if (!initial || state.processedMessageIds.includes(initial.messageId)) {
+                        return { ...state, idleDeadlineAt };
+                    }
+                    return {
+                        ...state,
+                        pendingMessages: [initial],
+                        processedMessageIds: [initial.messageId],
+                        idleDeadlineAt,
+                    };
+                }
+                case 'agent.session.message.submitted': {
+                    const payload = objectPayload(event);
+                    const message = messageFrom(payload);
+                    if (!message || state.processedMessageIds.includes(message.messageId)) {
+                        return state;
+                    }
+                    const processedMessageIds = [...state.processedMessageIds, message.messageId];
+                    const idleDeadlineAt = state.idleTimeoutMs > 0 ? event.ts + state.idleTimeoutMs : null;
+                    if (message.delivery === 'nextTurn') {
+                        return {
+                            ...state,
+                            nextTurnMessages: [...state.nextTurnMessages, message],
+                            processedMessageIds,
+                            idleDeadlineAt,
+                            parked: false,
+                        };
+                    }
+                    const queued = message.delivery === 'steer' && state.activeTurn
+                        ? { ...message, steeredIntoMessageId: state.activeTurn.messageId }
+                        : message;
+                    return {
+                        ...state,
+                        pendingMessages: [...state.pendingMessages, queued],
+                        pendingSteerDeliveries: queued.steeredIntoMessageId &&
+                            state.activeTurn &&
+                            payload.activeChildThreadId !== state.activeTurn.childThreadId
+                            ? [...state.pendingSteerDeliveries, queued]
+                            : state.pendingSteerDeliveries,
+                        processedMessageIds,
+                        idleDeadlineAt,
+                        parked: false,
+                    };
+                }
+                case 'agent.session.turn.started': {
+                    const messageId = event.payload.messageId;
+                    const admitted = state.pendingMessages.find((message) => message.messageId === messageId);
+                    const text = [...state.nextTurnMessages, ...(admitted ? [admitted] : [])]
+                        .map((message) => message.text)
+                        .join('\n');
+                    return {
+                        ...state,
+                        pendingMessages: state.pendingMessages.filter((message) => message.messageId !== messageId),
+                        activeTurn: {
+                            messageId,
+                            childThreadId: event.payload.childThreadId,
+                            text,
+                        },
+                        nextTurnMessages: [],
+                        lastSequence: state.lastSequence + 1,
+                        cancelling: false,
+                    };
+                }
+                case 'agent.session.steer.delivered':
+                    return {
+                        ...state,
+                        pendingSteerDeliveries: state.pendingSteerDeliveries.filter((message) => message.messageId !== event.payload.messageId),
+                    };
+                case 'agent.session.turn.closed':
+                    return {
+                        ...state,
+                        pendingClosures: state.pendingClosures.filter((closure) => closure.messageId !== event.payload.messageId),
+                    };
+                case 'agent.session.cancel.requested':
+                case 'runtime.thread.cancel.requested':
+                    return state.activeTurn ? { ...state, cancelling: true } : state;
+                case 'runtime.wait.satisfied': {
+                    const payload = objectPayload(event);
+                    const tag = Predicate.isObject(payload.tag) ? payload.tag : {};
+                    if (tag.kind === 'agent-session-idle') {
+                        if (tag.deadlineAt === state.idleDeadlineAt && state.activeTurn === null) {
+                            return { ...state, parked: true, idleDeadlineAt: null };
+                        }
+                        return state;
+                    }
+                    if (tag.kind !== 'agent-session-turn' || !state.activeTurn) {
+                        return state;
+                    }
+                    const active = state.activeTurn;
+                    const consumed = new Set(consumedIds(event));
+                    const result = closureStatus(event);
+                    const pendingClosures = [
+                        ...state.pendingClosures,
+                        close(active.messageId, result.status, result.error),
+                        ...[...consumed].map((messageId) => close(messageId, result.status, result.error)),
+                    ];
+                    return {
+                        ...state,
+                        pendingMessages: state.pendingMessages.flatMap((message) => {
+                            if (consumed.has(message.messageId)) {
+                                return [];
+                            }
+                            return message.steeredIntoMessageId === active.messageId
+                                ? [{ ...message, steeredIntoMessageId: undefined }]
+                                : [message];
+                        }),
+                        pendingSteerDeliveries: state.pendingSteerDeliveries.filter((message) => !consumed.has(message.messageId) &&
+                            message.steeredIntoMessageId !== active.messageId),
+                        pendingClosures,
+                        activeTurn: null,
+                        lastSequence: state.lastSequence + 1,
+                        cancelling: false,
+                        idleDeadlineAt: state.idleTimeoutMs > 0 ? event.ts + state.idleTimeoutMs : null,
+                    };
+                }
+                default:
+                    return state;
+            }
+        },
+        effects(state, ctx) {
+            const effects = [];
+            for (const closure of state.pendingClosures) {
+                effects.push(emit(agentModule.input('session.turn.closed', { messageId: closure.messageId, status: closure.status, error: closure.error }, { threadId: ctx.threadId }), `session_close_${closure.messageId}`));
+            }
+            for (const message of state.pendingSteerDeliveries) {
+                if (!state.activeTurn || message.steeredIntoMessageId !== state.activeTurn.messageId) {
+                    continue;
+                }
+                effects.push(emit(agentModule.input('steered', {
+                    turn: 0,
+                    messageId: message.messageId,
+                    message: { role: 'user', content: message.text },
+                    interrupt: true,
+                }, { threadId: state.activeTurn.childThreadId }), `session_steer_${message.messageId}`), emit(agentModule.input('session.steer.delivered', { messageId: message.messageId, activeMessageId: state.activeTurn.messageId }, { threadId: ctx.threadId }), `session_steer_delivered_${message.messageId}`));
+            }
+            if (state.activeTurn) {
+                const { childThreadId: turnThreadId, messageId, text } = state.activeTurn;
+                const definition = definitions.get(state.definitionName, state.definitionVersion);
+                if (state.cancelling) {
+                    effects.push(cancel(turnThreadId));
+                }
+                else if (definition) {
+                    effects.push(spawn({
+                        childThreadId: turnThreadId,
+                        kind: 'agent',
+                        definitionName: definition.agent.name,
+                        definitionVersion: definition.agent.version,
+                        input: { text },
+                    }));
+                }
+                // The turn wait must survive cancellation: the child's cancelled event is what closes it.
+                effects.push(wait({
+                    waitId: createWaitId(ctx.threadId, `turn_${messageId}`),
+                    on: {
+                        type: [
+                            'runtime.thread.completed',
+                            'runtime.thread.failed',
+                            'runtime.thread.cancelled',
+                        ],
+                        match: { threadId: turnThreadId },
+                    },
+                    tag: { kind: 'agent-session-turn', messageId },
+                }));
+                return effects;
+            }
+            const next = state.pendingMessages.find((message) => message.steeredIntoMessageId === undefined);
+            if (next) {
+                effects.push(emit(agentModule.input('session.turn.started', {
+                    messageId: next.messageId,
+                    childThreadId: deterministicThreadId(ctx.threadId, 'turn', next.messageId),
+                }, { threadId: ctx.threadId }), `session_admit_${next.messageId}`));
+                return effects;
+            }
+            if (state.parked || state.idleTimeoutMs === 0 || state.idleDeadlineAt === null) {
+                effects.push(wait({
+                    waitId: createWaitId(ctx.threadId, 'mailbox'),
+                    on: { type: 'agent.session.message.submitted', match: { threadId: ctx.threadId } },
+                    tag: { kind: 'agent-session-mailbox' },
+                }));
+            }
+            else {
+                effects.push(wait({
+                    waitId: createWaitId(ctx.threadId, `idle_${state.idleDeadlineAt}`),
+                    on: { timerAt: state.idleDeadlineAt },
+                    tag: { kind: 'agent-session-idle', deadlineAt: state.idleDeadlineAt },
+                }));
+            }
+            return effects;
+        },
+    });
+}
+export function agentSessionSnapshot(state) {
+    return {
+        activeTurnId: state.activeTurn?.messageId ?? null,
+        activeChildThreadId: state.activeTurn?.childThreadId ?? null,
+        pendingMessageCount: state.pendingMessages.length,
+        nextTurnHeldCount: state.nextTurnMessages.length,
+        processedMessageIds: state.processedMessageIds,
+        lastSequence: state.lastSequence,
+        parked: state.parked,
+    };
+}

package/dist/agent/debugger/agent-chat.d.ts

@@ -0,0 +1,2 @@
+import { type WorkspaceContext } from '@swirls/looms/debugger';
+export declare function AgentChat(context: WorkspaceContext): import("react").JSX.Element;

package/dist/agent/debugger/agent-chat.js

@@ -0,0 +1,176 @@
+import { Fragment as _Fragment, jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { Bot, CornerDownRight, MessageSquare, Settings2, User, Wrench } from 'lucide-react';
+import { useMemo, useState } from 'react';
+import { createEventId, isJsonObject, isJsonString } from '@swirls/looms/core';
+import { cn, Composer, EmptyState, errorMessage, FollowList, inputForm, JsonTree, messageInput, parseStructuredJson, Select, SelectContent, SelectItem, SelectTrigger, SelectValue, shortId, useDebugger, useStartRun, } from '@swirls/looms/debugger';
+import { createFold, useEventFold, useProjection, useRunStore, useRunSummary } from '@swirls/looms/react';
+import { conversation } from '../projections.js';
+import { agentSessionMessageEvents, userMessage } from '../signals.js';
+/** Child thread of the session turn that is still open, from the events the store already has. */
+function activeSessionChild(events) {
+    let child;
+    for (const event of events) {
+        if (!isJsonObject(event.payload)) {
+            continue;
+        }
+        if (event.type === 'agent.session.turn.started' && isJsonString(event.payload.childThreadId)) {
+            child = event.payload.childThreadId;
+            continue;
+        }
+        const tag = event.payload.tag;
+        if (event.type === 'runtime.wait.satisfied' &&
+            isJsonObject(tag) &&
+            tag.kind === 'agent-session-turn') {
+            child = undefined;
+        }
+    }
+    return child;
+}
+const streamingFold = createFold({
+    name: 'agentStreamingText',
+    initialState: { lastMessageSeq: -1, turnStarted: false, parts: [] },
+    includeEphemeral: true,
+    reduce(state, event) {
+        if (event.type === 'agent.message') {
+            return { lastMessageSeq: event.seq, turnStarted: false, parts: [] };
+        }
+        if (event.seq <= state.lastMessageSeq) {
+            return state;
+        }
+        if (event.type === 'agent.turn.started') {
+            return { ...state, turnStarted: true };
+        }
+        if (event.type === 'agent.turn.text_delta' &&
+            isJsonObject(event.payload) &&
+            isJsonString(event.payload.delta)) {
+            return {
+                ...state,
+                turnStarted: true,
+                parts: state.parts.concat(event.payload.delta),
+            };
+        }
+        return state;
+    },
+});
+const deliveryOptions = [
+    { value: 'followUp', label: 'Follow up', description: 'Queue after the current turn' },
+    { value: 'steer', label: 'Steer', description: 'Redirect the active turn' },
+    { value: 'nextTurn', label: 'Next turn', description: 'Hold until the next turn starts' },
+];
+function RoleLabel({ icon, children }) {
+    return (_jsxs("div", { className: "text-muted-foreground mb-1.5 flex items-center gap-1.5 text-[11px] font-medium [&_svg]:size-3", children: [icon, children] }));
+}
+function MessageText({ content, className }) {
+    const structured = useMemo(() => parseStructuredJson(content), [content]);
+    if (structured !== undefined) {
+        return _jsx(JsonTree, { value: structured, defaultExpandDepth: 2 });
+    }
+    return (_jsx("div", { className: cn('text-[13px] leading-relaxed break-words whitespace-pre-wrap', className), children: content }));
+}
+function ToolCard({ icon, name, meta, children, }) {
+    return (_jsxs("div", { className: "border-border bg-card/60 overflow-hidden rounded-lg border", children: [_jsxs("div", { className: "border-border/70 flex h-7 items-center gap-1.5 border-b px-2.5 text-[11px] [&_svg]:size-3", children: [_jsx("span", { className: "text-muted-foreground", children: icon }), _jsx("span", { className: "font-mono font-medium", children: name }), meta ? (_jsx("span", { className: "text-muted-foreground ml-auto truncate font-mono text-[10px]", children: meta })) : null] }), _jsx("div", { className: "px-2.5 py-1.5", children: children })] }));
+}
+function ToolCallCard({ call }) {
+    return (_jsx(ToolCard, { icon: _jsx(Wrench, {}), name: call.name, meta: shortId(call.id), children: _jsx(JsonTree, { value: call.arguments, defaultExpandDepth: 2 }) }));
+}
+function MessageItem({ line, toolName }) {
+    switch (line.role) {
+        case 'user':
+            return (_jsxs(_Fragment, { children: [_jsx(RoleLabel, { icon: _jsx(User, {}), children: "User" }), _jsx("div", { className: "bg-secondary w-fit max-w-full rounded-lg px-3 py-2", children: _jsx(MessageText, { content: line.content }) })] }));
+        case 'assistant':
+            return (_jsxs(_Fragment, { children: [_jsx(RoleLabel, { icon: _jsx(Bot, {}), children: "Assistant" }), _jsxs("div", { className: "grid gap-2", children: [line.content ? _jsx(MessageText, { content: line.content }) : null, line.toolCalls?.map((call) => (_jsx(ToolCallCard, { call: call }, call.id)))] })] }));
+        case 'tool':
+            return (_jsx(ToolCard, { icon: _jsx(CornerDownRight, {}), name: `${line.name ?? toolName ?? 'tool'} result`, meta: line.toolCallId ? shortId(line.toolCallId) : undefined, children: _jsx(MessageText, { content: line.content }) }));
+        case 'system':
+            return (_jsxs(_Fragment, { children: [_jsx(RoleLabel, { icon: _jsx(Settings2, {}), children: "System" }), _jsx(MessageText, { content: line.content, className: "text-muted-foreground" })] }));
+        default: {
+            const exhaustive = line.role;
+            return exhaustive;
+        }
+    }
+}
+function StreamingItem({ text }) {
+    return (_jsxs(_Fragment, { children: [_jsx(RoleLabel, { icon: _jsx(Bot, {}), children: "Assistant" }), _jsxs("div", { className: "text-[13px] leading-relaxed break-words whitespace-pre-wrap", children: [text, _jsx("span", { "aria-label": "Generating", className: "bg-foreground/70 ml-0.5 inline-block h-3.5 w-1.5 animate-pulse rounded-[1px] align-[-2px]" })] })] }));
+}
+function Transcript({ runId }) {
+    const store = useRunStore(runId);
+    const convo = useProjection(store, conversation);
+    const streaming = useEventFold(store, streamingFold);
+    const stream = streaming.turnStarted ? streaming.parts.join('') : null;
+    const toolNames = useMemo(() => {
+        const names = new Map();
+        for (const line of convo.lines) {
+            for (const call of line.toolCalls ?? []) {
+                names.set(call.id, call.name);
+            }
+        }
+        return names;
+    }, [convo.lines]);
+    const items = useMemo(() => {
+        const lines = convo.lines.map((line, index) => ({
+            kind: 'line',
+            line,
+            index,
+        }));
+        return stream === null ? lines : [...lines, { kind: 'stream', text: stream }];
+    }, [convo.lines, stream]);
+    return (_jsx(FollowList, { items: items, estimateSize: 96, overscan: 4, paddingStart: 8, paddingEnd: 12, getKey: (item) => (item.kind === 'stream' ? 'stream' : item.index), empty: _jsx("p", { className: "text-muted-foreground p-6 text-center text-xs", children: "Waiting for messages\u2026" }), renderItem: (item) => (_jsx("div", { className: "px-4 py-2", children: item.kind === 'stream' ? (_jsx(StreamingItem, { text: item.text })) : (_jsx(MessageItem, { line: item.line, toolName: item.line.toolCallId ? toolNames.get(item.line.toolCallId) : undefined })) })) }));
+}
+function DeliverySelect({ value, onChange, }) {
+    return (_jsxs(Select, { value: value, onValueChange: (next) => {
+            const option = deliveryOptions.find((candidate) => candidate.value === next);
+            if (option) {
+                onChange(option.value);
+            }
+        }, children: [_jsx(SelectTrigger, { "aria-label": "Delivery", children: _jsx(SelectValue, {}) }), _jsx(SelectContent, { align: "start", className: "w-60", children: deliveryOptions.map((option) => (_jsx(SelectItem, { value: option.value, description: option.description, children: option.label }, option.value))) })] }));
+}
+export function AgentChat(context) {
+    const { definition, runId } = context;
+    const { client } = useDebugger();
+    const [draft, setDraft] = useState('');
+    const [delivery, setDelivery] = useState('followUp');
+    const { start, pending, error } = useStartRun(context);
+    const session = definition.kind === 'agent-session';
+    const form = inputForm(definition.inputSchema);
+    function send() {
+        const content = draft.trim();
+        const input = session ? null : messageInput(form, content);
+        if (!content || input === undefined) {
+            return;
+        }
+        setDraft('');
+        start(input, session
+            ? (started) => client.signal(started.runId, agentSessionMessageEvents(createEventId(), content, { threadId: started.threadId }))
+            : undefined);
+    }
+    return (_jsxs("div", { className: "flex h-full min-h-0 flex-col", children: [runId ? (_jsx(Transcript, { runId: runId })) : (_jsx("div", { className: "min-h-0 flex-1", children: _jsx(EmptyState, { icon: _jsx(MessageSquare, {}), title: `Talk to ${definition.name}`, children: "Your first message starts a new run." }) })), runId ? (_jsx(FollowUp, { runId: runId, session: session, delivery: delivery, setDelivery: setDelivery, startError: error })) : (_jsx(Composer, { value: draft, onChange: setDraft, onSubmit: send, pending: pending, placeholder: `Message ${definition.name}…`, submitLabel: "Start", error: error }))] }));
+}
+function FollowUp({ runId, session, delivery, setDelivery, startError, }) {
+    const store = useRunStore(runId);
+    const { rootThreadId } = useRunSummary(store);
+    const [draft, setDraft] = useState('');
+    const [pending, setPending] = useState(false);
+    const [error, setError] = useState(null);
+    function send() {
+        const content = draft.trim();
+        if (!content || !rootThreadId) {
+            return;
+        }
+        setPending(true);
+        setError(null);
+        const events = session
+            ? agentSessionMessageEvents(createEventId(), content, {
+                delivery,
+                threadId: rootThreadId,
+                activeChildThreadId: delivery === 'steer' ? activeSessionChild(store.events()) : undefined,
+            })
+            : [userMessage(content, { threadId: rootThreadId })];
+        const [only] = events;
+        const commit = events.length === 1 && only ? store.commit(only) : store.commit(events);
+        commit
+            .then(() => setDraft(''))
+            .catch((cause) => setError(errorMessage(cause)))
+            .finally(() => setPending(false));
+    }
+    return (_jsx(Composer, { value: draft, onChange: setDraft, onSubmit: send, pending: pending, disabled: !rootThreadId, placeholder: "Send a follow-up\u2026", error: error ?? startError, toolbar: session ? _jsx(DeliverySelect, { value: delivery, onChange: setDelivery }) : null }));
+}

package/dist/agent/debugger/index.d.ts

@@ -0,0 +1,5 @@
+import { type DebuggerPlugin } from '@swirls/looms/debugger';
+import { AgentChat } from './agent-chat';
+import { TokenUsageView } from './token-usage';
+export declare const agentDebugger: DebuggerPlugin;
+export { AgentChat, TokenUsageView };

package/dist/agent/debugger/index.js

@@ -0,0 +1,19 @@
+import { inputForm, messageInput } from '@swirls/looms/debugger';
+import { tokenUsage } from '../projections.js';
+import { AgentChat } from './agent-chat.js';
+import { summarizeAgentEvent } from './summarize.js';
+import { TokenUsageView } from './token-usage.js';
+function isChat(definition) {
+    return messageInput(inputForm(definition.inputSchema), '') !== undefined;
+}
+export const agentDebugger = {
+    name: 'agent',
+    families: [{ family: 'agent', color: 'oklch(0.74 0.12 240)', summarize: summarizeAgentEvent }],
+    workspace: {
+        kinds: ['agent', 'agent-session'],
+        matches: (definition) => definition.kind === 'agent-session' || isChat(definition),
+        component: AgentChat,
+    },
+    projections: [{ name: tokenUsage.name, component: TokenUsageView }],
+};
+export { AgentChat, TokenUsageView };

package/dist/agent/debugger/summarize.d.ts

@@ -0,0 +1,2 @@
+import { type DebuggerEvent, type EventSummary } from '@swirls/looms/debugger';
+export declare function summarizeAgentEvent(event: DebuggerEvent): EventSummary | undefined;

package/dist/agent/debugger/summarize.js

@@ -0,0 +1,51 @@
+import { isJsonObject, isJsonString } from '@swirls/looms/core';
+import { compactJson, jsonFields, jsonNumberText, jsonText, } from '@swirls/looms/debugger';
+function messageContent(payload) {
+    const message = jsonFields(payload).message;
+    return isJsonObject(message) && isJsonString(message.content) ? message.content : undefined;
+}
+function toolCallSummary(payload) {
+    const call = jsonFields(payload).toolCall;
+    if (!isJsonObject(call)) {
+        return { name: 'tool', args: null };
+    }
+    return {
+        name: isJsonString(call.name) ? call.name : 'tool',
+        args: call.arguments ?? null,
+    };
+}
+export function summarizeAgentEvent(event) {
+    const payload = jsonFields(event.payload);
+    switch (event.type) {
+        case 'agent.message.received':
+            return { title: 'user message', detail: messageContent(event.payload) };
+        case 'agent.turn.started':
+            return { title: 'turn started', detail: `turn ${jsonNumberText(payload.turn) ?? ''}` };
+        case 'agent.turn.text_delta':
+            return { title: 'text delta', detail: jsonText(payload.delta) };
+        case 'agent.message':
+            return { title: 'agent message', detail: messageContent(event.payload) };
+        case 'agent.tool_call.requested': {
+            const call = toolCallSummary(event.payload);
+            return { title: `tool ${call.name}`, detail: compactJson(call.args) };
+        }
+        case 'agent.tool.result':
+            return {
+                title: jsonText(payload.error)
+                    ? `tool error ${jsonText(payload.name)}`
+                    : `tool result ${jsonText(payload.name)}`,
+                detail: jsonText(payload.error) ?? compactJson(payload.result ?? null),
+            };
+        case 'agent.steered':
+            return { title: 'steered', detail: messageContent(event.payload) };
+        case 'agent.spawn.requested':
+            return {
+                title: 'agent spawn',
+                detail: `${jsonText(payload.kind) ?? 'agent'}:${jsonText(payload.definitionName) ?? 'unknown'}`,
+            };
+        case 'agent.effects.requested':
+            return { title: 'agent effects', detail: jsonText(payload.toolCallId) };
+        default:
+            return undefined;
+    }
+}

package/dist/agent/debugger/token-usage.d.ts

@@ -0,0 +1,3 @@
+export declare function TokenUsageView({ runId }: {
+    runId: string;
+}): import("react").JSX.Element;

package/dist/agent/debugger/token-usage.js

@@ -0,0 +1,11 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { useProjection, useRunStore } from '@swirls/looms/react';
+import { tokenUsage } from '../projections.js';
+const format = new Intl.NumberFormat();
+function Stat({ label, value }) {
+    return (_jsxs("div", { className: "border-border bg-card/60 rounded-lg border px-2.5 py-2", children: [_jsx("p", { className: "text-muted-foreground text-[11px]", children: label }), _jsx("p", { className: "font-mono text-[13px] font-medium tabular-nums", children: format.format(value) })] }));
+}
+export function TokenUsageView({ runId }) {
+    const state = useProjection(useRunStore(runId), tokenUsage);
+    return (_jsxs("div", { className: "grid grid-cols-3 gap-2", children: [_jsx(Stat, { label: "Input", value: state.input }), _jsx(Stat, { label: "Output", value: state.output }), _jsx(Stat, { label: "Total", value: state.input + state.output })] }));
+}

package/dist/agent/definitions-store.d.ts

@@ -1,8 +1,7 @@
 import { Context, Layer } from 'effect';
+import { type DefinitionStore } from '@swirls/looms/core';
 import type { AgentDefinition } from './definitions';
-export interface AgentDefinitionStore {
-    get(name: string): AgentDefinition | undefined;
-}
+export type AgentDefinitionStore = DefinitionStore<AgentDefinition>;
 declare const AgentDefinitionsTag_base: Context.ServiceClass<AgentDefinitionsTag, "looms/AgentDefinitions", AgentDefinitionStore>;
 export declare class AgentDefinitionsTag extends AgentDefinitionsTag_base {
 }

package/dist/agent/definitions-store.js

@@ -1,10 +1,8 @@
 import { Context, Layer } from 'effect';
+import { makeDefinitionStore } from '@swirls/looms/core';
 export class AgentDefinitionsTag extends Context.Service()('looms/AgentDefinitions') {
 }
 export function makeAgentDefinitionStore(definitions) {
-    const map = new Map(definitions.map((def) => [def.name, def]));
-    return {
-        get: (name) => map.get(name),
-    };
+    return makeDefinitionStore('agent', definitions);
 }
 export const AgentDefinitionsLive = (definitions) => Layer.succeed(AgentDefinitionsTag, makeAgentDefinitionStore(definitions));