mu-harness 0.19.0 → 0.20.0

package/esm/agents/registry.d.ts

@@ -2,17 +2,7 @@ import type { Agent, ToolDecision } from './types.js';
 export interface AgentRegistry {
     list(): Agent[];
     get(name: string): Agent | undefined;
-    /**
-     * Register (or replace) an agent at runtime — mirrors {@link SkillRegistry.add}.
-     * Lets tools like `create_agent` make a freshly-authored agent immediately
-     * delegatable without a restart. Agents that `extends` the added one are
-     * re-resolved so they pick up the change.
-     */
     add(agent: Agent): void;
-    /**
-     * Replace the entire set in place (rebuild) — used by hot-reload to reflect
-     * created, edited, and deleted definitions. Existing references see the new set.
-     */
     replaceAll(agents: Agent[]): void;
 }
 export declare const grantArg: (tool: string, input: unknown) => string | undefined;

package/esm/channels/adapter.d.ts

@@ -0,0 +1,26 @@
+import type { ApprovalManager } from '../permissions/index.js';
+import type { Harness } from '../harness/types.js';
+import type { ChannelManager } from './types.js';
+export interface ChannelAdapterContext {
+    readonly harness: Harness;
+    readonly manager: ChannelManager;
+    readonly approvals: ApprovalManager;
+}
+export interface ChannelAdapterHandle {
+    stop(): Promise<void>;
+}
+export interface ChannelAdapter {
+    readonly name: string;
+    start(ctx: ChannelAdapterContext): Promise<ChannelAdapterHandle>;
+}
+export interface RunChannelsOptions {
+    harness: Harness;
+    approvals: ApprovalManager;
+    adapters: ChannelAdapter[];
+    idGen?: () => string;
+}
+export interface ChannelHost {
+    readonly manager: ChannelManager;
+    stop(): Promise<void>;
+}
+export declare function runChannels(opts: RunChannelsOptions): Promise<ChannelHost>;

package/esm/channels/adapter.js

@@ -0,0 +1,27 @@
+import { createChannelManager } from './manager.js';
+export async function runChannels(opts) {
+    const { harness, approvals, adapters, idGen } = opts;
+    // Channels bind to a SPECIFIC session id: reopen it from disk if it exists,
+    // else create it. This is what lets a network adapter address persisted
+    // sessions by id (a plain `() => create()` could only ever make new ones).
+    const manager = createChannelManager({
+        createSession: async (id) => {
+            const stored = await harness.sessions.read(id);
+            return stored ? await harness.sessions.open(id) : harness.sessions.create({ id });
+        },
+        idGen,
+    });
+    const handles = [];
+    for (const adapter of adapters) {
+        handles.push(await adapter.start({ harness, manager, approvals }));
+    }
+    return {
+        manager,
+        stop: async () => {
+            for (const handle of handles.reverse())
+                await handle.stop();
+            for (const channel of manager.list())
+                manager.close(channel.id);
+        },
+    };
+}

package/esm/channels/channel.d.ts

@@ -3,5 +3,5 @@ import type { Channel } from './types.js';
 export declare const createChannel: (config: {
     id: string;
     title: string;
-    createSession: () => AgentSession;
+    createSession: (id: string) => AgentSession | Promise<AgentSession>;
 }) => Channel;

package/esm/channels/channel.js

@@ -1,13 +1,17 @@
 import { createEmitter } from '../common/index.js';
 export const createChannel = (config) => {
     let session;
+    let pending;
     const emitter = createEmitter();
     const ensure = () => {
-        if (!session) {
-            session = config.createSession();
-            session.subscribe(emitter.emit);
+        if (!pending) {
+            pending = Promise.resolve(config.createSession(config.id)).then((s) => {
+                session = s;
+                s.subscribe(emitter.emit);
+                return s;
+            });
         }
-        return session;
+        return pending;
     };
     return {
         id: config.id,
@@ -18,7 +22,7 @@ export const createChannel = (config) => {
         get messages() {
             return session?.messages ?? [];
         },
-        send: (input) => ensure().send(input),
+        send: async (input) => (await ensure()).send(input),
         abort: () => session?.abort(),
         subscribe: emitter.subscribe,
     };

package/esm/channels/index.d.ts

@@ -1,3 +1,5 @@
 export type { Channel, ChannelEvent, ChannelManager, ChannelManagerEvent } from './types.js';
 export { createChannel } from './channel.js';
 export { createChannelManager } from './manager.js';
+export { type ChannelAdapter, type ChannelAdapterContext, type ChannelAdapterHandle, type ChannelHost, runChannels, type RunChannelsOptions, } from './adapter.js';
+export * from './ws/index.js';

package/esm/channels/index.js

@@ -1,2 +1,4 @@
 export { createChannel } from './channel.js';
 export { createChannelManager } from './manager.js';
+export { runChannels, } from './adapter.js';
+export * from './ws/index.js';

package/esm/channels/manager.d.ts

@@ -1,6 +1,6 @@
 import type { AgentSession } from '../session/index.js';
 import type { ChannelManager } from './types.js';
 export declare const createChannelManager: (config: {
-    createSession: () => AgentSession;
+    createSession: (id: string) => AgentSession | Promise<AgentSession>;
     idGen?: () => string;
 }) => ChannelManager;

package/esm/channels/ws/client.d.ts

@@ -0,0 +1,24 @@
+import type { ChatFeatures, ChatHost } from '../../tui/index.js';
+export interface ConnectHarnessOptions {
+    url: string;
+    token?: string;
+    sessionId?: string;
+    cwd: string;
+    initialTheme?: string;
+    saveTheme?: (name: string) => void;
+    initialThinking?: boolean;
+    saveThinking?: (visible: boolean) => void;
+    history?: {
+        load(): string[];
+        append(text: string): void;
+    };
+    banner?: string;
+    minimal?: boolean;
+    features?: ChatFeatures;
+    onExit?: (code: number) => void;
+}
+export interface RemoteHarness {
+    host: ChatHost;
+    close(): Promise<void>;
+}
+export declare function connectHarness(opts: ConnectHarnessOptions): Promise<RemoteHarness>;

package/esm/channels/ws/client.js

@@ -0,0 +1,303 @@
+import { createWsClient } from './ws-client.js';
+import { textOf } from './wire.js';
+function deferred() {
+    let resolve;
+    const promise = new Promise((r) => (resolve = r));
+    return { promise, resolve };
+}
+const parseArgs = (raw) => {
+    try {
+        return JSON.parse(raw);
+    }
+    catch {
+        return raw;
+    }
+};
+function wireToEvents(wire) {
+    if (wire.role !== 'assistant')
+        return [];
+    const events = [];
+    for (const tc of wire.toolCalls ?? []) {
+        events.push({ type: 'tool_call', id: tc.id, name: tc.function.name, input: parseArgs(tc.function.arguments) });
+    }
+    events.push({ type: 'message', message: { role: 'assistant', content: [{ type: 'text', text: wire.content }] } });
+    return events;
+}
+export async function connectHarness(opts) {
+    const client = createWsClient({ url: opts.url, token: opts.token, sessionId: opts.sessionId });
+    // Caches hydrated from connect-time frames (feed the synchronous host methods).
+    let agents = [];
+    let activeAgentId = null;
+    let models = [];
+    let modelSelected = '';
+    let commands = [];
+    const sessionsById = new Map();
+    const subSessions = new Map();
+    const approvalListeners = new Set();
+    const subAgentListeners = new Set();
+    const forkWaiters = new Map();
+    const subagentWaiters = new Map();
+    const listWaiters = [];
+    const modelWaiters = [];
+    const rawWaiters = new Map();
+    const agentsReady = deferred();
+    const route = (sessionId, event) => sessionsById.get(sessionId)?._emit(event);
+    const applyRaw = (sessionId, messages) => {
+        sessionsById.get(sessionId)?._setMessages([...messages]);
+        rawWaiters.get(sessionId)?.(messages);
+        rawWaiters.delete(sessionId);
+    };
+    const makeFakeSession = (id, initial, readonly = false) => {
+        let messages = [...initial];
+        const listeners = new Set();
+        return {
+            id,
+            get messages() {
+                return messages;
+            },
+            tools: [],
+            send: (input) => {
+                if (!readonly) {
+                    client.send({ type: 'chat', sessionId: id, text: typeof input === 'string' ? input : textOf(input) });
+                }
+                return Promise.resolve();
+            },
+            abort: () => {
+                if (!readonly)
+                    client.send({ type: 'abort', sessionId: id });
+            },
+            subscribe: (l) => {
+                listeners.add(l);
+                return () => listeners.delete(l);
+            },
+            _emit: (event) => {
+                for (const l of [...listeners])
+                    l(event);
+            },
+            _setMessages: (m) => {
+                messages = m;
+            },
+        };
+    };
+    const handleSubAgentEvent = (ev) => {
+        if (ev.type === 'started') {
+            const session = makeFakeSession(ev.runId, [], true);
+            subSessions.set(ev.runId, session);
+            const run = { runId: ev.runId, agent: ev.agentName, parentId: ev.parentSessionId, session };
+            for (const l of [...subAgentListeners])
+                l(run);
+            return;
+        }
+        const session = subSessions.get(ev.runId);
+        if (!session)
+            return;
+        switch (ev.type) {
+            case 'content':
+                session._emit({ type: 'text', text: ev.detail ?? '' });
+                return;
+            case 'tool_call':
+                session._emit({
+                    type: 'tool_call',
+                    id: crypto.randomUUID(),
+                    name: ev.detail?.name ?? '',
+                    input: parseArgs(ev.detail?.arguments ?? '{}'),
+                });
+                return;
+            case 'completed':
+                session._setMessages([{ role: 'assistant', content: [{ type: 'text', text: ev.detail?.content ?? '' }] }]);
+                session._emit({ type: 'turn_end' });
+                subSessions.delete(ev.runId);
+                return;
+            case 'error':
+                session._emit({ type: 'error', error: new Error(ev.detail ?? 'sub-agent error') });
+                subSessions.delete(ev.runId);
+                return;
+            default:
+                return;
+        }
+    };
+    const unsub = client.on((frame) => {
+        switch (frame.type) {
+            case 'agents':
+                agents = frame.agents;
+                activeAgentId = frame.activeAgentId ?? null;
+                agentsReady.resolve();
+                return;
+            case 'commands':
+                commands = frame.commands;
+                return;
+            case 'models:listed': {
+                models = frame.models.map((m) => ({ id: m.id, ownedBy: m.ownedBy }));
+                modelSelected = frame.selected;
+                const waiters = modelWaiters.splice(0);
+                for (const w of waiters)
+                    w(models);
+                return;
+            }
+            case 'sessions:listed': {
+                const records = frame.sessions.map((s) => ({
+                    id: s.id,
+                    title: s.title,
+                    cwd: opts.cwd,
+                    createdAt: s.createdAt,
+                }));
+                listWaiters.shift()?.(records);
+                return;
+            }
+            case 'sessions:raw':
+                applyRaw(frame.sessionId, frame.messages);
+                return;
+            case 'sessions:forked':
+                forkWaiters.get(frame.requestId)?.({ id: frame.sessionId, messages: frame.messages });
+                forkWaiters.delete(frame.requestId);
+                return;
+            case 'subagent:result':
+                subagentWaiters.get(frame.requestId)?.resolve({ agent: frame.agent, text: frame.text });
+                subagentWaiters.delete(frame.requestId);
+                return;
+            case 'subagent:error':
+                subagentWaiters.get(frame.requestId)?.reject(new Error(frame.message));
+                subagentWaiters.delete(frame.requestId);
+                return;
+            case 'approval_request': {
+                const req = { id: frame.requestId, name: frame.toolName, input: parseArgs(frame.args) };
+                for (const l of [...approvalListeners])
+                    l(req);
+                return;
+            }
+            case 'sub_agent_event':
+                handleSubAgentEvent(frame.event);
+                return;
+            case 'stream':
+                route(frame.sessionId, { type: 'text', text: frame.text });
+                return;
+            case 'reasoning':
+                route(frame.sessionId, { type: 'reasoning', text: frame.text });
+                return;
+            case 'turn_start':
+                route(frame.sessionId, { type: 'turn_start', input: { role: 'user', content: [] } });
+                return;
+            case 'usage':
+                route(frame.sessionId, { type: 'usage', usage: frame.usage });
+                return;
+            case 'message':
+                for (const event of wireToEvents(frame.message))
+                    route(frame.sessionId, event);
+                return;
+            case 'turn_end':
+                route(frame.sessionId, { type: 'turn_end' });
+                // Resync messages losslessly so /export + model-switch carry-over are faithful.
+                if (sessionsById.has(frame.sessionId))
+                    client.send({ type: 'sessions:get', sessionId: frame.sessionId });
+                return;
+            case 'error':
+                if (frame.sessionId)
+                    route(frame.sessionId, { type: 'error', error: new Error(frame.message) });
+                return;
+            default:
+                return;
+        }
+    });
+    const approvals = {
+        hooks: {},
+        hooksFor: () => ({}),
+        pending: () => [],
+        resolve: (id, action) => {
+            client.send({ type: 'approval_response', requestId: id, action });
+            return true;
+        },
+        subscribe: (l) => {
+            approvalListeners.add(l);
+            return () => approvalListeners.delete(l);
+        },
+    };
+    const subAgents = {
+        register: () => { },
+        get: () => undefined,
+        list: () => [],
+        byParent: () => [],
+        subscribe: (l) => {
+            subAgentListeners.add(l);
+            return () => subAgentListeners.delete(l);
+        },
+    };
+    const agentRef = () => activeAgentId ?? agents[0]?.name ?? 'agent';
+    const requestRaw = (id) => new Promise((resolve) => {
+        rawWaiters.set(id, resolve);
+        client.send({ type: 'sessions:get', sessionId: id });
+    });
+    const host = {
+        // No initial session → ChatApp creates one lazily on the first message.
+        approvals,
+        cwd: opts.cwd,
+        createSession: () => {
+            const id = crypto.randomUUID();
+            const session = makeFakeSession(id, []);
+            sessionsById.set(id, session);
+            client.send({ type: 'sessions:create', sessionId: id });
+            return session;
+        },
+        forkSession: async (id, upToIndex) => {
+            const requestId = crypto.randomUUID();
+            const { id: newId, messages } = await new Promise((resolve) => {
+                forkWaiters.set(requestId, resolve);
+                client.send({ type: 'sessions:fork', requestId, sessionId: id, upToIndex });
+            });
+            const session = makeFakeSession(newId, messages);
+            sessionsById.set(newId, session);
+            return session;
+        },
+        listSessions: () => new Promise((resolve) => {
+            listWaiters.push(resolve);
+            client.send({ type: 'sessions:list' });
+        }),
+        openSession: async (id) => {
+            const messages = await requestRaw(id);
+            const session = makeFakeSession(id, messages);
+            sessionsById.set(id, session);
+            return session;
+        },
+        selectModel: (ref) => {
+            modelSelected = ref;
+            client.send({ type: 'models:select', ref });
+        },
+        modelRef: () => modelSelected,
+        listModels: () => new Promise((resolve) => {
+            modelWaiters.push(resolve);
+            client.send({ type: 'models:list' });
+        }),
+        agentRef,
+        agentColor: () => agents.find((a) => a.name === agentRef())?.color,
+        cycleAgent: () => agentRef(),
+        agentNames: () => agents.map((a) => a.name).filter((n) => n !== agentRef() && n !== 'title'),
+        subAgents,
+        dispatchSubAgent: (agent, task, parentId) => new Promise((resolve, reject) => {
+            const requestId = crypto.randomUUID();
+            subagentWaiters.set(requestId, { resolve, reject });
+            client.send({ type: 'subagent:dispatch', requestId, agent, task, parentId });
+        }),
+        initialTheme: opts.initialTheme ?? 'dark',
+        saveTheme: opts.saveTheme ?? (() => { }),
+        initialThinking: opts.initialThinking ?? false,
+        saveThinking: opts.saveThinking ?? (() => { }),
+        history: opts.history,
+        features: opts.features,
+        banner: opts.banner,
+        minimal: opts.minimal,
+        commands: () => commands.map((c) => ({ name: c.command.replace(/^\//, ''), description: c.description })),
+        runCommand: (input) => {
+            client.send({ type: 'command', text: input });
+            return Promise.resolve({ ok: true });
+        },
+        onExit: opts.onExit ?? (() => { }),
+    };
+    await client.connect();
+    await agentsReady.promise;
+    return {
+        host,
+        close: async () => {
+            unsub();
+            await client.close();
+        },
+    };
+}

package/esm/channels/ws/index.d.ts

@@ -0,0 +1,6 @@
+export * from './protocol.js';
+export { type SessionSummaryWire, type PersistedSessionWire, type SessionService, createSessionService } from './session-service.js';
+export { type WireMessage, messagesToWire } from './wire.js';
+export { type WebSocketAdapter, type WebSocketAdapterOptions, webSocketAdapter } from './server.js';
+export { type ConnectHarnessOptions, connectHarness, type RemoteHarness } from './client.js';
+export { createWsClient, type WsClient, type WsClientOptions } from './ws-client.js';

package/esm/channels/ws/index.js

@@ -0,0 +1,6 @@
+export * from './protocol.js';
+export { createSessionService } from './session-service.js';
+export { messagesToWire } from './wire.js';
+export { webSocketAdapter } from './server.js';
+export { connectHarness } from './client.js';
+export { createWsClient } from './ws-client.js';