mu-harness 0.16.3

package/script/harness/npm/src/plugin/import-ts.js

@@ -0,0 +1,122 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.importModule = void 0;
+const wasm_typescript_1 = require("@swc/wasm-typescript");
+const promises_1 = require("node:fs/promises");
+const node_os_1 = require("node:os");
+const node_path_1 = require("node:path");
+const node_url_1 = require("node:url");
+const TS_EXT = /\.(?:[cm]?ts|tsx)$/;
+const REMOTE = /^(?:npm|jsr|node|bun|http|https|data|file):/;
+const SPECIFIER = /(?:\bfrom|\bimport|\bexport\s*\*\s*from|\bimport)\s*\(?\s*(['"])(\.{1,2}\/[^'"]+)\1/g;
+const isLocalTs = (spec) => TS_EXT.test(spec) && !REMOTE.test(spec);
+const toAbs = (spec) => {
+    if (spec.startsWith('file://'))
+        return (0, node_path_1.resolve)(decodeURIComponent(new URL(spec).pathname));
+    return (0, node_path_1.isAbsolute)(spec) ? spec : (0, node_path_1.resolve)(spec);
+};
+const resolveRelative = async (from, spec) => {
+    const base = (0, node_path_1.resolve)((0, node_path_1.dirname)(from), spec);
+    const candidates = TS_EXT.test(base) ? [base] : [
+        base,
+        `${base}.ts`,
+        `${base}.tsx`,
+        `${base}.mts`,
+        `${base}.cts`,
+        (0, node_path_1.join)(base, 'index.ts'),
+        (0, node_path_1.join)(base, 'index.tsx'),
+    ];
+    for (const candidate of candidates) {
+        try {
+            await (0, promises_1.readFile)(candidate);
+            return candidate;
+        }
+        catch {
+            continue;
+        }
+    }
+    throw new Error(`cannot resolve "${spec}" from ${from}`);
+};
+const collect = async (entry) => {
+    const sources = new Map();
+    const pending = [entry];
+    while (pending.length > 0) {
+        const file = pending.pop();
+        if (sources.has(file))
+            continue;
+        const source = await (0, promises_1.readFile)(file, 'utf-8');
+        sources.set(file, source);
+        for (const match of source.matchAll(SPECIFIER)) {
+            pending.push(await resolveRelative(file, match[2]));
+        }
+    }
+    return sources;
+};
+const commonBase = (files) => {
+    if (files.length === 1)
+        return (0, node_path_1.dirname)(files[0]);
+    const split = files.map((f) => (0, node_path_1.dirname)(f).split(node_path_1.sep));
+    const first = split[0];
+    let i = 0;
+    while (i < first.length && split.every((parts) => parts[i] === first[i]))
+        i++;
+    return first.slice(0, i).join(node_path_1.sep) || node_path_1.sep;
+};
+const outName = (path) => path.replace(TS_EXT, '.mjs');
+const rewriteSpecifiers = (code) => code.replace(SPECIFIER, (whole, quote, spec) => whole.replace(`${quote}${spec}${quote}`, `${quote}${outName(spec)}${quote}`));
+const transpileTree = async (entry) => {
+    const sources = await collect(entry);
+    if (sources.size === 1) {
+        const { code } = (0, wasm_typescript_1.transformSync)(sources.get(entry), { mode: 'transform', module: true });
+        return `data:text/javascript;base64,${btoa(unescape(encodeURIComponent(code)))}`;
+    }
+    const base = commonBase([...sources.keys()]);
+    const outDir = await (0, promises_1.mkdtemp)((0, node_path_1.join)((0, node_os_1.tmpdir)(), 'mu-plugin-'));
+    for (const [file, source] of sources) {
+        const { code } = (0, wasm_typescript_1.transformSync)(source, { mode: 'transform', module: true });
+        const out = (0, node_path_1.join)(outDir, outName((0, node_path_1.relative)(base, file)));
+        await (0, promises_1.mkdir)((0, node_path_1.dirname)(out), { recursive: true });
+        await (0, promises_1.writeFile)(out, rewriteSpecifiers(code), 'utf-8');
+    }
+    return (0, node_url_1.pathToFileURL)((0, node_path_1.join)(outDir, outName((0, node_path_1.relative)(base, entry)))).href;
+};
+const importModule = async (spec) => {
+    if (!isLocalTs(spec))
+        return (await Promise.resolve(`${spec}`).then(s => __importStar(require(s))));
+    const url = await transpileTree(toAbs(spec));
+    return (await Promise.resolve(`${url}`).then(s => __importStar(require(s))));
+};
+exports.importModule = importModule;

package/script/harness/npm/src/plugin/index.d.ts

@@ -0,0 +1,5 @@
+export type { Plugin } from './types.js';
+export { definePlugin } from './define.js';
+export { resolve, type Resolved, type ResolveInput } from './resolve.js';
+export { createPluginStore, type PluginStore } from './store.js';
+export { importModule } from './import-ts.js';

package/script/harness/npm/src/plugin/index.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.importModule = exports.createPluginStore = exports.resolve = exports.definePlugin = void 0;
+var define_js_1 = require("./define.js");
+Object.defineProperty(exports, "definePlugin", { enumerable: true, get: function () { return define_js_1.definePlugin; } });
+var resolve_js_1 = require("./resolve.js");
+Object.defineProperty(exports, "resolve", { enumerable: true, get: function () { return resolve_js_1.resolve; } });
+var store_js_1 = require("./store.js");
+Object.defineProperty(exports, "createPluginStore", { enumerable: true, get: function () { return store_js_1.createPluginStore; } });
+var import_ts_js_1 = require("./import-ts.js");
+Object.defineProperty(exports, "importModule", { enumerable: true, get: function () { return import_ts_js_1.importModule; } });

package/script/harness/npm/src/plugin/resolve.d.ts

@@ -0,0 +1,13 @@
+import type { Tool } from 'mu-core';
+import { type AgentSessionHooks } from '../hooks/index.js';
+import type { Plugin } from './types.js';
+export interface Resolved {
+    tools: Tool[];
+    hooks: AgentSessionHooks;
+}
+export interface ResolveInput {
+    tools?: Tool[];
+    hooks?: AgentSessionHooks;
+    plugins?: Plugin[];
+}
+export declare const resolve: (config: ResolveInput) => Resolved;

package/script/harness/npm/src/plugin/resolve.js

@@ -0,0 +1,21 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.resolve = void 0;
+const index_js_1 = require("../hooks/index.js");
+const resolve = (config) => {
+    const plugins = config.plugins ?? [];
+    return {
+        tools: dedupeTools([...plugins.flatMap((p) => p.tools ?? []), ...(config.tools ?? [])]),
+        hooks: (0, index_js_1.mergeHooks)([...plugins.map((p) => p.hooks), config.hooks]),
+    };
+};
+exports.resolve = resolve;
+const dedupeTools = (tools) => {
+    const seen = new Set();
+    for (const tool of tools) {
+        if (seen.has(tool.name))
+            throw new Error(`AgentSession: duplicate tool name "${tool.name}"`);
+        seen.add(tool.name);
+    }
+    return tools;
+};

package/script/harness/npm/src/plugin/store.d.ts

@@ -0,0 +1,8 @@
+export interface PluginStore {
+    write(name: string, content: string): Promise<string>;
+    list(): Promise<string[]>;
+    remove(name: string): Promise<void>;
+}
+export declare const createPluginStore: ({ dir }: {
+    dir: string;
+}) => PluginStore;

package/script/harness/npm/src/plugin/store.js

@@ -0,0 +1,30 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createPluginStore = void 0;
+const promises_1 = require("node:fs/promises");
+const node_path_1 = require("node:path");
+const fileFor = (dir, name) => {
+    if (name.includes('/') || name.includes('..') || name === '')
+        throw new Error(`PluginStore: invalid name "${name}"`);
+    return (0, node_path_1.join)(dir, name);
+};
+const createPluginStore = ({ dir }) => ({
+    write: async (name, content) => {
+        const path = fileFor(dir, name);
+        await (0, promises_1.mkdir)(dir, { recursive: true });
+        await (0, promises_1.writeFile)(path, content, 'utf-8');
+        return path;
+    },
+    list: async () => {
+        try {
+            return await (0, promises_1.readdir)(dir);
+        }
+        catch {
+            return [];
+        }
+    },
+    remove: async (name) => {
+        await (0, promises_1.rm)(fileFor(dir, name), { force: true });
+    },
+});
+exports.createPluginStore = createPluginStore;

package/script/harness/npm/src/plugin/types.d.ts

@@ -0,0 +1,11 @@
+import type { Tool } from 'mu-core';
+import type { Agent } from '../agents/index.js';
+import type { AgentSessionHooks } from '../hooks/index.js';
+import type { Skill } from '../skills/index.js';
+export interface Plugin {
+    name: string;
+    tools?: Tool[];
+    hooks?: AgentSessionHooks;
+    agents?: Agent[];
+    skills?: Skill[];
+}

package/script/harness/npm/src/plugin/types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/script/harness/npm/src/scheduler/command.d.ts

@@ -0,0 +1,3 @@
+import type { TaskStore } from './engine/index.js';
+import type { Command } from '../commands/index.js';
+export declare const createTasksCommand: (tasks: TaskStore) => Command;

package/script/harness/npm/src/scheduler/command.js

@@ -0,0 +1,23 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createTasksCommand = void 0;
+const createTasksCommand = (tasks) => ({
+    name: 'tasks',
+    description: 'List scheduled tasks',
+    run: async () => {
+        const list = await tasks.list();
+        if (list.length === 0)
+            return { ok: true, output: 'No tasks scheduled.' };
+        const describe = (t) => {
+            const when = t.schedule.kind === 'cron'
+                ? t.schedule.expr
+                : t.schedule.kind === 'interval'
+                    ? `every ${t.schedule.ms}ms`
+                    : 'once';
+            const state = t.enabled ? when : `${when} (disabled)`;
+            return `- ${t.id} — ${t.skill} [${state}]`;
+        };
+        return { ok: true, output: list.map(describe).join('\n') };
+    },
+});
+exports.createTasksCommand = createTasksCommand;

package/script/harness/npm/src/scheduler/engine/index.d.ts

@@ -0,0 +1,3 @@
+export type { Schedule, Task, TaskInput, TaskResult, TaskRunner, TaskStore } from './types.js';
+export { createTaskStore } from './store.js';
+export { createScheduler, type Scheduler } from './scheduler.js';

package/script/harness/npm/src/scheduler/engine/index.js

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createScheduler = exports.createTaskStore = void 0;
+var store_js_1 = require("./store.js");
+Object.defineProperty(exports, "createTaskStore", { enumerable: true, get: function () { return store_js_1.createTaskStore; } });
+var scheduler_js_1 = require("./scheduler.js");
+Object.defineProperty(exports, "createScheduler", { enumerable: true, get: function () { return scheduler_js_1.createScheduler; } });

package/script/harness/npm/src/scheduler/engine/scheduler.d.ts

@@ -0,0 +1,12 @@
+import type { Task, TaskRunner, TaskStore } from './types.js';
+export interface Scheduler {
+    start(): Promise<void>;
+    stop(): void;
+    reload(): Promise<void>;
+    runNow(id: string): Promise<void>;
+}
+export declare const createScheduler: (deps: {
+    store: TaskStore;
+    run: TaskRunner;
+    onError?: (error: unknown, task: Task) => void;
+}) => Scheduler;

package/script/harness/npm/src/scheduler/engine/scheduler.js

@@ -0,0 +1,69 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createScheduler = void 0;
+const croner_1 = require("croner");
+const createScheduler = (deps) => {
+    const { store, run } = deps;
+    const crons = new Map();
+    const timers = new Map();
+    let started = false;
+    const fire = async (id) => {
+        const task = await store.get(id);
+        if (!task || !task.enabled)
+            return;
+        try {
+            const result = await run(task);
+            await store.update(id, { lastRun: Date.now(), lastResult: result });
+        }
+        catch (error) {
+            deps.onError?.(error, task);
+            const message = error instanceof Error ? error.message : String(error);
+            await store.update(id, { lastRun: Date.now(), lastResult: { ok: false, error: message } });
+        }
+        if (task.schedule.kind === 'once')
+            await store.update(id, { enabled: false });
+    };
+    const clear = () => {
+        for (const cron of crons.values())
+            cron.stop();
+        for (const timer of timers.values())
+            clearTimeout(timer);
+        crons.clear();
+        timers.clear();
+    };
+    const schedule = (task) => {
+        if (!task.enabled)
+            return;
+        const s = task.schedule;
+        if (s.kind === 'cron') {
+            crons.set(task.id, new croner_1.Cron(s.expr, () => void fire(task.id)));
+        }
+        else if (s.kind === 'interval') {
+            timers.set(task.id, setInterval(() => void fire(task.id), s.ms));
+        }
+        else {
+            const delay = s.at ? Math.max(0, s.at - Date.now()) : 0;
+            timers.set(task.id, setTimeout(() => void fire(task.id), delay));
+        }
+    };
+    const reload = async () => {
+        clear();
+        if (!started)
+            return;
+        for (const task of await store.list())
+            schedule(task);
+    };
+    return {
+        start: async () => {
+            started = true;
+            await reload();
+        },
+        stop: () => {
+            started = false;
+            clear();
+        },
+        reload,
+        runNow: (id) => fire(id),
+    };
+};
+exports.createScheduler = createScheduler;

package/script/harness/npm/src/scheduler/engine/store.d.ts

@@ -0,0 +1,4 @@
+import type { TaskStore } from './types.js';
+export declare const createTaskStore: (options: {
+    dir: string;
+}) => TaskStore;

package/script/harness/npm/src/scheduler/engine/store.js

@@ -0,0 +1,59 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createTaskStore = void 0;
+const promises_1 = require("node:fs/promises");
+const node_path_1 = require("node:path");
+const createTaskStore = (options) => {
+    const { dir } = options;
+    const file = (id) => (0, node_path_1.join)(dir, `${id}.json`);
+    const read = async (id) => {
+        try {
+            return JSON.parse(await (0, promises_1.readFile)(file(id), 'utf-8'));
+        }
+        catch {
+            return undefined;
+        }
+    };
+    const write = async (task) => {
+        await (0, promises_1.mkdir)(dir, { recursive: true });
+        await (0, promises_1.writeFile)(file(task.id), JSON.stringify(task, null, 2), 'utf-8');
+    };
+    return {
+        list: async () => {
+            let entries;
+            try {
+                entries = await (0, promises_1.readdir)(dir);
+            }
+            catch {
+                return [];
+            }
+            const tasks = [];
+            for (const name of entries.sort()) {
+                if (!name.endsWith('.json'))
+                    continue;
+                const task = await read(name.slice(0, -'.json'.length));
+                if (task)
+                    tasks.push(task);
+            }
+            return tasks;
+        },
+        get: read,
+        create: async (input) => {
+            const task = { ...input, id: crypto.randomUUID(), enabled: input.enabled ?? true, createdAt: Date.now() };
+            await write(task);
+            return task;
+        },
+        update: async (id, patch) => {
+            const task = await read(id);
+            if (!task)
+                return undefined;
+            const next = { ...task, ...patch, id: task.id };
+            await write(next);
+            return next;
+        },
+        remove: async (id) => {
+            await (0, promises_1.rm)(file(id), { force: true });
+        },
+    };
+};
+exports.createTaskStore = createTaskStore;

package/script/harness/npm/src/scheduler/engine/types.d.ts

@@ -0,0 +1,37 @@
+export type Schedule = {
+    kind: 'cron';
+    expr: string;
+} | {
+    kind: 'interval';
+    ms: number;
+} | {
+    kind: 'once';
+    at?: number;
+};
+export interface TaskResult {
+    ok: boolean;
+    output?: string;
+    error?: string;
+}
+export interface Task {
+    id: string;
+    skill: string;
+    prompt: string;
+    agent?: string;
+    schedule: Schedule;
+    enabled: boolean;
+    createdAt: number;
+    lastRun?: number;
+    lastResult?: TaskResult;
+}
+export type TaskInput = Omit<Task, 'id' | 'enabled' | 'createdAt' | 'lastRun' | 'lastResult'> & {
+    enabled?: boolean;
+};
+export type TaskRunner = (task: Task) => Promise<TaskResult>;
+export interface TaskStore {
+    list(): Promise<Task[]>;
+    get(id: string): Promise<Task | undefined>;
+    create(input: TaskInput): Promise<Task>;
+    update(id: string, patch: Partial<Task>): Promise<Task | undefined>;
+    remove(id: string): Promise<void>;
+}

package/script/harness/npm/src/scheduler/engine/types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/script/harness/npm/src/scheduler/index.d.ts

@@ -0,0 +1,4 @@
+export type { Schedule, Task, TaskInput, TaskResult, TaskRunner, TaskStore } from './engine/index.js';
+export { createScheduler, createTaskStore, type Scheduler } from './engine/index.js';
+export { createScheduleTaskTool } from './tool.js';
+export { createTasksCommand } from './command.js';

package/script/harness/npm/src/scheduler/index.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createTasksCommand = exports.createScheduleTaskTool = exports.createTaskStore = exports.createScheduler = void 0;
+var index_js_1 = require("./engine/index.js");
+Object.defineProperty(exports, "createScheduler", { enumerable: true, get: function () { return index_js_1.createScheduler; } });
+Object.defineProperty(exports, "createTaskStore", { enumerable: true, get: function () { return index_js_1.createTaskStore; } });
+var tool_js_1 = require("./tool.js");
+Object.defineProperty(exports, "createScheduleTaskTool", { enumerable: true, get: function () { return tool_js_1.createScheduleTaskTool; } });
+var command_js_1 = require("./command.js");
+Object.defineProperty(exports, "createTasksCommand", { enumerable: true, get: function () { return command_js_1.createTasksCommand; } });

package/script/harness/npm/src/scheduler/tool.d.ts

@@ -0,0 +1,8 @@
+import type { Tool } from 'mu-core';
+import type { TaskStore } from './engine/index.js';
+import type { SkillRegistry } from '../skills/index.js';
+export declare const createScheduleTaskTool: (deps: {
+    store: TaskStore;
+    skills: SkillRegistry;
+    onChange?: () => void | Promise<void>;
+}) => Tool;

package/script/harness/npm/src/scheduler/tool.js

@@ -0,0 +1,53 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createScheduleTaskTool = void 0;
+const toSchedule = (raw) => {
+    const { cron, everyMs, at } = (raw ?? {});
+    if (typeof cron === 'string' && cron.trim())
+        return { kind: 'cron', expr: cron.trim() };
+    if (typeof everyMs === 'number' && everyMs > 0)
+        return { kind: 'interval', ms: everyMs };
+    if (typeof at === 'number')
+        return { kind: 'once', at };
+    return undefined;
+};
+const createScheduleTaskTool = (deps) => ({
+    name: 'schedule_task',
+    description: 'Persist a recurring (cron / heartbeat) or one-shot task that runs a sub-agent under a skill on a given prompt.',
+    prompt: 'Use `schedule_task` to register work that should run later or on a schedule: a `cron` expression, an `everyMs` heartbeat, or a one-shot `at` timestamp. It invokes a skill on a prompt, like `run_skill`.',
+    parameters: {
+        type: 'object',
+        properties: {
+            skill: { type: 'string', description: 'Skill name to run.' },
+            prompt: { type: 'string', description: 'The task prompt handed to the agent on each run.' },
+            agent: { type: 'string', description: 'Agent persona to run the skill as (defines its tools).' },
+            schedule: {
+                type: 'object',
+                description: 'Exactly one of: cron, everyMs, at.',
+                properties: {
+                    cron: { type: 'string', description: 'Cron expression, e.g. "0 9 * * *".' },
+                    everyMs: { type: 'number', description: 'Heartbeat interval in milliseconds.' },
+                    at: { type: 'number', description: 'One-shot epoch-ms timestamp (omit to run as soon as scheduled).' },
+                },
+                additionalProperties: false,
+            },
+        },
+        required: ['skill', 'prompt', 'agent', 'schedule'],
+        additionalProperties: false,
+    },
+    run: async (input) => {
+        const { skill, prompt, agent, schedule } = (input ?? {});
+        if (!skill || !prompt || !agent) {
+            return [{ type: 'text', text: 'Error: schedule_task requires `skill`, `prompt`, and `agent`.' }];
+        }
+        if (!deps.skills.get(skill))
+            return [{ type: 'text', text: `Error: unknown skill "${skill}".` }];
+        const parsed = toSchedule(schedule);
+        if (!parsed)
+            return [{ type: 'text', text: 'Error: schedule needs one of `cron`, `everyMs`, or `at`.' }];
+        const task = await deps.store.create({ skill, prompt, agent, schedule: parsed });
+        await deps.onChange?.();
+        return [{ type: 'text', text: `Scheduled task ${task.id} (${parsed.kind}) running skill "${skill}".` }];
+    },
+});
+exports.createScheduleTaskTool = createScheduleTaskTool;

package/script/harness/npm/src/session/agent-session.d.ts

@@ -0,0 +1,15 @@
+import { type Message, type Provider, type Tool } from 'mu-core';
+import { type AgentSessionHooks } from '../hooks/index.js';
+import { type Plugin } from '../plugin/index.js';
+import type { AgentSession } from './types.js';
+export interface AgentSessionConfig {
+    provider: Provider;
+    model: string;
+    tools?: Tool[];
+    hooks?: AgentSessionHooks;
+    plugins?: Plugin[];
+    system?: string;
+    id?: string;
+    messages?: Message[];
+}
+export declare const createAgentSession: (config: AgentSessionConfig) => AgentSession;

package/script/harness/npm/src/session/agent-session.js

@@ -0,0 +1,86 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createAgentSession = void 0;
+const mu_core_1 = require("mu-core");
+const index_js_1 = require("../common/index.js");
+const index_js_2 = require("../hooks/index.js");
+const index_js_3 = require("../plugin/index.js");
+const toMessage = (input) => ({
+    role: 'user',
+    content: typeof input === 'string' ? [{ type: 'text', text: input }] : input,
+});
+const systemMessage = (text) => ({ role: 'system', content: [{ type: 'text', text }] });
+const textOf = (message) => message.content.map((part) => (part.type === 'text' ? part.text : '')).join('');
+const createAgentSession = (config) => {
+    const { provider } = config;
+    const { tools, hooks } = (0, index_js_3.resolve)(config);
+    const decorated = tools.map((tool) => (0, index_js_2.withHooks)(tool, hooks));
+    const id = config.id ?? crypto.randomUUID();
+    const messages = config.messages
+        ? [...config.messages]
+        : config.system
+            ? [{ role: 'system', content: [{ type: 'text', text: config.system }] }]
+            : [];
+    const emitter = (0, index_js_1.createEmitter)();
+    let started = false;
+    let running = false;
+    let controller;
+    const send = async (input) => {
+        if (running)
+            throw new Error('AgentSession: busy (a turn is already running)');
+        running = true;
+        const ac = new AbortController();
+        controller = ac;
+        try {
+            if (!started) {
+                started = true;
+                await hooks.sessionStart?.();
+            }
+            const message = toMessage(input);
+            messages.push(message);
+            emitter.emit({ type: 'turn_start', input: message });
+            const hasSystem = messages[0]?.role === 'system';
+            const system = hasSystem ? textOf(messages[0]) : '';
+            const prepared = await hooks.prepareRequest?.({ system, tools: decorated });
+            const callTools = prepared?.tools ?? decorated;
+            const baseSystem = prepared?.system ?? system;
+            const toolBlock = callTools.map((tool) => tool.prompt?.trim()).filter(Boolean).join('\n');
+            const effectiveSystem = [baseSystem, toolBlock].filter(Boolean).join('\n\n');
+            const body = hasSystem ? messages.slice(1) : messages;
+            const callMessages = effectiveSystem ? [systemMessage(effectiveSystem), ...body] : body;
+            const events = (0, mu_core_1.run)({
+                provider,
+                model: config.model,
+                tools: callTools,
+                messages: callMessages,
+                signal: ac.signal,
+            });
+            for await (const event of events) {
+                if (event.type === 'message')
+                    messages.push(event.message);
+                emitter.emit(event);
+            }
+            emitter.emit({ type: 'turn_end' });
+        }
+        catch (error) {
+            if (ac.signal.aborted)
+                emitter.emit({ type: 'turn_end' });
+            else
+                emitter.emit({ type: 'error', error });
+        }
+        finally {
+            running = false;
+            controller = undefined;
+        }
+    };
+    return {
+        id,
+        get messages() {
+            return messages;
+        },
+        send,
+        abort: () => controller?.abort(),
+        subscribe: emitter.subscribe,
+    };
+};
+exports.createAgentSession = createAgentSession;