mu-core 0.15.0 → 0.16.3

package/esm/agent.d.ts

@@ -0,0 +1,39 @@
+import type { ContentPart, Message, Provider, Tool, Usage } from './types.js';
+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/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/index.d.ts

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

package/esm/index.js

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

package/esm/package.json

@@ -0,0 +1,3 @@
+{
+  "type": "module"
+}

package/esm/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/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/package.json

@@ -1,14 +1,18 @@
 {
   "name": "mu-core",
-  "version": "0.15.0",
-  "description": "Agent loop orchestration core: types, plugin SDK, channels, sessions",
-  "type": "module",
-  "main": "./src/index.ts",
-  "types": "./src/index.ts",
+  "version": "0.16.3",
+  "description": "Standalone multimodal agentic loop: content, messages, tools, provider interface, createAgent",
+  "license": "MIT",
+  "main": "./script/index.js",
+  "module": "./esm/index.js",
   "exports": {
-    ".": "./src/index.ts"
+    ".": {
+      "import": "./esm/index.js",
+      "require": "./script/index.js"
+    }
   },
-  "files": [
-    "src"
-  ]
-}
+  "scripts": {},
+  "type": "module",
+  "dependencies": {},
+  "_generatedBy": "dnt@dev"
+}

package/script/agent.d.ts

@@ -0,0 +1,39 @@
+import type { ContentPart, Message, Provider, Tool, Usage } from './types.js';
+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/script/agent.js

@@ -0,0 +1,101 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createAgent = void 0;
+exports.run = run;
+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) }];
+    }
+};
+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 }];
+};
+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 };
+};
+exports.createAgent = createAgent;

package/script/index.d.ts

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

package/script/index.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.run = exports.createAgent = exports.text = exports.image = exports.audio = void 0;
+var types_js_1 = require("./types.js");
+Object.defineProperty(exports, "audio", { enumerable: true, get: function () { return types_js_1.audio; } });
+Object.defineProperty(exports, "image", { enumerable: true, get: function () { return types_js_1.image; } });
+Object.defineProperty(exports, "text", { enumerable: true, get: function () { return types_js_1.text; } });
+var agent_js_1 = require("./agent.js");
+Object.defineProperty(exports, "createAgent", { enumerable: true, get: function () { return agent_js_1.createAgent; } });
+Object.defineProperty(exports, "run", { enumerable: true, get: function () { return agent_js_1.run; } });

package/script/package.json

@@ -0,0 +1,3 @@
+{
+  "type": "commonjs"
+}

package/script/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/script/types.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.audio = exports.image = exports.text = void 0;
+const text = (value) => ({ type: 'text', text: value });
+exports.text = text;
+const image = (mime, data) => ({ type: 'image', mime, data });
+exports.image = image;
+const audio = (mime, data) => ({ type: 'audio', mime, data });
+exports.audio = audio;

package/README.md

@@ -1,110 +0,0 @@
-# mu-core
-
-The mu plugin SDK. Provides the agent loop, plugin registry, LLM types, and
-the multi-host primitives (channels, sessions, activity bus, providers).
-Provider implementations are separate packages — for OpenAI-compatible APIs,
-add `mu-openai-provider` and register its plugin alongside.
-
-## Install
-
-```bash
-npm install mu-core mu-openai-provider
-```
-
-## Usage
-
-```ts
-import { runAgent, PluginRegistry } from "mu-core";
-import type { ChatMessage, ProviderConfig } from "mu-core";
-import { createOpenAIProviderPlugin } from "mu-openai-provider";
-
-const config: ProviderConfig = {
-  baseUrl: "http://localhost:11434/v1",
-  maxTokens: 4096,
-  temperature: 0.7,
-  streamTimeoutMs: 30000,
-  // providerId defaults to 'openai' — register at least one provider
-  // implementation (e.g. via createOpenAIProviderPlugin) before running.
-};
-
-const registry = new PluginRegistry({ cwd: process.cwd(), config: {} });
-await registry.register(createOpenAIProviderPlugin());
-
-const messages: ChatMessage[] = [
-  { role: "user", content: "Hello" },
-];
-
-const controller = new AbortController();
-
-for await (const event of runAgent(messages, config, "qwen2.5", controller.signal, registry)) {
-  if (event.type === "content") process.stdout.write(event.text);
-}
-```
-
-For a higher-level API that owns conversation state, channel I/O, and
-multi-session lifecycle, see `startMu` and `Session` (`createSessionManager`).
-
-## Plugin System
-
-Plugins can provide tools, system prompts, lifecycle hooks, slash commands,
-custom agent loops, and side-channel registries (channels, providers,
-activity bus, agent sources).
-
-```ts
-import type { Plugin } from "mu-core";
-
-const myPlugin: Plugin = {
-  name: "my-plugin",
-  tools: [
-    {
-      definition: {
-        type: "function",
-        function: {
-          name: "hello",
-          description: "Say hello",
-          parameters: { type: "object", properties: {} },
-        },
-      },
-      execute: async () => "Hello, world!",
-    },
-  ],
-  hooks: {
-    beforeLlmCall: (messages, config) => messages,
-    afterLlmCall: (result) => result,
-    beforeToolExec: (toolCall) => toolCall,
-    afterToolExec: (toolCall, result) => result,
-  },
-};
-
-await registry.register(myPlugin);
-```
-
-Filesystem and shell tools live in `mu-coding` (`createCodingToolsPlugin`),
-not in mu-core — keeps the SDK host-agnostic.
-
-## API
-
-### Agent loop
-- `runAgent(messages, config, model, signal, registry)` — async generator yielding `AgentEvent` (`content`, `reasoning`, `messages`, `usage`, `turn_end`).
-- Provider resolution: looks up `config.providerId ?? 'openai'` in the registered `ProviderRegistry`. Throws if no provider is registered.
-
-### Sessions
-- `createSessionManager({ registry, config, model })` returns a `SessionManager`.
-- `session.runTurn({ userMessage, ... })` — appends, drains queue, runs agent loop, emits events.
-- `session.subscribe(listener)` — `messages_changed`, `stream_partial`, `stream_started`, `stream_ended`, `usage`, `error`.
-
-### Channels
-- `Channel` interface (`id`, `start`, `stop`) — input surfaces (TUI, Telegram, websocket).
-- `createChannelRegistry()` — host-managed registry; `startAll()` / `stopAll()` for lifecycle.
-
-### Providers
-- `ProviderAdapter` + `createProvider(adapter)` — build a `Provider` from raw HTTP semantics.
-- `readSSE`, `readNDJSON`, `fetchWithIdleTimeout` — transport primitives.
-- `ProviderRegistry` — host-managed; populated by provider plugins.
-
-### Host
-- `startMu(options)` — generic bootstrap: loads config, builds registries, activates plugins (config-listed via `options.resolvePlugin`, then code-passed), starts channels.
-
-## License
-
-MIT

package/src/activity.test.ts

@@ -1,44 +0,0 @@
-import { describe, expect, it } from 'bun:test';
-import { createActivityBus } from './activity';
-
-describe('ActivityBus', () => {
-  it('emits events to multiple subscribers', () => {
-    const bus = createActivityBus();
-    const a: string[] = [];
-    const b: string[] = [];
-    bus.subscribe((e) => a.push(e.summary));
-    bus.subscribe((e) => b.push(e.summary));
-    bus.emit('tool_start', 'bash', 'running git status');
-    expect(a).toEqual(['running git status']);
-    expect(b).toEqual(['running git status']);
-  });
-
-  it('unsubscribes', () => {
-    const bus = createActivityBus();
-    const seen: string[] = [];
-    const off = bus.subscribe((e) => seen.push(e.summary));
-    bus.emit('tool_start', 'bash', 'first');
-    off();
-    bus.emit('tool_start', 'bash', 'second');
-    expect(seen).toEqual(['first']);
-  });
-
-  it('subagent stream is independent', () => {
-    const bus = createActivityBus();
-    const sub: string[] = [];
-    bus.subscribeSubAgent((e) => sub.push(e.kind));
-    bus.emitSubAgent({ runId: 'r1', agentId: 'review', kind: 'invocation_start', ts: 1, data: {} });
-    expect(sub).toEqual(['invocation_start']);
-  });
-
-  it('throwing listener does not break the bus', () => {
-    const bus = createActivityBus();
-    bus.subscribe(() => {
-      throw new Error('boom');
-    });
-    const seen: string[] = [];
-    bus.subscribe((e) => seen.push(e.summary));
-    bus.emit('tool_end', 'bash', 'ok');
-    expect(seen).toEqual(['ok']);
-  });
-});