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

package/dist/shared/cloud-task-runtime-api.d.ts

@@ -0,0 +1,253 @@
+import type { HistoryPage, QueueSnapshot, RunState, SessionEvent } from './sdk-session-contract.js';
+import type { CloudTask, CloudTaskAttachment as LegacyTaskAttachment, CloudTaskArtifact, CloudTaskEvent, CloudTaskRun } from './collaboration-task-api.js';
+import type { TaskSelectedResource } from './account-schedules-api.js';
+import type { LocalTaskMessageMode, LocalTaskPermissionMode } from './local-task-api.js';
+import type { ModelReasoningEffort } from './model-selection.js';
+import type { TaskExecutionBinding, TaskExecutionEndpointsApi } from './task-execution-api.js';
+import type { CloudSessionResources } from './cloud-task-resources.js';
+export type { HistoryPage, QueueSnapshot, RunState, SessionEvent } from './sdk-session-contract.js';
+export interface CloudTaskRef {
+    actorUserId: string;
+    taskId: string;
+    remote?: boolean;
+}
+export interface CloudTaskLifecycleInput {
+    commandId: string;
+    action: 'reset' | 'delete';
+    revision: number;
+    sessionId: string | null;
+    historyVersion: string | null;
+}
+export interface CloudTaskLifecycleReceipt {
+    command_id: string;
+    action: 'reset' | 'delete';
+    status: 'settled';
+    session_id: string | null;
+    session_generation: number | null;
+    replacement?: {
+        session_id: string;
+        session_generation: number;
+    };
+}
+export interface CloudTaskEntry {
+    id: string;
+    title: string;
+    workspaceId: string;
+    projectId: string | null;
+    sourceType: string;
+    status: string;
+    pinned: boolean;
+    createdAt: string;
+    updatedAt: string;
+}
+export interface CloudTaskDetail {
+    task: Omit<CloudTask, 'runtimeEngine'> & {
+        runtimeEngine: 'cloud-task';
+    };
+    memory: {
+        read: boolean;
+        write: boolean;
+    };
+    resources: TaskSelectedResource[];
+    execution: TaskExecutionBinding | null;
+}
+export interface CloudTaskCreation {
+    commandId: string;
+    content: string;
+    model: string;
+    mode: LocalTaskMessageMode;
+    thinkingEnabled: boolean;
+    reasoningEffort?: ModelReasoningEffort;
+    permissionMode: LocalTaskPermissionMode;
+    memory: {
+        read: boolean;
+        write: boolean;
+    };
+    projectId?: string;
+    executionEndpointId?: string;
+    title?: string;
+    visibility?: 'PRIVATE' | 'PROJECT';
+    resourceBindingIds?: string[];
+    skillIds?: string[];
+}
+export interface CloudTaskMessage {
+    commandId: string;
+    content: string;
+    options: Record<string, unknown>;
+    memory: {
+        read: boolean;
+        write: boolean;
+    };
+    enqueue?: boolean;
+    attachmentIds?: string[];
+}
+export interface CloudTaskReceipt {
+    command_id: string;
+    session_id: string;
+    session_generation: number;
+    run_id?: string;
+    message_id?: string;
+    status?: string;
+}
+export interface CloudTaskCommand {
+    command_id: string;
+    state: 'ABSENT' | 'PENDING' | 'ACCEPTED' | 'FINISHED' | 'REJECTED' | 'SUPERSEDED';
+    receipt: CloudTaskReceipt | null;
+    rejection?: {
+        code: string;
+        message?: string;
+    };
+    queue?: {
+        reason: 'ACCOUNT_CAPACITY';
+        maximum: number;
+    };
+}
+export interface CloudTaskNotAdmitted {
+    command_id: string;
+    admitted: false;
+    error: {
+        status: number;
+        message: string;
+    };
+}
+export type CloudTaskSendResult = CloudTaskReceipt | CloudTaskCommand | CloudTaskNotAdmitted;
+export interface CloudTaskSnapshot extends CloudSessionResources {
+    history: HistoryPage;
+    queue: QueueSnapshot;
+    configuration: Record<string, unknown>;
+}
+export interface CloudTaskBinding {
+    taskId: string;
+    sessionId: string;
+    generation: number;
+    cursor: string | null;
+    snapshot: CloudTaskSnapshot | null;
+    snapshotRevision: number;
+}
+export interface CloudTaskProjection {
+    bindings: CloudTaskBinding[];
+    events: Array<{
+        order: number;
+        event: SessionEvent;
+    }>;
+}
+export interface CloudTaskAction {
+    sessionId: string;
+    runId: string;
+    action: 'cancel' | 'confirm-plan' | 'approve' | 'answer' | 'cancel-input';
+    parameters: Record<string, unknown>;
+}
+export interface CloudTaskQueueAction {
+    sessionId: string;
+    action: 'edit' | 'remove' | 'reorder' | 'dispatch';
+    parameters: Record<string, unknown>;
+}
+export interface CloudTaskAttachment {
+    id: string;
+    taskId: string;
+    uploaderUserId: string;
+    fileName: string;
+    mediaType: string;
+    sizeBytes: number;
+    sha256: string;
+    createdAt: string;
+}
+export interface CloudTaskRuntimeApi extends TaskExecutionEndpointsApi {
+    projectExecutions(ref: import('./collaboration-task-execution.js').ProjectExecutionRef, offset: number): Promise<import('./collaboration-task-execution.js').ProjectTaskExecution[]>;
+    startProjectMessage(ref: import('./collaboration-task-execution.js').ProjectExecutionRef, input: import('./collaboration-task-execution.js').ProjectTaskStart): Promise<import('./collaboration-task-execution.js').ProjectTaskExecution | import('./collaboration-task-execution.js').ProjectTaskNotAdmitted>;
+    cancelProjectExecution(ref: import('./collaboration-task-execution.js').ProjectExecutionRef, id: string, commandId: string): Promise<void>;
+    catalog(actorUserId: string, workspaceId: string, query: Parameters<import('./collaboration-task-api.js').CloudTaskApi['list']>[0]): Promise<CloudTask[]>;
+    legacyHistory(ref: CloudTaskRef): Promise<{
+        runs: CloudTaskRun[];
+        attachments: LegacyTaskAttachment[];
+        artifacts: CloudTaskArtifact[];
+        events: CloudTaskEvent[];
+    }>;
+    legacyFile(ref: CloudTaskRef, kind: 'attachments' | 'artifacts', id: string): Promise<{
+        data: Uint8Array;
+        mediaType: string | null;
+    }>;
+    inspect(ref: CloudTaskRef): Promise<CloudTask>;
+    projectResources(ref: CloudTaskRef): Promise<{
+        skills: Record<string, unknown>[];
+        plugins: Record<string, unknown>[];
+    }>;
+    list(actorUserId: string, query: {
+        keyword: string;
+        view: 'recent' | 'running' | 'archived';
+        offset: number;
+    }): Promise<CloudTaskEntry[]>;
+    detail(ref: CloudTaskRef): Promise<CloudTaskDetail>;
+    create(actorUserId: string, workspaceId: string, input: CloudTaskCreation): Promise<CloudTaskDetail>;
+    update(ref: CloudTaskRef, revision: number, change: {
+        title: string;
+    } | {
+        pinned: boolean;
+    }): Promise<CloudTaskDetail['task']>;
+    lifecycle(ref: CloudTaskRef, input: CloudTaskLifecycleInput): Promise<CloudTaskLifecycleReceipt | CloudTaskCommand | CloudTaskNotAdmitted>;
+    enterpriseInvocations(ref: CloudTaskRef, sessionId: string): Promise<import('./task-enterprise-project-api.js').EnterpriseProjectInvocation[]>;
+    respondEnterpriseInvocation(ref: CloudTaskRef, invocationId: string, interactionId: string, responseId: string, response: import('./task-enterprise-project-api.js').JsonValue): Promise<import('./task-enterprise-project-api.js').EnterpriseProjectInvocation>;
+    projection(ref: CloudTaskRef, after: number): Promise<CloudTaskProjection>;
+    send(ref: CloudTaskRef, input: CloudTaskMessage): Promise<CloudTaskSendResult>;
+    command(ref: CloudTaskRef, commandId: string): Promise<CloudTaskCommand>;
+    action(ref: CloudTaskRef, input: CloudTaskAction): Promise<CloudTaskReceipt>;
+    queueAction(ref: CloudTaskRef, input: CloudTaskQueueAction): Promise<CloudTaskReceipt>;
+    availability(ref: CloudTaskRef): Promise<{
+        present: boolean;
+        terminating?: boolean;
+    }>;
+    history(ref: CloudTaskRef, sessionId: string, cursor?: string): Promise<HistoryPage>;
+    queue(ref: CloudTaskRef, sessionId: string): Promise<QueueSnapshot>;
+    state(ref: CloudTaskRef, sessionId: string, runId: string): Promise<RunState>;
+    resources(ref: CloudTaskRef, sessionId: string): Promise<CloudSessionResources>;
+    attachments(ref: CloudTaskRef): Promise<CloudTaskAttachment[]>;
+    upload(ref: CloudTaskRef, uploadId: string, file: {
+        name: string;
+        mediaType: string;
+        data: Uint8Array;
+    }): Promise<CloudTaskAttachment>;
+    downloadAttachment(ref: CloudTaskRef, id: string): Promise<{
+        data: Uint8Array;
+        mediaType: string | null;
+    }>;
+    files(ref: CloudTaskRef, path?: string, cursor?: string): Promise<{
+        items: CloudTaskFile[];
+        nextCursor: string | null;
+    }>;
+    downloadFile(ref: CloudTaskRef, path: string): Promise<{
+        data: Uint8Array;
+        mediaType: string | null;
+    }>;
+}
+export interface CloudTaskFile {
+    name: string;
+    path: string;
+    directory: boolean;
+    size: number;
+    modifiedAt: string | null;
+}
+export interface CloudTaskEventRequest extends CloudTaskRef {
+    sessionId: string;
+    cursor?: string;
+}
+export type CloudTaskEventMessage = {
+    subscriptionId: string;
+    type: 'event';
+    event: SessionEvent;
+} | {
+    subscriptionId: string;
+    type: 'connection';
+    state: 'live' | 'closed';
+    cursor?: string;
+    error?: string;
+    retryable?: boolean;
+};
+export interface TaskConversationEventApi {
+    subscribe(request: CloudTaskEventRequest): Promise<{
+        subscriptionId: string;
+    }>;
+    start(subscriptionId: string): Promise<void>;
+    acknowledge(subscriptionId: string, cursor: string): Promise<void>;
+    unsubscribe(subscriptionId: string): Promise<void>;
+    onEvent(listener: (message: CloudTaskEventMessage) => void): () => void;
+}

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

@@ -0,0 +1,17 @@
+import type { CollaborationProjectApi } from './collaboration-project-api.js';
+import type { CollaborationPlanApi } from './collaboration-plan-api.js';
+import type { CloudTaskApi } from './collaboration-task-api.js';
+import type { CloudTaskRuntimeApi, TaskConversationEventApi } from './cloud-task-runtime-api.js';
+import type { CollaborationResourceApi } from './collaboration-resource-api.js';
+import type { CollaborationAutomationApi } from './collaboration-automation-api.js';
+import type { CollaborationEventApi } from './collaboration-event-api.js';
+export interface CollaborationDesktopApi {
+    projects: CollaborationProjectApi;
+    plan: CollaborationPlanApi;
+    tasks: CloudTaskApi;
+    taskConversations: CloudTaskRuntimeApi;
+    conversationEvents: TaskConversationEventApi;
+    resources: CollaborationResourceApi;
+    automations: CollaborationAutomationApi;
+    events: CollaborationEventApi;
+}

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

@@ -0,0 +1,55 @@
+export interface CollaborationAutomation {
+    id: string;
+    projectId: string;
+    name: string;
+    prompt: string;
+    triggerType: 'ONCE' | 'INTERVAL' | 'CRON';
+    triggerAt: string | null;
+    intervalSeconds: number | null;
+    cronExpression: string | null;
+    zoneId: string | null;
+    enabled: boolean;
+    expertMode: boolean;
+    modelId: string;
+    thinkingEnabled: boolean;
+    reasoningEffort: string | null;
+    approvalMode: string;
+    resourceBindingIds: string[];
+    lastRunStatus: string | null;
+    lastRunAt: string | null;
+    revision: number;
+    nextRunAt: string | null;
+    createdAt: string;
+    updatedAt: string;
+}
+export interface SaveCollaborationAutomationRequest {
+    name: string;
+    prompt: string;
+    trigger_type: CollaborationAutomation['triggerType'];
+    trigger_config: {
+        cron: string | null;
+        zone_id: string | null;
+        trigger_at: string | null;
+        interval_seconds: number | null;
+    };
+    enabled: boolean;
+    runtime_config: {
+        expert_mode: boolean;
+        model_id: string;
+        thinking_enabled: boolean;
+        reasoning_effort: string | null;
+        approval_mode: string;
+        resource_binding_ids: string[];
+    };
+}
+export interface CollaborationAutomationApi {
+    list(projectId: string): Promise<CollaborationAutomation[]>;
+    get(projectId: string, automationId: string): Promise<CollaborationAutomation>;
+    create(projectId: string, request: SaveCollaborationAutomationRequest): Promise<CollaborationAutomation>;
+    update(projectId: string, automationId: string, request: Partial<SaveCollaborationAutomationRequest> & {
+        revision: number;
+    }): Promise<CollaborationAutomation>;
+    delete(projectId: string, automationId: string): Promise<void>;
+    test(projectId: string, automationId: string): Promise<import('./collaboration-task-api.js').CloudTask>;
+    runs(projectId: string, automationId: string): Promise<Array<Record<string, unknown>>>;
+}

package/dist/shared/collaboration-deep-link.d.ts

@@ -0,0 +1,15 @@
+export type CollaborationDeepLink = {
+    kind: 'project_invitation';
+    token: string;
+} | {
+    kind: 'task_invitation';
+    token: string;
+} | {
+    kind: 'task_share';
+    token: string;
+} | {
+    kind: 'plan_item';
+    projectId: string;
+    itemId: string;
+};
+export type CollaborationDeepLinkKind = CollaborationDeepLink['kind'];

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

@@ -0,0 +1,19 @@
+export interface CollaborationDesktopEvent {
+    eventId: string;
+    projectId: string;
+    sequence: number;
+    eventType: string;
+    occurredAt: string;
+    payload: Record<string, unknown>;
+}
+export interface CollaborationEventApi {
+    subscribe(request: {
+        projectId: string;
+        afterSequence?: number;
+        versions: number[];
+    }): Promise<{
+        subscriptionId: string;
+    }>;
+    unsubscribe(subscriptionId: string): Promise<void>;
+    onEvent(listener: (event: CollaborationDesktopEvent) => void): () => void;
+}

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

@@ -0,0 +1,159 @@
+export type CollaborationPlanViewType = 'LIST' | 'BOARD' | 'TABLE' | 'GANTT' | 'CALENDAR';
+export type CollaborationPlanStatus = 'TODO' | 'IN_PROGRESS' | 'PAUSED' | 'DONE';
+export type CollaborationPlanPriority = 'NONE' | 'LOW' | 'MEDIUM' | 'HIGH' | 'URGENT';
+export type CollaborationPlanSource = 'MANUAL' | 'TRANSFER' | 'AUTOMATION' | 'IMPORT';
+export interface CollaborationPlanView {
+    id: string;
+    projectId: string;
+    name: string;
+    viewType: CollaborationPlanViewType;
+    config: Record<string, unknown>;
+    shared: boolean;
+    sortOrder: number;
+    systemView: boolean;
+}
+export interface CollaborationPlanItem {
+    id: string;
+    projectId: string;
+    parentId: string | null;
+    title: string;
+    description: unknown;
+    status: CollaborationPlanStatus;
+    priority: CollaborationPlanPriority;
+    assigneeUserIds: string[];
+    tagIds: string[];
+    attachments: CollaborationPlanAttachment[];
+    sourceType: CollaborationPlanSource;
+    startAt: string | null;
+    dueAt: string | null;
+    estimateMinutes: number | null;
+    progress: number;
+    sortOrder: number;
+    executionTaskId: string | null;
+    taskProgressSummary: string | null;
+    taskArtifactRefs: unknown[];
+    commentCount: number;
+    revision: number;
+    createdAt: string;
+    updatedAt: string;
+}
+export interface CollaborationPlanComment {
+    id: string;
+    projectId: string;
+    itemId: string;
+    authorUserId: string;
+    content: unknown;
+    mentions: unknown[];
+    attachments: unknown[];
+    createdAt: string;
+    updatedAt: string;
+}
+export interface CollaborationPlanActivity {
+    id: string;
+    projectId: string;
+    itemId: string;
+    activityType: string;
+    actorUserId: string;
+    payload: Record<string, unknown>;
+    createdAt: string;
+}
+export interface CollaborationPlanTag {
+    id: string;
+    projectId: string;
+    name: string;
+    color: string;
+}
+export interface CollaborationPlanAttachment {
+    artifactId: string;
+    projectId: string;
+    name: string;
+    fullPath: string;
+    contentType: string | null;
+    sizeBytes: number;
+}
+export interface CollaborationPlanImportPreview {
+    importId: string;
+    mapping: Record<string, string>;
+    validCount: number;
+    errorCount: number;
+    previewRows: Array<Record<string, unknown>>;
+    errors: Array<{
+        rowNumber: number;
+        message: string;
+    }>;
+}
+export interface CollaborationPlanImportCommit {
+    importId: string;
+    itemIds: string[];
+    committedCount: number;
+}
+export interface CollaborationPlanApi {
+    listViews(projectId: string): Promise<CollaborationPlanView[]>;
+    createView(projectId: string, request: Partial<CollaborationPlanView> & {
+        name: string;
+        viewType: CollaborationPlanViewType;
+    }): Promise<CollaborationPlanView>;
+    updateView(projectId: string, viewId: string, request: Record<string, unknown>): Promise<CollaborationPlanView>;
+    deleteView(projectId: string, viewId: string): Promise<void>;
+    reorderViews(projectId: string, items: Array<{
+        id: string;
+        sortOrder: number;
+    }>): Promise<CollaborationPlanView[]>;
+    listItems(projectId: string, query?: {
+        statuses?: CollaborationPlanStatus[];
+        assigneeUserIds?: string[];
+        tagIds?: string[];
+        priorities?: CollaborationPlanPriority[];
+        sourceTypes?: CollaborationPlanSource[];
+        matchMode?: 'ALL' | 'ANY';
+        keyword?: string;
+    }): Promise<CollaborationPlanItem[]>;
+    getItem(projectId: string, itemId: string): Promise<CollaborationPlanItem>;
+    createItem(projectId: string, request: Record<string, unknown> & {
+        title: string;
+    }): Promise<CollaborationPlanItem>;
+    updateItem(projectId: string, itemId: string, request: Record<string, unknown> & {
+        revision: number;
+    }): Promise<CollaborationPlanItem>;
+    deleteItem(projectId: string, itemId: string): Promise<void>;
+    deleteItems(projectId: string, items: Array<{
+        id: string;
+        revision: number;
+    }>): Promise<void>;
+    reorderItems(projectId: string, items: Array<{
+        id: string;
+        status: CollaborationPlanStatus;
+        sortOrder: number;
+        revision: number;
+    }>): Promise<CollaborationPlanItem[]>;
+    batchItems(projectId: string, items: Array<Record<string, unknown> & {
+        id: string;
+        revision: number;
+    }>): Promise<CollaborationPlanItem[]>;
+    executeItem(projectId: string, itemId: string, request?: Record<string, unknown>): Promise<import('./collaboration-task-api.js').CloudTask>;
+    listActivities(projectId: string, itemId: string): Promise<CollaborationPlanActivity[]>;
+    listComments(projectId: string, itemId: string): Promise<CollaborationPlanComment[]>;
+    createComment(projectId: string, itemId: string, request: Record<string, unknown>): Promise<CollaborationPlanComment>;
+    updateComment(projectId: string, itemId: string, commentId: string, request: Record<string, unknown>): Promise<CollaborationPlanComment>;
+    deleteComment(projectId: string, itemId: string, commentId: string): Promise<void>;
+    uploadCommentAttachment(projectId: string, itemId: string, request: {
+        fileName: string;
+        mediaType: string;
+        data: Uint8Array;
+    }): Promise<CollaborationPlanAttachment>;
+    listTags(projectId: string): Promise<CollaborationPlanTag[]>;
+    createTag(projectId: string, request: {
+        name: string;
+        color: string;
+    }): Promise<CollaborationPlanTag>;
+    updateTag(projectId: string, tagId: string, request: {
+        name?: string;
+        color?: string;
+    }): Promise<CollaborationPlanTag>;
+    deleteTag(projectId: string, tagId: string): Promise<void>;
+    previewImport(projectId: string, request: {
+        mapping: Record<string, string>;
+        rows: Array<Record<string, unknown>>;
+    }): Promise<CollaborationPlanImportPreview>;
+    commitImport(projectId: string, importId: string, idempotencyKey: string): Promise<CollaborationPlanImportCommit>;
+}