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

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

@@ -0,0 +1,372 @@
+import type { LocalTaskEventType, LocalTaskMessageMode, LocalTaskRichContent } from './local-task-api.js';
+import type { ModelReasoningEffort } from './model-selection.js';
+export type CloudTaskRuntimeEngine = 'licos' | 'codex';
+export type CloudTaskStatus = 'DRAFT' | 'PLANNING' | 'PROVISIONING' | 'RUNNING' | 'WAITING_INPUT' | 'COMPLETED' | 'FAILED' | 'CANCELED' | 'ARCHIVED';
+export type CloudTaskSource = 'MANUAL' | 'PLAN' | 'AUTOMATION' | 'TRANSFER';
+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 CreateCloudTaskRequest {
+    projectId?: string;
+    planItemId?: string;
+    sourceType: CloudTaskSource;
+    sourceId?: string;
+    title: string;
+    description?: string;
+    prompt: string;
+    visibility: 'PRIVATE' | 'PROJECT';
+    expertMode: boolean;
+    model: string;
+    recommendedModel?: string;
+    thinkingEnabled: boolean;
+    reasoningEffort?: string;
+    approvalMode: string;
+    mode: LocalTaskMessageMode;
+    resourceBindingIds: string[];
+    execute: boolean;
+    skillIds?: string[];
+    idempotencyKey: 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 CloudTaskEventSubscriptionRequest {
+    taskId: string;
+    afterSeqId?: number;
+}
+export interface ResolveCloudTaskInteractionRequest {
+    runId: string;
+    interactionId: string;
+    decision: string;
+    idempotencyKey: string;
+}
+export interface SubmitCloudTaskUserInputRequest {
+    runId: string;
+    interactionId: string;
+    response: Record<string, unknown>;
+    cancel?: boolean;
+    idempotencyKey: string;
+}
+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[]>;
+    create(request: CreateCloudTaskRequest): Promise<CloudTask>;
+    get(taskId: string): Promise<CloudTask>;
+    update(taskId: string, request: {
+        title?: string;
+        description?: string;
+        visibility?: 'PRIVATE' | 'PROJECT';
+        recommendedModel?: string;
+        revision: number;
+    }): Promise<CloudTask>;
+    updatePlugins(taskId: string, request: {
+        pluginBindingIds: string[];
+        revision: number;
+    }): Promise<CloudTask>;
+    delete(taskId: string): Promise<void>;
+    initializeInstance(taskId: string): Promise<CloudTask>;
+    execute(taskId: string, request?: {
+        richContent?: LocalTaskRichContent;
+        references?: Array<Record<string, unknown>>;
+    }): Promise<CloudTask>;
+    messages(taskId: string): Promise<Array<Record<string, unknown>>>;
+    events(taskId: string, query?: {
+        runId?: string;
+        afterSeqId?: number;
+        limit?: number;
+    }): Promise<CloudTaskEventPage>;
+    sendMessage(taskId: string, request: {
+        content: string;
+        model: string;
+        recommendedModel?: string;
+        thinkingEnabled: boolean;
+        reasoningEffort: ModelReasoningEffort | undefined;
+        mode: LocalTaskMessageMode;
+        resourceBindingIds: string[];
+        attachments?: Array<Record<string, unknown>>;
+        references?: Array<Record<string, unknown>>;
+        skillIds?: string[];
+        richContent?: LocalTaskRichContent;
+    }): Promise<Record<string, unknown>>;
+    resolveInteraction(taskId: string, request: ResolveCloudTaskInteractionRequest): Promise<void>;
+    submitUserInput(taskId: string, request: SubmitCloudTaskUserInputRequest): Promise<void>;
+    cancel(taskId: string): Promise<void>;
+    markRead(taskId: string): Promise<void>;
+    runs(taskId: string): Promise<CloudTaskRun[]>;
+    artifacts(taskId: string): Promise<CloudTaskArtifact[]>;
+    readArtifact(taskId: string, artifactId: string): Promise<{
+        data: Uint8Array;
+        mediaType: string | null;
+    }>;
+    attachments(taskId: string): Promise<CloudTaskAttachment[]>;
+    uploadAttachment(taskId: string, request: {
+        fileName: string;
+        mediaType: string;
+        data: Uint8Array;
+    }): Promise<CloudTaskAttachment>;
+    readAttachment(taskId: string, attachmentId: string): Promise<{
+        data: Uint8Array;
+        mediaType: string | null;
+    }>;
+    deleteAttachment(taskId: string, attachmentId: string): Promise<void>;
+    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>;
+    archive(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;
+    transfers: TaskTransferApi;
+}
+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 interface TaskTransferApi {
+    list(taskId: string): Promise<Array<Record<string, unknown>>>;
+    create(taskId: string, request: Record<string, unknown>): Promise<Record<string, unknown>>;
+    preview(transferId: string): Promise<Record<string, unknown>>;
+    accept(transferId: string, idempotencyKey: string): Promise<Record<string, unknown>>;
+    reject(transferId: string): Promise<Record<string, unknown>>;
+}
+export {};

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;