@kmlckj/aios-agent-server-sdk 0.0.0-stage → 0.0.2

package/dist/shared/collaboration-project-api.d.ts

@@ -0,0 +1,206 @@
+import type { CollaborationProject, CollaborationMember, CloudFileEntry } from './cloud-assistant-api.js';
+export interface CollaborationProjectTemplate {
+    id: string;
+    name: string;
+    description: string | null;
+    icon: string | null;
+    settings: Record<string, unknown>;
+    planViews: Array<Record<string, unknown>>;
+    sortOrder: number;
+}
+export interface DesktopTaskSummary {
+    taskId: string;
+    projectId: string;
+    title: string;
+    status: string;
+    unread: boolean;
+    updatedAt: string;
+}
+export interface DesktopProjectSidebarItem {
+    project: CollaborationProject;
+    tasks: DesktopTaskSummary[];
+    hasMoreTasks: boolean;
+}
+export interface DesktopProjectSettings {
+    projectId: string;
+    initialized: boolean;
+    templateId: string | null;
+    instruction: string;
+    defaultModelId: string | null;
+    defaultExpertMode: boolean;
+    defaultThinkingEnabled: boolean;
+    defaultReasoningEffort: string | null;
+    revision: number;
+    initializedAt: string | null;
+    updatedAt: string | null;
+    editable: boolean;
+}
+export interface DesktopActivity {
+    id: string;
+    projectId: string;
+    sequence: number;
+    activityType: string;
+    sourceType: string;
+    sourceId: string | null;
+    actorUserId: string | null;
+    content: Record<string, unknown>;
+    createdAt: string;
+    updatedAt: string | null;
+    editable: boolean;
+}
+export interface ProjectInvitation {
+    id: string;
+    projectId: string;
+    status: string;
+    role: string;
+    expiresAt: string;
+    createdAt: string;
+    inviteUrl?: string;
+}
+export interface ProjectJoinRequest {
+    id: string;
+    projectId: string;
+    applicantUserId: string;
+    note: string | null;
+    status: string;
+    createdAt: string;
+}
+export interface ProjectFileUsage {
+    usedBytes: number;
+    quotaBytes: number | null;
+    remainingBytes: number | null;
+    unlimited: boolean;
+    canUpgrade: boolean;
+}
+export interface ProjectFileType {
+    category: string;
+    label: string;
+    extensions: string[];
+    mimeTypes: string[];
+}
+export interface CollaborationProjectApi {
+    templates: {
+        list(): Promise<CollaborationProjectTemplate[]>;
+        get(templateId: string): Promise<CollaborationProjectTemplate>;
+    };
+    sidebar: {
+        get(taskLimit?: number): Promise<DesktopProjectSidebarItem[]>;
+    };
+    settings: {
+        get(projectId: string): Promise<DesktopProjectSettings>;
+        initialize(projectId: string, request: {
+            templateId?: string | null;
+            instruction?: string;
+            defaultModelId?: string | null;
+            expertMode: boolean;
+            thinkingEnabled?: boolean;
+            reasoningEffort?: string;
+            idempotencyKey: string;
+        }): Promise<DesktopProjectSettings>;
+        updateInstruction(projectId: string, request: {
+            instruction: string;
+            revision: number;
+        }): Promise<DesktopProjectSettings>;
+        updateRuntime(projectId: string, request: {
+            modelId: string;
+            expertMode: boolean;
+            thinkingEnabled: boolean;
+            reasoningEffort?: string;
+        }): Promise<DesktopProjectSettings>;
+    };
+    activities: {
+        list(projectId: string, query?: {
+            afterSequence?: number;
+            beforeSequence?: number;
+            type?: string;
+            actorUserIds?: string[];
+            limit?: number;
+        }): Promise<DesktopActivity[]>;
+        post(projectId: string, request: {
+            content: string;
+            mentions?: Array<Record<string, unknown>>;
+            attachments?: Array<Record<string, unknown>>;
+            replyToActivityId?: string;
+            idempotencyKey: string;
+        }): Promise<DesktopActivity>;
+        update(projectId: string, activityId: string, request: {
+            content: string;
+            mentions?: Array<Record<string, unknown>>;
+            attachments?: Array<Record<string, unknown>>;
+        }): Promise<DesktopActivity>;
+        delete(projectId: string, activityId: string): Promise<void>;
+        markRead(projectId: string, sequence: number): Promise<void>;
+    };
+    webMessages: {
+        post(projectId: string, content: string): Promise<Record<string, unknown>>;
+    };
+    invitations: {
+        list(projectId: string): Promise<ProjectInvitation[]>;
+        create(projectId: string, request: {
+            role: string;
+            expiresInDays: number;
+            maxUses: number;
+        }): Promise<ProjectInvitation>;
+        revoke(projectId: string, invitationId: string): Promise<void>;
+        preview(token: string): Promise<Record<string, unknown>>;
+        apply(token: string, note?: string): Promise<ProjectJoinRequest>;
+        listRequests(projectId: string): Promise<ProjectJoinRequest[]>;
+        approve(projectId: string, requestId: string): Promise<ProjectJoinRequest>;
+        reject(projectId: string, requestId: string, reason?: string): Promise<ProjectJoinRequest>;
+        cancel(projectId: string, requestId: string): Promise<ProjectJoinRequest>;
+    };
+    assets: {
+        list(projectId: string, query?: {
+            projectDir?: string;
+            depth?: number;
+            keyword?: string;
+            fileType?: string;
+            limit?: number;
+            offset?: number;
+        }): Promise<CloudFileEntry[]>;
+        get(projectId: string, artifactId: string): Promise<CloudFileEntry>;
+        readText(projectId: string, artifactId: string): Promise<{
+            content: string;
+            mediaType: string;
+            truncated: boolean;
+        }>;
+        readBinary(projectId: string, artifactId: string): Promise<{
+            data: Uint8Array;
+            mediaType: string | null;
+        }>;
+        upload(projectId: string, request: {
+            projectDir?: string;
+            fileType?: string;
+            fileName: string;
+            mediaType: string;
+            data: Uint8Array;
+        }): Promise<CloudFileEntry>;
+        replace(projectId: string, artifactId: string, request: {
+            fileName: string;
+            mediaType: string;
+            data: Uint8Array;
+        }): Promise<CloudFileEntry>;
+        updateText(projectId: string, artifactId: string, request: {
+            content: string;
+            mediaType?: string;
+        }): Promise<CloudFileEntry>;
+        createFolder(projectId: string, request: {
+            projectDir?: string;
+            name: string;
+        }): Promise<CloudFileEntry>;
+        move(projectId: string, artifactId: string, request: {
+            projectDir?: string;
+            name?: string;
+        }): Promise<CloudFileEntry>;
+        delete(projectId: string, artifactId: string): Promise<void>;
+        usage(projectId: string): Promise<ProjectFileUsage>;
+        types(projectId: string): Promise<ProjectFileType[]>;
+        accessUrl(projectId: string, artifactId: string): Promise<string>;
+    };
+    members: {
+        list(projectId: string): Promise<CollaborationMember[]>;
+        update(projectId: string, memberId: string, role: 'ADMIN' | 'MEMBER' | 'VIEWER'): Promise<CollaborationMember>;
+        remove(projectId: string, memberId: string): Promise<void>;
+        leave(projectId: string): Promise<void>;
+    };
+}

package/dist/shared/collaboration-resource-api.d.ts

@@ -0,0 +1,41 @@
+export interface DesktopProjectResource {
+    id: string;
+    projectId: string;
+    resourceType: 'SKILL' | 'CONNECTOR';
+    resourceId: string;
+    resourceVersion: string | null;
+    authorizationId: string | null;
+    authorizationScope: 'PUBLIC' | 'PERSONAL' | null;
+    enabled: boolean;
+    sortOrder: number;
+    config: Record<string, unknown>;
+}
+export interface DesktopResourceCatalogItem {
+    resourceType: 'SKILL' | 'CONNECTOR';
+    resourceId: string;
+    name: string;
+    description: string | null;
+    iconUrl: string | null;
+    version: string | null;
+    authorizationModes: string[];
+    authorizationRequired: boolean;
+}
+export interface ConnectorAuthorization {
+    id: string;
+    projectId: string;
+    connectorId: string;
+    authorizationScope: 'PUBLIC' | 'PERSONAL';
+    ownerUserId: string | null;
+    status: string;
+}
+export interface CollaborationResourceApi {
+    catalog(): Promise<DesktopResourceCatalogItem[]>;
+    list(projectId: string): Promise<DesktopProjectResource[]>;
+    create(projectId: string, request: Record<string, unknown>): Promise<DesktopProjectResource>;
+    update(projectId: string, bindingId: string, request: Record<string, unknown>): Promise<DesktopProjectResource>;
+    delete(projectId: string, bindingId: string): Promise<void>;
+    validate(projectId: string, bindingId: string): Promise<Record<string, unknown>>;
+    authorizations(projectId: string): Promise<ConnectorAuthorization[]>;
+    bindPublicAuthorization(projectId: string, request: Record<string, unknown>): Promise<ConnectorAuthorization>;
+    unbindPublicAuthorization(projectId: string, authorizationId: string): Promise<void>;
+}

package/dist/shared/collaboration-task-api.d.ts

@@ -0,0 +1,276 @@
+import type { LocalTaskEventType, LocalTaskMessageMode, LocalTaskRichContent } from './local-task-api.js';
+export type CloudTaskRuntimeEngine = 'licos' | 'codex' | 'cloud-task';
+export type CloudTaskStatus = 'DRAFT' | 'PLANNING' | 'PROVISIONING' | 'RUNNING' | 'WAITING_INPUT' | 'COMPLETED' | 'FAILED' | 'CANCELED' | 'INTERRUPTED' | 'ARCHIVED';
+export type CloudTaskSource = 'MANUAL' | 'PLAN' | 'AUTOMATION' | 'SCHEDULE' | 'COLLABORATION' | 'CODING';
+export type CloudTaskInstanceStatus = 'UNINITIALIZED' | 'PROVISIONING' | 'READY' | 'FAILED';
+export interface CloudTaskResourceSnapshot {
+    bindingId: string;
+    resourceType: 'SKILL' | 'CONNECTOR';
+    resourceId: string;
+    resourceVersion: string | null;
+    name: string;
+    description: string | null;
+    iconUrl: string | null;
+}
+export interface CloudTask {
+    id: string;
+    workspaceId: string;
+    ownerUserId: string;
+    projectId: string | null;
+    planItemId: string | null;
+    sourceType: CloudTaskSource;
+    sourceId: string | null;
+    title: string;
+    description: string | null;
+    prompt: string;
+    visibility: 'PRIVATE' | 'PROJECT';
+    status: CloudTaskStatus;
+    expertMode: boolean;
+    runtimeEngine: CloudTaskRuntimeEngine;
+    modelId: string;
+    recommendedModelId?: string | null;
+    thinkingEnabled: boolean;
+    reasoningEffort: string | null;
+    approvalMode: string;
+    messageMode: LocalTaskMessageMode;
+    resourceBindingIds: string[];
+    resourceSnapshots: CloudTaskResourceSnapshot[];
+    instanceId: string | null;
+    instanceStatus: CloudTaskInstanceStatus;
+    currentRunId: string | null;
+    summary: string | null;
+    errorCode: string | null;
+    errorMessage: string | null;
+    diagnosticId: string | null;
+    revision: number;
+    pinned: boolean;
+    unread: boolean;
+    viewerRole: 'OWNER' | 'EDITOR' | 'VIEWER' | 'PROJECT_MEMBER';
+    archivedAt: string | null;
+    createdAt: string;
+    updatedAt: string;
+}
+export interface CloudTaskRun {
+    id: string;
+    taskId: string;
+    runNumber: number;
+    status: string;
+    triggerType: string;
+    prompt: string;
+    runtimeEngine: CloudTaskRuntimeEngine;
+    modelId: string;
+    mode: LocalTaskMessageMode;
+    resourceBindingIds: string[];
+    richContent?: LocalTaskRichContent;
+    errorCode: string | null;
+    errorMessage: string | null;
+    startedAt: string | null;
+    completedAt: string | null;
+    createdAt: string;
+}
+export interface CloudTaskArtifact {
+    id: string;
+    taskId: string;
+    runId: string | null;
+    name: string;
+    path: string;
+    mimeType: string | null;
+    sizeBytes: number | null;
+    sha256: string | null;
+    artifactType: string;
+    promotedProjectId: string | null;
+    promotedArtifactId: string | null;
+    createdAt: string;
+}
+export interface CloudTaskAttachment {
+    id: string;
+    taskId: string;
+    runId: string | null;
+    uploaderUserId: string;
+    fileName: string;
+    mediaType: string;
+    sizeBytes: number;
+    sha256: string;
+    workspacePath: string | null;
+    hydratedAt: string | null;
+    createdAt: string;
+}
+export type CloudTaskEventType = 'task.state.changed' | 'task.thinking.delta' | 'task.answer.delta' | 'task.answer.completed' | 'task.execution.event' | 'task.error' | 'task.interaction.required' | 'task.interaction.resolved' | 'task.artifact.created' | 'task.artifact.promoted';
+interface CloudTaskEventBase<TType extends CloudTaskEventType, TPayload> {
+    id: string;
+    workspaceId: string;
+    taskId: string;
+    runId: string;
+    eventId: string;
+    traceId: string | null;
+    sessionId: string;
+    turnId: string | null;
+    executionRoundId: string | null;
+    executionRoundIndex: number | null;
+    seqId: number;
+    eventType: TType;
+    payload: TPayload;
+    occurredAt: string;
+    createdAt: string;
+}
+export interface CloudTaskInteractionOption {
+    id?: string;
+    label: string;
+    description?: string;
+    rule?: string;
+}
+export interface CloudTaskInteractionPayload {
+    kind: 'approval' | 'user_input' | 'elicitation';
+    interactionId: string;
+    interactionType?: 'question' | 'elicitation';
+    title?: string;
+    question?: string;
+    description?: string;
+    toolCallId?: string;
+    toolName?: string;
+    toolCategory?: string;
+    riskLevel?: string;
+    requestId?: string;
+    options?: CloudTaskInteractionOption[];
+    allowOther?: boolean;
+    secret?: boolean;
+    mode?: string;
+    serverName?: string;
+    cancelable?: boolean;
+    formSchema?: Record<string, unknown> | unknown[];
+    url?: string;
+    status?: 'pending' | 'approved' | 'denied' | 'submitted' | 'cancelled' | 'timed_out';
+    approved?: boolean;
+    response?: unknown;
+}
+export type CloudTaskEvent = CloudTaskEventBase<'task.state.changed', {
+    state: string;
+    sessionId: string;
+    turnId?: string;
+}> | CloudTaskEventBase<'task.thinking.delta', {
+    text: string;
+    sessionId: string;
+    turnId?: string;
+}> | CloudTaskEventBase<'task.answer.delta', {
+    text: string;
+    sessionId: string;
+    turnId?: string;
+}> | CloudTaskEventBase<'task.answer.completed', {
+    text: string;
+    sessionId: string;
+    turnId?: string;
+    total_input_tokens?: number;
+    total_output_tokens?: number;
+    total_cache_read_tokens?: number;
+    total_cache_write_tokens?: number;
+    charged_points?: number;
+    turn_count?: number;
+    duration_ms?: number;
+}> | CloudTaskEventBase<'task.execution.event', {
+    type: LocalTaskEventType;
+    data: Record<string, unknown>;
+    sessionId: string;
+    turnId?: string;
+}> | CloudTaskEventBase<'task.error', {
+    message: string;
+    retryable: boolean;
+    sessionId: string;
+    turnId?: string;
+}> | CloudTaskEventBase<'task.interaction.required', CloudTaskInteractionPayload & {
+    sessionId: string;
+    turnId?: string;
+}> | CloudTaskEventBase<'task.interaction.resolved', {
+    kind: 'approval' | 'user_input' | 'elicitation';
+    interactionId: string;
+    interactionType?: 'question' | 'elicitation';
+    approved?: boolean;
+    optionId?: string;
+    status?: string;
+    response?: unknown;
+    sessionId: string;
+    turnId?: string;
+}> | CloudTaskEventBase<'task.artifact.created' | 'task.artifact.promoted', {
+    artifactId?: string;
+    name?: string;
+    mimeType?: string;
+    size_bytes?: number;
+    sessionId: string;
+    turnId?: string;
+}>;
+export interface CloudTaskEventPage {
+    items: CloudTaskEvent[];
+    nextSeqId: number;
+    hasMore: boolean;
+    taskStatus: CloudTaskStatus;
+    runStatus: string | null;
+}
+export interface CloudTaskApi {
+    sources(): Promise<CloudTaskSource[]>;
+    list(query?: {
+        projectId?: string;
+        status?: CloudTaskStatus;
+        sourceType?: CloudTaskSource;
+        ownerUserId?: string;
+        keyword?: string;
+        createdAfter?: string;
+        createdBefore?: string;
+        limit?: number;
+        offset?: number;
+    }): Promise<CloudTask[]>;
+    get(taskId: string): Promise<CloudTask>;
+    markRead(taskId: string): Promise<void>;
+    artifacts(taskId: string): Promise<CloudTaskArtifact[]>;
+    readArtifact(taskId: string, artifactId: string): Promise<{
+        data: Uint8Array;
+        mediaType: string | null;
+    }>;
+    readAttachment(taskId: string, attachmentId: string): Promise<{
+        data: Uint8Array;
+        mediaType: string | null;
+    }>;
+    artifact(taskId: string, artifactId: string): Promise<CloudTaskArtifact>;
+    artifactAccess(taskId: string, artifactId: string): Promise<{
+        artifactId: string;
+        previewUrl: string;
+        downloadUrl: string;
+        mimeType: string | null;
+        sizeBytes: number | null;
+    }>;
+    promoteArtifact(taskId: string, artifactId: string, request: {
+        projectId: string;
+        projectDir?: string;
+        name?: string;
+    }): Promise<CloudTaskArtifact>;
+    pin(taskId: string): Promise<CloudTask>;
+    unpin(taskId: string): Promise<CloudTask>;
+    comments(taskId: string): Promise<Array<Record<string, unknown>>>;
+    addComment(taskId: string, request: Record<string, unknown>): Promise<Record<string, unknown>>;
+    updateComment(taskId: string, commentId: string, request: Record<string, unknown>): Promise<Record<string, unknown>>;
+    deleteComment(taskId: string, commentId: string): Promise<void>;
+    shares: TaskShareApi;
+    invitations: TaskInvitationApi;
+    collaborators: TaskCollaboratorApi;
+}
+export interface TaskShareApi {
+    list(taskId: string): Promise<Array<Record<string, unknown>>>;
+    create(taskId: string, request: Record<string, unknown>): Promise<Record<string, unknown>>;
+    revoke(taskId: string, shareId: string): Promise<void>;
+    preview(token: string): Promise<Record<string, unknown>>;
+    requestAccess(token: string, request: Record<string, unknown>): Promise<Record<string, unknown>>;
+    listRequests(taskId: string): Promise<Array<Record<string, unknown>>>;
+    reviewRequest(taskId: string, requestId: string, approve: boolean): Promise<Record<string, unknown>>;
+}
+export interface TaskInvitationApi {
+    list(taskId: string): Promise<Array<Record<string, unknown>>>;
+    create(taskId: string, request: Record<string, unknown>): Promise<Record<string, unknown>>;
+    revoke(taskId: string, invitationId: string): Promise<void>;
+    preview(token: string): Promise<Record<string, unknown>>;
+    accept(token: string, idempotencyKey: string): Promise<Record<string, unknown>>;
+    reject(token: string): Promise<Record<string, unknown>>;
+}
+export interface TaskCollaboratorApi {
+    list(taskId: string): Promise<Array<Record<string, unknown>>>;
+    update(taskId: string, collaboratorId: string, role: string): Promise<Record<string, unknown>>;
+    remove(taskId: string, collaboratorId: string): Promise<void>;
+}
+export {};

package/dist/shared/collaboration-task-execution.d.ts

@@ -0,0 +1,39 @@
+export interface ProjectExecutionRef {
+    actorUserId: string;
+    projectId: string;
+}
+export interface ProjectTaskNotAdmitted {
+    admitted: false;
+    message: string;
+}
+export interface ProjectTaskExecution {
+    id: string;
+    projectId: string;
+    sourceMessageId: string;
+    actorUserId: string;
+    taskId: string;
+    taskTitle: string;
+    messageCommandId: string;
+    status: string;
+    replyMessageId: string;
+}
+export interface ProjectTaskStart {
+    commandId: string;
+    sourceMessageId: string;
+    taskId?: string;
+    workspaceId?: string;
+    memory?: {
+        read: boolean;
+        write: boolean;
+    };
+    newTask?: {
+        title: string;
+        model: string;
+        mode: 'agent' | 'plan';
+        thinkingEnabled: boolean;
+        reasoningEffort?: string;
+        approvalMode: 'DEFAULT' | 'AUTO';
+    };
+    options: Record<string, unknown>;
+    attachmentIds?: string[];
+}

package/dist/shared/computer-use-api.d.ts

@@ -0,0 +1,80 @@
+import type { ComputerUsePeerMetadata } from './computer-use-handshake.js';
+export type ComputerUseDecision = 'allow' | 'deny';
+export declare const MINIMUM_CHROME_MAJOR_VERSION = 120;
+export type ComputerUseAction = 'navigation' | 'history' | 'download' | 'upload';
+export interface ChromeComputerUseSettings {
+    enabled: boolean;
+    fullCdpEnabled: boolean;
+}
+export type DesktopComputerUseAction = 'observation' | 'windowControl' | 'pointer' | 'keyboard';
+export interface DesktopComputerUseSettings {
+    enabled: boolean;
+    executionMode: 'standard' | 'strict_background';
+}
+export interface ComputerUseSettings {
+    enabled: boolean;
+    chrome: ChromeComputerUseSettings;
+    desktop: DesktopComputerUseSettings;
+}
+export interface ComputerUseStatus {
+    platform: 'darwin' | 'win32' | 'linux';
+    desktop: {
+        available: boolean;
+        helperRunning: boolean;
+        executablePath?: string;
+        protocolValidated: boolean;
+        protocolVersion?: number;
+        architectureValidated: boolean;
+        architectureVersion?: number;
+        invariants?: string[];
+        capabilities?: {
+            uiAutomation?: boolean;
+            screenCapture?: boolean;
+            targetIntegrityBoundary?: string;
+            uiAutomationError?: string;
+            screenCaptureError?: string;
+        };
+        error?: string;
+    };
+    chrome: {
+        installed: boolean;
+        executablePath?: string;
+        connectedBrowser?: {
+            name: 'Google Chrome' | 'Microsoft Edge' | 'Opera' | 'Chromium 浏览器';
+            version?: string;
+            majorVersion?: number;
+            supported?: boolean;
+            userAgent: string;
+        };
+        mcpConfigured: boolean;
+        mcpEnabled: boolean;
+        toolsDiscovered: number;
+        toolsEnabled: number;
+    };
+    bridge: {
+        brokerRunning: boolean;
+        nativeHostRegistered: boolean;
+        hostConnected: boolean;
+        extensionInstalled: boolean;
+        extensionConnected: boolean;
+        extensionInstallationMode: 'bundled' | 'web_store' | 'web_store_with_offline';
+        extensionId: string;
+        extensionDirectory: string;
+        manifestPath: string;
+        protocolVersion: number;
+        lastHeartbeatAt?: string;
+        peers?: Partial<Record<ComputerUsePeerMetadata['role'], ComputerUsePeerMetadata>>;
+        error?: string;
+        registrationError?: string;
+    };
+}
+export interface ComputerUseApi {
+    getStatus: () => Promise<ComputerUseStatus>;
+    registerNativeHost: () => Promise<ComputerUseStatus>;
+    unregisterNativeHost: () => Promise<ComputerUseStatus>;
+    copyExtensionPath: () => Promise<void>;
+    openChromeExtensionsPage: () => Promise<void>;
+    openExtensionStorePage: () => Promise<void>;
+}
+export declare const DEFAULT_COMPUTER_USE_SETTINGS: ComputerUseSettings;
+export declare function normalizeComputerUseSettings(value: unknown, fallback?: ComputerUseSettings): ComputerUseSettings;

package/dist/shared/computer-use-handshake.d.ts

@@ -0,0 +1,19 @@
+export declare const COMPUTER_USE_METADATA_PROTOCOL_VERSION = 5;
+export declare const COMPUTER_USE_SUPPORTED_PROTOCOLS: readonly [4, 5];
+export type ComputerUseProtocolVersion = typeof COMPUTER_USE_SUPPORTED_PROTOCOLS[number];
+export declare const COMPUTER_USE_TRANSPORT_CAPABILITIES: readonly ["peer-metadata", "connection-diagnostics"];
+export interface ComputerUsePeerMetadata {
+    connectionId: string;
+    role: 'desktop' | 'host' | 'extension';
+    version: string;
+    build: string;
+    supportedProtocols: number[];
+    capabilities: string[];
+}
+export declare const COMPUTER_USE_DIAGNOSTIC_EVENTS: readonly ["capabilities-ready", "control-disabled", "paused", "resumed", "manual-disconnect"];
+export interface ComputerUsePeerDiagnostic {
+    connectionId: string;
+    event: typeof COMPUTER_USE_DIAGNOSTIC_EVENTS[number];
+}
+export declare function isComputerUsePeerMetadata(value: unknown): value is ComputerUsePeerMetadata;
+export declare function isComputerUsePeerDiagnostic(value: unknown): value is ComputerUsePeerDiagnostic;