@kmlckj/aios-agent-server-sdk 0.0.1 → 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

@@ -1,15 +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 { 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';
-import type { CloudTaskEventApi } from './cloud-task-event-api.js';
 export interface CollaborationDesktopApi {
     projects: CollaborationProjectApi;
     plan: CollaborationPlanApi;
     tasks: CloudTaskApi;
-    taskEvents: CloudTaskEventApi;
+    taskConversations: CloudTaskRuntimeApi;
+    conversationEvents: TaskConversationEventApi;
     resources: CollaborationResourceApi;
     automations: CollaborationAutomationApi;
     events: CollaborationEventApi;

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

@@ -7,9 +7,6 @@ export type CollaborationDeepLink = {
 } | {
     kind: 'task_share';
     token: string;
-} | {
-    kind: 'task_transfer';
-    transferId: string;
 } | {
     kind: 'plan_item';
     projectId: string;

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

@@ -1,8 +1,7 @@
 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 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;
@@ -51,27 +50,6 @@ export interface CloudTask {
     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;
@@ -226,23 +204,6 @@ export interface CloudTaskEventPage {
     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?: {
@@ -256,65 +217,17 @@ export interface CloudTaskApi {
         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;
@@ -330,7 +243,6 @@ export interface CloudTaskApi {
     }): 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>>;
@@ -338,7 +250,6 @@ export interface CloudTaskApi {
     shares: TaskShareApi;
     invitations: TaskInvitationApi;
     collaborators: TaskCollaboratorApi;
-    transfers: TaskTransferApi;
 }
 export interface TaskShareApi {
     list(taskId: string): Promise<Array<Record<string, unknown>>>;
@@ -362,11 +273,4 @@ export interface TaskCollaboratorApi {
     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/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/desktop-api.d.ts

@@ -351,6 +351,7 @@ export interface DesktopApi {
     navigation: NavigationApi;
     taskMenu: TaskMenuApi;
     app: {
+        connectTaskExecution: (actor: string, pairingId: string) => Promise<void>;
         getConfig: () => Promise<DesktopRuntimeConfig>;
         getVersion: () => Promise<string>;
         getAboutInfo: () => Promise<DesktopAboutInfo>;

package/dist/shared/execution-context.d.ts

@@ -29,6 +29,31 @@ export interface ExecutionBinding {
     runId: string;
     context?: ExecutionContext;
 }
+/** A supplemental message has its own correlation IDs but must retain the active execution scope. */
+export declare function executionSteeringScope(context?: ExecutionContext): {
+    actor: {
+        userId: string;
+        tenantId: string | null;
+        name?: string;
+    };
+    owner: {
+        userId: string;
+        tenantId: string | null;
+        name?: string;
+    };
+    workspaceId: string | null;
+    projectId?: string;
+    collaborationProjectId?: string;
+    assistantId?: string;
+    platformSessionId?: string;
+    platformTurnId?: string;
+    platformTaskId?: string;
+    platformRunId?: string;
+    traceId?: string;
+    /** Host-owned business data; never used as identity or routing headers. */
+    metadata?: Record<string, Record<string, string | number | boolean | null>>;
+    usageScene: "personal" | "greeting" | "task" | "collaboration" | "coding";
+} | null;
 export declare function parseExecutionContext(value: unknown): ExecutionContext;
 export declare function parseExecutionBinding(value: unknown): ExecutionBinding;
 export declare function executionRoutingIdentity(context: ExecutionContext): ModelRoutingIdentity;

package/dist/shared/expert-selection.d.ts

@@ -0,0 +1,22 @@
+import type { AgentTeamDefinition } from './agent-team.js';
+import type { LocalTaskProfessionReference } from './local-task-api.js';
+/** Only an immutable platform version is selected; executable content is resolved by the host. */
+export interface ExpertSelection {
+    professionId: string;
+    versionId: string;
+}
+/** A business host must authorize this source before supplying it. It is never model input. */
+export interface ResolvedExpertSource extends ExpertSelection {
+    versionNo: string;
+    professionForm: 'EXPERT' | 'EXPERT_TEAM';
+    name: string;
+    summary: string;
+    iconUrl?: string | null;
+    instructions?: string;
+    packageRef?: string;
+}
+export interface PreparedExpertAgent {
+    profession: LocalTaskProfessionReference;
+    instructions: string;
+    team?: AgentTeamDefinition;
+}

package/dist/shared/local-task-command.d.ts

@@ -27,6 +27,7 @@ export type LocalTaskCommand = Header<'send' | 'enqueue', {
 }> | Header<'plan_start', {
     runId: string;
     targetRunId: string | null;
+    planRunId?: string;
 }> | Header<'compact', {
     runId: string;
     historyVersion: string;
@@ -85,6 +86,7 @@ export interface LocalTaskCommandRecord {
 }
 export interface LocalTaskCommandTargets {
     activeRunId: string | null;
+    planRunId?: string | null;
     queueVersion: string;
     historyVersion: string;
 }

package/dist/shared/managed-authorization.d.ts

@@ -43,6 +43,8 @@ export interface ManagedAuthorizationConnection extends CredentialConnection {
     platformBaseUrl: string;
     principal: ManagedPrincipal;
     allowedOrigins: string[];
+    /** Resolved from authenticated platform model details, keyed by model code. */
+    configuredModelOrigins?: Record<string, string[]>;
 }
 export interface AuthorizedPlatformContext {
     accessToken: string;

package/dist/shared/profession-market-api.d.ts

@@ -91,6 +91,6 @@ export interface ProfessionMarketApi {
     search: (query: ProfessionMarketSearchQuery) => Promise<ProfessionMarketSearchResult>;
     getDetail: (professionId: string) => Promise<ProfessionMarketDetail>;
     listInstalled: (query: ListInstalledProfessionsQuery) => Promise<InstalledProfessionResult>;
-    prepareForLocalTask: (professionId: string) => Promise<import('./local-task-api.js').LocalTaskProfessionReference>;
+    prepareForLocalTask: (professionId: string, versionId?: string) => Promise<import('./local-task-api.js').LocalTaskProfessionReference>;
     recordUsage: (professionId: string) => Promise<void>;
 }

package/dist/shared/sdk-session-contract.d.ts

@@ -0,0 +1,96 @@
+/** SDK schema version 1, shared by SDK clients and conversation renderers. No host runtime imports. */
+export interface TaskEvent {
+    schemaVersion: 1;
+    /** Save after processing this event to resume without skipping the rest of its page. */
+    cursor: string;
+    sessionId: string;
+    id: string;
+    type: import('./local-task-api.js').LocalTaskEventType;
+    runId: string;
+    /** Sequence within this cursor stream; use the event ID for deduplication. */
+    sequence: number;
+    runtimeSequence?: number;
+    /** Original engine event kind; payload retains its full structured fields. */
+    runtimeType?: string;
+    threadId?: string;
+    turnId?: string;
+    itemId?: string;
+    requestId?: string;
+    rootThreadId?: string;
+    sourceThreadId?: string;
+    parentThreadId?: string;
+    /** Host-supplied business ownership; separate from local task/member/thread identifiers. */
+    context?: import('./execution-context.js').ExecutionContext;
+    payload: Record<string, unknown>;
+    createdAt?: string;
+}
+/** Includes session-level events without a run and late updates after a run completes. */
+export type SessionEvent = Omit<TaskEvent, 'runId'> & {
+    runId?: string;
+};
+export interface SessionEventPage {
+    events: SessionEvent[];
+    cursor: string;
+}
+export interface EventObservationOptions {
+    cursor?: string;
+    signal?: AbortSignal;
+}
+export interface TaskInteraction {
+    id: string;
+    taskId?: string;
+    itemId?: string;
+    createdAt?: string;
+    updatedAt?: string;
+    kind: string;
+    requestId: string;
+    runId: string;
+    status: string;
+    payload: Record<string, unknown>;
+}
+/** Same history contract consumed by the desktop renderer, including references, reasoning and usage. */
+export type TaskMessage = import('./local-task-api.js').LocalTaskMessage;
+export interface HistoryQuery {
+    text?: string;
+    around?: string;
+    cursor?: string;
+    limit?: number;
+}
+export interface HistoryPage {
+    items: TaskMessage[];
+    historyVersion: string;
+    hasMore: boolean;
+    nextCursor?: string;
+}
+export interface RunQuery {
+    cursor?: string;
+    limit?: number;
+}
+export interface RunRecord {
+    runId: string;
+    status: RunState['status'];
+    messageCount: number;
+    /** Journal timestamps; these do not claim the time a model request began. */
+    firstMessageAt?: string;
+    queuedAt?: string;
+    finishedAt?: string;
+    context?: import('./execution-context.js').ExecutionContext;
+}
+export interface RunPage {
+    items: RunRecord[];
+    revision: string;
+    hasMore: boolean;
+    nextCursor?: string;
+}
+export interface RunState {
+    status: 'queued' | 'running' | 'waiting' | 'completed' | 'failed' | 'cancelled' | 'interrupted';
+    runId: string;
+    interactions: TaskInteraction[];
+    messages: TaskMessage[];
+}
+export interface QueueSnapshot {
+    messages: import('./local-task-api.js').LocalTaskPendingMessage[];
+    queueVersion: string;
+    activeRunId: string | null;
+    historyVersion: string;
+}