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

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

@@ -0,0 +1,132 @@
+import type { GitTarget, GitResult, GitFailure, RepositoryCommand } from './git-api.js';
+export type HostedGitProvider = 'github' | 'gitlab';
+export interface HostedGitConnection {
+    id: string;
+    provider: HostedGitProvider;
+    webOrigin: string;
+    apiBase: string;
+    account: string;
+    accountId?: string;
+}
+export interface SaveHostedGitConnectionRequest {
+    provider: HostedGitProvider;
+    webOrigin: string;
+    apiBase: string;
+    token: string;
+}
+export interface HostedGitTarget extends GitTarget {
+    connectionId: string;
+    remote: string;
+}
+export interface HostedGitRepository {
+    connectionId: string;
+    provider: HostedGitProvider;
+    webOrigin: string;
+    apiBase: string;
+    path: string;
+}
+export interface HostedPullRequest {
+    number: number;
+    url: string;
+    title: string;
+    body: string;
+    source: string;
+    target: string;
+    head: string;
+    state: 'open' | 'closed' | 'merged';
+    draft: boolean;
+    mergeable: boolean | null;
+    mergeState: string;
+    sameRepository: boolean;
+}
+export interface CreateHostedPullRequest extends HostedGitTarget {
+    requestId: string;
+    expectedRevision: string;
+    source: string;
+    target: string;
+    title: string;
+    body: string;
+    draft: boolean;
+    commitAndPush?: {
+        message?: string;
+        credentialId?: string;
+    };
+}
+export interface HostedGitOperation {
+    version: 1;
+    id: string;
+    ownerUserId: string;
+    request: CreateHostedPullRequest;
+    repository: HostedGitRepository;
+    initialHead: string;
+    initialStaged: string[];
+    commands: RepositoryCommand[];
+    filePaths: string[];
+    phase: 'awaiting-authorization' | 'committing' | 'pushing' | 'creating' | 'unknown' | 'completed' | 'failed';
+    completedSteps: string[];
+    createdAt: string;
+    updatedAt: string;
+    result?: HostedPullRequest;
+    error?: GitFailure;
+    submittedHead?: string;
+}
+export interface HostedGitMonitor {
+    executionScope?: string;
+    version: 1;
+    id: string;
+    authorizationId: string;
+    ownerUserId: string;
+    taskId: string;
+    target: HostedGitTarget;
+    repository: HostedGitRepository;
+    number: number;
+    enabled: boolean;
+    repair: boolean;
+    repairInstructions: string;
+    autoMerge: boolean;
+    mergeMethod: 'merge' | 'squash';
+    authorizedHead: string;
+    phase: 'watching' | 'repairing' | 'merge-unknown' | 'merged' | 'closed' | 'blocked';
+    fingerprint?: string;
+    last?: HostedPullRequest;
+    error?: GitFailure;
+    repairCommandId?: string;
+    repairingFingerprint?: string;
+    updatedAt: string;
+}
+export interface ConfigureHostedGitMonitorRequest extends HostedGitTarget {
+    number: number;
+    enabled: boolean;
+    repair: boolean;
+    repairInstructions: string;
+    autoMerge: boolean;
+    mergeMethod: 'merge' | 'squash';
+    expectedHead: string;
+    confirmed: true;
+}
+export interface HostedGitApi {
+    connections(taskId?: string): Promise<GitResult<HostedGitConnection[]>>;
+    saveConnection(request: SaveHostedGitConnectionRequest & {
+        taskId?: string;
+    }): Promise<GitResult<HostedGitConnection>>;
+    removeConnection(request: {
+        id: string;
+        taskId?: string;
+    }): Promise<GitResult<void>>;
+    list(request: HostedGitTarget): Promise<GitResult<HostedPullRequest[]>>;
+    prepare(request: CreateHostedPullRequest): Promise<GitResult<HostedGitOperation>>;
+    execute(request: {
+        taskId: string;
+        operationId: string;
+    }): Promise<GitResult<HostedGitOperation>>;
+    status(request: {
+        taskId: string;
+        operationId: string;
+    }): Promise<GitResult<HostedGitOperation>>;
+    configureMonitor(request: ConfigureHostedGitMonitorRequest): Promise<GitResult<HostedGitMonitor>>;
+    monitors(taskId: string): Promise<GitResult<HostedGitMonitor[]>>;
+    pollMonitor(request: {
+        taskId: string;
+        monitorId: string;
+    }): Promise<GitResult<HostedGitMonitor>>;
+}

package/dist/shared/js-agent-hooks.d.ts

@@ -0,0 +1,23 @@
+export interface JsHookDefinition {
+    event: 'PreToolUse' | 'PostToolUse';
+    callback: string;
+    matcher?: string;
+    timeoutMs: number;
+}
+export interface ToolLifecycleEvent {
+    sessionId: string;
+    event: 'beforeTool' | 'afterTool';
+    toolName: string;
+    toolCallId: string;
+    input: unknown;
+    result?: unknown;
+    /** Original event preserves engine thread and turn identifiers separately from the SDK session. */
+    raw: Readonly<Record<string, unknown>>;
+}
+export interface ToolHookDecision {
+    decision?: 'continue' | 'deny';
+    reason?: string;
+    additionalContext?: string;
+}
+export declare function parseJsHookDefinitions(value: unknown): JsHookDefinition[];
+export declare function hookOutput(event: JsHookDefinition['event'], value: unknown): Record<string, unknown>;

package/dist/shared/local-custom-model-api.d.ts

@@ -0,0 +1,55 @@
+import type { ModelReasoningEffort } from './model-selection.js';
+export declare const LOCAL_CUSTOM_MODEL_ID_PREFIX = "custom-model:";
+export interface LocalCustomModel {
+    upstreamProtocol?: 'responses' | 'chat_completions';
+    id: string;
+    selectionId: string;
+    endpoint: string;
+    model: string;
+    apiKeyConfigured: boolean;
+    functionCalling: boolean;
+    imageInput: boolean;
+    videoInput: boolean;
+    reasoning: boolean;
+    thinkingOnly: boolean;
+    allowDisableThinking: boolean;
+    customProtocol: boolean;
+    defaultReasoningEffort?: ModelReasoningEffort;
+    supportedReasoningEfforts: ModelReasoningEffort[];
+    maxInputTokens?: number;
+    maxOutputTokens?: number;
+    createdAt: string;
+    updatedAt: string;
+}
+export interface SaveLocalCustomModelRequest {
+    id?: string;
+    endpoint: string;
+    apiKey?: string;
+    clearApiKey?: boolean;
+    model: string;
+    functionCalling: boolean;
+    imageInput: boolean;
+    videoInput: boolean;
+    reasoning: boolean;
+    thinkingOnly?: boolean;
+    allowDisableThinking?: boolean;
+    customProtocol: boolean;
+    defaultReasoningEffort?: ModelReasoningEffort;
+    supportedReasoningEfforts?: ModelReasoningEffort[];
+    maxInputTokens?: number;
+    maxOutputTokens?: number;
+}
+export interface LocalCustomModelStorageInfo {
+    filePath: string;
+    displayPath: string;
+}
+export interface LocalCustomModelApi {
+    getStorageInfo: () => Promise<LocalCustomModelStorageInfo>;
+    list: () => Promise<LocalCustomModel[]>;
+    save: (request: SaveLocalCustomModelRequest) => Promise<LocalCustomModel>;
+    remove: (modelId: string) => Promise<void>;
+}
+export interface LocalCustomRuntimeModel extends Omit<LocalCustomModel, 'apiKeyConfigured'> {
+    generationCapabilities?: import('./runtime-tuning.js').GenerationCapabilities;
+    apiKey: string;
+}

package/dist/shared/local-environment-api.d.ts

@@ -0,0 +1,110 @@
+import type { GitResult, RepositoryCommand } from './git-api.js';
+import type { WorktreeScript } from './worktree-api.js';
+import type { LocalWorkspace } from './local-workspace.js';
+export type { LocalWorkspace } from './local-workspace.js';
+export type EnvironmentPlatform = 'darwin' | 'linux' | 'win32';
+export type EnvironmentActionIcon = 'tool' | 'run' | 'debug' | 'test';
+export interface LocalEnvironmentAction {
+    id: string;
+    name: string;
+    icon: EnvironmentActionIcon;
+    command: string;
+    platform?: EnvironmentPlatform;
+}
+export interface LocalEnvironmentConfig {
+    version: 1;
+    id: string;
+    name: string;
+    setup: WorktreeScript;
+    cleanup: WorktreeScript;
+    actions: LocalEnvironmentAction[];
+}
+export interface LocalEnvironmentFile extends LocalEnvironmentConfig {
+    localWorkspaceId: string;
+    fileName: string;
+    revision: string;
+}
+export interface LocalWorkspaceEntry extends LocalWorkspace {
+    environments: LocalEnvironmentFile[];
+    errors: string[];
+}
+export interface EnvironmentMigrationIssue {
+    id: string;
+    name: string;
+    message: string;
+}
+export interface LocalEnvironmentCatalog {
+    workspaces: LocalWorkspaceEntry[];
+    migrationIssues: EnvironmentMigrationIssue[];
+    platform: EnvironmentPlatform;
+}
+export interface SaveLocalEnvironmentRequest {
+    localWorkspaceId: string;
+    config: LocalEnvironmentConfig;
+    fileName?: string;
+    expectedRevision?: string;
+}
+export interface EnvironmentTarget {
+    taskId: string;
+    worktreeId?: string;
+}
+export interface EnvironmentContext {
+    rootPath: string;
+    workspace?: LocalWorkspaceEntry;
+    platform: EnvironmentPlatform;
+    sourcePath: string;
+}
+export interface EnvironmentRun {
+    id: string;
+    ownerUserId: string;
+    target: EnvironmentTarget;
+    localWorkspaceId: string;
+    environmentId: string;
+    actionId: string;
+    name: string;
+    requestId: string;
+    revision: string;
+    command: RepositoryCommand;
+    phase: 'awaiting-authorization' | 'running' | 'completed' | 'failed' | 'cancelled' | 'interrupted';
+    startedAt: string;
+    finishedAt?: string;
+    output: string;
+    error?: string;
+    pid?: number;
+    errorCode?: string;
+}
+export interface LocalEnvironmentApi {
+    list(): Promise<GitResult<LocalEnvironmentCatalog>>;
+    migrate(request: {
+        environmentId: string;
+    }): Promise<GitResult<void>>;
+    addWorkspace(): Promise<GitResult<LocalWorkspaceEntry | null>>;
+    removeWorkspace(request: {
+        localWorkspaceId: string;
+    }): Promise<GitResult<void>>;
+    save(request: SaveLocalEnvironmentRequest): Promise<GitResult<LocalEnvironmentFile>>;
+    remove(request: {
+        localWorkspaceId: string;
+        fileName: string;
+        expectedRevision: string;
+    }): Promise<GitResult<void>>;
+    select(request: {
+        localWorkspaceId: string;
+        environmentId?: string;
+    }): Promise<GitResult<void>>;
+    context(request: EnvironmentTarget): Promise<GitResult<EnvironmentContext>>;
+    prepareAction(request: EnvironmentTarget & {
+        environmentId: string;
+        actionId: string;
+        requestId: string;
+    }): Promise<GitResult<EnvironmentRun>>;
+    executeAction(request: {
+        taskId: string;
+        operationId: string;
+    }): Promise<GitResult<EnvironmentRun>>;
+    runs(request: EnvironmentTarget): Promise<GitResult<EnvironmentRun[]>>;
+    stopAction(request: {
+        taskId: string;
+        operationId: string;
+    }): Promise<GitResult<EnvironmentRun>>;
+}

package/dist/shared/local-mcp-server-api.d.ts

@@ -0,0 +1,91 @@
+export type LocalMcpServerTransport = 'HTTP' | 'STDIO';
+export type LocalMcpServerSource = 'builtin' | 'custom' | 'managed';
+export type LocalMcpAuthorizationStatus = 'not_required' | 'required' | 'granted';
+export interface LocalMcpRegistrySource {
+    name: string;
+    version: string;
+    serviceId?: string;
+    packageSha256?: string;
+}
+export interface LocalMcpServerTool {
+    name: string;
+    title?: string;
+    description?: string;
+    enabled: boolean;
+}
+export interface LocalMcpServer {
+    id: string;
+    key: string;
+    name: string;
+    description?: string;
+    source: LocalMcpServerSource;
+    authorizationStatus: LocalMcpAuthorizationStatus;
+    authorizedAt?: string;
+    transport: LocalMcpServerTransport;
+    enabled: boolean;
+    url?: string;
+    bearerTokenConfigured: boolean;
+    command?: string;
+    args: string[];
+    env: Record<string, boolean>;
+    tools: LocalMcpServerTool[];
+    registry?: LocalMcpRegistrySource;
+    createdAt: string;
+    updatedAt: string;
+}
+export interface SaveLocalMcpServerRequest {
+    id?: string;
+    key?: string;
+    name: string;
+    description?: string;
+    transport: LocalMcpServerTransport;
+    enabled: boolean;
+    url?: string;
+    bearerToken?: string;
+    clearBearerToken?: boolean;
+    command?: string;
+    args?: string[];
+    env?: Record<string, string>;
+    preserveExistingEnv?: boolean;
+    registry?: LocalMcpRegistrySource;
+}
+export interface SetLocalMcpServerEnabledRequest {
+    serverId: string;
+    enabled: boolean;
+}
+export interface SetLocalMcpServerToolEnabledRequest {
+    serverId: string;
+    toolName: string;
+    enabled: boolean;
+}
+export interface LocalMcpRuntimeServer {
+    id: string;
+    key: string;
+    name: string;
+    description?: string;
+    source?: LocalMcpServerSource;
+    authorizationRequired?: boolean;
+    authorizationGranted?: boolean;
+    authorizationFingerprint?: string;
+    transport: LocalMcpServerTransport;
+    url?: string;
+    bearerToken?: string;
+    command?: string;
+    args: string[];
+    env: Record<string, string>;
+    tools?: string[];
+    toolTitles?: Record<string, string>;
+    disabledTools?: string[];
+    defaultToolsApproval?: 'auto' | 'prompt';
+    toolApprovals?: Record<string, 'auto' | 'prompt'>;
+}
+export interface LocalMcpServerApi {
+    list: () => Promise<LocalMcpServer[]>;
+    save: (request: SaveLocalMcpServerRequest) => Promise<LocalMcpServer>;
+    saveBatch: (requests: SaveLocalMcpServerRequest[]) => Promise<LocalMcpServer[]>;
+    setEnabled: (request: SetLocalMcpServerEnabledRequest) => Promise<LocalMcpServer>;
+    refreshTools: (serverId: string) => Promise<LocalMcpServer>;
+    setToolEnabled: (request: SetLocalMcpServerToolEnabledRequest) => Promise<LocalMcpServer>;
+    revokeAuthorization: (serverId: string) => Promise<LocalMcpServer>;
+    remove: (serverId: string) => Promise<void>;
+}

package/dist/shared/local-memory.d.ts

@@ -0,0 +1,165 @@
+export declare const MEMORY_GROUPS: readonly ["工作背景", "个人背景", "当前关注", "近期动态"];
+export type MemoryGroup = typeof MEMORY_GROUPS[number];
+export type MemoryKind = 'instruction' | 'fact' | 'preference' | 'decision' | 'task';
+/** Long-term memory belongs to one account, independent of enterprise or personal mode. */
+export interface MemoryScope {
+    environment: 'dev' | 'prod';
+    userId: string; /** Host-authorized namespace; absent for existing desktop/CLI account memory. */
+    namespace?: string;
+}
+export interface MemorySource {
+    kind: 'user_edit' | 'user_import' | 'conversation';
+    taskId?: string;
+    messageId?: string;
+    generation?: string;
+    role?: string;
+    occurredAt: string | null;
+}
+export interface MemoryResource {
+    id: string;
+    kind: 'file' | 'skill';
+    name: string;
+    path: string;
+    version: string;
+}
+export interface MemoryApplicability {
+    platforms?: Array<'win32' | 'darwin' | 'linux'>;
+    resources?: MemoryResource[];
+}
+export interface MemoryLifecycle {
+    state: 'ongoing' | 'completed';
+    expiresAt?: string;
+}
+export interface MemoryRecallContext {
+    platform: string;
+    projectId?: string;
+    permissionVersion: string;
+}
+export interface MemoryRecord {
+    /** subject names the entity or topic; content describes it. Present both to users and consumers. */
+    id: string;
+    revision: number;
+    kind: MemoryKind;
+    group: MemoryGroup;
+    subject: string;
+    content: string;
+    originalInstruction?: string;
+    occurredAt: string | null;
+    status: 'active' | 'candidate' | 'conflicted' | 'superseded' | 'invalidated';
+    sources: MemorySource[];
+    updatedAt: string;
+    conflictsWith?: string[];
+    createdAt?: string;
+    manualUpdatedAt?: string;
+    contentDigest?: string;
+    applicability?: MemoryApplicability;
+    lifecycle?: MemoryLifecycle;
+    invalidationReason?: 'source_changed' | 'resource_changed' | 'expired' | 'unsupported_evidence' | 'unresolved_conflict';
+    previous?: {
+        revision: number;
+        content: string;
+        updatedAt: string;
+    };
+}
+export interface MemoryState {
+    organizationVersion?: 2;
+    version: 1;
+    epoch: string;
+    revision: number;
+    enabled: boolean;
+    resetAt: string;
+    updatedAt?: string;
+    operation?: MemoryOperation;
+    cursors: Record<string, string>;
+    revoked?: string[];
+    deletedSubjects?: Record<string, string>;
+    collectionAfter?: string;
+    cleanupEpochs?: string[];
+    completedOperations?: string[];
+    quarantined?: string[];
+}
+export interface MemoryOperation {
+    id: string;
+    status: 'running' | 'completed' | 'failed' | 'cancelled';
+    mode?: 'edit' | 'import' | 'extract';
+    error?: string;
+    clarification?: string;
+}
+export interface MemoryView {
+    scope: MemoryScope;
+    enabled: boolean;
+    revision: number;
+    updatedAt?: string;
+    groups: Array<{
+        title: MemoryGroup;
+        items: MemoryRecord[];
+    }>;
+    total: number;
+    operation?: MemoryOperation;
+    storageNotice?: string;
+    page?: number;
+    hasMore?: boolean;
+}
+export interface MemoryChange {
+    action: 'add' | 'merge' | 'replace' | 'remove' | 'no_change';
+    id?: string;
+    revision?: number;
+    kind?: MemoryKind;
+    group?: MemoryGroup;
+    subject?: string;
+    content?: string;
+    originalInstruction?: string;
+    occurredAt?: string | null;
+    sourceIds?: string[];
+    applicability?: Omit<MemoryApplicability, 'resources'>;
+    resourceIds?: string[];
+    lifecycle?: MemoryLifecycle;
+}
+export interface MemoryProposal {
+    changes: MemoryChange[];
+    clarification?: string;
+}
+export interface MemorySearchHit {
+    id: string;
+    subject: string;
+    content: string;
+    kind: MemoryKind;
+    group: MemoryGroup;
+    sources: MemorySource[];
+    lifecycle?: MemoryLifecycle;
+    occurredAt?: string | null;
+}
+export interface HistoryHit {
+    id: string;
+    taskId: string;
+    recordId: string;
+    role: string;
+    occurredAt: string;
+    content: string;
+    generation: string;
+    truncated: boolean;
+}
+export interface MemoryContextRequest {
+    page?: number; /** SDK management calls select an explicitly authorized session. */
+    sessionId?: string;
+}
+export interface MemoryEditRequest extends MemoryContextRequest {
+    text: string;
+    mode: 'edit' | 'import';
+    operationId: string;
+}
+export interface LocalMemoryApi {
+    get(request?: MemoryContextRequest): Promise<MemoryView>;
+    setEnabled(request: MemoryContextRequest & {
+        enabled: boolean;
+    }): Promise<MemoryView>;
+    edit(request: MemoryEditRequest): Promise<MemoryView>;
+    reset(request: MemoryContextRequest): Promise<MemoryView>;
+}
+export declare function sameMemoryIdentity(a: MemoryScope, b: MemoryScope): boolean;
+/** A bounded deterministic lexical vocabulary, including Chinese words without a vector service. */
+export declare function memoryTerms(text: string): string[];
+export declare function memorySearchExpression(text: string): string;
+export declare function memoryInput(value: unknown, limit?: number): string;
+/** Credential-bearing lines never enter the persistent memory pipeline. */
+export declare function redactMemorySecrets(text: string): string;

package/dist/shared/local-plugin-api.d.ts

@@ -0,0 +1,26 @@
+import type { LocalTaskPluginReference } from './local-task-api.js';
+import type { PluginMarketDetail } from './plugin-market-api.js';
+export type LocalPluginSource = 'PLATFORM' | 'ENTERPRISE';
+export interface LocalPluginInstallation {
+    plugin: PluginMarketDetail;
+    runtime: LocalTaskPluginReference;
+    source: LocalPluginSource;
+    enabled: boolean;
+    installedAt: string;
+    updatedAt: string;
+}
+export interface InstallLocalPluginRequest {
+    plugin: PluginMarketDetail;
+    source: LocalPluginSource;
+}
+export interface SetLocalPluginEnabledRequest {
+    pluginId: string;
+    enabled: boolean;
+}
+export interface LocalPluginApi {
+    list: () => Promise<LocalPluginInstallation[]>;
+    refresh: () => Promise<LocalPluginInstallation[]>;
+    install: (request: InstallLocalPluginRequest) => Promise<LocalPluginInstallation>;
+    setEnabled: (request: SetLocalPluginEnabledRequest) => Promise<LocalPluginInstallation>;
+    remove: (pluginId: string) => Promise<void>;
+}

package/dist/shared/local-runtime-api.d.ts

@@ -0,0 +1,32 @@
+export type LocalRuntimeStatus = 'unavailable' | 'stopped' | 'starting' | 'ready' | 'stopping' | 'failed';
+export interface LocalRuntimeExecutionLease {
+    taskId: string;
+    runId: string;
+    acquiredAt: string;
+}
+export interface LocalRuntimeTaskState {
+    resourceConfiguration?: import('./task-resource-manifest.js').TaskResourceManifest['configuration'];
+    status: LocalRuntimeStatus;
+    taskId: string;
+    startedAt?: string;
+    stoppedAt?: string;
+    lastError?: string;
+    executionLease?: LocalRuntimeExecutionLease;
+}
+export interface LocalRuntimeState {
+    status: LocalRuntimeStatus;
+    taskId?: string;
+    startedAt?: string;
+    stoppedAt?: string;
+    lastError?: string;
+    executionLease?: LocalRuntimeExecutionLease;
+    taskStates?: LocalRuntimeTaskState[];
+    executionLeases?: LocalRuntimeExecutionLease[];
+}
+export interface LocalRuntimeApi {
+    getState: () => Promise<LocalRuntimeState>;
+    start: (taskId: string) => Promise<LocalRuntimeState>;
+    stop: (taskId: string) => Promise<LocalRuntimeState>;
+    restart: (taskId: string) => Promise<LocalRuntimeState>;
+    onStateChanged: (listener: (state: LocalRuntimeState) => void) => () => void;
+}

package/dist/shared/local-skill-api.d.ts

@@ -0,0 +1,42 @@
+import type { LocalTaskSkillReference } from './local-task-api.js';
+import type { PersonalSkillUploadResult } from './skill-upload.js';
+export type LocalSkillImportKind = 'FILE' | 'DIRECTORY';
+export interface LocalSkillDefinition {
+    /** Opaque installation/profile identity; never a portable same-name reference. */
+    executionScope?: string;
+    /** 新版本地技能的稳定身份，等于安装目录名称。 */
+    folderName: string;
+    /**
+     * UI 和既有项目配置使用的本地引用。新版等于 folderName；旧版保持原有
+     * local:<digest> 值，读取旧数据时不会改写磁盘内容。
+     */
+    reference: string;
+    legacySkillId?: string;
+    name: string;
+    description: string;
+    version?: string;
+    packagePath: string;
+    skillPath: string;
+    installedAt: string;
+    updatedAt: string;
+}
+export interface ImportLocalSkillsRequest {
+    kind: LocalSkillImportKind;
+}
+export interface ImportLocalSkillsResult {
+    canceled: boolean;
+    skills: LocalSkillDefinition[];
+}
+export interface LocalSkillContent {
+    skill: LocalSkillDefinition;
+    content: string;
+}
+export interface LocalSkillApi {
+    list: () => Promise<LocalSkillDefinition[]>;
+    getContent: (reference: string) => Promise<LocalSkillContent>;
+    openDirectory: (reference: string) => Promise<void>;
+    importFromDialog: (request: ImportLocalSkillsRequest) => Promise<ImportLocalSkillsResult>;
+    remove: (reference: string) => Promise<void>;
+    uploadToPersonal: (reference: string) => Promise<PersonalSkillUploadResult>;
+    prepareForLocalTask: (reference: string) => Promise<LocalTaskSkillReference>;
+}