agent-afk 5.219.4 → 5.220.0

package/dist/agent/daemon/scheduler.d.ts

@@ -67,5 +67,4 @@ export declare class CronScheduler {
     private telemetryPath;
     private ensureTelemetrySink;
     private writeTelemetry;
-    private fireOnTaskComplete;
 }

package/dist/agent/daemon/scheduler.pull-tick.d.ts

@@ -0,0 +1,16 @@
+import type { ScheduledTask } from './triggers.js';
+import type { TelemetryRecord, TelemetryTrigger, TaskCompletionDetails } from './scheduler.js';
+export interface PullTickContext {
+    queueDir: string;
+    isIdle: () => boolean;
+    getIsDequeuing: () => boolean;
+    setIsDequeuing: (v: boolean) => void;
+    runOnce: (task: ScheduledTask, trigger: 'pull') => Promise<TelemetryRecord>;
+}
+export declare function sweepAnsweredHandoffs(queueDir: string): void;
+export declare function executePullTick(ctx: PullTickContext): Promise<void>;
+export interface FireOnTaskCompleteOptions {
+    onTaskComplete?: (record: TelemetryRecord, details?: TaskCompletionDetails) => void | Promise<void>;
+}
+export declare function fireOnTaskComplete(record: TelemetryRecord, options: FireOnTaskCompleteOptions, task?: ScheduledTask, details?: TaskCompletionDetails): void;
+export type { TelemetryTrigger };

package/dist/agent/facets/schema.d.ts

@@ -92,8 +92,8 @@ export declare const SessionFacetSchema: z.ZodObject<{
     source: z.ZodEnum<{
         telegram: "telegram";
         cli: "cli";
-        unknown: "unknown";
         web: "web";
+        unknown: "unknown";
     }>;
     model: z.ZodString;
     derived_at: z.ZodString;

package/dist/agent/session/accounting-accumulator.d.ts

@@ -0,0 +1,42 @@
+import type { ClosureSignals } from './closure-emitter.js';
+import type { ResponseMetadata } from '../types.js';
+interface TokenCounters {
+    input: number;
+    output: number;
+    cacheRead: number;
+    cacheCreation: number;
+}
+export interface AccountingSnapshot {
+    sessionRunningCostUsd: number;
+    sessionRunningTokens: Readonly<TokenCounters>;
+    subagentCompletedCount: number;
+    subagentRunningTokens: Readonly<TokenCounters>;
+    subagentRunningCostUsd: number;
+}
+export declare class AccountingAccumulator {
+    private sessionRunningCostUsd;
+    private sessionRunningTokens;
+    private lastStopReason;
+    private maxTurnsHit;
+    private hookBlocked;
+    private sawProviderError;
+    readonly sessionStartedAt: number;
+    private subagentCompletedCount;
+    private subagentRunningTokens;
+    private subagentRunningCostUsd;
+    reset(): void;
+    recordTurnMetadata(m: ResponseMetadata): void;
+    markHookBlocked(): void;
+    markMaxTurnsHit(): void;
+    markProviderError(): void;
+    clearProviderError(): void;
+    recordSubagentCompletion(usage?: {
+        inputTokens?: number;
+        outputTokens?: number;
+        cacheReadTokens?: number;
+        cacheCreationTokens?: number;
+    }, costUsd?: number): void;
+    closureSignals(signal: AbortSignal, dispatchReason: string): ClosureSignals;
+    snapshot(): AccountingSnapshot;
+}
+export {};

package/dist/agent/session/agent-session.d.ts

@@ -2,8 +2,8 @@ import type { ContentBlockParam } from '@anthropic-ai/sdk/resources';
 import type { TraceWriter } from '../trace/writer.js';
 import type { HookRegistry } from '../hooks.js';
 import type { ProviderCommandInfo, ProviderCompactResult, ProviderQuery, ProviderRewindConversationResult, RewindTarget } from '../provider.js';
-import { type ZodType } from 'zod';
 import type { AccountInfo, AgentConfig, AgentInfo, AgentModelInput, IAgentSession, InputStreamRef, McpServerStatus, Message, ModelInfo, OutputEvent, PermissionMode, ResponseMetadata, RewindFilesResult, SDKControlGetContextUsageResponse, SendMessageOptions, SessionIdentity, SessionMetadata, SessionState, StructuredMessageOptions } from '../types.js';
+import type { ZodType } from 'zod';
 import type { ElicitationRequest } from '../types/sdk-types.js';
 export declare class AgentSession implements IAgentSession {
     private readonly ownedTraceWriter;
@@ -22,38 +22,25 @@ export declare class AgentSession implements IAgentSession {
     private inputStream;
     private readonly abortController;
     private readonly _hookRegistry;
-    private sessionEndDispatched;
     private readonly ownsTraceSeal;
     private stateManager;
-    private sessionRunningCostUsd;
-    private sessionRunningTokens;
-    private lastStopReason;
-    private maxTurnsHit;
-    private hookBlocked;
-    private sawProviderError;
-    private readonly sessionStartedAt;
-    private subagentCompletedCount;
-    private subagentRunningTokens;
-    private subagentRunningCostUsd;
+    private readonly accounting;
     private readonly ledger;
     private readonly outputBroadcast;
+    private readonly shutdown;
+    private runner;
     constructor(config: AgentConfig, ownedTraceWriter?: TraceWriter);
     private initSdkLifecycle;
-    private pullInitialization;
-    private buildTransformDeps;
     get state(): SessionState;
     get sessionId(): string | undefined;
     get cwd(): string | undefined;
     get abortSignal(): AbortSignal;
     get hookRegistry(): HookRegistry | undefined;
     abort(reason: string): void;
+    private makeSendDeps;
     sendMessage(content: string, options?: SendMessageOptions): Promise<Message>;
     sendMessageStructured<T>(content: string, schema: ZodType<T>, options?: StructuredMessageOptions): Promise<T>;
     sendMessageStream(content: string | ContentBlockParam[]): AsyncIterableIterator<OutputEvent>;
-    private sendMessageStreamInternal;
-    private ensureLedger;
-    recordLedgerElicitation(reqId: string, request: ElicitationRequest): void;
-    private summarizeContentBlocks;
     interrupt(): Promise<void>;
     setBeforeNextRound(cb: (() => string | undefined) | undefined): void;
     reset(): Promise<void>;
@@ -88,16 +75,14 @@ export declare class AgentSession implements IAgentSession {
     compact(): Promise<ProviderCompactResult>;
     listRewindTargets(): RewindTarget[];
     rewindConversation(turnIndex: number): Promise<ProviderRewindConversationResult>;
+    private makePassthroughDeps;
     getLastResponseMetadata(): ResponseMetadata | null;
     getOutputStream(): AsyncIterable<OutputEvent>;
     queueFrameworkContext(text: string): void;
-    private withPendingFrameworkContext;
     getInputStreamRef(): Pick<InputStreamRef, 'pushUserMessage' | 'queueFrameworkContext'>;
     getHistory(): readonly Message[];
     getTurnCount(): number;
     close(): Promise<void>;
-    private dispatchSessionEndOnce;
-    private closureSignals;
     recordSubagentCompletion(usage?: {
         inputTokens?: number;
         outputTokens?: number;
@@ -105,5 +90,5 @@ export declare class AgentSession implements IAgentSession {
         cacheCreationTokens?: number;
     }, costUsd?: number): void;
     pushSidebandEvent(event: OutputEvent): void;
-    private assertCanSend;
+    recordLedgerElicitation(reqId: string, request: ElicitationRequest): void;
 }

package/dist/agent/session/provider-lifecycle.d.ts

@@ -0,0 +1,16 @@
+import { SessionStateManager } from './session-state.js';
+import { QueryInputStream } from './input-iterable.js';
+import type { AccountingAccumulator } from './accounting-accumulator.js';
+import type { SessionShutdown } from './session-shutdown.js';
+import type { AgentConfig } from '../types.js';
+import type { ProviderQuery, ProviderEvent } from '../provider.js';
+import type { HookRegistry } from '../hooks.js';
+import type { TransformDeps } from './stream-consumer.js';
+export interface ProviderLifecycleResult {
+    stateManager: SessionStateManager;
+    inputStream: QueryInputStream;
+    providerQuery: ProviderQuery;
+    providerIterator: AsyncIterator<ProviderEvent>;
+}
+export declare function buildProviderLifecycle(config: AgentConfig): ProviderLifecycleResult;
+export declare function runInitialization(config: AgentConfig, providerIterator: AsyncIterator<ProviderEvent>, abortSignal: AbortSignal, stateManager: SessionStateManager, accounting: AccountingAccumulator, shutdown: SessionShutdown, hookRegistry: HookRegistry | undefined, queueFrameworkContext: (text: string) => void, buildTransformDeps: () => TransformDeps): Promise<void>;

package/dist/agent/session/provider-passthrough.d.ts

@@ -0,0 +1,19 @@
+import type { AccountInfo, AgentInfo, McpServerStatus, ModelInfo, RewindFilesResult, SDKControlGetContextUsageResponse, SessionState } from '../types.js';
+import type { ProviderCommandInfo, ProviderCompactResult, ProviderQuery, ProviderRewindConversationResult, RewindTarget } from '../provider.js';
+export interface PassthroughDeps {
+    getState: () => SessionState;
+    setState: (s: SessionState) => void;
+    getProviderQuery: () => ProviderQuery;
+}
+export declare function supportedCommands(deps: PassthroughDeps): Promise<ProviderCommandInfo[]>;
+export declare function supportedModels(deps: PassthroughDeps): Promise<ModelInfo[]>;
+export declare function supportedAgents(deps: PassthroughDeps): Promise<AgentInfo[]>;
+export declare function getContextUsage(deps: PassthroughDeps): Promise<SDKControlGetContextUsageResponse>;
+export declare function mcpServerStatus(deps: PassthroughDeps): Promise<McpServerStatus[]>;
+export declare function accountInfo(deps: PassthroughDeps): Promise<AccountInfo>;
+export declare function rewindFiles(userMessageId: string, options: {
+    dryRun?: boolean;
+} | undefined, deps: PassthroughDeps): Promise<RewindFilesResult>;
+export declare function compact(deps: PassthroughDeps): Promise<ProviderCompactResult>;
+export declare function listRewindTargets(deps: PassthroughDeps): RewindTarget[];
+export declare function rewindConversation(turnIndex: number, deps: PassthroughDeps): Promise<ProviderRewindConversationResult>;

package/dist/agent/session/session-reset.d.ts

@@ -0,0 +1,18 @@
+import type { AgentConfig, SessionState } from '../types.js';
+import type { ProviderQuery, ProviderEvent } from '../provider.js';
+import type { SessionStateManager } from './session-state.js';
+import type { SessionShutdown } from './session-shutdown.js';
+import type { LedgerLifecycle } from './ledger-lifecycle.js';
+export interface ResetDeps {
+    getState: () => SessionState;
+    setState: (s: SessionState) => void;
+    getAbortController: () => AbortController;
+    getProviderQuery: () => ProviderQuery;
+    getProviderIterator: () => AsyncIterator<ProviderEvent>;
+    getInitPromise: () => Promise<void> | null;
+    getShutdown: () => SessionShutdown;
+    getLedger: () => LedgerLifecycle;
+    getStateManager: () => SessionStateManager;
+    reinitialize: (patchConfig: (prev: AgentConfig) => AgentConfig) => void;
+}
+export declare function resetSession(deps: ResetDeps): Promise<void>;

package/dist/agent/session/session-send.d.ts

@@ -0,0 +1,25 @@
+import type { ContentBlockParam } from '@anthropic-ai/sdk/resources';
+import { type ZodType } from 'zod';
+import type { Message, OutputEvent, SendMessageOptions, SessionState, StructuredMessageOptions } from '../types.js';
+import type { ProviderQuery } from '../provider.js';
+import type { AgentConfig } from '../types.js';
+import type { TurnStreamRunner } from './turn-stream-runner.js';
+import type { QueryInputStream } from './input-iterable.js';
+import type { PlanExitBridge } from './plan-exit-bridge.js';
+export interface SendDeps {
+    getConfig: () => AgentConfig;
+    getAbortController: () => AbortController;
+    getState: () => SessionState;
+    setState: (s: SessionState) => void;
+    getSessionId: () => string | undefined;
+    runner: TurnStreamRunner;
+    getInputStream: () => QueryInputStream;
+    getProviderQuery: () => ProviderQuery;
+    planExit: PlanExitBridge;
+}
+export declare function sendMessage(content: string, options: SendMessageOptions | undefined, deps: SendDeps): Promise<Message>;
+export declare function sendMessageStructured<T>(content: string, schema: ZodType<T>, options: StructuredMessageOptions | undefined, deps: SendDeps): Promise<T>;
+export declare function sendMessageStream(content: string | ContentBlockParam[], deps: SendDeps): AsyncIterableIterator<OutputEvent>;
+export declare function sendMessageStreamInternal(content: string | ContentBlockParam[], deps: SendDeps): AsyncIterableIterator<OutputEvent>;
+export declare function interrupt(deps: Pick<SendDeps, 'getState' | 'setState' | 'getProviderQuery'>): Promise<void>;
+export declare function setBeforeNextRound(cb: (() => string | undefined) | undefined, deps: Pick<SendDeps, 'getProviderQuery'>): void;

package/dist/agent/session/session-shutdown.d.ts

@@ -0,0 +1,21 @@
+import type { TraceWriter } from '../trace/writer.js';
+import type { AccountingAccumulator } from './accounting-accumulator.js';
+import type { HookRegistry } from '../hooks.js';
+import type { AgentConfig } from '../types.js';
+export interface ShutdownDeps {
+    getConfig: () => AgentConfig;
+    getAbortController: () => AbortController;
+    getHookRegistry: () => HookRegistry | undefined;
+    accounting: AccountingAccumulator;
+    getTurnCount: () => number;
+    getSessionId: () => string | undefined;
+    ownedTraceWriter: TraceWriter | undefined;
+    ownsTraceSeal: boolean;
+}
+export declare class SessionShutdown {
+    private dispatched;
+    private readonly deps;
+    constructor(deps: ShutdownDeps);
+    reset(): void;
+    dispatchOnce(reason: string): Promise<void>;
+}

package/dist/agent/session/turn-stream-runner.d.ts

@@ -0,0 +1,49 @@
+import type { ContentBlockParam } from '@anthropic-ai/sdk/resources';
+import { type SubagentOutputRecorder } from './subagent-output-capture.js';
+import { type TransformDeps } from './stream-consumer.js';
+import type { AccountingAccumulator } from './accounting-accumulator.js';
+import type { LedgerLifecycle } from './ledger-lifecycle.js';
+import type { OutputBroadcast } from './output-broadcast.js';
+import type { SessionStateManager } from './session-state.js';
+import type { AgentConfig, OutputEvent, ResponseMetadata, SessionState } from '../types.js';
+import type { ProviderQuery, ProviderEvent } from '../provider.js';
+import type { Message } from '../types.js';
+export interface TurnRunnerDeps {
+    getConfig: () => AgentConfig;
+    getAbortController: () => AbortController;
+    getProviderIterator: () => AsyncIterator<ProviderEvent>;
+    stateManager: SessionStateManager;
+    accounting: AccountingAccumulator;
+    ledger: LedgerLifecycle;
+    outputBroadcast: OutputBroadcast;
+    conversationHistory: Message[];
+    getInitPromise: () => Promise<void> | null;
+    getSessionId: () => string | undefined;
+    getState: () => SessionState;
+    setState: (s: SessionState) => void;
+    getLastResponseMetadata: () => ResponseMetadata | null;
+    setLastResponseMetadata: (m: ResponseMetadata) => void;
+    getPendingFrameworkContext: () => string[];
+    setPendingFrameworkContext: (v: string[]) => void;
+    getInboundMessageCount: () => number;
+    incInboundMessageCount: () => number;
+    getTurnCount: () => number;
+    incTurnCount: () => void;
+    getSubagentOutputRecorder: () => SubagentOutputRecorder | null | undefined;
+    setSubagentOutputRecorder: (r: SubagentOutputRecorder | null) => void;
+    getProviderQuery: () => ProviderQuery;
+    getLedgerMetadata: () => ReturnType<SessionStateManager['getSessionMetadata']>;
+}
+export declare class TurnStreamRunner {
+    private readonly deps;
+    constructor(deps: TurnRunnerDeps);
+    assertCanSend(): void;
+    summarize(blocks: ContentBlockParam[]): string;
+    withPendingContext(content: string | ContentBlockParam[]): string | ContentBlockParam[];
+    ensureLedger(): void;
+    buildTransformDeps(): TransformDeps;
+    runStream(content: string | ContentBlockParam[], inputStream: {
+        pushUserMessage: (c: string | ContentBlockParam[]) => void;
+    }): AsyncIterableIterator<OutputEvent>;
+    queueFrameworkContext(text: string): void;
+}

package/dist/agent/tools/dispatcher.core-exec.d.ts

@@ -0,0 +1,34 @@
+import type { HookRegistry } from '../hooks.js';
+import type { AnthropicToolDef } from '../providers/anthropic-direct/types.js';
+import type { ToolCall, ToolResult } from '../providers/anthropic-direct/types.js';
+import type { SubagentExecutor } from './subagent-executor.js';
+import type { SkillExecutor } from './skill-executor.js';
+import type { ComposeExecutor } from './compose-executor.js';
+import type { ToolHandler, ToolHandlerContext } from './types.js';
+import type { TraceSink } from '../trace/index.js';
+import type { GrantManager } from '../../cli/slash/commands/allow-dir.js';
+import type { PreDispatchGateDeps } from './dispatcher.pre-dispatch-gates.js';
+export interface CoreExecDeps {
+    handlers: Map<string, ToolHandler>;
+    hookRegistry: HookRegistry | undefined;
+    sessionId: string | undefined;
+    parentSessionId: string | undefined;
+    sessionGrantManager: GrantManager | undefined;
+    traceWriter: TraceSink | undefined;
+    maxOutputBytes: number | undefined;
+    subagentExecutor: SubagentExecutor | undefined;
+    skillExecutor: SkillExecutor | undefined;
+    composeExecutor: ComposeExecutor | undefined;
+    callHandlerContext: (call: ToolCall) => ToolHandlerContext;
+    gateDeps: () => PreDispatchGateDeps;
+    toolDefs: readonly AnthropicToolDef[];
+}
+export declare function isRegisteredTool(toolName: string, deps: CoreExecDeps): boolean;
+export declare function unknownToolMessage(toolName: string, deps: CoreExecDeps): string;
+export declare function denialReason(toolName: string, permissionReason: string | undefined, deps: CoreExecDeps): string;
+export declare function firePostToolUse(toolName: string, output: string, signal: AbortSignal, deps: CoreExecDeps, input?: unknown, resultFlags?: Pick<ToolResult, 'incomplete' | 'incompleteReason' | 'isError'>): void;
+export declare function firePostToolUseFailure(toolName: string, errorMessage: string, signal: AbortSignal, deps: CoreExecDeps, input?: unknown): void;
+export declare function applyOutputCap(result: ToolResult, deps: CoreExecDeps): ToolResult;
+export declare function executeCompose(call: ToolCall, deps: CoreExecDeps): Promise<ToolResult>;
+export declare function executeCoreInner(call: ToolCall, deps: CoreExecDeps): Promise<ToolResult>;
+export declare function executeCore(call: ToolCall, deps: CoreExecDeps): Promise<ToolResult>;

package/dist/agent/tools/dispatcher.d.ts

@@ -9,7 +9,7 @@ import type { ComposeExecutor } from './compose-executor.js';
 import type { ToolHandler, ConcurrencyClassifier } from './types.js';
 import type { ToolActivityReporter } from '../providers/shared/tool-activity.js';
 import type { SpawnedPidRegistry } from './handlers/pid-registry.js';
-import { type ToolPermissionConfig } from './permissions.js';
+import type { ToolPermissionConfig } from './permissions.js';
 import type { CanUseTool } from '../types/sdk-types.js';
 import { type GrantSnapshot } from './grant-manager.js';
 import type { GrantManager } from '../../cli/slash/commands/allow-dir.js';
@@ -68,10 +68,8 @@ export declare class SessionToolDispatcher implements ToolDispatcher {
     private readonly maxOutputBytes;
     private readonly spawnedPidRegistry;
     private readonly bashOutputTailReporter;
-    private repeatBreaker;
+    private readonly gateState;
     private readonly repeatFailureGuard;
-    private denialBreaker;
-    private suspectedLoopWindow;
     private readonly grantManager;
     constructor(opts: SessionToolDispatcherOptions);
     private get handlerContext();
@@ -83,24 +81,11 @@ export declare class SessionToolDispatcher implements ToolDispatcher {
     setAllowAll(allow: boolean): void;
     setResolveBase(newCwd: string): void;
     get toolDefs(): readonly AnthropicToolDef[];
-    private denialReason;
-    private isRegisteredTool;
-    private unknownToolMessage;
-    private checkReadOnlyBash;
-    private emitPreToolUseBlock;
-    private checkRepeatCircuitBreaker;
-    private checkRepeatFailureGuard;
-    private observeSuspectedLoop;
-    private recordForkReadDenial;
-    private resetDenialBreaker;
-    private runCanUseTool;
+    private gateDeps;
+    private coreExecDeps;
     private runPreDispatchGates;
+    private resetDenialBreaker;
     execute(call: ToolCall): Promise<ToolResult>;
     executeBatch(calls: ToolCall[], onActivity?: ToolActivityReporter): Promise<ToolResult[]>;
     private executeCore;
-    private applyOutputCap;
-    private executeCoreInner;
-    private executeCompose;
-    private firePostToolUse;
-    private firePostToolUseFailure;
 }

package/dist/agent/tools/dispatcher.pre-dispatch-gates.d.ts

@@ -0,0 +1,38 @@
+import { type ToolPermissionConfig } from './permissions.js';
+import { type SuspectedLoopWindow } from './suspected-loop-detector.js';
+import { RepeatFailureGuard } from './repeat-failure-guard.js';
+import type { HookRegistry } from '../hooks.js';
+import type { ToolCall, ToolResult } from '../providers/anthropic-direct/types.js';
+import type { CanUseTool } from '../types/sdk-types.js';
+import type { TraceSink } from '../trace/index.js';
+import type { GrantManager } from '../../cli/slash/commands/allow-dir.js';
+export interface PreDispatchGateMutableState {
+    repeatBreaker: {
+        fingerprint: string;
+        count: number;
+    } | null;
+    suspectedLoopWindow: SuspectedLoopWindow | null;
+    denialBreaker: {
+        count: number;
+        deniedPaths: string[];
+    } | null;
+}
+export interface PreDispatchGateDeps {
+    state: PreDispatchGateMutableState;
+    hookRegistry: HookRegistry | undefined;
+    permissions: ToolPermissionConfig | undefined;
+    canUseTool: CanUseTool | undefined;
+    readOnlyBash: boolean;
+    repeatFailureGuard: RepeatFailureGuard;
+    sessionId: string | undefined;
+    parentSessionId: string | undefined;
+    subagentId: string | undefined;
+    sessionGrantManager: GrantManager | undefined;
+    resolveBase: string | undefined;
+    traceWriter: TraceSink | undefined;
+    isRegisteredTool: (toolName: string) => boolean;
+    denialReason: (toolName: string, permissionReason: string | undefined) => string;
+}
+export declare function emitPreToolUseBlock(blockedTool: string, reason: string, deps: PreDispatchGateDeps): Promise<void>;
+export declare function resetDenialBreaker(state: PreDispatchGateMutableState): void;
+export declare function runPreDispatchGates(call: ToolCall, deps: PreDispatchGateDeps, repeatBreakerExemptTools: ReadonlySet<string>, repeatCircuitBreakerThreshold: number): Promise<ToolResult | null>;

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

@@ -558,8 +558,8 @@ export declare const SessionPhasePayloadSchema: z.ZodObject<{
         telegram: "telegram";
         daemon: "daemon";
         cli: "cli";
-        unknown: "unknown";
         web: "web";
+        unknown: "unknown";
     }>>;
     actor: z.ZodOptional<z.ZodEnum<{
         main: "main";
@@ -918,8 +918,8 @@ export declare const TraceEventInputSchema: z.ZodDiscriminatedUnion<[z.ZodObject
             telegram: "telegram";
             daemon: "daemon";
             cli: "cli";
-            unknown: "unknown";
             web: "web";
+            unknown: "unknown";
         }>>;
         actor: z.ZodOptional<z.ZodEnum<{
             main: "main";
@@ -1288,8 +1288,8 @@ export declare const TraceEventSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
             telegram: "telegram";
             daemon: "daemon";
             cli: "cli";
-            unknown: "unknown";
             web: "web";
+            unknown: "unknown";
         }>>;
         actor: z.ZodOptional<z.ZodEnum<{
             main: "main";

package/dist/cli/commands/daemon-session-factory.d.ts

@@ -0,0 +1,10 @@
+import type { AgentConfig, AgentModelInput } from '../../agent/types.js';
+import { AgentSession } from '../../agent/session.js';
+export interface BuildDaemonSessionFactoryOpts {
+    model: AgentModelInput;
+    apiKey?: string;
+    baseUrl?: string;
+    openaiBaseUrl?: string;
+    cwd?: string;
+}
+export declare function buildDaemonSessionFactory(opts: BuildDaemonSessionFactoryOpts): (config: AgentConfig, ownedTraceWriter?: import('../../agent/trace/index.js').TraceWriter) => AgentSession;

package/dist/cli/commands/daemon.d.ts

@@ -1,15 +1,7 @@
 import { Command } from 'commander';
 import type { TaskCompletionDetails, TelemetryRecord } from '../../agent/daemon/scheduler.js';
-import type { AgentConfig, AgentModelInput } from '../../agent/types.js';
-import { AgentSession } from '../../agent/session.js';
-export interface BuildDaemonSessionFactoryOpts {
-    model: AgentModelInput;
-    apiKey?: string;
-    baseUrl?: string;
-    openaiBaseUrl?: string;
-    cwd?: string;
-}
-export declare function buildDaemonSessionFactory(opts: BuildDaemonSessionFactoryOpts): (config: AgentConfig, ownedTraceWriter?: import('../../agent/trace/index.js').TraceWriter) => AgentSession;
+export type { BuildDaemonSessionFactoryOpts } from './daemon-session-factory.js';
+export { buildDaemonSessionFactory } from './daemon-session-factory.js';
 export declare function resolveNotifyChatTarget(notifyChat: number | string | undefined, taskId: string): number | undefined;
 export declare function formatTaskCompletion(record: TelemetryRecord, details?: TaskCompletionDetails, verifyDone?: boolean): string;
 export declare function registerDaemonCommand(program: Command): void;

package/dist/cli/markdown-stream-inline-close.d.ts

@@ -0,0 +1 @@
+export declare function closePendingInlineSyntax(text: string): string;