@alisio/core 0.1.0-alpha.3

package/dist/providers/openai-compatible.js

@@ -0,0 +1,228 @@
+import OpenAI from "openai";
+const dataUrl = (a) => `data:${a.mimeType};base64,${a.data}`;
+export class OpenAICompatibleProvider {
+    config;
+    id;
+    model;
+    client;
+    constructor(config, client) {
+        this.config = config;
+        this.model = config.model;
+        if (!this.model)
+            throw new Error("Set ALISIO_MODEL, --model, or provider.model");
+        const key = config.auth === "none" ? "unused" : process.env[config.apiKeyEnv];
+        if (!client && !key)
+            throw new Error(`Missing API key environment variable: ${config.apiKeyEnv}`);
+        this.id = `openai-compatible:${config.apiMode}:${config.baseURL.replace(/\/$/, "")}`;
+        this.client =
+            client ??
+                new OpenAI({
+                    baseURL: config.baseURL,
+                    apiKey: key,
+                    maxRetries: 0,
+                    timeout: 120_000,
+                    ...(config.auth === "none" ? { defaultHeaders: { Authorization: null } } : {}),
+                });
+    }
+    /** Lists models from GET /models. Context window fields are provider extensions. */
+    async listModels(signal) {
+        const models = [];
+        for await (const m of this.client.models.list({ signal })) {
+            const extra = m;
+            const window = [extra.context_window, extra.context_length, extra.max_context_length].find((v) => typeof v === "number" && Number.isFinite(v) && v > 0);
+            models.push({ id: m.id, ...(window ? { contextWindow: window } : {}) });
+            if (models.length >= 1000)
+                break;
+        }
+        return models;
+    }
+    async *stream(request) {
+        if (this.config.apiMode === "responses") {
+            yield* this.responses(request);
+            return;
+        }
+        const messages = [
+            { role: "system", content: request.instructions },
+        ];
+        for (const m of request.messages) {
+            if (m.role === "user") {
+                if (m.attachments?.length) {
+                    const parts = [];
+                    if (m.text.trim())
+                        parts.push({ type: "text", text: m.text });
+                    for (const a of m.attachments)
+                        parts.push({ type: "image_url", image_url: { url: dataUrl(a) } });
+                    messages.push({ role: "user", content: parts });
+                }
+                else
+                    messages.push({ role: "user", content: m.text });
+            }
+            else if (m.role === "tool")
+                messages.push({ role: "tool", tool_call_id: m.callId, content: JSON.stringify(m.result) });
+            else
+                messages.push({
+                    role: "assistant",
+                    content: m.text || null,
+                    ...(m.calls.length
+                        ? {
+                            tool_calls: m.calls.map((c) => ({
+                                id: c.id,
+                                type: "function",
+                                function: { name: c.name, arguments: c.arguments },
+                            })),
+                        }
+                        : {}),
+                });
+        }
+        const limit = this.config.tokenParameter === "omit"
+            ? {}
+            : { [this.config.tokenParameter]: request.maxOutputTokens };
+        const stream = await this.client.chat.completions.create({
+            model: request.model || this.model,
+            messages,
+            stream: true,
+            ...limit,
+            ...(this.config.streamUsage ? { stream_options: { include_usage: true } } : {}),
+            ...(request.tools.length || request.nativeTools?.length
+                ? {
+                    tools: [
+                        ...request.tools.map((t) => ({
+                            type: "function",
+                            function: { name: t.name, description: t.description, parameters: t.inputSchema },
+                        })),
+                        ...(request.nativeTools ?? []),
+                    ],
+                }
+                : {}),
+        }, { signal: request.signal });
+        let text = "", finish = null, usage;
+        const calls = new Map();
+        for await (const chunk of stream) {
+            if (chunk.usage) {
+                // DeepSeek reports prompt_cache_hit_tokens; OpenAI uses prompt_tokens_details.
+                const extra = chunk.usage;
+                const cached = chunk.usage.prompt_tokens_details?.cached_tokens ?? extra.prompt_cache_hit_tokens;
+                usage = {
+                    input: chunk.usage.prompt_tokens,
+                    output: chunk.usage.completion_tokens,
+                    ...(typeof cached === "number" ? { cachedInput: cached } : {}),
+                };
+            }
+            const choice = chunk.choices[0];
+            if (!choice)
+                continue;
+            const reasoning = choice.delta.reasoning_content;
+            if (typeof reasoning === "string" && reasoning)
+                yield { type: "reasoning_delta", delta: reasoning };
+            if (choice.delta.content) {
+                text += choice.delta.content;
+                yield { type: "text_delta", delta: choice.delta.content };
+            }
+            if (choice.delta.refusal)
+                throw new Error(`Provider refusal: ${choice.delta.refusal}`);
+            for (const part of choice.delta.tool_calls ?? []) {
+                const c = calls.get(part.index) ?? { id: "", name: "", arguments: "" };
+                if (part.id)
+                    c.id = part.id;
+                if (part.function?.name)
+                    c.name += part.function.name;
+                if (part.function?.arguments)
+                    c.arguments += part.function.arguments;
+                calls.set(part.index, c);
+            }
+            if (choice.finish_reason)
+                finish = choice.finish_reason;
+        }
+        if (finish !== "stop" && finish !== "tool_calls")
+            throw new Error(`Provider response incomplete: ${finish ?? "stream ended"}`);
+        const completed = [...calls.entries()].sort(([a], [b]) => a - b).map(([, c]) => c);
+        if (completed.some((c) => !c.id || !c.name))
+            throw new Error("Incomplete tool call");
+        yield { type: "completed", message: { role: "assistant", text, calls: completed }, usage };
+    }
+    async *responses(request) {
+        const input = [];
+        for (const m of request.messages) {
+            if (m.role === "user") {
+                if (m.attachments?.length) {
+                    const content = [];
+                    if (m.text.trim())
+                        content.push({ type: "input_text", text: m.text });
+                    for (const a of m.attachments)
+                        content.push({ type: "input_image", image_url: dataUrl(a), detail: "auto" });
+                    input.push({ role: "user", content });
+                }
+                else
+                    input.push({ role: "user", content: m.text });
+            }
+            else if (m.role === "tool")
+                input.push({
+                    type: "function_call_output",
+                    call_id: m.callId,
+                    output: JSON.stringify(m.result),
+                });
+            else if (m.providerData)
+                input.push(...m.providerData);
+            else
+                throw new Error("Missing provider continuation data for Responses session");
+        }
+        const stream = await this.client.responses.create({
+            model: request.model || this.model,
+            instructions: request.instructions,
+            input,
+            stream: true,
+            store: false,
+            include: ["reasoning.encrypted_content"],
+            max_output_tokens: request.maxOutputTokens,
+            tools: [
+                ...request.tools.map((t) => ({
+                    type: "function",
+                    name: t.name,
+                    description: t.description,
+                    parameters: t.inputSchema,
+                    strict: false,
+                })),
+                ...(request.nativeTools ?? []),
+            ],
+        }, { signal: request.signal });
+        let complete = false;
+        for await (const event of stream) {
+            if (event.type === "response.output_text.delta")
+                yield { type: "text_delta", delta: event.delta };
+            if (event.type === "response.reasoning_summary_text.delta")
+                yield { type: "reasoning_delta", delta: event.delta };
+            if (event.type === "response.failed" ||
+                event.type === "response.incomplete" ||
+                event.type === "error")
+                throw new Error(`Provider response failed: ${event.type}`);
+            if (event.type === "response.completed") {
+                complete = true;
+                const r = event.response;
+                const calls = r.output
+                    .filter((x) => x.type === "function_call")
+                    .map((x) => ({ id: x.call_id, name: x.name, arguments: x.arguments }));
+                const text = r.output
+                    .filter((x) => x.type === "message")
+                    .flatMap((x) => x.content)
+                    .filter((x) => x.type === "output_text")
+                    .map((x) => x.text)
+                    .join("");
+                yield {
+                    type: "completed",
+                    message: { role: "assistant", text, calls, providerData: r.output },
+                    usage: r.usage
+                        ? {
+                            input: r.usage.input_tokens,
+                            output: r.usage.output_tokens,
+                            ...(typeof r.usage.input_tokens_details?.cached_tokens === "number"
+                                ? { cachedInput: r.usage.input_tokens_details.cached_tokens }
+                                : {}),
+                        }
+                        : undefined,
+                };
+            }
+        }
+        if (!complete)
+            throw new Error("Responses stream ended before completion");
+    }
+}

package/dist/providers/registry.d.ts

@@ -0,0 +1,35 @@
+import type { ModelInfo, ModelProvider, ProviderCreateRequest, ProviderRegistration } from "@alisio/sdk";
+export interface RegisteredProvider extends ProviderRegistration {
+    plugin: string;
+    builtin: boolean;
+}
+/** Additive provider catalog. Registrations are unique by provider id and independently removable. */
+export declare class ProviderRegistry {
+    private entries;
+    register(registration: ProviderRegistration, owner: {
+        plugin: string;
+        builtin: boolean;
+    }): () => void;
+    get(id: string): RegisteredProvider | undefined;
+    list(): RegisteredProvider[];
+    create(id: string, request: ProviderCreateRequest): Promise<ModelProvider>;
+}
+/** Mutable facade keeps runner/plugin completion references stable while the active provider changes. */
+export declare class ActiveProvider implements ModelProvider {
+    private current;
+    constructor(current: ModelProvider);
+    /** Core-only lifecycle access; credentials remain encapsulated by the provider instance. */
+    get currentProvider(): ModelProvider;
+    get id(): string;
+    get model(): string;
+    stream(request: Parameters<ModelProvider["stream"]>[0]): AsyncIterable<import("@alisio/sdk").ProviderEvent>;
+    listModels(signal: AbortSignal): Promise<ModelInfo[]>;
+    /** Swap only after the candidate exists; a failed candidate creation leaves the old provider live. */
+    replace(next: ModelProvider, disposePrevious?: boolean): Promise<void>;
+    dispose(): void | Promise<void> | undefined;
+}
+export declare class UnconfiguredProvider implements ModelProvider {
+    readonly id = "unconfigured";
+    readonly model = "";
+    stream(): AsyncIterable<never>;
+}

package/dist/providers/registry.js

@@ -0,0 +1,74 @@
+/** Additive provider catalog. Registrations are unique by provider id and independently removable. */
+export class ProviderRegistry {
+    entries = new Map();
+    register(registration, owner) {
+        if (!/^[a-z0-9][a-z0-9.-]{0,63}$/.test(registration.id))
+            throw new Error(`Invalid provider id: ${registration.id}`);
+        if (this.entries.has(registration.id))
+            throw new Error(`Duplicate provider: ${registration.id}`);
+        const entry = { ...registration, ...owner };
+        this.entries.set(entry.id, entry);
+        return () => {
+            if (this.entries.get(entry.id) === entry)
+                this.entries.delete(entry.id);
+        };
+    }
+    get(id) {
+        return this.entries.get(id);
+    }
+    list() {
+        return [...this.entries.values()].sort((a, b) => a.name.localeCompare(b.name));
+    }
+    async create(id, request) {
+        const registration = this.entries.get(id);
+        if (!registration)
+            throw new Error(`Unknown provider: ${id}`);
+        return registration.create(request);
+    }
+}
+/** Mutable facade keeps runner/plugin completion references stable while the active provider changes. */
+export class ActiveProvider {
+    current;
+    constructor(current) {
+        this.current = current;
+    }
+    /** Core-only lifecycle access; credentials remain encapsulated by the provider instance. */
+    get currentProvider() {
+        return this.current;
+    }
+    get id() {
+        return this.current.id;
+    }
+    get model() {
+        return this.current.model;
+    }
+    stream(request) {
+        return this.current.stream(request);
+    }
+    listModels(signal) {
+        return this.current.listModels?.(signal) ?? Promise.resolve([]);
+    }
+    /** Swap only after the candidate exists; a failed candidate creation leaves the old provider live. */
+    async replace(next, disposePrevious = true) {
+        const previous = this.current;
+        this.current = next;
+        if (!disposePrevious)
+            return;
+        try {
+            await previous.dispose?.();
+        }
+        catch {
+            // Activation already committed. A stale provider disposal failure must not roll it back.
+        }
+    }
+    dispose() {
+        return this.current.dispose?.();
+    }
+}
+export class UnconfiguredProvider {
+    id = "unconfigured";
+    model = "";
+    async *stream() {
+        throw new Error("No model provider is configured. Use /connect in the TUI or configure one before running headless.");
+    }
+}

package/dist/providers/routing.d.ts

@@ -0,0 +1,11 @@
+import type { AvailableProviderModel, ResolvedProviderModel } from "@alisio/sdk";
+export interface ProviderModelCatalog {
+    profile: string;
+    provider: string;
+    title: string;
+    models: AvailableProviderModel["model"][];
+    unavailable: boolean;
+}
+export declare function availableProviderModels(catalogs: readonly ProviderModelCatalog[]): AvailableProviderModel[];
+/** Resolves canonical provider/model selectors and safe, unique bare model ids. */
+export declare function resolveProviderModel(catalogs: readonly ProviderModelCatalog[], input: string): ResolvedProviderModel;

package/dist/providers/routing.js

@@ -0,0 +1,41 @@
+export function availableProviderModels(catalogs) {
+    return catalogs
+        .flatMap((catalog) => catalog.unavailable
+        ? []
+        : catalog.models.map((model) => ({
+            reference: `${catalog.provider}/${model.id}`,
+            provider: catalog.provider,
+            profile: catalog.profile,
+            providerName: catalog.title,
+            model,
+        })))
+        .sort((a, b) => a.reference.localeCompare(b.reference));
+}
+const choices = (available) => [...new Set(available.map((entry) => entry.reference))].slice(0, 12).join(", ");
+/** Resolves canonical provider/model selectors and safe, unique bare model ids. */
+export function resolveProviderModel(catalogs, input) {
+    const reference = input.trim();
+    if (!reference)
+        throw new Error("Model selector must not be empty");
+    const available = availableProviderModels(catalogs);
+    const providers = [...new Set(catalogs.map((catalog) => catalog.provider))].sort((a, b) => b.length - a.length);
+    const provider = providers.find((id) => reference.startsWith(`${id}/`));
+    let matches;
+    if (provider) {
+        const model = reference.slice(provider.length + 1);
+        const matchingCatalogs = catalogs.filter((catalog) => catalog.provider === provider);
+        matches = available.filter((entry) => entry.provider === provider && entry.model.id === model);
+        if (!matches.length && matchingCatalogs.some((catalog) => catalog.unavailable))
+            throw new Error(`Configured provider "${provider}" is unavailable. Reconnect it with /connect and retry ${reference}.`);
+    }
+    else
+        matches = available.filter((entry) => entry.model.id === reference);
+    if (matches.length === 1)
+        return matches[0];
+    if (matches.length > 1)
+        throw new Error(`Model selector "${reference}" is ambiguous. Use one of: ${choices(matches)}.`);
+    const guidance = choices(available);
+    throw new Error(`Model selector "${reference}" is not available from configured /connect profiles.${guidance
+        ? ` Available provider/model choices: ${guidance}.`
+        : " Configure a provider with /connect first."}`);
+}

package/dist/providers/settings.d.ts

@@ -0,0 +1,30 @@
+import type { ProviderConfigurationValue } from "@alisio/sdk";
+export interface ProviderProfile {
+    provider: string;
+    values: Record<string, ProviderConfigurationValue>;
+    model: string;
+}
+export interface ProviderSettings {
+    schemaVersion: 1;
+    active?: string;
+    profiles: Record<string, ProviderProfile>;
+}
+export declare class ProviderSettingsStore {
+    readonly profilesPath: string;
+    readonly credentialsPath: string;
+    constructor(root?: string);
+    load(): Promise<ProviderSettings>;
+    private credentials;
+    active(): Promise<{
+        name: string;
+        profile: ProviderProfile;
+        credentials: Record<string, string>;
+    } | undefined>;
+    /** Resolves one stored plugin profile for host use. Display layers must not call this. */
+    resolve(name: string): Promise<{
+        name: string;
+        profile: ProviderProfile;
+        credentials: Record<string, string>;
+    } | undefined>;
+    saveActive(name: string, profile: ProviderProfile, secrets: Record<string, string>): Promise<void>;
+}

package/dist/providers/settings.js

@@ -0,0 +1,80 @@
+import { chmod, mkdir, open, readFile, rename } from "node:fs/promises";
+import { dirname, join } from "node:path";
+import { configHome } from "../config.js";
+const emptySettings = () => ({ schemaVersion: 1, profiles: {} });
+const emptyCredentials = () => ({ schemaVersion: 1, providers: {} });
+async function read(path, fallback) {
+    try {
+        return JSON.parse(await readFile(path, "utf8"));
+    }
+    catch (error) {
+        if (error.code === "ENOENT")
+            return fallback;
+        throw error;
+    }
+}
+async function atomicJson(path, value, mode) {
+    await mkdir(dirname(path), { recursive: true, mode: 0o700 });
+    await chmod(dirname(path), 0o700).catch(() => { });
+    const temporary = `${path}.${process.pid}.${crypto.randomUUID()}.tmp`;
+    const handle = await open(temporary, "wx", mode);
+    try {
+        await handle.writeFile(`${JSON.stringify(value, null, 2)}\n`, "utf8");
+        await handle.sync();
+    }
+    finally {
+        await handle.close();
+    }
+    await chmod(temporary, mode);
+    await rename(temporary, path);
+    await chmod(path, mode);
+}
+export class ProviderSettingsStore {
+    profilesPath;
+    credentialsPath;
+    constructor(root = configHome()) {
+        this.profilesPath = join(root, "providers.json");
+        this.credentialsPath = join(root, "credentials.json");
+    }
+    load() {
+        return read(this.profilesPath, emptySettings());
+    }
+    credentials() {
+        return read(this.credentialsPath, emptyCredentials()).then(async (value) => {
+            await chmod(this.credentialsPath, 0o600).catch(() => { });
+            return value;
+        });
+    }
+    async active() {
+        const settings = await this.load();
+        if (!settings.active)
+            return undefined;
+        const profile = settings.profiles[settings.active];
+        if (!profile)
+            return undefined;
+        const credentials = await this.credentials();
+        return {
+            name: settings.active,
+            profile,
+            credentials: credentials.providers[settings.active] ?? {},
+        };
+    }
+    /** Resolves one stored plugin profile for host use. Display layers must not call this. */
+    async resolve(name) {
+        const settings = await this.load();
+        const profile = settings.profiles[name];
+        if (!profile)
+            return undefined;
+        const credentials = await this.credentials();
+        return { name, profile, credentials: credentials.providers[name] ?? {} };
+    }
+    async saveActive(name, profile, secrets) {
+        const [settings, credentials] = await Promise.all([this.load(), this.credentials()]);
+        settings.active = name;
+        settings.profiles[name] = profile;
+        credentials.providers[name] = { ...(credentials.providers[name] ?? {}), ...secrets };
+        // Credentials first: an interrupted update can leave an unused secret, never an active profile without it.
+        await atomicJson(this.credentialsPath, credentials, 0o600);
+        await atomicJson(this.profilesPath, settings, 0o600);
+    }
+}

package/dist/resources/context.d.ts

@@ -0,0 +1,39 @@
+import type { ContextSource } from "../core/contracts.ts";
+export type InstructionKind = "override" | "agents" | "legacy" | "claude";
+export interface InstructionFile {
+    path: string;
+    text: string;
+    kind: InstructionKind;
+}
+export interface ProjectContextOptions {
+    /** Directory holding the global AGENTS.md / AGENTS.override.md. */
+    globalDir?: string;
+    cwd?: string;
+    /** Use CLAUDE.md when a directory has no AGENTS file (default false). */
+    claudeMdFallback?: boolean;
+    /** Total bytes of instruction files (default 32 KiB). */
+    maxBytes?: number;
+}
+export declare class ProjectContext implements ContextSource {
+    readonly workspace: string;
+    extras: Array<() => Promise<string>>;
+    readonly cwd: string;
+    private options;
+    /** Per session: nested instruction file path → fingerprint already attached. */
+    private attached;
+    constructor(workspace: string, options?: ProjectContextOptions);
+    private names;
+    private readDir;
+    /** Directories from the workspace root down to the directory containing `path`. */
+    private chain;
+    private baseFiles;
+    explain(path: string): Promise<InstructionFile[]>;
+    /**
+     * Instruction files for paths a tool is about to touch that are not part of the base walk
+     * and were not attached to this session yet (or changed since). Returns their text.
+     */
+    beforePaths(paths: string[], sessionId?: string): Promise<string | undefined>;
+    instructions(sessionId?: string): Promise<string>;
+    /** Keeps the closest files within the byte budget; drops or truncates the farthest ones. */
+    private capped;
+}