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

package/dist/shared/task-enterprise-project-api.d.ts

@@ -0,0 +1,75 @@
+export type JsonValue = null | boolean | number | string | JsonValue[] | {
+    [key: string]: JsonValue;
+};
+export interface EnterpriseProjectInteraction {
+    interaction_id: string;
+    type: 'approval' | 'single_select' | 'multi_select' | 'form' | 'text';
+    title: string;
+    description?: string | null;
+    details?: JsonValue;
+    options: {
+        id: string;
+        label: string;
+        value: JsonValue;
+    }[];
+    schema: JsonSchema;
+    expires_at?: string | null;
+    status: 'pending' | 'resolved' | 'expired';
+}
+export interface JsonSchema {
+    [keyword: string]: unknown;
+    type?: 'object' | 'array' | 'string' | 'number' | 'integer' | 'boolean' | 'null';
+    title?: string;
+    description?: string;
+    properties?: Record<string, JsonSchema>;
+    required?: string[];
+    items?: JsonSchema;
+    enum?: JsonValue[];
+    minLength?: number;
+    maxLength?: number;
+    minimum?: number;
+    maximum?: number;
+    minItems?: number;
+    maxItems?: number;
+    pattern?: string;
+    format?: string;
+}
+export interface EnterpriseProjectArtifact {
+    name: string;
+    url: string;
+    mime_type?: string;
+}
+export interface EnterpriseProjectInvocation {
+    invocation_id: string;
+    record_id: string;
+    name: string;
+    task_id: string;
+    session_id: string;
+    status: 'queued' | 'running' | 'waiting_input' | 'waiting_approval' | 'succeeded' | 'incomplete' | 'failed' | 'cancelled' | 'interrupted';
+    result: JsonValue;
+    artifacts: EnterpriseProjectArtifact[];
+    required_action: EnterpriseProjectInteraction[];
+    error: JsonValue;
+    revision: number;
+    created_at: string;
+    updated_at: string;
+}
+export interface EnterpriseProjectResource {
+    tenant_id: string;
+    workspace_id: string;
+    resource_type: 'AGENT' | 'AICODING_AGENT' | 'AICODING_WORKFLOW';
+    resource_id: string;
+}
+export interface EnterpriseProjectCapability extends EnterpriseProjectResource {
+    record_id: string;
+    name: string;
+    description?: string | null;
+    contract_revision: string;
+}
+export interface EnterpriseProjectCapabilityPage {
+    list: EnterpriseProjectCapability[];
+    page: number;
+    page_size: number;
+    has_next: boolean;
+    verification_pending: number;
+}

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

@@ -0,0 +1,35 @@
+export type TaskExecutionProvider = 'LICOS' | 'CLAUDE' | 'CODEX';
+export interface TaskExecutionEndpoint {
+    id: string;
+    name: string;
+    provider: TaskExecutionProvider;
+    status: 'PENDING' | 'ACTIVE' | 'REVOKED';
+    connected: boolean;
+    deviceId: string | null;
+    capabilities: {
+        protocolVersion?: number;
+        methods?: string[];
+    };
+}
+export interface TaskEndpointPairing {
+    id: string;
+    endpointId: string;
+    token: string;
+    expiresAt: string;
+}
+export interface TaskExecutionBinding {
+    endpointId: string;
+    deviceId: string;
+    provider: TaskExecutionProvider;
+    name: string;
+}
+export interface TaskExecutionEndpointsApi {
+    executionEndpoints(actor: string, offset: number): Promise<TaskExecutionEndpoint[]>;
+    createExecutionEndpoint(actor: string, name: string, provider: TaskExecutionProvider): Promise<TaskEndpointPairing>;
+    pairExecutionEndpoint(actor: string, id: string): Promise<TaskEndpointPairing>;
+    executionPairingStatus(actor: string, pair: TaskEndpointPairing): Promise<{
+        status: 'PENDING' | 'CLAIMED' | 'CANCELLED' | 'EXPIRED';
+    }>;
+    cancelExecutionPairing(actor: string, pair: TaskEndpointPairing): Promise<void>;
+    revokeExecutionEndpoint(actor: string, id: string): Promise<void>;
+}

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

@@ -0,0 +1,44 @@
+export interface GenerateTaskTitleRequest {
+    permissionMode?: 'ask_dangerous' | 'allow_all';
+    prompt: string;
+    projectId?: string;
+}
+export interface GenerateTaskTitleResult {
+    title: string;
+    model: string;
+}
+export interface EnhanceTaskPromptRequest {
+    permissionMode?: 'ask_dangerous' | 'allow_all';
+    prompt: string;
+    projectId?: string;
+}
+export interface EnhanceTaskPromptResult {
+    prompt: string;
+    model: string;
+}
+export interface RecommendTaskModelRequest {
+    permissionMode?: 'ask_dangerous' | 'allow_all';
+    prompt: string;
+    projectId?: string;
+    attachments?: Array<{
+        name: string;
+        mediaType: string;
+    }>;
+}
+export interface RecommendTaskModelResult {
+    model: string;
+    source: 'recommended' | 'default';
+}
+export interface ResolveTaskExecutionModelRequest extends RecommendTaskModelRequest {
+    recommendedModel?: string;
+}
+export interface ResolveTaskExecutionModelResult {
+    model: string;
+    source: 'existing' | 'recommended' | 'default';
+}
+export interface TaskInitializationApi {
+    generateTitle(request: GenerateTaskTitleRequest): Promise<GenerateTaskTitleResult>;
+    enhancePrompt(request: EnhanceTaskPromptRequest): Promise<EnhanceTaskPromptResult>;
+    recommendModel(request: RecommendTaskModelRequest): Promise<RecommendTaskModelResult>;
+    resolveModelForExecution(request: ResolveTaskExecutionModelRequest): Promise<ResolveTaskExecutionModelResult>;
+}

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

@@ -0,0 +1,27 @@
+export type TaskMenuTarget = {
+    kind: 'local';
+    taskId: string;
+} | {
+    kind: 'cloud';
+    taskId: string;
+    projectId: string;
+};
+export type TaskMenuAction = {
+    kind: 'new-task';
+} | TaskMenuTarget;
+export interface TaskMenuEntry {
+    target: TaskMenuTarget;
+    title: string;
+    projectName?: string;
+    updatedAt: string;
+    unread: boolean;
+}
+export interface TaskMenuSnapshot {
+    ownerUserId: string;
+    source: 'local' | 'cloud';
+    tasks: TaskMenuEntry[];
+}
+export interface TaskMenuApi {
+    update(snapshot: TaskMenuSnapshot): Promise<void>;
+    onAction(listener: (action: TaskMenuAction) => void): () => void;
+}

package/dist/shared/task-operation.d.ts

@@ -0,0 +1,19 @@
+/** A reference to the existing execution owner, never another task or scheduler. */
+export interface TaskOperationReference {
+    id: string;
+    sessionId: string;
+    runId: string;
+    kind: 'process' | 'document' | 'model-media';
+    ownerId: string;
+    createdAt: string;
+}
+export interface TaskOperationSnapshot {
+    reference: TaskOperationReference;
+    status: 'running' | 'completed' | 'failed' | 'cancelled' | 'unknown';
+    canCancel: boolean;
+    observedAt: string;
+    /** Actual owner response. This can include expiring remote download URLs; it is not browser-safe HTML. */
+    result?: unknown;
+    /** Unknown is not success or cancellation; e.g. a process owner exited without a terminal record. */
+    reason?: string;
+}

package/dist/shared/task-path-policy.d.ts

@@ -0,0 +1,14 @@
+/** Explicit host grants. Omitted policy preserves existing desktop/CLI task behavior. */
+export interface TaskPathPolicy {
+    cwd?: string;
+    readRoots: string[];
+    writeRoots: string[];
+    /** Elevated requires a sandbox already provisioned by the machine administrator. */
+    windowsSandbox?: 'unelevated' | 'elevated';
+}
+export interface ResolvedTaskPathPolicy extends TaskPathPolicy {
+    cwd: string;
+    workspaceRoot: string;
+    stateRoot: string;
+}
+export declare function parseTaskPathPolicy(value: unknown): TaskPathPolicy;

package/dist/shared/task-resource-manifest.d.ts

@@ -0,0 +1,33 @@
+/** Auditable preparation metadata only. Never contains secrets, tokens, full
+ * service configuration, or controller-local filesystem paths. */
+export interface TaskResourceManifest {
+    schemaVersion: 1;
+    preparedAt: string;
+    configuration: {
+        mcpRevision: string;
+        modelRevision: string;
+    };
+    skills: Array<{
+        id: string;
+        source: string;
+        scope?: string;
+        version?: string;
+        revision?: string;
+        contentHash: string;
+        selected: boolean;
+        available: boolean;
+    }>;
+    plugins: Array<{
+        id: string;
+        runtimeId?: string;
+        version?: string;
+        definitionHash: string;
+    }>;
+    expert?: {
+        id: string;
+        versionId: string;
+        version: string;
+        packageHash?: string;
+        instructionsHash?: string;
+    };
+}

package/dist/shared/task-storage-recovery.d.ts

@@ -0,0 +1,33 @@
+import type { LocalTaskMessage } from './local-task-api.js';
+import type { StorageProblem } from './storage-integrity.js';
+export interface TaskStorageProblem {
+    file: string;
+    status: StorageProblem;
+    message: string;
+    offset?: number;
+    endOffset?: number;
+}
+export interface TaskStorageReport {
+    taskId: string;
+    status: 'healthy' | 'partial' | 'unrecoverable' | 'temporarily_unavailable';
+    checkedAt: string;
+    issues: TaskStorageProblem[];
+    issueCount: number;
+    messages: LocalTaskMessage[];
+    messagesSource?: 'checkpoint';
+    messagesLimited: boolean;
+    validMessageCount: number;
+    canRestore: boolean;
+    checkpointAt?: string;
+    checkpointBytes?: number;
+    fingerprint: string;
+    protectionIssue?: string;
+    /** Missing live external references do not invalidate the task journals. */
+    resourceIssues?: TaskStorageProblem[];
+}
+export interface TaskStorageRecoveryApi {
+    inspect: (taskId: string) => Promise<TaskStorageReport>;
+    restore: (taskId: string, fingerprint: string) => Promise<TaskStorageReport>;
+    cancel: (taskId: string) => Promise<void>;
+    createFromRecovered: (taskId: string, fingerprint: string) => Promise<import('./local-task-api.js').LocalTask>;
+}

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

@@ -0,0 +1,48 @@
+export interface TaskTerminalTarget {
+    taskId: string;
+    tabId: string;
+}
+export interface TaskTerminalSize {
+    cols: number;
+    rows: number;
+}
+export type TaskTerminalEvent = TaskTerminalTarget & {
+    sequence: number;
+} & ({
+    type: 'output';
+    dataBase64: string;
+} | {
+    type: 'exit';
+    exitCode: number;
+} | {
+    type: 'error';
+    message: string;
+});
+export interface TaskTerminalSnapshot {
+    cwd: string;
+    events: TaskTerminalEvent[];
+    running: boolean;
+}
+export type TaskTerminalStateUpdate = {
+    status: 'connected';
+    snapshot: TaskTerminalSnapshot;
+} | {
+    status: 'disconnected' | 'error';
+    message: string;
+};
+export type TaskTerminalState = TaskTerminalTarget & TaskTerminalStateUpdate;
+export interface TaskTerminalApi {
+    open(request: TaskTerminalTarget & {
+        worktreeId?: string;
+        size: TaskTerminalSize;
+    }): Promise<TaskTerminalSnapshot>;
+    write(request: TaskTerminalTarget & {
+        data: string;
+    }): Promise<void>;
+    resize(request: TaskTerminalTarget & {
+        size: TaskTerminalSize;
+    }): Promise<void>;
+    close(request: TaskTerminalTarget): Promise<void>;
+    onEvent(listener: (event: TaskTerminalEvent) => void): () => void;
+    onState(listener: (state: TaskTerminalState) => void): () => void;
+}

package/dist/shared/team-control.d.ts

@@ -0,0 +1,60 @@
+export interface TeamMemberState {
+    memberRunId: string;
+    memberId: string;
+    threadId: string;
+    status: string;
+    displayName: string;
+    finalText?: string;
+    error?: string;
+    createdAt: string;
+    completedAt?: string;
+    closedAt?: string;
+}
+export interface TeamTaskState {
+    workflowTaskId: string;
+    teamRunId: string;
+    subject: string;
+    description: string;
+    ownerMemberId: string;
+    blockedBy: string[];
+    status: string;
+    revision: number;
+}
+export interface TeamState {
+    teamRunId: string;
+    taskSnapshotHash: string;
+    status: string;
+    ownerAvailable: boolean;
+    members: TeamMemberState[];
+    tasks: TeamTaskState[];
+}
+export type TeamCommand = {
+    action: 'task.create';
+    subject: string;
+    description: string;
+    ownerMemberId: string;
+    blockedBy?: string[];
+} | {
+    action: 'task.update';
+    taskId: string;
+    expectedRevision: number;
+    status: 'pending' | 'in_progress' | 'completed' | 'failed' | 'cancelled';
+} | {
+    action: 'delegate' | 'followUp';
+    memberId: string;
+    taskId: string;
+    message: string;
+} | {
+    action: 'wait';
+    memberIds: string[];
+} | {
+    action: 'stop' | 'close';
+    memberId: string;
+};
+export interface TeamCommandResult {
+    success: boolean;
+    contentItems: Array<{
+        type: string;
+        text: string;
+    }>;
+}

package/dist/shared/tool-activity.d.ts

@@ -0,0 +1,18 @@
+type RecordValue = Record<string, unknown>;
+export type ToolActivityCategory = 'file' | 'browser' | 'command' | 'mcp';
+export interface ToolActivityTitle {
+    title: string;
+    category?: ToolActivityCategory;
+}
+export interface ToolDisplayIdentity {
+    provider?: string;
+    operation?: string;
+    external?: boolean;
+}
+export declare function activityRecord(value: unknown): RecordValue;
+/** Strip URL credentials, queries and fragments before shortening; never display script/body contents. */
+export declare function safeActivityText(value: string): string;
+/** Exact known namespaces only. A third-party tool called read_file is not our file tool. */
+export declare function activityToolName(payload: RecordValue): string;
+export declare function toolActivityTitle(payload: RecordValue, language?: 'zh-CN' | 'en-US', identity?: ToolDisplayIdentity, protect?: (value: string) => string): ToolActivityTitle | undefined;
+export {};

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

@@ -0,0 +1,65 @@
+export type ClientReleasePlatform = 'WINDOWS' | 'MACOS_INTEL' | 'MACOS_APPLE_SILICON' | 'LINUX_X64' | 'LINUX_ARM64';
+export type ClientReleaseChannel = 'STABLE' | 'BETA' | 'CANARY';
+export type ClientUpdateReason = 'NO_RELEASE' | 'UP_TO_DATE' | 'UPDATE_AVAILABLE' | 'DOWNGRADE_AVAILABLE' | 'ROLLOUT_HOLD' | 'RELEASE_NOT_READY';
+export interface ClientUpdateCheckRequest {
+    platform: ClientReleasePlatform;
+    architecture: string;
+    currentVersion: string;
+    currentBuildNumber: number;
+    osVersion: string;
+    channel: ClientReleaseChannel;
+    installationId: string;
+}
+export interface ClientUpdateRelease {
+    platform: ClientReleasePlatform;
+    version: string;
+    buildNumber: number;
+    channel: ClientReleaseChannel;
+    releaseNotes?: string | null;
+    minimumOsVersion?: string | null;
+    publishedAt?: string | null;
+    activatedAt?: string | null;
+}
+export interface ClientUpdatePackage {
+    type: 'FULL' | 'DELTA';
+    fromBuildNumber?: number | null;
+    downloadUrl: string;
+    fileSizeBytes: number;
+    checksumSha256: string;
+    signature: string;
+    signatureAlgorithm: string;
+}
+export interface ClientUpdateCheckResult {
+    updateAvailable: boolean;
+    required: boolean;
+    downgrade: boolean;
+    reason: ClientUpdateReason;
+    checkAfterSeconds: number;
+    release?: ClientUpdateRelease | null;
+    updatePackage?: ClientUpdatePackage | null;
+}
+export type DesktopUpdateStatus = 'idle' | 'checking' | 'up-to-date' | 'available' | 'downloading' | 'downloaded' | 'installing' | 'error';
+export interface DesktopUpdateState {
+    status: DesktopUpdateStatus;
+    currentVersion: string;
+    currentBuildNumber: number;
+    canInstallAutomatically: boolean;
+    osSupported?: boolean;
+    osCompatibilityMessage?: string;
+    checkedAt?: string;
+    result?: ClientUpdateCheckResult;
+    progressPercent?: number;
+    bytesDownloaded?: number;
+    totalBytes?: number;
+    deferredUntil?: string;
+    error?: string;
+}
+export interface DesktopUpdatesApi {
+    getState: () => Promise<DesktopUpdateState>;
+    check: () => Promise<DesktopUpdateState>;
+    download: () => Promise<DesktopUpdateState>;
+    install: () => Promise<void>;
+    defer: () => Promise<DesktopUpdateState>;
+    openDownloadPage: () => Promise<void>;
+    onStateChanged: (listener: (state: DesktopUpdateState) => void) => () => void;
+}

package/dist/shared/usage-statistics-api.d.ts

@@ -0,0 +1,18 @@
+export interface UsageStatisticsDay {
+    date: string;
+    callCount: number;
+    totalTokens: number;
+}
+export interface UsageStatisticsModelDay extends UsageStatisticsDay {
+    modelName: string | null;
+}
+export interface PersonalUsageStatistics {
+    totalTokens: number;
+    days: UsageStatisticsDay[];
+    modelDays: UsageStatisticsModelDay[];
+}
+export interface UsageStatisticsApi {
+    getStatistics: (query: {
+        endDate: string;
+    }) => Promise<PersonalUsageStatistics>;
+}

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

@@ -0,0 +1,188 @@
+import type { GitCheckout, GitFailure, GitResult, GitTarget, RepositoryCommand } from './git-api.js';
+import type { LocalTask } from './local-task-api.js';
+import type { LocalEnvironmentFile } from './local-environment-api.js';
+export interface WorktreeSettings {
+    rootDirectory: string;
+    fetchBeforeCreate: boolean;
+    automaticCleanup?: boolean;
+    retainedCount?: number;
+}
+export declare const DEFAULT_WORKTREE_SETTINGS: WorktreeSettings;
+export interface WorktreeScript {
+    common: string;
+    darwin?: string;
+    linux?: string;
+    win32?: string;
+}
+export interface WorktreeEnvironment {
+    version: 1;
+    id: string;
+    repositoryId: string;
+    ownerUserId: string;
+    name: string;
+    setup: WorktreeScript;
+    cleanup?: WorktreeScript;
+    actions?: Array<{
+        id: string;
+        name: string;
+        script: WorktreeScript;
+        platform?: 'darwin' | 'linux' | 'win32';
+    }>;
+}
+export interface SaveWorktreeEnvironmentRequest {
+    taskId: string;
+    checkoutId: string;
+    id?: string;
+    name: string;
+    setup: WorktreeScript;
+    cleanup?: WorktreeScript;
+    actions?: WorktreeEnvironment['actions'];
+}
+export interface WorktreeAssociation {
+    taskId: string;
+    kind: 'default' | 'attachment';
+}
+export interface ManagedWorktree {
+    version: 1;
+    id: string;
+    ownerUserId: string;
+    projectId?: string;
+    repositoryId: string;
+    sourcePath: string;
+    commonGitDir: string;
+    path: string;
+    name: string;
+    head: string;
+    createdAt: string;
+    operationId: string;
+    state: 'ready' | 'initialization-failed' | 'archived';
+    associations: WorktreeAssociation[];
+    environmentId?: string;
+    retained?: boolean;
+    snapshot?: WorktreeSnapshot;
+    projectRelativePath?: string;
+    sourceWorkspacePath?: string;
+    localWorkspaceId?: string;
+}
+export interface WorktreeListItem extends ManagedWorktree {
+    available: boolean;
+    revision?: string;
+    tasks: Array<{
+        id: string;
+        name: string;
+        status: LocalTask['status'];
+        kind: WorktreeAssociation['kind'];
+    }>;
+}
+export interface CreateWorktreeRequest extends GitTarget {
+    requestId: string;
+    expectedRevision: string;
+    ref?: string;
+    remote?: string;
+    name?: string;
+    basis?: 'ref' | 'working-state';
+    environmentId?: string;
+    includeIgnored?: string[];
+    credentialId?: string;
+}
+export type WorktreePhase = 'awaiting-authorization' | 'preparing' | 'fetching' | 'creating' | 'copying' | 'initializing' | 'registering' | 'completed' | 'failed' | 'cancelled' | 'interrupted';
+export type WorktreeCommand = RepositoryCommand;
+export interface WorktreeOperation {
+    version: 1;
+    id: string;
+    worktreeId: string;
+    taskId: string;
+    ownerUserId: string;
+    projectId?: string;
+    request: CreateWorktreeRequest;
+    source: GitCheckout;
+    sourceRef: string;
+    head: string;
+    path: string;
+    name: string;
+    phase: WorktreePhase;
+    completedSteps: string[];
+    createdAt: string;
+    updatedAt: string;
+    commands: WorktreeCommand[];
+    fetchRemote?: string;
+    environment?: WorktreeEnvironment;
+    registered: boolean;
+    directoryCreated: boolean;
+    defaultCwdChanged: false;
+    error?: GitFailure;
+    projectRelativePath?: string;
+    sourceWorkspacePath?: string;
+    localEnvironment?: LocalEnvironmentFile;
+}
+export interface WorktreeSnapshot {
+    commit: string;
+    tree: string;
+    parent: string;
+    ref: string;
+    createdAt: string;
+    includedIgnored: string[];
+}
+export interface WorktreeLifecycleRequest {
+    taskId?: string;
+    worktreeId: string;
+    requestId: string;
+    action: 'archive' | 'restore' | 'environment-action';
+    expectedRevision?: string;
+    includeIgnored?: string[];
+    actionId?: string;
+    confirmed?: boolean;
+}
+export interface WorktreeLifecycleOperation {
+    version: 1;
+    id: string;
+    ownerUserId: string;
+    request: WorktreeLifecycleRequest;
+    worktree: ManagedWorktree;
+    phase: 'awaiting-authorization' | 'snapshotting' | 'removing' | 'restoring' | 'initializing' | 'completed' | 'failed' | 'interrupted';
+    commands: RepositoryCommand[];
+    filePaths: string[];
+    completedSteps: string[];
+    createdAt: string;
+    updatedAt: string;
+    snapshot?: WorktreeSnapshot;
+    error?: GitFailure;
+    automaticCleanup?: boolean;
+}
+export interface WorktreeApi {
+    list(taskId?: string): Promise<GitResult<WorktreeListItem[]>>;
+    status(request: {
+        taskId: string;
+        operationId: string;
+    }): Promise<GitResult<WorktreeOperation>>;
+    cancel(request: {
+        taskId: string;
+        operationId: string;
+    }): Promise<GitResult<WorktreeOperation>>;
+    newTask(request: {
+        taskId?: string;
+        worktreeId: string;
+        name?: string;
+    }): Promise<GitResult<LocalTask>>;
+    listEnvironments(target: GitTarget): Promise<GitResult<WorktreeEnvironment[]>>;
+    saveEnvironment(request: SaveWorktreeEnvironmentRequest): Promise<GitResult<WorktreeEnvironment>>;
+    removeEnvironment(request: {
+        taskId: string;
+        checkoutId: string;
+        id: string;
+    }): Promise<GitResult<void>>;
+    prepareLifecycle(request: WorktreeLifecycleRequest): Promise<GitResult<WorktreeLifecycleOperation>>;
+    executeLifecycle(request: {
+        taskId?: string;
+        operationId: string;
+    }): Promise<GitResult<WorktreeLifecycleOperation>>;
+    lifecycleStatus(request: {
+        taskId?: string;
+        operationId: string;
+    }): Promise<GitResult<WorktreeLifecycleOperation>>;
+    retain(request: {
+        taskId?: string;
+        worktreeId: string;
+        retained: boolean;
+    }): Promise<GitResult<void>>;
+}