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

package/dist/shared/document-session-api.d.ts

@@ -0,0 +1,91 @@
+/** Editor state is distinct from the last saved disk revision. */
+export interface DocumentEditorVersion {
+    documentId: string;
+    diskRevision: string;
+    editorRevision: number;
+}
+export type DocumentSelectionLocator = {
+    kind: 'text';
+    start: number;
+    end: number;
+    format?: 'markdown' | 'html';
+    element?: string;
+    htmlTextRanges?: Array<{
+        start: number;
+        end: number;
+    }>;
+} | {
+    kind: 'word';
+    targetJson: string;
+} | {
+    kind: 'word-table';
+    table: number;
+    nodeId: string;
+    row: [number, number];
+    column: [number, number];
+} | {
+    kind: 'word-image';
+    part: string;
+    imageId: string;
+} | {
+    kind: 'sheet-image';
+    sheetId: string;
+    sheetName: string;
+    imageId: string;
+    imageIndex: number;
+} | {
+    kind: 'cells';
+    sheetId: string;
+    sheetName: string;
+    row: [number, number];
+    column: [number, number];
+} | {
+    kind: 'slide-elements';
+    slideIndex: number;
+    elementIds: string[];
+} | {
+    kind: 'image-region';
+    imageWidth: number;
+    imageHeight: number;
+    rect: DocumentRectangle;
+};
+export interface DocumentRectangle {
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+}
+export interface DocumentSelection extends DocumentEditorVersion {
+    fileName: string;
+    locator: DocumentSelectionLocator;
+    text: string;
+}
+/** A snapshot replacement is an explicit whole editor transaction, not a text conversion. */
+export type DocumentEdit = {
+    kind: 'replace-snapshot';
+    data: Uint8Array;
+} | {
+    kind: 'replace-text';
+    selection: DocumentSelection;
+    text: string;
+} | {
+    kind: 'set-cells';
+    selection: DocumentSelection;
+    values: Array<Array<string | number | boolean | null>>;
+} | {
+    kind: 'update-slide-text';
+    selection: DocumentSelection;
+    elementId: string;
+    text: string;
+};
+export interface DocumentEditorController {
+    getVersion(): DocumentEditorVersion;
+    getSelection(): DocumentSelection | null;
+    /** Present only for editors that expose reference navigation. */
+    readonly locateSelection?: (selection: DocumentSelection) => void;
+    exportSnapshot(): Promise<Uint8Array>;
+    applyEdit(edit: DocumentEdit, expectedEditorRevision: number): Promise<void>;
+    save(): Promise<void>;
+    undo(): Promise<void>;
+    redo(): Promise<void>;
+}

package/dist/shared/enterprise-knowledge-api.d.ts

@@ -0,0 +1,103 @@
+export type EnterpriseKnowledgeType = 'STANDARD' | 'GRAPH' | 'OBJECT_STORAGE';
+export type EnterpriseKnowledgeNodeType = 'ROOT' | 'ORGANIZATION' | 'FOLDER' | 'KNOWLEDGE_BASE' | 'GRAPH' | 'OBJECT_STORAGE';
+export interface EnterpriseKnowledgeCapabilities {
+    retrieve: boolean;
+    upload: boolean;
+    listFiles: boolean;
+    batchDeleteFiles: boolean;
+}
+export interface EnterpriseKnowledgeBase {
+    id: string;
+    sourceId: string | null;
+    name: string;
+    description: string;
+    knowledgeType: EnterpriseKnowledgeType;
+    status: string | null;
+    capabilities: EnterpriseKnowledgeCapabilities;
+}
+export interface EnterpriseKnowledgeTreeNode {
+    id: string;
+    parentId: string | null;
+    nodeType: EnterpriseKnowledgeNodeType;
+    name: string;
+    protected: boolean;
+    deletable: boolean;
+    knowledgeBase: EnterpriseKnowledgeBase | null;
+    children: EnterpriseKnowledgeTreeNode[];
+}
+export interface EnterpriseKnowledgeTreeResult {
+    tenantId: string | null;
+    permissionScope: string | null;
+    nodes: EnterpriseKnowledgeTreeNode[];
+}
+export interface EnterpriseKnowledgeSearchQuery {
+    keyword?: string;
+    page?: number;
+    pageSize?: number;
+}
+export interface EnterpriseKnowledgeSearchResult {
+    items: EnterpriseKnowledgeBase[];
+    page: number;
+    pageSize: number;
+    total: number;
+}
+export interface EnterpriseKnowledgeDocument {
+    id: string;
+    name: string;
+    status: string | null;
+    fileType: string | null;
+    sizeBytes: number | null;
+    createdByName: string | null;
+    createdAt: string | null;
+    updatedAt: string | null;
+    canPreview: boolean;
+    canDownload: boolean;
+}
+export interface EnterpriseKnowledgeDocumentPreviewRequest {
+    documentId: string;
+    fileName: string;
+    page?: number;
+}
+export interface EnterpriseKnowledgeDocumentPreviewResult {
+    name: string;
+    mediaType: string | null;
+    sizeBytes: number;
+    dataUrl: string;
+    page: number;
+    pageCount: number;
+    canDownload: boolean;
+}
+export interface EnterpriseKnowledgeDocumentDownloadLink {
+    documentId: string;
+    downloadUrl: string;
+}
+export interface EnterpriseKnowledgeAttachment {
+    id: string;
+    documentId: string;
+    knowledgeBaseId: string;
+    name: string;
+    mimeType: string;
+    sizeBytes: number;
+    url: string;
+}
+export interface EnterpriseKnowledgeDocumentQuery {
+    sourceId: string;
+    keyword?: string;
+    page?: number;
+    pageSize?: number;
+}
+export interface EnterpriseKnowledgeDocumentResult {
+    items: EnterpriseKnowledgeDocument[];
+    page: number;
+    pageSize: number;
+    total: number;
+    hasPrevious: boolean;
+    hasNext: boolean;
+}
+export interface EnterpriseKnowledgeApi {
+    tree(): Promise<EnterpriseKnowledgeTreeResult>;
+    search(query?: EnterpriseKnowledgeSearchQuery): Promise<EnterpriseKnowledgeSearchResult>;
+    listDocuments(query: EnterpriseKnowledgeDocumentQuery): Promise<EnterpriseKnowledgeDocumentResult>;
+    readDocument(request: EnterpriseKnowledgeDocumentPreviewRequest): Promise<EnterpriseKnowledgeDocumentPreviewResult>;
+    getDocumentDownloadLink(documentId: string): Promise<EnterpriseKnowledgeDocumentDownloadLink>;
+}

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

@@ -0,0 +1,26 @@
+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;
+}
+export interface EnterpriseProjectSearchRequest {
+    userId: string;
+    tenantId: string;
+    keyword: string;
+    page: number;
+}
+export declare function enterpriseProjectKey(resource: EnterpriseProjectResource): string;

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

@@ -0,0 +1,3 @@
+import type { LocalTaskExecutionState } from './local-task-api.js';
+export type OwnedRuntimeActivity = Pick<LocalTaskExecutionState, 'taskId' | 'running' | 'pendingInteractionCount' | 'activity'>;
+export declare function readExecutionActivity(value: unknown): NonNullable<LocalTaskExecutionState['activity']>;

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

@@ -0,0 +1,37 @@
+import { type ModelRoutingIdentity } from './model-routing.js';
+/** Supplied only by the authenticated application host, never by tool arguments. */
+export interface 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';
+}
+export interface ExecutionBinding {
+    sessionId: string;
+    runId: string;
+    context?: ExecutionContext;
+}
+export declare function parseExecutionContext(value: unknown): ExecutionContext;
+export declare function parseExecutionBinding(value: unknown): ExecutionBinding;
+export declare function executionRoutingIdentity(context: ExecutionContext): ModelRoutingIdentity;
+export declare function executionContextHeaders(binding: ExecutionBinding): Record<string, string>;
+export declare function executionBindingHeaders(binding?: ExecutionBinding): Record<string, string>;
+export declare function decodeExecutionBinding(value: string | undefined): ExecutionBinding | undefined;

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

@@ -0,0 +1,7 @@
+/** Local application identity is not a platform user or tenant. */
+export interface StandaloneExecutionIdentity {
+    mode: 'standalone';
+    appId: string;
+    userScope: string;
+}
+export declare function validateStandaloneIdentity(value: StandaloneExecutionIdentity): StandaloneExecutionIdentity;

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

@@ -0,0 +1,6 @@
+/** Describes the execution host, not the user's authorization or model permissions. */
+export interface ExecutionProfile {
+    host: 'desktop' | 'server';
+    role: 'personal' | 'task' | 'coding';
+}
+export declare function parseExecutionProfile(value: unknown): ExecutionProfile;

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

@@ -0,0 +1,71 @@
+/** Execution location is independent of workspace kind and worktree environments. */
+export type ExecutionTargetKind = 'local' | 'ssh' | 'docker' | 'wsl';
+export type RemoteExecutionTargetKind = Exclude<ExecutionTargetKind, 'local'>;
+export type ExecutionTargetPlatform = 'darwin' | 'linux' | 'win32';
+export interface OwnerPrincipal {
+    platformUrl: string;
+    userId: string;
+}
+export interface ExecutionTargetIdentity {
+    executionTargetId: string;
+    dataRootId: string;
+}
+export interface TaskRef extends ExecutionTargetIdentity {
+    kind: ExecutionTargetKind;
+    owner: OwnerPrincipal;
+    taskId: string;
+}
+export interface WorkspaceRef extends ExecutionTargetIdentity {
+    kind: ExecutionTargetKind;
+    owner: OwnerPrincipal;
+    workspaceId: string;
+    /** Resolved by the target, never by the controlling machine's path/fs APIs. */
+    canonicalPath: string;
+    name: string;
+}
+export interface MemberRef {
+    task: TaskRef;
+    runId: string;
+    sourceThreadId: string;
+    teamRunId?: string;
+    memberRunId?: string;
+}
+export interface TargetFileRef {
+    task: TaskRef;
+    fileId: string;
+    contentVersion: string;
+    name: string;
+}
+export interface TargetArtifactRef {
+    task: TaskRef;
+    artifactId: string;
+    file: TargetFileRef;
+    runId?: string;
+    memberRunId?: string;
+}
+/** This is a verified session reference, not credentials or proof supplied by a caller. */
+export interface TargetAuthBinding {
+    id: string;
+    owner: OwnerPrincipal;
+    tenantId: string;
+    personalMode: boolean;
+    contextVersion: number;
+    sessionId: string;
+    clientAuthGeneration: number;
+    expiresAt: string;
+}
+export type ExecutionTargetErrorCode = 'INVALID_TARGET_REFERENCE' | 'TARGET_MISMATCH' | 'OWNER_MISMATCH' | 'TASK_SCOPE_UNSUPPORTED' | 'TARGET_UNAVAILABLE' | 'STALE_BINDING' | 'PROTOCOL_ERROR' | 'PROTOCOL_MISMATCH' | 'METHOD_UNAVAILABLE' | 'HANDSHAKE_REQUIRED' | 'AUTH_REQUIRED' | 'INPUT_TOO_LARGE' | 'CONNECTION_CLOSED' | 'QUERY_CANCELLED';
+export declare class ExecutionTargetError extends Error {
+    readonly code: ExecutionTargetErrorCode;
+    readonly cause?: unknown;
+    constructor(code: ExecutionTargetErrorCode, message: string, options?: {
+        cause?: unknown;
+    });
+}
+export declare function canonicalPlatformUrl(value: string): string;
+export declare function principalKey(owner: OwnerPrincipal): string;
+export declare function targetKey(target: ExecutionTargetIdentity): string;
+export declare function taskRefKey(ref: TaskRef): string;
+export declare function workspaceRefKey(ref: WorkspaceRef): string;
+export declare function assertTargetIdentity(expected: ExecutionTargetIdentity, actual: ExecutionTargetIdentity): void;
+export declare function assertOwnerPrincipal(expected: OwnerPrincipal, actual: OwnerPrincipal): void;

package/dist/shared/expert-team-api.d.ts

@@ -0,0 +1,54 @@
+import type { LocalTaskExpertTeamMemberReference } from './local-task-api.js';
+export interface ExpertTeamAgentSnapshot extends LocalTaskExpertTeamMemberReference {
+    sdk?: Pick<import('./agent-team.js').AgentTeamMember, 'model' | 'reasoningEffort' | 'tools' | 'paths'>;
+    runtimeRole: string;
+    description: string;
+    instructions: string;
+    maxTurns: number | null;
+    skills: string[];
+    capabilities: string[];
+}
+export type ExpertTeamWritePolicy = 'leader_only' | 'team_shared_workspace';
+export interface ExpertTeamRunSnapshot {
+    schemaVersion: 1;
+    packageFormat: 'aios-expert-team';
+    packageId: string;
+    packageVersion: string;
+    packageHash: string;
+    snapshotHash: string;
+    displayName: string;
+    description: string;
+    teamAvatarRelativePath: string;
+    leader: ExpertTeamAgentSnapshot;
+    members: ExpertTeamAgentSnapshot[];
+    workflow: string;
+    writePolicy: ExpertTeamWritePolicy;
+}
+/**
+ * 首次执行前由 Electron 主进程锁定的任务级专家团快照。
+ * Renderer 不能创建或修改此对象；后续消息、重试和恢复必须复用同一份快照。
+ */
+export interface TeamExecutionSnapshot {
+    schemaVersion: 1;
+    teamRunId: string;
+    taskId: string;
+    selectionLockedAt: string;
+    package: ExpertTeamRunSnapshot;
+    taskSnapshotHash: string;
+    source?: {
+        kind: 'application';
+        agentId: string;
+        agentVersion: string;
+    };
+}
+export interface ExpertTeamTaskSnapshot extends TeamExecutionSnapshot {
+    professionId: string;
+    professionVersionId: string;
+    professionVersionNo: string;
+}
+export interface PrepareExpertTeamPackageRequest {
+    professionId: string;
+    versionId: string;
+    versionNo: string;
+    packageRef: string;
+}

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

@@ -0,0 +1,20 @@
+export interface DesktopFeedbackFileAttachment {
+    name: string;
+    mediaType: string;
+    sizeBytes: number;
+    sourcePath?: string;
+    data?: ArrayBuffer;
+}
+export interface SubmitDesktopFeedbackRequest {
+    description: string;
+    attachments: DesktopFeedbackFileAttachment[];
+    includeDiagnostics: boolean;
+}
+export interface DesktopFeedbackSubmission {
+    id: string;
+    status: 'PENDING' | 'PROCESSED';
+    createdAt: string;
+}
+export interface DesktopFeedbackApi {
+    submit(request: SubmitDesktopFeedbackRequest): Promise<DesktopFeedbackSubmission>;
+}

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

@@ -0,0 +1,227 @@
+/** A checkout is an authorized directory, not a task's execution directory. */
+export interface GitCheckout {
+    id: string;
+    repositoryId: string;
+    root: string;
+    scopePath: string;
+    commonGitDir: string;
+    name: string;
+    worktreeId?: string;
+}
+export interface GitTarget {
+    taskId: string;
+    checkoutId: string;
+}
+export interface GitFileStatus {
+    path: string;
+    originalPath?: string;
+    index: string;
+    workingTree: string;
+    untracked: boolean;
+    conflicted: boolean;
+}
+export interface GitStatus {
+    checkout: GitCheckout;
+    revision: string;
+    head: string | null;
+    branch: string | null;
+    upstream?: string;
+    ahead: number;
+    behind: number;
+    files: GitFileStatus[];
+    branches: string[];
+    refs: string[];
+    remotes: string[];
+    turnDiffRevision?: string;
+}
+export type GitDiffScope = 'last-turn' | 'uncommitted' | 'unstaged' | 'staged' | 'branch' | 'commit';
+export interface GitTurnDiffSnapshot {
+    runId: string;
+    revision: string;
+    workspacePath: string;
+    patch?: string;
+}
+export interface GitCommit {
+    id: string;
+    subject: string;
+    author: string;
+    committedAt: string;
+}
+export interface GitCommitsRequest extends GitTarget {
+    head?: string;
+    offset?: number;
+}
+export interface GitCommits {
+    checkoutId: string;
+    head: string | null;
+    items: GitCommit[];
+    nextOffset?: number;
+}
+export interface GitDiffRequest extends GitTarget {
+    path: string;
+    scope: GitDiffScope;
+    ref?: string;
+}
+export interface GitChangesRequest extends GitTarget {
+    scope: GitDiffScope;
+    ref?: string;
+}
+export interface GitChangedFile {
+    path: string;
+    additions: number | null;
+    deletions: number | null;
+}
+export interface GitChanges {
+    checkoutId: string;
+    revision: string;
+    files: GitChangedFile[];
+}
+export interface GitHunk {
+    id: string;
+    header: string;
+    patch: string;
+}
+export interface GitDiff {
+    checkoutId: string;
+    revision: string;
+    path: string;
+    scope: GitDiffScope;
+    binary: boolean;
+    patch: string;
+    hunks: GitHunk[];
+}
+export type GitMutation = {
+    action: 'stage' | 'unstage';
+    paths: string[];
+} | {
+    action: 'revert';
+    paths: string[];
+    confirmed: true;
+} | {
+    action: 'stage-hunk' | 'unstage-hunk';
+    path: string;
+    hunkId: string;
+} | {
+    action: 'revert-hunk';
+    path: string;
+    hunkId: string;
+    confirmed: true;
+} | {
+    action: 'commit';
+    message: string;
+} | {
+    action: 'create-branch';
+    name: string;
+} | {
+    action: 'switch-branch';
+    name: string;
+} | {
+    action: 'fetch';
+    remote: string;
+    credentialId?: string;
+} | {
+    action: 'push';
+    remote: string;
+    branch: string;
+    remoteBranch: string;
+    credentialId?: string;
+    lease?: {
+        expectedRemoteHead: string;
+        confirmed: true;
+    };
+};
+export type GitMutationRequest = GitTarget & {
+    expectedRevision: string;
+} & GitMutation;
+export interface RepositoryCommand {
+    command: string[];
+    cwd: string;
+    networkDomains?: string[];
+    environment?: Record<string, string>;
+}
+export interface GitMutationPlan {
+    checkout: GitCheckout;
+    revision: string;
+    action: GitMutation['action'];
+    commands: RepositoryCommand[];
+    filePaths: string[];
+    deleting: boolean;
+}
+export interface GitMutationResult {
+    checkoutId: string;
+    action: GitMutation['action'];
+    output: string;
+    completedSteps: string[];
+}
+export interface GitFailure {
+    code: string;
+    message: string;
+    completedSteps?: string[];
+    details?: string;
+}
+export type GitResult<T> = {
+    ok: true;
+    value: T;
+} | {
+    ok: false;
+    error: GitFailure;
+};
+export interface GitSettings {
+    branchPrefix: string;
+    commitInstructions: string;
+    pullRequestInstructions?: string;
+    monitorRepairInstructions?: string;
+    mergeMethod?: 'merge' | 'squash';
+    draftPullRequests?: boolean;
+    reviewPresentation?: 'inline' | 'separate';
+    automaticMerge?: boolean;
+    forcePush?: boolean;
+}
+export declare const DEFAULT_GIT_SETTINGS: GitSettings;
+export interface GitApi {
+    credentials(taskId?: string): Promise<GitResult<import('./git-http-api.js').GitHttpCredential[]>>;
+    saveCredential(request: import('./git-http-api.js').SaveGitHttpCredential & {
+        taskId?: string;
+    }): Promise<GitResult<import('./git-http-api.js').GitHttpCredential>>;
+    removeCredential(request: {
+        id: string;
+        taskId?: string;
+    }): Promise<GitResult<void>>;
+    listCheckouts(taskId: string): Promise<GitResult<GitCheckout[]>>;
+    status(target: GitTarget): Promise<GitResult<GitStatus>>;
+    diff(request: GitDiffRequest): Promise<GitResult<GitDiff>>;
+    changes(request: GitChangesRequest): Promise<GitResult<GitChanges>>;
+    commits(request: GitCommitsRequest): Promise<GitResult<GitCommits>>;
+    mutate(request: GitMutationRequest): Promise<GitResult<GitMutationResult>>;
+    assist(request: GitAssistantRequest): Promise<GitResult<GitAssistantResult>>;
+}
+export interface GitAssistantRequest extends GitChangesRequest {
+    kind: 'commit-message' | 'review' | 'pull-request';
+    expectedRevision: string;
+    presentation?: 'inline' | 'separate';
+}
+export type GitAssistantResult = {
+    kind: 'commit-message';
+    checkoutId: string;
+    revision: string;
+    message: string;
+} | {
+    kind: 'pull-request';
+    checkoutId: string;
+    revision: string;
+    title: string;
+    body: string;
+} | {
+    kind: 'review';
+    checkoutId: string;
+    revision: string;
+    summary: string;
+    findings: Array<{
+        path: string;
+        line: number;
+        severity: 'high' | 'medium' | 'low';
+        title: string;
+        detail: string;
+    }>;
+    reviewTaskId?: string;
+};

package/dist/shared/git-http-api.d.ts

@@ -0,0 +1,12 @@
+export interface GitHttpCredential {
+    id: string;
+    url: string;
+    username: string;
+    mode: 'password' | 'token';
+}
+export interface SaveGitHttpCredential {
+    url: string;
+    username: string;
+    mode: GitHttpCredential['mode'];
+    secret: string;
+}