@alisio/core 0.1.0-alpha.17 → 0.1.0-alpha.19

package/dist/core/runner.js

@@ -1,4 +1,4 @@
-import { textProjection, textResult, } from "@alisio/sdk";
+import { isEphemeralRunEventType, textProjection, textResult, } from "@alisio/sdk";
 import { checkpointInstructions, estimateTokens, MAX_TRUSTED_WINDOW, parseCheckpointOutput, planCompaction, reduceMessagesToBudget, shouldCompactContext, summarize, summaryMessage, } from "./compaction.js";
 /**
  * Default cumulative token budget for one run: several context windows (each turn re-sends the
@@ -49,8 +49,9 @@ export class AgentRunner {
             ...(compaction ? { compaction: { ...this.options.compaction, ...compaction } } : {}),
         };
     }
-    emitter(sessionId) {
-        const runId = crypto.randomUUID();
+    emitter(sessionId, run = {}) {
+        const runId = run.runId ?? crypto.randomUUID();
+        const correlationId = run.correlationId;
         let seq = 0;
         return (type, data) => {
             const event = {
@@ -62,8 +63,15 @@ export class AgentRunner {
                 timestamp: new Date().toISOString(),
                 data,
             };
-            if (type !== "text_delta" && type !== "tool_progress" && type !== "reasoning_delta")
-                this.options.store.event(sessionId, runId, type, data);
+            if (!isEphemeralRunEventType(type)) {
+                const persisted = correlationId !== undefined
+                    ? this.options.store.event(sessionId, runId, type, data, { correlationId })
+                    : this.options.store.event(sessionId, runId, type, data);
+                if (typeof persisted === "number")
+                    event.eventId = String(persisted);
+            }
+            if (correlationId !== undefined)
+                event.correlationId = correlationId;
             try {
                 this.options.onEvent?.(event);
             }
@@ -147,6 +155,30 @@ export class AgentRunner {
             };
         return { total: undefined, basis: "unknown", compactionAt: 100 };
     }
+    /**
+     * What a tool-less side call about a session needs (for example a `/btw` side question): the
+     * session's provider and model, its system instructions, its ACTIVE history and the current
+     * limits. Claims no lock and writes nothing, so it is safe while a run is active.
+     */
+    async sideContext(sessionId) {
+        const o = this.options;
+        const session = o.store.get(sessionId);
+        const provider = await (o.providerFor?.(session) ?? o.provider);
+        const window = o.contextWindow?.(session.model);
+        return {
+            provider,
+            model: session.model,
+            ...(window !== undefined && window > 0 && window <= MAX_TRUSTED_WINDOW
+                ? { contextWindow: window }
+                : {}),
+            instructions: await o.context.instructions(sessionId),
+            messages: o.store.messages(sessionId),
+            maxContextChars: o.maxContextChars ?? 800_000,
+            maxOutputTokens: o.maxOutputTokens ?? 4096,
+            timeoutMs: o.timeoutMs ?? 300_000,
+            ...(o.reasoningEffort ? { reasoningEffort: o.reasoningEffort } : {}),
+        };
+    }
     /** Change the model used by subsequent turns of a session; recorded in the store. */
     setModel(sessionId, model) {
         const id = model.trim();
@@ -280,7 +312,17 @@ export class AgentRunner {
     }
     async run(sessionId, prompt, signal, options = {}) {
         const controller = this.claim(sessionId);
-        const o = this.options, emit = this.emitter(sessionId);
+        const runId = options.runId ?? crypto.randomUUID();
+        const o = this.options, emit = this.emitter(sessionId, { runId, correlationId: options.correlationId });
+        /** Run journal (v4 stores only): an auxiliary record that never changes the run outcome. */
+        const finish = (status, error) => {
+            try {
+                o.store.endRun?.(runId, { status, usage: usageTotal, ...(error ? { error } : {}) });
+            }
+            catch {
+                /* A journal write failure cannot invalidate an executed run. */
+            }
+        };
         const limit = o.maxContextChars ?? 800_000;
         let tokens = 0, lastText = "", acquired = false;
         const usageTotal = { input: 0, output: 0 };
@@ -296,6 +338,13 @@ export class AgentRunner {
             return options.instructions ? `${base}\n\n${options.instructions}` : base;
         };
         try {
+            o.store.beginRun?.({
+                id: runId,
+                session: sessionId,
+                status: "running",
+                model: o.store.get(sessionId).model,
+                ...(options.correlationId !== undefined ? { correlationId: options.correlationId } : {}),
+            });
             o.store.acquire(sessionId);
             acquired = true;
             o.store.reconcile(sessionId);
@@ -414,6 +463,8 @@ export class AgentRunner {
                 // display-only extension of the persisted transcript and never reach a model prompt
                 // (raw image bytes included). The store keeps the rich parts for TUI replay.
                 const providerMessages = messages.map((m) => m.role === "tool" ? { ...m, result: textProjection(m.result) } : m);
+                const requested = Date.now();
+                let firstDelta;
                 for await (const e of provider.stream({
                     instructions,
                     messages: providerMessages,
@@ -428,6 +479,8 @@ export class AgentRunner {
                         : {}),
                 })) {
                     combined.throwIfAborted();
+                    if (e.type !== "completed")
+                        firstDelta ??= Date.now();
                     if (e.type === "text_delta")
                         emit("text_delta", { delta: e.delta });
                     else if (e.type === "reasoning_delta")
@@ -445,6 +498,7 @@ export class AgentRunner {
                 }
                 if (!completion)
                     throw new Error("Provider stream ended without a completed response");
+                const durationMs = Date.now() - requested;
                 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)))
@@ -466,6 +520,8 @@ export class AgentRunner {
                     calls: completion.calls.length,
                     model,
                     ...(usage ? { usage } : {}),
+                    durationMs,
+                    ...(firstDelta !== undefined ? { ttftMs: firstDelta - requested } : {}),
                 });
                 if (!completion.calls.length) {
                     const final = {
@@ -481,6 +537,7 @@ export class AgentRunner {
                         final.truncated = true;
                     }
                     emit("run_completed", final);
+                    finish("completed");
                     return { sessionId, text: lastText, status: "completed", usage: usageTotal };
                 }
                 const prepared = completion.calls.map((call) => {
@@ -571,7 +628,7 @@ export class AgentRunner {
                             if (decision === "session")
                                 policy[effect] = true;
                         }
-                        o.store.beginCall(sessionId, call);
+                        o.store.beginCall(sessionId, call, { runId, effect });
                         result = await p.tool.execute(p.input, {
                             signal: combined,
                             workspace,
@@ -594,8 +651,11 @@ export class AgentRunner {
                                 }
                                 : {}),
                         });
-                        if (JSON.stringify(result).length > 48_000)
-                            result = textResult(`${JSON.stringify(result).slice(0, 40_000)}\n[tool output truncated]`, result.isError);
+                        // The bound applies to what the model sees (the text projection): display-only
+                        // ui/image parts are bounded by their producers and must not push text over it.
+                        const projected = textProjection(result);
+                        if (JSON.stringify(projected).length > 48_000)
+                            result = textResult(`${JSON.stringify(projected).slice(0, 40_000)}\n[tool output truncated]`, result.isError);
                         if (pendingUpdate && effect === "read") {
                             result = {
                                 ...result,
@@ -664,14 +724,15 @@ export class AgentRunner {
             // can simply prompt again to continue in the same session. The real hard stops remain the
             // token budget (`maxTokens`) and the timeout; the turn count is a safety rail.
             emit("run_turns_exceeded", { turns: maxTurns, maxTurns });
+            finish("turns_exceeded");
             return { sessionId, text: lastText, status: "turns-exceeded", usage: usageTotal };
         }
         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),
-            });
+            const message = cause instanceof Error ? cause.message : String(cause);
+            emit(combined.aborted ? "run_cancelled" : "run_failed", { error: message });
+            finish(combined.aborted ? "cancelled" : "failed", message);
             throw error;
         }
         finally {

package/dist/index.d.ts

@@ -1,9 +1,11 @@
 /** @alisio/core public API: embed the Alisio agent programmatically. */
 export * from "@alisio/sdk";
+export { type ActiveAgent, type AgentPickerItem, activeAgentCatalog, agentCatalogFromState, agentPickerItems, agentRunOptions, BUILTIN_AGENTS, DEFAULT_AGENT_ID, type MainCapableAgentRecord, mainAgentFromRecord, resolveActiveAgent, } from "./agents/active.ts";
 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, isSettableSettingKey, type LoadedConfig, loadConfig, loadConfigWithProvenance, type McpServerSource, overridesSavedProviderProfile, type SettableSettingKey, setConfigValue, setGlobalMcpAllow, setMcpServerEnabled, setProjectPluginEnabled, setProjectSkillEnabled, stateHome, } from "./config.ts";
+export { BUILTIN_COMMANDS, type BuiltinCommand, CommandCatalog, type CommandExecutionContext, type CommandHost, type CommandResult, type CommandSurface, } from "./commands/catalog.ts";
+export { type Config, type ConfigLoadResult, type ConfigProvenance, configFile, configHome, configSchema, isSettableSettingKey, type LoadedConfig, loadConfig, loadConfigWithProvenance, type McpServerSource, overridesSavedProviderProfile, type SettableSettingInfo, type SettableSettingKey, setConfigValue, setGlobalMcpAllow, setMcpServerEnabled, setProjectPluginEnabled, setProjectSkillEnabled, settableSettings, 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 type { ApprovalDecision, ApprovalHandler, ApprovalRequest, BeginRunInput, ContextSource, EndRunInput, EventPage, HookFailure, MessagePage, PageOptions, Policy, RunnerExtensions, RunRecord, RunStatus, Session, SessionStore, StoredEvent, TerminalRunStatus, ToolCallMeta, } from "./core/contracts.ts";
 export { ToolRegistry } from "./core/registry.ts";
 export { AgentRunner, type CompactionResult, defaultTokenBudget, type RunnerOptions, type RunnerSettingsPatch, type RunOptions, } from "./core/runner.ts";
 export { type ExtensionConflict, ExtensionRegistry } from "./extensions/registry.ts";
@@ -13,18 +15,21 @@ export { discoverPlugins, PluginHost, type PluginHostOptions, pluginPrefix, } fr
 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";
+export { maskSecret, 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 { type ExternalDirectoryDecision, type ExternalDirectoryHandler, type ExternalDirectoryRequest, PathAccess, type PathAccessOptions, type ResolvePathOptions, } from "./runtime/access.ts";
+export { BlobStore, type BlobStoreOptions } from "./runtime/blobs.ts";
+export { clipLines, unifiedPatch } from "./runtime/diff.ts";
 export { exists, fileSize, readHead, readJson, readText, which } from "./runtime/fs.ts";
 export { defaultGlobalRoots, isPathSpec, PLUGIN_KEYWORD, resolvePluginSpec, } from "./runtime/modules.ts";
-export { findWorkspace, outsideRootsMessage, safePath } from "./runtime/paths.ts";
+export { findWorkspace, inside, outsideRootsMessage, safePath } from "./runtime/paths.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";
+export { formatSideQuestion, SIDE_QUESTION_DESCRIPTION, SIDE_QUESTION_HISTORY_LIMIT, SIDE_QUESTION_INSTRUCTIONS, SIDE_QUESTION_MAX_CHARS, SIDE_QUESTION_USAGE, SIDE_QUESTIONS_NAMESPACE, type SideQuestionEntry, SideQuestions, type SideQuestionsOptions, sideTranscript, } from "./sessions/side-questions.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";

package/dist/index.js

@@ -1,7 +1,9 @@
 /** @alisio/core public API: embed the Alisio agent programmatically. */
 export * from "@alisio/sdk";
+export { activeAgentCatalog, agentCatalogFromState, agentPickerItems, agentRunOptions, BUILTIN_AGENTS, DEFAULT_AGENT_ID, mainAgentFromRecord, resolveActiveAgent, } from "./agents/active.js";
 export { createApplication, enabledBuiltins, } from "./application.js";
-export { configFile, configHome, configSchema, isSettableSettingKey, loadConfig, loadConfigWithProvenance, overridesSavedProviderProfile, setConfigValue, setGlobalMcpAllow, setMcpServerEnabled, setProjectPluginEnabled, setProjectSkillEnabled, stateHome, } from "./config.js";
+export { BUILTIN_COMMANDS, CommandCatalog, } from "./commands/catalog.js";
+export { configFile, configHome, configSchema, isSettableSettingKey, loadConfig, loadConfigWithProvenance, overridesSavedProviderProfile, setConfigValue, setGlobalMcpAllow, setMcpServerEnabled, setProjectPluginEnabled, setProjectSkillEnabled, settableSettings, 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";
@@ -12,18 +14,21 @@ 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";
+export { maskSecret, ProviderSettingsStore, } from "./providers/settings.js";
 export { ProjectContext, } from "./resources/context.js";
 export { expandSlashPrompt, loadPromptTemplates, parsePromptTemplate, promptSources, renderPromptTemplate, splitArguments, } from "./resources/prompts.js";
 export { Skills, skillRoots, } from "./resources/skills.js";
 export { PathAccess, } from "./runtime/access.js";
+export { BlobStore } from "./runtime/blobs.js";
+export { clipLines, unifiedPatch } from "./runtime/diff.js";
 export { exists, fileSize, readHead, readJson, readText, which } from "./runtime/fs.js";
 export { defaultGlobalRoots, isPathSpec, PLUGIN_KEYWORD, resolvePluginSpec, } from "./runtime/modules.js";
-export { findWorkspace, outsideRootsMessage, safePath } from "./runtime/paths.js";
+export { findWorkspace, inside, outsideRootsMessage, safePath } from "./runtime/paths.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";
+export { formatSideQuestion, SIDE_QUESTION_DESCRIPTION, SIDE_QUESTION_HISTORY_LIMIT, SIDE_QUESTION_INSTRUCTIONS, SIDE_QUESTION_MAX_CHARS, SIDE_QUESTION_USAGE, SIDE_QUESTIONS_NAMESPACE, SideQuestions, sideTranscript, } from "./sessions/side-questions.js";
 export { composeSideBySide, DefaultAlisioMascot, DefaultStartupScreen, infoSection, mascotSection, padEnd, pluginsSection, renderStartup, sanitizeLine, shortenPath, startupTips, stripAnsi, tipsSection, titleSection, truncate, visibleWidth, welcomeSection, } from "./startup/index.js";
 export { hash, objectSchema, registerStandard } from "./tools/standard.js";
 export { getTrust, hashProjectConfig, hasProjectResources, listTrust, resolveTrust, revokeTrust, setTrust, trustStorePath, } from "./trust.js";

package/dist/mcp/rich.js

@@ -16,6 +16,7 @@
  *   `JSON.stringify(result)` behavior verbatim.
  */
 import { textResult } from "@alisio/sdk";
+import { stripAnsi } from "../startup/text.js";
 const scalar = (value) => typeof value === "string"
     ? value
     : typeof value === "number" || typeof value === "boolean" || value === null
@@ -177,6 +178,73 @@ export function renderUiBlockText(block) {
         }
         case "markdown":
             return block.text;
+        case "diff": {
+            const label = [block.caption, block.path].filter(Boolean).join(" · ");
+            const head = label ? `[diff: ${label}]` : "[diff]";
+            if (block.patch !== undefined)
+                return `${head}\n${fenced(block.patch, "diff")}`;
+            return [
+                head,
+                `before:\n${fenced(block.before ?? "", block.lang)}`,
+                `after:\n${fenced(block.after ?? "", block.lang)}`,
+            ].join("\n");
+        }
+        case "terminal": {
+            const status = [
+                block.exitCode !== undefined ? `exit ${block.exitCode}` : "",
+                block.durationMs !== undefined ? `${block.durationMs}ms` : "",
+                block.truncated ? "output truncated" : "",
+            ]
+                .filter(Boolean)
+                .join(" · ");
+            return [
+                block.command ? `$ ${block.command}` : "[terminal]",
+                fenced(stripAnsi(block.output)),
+                status,
+            ]
+                .filter((line) => line !== "")
+                .join("\n");
+        }
+        case "mermaid":
+            return [block.title ? `[mermaid: ${block.title}]` : "", fenced(block.source, "mermaid")]
+                .filter((line) => line !== "")
+                .join("\n");
+        case "math":
+            return block.display ? `$$\n${block.latex}\n$$` : `$${block.latex}$`;
+        case "json":
+            return [
+                block.caption ? `[json: ${block.caption}]` : "",
+                fenced(jsonText(block.value), "json"),
+            ]
+                .filter((line) => line !== "")
+                .join("\n");
+        case "test-results": {
+            const cases = block.suites.flatMap((suite) => suite.cases.map((c) => `${c.status.toUpperCase()} ${suite.name} › ${c.name}${c.error ? `: ${c.error}` : ""}`));
+            return [`[test-results${block.framework ? `: ${block.framework}` : ""}]`, ...cases].join("\n");
+        }
+        case "progress":
+            return [
+                block.title ? `[progress: ${block.title}]` : "[progress]",
+                ...block.steps.map((step) => `- [${step.status}] ${step.label}${step.detail ? ` (${step.detail})` : ""}`),
+            ].join("\n");
+        default: {
+            // A kind this build does not know (e.g. persisted by a newer Alisio): keep it readable.
+            const kind = String(block.kind ?? "unknown");
+            return `[ui block: ${kind}]\n${fenced(jsonText(block), "json")}`;
+        }
+    }
+}
+function fenced(text, lang) {
+    const body = text.endsWith("\n") ? text : `${text}\n`;
+    return `\`\`\`${lang ?? ""}\n${body}\`\`\``;
+}
+/** `JSON.stringify` that never throws and never returns `undefined`. */
+function jsonText(value) {
+    try {
+        return JSON.stringify(value, null, 2) ?? String(value);
+    }
+    catch {
+        return String(value);
     }
 }
 const base64Bytes = (data) => Math.floor((data.length * 3) / 4);

package/dist/plugins/host.d.ts

@@ -37,6 +37,8 @@ export declare class PluginHost implements RunnerExtensions {
     private startHandlers;
     private endHandlers;
     private fieldOwners;
+    /** Registered tool name → contributing plugin id. */
+    private toolOwners;
     private completer?;
     private modelsImpl?;
     observers: Set<(event: Readonly<RunEvent>) => void>;
@@ -166,6 +168,8 @@ export declare class PluginHost implements RunnerExtensions {
     }>;
     /** Loaded plugins (id, version, built-in flag), ordered by id. */
     metadata(): PluginMetadata[];
+    /** Registered names of the tools a plugin contributes (namespaced unless built in). */
+    toolsOf(plugin: string): string[];
     get hasSessionEndHooks(): boolean;
     /** Conservative ownership check used to protect a live session from plugin removal. */
     ownsSessionResources(plugin: string): boolean;

package/dist/plugins/host.js

@@ -38,6 +38,8 @@ export class PluginHost {
     startHandlers = [];
     endHandlers = [];
     fieldOwners = new Map();
+    /** Registered tool name → contributing plugin id. */
+    toolOwners = new Map();
     completer;
     modelsImpl;
     observers = new Set();
@@ -198,14 +200,22 @@ export class PluginHost {
         };
         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" } : {}),
-                    })),
+                register: (tool) => {
+                    const registered = builtin
+                        ? tool
+                        : {
+                            ...tool,
+                            name: `${pluginPrefix(plugin.id)}_${tool.name}`,
+                            // Only built-ins may claim the always-allowed internal effect.
+                            ...(tool.effect === "internal" ? { effect: "external" } : {}),
+                        };
+                    const unregister = this.registry.register(registered);
+                    this.toolOwners.set(registered.name, plugin.id);
+                    return track(() => {
+                        unregister();
+                        this.toolOwners.delete(registered.name);
+                    });
+                },
             },
             commands: {
                 register: (name, handler, info) => {
@@ -544,6 +554,10 @@ export class PluginHost {
         }))
             .sort((a, b) => (a.id < b.id ? -1 : a.id > b.id ? 1 : 0));
     }
+    /** Registered names of the tools a plugin contributes (namespaced unless built in). */
+    toolsOf(plugin) {
+        return [...this.toolOwners].filter(([, owner]) => owner === plugin).map(([name]) => name);
+    }
     get hasSessionEndHooks() {
         return this.endHandlers.length > 0;
     }

package/dist/providers/settings.d.ts

@@ -9,6 +9,11 @@ export interface ProviderSettings {
     active?: string;
     profiles: Record<string, ProviderProfile>;
 }
+/**
+ * Display form of a secret: its last three characters behind an ellipsis, and nothing at all for
+ * secrets shorter than 16 characters (a tail would reveal too much of them).
+ */
+export declare function maskSecret(secret: string): string | undefined;
 export declare class ProviderSettingsStore {
     readonly profilesPath: string;
     readonly credentialsPath: string;
@@ -27,4 +32,14 @@ export declare class ProviderSettingsStore {
         credentials: Record<string, string>;
     } | undefined>;
     saveActive(name: string, profile: ProviderProfile, secrets: Record<string, string>): Promise<void>;
+    /** Stores or replaces a profile's non-secret values without changing the active profile. */
+    saveProfile(name: string, profile: ProviderProfile): Promise<void>;
+    /** Merges secrets into a profile's stored credentials (write-only: nothing is returned). */
+    setCredentials(name: string, secrets: Record<string, string>): Promise<void>;
+    /** Removes every stored credential of a profile; false when it had none. */
+    deleteCredentials(name: string): Promise<boolean>;
+    /** Which credentials a profile has stored, masked (`maskSecret`); never the values. */
+    credentialStatus(name: string): Promise<Record<string, {
+        tail?: string;
+    }>>;
 }

package/dist/providers/settings.js

@@ -29,6 +29,13 @@ async function atomicJson(path, value, mode) {
     await rename(temporary, path);
     await chmod(path, mode);
 }
+/**
+ * Display form of a secret: its last three characters behind an ellipsis, and nothing at all for
+ * secrets shorter than 16 characters (a tail would reveal too much of them).
+ */
+export function maskSecret(secret) {
+    return secret.length >= 16 ? `…${secret.slice(-3)}` : undefined;
+}
 export class ProviderSettingsStore {
     profilesPath;
     credentialsPath;
@@ -77,4 +84,35 @@ export class ProviderSettingsStore {
         await atomicJson(this.credentialsPath, credentials, 0o600);
         await atomicJson(this.profilesPath, settings, 0o600);
     }
+    /** Stores or replaces a profile's non-secret values without changing the active profile. */
+    async saveProfile(name, profile) {
+        const settings = await this.load();
+        settings.profiles[name] = profile;
+        await atomicJson(this.profilesPath, settings, 0o600);
+    }
+    /** Merges secrets into a profile's stored credentials (write-only: nothing is returned). */
+    async setCredentials(name, secrets) {
+        const credentials = await this.credentials();
+        credentials.providers[name] = { ...(credentials.providers[name] ?? {}), ...secrets };
+        await atomicJson(this.credentialsPath, credentials, 0o600);
+    }
+    /** Removes every stored credential of a profile; false when it had none. */
+    async deleteCredentials(name) {
+        const credentials = await this.credentials();
+        if (!credentials.providers[name] || !Object.keys(credentials.providers[name]).length)
+            return false;
+        delete credentials.providers[name];
+        await atomicJson(this.credentialsPath, credentials, 0o600);
+        return true;
+    }
+    /** Which credentials a profile has stored, masked (`maskSecret`); never the values. */
+    async credentialStatus(name) {
+        const stored = (await this.credentials()).providers[name] ?? {};
+        return Object.fromEntries(Object.entries(stored)
+            .filter(([, value]) => typeof value === "string" && value.length > 0)
+            .map(([key, value]) => {
+            const tail = maskSecret(value);
+            return [key, tail ? { tail } : {}];
+        }));
+    }
 }

package/dist/runtime/blobs.d.ts

@@ -0,0 +1,29 @@
+import type { Attachment, BlobRef, SqlDatabase } from "@alisio/sdk";
+export interface BlobStoreOptions {
+    /** Directory that holds `sha256/…` (by default `<state home>/blobs`). */
+    root: string;
+    /** Session database with the v4 `blobs` table (e.g. `SQLiteStore.db`). */
+    db: SqlDatabase;
+}
+export declare class BlobStore {
+    private readonly options;
+    constructor(options: BlobStoreOptions);
+    /** Absolute file path of a blob. Throws for anything that is not a lowercase sha256 hex. */
+    path(hash: string): string;
+    has(hash: string): boolean;
+    private row;
+    /** Stores bytes once per content hash and returns their reference. */
+    put(bytes: Uint8Array, mimeType: string, dims?: {
+        width?: number;
+        height?: number;
+    }): BlobRef;
+    get(hash: string): {
+        bytes: Buffer;
+        mimeType: string;
+    } | undefined;
+    /**
+     * Resolves a reference into a provider-ready image `Attachment` (base64 `data`), verifying
+     * that the stored bytes still match the hash.
+     */
+    attachment(ref: BlobRef): Attachment;
+}

package/dist/runtime/blobs.js

@@ -0,0 +1,94 @@
+/**
+ * Content-addressed attachment bytes (v4). Files live at `<root>/sha256/<hash[0..2]>/<hash>`
+ * (directories 0700, files 0600, atomic temp-file + rename); metadata lives in the `blobs` table
+ * of the session database. Portable `node:fs`/`node:crypto` only (Node and Bun).
+ *
+ * `Attachment.data` stays required in the SDK, so blobs never reach the runner by reference: the
+ * host resolves a `BlobRef` into a base64 `Attachment` with `attachment()` before `runner.run`.
+ * Persisted messages therefore still carry base64 (as legacy inline attachments do).
+ */
+import { createHash, randomUUID } from "node:crypto";
+import { chmodSync, existsSync, mkdirSync, readFileSync, renameSync, rmSync, writeFileSync, } from "node:fs";
+import { join } from "node:path";
+const HASH = /^[0-9a-f]{64}$/;
+export class BlobStore {
+    options;
+    constructor(options) {
+        this.options = options;
+    }
+    /** Absolute file path of a blob. Throws for anything that is not a lowercase sha256 hex. */
+    path(hash) {
+        if (!HASH.test(hash))
+            throw new Error(`Invalid blob hash: ${hash.slice(0, 80)}`);
+        return join(this.options.root, "sha256", hash.slice(0, 2), hash);
+    }
+    has(hash) {
+        return HASH.test(hash) && existsSync(this.path(hash)) && !!this.row(hash);
+    }
+    row(hash) {
+        return this.options.db.prepare("SELECT * FROM blobs WHERE hash=?").get(hash);
+    }
+    /** Stores bytes once per content hash and returns their reference. */
+    put(bytes, mimeType, dims = {}) {
+        const mime = mimeType.trim();
+        if (!mime || mime.length > 255)
+            throw new Error("A blob needs a MIME type");
+        const hash = createHash("sha256").update(bytes).digest("hex");
+        const file = this.path(hash);
+        if (!existsSync(file)) {
+            const dir = join(this.options.root, "sha256", hash.slice(0, 2));
+            mkdirSync(dir, { recursive: true, mode: 0o700 });
+            chmodSync(dir, 0o700);
+            const temp = join(dir, `.tmp-${randomUUID()}`);
+            try {
+                writeFileSync(temp, bytes, { mode: 0o600, flag: "wx" });
+                renameSync(temp, file);
+            }
+            catch (error) {
+                rmSync(temp, { force: true });
+                throw error;
+            }
+        }
+        this.options.db
+            .prepare("INSERT OR IGNORE INTO blobs(hash,mime,size,width,height,created_at) VALUES(?,?,?,?,?,?)")
+            .run(hash, mime, bytes.byteLength, dims.width ?? null, dims.height ?? null, Date.now());
+        const row = this.row(hash);
+        return {
+            hash,
+            mimeType: row?.mime ?? mime,
+            bytes: bytes.byteLength,
+            ...(row?.width != null ? { width: Number(row.width) } : {}),
+            ...(row?.height != null ? { height: Number(row.height) } : {}),
+        };
+    }
+    get(hash) {
+        if (!HASH.test(hash))
+            return undefined;
+        const row = this.row(hash);
+        const file = this.path(hash);
+        if (!row || !existsSync(file))
+            return undefined;
+        return { bytes: readFileSync(file), mimeType: row.mime };
+    }
+    /**
+     * Resolves a reference into a provider-ready image `Attachment` (base64 `data`), verifying
+     * that the stored bytes still match the hash.
+     */
+    attachment(ref) {
+        const found = this.get(ref.hash);
+        if (!found)
+            throw new Error(`Blob not found: ${ref.hash}`);
+        if (createHash("sha256").update(found.bytes).digest("hex") !== ref.hash)
+            throw new Error(`Blob content does not match its hash: ${ref.hash}`);
+        if (!found.mimeType.startsWith("image/"))
+            throw new Error(`Only image blobs can be attached (got ${found.mimeType})`);
+        return {
+            kind: "image",
+            mimeType: found.mimeType,
+            data: found.bytes.toString("base64"),
+            bytes: found.bytes.byteLength,
+            ...(ref.width !== undefined ? { width: ref.width } : {}),
+            ...(ref.height !== undefined ? { height: ref.height } : {}),
+        };
+    }
+}

package/dist/runtime/diff.d.ts

@@ -0,0 +1,23 @@
+/**
+ * Unified line diffs for the `diff` UiBlock that `write_file`/`edit_file` attach for rich
+ * clients (spec §8.6, RF-13). Myers O((N+M)·D) on lines after trimming the common prefix and
+ * suffix; when the edit distance exceeds `maxD` the middle becomes a full replacement. Pure and
+ * portable (no dependency). The web UI ships its own copy of the algorithm for third-party blocks
+ * that only carry `before`/`after` (packages cannot share code with the browser bundle).
+ */
+type Op = 0 | 1 | 2;
+/** Line edit script (0 equal, 1 delete, 2 insert). */
+export declare function lineEdits(a: string[], b: string[], maxD?: number): Op[];
+/**
+ * A unified patch (`--- a/path`, `+++ b/path`, hunks with `context` lines) from `before` to
+ * `after`; `undefined` means the file did not exist. Identical texts give `""`.
+ */
+export declare function unifiedPatch(path: string, before: string | undefined, after: string | undefined, options?: {
+    context?: number;
+}): string;
+/** Cuts `text` at a line boundary so it fits in `maxBytes` (UTF-8). */
+export declare function clipLines(text: string, maxBytes: number): {
+    text: string;
+    clipped: boolean;
+};
+export {};