@alisio/core 0.1.0-alpha.10

package/dist/core/contracts.js

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

package/dist/core/registry.d.ts

@@ -0,0 +1,8 @@
+import type { ToolDefinition } from "@alisio/sdk";
+export declare class ToolRegistry {
+    private entries;
+    register(tool: ToolDefinition): () => void;
+    list(): ToolDefinition[];
+    get(name: string): ToolDefinition;
+    parse(name: string, argumentsText: string): Record<string, unknown>;
+}

package/dist/core/registry.js

@@ -0,0 +1,54 @@
+import Ajv from "ajv";
+import Ajv2020 from "ajv/dist/2020.js";
+const ajv2020 = new Ajv2020({ allErrors: true, strict: true });
+const ajv = new Ajv({ allErrors: true, strict: true });
+function rejectReferences(value) {
+    if (!value || typeof value !== "object")
+        return;
+    for (const [k, v] of Object.entries(value)) {
+        if (["$ref", "$id", "$async"].includes(k))
+            throw new Error(`Schema keyword ${k} is not supported`);
+        rejectReferences(v);
+    }
+}
+export class ToolRegistry {
+    entries = new Map();
+    register(tool) {
+        if (!/^[a-zA-Z0-9_-]{1,64}$/.test(tool.name))
+            throw new Error(`Invalid tool name: ${tool.name}`);
+        if (this.entries.has(tool.name))
+            throw new Error(`Duplicate tool: ${tool.name}`);
+        if (tool.inputSchema.type !== "object")
+            throw new Error("Tool input schema must be an object");
+        rejectReferences(tool.inputSchema);
+        const entry = {
+            tool,
+            validate: (tool.inputSchema.$schema === "https://json-schema.org/draft/2020-12/schema"
+                ? ajv2020
+                : ajv).compile(tool.inputSchema),
+        };
+        this.entries.set(tool.name, entry);
+        return () => {
+            if (this.entries.get(tool.name) === entry)
+                this.entries.delete(tool.name);
+        };
+    }
+    list() {
+        return [...this.entries.values()].map((x) => x.tool);
+    }
+    get(name) {
+        const e = this.entries.get(name);
+        if (!e)
+            throw new Error(`Unknown tool: ${name}`);
+        return e.tool;
+    }
+    parse(name, argumentsText) {
+        const e = this.entries.get(name);
+        if (!e)
+            throw new Error(`Unknown tool: ${name}`);
+        const value = JSON.parse(argumentsText);
+        if (!e.validate(value))
+            throw new Error(ajv.errorsText(e.validate.errors));
+        return value;
+    }
+}

package/dist/core/runner.d.ts

@@ -0,0 +1,160 @@
+import { type Attachment, type Message, type ModelProvider, type RunEvent, type ToolDefinition } from "@alisio/sdk";
+import type { ApprovalHandler, ContextSource, Policy, RunnerExtensions, SessionStore } from "./contracts.ts";
+import type { ToolRegistry } from "./registry.ts";
+export interface CompactionSettings {
+    /** Compact automatically when context usage crosses `threshold` of a known window. */
+    auto?: boolean;
+    threshold?: number;
+    keepTurns?: number;
+    /**
+     * Per-call output token budget for the summarizer. Defaults to 4096 when unset; never falls
+     * back to the agent-loop `maxOutputTokens`. A truncated summary is accepted as partial.
+     */
+    maxOutputTokens?: number;
+}
+export interface RunnerOptions {
+    /** Provider bound to this persisted session. */
+    provider: ModelProvider;
+    providerFor?: (session: import("./contracts.ts").Session) => Promise<ModelProvider>;
+    registry: ToolRegistry;
+    store: SessionStore;
+    context: ContextSource;
+    policy: Policy;
+    workspace: string;
+    maxTurns?: number;
+    timeoutMs?: number;
+    maxContextChars?: number;
+    maxOutputTokens?: number;
+    maxTokens?: number;
+    onEvent?: (event: RunEvent) => void;
+    readConcurrency?: number;
+    /** Context window in tokens for a model, when known. Drives auto-compaction at `threshold`; when
+     *  unknown (or absurdly large, see `MAX_TRUSTED_WINDOW`) the char budget falls back. */
+    contextWindow?: (model: string) => number | undefined;
+    compaction?: CompactionSettings;
+    /** When set, write/process tools not allowed by the policy are offered and ask first. */
+    approve?: ApprovalHandler;
+    /** Generic hooks (implemented by the plugin host) for compaction and session start. */
+    extensions?: RunnerExtensions;
+    /**
+     * Provider-native tool definitions (for example a hosted `web_search` tool) appended to every
+     * request's `tools` alongside the registry's function tools. Opt-in, set once for the whole
+     * runner; only meaningful for a provider that documents an equivalent server-side tool.
+     */
+    nativeTools?: Array<Record<string, unknown>>;
+}
+/** The settings a running TUI can change live; merged into the runner options on apply. */
+export interface RunnerSettingsPatch {
+    /** Compaction settings; merged over the current ones (any subset). */
+    compaction?: Partial<CompactionSettings>;
+    /** Maximum turns per run. */
+    maxTurns?: number;
+    /** Per-call max output tokens budget. */
+    maxOutputTokens?: number;
+    /** Post-compaction context budget in characters. */
+    maxContextChars?: number;
+    /** Per-run timeout in milliseconds; the next run honors it. */
+    timeoutMs?: number;
+}
+/**
+ * Per-run overrides used by embedders and child sessions. Callers must only NARROW: `policy`
+ * and `toolFilter` are applied on top of the runner's policy and tools.
+ */
+export interface RunOptions {
+    /** What UIs show instead of the prompt (e.g. `/init`). */
+    display?: string;
+    /** Images attached to this turn's user message, sent as vision content parts. */
+    attachments?: Attachment[];
+    /** Extra system instructions for this run (e.g. an agent persona). */
+    instructions?: string;
+    toolFilter?: (tool: ToolDefinition) => boolean;
+    policy?: Policy;
+    /** Allow interactive approvals for this run (default: when the runner has a handler). */
+    approvals?: boolean;
+    /** Shown with approval requests, e.g. the agent path of a child session. */
+    label?: string;
+    workspace?: string;
+    context?: ContextSource;
+    maxTurns?: number;
+    maxTokens?: number;
+    /** Per-call output token budget for this run; beats the runner-level budget when set. */
+    maxOutputTokens?: number;
+    timeoutMs?: number;
+}
+/**
+ * Default cumulative token budget for one run: several context windows (each turn re-sends the
+ * context), clamped; 1M tokens when the window is unknown.
+ */
+export declare function defaultTokenBudget(contextWindow?: number): number;
+export interface CompactionResult {
+    replaced: number;
+    before: number;
+    after: number;
+    summary: Extract<Message, {
+        role: "user";
+    }>;
+}
+export declare class AgentRunner {
+    private options;
+    /** Sessions with an active run or compaction (one at a time per session). */
+    private active;
+    /** Messages queued for a session's next turn (e.g. input for a running child). */
+    private inbox;
+    /** Last provider-reported context size per session and the history length it covered. */
+    private reported;
+    constructor(options: RunnerOptions);
+    /** Current capability policy (may widen when the user approves an effect for the session). */
+    get policy(): Readonly<Policy>;
+    /** Whether write/process tools can be approved interactively. */
+    get approvals(): boolean;
+    /**
+     * Live-update runnable settings so the next `run`/`compact` call honors them without restarting
+     * Alisio. Every patch field is merged over the current options; unrelated settings are kept.
+     */
+    applySettings(patch: RunnerSettingsPatch): void;
+    private emitter;
+    /** Tools offered to the model under the current policy (and optional run narrowing). */
+    availableTools(run?: RunOptions): ToolDefinition[];
+    /** Abort signal of the session's active run, if any (used to cascade cancellation). */
+    signal(sessionId: string): AbortSignal | undefined;
+    isRunning(sessionId: string): boolean;
+    /** Aborts the active run (or compaction) of a session. */
+    abort(sessionId: string, reason?: unknown): boolean;
+    /** Queues text as a user message for the session's next turn (or next run when idle). */
+    enqueue(sessionId: string, text: string): void;
+    private drain;
+    private claim;
+    private toolsText;
+    /** Estimated tokens the next request of a session would send. */
+    estimateContext(sessionId: string): Promise<number>;
+    /**
+     * The effective context budget the TUI context bar displays. The model window is the total
+     * when known (and not beyond `MAX_TRUSTED_WINDOW`); otherwise the bar reports an honest
+     * unknown (`basis: "unknown"`, no fabricated total). `compactionAt` is the percentage of
+     * `total` where auto-compaction triggers, so the bar turns red exactly where the engine
+     * compacts. The engine's own auto-compaction guardrail still falls back to the char budget
+     * internally (see `shouldCompactContext`) — that fallback is never shown as a fake total.
+     */
+    contextBudget(model: string): {
+        total?: number;
+        basis: "window" | "unknown";
+        compactionAt: number;
+    };
+    /** Change the model used by subsequent turns of a session; recorded in the store. */
+    setModel(sessionId: string, model: string): void;
+    /** Manually compact a session outside a run. */
+    compact(sessionId: string, request?: {
+        focus?: string;
+        signal?: AbortSignal;
+    }): Promise<CompactionResult | undefined>;
+    private compactLocked;
+    run(sessionId: string, prompt: string, signal?: AbortSignal, options?: RunOptions): Promise<{
+        sessionId: string;
+        text: string;
+        status: string;
+        usage: {
+            input: number;
+            output: number;
+        };
+    }>;
+}