@xpert-ai/plugin-sdk 3.15.9 → 3.15.11

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@xpert-ai/plugin-sdk",
-  "version": "3.15.9",
+  "version": "3.15.11",
   "license": "AGPL-3.0",
   "repository": {
     "type": "git",
@@ -17,7 +17,7 @@
   },
   "dependencies": {
     "@langchain/openai": "0.6.9",
-    "@xpert-ai/contracts": "3.15.9",
+    "@xpert-ai/contracts": "3.15.11",
     "express": "^4.22.1",
     "js-tiktoken": "^1.0.21"
   },
@@ -38,5 +38,20 @@
     "yaml": "*",
     "zod": "*"
   },
+  "exports": {
+    "./package.json": "./package.json",
+    ".": {
+      "module": "./index.esm.js",
+      "types": "./index.d.ts",
+      "import": "./index.cjs.mjs",
+      "default": "./index.cjs.js"
+    },
+    "./collaboration-client": {
+      "module": "./collaboration-client.esm.js",
+      "types": "./collaboration-client.d.ts",
+      "import": "./collaboration-client.cjs.mjs",
+      "default": "./collaboration-client.cjs.js"
+    }
+  },
   "types": "./index.d.ts"
 }

package/src/collaboration-client.d.ts

@@ -0,0 +1,3 @@
+/** Browser-safe collaboration client entry point without server-side SDK dependencies. */
+export * from './lib/collaboration/client';
+export type * from './lib/collaboration/types';

package/src/index.d.ts

@@ -23,3 +23,4 @@ export * from './lib/sandbox/index';
 export * from './lib/managed-connection/index';
 export * from './lib/managed-queue/index';
 export * from './lib/view-extension/index';
+export * from './lib/collaboration/index';

package/src/lib/agent/middleware/capabilities/assistant-task.d.ts

@@ -15,6 +15,7 @@ export type AgentMiddlewareAssistantTaskInput = {
     xpertId: string;
     agentKey?: string;
     conversationId?: string | null;
+    executionId?: string | null;
     projectId?: string | null;
     taskId?: string;
     clientMessageId?: string;

package/src/lib/collaboration/client.d.ts

@@ -0,0 +1,118 @@
+import type { ApplyCollaborationUpdateResult, CollaborationPresencePatch, CollaborationSessionDescriptor, ICollaborationActor, ICollaborationPresence } from './types';
+export type CollaborationTransportPayload = Record<string, unknown>;
+export type CollaborationTransportHandler = (payload: CollaborationTransportPayload) => void;
+/** Framework-neutral event transport used by the collaboration client. */
+export interface CollaborationTransport {
+    readonly connected: boolean;
+    /** Socket/session identifier for this exact browser client, when the transport exposes one. */
+    readonly clientId?: string | null;
+    connect(): void;
+    disconnect(): void;
+    emit(event: string, payload?: CollaborationTransportPayload): void;
+    on(event: string, handler: CollaborationTransportHandler): () => void;
+}
+/** Minimal Socket.IO-compatible shape; keeps socket.io-client out of the SDK bundle. */
+export interface CollaborationSocketLike {
+    readonly connected: boolean;
+    readonly id?: string;
+    connect(): unknown;
+    disconnect(): unknown;
+    emit(event: string, payload?: CollaborationTransportPayload): unknown;
+    on(event: string, handler: CollaborationTransportHandler): unknown;
+    off(event: string, handler: CollaborationTransportHandler): unknown;
+}
+/** Adapt a caller-owned Socket.IO client to the SDK's framework-neutral transport. */
+export declare function createSocketIoTransportAdapter(socket: CollaborationSocketLike): CollaborationTransport;
+export type CollaborationDocumentUpdateHandler = (update: Uint8Array, origin: unknown) => void;
+/** Binary CRDT operations required by the generic collaboration client. */
+export interface CollaborationBinaryDocumentAdapter {
+    applyUpdate(update: Uint8Array, origin: unknown): void;
+    encodeStateVector(): Uint8Array;
+    mergeUpdates(updates: Uint8Array[]): Uint8Array;
+    onUpdate(handler: CollaborationDocumentUpdateHandler): () => void;
+}
+/** Minimal observable Yjs document surface accepted by `createYjsDocumentAdapter`. */
+export interface YjsDocumentLike {
+    on(event: 'update', handler: CollaborationDocumentUpdateHandler): void;
+    off(event: 'update', handler: CollaborationDocumentUpdateHandler): void;
+}
+/** Caller-supplied Yjs functions, avoiding a second Yjs runtime in plugin bundles. */
+export interface YjsApiLike<TDocument extends YjsDocumentLike> {
+    applyUpdate(document: TDocument, update: Uint8Array, origin?: unknown): void;
+    encodeStateVector(document: TDocument): Uint8Array;
+    mergeUpdates(updates: Uint8Array[]): Uint8Array;
+}
+/** Wrap a caller-owned `Y.Doc` without passing it across the runtime capability boundary. */
+export declare function createYjsDocumentAdapter<TDocument extends YjsDocumentLike>(document: TDocument, yjs: YjsApiLike<TDocument>): CollaborationBinaryDocumentAdapter;
+/** Timings, callbacks, transport, and document adapter used by a browser client. */
+export type CollaborationClientOptions = {
+    session: CollaborationSessionDescriptor;
+    transport: CollaborationTransport;
+    document: CollaborationBinaryDocumentAdapter;
+    initialPresence?: CollaborationPresencePatch;
+    batchMs?: number;
+    syncIntervalMs?: number;
+    presenceHeartbeatMs?: number;
+    /** Remove a presence locally when no refresh has been received within this interval. */
+    presenceStaleMs?: number;
+    onAck?: (ack: ApplyCollaborationUpdateResult) => void;
+    onPresence?: (presence: ICollaborationPresence) => void;
+    onPresenceSnapshot?: (items: ICollaborationPresence[], metadata: CollaborationPresenceSnapshotMetadata) => void;
+    onPresenceRemove?: (clientId: string) => void;
+    onConnectionChange?: (state: 'connecting' | 'connected' | 'disconnected') => void;
+    onError?: (error: Error) => void;
+};
+/** Lifecycle and presence controls returned by `createCollaborationClient`. */
+export interface CollaborationClient {
+    /** Stable origin applied to remote updates so local observers can prevent echo loops. */
+    readonly remoteOrigin: object;
+    /** Socket id for this exact tab/device; distinct from the stable actor `presenceId`. */
+    readonly selfClientId: string | null;
+    connect(): void;
+    disconnect(): void;
+    flush(): void;
+    requestSync(): void;
+    setPresence(patch: CollaborationPresencePatch): void;
+}
+/** Connection-specific metadata delivered with a presence snapshot. */
+export type CollaborationPresenceSnapshotMetadata = {
+    selfClientId: string | null;
+};
+/** Stable, framework-neutral view of active collaboration sessions and deduplicated actors. */
+export type CollaborationPresenceStoreSnapshot = {
+    selfClientId: string | null;
+    /** Every active browser/Agent session keyed by `clientId`. */
+    sessions: ICollaborationPresence[];
+    /** Sessions excluding only this exact browser client. */
+    remoteSessions: ICollaborationPresence[];
+    /** One entry per actor identity, including the local actor when supplied. */
+    collaborators: ICollaborationPresence[];
+};
+export type CollaborationPresenceStoreOptions = {
+    selfActor?: ICollaborationActor | null;
+    includeSelf?: boolean;
+    onChange?: (snapshot: CollaborationPresenceStoreSnapshot) => void;
+};
+/** Mutable presence projection used by plugin UIs without coupling them to a framework. */
+export interface CollaborationPresenceStore {
+    setSelfClientId(clientId: string | null): void;
+    replace(items: ICollaborationPresence[], selfClientId?: string | null): void;
+    upsert(item: ICollaborationPresence): void;
+    remove(clientId: string): void;
+    clear(): void;
+    snapshot(): CollaborationPresenceStoreSnapshot;
+}
+/**
+ * Keep per-client sessions for cursors while exposing one collaborator per stable actor identity.
+ * This prevents a second tab owned by the same user from either duplicating or hiding that user.
+ */
+export declare function createCollaborationPresenceStore(options?: CollaborationPresenceStoreOptions): CollaborationPresenceStore;
+/**
+ * Create a collaboration client with update batching, state-vector repair, presence heartbeat,
+ * and reconnect synchronization. The caller retains ownership of the document and transport.
+ */
+export declare function createCollaborationClient(options: CollaborationClientOptions): CollaborationClient;
+/** Encode bytes in browsers without Node.js `Buffer`; chunks avoid argument-size limits. */
+export declare function bytesToBase64(bytes: Uint8Array): string;
+/** Decode base64 in browsers without requiring Node.js polyfills. */
+export declare function base64ToBytes(value: string): Uint8Array;

package/src/lib/collaboration/index.d.ts

@@ -0,0 +1,5 @@
+export * from './types';
+export * from './runtime-capability';
+export * from './provider.decorator';
+export * from './provider.registry';
+export * from './client';

package/src/lib/collaboration/provider.decorator.d.ts

@@ -0,0 +1,3 @@
+export declare const COLLABORATION_DOCUMENT_PROVIDER = "COLLABORATION_DOCUMENT_PROVIDER";
+/** Register a plugin adapter for one stable collaboration resource type. */
+export declare const CollaborationDocumentProvider: (providerKey: string) => <TFunction extends Function, Y>(target: TFunction | object, propertyKey?: string | symbol, descriptor?: TypedPropertyDescriptor<Y>) => void;

package/src/lib/collaboration/provider.registry.d.ts

@@ -0,0 +1,7 @@
+import { DiscoveryService, Reflector } from '@nestjs/core';
+import { BaseStrategyRegistry } from '../strategy';
+import type { ICollaborationDocumentProvider } from './types';
+/** Discovers system and organization-scoped collaboration providers from loaded plugins. */
+export declare class CollaborationDocumentProviderRegistry extends BaseStrategyRegistry<ICollaborationDocumentProvider> {
+    constructor(discoveryService: DiscoveryService, reflector: Reflector);
+}

package/src/lib/collaboration/runtime-capability.d.ts

@@ -0,0 +1,3 @@
+import type { CollaborationApi } from './types';
+/** Platform-owned real-time collaboration capability available to scoped plugin runtimes. */
+export declare const CollaborationRuntimeCapability: import("../core/runtime-capability").RuntimeCapabilityKey<CollaborationApi>;

package/src/lib/collaboration/types.d.ts

@@ -0,0 +1,190 @@
+import type { CollaborationAccess, CollaborationActorStatus, CollaborationActorType, CollaborationDocumentStatus, CollaborationEngine, CollaborationMaterializationStatus, ICollaborationActor, ICollaborationFocus, ICollaborationPointer, ICollaborationPresence, ICollaborationSelection, ICollaborationViewport } from '@xpert-ai/contracts';
+export type { CollaborationAccess, CollaborationActorStatus, CollaborationActorType, CollaborationDocumentStatus, CollaborationEngine, CollaborationMaterializationStatus, ICollaborationActor, ICollaborationFocus, ICollaborationPointer, ICollaborationPresence, ICollaborationSelection, ICollaborationViewport } from '@xpert-ai/contracts';
+/** Tenant and business scope inherited by every collaboration operation. */
+export type CollaborationScope = {
+    tenantId?: string | null;
+    organizationId?: string | null;
+    workspaceId?: string | null;
+    projectId?: string | null;
+    xpertId?: string | null;
+    userId?: string | null;
+};
+/** Optional identity override for Agent or system initiated runtime calls. */
+export type CollaborationRuntimeActor = {
+    actorType?: CollaborationActorType | null;
+    actorKey?: string | null;
+    displayName?: string | null;
+    avatarUrl?: string | null;
+};
+/** Metadata-only representation of the platform collaboration document. */
+export type CollaborationDocumentRecord = CollaborationScope & {
+    id: string;
+    providerKey: string;
+    resourceId: string;
+    engine: CollaborationEngine;
+    schemaVersion: number;
+    status: CollaborationDocumentStatus;
+    sequenceNumber: number;
+    updateCount: number;
+    materializedSequence: number;
+    materializationStatus: CollaborationMaterializationStatus;
+    lastMaterializationError?: string | null;
+    metadata?: Record<string, unknown> | null;
+    createdAt?: string | Date;
+    updatedAt?: string | Date;
+};
+/**
+ * A full or state-vector-relative Yjs update together with its document metadata.
+ * `updateBase64` is safe to apply to a client whose vector was supplied in the request.
+ */
+export type CollaborationDocumentState = {
+    document: CollaborationDocumentRecord;
+    updateBase64: string;
+    stateVectorBase64: string;
+    sequenceNumber: number;
+};
+/** Creates the platform document lazily through the registered plugin provider. */
+export type EnsureCollaborationDocumentInput = {
+    providerKey: string;
+    resourceId: string;
+    schemaVersion?: number | null;
+    metadata?: Record<string, unknown> | null;
+};
+/** Locate a document either by platform id or by the provider's business resource key. */
+export type GetCollaborationDocumentInput = {
+    documentId: string;
+    providerKey?: never;
+    resourceId?: never;
+} | {
+    documentId?: never;
+    providerKey: string;
+    resourceId: string;
+};
+export type GetCollaborationDocumentStateInput = GetCollaborationDocumentInput & {
+    /** Omit for complete state; provide a Yjs state vector to receive only the missing delta. */
+    stateVectorBase64?: string | null;
+};
+/** Submit one Yjs update to the authoritative platform document. */
+export type ApplyCollaborationUpdateInput = {
+    documentId: string;
+    updateBase64: string;
+    origin?: string | null;
+    /** Optional compare-and-set guard for destructive or order-sensitive operations. */
+    expectedSequence?: number | null;
+    actor?: CollaborationRuntimeActor | null;
+};
+/** Acknowledgement for a unique or deduplicated collaboration update. */
+export type ApplyCollaborationUpdateResult = {
+    documentId: string;
+    duplicate: boolean;
+    sequenceNumber: number;
+    updateId?: string | null;
+    stateVectorBase64: string;
+    materializationStatus: CollaborationMaterializationStatus;
+};
+/** Request a short-lived browser session with no platform token exposure. */
+export type CreateCollaborationSessionInput = {
+    documentId: string;
+    access?: Exclude<CollaborationAccess, 'manage'> | null;
+};
+/** Credentials and backend URL required by a browser transport. */
+export type CollaborationSessionDescriptor = {
+    sessionId: string;
+    clientKey: string;
+    documentId: string;
+    namespace: string;
+    /** Backend public base URL; clients must not derive this from `window.location`. */
+    connectionUrl: string;
+    access: Exclude<CollaborationAccess, 'manage'>;
+    actor: ICollaborationActor;
+    expiresAt: number;
+};
+/** Bounded, ephemeral state that may be broadcast without persisting document content. */
+export type CollaborationPresencePatch = {
+    pageId?: string | null;
+    pointer?: ICollaborationPointer | null;
+    focus?: ICollaborationFocus | null;
+    selection?: ICollaborationSelection | null;
+    viewport?: ICollaborationViewport | null;
+    mode?: string | null;
+    status?: CollaborationActorStatus | null;
+    toolName?: string | null;
+    operationLabel?: string | null;
+};
+/** Create or refresh an Agent/system presence without opening a WebSocket connection. */
+export type UpsertVirtualPresenceInput = {
+    documentId: string;
+    actor?: CollaborationRuntimeActor | null;
+    presence: CollaborationPresencePatch;
+};
+/** Remove a virtual presence explicitly; otherwise it disappears through TTL expiry. */
+export type RemoveVirtualPresenceInput = {
+    documentId: string;
+    presenceId?: string | null;
+    actorKey?: string | null;
+};
+/** Runtime capability exposed to scoped plugin and Agent executions. */
+export interface CollaborationApi {
+    /** Ensure a provider/resource pair has one platform collaboration document. */
+    ensureDocument(input: EnsureCollaborationDocumentInput): Promise<CollaborationDocumentRecord>;
+    /** Read document metadata and trigger materialization read repair when required. */
+    getDocument(input: GetCollaborationDocumentInput): Promise<CollaborationDocumentRecord>;
+    /** Read complete state or a state-vector-relative Yjs delta. */
+    getDocumentState(input: GetCollaborationDocumentStateInput): Promise<CollaborationDocumentState>;
+    /** Authorize, deduplicate, merge, persist, broadcast, and materialize an update. */
+    applyUpdate(input: ApplyCollaborationUpdateInput): Promise<ApplyCollaborationUpdateResult>;
+    /** Issue single-document browser credentials with read or write access. */
+    createSession(input: CreateCollaborationSessionInput): Promise<CollaborationSessionDescriptor>;
+    /** List currently active user and virtual collaborator presence. */
+    listPresence(input: {
+        documentId: string;
+    }): Promise<ICollaborationPresence[]>;
+    /** Publish or refresh an Agent/system collaborator. */
+    upsertVirtualPresence(input: UpsertVirtualPresenceInput): Promise<ICollaborationPresence | null>;
+    /** Remove an Agent/system collaborator before its TTL expires. */
+    removeVirtualPresence(input: RemoveVirtualPresenceInput): Promise<void>;
+    /** Stop normal editing while retaining the document. */
+    archiveDocument(input: GetCollaborationDocumentInput): Promise<CollaborationDocumentRecord>;
+    /** Soft-delete the platform document and notify its provider. */
+    deleteDocument(input: GetCollaborationDocumentInput): Promise<CollaborationDocumentRecord>;
+}
+export type CollaborationProviderOperation = CollaborationAccess | 'initialize' | 'materialize' | 'delete';
+/** Context passed to a plugin provider for every authorization and lifecycle operation. */
+export type CollaborationProviderContext = CollaborationScope & {
+    documentId?: string | null;
+    providerKey: string;
+    resourceId: string;
+    operation: CollaborationProviderOperation;
+    actor?: ICollaborationActor | null;
+};
+/** Initial Yjs snapshot returned when the platform first sees a business resource. */
+export type CollaborationDocumentInitialization = {
+    stateBase64: string;
+    schemaVersion: number;
+    /** Preserve an existing plugin revision when migrating legacy collaborative data. */
+    initialSequence?: number | null;
+    metadata?: Record<string, unknown> | null;
+};
+/** Authoritative state delivered to the plugin after an accepted update or read repair. */
+export type CollaborationMaterializationEvent = CollaborationProviderContext & {
+    documentId: string;
+    stateBase64: string;
+    stateVectorBase64: string;
+    sequenceNumber: number;
+    updateBase64?: string | null;
+    origin?: string | null;
+};
+/**
+ * Plugin-owned adapter between a business resource and the platform collaboration engine.
+ * Authorization remains the plugin's responsibility; the platform owns transport and CRDT state.
+ */
+export interface ICollaborationDocumentProvider {
+    /** Authorize the exact resource and requested operation in the supplied platform scope. */
+    authorize(context: CollaborationProviderContext): Promise<boolean> | boolean;
+    /** Return an idempotent initial snapshot without creating a business version. */
+    initializeDocument(context: CollaborationProviderContext): Promise<CollaborationDocumentInitialization> | CollaborationDocumentInitialization;
+    /** Project platform state into plugin query/export entities. The method must be idempotent. */
+    materializeDocument(event: CollaborationMaterializationEvent): Promise<void> | void;
+    /** Optionally clean plugin-owned associations after a platform soft delete. */
+    onDocumentDeleted?(context: CollaborationProviderContext): Promise<void> | void;
+}

package/src/lib/runtime/capabilities/artifacts.d.ts

@@ -0,0 +1,163 @@
+import type { ArtifactAccessMode, ArtifactKind, ArtifactLinkDisposition, ArtifactLinkStatus, ArtifactLinkVersionMode, ArtifactSafeHtmlProfile, ArtifactStatus, ArtifactVersionStatus } from '@xpert-ai/contracts';
+import type { WorkspacePortableFileReference } from './workspace-files';
+export type { ArtifactAccessMode, ArtifactKind, ArtifactLinkDisposition, ArtifactLinkStatus, ArtifactLinkVersionMode, ArtifactSafeHtmlProfile, ArtifactStatus, ArtifactVersionStatus } from '@xpert-ai/contracts';
+/** Scope fields used when an Artifact belongs to a user/workspace/project/Xpert context. */
+export type ArtifactScopeInput = {
+    tenantId?: string | null;
+    organizationId?: string | null;
+    userId?: string | null;
+    workspaceId?: string | null;
+    projectId?: string | null;
+    xpertId?: string | null;
+};
+/** Stable plugin-owned business identity for an Artifact container. */
+export type ArtifactSourceInput = {
+    pluginName: string;
+    resourceType: string;
+    resourceId: string;
+    checksum?: string | null;
+};
+/** Creates or locates an Artifact container without uploading content bytes. */
+export type CreateArtifactInput = {
+    source: ArtifactSourceInput;
+    kind?: ArtifactKind | null;
+    title?: string | null;
+    description?: string | null;
+    scope?: ArtifactScopeInput | null;
+    metadata?: Record<string, unknown> | null;
+};
+/** Immutable content payload metadata for a new Artifact version. */
+export type ArtifactVersionInput = {
+    workspaceFileRef: WorkspacePortableFileReference;
+    mimeType: string;
+    fileName?: string | null;
+    title?: string | null;
+    description?: string | null;
+    size?: number | null;
+    sha256?: string | null;
+    sourceVersionId?: string | null;
+    checksum?: string | null;
+    setCurrent?: boolean | null;
+    metadata?: Record<string, unknown> | null;
+};
+export type CreateArtifactVersionInput = ArtifactVersionInput & {
+    artifactId: string;
+};
+/** Access policy requested for an Artifact link. */
+export type ArtifactLinkAccessInput = {
+    mode: ArtifactAccessMode;
+    customPrincipals?: string[] | null;
+    expiresAt?: string | Date | null;
+    ttlSeconds?: number | null;
+    userConfirmedPublicLink?: boolean | null;
+};
+/** Browser response hints and HTML safety profile for an Artifact link. */
+export type ArtifactLinkPresentationInput = {
+    disposition?: ArtifactLinkDisposition | null;
+    allowDownload?: boolean | null;
+    safeHtmlProfile?: ArtifactSafeHtmlProfile | null;
+};
+/** Creates a share/open/download entrypoint for an Artifact. */
+export type CreateArtifactLinkInput = {
+    artifactId: string;
+    artifactVersionId?: string | null;
+    versionMode?: ArtifactLinkVersionMode | null;
+    access: ArtifactLinkAccessInput;
+    presentation?: ArtifactLinkPresentationInput | null;
+    metadata?: Record<string, unknown> | null;
+};
+/** Creates a short-lived signed preview link; never use this as a durable share URL. */
+export type CreateSignedArtifactPreviewLinkInput = Omit<CreateArtifactLinkInput, 'access'> & {
+    ttlSeconds?: number | null;
+};
+/** Immutable Artifact version returned to plugins. */
+export type ArtifactVersionRecord = {
+    id: string;
+    artifactId: string;
+    versionNumber: number;
+    status: ArtifactVersionStatus;
+    sourceVersionId?: string | null;
+    checksum?: string | null;
+    mimeType: string;
+    fileName?: string | null;
+    title?: string | null;
+    description?: string | null;
+    size?: number | null;
+    sha256?: string | null;
+    createdAt?: string | Date;
+};
+/** Durable Artifact container returned to plugins. */
+export type ArtifactRecord = ArtifactScopeInput & {
+    id: string;
+    pluginName: string;
+    resourceType: string;
+    resourceId: string;
+    checksum?: string | null;
+    kind: ArtifactKind;
+    status: ArtifactStatus;
+    title?: string | null;
+    description?: string | null;
+    currentVersionId?: string | null;
+    currentVersion?: ArtifactVersionRecord | null;
+    createdAt?: string | Date;
+    updatedAt?: string | Date;
+};
+/** Share/open/download entrypoint returned to plugins. */
+export type ArtifactLinkRecord = ArtifactScopeInput & {
+    id: string;
+    artifactId: string;
+    artifactVersionId?: string | null;
+    versionMode: ArtifactLinkVersionMode;
+    slug: string;
+    publicUrl: string;
+    accessMode: ArtifactAccessMode;
+    status: ArtifactLinkStatus;
+    customPrincipals?: string[] | null;
+    expiresAt?: string | Date | null;
+    revokedAt?: string | Date | null;
+    accessCount?: number;
+    downloadCount?: number;
+    disposition: ArtifactLinkDisposition;
+    allowDownload: boolean;
+    safeHtmlProfile?: ArtifactSafeHtmlProfile | null;
+    createdAt?: string | Date;
+    updatedAt?: string | Date;
+    artifact?: ArtifactRecord;
+    version?: ArtifactVersionRecord | null;
+};
+/** Filter used when listing Artifacts visible to the current plugin/runtime scope. */
+export type ListArtifactsInput = {
+    pluginName?: string | null;
+    resourceType?: string | null;
+    resourceId?: string | null;
+    status?: ArtifactStatus | 'all' | null;
+    page?: number | null;
+    pageSize?: number | null;
+};
+export type ListArtifactsResult = {
+    items: ArtifactRecord[];
+    total: number;
+    page: number;
+    pageSize: number;
+};
+/** Mutable parts of an Artifact link; content versions remain immutable. */
+export type UpdateArtifactLinkAccessInput = {
+    access?: ArtifactLinkAccessInput | null;
+    presentation?: ArtifactLinkPresentationInput | null;
+    artifactVersionId?: string | null;
+    versionMode?: ArtifactLinkVersionMode | null;
+};
+/** Platform runtime capability exposed to plugins for managing generated Artifacts. */
+export interface ArtifactsApi {
+    createArtifact(input: CreateArtifactInput): Promise<ArtifactRecord>;
+    createArtifactVersion(input: CreateArtifactVersionInput): Promise<ArtifactVersionRecord>;
+    getArtifact(idOrSlug: string): Promise<ArtifactRecord>;
+    listArtifacts(input?: ListArtifactsInput): Promise<ListArtifactsResult>;
+    archiveArtifact(idOrSlug: string): Promise<ArtifactRecord>;
+    deleteArtifact(idOrSlug: string): Promise<ArtifactRecord>;
+    createArtifactLink(input: CreateArtifactLinkInput): Promise<ArtifactLinkRecord>;
+    createSignedPreviewLink(input: CreateSignedArtifactPreviewLinkInput): Promise<ArtifactLinkRecord>;
+    updateArtifactLinkAccess(idOrSlug: string, patch: UpdateArtifactLinkAccessInput): Promise<ArtifactLinkRecord>;
+    revokeArtifactLink(idOrSlug: string): Promise<ArtifactLinkRecord>;
+}
+export declare const ArtifactsRuntimeCapability: import("../../core/runtime-capability").RuntimeCapabilityKey<ArtifactsApi>;

package/src/lib/runtime/capabilities/index.d.ts

@@ -1,3 +1,4 @@
 export * from './knowledgebase';
 export * from './knowledgebase-documents';
+export * from './artifacts';
 export * from './workspace-files';