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

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

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