@crewx/sdk 0.9.0-rc.12 → 0.9.0-rc.121

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

@@ -1,3 +1,4 @@
+import type { DelegationResult } from '../task-log/delegation-trailer.js';
 export type TaskLogEntryType = 'text' | 'thinking' | 'tool_use' | 'tool_result' | 'error' | 'info' | 'running_instruction' | 'agent_call';
 export interface TaskLogEntry {
     timestamp: string;
@@ -8,6 +9,7 @@ export interface TaskLogEntry {
     toolUseId?: string;
     resultPreview?: string;
     isError?: boolean;
+    delegationResult?: DelegationResult | null;
     targetAgent?: string;
     targetTaskId?: string;
     errorMessage?: string;

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,17 @@
+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';
+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,9 @@
+export type { ActionReceipt, ActionReceiptOutcome, CreateUiInstanceInput, JsonObject, JsonPrimitive, JsonValue, UiActionHandlerContext, UiActionHandlerRegistration, UiActionHandlerResult, UiActionEnvelope, UiActionConfirmation, UiActor, UiDefinition, UiDefinitionAction, UiDefinitionDisplayMode, UiDefinitionInput, UiDefinitionRef, UiDefinitionUsage, UiProjectionPolicy, UiExecutionContext, UiAuthenticatedActor, UiTaskActorSnapshot, UiAuthenticatedExecutionContext, UiApprovalRequestContext, UiTaskExecutionContext, UiApprovalDecisionProvenance, UiApprovalPendingReceipt, UiApprovalRequestReceiptResult, UiAuthenticatedGrantPolicy, UiServerRuntimeFacade, UiServerRuntimeOptions, UiAgentContextProjection, UiExternalActionHandlerRegistration, 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 { UiInstanceStore, openUiInstanceReadStore } from './store.js';
+export type { UiAuditSnapshotInput, UiInstanceReadStore } from './store.js';
+export { createUiRuntimeForTest, createUiServerRuntime } from './runtime.js';

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

@@ -0,0 +1,8 @@
+import type { JsonObject, JsonValue } from './types.js';
+export declare function projectSafeJsonObject(value: unknown, envelopeDepth?: number, dataPaths?: readonly string[]): JsonObject;
+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/runtime.d.ts

@@ -0,0 +1,18 @@
+import type { UiRuntimeFacade, UiRuntimeOptions, UiServerRuntimeFacade, UiServerRuntimeOptions } from './types.js';
+import { UiInstanceStore } from './store.js';
+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,142 @@
+import type { ActionReceipt, ActionReceiptOutcome, UiApprovalDecisionProvenance, UiApprovalPendingReceipt, UiApprovalRequestReceiptResult, JsonObject, UiActionHandlerContext, UiActor, UiInstance, UiAuthenticatedActor, UiDefinitionRef } from './types.js';
+export type UiInstanceDataPathResolver = (definition: UiDefinitionRef) => readonly string[];
+interface UiInstanceStoreTestHooks {
+    injectDatabaseError?: () => unknown | undefined;
+    bumpRevisionBeforeCas?: boolean;
+    beforeOpenRead?: () => void;
+}
+export interface ReservationInput {
+    instanceId: string;
+    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 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;
+};
+interface ApprovalReceiptMarker {
+    state: 'pending' | 'executing' | 'settled';
+    approvalId: string;
+    expiresAt: number;
+    decidedBy?: string;
+}
+interface ApprovalReceiptRecord {
+    readonly receipt: ActionReceipt;
+    readonly approvalId: string;
+    readonly expiresAt: number;
+    readonly state: ApprovalReceiptMarker['state'];
+}
+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[];
+    close(): void;
+}
+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;
+    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;
+    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[];
+    updateAuditSnapshot(input: UiAuditSnapshotInput): UiInstance | null;
+    getReceipt(instanceId: string, requestId: string): ActionReceipt | null;
+    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;
+        result: JsonObject | null;
+        errorCode: string | null;
+        apply?: () => ReturnType<StateHandlerExecution['handle']>;
+        restoreRevisionOnFailure?: boolean;
+        now: number;
+    }): ActionReceipt;
+}
+export {};

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

@@ -0,0 +1,260 @@
+export type JsonPrimitive = string | number | boolean | null;
+export type JsonValue = JsonPrimitive | JsonObject | JsonValue[];
+export interface JsonObject {
+    [key: string]: JsonValue;
+}
+export type UiInstanceStatus = 'active' | 'completed' | 'expired' | 'revoked' | 'unsupported';
+export interface UiDefinitionRef {
+    id: string;
+    version: number;
+    hash: string;
+}
+export type UiDefinitionUsage = 'card' | 'window';
+export type UiDefinitionDisplayMode = 'inline' | 'floating' | 'focused';
+export declare const DEFAULT_UI_DEFINITION_USAGE: UiDefinitionUsage;
+export type UiActionConfirmation = 'none' | 'native';
+export interface UiDefinitionAction {
+    readonly capabilities: readonly string[];
+    readonly inputKeys?: readonly string[];
+    readonly dataInputs?: readonly string[];
+    readonly confirmation?: UiActionConfirmation;
+    readonly resultProjection?: UiProjectionPolicy;
+}
+export interface UiProjectionPolicy {
+    allow: readonly string[];
+}
+export interface UiDefinitionInput {
+    readonly id: string;
+    readonly version: number;
+    readonly sourceHash?: string;
+    readonly usage?: UiDefinitionUsage;
+    readonly detailPanel?: boolean;
+    readonly displayModes?: readonly UiDefinitionDisplayMode[];
+    readonly actions: Readonly<Record<string, UiDefinitionAction>>;
+    readonly renderer?: string;
+    readonly surfaces?: readonly string[];
+    readonly stateProjection?: UiProjectionPolicy;
+    readonly dataPaths?: readonly string[];
+}
+export interface UiDefinition extends UiDefinitionInput {
+    readonly hash: string;
+}
+export interface CreateUiInstanceInput {
+    definition: UiDefinitionRef;
+    workspaceId: string;
+    threadId: string;
+    anchorTaskId?: string;
+    domainRef: JsonObject;
+    state: JsonObject;
+}
+export interface UiInstance {
+    id: string;
+    definition: UiDefinitionRef;
+    workspaceId: string;
+    threadId: string;
+    appId: string | null;
+    anchorTaskId: string | null;
+    domainRef: JsonObject;
+    state: JsonObject;
+    revision: number;
+    status: UiInstanceStatus;
+    grantedCapabilities: readonly string[];
+    openedBy?: UiAuthenticatedActor | null;
+    createdAt: number;
+    updatedAt: number;
+}
+export interface UiActionEnvelope {
+    instanceId: string;
+    actionId: string;
+    expectedRevision: number;
+    requestId: string;
+    input: JsonObject;
+}
+export type UiActor = {
+    kind: 'local';
+    id: string;
+} | UiAuthenticatedActor | {
+    kind: 'agent';
+    id: string;
+};
+export interface UiExecutionContext {
+    source: 'cli' | 'ui_host' | 'system' | 'mcp';
+    workspaceId: string;
+    actor: UiActor;
+}
+export interface UiAuthenticatedActor {
+    kind: 'authenticated';
+    id: string;
+    task?: UiTaskActorSnapshot;
+}
+export interface UiTaskActorSnapshot {
+    taskId: string;
+    agentId: string;
+    threadId: string;
+    workspaceId: string;
+    parentTaskId: string | null;
+    parentTaskIds: readonly string[];
+}
+export declare function isUiAuthenticatedActor(value: unknown): value is UiAuthenticatedActor;
+export interface UiAuthenticatedExecutionContext {
+    source: 'ui_host' | 'system';
+    workspaceId: string;
+    threadId: string;
+    actor: UiAuthenticatedActor;
+}
+export interface UiApprovalRequestContext {
+    source: 'cli';
+    workspaceId: string;
+    threadId: string;
+    actor: UiAuthenticatedActor;
+}
+export interface UiTaskExecutionContext {
+    source: 'cli';
+    workspaceId: string;
+    threadId: string;
+    actor: UiAuthenticatedActor & {
+        task: UiTaskActorSnapshot;
+    };
+}
+export interface UiApprovalDecisionProvenance {
+    approvalId: string;
+    decidedBy: string;
+}
+export interface UiApprovalPendingReceipt {
+    receipt: ActionReceipt;
+    approvalId: string;
+    expiresAt: number;
+}
+export interface UiApprovalRequestReceiptResult {
+    receipt: ActionReceipt;
+    approval: {
+        approvalId: string;
+        expiresAt: number;
+    } | null;
+}
+export type ActionReceiptOutcome = 'succeeded' | 'rejected' | 'failed' | 'conflicted' | 'expired';
+export interface ActionReceipt {
+    id: string;
+    instanceId: string;
+    requestId: string;
+    actionId: string;
+    actor: UiActor;
+    source: 'cli' | 'ui_host' | 'system' | 'mcp';
+    expectedRevision: number;
+    beforeRevision: number;
+    afterRevision: number | null;
+    status: 'requested' | 'settled';
+    outcome: ActionReceiptOutcome | null;
+    input: JsonObject;
+    result: JsonObject | null;
+    errorCode: string | null;
+    requestedAt: number;
+    settledAt: number | null;
+}
+export interface UiLocalGrantPolicy {
+    resolveInstanceGrants(input: {
+        definition: UiDefinitionRef;
+        workspaceId: string;
+        actor: Extract<UiActor, {
+            kind: 'local';
+        }>;
+    }): readonly string[];
+    resolveActionCapabilities(input: {
+        definition: UiDefinitionRef;
+        actionId: string;
+    }): readonly string[];
+}
+export interface UiActionHandlerContext {
+    instance: UiInstance;
+    actor: UiActor;
+    source: 'cli' | 'ui_host' | 'system' | 'mcp';
+    input: JsonObject;
+    requestId: string;
+}
+export type UiActionHandlerResult = {
+    state?: JsonObject;
+    result?: JsonObject;
+} | {
+    outcome: 'rejected' | 'failed';
+    errorCode: string;
+    state?: JsonObject;
+    result?: JsonObject;
+};
+export interface UiStateActionHandlerRegistration {
+    definitionId: string;
+    version: number;
+    actionId: string;
+    kind: 'state';
+    handle: (context: UiActionHandlerContext) => UiActionHandlerResult;
+}
+export interface UiExternalActionHandlerRegistration {
+    definitionId: string;
+    version: number;
+    actionId: string;
+    kind: 'external';
+    handle: (context: UiActionHandlerContext) => Promise<UiActionHandlerResult>;
+}
+export type UiActionHandlerRegistration = UiStateActionHandlerRegistration | UiExternalActionHandlerRegistration;
+export interface UiRuntimeOptions {
+    dbPath?: string;
+    localActor: Extract<UiActor, {
+        kind: 'local';
+    }>;
+    localGrantPolicy?: UiLocalGrantPolicy;
+    definitions?: readonly UiDefinition[];
+    handlers?: readonly UiActionHandlerRegistration[];
+    clock?: () => number;
+}
+export interface UiRuntimeFacade {
+    resolveDefinition(ref: UiDefinitionRef): UiDefinition | null;
+    createInstance(input: CreateUiInstanceInput): Promise<UiInstance>;
+    dispatchAction(input: UiActionEnvelope, context: UiExecutionContext): Promise<ActionReceipt>;
+    getReceipt(instanceId: string, requestId: string): Promise<ActionReceipt | null>;
+    close(): void;
+}
+export interface UiAuthenticatedGrantPolicy {
+    resolveInstanceGrants(input: {
+        definition: UiDefinitionRef;
+        workspaceId: string;
+        actor: UiAuthenticatedActor;
+    }): readonly string[];
+    resolveDispatchCapabilities?(input: {
+        definition: UiDefinitionRef;
+        actionId: string;
+        actor: UiAuthenticatedActor;
+        source: 'ui_host' | 'system' | 'cli';
+    }): readonly string[];
+}
+export declare function resolveUiEffectiveCapabilities(declared: readonly string[], instanceGranted: readonly string[], dispatchGranted?: readonly string[]): readonly string[];
+export interface UiServerRuntimeOptions {
+    workspaceId: string;
+    dbPath: string;
+    definitions: readonly UiDefinition[];
+    handlers: readonly UiActionHandlerRegistration[];
+    grantPolicy: UiAuthenticatedGrantPolicy;
+    clock?: () => number;
+}
+export interface UiServerRuntimeFacade {
+    resolveDefinition(ref: UiDefinitionRef): UiDefinition | null;
+    getInstance(instanceId: string, context: UiAuthenticatedExecutionContext): Promise<UiInstance | null>;
+    createInstance(input: CreateUiInstanceInput, context: UiAuthenticatedExecutionContext): Promise<UiInstance>;
+    dispatchAction(input: UiActionEnvelope, context: UiAuthenticatedExecutionContext | UiTaskExecutionContext): Promise<ActionReceipt>;
+    getReceipt(instanceId: string, requestId: string, context: UiAuthenticatedExecutionContext): Promise<ActionReceipt | null>;
+    createApprovalPendingReceipt(input: UiActionEnvelope, context: UiApprovalRequestContext, approval: {
+        approvalId: string;
+        expiresAt: number;
+    }): Promise<UiApprovalRequestReceiptResult>;
+    executeApprovalPending(input: UiActionEnvelope, receiptId: string, provenance: UiApprovalDecisionProvenance): Promise<ActionReceipt>;
+    settleApprovalPending(receiptId: string, outcome: 'rejected' | 'expired' | 'conflicted', provenance: UiApprovalDecisionProvenance): Promise<ActionReceipt | null>;
+    listApprovalPendingReceipts(): Promise<UiApprovalPendingReceipt[]>;
+    close(): void;
+}
+export interface UiAgentContextProjection {
+    instanceId: string;
+    definition: UiDefinitionRef;
+    revision: number;
+    facts: JsonObject;
+    recentChanges: readonly JsonObject[];
+    pendingDecision: JsonObject | null;
+    availableActions: readonly string[];
+}

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

@@ -0,0 +1,4 @@
+export { canonicalManifestJson, manifestHash } from './manifest.js';
+export { UiPluginValidationError, normalizeManifest, validateInitialState, validateManifest, validatePayload, } from './validator.js';
+export { UI_PLUGIN_CAPABILITY_PATTERN, UI_PLUGIN_HANDLER_PATTERN, UI_PLUGIN_IDENTIFIER_PATTERN, UI_PLUGIN_MAX_ACTIONS, UI_PLUGIN_MAX_ARRAY_LENGTH, UI_PLUGIN_MAX_CANDIDATE_DEPTH, UI_PLUGIN_MAX_COMMAND_LENGTH, UI_PLUGIN_MAX_COMMAND_PARTS, UI_PLUGIN_MAX_DISCOVERED_APPS, UI_PLUGIN_MAX_DISCOVERY_TIME_MS, UI_PLUGIN_MAX_HEIGHT, UI_PLUGIN_MAX_INITIAL_STATE_BYTES, UI_PLUGIN_MAX_JSON_DEPTH, UI_PLUGIN_MAX_MANIFEST_BYTES, UI_PLUGIN_MAX_PROJECTION_PATHS, UI_PLUGIN_MAX_SCHEMA_DEPTH, UI_PLUGIN_MAX_SCHEMA_PROPERTIES, UI_PLUGIN_MAX_STRING_LENGTH, UI_PLUGIN_MAX_SUBTREE_BYTES, UI_PLUGIN_MAX_SURFACES, UI_PLUGIN_RESERVED_STATE_KEYS, UI_PLUGIN_SAFE_PATH_PATTERN, UI_PLUGIN_SAFE_PATH_SEGMENT_PATTERN, UI_PLUGIN_SKILL_TOKEN_PATTERN, UI_PLUGIN_SURFACES, UI_PLUGIN_TONES, isUiPluginReservedStateKey, } from './limits.js';
+export type { UiPluginActivation, UiPluginAction, UiPluginBackend, UiPluginCardShellNode, UiPluginCoreBackend, UiPluginFieldSchema, UiPluginHeadingNode, UiPluginInputSchema, UiPluginJsonSchema, UiPluginJsonSchemaType, UiPluginLabeledTextNode, UiPluginLayoutNode, UiPluginLayout, UiPluginManifest, UiPluginManifestMode, UiPluginManifestV1, UiPluginManifestV2, UiPluginMetaBannerNode, UiPluginNormalizedManifestV2, UiPluginNormalizedV2, UiPluginPayload, UiPluginPayloadValue, UiPluginPrimitive, UiPluginProjectionPolicy, UiPluginResourceMetadata, UiPluginResourceRef, UiPluginSchemaType, UiPluginSchema, UiPluginSize, UiPluginSkillBackend, UiPluginStep, UiPluginStepFlowNode, UiPluginStepListSchema, UiPluginTextListNode, UiPluginTextListSchema, UiPluginTextSchema, UiPluginSurface, UiPluginTone, UiPluginHandlerMetadata, UiPluginValidationErrorCode, UiPluginValidationOptions, } from './types.js';

package/dist/ui-plugin/limits.d.ts

@@ -0,0 +1,27 @@
+export declare const UI_PLUGIN_MAX_STRING_LENGTH = 4096;
+export declare const UI_PLUGIN_MAX_ARRAY_LENGTH = 128;
+export declare const UI_PLUGIN_MAX_SUBTREE_BYTES: number;
+export declare const UI_PLUGIN_MAX_INITIAL_STATE_BYTES: number;
+export declare const UI_PLUGIN_MAX_JSON_DEPTH = 8;
+export declare const UI_PLUGIN_MAX_SCHEMA_DEPTH = 8;
+export declare const UI_PLUGIN_MAX_SCHEMA_PROPERTIES = 64;
+export declare const UI_PLUGIN_MAX_ACTIONS = 32;
+export declare const UI_PLUGIN_MAX_SURFACES = 2;
+export declare const UI_PLUGIN_MAX_PROJECTION_PATHS = 128;
+export declare const UI_PLUGIN_MAX_COMMAND_PARTS = 16;
+export declare const UI_PLUGIN_MAX_COMMAND_LENGTH = 256;
+export declare const UI_PLUGIN_MAX_HEIGHT = 720;
+export declare const UI_PLUGIN_MAX_DISCOVERED_APPS = 64;
+export declare const UI_PLUGIN_MAX_MANIFEST_BYTES: number;
+export declare const UI_PLUGIN_MAX_CANDIDATE_DEPTH = 2;
+export declare const UI_PLUGIN_MAX_DISCOVERY_TIME_MS = 5000;
+export declare const UI_PLUGIN_RESERVED_STATE_KEYS: readonly ["__proto__", "prototype", "constructor", "proof", "token", "secret", "password", "cookie", "authorization", "private_key", "private-key", "stack", "exception", "plugin_text", "url", "uri", "endpoint", "path", "filename", "filepath", "cwd", "shell", "directory", "dir", "folder"];
+export declare function isUiPluginReservedStateKey(key: string): boolean;
+export declare const UI_PLUGIN_SAFE_PATH_SEGMENT_PATTERN: RegExp;
+export declare const UI_PLUGIN_SAFE_PATH_PATTERN: RegExp;
+export declare const UI_PLUGIN_IDENTIFIER_PATTERN: RegExp;
+export declare const UI_PLUGIN_CAPABILITY_PATTERN: RegExp;
+export declare const UI_PLUGIN_HANDLER_PATTERN: RegExp;
+export declare const UI_PLUGIN_SKILL_TOKEN_PATTERN: RegExp;
+export declare const UI_PLUGIN_TONES: readonly ["blue", "violet", "emerald", "amber", "rose", "sky", "slate", "indigo"];
+export declare const UI_PLUGIN_SURFACES: readonly ["inline", "panel"];

package/dist/ui-plugin/manifest.d.ts

@@ -0,0 +1,3 @@
+import type { UiPluginManifest } from './types.js';
+export declare function canonicalManifestJson(manifest: UiPluginManifest): string;
+export declare function manifestHash(manifest: UiPluginManifest): string;