@alisio/core 0.2.0 → 0.3.0

package/dist/decisions/service.js

@@ -0,0 +1,377 @@
+import { DecisionRequestError, } from "@alisio/sdk";
+import { CircuitBreaker } from "./breaker.js";
+import { splitSupported, validateAnswers, validateRequest } from "./validate.js";
+export const DEFAULT_DECISIONS_CONFIG = {
+    enabled: true,
+    provider: null,
+    timeoutMs: 1500,
+    minConfidence: 0.6,
+    telemetry: true,
+};
+/** `/decisions` asks the provider's health with its own short limit. */
+export const HEALTH_TIMEOUT_MS = 1000;
+/** `decide()` failure: the typed counterpart of a `null` from `tryDecide`. */
+export class DecisionError extends Error {
+    reason;
+    constructor(reason, message) {
+        super(message ?? `Decision unavailable: ${reason}`);
+        this.reason = reason;
+        this.name = "DecisionError";
+    }
+}
+const isProviderError = (error) => !!error &&
+    typeof error === "object" &&
+    error.name === "DecisionProviderError" &&
+    typeof error.code === "string";
+const finiteUnits = (usage) => {
+    if (!usage || typeof usage !== "object")
+        return undefined;
+    const out = {};
+    for (const key of ["inputUnits", "outputUnits"]) {
+        const value = usage[key];
+        if (typeof value === "number" && Number.isFinite(value) && value >= 0)
+            out[key] = value;
+    }
+    return Object.keys(out).length ? out : undefined;
+};
+/**
+ * Decision Intelligence service: one active provider (chosen by configuration), request and answer
+ * validation per decision, a core-enforced time limit and a circuit breaker. Without an active
+ * provider it is a silent null object: no metrics, no events.
+ */
+export class DecisionService {
+    registry;
+    config;
+    metrics;
+    now;
+    breaker;
+    /** Registration the breaker state belongs to; a change of provider resets it. */
+    breakerOwner;
+    lifecycle;
+    /** The registration `activate` was last requested for (the one that is active, lifecycle-wise). */
+    lifecycleEntry;
+    lifecycleOn = false;
+    closed = false;
+    /** Per-registration queue: `deactivate` never crosses a still-running `activate`. */
+    queues = new Map();
+    lifecycleError;
+    constructor(deps) {
+        this.registry = deps.registry;
+        this.config = deps.config;
+        this.metrics = deps.metrics;
+        this.now = deps.now ?? (() => Date.now());
+        this.breaker = new CircuitBreaker({ now: this.now, ...deps.breaker });
+        this.lifecycle = deps.lifecycle ?? {};
+        // Registrations that happen after the first `syncActive` (late plugins, removals) follow it.
+        this.registry.onChange(() => {
+            if (this.lifecycleOn)
+                this.syncActive();
+        });
+    }
+    /**
+     * Lifecycle (ADR-11): makes `activate`/`deactivate` follow what the configuration and the
+     * registry say is the active provider. Idempotent, synchronous and never throws: the hooks run
+     * in the background (bounded, serialized per provider, failures recorded). The first call (after
+     * the plugins loaded) also arms the follow-up on registry changes.
+     */
+    syncActive() {
+        if (this.closed)
+            return;
+        this.lifecycleOn = true;
+        const config = this.config();
+        const wanted = config.enabled && config.provider ? this.registry.get(config.provider) : undefined;
+        const previous = this.lifecycleEntry;
+        if (wanted === previous)
+            return;
+        this.lifecycleEntry = wanted;
+        if (previous)
+            this.enqueue(previous, "deactivate");
+        if (wanted)
+            this.enqueue(wanted, "activate");
+    }
+    /** Close: deactivates the active provider (bounded by `timeoutMs`) and stops following changes. */
+    async shutdown(timeoutMs) {
+        this.closed = true;
+        this.lifecycleOn = false;
+        const previous = this.lifecycleEntry;
+        this.lifecycleEntry = undefined;
+        if (!previous)
+            return;
+        await this.enqueue(previous, "deactivate", timeoutMs);
+    }
+    enqueue(entry, phase, timeoutMs) {
+        const next = (this.queues.get(entry) ?? Promise.resolve()).then(() => this.runLifecycle(entry, phase, timeoutMs));
+        this.queues.set(entry, next);
+        return next;
+    }
+    /** Runs one hook with a limit; resolves always (a failure is recorded, never propagated). */
+    async runLifecycle(entry, phase, timeoutMs = this.lifecycle.timeoutMs?.() ?? 15_000) {
+        const { provider } = entry;
+        const hook = provider[phase];
+        if (typeof hook !== "function")
+            return;
+        let timer;
+        try {
+            await Promise.race([
+                Promise.resolve().then(() => hook.call(provider)),
+                new Promise((_, reject) => {
+                    timer = setTimeout(() => reject(new Error(`${phase} timed out after ${timeoutMs}ms`)), timeoutMs);
+                }),
+            ]);
+            if (phase === "activate" && this.lifecycleError?.provider === provider.id)
+                this.lifecycleError = undefined;
+        }
+        catch (error) {
+            const message = error instanceof Error ? error.message : String(error);
+            this.lifecycleError = { provider: provider.id, phase, message, at: this.now() };
+            try {
+                this.lifecycle.log?.(`decision provider ${provider.id}: ${phase} failed: ${message}`);
+            }
+            catch {
+                /* A logger cannot break the lifecycle. */
+            }
+        }
+        finally {
+            clearTimeout(timer);
+        }
+    }
+    active() {
+        const config = this.config();
+        if (!config.enabled || !config.provider)
+            return undefined;
+        const entry = this.registry.get(config.provider);
+        if (!entry)
+            return undefined;
+        if (this.breakerOwner !== entry) {
+            this.breakerOwner = entry;
+            this.breaker.reset();
+        }
+        return { provider: entry.provider, config };
+    }
+    available() {
+        return this.active() !== undefined;
+    }
+    activeProvider() {
+        const active = this.active();
+        return active ? { id: active.provider.id, name: active.provider.name } : null;
+    }
+    async tryDecide(req, opts) {
+        return (await this.attempt(req, opts)).response;
+    }
+    /** Like `tryDecide`, but a missing response throws a typed `DecisionError`. */
+    async decide(req, opts) {
+        const { response, outcome } = await this.attempt(req, opts);
+        if (response)
+            return response;
+        if (outcome?.status === "fallback")
+            throw new DecisionError(outcome.reason);
+        throw new DecisionError(this.config().enabled ? "no_provider" : "disabled");
+    }
+    /**
+     * The full result of one call, with the outcome the run integration turns into an event.
+     * Throws `DecisionRequestError` for a malformed request and rethrows the caller's abort.
+     */
+    async attempt(req, opts = {}, ctx = {}) {
+        validateRequest(req);
+        if (opts.timeoutMs !== undefined && !(Number.isFinite(opts.timeoutMs) && opts.timeoutMs > 0))
+            throw new DecisionRequestError("timeoutMs must be a positive number");
+        if (opts.minConfidence !== undefined &&
+            !(Number.isFinite(opts.minConfidence) && opts.minConfidence >= 0 && opts.minConfidence <= 1))
+            throw new DecisionRequestError("minConfidence must be within [0, 1]");
+        opts.signal?.throwIfAborted();
+        const active = this.active();
+        if (!active)
+            return { response: null };
+        const { provider, config } = active;
+        const timeoutMs = opts.timeoutMs ?? config.timeoutMs;
+        const minConfidence = opts.minConfidence ?? config.minConfidence;
+        const base = {
+            decisionId: req.id,
+            ...(req.pack ? { pack: { ...req.pack } } : {}),
+            provider: provider.id,
+        };
+        const fallback = (reason, latencyMs) => {
+            const outcome = { status: "fallback", ...base, latencyMs, reason };
+            this.metrics.record(outcome, ctx.sessionId);
+            return { response: null, outcome };
+        };
+        const { supported, unsupported } = splitSupported(req, provider);
+        if (supported.length === 0)
+            return fallback("unsupported", 0);
+        const mode = this.breaker.allow();
+        if (mode === "open")
+            return fallback("circuit_open", 0);
+        // From here every path must settle the breaker (probe included).
+        let settled = false;
+        const settle = (verdict) => {
+            if (settled)
+                return;
+            settled = true;
+            this.breaker[verdict]();
+        };
+        const sent = unsupported.length === 0
+            ? req
+            : {
+                ...req,
+                decisions: Object.fromEntries(supported.map((key) => [key, req.decisions[key]])),
+            };
+        const started = this.now();
+        const controller = new AbortController();
+        let timer;
+        let onAbort;
+        const outcome = await new Promise((resolve) => {
+            timer = setTimeout(() => {
+                controller.abort(new DOMException("Decision timed out", "TimeoutError"));
+                resolve({ kind: "timeout" });
+            }, timeoutMs);
+            if (opts.signal) {
+                onAbort = () => {
+                    controller.abort(opts.signal?.reason);
+                    resolve({ kind: "aborted" });
+                };
+                opts.signal.addEventListener("abort", onAbort, { once: true });
+            }
+            let call;
+            try {
+                call = Promise.resolve(provider.decide(sent, { signal: controller.signal, timeoutMs }));
+            }
+            catch (error) {
+                call = Promise.reject(error);
+            }
+            // A provider that ignores the signal must not retain or crash anything after the race ends.
+            call.then((value) => resolve({ kind: "result", value }), (error) => resolve({ kind: "error", error }));
+        }).finally(() => {
+            clearTimeout(timer);
+            if (onAbort)
+                opts.signal?.removeEventListener("abort", onAbort);
+        });
+        const latencyMs = Math.max(0, this.now() - started);
+        try {
+            switch (outcome.kind) {
+                case "aborted":
+                    settle("neutral");
+                    throw opts.signal?.reason ?? new DOMException("Aborted", "AbortError");
+                case "timeout":
+                    settle("failure");
+                    return fallback("timeout", latencyMs);
+                case "error": {
+                    const error = outcome.error;
+                    if (isProviderError(error)) {
+                        switch (error.code) {
+                            case "not_ready":
+                            case "unavailable":
+                                settle("neutral");
+                                return fallback(error.code, latencyMs);
+                            case "timeout":
+                            case "invalid_response":
+                                settle("failure");
+                                return fallback(error.code, latencyMs);
+                            default:
+                                settle("failure");
+                                return fallback("provider_error", latencyMs);
+                        }
+                    }
+                    settle("failure");
+                    return fallback("provider_error", latencyMs);
+                }
+                case "result": {
+                    let accepted;
+                    let rejected;
+                    try {
+                        ({ accepted, rejected } = validateAnswers(sent, provider, outcome.value, minConfidence));
+                    }
+                    catch {
+                        settle("failure");
+                        return fallback("invalid_response", latencyMs);
+                    }
+                    settle("success");
+                    for (const key of unsupported)
+                        rejected[key] = "unsupported";
+                    const confidences = Object.values(accepted).map((a) => a.confidence);
+                    if (confidences.length === 0)
+                        return fallback("all_rejected", latencyMs);
+                    const usage = finiteUnits(outcome.value.usage);
+                    const response = {
+                        provider: provider.id,
+                        latencyMs,
+                        decisions: accepted,
+                        rejected,
+                        ...(usage ? { usage } : {}),
+                    };
+                    const done = {
+                        status: "completed",
+                        ...base,
+                        latencyMs,
+                        decisionCount: confidences.length,
+                        rejectedCount: Object.keys(rejected).length,
+                        confidenceMin: Math.min(...confidences),
+                    };
+                    this.metrics.record(done, ctx.sessionId);
+                    return { response, outcome: done };
+                }
+            }
+        }
+        finally {
+            settle("neutral");
+        }
+    }
+    /** For `/decisions` only: the one place `health()` is called, with its own short limit. */
+    async status(signal) {
+        const config = this.config();
+        const active = this.active();
+        const status = {
+            enabled: config.enabled,
+            configured: config.provider,
+            active: active
+                ? {
+                    id: active.provider.id,
+                    name: active.provider.name,
+                    capabilities: { ...active.provider.capabilities },
+                }
+                : null,
+            registered: this.registry.list(),
+            circuit: this.breaker.state(),
+            ...(this.lifecycleError ? { lastLifecycleError: { ...this.lifecycleError } } : {}),
+        };
+        const health = active?.provider.health;
+        if (!active || typeof health !== "function")
+            return status;
+        const controller = new AbortController();
+        const abort = () => controller.abort(signal?.reason);
+        signal?.addEventListener("abort", abort, { once: true });
+        let timer;
+        try {
+            status.health = await new Promise((resolve) => {
+                timer = setTimeout(() => {
+                    controller.abort(new DOMException("Health check timed out", "TimeoutError"));
+                    resolve({ status: "unavailable", detail: "health check timed out" });
+                }, HEALTH_TIMEOUT_MS);
+                let call;
+                try {
+                    call = Promise.resolve(health.call(active.provider, controller.signal));
+                }
+                catch (error) {
+                    call = Promise.reject(error);
+                }
+                call.then((value) => {
+                    const ok = value &&
+                        ["ready", "starting", "unavailable"].includes(value.status);
+                    resolve(ok
+                        ? {
+                            status: value.status,
+                            ...(typeof value.detail === "string" ? { detail: value.detail } : {}),
+                        }
+                        : { status: "unavailable", detail: "invalid health response" });
+                }, (error) => resolve({
+                    status: "unavailable",
+                    detail: error instanceof Error ? error.message : String(error),
+                }));
+            });
+        }
+        finally {
+            clearTimeout(timer);
+            signal?.removeEventListener("abort", abort);
+        }
+        return status;
+    }
+}

package/dist/decisions/validate.d.ts

@@ -0,0 +1,26 @@
+import { type DecisionAnswer, type DecisionProvider, type DecisionRejection, type DecisionRequest } from "@alisio/sdk";
+export declare const DECISION_LIMITS: {
+    readonly maxDecisions: 16;
+    readonly maxOptions: 20;
+    readonly minOptions: 2;
+    readonly maxLevels: 12;
+    readonly minLevels: 2;
+    readonly stateBytes: number;
+    readonly requestBytes: number;
+};
+/** Pure. Throws `DecisionRequestError` (a `TypeError`) before any provider is called. */
+export declare function validateRequest(req: unknown): asserts req is DecisionRequest;
+/** Which decisions the provider can take and which it cannot (those are never sent). */
+export declare function splitSupported(req: DecisionRequest, provider: Pick<DecisionProvider, "capabilities">): {
+    supported: string[];
+    unsupported: string[];
+};
+/**
+ * Pure. Validates a provider result decision by decision against the request. Answers are rebuilt
+ * from known fields only. A result that is not `{ decisions: {…} }` is a provider failure and
+ * throws `DecisionProviderError("invalid_response")`.
+ */
+export declare function validateAnswers(req: DecisionRequest, provider: Pick<DecisionProvider, "capabilities">, raw: unknown, minConfidence: number): {
+    accepted: Record<string, DecisionAnswer>;
+    rejected: Record<string, DecisionRejection>;
+};

package/dist/decisions/validate.js

@@ -0,0 +1,182 @@
+import { DecisionProviderError, DecisionRequestError, } from "@alisio/sdk";
+export const DECISION_LIMITS = {
+    maxDecisions: 16,
+    maxOptions: 20,
+    minOptions: 2,
+    maxLevels: 12,
+    minLevels: 2,
+    stateBytes: 16 * 1024,
+    requestBytes: 32 * 1024,
+};
+const DECISION_KEY = /^[a-zA-Z][a-zA-Z0-9_]{0,63}$/;
+const REQUEST_ID = /^[a-z0-9][a-z0-9._-]{0,127}$/;
+const LANGUAGE = /^[A-Za-z]{2,3}(-[A-Za-z0-9]{2,8})*$/;
+const encoder = new TextEncoder();
+const isRecord = (value) => !!value && typeof value === "object" && !Array.isArray(value);
+const hasOwn = (object, key) => Object.hasOwn(object, key);
+const nonEmpty = (value) => typeof value === "string" && value.trim().length > 0;
+const unit = (value) => typeof value === "number" && Number.isFinite(value) && value >= 0 && value <= 1;
+function bytes(value, what) {
+    let json;
+    try {
+        json = JSON.stringify(value);
+    }
+    catch {
+        throw new DecisionRequestError(`${what} is not JSON-serializable`);
+    }
+    if (json === undefined)
+        throw new DecisionRequestError(`${what} is not JSON-serializable`);
+    return encoder.encode(json).length;
+}
+function validateDefinition(key, definition) {
+    const at = `decision "${key}"`;
+    if (!isRecord(definition))
+        throw new DecisionRequestError(`${at} must be an object`);
+    if (!nonEmpty(definition.instruction))
+        throw new DecisionRequestError(`${at} needs a non-empty instruction`);
+    switch (definition.type) {
+        case "select": {
+            const options = definition.options;
+            if (!isRecord(options))
+                throw new DecisionRequestError(`${at} needs an options object`);
+            const keys = Object.keys(options);
+            if (keys.length < DECISION_LIMITS.minOptions || keys.length > DECISION_LIMITS.maxOptions)
+                throw new DecisionRequestError(`${at} needs ${DECISION_LIMITS.minOptions}..${DECISION_LIMITS.maxOptions} options`);
+            for (const optionKey of keys) {
+                if (!optionKey.trim() || optionKey === "__proto__")
+                    throw new DecisionRequestError(`${at} has an empty or reserved option key`);
+                if (!nonEmpty(options[optionKey]))
+                    throw new DecisionRequestError(`${at} option "${optionKey}" needs a description`);
+            }
+            return;
+        }
+        case "boolean":
+            for (const meaning of ["trueMeaning", "falseMeaning"])
+                if (definition[meaning] !== undefined && !nonEmpty(definition[meaning]))
+                    throw new DecisionRequestError(`${at} ${meaning} must be a non-empty string`);
+            return;
+        case "ordinal": {
+            const levels = definition.levels;
+            if (!Array.isArray(levels) ||
+                levels.length < DECISION_LIMITS.minLevels ||
+                levels.length > DECISION_LIMITS.maxLevels)
+                throw new DecisionRequestError(`${at} needs ${DECISION_LIMITS.minLevels}..${DECISION_LIMITS.maxLevels} levels`);
+            if (!levels.every(nonEmpty))
+                throw new DecisionRequestError(`${at} has an empty level`);
+            if (new Set(levels).size !== levels.length)
+                throw new DecisionRequestError(`${at} has duplicate levels`);
+            return;
+        }
+        default:
+            throw new DecisionRequestError(`${at} has an unknown type`);
+    }
+}
+/** Pure. Throws `DecisionRequestError` (a `TypeError`) before any provider is called. */
+export function validateRequest(req) {
+    if (!isRecord(req))
+        throw new DecisionRequestError("Decision request must be an object");
+    if (req.version !== 1)
+        throw new DecisionRequestError(`Unsupported decision request version: ${String(req.version)}`);
+    if (typeof req.id !== "string" || !REQUEST_ID.test(req.id))
+        throw new DecisionRequestError("Decision request id must match ^[a-z0-9][a-z0-9._-]{0,127}$");
+    if (req.language !== undefined &&
+        (typeof req.language !== "string" || !LANGUAGE.test(req.language)))
+        throw new DecisionRequestError("Decision request language must be a BCP 47 tag");
+    if (req.pack !== undefined) {
+        const pack = req.pack;
+        if (!isRecord(pack) ||
+            typeof pack.id !== "string" ||
+            !REQUEST_ID.test(pack.id) ||
+            !Number.isInteger(pack.version) ||
+            pack.version < 0)
+            throw new DecisionRequestError("Decision request pack must be { id, version }");
+    }
+    if (!("state" in req) || req.state === undefined)
+        throw new DecisionRequestError("Decision request needs a state");
+    if (bytes(req.state, "state") > DECISION_LIMITS.stateBytes)
+        throw new DecisionRequestError(`state exceeds ${DECISION_LIMITS.stateBytes} bytes`);
+    const decisions = req.decisions;
+    if (!isRecord(decisions))
+        throw new DecisionRequestError("Decision request needs decisions");
+    const keys = Object.keys(decisions);
+    if (keys.length < 1 || keys.length > DECISION_LIMITS.maxDecisions)
+        throw new DecisionRequestError(`Decision request needs 1..${DECISION_LIMITS.maxDecisions} decisions`);
+    for (const key of keys) {
+        if (!DECISION_KEY.test(key))
+            throw new DecisionRequestError(`Invalid decision key: ${key.slice(0, 80)}`);
+        validateDefinition(key, decisions[key]);
+    }
+    if (bytes(req, "request") > DECISION_LIMITS.requestBytes)
+        throw new DecisionRequestError(`Decision request exceeds ${DECISION_LIMITS.requestBytes} bytes`);
+}
+/** Which decisions the provider can take and which it cannot (those are never sent). */
+export function splitSupported(req, provider) {
+    const supported = [];
+    const unsupported = [];
+    for (const [key, definition] of Object.entries(req.decisions))
+        (provider.capabilities[definition.type] === true ? supported : unsupported).push(key);
+    return { supported, unsupported };
+}
+function rebuild(definition, raw) {
+    if (!isRecord(raw) || raw.type !== definition.type || !unit(raw.confidence))
+        return undefined;
+    const confidence = raw.confidence;
+    switch (definition.type) {
+        case "select": {
+            if (typeof raw.value !== "string" || !hasOwn(definition.options, raw.value))
+                return undefined;
+            const answer = { type: "select", value: raw.value, confidence };
+            const p = raw.probabilities;
+            if (isRecord(p) &&
+                Object.entries(p).every(([k, v]) => hasOwn(definition.options, k) && unit(v)))
+                answer.probabilities = Object.fromEntries(Object.entries(p));
+            return answer;
+        }
+        case "boolean":
+            if (typeof raw.value !== "boolean" || !unit(raw.probability))
+                return undefined;
+            return { type: "boolean", value: raw.value, confidence, probability: raw.probability };
+        case "ordinal": {
+            if (typeof raw.level !== "string")
+                return undefined;
+            const index = definition.levels.indexOf(raw.level);
+            if (index < 0 || raw.index !== index)
+                return undefined;
+            const answer = { type: "ordinal", level: raw.level, index, confidence };
+            const d = raw.distribution;
+            if (Array.isArray(d) && d.length === definition.levels.length && d.every(unit))
+                answer.distribution = [...d];
+            return answer;
+        }
+    }
+}
+/**
+ * Pure. Validates a provider result decision by decision against the request. Answers are rebuilt
+ * from known fields only. A result that is not `{ decisions: {…} }` is a provider failure and
+ * throws `DecisionProviderError("invalid_response")`.
+ */
+export function validateAnswers(req, provider, raw, minConfidence) {
+    if (!isRecord(raw) || !isRecord(raw.decisions))
+        throw new DecisionProviderError("invalid_response", "Provider result has no decisions object");
+    const answers = raw.decisions;
+    const accepted = {};
+    const rejected = {};
+    for (const [key, definition] of Object.entries(req.decisions)) {
+        if (provider.capabilities[definition.type] !== true) {
+            rejected[key] = "unsupported";
+            continue;
+        }
+        if (!hasOwn(answers, key)) {
+            rejected[key] = "missing";
+            continue;
+        }
+        const answer = rebuild(definition, answers[key]);
+        if (!answer)
+            rejected[key] = "invalid";
+        else if (answer.confidence < minConfidence)
+            rejected[key] = "low_confidence";
+        else
+            accepted[key] = answer;
+    }
+    return { accepted, rejected };
+}

package/dist/goal/host.d.ts

@@ -8,6 +8,8 @@ export interface RunSummary {
         output: number;
     };
     toolCalls?: number;
+    /** Active time of the run: waits for a person are not counted. */
+    activeMs?: number;
 }
 /**
  * The outcome of one run. `cancelled` is whether the run's abort signal fired (the user stopped

package/dist/goal/host.js

@@ -30,7 +30,8 @@ export function goalOutcome(input) {
         text: result?.text ?? "",
         toolCalls: result?.toolCalls ?? stats?.toolCalls ?? 0,
         startedAt: input.startedAt,
-        durationMs: Math.max(0, input.endedAt - input.startedAt),
+        // `goal.maxMinutes` counts the time a run was working, never the time it waited for you.
+        durationMs: Math.max(0, Math.min(input.endedAt - input.startedAt, result?.activeMs ?? stats?.activeMs ?? Number.POSITIVE_INFINITY)),
     };
 }
 /**

package/dist/index.d.ts

@@ -33,11 +33,14 @@ export { changelogNews, compareVersions, formatChangelogMarkdown, isVersion, loa
 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, OCI_IMAGE_PATTERN, 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, ArtifactPublisherFactory, BeginRunInput, CapabilityGate, ContextSource, CoreArtifactPublisher, EndRunInput, EventPage, HookFailure, MessagePage, PageOptions, Policy, PublishedArtifactInfo, RunnerExtensions, RunRecord, RunStatus, Session, SessionStore, StoredEvent, TerminalRunStatus, ToolCallMeta, } from "./core/contracts.ts";
+export type { ApprovalDecision, ApprovalHandler, ApprovalRequest, ArtifactPublisherFactory, BeginRunInput, CapabilityGate, ContextSource, CoreArtifactPublisher, DecisionsFactory, EndRunInput, EventPage, HookFailure, MessagePage, PageOptions, Policy, PublishedArtifactInfo, RunnerExtensions, RunRecord, RunStatus, Session, SessionStore, StoredEvent, TerminalRunStatus, ToolCallMeta, } from "./core/contracts.ts";
+export { HumanWaits } from "./core/human-wait.ts";
 export { EXIT_PLAN_TOOL, GOAL_TOOLS, OPT_IN_TOOLS } from "./core/opt-in.ts";
 export { DEFAULT_MAX_OUTPUT_TOKENS, describeOutputLimitSource, MAX_AUTO_OUTPUT_TOKENS, type OutputLimit, type OutputLimitSource, resolveMaxOutputTokens, } from "./core/output-limit.ts";
 export { ToolRegistry } from "./core/registry.ts";
+export { RunClock } from "./core/run-clock.ts";
 export { AgentRunner, type CompactionResult, defaultTokenBudget, type RunnerOptions, type RunnerSettingsPatch, type RunOptions, } from "./core/runner.ts";
+export { CircuitBreaker, type CircuitBreakerOptions, type CircuitState, DECISION_LIMITS, DEFAULT_DECISIONS_CONFIG, type DecisionAttempt, DecisionError, type DecisionMetricEntry, DecisionMetrics, type DecisionMetricsSnapshot, type DecisionOutcome, DecisionRegistry, DecisionService, type DecisionServiceDeps, type DecisionStatus, type DecisionsConfig, formatDecisionStatsSection, formatDecisionsReport, HEALTH_TIMEOUT_MS, type RegisteredDecisionProvider, splitSupported, validateAnswers, validateRequest, } from "./decisions/index.ts";
 export { type ExtensionConflict, ExtensionRegistry } from "./extensions/registry.ts";
 export * from "./goal/index.ts";
 export { HerdrBridge } from "./integrations/herdr.ts";
@@ -46,7 +49,7 @@ export { describePermissionStatus, type EffectState, effectState, FULL_ACCESS_WA
 export { DIAGRAM_MAX_BYTES, DIAGRAM_MAX_NODES, DIAGRAM_SYNTAXES, DIAGRAMS_MAX_ALLOWED, mermaidProblem, type PlanDiagram, validateDiagrams, } from "./plan/diagrams.ts";
 export { buildPlanManifest, parsePlanHeadings, slugifyHeading, } from "./plan/manifest.ts";
 export { claimApprovedPlan, currentPlan, discardApprovedPlan, IMPLEMENTATION_AGENT_ID, implementationPrompt, PLAN_CONTEXT_MAX_CHARS, PLAN_OPTIONS, PLAN_QUESTION_ID, PLAN_REVIEW_TITLE, PLAN_TEXT_KEY, type PlanFollowUp, type PlanState, type PlanStatus, planHash, readPlanState, settlePlanRun, withdrawPendingPlan, } from "./plan/state.ts";
-export { discoverPlugins, PluginHost, type PluginHostOptions, pluginPrefix, type ViewInfo, ViewRunError, } from "./plugins/host.ts";
+export { discoverPlugins, type PluginEnvironment, PluginHost, type PluginHostOptions, pluginPrefix, type ViewInfo, ViewRunError, } 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";

package/dist/index.js

@@ -33,10 +33,13 @@ export { changelogNews, compareVersions, formatChangelogMarkdown, isVersion, loa
 export { BUILTIN_COMMANDS, CommandCatalog, } from "./commands/catalog.js";
 export { configFile, configHome, configSchema, isSettableSettingKey, loadConfig, loadConfigWithProvenance, OCI_IMAGE_PATTERN, 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 { HumanWaits } from "./core/human-wait.js";
 export { EXIT_PLAN_TOOL, GOAL_TOOLS, OPT_IN_TOOLS } from "./core/opt-in.js";
 export { DEFAULT_MAX_OUTPUT_TOKENS, describeOutputLimitSource, MAX_AUTO_OUTPUT_TOKENS, resolveMaxOutputTokens, } from "./core/output-limit.js";
 export { ToolRegistry } from "./core/registry.js";
+export { RunClock } from "./core/run-clock.js";
 export { AgentRunner, defaultTokenBudget, } from "./core/runner.js";
+export { CircuitBreaker, DECISION_LIMITS, DEFAULT_DECISIONS_CONFIG, DecisionError, DecisionMetrics, DecisionRegistry, DecisionService, formatDecisionStatsSection, formatDecisionsReport, HEALTH_TIMEOUT_MS, splitSupported, validateAnswers, validateRequest, } from "./decisions/index.js";
 export { ExtensionRegistry } from "./extensions/registry.js";
 export * from "./goal/index.js";
 export { HerdrBridge } from "./integrations/herdr.js";