@crewx/sdk 0.9.0-rc.22 → 0.9.0-rc.220

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

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

@@ -0,0 +1,74 @@
+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 const PROCESS_START_TIME_TOLERANCE_MS = 3000;
+export type ProcessIdentityLookup = {
+    status: 'found';
+    startedAtMs: number;
+    groupId: number | null;
+} | {
+    status: 'not_found';
+} | {
+    status: 'unknown';
+};
+export declare function parseProcessElapsedSeconds(value: string): number | undefined;
+export declare function parseWindowsCreationDate(value: string): number | undefined;
+export declare function readProcessIdentity(pid: number, options?: ProcessControlOptions): ProcessIdentityLookup;
+export declare function readProcessIdentityAsync(pid: number, options?: ProcessControlOptions): Promise<ProcessIdentityLookup>;
+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/adapter.d.ts

@@ -1,6 +1,7 @@
-import type { NewSessionRequest, SessionNotification, PromptResponse } from './types.js';
-import type { ProviderUsage } from '../bridge.js';
+import type { RequestPermissionRequest, RequestPermissionResponse, NewSessionRequest, NewSessionResponse, ResumeSessionResponse, SessionNotification, PromptResponse, InitializeResponse, ClientCapabilities } from './types.js';
+import type { ProviderQueryOptions, ProviderUsage } from '../bridge.js';
 import type { AcpSessionOptions, AcpOptionAction } from './types.js';
+import type { AcpConnection } from './connection.js';
 import type { TaskLogEntry } from '../../types/task-log.types.js';
 export type { AcpSessionOptions, AcpOptionAction };
 export interface AcpToolCallParsed {
@@ -27,9 +28,42 @@ export interface AcpProviderMeta {
     displayName: string;
     defaultMode?: string;
 }
+export type AcpPermissionPolicy = (request: RequestPermissionRequest) => RequestPermissionResponse | Promise<RequestPermissionResponse>;
+export interface AcpSessionSelectionContext {
+    readonly connection: AcpConnection;
+    readonly sessionId: string;
+    readonly resumed: boolean;
+    readonly sessionState?: NewSessionResponse | ResumeSessionResponse;
+    readonly options: ProviderQueryOptions;
+}
+export interface AcpAppliedSelection {
+    readonly model?: {
+        readonly requested?: string;
+        readonly applied?: string;
+    };
+    readonly effort?: {
+        readonly requested?: string;
+        readonly applied?: string;
+    };
+}
+export type AcpLineInterceptor = (stream: 'stdout' | 'stderr', line: string) => boolean;
 export interface AcpProviderAdapter {
     readonly spawn: AcpSpawnConfig;
+    readonly completionProof?: boolean;
+    readonly completionEligible?: () => boolean;
     readonly meta?: AcpProviderMeta;
+    readonly strictOptions?: boolean;
+    readonly connectTimeoutMs?: number;
+    readonly sessionTimeoutMs?: number;
+    readonly permissionPolicy?: AcpPermissionPolicy;
+    readonly autoAuthenticate?: boolean;
+    readonly allowIdOnlyAuth?: boolean;
+    readonly sessionResume?: boolean;
+    readonly clientCapabilities?: ClientCapabilities;
+    readonly validateInitialize?: (initializeResult: InitializeResponse) => void;
+    readonly beforeSession?: (connection: AcpConnection, initializeResult: InitializeResponse, options: ProviderQueryOptions) => void | Promise<void>;
+    readonly applySessionSelection?: (context: AcpSessionSelectionContext) => Promise<AcpAppliedSelection | void>;
+    readonly interceptLine?: AcpLineInterceptor;
     readonly npmPackage?: string;
     readonly clientInfo?: {
         name: string;
@@ -40,6 +74,7 @@ export interface AcpProviderAdapter {
     extractUsage?(result: PromptResponse): ProviderUsage | null;
     buildEffortAction?(effort: string, model?: string): AcpOptionAction | null;
     buildSpawnEnv?(model: string): Record<string, string> | undefined;
+    buildTrustedSpawnEnv?(options: ProviderQueryOptions): Record<string, string> | undefined;
     resolveMode?(mode: string): string | null;
     readonly yoloModeId?: string;
     parseToolCall?(event: AcpToolCallEvent): AcpToolCallParsed | null;

package/dist/provider/acp/adapters/antigravity-account.d.ts

@@ -0,0 +1,4 @@
+import type { AiAccountRunBinding } from '../../../provider-account/antigravity-acp/lifecycle.js';
+import type { AcpProviderAdapter } from '../adapter.js';
+export declare function createAntigravityAccountAdapter(input: AiAccountRunBinding): AcpProviderAdapter;
+export declare function resolveAntigravityAccountMode(mode: string): string | null;

package/dist/provider/acp/completion-observer.d.ts

@@ -0,0 +1,24 @@
+export declare class AcpCompletionObserver {
+    private valid;
+    private eofObserved;
+    private sessionId;
+    private readonly pendingSessionUpdates;
+    private readonly tools;
+    private readonly pendingAgentRequests;
+    private readonly pendingClientRequests;
+    private readonly seenAgentRequestIds;
+    private readonly seenClientRequestIds;
+    observeLine(line: string): void;
+    observeOutgoingLine(line: string): void;
+    setSessionId(sessionId: string): void;
+    observeEndOfStream(): void;
+    invalidate(): void;
+    isCompleteFor(sessionId: string): boolean;
+    private observeAgentRequest;
+    private observeAgentNotification;
+    private observeAgentResponse;
+    private observeClientRequest;
+    private observeClientNotification;
+    private observeClientResponse;
+    private applySessionUpdate;
+}

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

@@ -1,27 +1,65 @@
-import type { NewSessionRequest, NewSessionResponse, InitializeResponse, SessionNotification, PromptResponse, ContentBlock } from './types.js';
+import type { SetSessionConfigOptionResponse } from '@agentclientprotocol/sdk';
+import type { NewSessionRequest, NewSessionResponse, InitializeResponse, SessionNotification, PromptResponse, ContentBlock, ResumeSessionRequest, ResumeSessionResponse, ClientCapabilities } from './types.js';
 import { AcpProtocolError } from './types.js';
-import type { AcpSpawnConfig } from './adapter.js';
+import type { AcpLineInterceptor, AcpPermissionPolicy, AcpSpawnConfig } from './adapter.js';
 export interface AcpConnectionOptions {
     spawn: AcpSpawnConfig;
     env?: Record<string, string>;
+    trustedEnv?: Record<string, string>;
+    unsetEnv?: readonly string[];
+    unsetEnvPrefixes?: readonly string[];
     cwd?: string;
     timeoutMs?: number;
+    connectTimeoutMs?: number;
+    sessionTimeoutMs?: number;
+    strictOptions?: boolean;
+    autoAuthenticate?: boolean;
+    allowIdOnlyAuth?: boolean;
+    sessionResume?: boolean;
+    clientCapabilities?: ClientCapabilities;
+    interceptLine?: AcpLineInterceptor;
+    onProtocolLine?: (line: string) => void;
+    onOutgoingProtocolLine?: (line: string) => void;
+    verifyOwnedProcessGroup?: boolean;
+    signal?: AbortSignal;
+    idleMs?: number;
     onStderr?: (line: string) => void;
     onPid?: (pid: number) => void;
     configOptions?: Record<string, string>;
+    permissionPolicy?: AcpPermissionPolicy;
 }
 export declare class AcpConnection {
     private readonly options;
     private proc;
     private sdkConnection;
     private disposed;
+    private disposePromise;
     private stderrBuffer;
     private collectedStderr;
+    private stderrDecoder;
+    private stderrDecodeChain;
     private pendingUpdateCallback;
+    private idleWatchdog;
+    private idleReject;
+    private idlePromise;
     private authMethods;
+    private effectiveEnv;
     private _initResponse;
+    private stdoutDecoder;
+    private stdoutLineBuffer;
+    private outgoingDecoder;
+    private outgoingLineBuffer;
+    private _stdoutTailObserved;
+    private stdoutTailDone;
+    private readonly stdoutTailPromise;
+    private resolveStdoutTail;
+    private processClosePromise;
+    private ownedProcessGroupId;
+    private _ownedProcessGroupDisposed;
     get initResponse(): InitializeResponse | null;
     constructor(options: AcpConnectionOptions);
+    get ownedProcessGroupDisposed(): boolean;
+    get stdoutTailObserved(): boolean;
     connect(clientInfo?: {
         name: string;
         version: string;
@@ -31,14 +69,42 @@ export declare class AcpConnection {
     private newSessionWithTimeout;
     newSessionRaw(params: NewSessionRequest): Promise<NewSessionResponse>;
     private newSessionRawTimeout;
+    resumeSession(params: ResumeSessionRequest): Promise<string>;
+    resumeSessionRaw(params: ResumeSessionRequest): Promise<ResumeSessionResponse>;
+    private resumeSessionRawTimeout;
+    getAuthMethods(): Array<{
+        id: string;
+        name?: string;
+        type?: string;
+    }>;
+    authenticate(methodId: string, options?: {
+        signal?: AbortSignal;
+    }): Promise<void>;
+    logout(options?: {
+        signal?: AbortSignal;
+    }): Promise<void>;
+    private withProcessReply;
     private isAuthError;
     private tryAuthenticate;
     private hasEnvVarsFor;
+    private hasResumeCapability;
+    private createAuthRequiredError;
+    private assertCanOperate;
+    private withSignal;
+    private withTimeoutAndSignal;
+    private shouldConsumeLine;
+    private consumeStdoutText;
+    private finishStdoutTail;
+    private consumeOutgoingText;
+    private consumeStderrText;
+    private emitStderrLine;
     setModel(sessionId: string, modelId: string): Promise<void>;
     setMode(sessionId: string, modeId: string): Promise<void>;
-    setConfigOption(sessionId: string, configId: string, value: string): Promise<void>;
+    setConfigOption(sessionId: string, configId: string, value: string): Promise<SetSessionConfigOptionResponse>;
     prompt(sessionId: string, promptBlocks: ContentBlock[], onUpdate?: (notification: SessionNotification) => void, timeoutMs?: number): Promise<PromptResponse>;
     dispose(): Promise<void>;
+    private disposeResources;
+    private disposeOwnedProcessGroup;
     get isConnected(): boolean;
 }
 export { AcpProtocolError };

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

@@ -1,6 +1,6 @@
-export { AcpProtocolError } from './types.js';
-export type { AcpSessionOptions, InitializeRequest, InitializeResponse, NewSessionRequest, NewSessionResponse, PromptRequest, PromptResponse, SessionNotification, SessionUpdate, ContentBlock, McpServer, } from './types.js';
-export type { AcpProviderAdapter, AcpProviderMeta, AcpSpawnConfig } from './adapter.js';
+export { AcpAbortError, AcpAuthMethodError, AcpAuthRequiredError, AcpCapabilityError, AcpOptionError, AcpProtocolError, } from './types.js';
+export type { AcpSessionOptions, AcpProtocolErrorReason, ClientCapabilities, InitializeRequest, InitializeResponse, NewSessionRequest, NewSessionResponse, PromptRequest, PromptResponse, ResumeSessionRequest, ResumeSessionResponse, RequestPermissionRequest, RequestPermissionResponse, SessionNotification, SessionUpdate, ContentBlock, McpServer, } from './types.js';
+export type { AcpAppliedSelection, AcpLineInterceptor, AcpPermissionPolicy, AcpProviderAdapter, AcpProviderMeta, AcpSessionSelectionContext, AcpSpawnConfig, } from './adapter.js';
 export { defaultExtractText, defaultParseEvent } from './adapter.js';
 export type { AcpProviderMetaResult } from './meta.js';
 export { queryAcpProviderMeta, queryAllAcpProviderMetas } from './meta.js';

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/acp/register.d.ts

@@ -1,2 +1,3 @@
 import type { ProviderFactory } from '../bridge.js';
 export declare function registerAcpProviders(factory?: ProviderFactory): void;
+export declare function registerAntigravityAccountProvider(): void;

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

@@ -7,6 +7,7 @@ export declare class AcpProviderRuntime implements ProviderRuntime {
     execute(message: string, options?: ProviderQueryOptions): Promise<string>;
     dispose(): Promise<void>;
     private runPrompt;
+    private awaitWithSignal;
     private applySessionOptions;
     private composePrompt;
     private handleUpdate;

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

@@ -1,5 +1,5 @@
-import type { InitializeRequest, InitializeResponse, NewSessionRequest, NewSessionResponse, PromptRequest, PromptResponse, SessionNotification, SessionUpdate, ContentBlock, McpServer, ClientCapabilities } from '@agentclientprotocol/sdk';
-export type { InitializeRequest, InitializeResponse, NewSessionRequest, NewSessionResponse, PromptRequest, PromptResponse, SessionNotification, SessionUpdate, ContentBlock, McpServer, ClientCapabilities, };
+import type { InitializeRequest, InitializeResponse, NewSessionRequest, NewSessionResponse, PromptRequest, PromptResponse, ResumeSessionRequest, ResumeSessionResponse, RequestPermissionRequest, RequestPermissionResponse, SessionNotification, SessionUpdate, ContentBlock, McpServer, ClientCapabilities } from '@agentclientprotocol/sdk';
+export type { InitializeRequest, InitializeResponse, NewSessionRequest, NewSessionResponse, PromptRequest, PromptResponse, ResumeSessionRequest, ResumeSessionResponse, RequestPermissionRequest, RequestPermissionResponse, SessionNotification, SessionUpdate, ContentBlock, McpServer, ClientCapabilities, };
 export interface AcpSessionOptions {
     cwd?: string;
     env?: Record<string, string>;
@@ -16,9 +16,36 @@ export type AcpOptionAction = {
     type: 'set_model';
     modelId: string;
 };
+export type AcpProtocolErrorReason = 'connect_timeout' | 'session_timeout' | 'resume_unsupported' | 'auth_required' | 'auth_method_unsupported' | 'aborted';
 export declare class AcpProtocolError extends Error {
     readonly code?: number | undefined;
     readonly data?: unknown | undefined;
-    readonly name = "AcpProtocolError";
-    constructor(message: string, code?: number | undefined, data?: unknown | undefined);
+    readonly reason?: AcpProtocolErrorReason | undefined;
+    readonly name: string;
+    constructor(message: string, code?: number | undefined, data?: unknown | undefined, reason?: AcpProtocolErrorReason | undefined);
+}
+export declare class AcpAuthRequiredError extends AcpProtocolError {
+    readonly name = "AcpAuthRequiredError";
+    readonly methodIds: readonly string[];
+    constructor(methodIds: readonly string[]);
+}
+export declare class AcpAuthMethodError extends AcpProtocolError {
+    readonly name = "AcpAuthMethodError";
+    constructor();
+}
+export declare class AcpCapabilityError extends AcpProtocolError {
+    readonly capability: 'session.resume' | 'auth.logout';
+    readonly name = "AcpCapabilityError";
+    constructor(capability: 'session.resume' | 'auth.logout');
+}
+export declare class AcpAbortError extends AcpProtocolError {
+    readonly name = "AcpAbortError";
+    constructor();
+}
+export declare class AcpOptionError extends AcpProtocolError {
+    readonly name: string;
+    readonly option: 'model' | 'mode' | 'config';
+    readonly requestedValue: string;
+    readonly supportedValues?: readonly string[];
+    constructor(option: 'model' | 'mode' | 'config', requestedValue: string, supportedValues?: readonly string[], reason?: string);
 }

package/dist/provider/bridge.browser.d.ts

@@ -5,13 +5,16 @@ export interface ProviderUsage {
     outputTokens: number;
     cachedInputTokens: number;
     costUsd: number;
+    complete?: boolean;
 }
 export interface ProviderQueryOptions {
+    signal?: AbortSignal;
     model?: string;
     context?: string;
     systemPrompt?: string;
     additionalArgs?: string[];
     onOutput?: (line: string, level: 'stdout' | 'stderr') => void;
+    onSpawn?: () => void;
     onPid?: (pid: number) => void;
     onCommand?: (command: string) => void;
     onUsage?: (usage: ProviderUsage) => void;

package/dist/provider/bridge.d.ts

@@ -1,20 +1,27 @@
-import type { CliProviderAdapter } from './cli/adapter.types.js';
+import type { CliProviderAdapter, CliProviderInvocation, 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 {
+    signal?: AbortSignal;
     timeoutMs?: number;
+    idleMs?: number;
+    resumeSessionId?: string;
+    onProviderSessionId?: (id: string) => void;
     env?: Record<string, string>;
+    unsetEnv?: readonly string[];
     cwd?: string;
     onOutput?: (line: string, level: 'stdout' | 'stderr') => void;
+    onRateLimitObserved?: (windows: ProviderRateLimitWindows) => void;
+    onSpawn?: () => void;
     onPid?: (pid: number) => void;
     onExitCode?: (code: number) => void;
     onUsage?: (usage: ProviderUsage) => void;
     onModel?: (model: string) => void;
 }
-export declare function runCliProcess(command: string, args: string[], providerStr: string, _providerId: string, options?: RunCliProcessOptions, stdinMessage?: string, adapter?: CliProviderAdapter): Promise<{
+export declare function runCliProcess(command: string, args: string[], providerStr: string, _providerId: string, options?: RunCliProcessOptions, stdinMessage?: string, adapter?: CliProviderAdapter, disposeInvocation?: CliProviderInvocation['dispose']): Promise<{
     stdout: string;
     parsed: string;
 }>;
@@ -37,7 +44,7 @@ export declare class ClientToolCallRequiredError extends Error {
     readonly name = "ClientToolCallRequiredError";
     constructor(toolCall: ClientToolCall, continuationState: ContinuationState);
 }
-export type ProviderFactory = (id: string, providerStr: string) => ProviderRuntime;
+export type ProviderFactory = (id: string, providerStr: string, context?: unknown) => ProviderRuntime;
 export type AdditionalArgsProvider = (ctx: {
     providerStr: string;
     providerId: string;
@@ -49,15 +56,26 @@ export interface ProviderUsage {
     outputTokens: number;
     cachedInputTokens: number;
     costUsd: number;
+    complete?: boolean;
 }
 export interface ProviderQueryOptions {
+    signal?: AbortSignal;
     model?: string;
     effort?: string;
     mode?: string;
+    providerOptions?: Record<string, unknown>;
     context?: string;
     systemPrompt?: string;
     additionalArgs?: string[];
     resumeSessionId?: string;
+    providerSessionId?: string;
+    onProviderSessionId?: (id: string) => void;
+    onAcpCompletionProof?: (proof: {
+        sessionId: string;
+        stopReason: 'end_turn';
+        lifecycleComplete: true;
+    }) => void;
+    onSpawn?: () => void;
     onOutput?: (line: string, level: 'stdout' | 'stderr') => void;
     onPid?: (pid: number) => void;
     onCommand?: (command: string) => void;
@@ -66,8 +84,12 @@ export interface ProviderQueryOptions {
     onModel?: (model: string) => void;
     onTaskLog?: (entries: import('../types/task-log.types').TaskLogEntry[]) => void;
     env?: Record<string, string>;
+    unsetEnv?: readonly string[];
+    unsetEnvPrefixes?: readonly string[];
+    onRateLimitObserved?: (windows: ProviderRateLimitWindows) => void;
     cwd?: string;
     timeoutMs?: number;
+    idleMs?: number;
     configOptions?: Record<string, string>;
     tools?: import('../facade/Crewx').ToolDefinition[];
     maxSteps?: number;
@@ -83,6 +105,7 @@ export interface ProviderRuntime {
     dispose?(): Promise<void>;
 }
 export declare function createProvider(providerStr: string, additionalArgsProvider?: AdditionalArgsProvider): ProviderRuntime;
+export declare function createProviderWithContext(providerStr: string, additionalArgsProvider?: AdditionalArgsProvider, context?: unknown): ProviderRuntime;
 export declare function mergeAdditionalArgs(options: ProviderQueryOptions | undefined, provider: AdditionalArgsProvider | undefined, ctx: {
     providerStr: string;
     providerId: string;

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>>;