@alisio/core 0.1.0-alpha.3

package/dist/core/runner.js

@@ -0,0 +1,543 @@
+import { textResult, } from "@alisio/sdk";
+import { checkpointInstructions, estimateTokens, parseCheckpointOutput, planCompaction, shouldCompact, summarize, summaryMessage, } from "./compaction.js";
+/**
+ * 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 function defaultTokenBudget(contextWindow) {
+    if (!contextWindow || contextWindow <= 0)
+        return 1_000_000;
+    return Math.min(8_000_000, Math.max(400_000, contextWindow * 8));
+}
+/** Extension output appended to history is capped regardless of what hooks return. */
+const MAX_INJECT_CHARS = 24_000;
+const allowed = (policy, effect) => effect === "read" || effect === "internal" || !!policy[effect];
+export class AgentRunner {
+    options;
+    /** Sessions with an active run or compaction (one at a time per session). */
+    active = new Map();
+    /** Messages queued for a session's next turn (e.g. input for a running child). */
+    inbox = new Map();
+    /** Last provider-reported context size per session and the history length it covered. */
+    reported = new Map();
+    constructor(options) {
+        this.options = options;
+    }
+    /** Current capability policy (may widen when the user approves an effect for the session). */
+    get policy() {
+        return this.options.policy;
+    }
+    /** Whether write/process tools can be approved interactively. */
+    get approvals() {
+        return !!this.options.approve;
+    }
+    emitter(sessionId) {
+        const runId = crypto.randomUUID();
+        let seq = 0;
+        return (type, data) => {
+            const event = {
+                schemaVersion: 1,
+                runId,
+                sessionId,
+                seq: ++seq,
+                type,
+                timestamp: new Date().toISOString(),
+                data,
+            };
+            if (type !== "text_delta" && type !== "tool_progress" && type !== "reasoning_delta")
+                this.options.store.event(sessionId, runId, type, data);
+            try {
+                this.options.onEvent?.(event);
+            }
+            catch {
+                /* An observer cannot invalidate an executed operation. */
+            }
+        };
+    }
+    /** Tools offered to the model under the current policy (and optional run narrowing). */
+    availableTools(run = {}) {
+        const o = this.options;
+        const policy = run.policy ?? o.policy;
+        const approvals = !!o.approve && run.approvals !== false;
+        return o.registry.list().filter((t) => {
+            if (run.toolFilter && !run.toolFilter(t))
+                return false;
+            const effect = t.effect ?? "external";
+            if (allowed(policy, effect))
+                return true;
+            return approvals && (effect === "write" || effect === "process" || effect === "external");
+        });
+    }
+    /** Abort signal of the session's active run, if any (used to cascade cancellation). */
+    signal(sessionId) {
+        return this.active.get(sessionId)?.signal;
+    }
+    isRunning(sessionId) {
+        return this.active.has(sessionId);
+    }
+    /** Aborts the active run (or compaction) of a session. */
+    abort(sessionId, reason = new Error("Cancelled")) {
+        const controller = this.active.get(sessionId);
+        if (!controller)
+            return false;
+        controller.abort(reason);
+        return true;
+    }
+    /** Queues text as a user message for the session's next turn (or next run when idle). */
+    enqueue(sessionId, text) {
+        const queue = this.inbox.get(sessionId) ?? [];
+        queue.push(text.slice(0, 50_000));
+        this.inbox.set(sessionId, queue.slice(-20));
+    }
+    drain(sessionId) {
+        const queue = this.inbox.get(sessionId) ?? [];
+        this.inbox.delete(sessionId);
+        return queue;
+    }
+    claim(sessionId) {
+        if (this.active.has(sessionId))
+            throw new Error("Session is busy; await the current run or cancel it");
+        const controller = new AbortController();
+        this.active.set(sessionId, controller);
+        return controller;
+    }
+    toolsText(tools) {
+        return JSON.stringify(tools.map((t) => ({ name: t.name, schema: t.inputSchema, description: t.description })));
+    }
+    /** Estimated tokens the next request of a session would send. */
+    async estimateContext(sessionId) {
+        const instructions = await this.options.context.instructions(sessionId);
+        return (estimateTokens(instructions) +
+            estimateTokens(this.options.store.messages(sessionId)) +
+            estimateTokens(this.toolsText(this.availableTools())));
+    }
+    /** Change the model used by subsequent turns of a session; recorded in the store. */
+    setModel(sessionId, model) {
+        const id = model.trim();
+        if (!id)
+            throw new Error("Model ID must not be empty");
+        const previous = this.options.store.get(sessionId).model;
+        if (previous === id)
+            return;
+        this.options.store.setModel(sessionId, id);
+        this.reported.delete(sessionId);
+        this.emitter(sessionId)("model_changed", { model: id, previous });
+    }
+    /** Manually compact a session outside a run. */
+    async compact(sessionId, request = {}) {
+        const controller = this.claim(sessionId);
+        const o = this.options;
+        let acquired = false;
+        const timeout = AbortSignal.timeout(o.timeoutMs ?? 300_000);
+        const signal = AbortSignal.any([
+            controller.signal,
+            timeout,
+            ...(request.signal ? [request.signal] : []),
+        ]);
+        try {
+            o.store.acquire(sessionId);
+            acquired = true;
+            o.store.reconcile(sessionId);
+            const session = o.store.get(sessionId);
+            return await this.compactLocked(sessionId, this.emitter(sessionId), session.model, signal, "manual", request.focus);
+        }
+        finally {
+            if (acquired)
+                o.store.release(sessionId);
+            this.active.delete(sessionId);
+        }
+    }
+    async compactLocked(sessionId, emit, model, signal, reason, focus) {
+        const o = this.options;
+        const messages = o.store.messages(sessionId);
+        const plan = planCompaction(messages, { keepTurns: o.compaction?.keepTurns ?? 2 });
+        const before = await this.estimateContext(sessionId);
+        if (!plan) {
+            emit("compaction_skipped", { reason, before, detail: "Not enough history to compact" });
+            return undefined;
+        }
+        emit("compaction_started", { reason, before, messages: plan.summarized.length });
+        const reportFailures = (failures) => {
+            for (const f of failures)
+                emit("plugin_hook_failed", { ...f, continued: true });
+        };
+        try {
+            const ext = o.extensions;
+            const hookInput = { sessionId, reason, messages: plan.summarized, focus };
+            let contribution = {
+                instructions: [],
+                fields: {},
+                failures: [],
+            };
+            if (ext)
+                try {
+                    contribution = await ext.beforeCompact(hookInput);
+                }
+                catch (error) {
+                    contribution.failures.push({
+                        source: "host",
+                        hook: "beforeCompact",
+                        error: String(error),
+                    });
+                }
+            reportFailures(contribution.failures);
+            const fields = Object.fromEntries(Object.entries(contribution.fields).map(([name, f]) => [name, f.description]));
+            const provider = await (o.providerFor?.(o.store.get(sessionId)) ?? o.provider);
+            const raw = await summarize(provider, {
+                instructions: checkpointInstructions(contribution.instructions, fields),
+                messages: plan.summarized,
+                focus,
+                model,
+                maxOutputTokens: o.maxOutputTokens ?? 4096,
+                signal,
+                sessionId,
+            });
+            const output = parseCheckpointOutput(raw, Object.keys(fields));
+            let after = {
+                inject: [],
+                reports: {},
+                failures: [],
+            };
+            if (ext)
+                try {
+                    after = await ext.afterCompact({
+                        ...hookInput,
+                        model,
+                        replaced: plan.cut,
+                        structured: output.structured,
+                        ...(output.checkpoint ? { checkpoint: output.checkpoint } : {}),
+                        checkpointText: output.text,
+                        extracted: output.extracted,
+                    });
+                }
+                catch (error) {
+                    after.failures.push({ source: "host", hook: "afterCompact", error: String(error) });
+                }
+            reportFailures(after.failures);
+            const body = [output.text, ...after.inject.map((x) => x.slice(0, MAX_INJECT_CHARS))]
+                .filter((x) => x.trim())
+                .join("\n\n");
+            const summary = summaryMessage(body, plan.cut);
+            o.store.compact(sessionId, plan.cut, summary);
+            this.reported.delete(sessionId);
+            const afterTokens = await this.estimateContext(sessionId);
+            emit("compaction_completed", {
+                reason,
+                before,
+                after: afterTokens,
+                replaced: plan.cut,
+                structured: output.structured,
+                summarizedTokens: estimateTokens(plan.summarized),
+                checkpointTokens: estimateTokens(summary.text),
+                plugins: after.reports,
+            });
+            return { replaced: plan.cut, before, after: afterTokens, summary };
+        }
+        catch (error) {
+            emit("compaction_failed", {
+                reason,
+                error: error instanceof Error ? error.message : String(error),
+            });
+            throw error;
+        }
+    }
+    async run(sessionId, prompt, signal, options = {}) {
+        const controller = this.claim(sessionId);
+        const o = this.options, emit = this.emitter(sessionId);
+        let tokens = 0, lastText = "", acquired = false;
+        const usageTotal = { input: 0, output: 0 };
+        const timeout = AbortSignal.timeout(options.timeoutMs ?? o.timeoutMs ?? 300_000);
+        const combined = AbortSignal.any([controller.signal, timeout, ...(signal ? [signal] : [])]);
+        const context = options.context ?? o.context;
+        const workspace = options.workspace ?? o.workspace;
+        const policy = options.policy ?? o.policy;
+        const approvals = !!o.approve && options.approvals !== false;
+        const withPersona = async () => {
+            const base = await context.instructions(sessionId);
+            return options.instructions ? `${base}\n\n${options.instructions}` : base;
+        };
+        try {
+            o.store.acquire(sessionId);
+            acquired = true;
+            o.store.reconcile(sessionId);
+            const session = o.store.get(sessionId);
+            const provider = await (o.providerFor?.(session) ?? o.provider);
+            if (session.provider !== provider.id || session.workspace !== workspace)
+                throw new Error("Session provider/workspace mismatch");
+            // The session records the model; switching models is explicit via setModel.
+            const model = session.model;
+            combined.throwIfAborted();
+            if (o.extensions && o.store.messages(sessionId).length === 0) {
+                // New session: extensions may inject budgeted context once, persisted with the session.
+                try {
+                    const start = await o.extensions.sessionStart({
+                        sessionId,
+                        model,
+                        workspace,
+                    });
+                    for (const f of start.failures)
+                        emit("plugin_hook_failed", { ...f, continued: true });
+                    const text = start.inject
+                        .map((x) => x.text.slice(0, MAX_INJECT_CHARS))
+                        .filter((x) => x.trim())
+                        .join("\n\n");
+                    if (text) {
+                        o.store.append(sessionId, { role: "user", text, summary: true });
+                        emit("session_context_injected", {
+                            tokens: estimateTokens(text),
+                            sources: start.inject.map((x) => x.source),
+                        });
+                    }
+                }
+                catch (error) {
+                    emit("plugin_hook_failed", {
+                        source: "host",
+                        hook: "sessionStart",
+                        error: String(error),
+                        continued: true,
+                    });
+                }
+                combined.throwIfAborted();
+            }
+            for (const queued of this.drain(sessionId))
+                o.store.append(sessionId, { role: "user", text: queued });
+            o.store.append(sessionId, {
+                role: "user",
+                text: prompt,
+                ...(options.display ? { display: options.display } : {}),
+                ...(options.attachments?.length ? { attachments: options.attachments } : {}),
+            });
+            emit("run_started", { model });
+            const budget = options.maxTokens ?? o.maxTokens ?? defaultTokenBudget(o.contextWindow?.(model));
+            const compaction = o.compaction ?? {};
+            for (let turn = 0; turn < (options.maxTurns ?? o.maxTurns ?? 20); turn++) {
+                combined.throwIfAborted();
+                // Input queued while the run was working (e.g. a parent's message to a child).
+                if (turn > 0)
+                    for (const queued of this.drain(sessionId))
+                        o.store.append(sessionId, { role: "user", text: queued });
+                let instructions = await withPersona();
+                let messages = o.store.messages(sessionId);
+                const tools = this.availableTools(options);
+                const toolsText = this.toolsText(tools);
+                const chars = () => instructions.length + JSON.stringify(messages).length + toolsText.length;
+                const used = () => {
+                    const last = this.reported.get(sessionId);
+                    return last && last.count <= messages.length
+                        ? last.tokens + estimateTokens(messages.slice(last.count))
+                        : estimateTokens(instructions) + estimateTokens(messages) + estimateTokens(toolsText);
+                };
+                const overChars = chars() > (o.maxContextChars ?? 160_000);
+                const overWindow = compaction.auto !== false &&
+                    shouldCompact(used(), o.contextWindow?.(model), compaction.threshold ?? 0.85);
+                if (overWindow || (overChars && compaction.auto !== false)) {
+                    await this.compactLocked(sessionId, emit, model, combined, "auto");
+                    instructions = await withPersona();
+                    messages = o.store.messages(sessionId);
+                }
+                if (chars() > (o.maxContextChars ?? 160_000))
+                    throw new Error("Context budget exceeded and compaction could not reduce it; start a new session.");
+                let completion;
+                let usage;
+                for await (const e of provider.stream({
+                    instructions,
+                    messages,
+                    tools,
+                    maxOutputTokens: o.maxOutputTokens ?? 4096,
+                    signal: combined,
+                    model,
+                    sessionId,
+                    ...(o.nativeTools?.length ? { nativeTools: o.nativeTools } : {}),
+                })) {
+                    combined.throwIfAborted();
+                    if (e.type === "text_delta")
+                        emit("text_delta", { delta: e.delta });
+                    else if (e.type === "reasoning_delta")
+                        emit("reasoning_delta", { delta: e.delta });
+                    else {
+                        if (completion)
+                            throw new Error("Provider emitted multiple completions");
+                        completion = e.message;
+                        usage = e.usage;
+                        tokens += (e.usage?.input ?? 0) + (e.usage?.output ?? 0);
+                        usageTotal.input += e.usage?.input ?? 0;
+                        usageTotal.output += e.usage?.output ?? 0;
+                    }
+                }
+                if (!completion)
+                    throw new Error("Provider stream ended without a completed response");
+                const ids = completion.calls.map((c) => c.id);
+                const previousIds = new Set(messages.flatMap((m) => (m.role === "assistant" ? m.calls.map((c) => c.id) : [])));
+                if (ids.some((id) => previousIds.has(id)))
+                    throw new Error("Provider reused a tool call ID across turns");
+                if (new Set(ids).size !== ids.length)
+                    throw new Error("Provider returned duplicate tool call IDs");
+                if (completion.calls.length > 64)
+                    throw new Error("Too many tool calls in one turn");
+                o.store.append(sessionId, completion);
+                if (usage)
+                    this.reported.set(sessionId, {
+                        tokens: usage.input + usage.output,
+                        count: messages.length + 1,
+                    });
+                lastText = completion.text;
+                emit("turn_completed", {
+                    turn: turn + 1,
+                    tokens,
+                    calls: completion.calls.length,
+                    model,
+                    ...(usage ? { usage } : {}),
+                });
+                if (!completion.calls.length) {
+                    emit("run_completed", { tokens, text: lastText });
+                    return { sessionId, text: lastText, status: "completed", usage: usageTotal };
+                }
+                const prepared = completion.calls.map((call) => {
+                    try {
+                        const tool = o.registry.get(call.name), input = o.registry.parse(call.name, call.arguments);
+                        return { call, tool, input };
+                    }
+                    catch (error) {
+                        return { call, error: String(error) };
+                    }
+                });
+                // Resolve scopes before tools execute. New nested instructions are attached to the first
+                // read result; state-changing calls return to the model for reconsideration instead.
+                let contextUpdate;
+                const paths = prepared.flatMap((p) => p.tool?.paths?.(p.input ?? {}) ?? []);
+                if (paths.length)
+                    contextUpdate = await context.beforePaths(paths, sessionId);
+                let pendingUpdate = contextUpdate;
+                const execute = async (p) => {
+                    const { call } = p;
+                    let result;
+                    const started = Date.now();
+                    emit("tool_started", { name: call.name, id: call.id, arguments: call.arguments });
+                    try {
+                        combined.throwIfAborted();
+                        if (p.error)
+                            throw new Error(p.error);
+                        if (!p.tool || !p.input)
+                            throw new Error("Invalid tool");
+                        const effect = p.tool.effect ?? "external";
+                        if (contextUpdate && effect !== "read")
+                            throw new Error(`Context changed; reconsider this call before retrying.\n${contextUpdate}`);
+                        if (tokens >= budget)
+                            throw new Error("Token budget exhausted; tool was not executed");
+                        if (options.toolFilter && !options.toolFilter(p.tool))
+                            throw new Error(`Tool ${call.name} is not available in this session`);
+                        if (!allowed(policy, effect)) {
+                            if (!o.approve ||
+                                !approvals ||
+                                (effect !== "write" && effect !== "process" && effect !== "external"))
+                                throw new Error(`Capability denied: ${effect}`);
+                            emit("approval_requested", {
+                                id: call.id,
+                                name: call.name,
+                                effect,
+                                ...(options.label ? { label: options.label } : {}),
+                            });
+                            const decision = await o.approve({
+                                call,
+                                effect,
+                                input: p.input,
+                                signal: combined,
+                                session: sessionId,
+                                ...(options.label ? { label: options.label } : {}),
+                            });
+                            combined.throwIfAborted();
+                            emit("approval_resolved", { id: call.id, name: call.name, effect, decision });
+                            if (decision === "deny")
+                                throw new Error(`Capability ${effect} denied by the user for this call`);
+                            if (decision === "session")
+                                policy[effect] = true;
+                        }
+                        o.store.beginCall(sessionId, call);
+                        result = await p.tool.execute(p.input, {
+                            signal: combined,
+                            workspace,
+                            session: sessionId,
+                            emit: (data) => emit("tool_progress", { id: call.id, data }),
+                            ...(options.label ? { label: options.label } : {}),
+                        });
+                        if (JSON.stringify(result).length > 48_000)
+                            result = textResult(`${JSON.stringify(result).slice(0, 40_000)}\n[tool output truncated]`, result.isError);
+                        if (pendingUpdate && effect === "read") {
+                            result = {
+                                ...result,
+                                content: [
+                                    ...result.content,
+                                    { type: "text", text: `\n<instructions>\n${pendingUpdate}\n</instructions>` },
+                                ],
+                            };
+                            pendingUpdate = undefined;
+                        }
+                        o.store.endCall(sessionId, call, result);
+                    }
+                    catch (error) {
+                        result = textResult(error instanceof Error ? error.message : String(error), true);
+                        // A cancellation after execution may have left effects; journal remains pending.
+                        if (!combined.aborted)
+                            o.store.endCall(sessionId, call, result);
+                    }
+                    emit("tool_completed", {
+                        id: call.id,
+                        name: call.name,
+                        isError: result.isError ?? false,
+                        durationMs: Date.now() - started,
+                        preview: result.content
+                            .map((c) => c.text)
+                            .join("\n")
+                            .slice(0, 2_000),
+                    });
+                    return result;
+                };
+                const results = [];
+                // Bounded parallel batches for consecutive read or explicitly concurrent tools.
+                const parallel = (p) => !!p?.tool && (p.tool.effect === "read" || p.tool.concurrent === true);
+                for (let i = 0; i < prepared.length;) {
+                    const current = prepared[i];
+                    if (!current)
+                        break;
+                    if (parallel(current)) {
+                        const batch = [];
+                        while (i < prepared.length &&
+                            parallel(prepared[i]) &&
+                            batch.length < (o.readConcurrency ?? 4)) {
+                            const p = prepared[i++];
+                            if (p)
+                                batch.push(p);
+                        }
+                        results.push(...(await Promise.all(batch.map(execute))));
+                    }
+                    else {
+                        results.push(await execute(current));
+                        i++;
+                    }
+                    combined.throwIfAborted();
+                }
+                for (let i = 0; i < completion.calls.length; i++) {
+                    const c = completion.calls[i], r = results[i];
+                    if (c && r)
+                        o.store.append(sessionId, { role: "tool", callId: c.id, result: r });
+                }
+                if (tokens >= budget)
+                    throw new Error("Token budget exhausted");
+            }
+            throw new Error("Maximum turns reached");
+        }
+        catch (error) {
+            // On cancellation report the abort reason, not the transport's secondary error.
+            const cause = combined.aborted ? (combined.reason ?? error) : error;
+            emit(combined.aborted ? "run_cancelled" : "run_failed", {
+                error: cause instanceof Error ? cause.message : String(cause),
+            });
+            throw error;
+        }
+        finally {
+            if (acquired)
+                o.store.release(sessionId);
+            this.active.delete(sessionId);
+        }
+    }
+}

package/dist/extensions/registry.d.ts

@@ -0,0 +1,28 @@
+/**
+ * Generic, typed extension registry. Resolution is deterministic and independent of plugin
+ * load order: highest priority, then plugin id (lexicographic), then registration order
+ * within the plugin. Fallbacks (built-in defaults) only win when nothing else is registered.
+ */
+import type { ExtensionPoints } from "@alisio/sdk";
+export interface ExtensionConflict {
+    point: string;
+    /** `plugin/provider` of the chosen provider. */
+    winner: string;
+    losers: string[];
+}
+export declare class ExtensionRegistry {
+    private entries;
+    private seq;
+    register<K extends keyof ExtensionPoints>(point: K, provider: ExtensionPoints[K], options: {
+        plugin: string;
+        priority?: number;
+        fallback?: boolean;
+    }): () => void;
+    private ranked;
+    resolve<K extends keyof ExtensionPoints>(point: K): {
+        provider: ExtensionPoints[K];
+        plugin: string;
+    } | undefined;
+    /** Equal-priority, non-fallback competitors for each point's winning slot. */
+    conflicts(point?: keyof ExtensionPoints): ExtensionConflict[];
+}

package/dist/extensions/registry.js

@@ -0,0 +1,58 @@
+const key = (e) => `${e.plugin}/${e.provider.id}`;
+function compare(a, b) {
+    if (a.fallback !== b.fallback)
+        return a.fallback ? 1 : -1;
+    if (a.priority !== b.priority)
+        return b.priority - a.priority;
+    if (a.plugin !== b.plugin)
+        return a.plugin < b.plugin ? -1 : 1;
+    return a.seq - b.seq;
+}
+export class ExtensionRegistry {
+    entries = [];
+    seq = 0;
+    register(point, provider, options) {
+        // `id` is the one thing every extension point shares; a point-specific shape (e.g. `render`
+        // for a renderable point) is validated by that point's own resolution call site, the same way
+        // a throwing or malformed provider already falls back there (see `startup/index.ts`).
+        if (!provider || typeof provider.id !== "string")
+            throw new Error(`Invalid ${point} provider: it needs an id`);
+        const priority = options.priority ?? 0;
+        if (!Number.isFinite(priority))
+            throw new Error("Extension priority must be a finite number");
+        const entry = {
+            point,
+            provider,
+            plugin: options.plugin,
+            priority,
+            fallback: !!options.fallback,
+            seq: this.seq++,
+        };
+        this.entries.push(entry);
+        return () => {
+            this.entries = this.entries.filter((e) => e !== entry);
+        };
+    }
+    ranked(point) {
+        return this.entries.filter((e) => e.point === point).sort(compare);
+    }
+    resolve(point) {
+        const top = this.ranked(point)[0];
+        return top ? { provider: top.provider, plugin: top.plugin } : undefined;
+    }
+    /** Equal-priority, non-fallback competitors for each point's winning slot. */
+    conflicts(point) {
+        const points = point ? [point] : [...new Set(this.entries.map((e) => e.point))];
+        const out = [];
+        for (const p of points) {
+            const ranked = this.ranked(p).filter((e) => !e.fallback);
+            const winner = ranked[0];
+            if (!winner)
+                continue;
+            const losers = ranked.filter((e) => e !== winner && e.priority === winner.priority);
+            if (losers.length)
+                out.push({ point: p, winner: key(winner), losers: losers.map(key) });
+        }
+        return out;
+    }
+}

package/dist/index.d.ts

@@ -0,0 +1,28 @@
+/** @alisio/core public API: embed the Alisio agent programmatically. */
+export * from "@alisio/sdk";
+export { type AppOptions, type BuiltinContext, type BuiltinPlugin, createApplication, enabledBuiltins, type PluginCatalogEntry, type PluginCatalogStatus, } from "./application.ts";
+export { type Config, type ConfigLoadResult, type ConfigProvenance, configFile, configHome, configSchema, type LoadedConfig, loadConfig, loadConfigWithProvenance, type McpServerSource, overridesSavedProviderProfile, setMcpServerEnabled, setProjectPluginEnabled, setProjectSkillEnabled, stateHome, } from "./config.ts";
+export { checkpointInstructions, completeText, estimateTokens, parseCheckpointOutput, planCompaction, renderCheckpoint, serializeForSummary, shouldCompact, } from "./core/compaction.ts";
+export type { ApprovalDecision, ApprovalHandler, ApprovalRequest, ContextSource, HookFailure, Policy, RunnerExtensions, Session, SessionStore, } from "./core/contracts.ts";
+export { ToolRegistry } from "./core/registry.ts";
+export { AgentRunner, type CompactionResult, defaultTokenBudget, type RunnerOptions, type RunOptions, } from "./core/runner.ts";
+export { type ExtensionConflict, ExtensionRegistry } from "./extensions/registry.ts";
+export { HerdrBridge } from "./integrations/herdr.ts";
+export { McpConnector, type McpServerInfo, type McpStatus, type McpToolInfo, } from "./mcp/connector.ts";
+export { discoverPlugins, PluginHost, type PluginHostOptions, pluginPrefix, } from "./plugins/host.ts";
+export { ActiveProvider, ProviderRegistry, UnconfiguredProvider } from "./providers/registry.ts";
+export { availableProviderModels, type ProviderModelCatalog, resolveProviderModel, } from "./providers/routing.ts";
+export { type ProviderProfile, type ProviderSettings, ProviderSettingsStore, } from "./providers/settings.ts";
+export { type InstructionFile, ProjectContext, type ProjectContextOptions, } from "./resources/context.ts";
+export { expandSlashPrompt, loadPromptTemplates, type PromptDiagnostic, type PromptRequirement, type PromptSource, type PromptSourceKind, type PromptTemplate, parsePromptTemplate, promptSources, renderPromptTemplate, splitArguments, } from "./resources/prompts.ts";
+export { type Skill, type SkillCatalogEntry, type SkillRoot, type SkillScope, Skills, skillRoots, } from "./resources/skills.ts";
+export { exists, fileSize, readHead, readJson, readText, which } from "./runtime/fs.ts";
+export { defaultGlobalRoots, isPathSpec, PLUGIN_KEYWORD, resolvePluginSpec, } from "./runtime/modules.ts";
+export { findWorkspace, safePath } from "./runtime/paths.ts";
+export { type ProcessResult, runProcess } from "./runtime/process.ts";
+export { isSqliteExperimentalWarning, openDatabase } from "./runtime/sqlite.ts";
+export { SQLiteStore } from "./runtime/store.ts";
+export { ChildSessions, type ChildSessionsOptions } from "./sessions/children.ts";
+export { composeSideBySide, DefaultAlisioMascot, DefaultStartupScreen, infoSection, mascotSection, padEnd, pluginsSection, renderStartup, type StartupDiagnostic, type StartupInput, type StartupResult, sanitizeLine, shortenPath, startupTips, stripAnsi, tipsSection, titleSection, truncate, visibleWidth, welcomeSection, } from "./startup/index.ts";
+export { hash, objectSchema, registerStandard } from "./tools/standard.ts";
+export { getTrust, hashProjectConfig, hasProjectResources, listTrust, resolveTrust, revokeTrust, setTrust, type TrustEntry, type TrustListing, type TrustResolution, trustStorePath, } from "./trust.ts";