@crewx/sdk 0.9.0-rc.16 → 0.9.0-rc.160

package/dist/app/index.js

@@ -0,0 +1,10 @@
+'use strict';var util=require('util'),fs=require('fs'),crypto=require('crypto'),console$1=require('console'),stream=require('stream');var h=["text/plain","application/json"];var Y=Symbol;Y.metadata===void 0&&Object.defineProperty(Symbol,"metadata",{configurable:false,value:Symbol.for("Symbol.metadata")});var ue=Y.metadata,N=Symbol.for("crewx.app.tool-metadata"),A=class extends Error{code;detail;outcome;constructor(t,n=null,o){super(t),this.name="AppError",this.code=t,this.detail=n,this.outcome=B(o?.outcome);}};function B(e){return e==="rejected"?"rejected":"failed"}var q=class{static devtools=process.env.CREWX_APP_DEV==="1"?Object.freeze({log:true}):void 0;currentState;stateWasSet=false;answerBody;answerRange;callContext;workspaceRoot;constructor(t={workspaceRoot:process.cwd()}){this.currentState=t.state??{},this.workspaceRoot=t.workspaceRoot,this.callContext=t.context===void 0?void 0:fe(t.context);}get context(){if(this.callContext===void 0)throw new TypeError("this.context is only set when the Host runs the action; pass options.context when you construct the App in a test");return this.callContext}get state(){return this.currentState}get didSetState(){return this.stateWasSet}setState(t){this.currentState=t,this.stateWasSet=true;}get didSetContent(){return this.answerBody!==void 0}get producedContent(){return this.answerBody===void 0?void 0:{body:this.answerBody,...this.answerRange===void 0?{}:{range:this.answerRange}}}setContent(t,n){if(typeof t!="string"&&!(t instanceof Uint8Array))throw new TypeError("setContent needs a string or a Uint8Array");if(n!==void 0&&!me(n))throw new TypeError("setContent range must be { startLine, lineCount, totalLines }, three integers of at least 1");this.answerBody=typeof t=="string"?new TextEncoder().encode(t):new Uint8Array(t),this.answerRange=n===void 0?void 0:{startLine:n.startLine,lineCount:n.lineCount,totalLines:n.totalLines};}emptyState(){return {}}validate(t,n,o){}mapError(t){return {code:"EXECUTION_FAILED",detail:null}}errorState(t,n,o){return {...O(o.state)?o.state:{},error:{code:t,detail:n}}}};function ce(e){return function(t,n){if(n.static||n.private||n.kind!=="method")throw new TypeError("@Tool can decorate public instance methods only");let o=n.metadata;if(!o)throw new TypeError("standard decorator metadata is unavailable");let i=Object.hasOwn(o,N)?o[N]:[];if(i.some(s=>s.methodName===String(n.name)))throw new TypeError(`@Tool is declared more than once for ${String(n.name)}`);let r=e.content===void 0?void 0:pe(e.name,e.content);o[N]=[...i,{methodName:String(n.name),options:Object.freeze({...e,...r===void 0?{}:{content:r}})}];}}function D(e){let t=e[ue],n=t&&Object.hasOwn(t,N)?t[N]:[],o=new Map(n.map(r=>[r.methodName,r])),i=Object.getOwnPropertyNames(e.prototype).map(r=>o.get(r)).filter(r=>r!==void 0);if(i.length!==n.length)throw new TypeError("a @Tool method is missing from the App prototype");return i}function H(e){let t=e.definition,n=D(e),o=new Set;return n.map(({options:i})=>{if(o.has(i.name))throw new TypeError(`duplicate @Tool name: ${i.name}`);return o.add(i.name),{actionId:i.name,...i.dataInputs===void 0?{}:{dataInputs:[...i.dataInputs]},confirmation:i.confirmation??"none",capability:i.capability??"app.read",mutation:i.mutation??true,inputSchema:i.inputSchema,...i.content===void 0?{}:{content:ye(i.content)},resultProjection:i.resultProjection??{allow:[...t.stateProjection.allow]},_meta:{description:i.description}}})}function le(e,t){if(t.length===0)throw new TypeError("backendCommand must name the skill command");let n=H(e).map(({_meta:o,...i})=>({...i,backend:{type:"skill",command:[...t]},_meta:o}));return {...e.definition,actions:n}}function pe(e,t){let n=r=>{throw new TypeError(`@Tool ${e}: content ${r}`)},o=(r,s,u)=>{if(!O(u))return n(`${r} must be an object`);for(let a of Object.keys(u))if(a==="mediaType"){if(!h.includes(u[a]))return n(`${r}.mediaType must be one of ${h.join(", ")}`)}else if(a===s){if(typeof u[a]!="boolean")return n(`${r}.${a} must be true or false`)}else return n(`${r} has the unknown key "${a}"`);return Object.hasOwn(u,"mediaType")?Object.freeze({...u}):n(`${r}.mediaType is required`)};if(!O(t))return n("must be an object");let i={};for(let r of Object.keys(t))if(r==="in")i[r]=o("in","required",t[r]);else if(r==="out")i[r]=o("out","range",t[r]);else return n(`has the unknown key "${r}"; use "in" and/or "out"`);return Object.keys(i).length===0?n('needs "in" and/or "out"'):Object.freeze(i)}function fe(e){return Object.freeze({instanceId:e.instanceId,threadId:e.threadId,actor:e.actor,requestId:e.requestId,nowMs:e.nowMs})}function ye(e){let t={};for(let[n,o]of Object.entries(e))t[n]={...o};return t}function me(e){return O(e)&&["startLine","lineCount","totalLines"].every(t=>Number.isSafeInteger(e[t])&&e[t]>=1)}function O(e){if(e===null||typeof e!="object"||Array.isArray(e))return  false;let t=Object.getPrototypeOf(e);return t===Object.prototype||t===null}var Te=/^[A-Za-z0-9._:-]{1,128}$/u,Ee=/[\u0000-\u001f\u007f\u2028\u2029]/u;function K(e=process.env){let t=G(e.CREWX_APP_INSTANCE_ID),n=e.CREWX_APP_REQUEST_ID,o=e.CREWX_APP_ACTOR_KIND,i=e.CREWX_APP_NOW_MS;if(t===void 0||typeof n!="string"||!Te.test(n)||o!=="user"&&o!=="agent"||typeof i!="string"||!/^\d{1,16}$/u.test(i))return;let r=Number(i);if(!Number.isSafeInteger(r))return;let s=e.CREWX_THREAD_ID===void 0?null:G(e.CREWX_THREAD_ID);if(s!==void 0)return Object.freeze({instanceId:t,threadId:s,actor:o,requestId:n,nowMs:r})}function G(e){if(!(typeof e!="string"||e.length===0||Ee.test(e)))return new TextEncoder().encode(e).byteLength<=512?e:void 0}var ge="dist/tools.json",Ae=1,Ce="dist/main.mjs";var Q=["CREWX_APP_INSTANCE_ID","CREWX_THREAD_ID"];function Oe(e){if(!Array.isArray(e)||e.length===0)return  false;let t=new Set;for(let n of e){if(!Q.some(o=>o===n)||t.has(n))return  false;t.add(n);}return  true}var j=2,L=2097152;var R=2*1024*1024,U=2e4;function $(e){return crypto.createHash("sha256").update(e).digest("hex")}function F(e){if(e.byteLength===0)return 0;let t=0;for(let n of e)n===10&&(t+=1);return e[e.byteLength-1]!==10&&(t+=1),t}var be=L+1+R,Se=64*1024,Ie=10,P={kind:"invalid"};function he(e,t){try{let n=[],o=0;for(;;){let s=new Uint8Array(Se),u=fs.readSync(e,s,0,s.length,null);if(u===0)break;if(o+=u,o>t)return;n.push(s.subarray(0,u));}let i=new Uint8Array(o),r=0;for(let s of n)i.set(s,r),r+=s.byteLength;return i}catch{return}}function M(e){return Re(he(e,be))}function Re(e){if(e===void 0)return P;let t=e.indexOf(Ie);if(e.byteLength<=L){let o=Le(Buffer.from(e.buffer,e.byteOffset,e.byteLength).toString("utf8"));if(o.ok&&!(t>=0&&b(o.value)&&o.value.schemaVersion===j))return {kind:"v1",value:o.value}}if(t<=0||t>L)return P;let n;try{n=JSON.parse(new TextDecoder("utf-8",{fatal:!0}).decode(e.subarray(0,t)));}catch{return P}return !b(n)||n.schemaVersion!==j?P:{kind:"v2",header:n,body:e.subarray(t+1)}}var Ne="actionId,content,input,schemaVersion,state",xe="bytes,lines,mediaType,sha256",ke="mediaType,range",De=/^[a-f0-9]{64}$/u,je=new TextDecoder("utf-8",{fatal:true,ignoreBOM:true});function te(e,t){let n=a=>({code:a,outcome:"rejected"});if(x(e)!==Ne||e.schemaVersion!==j||typeof e.actionId!="string"||!b(e.input)||!b(e.state)||!b(e.content)||x(e.content)!=="in,out")return {code:"INPUT_INVALID",outcome:"failed"};let o=e.content,i,r=o.in;if(r===null){if(t.byteLength!==0)return n(t.byteLength>R?"CONTENT_TOO_LARGE":"CONTENT_DIGEST_MISMATCH")}else {if(!b(r)||x(r)!==xe||!Z(r.mediaType)||!ee(r.bytes,R)||!ee(r.lines,U)||typeof r.sha256!="string"||!De.test(r.sha256)||t.byteLength!==r.bytes)return n(t.byteLength>R?"CONTENT_TOO_LARGE":"CONTENT_DIGEST_MISMATCH");if($(t)!==r.sha256||F(t)!==r.lines)return n("CONTENT_DIGEST_MISMATCH");let a;try{a=je.decode(t);}catch{return n("CONTENT_ENCODING_INVALID")}i={mediaType:r.mediaType,text:a};}let s,u=o.out;if(u!==null){if(!b(u)||x(u)!==ke||!Z(u.mediaType))return n("CONTENT_SOURCE_UNSUPPORTED");let a=u.range;if(a!==null&&!Ue(a))return n("CONTENT_SOURCE_UNSUPPORTED");s={mediaType:u.mediaType,...a===null?{}:{range:{startLine:a.startLine,lineCount:a.lineCount}}};}return {actionId:e.actionId,input:e.input,state:e.state,content:{...i===void 0?{}:{in:i},...s===void 0?{}:{out:s}}}}function ne(e){return Object.hasOwn(e,"code")}function oe(e,t){let n=o=>({code:o,outcome:"rejected"});if(e?.in===void 0){if(t.in!==void 0)return n("CONTENT_SOURCE_UNSUPPORTED")}else if(t.in===void 0){if(e.in.required===true)return n("CONTENT_REQUIRED")}else if(t.in.mediaType!==e.in.mediaType)return n("CONTENT_SOURCE_UNSUPPORTED");if(e?.out===void 0){if(t.out!==void 0)return n("CONTENT_SOURCE_UNSUPPORTED")}else {if(t.out===void 0)return n("CONTENT_REQUIRED");if(t.out.mediaType!==e.out.mediaType||t.out.range!==void 0&&e.out.range!==true)return n("CONTENT_SOURCE_UNSUPPORTED")}}function v(e,t){let{content:n,...o}=e,i=t===void 0?o:{...o,content:{bytes:t.body.byteLength,lines:F(t.body),sha256:$(t.body),...t.range===void 0?{}:{range:t.range}}},r=new TextEncoder().encode(`${JSON.stringify(i)}
+`);if(t===void 0)return r;let s=new Uint8Array(r.byteLength+t.body.byteLength);return s.set(r,0),s.set(t.body,r.byteLength),s}function re(e){if(e.body.byteLength>R||F(e.body)>U)return {code:"CONTENT_TOO_LARGE",outcome:"failed"}}function Le(e){try{return {ok:!0,value:JSON.parse(e)}}catch{return {ok:false}}}function x(e){return Object.keys(e).sort().join(",")}function b(e){if(e===null||typeof e!="object"||Array.isArray(e))return  false;let t=Object.getPrototypeOf(e);return t===Object.prototype||t===null}function Z(e){return typeof e=="string"&&h.includes(e)}function ee(e,t){return Number.isSafeInteger(e)&&e>=0&&e<=t}function Ue(e){return b(e)&&x(e)==="lineCount,startLine"&&Number.isSafeInteger(e.startLine)&&e.startLine>=1&&Number.isSafeInteger(e.lineCount)&&e.lineCount>=1&&e.lineCount<=U}var Pe=1;async function Me(e,t,n=process.env.CREWX_WORKSPACE_ROOT??process.cwd(),o){return (await se(e,t,n,void 0,true,void 0,o)).response}async function se(e,t,n,o,i=true,r,s){let u=r!==void 0,a=O(t)?t:void 0,m=a?.input,T=a?.state,d=new e({state:O(T)?T:{},workspaceRoot:n,...s===void 0?{}:{context:s}}),C=O(m)?m:{},E=O(T)?T:d.emptyState(),y={};try{let c;if(u){if(a===void 0)throw new A("INPUT_INVALID");let f=te(a,r);if(ne(f))throw new A(f.code,null,{outcome:f.outcome});(({actionId:c,input:C,state:E}=f)),y=f.content;}else {if(!a||Object.keys(a).length!==4||!["schemaVersion","actionId","input","state"].every(f=>Object.hasOwn(a,f))||a.schemaVersion!==Pe||typeof a.actionId!="string"||!O(m)||!O(T))throw new A("INPUT_INVALID");c=a.actionId,C=m,E=T;}d=new e({state:E,workspaceRoot:n,...s===void 0?{}:{context:s}}),await d.validate(c,C,E);let l=D(e).find(({options:f})=>f.name===c);if(!l)throw new A("INPUT_INVALID");let g=d[l.methodName];if(typeof g!="function")throw new A("EXECUTION_FAILED");let p=oe(l.options.content,y);if(p)throw new A(p.code,null,{outcome:p.outcome});let k=Object.freeze({...y.in===void 0?{}:{in:Object.freeze({text:y.in.text})},...y.out===void 0?{}:{out:Object.freeze(y.out.range===void 0?{}:{range:Object.freeze({...y.out.range})})}}),I=()=>g.call(d,C,k),S=i?await Je(I):await I();if(S!==void 0&&!O(S))throw new A("EXECUTION_FAILED");let _;if(y.out!==void 0){if(_=d.producedContent,_===void 0)throw new A("EXECUTION_FAILED","content.out was requested but setContent was never called");let f=re(_);if(f)throw new A(f.code,null,{outcome:f.outcome})}else if(d.didSetContent)throw new A("EXECUTION_FAILED","setContent was called but the request asked for no content.out");return {response:{...d.didSetState?{state:d.state}:{},...S===void 0?{}:{result:S}},..._===void 0?{}:{answer:_}}}catch(c){let l,g=c,p=c instanceof A?c:void 0;if(p)l={code:p.code,detail:p.detail,outcome:p.outcome};else try{l=d.mapError(c);}catch(X){l={code:"EXECUTION_FAILED",detail:null},g=X;}let k=qe(l?.code),I=k?l.code:"EXECUTION_FAILED",S=typeof l?.detail=="string"?l.detail:null,_=k?B(l.outcome):"failed",f;try{f=d.errorState(I,S,{input:C,state:E});}catch(X){g=new AggregateError([g,X],"App error handling failed"),f=d.emptyState();}return o?.(I,g,{outcome:_,detail:S,expected:p!==void 0&&g===p}),{response:{outcome:_,errorCode:I,state:O(f)?f:d.emptyState()}}}}async function ve(e,t={}){let n=t.output??process.stdout,o,i;if(t.preloadedInput!==void 0)o=t.preloadedInput.value,i=t.preloadedInput.body;else {let d=M(t.inputFd??0);d.kind==="v1"?o=d.value:d.kind==="v2"&&(o=d.header,i=d.body);}let r=i!==void 0,s=t.context??K(),u=false,a=(d,C,E)=>{u=true,t.onFailure?.(d,C,E);},m;try{m=await se(e,o,process.env.CREWX_WORKSPACE_ROOT??process.cwd(),a,t.consoleManaged!==!0,i,s);}catch(d){a("EXECUTION_FAILED",d),m={response:ie(t.emptyState)};}Xe(m.response)&&!u&&a(m.response.errorCode,void 0,{outcome:m.response.outcome,detail:null,expected:false});let T;try{let d=(t.sanitize??ae)(m.response);T=r?v(d,m.answer):`${JSON.stringify(d)}
+`;}catch(d){a("EXECUTION_FAILED",d);let C=ie(t.emptyState);try{let E=(t.sanitize??ae)(C);T=r?v(E):`${JSON.stringify(E)}
+`;}catch(E){a("EXECUTION_FAILED",E),T=r?v(C):`${JSON.stringify(C)}
+`;}}n.write(T);}async function Je(e){let t=["log","info","debug"],n=new Map;for(let o of t)n.set(o,console[o]),console[o]=(...i)=>process.stderr.write(`${util.format(...i)}
+`);try{return await e()}finally{for(let o of t)console[o]=n.get(o);}}function ie(e={}){return {outcome:"failed",errorCode:"EXECUTION_FAILED",state:{...e,error:{code:"EXECUTION_FAILED",detail:null}}}}function Xe(e){return (e.outcome==="failed"||e.outcome==="rejected")&&typeof e.errorCode=="string"}function qe(e){return typeof e=="string"&&/^[A-Z][A-Z0-9_]{0,127}$/u.test(e)}function ae(e){return e}var z={depth:null,maxArrayLength:null,maxStringLength:null},W=class extends stream.Writable{#e="buffer";#t=[];_write(t,n,o){if(this.#e==="buffer"){this.#t.push(typeof t=="string"?t:Uint8Array.from(t)),o();return}if(this.#e==="discard"){o();return}process.stderr.write(t,o);}flushToStderr(){this.#e="stderr";for(let t of this.#t)process.stderr.write(t);this.#t=[];}discard(){this.#e="discard",this.#t=[];}};async function $e(e,t={}){let n=process.stdout,o=n.write.bind(n),i=new W,r=new console$1.Console({stdout:i,stderr:i,inspectOptions:{...z}});globalThis.console=r;let s=false,u="-",a="-",m,T=false,d,C;try{let c=Ve(t.inputFd??0);u=We(c.value),a=J(process.env.CREWX_APP_REQUEST_ID),m=new Date().toISOString();try{d=await e();}catch(p){T=!0,C=p;}let l=d?.default;if(!T&&l?.devtools?.log===!0?(Object.assign(util.inspect.defaultOptions,z),E(m),i.flushToStderr()):i.discard(),T){y("EXECUTION_FAILED",C),V(o,t,y);return}try{if(typeof d?.runSkillApp!="function")throw new TypeError("App module does not export runSkillApp");let p={sanitize:t.sanitize,emptyState:t.emptyState??ze(l),preloadedInput:c.body===void 0?{value:c.value}:{value:c.value,body:c.body},onFailure:y,consoleManaged:!0,output:{write:o}};await d.runSkillApp(l,p);}catch(p){y("EXECUTION_FAILED",p),V(o,t,y);}}catch(c){y("EXECUTION_FAILED",c),V(o,t,y);}finally{process.exitCode=0;}function E(c){s||(process.stderr.write(`[crewx-app] ${c??new Date().toISOString()} ${J(u)} req=${a}
+`),s=true);}function y(c,l,g){E();let p=g?.expected===true&&g.detail?` ${J(g.detail)}`:"";process.stderr.write(`[crewx-app] ${g?.outcome??"failed"} ${J(c)}${p}
+`),l!==void 0&&g?.expected!==true&&process.stderr.write(`${util.inspect(l,z)}
+`);}}function ze(e){if(typeof e=="function")try{let n=new e({workspaceRoot:process.cwd()}).emptyState();return n!==null&&typeof n=="object"&&!Array.isArray(n)?n:void 0}catch{return}}function Ve(e){let t=M(e);return t.kind==="v1"?{value:t.value}:t.kind==="v2"?{value:t.header,body:t.body}:{value:void 0}}function We(e){return e!==null&&typeof e=="object"&&!Array.isArray(e)&&typeof e.actionId=="string"?e.actionId:"-"}function J(e){return typeof e!="string"||e.length===0?"-":e.replace(/[\u0000-\u001f\u007f\u2028\u2029]/gu,"_")}function V(e,t,n){let o={code:"EXECUTION_FAILED",detail:null},r={outcome:"failed",errorCode:"EXECUTION_FAILED",state:t.emptyState!==null&&typeof t.emptyState=="object"&&!Array.isArray(t.emptyState)?{...t.emptyState,error:o}:{error:o}},s=r;try{s=(t.sanitize??Ye)(r);}catch(u){n("EXECUTION_FAILED",u);}e(`${JSON.stringify(s)}
+`);}function Ye(e){return e}exports.APP_TOOLS_FILE=ge;exports.APP_TOOLS_SCHEMA_VERSION=Ae;exports.APP_TOOL_ENTRY=Ce;exports.AppError=A;exports.CrewXApp=q;exports.SKILL_BACKEND_ENV_NAMES=Q;exports.Tool=ce;exports.executeAppRequest=Me;exports.generateManifest=le;exports.generateToolDeclarations=H;exports.getToolDeclarations=D;exports.isSkillBackendEnv=Oe;exports.readAppContext=K;exports.runAppEntry=$e;exports.runSkillApp=ve;

package/dist/app/protocol.d.ts

@@ -0,0 +1,9 @@
+export { UI_CONTENT_MEDIA_TYPES } from './content-media-types.js';
+export type { UiContentMediaType } from './content-media-types.js';
+export declare const SKILL_BACKEND_CONTENT_SCHEMA_VERSION: 2;
+export declare const SKILL_BACKEND_MAX_INPUT_BYTES = 2097152;
+export declare const SKILL_BACKEND_MAX_OUTPUT_BYTES = 2097152;
+export declare const UI_CONTENT_MAX_BYTES: number;
+export declare const UI_CONTENT_MAX_LINES = 20000;
+export declare function sha256Content(bytes: Uint8Array): string;
+export declare function countContentLines(bytes: Uint8Array): number;

package/dist/app/runtime.d.ts

@@ -0,0 +1,21 @@
+import { type AppContext, type AppFailureOutcome, type CrewXAppConstructor, type JsonObject } from './app.js';
+export interface AppFailureInfo {
+    readonly outcome: AppFailureOutcome;
+    readonly detail: string | null;
+    readonly expected: boolean;
+}
+export interface RunSkillAppOptions {
+    readonly sanitize?: (value: unknown) => unknown;
+    readonly inputFd?: number;
+    readonly output?: Pick<NodeJS.WriteStream, 'write'>;
+    readonly emptyState?: JsonObject;
+    readonly preloadedInput?: {
+        readonly value: unknown;
+        readonly body?: Uint8Array;
+    };
+    readonly onFailure?: (errorCode: string, error?: unknown, info?: AppFailureInfo) => void;
+    readonly consoleManaged?: boolean;
+    readonly context?: AppContext;
+}
+export declare function executeAppRequest(appClass: CrewXAppConstructor, rawRequest: unknown, workspaceRoot?: string, context?: AppContext): Promise<JsonObject>;
+export declare function runSkillApp(appClass: CrewXAppConstructor, options?: RunSkillAppOptions): Promise<void>;

package/dist/app/tool-mode.d.ts

@@ -0,0 +1,3 @@
+export declare const APP_TOOLS_FILE = "dist/tools.json";
+export declare const APP_TOOLS_SCHEMA_VERSION: 1;
+export declare const APP_TOOL_ENTRY = "dist/main.mjs";

package/dist/boxing/box.types.d.ts

@@ -43,11 +43,15 @@ export interface ThreadMessage {
     content: string;
     timestamp: string;
     metadata: Record<string, unknown> | null;
+    contentTruncated?: boolean;
+    originalTokens?: number;
+    includedTokens?: number;
 }
 export interface ContextBuildParams {
     maxTokens: number;
     hotzoneRatio: number;
     warmzoneRatio: number;
+    minGuaranteedPairs?: number;
 }
 export interface ContextBuildResponse {
     hot: ThreadMessage[];

package/dist/config/canonicalize-agent-options.d.ts

@@ -0,0 +1,18 @@
+export declare function normalizeClaudeMode(mode: string): string;
+export interface AgentOptionsLike {
+    query?: unknown;
+    execute?: unknown;
+    [key: string]: unknown;
+}
+export interface CanonicalizeAgentOptionsInput {
+    provider?: string;
+    model?: string;
+    options: unknown;
+}
+export interface CanonicalizeAgentOptionsResult {
+    options: unknown;
+    changed: boolean;
+    removed: string[];
+}
+export declare function normalizeProviderMode(providerId: string, mode: string): string;
+export declare function canonicalizeAgentOptions(input: CanonicalizeAgentOptionsInput): CanonicalizeAgentOptionsResult;

package/dist/config/default-agent-models.d.ts

@@ -0,0 +1,11 @@
+import { type ProviderExecutionOptions } from './models.generated.js';
+export type DefaultAgentStage = {
+    model: string;
+    query: Pick<ProviderExecutionOptions, 'mode' | 'effort'>;
+    execute: Pick<ProviderExecutionOptions, 'mode' | 'effort'>;
+};
+export interface DefaultAgentProfile {
+    planner: DefaultAgentStage;
+    worker: DefaultAgentStage;
+}
+export declare function getDefaultAgentProfile(provider: string): DefaultAgentProfile | undefined;

package/dist/config/global-settings.d.ts

@@ -0,0 +1,33 @@
+import { mkdirSync, readFileSync, renameSync, statSync, writeFileSync } from 'fs';
+import type { LocalServerSettings } from '../local-server/types';
+export interface GlobalSettings {
+    cron?: {
+        auto_start?: boolean;
+        [key: string]: unknown;
+    };
+    ai_server?: LocalServerSettings;
+    [key: string]: unknown;
+}
+export type DeepPartial<T> = T extends object ? {
+    [K in keyof T]?: DeepPartial<T[K]>;
+} : T;
+export interface GlobalSettingsStore {
+    read(): GlobalSettings;
+    update(patch: DeepPartial<GlobalSettings>): GlobalSettings;
+    set(key: string, value: unknown): GlobalSettings;
+    remove(key: string): GlobalSettings;
+    readonly path: string;
+}
+interface GlobalSettingsFileSystem {
+    mkdirSync: typeof mkdirSync;
+    readFileSync: typeof readFileSync;
+    renameSync: typeof renameSync;
+    statSync: typeof statSync;
+    writeFileSync: typeof writeFileSync;
+}
+export interface CreateGlobalSettingsStoreOptions {
+    filePath?: string;
+    fileSystem?: Partial<GlobalSettingsFileSystem>;
+}
+export declare function createGlobalSettingsStore(opts?: CreateGlobalSettingsStoreOptions): GlobalSettingsStore;
+export {};

package/dist/config/migrate-grok-mode.d.ts

@@ -0,0 +1,6 @@
+export type GrokSandbox = 'workspace' | 'read-only' | 'off';
+export interface GrokNativeOptions {
+    alwaysApprove?: boolean;
+    sandbox?: GrokSandbox;
+}
+export declare function migrateGrokLegacyMode<T>(slot: T): T;

package/dist/config/model-compat.d.ts

@@ -0,0 +1,31 @@
+export declare const CLAUDE_OPUS_4_8_BASE_MODEL_ID: "claude-opus-4-8";
+export declare const CLAUDE_OPUS_4_8_LEGACY_MODEL_ID: "claude-opus-4-8[1m]";
+export declare const CLAUDE_MODEL_COMPATIBILITY_PAIRS: readonly [{
+    readonly baseModelId: "claude-opus-4-8";
+    readonly catalogModelId: "claude-opus-4-8[1m]";
+}, {
+    readonly baseModelId: "claude-opus-4-7";
+    readonly catalogModelId: "claude-opus-4-7[1m]";
+}, {
+    readonly baseModelId: "claude-opus-4-6";
+    readonly catalogModelId: "claude-opus-4-6[1m]";
+}, {
+    readonly baseModelId: "claude-sonnet-4-6";
+    readonly catalogModelId: "claude-sonnet-4-6[1m]";
+}];
+export declare function normalizeAntigravityMode(mode: string): string;
+export declare function resolveCatalogModelId(model: string): string;
+export declare const ANTIGRAVITY_MODEL_COMPATIBILITY: ReadonlyArray<{
+    legacyId: string;
+    model: string;
+    effort?: string;
+}>;
+export type AntigravityResolvedModel = {
+    model?: string;
+    effort?: string;
+};
+export declare function resolveAntigravityModel(model?: string): AntigravityResolvedModel;
+export declare function resolveProviderCatalogModel(providerId: string, model?: string): {
+    model?: string;
+    effort?: string;
+};

package/dist/config/models.generated.d.ts

@@ -1,7 +1,20 @@
+import type { ModelApiPricing } from './pricing.types.js';
+export declare const MODEL_TIERS: readonly ["flagship", "balanced", "speed"];
+export type ModelTier = (typeof MODEL_TIERS)[number];
+export declare const EFFORT_LEVELS: readonly ["none", "minimal", "low", "medium", "high", "xhigh", "max", "ultra"];
+export type EffortLevel = (typeof EFFORT_LEVELS)[number];
+export type KnownEffortLevel = EffortLevel;
+export declare const PROVIDER_ARGV_EFFORTS: Record<string, readonly string[]>;
+export declare const MODEL_CATALOG_VERSION = 33;
+export declare const MODEL_CATALOG_UPDATED = "2026-10-08T00:00:00Z";
 export interface ModelCatalogEntry {
     id: string;
     name: string;
     description?: string;
+    contextWindowTokens?: number;
+    tier?: ModelTier;
+    recommended?: boolean;
+    apiPricing?: ModelApiPricing;
 }
 export interface ProviderModeEntry {
     id: string;
@@ -12,11 +25,35 @@ export interface ProviderModelOverride {
     effort?: string[];
     defaultEffort?: string;
 }
+export type ProviderOptionSpec = {
+    key: string;
+    type: 'boolean';
+} | {
+    key: string;
+    type: 'enum';
+    values: string[];
+};
+export interface ProviderExecutionOptions {
+    mode: string;
+    effort: string;
+    providerOptions?: Record<string, unknown>;
+}
+export interface ProviderDefaultProfile {
+    model: string;
+    query: ProviderExecutionOptions;
+    execute: ProviderExecutionOptions;
+}
+export interface ProviderDefaults {
+    version: number;
+    providers: Record<string, ProviderDefaultProfile>;
+}
 export interface ProviderCatalogEntry {
     models: ModelCatalogEntry[];
     modes: ProviderModeEntry[];
     effort: string[];
     modelOverrides: Record<string, ProviderModelOverride>;
+    providerOptions?: ProviderOptionSpec[];
 }
 export declare const PROVIDER_CATALOGS: Record<string, ProviderCatalogEntry>;
+export declare const PROVIDER_DEFAULTS: ProviderDefaults;
 export declare const PROVIDER_MODELS: Record<string, ModelCatalogEntry[]>;

package/dist/config/models.remote.d.ts

@@ -1,3 +1,4 @@
+export declare const MIN_REMOTE_CATALOG_VERSION = 20;
 export declare function initModelsRemote(opts?: {
     endpoint?: string;
     ttlMs?: number;

package/dist/config/overdrive.d.ts

@@ -3,6 +3,7 @@ export interface OverdriveProfile {
     model?: string;
     mode?: string;
     effort?: string;
+    providerOptions?: Record<string, unknown>;
 }
 export type OverdriveSignalInput = boolean | {
     mode?: 'count' | 'latch';
@@ -20,5 +21,11 @@ export interface OverdriveResolution {
     mode?: string;
     effort?: string;
     crossProvider: boolean;
+    providerOptions?: Record<string, unknown>;
 }
 export declare function resolveOverdrive(agentOptions: unknown, mode: 'query' | 'execute', baseProvider: string, signal: OverdriveSignal): OverdriveResolution;
+export interface ModeOverrideResolution {
+    provider?: string;
+    model?: string;
+}
+export declare function resolveModeOverride(agentOptions: unknown, mode: 'query' | 'execute'): ModeOverrideResolution;

package/dist/config/pricing.d.ts

@@ -1,9 +1,12 @@
-import type { ModelPricing } from './pricing.types.js';
-export type { ModelPricing } from './pricing.types.js';
-export { MODEL_PRICING } from './pricing.generated.js';
+import type { ModelApiPricing, ModelPricing } from './pricing.types.js';
+export type { ModelApiPricing, ModelPricing } from './pricing.types.js';
+export { MODEL_PRICING, UNPUBLISHED_MODEL_IDS } from './pricing.generated.js';
 export declare function setPricingOverride(models: Record<string, ModelPricing>): void;
 export declare function clearPricingOverride(): void;
+export declare function setApiPricingOverride(models: Record<string, ModelApiPricing>): void;
+export declare function clearApiPricingOverride(): void;
 export declare function normalizeModel(model: string): string;
+export declare function lookupApiPricing(model: string | null | undefined): ModelApiPricing | undefined;
 export declare function getPricing(model: string | null | undefined): ModelPricing;
 export declare function calculateCost(inputTokens: number, outputTokens: number, model: string | null | undefined, cachedInputTokens?: number, _date?: Date): number;
 export declare function resolveCost(costUsd: number | undefined, inputTokens: number | undefined, outputTokens: number | undefined, cachedInputTokens: number | undefined, model: string | null | undefined, date?: Date): number;

package/dist/config/pricing.generated.d.ts

@@ -1,2 +1,6 @@
 import type { ModelPricing } from './pricing.types.js';
 export declare const MODEL_PRICING: Record<string, ModelPricing>;
+export declare const MODEL_PRICING_VERSION = 33;
+export declare const MODEL_PRICING_UPDATED = "2026-10-08T00:00:00Z";
+export declare const UNPUBLISHED_MODEL_IDS: ReadonlySet<string>;
+export declare const CATALOG_MODEL_IDS: ReadonlySet<string>;

package/dist/config/pricing.types.d.ts

@@ -3,3 +3,7 @@ export interface ModelPricing {
     cachedInput: number;
     output: number;
 }
+export interface ModelApiPricing {
+    inputPerMillionTokensUsd: number;
+    outputPerMillionTokensUsd: number;
+}

package/dist/config/timeout.config.d.ts

@@ -1,5 +1,9 @@
 export interface TimeoutConfig {
     queryMs: number;
     executeMs: number;
+    idleMs: number;
 }
+export declare const DEFAULT_IDLE_MS: number;
+export declare const DEFAULT_RESUME_TIMEOUT_MS = 60000;
+export declare function parseIdleEnvOverride(env?: NodeJS.ProcessEnv): number | undefined;
 export declare function getProviderTimeoutConfig(env?: NodeJS.ProcessEnv): TimeoutConfig;

package/dist/config/wi-boards.d.ts

@@ -0,0 +1,19 @@
+import type { CrewxProjectConfig } from '../types';
+export declare const DEFAULT_WI_BOARD_ID = "default";
+export declare const ARCHIVE_WI_BOARD_ID = "archive";
+export declare const DEFAULT_WI_WORKFLOW_ID = "wi-default-flow";
+export declare const WI_PLAN_WORKFLOW_ID = "wi-plan-flow";
+export declare const WI_DEFAULT_FLOW_FILENAME = "wi-default-flow.yaml";
+export declare const WI_PLAN_FLOW_FILENAME = "wi-plan-flow.yaml";
+export declare const WI_BOARD_ID_PATTERN: RegExp;
+export declare function isReservedWiBoardId(id: string): boolean;
+export interface ResolvedWiBoard {
+    id: string;
+    name: string;
+    workflowId: string;
+    description?: string;
+    goalId?: string;
+    system: boolean;
+    readOnly: boolean;
+}
+export declare function resolveWiBoards(config: CrewxProjectConfig | undefined): ResolvedWiBoard[];

package/dist/context-budget/continuity.d.ts

@@ -0,0 +1,63 @@
+import type { ConversationHighlight, ConversationThreadState, SemanticContinuityContext, TemplateMessage } from '../conversation/types.js';
+export declare const DEFAULT_PROTECTED_TURN_COUNT = 5;
+export declare const DEFAULT_HIGHLIGHT_BUDGET_PERCENT = 5;
+export declare const MAX_ACTIVE_HIGHLIGHTS = 12;
+export declare const MAX_ACTIVE_HIGHLIGHT_CHARS = 2000;
+export declare const MAX_THREAD_TITLE_CHARS = 200;
+export declare const MAX_THREAD_STATE_VALUE_CHARS = 64;
+export interface ConversationTurn {
+    taskId?: string;
+    messages: TemplateMessage[];
+    ordinal: number;
+}
+export interface GroupedConversationTurns {
+    turns: ConversationTurn[];
+    unpairedMessages: TemplateMessage[];
+    droppedMessages: TemplateMessage[];
+}
+export interface ConversationTurnSelection {
+    includedTurns: ConversationTurn[];
+    omittedTurns: ConversationTurn[];
+    protectedTurns: ConversationTurn[];
+    tokenCount: number;
+    protectedTokenCount: number;
+    overBudget: boolean;
+}
+export interface SelectConversationTurnsOptions {
+    turns: readonly ConversationTurn[];
+    maxTokenCount: number;
+    countTokens: (text: string) => number;
+    protectedTurnCount?: number;
+    materializeTurn?: (turn: ConversationTurn) => string;
+}
+export interface ConversationHighlightSelection {
+    includedHighlights: ConversationHighlight[];
+    omittedHighlights: ConversationHighlight[];
+    truncatedHighlights: number;
+    representedTaskIds: string[];
+    unrepresentedTaskIds: string[];
+    tokenCount: number;
+    budgetTokens: number;
+}
+export interface SelectConversationHighlightsOptions {
+    highlights: readonly ConversationHighlight[];
+    omittedTaskIds: readonly string[];
+    taskOrder: readonly string[];
+    maxTokenCount: number;
+    countTokens: (text: string) => number;
+    applySafetyCap?: boolean;
+}
+export declare function getConversationMessageTaskId(message: TemplateMessage): string | undefined;
+export declare function groupConversationTurns(messages: readonly TemplateMessage[]): GroupedConversationTurns;
+export declare function withoutDroppedAppCards(messages: readonly TemplateMessage[]): TemplateMessage[];
+export declare function materializeConversationTurn(turn: ConversationTurn, includeActivityLog?: boolean): string;
+export declare function selectConversationTurns(options: SelectConversationTurnsOptions): ConversationTurnSelection;
+export declare function buildThreadStateContext(state: ConversationThreadState | undefined): ConversationThreadState | undefined;
+export declare function selectConversationHighlights(options: SelectConversationHighlightsOptions): ConversationHighlightSelection;
+export interface BuildSemanticContinuityContextOptions {
+    highlights: readonly ConversationHighlight[];
+    omittedTaskIds: readonly string[];
+    representedTaskIds: readonly string[];
+    applySafetyCap?: boolean;
+}
+export declare function buildSemanticContinuityContext(options: BuildSemanticContinuityContextOptions): SemanticContinuityContext;

package/dist/context-budget/index.d.ts

@@ -0,0 +1,142 @@
+export declare const DEFAULT_INPUT_BUDGET_PERCENT = 60;
+export declare const MIN_INPUT_BUDGET_PERCENT = 30;
+export declare const MAX_INPUT_BUDGET_PERCENT = 80;
+export declare const INPUT_BUDGET_TOKENIZER_ENCODING = "o200k_base";
+export declare const FRESH_PROVIDER_INITIAL_INPUT_SEPARATOR = "\n\n---\n\n";
+export declare const FRESH_PROVIDER_INITIAL_INPUT_FRAMING = "system_prompt\\n\\n---\\n\\nmessage";
+export declare const RESUME_PROVIDER_INITIAL_INPUT_FRAMING = "message";
+export type InputBudgetUnresolvedReason = 'invalid_input_budget_percent' | 'provider_catalog_unavailable' | 'model_not_found' | 'context_window_tokens_unavailable';
+export type TokenizerFallbackReason = 'vendor_tokenizer_unavailable';
+export interface ResolveInputBudgetOptions {
+    provider: string;
+    model: string;
+    inputBudgetPercent?: number;
+}
+export interface TokenizerOptions {
+    provider?: string;
+    model?: string;
+}
+export interface TokenizerMetadata {
+    provider: string;
+    model: string;
+    encoding: typeof INPUT_BUDGET_TOKENIZER_ENCODING;
+    exact: boolean;
+    fallbackReason?: TokenizerFallbackReason;
+}
+export interface ResolvedInputBudget {
+    resolved: true;
+    requestedProvider: string;
+    provider: string;
+    model: string;
+    contextWindowTokens: number;
+    inputBudgetPercent: number;
+    inputBudgetTokens: number;
+    tokenizer: TokenizerMetadata;
+}
+export interface UnresolvedInputBudget {
+    resolved: false;
+    requestedProvider: string;
+    provider: string;
+    model: string;
+    reason: InputBudgetUnresolvedReason;
+    inputBudgetPercent?: number;
+    tokenizer: TokenizerMetadata;
+}
+export type ResolveInputBudgetResult = ResolvedInputBudget | UnresolvedInputBudget;
+export type ContextBudgetPhase = 'fresh' | 'resume';
+export type ProviderInitialInputFraming = typeof FRESH_PROVIDER_INITIAL_INPUT_FRAMING | typeof RESUME_PROVIDER_INITIAL_INPUT_FRAMING;
+export interface ContextBudgetLayoutCapability {
+    layoutId: string;
+    supportsSemanticContinuity: boolean;
+    slot: string | null;
+    requiredForOmittedTurns: boolean;
+    warning?: string;
+}
+export interface ContextBudgetActivityDegradation {
+    taskId: string;
+    taskDistance: number;
+    action: 'reduced' | 'omitted';
+}
+export type ContextBudgetAssemblyErrorCode = 'INPUT_BUDGET_EXCEEDED' | 'CONTINUITY_SLOT_REQUIRED';
+export declare class ContextBudgetLayoutError extends Error {
+    readonly layoutId: string;
+    readonly omittedTurnCount: number;
+    readonly code: "CONTINUITY_SLOT_REQUIRED";
+    constructor(message: string, layoutId: string, omittedTurnCount: number);
+}
+export interface ContextBudgetManifest {
+    runningInstructionAppsOmitted?: number;
+    phase: ContextBudgetPhase;
+    initialInputFraming: ProviderInitialInputFraming;
+    resolved: boolean;
+    reason?: InputBudgetUnresolvedReason;
+    requestedProvider: string;
+    requestedModel: string | null;
+    effectiveProvider: string;
+    effectiveModel: string | null;
+    contextWindowTokens: number | null;
+    inputBudgetPercent: number | null;
+    inputBudgetTokens: number | null;
+    tokenizer: TokenizerMetadata;
+    initialTokenCount: number | null;
+    finalTokenCount: number | null;
+    activityLogTokenCount: number | null;
+    activityIncludedEntries: number | null;
+    activityOmittedEntries: number | null;
+    activityRemovedForBudget: boolean;
+    activityNewestTaskTokenCap: number | null;
+    historyOriginalMessages: number;
+    historyIncludedMessages: number;
+    historyOmittedMessages: number;
+    turnOriginal: number;
+    turnIncluded: number;
+    turnOmitted: number;
+    highlightOriginal: number;
+    highlightIncluded: number;
+    highlightOmitted: number;
+    highlightTruncated: number;
+    representedOmittedTurns: number;
+    unrepresentedOmittedTurns: number;
+    activityDegraded: boolean;
+    activityIncludedTasks: number;
+    activityOmittedTasks: number;
+    activityDegradation: ContextBudgetActivityDegradation[];
+    highlightLookupFailed: boolean;
+    layoutCapability: ContextBudgetLayoutCapability;
+    overBudget: boolean;
+    overdriveProviderSuppressed?: boolean;
+}
+export interface TokenCountResult {
+    tokenCount: number;
+    tokenizer: TokenizerMetadata;
+}
+export interface TokenCounter {
+    metadata: TokenizerMetadata;
+    countTokens(text: string): number;
+}
+export interface FreshProviderInitialInput {
+    systemPrompt?: string | null;
+    message: string;
+}
+type PieceCacheEventType = 'hit' | 'miss' | 'evict' | 'full_encode';
+interface PieceCacheEvent {
+    type: PieceCacheEventType;
+    piece?: string;
+    tokenCount?: number;
+    reason?: 'special_token';
+}
+type PieceCacheObserver = (event: PieceCacheEvent) => void;
+interface TokenCounterInternalOptions {
+    pieceCacheMaxEntries?: number;
+    observePieceCache?: PieceCacheObserver;
+}
+export declare function normalizeInputBudgetProvider(provider: string): string;
+export declare function resolveTokenizerMetadata(options?: TokenizerOptions): TokenizerMetadata;
+export declare function countTokens(text: string, options?: TokenizerOptions): TokenCountResult;
+export declare function renderFreshProviderInitialInput(input: FreshProviderInitialInput): string;
+export declare function countFreshProviderInitialInput(input: FreshProviderInitialInput, count: (text: string) => number): number;
+export declare function createTokenCounter(options?: TokenizerOptions): TokenCounter;
+export declare function __createTokenCounterForTest(options?: TokenizerOptions, internalOptions?: TokenCounterInternalOptions): TokenCounter;
+export declare function resolveInputBudget(options: ResolveInputBudgetOptions): ResolveInputBudgetResult;
+export { DEFAULT_HIGHLIGHT_BUDGET_PERCENT, DEFAULT_PROTECTED_TURN_COUNT, MAX_ACTIVE_HIGHLIGHT_CHARS, MAX_ACTIVE_HIGHLIGHTS, MAX_THREAD_STATE_VALUE_CHARS, MAX_THREAD_TITLE_CHARS, buildSemanticContinuityContext, buildThreadStateContext, getConversationMessageTaskId, groupConversationTurns, materializeConversationTurn, selectConversationHighlights, selectConversationTurns, withoutDroppedAppCards, } from './continuity.js';
+export type { BuildSemanticContinuityContextOptions, ConversationHighlightSelection, ConversationTurn, ConversationTurnSelection, GroupedConversationTurns, SelectConversationHighlightsOptions, SelectConversationTurnsOptions, } from './continuity.js';

package/dist/conversation/index.d.ts

@@ -1,3 +1,3 @@
 export * from './types.js';
 export { toTaskReader } from './to-task-reader.js';
-export { toTemplateMessages } from './to-template-messages.js';
+export { LEGACY_UI_CARD_SAFE_SUMMARY, sanitizeLegacyUiCardText, sanitizeTemplateMessages, toTemplateMessages, } from './to-template-messages.js';

package/dist/conversation/sqlite-provider.d.ts

@@ -1,15 +1,18 @@
-import type { ConversationThread, FetchHistoryOptions, IConversationHistoryProvider, Platform } from './types';
+import type { ConversationHighlight, ConversationThread, ConversationThreadState, FetchHistoryOptions, IConversationHistoryProvider, Platform, ThreadCreationOptions } from './types';
 export declare class SqliteConversationProvider implements IConversationHistoryProvider {
     private readonly dbPath;
     constructor(dbPath?: string);
     private getThreadRepo;
+    private getThreadHistoryRepo;
     updateThread(id: string, patch: {
         title?: string;
     }): void;
-    ensureThread(threadId: string, platform: Platform, workspaceId?: string): Promise<{
+    ensureThread(threadId: string, platform: Platform, workspaceId?: string, creator?: ThreadCreationOptions): Promise<{
         created: boolean;
     }>;
     fetchHistory(threadId: string, options?: FetchHistoryOptions): Promise<ConversationThread>;
+    fetchThreadState(threadId: string): Promise<ConversationThreadState | undefined>;
+    fetchHighlights(threadId: string): Promise<ConversationHighlight[] | undefined>;
     saveUserMessage(threadId: string, text: string, _userId?: string, _metadata?: Record<string, unknown>): Promise<{
         id: string;
         firstMessage: boolean;
@@ -18,6 +21,6 @@ export declare class SqliteConversationProvider implements IConversationHistoryP
         id: string;
     }>;
     close(): void;
-    private normalizeStatus;
+    private readActiveHighlights;
     private rowsToMessages;
 }

package/dist/conversation/to-template-messages.d.ts

@@ -1,2 +1,11 @@
 import type { ConversationThread, TemplateMessage } from './types';
+import type { UiAgentContextProjection } from '../ui-instance/types.js';
+import type { McpAppStateDescriptor } from '../mcp-app/types.js';
+export declare const LEGACY_UI_CARD_SAFE_SUMMARY = "[workflow card omitted from AI context]";
+export declare const V2_UI_INSTANCE_SAFE_SUMMARY = "[workflow UI instance omitted from AI context]";
+export declare function sanitizeUiInstanceReferenceText(text: string): string;
+export declare function sanitizeLegacyUiCardText(text: string): string;
+export declare function sanitizeTemplateMessages(messages: readonly TemplateMessage[]): TemplateMessage[];
+export declare function appendUiProjections(messages: readonly TemplateMessage[], projections: readonly UiAgentContextProjection[] | undefined): TemplateMessage[];
+export declare function appendMcpAppProjections(messages: readonly TemplateMessage[], descriptors: readonly McpAppStateDescriptor[] | undefined): TemplateMessage[];
 export declare function toTemplateMessages(thread: ConversationThread): TemplateMessage[];