@alisio/core 0.1.0-alpha.3

package/dist/plugins/host.js

@@ -0,0 +1,572 @@
+var __rewriteRelativeImportExtension = (this && this.__rewriteRelativeImportExtension) || function (path, preserveJsx) {
+    if (typeof path === "string" && /^\.\.?\//.test(path)) {
+        return path.replace(/\.(tsx)$|((?:\.d)?)((?:\.[^./]+?)?)\.([cm]?)ts$/i, function (m, tsx, d, ext, cm) {
+            return tsx ? preserveJsx ? ".jsx" : ".js" : d && (!ext || !cm) ? m : (d + ext + "." + cm.toLowerCase() + "js");
+        });
+    }
+    return path;
+};
+import { createHash } from "node:crypto";
+import { readdir, stat } from "node:fs/promises";
+import { dirname, join, resolve } from "node:path";
+import { pathToFileURL } from "node:url";
+import { z } from "zod";
+import { ExtensionRegistry } from "../extensions/registry.js";
+import { readJson } from "../runtime/fs.js";
+import { resolvePluginSpec } from "../runtime/modules.js";
+import { inside } from "../runtime/paths.js";
+import { openDatabase } from "../runtime/sqlite.js";
+export const pluginPrefix = (id) => `p_${createHash("sha256").update(id).digest("hex").slice(0, 10)}`;
+const message = (error) => (error instanceof Error ? error.message : String(error));
+export class PluginHost {
+    registry;
+    state;
+    options;
+    providers;
+    commands = new Map();
+    commandInfo = new Map();
+    /** Ids of active built-in plugins. */
+    builtins = new Set();
+    /** Status entries contributed through `ui.status`, keyed `plugin:key`. */
+    status = new Map();
+    onStatusChange;
+    /** Providers for typed extension points (mascot, startup-screen, ...). */
+    extensions = new ExtensionRegistry();
+    /** Loaded plugins that did not come from the built-in registry. */
+    externalCount = 0;
+    compactionHooks = [];
+    startHandlers = [];
+    endHandlers = [];
+    fieldOwners = new Map();
+    completer;
+    modelsImpl;
+    observers = new Set();
+    contexts = [];
+    /** Skill directories registered by plugins, retaining trusted registration ownership. */
+    skillSources = [];
+    /** Prompt template directories registered by plugins, with their plugin id. */
+    promptSources = [];
+    /** Agent definition directories registered by plugins, with their plugin id. */
+    agentSources = [];
+    /** Tree panels contributed by plugins, keyed `plugin:id`. */
+    panels = new Map();
+    sessionsImpl;
+    uiImpl;
+    /** Binds the child session service once the runner exists. */
+    setSessions(sessions) {
+        this.sessionsImpl = sessions;
+    }
+    /** Binds interactive UI services (the TUI); without them select/askQuestions resolve undefined. */
+    setInteractiveUI(ui) {
+        this.uiImpl = ui;
+    }
+    get sessions() {
+        if (!this.sessionsImpl)
+            throw new Error("Child sessions are not available yet");
+        return this.sessionsImpl;
+    }
+    /**
+     * Live accessor for core standard tools (e.g. `ask_user_question`), which are not "a plugin"
+     * with an id and so cannot use the per-plugin `ui` wrapper built in `activate()`. Bound lazily
+     * (reads `this.uiImpl` at call time) since `registerStandard` runs before the TUI calls
+     * `setInteractiveUI`. `interactive()` reflects whether ANY interactive UI is bound at all,
+     * never which session is asking, so child sessions under an interactive root TUI pass too.
+     */
+    get ui() {
+        return {
+            interactive: () => !!this.uiImpl,
+            askQuestions: (request) => this.uiImpl
+                ? this.uiImpl.askQuestions(request)
+                : Promise.resolve(Object.fromEntries(request.questions.map((q) => [q.id, undefined]))),
+        };
+    }
+    get promptRoots() {
+        return this.promptSources.map((s) => s.dir);
+    }
+    get skillRoots() {
+        return this.skillSources.map((source) => source.dir);
+    }
+    loaded = new Map();
+    constructor(registry, state, options = {}, providers) {
+        this.registry = registry;
+        this.state = state;
+        this.options = options;
+        this.providers = providers;
+    }
+    /** Binds the provider-agnostic completion service once a provider exists. */
+    setCompleter(fn) {
+        this.completer = fn;
+    }
+    /** Binds credential-free model discovery/resolution after provider startup is complete. */
+    setModels(models) {
+        this.modelsImpl = models;
+    }
+    /**
+     * Loads an explicitly trusted plugin: a file/directory path, or an npm package name resolved
+     * from `from` (project) upwards and then global roots. Never called for untrusted input.
+     */
+    async load(spec, options = {}) {
+        const candidate = await this.inspect(spec, options);
+        await this.activate(candidate.plugin, candidate.base);
+    }
+    /** Imports and validates a trusted plugin without running setup, for cataloging disabled entries. */
+    async inspect(spec, options = {}) {
+        let path = await resolvePluginSpec(spec, {
+            from: options.from ?? process.cwd(),
+            ...(options.globalRoots ? { globalRoots: options.globalRoots } : {}),
+        });
+        if ((await stat(path)).isDirectory()) {
+            const manifest = z
+                .object({ entry: z.string(), apiVersion: z.literal(1) })
+                .passthrough()
+                .parse(await readJson(join(path, "alisio-plugin.json")));
+            const entry = resolve(path, manifest.entry);
+            if (!inside(path, entry))
+                throw new Error("Plugin entry escapes directory");
+            path = entry;
+        }
+        // Caller must explicitly trust before import: module evaluation executes arbitrary code.
+        let module;
+        try {
+            module = await import(__rewriteRelativeImportExtension(pathToFileURL(path).href));
+        }
+        catch (error) {
+            if (error.code === "ERR_UNKNOWN_FILE_EXTENSION")
+                throw new Error(`Cannot load ${path}: TypeScript plugins need Bun or Node >=22.18 (type stripping); publish plugins as JavaScript.`);
+            throw error;
+        }
+        const plugin = module.default;
+        this.validate(plugin);
+        return { plugin, base: dirname(path) };
+    }
+    validate(plugin) {
+        z.object({
+            id: z.string().regex(/^[a-z0-9][a-z0-9.-]{0,63}$/),
+            version: z.string().regex(/^\d+\.\d+\.\d+(?:-[\w.-]+)?$/),
+            apiVersion: z.literal(1),
+            name: z.string().min(1).optional(),
+            description: z.string().min(1).optional(),
+            categories: z.array(z.literal("model-provider")).optional(),
+            setup: z.function(),
+        })
+            .passthrough()
+            .parse(plugin);
+    }
+    /**
+     * `builtin` is reserved for first-party plugins from the built-in registry: their tools and
+     * commands keep unprefixed names and may declare the `internal` effect.
+     */
+    async activate(plugin, base, options = {}) {
+        const builtin = !!options.builtin;
+        this.validate(plugin);
+        if (this.loaded.has(plugin.id))
+            throw new Error(`Duplicate plugin: ${plugin.id}`);
+        const undo = [];
+        const statusKeys = new Set();
+        const track = (fn) => {
+            undo.push(fn);
+            return fn;
+        };
+        const api = {
+            tools: {
+                register: (tool) => track(this.registry.register(builtin
+                    ? tool
+                    : {
+                        ...tool,
+                        name: `${pluginPrefix(plugin.id)}_${tool.name}`,
+                        // Only built-ins may claim the always-allowed internal effect.
+                        ...(tool.effect === "internal" ? { effect: "external" } : {}),
+                    })),
+            },
+            commands: {
+                register: (name, handler, info) => {
+                    const key = builtin ? name : `${plugin.id}:${name}`;
+                    if (this.commands.has(key))
+                        throw new Error(`Duplicate command ${key}`);
+                    this.commands.set(key, handler);
+                    this.commandInfo.set(key, { ...info, plugin: plugin.id, builtin });
+                    return track(() => {
+                        this.commands.delete(key);
+                        this.commandInfo.delete(key);
+                    });
+                },
+            },
+            events: {
+                on: (handler) => {
+                    this.observers.add(handler);
+                    return track(() => {
+                        this.observers.delete(handler);
+                    });
+                },
+            },
+            context: {
+                register: (provider) => {
+                    this.contexts.push(provider);
+                    return track(() => {
+                        const i = this.contexts.indexOf(provider);
+                        if (i >= 0)
+                            this.contexts.splice(i, 1);
+                    });
+                },
+            },
+            resources: {
+                skills: (path) => {
+                    const entry = {
+                        plugin: plugin.id,
+                        name: plugin.name ?? plugin.id,
+                        dir: resolve(base, path),
+                    };
+                    this.skillSources.push(entry);
+                    track(() => {
+                        this.skillSources = this.skillSources.filter((x) => x !== entry);
+                    });
+                },
+                prompts: (path) => {
+                    const entry = { plugin: plugin.id, dir: resolve(base, path) };
+                    this.promptSources.push(entry);
+                    track(() => {
+                        this.promptSources = this.promptSources.filter((x) => x !== entry);
+                    });
+                },
+                agents: (path) => {
+                    const entry = { plugin: plugin.id, dir: resolve(base, path) };
+                    this.agentSources.push(entry);
+                    track(() => {
+                        this.agentSources = this.agentSources.filter((x) => x !== entry);
+                    });
+                },
+                list: (kind) => (kind === "skills"
+                    ? this.skillSources
+                    : kind === "prompts"
+                        ? this.promptSources
+                        : this.agentSources).map((x) => ({ ...x })),
+            },
+            state: {
+                get: (key) => this.state.getState(plugin.id, key),
+                set: (key, value) => this.state.setState(plugin.id, key, value),
+            },
+            storage: {
+                sqlite: (file) => {
+                    const db = openDatabase(file);
+                    track(() => {
+                        try {
+                            db.close();
+                        }
+                        catch {
+                            /* Already closed by the plugin. */
+                        }
+                    });
+                    return db;
+                },
+            },
+            compaction: {
+                register: (hooks) => {
+                    const entry = { plugin: plugin.id, hooks };
+                    this.compactionHooks.push(entry);
+                    return track(() => {
+                        this.compactionHooks = this.compactionHooks.filter((x) => x !== entry);
+                    });
+                },
+            },
+            session: {
+                onStart: (handler) => {
+                    const entry = { plugin: plugin.id, handler };
+                    this.startHandlers.push(entry);
+                    return track(() => {
+                        this.startHandlers = this.startHandlers.filter((x) => x !== entry);
+                    });
+                },
+                onEnd: (handler) => {
+                    const entry = { plugin: plugin.id, handler };
+                    this.endHandlers.push(entry);
+                    return track(() => {
+                        this.endHandlers = this.endHandlers.filter((x) => x !== entry);
+                    });
+                },
+            },
+            model: {
+                complete: async (request) => {
+                    if (!this.completer)
+                        throw new Error("Model completion is not available yet");
+                    const timeout = AbortSignal.timeout(120_000);
+                    return this.completer({
+                        ...request,
+                        signal: request.signal ? AbortSignal.any([request.signal, timeout]) : timeout,
+                    });
+                },
+            },
+            models: {
+                list: (signal) => {
+                    if (!this.modelsImpl)
+                        throw new Error("Model resolution is not available yet");
+                    return this.modelsImpl.list(signal);
+                },
+                resolve: (reference, signal) => {
+                    if (!this.modelsImpl)
+                        throw new Error("Model resolution is not available yet");
+                    return this.modelsImpl.resolve(reference, signal);
+                },
+            },
+            providers: {
+                register: (provider) => {
+                    if (!this.providers)
+                        throw new Error("Provider registry is not available");
+                    return track(this.providers.register(provider, { plugin: plugin.id, builtin }));
+                },
+            },
+            extensions: {
+                register: (point, provider, options) => track(this.extensions.register(point, provider, {
+                    plugin: plugin.id,
+                    ...(options?.priority !== undefined ? { priority: options.priority } : {}),
+                })),
+            },
+            sessions: {
+                spawn: (spec) => this.sessions.spawn(spec),
+                create: (spec) => this.sessions.create(spec),
+                run: (id, prompt, options) => this.sessions.run(id, prompt, options),
+                get: (id) => this.sessions.get(id),
+                children: (parentId) => this.sessions.children(parentId),
+                ancestors: (id) => this.sessions.ancestors(id),
+                cancel: (id) => this.sessions.cancel(id),
+                enqueue: (id, text) => this.sessions.enqueue(id, text),
+                isRunning: (id) => this.sessions.isRunning(id),
+                capabilities: (id) => this.sessions.capabilities(id),
+                model: (id) => this.sessions.model(id),
+                workspace: (id) => this.sessions.workspace(id),
+                setStatus: (id, status) => this.sessions.setStatus(id, status),
+            },
+            ui: {
+                panel: (id, provider) => {
+                    const key = `${plugin.id}:${id}`;
+                    this.panels.set(key, { plugin: plugin.id, provider });
+                    return track(() => {
+                        this.panels.delete(key);
+                    });
+                },
+                select: async (request) => (this.uiImpl ? this.uiImpl.select(request) : undefined),
+                askQuestions: async (request) => this.uiImpl
+                    ? this.uiImpl.askQuestions(request)
+                    : Object.fromEntries(request.questions.map((q) => [q.id, undefined])),
+                open: (sessionId) => this.uiImpl?.open(sessionId) ?? false,
+                interactive: () => !!this.uiImpl,
+                status: (key, text, detail) => {
+                    const id = `${plugin.id}:${key}`;
+                    if (text === undefined)
+                        this.status.delete(id);
+                    else
+                        this.status.set(id, { plugin: plugin.id, text, ...(detail ? { detail } : {}) });
+                    if (!statusKeys.has(id)) {
+                        statusKeys.add(id);
+                        track(() => {
+                            this.status.delete(id);
+                        });
+                    }
+                    try {
+                        this.onStatusChange?.();
+                    }
+                    catch {
+                        /* UI observers cannot break plugins. */
+                    }
+                },
+            },
+        };
+        try {
+            // Declarative sugar: `extensions: { mascot, "startup-screen" }` registers at priority 0.
+            for (const [point, provider] of Object.entries(plugin.extensions ?? {}))
+                if (provider)
+                    api.extensions.register(point, provider);
+            await plugin.setup(api);
+            this.loaded.set(plugin.id, { plugin, undo, builtin });
+            if (builtin)
+                this.builtins.add(plugin.id);
+            else
+                this.externalCount++;
+        }
+        catch (error) {
+            for (const fn of undo.reverse())
+                fn();
+            await plugin.dispose?.();
+            throw error;
+        }
+    }
+    /** Runs one hook with a host-enforced timeout; the hook receives an abort signal. */
+    async guarded(ms, run) {
+        const controller = new AbortController();
+        let timer;
+        const timeout = new Promise((_, reject) => {
+            timer = setTimeout(() => {
+                const error = new Error(`Timed out after ${ms}ms`);
+                controller.abort(error);
+                reject(error);
+            }, ms);
+        });
+        try {
+            return await Promise.race([run(controller.signal), timeout]);
+        }
+        finally {
+            clearTimeout(timer);
+        }
+    }
+    async beforeCompact(input) {
+        const instructions = [];
+        const fields = {};
+        const failures = [];
+        const owners = new Map();
+        for (const { plugin, hooks } of this.compactionHooks) {
+            if (!hooks.beforeCompact)
+                continue;
+            try {
+                const result = await this.guarded(this.options.hookTimeoutMs ?? 15_000, (signal) => Promise.resolve(hooks.beforeCompact?.({ ...input, signal })));
+                if (result?.instructions)
+                    instructions.push(result.instructions);
+                for (const [name, description] of Object.entries(result?.outputFields ?? {})) {
+                    if (name === "checkpoint" || fields[name] || !/^[a-zA-Z][\w]{0,40}$/.test(name)) {
+                        failures.push({
+                            source: plugin,
+                            hook: "beforeCompact",
+                            error: `Output field rejected: ${name}`,
+                        });
+                        continue;
+                    }
+                    fields[name] = { source: plugin, description };
+                    owners.set(name, plugin);
+                }
+            }
+            catch (error) {
+                failures.push({ source: plugin, hook: "beforeCompact", error: message(error) });
+            }
+        }
+        this.fieldOwners.set(input.sessionId, owners);
+        return { instructions, fields, failures };
+    }
+    async afterCompact(input) {
+        const inject = [];
+        const reports = {};
+        const failures = [];
+        const owners = this.fieldOwners.get(input.sessionId) ?? new Map();
+        this.fieldOwners.delete(input.sessionId);
+        for (const { plugin, hooks } of this.compactionHooks) {
+            if (!hooks.afterCompact)
+                continue;
+            const extracted = Object.fromEntries(Object.entries(input.extracted).filter(([name]) => owners.get(name) === plugin));
+            try {
+                const result = await this.guarded(this.options.hookTimeoutMs ?? 15_000, (signal) => Promise.resolve(hooks.afterCompact?.({ ...input, extracted, signal })));
+                if (result?.injectContext?.trim())
+                    inject.push(result.injectContext);
+                if (result?.report)
+                    reports[plugin] = result.report;
+            }
+            catch (error) {
+                failures.push({ source: plugin, hook: "afterCompact", error: message(error) });
+            }
+        }
+        return { inject, reports, failures };
+    }
+    async sessionStart(input) {
+        const inject = [];
+        const failures = [];
+        for (const { plugin, handler } of this.startHandlers) {
+            try {
+                const text = await this.guarded(this.options.hookTimeoutMs ?? 15_000, (signal) => handler({ ...input, reason: "start", messages: [], signal }));
+                if (typeof text === "string" && text.trim())
+                    inject.push({ source: plugin, text });
+            }
+            catch (error) {
+                failures.push({ source: plugin, hook: "sessionStart", error: message(error) });
+            }
+        }
+        return { inject, failures };
+    }
+    /** Session end hooks run concurrently and are bounded by one host timeout. */
+    async sessionEnd(input) {
+        const failures = [];
+        await Promise.all(this.endHandlers.map(async ({ plugin, handler }) => {
+            try {
+                await this.guarded(this.options.sessionEndTimeoutMs ?? 10_000, (signal) => handler({ ...input, signal }));
+            }
+            catch (error) {
+                failures.push({ source: plugin, hook: "sessionEnd", error: message(error) });
+            }
+        }));
+        return { failures };
+    }
+    /** Loaded plugins (id, version, built-in flag), ordered by id. */
+    metadata() {
+        return [...this.loaded.values()]
+            .map(({ plugin, builtin }) => ({
+            id: plugin.id,
+            version: plugin.version,
+            builtin,
+            ...(plugin.name ? { name: plugin.name } : {}),
+            ...(plugin.description ? { description: plugin.description } : {}),
+            ...((plugin.categories?.length ?? 0) > 0 ||
+                this.providers?.list().some((provider) => provider.plugin === plugin.id)
+                ? {
+                    categories: [
+                        ...new Set([
+                            ...(plugin.categories ?? []),
+                            ...(this.providers?.list().some((provider) => provider.plugin === plugin.id)
+                                ? ["model-provider"]
+                                : []),
+                        ]),
+                    ],
+                }
+                : {}),
+        }))
+            .sort((a, b) => (a.id < b.id ? -1 : a.id > b.id ? 1 : 0));
+    }
+    get hasSessionEndHooks() {
+        return this.endHandlers.length > 0;
+    }
+    /** Conservative ownership check used to protect a live session from plugin removal. */
+    ownsSessionResources(plugin) {
+        return (this.startHandlers.some((entry) => entry.plugin === plugin) ||
+            this.endHandlers.some((entry) => entry.plugin === plugin) ||
+            [...this.panels.values()].some((entry) => entry.plugin === plugin));
+    }
+    emit(event) {
+        for (const observer of this.observers) {
+            try {
+                observer(Object.freeze(structuredClone(event)));
+            }
+            catch {
+                /* Observers cannot break runs. */
+            }
+        }
+    }
+    async close() {
+        const errors = [];
+        for (const { plugin, undo } of [...this.loaded.values()].reverse()) {
+            try {
+                await plugin.dispose?.();
+            }
+            catch (e) {
+                errors.push(e);
+            }
+            finally {
+                for (const fn of undo.reverse())
+                    fn();
+            }
+        }
+        this.loaded.clear();
+        this.externalCount = 0;
+        this.builtins.clear();
+        if (errors.length)
+            throw new AggregateError(errors, "Plugin disposal failed");
+    }
+}
+export async function discoverPlugins(root) {
+    let entries;
+    try {
+        entries = await readdir(root, { withFileTypes: true });
+    }
+    catch (e) {
+        if (e.code === "ENOENT")
+            return [];
+        throw e;
+    }
+    return entries
+        .filter((e) => (e.isFile() && /\.[cm]?[jt]s$/.test(e.name)) || e.isDirectory())
+        .map((e) => join(root, e.name))
+        .sort();
+}

package/dist/providers/openai-compatible.d.ts

@@ -0,0 +1,14 @@
+import type { ModelInfo, ModelProvider, ProviderEvent } from "@alisio/sdk";
+import OpenAI from "openai";
+import type { Config } from "../config.ts";
+export declare class OpenAICompatibleProvider implements ModelProvider {
+    private config;
+    readonly id: string;
+    readonly model: string;
+    private client;
+    constructor(config: Config["provider"], client?: OpenAI);
+    /** Lists models from GET /models. Context window fields are provider extensions. */
+    listModels(signal: AbortSignal): Promise<ModelInfo[]>;
+    stream(request: Parameters<ModelProvider["stream"]>[0]): AsyncIterable<ProviderEvent>;
+    private responses;
+}