@crewx/sdk 0.9.0-rc.17 → 0.9.0-rc.170

package/dist/plugins/sqlite-tracing.d.ts

@@ -1,15 +1,61 @@
 import { CrewxPlugin } from '../plugin';
 import type { Crewx } from '../facade/Crewx';
+export interface SqliteTracingMetrics {
+    flushCount: number;
+    flushedEntries: number;
+    maxQueueEntries: number;
+    maxQueueBytes: number;
+    appendFailureCount: number;
+    appendFailureEntries: number;
+    appendFailureBytes: number;
+    appendFailureByCode: Record<string, number>;
+    appendFailureByCause: Record<string, number>;
+    pendingQueueEntries: number;
+    pendingQueueBytes: number;
+}
+export interface SqliteTracingRunnerIdentity {
+    detachedRunner: boolean;
+    assignedTaskId?: string;
+}
+export interface OwnedTaskRun {
+    taskId: string;
+    runEpoch: number;
+    workspaceId: string | null;
+    ownership: 'runner' | 'caller';
+}
 export interface SqliteTracingPluginOptions {
     dbRoot?: string;
     version?: string;
+    runnerIdentity?: SqliteTracingRunnerIdentity;
+    inheritWorktreeOwner?: boolean;
 }
 export declare class SqliteTracingPlugin extends CrewxPlugin {
     readonly name = "sqlite-tracing";
     private unsubs;
     private readonly dbPath;
     private readonly version;
+    private readonly inheritWorktreeOwner;
+    private readonly runnerIdentity;
+    private taskRepo?;
+    private readonly heartbeatTaskIds;
+    private readonly ownedTaskRuns;
+    private readonly ignoredDetachedTaskIds;
+    private readonly queues;
+    private metrics;
     constructor(opts?: SqliteTracingPluginOptions);
     attach(crewx: Crewx): void;
     detach(_crewx: Crewx): void;
+    listOwnedRunningTasks(): OwnedTaskRun[];
+    stopOwnedRunningTasksForHostShutdown(): Promise<void>;
+    getMetrics(): SqliteTracingMetrics;
+    private resolveTaskId;
+    private recordOwnedTaskRun;
+    private removeOwnedTaskRun;
+    private enqueueLog;
+    private recoverPartialResult;
+    private handleStopRequested;
+    private flushTaskLogs;
+    private flushAllTaskLogs;
+    private clearAllTimers;
+    private recordAppendFailure;
 }

package/dist/process/index.d.ts

@@ -0,0 +1,2 @@
+export { checkProcessOwnership, checkProcessOwnershipAsync, OWNED_GROUP_KILL_CONFIRM_MS, probeProcessLiveness, terminateOwnedProcessGroup, terminateProcessTree, UNIX_PROCESS_POLL_INTERVAL_MS, UNIX_SIGKILL_CONFIRM_MS, UNIX_SIGTERM_GRACE_MS, } from './process-control.js';
+export type { OwnedProcessGroupErrorKind, OwnedProcessGroupSignal, OwnedProcessGroupStatus, OwnedProcessGroupTerminationResult, ProcessCommandLineResult, ProcessCommandResult, ProcessCommandRunner, ProcessCommandRunnerAsync, ProcessControlOptions, ProcessLiveness, ProcessOwnership, ProcessTerminationResult, ProcessTerminationStatus, TerminateOwnedProcessGroupOptions, } from './process-control.js';

package/dist/process/index.js

@@ -0,0 +1 @@
+'use strict';var child_process=require('child_process');var C=3e3;var y=2e3,G=25,k=100;function R(e){return e instanceof Error?e:e===void 0?void 0:new Error(String(e))}function O(e){return typeof e=="object"&&e!==null&&"code"in e?String(e.code):void 0}function g(e){return Number.isSafeInteger(e)&&e>0}function K(e,t){try{let r=child_process.spawnSync(e,t,{encoding:"utf8",timeout:C,windowsHide:!0});return {status:r.status,stdout:typeof r.stdout=="string"?r.stdout:"",stderr:typeof r.stderr=="string"?r.stderr:"",error:r.error}}catch(r){return {status:null,stdout:"",stderr:"",error:R(r)}}}function F(e,t){return new Promise(r=>{let n;try{n=child_process.spawn(e,t,{windowsHide:!0});}catch(c){r({status:null,stdout:"",stderr:"",error:R(c)});return}let o="",s="",u=false,i,l=setTimeout(()=>{try{n.kill();}catch{}i({status:null,stdout:o,stderr:s,error:new Error(`Command timed out after ${C}ms`)});},C);i=c=>{u||(u=true,clearTimeout(l),r(c));},n.stdout?.setEncoding("utf8"),n.stderr?.setEncoding("utf8"),n.stdout?.on("data",c=>{o+=String(c);}),n.stderr?.on("data",c=>{s+=String(c);}),n.once("error",c=>{i({status:null,stdout:o,stderr:s,error:c});}),n.once("close",c=>{i({status:c,stdout:o,stderr:s});});})}async function T(e,t,r){return r.runCommandAsync?r.runCommandAsync(e,t):r.runCommand?r.runCommand(e,t):F(e,t)}function b(e){return new Promise(t=>{setTimeout(t,Math.max(0,e));})}function L(){return new Promise(e=>{setImmediate(e);})}function w(e,t=process.kill){try{return t(e,0),"alive"}catch(r){return O(r)==="ESRCH"?"not_found":O(r)==="EPERM"?"alive":"unknown"}}function D(e,t){if(!g(e))return {status:"unknown"};let r=t.platform??process.platform,n=t.runCommand??K,o=r==="win32"?"powershell.exe":"ps",s=r==="win32"?["-NoLogo","-NoProfile","-NonInteractive","-ExecutionPolicy","Bypass","-Command",`$p = Get-CimInstance -ClassName Win32_Process -Filter 'ProcessId = ${e}' -ErrorAction Stop; if ($null -ne $p) { [Console]::Write([string]$p.CommandLine) }`]:["-p",String(e),"-o","command="],u;try{u=n(o,s);}catch{return {status:"unknown"}}if(u.error||u.status!==0)return {status:"unknown"};let i=u.stdout.trim();return i?{status:"found",commandLine:i}:{status:"not_found"}}function W(e,t){let r=w(-e,t),n=w(e,t);return r==="alive"||n==="alive"?"alive":r==="unknown"||n==="unknown"?"unknown":"not_found"}async function N(e,t,r,n){let o=Math.max(0,r),s=Math.max(1,n.pollIntervalMs??G),u=Date.now()+o,i,l=o===0,c=n.sleep?Promise.resolve().then(()=>n.sleep(o)).then(()=>{},()=>{}):new Promise(a=>{i=setTimeout(a,o);});c.then(()=>{l=true;});try{for(await L();;){let a=W(e,t);if(a==="not_found")return a;let m=u-Date.now();if(l||m<=0)return a;await Promise.race([c,b(Math.min(s,m))]);}}finally{i!==void 0&&clearTimeout(i);}}async function h(e,t,r,n,o){let s=await N(e,t,o.hardConfirmMs??k,{...o,sleep:void 0});return s==="not_found"?r?{status:"not_found",pid:e,method:n}:{status:"terminated",pid:e,method:n}:s==="alive"?{status:"failed",pid:e,method:n,error:"Process is still running after termination attempt"}:{status:"failed",pid:e,method:n,error:"Unable to verify process termination"}}function $(e,t,r={}){let n=D(e,r);if(n.status!=="found")return n.status;let o=r.platform??process.platform,s=o==="win32"?n.commandLine.toLowerCase():n.commandLine;return t.filter(i=>i.trim().length>0).some(i=>{let l=o==="win32"?i.toLowerCase():i;return s.includes(l)})?"owned":"not_owned"}async function H(e,t,r={}){if(!g(e))return "unknown";let n=r.platform??process.platform,o=n==="win32"?"powershell.exe":"ps",s=n==="win32"?["-NoLogo","-NoProfile","-NonInteractive","-ExecutionPolicy","Bypass","-Command",`$p = Get-CimInstance -ClassName Win32_Process -Filter 'ProcessId = ${e}' -ErrorAction Stop; if ($null -ne $p) { [Console]::Write([string]$p.CommandLine) }`]:["-p",String(e),"-o","command="],u;try{u=await T(o,s,r);}catch{return "unknown"}if(u.error||u.status!==0)return "unknown";let i=u.stdout.trim();if(!i)return "not_found";let l=n==="win32"?i.toLowerCase():i;return t.filter(a=>a.trim().length>0).some(a=>{let m=n==="win32"?a.toLowerCase():a;return l.includes(m)})?"owned":"not_owned"}async function X(e,t={}){let r=t.platform??process.platform,n=r==="win32"?"taskkill":"process-group",o=f=>({status:"failed",pid:e,method:n,error:f});if(!g(e))return o("Invalid process ID");let s=t.kill??process.kill,u=w(e,s);if(u==="not_found")return {status:"not_found",pid:e,method:n};if(u!=="alive")return o("Unable to determine whether the process is alive");if(r==="win32"){let f;try{f=await T("taskkill",["/PID",String(e),"/T","/F"],t);}catch(P){f={status:null,stdout:"",stderr:"",error:R(P)};}let p=w(e,s);return p==="not_found"?f.status===0&&!f.error?{status:"terminated",pid:e,method:n}:{status:"not_found",pid:e,method:n}:o(p==="alive"?"Process is still running after termination attempt":"Unable to verify process termination")}let i,l=t.signal??"SIGKILL";try{s(-e,l);}catch(f){i=f;}if(l==="SIGKILL")return h(e,s,i,n,t);if(await N(e,s,t.graceMs??y,t)==="not_found")return i?{status:"not_found",pid:e,method:n}:{status:"terminated",pid:e,method:n};let a;try{s(-e,"SIGKILL");}catch(f){a=f;}let m=await h(e,s,a,n,t);return m.status==="terminated"?m:m.status==="not_found"?i?m:{status:"terminated",pid:e,method:n}:o(m.error??"Process termination failed")}var v=1e3,B=["SIGTERM","SIGINT","SIGHUP","SIGKILL"],J=6e4,V=100,j=3e4,q=1e3;function S(e,t,r){return Number.isFinite(e)&&e>=t&&e<=r}function z(e){return Number.isSafeInteger(e)&&e>1&&e!==process.pid}function M(e,t){try{return t(-e,0),"alive"}catch(r){let n=O(r);return n==="ESRCH"?"not_found":n==="EPERM"?"denied":"unknown"}}function E(e,t,r){try{return r(-e,t),"sent"}catch(n){let o=O(n);return o==="ESRCH"?"empty":o==="EPERM"?"denied":"failed"}}function _(){return performance.now()}async function I(e,t,r,n){let o=_()+r;for(;;){await L();let s=M(e,t);if(s==="not_found")return s;let u=o-_();if(u<=0)return s;await b(Math.min(n,u));}}async function Q(e,t,r,n){for(;;){await L();let o=M(e,t);if(o==="not_found"||o==="alive")return o;let s=r-_();if(s<=0)return o;await b(Math.min(n,s));}}function d(e,t,r,n){return {status:t,groupId:e,...r?{lastSignal:r}:{},...n?{errorKind:n}:{}}}async function Y(e,t={}){let r=t.signal??"SIGTERM",n=t.graceMs??y,o=t.hardConfirmMs??v,s=t.pollIntervalMs??G;if(!z(e))return d(e,"failed",void 0,"invalid_group_id");if(!B.includes(r)||!S(n,0,J)||!S(o,V,j)||!S(s,1,q))return d(e,"failed",void 0,"invalid_option");if((t.platform??process.platform)==="win32")return d(e,"unsupported",void 0,"unsupported_platform");let i=t.kill??process.kill,l=M(e,i);if(l==="not_found")return d(e,"exited");let c=n;if(l==="denied"&&r!=="SIGKILL"&&n>0){let p=_()+n,P=await Q(e,i,p,s);if(P==="not_found")return d(e,"exited");if(P!=="alive")return d(e,"failed",void 0,P==="denied"?"probe_denied":"probe_failed");c=Math.max(0,p-_());}else if(l!=="alive")return d(e,"failed",void 0,l==="denied"?"probe_denied":"probe_failed");let a;if(r!=="SIGKILL"){let p=E(e,r,i);if(p==="empty")return d(e,"exited");if(p!=="sent")return d(e,"failed",void 0,p==="denied"?"signal_denied":"signal_failed");a=r;let P=await I(e,i,c,s);if(P==="not_found")return d(e,"exited",a);if(P!=="alive")return d(e,"failed",a,P==="denied"?"probe_denied":"probe_failed")}let m=E(e,"SIGKILL",i);if(m==="empty")return d(e,"exited",a);if(m!=="sent")return d(e,"failed",a,m==="denied"?"signal_denied":"signal_failed");a="SIGKILL";let f=await I(e,i,o,s);return f==="not_found"?d(e,"exited",a):f==="alive"?d(e,"failed",a,"still_running"):d(e,"failed",a,f==="denied"?"probe_denied":"probe_failed")}exports.OWNED_GROUP_KILL_CONFIRM_MS=v;exports.UNIX_PROCESS_POLL_INTERVAL_MS=G;exports.UNIX_SIGKILL_CONFIRM_MS=k;exports.UNIX_SIGTERM_GRACE_MS=y;exports.checkProcessOwnership=$;exports.checkProcessOwnershipAsync=H;exports.probeProcessLiveness=w;exports.terminateOwnedProcessGroup=Y;exports.terminateProcessTree=X;

package/dist/process/process-control.d.ts

@@ -0,0 +1,60 @@
+export type ProcessLiveness = 'alive' | 'not_found' | 'unknown';
+export type ProcessOwnership = 'owned' | 'not_owned' | 'not_found' | 'unknown';
+export type ProcessTerminationStatus = 'terminated' | 'not_found' | 'failed';
+export interface ProcessCommandResult {
+    status: number | null;
+    stdout: string;
+    stderr: string;
+    error?: Error;
+}
+export type ProcessCommandRunner = (command: string, args: string[]) => ProcessCommandResult;
+export type ProcessCommandRunnerAsync = (command: string, args: string[]) => Promise<ProcessCommandResult>;
+export interface ProcessControlOptions {
+    platform?: NodeJS.Platform;
+    kill?: typeof process.kill;
+    runCommand?: ProcessCommandRunner;
+    runCommandAsync?: ProcessCommandRunnerAsync;
+    sleep?: (ms: number) => void | PromiseLike<void>;
+    graceMs?: number;
+    pollIntervalMs?: number;
+    hardConfirmMs?: number;
+}
+export interface ProcessCommandLineResult {
+    status: 'found' | 'not_found' | 'unknown';
+    commandLine?: string;
+}
+export interface ProcessTerminationResult {
+    status: ProcessTerminationStatus;
+    pid: number;
+    method: 'taskkill' | 'process-group';
+    error?: string;
+}
+export declare const POSIX_COOPERATIVE_STOP_SIGNAL: NodeJS.Signals;
+export declare const UNIX_SIGTERM_GRACE_MS = 2000;
+export declare const UNIX_PROCESS_POLL_INTERVAL_MS = 25;
+export declare const UNIX_SIGKILL_CONFIRM_MS = 100;
+export declare function probeProcessLiveness(pid: number, kill?: typeof process.kill): ProcessLiveness;
+export declare function checkProcessOwnership(pid: number, markers: readonly string[], options?: ProcessControlOptions): ProcessOwnership;
+export declare function checkProcessOwnershipAsync(pid: number, markers: readonly string[], options?: ProcessControlOptions): Promise<ProcessOwnership>;
+export declare function terminateProcessTree(pid: number, options?: ProcessControlOptions & {
+    signal?: NodeJS.Signals;
+}): Promise<ProcessTerminationResult>;
+export declare const OWNED_GROUP_KILL_CONFIRM_MS = 1000;
+export type OwnedProcessGroupSignal = 'SIGTERM' | 'SIGINT' | 'SIGHUP' | 'SIGKILL';
+export type OwnedProcessGroupStatus = 'exited' | 'failed' | 'unsupported';
+export type OwnedProcessGroupErrorKind = 'invalid_group_id' | 'invalid_option' | 'unsupported_platform' | 'probe_denied' | 'probe_failed' | 'signal_denied' | 'signal_failed' | 'still_running';
+export interface OwnedProcessGroupTerminationResult {
+    status: OwnedProcessGroupStatus;
+    groupId: number;
+    lastSignal?: OwnedProcessGroupSignal;
+    errorKind?: OwnedProcessGroupErrorKind;
+}
+export interface TerminateOwnedProcessGroupOptions {
+    signal?: OwnedProcessGroupSignal;
+    graceMs?: number;
+    hardConfirmMs?: number;
+    pollIntervalMs?: number;
+    platform?: NodeJS.Platform;
+    kill?: typeof process.kill;
+}
+export declare function terminateOwnedProcessGroup(groupId: number, options?: TerminateOwnedProcessGroupOptions): Promise<OwnedProcessGroupTerminationResult>;

package/dist/prompt/tag-names.d.ts

@@ -0,0 +1,22 @@
+export declare const PROMPT_TAGS: {
+    readonly crewxSystemPrompt: "crewx_system_prompt";
+    readonly systemPrompt: "system_prompt";
+    readonly threadContext: "crewx_thread_context";
+    readonly threadState: "thread_state";
+    readonly apps: "apps";
+    readonly appsGuidance: "apps_guidance";
+    readonly availableApps: "available_apps";
+    readonly crewxUiState: "crewx_ui_state";
+    readonly highlights: "highlights";
+    readonly highlight: "highlight";
+    readonly omittedTurns: "omitted_turns";
+    readonly messages: "messages";
+    readonly message: "message";
+    readonly userQuery: "user_query";
+    readonly execOutput: "exec_output";
+};
+export declare const LEGACY_PROMPT_TAGS: {
+    readonly conversationHistory: "conversation_history";
+    readonly semanticContinuity: "semantic_continuity";
+    readonly execOutput: "exec-output";
+};

package/dist/provider/acp/connection.d.ts

@@ -6,6 +6,7 @@ export interface AcpConnectionOptions {
     env?: Record<string, string>;
     cwd?: string;
     timeoutMs?: number;
+    idleMs?: number;
     onStderr?: (line: string) => void;
     onPid?: (pid: number) => void;
     configOptions?: Record<string, string>;
@@ -17,7 +18,12 @@ export declare class AcpConnection {
     private disposed;
     private stderrBuffer;
     private collectedStderr;
+    private stderrDecoder;
+    private stderrDecodeChain;
     private pendingUpdateCallback;
+    private idleWatchdog;
+    private idleReject;
+    private idlePromise;
     private authMethods;
     private _initResponse;
     get initResponse(): InitializeResponse | null;

package/dist/provider/acp/meta.d.ts

@@ -1,3 +1,7 @@
+import type { ProviderDefaultProfile } from '../models.js';
+import type { ProviderOptionSpec } from '../models.js';
+import type { ModelTier } from '../../config/models.generated.js';
+import type { ModelApiPricing } from '../../config/pricing.types.js';
 import type { InitializeResponse, NewSessionResponse } from './types.js';
 export interface AcpProviderMetaResult {
     id: string;
@@ -11,11 +15,18 @@ export interface AcpProviderMetaResult {
     models: Array<{
         id: string;
         name?: string;
+        description?: string;
+        contextWindowTokens?: number;
+        tier?: ModelTier;
+        recommended?: boolean;
+        apiPricing?: ModelApiPricing;
     }>;
     modelOverrides?: Record<string, {
         effort?: string[];
         defaultEffort?: string;
     }>;
+    providerOptions?: ProviderOptionSpec[];
+    defaults?: ProviderDefaultProfile;
     capabilities: Record<string, boolean>;
 }
 declare function extractProviderMeta(adapterId: string, displayName: string | undefined, initResponse: InitializeResponse, sessionResponse: NewSessionResponse): AcpProviderMetaResult;

package/dist/provider/bridge.d.ts

@@ -1,14 +1,18 @@
-import type { CliProviderAdapter } from './cli/adapter.types.js';
+import type { CliProviderAdapter, ProviderRateLimitWindows } from './cli/adapter.types.js';
 export declare function parseStreamJsonOutput(raw: string): string;
 export declare function parseResultEventUsage(raw: string): ProviderUsage | null;
-export { ProviderError, IdleTimeoutError, TotalTimeoutError, type ProviderErrorCode, type ProviderErrorKind, type ProviderErrorOptions, } from './errors.js';
+export { ProviderError, IdleTimeoutError, TotalTimeoutError, type ProviderErrorCode, type ProviderErrorKind, type ProviderErrorOptions, ResumeTimeoutError, } from './errors.js';
 export declare function shouldFallbackToGhCopilot(providerId: string, err: unknown, platform?: NodeJS.Platform): boolean;
 export declare const KILL_GRACE_MS = 2000;
 export interface RunCliProcessOptions {
     timeoutMs?: number;
+    idleMs?: number;
+    resumeSessionId?: string;
     env?: Record<string, string>;
+    unsetEnv?: readonly string[];
     cwd?: string;
     onOutput?: (line: string, level: 'stdout' | 'stderr') => void;
+    onRateLimitObserved?: (windows: ProviderRateLimitWindows) => void;
     onPid?: (pid: number) => void;
     onExitCode?: (code: number) => void;
     onUsage?: (usage: ProviderUsage) => void;
@@ -54,10 +58,13 @@ export interface ProviderQueryOptions {
     model?: string;
     effort?: string;
     mode?: string;
+    providerOptions?: Record<string, unknown>;
     context?: string;
     systemPrompt?: string;
     additionalArgs?: string[];
     resumeSessionId?: string;
+    providerSessionId?: string;
+    onProviderSessionId?: (id: string) => void;
     onOutput?: (line: string, level: 'stdout' | 'stderr') => void;
     onPid?: (pid: number) => void;
     onCommand?: (command: string) => void;
@@ -66,8 +73,11 @@ export interface ProviderQueryOptions {
     onModel?: (model: string) => void;
     onTaskLog?: (entries: import('../types/task-log.types').TaskLogEntry[]) => void;
     env?: Record<string, string>;
+    unsetEnv?: readonly string[];
+    onRateLimitObserved?: (windows: ProviderRateLimitWindows) => void;
     cwd?: string;
     timeoutMs?: number;
+    idleMs?: number;
     configOptions?: Record<string, string>;
     tools?: import('../facade/Crewx').ToolDefinition[];
     maxSteps?: number;

package/dist/provider/classify-task-error.d.ts

@@ -0,0 +1,2 @@
+import type { TaskErrorProjection } from './task-error.types.js';
+export declare function classifyTaskError(input: unknown): TaskErrorProjection;

package/dist/provider/claude-agent-env.d.ts

@@ -0,0 +1 @@
+export declare const CLAUDE_AGENT_ENV: Readonly<Record<string, string>>;

package/dist/provider/cli/adapter.types.d.ts

@@ -1,18 +1,29 @@
 import type { ProviderQueryOptions, ProviderUsage } from '../bridge.js';
 import type { TaskLogEntry } from '../../types/task-log.types.js';
+import type { ModelTier } from '../../config/models.generated.js';
 import { ProviderError } from '../errors.js';
+export interface ParseEventContext {
+    readonly rowIndex: number;
+    readonly state: Map<string, unknown>;
+}
 export interface CliProviderAdapter {
     readonly command: string;
+    createSessionId?(): string;
     readonly meta?: {
         displayName?: string;
         models?: Array<{
             id: string;
             name?: string;
+            description?: string;
+            contextWindowTokens?: number;
+            tier?: ModelTier;
         }>;
         defaultTimeoutMs?: {
             query?: number;
             execute?: number;
         };
+        defaultIdleMs?: number;
+        defaultResumeTimeoutMs?: number;
         capabilities?: {
             resume?: boolean;
             image?: boolean;
@@ -27,14 +38,24 @@ export interface CliProviderAdapter {
         env?: Record<string, string>;
     };
     extractText(stdout: string): string;
+    extractPartialText?(stdout: string): string | undefined;
     extractFailure?(line: string): Error | null;
-    interpretExit?(code: number, stderr: string): Error | null;
+    interpretExit?(code: number, stderr: string, stdout?: string): Error | null;
     parseResultMeta?(stdout: string): {
         usage?: ProviderUsage | null;
         model?: string | null;
     };
-    parseEvent?(line: string, timestamp?: string): TaskLogEntry[];
+    parseEvent?(line: string, timestamp?: string, context?: ParseEventContext): TaskLogEntry[];
     suppressOutputLine?(line: string): boolean;
+    observeRateLimit?(line: string): ProviderRateLimitWindows | undefined;
+}
+export interface ProviderRateLimitWindow {
+    utilization: number;
+    resetsAt: number;
+}
+export interface ProviderRateLimitWindows {
+    five_hour?: ProviderRateLimitWindow;
+    seven_day?: ProviderRateLimitWindow;
 }
 export declare class RateLimitError extends ProviderError {
     readonly name = "RateLimitError";

package/dist/provider/cli/adapters/agent-call.util.d.ts

@@ -1,3 +1,3 @@
 import type { TaskLogEntry } from '../../../types/task-log.types';
 export declare function isAgentCallCommand(command: string): boolean;
-export declare function parseAgentCall(timestamp: string, command: string): TaskLogEntry;
+export declare function parseAgentCall(timestamp: string, command: string, toolUseId?: string): TaskLogEntry;

package/dist/provider/cli/adapters/cli-knob.util.d.ts

@@ -6,3 +6,10 @@ export declare function codexModeArgs(mode?: string): string[];
 export declare function codexResumeModeArgs(mode?: string): string[];
 export declare function codexEffortArgs(effort?: string): string[];
 export declare function claudeModeArgs(mode?: string): string[];
+export declare function claudeEffortArgs(effort?: string): string[];
+export declare function grokModeArgs(mode?: string): string[];
+export declare function grokAlwaysApproveArgs(alwaysApprove?: unknown): string[];
+export declare function grokSandboxArgs(sandbox?: unknown, onWarning?: (message: string) => void): string[];
+export declare function grokEffortArgs(effort?: string): string[];
+export declare function antigravityModeArgs(mode?: string): string[];
+export declare function antigravityEffortArgs(effort?: string): string[];

package/dist/provider/cli/adapters/codex-item.d.ts

@@ -0,0 +1 @@
+export declare function isCodexDisplaySkippedStart(value: unknown): boolean;

package/dist/provider/cli/adapters/event-timestamp.util.d.ts

@@ -0,0 +1 @@
+export declare function resolveEventTimestamp(parsed: unknown, fallbackTs: string): string;

package/dist/provider/cli/adapters/grok.d.ts

@@ -0,0 +1,2 @@
+import type { CliProviderAdapter } from '../adapter.types.js';
+export declare const grokAdapter: CliProviderAdapter;

package/dist/provider/cli/adapters/index.d.ts

@@ -5,6 +5,11 @@ export { copilotAdapter } from './copilot.js';
 export { codexAdapter } from './codex.js';
 export { opencodeAdapter } from './opencode.js';
 export { antigravityAdapter } from './antigravity.js';
+export { grokAdapter } from './grok.js';
 export { isAgentCallCommand, parseAgentCall } from './agent-call.util.js';
 export declare const BUILTIN_ADAPTERS: Record<string, CliProviderAdapter>;
 export declare function parseStdoutEvent(timestamp: string, message: string, providerId?: string): TaskLogEntry[];
+export interface LogParseSession {
+    parse(timestamp: string, message: string, rowIndex: number): TaskLogEntry[];
+}
+export declare function createLogParseSession(providerId?: string): LogParseSession;

package/dist/provider/cli/index.d.ts

@@ -1,3 +1,4 @@
-export { BUILTIN_ADAPTERS, parseStdoutEvent, claudeAdapter, copilotAdapter, codexAdapter, opencodeAdapter, antigravityAdapter, isAgentCallCommand, parseAgentCall, } from './adapters/index.js';
-export type { CliProviderAdapter } from './adapter.types.js';
+export { BUILTIN_ADAPTERS, parseStdoutEvent, createLogParseSession, claudeAdapter, copilotAdapter, codexAdapter, opencodeAdapter, antigravityAdapter, grokAdapter, isAgentCallCommand, parseAgentCall, } from './adapters/index.js';
+export type { CliProviderAdapter, ParseEventContext } from './adapter.types.js';
 export { RateLimitError } from './adapter.types.js';
+export type { LogParseSession } from './adapters/index.js';

package/dist/provider/cli/meta.d.ts

@@ -1,4 +1,5 @@
 import type { AcpProviderMetaResult } from '../acp/meta.js';
+import type { ModelTier } from '../../config/models.generated.js';
 import type { CliProviderAdapter } from './adapter.types.js';
 export declare function queryOpencodeModels(): Promise<Array<{
     id: string;
@@ -6,6 +7,10 @@ export declare function queryOpencodeModels(): Promise<Array<{
 export declare function cliAdapterMetaToProviderMeta(key: string, adapter: CliProviderAdapter, overrideModels?: Array<{
     id: string;
     name?: string;
+    description?: string;
+    contextWindowTokens?: number;
+    tier?: ModelTier;
+    recommended?: boolean;
 }>): AcpProviderMetaResult | null;
 export declare function queryAllCliProviderMetas(options?: {
     includeOpencodeRuntimeModels?: boolean;

package/dist/provider/cli/protocol-envelope.d.ts

@@ -0,0 +1,3 @@
+export declare function shouldSkipRawStdoutJsonFallback(message: string, providerId?: string): boolean;
+export declare function isProtocolOnlyText(text: string, providerId?: string): boolean;
+export declare function isMetadataOnlyProtocolLine(message: string, providerId: string): boolean;

package/dist/provider/errors.d.ts

@@ -1,5 +1,5 @@
 export type ProviderErrorKind = 'transient' | 'permanent' | 'config';
-export type ProviderErrorCode = 'QUOTA_EXHAUSTED' | 'RATE_LIMITED' | 'EMPTY_OUTPUT' | 'AUTH_REQUIRED' | 'MODEL_UNAVAILABLE' | 'TIMEOUT_IDLE' | 'TIMEOUT_TOTAL' | 'PROVIDER_NOT_FOUND' | 'INVALID_PROVIDER_FORMAT' | 'PROVIDER_CRASHED' | 'UNKNOWN';
+export type ProviderErrorCode = 'QUOTA_EXHAUSTED' | 'RATE_LIMITED' | 'EMPTY_OUTPUT' | 'AUTH_REQUIRED' | 'MODEL_UNAVAILABLE' | 'TIMEOUT_IDLE' | 'TIMEOUT_TOTAL' | 'TIMEOUT_RESUME' | 'PROVIDER_NOT_FOUND' | 'INVALID_PROVIDER_FORMAT' | 'PROVIDER_CRASHED' | 'UNKNOWN';
 export interface ProviderErrorOptions {
     code?: ProviderErrorCode;
     kind?: ProviderErrorKind;
@@ -10,6 +10,7 @@ export declare class ProviderError extends Error {
     readonly code: ProviderErrorCode;
     readonly kind?: ProviderErrorKind;
     readonly retryAfterMs?: number;
+    stdout?: string;
     constructor(message: string, providerStr: string, options?: ProviderErrorOptions);
 }
 export declare class IdleTimeoutError extends ProviderError {
@@ -18,3 +19,6 @@ export declare class IdleTimeoutError extends ProviderError {
 export declare class TotalTimeoutError extends ProviderError {
     constructor(message: string, providerStr: string);
 }
+export declare class ResumeTimeoutError extends ProviderError {
+    constructor(message: string, providerStr: string);
+}

package/dist/provider/idle-watchdog.d.ts

@@ -0,0 +1,19 @@
+export interface IdleWatchdogOptions {
+    timeoutMs: number;
+    onIdle: () => void;
+    now?: () => number;
+}
+export declare class IdleWatchdog {
+    private readonly timeoutMs;
+    private readonly onIdleCb;
+    private readonly now;
+    private timer;
+    private lastActivity;
+    private settled;
+    constructor(options: IdleWatchdogOptions);
+    start(): void;
+    refresh(): void;
+    stop(): void;
+    private scheduleCheck;
+    private fireIdle;
+}

package/dist/provider/models.d.ts

@@ -1,9 +1,22 @@
-import { type ModelCatalogEntry, type ProviderCatalogEntry, type ProviderModeEntry, type ProviderModelOverride } from '../config/models.generated.js';
-export type { ModelCatalogEntry, ProviderCatalogEntry, ProviderModeEntry, ProviderModelOverride, } from '../config/models.generated.js';
+import { type ModelCatalogEntry, type ModelTier, type ProviderCatalogEntry, type ProviderDefaultProfile, type ProviderModeEntry, type ProviderModelOverride } from '../config/models.generated.js';
+import type { ModelApiPricing } from '../config/pricing.types.js';
+export type { ModelTier, ModelCatalogEntry, ProviderCatalogEntry, ProviderDefaultProfile, ProviderDefaults, ProviderModeEntry, ProviderOptionSpec, ProviderModelOverride, } from '../config/models.generated.js';
+export type ModelMergeEntry = {
+    id: string;
+    name?: string;
+    description?: string;
+    contextWindowTokens?: number;
+    tier?: ModelTier;
+    recommended?: boolean;
+    apiPricing?: ModelApiPricing;
+};
 export declare function setModelsOverride(providers: Record<string, ProviderCatalogEntry | ModelCatalogEntry[]>): void;
 export declare function clearModelsOverride(): void;
+export declare function setModelsDefaultsOverride(providers: Record<string, ProviderDefaultProfile>): void;
+export declare function clearModelsDefaultsOverride(): void;
 export declare function getProviderModels(provider: string): ModelCatalogEntry[];
 export declare function getProviderCatalog(provider: string): ProviderCatalogEntry;
+export declare function getProviderDefaultProfile(provider: string): ProviderDefaultProfile | undefined;
 export declare function getProviderModes(provider: string): ProviderModeEntry[];
 export declare function getProviderEffort(provider: string, model?: string): string[];
 export declare function getProviderModelOverrides(provider: string): Record<string, ProviderModelOverride>;
@@ -11,13 +24,5 @@ export declare function getClaudeModels(): ModelCatalogEntry[];
 export declare function getCodexModels(): ModelCatalogEntry[];
 export declare function getCopilotModels(): ModelCatalogEntry[];
 export declare function getAntigravityModels(): ModelCatalogEntry[];
-export declare function mergeModels(a: Array<{
-    id: string;
-    name?: string;
-}>, b: Array<{
-    id: string;
-    name?: string;
-}>): Array<{
-    id: string;
-    name?: string;
-}>;
+export declare function mergeModels(a: ModelMergeEntry[], b: ModelMergeEntry[]): ModelMergeEntry[];
+export declare function withApiPricing(models: ModelMergeEntry[]): ModelMergeEntry[];

package/dist/provider/order.d.ts

@@ -1,4 +1,4 @@
-export declare const PROVIDER_ORDER: readonly ["codex", "claude", "opencode", "antigravity", "copilot"];
+export declare const PROVIDER_ORDER: readonly ["codex", "claude", "grok", "opencode", "antigravity", "copilot"];
 export declare function providerRank(id: string): number;
 export declare function compareProviders(a: string, b: string): number;
 export declare function normalizeProviderId(provider?: string): string;

package/dist/provider/parse-usage.d.ts

@@ -3,4 +3,10 @@ export interface ParsedUsage {
     outputTokens: number;
     cachedInputTokens: number;
 }
+export interface ClaudePartialUsage {
+    inputTokens: number;
+    cachedInputTokens: number;
+    model?: string;
+}
+export declare function parseClaudePartialUsage(stdout: string): ClaudePartialUsage | undefined;
 export declare function parseUsage(stdout: string): ParsedUsage | undefined;

package/dist/provider/provider-selection.d.ts

@@ -0,0 +1,8 @@
+import type { CliProviderAdapter } from './cli/adapter.types.js';
+export declare function lookupCliAdapter(providerStr: string): CliProviderAdapter | undefined;
+export type ProviderAvailabilityDeps = {
+    lookupAdapter?: (providerStr: string) => CliProviderAdapter | undefined;
+    env?: NodeJS.ProcessEnv;
+};
+export declare function isProviderAvailable(providerStr: string, deps?: ProviderAvailabilityDeps): boolean;
+export declare function selectAvailableProvider(providers: string | string[], deps?: ProviderAvailabilityDeps): string;

package/dist/provider/redact-technical-message.d.ts

@@ -0,0 +1 @@
+export declare function redactTechnicalMessage(value: unknown): string | undefined;

package/dist/provider/task-error.types.d.ts

@@ -0,0 +1,17 @@
+export type TaskErrorCode = 'USAGE_LIMITED' | 'CONTEXT_WINDOW_EXCEEDED' | 'INPUT_TOO_LARGE' | 'MODEL_NOT_SUPPORTED' | 'MODEL_AT_CAPACITY' | 'AUTH_REQUIRED' | 'CLI_NOT_AVAILABLE' | 'CLI_UPDATE_REQUIRED' | 'AGENT_NOT_FOUND' | 'PERMISSION_OR_TRUST' | 'TIMEOUT_OR_STUCK' | 'NETWORK_OR_PROVIDER_TRANSIENT' | 'PROVIDER_CONFIGURATION' | 'AGENT_MODE_RESTRICTED' | 'PROCESS_FAILED';
+export interface TaskErrorMeta {
+    resetAt?: string | number;
+    model?: string;
+    cliName?: string;
+    envKey?: string;
+    upstreamType?: string;
+    upstreamCode?: string | number;
+    mode?: string;
+    referenceId?: string;
+    technicalMessage?: string;
+}
+export interface TaskErrorProjection {
+    errorCode: TaskErrorCode | null;
+    errorProvider: string | null;
+    errorMeta?: TaskErrorMeta;
+}

package/dist/provider-account/accounts.d.ts

@@ -0,0 +1,15 @@
+import { type AddedAiAccount, type AiAccountEnvPlan, type AiAccountInvocation, type AiAccountProvider, type AiAccountSummary, type ResolvedAiAccount, type ResolveAiAccountInput } from './types';
+export declare function aiAccountEnvPlan(provider: AiAccountProvider, namedDir?: string): AiAccountEnvPlan;
+export declare function applyAiAccountEnv(base: NodeJS.ProcessEnv, plan: AiAccountEnvPlan): NodeJS.ProcessEnv;
+export declare function listAiAccounts(provider: string): AiAccountSummary[];
+export declare function addAiAccount(provider: string, label: string): AddedAiAccount;
+export declare function removeAiAccount(id: string): {
+    id: string;
+    label: string;
+    provider: AiAccountProvider;
+    removedAt: string;
+};
+export declare function setActiveAiAccount(provider: string, id: string): void;
+export declare function getLoginInvocation(id: string, provider?: string): AiAccountInvocation;
+export declare function getStatusInvocation(id: string, provider?: string): AiAccountInvocation;
+export declare function resolveAiAccountForRun(input: ResolveAiAccountInput): ResolvedAiAccount | undefined;

package/dist/provider-account/index.d.ts

@@ -0,0 +1,5 @@
+export { addAiAccount, applyAiAccountEnv, aiAccountEnvPlan, getLoginInvocation, getStatusInvocation, listAiAccounts, removeAiAccount, resolveAiAccountForRun, setActiveAiAccount, } from './accounts';
+export { defaultAiAccountDir, loadProviderAccountsRegistry, providerAccountsRegistryPath, providerAccountsRoot, } from './registry';
+export type { ProviderAccountsRegistry, RemovedAiAccount, StoredAiAccount, } from './registry';
+export { AI_ACCOUNT_PROVIDERS, AiAccountError, CLAUDE_ACCOUNT_STRIPPED_ENV, DEFAULT_AI_ACCOUNT_ID, } from './types';
+export type { AddedAiAccount, AiAccountEnvPlan, AiAccountErrorCode, AiAccountInvocation, AiAccountProvider, AiAccountSummary, ResolveAiAccountInput, ResolvedAiAccount, } from './types';

package/dist/provider-account/registry.d.ts

@@ -0,0 +1,30 @@
+import { type AiAccountProvider } from './types';
+export interface StoredAiAccount {
+    id: string;
+    label: string;
+    dir: string;
+    createdAt: string;
+}
+export interface RemovedAiAccount {
+    id: string;
+    label: string;
+    provider: AiAccountProvider;
+    removedAt: string;
+}
+export interface ProviderAccountSlot {
+    active: string;
+    accounts: StoredAiAccount[];
+}
+export interface ProviderAccountsRegistry {
+    version: 1;
+    providers: Record<AiAccountProvider, ProviderAccountSlot>;
+    removed: RemovedAiAccount[];
+}
+export declare function providerAccountsRegistryPath(): string;
+export declare function providerAccountsRoot(): string;
+export declare function defaultAiAccountDir(provider: AiAccountProvider): string;
+export declare function isAiAccountProvider(value: string): value is AiAccountProvider;
+export declare function emptyProviderAccountsRegistry(): ProviderAccountsRegistry;
+export declare function loadProviderAccountsRegistry(): ProviderAccountsRegistry;
+export declare function saveProviderAccountsRegistry(registry: ProviderAccountsRegistry): void;
+export declare function allocatedAiAccountIds(registry: ProviderAccountsRegistry): Set<string>;

package/dist/provider-account/types.d.ts

@@ -0,0 +1,40 @@
+export declare const AI_ACCOUNT_PROVIDERS: readonly ["cli/claude", "cli/codex"];
+export type AiAccountProvider = (typeof AI_ACCOUNT_PROVIDERS)[number];
+export declare const DEFAULT_AI_ACCOUNT_ID = "default";
+export declare const CLAUDE_ACCOUNT_STRIPPED_ENV: readonly ["ANTHROPIC_API_KEY", "ANTHROPIC_AUTH_TOKEN", "CLAUDE_CODE_OAUTH_TOKEN"];
+export type AiAccountErrorCode = 'ACCOUNT_LABEL_INVALID' | 'ACCOUNT_PROVIDER_INVALID' | 'ACCOUNT_PROVIDER_UNSUPPORTED' | 'ACCOUNT_NOT_FOUND' | 'ACCOUNT_UNKNOWN' | 'ACCOUNT_DEFAULT_PROTECTED' | 'ACCOUNT_ACTIVE_PROTECTED' | 'ACCOUNT_RESUME_REMOVED' | 'ACCOUNT_REGISTRY_INVALID';
+export declare class AiAccountError extends Error {
+    readonly code: AiAccountErrorCode;
+    constructor(code: AiAccountErrorCode, message: string);
+}
+export interface AiAccountSummary {
+    id: string;
+    label: string;
+    provider: AiAccountProvider;
+    dir: string;
+    builtIn: boolean;
+    active: boolean;
+    createdAt?: string;
+}
+export interface AddedAiAccount {
+    id: string;
+    dir: string;
+}
+export interface AiAccountEnvPlan {
+    env: Record<string, string>;
+    unsetEnv: string[];
+}
+export interface AiAccountInvocation extends AiAccountEnvPlan {
+    command: string;
+    argv: string[];
+}
+export interface ResolvedAiAccount extends AiAccountEnvPlan {
+    id: string;
+    label: string;
+    fallback?: 'removed';
+}
+export interface ResolveAiAccountInput {
+    provider: string;
+    agentField?: string;
+    pinnedId?: string;
+}