mu-harness 0.16.3

package/esm/tui/src/utils.js

@@ -0,0 +1,292 @@
+// deno-lint-ignore no-control-regex
+const ANSI_RE = /\u001B\[[0-?]*[ -/]*[@-~]|\u001B\][^\u0007]*(?:\u0007|\u001B\\)/g;
+// deno-lint-ignore no-control-regex
+const ANSI_TOKEN_RE = /\u001B\[[0-?]*[ -/]*[@-~]|\u001B\][^\u0007]*(?:\u0007|\u001B\\)/gy;
+export function stripAnsi(s) {
+    return s.replace(ANSI_RE, '');
+}
+export function visibleWidth(s) {
+    const stripped = stripAnsi(s);
+    let w = 0;
+    for (let i = 0; i < stripped.length;) {
+        const code = stripped.codePointAt(i) ?? 0;
+        w += charWidth(code);
+        i += code > 0xffff ? 2 : 1;
+    }
+    return w;
+}
+export function charWidth(code) {
+    if (code === 0 || code < 0x20 || code === 0x7f)
+        return 0;
+    if ((code >= 0x1100 && code <= 0x115f) ||
+        (code >= 0x231a && code <= 0x231b) ||
+        (code >= 0x2329 && code <= 0x232a) ||
+        (code >= 0x23e9 && code <= 0x23f3) ||
+        (code >= 0x23f8 && code <= 0x23fa) ||
+        (code >= 0x25fd && code <= 0x25fe) ||
+        (code >= 0x2614 && code <= 0x2615) ||
+        (code >= 0x2648 && code <= 0x2653) ||
+        code === 0x267f ||
+        code === 0x2693 ||
+        code === 0x26a1 ||
+        (code >= 0x26aa && code <= 0x26ab) ||
+        (code >= 0x26bd && code <= 0x26be) ||
+        (code >= 0x26c4 && code <= 0x26c5) ||
+        code === 0x26ce ||
+        code === 0x26d4 ||
+        code === 0x26ea ||
+        (code >= 0x26f2 && code <= 0x26f3) ||
+        code === 0x26f5 ||
+        code === 0x26fa ||
+        code === 0x26fd ||
+        code === 0x2702 ||
+        code === 0x2705 ||
+        (code >= 0x2708 && code <= 0x270d) ||
+        code === 0x270f ||
+        code === 0x2712 ||
+        code === 0x2714 ||
+        code === 0x2716 ||
+        code === 0x271d ||
+        code === 0x2721 ||
+        code === 0x2728 ||
+        (code >= 0x2733 && code <= 0x2734) ||
+        code === 0x2744 ||
+        code === 0x2747 ||
+        code === 0x274c ||
+        code === 0x274e ||
+        (code >= 0x2753 && code <= 0x2755) ||
+        code === 0x2757 ||
+        (code >= 0x2795 && code <= 0x2797) ||
+        code === 0x27a1 ||
+        code === 0x27b0 ||
+        code === 0x27bf ||
+        (code >= 0x2934 && code <= 0x2935) ||
+        (code >= 0x2b05 && code <= 0x2b07) ||
+        (code >= 0x2b1b && code <= 0x2b1c) ||
+        code === 0x2b50 ||
+        code === 0x2b55 ||
+        (code >= 0x2e80 && code <= 0x303e) ||
+        (code >= 0x3041 && code <= 0x33ff) ||
+        (code >= 0x3400 && code <= 0x4dbf) ||
+        (code >= 0x4e00 && code <= 0x9fff) ||
+        (code >= 0xa000 && code <= 0xa4cf) ||
+        (code >= 0xac00 && code <= 0xd7a3) ||
+        (code >= 0xf900 && code <= 0xfaff) ||
+        (code >= 0xfe30 && code <= 0xfe4f) ||
+        (code >= 0xff00 && code <= 0xff60) ||
+        (code >= 0xffe0 && code <= 0xffe6) ||
+        (code >= 0x1f004 && code <= 0x1f004) ||
+        (code >= 0x1f0cf && code <= 0x1f0cf) ||
+        (code >= 0x1f170 && code <= 0x1f171) ||
+        code === 0x1f17e ||
+        code === 0x1f17f ||
+        code === 0x1f18e ||
+        (code >= 0x1f191 && code <= 0x1f19a) ||
+        (code >= 0x1f1e0 && code <= 0x1f1ff) ||
+        (code >= 0x1f200 && code <= 0x1f202) ||
+        code === 0x1f21a ||
+        code === 0x1f22f ||
+        (code >= 0x1f232 && code <= 0x1f23a) ||
+        (code >= 0x1f250 && code <= 0x1f251) ||
+        (code >= 0x1f300 && code <= 0x1f321) ||
+        (code >= 0x1f324 && code <= 0x1f393) ||
+        (code >= 0x1f396 && code <= 0x1f397) ||
+        (code >= 0x1f399 && code <= 0x1f39b) ||
+        (code >= 0x1f39e && code <= 0x1f3f0) ||
+        (code >= 0x1f3f3 && code <= 0x1f3f5) ||
+        (code >= 0x1f3f7 && code <= 0x1f4fd) ||
+        (code >= 0x1f4ff && code <= 0x1f53d) ||
+        (code >= 0x1f549 && code <= 0x1f54e) ||
+        (code >= 0x1f550 && code <= 0x1f567) ||
+        (code >= 0x1f56f && code <= 0x1f570) ||
+        (code >= 0x1f573 && code <= 0x1f57a) ||
+        code === 0x1f587 ||
+        (code >= 0x1f58a && code <= 0x1f58d) ||
+        code === 0x1f590 ||
+        (code >= 0x1f595 && code <= 0x1f596) ||
+        code === 0x1f5a4 ||
+        (code >= 0x1f5a5 && code <= 0x1f5a8) ||
+        (code >= 0x1f5b1 && code <= 0x1f5b2) ||
+        code === 0x1f5bc ||
+        (code >= 0x1f5c2 && code <= 0x1f5c4) ||
+        (code >= 0x1f5d1 && code <= 0x1f5d3) ||
+        (code >= 0x1f5dc && code <= 0x1f5de) ||
+        code === 0x1f5e1 ||
+        code === 0x1f5e3 ||
+        code === 0x1f5e8 ||
+        code === 0x1f5ef ||
+        code === 0x1f5f3 ||
+        (code >= 0x1f5fa && code <= 0x1f64f) ||
+        (code >= 0x1f680 && code <= 0x1f6c5) ||
+        (code >= 0x1f6cb && code <= 0x1f6d2) ||
+        (code >= 0x1f6d5 && code <= 0x1f6d7) ||
+        (code >= 0x1f6e0 && code <= 0x1f6e5) ||
+        code === 0x1f6e9 ||
+        (code >= 0x1f6eb && code <= 0x1f6ec) ||
+        code === 0x1f6f0 ||
+        (code >= 0x1f6f3 && code <= 0x1f6fc) ||
+        (code >= 0x1f7e0 && code <= 0x1f7eb) ||
+        (code >= 0x1f90c && code <= 0x1f93a) ||
+        (code >= 0x1f93c && code <= 0x1f945) ||
+        (code >= 0x1f947 && code <= 0x1f9ff) ||
+        (code >= 0x1fa00 && code <= 0x1fa53) ||
+        (code >= 0x1fa60 && code <= 0x1fa6d) ||
+        (code >= 0x1fa70 && code <= 0x1fa7c) ||
+        (code >= 0x1fa80 && code <= 0x1fa88) ||
+        (code >= 0x1fa90 && code <= 0x1fabd) ||
+        (code >= 0x1fabf && code <= 0x1fac5) ||
+        (code >= 0x1face && code <= 0x1fadb) ||
+        (code >= 0x1fae0 && code <= 0x1fae8) ||
+        (code >= 0x1faf0 && code <= 0x1faf8)) {
+        return 2;
+    }
+    return 1;
+}
+export function truncateToWidth(s, width, ellipsis = '\u2026') {
+    if (visibleWidth(s) <= width)
+        return s;
+    const ellipsisWidth = visibleWidth(ellipsis);
+    let result = '';
+    let currentWidth = 0;
+    const targetWidth = Math.max(0, width - ellipsisWidth);
+    for (const token of tokenizeAnsi(s)) {
+        if (token.ansi) {
+            result += token.value;
+            continue;
+        }
+        for (const ch of token.value) {
+            const code = ch.codePointAt(0) ?? 0;
+            const chWidth = charWidth(code);
+            if (currentWidth + chWidth > targetWidth) {
+                return result + ellipsis + extractTrailingAnsi(s);
+            }
+            result += ch;
+            currentWidth += chWidth;
+        }
+    }
+    return result + ellipsis + extractTrailingAnsi(s);
+}
+export function wrapText(text, width) {
+    if (width <= 0 || !text)
+        return [''];
+    const out = [];
+    for (const segment of text.split('\n')) {
+        const wrapped = wrapSegment(segment, width);
+        out.push(...wrapped);
+    }
+    return out.length === 0 ? [''] : out;
+}
+function pushLine(state) {
+    state.lines.push(state.current);
+    state.current = '';
+    state.col = 0;
+}
+function wrapSegment(segment, width) {
+    if (segment.length === 0)
+        return [''];
+    const tokens = segment.split(/(\s+)/);
+    const state = { lines: [], current: '', col: 0 };
+    for (const tok of tokens) {
+        if (tok.length === 0)
+            continue;
+        const w = visibleWidth(tok);
+        if (w === 0)
+            continue;
+        if (/^\s+$/.test(tok)) {
+            if (state.col === 0) {
+                state.current += tok;
+                state.col += w;
+            }
+            else if (state.col + w <= width) {
+                state.current += tok;
+                state.col += w;
+            }
+            else {
+                pushLine(state);
+            }
+        }
+        else if (w > width) {
+            if (state.col > 0)
+                pushLine(state);
+            let j = 0;
+            let buf = '';
+            let bufW = 0;
+            while (j < tok.length) {
+                const code = tok.codePointAt(j) ?? 0;
+                const chW = charWidth(code);
+                const chStr = code > 0xffff ? tok.slice(j, j + 2) : tok.slice(j, j + 1);
+                if (bufW + chW > width) {
+                    state.lines.push(buf);
+                    buf = chStr;
+                    bufW = chW;
+                }
+                else {
+                    buf += chStr;
+                    bufW += chW;
+                }
+                j += code > 0xffff ? 2 : 1;
+            }
+            state.current = buf;
+            state.col = bufW;
+        }
+        else if (state.col + w > width) {
+            pushLine(state);
+            state.current = tok;
+            state.col = w;
+        }
+        else {
+            state.current += tok;
+            state.col += w;
+        }
+    }
+    state.lines.push(state.current);
+    return state.lines;
+}
+export function sliceByColumn(s, start, end, strict = false) {
+    let col = 0;
+    let result = '';
+    for (const token of tokenizeAnsi(s)) {
+        if (token.ansi) {
+            result += token.value;
+            continue;
+        }
+        for (const ch of token.value) {
+            const code = ch.codePointAt(0) ?? 0;
+            const chWidth = charWidth(code);
+            const nextCol = col + chWidth;
+            if (nextCol > start) {
+                if (col >= end)
+                    return result + extractTrailingAnsi(s);
+                if (col >= start) {
+                    if (!strict || nextCol <= end)
+                        result += ch;
+                }
+            }
+            col = nextCol;
+        }
+    }
+    return result + extractTrailingAnsi(s);
+}
+function tokenizeAnsi(s) {
+    const tokens = [];
+    let index = 0;
+    while (index < s.length) {
+        ANSI_TOKEN_RE.lastIndex = index;
+        const match = ANSI_TOKEN_RE.exec(s);
+        if (match) {
+            tokens.push({ value: match[0], ansi: true });
+            index = ANSI_TOKEN_RE.lastIndex;
+            continue;
+        }
+        const nextEsc = s.indexOf('\x1b', index + 1);
+        const end = nextEsc === -1 ? s.length : nextEsc;
+        tokens.push({ value: s.slice(index, end), ansi: false });
+        index = end;
+    }
+    return tokens;
+}
+function extractTrailingAnsi(s) {
+    // deno-lint-ignore no-control-regex
+    const match = s.match(/(\u001B\[[0-?]*[ -/]*[@-~])$/);
+    return match ? match[1] : '';
+}

package/esm/tui/src/views.d.ts

@@ -0,0 +1,35 @@
+import { type Color } from './layout/types';
+import { type Component } from './surface';
+export declare const text: (value: string) => Component;
+export interface FlexItem {
+    readonly flex: number;
+    readonly component: Component;
+}
+export declare const flex: (component: Component, weight?: number) => FlexItem;
+export declare const column: (children: (Component | FlexItem)[]) => Component;
+export declare const row: (children: (Component | FlexItem)[]) => Component;
+export interface BoxOptions {
+    border?: boolean;
+    background?: Color;
+    backgroundOpacity?: number;
+    padding?: number;
+}
+export declare const box: (child: Component, opts?: BoxOptions) => Component;
+export interface OverlayOptions {
+    width?: number;
+    opacity?: number;
+}
+export declare const overlay: (background: Component, panel: Component, opts?: OverlayOptions) => Component;
+export interface ModalOptions {
+    title?: string;
+    width?: number;
+    opacity?: number;
+    border?: boolean;
+    background?: Color;
+}
+export type ToastKind = 'info' | 'success' | 'error';
+export interface ToastOptions {
+    kind?: ToastKind;
+}
+export declare const toast: (message: string, opts?: ToastOptions) => Component;
+export declare const modal: (content: Component, opts?: ModalOptions) => Component;

package/esm/tui/src/views.js

@@ -0,0 +1,112 @@
+import { DEFAULT_BORDER_CHARS } from './layout/types';
+import { measureWidth } from './surface';
+import { wrapText } from './utils';
+export const text = (value) => ({
+    render: (s) => {
+        const lines = wrapText(value, s.width);
+        for (let i = 0; i < lines.length && i < s.height; i++)
+            s.text(0, i, lines[i]);
+    },
+});
+export const flex = (component, weight = 1) => ({ flex: weight, component });
+const isFlex = (item) => 'flex' in item;
+const distributeFlex = (children, sizes, remaining) => {
+    const totalFlex = children.reduce((sum, item) => (isFlex(item) ? sum + item.flex : sum), 0);
+    if (totalFlex === 0)
+        return;
+    const flexIndices = children.flatMap((item, i) => (isFlex(item) ? [i] : []));
+    let used = 0;
+    flexIndices.forEach((index, k) => {
+        const item = children[index];
+        const last = k === flexIndices.length - 1;
+        sizes[index] = Math.max(0, last ? remaining - used : Math.floor((remaining * item.flex) / totalFlex));
+        used += sizes[index];
+    });
+};
+export const column = (children) => ({
+    render: (s) => {
+        const sizes = children.map((item) => (isFlex(item) ? -1 : s.measure(item, s.width)));
+        const usedAuto = sizes.reduce((sum, h) => (h >= 0 ? sum + h : sum), 0);
+        distributeFlex(children, sizes, Math.max(0, s.height - usedAuto));
+        let y = 0;
+        for (let i = 0; i < children.length; i++) {
+            const item = children[i];
+            const component = isFlex(item) ? item.component : item;
+            if (sizes[i] > 0)
+                s.child(component, { x: 0, y, width: s.width, height: sizes[i] });
+            y += sizes[i];
+        }
+    },
+});
+export const row = (children) => ({
+    render: (s) => {
+        const sizes = children.map((item) => (isFlex(item) ? -1 : measureWidth(item, s.width)));
+        const usedAuto = sizes.reduce((sum, w) => (w >= 0 ? sum + w : sum), 0);
+        distributeFlex(children, sizes, Math.max(0, s.width - usedAuto));
+        let x = 0;
+        for (let i = 0; i < children.length; i++) {
+            const item = children[i];
+            const component = isFlex(item) ? item.component : item;
+            if (sizes[i] > 0)
+                s.child(component, { x, y: 0, width: sizes[i], height: s.height });
+            x += sizes[i];
+        }
+    },
+});
+const drawBorder = (s, height) => {
+    const w = s.width;
+    if (w < 2 || height < 2)
+        return;
+    const c = DEFAULT_BORDER_CHARS;
+    s.text(0, 0, c.topLeft + c.horizontal.repeat(w - 2) + c.topRight);
+    for (let y = 1; y < height - 1; y++) {
+        s.text(0, y, c.vertical);
+        s.text(w - 1, y, c.vertical);
+    }
+    s.text(0, height - 1, c.bottomLeft + c.horizontal.repeat(w - 2) + c.bottomRight);
+};
+export const box = (child, opts = {}) => ({
+    render: (s) => {
+        const inset = (opts.border ? 1 : 0) + (opts.padding ?? 0);
+        const innerW = Math.max(0, s.width - 2 * inset);
+        const contentH = s.measure(child, innerW);
+        const selfH = Math.min(contentH + 2 * inset, s.height);
+        if (opts.background) {
+            s.fill({ x: 0, y: 0, width: s.width, height: selfH }, opts.background, opts.backgroundOpacity);
+        }
+        if (opts.border)
+            drawBorder(s, selfH);
+        const innerH = Math.max(0, selfH - 2 * inset);
+        if (innerW > 0 && innerH > 0)
+            s.child(child, { x: inset, y: inset, width: innerW, height: innerH });
+    },
+});
+export const overlay = (background, panel, opts = {}) => ({
+    render: (s) => {
+        s.child(background, { x: 0, y: 0, width: s.width, height: s.height });
+        s.fill({ x: 0, y: 0, width: s.width, height: s.height }, '#000000', opts.opacity ?? 0.6);
+        const w = Math.min(opts.width ?? 60, s.width);
+        const h = Math.min(s.measure(panel, w), s.height);
+        const x = Math.max(0, Math.floor((s.width - w) / 2));
+        const y = Math.max(0, Math.floor((s.height - h) / 2));
+        s.child(panel, { x, y, width: w, height: h });
+    },
+});
+const TOAST_BACKGROUND = {
+    info: '#1e3a5f',
+    success: '#1e4620',
+    error: '#5f1e1e',
+};
+export const toast = (message, opts = {}) => box(text(message), { border: true, background: TOAST_BACKGROUND[opts.kind ?? 'info'], padding: 0 });
+export const modal = (content, opts = {}) => ({
+    render: (s) => {
+        s.fill({ x: 0, y: 0, width: s.width, height: s.height }, '#000000', opts.opacity ?? 0.6);
+        const inner = opts.title ? column([text(opts.title), content]) : content;
+        const panel = box(inner, { border: opts.border ?? true, background: opts.background ?? '#1c1c1c' });
+        const w = Math.min(opts.width ?? 60, Math.max(0, s.width - 2));
+        const h = Math.min(s.measure(panel, w), Math.max(0, s.height - 2));
+        const x = Math.max(0, Math.floor((s.width - w) / 2));
+        const y = Math.max(0, Math.floor((s.height - h) / 2));
+        s.child(panel, { x, y, width: w, height: h });
+    },
+});

package/package.json

@@ -0,0 +1,23 @@
+{
+  "name": "mu-harness",
+  "version": "0.16.3",
+  "description": "Agent harness: createHarness wires mu-core into a host — XDG paths, model registry, plugins, disk-loaded agents & skills, sub-agents, sessions (JSONL + SQLite catalog), slash commands, permission/approval hooks, an optional scheduler, and a composable TUI chat app",
+  "license": "MIT",
+  "main": "./script/index.js",
+  "module": "./esm/index.js",
+  "exports": {
+    ".": {
+      "import": "./esm/index.js",
+      "require": "./script/index.js"
+    }
+  },
+  "scripts": {},
+  "type": "module",
+  "dependencies": {
+    "@swc/wasm-typescript": "^1.15.0",
+    "croner": "^9.0.0",
+    "mu-core": "^0.16.3",
+    "mu-tui": "^0.16.3"
+  },
+  "_generatedBy": "dnt@dev"
+}

package/script/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/script/core/src/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/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/script/core/src/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_1 = require("./types");
+Object.defineProperty(exports, "audio", { enumerable: true, get: function () { return types_1.audio; } });
+Object.defineProperty(exports, "image", { enumerable: true, get: function () { return types_1.image; } });
+Object.defineProperty(exports, "text", { enumerable: true, get: function () { return types_1.text; } });
+var agent_1 = require("./agent");
+Object.defineProperty(exports, "createAgent", { enumerable: true, get: function () { return agent_1.createAgent; } });
+Object.defineProperty(exports, "run", { enumerable: true, get: function () { return agent_1.run; } });

package/script/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/script/core/src/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;