openbot 0.3.6 → 0.4.0

package/README.md

@@ -18,7 +18,8 @@ OpenBot is a local-first harness for running AI agents. It is built around a sma
 
 - Runs a local agent server.
 - Stores channels, threads, agents, plugins, config, and variables under `~/.openbot`.
-- Ships with a built-in `system` agent named OpenBot.
+- Ships with a built-in `system` agent named OpenBot (orchestrator, includes the LLM runtime).
+- Ships with a built-in `state` agent for deterministic, non-LLM handling (e.g. `/api/state` defaults).
 - Loads custom agents from `~/.openbot/agents/<agent-id>/AGENT.md`.
 - Loads shared plugins from `~/.openbot/plugins`.
 - Streams events to clients with Server-Sent Events.
@@ -50,15 +51,17 @@ npm run dev
 OpenBot intentionally keeps the public API small:
 
 - `GET /api/events` opens an SSE stream for a channel or thread.
-- `POST /api/publish` publishes an event into the harness.
-- `GET /api/state` runs an event and returns the resulting events without opening a stream.
+- `POST /api/publish` publishes an event into the harness (defaults to the built-in `system` agent with the OpenBot / LLM runtime).
+- `GET /api/state` runs an event and returns the resulting events without opening a stream (defaults to the built-in `state` agent: storage-oriented plugins, no LLM).
+
+You can override the agent with `agentId` (header, query, or body where applicable).
 
 Example:
 
 ```bash
 curl -X POST http://localhost:4132/api/publish \
   -H "content-type: application/json" \
-  -d '{"type":"user:input","data":{"content":"hello"}}'
+  -d '{"type":"agent:invoke","data":{"role":"user","content":"hello"}}'
 ```
 
 Useful context can be passed as headers, query params, or body fields:
@@ -76,8 +79,7 @@ OpenBot reads config from `~/.openbot/config.json`.
 {
   "port": 4132,
   "baseDir": "~/.openbot",
-  "model": "openai/gpt-4o-mini",
-  "mcpServers": []
+  "model": "openai/gpt-4o-mini"
 }
 ```
 
@@ -91,12 +93,11 @@ The built-in `system` agent is always available. Add a custom agent by creating
 ---
 name: Researcher
 description: Helps collect and summarize information.
-runtime:
-  name: ai-sdk
-  config:
-    model: openai/gpt-4o-mini
 plugins:
-  - name: storage
+  - id: openbot
+    config:
+      model: openai/gpt-4o-mini
+  - id: storage
 ---
 
 You are a careful research assistant.
@@ -109,18 +110,16 @@ Agents are discovered from disk when the server starts.
 
 Built-in plugins include:
 
-- `storage`
+- `storage-tools`
 - `delegation`
-- `mcp`
-- `ui`
-- `ai-sdk`
+- `openbot`
 
 Shared plugins can be placed in `~/.openbot/plugins` and referenced by agents.
 
 ## Project Layout
 
 - `src/app`: CLI, server, event types, and app config.
-- `src/harness`: orchestration, process, and MCP runtime helpers.
+- `src/harness`: orchestration and process helpers.
 - `src/plugins`: built-in plugin implementations.
 - `src/services`: local storage service.
 - `src/registry`: plugin registry.

package/dist/app/agent-ids.js

@@ -0,0 +1,4 @@
+/** Built-in orchestrator agent id. Optional `agents/system/AGENT.md` overrides code defaults. */
+export const ORCHESTRATOR_AGENT_ID = 'system';
+/** Built-in infra agent for deterministic `/api/state` and marketplace/plugin lifecycle; optional AGENT.md overlay. */
+export const STATE_AGENT_ID = 'state';

package/dist/app/cli.js

@@ -16,7 +16,7 @@ function checkNodeVersion() {
     }
 }
 checkNodeVersion();
-program.name('openbot').description('OpenBot CLI').version('0.3.6');
+program.name('openbot').description('OpenBot CLI').version('0.4.0');
 program
     .command('start')
     .description('Start the OpenBot harness')

package/dist/app/config.js

@@ -46,22 +46,3 @@ export function loadVariables() {
     }
     return { version: 1, variables: [] };
 }
-export const DEFAULT_AGENT_MD = `---
-description: A specialized AI agent
----
-
-# Agent Profile
-
-You are a specialized AI agent within the OpenBot system.
-Your role is defined by your configuration and the tools you have access to.
-
-## Persona
-- Helpful and precise
-- Focused on my specific domain
-- Professional in all interactions
-`;
-export const DEFAULT_USER_MD = `# About Me
-
-<!-- OpenBot reads this file to understand who you are and how you like to work. -->
-<!-- Edit it here or just chat — agents can update it with the "remember" tool. -->
-`;

package/dist/app/server.js

@@ -9,10 +9,9 @@ const require = createRequire(import.meta.url);
 const pkg = require('../../package.json');
 import { generateId } from 'melony';
 import { DEFAULT_BASE_DIR, loadConfig, resolvePath } from '../app/config.js';
-import { processService } from '../harness/process.js';
-import { storageService } from '../services/storage.js';
-import { dispatch } from '../harness/dispatcher.js';
-import { initPlugins } from '../registry/plugins.js';
+import { processService } from '../services/process.js';
+import { runAgent, STATE_AGENT_ID, ORCHESTRATOR_AGENT_ID } from '../harness/index.js';
+import { initPlugins } from '../services/plugins/registry.js';
 import { ensureEventId, openBotEventFromQuery } from './utils.js';
 export async function startServer(options = {}) {
     const publishEventSchema = z
@@ -171,7 +170,6 @@ export async function startServer(options = {}) {
             return;
         }
         const onEvent = async (chunk, state) => {
-            ensureEventId(chunk);
             const targetChannelId = state?.channelId || channelId;
             const targetThreadId = state?.threadId || threadId;
             const targetClientKey = getClientKey(targetChannelId, targetThreadId);
@@ -186,11 +184,6 @@ export async function startServer(options = {}) {
             else if (chunk.type === 'agent:run:end') {
                 activeRuns.delete(getRunKey(chunk.data.runId, chunk.data.agentId, chunk.data.channelId, chunk.data.threadId));
             }
-            await storageService.storeEvent({
-                channelId: targetChannelId,
-                threadId: targetThreadId,
-                event: chunk,
-            });
             sendToClientKey(targetClientKey, chunk);
             if (chunk.type === 'agent:run:start' ||
                 chunk.type === 'agent:run:end' ||
@@ -200,9 +193,9 @@ export async function startServer(options = {}) {
         };
         try {
             ensureEventId(event);
-            await dispatch({
+            await runAgent({
                 runId,
-                agentId: agentId || 'system',
+                agentId: agentId || ORCHESTRATOR_AGENT_ID,
                 event,
                 channelId,
                 threadId,
@@ -238,12 +231,13 @@ export async function startServer(options = {}) {
         };
         try {
             ensureEventId(event);
-            await dispatch({
+            await runAgent({
                 runId,
-                agentId: agentId || 'system',
+                agentId: agentId || STATE_AGENT_ID,
                 event,
                 channelId,
                 threadId,
+                persistEvents: false,
                 onEvent,
             });
             res.json({ events });

package/dist/bus/services.js

@@ -1,25 +1,6 @@
 import { DEFAULT_MARKETPLACE_REGISTRY_URL, loadConfig } from '../app/config.js';
 import { storageService } from '../services/storage.js';
 import { pluginService } from '../services/plugins.js';
-const readTodos = (state) => {
-    const raw = state.threadDetails?.state?.todos;
-    return Array.isArray(raw) ? raw : [];
-};
-let todoCounter = 0;
-const newTodoId = (now, idx) => `todo_${now.toString(36)}_${(todoCounter++).toString(36)}_${idx}`;
-async function persistTodos(storage, state, todos) {
-    if (!state.threadId)
-        throw new Error('No active thread');
-    await storage.patchThreadState({
-        channelId: state.channelId,
-        threadId: state.threadId,
-        state: { todos },
-    });
-    state.threadDetails = await storage.getThreadDetails({
-        channelId: state.channelId,
-        threadId: state.threadId,
-    });
-}
 /**
  * Resolve a scope alias to a concrete scope string. Aliases let tools accept
  * `agent`/`channel`/`global` without knowing the active ids; the bus rewrites
@@ -44,26 +25,7 @@ function resolveMemoryScopeFilter(alias, state) {
     }
     return [resolveMemoryScope(alias, state)];
 }
-const DEFAULT_MARKETPLACE_AGENTS = [
-    {
-        id: 'researcher',
-        name: 'Researcher',
-        description: 'Specialized in web research and information synthesis.',
-        instructions: 'You are a research assistant. Use available tools to find information.',
-        plugins: [
-            { id: 'ai-sdk', config: { model: 'openai/gpt-4o' } },
-            { id: 'mcp' },
-            { id: 'shell' },
-        ],
-    },
-    {
-        id: 'coder',
-        name: 'Coder',
-        description: 'Expert in multiple programming languages and software architecture.',
-        instructions: 'You are an expert software engineer. Help the user with coding tasks.',
-        plugins: [{ id: 'claude-code' }],
-    },
-];
+const DEFAULT_MARKETPLACE_AGENTS = [];
 function isRecord(value) {
     return typeof value === 'object' && value !== null && !Array.isArray(value);
 }
@@ -311,6 +273,15 @@ export const busServicesPlugin = (options) => (builder) => {
             context.state.channelDetails = await storage.getChannelDetails({
                 channelId: context.state.channelId,
             });
+            yield {
+                type: "client:ui:widget",
+                data: {
+                    kind: "message",
+                    title: "Channel details updated.",
+                    body: "The channel details have been updated.",
+                },
+                meta: resultMeta,
+            };
             yield {
                 type: 'action:patch_channel_details:result',
                 data: { success: true, updatedFields },
@@ -358,91 +329,30 @@ export const busServicesPlugin = (options) => (builder) => {
             };
         }
     });
-    builder.on('action:todo_write', async function* (event, context) {
-        const resultMeta = { ...(event.meta || {}), agentId: context.state.agentId };
-        try {
-            if (!context.state.threadId) {
-                throw new Error('todo_write requires an active thread');
-            }
-            const existing = readTodos(context.state);
-            const byId = new Map(existing.map((t) => [t.id, t]));
-            const now = Date.now();
-            const author = context.state.agentId || 'system';
-            const inputs = event.data.todos || [];
-            const next = inputs.map((raw, idx) => {
-                const prior = raw.id ? byId.get(raw.id) : undefined;
-                return {
-                    id: prior?.id || raw.id || newTodoId(now, idx),
-                    content: raw.content,
-                    status: raw.status || prior?.status || 'pending',
-                    assignee: raw.assignee ?? prior?.assignee,
-                    createdBy: prior?.createdBy || author,
-                    createdAt: prior?.createdAt || now,
-                    updatedAt: now,
-                    ...(prior?.result !== undefined ? { result: prior.result } : {}),
-                };
-            });
-            await persistTodos(storage, context.state, next);
-            yield {
-                type: 'action:todo_write:result',
-                data: { success: true, todos: next },
-                meta: resultMeta,
-            };
-        }
-        catch (error) {
-            yield {
-                type: 'action:todo_write:result',
-                data: {
-                    success: false,
-                    todos: readTodos(context.state),
-                    error: error instanceof Error ? error.message : 'Unknown error',
-                },
-                meta: resultMeta,
-            };
-        }
-    });
-    builder.on('action:todo_update', async function* (event, context) {
-        const resultMeta = { ...(event.meta || {}), agentId: context.state.agentId };
-        const patch = event.data;
-        try {
-            if (!context.state.threadId) {
-                throw new Error('todo_update requires an active thread');
-            }
-            const existing = readTodos(context.state);
-            const idx = existing.findIndex((t) => t.id === patch.id);
-            if (idx === -1) {
-                throw new Error(`Todo "${patch.id}" not found`);
-            }
-            const now = Date.now();
-            const updated = {
-                ...existing[idx],
-                ...(patch.content !== undefined ? { content: patch.content } : {}),
-                ...(patch.status !== undefined ? { status: patch.status } : {}),
-                ...(patch.assignee !== undefined
-                    ? { assignee: patch.assignee === '' ? undefined : patch.assignee }
-                    : {}),
-                updatedAt: now,
-            };
-            const next = [...existing];
-            next[idx] = updated;
-            await persistTodos(storage, context.state, next);
-            yield {
-                type: 'action:todo_update:result',
-                data: { success: true, todo: updated, todos: next },
-                meta: resultMeta,
-            };
-        }
-        catch (error) {
-            yield {
-                type: 'action:todo_update:result',
-                data: {
-                    success: false,
-                    todos: readTodos(context.state),
-                    error: error instanceof Error ? error.message : 'Unknown error',
-                },
-                meta: resultMeta,
-            };
-        }
+    builder.on('agent:usage', async function* (event, context) {
+        const { usage } = event.data;
+        if (!context.state.threadId)
+            return;
+        const currentState = context.state.threadDetails?.state || {};
+        const currentUsage = currentState.usage || {
+            promptTokens: 0,
+            completionTokens: 0,
+            totalTokens: 0,
+        };
+        const nextUsage = {
+            promptTokens: (currentUsage.promptTokens || 0) + usage.promptTokens,
+            completionTokens: (currentUsage.completionTokens || 0) + usage.completionTokens,
+            totalTokens: (currentUsage.totalTokens || 0) + usage.totalTokens,
+        };
+        await storage.patchThreadState({
+            channelId: context.state.channelId,
+            threadId: context.state.threadId,
+            state: { usage: nextUsage },
+        });
+        context.state.threadDetails = await storage.getThreadDetails({
+            channelId: context.state.channelId,
+            threadId: context.state.threadId,
+        });
     });
     builder.on('action:storage:get-channels', async function* () {
         const channels = await storage.getChannels();

package/dist/harness/agent-invoke-run.js

@@ -0,0 +1,44 @@
+import { createAgentRuntime } from './runtime-factory.js';
+/**
+ * Shared `runtime.run(agent:invoke)` loop: tags chunks with `agentId`, skips echo of the
+ * trigger event, optionally polls for stop, tracks last `agent:output` text.
+ *
+ * Does not emit `agent:run:start` / `agent:run:end` — callers bracket those.
+ */
+export async function* streamTaggedAgentInvokeRuntime(options) {
+    const { target, event, state, pollInterrupt } = options;
+    const { runId, agentId } = target;
+    let lastAgentOutput;
+    const runtime = await createAgentRuntime(state);
+    for await (const chunk of runtime.run(event, { state, runId })) {
+        const interrupt = pollInterrupt?.();
+        if (interrupt) {
+            yield interrupt;
+            break;
+        }
+        if (chunk.id === event.id && chunk.type === event.type)
+            continue;
+        if (chunk.type === 'agent:output' &&
+            chunk.meta?.agentId === agentId) {
+            const content = chunk.data?.content;
+            if (typeof content === 'string' && content.trim()) {
+                lastAgentOutput = content.trim();
+            }
+        }
+        chunk.meta = { ...chunk.meta, agentId };
+        yield chunk;
+    }
+    return { lastAgentOutput };
+}
+/**
+ * Drive {@link streamTaggedAgentInvokeRuntime} with a callback per chunk (dispatcher path).
+ */
+export async function consumeAgentInvokeStream(options, onChunk) {
+    const gen = streamTaggedAgentInvokeRuntime(options);
+    let step = await gen.next();
+    while (!step.done) {
+        await onChunk(step.value);
+        step = await gen.next();
+    }
+    return step.value;
+}

package/dist/harness/agent-turn.js

@@ -0,0 +1,99 @@
+import { ensureEventId } from '../app/utils.js';
+import { storageService } from '../services/storage.js';
+import { createAgentRuntime } from './runtime-factory.js';
+const TODO_RESULT_MAX_CHARS = 12000;
+const readThreadState = (state) => state.threadDetails?.state ?? {};
+const readTodos = (state) => {
+    const raw = readThreadState(state).todos;
+    return Array.isArray(raw) ? raw : [];
+};
+function truncateTodoResult(text, maxChars = TODO_RESULT_MAX_CHARS) {
+    const trimmed = text.trim();
+    if (!trimmed)
+        return undefined;
+    if (trimmed.length <= maxChars)
+        return trimmed;
+    return `${trimmed.slice(0, maxChars)}\n…[truncated]`;
+}
+function resolveTodoIdForWorker(todos, workerId, delegationTodoId) {
+    if (delegationTodoId && todos.some((t) => t.id === delegationTodoId)) {
+        return delegationTodoId;
+    }
+    const inProgress = todos.find((t) => t.status === 'in_progress' && t.assignee === workerId);
+    if (inProgress)
+        return inProgress.id;
+    const assigned = todos.find((t) => (t.status === 'pending' || t.status === 'in_progress') && t.assignee === workerId);
+    return assigned?.id;
+}
+export async function recordWorkerTodoResult(state, workerId, output, delegationTodoId) {
+    if (!state.threadId)
+        return;
+    const result = truncateTodoResult(output ?? '');
+    if (!result)
+        return;
+    const todos = readTodos(state);
+    if (todos.length === 0)
+        return;
+    const todoId = resolveTodoIdForWorker(todos, workerId, delegationTodoId);
+    if (!todoId)
+        return;
+    const prior = todos.find((t) => t.id === todoId);
+    if (prior?.result === result)
+        return;
+    const now = Date.now();
+    const next = todos.map((t) => (t.id === todoId ? { ...t, result, updatedAt: now } : t));
+    await storageService.patchThreadState({
+        channelId: state.channelId,
+        threadId: state.threadId,
+        state: { todos: next },
+    });
+}
+export function makeInternalInvoke(content, threadId) {
+    return ensureEventId({
+        type: 'agent:invoke',
+        data: { role: 'user', content },
+        meta: { threadId, internal: true },
+    });
+}
+/**
+ * Run one agent turn (no dispatcher chaining). Yields all runtime events for
+ * persistence/streaming; returns the last non-empty `agent:output` text.
+ */
+export async function* runAgentTurn(options) {
+    const { runId, channelId, threadId, agentId, event, delegationTodoId } = options;
+    const target = { runId, agentId, channelId, threadId };
+    let state;
+    try {
+        state = await storageService.getOpenBotState({ ...target, event });
+    }
+    catch (error) {
+        if (error.code === 'AGENT_NOT_FOUND') {
+            return undefined;
+        }
+        throw error;
+    }
+    yield { type: 'agent:run:start', data: { ...target } };
+    let lastAgentOutput;
+    try {
+        const runtime = await createAgentRuntime(state);
+        for await (const chunk of runtime.run(event, { state, runId })) {
+            if (chunk.id === event.id && chunk.type === event.type)
+                continue;
+            if (chunk.type === 'agent:output' &&
+                chunk.meta?.agentId === agentId) {
+                const content = chunk.data?.content;
+                if (typeof content === 'string' && content.trim()) {
+                    lastAgentOutput = content.trim();
+                }
+            }
+            chunk.meta = { ...chunk.meta, agentId };
+            yield chunk;
+        }
+    }
+    finally {
+        const stateAfterRun = await storageService.getOpenBotState({ ...target, event });
+        yield { type: 'agent:run:end', data: { ...target } };
+        await recordWorkerTodoResult(stateAfterRun, agentId, lastAgentOutput, delegationTodoId);
+    }
+    return lastAgentOutput;
+}

package/dist/harness/channel-participants.js

@@ -0,0 +1,40 @@
+/**
+ * Channel `participants` (from `state.json`) scope which agents may collaborate
+ * in that channel. Used for system-prompt hints and dispatch guards.
+ */
+/** Multi-participant channel: user messages always route to the orchestrator. */
+export function isMultiAgentChannel(participants) {
+    return participants.length > 1;
+}
+/** Solo DM: exactly one participant and it is the acting agent (no peer bots). */
+export function isDmSoloChannel(participants, actingAgentId) {
+    return participants.length === 1 && participants[0] === actingAgentId;
+}
+/**
+ * Resolve which agent handles an incoming user message.
+ * Multi-participant channels always route to the orchestrator (hub-and-spoke).
+ */
+export function resolveMessageTargetAgent(participants, orchestratorAgentId, requestedAgentId) {
+    if (isMultiAgentChannel(participants)) {
+        return orchestratorAgentId;
+    }
+    if (participants.length === 1) {
+        return requestedAgentId || participants[0];
+    }
+    return requestedAgentId || orchestratorAgentId;
+}
+/**
+ * When `participants` is non-empty, todo dispatch targets must appear
+ * in that list. Solo DM forbids targeting any agent other than yourself (for
+ * chained steps); there are no peer bots.
+ */
+export function isParticipantDispatchAllowed(participants, actingAgentId, targetAgentId) {
+    if (participants.length === 0)
+        return true;
+    if (!participants.includes(targetAgentId))
+        return false;
+    if (isDmSoloChannel(participants, actingAgentId) && targetAgentId !== actingAgentId) {
+        return false;
+    }
+    return true;
+}

package/dist/harness/constants.js

@@ -0,0 +1,2 @@
+/** Built-in orchestrator agent id (`~/.openbot/agents/system/AGENT.md` overrides instructions). */
+export const ORCHESTRATOR_AGENT_ID = 'system';

package/dist/harness/context-meter.js

@@ -0,0 +1,97 @@
+import { OPENBOT_SYSTEM_PROMPT } from '../plugins/openbot/system-prompt.js';
+import { ORCHESTRATOR_AGENT_ID, estimateTokens, } from './context.js';
+import { reconstructHistory } from './history.js';
+/** Reserved headroom for model output when computing fill percentage. */
+export const CONTEXT_METER_OUTPUT_RESERVE = 4096;
+const DEFAULT_CONTEXT_LIMIT = 128000;
+const MODEL_CONTEXT_LIMITS = {
+    'gpt-4o': 128000,
+    'gpt-4o-mini': 128000,
+    'gpt-4-turbo': 128000,
+    'gpt-4': 128000,
+    'gpt-3.5-turbo': 16385,
+    'claude-3-5-sonnet-20240620': 200000,
+    'claude-3-5-sonnet-20241022': 200000,
+    'claude-3-opus-20240229': 200000,
+    'claude-3-haiku-20240307': 200000,
+};
+export function getModelContextLimit(modelString) {
+    const modelId = modelString.split('/').slice(1).join('/');
+    if (MODEL_CONTEXT_LIMITS[modelId])
+        return MODEL_CONTEXT_LIMITS[modelId];
+    if (modelId.includes('claude'))
+        return 200000;
+    return DEFAULT_CONTEXT_LIMIT;
+}
+function buildInstructions(state) {
+    if (state.agentId === ORCHESTRATOR_AGENT_ID) {
+        return state.agentDetails?.instructions?.trim() || OPENBOT_SYSTEM_PROMPT;
+    }
+    return OPENBOT_SYSTEM_PROMPT;
+}
+function estimateMessagesTokens(messages) {
+    if (messages.length === 0)
+        return 0;
+    return estimateTokens(JSON.stringify(messages));
+}
+function estimateToolsTokens(tools) {
+    const names = Object.keys(tools);
+    if (names.length === 0)
+        return 0;
+    return estimateTokens(JSON.stringify(tools));
+}
+function applyTrigger(messages, trigger) {
+    const triggerContent = trigger?.data?.content?.trim();
+    if (!triggerContent || !trigger)
+        return messages;
+    const role = (trigger.data?.role || 'user');
+    const last = messages[messages.length - 1];
+    const alreadyLast = last &&
+        last.role === role &&
+        typeof last.content === 'string' &&
+        last.content.trim() === triggerContent;
+    if (alreadyLast)
+        return messages;
+    return [...messages, { role, content: triggerContent }];
+}
+function computePercent(used, limit) {
+    const budget = Math.max(limit - CONTEXT_METER_OUTPUT_RESERVE, 1);
+    return Math.min(100, Math.round((used / budget) * 100));
+}
+export async function computeContextMeter(options) {
+    const { state, storage, modelString, contextEngine, toolDefinitions = {}, trigger, lastUsage, } = options;
+    const limit = getModelContextLimit(modelString);
+    const instructions = buildInstructions(state);
+    const contextBlock = await contextEngine.buildContext(state, storage);
+    const systemTokens = estimateTokens([instructions, contextBlock].filter(Boolean).join('\n\n'));
+    const events = await storage.getEvents({
+        channelId: state.channelId,
+        threadId: state.threadId,
+    });
+    const messages = applyTrigger(reconstructHistory(events), trigger);
+    const historyTokens = estimateMessagesTokens(messages);
+    const toolsTokens = estimateToolsTokens(toolDefinitions);
+    let used = systemTokens + historyTokens + toolsTokens;
+    let estimated = true;
+    if (lastUsage?.input && lastUsage.input > 0) {
+        used = lastUsage.input;
+        estimated = false;
+    }
+    return {
+        model: modelString,
+        limit,
+        used,
+        percent: computePercent(used, limit),
+        estimated,
+        breakdown: {
+            system: systemTokens,
+            history: historyTokens,
+            tools: toolsTokens,
+        },
+        messageCount: messages.length,
+        ...(lastUsage ? { lastUsage } : {}),
+    };
+}
+export function contextMeterEvent(snapshot, meta) {
+    return { type: 'client:ui:context-meter', data: snapshot, meta };
+}