@alisio/core 0.1.0-alpha.3 → 0.1.0-alpha.6

package/dist/core/runner.d.ts

@@ -6,6 +6,11 @@ export interface CompactionSettings {
     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. */
@@ -23,7 +28,8 @@ export interface RunnerOptions {
     maxTokens?: number;
     onEvent?: (event: RunEvent) => void;
     readConcurrency?: number;
-    /** Context window in tokens for a model, when known. Unknown disables auto compaction. */
+    /** 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. */
@@ -101,6 +107,19 @@ export declare class AgentRunner {
     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. */

package/dist/core/runner.js

@@ -1,5 +1,5 @@
 import { textResult, } from "@alisio/sdk";
-import { checkpointInstructions, estimateTokens, parseCheckpointOutput, planCompaction, shouldCompact, summarize, summaryMessage, } from "./compaction.js";
+import { checkpointInstructions, estimateTokens, MAX_TRUSTED_WINDOW, parseCheckpointOutput, planCompaction, shouldCompactContext, 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.
@@ -111,6 +111,24 @@ export class AgentRunner {
             estimateTokens(this.options.store.messages(sessionId)) +
             estimateTokens(this.toolsText(this.availableTools())));
     }
+    /**
+     * 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) {
+        const window = this.options.contextWindow?.(model);
+        if (window !== undefined && window > 0 && window <= MAX_TRUSTED_WINDOW)
+            return {
+                total: window,
+                basis: "window",
+                compactionAt: Math.round((this.options.compaction?.threshold ?? 0.85) * 100),
+            };
+        return { total: undefined, basis: "unknown", compactionAt: 100 };
+    }
     /** Change the model used by subsequent turns of a session; recorded in the store. */
     setModel(sessionId, model) {
         const id = model.trim();
@@ -183,12 +201,12 @@ export class AgentRunner {
             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, {
+            const { text: raw, truncated: summaryTruncated } = await summarize(provider, {
                 instructions: checkpointInstructions(contribution.instructions, fields),
                 messages: plan.summarized,
                 focus,
                 model,
-                maxOutputTokens: o.maxOutputTokens ?? 4096,
+                maxOutputTokens: o.compaction?.maxOutputTokens ?? 4096,
                 signal,
                 sessionId,
             });
@@ -230,6 +248,7 @@ export class AgentRunner {
                 summarizedTokens: estimateTokens(plan.summarized),
                 checkpointTokens: estimateTokens(summary.text),
                 plugins: after.reports,
+                ...(summaryTruncated ? { partial: true } : {}),
             });
             return { replaced: plan.cut, before, after: afterTokens, summary };
         }
@@ -327,10 +346,12 @@ export class AgentRunner {
                         ? 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)) {
+                // One effective budget: a known window triggers at `used >= window * threshold`; an
+                // unknown (or absurdly large, see MAX_TRUSTED_WINDOW) window falls back to the char
+                // estimate (`chars / 4 >= maxContextChars / 4`). `maxContextChars` below stays as the
+                // post-compaction hard limit.
+                if (compaction.auto !== false &&
+                    shouldCompactContext(used(), chars(), o.contextWindow?.(model), o.maxContextChars ?? 160_000, compaction.threshold ?? 0.85)) {
                     await this.compactLocked(sessionId, emit, model, combined, "auto");
                     instructions = await withPersona();
                     messages = o.store.messages(sessionId);
@@ -338,6 +359,7 @@ export class AgentRunner {
                 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 truncated = false;
                 let usage;
                 for await (const e of provider.stream({
                     instructions,
@@ -358,6 +380,7 @@ export class AgentRunner {
                         if (completion)
                             throw new Error("Provider emitted multiple completions");
                         completion = e.message;
+                        truncated = e.message.truncated === true;
                         usage = e.usage;
                         tokens += (e.usage?.input ?? 0) + (e.usage?.output ?? 0);
                         usageTotal.input += e.usage?.input ?? 0;
@@ -389,7 +412,19 @@ export class AgentRunner {
                     ...(usage ? { usage } : {}),
                 });
                 if (!completion.calls.length) {
-                    emit("run_completed", { tokens, text: lastText });
+                    const final = {
+                        tokens,
+                        text: lastText,
+                    };
+                    if (truncated) {
+                        // The adapter kept a usable answer, but the token budget cut it off.
+                        emit("response_truncated", {
+                            turn: turn + 1,
+                            maxOutputTokens: o.maxOutputTokens ?? 4096,
+                        });
+                        final.truncated = true;
+                    }
+                    emit("run_completed", final);
                     return { sessionId, text: lastText, status: "completed", usage: usageTotal };
                 }
                 const prepared = completion.calls.map((call) => {

package/dist/index.d.ts

@@ -1,8 +1,8 @@
 /** @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 Config, type ConfigLoadResult, type ConfigProvenance, configFile, configHome, configSchema, type LoadedConfig, loadConfig, loadConfigWithProvenance, type McpServerSource, overridesSavedProviderProfile, setGlobalMcpAllow, setMcpServerEnabled, setProjectPluginEnabled, setProjectSkillEnabled, stateHome, } from "./config.ts";
+export { type ContextBudget, checkpointInstructions, completeText, effectiveContextBudget, estimateTokens, MAX_TRUSTED_WINDOW, parseCheckpointOutput, planCompaction, renderCheckpoint, serializeForSummary, shouldCompact, shouldCompactContext, summarize, } 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";
@@ -10,6 +10,7 @@ export { type ExtensionConflict, ExtensionRegistry } from "./extensions/registry
 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 { type CliInstallOptions, cliInstall, INSTALL_TIMEOUT_MS, type InstallPluginInput, type InstallPluginResult, type InstallRunner, installedNpmPlugins, installPlugin, npmInstallTarget, type PluginSpec, parsePluginSpec, pluginTrustRemark, printInstallResult, registerPluginInstallTool, sanitizeNpmError, } from "./plugins/install.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";
@@ -19,7 +20,7 @@ export { type Skill, type SkillCatalogEntry, type SkillRoot, type SkillScope, Sk
 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 { isMissingCommand, type ProcessResult, RIPGREP_INSTALL_HINT, 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";

package/dist/index.js

@@ -1,14 +1,15 @@
 /** @alisio/core public API: embed the Alisio agent programmatically. */
 export * from "@alisio/sdk";
 export { createApplication, enabledBuiltins, } from "./application.js";
-export { configFile, configHome, configSchema, loadConfig, loadConfigWithProvenance, overridesSavedProviderProfile, setMcpServerEnabled, setProjectPluginEnabled, setProjectSkillEnabled, stateHome, } from "./config.js";
-export { checkpointInstructions, completeText, estimateTokens, parseCheckpointOutput, planCompaction, renderCheckpoint, serializeForSummary, shouldCompact, } from "./core/compaction.js";
+export { configFile, configHome, configSchema, loadConfig, loadConfigWithProvenance, overridesSavedProviderProfile, setGlobalMcpAllow, setMcpServerEnabled, setProjectPluginEnabled, setProjectSkillEnabled, stateHome, } from "./config.js";
+export { checkpointInstructions, completeText, effectiveContextBudget, estimateTokens, MAX_TRUSTED_WINDOW, parseCheckpointOutput, planCompaction, renderCheckpoint, serializeForSummary, shouldCompact, shouldCompactContext, summarize, } from "./core/compaction.js";
 export { ToolRegistry } from "./core/registry.js";
 export { AgentRunner, defaultTokenBudget, } from "./core/runner.js";
 export { ExtensionRegistry } from "./extensions/registry.js";
 export { HerdrBridge } from "./integrations/herdr.js";
 export { McpConnector, } from "./mcp/connector.js";
 export { discoverPlugins, PluginHost, pluginPrefix, } from "./plugins/host.js";
+export { cliInstall, INSTALL_TIMEOUT_MS, installedNpmPlugins, installPlugin, npmInstallTarget, parsePluginSpec, pluginTrustRemark, printInstallResult, registerPluginInstallTool, sanitizeNpmError, } from "./plugins/install.js";
 export { ActiveProvider, ProviderRegistry, UnconfiguredProvider } from "./providers/registry.js";
 export { availableProviderModels, resolveProviderModel, } from "./providers/routing.js";
 export { ProviderSettingsStore, } from "./providers/settings.js";
@@ -18,7 +19,7 @@ export { Skills, skillRoots, } from "./resources/skills.js";
 export { exists, fileSize, readHead, readJson, readText, which } from "./runtime/fs.js";
 export { defaultGlobalRoots, isPathSpec, PLUGIN_KEYWORD, resolvePluginSpec, } from "./runtime/modules.js";
 export { findWorkspace, safePath } from "./runtime/paths.js";
-export { runProcess } from "./runtime/process.js";
+export { isMissingCommand, RIPGREP_INSTALL_HINT, runProcess, } from "./runtime/process.js";
 export { isSqliteExperimentalWarning, openDatabase } from "./runtime/sqlite.js";
 export { SQLiteStore } from "./runtime/store.js";
 export { ChildSessions } from "./sessions/children.js";

package/dist/mcp/connector.d.ts

@@ -48,6 +48,8 @@ export declare class McpConnector {
     constructor(servers: Record<string, ServerConfig>, registry: ToolRegistry, workspace: string, availability?: "allowed" | "disabled" | "read-only", sources?: Record<string, McpServerSource>);
     register(): void;
     grantRuntimePermission(): void;
+    /** Drop the runtime grant: disconnect every server and unregister the bridge (used on revoke). */
+    revokeRuntimePermission(): Promise<void>;
     runtimePermission(): McpServerInfo["runtimePermission"];
     private assertAvailable;
     private client;

package/dist/mcp/connector.js

@@ -3,6 +3,7 @@ import { textResult } from "@alisio/sdk";
 import { Client, StreamableHTTPClientTransport } from "@modelcontextprotocol/client";
 import { StdioClientTransport } from "@modelcontextprotocol/client/stdio";
 import { objectSchema } from "../tools/standard.js";
+import { loadVersion } from "../version.js";
 const TOOL_NAME_LIMIT = 64;
 const semanticSegment = (value, fallback) => value
     .normalize("NFKD")
@@ -138,6 +139,13 @@ export class McpConnector {
         this.availability = "allowed";
         this.register();
     }
+    /** Drop the runtime grant: disconnect every server and unregister the bridge (used on revoke). */
+    async revokeRuntimePermission() {
+        await Promise.all([...this.clients.keys()].map((name) => this.disconnect(name)));
+        for (const undo of this.bridgeUndo.splice(0).reverse())
+            undo();
+        this.availability = "disabled";
+    }
     runtimePermission() {
         return this.availability === "allowed"
             ? "granted"
@@ -212,7 +220,7 @@ export class McpConnector {
         }
         this.statuses.set(name, "connecting");
         this.diagnostics.delete(name);
-        const client = new Client({ name: "alisio", version: "0.1.0-alpha.1" }, { capabilities: {} });
+        const client = new Client({ name: "alisio", version: loadVersion(import.meta.url) }, { capabilities: {} });
         const undo = [];
         const generation = Symbol(name);
         const transport = config.transport === "stdio"

package/dist/plugins/host.js

@@ -566,7 +566,13 @@ export async function discoverPlugins(root) {
         throw e;
     }
     return entries
-        .filter((e) => (e.isFile() && /\.[cm]?[jt]s$/.test(e.name)) || e.isDirectory())
+        .filter(
+    // A root may hold an `npm install --prefix` layout (`node_modules`, package.json/lock);
+    // npm packages there are resolved through the configured `plugins` array instead.
+    (e) => e.name !== "node_modules" &&
+        e.name !== "package.json" &&
+        e.name !== "package-lock.json" &&
+        ((e.isFile() && /\.[cm]?[jt]s$/.test(e.name)) || e.isDirectory()))
         .map((e) => join(root, e.name))
         .sort();
 }

package/dist/plugins/install.d.ts

@@ -0,0 +1,100 @@
+import type { ToolRegistry } from "../core/registry.ts";
+import { type ProcessResult } from "../runtime/process.ts";
+export interface PluginSpec {
+    name: string;
+    version?: string;
+}
+/**
+ * Validates an install spec without touching the network: `npm:<package>[@<version>]` (canonical),
+ * a bare package name (same resolution), and nothing else. Rejects shell metacharacters, `..` /
+ * absolute paths, and unknown prefixes (`registry:`, `git:`, `file:`, URLs) with a clear error.
+ */
+export declare function parsePluginSpec(spec: string): PluginSpec;
+/** The npm argument for a spec: `name`, `name@<version>` or `name@latest` for `--update`. */
+export declare function npmInstallTarget(name: string, version?: string, update?: boolean): string;
+/**
+ * Injectable process runner so tests can substitute a fake `npm` without a network or a PATH shim.
+ * The default runs the real npm with a generous timeout and bounded output.
+ */
+export type InstallRunner = (command: string, args: string[], options: {
+    cwd: string;
+    signal: AbortSignal;
+    env?: Record<string, string>;
+}) => Promise<ProcessResult>;
+export declare const INSTALL_TIMEOUT_MS = 300000;
+export interface InstallPluginInput {
+    /** `npm:<package>[@<version>]` or a bare package name. */
+    spec: string;
+    /** Defaults to `configHome()` (ALISIO_CONFIG_HOME, else ~/.config/alisio). */
+    configHome?: string;
+    /** Refresh an already-installed package to `@latest`, keeping the npm name in the config. */
+    update?: boolean;
+    /** Refuse immediately; loading and installing executable plugins is disabled under --read-only. */
+    readOnly?: boolean;
+    signal?: AbortSignal;
+    /** Injected installer for tests (fake npm); defaults to the real npm. */
+    runner?: InstallRunner;
+}
+export interface InstallPluginResult {
+    packageName: string;
+    /** Version read back from the installed package.json, or "unknown". */
+    installedVersion: string;
+    /** `<configHome>/plugins/node_modules/<name>` (a directory). */
+    path: string;
+    /** The npm name persisted in the global configuration `plugins` array. */
+    configEntry: string;
+    /** The global configuration file that received the entry. */
+    configFile: string;
+    pluginsDir: string;
+    /** Already present in the global plugins directory before this call (no npm run performed). */
+    alreadyInstalled: boolean;
+    /** Refreshed to `@latest` by this call. */
+    updated: boolean;
+    /** Plain-text remark about where the plugin loads and how project trust applies. */
+    trustRemark: string;
+}
+/**
+ * Redacts probable secrets from npm output (auth tokens, JWTs, bearer credentials, userinfo in
+ * URLs) and caps the size, so a failing install never echoes credentials to the user.
+ */
+export declare function sanitizeNpmError(text: string, maxLength?: number): string;
+/** The shared install routine used by both the CLI command and the `plugin_install` tool. */
+export declare function installPlugin(input: InstallPluginInput): Promise<InstallPluginResult>;
+/** Final remark about loading and project trust, printed by the CLI and returned by the tool. */
+export declare function pluginTrustRemark(name: string): string;
+export interface CliInstallOptions {
+    spec: string;
+    configHome?: string;
+    /** `--yes`/`--trust-plugin`: skip the interactive pre-install confirmation. */
+    yes?: boolean;
+    update?: boolean;
+    readOnly?: boolean;
+    /** True when the CLI can prompt (interactive TTY, not --json). */
+    interactive?: boolean;
+    /** Print the result as JSON instead of human lines. */
+    json?: boolean;
+    signal?: AbortSignal;
+    runner?: InstallRunner;
+    /** Injectable confirmation for the interactive path (tests); defaults to a readline prompt. */
+    confirm?: () => Promise<boolean>;
+}
+export declare function cliInstall(options: CliInstallOptions): Promise<InstallPluginResult>;
+export declare function printInstallResult(result: InstallPluginResult, options?: {
+    json?: boolean;
+}): void;
+/**
+ * Registers the host-owned `plugin_install` tool (agent capability). It has process effect so it
+ * goes through the existing write/process/external permission gate (TUI approval or
+ * `--allow-process`; never available under `--read-only`, where it is not registered at all).
+ */
+export declare function registerPluginInstallTool(registry: ToolRegistry, options?: {
+    readOnly?: boolean;
+    configHome?: string;
+    runner?: InstallRunner;
+}): void;
+/**
+ * Lists npm packages installed under `<root>/node_modules` that declare the `alisio-plugin`
+ * keyword — the same packages `plugins`-array entries resolve to. Used by `alisio plugins list`
+ * so an installed package shows up alongside file/directory plugins.
+ */
+export declare function installedNpmPlugins(root: string): Promise<string[]>;