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

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

@@ -0,0 +1,337 @@
+import type { AppScheduleDirective, AppScheduleIntervalMinutes, AppScheduleSnapshot } from '../app/schedule-contract.js';
+import type { ContentFrame, UiActionContentDeclaration, UiContentChannelPort, UiContentRangeRequest } from '../mcp-app/content-channel.js';
+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 type UiSkillBackendEnvironmentKey = 'CREWX_APP_INSTANCE_ID' | 'CREWX_THREAD_ID';
+export interface UiDefinitionAction {
+    readonly capabilities: readonly string[];
+    readonly inputKeys?: readonly string[];
+    readonly dataInputs?: readonly string[];
+    readonly confirmation?: UiActionConfirmation;
+    readonly resultProjection?: UiProjectionPolicy;
+    readonly content?: UiActionContentDeclaration;
+    readonly env?: readonly UiSkillBackendEnvironmentKey[];
+    readonly schedule?: UiDefinitionActionSchedule;
+}
+export interface UiDefinitionActionSchedule {
+    readonly everyMinutes: AppScheduleIntervalMinutes;
+    readonly timeoutMs: number;
+}
+export interface UiProjectionPolicy {
+    allow: readonly string[];
+}
+export type UiDefinitionLegacyToolVisibility = 'model' | 'app';
+export interface UiDefinitionLegacyTool {
+    readonly name: string;
+    readonly description: string;
+    readonly inputSchema: JsonObject;
+    readonly textFallback: string;
+    readonly visibility: readonly UiDefinitionLegacyToolVisibility[];
+}
+export interface UiDefinitionLegacyReadTool extends UiDefinitionLegacyTool {
+    readonly fixedResult?: {
+        readonly structuredContent: JsonObject;
+        readonly argsPolicy: 'empty-only' | 'ignore';
+    };
+}
+export interface UiDefinitionLegacyMetadata {
+    readonly readTool?: UiDefinitionLegacyReadTool;
+    readonly actionTool?: UiDefinitionLegacyTool;
+    readonly hostTools?: Readonly<Record<string, string>>;
+    readonly agentAccess?: Readonly<Record<string, 'allowed' | 'denied'>>;
+}
+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[];
+    readonly summaryProjection?: UiProjectionPolicy;
+    readonly legacy?: UiDefinitionLegacyMetadata;
+}
+export interface UiDefinition extends UiDefinitionInput {
+    readonly hash: string;
+}
+export interface CreateUiInstanceInput {
+    definition: UiDefinitionRef;
+    workspaceId: string;
+    threadId: string;
+    anchorTaskId?: string;
+    domainRef: JsonObject;
+    state: JsonObject;
+}
+export type UiAgentOpenReason = 'open' | 'approval';
+export interface UiAgentOpenRequest {
+    requestId: string;
+    taskId: string;
+    reason: UiAgentOpenReason;
+    approvalId?: string;
+    requestedAt: number;
+}
+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;
+    resolvedDefinition?: UiDefinitionRef;
+    content?: {
+        in?: {
+            readonly ticket: string;
+            readonly sha256: string;
+        };
+        out?: {
+            readonly range?: UiContentRangeRequest;
+        };
+    };
+}
+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;
+    scope?: 'thread';
+    taskMode?: 'query' | 'execute';
+}
+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 ActionReceiptResultSummary {
+    readonly crewxResult?: {
+        readonly keys: readonly string[];
+        readonly bytes: number;
+        readonly sha256: string;
+    };
+    readonly crewxContent?: JsonObject;
+}
+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;
+    resultSummary: ActionReceiptResultSummary | null;
+    errorCode: string | null;
+    requestedAt: number;
+    settledAt: number | null;
+}
+export interface ActionExecutionReceipt extends ActionReceipt {
+    actionResult?: JsonObject;
+}
+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;
+    reservationNow?: number;
+    content?: {
+        readonly in?: ContentFrame;
+        readonly out?: {
+            readonly range?: UiContentRangeRequest;
+        };
+    };
+    schedule?: AppScheduleSnapshot;
+}
+export type UiActionHandlerResult = {
+    state?: JsonObject;
+    result?: JsonObject;
+    content?: ContentFrame;
+    schedule?: AppScheduleDirective;
+} | {
+    outcome: 'rejected' | 'failed';
+    errorCode: string;
+    state?: JsonObject;
+    result?: JsonObject;
+    content?: ContentFrame;
+};
+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;
+    contentChannel?: UiContentChannelPort;
+}
+export interface UiRuntimeFacade {
+    resolveDefinition(ref: UiDefinitionRef): UiDefinition | null;
+    createInstance(input: CreateUiInstanceInput): Promise<UiInstance>;
+    dispatchAction(input: UiActionEnvelope, context: UiExecutionContext): Promise<ActionExecutionReceipt>;
+    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;
+    verifiedBundles?: readonly import('../mcp-app/agent-access.js').McpAppVerifiedBundleAccessContext[];
+    clock?: () => number;
+    contentChannel?: UiContentChannelPort;
+}
+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<ActionExecutionReceipt>;
+    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<ActionExecutionReceipt>;
+    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/app-icon.d.ts

@@ -0,0 +1,50 @@
+export declare const APP_ICON_MAX_BYTES = 262144;
+export type AppIconContentType = 'image/svg+xml' | 'image/png' | 'image/jpeg';
+export type AppIconReason = 'missing' | 'bad-path' | 'bad-type' | 'bytes-mismatch' | 'too-large' | 'unsafe-svg';
+export interface AppIconDiagnostic {
+    readonly code: 'ICON_INVALID' | 'ICON_NOT_FILE' | 'ICON_NOT_SQUARE';
+    readonly severity: 'error' | 'warning';
+    readonly reason?: AppIconReason;
+    readonly declared?: string;
+}
+export interface AppIconFileBytes {
+    readonly path: string;
+    readonly contentType: AppIconContentType;
+    readonly byteLength: number;
+    readonly bytes: Uint8Array;
+}
+export interface AppIconFile {
+    readonly path: string;
+    readonly sha256: string;
+    readonly contentType: AppIconContentType;
+    readonly byteLength: number;
+}
+export type AppIconDeclaration = {
+    readonly kind: 'none';
+} | {
+    readonly kind: 'file';
+    readonly path: string;
+    readonly contentType: AppIconContentType;
+} | {
+    readonly kind: 'url';
+    readonly declared: string;
+} | {
+    readonly kind: 'invalid';
+    readonly reason: 'bad-path' | 'bad-type';
+    readonly declared?: string;
+};
+export type AppIconReadFailure = 'missing' | 'bad-path' | 'too-large';
+export interface ResolvedAppIcon {
+    readonly file?: AppIconFileBytes;
+    readonly diagnostics: readonly AppIconDiagnostic[];
+}
+export declare function classifyAppIconDeclaration(value: unknown): AppIconDeclaration;
+export declare function resolveAppIcon(value: unknown, read: (path: string) => Promise<Uint8Array | AppIconReadFailure>): Promise<ResolvedAppIcon>;
+export type AppIconInspection = {
+    readonly ok: true;
+    readonly square: boolean | undefined;
+} | {
+    readonly ok: false;
+    readonly reason: AppIconReason;
+};
+export declare function inspectAppIconBytes(contentType: AppIconContentType, bytes: Uint8Array): AppIconInspection;

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

@@ -0,0 +1,64 @@
+import type { JsonValue } from '../ui-instance/types.js';
+import { APP_TOOLS_FILE } from '../app/tool-mode.js';
+import type { UiPluginManifestMode, UiPluginManifestV2, UiPluginValidationErrorCode } from './types.js';
+export declare const APP_MANIFEST_FILE = "manifest.json";
+export declare const LEGACY_APP_MANIFEST_FILE = "ui-plugin.json";
+export declare const APP_MANIFEST_FILES: readonly ["manifest.json", "ui-plugin.json"];
+export type AppManifestFileName = (typeof APP_MANIFEST_FILES)[number];
+export { APP_TOOLS_FILE };
+export type AppToolsFileName = typeof APP_TOOLS_FILE;
+export declare const MCPB_MANIFEST_VERSION = "0.3";
+export declare const CREWX_META_NAMESPACE = "dev.crewx";
+export declare const MCPB_MANIFEST_KEYS: readonly ["manifest_version", "name", "display_name", "version", "description", "long_description", "author", "repository", "homepage", "documentation", "support", "icon", "icons", "screenshots", "localization", "server", "tools", "tools_generated", "prompts", "prompts_generated", "keywords", "license", "privacy_policies", "compatibility", "user_config", "_meta"];
+export declare const APP_MANIFEST_REQUIRED_KEYS: readonly ["manifest_version", "name", "display_name", "version", "description", "_meta"];
+export declare const APP_MANIFEST_PASSTHROUGH_KEYS: readonly ("name" | "description" | "server" | "tools" | "version" | "_meta" | "icon" | "manifest_version" | "display_name" | "long_description" | "author" | "repository" | "homepage" | "documentation" | "support" | "icons" | "screenshots" | "localization" | "tools_generated" | "prompts" | "prompts_generated" | "keywords" | "license" | "privacy_policies" | "compatibility" | "user_config")[];
+export declare const CREWX_META_REQUIRED_KEYS: readonly ["entry", "surfaces", "size", "stateProjection", "actions"];
+export declare const CREWX_META_OPTIONAL_KEYS: readonly ["definitionId", "definitionVersion", "icon", "tone", "entryHash", "runtime", "initialState", "usage", "detailPanel", "displayModes", "summaryProjection", "dataPaths", "focusedAiDataPaths", "csp"];
+export declare function isAppSemver(value: unknown): value is string;
+export interface AppManifestReason {
+    readonly path: string;
+    readonly rule: string;
+    readonly message?: string;
+    readonly file?: AppManifestFileName | AppToolsFileName;
+}
+export type AppManifestRejectionCode = UiPluginValidationErrorCode | 'MANIFEST_DUAL_MISMATCH';
+export interface AppManifestRejection {
+    readonly code: AppManifestRejectionCode;
+    readonly reason: AppManifestReason;
+    readonly files: readonly AppManifestFileName[];
+}
+export interface AppManifestIdentity {
+    readonly pluginId: string;
+    readonly definitionId?: string;
+    readonly definitionVersion?: number;
+}
+export interface AppManifestFileResult {
+    readonly file: AppManifestFileName;
+    readonly manifest: UiPluginManifestV2;
+    readonly v2Input: Readonly<Record<string, unknown>>;
+    readonly releaseVersion?: string;
+    readonly mcpb?: Readonly<Record<string, JsonValue>>;
+}
+export interface AppManifestSource extends AppManifestFileResult {
+    readonly ok: true;
+    readonly identity: AppManifestIdentity;
+    readonly files: readonly AppManifestFileName[];
+}
+export interface AppManifestFailure {
+    readonly ok: false;
+    readonly rejection: AppManifestRejection;
+    readonly parseFailure: boolean;
+    readonly identity?: AppManifestIdentity;
+    readonly builtinOnly: boolean;
+}
+export type AppManifestResult = AppManifestSource | AppManifestFailure;
+export interface AppManifestOptions {
+    readonly mode?: UiPluginManifestMode;
+    readonly maxBytes?: number;
+}
+export type AppManifestFileBytes = Partial<Record<AppManifestFileName, Uint8Array>> & {
+    [APP_TOOLS_FILE]?: Uint8Array;
+};
+export declare function claimsCrewxNamespace(bytes: Uint8Array): boolean;
+export declare function appManifestDefinitionHash(manifest: UiPluginManifestV2): string;
+export declare function resolveAppManifest(files: AppManifestFileBytes, options?: AppManifestOptions): AppManifestResult;

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

@@ -0,0 +1,28 @@
+export interface UiPluginCspInput {
+    readonly connectDomains?: readonly string[];
+    readonly frameDomains?: readonly string[];
+    readonly resourceDomains?: readonly string[];
+    readonly baseUriDomains?: readonly string[];
+}
+export type UiPluginCspNormalizationErrorCode = 'CSP_AXIS_UNSUPPORTED' | 'CSP_AXIS_UNKNOWN' | 'CSP_LIMIT_EXCEEDED' | 'CSP_ORIGIN_INVALID' | 'CSP_ORIGIN_FORBIDDEN';
+export interface NormalizedUiPluginCsp {
+    readonly declared: boolean;
+    readonly connectDomains: readonly string[];
+    readonly frameDomains: readonly string[];
+    readonly resourceDomains: readonly [];
+    readonly baseUriDomains: readonly [];
+    readonly cspHash: string;
+}
+export interface UiPluginCspNormalizeOptions {
+    readonly runtimeHostnames?: readonly string[];
+}
+export interface UiPluginPolicyRuntime {
+    readonly wasm?: boolean;
+}
+export interface UiPluginPolicyHashInput {
+    readonly runtime?: UiPluginPolicyRuntime;
+    readonly cspHash: string;
+    readonly policySchema: number;
+}
+export declare function normalizeUiPluginCsp(input: UiPluginCspInput | undefined, options?: UiPluginCspNormalizeOptions): NormalizedUiPluginCsp;
+export declare function policyHash(input: UiPluginPolicyHashInput): string;

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

@@ -0,0 +1,8 @@
+export { canonicalManifestJson, manifestHash } from './manifest.js';
+export { APP_MANIFEST_FILE, APP_MANIFEST_FILES, APP_MANIFEST_PASSTHROUGH_KEYS, APP_MANIFEST_REQUIRED_KEYS, CREWX_META_NAMESPACE, CREWX_META_OPTIONAL_KEYS, CREWX_META_REQUIRED_KEYS, LEGACY_APP_MANIFEST_FILE, MCPB_MANIFEST_KEYS, MCPB_MANIFEST_VERSION, appManifestDefinitionHash, APP_TOOLS_FILE, claimsCrewxNamespace, isAppSemver, resolveAppManifest, } from './app-manifest.js';
+export type { AppManifestFailure, AppManifestFileBytes, AppManifestFileName, AppManifestFileResult, AppManifestIdentity, AppManifestOptions, AppManifestReason, AppManifestRejection, AppManifestRejectionCode, AppManifestResult, AppManifestSource, AppToolsFileName, } from './app-manifest.js';
+export { APP_ICON_MAX_BYTES, classifyAppIconDeclaration, inspectAppIconBytes, resolveAppIcon, } from './app-icon.js';
+export type { AppIconContentType, AppIconDeclaration, AppIconDiagnostic, AppIconFile, AppIconFileBytes, AppIconInspection, AppIconReadFailure, AppIconReason, ResolvedAppIcon, } from './app-icon.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, UiPluginCspRequest, UiPluginRuntimeRequest, 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 = 2097152;
+export declare const UI_PLUGIN_MAX_INITIAL_STATE_BYTES = 2097152;
+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;