autopilot-ai 1.2.2 → 1.5.0

package/dist/sdk/index.d.ts

@@ -91,6 +91,8 @@ interface OpenRouterProviderPrefs {
     max_price?: Record<string, number>;
 }
 
+type SubagentPolicy = "off" | "suggest" | "auto";
+
 type ReasoningEffort = "low" | "medium" | "high";
 interface McpServerConfig {
     type: "local" | "remote";
@@ -124,6 +126,13 @@ interface KimiConfig {
      * Bring-your-own only: kimiflare never pays for or proxies model calls.
      */
     openrouterApiKey?: string;
+    /**
+     * Optional Requesty API key (env: REQUESTY_API_KEY, which wins over the
+     * file). Used only when no OpenRouter key and no custom endpoint are
+     * configured: model calls then go to Requesty (https://requesty.ai). Set
+     * REQUESTY_BASE_URL to pick a region, e.g. https://router.eu.requesty.ai/v1.
+     */
+    requestyApiKey?: string;
     /** OpenRouter model id, e.g. "moonshotai/kimi-k2.6". */
     model: string;
     /**
@@ -156,6 +165,8 @@ interface KimiConfig {
     accountId?: string;
     apiToken?: string;
     reasoningEffort?: ReasoningEffort;
+    /** Harness subagent routing: off, suggest (default), or auto. Auto never bypasses tool permission or worker budgets. */
+    subagentPolicy?: SubagentPolicy;
     /**
      * Feature flag for the plan / edit / auto permission modes. Off by default:
      * every session runs in auto (tools run without per-call prompts) and the
@@ -228,6 +239,8 @@ interface KimiConfig {
     uiEngine?: "ink" | "camouflage";
     /** Worker endpoint URL for spawning standalone research/executor workers. */
     workerEndpoint?: string;
+    /** Worker provider. Remote remains the compatibility default. */
+    workerBackend?: "remote" | "hotcell";
     /** Max cost per worker in USD (default: 1.0). */
     workerBudgetUsd?: number;
     /** Hard ceiling for workerBudgetUsd. Any configured or programmatic value above this is silently capped. Default: 5.0. */
@@ -319,6 +332,8 @@ declare function saveConfig(cfg: KimiConfig): Promise<string>;
 interface LlmAuth {
     /** The user's OpenRouter key. */
     openrouterApiKey?: string;
+    /** The user's Requesty key; used only when there is no OpenRouter key or custom endpoint. */
+    requestyApiKey?: string;
     /** Host-app broker endpoint; when set, used instead of OpenRouter. */
     customEndpoint?: CustomEndpoint;
     /** Extra OpenRouter provider-routing preferences. */
@@ -372,6 +387,7 @@ interface MemoryStats {
 interface MemoryManagerOpts {
     dbPath: string;
     openrouterApiKey?: string;
+    requestyApiKey?: string;
     customEndpoint?: CustomEndpoint;
     model?: string;
     plumbingModel?: string;
@@ -384,6 +400,7 @@ interface MemoryManagerOpts {
 }
 interface LlmOpts {
     openrouterApiKey?: string;
+    requestyApiKey?: string;
     customEndpoint?: CustomEndpoint;
     model: string;
     provider?: OpenRouterProviderPrefs;
@@ -506,6 +523,12 @@ interface ToolContext {
     llmAuth?: LlmAuth;
     /** Model id for tools that need to call an LLM. */
     model?: string;
+    /** Optional override for the durable managed-jobs database (primarily for embedding/tests). */
+    jobsDbPath?: string;
+    /** Run identifier for durable tool-boundary journaling in unattended runs. */
+    runId?: string;
+    /** Optional override for the durable run/event/timer database. */
+    runsDbPath?: string;
     /** When false (default), the bash tool blocks `git push` to the repository's
      *  default branch and directs the model to open a PR instead. */
     allowDirectPush?: boolean;
@@ -519,10 +542,19 @@ interface ToolRender {
         after: string;
     };
 }
+interface RunWaitRequest {
+    runId: string;
+    timerId: string;
+    condition: "time" | "job";
+    jobId?: string;
+    wakeAt: number;
+}
 interface ToolOutput {
     content: string;
     rawBytes: number;
     reducedBytes: number;
+    /** Internal control signal: persist the wait and end this agent turn. */
+    waitRequest?: RunWaitRequest;
 }
 interface ToolSpec<Args = any> {
     name: string;
@@ -741,6 +773,152 @@ declare function createDefaultPermissionHandler(options: {
 
 declare function startRpcServer(input?: Readable, output?: Writable, createSession?: typeof createAgentSession): Promise<void>;
 
+type RunStatus = "queued" | "running" | "waiting" | "needs_input" | "completed" | "failed" | "cancelled" | "interrupted_unknown";
+type RunEventType = "state" | "tool_intent" | "tool_result";
+type TimerCondition = "time" | "job" | "approval";
+type TimerStatus = "scheduled" | "claimed" | "completed" | "failed" | "cancelled";
+interface RunRecord {
+    id: string;
+    sessionId: string | null;
+    cwd: string;
+    task: string;
+    status: RunStatus;
+    stopReason: string | null;
+    allowedTools: string[];
+    maxToolIterations: number;
+    maxRuntimeMs: number;
+    createdAt: number;
+    updatedAt: number;
+    startedAt: number | null;
+    finishedAt: number | null;
+}
+interface RunEvent {
+    sequence: number;
+    runId: string;
+    type: RunEventType;
+    toolCallId: string | null;
+    toolName: string | null;
+    metadata: Record<string, unknown>;
+    createdAt: number;
+}
+interface RunTimer {
+    id: string;
+    runId: string;
+    condition: TimerCondition;
+    jobId: string | null;
+    wakeAt: number;
+    intervalMs: number;
+    status: TimerStatus;
+    attempts: number;
+    maxAttempts: number;
+    leaseUntil: number | null;
+    lastError: string | null;
+    createdAt: number;
+}
+/**
+ * SQLite persistence for unattended runs, tool-boundary checkpoints, and
+ * durable wake timers. Constructing a store only opens/migrates the schema;
+ * call reconcileInterruptedRuns explicitly once at supervisor startup.
+ */
+declare class RunStore {
+    private readonly db;
+    constructor(dbPath?: string);
+    close(): void;
+    createRun(input: {
+        task: string;
+        cwd: string;
+        sessionId?: string;
+        allowedTools?: string[];
+        maxToolIterations?: number;
+        maxRuntimeMs?: number;
+    }): RunRecord;
+    getRun(id: string): RunRecord | undefined;
+    listRuns(options?: {
+        status?: RunStatus;
+        limit?: number;
+    }): RunRecord[];
+    transition(id: string, status: RunStatus, reason?: string): RunRecord;
+    /** Persist a tool intent before execution. Only hashes are retained, never raw arguments. */
+    recordToolIntent(runId: string, toolCallId: string, toolName: string, args: unknown): void;
+    /** Persist completion metadata after execution without storing tool output text. */
+    recordToolResult(runId: string, toolCallId: string, toolName: string, result: {
+        ok: boolean;
+        content: string;
+        errorCode?: string;
+    }): void;
+    listEvents(runId: string): RunEvent[];
+    countToolIterations(runId: string): number;
+    /**
+     * On daemon startup, mark every still-running run interrupted. An unmatched
+     * intent is the explicit ambiguous-action case; no tool is ever replayed.
+     */
+    reconcileInterruptedRuns(now?: number): RunRecord[];
+    scheduleTimer(input: {
+        runId: string;
+        condition: TimerCondition;
+        wakeAt: number;
+        intervalMs?: number;
+        jobId?: string;
+        maxAttempts?: number;
+    }): RunTimer;
+    getTimer(id: string): RunTimer | undefined;
+    nextTimerAt(): number | null;
+    listFailedTimers(limit?: number): RunTimer[];
+    /** Reschedule a successful job-status check without consuming failure retries. */
+    rescheduleTimer(id: string, wakeAt: number): RunTimer;
+    /** Atomically lease timers due now; expired claims are safely retried. */
+    claimDueTimers(now?: number, limit?: number, leaseMs?: number): RunTimer[];
+    completeTimer(id: string): RunTimer;
+    retryTimer(id: string, error: string, now?: number): RunTimer;
+    cancelTimersForRun(runId: string): number;
+    cancelTimer(id: string): RunTimer;
+    private updateTimer;
+    private appendEvent;
+    private assertRunExists;
+    private assertRunActive;
+}
+
+type JobStatus = "starting" | "running" | "cancelling" | "completed" | "failed" | "timed_out" | "cancelled" | "unknown";
+
+interface RunWakeEvent {
+    runId: string;
+    timerId: string;
+    condition: "time" | "job";
+    jobId?: string;
+    jobStatus?: JobStatus | "not_found";
+}
+interface RunWakeSchedulerOptions {
+    /** Enqueue/resume the run; must be idempotent by timerId and return promptly. */
+    onWake: (event: RunWakeEvent) => void | Promise<void>;
+    runsDbPath?: string;
+    jobsDbPath?: string;
+    leaseMs?: number;
+    batchSize?: number;
+    onError?: (error: Error, timer?: RunTimer) => void;
+}
+/**
+ * Durable timer dispatcher. It holds no timer state in memory: every wake is
+ * claimed from SQLite, so a restart recovers scheduled and expired leases.
+ * onWake must be idempotent by timerId because delivery is at-least-once.
+ */
+declare class RunWakeScheduler {
+    private readonly store;
+    private readonly options;
+    private timer;
+    private running;
+    private disposed;
+    constructor(options: RunWakeSchedulerOptions);
+    start(): void;
+    stop(): void;
+    dispose(): void;
+    /** Deterministic entry point for tests and hosts that own their scheduler loop. */
+    processDueTimers(now?: number): Promise<number>;
+    private tick;
+    private scheduleNextTick;
+    private processTimer;
+    private failRunsForFailedTimers;
+}
+
 declare function resolveSdkConfig(opts: CreateSessionOptions): Promise<KimiConfig>;
 
-export { type ChatMessage, type CreateSessionOptions, DEFAULT_MODEL, DEFAULT_REASONING_EFFORT, type KimiConfig, type KimiFlareSession, type PermissionDecision, type PermissionHandler, type PermissionRequest, type PromptOptions, type SessionEvent, type SessionStatus, type SessionUsage, type Task, type ToolSpec, createAgentSession, createDefaultPermissionHandler, loadConfig, resolveSdkConfig, saveConfig, startRpcServer };
+export { type ChatMessage, type CreateSessionOptions, DEFAULT_MODEL, DEFAULT_REASONING_EFFORT, type KimiConfig, type KimiFlareSession, type PermissionDecision, type PermissionHandler, type PermissionRequest, type PromptOptions, type RunEvent, type RunEventType, type RunRecord, type RunStatus, RunStore, type RunTimer, type RunWakeEvent, RunWakeScheduler, type RunWakeSchedulerOptions, type SessionEvent, type SessionStatus, type SessionUsage, type Task, type TimerCondition, type TimerStatus, type ToolSpec, createAgentSession, createDefaultPermissionHandler, loadConfig, resolveSdkConfig, saveConfig, startRpcServer };