@mu-agent/mu 0.2.4 → 0.3.1

package/dist/types/ai/errors.d.ts

@@ -1,4 +1,5 @@
 export type AiErrorKind = "auth" | "rate_limit" | "overloaded" | "context_too_long" | "bad_request" | "not_found" | "network" | "api";
+export declare function isRetryableErrorKind(kind: string | undefined): boolean;
 export declare class AiError extends Error {
     readonly kind: AiErrorKind;
     readonly status?: number;
@@ -11,3 +12,4 @@ export declare class AiError extends Error {
 }
 export declare function isContextTooLongMessage(message: string): boolean;
 export declare function classifyHttpError(status: number, body: string, headers: Headers): AiError;
+export declare function classifyStreamError(payload: unknown, raw: string): AiError;

package/dist/types/ai/index.d.ts

@@ -3,22 +3,23 @@ export type { ModelDiscoveryOptions } from "./catalog.js";
 export { defaultModelId, defaultModelRef, discoverModels, findModel, listModels, modelRef, providerHasCredentials, refreshModels, registerModels, } from "./catalog.js";
 export { addUsage, computeCostUsd, zeroUsage } from "./cost.js";
 export type { AiErrorKind } from "./errors.js";
-export { AiError, classifyHttpError, isContextTooLongMessage } from "./errors.js";
-export { parseJsonWithRepair, parsePartialJson, repairJson, salvageToolArgs } from "./json.js";
+export { AiError, classifyHttpError, classifyStreamError, isContextTooLongMessage, isRetryableErrorKind, } from "./errors.js";
+export { parseJsonWithRepair, parsePartialJson, repairJson, StreamingToolArgs, salvageToolArgs, } from "./json.js";
 export { builtinProviderConfigs, modelApi, providerBaseUrl, providerConfig, providerEnvVars, } from "./provider-config.js";
 export { anthropic, streamAnthropic } from "./providers/anthropic.js";
 export { gemini, streamGemini } from "./providers/gemini.js";
 export { discoverGitHubCopilotModels } from "./providers/github-copilot.js";
+export { discoverInceptionModels, inceptionProvider } from "./providers/inception.js";
 export { discoverLlamaCppModels, llamaCpp } from "./providers/llama-cpp.js";
 export { discoverOpenAICodexModels, openai, openaiCodex, streamOpenAI, } from "./providers/openai.js";
 export { openaiCompletions, streamOpenAICompletions } from "./providers/openai-completions.js";
 export { getProvider, providers, registerProvider } from "./registry.js";
 export type { RetryOpts } from "./retry.js";
-export { withRetries } from "./retry.js";
+export { MAX_TURN_RETRIES, MAX_TURN_RETRY_DELAY_MS, sleep, turnRetryDelayMs, withRetries, } from "./retry.js";
 export type { SseEvent } from "./sse.js";
 export { iterateSse } from "./sse.js";
 export { AssistantStream, EventStream } from "./stream.js";
 export type { Cassette, RecordedInteraction, ReplayCall, ReplayHandle } from "./testing/replay.js";
 export { recordFetch, replayFetch } from "./testing/replay.js";
-export { defaultThinkingLevel, supportedThinkingLevels, thinkingLevelForModel, } from "./thinking.js";
+export { defaultThinkingLevel, supportedThinkingLevels, THINKING_EFFORTS, thinkingEffort, thinkingLevelForModel, } from "./thinking.js";
 export * from "./types.js";

package/dist/types/ai/json.d.ts

@@ -2,3 +2,14 @@ export declare function repairJson(json: string): string;
 export declare function parseJsonWithRepair<T = unknown>(json: string): T;
 export declare function parsePartialJson(text: string): unknown;
 export declare function salvageToolArgs(partialJson: string | undefined): Record<string, unknown>;
+export declare class StreamingToolArgs {
+    private readonly now;
+    private text;
+    private value;
+    private parsedAt;
+    private costMs;
+    constructor(now?: () => number);
+    get json(): string;
+    append(fragment: string): Record<string, unknown>;
+    finish(json?: string): Record<string, unknown>;
+}

package/dist/types/ai/provider-config.d.ts

@@ -7,9 +7,11 @@ export interface BuiltinProviderConfig {
     env: string[];
     auth?: "bearer" | "anthropic" | "google" | "azure" | "cloudflare" | "none";
     headers?: Record<string, string>;
+    cacheBreakpoints?: true | string;
 }
 export declare const builtinProviderConfigs: Map<string, BuiltinProviderConfig>;
 export declare function providerConfig(id: string): BuiltinProviderConfig | undefined;
+export declare function usesCacheBreakpoints(model: ModelInfo): boolean;
 export declare function modelApi(model: ModelInfo): LlmApi;
 export declare function providerBaseUrl(model: ModelInfo): string | undefined;
 export declare function providerEnvVars(provider: string): readonly string[];

package/dist/types/ai/providers/citation-markup.d.ts

@@ -0,0 +1,12 @@
+export declare class CitationMarkupFilter {
+    private held;
+    private consumed;
+    private emitted;
+    private dropSpace;
+    private readonly removed;
+    push(delta: string): string;
+    flush(): string;
+    mapIndex(raw: number): number;
+    private emit;
+}
+export declare function stripCitationMarkup(text: string): string;

package/dist/types/ai/providers/inception.d.ts

@@ -0,0 +1,3 @@
+import type { ModelInfo, Provider, ProviderModelDiscoveryOptions } from "../types.js";
+export declare function discoverInceptionModels(options: ProviderModelDiscoveryOptions): Promise<ModelInfo[] | undefined>;
+export declare const inceptionProvider: Provider;

package/dist/types/ai/retry.d.ts

@@ -1,6 +1,13 @@
+export declare function sleep(ms: number, signal?: AbortSignal): Promise<void>;
 export interface RetryOpts {
     maxRetries?: number;
     maxRetryDelayMs?: number;
     signal?: AbortSignal;
 }
 export declare function withRetries<T>(request: () => Promise<T>, opts?: RetryOpts): Promise<T>;
+export declare const MAX_TURN_RETRIES = 4;
+export declare const MAX_TURN_RETRY_DELAY_MS: number;
+export declare function turnRetryDelayMs(failure: {
+    errorKind?: string;
+    retryAfterMs?: number;
+}, attempt: number): number | undefined;

package/dist/types/ai/sse.d.ts

@@ -2,4 +2,5 @@ export interface SseEvent {
     event: string | null;
     data: string;
 }
-export declare function iterateSse(body: ReadableStream<Uint8Array>, signal?: AbortSignal): AsyncGenerator<SseEvent>;
+export declare const DEFAULT_STREAM_IDLE_TIMEOUT_MS = 300000;
+export declare function iterateSse(body: ReadableStream<Uint8Array>, signal?: AbortSignal, idleTimeoutMs?: number): AsyncGenerator<SseEvent>;

package/dist/types/ai/thinking.d.ts

@@ -1,4 +1,6 @@
 import type { ModelInfo, ThinkingLevel } from "./types.js";
 export declare function supportedThinkingLevels(model: ModelInfo): ThinkingLevel[];
 export declare function defaultThinkingLevel(model: ModelInfo): ThinkingLevel;
+export declare const THINKING_EFFORTS: readonly ThinkingLevel[];
+export declare function thinkingEffort(level: ThinkingLevel): number | undefined;
 export declare function thinkingLevelForModel(model: ModelInfo, requested: ThinkingLevel | undefined): ThinkingLevel;

package/dist/types/ai/types.d.ts

@@ -1,3 +1,4 @@
+import type { AiErrorKind } from "./errors.js";
 export interface TextContent {
     type: "text";
     text: string;
@@ -71,6 +72,8 @@ export interface AssistantMessage {
     usage: Usage;
     stopReason: StopReason;
     errorMessage?: string;
+    errorKind?: AiErrorKind;
+    retryAfterMs?: number;
     timestamp: number;
 }
 export interface ToolResultMessage {
@@ -130,6 +133,7 @@ export interface ModelInfo {
     defaultThinkingLevel?: ThinkingLevel;
     thinkingMode?: "adaptive" | "budget";
     pricing: ModelPricing;
+    inferred?: boolean;
 }
 export type ThinkingLevel = "off" | "none" | "minimal" | "low" | "medium" | "high" | "xhigh" | "max" | "ultra" | (string & {});
 export type Credential = {
@@ -160,6 +164,7 @@ export interface StreamOpts {
     thinkingLevel?: ThinkingLevel;
     signal?: AbortSignal;
     maxRetries?: number;
+    idleTimeoutMs?: number;
     headers?: Record<string, string>;
     fetch?: typeof fetch;
 }

package/dist/types/core/checkpoint.d.ts

@@ -3,9 +3,12 @@ export interface CheckpointDiffFile {
     added: number;
     removed: number;
     hunks: string[];
+    approximate?: boolean;
 }
 export interface CheckpointProvider {
-    snapshot(label?: string): Promise<string | undefined>;
+    readonly coverage?: "full" | "declared";
+    snapshot(label?: string, signal?: AbortSignal): Promise<string | undefined>;
+    snapshotResources?(baseRef: string | undefined, resources: string[], label?: string): Promise<string | undefined>;
     restore(ref: string): Promise<void>;
     restoreResources?(ref: string, resources: string[]): Promise<void>;
     diff(fromRef: string, toRef?: string): Promise<CheckpointDiffFile[]>;

package/dist/types/core/commands.d.ts

@@ -5,6 +5,7 @@ export interface CommandContext {
     print: (text: string) => void;
     getModel: () => string;
     setModel: (ref: string) => void;
+    isRunning?: () => boolean;
 }
 export interface CommandResult {
     handled: boolean;
@@ -14,13 +15,17 @@ export interface CommandResult {
 export interface Command {
     name: string;
     description: string;
-    sessionScoped?: boolean;
+    side?: boolean;
+    fallback?: boolean;
+    kind?: "skill";
+    hidden?: () => boolean;
     run: (ctx: CommandContext) => CommandResult | void | Promise<CommandResult | void>;
 }
 export declare class CommandRegistry {
     private commands;
     register(command: Command): void;
     get(name: string): Command | undefined;
+    all(): Command[];
     list(): Command[];
     has(name: string): boolean;
     parse(input: string): {

package/dist/types/core/events.d.ts

@@ -24,6 +24,8 @@ export type StreamDelta = {
 } | {
     kind: "toolcall_start";
     contentIndex: number;
+    toolCallId?: string;
+    toolName?: string;
 } | {
     kind: "toolcall_delta";
     contentIndex: number;
@@ -32,6 +34,8 @@ export type StreamDelta = {
     kind: "toolcall_end";
     contentIndex: number;
     toolCallId: string;
+    toolName?: string;
+    args?: Record<string, unknown>;
 };
 export type AgentEndReason = "done" | "aborted" | "budget" | "maxTurns" | "error";
 export type CompactionTrigger = "manual" | "threshold" | "overflow" | "model-change";
@@ -72,6 +76,7 @@ export type AgentEvent = {
     toolCallId: string;
     toolName: string;
     args: unknown;
+    backgroundable?: true;
 } | {
     type: "tool_execution_update";
     toolCallId: string;
@@ -123,6 +128,7 @@ export type AgentEvent = {
     taskId: string;
     command: string;
     background: boolean;
+    startedAt?: number;
 } | {
     type: "task_output";
     taskId: string;
@@ -132,6 +138,37 @@ export type AgentEvent = {
     taskId: string;
     exitCode: number | null;
     status?: "exited" | "killed";
+} | {
+    type: "provider_retry";
+    attempt: number;
+    maxAttempts: number;
+    delayMs: number;
+    errorMessage: string;
+} | {
+    type: "notices_held";
+    count: number;
+} | {
+    type: "thinking_adjusted";
+    model: string;
+    requested: string;
+    level: string;
+    inferredModel?: boolean;
+} | {
+    type: "subagent_started";
+    subagentId: string;
+    toolCallId: string;
+    kind: string;
+    description: string;
+} | {
+    type: "subagent_progress";
+    subagentId: string;
+    details: unknown;
+} | {
+    type: "subagent_ended";
+    subagentId: string;
+    status: "done" | "error" | "stopped";
+    content: ToolResultContent[];
+    details?: unknown;
 } | {
     type: "usage_updated";
     sessionTotals: Usage;

package/dist/types/core/extensions.d.ts

@@ -1,7 +1,7 @@
 import type { ModelInfo, Provider } from "../ai/index.js";
 import { type Command, CommandRegistry } from "./commands.js";
 import type { AgentEvent } from "./events.js";
-import type { AgentMessage } from "./messages.js";
+import type { AgentMessage, CustomMessage } from "./messages.js";
 import type { AnyTool, ToolResult } from "./tools.js";
 export interface ToolCallDirective {
     block?: boolean;
@@ -15,6 +15,7 @@ export interface ToolResultDirective {
 export interface InputDirective {
     consume?: boolean;
     text?: string;
+    context?: CustomMessage[];
 }
 export interface ToolCallHookInfo {
     toolName: string;
@@ -53,11 +54,15 @@ export interface ToolRenderer {
         result?: ToolResult;
     }) => string[];
 }
+export type ContextProvider = (messages: AgentMessage[], context: {
+    sessionId: string;
+}) => AgentMessage[] | Promise<AgentMessage[]>;
 export interface ExtensionAPI {
     on<T extends ExtensionEventType>(event: T, handler: (event: ExtensionEventFor<T>) => void): void;
     onToolCall(handler: (info: ToolCallHookInfo) => ToolCallDirective | undefined | Promise<ToolCallDirective | undefined>): void;
     onToolResult(handler: (info: ToolResultHookInfo) => ToolResultDirective | undefined | Promise<ToolResultDirective | undefined>): void;
     onContext(handler: (messages: AgentMessage[]) => AgentMessage[] | Promise<AgentMessage[]>): void;
+    registerContextProvider(provider: ContextProvider): void;
     onInput(handler: (text: string) => InputDirective | undefined | Promise<InputDirective | undefined>): void;
     registerTool(tool: AnyTool): void;
     registerCommand(command: Command): void;
@@ -83,6 +88,7 @@ export declare class ExtensionHost {
     private toolCallHooks;
     private toolResultHooks;
     private contextHooks;
+    private contextProviders;
     private inputHooks;
     register(extension: Extension): Promise<void>;
     shutdown(): Promise<void>;
@@ -92,6 +98,9 @@ export declare class ExtensionHost {
     runToolCallHooks(info: ToolCallHookInfo): Promise<ToolCallDirective | undefined>;
     runToolResultHooks(info: ToolResultHookInfo): Promise<ToolResultDirective | undefined>;
     runContextHooks(messages: AgentMessage[]): Promise<AgentMessage[]>;
+    runContextProviders(messages: AgentMessage[], context: {
+        sessionId: string;
+    }): Promise<AgentMessage[]>;
     runInputHooks(text: string): Promise<InputDirective | undefined>;
     get hasContextHooks(): boolean;
 }

package/dist/types/core/index.d.ts

@@ -5,7 +5,7 @@ export { CommandRegistry } from "./commands.js";
 export type { CompactionPlan, CompactionRequest, CompactionResult, CompactorOptions, ContextState, } from "./compaction.js";
 export { AUTO_COMPACT_THRESHOLD, applyCompaction, CompactionError, compact, compactionSummaryMessage, contextState, DEFAULT_KEEP_RECENT_TOKENS, estimateTextTokens, estimateTokens, formatCarryover, planCompaction, SUMMARY_PROMPT, serializeCompactionMessages, shouldCompact, } from "./compaction.js";
 export type { AgentEndReason, AgentEvent, AgentEventType, CompactionProgress, CompactionStage, CompactionTrigger, EventSink, StreamDelta, } from "./events.js";
-export type { Extension, ExtensionAPI, ExtensionEvent, ExtensionEventFor, ExtensionEventType, InputDirective, LifecycleEvent, LifecycleNotification, ToolCallDirective, ToolCallHookInfo, ToolRenderer, ToolResultDirective, ToolResultHookInfo, } from "./extensions.js";
+export type { ContextProvider, Extension, ExtensionAPI, ExtensionEvent, ExtensionEventFor, ExtensionEventType, InputDirective, LifecycleEvent, LifecycleNotification, ToolCallDirective, ToolCallHookInfo, ToolRenderer, ToolResultDirective, ToolResultHookInfo, } from "./extensions.js";
 export { ExtensionHost } from "./extensions.js";
 export type { AfterToolCallInfo, AgentContext, AgentRunResult, BeforeToolCallInfo, ContextPreparation, LoopConfig, NextTurnDirective, TurnInfo, } from "./loop.js";
 export { AgentEventStream, runAgent, runLoop } from "./loop.js";
@@ -14,14 +14,15 @@ export * from "./messages.js";
 export { customMessage, isCustomMessage, renderCustomMessage, toAiMessages, userMessage, } from "./messages.js";
 export type { MicrocompactionOptions, MicrocompactionResult } from "./microcompaction.js";
 export { IMAGE_TOMBSTONE, MICROCOMPACT_THRESHOLD, microcompact, SUPERSEDE_WITHIN_TURNS, TOMBSTONE, } from "./microcompaction.js";
-export type { PermissionAction, PermissionField, PermissionPreview, PermissionRequest, PermissionRule, PermissionSection, ToolPermissionDetails, } from "./permission.js";
-export { evaluate, permissionPreviewLines } from "./permission.js";
+export type { PermissionAction, PermissionField, PermissionPreview, PermissionReply, PermissionRequest, PermissionRule, PermissionSection, PermissionTarget, SavedPermissionRule, ToolPermissionDetails, } from "./permission.js";
+export { evaluate, evaluateTargets, permissionOutcome, permissionPreviewLines, } from "./permission.js";
 export type { ManagedProcessHandle, ProcessEvents, Spawner, SpawnRequest, TaskInfo, TaskStatus, } from "./process.js";
 export { exitNotification, OutputBuffer, ProcessManager } from "./process.js";
-export type { PermissionMode, PermissionModeTone, Profile, ProfileFactory, ProfileRuntime, ProfileRuntimeHost, ProfileSubagents, TaskSubagentSession, } from "./profile.js";
+export type { PermissionMode, PermissionModeTone, Profile, ProfileFactory, ProfileRuntime, ProfileRuntimeHost, ProfileSideAccess, ProfileSubagents, TaskSubagentSession, } from "./profile.js";
 export type { RecoveryAttempt } from "./recovery.js";
 export { isContextTooLongError, isContextTooLongResult, withContextRecovery, } from "./recovery.js";
 export type { NewTreeEntry, SessionEntry, SessionStore, TreeEntry } from "./session.js";
 export { isTreeEntry, MemorySessionStore, newEntryId, parseEntry, parseSession, SESSION_VERSION, SessionTree, serializeEntry, serializeSession, } from "./session.js";
 export type { AnyTool, Tool, ToolResult } from "./tools.js";
-export { concurrencySafe, errorResult, textResult } from "./tools.js";
+export { canBackground, concurrencySafe, errorResult, textResult } from "./tools.js";
+export { toWireEvent, type WireAgentEvent, WireEventDecoder } from "./wire.js";

package/dist/types/core/loop.d.ts

@@ -34,6 +34,12 @@ export interface ContextPreparation {
     messages: AgentMessage[];
     stop?: boolean;
 }
+export interface BeforeToolCallDirective {
+    block?: boolean;
+    denied?: boolean;
+    reason?: string;
+    rewrittenArgs?: Record<string, unknown>;
+}
 export interface LoopConfig {
     provider: Provider;
     model: ModelInfo;
@@ -42,21 +48,15 @@ export interface LoopConfig {
     maxTurns?: number;
     getSteeringMessages?: () => AgentMessage[] | Promise<AgentMessage[]>;
     getFollowUpMessages?: () => AgentMessage[] | Promise<AgentMessage[]>;
-    beforeToolCall?: (info: BeforeToolCallInfo, signal: AbortSignal) => {
-        block?: boolean;
-        reason?: string;
-        rewrittenArgs?: Record<string, unknown>;
-    } | undefined | Promise<{
-        block?: boolean;
-        reason?: string;
-        rewrittenArgs?: Record<string, unknown>;
-    } | undefined>;
+    getNotices?: () => AgentMessage[] | Promise<AgentMessage[]>;
+    beforeToolCall?: (info: BeforeToolCallInfo, signal: AbortSignal) => BeforeToolCallDirective | undefined | Promise<BeforeToolCallDirective | undefined>;
     afterToolCall?: (info: AfterToolCallInfo, signal: AbortSignal) => ToolResult | undefined | Promise<ToolResult | undefined>;
     shouldStopAfterTurn?: (turn: TurnInfo) => boolean | Promise<boolean>;
     recoverFromError?: (message: AssistantMessage) => boolean | Promise<boolean>;
     prepareNextTurn?: (turn: TurnInfo) => NextTurnDirective | undefined | Promise<NextTurnDirective | undefined>;
     prepareContext?: (messages: AgentMessage[]) => ContextPreparation | AgentMessage[] | Promise<ContextPreparation | AgentMessage[]>;
     transformContext?: (messages: AgentMessage[]) => AgentMessage[] | Promise<AgentMessage[]>;
+    backgroundCalls?: Map<string, AbortController>;
 }
 export interface AgentRunResult {
     messages: AgentMessage[];

package/dist/types/core/messages.d.ts

@@ -1,4 +1,4 @@
-import type { AiMessage, AssistantMessage, ImageContent, TextContent, ToolResultMessage, UserMessage } from "../ai/index.js";
+import type { AiMessage, AssistantMessage, ImageContent, TextContent, ToolResultMessage, Usage, UserMessage } from "../ai/index.js";
 export type { AssistantContent, AssistantMessage, ImageContent, StopReason, TextContent, ThinkingContent, ToolCallContent, ToolResultContent, ToolResultMessage, Usage, UserContent, UserMessage, WebSearchAction, WebSearchCitation, WebSearchContent, } from "../ai/index.js";
 export interface CustomMessage {
     role: "custom";
@@ -8,6 +8,8 @@ export interface CustomMessage {
     retention?: {
         key: string;
     };
+    details?: unknown;
+    usage?: Usage;
     timestamp: number;
 }
 export type AgentMessage = UserMessage | AssistantMessage | ToolResultMessage | CustomMessage;

package/dist/types/core/permission.d.ts

@@ -5,6 +5,9 @@ export interface PermissionRule {
     pattern: string;
     action: PermissionAction;
 }
+export interface SavedPermissionRule extends PermissionRule {
+    source: string;
+}
 export interface PermissionRequest {
     id: string;
     toolCallId: string;
@@ -13,6 +16,24 @@ export interface PermissionRequest {
     pattern: string;
     description: string;
     preview?: PermissionPreview;
+    allowRules?: {
+        permission: string;
+        pattern: string;
+    }[];
+}
+export type PermissionReply = "allow" | "deny" | {
+    outcome: "allow" | "deny";
+    message?: string | undefined;
+};
+export declare function permissionOutcome(reply: PermissionReply): {
+    outcome: "allow" | "deny";
+    message?: string;
+};
+export interface PermissionTarget {
+    permission?: string;
+    pattern: string;
+    exact?: boolean;
+    remember?: string;
 }
 export type PermissionPreview = {
     kind: "text";
@@ -37,4 +58,10 @@ export interface ToolPermissionDetails {
     description?: string;
     preview?: PermissionPreview;
 }
-export declare function evaluate(rules: PermissionRule[], permission: string | readonly string[], pattern: string): PermissionAction;
+export declare function evaluate(rules: PermissionRule[], permission: string | readonly string[], pattern: string, options?: {
+    exact?: boolean | undefined;
+}): PermissionAction;
+export declare function evaluateTargets(rules: PermissionRule[], toolName: string, targets: readonly PermissionTarget[]): {
+    action: PermissionAction;
+    asked: PermissionTarget[];
+};

package/dist/types/core/process.d.ts

@@ -1,5 +1,6 @@
 export interface ManagedProcessHandle {
     write: (data: string) => void;
+    acceptsInput?: boolean;
     resize: (cols: number, rows: number) => void;
     detach: () => void;
     kill: () => void;
@@ -23,6 +24,7 @@ export interface TaskInfo {
     outputBytes: number;
     truncated: boolean;
     detached: boolean;
+    acceptsInput?: false;
 }
 export declare class OutputBuffer {
     private headLimit;
@@ -59,10 +61,19 @@ export declare class ProcessManager {
         cols?: number;
         rows?: number;
     }): TaskInfo;
+    adopt(command: string, handle: ManagedProcessHandle, options: {
+        startedAt: number;
+        output?: string;
+    }): {
+        task: TaskInfo;
+        onOutput: (chunk: string) => void;
+    };
+    private prepare;
+    private register;
     get(id: string): TaskInfo | undefined;
     list(): TaskInfo[];
     get runningCount(): number;
-    output(id: string, since?: "start" | "new"): {
+    output(id: string, since?: "start" | "new" | "peek"): {
         text: string;
         truncated: boolean;
     } | undefined;
@@ -76,4 +87,4 @@ export declare class ProcessManager {
     private requestStops;
     wait(id: string): Promise<TaskInfo | undefined>;
 }
-export declare function exitNotification(task: TaskInfo): string;
+export declare function exitNotification(task: TaskInfo, stoppedByUser?: boolean): string;

package/dist/types/core/profile.d.ts

@@ -4,7 +4,7 @@ import type { Command } from "./commands.js";
 import type { AgentEvent } from "./events.js";
 import type { ToolRenderer } from "./extensions.js";
 import type { AgentMessage, CustomMessage } from "./messages.js";
-import type { PermissionRule } from "./permission.js";
+import type { PermissionRule, SavedPermissionRule } from "./permission.js";
 import type { AnyTool } from "./tools.js";
 export type PermissionModeTone = "restrictive" | "permissive" | "unrestricted";
 export interface PermissionMode {
@@ -17,10 +17,17 @@ export interface PermissionMode {
 export interface ProfileRuntimeHost {
     emit: (event: AgentEvent) => void;
     followUp: (message: string | CustomMessage) => void;
+    notify?: (message: CustomMessage) => void;
+    record?: (message: CustomMessage) => void;
 }
 export interface ProfileRuntime {
     attach: (host: ProfileRuntimeHost) => void;
     resize?: (cols: number, rows: number) => void;
+    stopTask?: (taskId: string) => boolean;
+    waitingOnUser?: () => {
+        reason: string;
+        done: Promise<void>;
+    } | undefined;
     stop?: () => void;
     shutdown?: () => void | Promise<void>;
 }
@@ -33,10 +40,13 @@ export interface TaskSubagentSession {
 export interface ProfileSubagents {
     taskSession?: (description: string, signal: AbortSignal) => Promise<TaskSubagentSession>;
     inspectionTools: string[];
-    searchPrompt?: string;
     counselPrompt?: string;
     recallScope?: Record<string, string>;
 }
+export interface ProfileSideAccess {
+    tools: string[];
+    permissions: PermissionRule[];
+}
 export interface Profile {
     name: string;
     toolset: AnyTool[];
@@ -45,11 +55,15 @@ export interface Profile {
     permissionModes?: PermissionMode[];
     defaultPermissionMode?: string;
     rememberPermission?: (permission: string, pattern: string) => void | Promise<void>;
+    savedPermissions?: () => SavedPermissionRule[] | Promise<SavedPermissionRule[]>;
+    forgetPermission?: (rule: SavedPermissionRule) => void | Promise<void>;
     renderers?: Record<string, ToolRenderer>;
     commands?: Command[];
     environment?: () => Promise<Record<string, string>> | Record<string, string>;
     contextMessages?: () => Promise<AgentMessage[]> | AgentMessage[];
     sideBoundary?: () => string;
+    sideAccess?: ProfileSideAccess;
+    contextLabel?: (customType: string) => string | undefined;
     subagents?: ProfileSubagents;
     refreshContext?: (messages: AgentMessage[], context: {
         sessionId: string;
@@ -57,6 +71,8 @@ export interface Profile {
     diagnostics?: string[];
     carryoverExtractor?: (messages: AgentMessage[]) => unknown;
     checkpointProvider?: CheckpointProvider;
+    checkpointUnavailable?: string;
+    checkpointNotice?: string;
     runtime?: ProfileRuntime;
     scope?: () => Promise<string> | string;
 }

package/dist/types/core/session.d.ts

@@ -8,6 +8,10 @@ export type SessionEntry = {
     profile: string;
     environment: Record<string, string>;
     title?: string;
+    forkedFrom?: {
+        sessionId: string;
+        entryId: string | null;
+    };
 } | {
     type: "message";
     id: string;
@@ -94,6 +98,7 @@ export declare class SessionTree {
         type: "session";
     });
     static fromJsonl(jsonl: string): SessionTree;
+    clone(): SessionTree;
     toJsonl(): string;
     get header(): (SessionEntry & {
         type: "session";

package/dist/types/core/testing/fake-provider.d.ts

@@ -1,8 +1,10 @@
-import { type AssistantContent, AssistantStream, type LlmContext, type ModelInfo, type Provider, type StopReason, type StreamOpts, type Usage } from "../../ai/index.js";
+import { type AiErrorKind, type AssistantContent, AssistantStream, type LlmContext, type ModelInfo, type Provider, type StopReason, type StreamOpts, type Usage } from "../../ai/index.js";
 export interface ScriptedTurn {
     content: AssistantContent[];
     stopReason?: StopReason;
     errorMessage?: string;
+    errorKind?: AiErrorKind;
+    retryAfterMs?: number;
     usage?: Partial<Usage>;
     delayMs?: number;
 }

package/dist/types/core/tools.d.ts

@@ -1,5 +1,5 @@
 import type { ToolResultContent, Usage } from "../ai/index.js";
-import type { ToolPermissionDetails } from "./permission.js";
+import type { PermissionTarget, ToolPermissionDetails } from "./permission.js";
 export interface ToolResult {
     content: ToolResultContent[];
     details?: unknown;
@@ -19,12 +19,16 @@ export interface Tool<Args = Record<string, unknown>> {
     isConcurrencySafe?: (args: Args) => boolean;
     executionMode?: "sequential";
     changesState?: boolean | ((args: Args) => boolean);
+    changedResources?: (args: Args) => string[];
     permissionScope?: (args: Args) => string;
     permissionPattern?: (args: Args) => string;
+    permissionTargets?: (args: Args) => PermissionTarget[];
     permissionDetails?: (args: Args) => ToolPermissionDetails | undefined | Promise<ToolPermissionDetails | undefined>;
-    execute: (toolCallId: string, args: Args, signal: AbortSignal, onUpdate?: (partial: ToolResultContent[], details?: unknown) => void) => Promise<ToolResult>;
+    canBackground?: (args: Args) => boolean;
+    execute: (toolCallId: string, args: Args, signal: AbortSignal, onUpdate?: (partial: ToolResultContent[], details?: unknown) => void, background?: AbortSignal) => Promise<ToolResult>;
 }
 export type AnyTool = Tool<any>;
 export declare function errorResult(message: string): ToolResult;
 export declare function textResult(text: string): ToolResult;
+export declare function canBackground(tool: AnyTool, args: unknown): boolean;
 export declare function concurrencySafe(tool: AnyTool, args: unknown): boolean;

package/dist/types/core/wire.d.ts

@@ -0,0 +1,16 @@
+import { type AssistantMessage } from "../ai/index.js";
+import type { AgentEvent, StreamDelta } from "./events.js";
+export type WireAgentEvent = Exclude<AgentEvent, {
+    type: "message_update";
+}> | {
+    type: "message_update";
+    delta: StreamDelta;
+    message?: AssistantMessage;
+};
+export declare function toWireEvent(event: AgentEvent): WireAgentEvent;
+export declare class WireEventDecoder {
+    private partial;
+    private args;
+    decode(event: WireAgentEvent): AgentEvent;
+    private apply;
+}

package/dist/types/profile-browser/actions/input.d.ts

@@ -5,6 +5,7 @@ export interface TypeOptions {
     submit?: boolean;
     keystrokes?: boolean;
     settle?: boolean;
+    choosing?: boolean;
 }
 export declare function typeText(ctx: ActionContext, ref: string, text: string, options?: TypeOptions): Promise<ActionResult>;
 export declare function pressKeys(ctx: ActionContext, keys: string, ref?: string): Promise<ActionResult>;

package/dist/types/profile-browser/agent/handoff.d.ts

@@ -5,10 +5,15 @@ export declare class Handoffs {
     private readonly pollMs;
     private host;
     private timer;
+    private waiting;
     constructor(pollMs?: number);
     attach(host: ProfileRuntimeHost): void;
+    get pending(): {
+        reason: string;
+        done: Promise<void>;
+    } | undefined;
     start(tab: Tab, reason: string): void;
-    cancel(): void;
+    cancel(settle?: boolean): void;
 }
 export declare function handoffTool(browser: BrowserManager, handoffs: Handoffs): import("../../sdk/index.js").Tool<{
     reason: string;