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

package/dist/types/task-log.types.d.ts

@@ -1,14 +1,19 @@
-export type TaskLogEntryType = 'text' | 'thinking' | 'tool_use' | 'tool_result' | 'error' | 'info' | 'running_instruction' | 'agent_call';
+import type { DelegationResult } from '../task-log/delegation-trailer.js';
+import type { InterceptorStepLog } from '../agent-interceptor/types.js';
+export type TaskLogEntryType = 'text' | 'thinking' | 'tool_use' | 'tool_result' | 'error' | 'info' | 'running_instruction' | 'agent_call' | 'interceptor';
 export interface TaskLogEntry {
     timestamp: string;
     type: TaskLogEntryType;
     content?: string;
     toolName?: string;
     toolInput?: string;
+    toolTitle?: string;
     toolUseId?: string;
     resultPreview?: string;
     isError?: boolean;
+    delegationResult?: DelegationResult | null;
     targetAgent?: string;
     targetTaskId?: string;
     errorMessage?: string;
+    interceptor?: InterceptorStepLog;
 }

package/dist/ui-card/index.d.ts

@@ -0,0 +1,2 @@
+export { extractLegacyWorkflowRunId, scanLegacyUiCardAt, scanLegacyUiCardTags, } from './legacy-card-parser';
+export type { LegacyUiCardTag } from './legacy-card-parser';

package/dist/ui-card/legacy-card-parser.d.ts

@@ -0,0 +1,11 @@
+export interface LegacyUiCardTag {
+    start: number;
+    end: number;
+    raw: string;
+    closed: boolean;
+    attrs: Readonly<Record<string, string>>;
+    privileged: boolean;
+}
+export declare function scanLegacyUiCardAt(text: string, start: number): LegacyUiCardTag;
+export declare function scanLegacyUiCardTags(text: string): LegacyUiCardTag[];
+export declare function extractLegacyWorkflowRunId(text: string | null | undefined): string | undefined;

package/dist/ui-instance/definition.d.ts

@@ -0,0 +1,6 @@
+import type { UiDefinition, UiDefinitionInput, UiDefinitionRef } from './types.js';
+export declare function hashUiDefinition(input: UiDefinitionInput): string;
+export declare function definitionKey(ref: UiDefinitionRef): string;
+export declare function validateDefinition(definition: UiDefinition): void;
+export declare function isExactCapability(value: string): boolean;
+export declare function refFromDefinition(definition: UiDefinition): UiDefinitionRef;

package/dist/ui-instance/errors.d.ts

@@ -0,0 +1,18 @@
+import type { UiContentErrorCode } from '../mcp-app/content-channel.js';
+export type UiRuntimeErrorCode = 'UNAUTHENTICATED' | 'INSTANCE_NOT_FOUND' | 'WORKSPACE_MISMATCH' | 'INSTANCE_NOT_ACTIONABLE' | 'DEFINITION_UNSUPPORTED' | 'CAPABILITY_DENIED' | 'INPUT_INVALID' | 'REVISION_CONFLICT' | 'ACTION_UNAVAILABLE' | 'HANDLER_NOT_FOUND' | 'ACTION_IN_FLIGHT' | 'DOMAIN_REJECTED' | 'EXECUTION_FAILED' | UiContentErrorCode;
+export declare class UiRuntimeError extends Error {
+    readonly code: UiRuntimeErrorCode;
+    readonly currentRevision?: number | undefined;
+    readonly name = "UiRuntimeError";
+    constructor(code: UiRuntimeErrorCode, message?: string, currentRevision?: number | undefined);
+}
+export declare class UiRetryableDatabaseError extends Error {
+    readonly cause: unknown;
+    readonly name = "UiRetryableDatabaseError";
+    constructor(cause: unknown);
+}
+export declare class UiReservationConflictError extends Error {
+    readonly currentRevision: number;
+    readonly name = "UiReservationConflictError";
+    constructor(currentRevision: number);
+}

package/dist/ui-instance/index.d.ts

@@ -0,0 +1,11 @@
+export type { ActionReceipt, ActionReceiptResultSummary, ActionExecutionReceipt, ActionReceiptOutcome, CreateUiInstanceInput, JsonObject, JsonPrimitive, JsonValue, UiActionHandlerContext, UiActionHandlerRegistration, UiActionHandlerResult, UiActionEnvelope, UiActionConfirmation, UiSkillBackendEnvironmentKey, UiActor, UiDefinition, UiDefinitionAction, UiDefinitionDisplayMode, UiDefinitionInput, UiDefinitionLegacyMetadata, UiDefinitionRef, UiDefinitionUsage, UiProjectionPolicy, UiExecutionContext, UiAuthenticatedActor, UiTaskActorSnapshot, UiAuthenticatedExecutionContext, UiApprovalRequestContext, UiTaskExecutionContext, UiApprovalDecisionProvenance, UiApprovalPendingReceipt, UiApprovalRequestReceiptResult, UiAuthenticatedGrantPolicy, UiServerRuntimeFacade, UiServerRuntimeOptions, UiAgentContextProjection, UiExternalActionHandlerRegistration, UiAgentOpenReason, UiAgentOpenRequest, UiInstance, UiInstanceStatus, UiLocalGrantPolicy, UiRuntimeFacade, UiRuntimeOptions, UiStateActionHandlerRegistration, } from './types.js';
+export { isUiAuthenticatedActor, resolveUiEffectiveCapabilities } from './types.js';
+export { UiRuntimeError } from './errors.js';
+export type { UiRuntimeErrorCode } from './errors.js';
+export { projectSafeJsonObject, redactJsonPaths } from './json.js';
+export { hashUiDefinition } from './definition.js';
+export { hasUiDefinitionLineageBreak, selectUiDefinitionLineageEntry, UiDefinitionLineageError, uiDefinitionStaticCompatibilityViolations, validateUiDefinitionLineage, } from './lineage.js';
+export type { UiDefinitionLineageEntry, UiDefinitionLineageFailureCode, ValidatedUiDefinitionLineage, } from './lineage.js';
+export { UiInstanceStore, WORKSPACE_REPIN_ENV, isWorkspaceRepinEnabled, openUiInstanceReadStore } from './store.js';
+export type { UiAuditSnapshotInput, UiInstanceReadStore, UiInstanceRepinInput, UiInstanceRepinLedgerEntry, UiInstanceRepinResult, UiInstanceRepinWorkspaceGenerationInput, UiInstanceRepinWorkspaceInput, ReservationInput, } from './store.js';
+export { createUiRuntimeForTest, createUiServerRuntime } from './runtime.js';

package/dist/ui-instance/json.d.ts

@@ -0,0 +1,19 @@
+import type { JsonObject, JsonValue } from './types.js';
+export declare function isProjectionUnsafeKey(key: string): boolean;
+export type ProjectionRule = 'html' | 'url' | 'local_path' | 'sensitive_key' | 'path_key' | 'depth' | 'non_finite_number' | 'unsupported_type' | 'cycle' | 'not_object' | 'bad_options';
+export interface ProjectionViolation {
+    readonly path: string;
+    readonly rule: ProjectionRule;
+}
+export interface FindProjectionViolationsOptions {
+    readonly envelopeDepth?: number;
+    readonly dataPaths?: readonly string[];
+}
+export declare function projectSafeJsonObject(value: unknown, envelopeDepth?: number, dataPaths?: readonly string[]): JsonObject;
+export declare function findProjectionViolations(value: unknown, options?: FindProjectionViolationsOptions): ProjectionViolation[];
+export declare function pathIsAtOrBelowPath(path: string, parentPath: string): boolean;
+export declare function omitJsonPaths(value: JsonObject, dataPaths: readonly string[]): JsonObject;
+export declare function redactJsonPaths(value: JsonObject, dataPaths: readonly string[], placeholder?: string): JsonObject;
+export declare function serializeJson(value: JsonValue): string;
+export declare function canonicalJson(value: JsonValue): string;
+export declare function utf8ByteLength(value: string): number;

package/dist/ui-instance/lineage.d.ts

@@ -0,0 +1,24 @@
+import type { UiDefinition, UiDefinitionInput, UiDefinitionRef } from './types.js';
+export type UiDefinitionLineageFailureCode = 'LINEAGE_INVALID' | 'LINEAGE_STALE';
+export interface UiDefinitionLineageEntry {
+    readonly version: number;
+    readonly hash: string;
+    readonly definition: UiDefinitionInput;
+    readonly sourceHash?: string;
+    readonly compat?: 'break';
+}
+export interface ValidatedUiDefinitionLineage {
+    readonly entries: readonly UiDefinitionLineageEntry[];
+    readonly current: UiDefinition;
+}
+export declare class UiDefinitionLineageError extends Error {
+    readonly code: UiDefinitionLineageFailureCode;
+    readonly violations: readonly string[];
+    readonly name = "UiDefinitionLineageError";
+    constructor(code: UiDefinitionLineageFailureCode, message?: string, violations?: readonly string[]);
+}
+export declare function parseUiDefinitionInput(value: unknown): UiDefinitionInput;
+export declare function uiDefinitionStaticCompatibilityViolations(previous: UiDefinitionInput, current: UiDefinitionInput): string[];
+export declare function validateUiDefinitionLineage(entriesValue: unknown, currentValue: unknown): ValidatedUiDefinitionLineage;
+export declare function selectUiDefinitionLineageEntry(entries: unknown, current: unknown, selected: UiDefinitionRef): UiDefinition;
+export declare function hasUiDefinitionLineageBreak(lineage: ValidatedUiDefinitionLineage, from: UiDefinitionRef, to?: UiDefinitionRef): boolean;

package/dist/ui-instance/runtime.d.ts

@@ -0,0 +1,19 @@
+import type { UiRuntimeFacade, UiRuntimeOptions, UiServerRuntimeFacade, UiServerRuntimeOptions } from './types.js';
+import { UiInstanceStore } from './store.js';
+export declare const UI_ACTION_INPUT_MAX_BYTES = 2097152;
+export interface UiRuntimeTestHooks {
+    beforeReservation?: () => Promise<void> | void;
+    injectDatabaseError?: () => unknown | undefined;
+    bumpRevisionBeforeCas?: boolean;
+}
+export interface UiRuntimeForTestOptions extends UiRuntimeOptions {
+    workspaceId: string;
+    testHooks?: UiRuntimeTestHooks;
+    store?: UiInstanceStore;
+}
+export interface UiRuntimeStoreOptions {
+    readonly store?: UiInstanceStore;
+}
+export declare function createUiRuntime(workspaceId: string, options: UiRuntimeOptions & UiRuntimeStoreOptions): UiRuntimeFacade;
+export declare function createUiRuntimeForTest(options: UiRuntimeForTestOptions): UiRuntimeFacade;
+export declare function createUiServerRuntime(options: UiServerRuntimeOptions & UiRuntimeStoreOptions): UiServerRuntimeFacade;

package/dist/ui-instance/store.d.ts

@@ -0,0 +1,213 @@
+import type { UiDefinitionLineageEntry } from './lineage.js';
+import type { ActionReceipt, ActionReceiptOutcome, UiApprovalDecisionProvenance, UiApprovalPendingReceipt, UiApprovalRequestReceiptResult, JsonObject, UiActionHandlerContext, UiActor, UiAgentOpenReason, UiAgentOpenRequest, UiInstance, UiAuthenticatedActor, UiDefinition, UiDefinitionRef } from './types.js';
+export type UiInstanceDataPathResolver = (definition: UiDefinitionRef) => readonly string[];
+interface UiInstanceStoreTestHooks {
+    injectDatabaseError?: () => unknown | undefined;
+    bumpRevisionBeforeCas?: boolean;
+    beforeOpenRead?: () => void;
+    bumpRevisionBeforeRepinCas?: boolean;
+    afterRepinGenerationRead?: () => void;
+}
+export interface ReservationInput {
+    instanceId: string;
+    definition?: UiDefinitionRef;
+    requestId: string;
+    actionId: string;
+    actor: UiActor;
+    source: 'cli' | 'ui_host' | 'system' | 'mcp';
+    expectedRevision: number;
+    input: JsonObject;
+    dataPaths?: readonly string[];
+    receiptInput?: JsonObject;
+    now: number;
+}
+export interface UiInstanceRepinInput {
+    readonly instanceId: string;
+    readonly workspaceId: string;
+    readonly appId: string;
+    readonly currentDefinition: UiDefinition;
+    readonly lineage: readonly UiDefinitionLineageEntry[];
+    readonly observedRevision: number;
+    readonly hasSkillActions: boolean;
+    readonly now: number;
+}
+export type UiInstanceRepinWorkspaceInput = Omit<UiInstanceRepinInput, 'instanceId' | 'observedRevision'>;
+export interface UiInstanceRepinWorkspaceGenerationInput {
+    readonly workspaceId: string;
+    readonly appId: string;
+    readonly currentDefinition: UiDefinition;
+    readonly hasSkillActions: boolean;
+    readonly now: number;
+}
+export declare const WORKSPACE_REPIN_ENV = "CREWX_APP_WORKSPACE_REPIN";
+export declare function isWorkspaceRepinEnabled(env?: Readonly<Record<string, string | undefined>>): boolean;
+export interface UiInstanceRepinLedgerEntry {
+    readonly instanceId: string;
+    readonly fromVersion: number;
+    readonly fromHash: string;
+    readonly toVersion: number;
+    readonly toHash: string;
+    readonly fromRevision: number;
+    readonly toRevision: number | null;
+    readonly status: 'applied' | 'deferred' | 'failed';
+    readonly code: string | null;
+    readonly attempts: number;
+    readonly firstAt: number;
+    readonly lastAt: number;
+}
+export interface UiInstanceRepinResult extends UiInstanceRepinLedgerEntry {
+}
+export interface ApprovalPendingReservationInput {
+    readonly reservation: ReservationInput;
+    readonly approvalId: string;
+    readonly expiresAt: number;
+}
+export type ApprovalPendingReservationResult = {
+    readonly kind: 'reserved';
+    readonly reservation: ExternalReservation;
+} | {
+    readonly kind: 'settled';
+    readonly receipt: ActionReceipt;
+};
+type ApprovalScopeFields = Pick<UiApprovalDecisionProvenance, 'scope' | 'taskMode'>;
+interface ApprovalReceiptMarker extends ApprovalScopeFields {
+    state: 'pending' | 'executing' | 'settled';
+    approvalId: string;
+    expiresAt: number;
+    decidedBy?: string;
+}
+interface ApprovalReceiptRecord extends ApprovalScopeFields {
+    readonly receipt: ActionReceipt;
+    readonly definition: UiDefinitionRef | null;
+    readonly approvalId: string;
+    readonly expiresAt: number;
+    readonly state: ApprovalReceiptMarker['state'];
+    readonly decidedBy?: string;
+}
+export interface StateHandlerExecution {
+    handle: (context: UiActionHandlerContext) => {
+        state?: JsonObject;
+        result?: JsonObject;
+    } | {
+        outcome: 'rejected' | 'failed';
+        errorCode: string;
+        state?: JsonObject;
+        result?: JsonObject;
+    };
+}
+export interface ExternalReservation {
+    instance: UiInstance;
+    receipt: ActionReceipt;
+    reservedRevision: number;
+    reservationMarker: number;
+}
+export interface UiAuditSnapshotInput {
+    instanceId: string;
+    workspaceId: string;
+    updatedAt: number;
+    state: JsonObject;
+    dataPaths?: readonly string[];
+}
+export interface UiInstanceReadStore {
+    get(instanceId: string): UiInstance | null;
+    listByThread(workspaceId: string, threadId: string): UiInstance[];
+    listAgentOpenRequests(workspaceId: string, threadId: string): Map<string, UiAgentOpenRequest>;
+    listUnboundByApp(workspaceId: string, appId: string): UiInstance[];
+    getThreadBinding(workspaceId: string, threadId: string): ThreadBinding;
+    close(): void;
+}
+type ThreadBinding = 'bound' | 'unbound' | 'conflict';
+export declare function openUiInstanceReadStore(dbPath?: string, resolveDataPaths?: UiInstanceDataPathResolver): UiInstanceReadStore;
+export declare class UiInstanceStore {
+    private readonly handle;
+    private readonly db;
+    private readonly testHooks?;
+    constructor(dbPath?: string, testHooks?: UiInstanceStoreTestHooks);
+    close(): void;
+    repinInstance(input: UiInstanceRepinInput): UiInstanceRepinResult | null;
+    repinWorkspaceApp(input: UiInstanceRepinWorkspaceInput): UiInstanceRepinResult[];
+    archiveDefinition(definition: UiDefinition, now: number): void;
+    getArchivedDefinition(definitionHash: string): UiDefinition | null;
+    repinWorkspaceGeneration(input: UiInstanceRepinWorkspaceGenerationInput): UiInstanceRepinResult[];
+    private repinGenerationRow;
+    getRepinLedgerEntry(instanceId: string, workspaceId: string, appId: string, toHash: string): UiInstanceRepinLedgerEntry | null;
+    listRepinLedgerEntries(workspaceId: string, appId: string, toHash: string): UiInstanceRepinLedgerEntry[];
+    private writeRepinLedger;
+    create(input: {
+        id: string;
+        definitionId: string;
+        definitionVersion: number;
+        definitionHash: string;
+        workspaceId: string;
+        threadId: string;
+        appId?: string | null;
+        anchorTaskId: string | null;
+        domainRef: JsonObject;
+        state: JsonObject;
+        dataPaths?: readonly string[];
+        grants: readonly string[];
+        openedBy?: UiAuthenticatedActor | null;
+        now: number;
+    }): UiInstance;
+    get(instanceId: string, resolveDataPaths?: UiInstanceDataPathResolver): UiInstance | null;
+    getAgentOpenRequest(instanceId: string): UiAgentOpenRequest | null;
+    listAgentOpenRequests(workspaceId: string, threadId: string): Map<string, UiAgentOpenRequest>;
+    recordAgentOpenRequest(input: {
+        instanceId: string;
+        workspaceId: string;
+        threadId: string;
+        taskId: string;
+        reason: UiAgentOpenReason;
+        approvalId?: string;
+        requestedAt: number;
+    }): UiAgentOpenRequest | null;
+    open(input: {
+        id?: string;
+        appId: string;
+        definitionId: string;
+        definitionVersion: number;
+        definitionHash: string;
+        workspaceId: string;
+        threadId: string;
+        anchorTaskId?: string | null;
+        domainRef: JsonObject;
+        state: JsonObject;
+        dataPaths?: readonly string[];
+        grants: readonly string[];
+        openedBy?: UiAuthenticatedActor | null;
+        now: number;
+    }): UiInstance;
+    listByThread(workspaceId: string, threadId: string, resolveDataPaths?: UiInstanceDataPathResolver): UiInstance[];
+    listActiveByThreadAndApp(workspaceId: string, threadId: string, appId: string, resolveDataPaths?: UiInstanceDataPathResolver): UiInstance[];
+    listUnboundByApp(workspaceId: string, appId: string, resolveDataPaths?: UiInstanceDataPathResolver): UiInstance[];
+    getThreadBinding(workspaceId: string, threadId: string): ThreadBinding;
+    updateAuditSnapshot(input: UiAuditSnapshotInput): UiInstance | null;
+    getReceipt(instanceId: string, requestId: string): ActionReceipt | null;
+    listRecentReceipts(instanceId: string, limit: number): ActionReceipt[];
+    getReceiptById(receiptId: string): ActionReceipt | null;
+    createApprovalPendingReceipt(reservation: ReservationInput, approval: {
+        readonly approvalId: string;
+        readonly expiresAt: number;
+    }): UiApprovalRequestReceiptResult;
+    getApprovalPendingReceipt(receiptId: string): UiApprovalPendingReceipt | null;
+    getApprovalReceipt(receiptId: string): ApprovalReceiptRecord | null;
+    listApprovalPendingReceipts(): UiApprovalPendingReceipt[];
+    settleApprovalPendingReceipt(receiptId: string, outcome: 'rejected' | 'expired' | 'conflicted', provenance: UiApprovalDecisionProvenance, now: number): ActionReceipt | null;
+    getLatestReceiptForInstance(instanceId: string): ActionReceipt | null;
+    runStateOnly(reservation: ReservationInput, handler: StateHandlerExecution['handle']): ActionReceipt;
+    reserveExternal(reservation: ReservationInput): ExternalReservation;
+    reserveApprovalPendingReceipt(reservation: ReservationInput, receiptId: string, provenance: UiApprovalDecisionProvenance): ApprovalPendingReservationResult;
+    settleExternal(input: {
+        reservation: ReservationInput;
+        reservedRevision: number;
+        reservationMarker: number;
+        outcome: ActionReceiptOutcome;
+        state: JsonObject;
+        resultSummary: JsonObject | null;
+        errorCode: string | null;
+        apply?: () => ReturnType<StateHandlerExecution['handle']>;
+        restoreRevisionOnFailure?: boolean;
+        now: number;
+    }): ActionReceipt;
+}
+export {};