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

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

@@ -0,0 +1,22 @@
+import type { CloudTaskEvent, CloudTaskEventSubscriptionRequest } from './collaboration-task-api.js';
+export interface CloudTaskEventSubscription {
+    subscriptionId: string;
+}
+export type CloudTaskEventStreamMessage = {
+    type: 'event';
+    subscriptionId: string;
+    generation: number;
+    event: CloudTaskEvent;
+} | {
+    type: 'connection';
+    subscriptionId: string;
+    generation: number;
+    state: 'connecting' | 'connected' | 'recovering' | 'closed';
+    lastSeqId: number;
+    reason?: string;
+};
+export interface CloudTaskEventApi {
+    subscribe(request: CloudTaskEventSubscriptionRequest): Promise<CloudTaskEventSubscription>;
+    unsubscribe(subscriptionId: string): Promise<void>;
+    onEvent(listener: (message: CloudTaskEventStreamMessage) => void): () => void;
+}

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

@@ -0,0 +1,16 @@
+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 { CollaborationResourceApi } from './collaboration-resource-api.js';
+import type { CollaborationAutomationApi } from './collaboration-automation-api.js';
+import type { CollaborationEventApi } from './collaboration-event-api.js';
+import type { CloudTaskEventApi } from './cloud-task-event-api.js';
+export interface CollaborationDesktopApi {
+    projects: CollaborationProjectApi;
+    plan: CollaborationPlanApi;
+    tasks: CloudTaskApi;
+    taskEvents: CloudTaskEventApi;
+    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,18 @@
+export type CollaborationDeepLink = {
+    kind: 'project_invitation';
+    token: string;
+} | {
+    kind: 'task_invitation';
+    token: string;
+} | {
+    kind: 'task_share';
+    token: string;
+} | {
+    kind: 'task_transfer';
+    transferId: 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>;
+}

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>;
+}