mu-core 0.16.1 → 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.16.1",
+  "version": "0.16.3",
   "description": "Standalone multimodal agentic loop: content, messages, tools, provider interface, createAgent",
-  "type": "module",
-  "main": "./src/index.ts",
-  "types": "./src/index.ts",
+  "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/src/agent.test.ts

@@ -1,45 +0,0 @@
-import { assertEquals } from '@std/assert';
-import { createAgent } from './agent';
-import { image } from './types';
-import type { ContentPart, Provider, Tool } from './types';
-
-const scripted = (turns: ContentPart[][]): Provider => {
-  let i = 0;
-  return {
-    async *stream() {
-      for (const event of turns[i++]) yield event;
-    },
-  };
-};
-
-Deno.test('loops on a tool_call and returns the final message', async () => {
-  const provider = scripted([
-    [{ type: 'tool_call', id: '1', name: 'snap', input: {} }],
-    [{ type: 'text', text: 'voici' }],
-  ]);
-
-  const snap: Tool = {
-    name: 'snap',
-    description: 'returns an image',
-    parameters: {},
-    run: async () => [image('image/png', new Uint8Array([1, 2, 3]))],
-  };
-
-  const agent = createAgent({ provider, model: 'mock', tools: [snap] });
-  const { message, messages } = await agent.run('photo ?');
-
-  assertEquals(message.content, [{ type: 'text', text: 'voici' }]);
-  const tool = messages.find((m) => m.role === 'user' && m.content[0]?.type === 'tool_result');
-  assertEquals(tool?.content[0], {
-    type: 'tool_result',
-    id: '1',
-    content: [{ type: 'image', mime: 'image/png', data: new Uint8Array([1, 2, 3]) }],
-  });
-});
-
-Deno.test('merges streamed text deltas', async () => {
-  const provider = scripted([[{ type: 'text', text: 'bon' }, { type: 'text', text: 'jour' }]]);
-  const agent = createAgent({ provider, model: 'mock' });
-  const { message } = await agent.run('salut');
-  assertEquals(message.content, [{ type: 'text', text: 'bonjour' }]);
-});

package/src/agent.ts

@@ -1,140 +0,0 @@
-import type { ContentPart, Message, Provider, Tool, Usage } from './types';
-
-type ToolCallPart = Extract<ContentPart, { type: 'tool_call' }>;
-
-export type LoopEvent =
-  | ContentPart
-  | { type: 'usage'; usage: Usage }
-  | { type: 'reasoning'; text: string }
-  | { type: 'message'; message: Message }
-  | { type: 'done'; messages: Message[] };
-
-const append = (parts: ContentPart[], part: ContentPart): void => {
-  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: Map<string, Tool>, call: ToolCallPart, signal?: AbortSignal): Promise<ContentPart[]> => {
-  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 interface RunOptions {
-  provider: Provider;
-  model: string;
-  messages: Message[];
-  tools?: Tool[];
-  signal?: AbortSignal;
-}
-
-export async function* run(opts: RunOptions): AsyncIterable<LoopEvent> {
-  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: ContentPart[] = [];
-    const calls: ToolCallPart[] = [];
-
-    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: Message = { role: 'assistant', content };
-    messages.push(message);
-    yield { type: 'message', message };
-
-    if (calls.length === 0) break;
-
-    const results: ContentPart[] = await Promise.all(
-      calls.map(async (call) => ({
-        type: 'tool_result' as const,
-        id: call.id,
-        content: await execute(registry, call, signal),
-      })),
-    );
-    const toolMessage: Message = { role: 'user', content: results };
-    messages.push(toolMessage);
-    yield { type: 'message', message: toolMessage };
-  }
-
-  yield { type: 'done', messages };
-}
-
-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>;
-}
-
-const isMessages = (input: ContentPart[] | Message[]): input is Message[] => input.length > 0 && 'role' in input[0];
-
-const toMessages = (input: Input): Message[] => {
-  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: AgentConfig): Agent => {
-  const tools = config.tools ?? [];
-
-  const build = (input: Input): Message[] => {
-    const messages = toMessages(input);
-    if (!config.system) return messages;
-    return [{ role: 'system', content: [{ type: 'text', text: config.system }] }, ...messages];
-  };
-
-  const stream = (input: Input): AsyncIterable<LoopEvent> =>
-    run({ provider: config.provider, model: config.model, tools, messages: build(input), signal: config.signal });
-
-  const runToEnd = async (input: Input): Promise<AgentResult> => {
-    let message: Message = { role: 'assistant', content: [] };
-    let messages: Message[] = [];
-    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/src/index.ts

@@ -1,5 +0,0 @@
-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/src/types.ts

@@ -1,37 +0,0 @@
-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 const text = (value: string): ContentPart => ({ type: 'text', text: value });
-export const image = (mime: string, data: Uint8Array): ContentPart => ({ type: 'image', mime, data });
-export const audio = (mime: string, data: Uint8Array): ContentPart => ({ type: 'audio', mime, data });
-
-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>;
-}