mu-harness 0.16.3

package/esm/core/src/agent.d.ts

@@ -0,0 +1,39 @@
+import type { ContentPart, Message, Provider, Tool, Usage } from './types';
+export type LoopEvent = ContentPart | {
+    type: 'usage';
+    usage: Usage;
+} | {
+    type: 'reasoning';
+    text: string;
+} | {
+    type: 'message';
+    message: Message;
+} | {
+    type: 'done';
+    messages: Message[];
+};
+export interface RunOptions {
+    provider: Provider;
+    model: string;
+    messages: Message[];
+    tools?: Tool[];
+    signal?: AbortSignal;
+}
+export declare function run(opts: RunOptions): AsyncIterable<LoopEvent>;
+export interface AgentConfig {
+    provider: Provider;
+    model: string;
+    tools?: Tool[];
+    system?: string;
+    signal?: AbortSignal;
+}
+export type Input = string | ContentPart[] | Message[];
+export interface AgentResult {
+    message: Message;
+    messages: Message[];
+}
+export interface Agent {
+    stream(input: Input): AsyncIterable<LoopEvent>;
+    run(input: Input): Promise<AgentResult>;
+}
+export declare const createAgent: (config: AgentConfig) => Agent;

package/esm/core/src/agent.js

@@ -0,0 +1,96 @@
+const append = (parts, part) => {
+    const last = parts[parts.length - 1];
+    if (part.type === 'text' && last?.type === 'text') {
+        last.text += part.text;
+    }
+    else if (part.type === 'audio' && last?.type === 'audio' && last.mime === part.mime) {
+        const merged = new Uint8Array(last.data.length + part.data.length);
+        merged.set(last.data);
+        merged.set(part.data, last.data.length);
+        last.data = merged;
+    }
+    else if (part.type === 'text') {
+        parts.push({ type: 'text', text: part.text });
+    }
+    else if (part.type === 'audio') {
+        parts.push({ type: 'audio', mime: part.mime, data: part.data });
+    }
+    else {
+        parts.push(part);
+    }
+};
+const execute = async (tools, call, signal) => {
+    const tool = tools.get(call.name);
+    if (!tool)
+        return [{ type: 'text', text: `Unknown tool: ${call.name}` }];
+    try {
+        return await tool.run(call.input, { signal });
+    }
+    catch (err) {
+        return [{ type: 'text', text: err instanceof Error ? err.message : String(err) }];
+    }
+};
+export async function* run(opts) {
+    const { provider, model, signal } = opts;
+    const tools = opts.tools ?? [];
+    const registry = new Map(tools.map((t) => [t.name, t]));
+    const messages = [...opts.messages];
+    while (true) {
+        const content = [];
+        const calls = [];
+        for await (const event of provider.stream({ model, messages, tools, signal })) {
+            if (event.type === 'usage' || event.type === 'reasoning') {
+                yield event;
+                continue;
+            }
+            yield event;
+            append(content, event);
+            if (event.type === 'tool_call')
+                calls.push(event);
+        }
+        const message = { role: 'assistant', content };
+        messages.push(message);
+        yield { type: 'message', message };
+        if (calls.length === 0)
+            break;
+        const results = await Promise.all(calls.map(async (call) => ({
+            type: 'tool_result',
+            id: call.id,
+            content: await execute(registry, call, signal),
+        })));
+        const toolMessage = { role: 'user', content: results };
+        messages.push(toolMessage);
+        yield { type: 'message', message: toolMessage };
+    }
+    yield { type: 'done', messages };
+}
+const isMessages = (input) => input.length > 0 && 'role' in input[0];
+const toMessages = (input) => {
+    if (typeof input === 'string')
+        return [{ role: 'user', content: [{ type: 'text', text: input }] }];
+    if (isMessages(input))
+        return input;
+    return [{ role: 'user', content: input }];
+};
+export const createAgent = (config) => {
+    const tools = config.tools ?? [];
+    const build = (input) => {
+        const messages = toMessages(input);
+        if (!config.system)
+            return messages;
+        return [{ role: 'system', content: [{ type: 'text', text: config.system }] }, ...messages];
+    };
+    const stream = (input) => run({ provider: config.provider, model: config.model, tools, messages: build(input), signal: config.signal });
+    const runToEnd = async (input) => {
+        let message = { role: 'assistant', content: [] };
+        let messages = [];
+        for await (const event of stream(input)) {
+            if (event.type === 'message' && event.message.role === 'assistant')
+                message = event.message;
+            else if (event.type === 'done')
+                messages = event.messages;
+        }
+        return { message, messages };
+    };
+    return { stream, run: runToEnd };
+};

package/esm/core/src/index.d.ts

@@ -0,0 +1,4 @@
+export type { ContentPart, Message, Provider, Role, StreamEvent, Tool, Usage } from './types';
+export { audio, image, text } from './types';
+export type { Agent, AgentConfig, AgentResult, Input, LoopEvent, RunOptions } from './agent';
+export { createAgent, run } from './agent';

package/esm/core/src/index.js

@@ -0,0 +1,2 @@
+export { audio, image, text } from './types';
+export { createAgent, run } from './agent';

package/esm/core/src/types.d.ts

@@ -0,0 +1,59 @@
+export type ContentPart = {
+    type: 'text';
+    text: string;
+} | {
+    type: 'image';
+    mime: string;
+    data: Uint8Array;
+} | {
+    type: 'audio';
+    mime: string;
+    data: Uint8Array;
+} | {
+    type: 'tool_call';
+    id: string;
+    name: string;
+    input: unknown;
+} | {
+    type: 'tool_result';
+    id: string;
+    content: ContentPart[];
+};
+export type Role = 'system' | 'user' | 'assistant';
+export type Message = {
+    role: Role;
+    content: ContentPart[];
+};
+export declare const text: (value: string) => ContentPart;
+export declare const image: (mime: string, data: Uint8Array) => ContentPart;
+export declare const audio: (mime: string, data: Uint8Array) => ContentPart;
+export interface Tool {
+    name: string;
+    description: string;
+    parameters: Record<string, unknown>;
+    prompt?: string;
+    run(input: unknown, ctx: {
+        signal?: AbortSignal;
+    }): Promise<ContentPart[]>;
+}
+export interface Usage {
+    input?: number;
+    output?: number;
+    total?: number;
+    contextWindow?: number;
+}
+export type StreamEvent = ContentPart | {
+    type: 'usage';
+    usage: Usage;
+} | {
+    type: 'reasoning';
+    text: string;
+};
+export interface Provider {
+    stream(req: {
+        model: string;
+        messages: Message[];
+        tools: Tool[];
+        signal?: AbortSignal;
+    }): AsyncIterable<StreamEvent>;
+}

package/esm/core/src/types.js

@@ -0,0 +1,3 @@
+export const text = (value) => ({ type: 'text', text: value });
+export const image = (mime, data) => ({ type: 'image', mime, data });
+export const audio = (mime, data) => ({ type: 'audio', mime, data });

package/esm/harness/npm/src/_dnt.polyfills.d.ts

@@ -0,0 +1,11 @@
+declare global {
+    interface Object {
+        /**
+         * Determines whether an object has a property with the specified name.
+         * @param o An object.
+         * @param v A property name.
+         */
+        hasOwn(o: object, v: PropertyKey): boolean;
+    }
+}
+export {};

package/esm/harness/npm/src/_dnt.polyfills.js

@@ -0,0 +1,15 @@
+// https://github.com/tc39/proposal-accessible-object-hasownproperty/blob/main/polyfill.js
+if (!Object.hasOwn) {
+    Object.defineProperty(Object, "hasOwn", {
+        value: function (object, property) {
+            if (object == null) {
+                throw new TypeError("Cannot convert undefined or null to object");
+            }
+            return Object.prototype.hasOwnProperty.call(Object(object), property);
+        },
+        configurable: true,
+        enumerable: false,
+        writable: true,
+    });
+}
+export {};

package/esm/harness/npm/src/agents/index.d.ts

@@ -0,0 +1,4 @@
+export type { Agent } from './types.js';
+export { type AgentRegistry, createAgentRegistry } from './registry.js';
+export { parseAgent } from './parser.js';
+export { loadAgents } from './loader.js';

package/esm/harness/npm/src/agents/index.js

@@ -0,0 +1,3 @@
+export { createAgentRegistry } from './registry.js';
+export { parseAgent } from './parser.js';
+export { loadAgents } from './loader.js';

package/esm/harness/npm/src/agents/loader.d.ts

@@ -0,0 +1,2 @@
+import type { Agent } from './types.js';
+export declare const loadAgents: (dir: string) => Promise<Agent[]>;

package/esm/harness/npm/src/agents/loader.js

@@ -0,0 +1,24 @@
+import { readdir, readFile } from 'node:fs/promises';
+import { basename, join } from 'node:path';
+import { parseAgent } from './parser.js';
+export const loadAgents = async (dir) => {
+    let entries;
+    try {
+        entries = await readdir(dir);
+    }
+    catch {
+        return [];
+    }
+    const files = entries.filter((name) => name.endsWith('.md')).sort();
+    const agents = [];
+    for (const file of files) {
+        try {
+            const source = await readFile(join(dir, file), 'utf-8');
+            agents.push(parseAgent(source, basename(file, '.md')));
+        }
+        catch {
+            continue;
+        }
+    }
+    return agents;
+};

package/esm/harness/npm/src/agents/parser.d.ts

@@ -0,0 +1,2 @@
+import type { Agent } from './types.js';
+export declare const parseAgent: (source: string, fallbackName: string) => Agent;

package/esm/harness/npm/src/agents/parser.js

@@ -0,0 +1,20 @@
+import { parseFrontmatter, str } from '../common/index.js';
+const parseToolList = (raw) => {
+    if (Array.isArray(raw)) {
+        return raw.filter((entry) => typeof entry === 'string').map((entry) => entry.trim()).filter(Boolean);
+    }
+    if (typeof raw === 'string')
+        return raw.split(',').map((part) => part.trim()).filter(Boolean);
+    return undefined;
+};
+export const parseAgent = (source, fallbackName) => {
+    const { fields, body } = parseFrontmatter(source);
+    return {
+        name: str(fields.name) ?? fallbackName,
+        description: str(fields.description) ?? '',
+        prompt: body,
+        tools: parseToolList(fields.tools),
+        model: str(fields.model),
+        extends: str(fields.extends),
+    };
+};

package/esm/harness/npm/src/agents/registry.d.ts

@@ -0,0 +1,6 @@
+import type { Agent } from './types.js';
+export interface AgentRegistry {
+    list(): Agent[];
+    get(name: string): Agent | undefined;
+}
+export declare const createAgentRegistry: (agents?: Agent[]) => AgentRegistry;

package/esm/harness/npm/src/agents/registry.js

@@ -0,0 +1,31 @@
+const merge = (base, child) => ({
+    name: child.name,
+    description: child.description || base.description,
+    prompt: child.prompt || base.prompt,
+    tools: child.tools ?? base.tools,
+    model: child.model ?? base.model,
+});
+export const createAgentRegistry = (agents = []) => {
+    const raw = new Map();
+    for (const agent of agents)
+        if (!raw.has(agent.name))
+            raw.set(agent.name, agent);
+    const resolve = (name, seen) => {
+        const agent = raw.get(name);
+        if (!agent.extends)
+            return agent;
+        if (seen.has(name))
+            throw new Error(`AgentRegistry: "extends" cycle at "${name}"`);
+        const base = raw.get(agent.extends);
+        if (!base)
+            throw new Error(`AgentRegistry: "${name}" extends unknown agent "${agent.extends}"`);
+        return merge(resolve(agent.extends, new Set(seen).add(name)), agent);
+    };
+    const byName = new Map();
+    for (const name of raw.keys())
+        byName.set(name, resolve(name, new Set()));
+    return {
+        list: () => [...byName.values()],
+        get: (name) => byName.get(name),
+    };
+};

package/esm/harness/npm/src/agents/types.d.ts

@@ -0,0 +1,8 @@
+export interface Agent {
+    name: string;
+    description: string;
+    prompt: string;
+    tools?: string[];
+    model?: string;
+    extends?: string;
+}

package/esm/harness/npm/src/agents/types.js

@@ -0,0 +1 @@
+export {};

package/esm/harness/npm/src/channels/channel.d.ts

@@ -0,0 +1,7 @@
+import type { AgentSession } from '../session/index.js';
+import type { Channel } from './types.js';
+export declare const createChannel: (config: {
+    id: string;
+    title: string;
+    createSession: () => AgentSession;
+}) => Channel;

package/esm/harness/npm/src/channels/channel.js

@@ -0,0 +1,25 @@
+import { createEmitter } from '../common/index.js';
+export const createChannel = (config) => {
+    let session;
+    const emitter = createEmitter();
+    const ensure = () => {
+        if (!session) {
+            session = config.createSession();
+            session.subscribe(emitter.emit);
+        }
+        return session;
+    };
+    return {
+        id: config.id,
+        title: config.title,
+        get started() {
+            return session !== undefined;
+        },
+        get messages() {
+            return session?.messages ?? [];
+        },
+        send: (input) => ensure().send(input),
+        abort: () => session?.abort(),
+        subscribe: emitter.subscribe,
+    };
+};

package/esm/harness/npm/src/channels/index.d.ts

@@ -0,0 +1,3 @@
+export type { Channel, ChannelEvent, ChannelManager, ChannelManagerEvent } from './types.js';
+export { createChannel } from './channel.js';
+export { createChannelManager } from './manager.js';

package/esm/harness/npm/src/channels/index.js

@@ -0,0 +1,2 @@
+export { createChannel } from './channel.js';
+export { createChannelManager } from './manager.js';

package/esm/harness/npm/src/channels/manager.d.ts

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

package/esm/harness/npm/src/channels/manager.js

@@ -0,0 +1,28 @@
+import { createEmitter } from '../common/index.js';
+import { createChannel } from './channel.js';
+export const createChannelManager = (config) => {
+    const channels = new Map();
+    const unsubs = new Map();
+    const emitter = createEmitter();
+    const idGen = config.idGen ?? (() => crypto.randomUUID());
+    return {
+        open(opts) {
+            const id = opts?.id ?? idGen();
+            const title = opts?.title ?? id;
+            const channel = createChannel({ id, title, createSession: config.createSession });
+            channels.set(id, channel);
+            unsubs.set(id, channel.subscribe((event) => emitter.emit({ channelId: id, ...event })));
+            emitter.emit({ channelId: id, type: 'channel_open', title });
+            return channel;
+        },
+        get: (id) => channels.get(id),
+        list: () => [...channels.values()],
+        close(id) {
+            unsubs.get(id)?.();
+            unsubs.delete(id);
+            if (channels.delete(id))
+                emitter.emit({ channelId: id, type: 'channel_close' });
+        },
+        subscribe: emitter.subscribe,
+    };
+};

package/esm/harness/npm/src/channels/types.d.ts

@@ -0,0 +1,30 @@
+import type { ContentPart, Message } from 'mu-core';
+import type { AgentSessionEvent } from '../session/index.js';
+export type ChannelEvent = AgentSessionEvent | {
+    type: 'channel_open';
+    title: string;
+} | {
+    type: 'channel_close';
+};
+export type ChannelManagerEvent = {
+    channelId: string;
+} & ChannelEvent;
+export interface Channel {
+    readonly id: string;
+    readonly title: string;
+    readonly started: boolean;
+    readonly messages: readonly Message[];
+    send(input: string | ContentPart[]): Promise<void>;
+    abort(): void;
+    subscribe(listener: (event: AgentSessionEvent) => void): () => void;
+}
+export interface ChannelManager {
+    open(opts?: {
+        id?: string;
+        title?: string;
+    }): Channel;
+    get(id: string): Channel | undefined;
+    list(): Channel[];
+    close(id: string): void;
+    subscribe(listener: (event: ChannelManagerEvent) => void): () => void;
+}

package/esm/harness/npm/src/channels/types.js

@@ -0,0 +1 @@
+export {};

package/esm/harness/npm/src/commands/defaults.d.ts

@@ -0,0 +1,9 @@
+import type { AgentRegistry } from '../agents/index.js';
+import type { SessionManager } from '../session/index.js';
+import type { SkillRegistry } from '../skills/index.js';
+import type { Command } from './types.js';
+export declare const createAgentsCommand: (agents: AgentRegistry) => Command;
+export declare const createSkillsCommand: (skills: SkillRegistry) => Command;
+export declare const createSessionsCommand: (sessions: SessionManager) => Command;
+export declare const createQuitCommand: (onQuit: () => void | Promise<void>) => Command;
+export declare const createHelpCommand: (list: () => Command[]) => Command;

package/esm/harness/npm/src/commands/defaults.js

@@ -0,0 +1,53 @@
+export const createAgentsCommand = (agents) => ({
+    name: 'agents',
+    description: 'List available agents',
+    run: () => {
+        const list = agents.list();
+        if (list.length === 0)
+            return { ok: true, output: 'No agents configured.' };
+        const lines = list.map((a) => `- ${a.name}${a.description ? ` — ${a.description}` : ''}`);
+        return { ok: true, output: lines.join('\n') };
+    },
+});
+export const createSkillsCommand = (skills) => ({
+    name: 'skills',
+    description: 'List available skills',
+    run: () => {
+        const list = skills.list();
+        if (list.length === 0)
+            return { ok: true, output: 'No skills configured.' };
+        const lines = list.map((s) => `- ${s.name}${s.description ? ` — ${s.description}` : ''}`);
+        return { ok: true, output: lines.join('\n') };
+    },
+});
+export const createSessionsCommand = (sessions) => ({
+    name: 'sessions',
+    description: 'List saved sessions',
+    run: async () => {
+        const list = await sessions.list();
+        if (list.length === 0)
+            return { ok: true, output: 'No sessions yet.' };
+        const lines = list.map((s) => `- ${s.title || s.id}`);
+        return { ok: true, output: lines.join('\n') };
+    },
+});
+export const createQuitCommand = (onQuit) => ({
+    name: 'quit',
+    description: 'Exit the session',
+    aliases: ['q'],
+    run: async () => {
+        await onQuit();
+        return { ok: true };
+    },
+});
+export const createHelpCommand = (list) => ({
+    name: 'help',
+    description: 'Show available commands',
+    run: () => {
+        const commands = list();
+        if (commands.length === 0)
+            return { ok: true, output: 'No commands registered.' };
+        const lines = commands.map((c) => `/${c.name} — ${c.description}`);
+        return { ok: true, output: lines.join('\n') };
+    },
+});

package/esm/harness/npm/src/commands/index.d.ts

@@ -0,0 +1,3 @@
+export { createAgentsCommand, createHelpCommand, createQuitCommand, createSessionsCommand, createSkillsCommand, } from './defaults.js';
+export { createCommandRegistry } from './registry.js';
+export type { Command, CommandContext, CommandRegistry, CommandResult } from './types.js';

package/esm/harness/npm/src/commands/index.js

@@ -0,0 +1,2 @@
+export { createAgentsCommand, createHelpCommand, createQuitCommand, createSessionsCommand, createSkillsCommand, } from './defaults.js';
+export { createCommandRegistry } from './registry.js';

package/esm/harness/npm/src/commands/registry.d.ts

@@ -0,0 +1,2 @@
+import type { Command, CommandRegistry } from './types.js';
+export declare const createCommandRegistry: (commands?: Command[]) => CommandRegistry;

package/esm/harness/npm/src/commands/registry.js

@@ -0,0 +1,59 @@
+export const createCommandRegistry = (commands = []) => {
+    const byName = new Map();
+    const aliasToName = new Map();
+    const resolve = (name) => byName.get(aliasToName.get(name) ?? name);
+    const register = (command, options = {}) => {
+        const taken = byName.has(command.name) || aliasToName.has(command.name);
+        if (taken && !options.override)
+            throw new Error(`Command "${command.name}" is already registered`);
+        const existing = byName.get(command.name);
+        if (existing) {
+            for (const alias of existing.aliases ?? [])
+                aliasToName.delete(alias);
+        }
+        byName.set(command.name, command);
+        for (const alias of command.aliases ?? []) {
+            if ((byName.has(alias) || aliasToName.has(alias)) && !options.override) {
+                throw new Error(`Command alias "${alias}" collides with an existing name or alias`);
+            }
+            aliasToName.set(alias, command.name);
+        }
+    };
+    for (const command of commands)
+        register(command);
+    const parse = (input) => {
+        const trimmed = input.trimStart();
+        if (!trimmed.startsWith('/'))
+            return undefined;
+        const body = trimmed.slice(1);
+        const firstSpace = body.search(/\s/);
+        const name = firstSpace === -1 ? body : body.slice(0, firstSpace);
+        const args = firstSpace === -1 ? '' : body.slice(firstSpace + 1).trim();
+        const command = resolve(name);
+        return command ? { command, args } : undefined;
+    };
+    return {
+        register,
+        unregister: (name) => {
+            const command = byName.get(name);
+            if (!command)
+                return;
+            byName.delete(name);
+            for (const alias of command.aliases ?? [])
+                aliasToName.delete(alias);
+        },
+        list: () => [...byName.values()],
+        get: resolve,
+        run: async (input, ctx = {}) => {
+            const parsed = parse(input);
+            if (!parsed)
+                return { ok: false, error: `Unknown command: "${input}"` };
+            try {
+                return await parsed.command.run(parsed.args, ctx);
+            }
+            catch (err) {
+                return { ok: false, error: err instanceof Error ? err.message : String(err) };
+            }
+        },
+    };
+};

package/esm/harness/npm/src/commands/types.d.ts

@@ -0,0 +1,23 @@
+export interface CommandResult {
+    ok: boolean;
+    output?: unknown;
+    error?: string;
+}
+export interface CommandContext {
+    sessionId?: string;
+}
+export interface Command {
+    name: string;
+    description: string;
+    aliases?: string[];
+    run: (args: string, ctx: CommandContext) => CommandResult | Promise<CommandResult>;
+}
+export interface CommandRegistry {
+    register(command: Command, options?: {
+        override?: boolean;
+    }): void;
+    unregister(name: string): void;
+    list(): Command[];
+    get(name: string): Command | undefined;
+    run(input: string, ctx?: CommandContext): Promise<CommandResult>;
+}

package/esm/harness/npm/src/commands/types.js

@@ -0,0 +1 @@
+export {};

package/esm/harness/npm/src/common/frontmatter.d.ts

@@ -0,0 +1,6 @@
+export interface Frontmatter {
+    fields: Record<string, unknown>;
+    body: string;
+}
+export declare const parseFrontmatter: (source: string) => Frontmatter;
+export declare const str: (value: unknown) => string | undefined;