@alisio/core 0.1.0-alpha.9 → 0.1.0

package/dist/application.d.ts

@@ -1,8 +1,20 @@
 import type { AvailableProviderModel, ModelInfo, ModelProvider, Plugin, PluginCategory, ProviderConfigurationValue, ResolvedProviderModel, RunEvent } from "@alisio/sdk";
+import { AgentDefinitionService } from "./agents/service.ts";
+import { CapabilityGrants } from "./analysis/capabilities.ts";
+import { DatasetService } from "./analysis/data/datasets.ts";
+import { AnalysisJanitor } from "./analysis/janitor.ts";
+import { AnalysisJobs } from "./analysis/jobs.ts";
+import { OciRuntime } from "./analysis/oci.ts";
+import { AnalysisRerun } from "./analysis/rerun.ts";
+import { AnalysisRuntimeManager } from "./analysis/runtime-manager.ts";
+import { ArtifactStore } from "./artifacts/store.ts";
+import type { NotifierTiming, TaskWake } from "./background/notify.ts";
+import { BackgroundTasks } from "./background/service.ts";
 import { type SettableSettingKey } from "./config.ts";
 import type { ApprovalHandler } from "./core/contracts.ts";
 import { ToolRegistry } from "./core/registry.ts";
 import { AgentRunner } from "./core/runner.ts";
+import { GoalService } from "./goal/service.ts";
 import { HerdrBridge } from "./integrations/herdr.ts";
 import { McpConnector } from "./mcp/connector.ts";
 import { PluginHost } from "./plugins/host.ts";
@@ -10,7 +22,10 @@ import { ActiveProvider, ProviderRegistry } from "./providers/registry.ts";
 import { ProviderSettingsStore } from "./providers/settings.ts";
 import { ProjectContext } from "./resources/context.ts";
 import { Skills } from "./resources/skills.ts";
+import { type ExternalDirectoryHandler, PathAccess } from "./runtime/access.ts";
+import { BlobStore } from "./runtime/blobs.ts";
 import { SQLiteStore } from "./runtime/store.ts";
+import { SideQuestions } from "./sessions/side-questions.ts";
 export interface AppOptions {
     cwd?: string;
     config?: string;
@@ -23,6 +38,8 @@ export interface AppOptions {
     allowMcp?: boolean;
     readOnly?: boolean;
     allowAgents?: boolean;
+    /** Extra directories the tools may touch outside the workspace (per-run `--add-dir`). */
+    addDirs?: string[];
     noHerdr?: boolean;
     model?: string;
     baseURL?: string;
@@ -45,6 +62,50 @@ export interface AppOptions {
     disablePlugins?: string[];
     /** Interactive approval for write/process tools; ignored in read-only mode. */
     approve?: ApprovalHandler;
+    /** Pre-allow the `analysis.run` capability only (`--allow-analysis`); `--read-only` wins. */
+    allowAnalysis?: boolean;
+    /** `--python <path>`: the interpreter for `python_run` (no discovery). */
+    python?: string;
+    /** Embedders and tests: a ready Python runtime manager instead of the default one. */
+    analysisRuntime?: AnalysisRuntimeManager;
+    /** Embedders and tests: replaces the container engine collaborators (a fake CLI). */
+    analysisOci?: Partial<import("./analysis/oci.ts").OciDeps>;
+    /** Delay before the first background retention sweep (default 30 s; tests use a short one). */
+    analysisSweepDelayMs?: number;
+    /** Recorded as the source of interactive capability decisions (default `tui`). */
+    approvalSource?: "tui" | "web";
+    /**
+     * Interactive approval for a tool path outside the workspace and every declared extra root,
+     * scoped to the containing directory (allow once / session / deny); ignored in read-only mode.
+     */
+    approveExternalDirectory?: ExternalDirectoryHandler;
+    /** Host hooks of the goal runtime (`/goal`). */
+    goals?: {
+        /** The goal of a session changed or was removed (`undefined`): UIs refresh. */
+        onChange?: (sessionId: string, goal: import("./goal/machine.ts").GoalRecord | undefined) => void;
+        /** A breaker observation (counts only). */
+        onLog?: (sessionId: string, log: import("./goal/machine.ts").GoalLog) => void;
+        /** Pause goals whose driving process is gone at startup (default true; tests turn it off). */
+        recover?: boolean;
+    };
+    /** Host hooks of the background-task runtime (`bg_run`). */
+    tasks?: {
+        /**
+         * Starts a run that tells the owner agent about finished tasks. Absent in headless hosts:
+         * no wake-up is ever sent (the tools say so).
+         */
+        wake?: TaskWake;
+        /** A task appeared or changed state (the server turns it into a `tasks_changed` frame). */
+        onChange?: (task: import("@alisio/sdk").BackgroundTaskInfo, rootSession: string) => void;
+        /** Notification timing (tests). */
+        timing?: Partial<NotifierTiming>;
+        /** Delay before the first retention sweep (default 30 s; tests use a short one). */
+        sweepDelayMs?: number;
+        /** Live tasks allowed across this process (default 16). */
+        maxPerProcess?: number;
+        /** SIGTERM → SIGKILL grace of a stop (default 3 s; tests use a short one). */
+        killGraceMs?: number;
+    };
 }
 export interface BuiltinContext {
     workspace: string;
@@ -95,6 +156,7 @@ export declare function enabledBuiltins(available: BuiltinPlugin[], config: Reco
 } & Record<string, unknown>>, disabled?: string[]): BuiltinPlugin[];
 export declare function createApplication(options?: AppOptions): Promise<{
     workspace: string;
+    pathAccess: PathAccess;
     config: import("./config.ts").LoadedConfig;
     prompts: {
         templates: Map<string, import("./index.ts").PromptTemplate>;
@@ -108,6 +170,33 @@ export declare function createApplication(options?: AppOptions): Promise<{
         template: import("./index.ts").PromptTemplate;
     } | undefined;
     store: SQLiteStore;
+    /** Uploaded attachment bytes; resolve a `BlobRef` with `blobs.attachment(ref)` before a run. */
+    blobs: BlobStore;
+    /** Published artifacts of every session (folders under `<state>/artifacts`). */
+    artifacts: ArtifactStore;
+    /** Persisted capability grants (`analysis.run`) and their audit rows. */
+    capabilityGrants: CapabilityGrants;
+    /** Background tasks (`bg_*` tools, `/tasks` panels): admission, state, output, stop. */
+    tasks: BackgroundTasks;
+    /** Session goals (`/goal`): state, user actions, the continuation controller. */
+    goals: GoalService;
+    /** Python discovery and job folders of `python_run`; `enabled` is false under --read-only. */
+    analysis: {
+        enabled: boolean;
+        runtime: AnalysisRuntimeManager;
+        jobs: AnalysisJobs;
+        /** Container runtime of the current configuration (status, pull); mode `managed` ignores it. */
+        oci: {
+            mode: () => "managed" | "oci";
+            runtime: () => OciRuntime;
+        };
+        rerun: AnalysisRerun;
+        janitor: AnalysisJanitor;
+    };
+    /** Keys a project layer set that only the user layer decides (ignored on load). */
+    configDiagnostics: string[];
+    /** Tabular datasets of every session (ingestion, read-only queries, pages). */
+    datasets: DatasetService;
     registry: ToolRegistry;
     context: ProjectContext;
     skills: Skills;
@@ -150,13 +239,16 @@ export declare function createApplication(options?: AppOptions): Promise<{
      * (only when runtime permission was granted). Never includes credentials or command paths.
      */
     mcpStartupFailures(): string[];
-    /** Host-owned interactive consent boundary. Headless callers remain blocked unless flagged. */
+    /**
+     * Host-owned interactive consent boundary: the TUI and the web UI (`alisio serve`, after an
+     * explicit confirmation dialog) may grant. Headless callers remain blocked unless flagged.
+     */
     grantMcpRuntimePermission(request: {
-        source: "interactive-tui";
+        source: "interactive-tui" | "interactive-web";
         confirmed: boolean;
     }): "granted" | "not-granted" | "read-only";
     /** Persist global consent atomically, then grant runtime permission for this process. */
-    rememberGlobalMcpConsent(): Promise<void>;
+    rememberGlobalMcpConsent(source?: "interactive-tui" | "interactive-web"): Promise<void>;
     /**
      * Clear the persisted global consent atomically and drop the runtime permission (disconnecting
      * servers as cleanup does). An explicit this-run `--allow-mcp` flag keeps the grant alive.
@@ -171,6 +263,8 @@ export declare function createApplication(options?: AppOptions): Promise<{
      * (next instructions load), `websearch.provider` mutates the shared config object the search
      * chain reads per call, `pluginHooks.timeoutMs` lands in the plugin host (next hook call),
      * and `tui.*` is persisted for the host to apply. Nothing in this set requires a restart.
+     * `agents.*` (active agent id and reasoning effort) is persisted for the TUI to consume:
+     * the next `/agents`/`/effort` selection and the next prompt already read the live config.
      * `mcp.allow` is deliberately not routed here: it flows through
      * `rememberGlobalMcpConsent`/`revokeGlobalMcpConsent` instead.
      * Throws under `--read-only`. Returns the written config file.
@@ -192,6 +286,14 @@ export declare function createApplication(options?: AppOptions): Promise<{
         profileName: undefined;
     } | undefined;
     runner: AgentRunner;
+    /** `/btw` side questions: tool-less answers about a session outside its conversation. */
+    sideQuestions: SideQuestions;
+    /**
+     * User agent files (`<workspace>/.agents/agents`, `~/.agents/agents`). Every write asks the
+     * subagents plugin (the runtime agent registry) to rediscover through its `/agents reload`
+     * verb and reports whether the saved file is loaded; without the plugin nothing reloads.
+     */
+    agentDefinitions: AgentDefinitionService;
     herdr: HerdrBridge;
     contextWindow: (model: string) => number | undefined;
     /** Effective context budget + compaction point shared by the runner and the TUI bar. */