agent-afk 5.1.0 → 5.2.0

package/dist/agent/trace/factory.d.ts

@@ -0,0 +1,10 @@
+import { type TraceWriter } from './writer.js';
+export interface CreateDefaultTraceWriterOptions {
+    sessionLabel?: string;
+}
+export interface CreatedTraceWriter {
+    writer: TraceWriter;
+    tracePath: string;
+    sessionLabel: string;
+}
+export declare function createDefaultTraceWriter(options?: CreateDefaultTraceWriterOptions): CreatedTraceWriter | null;

package/dist/agent/trace/index.d.ts

@@ -0,0 +1,4 @@
+export type { AbortOrigin, AbortPayload, BackgroundAgentCancelledPayload, BackgroundAgentCompletedPayload, BackgroundAgentFailedPayload, BackgroundAgentJoinedPayload, BackgroundAgentPayload, BackgroundAgentStartedPayload, BrowserActAction, BrowserEventPayload, BrowserEventTarget, BrowserEventTool, BudgetPayload, ClaimPayload, ClosurePayload, ClosureReason, CompactionPayloadInput, CompactionPayloadPersisted, CompactionSidecarRef, CompactionTrigger, HookDecisionPayload, HookEventName, SessionPhasePayload, SessionPhaseName, SessionSealedPayload, SubagentCancelledPayload, SubagentFailedPayload, SubagentLifecyclePayload, SubagentStartedPayload, SubagentSucceededPayload, ToolCallCompletedPayload, ToolCallPayload, ToolCallStartedPayload, TraceEvent, TraceEventInput, TraceEventKind, } from './types.js';
+export { AbortOriginSchema, AbortPayloadSchema, BackgroundAgentCancelledPayloadSchema, BackgroundAgentCompletedPayloadSchema, BackgroundAgentFailedPayloadSchema, BackgroundAgentJoinedPayloadSchema, BackgroundAgentPayloadSchema, BackgroundAgentStartedPayloadSchema, BrowserActActionSchema, BrowserEventPayloadSchema, BrowserEventTargetSchema, BrowserEventToolSchema, BudgetPayloadSchema, ClaimPayloadSchema, ClosurePayloadSchema, ClosureReasonSchema, CompactionPayloadInputSchema, CompactionPayloadPersistedSchema, CompactionSidecarRefSchema, CompactionTriggerSchema, HookDecisionPayloadSchema, HookEventNameSchema, SessionPhaseNameSchema, SessionPhasePayloadSchema, SessionSealedPayloadSchema, SubagentCancelledPayloadSchema, SubagentFailedPayloadSchema, SubagentLifecyclePayloadSchema, SubagentStartedPayloadSchema, SubagentSucceededPayloadSchema, ToolCallCompletedPayloadSchema, ToolCallPayloadSchema, ToolCallStartedPayloadSchema, TraceEventInputSchema, TraceEventSchema, } from './events.js';
+export { InMemoryTraceWriter, NdjsonTraceWriter, } from './writer.js';
+export type { NdjsonTraceWriterOptions, TraceWriter } from './writer.js';

package/dist/agent/trace/receipt.d.ts

@@ -0,0 +1,92 @@
+import type { HookHandler } from '../hooks.js';
+import type { ClosureReason, ToolFailureClass, TraceEvent, TraceEventKind } from './types.js';
+export declare const RECEIPT_SCHEMA_VERSION: 1;
+export interface ReceiptToolFailure {
+    toolUseId: string;
+    name: string;
+    failureClass?: ToolFailureClass;
+    durationMs: number;
+    ts: string;
+    truncated: boolean;
+    exempt: boolean;
+    subagentId?: string;
+}
+export interface RunReceipt {
+    schemaVersion: typeof RECEIPT_SCHEMA_VERSION;
+    generatedAt: string;
+    witnessLabel: string;
+    tracePath: string;
+    sessionId?: string;
+    endReason?: string;
+    status: 'succeeded' | 'failed' | 'cancelled' | 'unknown';
+    closureReason?: ClosureReason;
+    lastStopReason?: string;
+    guidance?: string;
+    incomplete: boolean;
+    startedAt?: string;
+    endedAt?: string;
+    durationMs?: number;
+    toolCalls: {
+        total: number;
+        succeeded: number;
+        errored: number;
+        erroredNotable: number;
+        circuitBreakerHits: number;
+        byTool: Record<string, {
+            total: number;
+            errored: number;
+        }>;
+        byFailureClass: Record<string, number>;
+    };
+    events: {
+        total: number;
+        byKind: Partial<Record<TraceEventKind, number>>;
+    };
+    subagents: {
+        started: number;
+        succeeded: number;
+        failed: number;
+        cancelled: number;
+    };
+    cost: {
+        finalCostUsd?: number;
+        turnCount?: number;
+        tokens?: {
+            input?: number;
+            output?: number;
+            cacheRead?: number;
+            cacheCreation?: number;
+        };
+    };
+    failures: ReceiptToolFailure[];
+    humanReviewRequired: boolean;
+    humanReviewReasons: string[];
+    limitations: string[];
+}
+export interface ReceiptMeta {
+    tracePath: string;
+    witnessLabel: string;
+    sessionId?: string;
+    endReason?: string;
+    now?: Date;
+}
+export declare function parseTraceJsonl(raw: string): TraceEvent[];
+export declare function receiptPathsFor(tracePath: string): {
+    label: string;
+    jsonPath: string;
+    mdPath: string;
+};
+export declare function generateReceipt(events: TraceEvent[], meta: ReceiptMeta): RunReceipt;
+export declare function renderReceiptMarkdown(r: RunReceipt): string;
+export interface WriteRunReceiptOptions {
+    tracePath: string;
+    sessionId?: string;
+    reason?: string;
+    now?: Date;
+}
+export declare function writeRunReceipt(opts: WriteRunReceiptOptions): Promise<{
+    label: string;
+    jsonPath: string;
+    mdPath: string;
+} | null>;
+export declare const runReceiptSessionEndHook: HookHandler;

package/dist/agent/trace/types.d.ts

@@ -0,0 +1,307 @@
+export type TraceEventKind = 'tool_call' | 'hook_decision' | 'subagent_lifecycle' | 'background_agent' | 'budget' | 'abort' | 'compaction' | 'closure' | 'claim' | 'browser_event' | 'session_phase' | 'session_sealed';
+export interface ToolCallStartedPayload {
+    phase: 'started';
+    toolUseId: string;
+    name: string;
+    inputBytes: number;
+    subagentId?: string;
+}
+export declare const TOOL_FAILURE_CLASSES: readonly ["policy-refusal", "timeout", "permission-denied", "hook-block", "abort", "elicitation-declined"];
+export type ToolFailureClass = (typeof TOOL_FAILURE_CLASSES)[number];
+export interface ToolCallCompletedPayload {
+    phase: 'completed';
+    toolUseId: string;
+    name: string;
+    resultBytes: number;
+    isError: boolean;
+    truncated: boolean;
+    durationMs: number;
+    circuitBreaker?: boolean;
+    failureClass?: ToolFailureClass;
+    subagentId?: string;
+}
+export type ToolCallPayload = ToolCallStartedPayload | ToolCallCompletedPayload;
+export type HookEventName = 'PreToolUse' | 'PostToolUse' | 'PostToolUseFailure' | 'SessionStart' | 'SessionEnd' | 'SubagentStart' | 'SubagentStop';
+export interface HookDecisionPayload {
+    hookEvent: HookEventName;
+    decision?: 'block' | 'approve';
+    reason?: string;
+    blockedTool?: string;
+    injectedContextBytes?: number;
+}
+export interface SubagentStartedPayload {
+    transition: 'started';
+    subagentId: string;
+    parentId: string;
+    model: string;
+    allowedTools?: readonly string[];
+    systemPromptHash?: string;
+}
+export interface SubagentSucceededPayload {
+    transition: 'succeeded';
+    subagentId: string;
+    durationMs: number;
+    turnCount: number;
+    totalCostUsd?: number;
+    outputBytes: number;
+}
+export interface SubagentFailedPayload {
+    transition: 'failed';
+    subagentId: string;
+    errorClass: string;
+    errorMessage: string;
+    partialOutputBytes: number;
+}
+export interface SubagentCancelledPayload {
+    transition: 'cancelled';
+    subagentId: string;
+    source: 'cascade' | 'explicit';
+}
+export type SubagentLifecyclePayload = SubagentStartedPayload | SubagentSucceededPayload | SubagentFailedPayload | SubagentCancelledPayload;
+export interface BackgroundAgentStartedPayload {
+    transition: 'started';
+    jobId: string;
+    subagentId: string;
+    label: string;
+    model: string;
+}
+export interface BackgroundAgentCompletedPayload {
+    transition: 'completed';
+    jobId: string;
+    subagentId: string;
+    durationMs: number;
+    outputBytes: number;
+}
+export interface BackgroundAgentFailedPayload {
+    transition: 'failed';
+    jobId: string;
+    subagentId: string;
+    durationMs: number;
+    errorClass: string;
+    errorMessage: string;
+}
+export interface BackgroundAgentCancelledPayload {
+    transition: 'cancelled';
+    jobId: string;
+    subagentId: string;
+    source: 'explicit' | 'cascade';
+}
+export interface BackgroundAgentJoinedPayload {
+    transition: 'joined';
+    jobId: string;
+    subagentId: string;
+    jobStatus: 'completed' | 'failed' | 'cancelled';
+}
+export type BackgroundAgentPayload = BackgroundAgentStartedPayload | BackgroundAgentCompletedPayload | BackgroundAgentFailedPayload | BackgroundAgentCancelledPayload | BackgroundAgentJoinedPayload;
+export interface BudgetPayload {
+    kind: 'monetary';
+    runningCostUsd: number;
+    maxBudgetUsd: number;
+    lastTurnCostUsd: number;
+}
+export type AbortOrigin = 'user_signal' | 'cascade' | 'timeout' | 'budget' | 'hook_block';
+export interface AbortPayload {
+    origin: AbortOrigin;
+    cascadedTo: readonly string[];
+    reason?: string;
+}
+export type CompactionTrigger = 'manual' | 'token_threshold' | 'turn_count';
+export interface CompactionPayloadInput {
+    trigger: CompactionTrigger;
+    preCompactionMessages: unknown[];
+    summary: string;
+    keptTailCount: number;
+    keepLastNConfig: number;
+    messagesBefore: number;
+    messagesAfter: number;
+    tokensSavedEstimate?: number;
+    summarizationTokens?: {
+        input: number;
+        output: number;
+    };
+}
+export interface CompactionSidecarRef {
+    path: string;
+    sizeBytes: number;
+    sha256: string;
+}
+export interface CompactionPayloadPersisted {
+    trigger: CompactionTrigger;
+    preCompactionMessagesRef: CompactionSidecarRef;
+    summary: string;
+    keptTailCount: number;
+    keepLastNConfig: number;
+    messagesBefore: number;
+    messagesAfter: number;
+    tokensSavedEstimate?: number;
+    summarizationTokens?: {
+        input: number;
+        output: number;
+    };
+}
+export type ClosureReason = 'model_end_turn' | 'truncated' | 'iteration_cap' | 'abort' | 'timeout' | 'budget_exceeded' | 'hook_blocked' | 'max_turns_exceeded';
+export interface ClosurePayload {
+    reason: ClosureReason;
+    finalTurnCount: number;
+    finalCostUsd: number;
+    finalTokens: {
+        input?: number;
+        output?: number;
+        cacheRead?: number;
+        cacheCreation?: number;
+    };
+    lastStopReason?: string;
+    guidance?: string;
+}
+export interface ClaimPayload {
+    source: string;
+    assertion: string;
+    evidence: readonly string[];
+    confidence: number;
+    dissent?: string;
+}
+export type BrowserEventTool = 'browser_open' | 'browser_observe' | 'browser_act' | 'browser_screenshot' | 'browser_extract' | 'browser_close';
+export type BrowserActAction = 'click' | 'fill' | 'press' | 'select' | 'hover' | 'scroll_to' | 'wait_for';
+export interface BrowserEventTarget {
+    kind: 'semantic' | 'element_id' | 'selector';
+    text?: string;
+    role?: string;
+    elementId?: string;
+    selectorHash?: string;
+}
+export interface BrowserEventPayload {
+    tool: BrowserEventTool;
+    action?: BrowserActAction;
+    toolUseId: string;
+    target?: BrowserEventTarget;
+    urlBefore: string | null;
+    urlAfter: string | null;
+    status: 'ok' | 'error' | 'ambiguous_target' | 'blocked_by_policy';
+    screenshotPath?: string;
+    observationSummary?: string;
+    error?: {
+        reason: string;
+        recoverable: boolean;
+    };
+    durationMs: number;
+}
+export type SessionPhaseName = 'bootstrap_start' | 'bootstrap_done' | 'session_init_start' | 'session_init_done' | 'mcp_connect_start' | 'mcp_connect_done' | 'mcp_server_start' | 'mcp_server_done' | 'loop_start' | 'loop_end' | 'model_ttfb';
+export interface SessionPhasePayload {
+    phase: SessionPhaseName;
+    durationMs?: number;
+    metadata?: Record<string, string | number | boolean>;
+    model?: string;
+    resolvedModel?: string;
+    origin?: 'cli' | 'telegram' | 'daemon' | 'unknown';
+    actor?: 'main' | 'subagent';
+}
+export interface SessionSealedPayload {
+    status: 'succeeded' | 'failed' | 'cancelled';
+    finalCostUsd: number;
+    finalTurnCount: number;
+    closedAt: string;
+    incomplete?: boolean;
+    subagentCount?: number;
+    subagentTokens?: {
+        input?: number;
+        output?: number;
+        cacheRead?: number;
+        cacheCreation?: number;
+    };
+    subagentCostUsd?: number;
+}
+export type TraceEventInput = {
+    kind: 'tool_call';
+    payload: ToolCallPayload;
+} | {
+    kind: 'hook_decision';
+    payload: HookDecisionPayload;
+} | {
+    kind: 'subagent_lifecycle';
+    payload: SubagentLifecyclePayload;
+} | {
+    kind: 'background_agent';
+    payload: BackgroundAgentPayload;
+} | {
+    kind: 'budget';
+    payload: BudgetPayload;
+} | {
+    kind: 'abort';
+    payload: AbortPayload;
+} | {
+    kind: 'compaction';
+    payload: CompactionPayloadInput;
+} | {
+    kind: 'closure';
+    payload: ClosurePayload;
+} | {
+    kind: 'claim';
+    payload: ClaimPayload;
+} | {
+    kind: 'browser_event';
+    payload: BrowserEventPayload;
+} | {
+    kind: 'session_phase';
+    payload: SessionPhasePayload;
+};
+export type TraceEvent = {
+    ts: string;
+    seq: number;
+    kind: 'tool_call';
+    payload: ToolCallPayload;
+} | {
+    ts: string;
+    seq: number;
+    kind: 'hook_decision';
+    payload: HookDecisionPayload;
+} | {
+    ts: string;
+    seq: number;
+    kind: 'subagent_lifecycle';
+    payload: SubagentLifecyclePayload;
+} | {
+    ts: string;
+    seq: number;
+    kind: 'background_agent';
+    payload: BackgroundAgentPayload;
+} | {
+    ts: string;
+    seq: number;
+    kind: 'budget';
+    payload: BudgetPayload;
+} | {
+    ts: string;
+    seq: number;
+    kind: 'abort';
+    payload: AbortPayload;
+} | {
+    ts: string;
+    seq: number;
+    kind: 'compaction';
+    payload: CompactionPayloadPersisted;
+} | {
+    ts: string;
+    seq: number;
+    kind: 'closure';
+    payload: ClosurePayload;
+} | {
+    ts: string;
+    seq: number;
+    kind: 'claim';
+    payload: ClaimPayload;
+} | {
+    ts: string;
+    seq: number;
+    kind: 'browser_event';
+    payload: BrowserEventPayload;
+} | {
+    ts: string;
+    seq: number;
+    kind: 'session_phase';
+    payload: SessionPhasePayload;
+} | {
+    ts: string;
+    seq: number;
+    kind: 'session_sealed';
+    payload: SessionSealedPayload;
+};

package/dist/agent/trace/writer.d.ts

@@ -0,0 +1,42 @@
+import type { CompactionPayloadInput, SessionSealedPayload, TraceEvent, TraceEventInput } from './types.js';
+export interface TraceWriter {
+    write(event: TraceEventInput): Promise<void>;
+    getTracePath(): string;
+    seal(payload: SessionSealedPayload): Promise<void>;
+    close(): Promise<void>;
+}
+export interface NdjsonTraceWriterOptions {
+    traceDir: string;
+}
+export declare class NdjsonTraceWriter implements TraceWriter {
+    private readonly traceDir;
+    private readonly tracePath;
+    private seq;
+    private sealed;
+    private fh;
+    private writeQueue;
+    constructor(options: NdjsonTraceWriterOptions);
+    getTracePath(): string;
+    write(event: TraceEventInput): Promise<void>;
+    seal(payload: SessionSealedPayload): Promise<void>;
+    close(): Promise<void>;
+    private enqueue;
+    private ensureOpen;
+    private closeHandle;
+    sealOnProcessExit(): void;
+    private appendLine;
+    private materializePersistedEvent;
+    private persistCompactionSidecar;
+}
+export declare class InMemoryTraceWriter implements TraceWriter {
+    private seq;
+    private sealed;
+    private readonly _events;
+    get events(): readonly TraceEvent[];
+    write(event: TraceEventInput): Promise<void>;
+    getTracePath(): string;
+    seal(payload: SessionSealedPayload): Promise<void>;
+    close(): Promise<void>;
+    private readonly _inlineCompactionPayloads;
+    getInlineCompactionPayload(seq: number): CompactionPayloadInput | undefined;
+}

package/dist/agent/transcript-search/transcript-index.d.ts

@@ -0,0 +1,21 @@
+export interface TranscriptSearchResult {
+    filename: string;
+    session_at: string;
+    snippet: string;
+    rank: number;
+}
+export interface ReindexResult {
+    indexed: number;
+    skipped: number;
+}
+export declare class TranscriptIndex {
+    private readonly indexDir;
+    private readonly transcriptsDir;
+    private readonly db;
+    constructor(indexDir?: string, transcriptsDir?: string);
+    reindex(): ReindexResult;
+    search(query: string, limit?: number): TranscriptSearchResult[];
+    count(): number;
+    close(): void;
+}
+export declare function withTranscriptIndex<T>(fn: (idx: TranscriptIndex) => T, indexDir?: string, transcriptsDir?: string): T;

package/dist/agent/trusted-skill-result.d.ts

@@ -0,0 +1,9 @@
+export interface TrustedSkillResult {
+    skillName: string;
+    durationMs: number;
+    claimsTotal?: number;
+    claimsConfirmed?: number;
+    claimsRefuted?: number;
+    claimsInconclusive?: number;
+    isError?: boolean;
+}

package/dist/agent/types/config-types.d.ts

@@ -0,0 +1,86 @@
+import type { AgentDefinition, EffortLevel, HookCallbackMatcher, HookEvent, OnElicitation, PermissionMode, SdkPluginConfig, SettingSource, ThinkingConfig } from './sdk-types.js';
+import type { HookRegistry } from '../hooks.js';
+import type { ModelProvider } from '../provider.js';
+import type { TraceWriter } from '../trace/index.js';
+import type { AgentModelInput } from './model-types.js';
+import type { ModelSlots } from '../session/model-slots.js';
+import type { CanUseTool, PermissionBubbler } from './permission-types.js';
+import type { Surface } from '../awareness/types.js';
+export interface ToolConfig {
+    allowedTools?: string[];
+    disallowedTools?: string[];
+}
+export interface ResumeHistoryTurn {
+    user: string;
+    assistant: string;
+}
+export interface PlanExitControls {
+    setPermissionMode(mode: PermissionMode): Promise<void>;
+    requestImplementSeed(message: string, mode: PermissionMode): void;
+}
+export interface AgentConfig {
+    model: AgentModelInput;
+    models?: ModelSlots;
+    apiKey?: string;
+    baseUrl?: string;
+    openaiBaseUrl?: string;
+    maxTurns?: number;
+    thinking?: ThinkingConfig;
+    effort?: EffortLevel;
+    tools?: ToolConfig;
+    permissionMode?: PermissionMode;
+    hooks?: Partial<Record<HookEvent, HookCallbackMatcher[]>>;
+    canUseTool?: CanUseTool;
+    permissionBubbler?: PermissionBubbler;
+    settingSources?: SettingSource[];
+    plugins?: SdkPluginConfig[];
+    systemPrompt?: string | {
+        type: 'preset';
+        preset: 'claude_code';
+        append?: string;
+    };
+    systemPromptSource?: string;
+    mcpServers?: Record<string, import('../mcp/types.js').McpServerConfig>;
+    mcpManager?: import('../mcp/index.js').McpManager;
+    agents?: Record<string, AgentDefinition>;
+    agent?: string;
+    cwd?: string;
+    readRoots?: string[];
+    writeRoots?: string[];
+    env?: Record<string, string>;
+    enableFileCheckpointing?: boolean;
+    pathToClaudeCodeExecutable?: string;
+    continue?: boolean;
+    resume?: string;
+    resumeHistory?: ResumeHistoryTurn[];
+    sessionId?: string;
+    resumeSessionAt?: string;
+    forkSession?: boolean;
+    persistSession?: boolean;
+    abortSignal?: AbortSignal;
+    timeoutMs?: number;
+    hookRegistry?: HookRegistry;
+    planExitControls?: PlanExitControls;
+    traceWriter?: TraceWriter;
+    provider?: ModelProvider;
+    providerFactory?: (model: string | undefined) => ModelProvider;
+    maxBudgetUsd?: number;
+    taskBudget?: number;
+    maxOutputTokens?: number;
+    includePartialMessages?: boolean;
+    includeHookEvents?: boolean;
+    agentProgressSummaries?: boolean;
+    onElicitation?: OnElicitation;
+    autoResumeOnUsageLimit?: boolean;
+    surface?: Surface;
+    parentSessionId?: string;
+    depth?: number;
+    maxDepth?: number;
+    phaseRole?: 'read-only' | 'read-write';
+    isSkillDispatch?: boolean;
+    isNonInteractive?: boolean;
+    autoCompact?: boolean | {
+        threshold: number;
+    };
+    customTools?: import('../tools/custom-tool.js').CustomToolDef[];
+}

package/dist/agent/types/message-types.d.ts

@@ -0,0 +1,77 @@
+import type { DiffPayload } from '../../utils/diff.js';
+export type MessageRole = 'user' | 'assistant';
+export interface ResponseMetadata extends Record<string, unknown> {
+    sessionId?: string;
+    stopReason?: string | null;
+    resultSubtype?: string;
+    durationMs?: number;
+    durationApiMs?: number;
+    totalCostUsd?: number;
+    numTurns?: number;
+    isError?: boolean;
+    usage?: Record<string, unknown>;
+    modelUsage?: Record<string, unknown>;
+    permissionDenials?: unknown[];
+    errors?: string[];
+}
+export interface Message {
+    role: MessageRole;
+    content: string;
+    metadata?: ResponseMetadata;
+    timestamp?: Date;
+}
+export interface ContentChunk {
+    type: 'content';
+    content: string;
+    metadata?: Record<string, unknown>;
+}
+export interface ToolUseChunk {
+    type: 'tool_use';
+    content: string;
+    metadata?: Record<string, unknown>;
+}
+export interface ToolUseDetailChunk {
+    type: 'tool_use_detail';
+    toolUseId: string;
+    toolName: string;
+    toolInput: string;
+    toolInputRaw?: string;
+    metadata?: Record<string, unknown>;
+}
+export interface ThinkingChunk {
+    type: 'thinking';
+    content: string;
+    metadata?: Record<string, unknown>;
+}
+export interface ToolResultChunk {
+    type: 'tool_result';
+    toolUseId: string;
+    content: string;
+    isError?: boolean;
+    truncated?: boolean;
+    persistedPath?: string;
+    sizeBytes?: number;
+    sizeLabel?: string;
+    lineCount?: number;
+    display?: string;
+    metadata?: Record<string, unknown>;
+}
+export interface ToolDiffChunk {
+    type: 'tool_diff';
+    toolUseId: string;
+    diff: DiffPayload;
+    metadata?: Record<string, unknown>;
+}
+export type MessageChunk = ContentChunk | ToolUseChunk | ToolUseDetailChunk | ThinkingChunk | ToolResultChunk | ToolDiffChunk | {
+    type: 'done' | 'error';
+    content?: string;
+    metadata?: Record<string, unknown>;
+};
+export interface SendMessageOptions {
+    stream?: boolean;
+    metadata?: Record<string, unknown>;
+}
+export interface StructuredMessageOptions extends SendMessageOptions {
+    maxRetries?: number;
+    injectSchemaPrompt?: boolean;
+}

package/dist/agent/types/model-types.d.ts

@@ -0,0 +1,2 @@
+export type ClaudeModel = 'opus' | 'opus_1m' | 'sonnet' | 'sonnet_1m' | 'haiku' | 'fable';
+export type AgentModelInput = ClaudeModel | string;

package/dist/agent/types/permission-types.d.ts

@@ -0,0 +1,8 @@
+import type { CanUseTool } from './sdk-types.js';
+export type { CanUseTool };
+export interface PermissionBubbler {
+    canUseTool: CanUseTool;
+}
+export interface InputStreamRef {
+    pushUserMessage(content: string): void;
+}