@nodus-ai/equile 0.0.1-preview

package/dist/nodus.d.cts

@@ -0,0 +1,709 @@
+type AgentRunStatus = "queued" | "provisioning" | "running" | "completed" | "failed" | "cancelled" | "timed_out";
+type AgentRunMode = "standard" | "goal";
+type AgentRunInputResource = {
+    /** HTTPS source the runtime downloads. Provide either url or contentBase64. */
+    url?: string;
+    /** Inline base64 payload (e.g. an image): Nodus stages it and hands the runtime a private download of its own. ~7 MB max per resource. */
+    contentBase64?: string;
+    path: string;
+    contentType?: string | null;
+    sizeBytes?: number | null;
+    checksum?: string | null;
+};
+type AgentRunResource = Omit<AgentRunInputResource, "url" | "contentBase64">;
+/** Per-message session attachment (e.g. a pasted image); staged into the
+ * session workspace and referenced by path in the delivered turn. */
+type SessionAttachment = {
+    name: string;
+    contentBase64: string;
+};
+type AgentRunArtifact = {
+    id: string;
+    path: string;
+    sizeBytes: number;
+    contentType: string;
+    expiresAt: string;
+    status: "available" | "expired";
+};
+type AgentRunUsage = {
+    inputTokens: number;
+    cachedInputTokens: number;
+    outputTokens: number;
+    reasoningOutputTokens: number;
+    runtimeSeconds: number;
+    model: string | null;
+    estimatedCostUsd: number | null;
+};
+type AgentRunMetadata = Record<string, unknown> & {
+    workspaceScheduled?: boolean;
+    workspaceId?: string;
+    scheduledProvider?: string;
+    attemptedAgentIds?: string[];
+    failoverCount?: number;
+    lastFailoverReason?: string;
+};
+type AgentRun = {
+    id: string;
+    /** Persistent runs keep their sandbox: continue it via sessions.run(sessionId, …). */
+    persistent?: boolean;
+    sessionId?: string;
+    mode: AgentRunMode;
+    userAgentId: string;
+    agentSessionId: string | null;
+    workspaceRevisionId: string | null;
+    status: AgentRunStatus;
+    /** Legacy alias for prompt. */
+    instructions: string;
+    prompt: string;
+    goal: string | null;
+    resources: AgentRunResource[];
+    idempotencyKey: string | null;
+    queueTimeoutAt: string | null;
+    executionTimeoutSeconds: number;
+    timeoutAt: string | null;
+    metadata: AgentRunMetadata;
+    usage: AgentRunUsage;
+    artifacts: AgentRunArtifact[];
+    finalOutput: string | null;
+    /** Parsed JSON deliverable when the run was created with outputSchema. */
+    structuredOutput?: unknown;
+    /** Where structuredOutput came from: the final message or a captured artifact. */
+    structuredOutputSource?: "final_output" | `artifact:${string}` | null;
+    error: string | null;
+    createdAt: string;
+    startedAt: string | null;
+    completedAt: string | null;
+    cleanupCompletedAt: string | null;
+    updatedAt: string;
+};
+type AgentRunSummary = Omit<AgentRun, "instructions" | "prompt" | "goal" | "resources" | "metadata">;
+type WorkspaceRuntime = {
+    id: string;
+    name: string;
+    defaultResourceProfile: string;
+    latestRevisionId: string | null;
+    createdAt: string;
+    updatedAt: string;
+    archivedAt: string | null;
+};
+type WorkspaceRevision = {
+    id: string;
+    workspaceRuntimeId: string;
+    sourceType: "interactive" | "dockerfile";
+    status: "ready" | "failed";
+    parentRevisionId: string | null;
+    capabilities: Record<string, unknown>;
+    validationReport: Record<string, unknown>;
+    createdAt: string;
+};
+type WorkspaceBuild = {
+    id: string;
+    workspaceRuntimeId: string;
+    mode: "interactive" | "dockerfile";
+    status: string;
+    baseRevisionId: string | null;
+    dockerfilePath: string | null;
+    resultRevisionId: string | null;
+    error: string | null;
+    logs: string;
+    createdAt: string;
+    updatedAt: string;
+};
+type DesktopRuntimePermission = "full" | "files_only";
+type DesktopRuntimeGrant = {
+    runtimeId: string;
+    userAgentId: string;
+    permission: DesktopRuntimePermission;
+    createdAt: string;
+    updatedAt: string;
+};
+type DesktopRuntime = {
+    id: string;
+    name: string;
+    defaultCwd: string;
+    homeDisplay: string;
+    skillCatalog: Array<Record<string, unknown>>;
+    mcpCatalog: Array<Record<string, unknown>>;
+    mode: "full" | "storage_only";
+    grantsEnabled: boolean;
+    grants: DesktopRuntimeGrant[];
+    platform: string;
+    codexVersion: string | null;
+    lastSeenAt: string | null;
+    online: boolean;
+    skillCount: number;
+    mcpCount: number; /** Legacy exclusive binding. New integrations should use grants. */
+    boundAgentId: string | null;
+    createdAt: string;
+    updatedAt: string;
+};
+type QuotaWindow = {
+    id: string;
+    usedPercent: number;
+    resetsAt: string | null;
+};
+type AgentQuota = {
+    supported: boolean;
+    reason?: string;
+    windows: QuotaWindow[];
+    exhausted: boolean;
+    exhaustedAt?: string | null;
+    capturedAt: string;
+    lastGoodAt?: string | null;
+    error?: string | null;
+    errorKind?: "auth" | "transient" | null;
+    source?: "poll" | "run_error";
+};
+type ReasoningEffort = "low" | "medium" | "high" | "xhigh" | "max";
+type Agent = {
+    id: string;
+    workspaceId: string;
+    provider: string;
+    harness: string;
+    displayName: string;
+    authStatus: string;
+    defaultResourceProfile: string;
+    maxConcurrency: number;
+    /** Free-form tenant tag set via metadata.ownerTag at create time — lets a
+     * product multiplexing many end users over one key filter agents per user. */
+    ownerTag: string | null;
+    modelId: string | null;
+    reasoningEffort: ReasoningEffort | null;
+    availableModels: string[];
+    createdAt: string;
+    updatedAt: string;
+};
+type CredentialProvider = "claude" | "codex" | "grok" | "gemini" | "cursor" | "factory";
+type AgentProvider = CredentialProvider | "opencode" | "goose" | "kimi" | "aider";
+type AgentCreateInput = {
+    /** Model and credential provider. */
+    provider: CredentialProvider;
+    /** Vendor CLI to run. Defaults to provider for backward compatibility. */
+    harnessProvider?: AgentProvider;
+    harness: "tui" | "headless" | "tmux" | "cli";
+    modelId: string;
+    displayName?: string;
+    defaultResourceProfile?: "small" | "medium" | "large" | "xl";
+    maxConcurrency?: number;
+    /** Curated metadata only (the SDK surface rejects unknown keys).
+     * ownerTag is echoed back as agent.ownerTag for per-tenant filtering. */
+    metadata?: {
+        ownerTag?: string;
+        reasoningEffort?: ReasoningEffort;
+        region?: string;
+    };
+    workspaceId?: string;
+};
+type AgentRunCreateInput = {
+    /** Initial request for this run. Prefer prompt; instructions remains backward compatible. */
+    instructions?: string;
+    prompt?: string;
+    /** Markdown Goal specification. Supported when mode is goal. */
+    goal?: string;
+    agentId?: string;
+    provider?: CredentialProvider;
+    /** Workspace Provider instance override for an existing Agent. */
+    providerId?: string;
+    /** Credential override within providerId (or the Agent default Provider). */
+    credentialId?: string;
+    model?: string;
+    mode?: AgentRunMode;
+    resources?: AgentRunInputResource[];
+    idempotencyKey?: string;
+    timeoutSeconds?: number;
+    workspaceRevisionId?: string;
+    desktopRuntimeId?: string;
+    /** Existing Browserbase Session to bind to this run. Nodus releases it with the run. */
+    browserSessionId?: string;
+    /** Working directory on the paired desktop the run executes in (requires desktopRuntimeId). */
+    desktopCwd?: string;
+    persistent?: boolean;
+    metadata?: Record<string, unknown>;
+    /** JSON Schema for the final deliverable. The runtime is instructed to end
+     * with exactly one JSON document; Nodus parses it (falling back to captured
+     * JSON artifacts) into run.structuredOutput. */
+    outputSchema?: Record<string, unknown>;
+};
+type RuntimeEvent = {
+    id: string;
+    sequence: number;
+    turnId: string | null;
+    type: string;
+    terminal: "none" | "turn" | "run" | "cleanup";
+    payload: Record<string, unknown>;
+    raw?: {
+        provider: string;
+        type: string;
+        payload: Record<string, unknown>;
+    };
+    createdAt: string;
+};
+type RuntimeTurn = {
+    id: string;
+    status: "running" | "completed" | "failed";
+    acceptedSequence: number;
+    startedAt: string;
+};
+type RuntimeTurnResult = {
+    turnId: string;
+    status: "running" | "completed" | "failed";
+    events: RuntimeEvent[];
+    lastSequence: number;
+    finalOutput: string | null;
+    error: string | null;
+};
+type RuntimeSession = {
+    id: string;
+    /** Persistent sandbox (claude-only): survives across turns, exempt from idle reaping. */
+    persistent?: boolean;
+    agentId: string;
+    workspaceRevisionId: string | null;
+    desktopRuntimeId: string | null;
+    status: "created" | "live" | "pausing" | "paused" | "resuming" | "failed" | "destroyed";
+    resumeMode: "conversation";
+    lastActivityAt: string | null;
+    createdAt: string;
+    updatedAt: string;
+};
+type RuntimeTelemetry = {
+    provider: string;
+    busy: boolean;
+    live: boolean;
+    tokens?: {
+        input: number;
+        output: number;
+        cacheRead: number;
+        cacheCreate: number;
+    };
+    costUsd?: {
+        input: number;
+        output: number;
+        cacheRead: number;
+        cacheCreate: number;
+        total: number;
+    };
+    realTotalTokens?: number;
+    cacheHitRate?: number;
+    usageReported?: boolean;
+    assistantMessages?: number;
+    userMessages?: number;
+    toolUses?: number;
+    lastActivityAt?: string | null;
+    model?: string | null;
+    resources?: {
+        cpuPercent: number;
+        memoryBytes: number;
+    };
+};
+type RuntimeTelemetryPoint = {
+    t: number;
+    input: number;
+    output: number;
+    total: number;
+    cost: number;
+    busy: boolean;
+    cpu: number;
+    memory: number;
+};
+type RuntimePort = {
+    process: string;
+    port: number;
+};
+type RuntimeDiff = {
+    status?: string;
+    patch?: string;
+    hash: string;
+    unchanged?: boolean;
+};
+declare class NodusError extends Error {
+    readonly status: number;
+    readonly data: unknown;
+    readonly code: string | null;
+    readonly retryAt: string | null;
+    constructor(message: string, status: number, data: unknown);
+}
+type WaitOptions = {
+    timeoutMs?: number;
+    pollIntervalMs?: number;
+    signal?: AbortSignal;
+};
+type TurnWaitOptions = {
+    turnId: string;
+    afterSequence?: number;
+    timeoutMs?: number;
+    waitSeconds?: number;
+    signal?: AbortSignal;
+};
+type EventOptions = {
+    after?: number;
+};
+type StreamOptions = EventOptions & {
+    pollIntervalMs?: number;
+    signal?: AbortSignal;
+};
+type AgentRunListOptions = {
+    agentId?: string;
+    status?: AgentRunStatus;
+    cursor?: string;
+    limit?: number;
+    metadata?: Record<string, string>;
+};
+declare function createNodus(options: {
+    baseUrl: string;
+    apiKey: string;
+    fetch?: typeof fetch;
+    requestTimeoutMs?: number;
+}): {
+    agents: {
+        list: () => Promise<Agent[]>;
+        /** Create an agent in the SDK key's workspace. Provider credentials are managed at workspace level. */
+        create: (input: AgentCreateInput) => Promise<{
+            agent: Agent;
+        }>;
+        update: (agentId: string, configuration: {
+            modelId?: string | null;
+            reasoningEffort?: ReasoningEffort | null;
+        }) => Promise<{
+            agent: Agent;
+        }>;
+        setRunConcurrency: (agentId: string, maxConcurrency: number) => Promise<{
+            agent: {
+                id: string;
+                maxConcurrency: number;
+            };
+        }>;
+        /** Remaining provider quota for one agent (cc-switch-style windows).
+         * `refresh: true` forces a live probe instead of the hourly snapshot. */
+        quota: (agentId: string, options?: {
+            refresh?: boolean;
+        }) => Promise<{
+            agentId: string;
+            quota: AgentQuota | null;
+        }>;
+        setConcurrency: (agentId: string, maxConcurrency: number) => Promise<{
+            agent: {
+                id: string;
+                maxConcurrency: number;
+            };
+        }>;
+    };
+    agentRuns: {
+        list: (listOptions?: AgentRunListOptions) => Promise<{
+            runs: AgentRunSummary[];
+            nextCursor: string | null;
+        }>;
+        queueStats: () => Promise<{
+            queued: number;
+            provisioning: number;
+            running: number;
+            completedLast10m: number;
+            throughputPerMinute: number;
+        }>;
+        create: (input: AgentRunCreateInput) => Promise<{
+            run: AgentRun;
+        }>;
+        get: (runId: string) => Promise<{
+            run: AgentRun;
+        }>;
+        events: (runId: string, eventOptions?: EventOptions) => Promise<{
+            events: RuntimeEvent[];
+        }>;
+        stream: (runId: string, streamOptions?: StreamOptions) => AsyncGenerator<RuntimeEvent, any, any>;
+        cancel: (runId: string) => Promise<{
+            run: AgentRun;
+        }>;
+        cancelMany: (runIds: string[]) => Promise<AgentRun[]>;
+        getArtifactDownloadUrl: (runId: string, artifactId: string) => Promise<{
+            url: string;
+            expiresAt: string;
+        }>;
+        wait: (runId: string, waitOptions?: WaitOptions) => Promise<AgentRun>;
+        createAndWait: (input: AgentRunCreateInput, waitOptions?: WaitOptions) => Promise<AgentRun>;
+    };
+    sessions: {
+        create: (input: {
+            agentId: string;
+            workspaceRevisionId?: string;
+            desktopRuntimeId?: string;
+            desktopCwd?: string;
+            persistent?: boolean;
+        }) => Promise<{
+            session: RuntimeSession;
+        }>;
+        list: (options?: {
+            status?: "active" | RuntimeSession["status"];
+            limit?: number;
+            cursor?: string;
+        }) => Promise<{
+            sessions: Array<RuntimeSession & {
+                provider: string | null;
+                runId: string | null;
+                runStatus: AgentRunStatus | null;
+                resourceProfile: string | null;
+                hasWorkspaceSnapshot: boolean;
+                hasAgentHomeSnapshot: boolean;
+                activeTurnId: string | null;
+                lastUsage: RuntimeTelemetry | null;
+                lastUsageAt: string | null;
+            }>;
+            nextCursor: string | null;
+        }>;
+        get: (sessionId: string) => Promise<{
+            session: RuntimeSession;
+        }>;
+        telemetry: (sessionId: string) => Promise<{
+            reachable: boolean;
+            telemetry: RuntimeTelemetry | null;
+        }>;
+        telemetryHistory: (sessionId: string, options?: {
+            startMs?: number;
+            endMs?: number;
+            stepSec?: number;
+        }) => Promise<{
+            startMs: number;
+            endMs: number;
+            stepSec: number;
+            points: RuntimeTelemetryPoint[];
+        }>;
+        diff: (sessionId: string, known?: string) => Promise<RuntimeDiff>;
+        terminalTicket: (sessionId: string) => Promise<{
+            ticket: string;
+        }>;
+        ports: (sessionId: string, known?: string) => Promise<{
+            ports?: RuntimePort[];
+            hash: string;
+            unchanged?: boolean;
+        }>;
+        git: (sessionId: string, input: {
+            action: "commit" | "revert";
+            message?: string;
+            path?: string;
+        }) => Promise<{
+            ok: boolean;
+            pushed: boolean;
+            output: string;
+        }>;
+        run: (sessionId: string, text: string, options?: {
+            attachments?: SessionAttachment[];
+        }) => Promise<{
+            turn: RuntimeTurn;
+        }>;
+        execWorkspace: (sessionId: string, cmd: string, timeoutSeconds?: number) => Promise<{
+            exitCode: number;
+            stdout: string;
+            stderr: string;
+        }>;
+        waitForIdle: (sessionId: string, options: TurnWaitOptions) => Promise<RuntimeTurnResult>;
+        runAndWait: (sessionId: string, text: string, waitOptions?: Omit<TurnWaitOptions, "turnId" | "afterSequence"> & {
+            attachments?: SessionAttachment[];
+        }) => Promise<RuntimeTurnResult>;
+        events: (sessionId: string, eventOptions?: EventOptions) => Promise<{
+            events: RuntimeEvent[];
+        }>;
+        stream: (sessionId: string, streamOptions?: StreamOptions) => AsyncGenerator<RuntimeEvent, any, any>;
+        pause: (sessionId: string) => Promise<{
+            session: RuntimeSession;
+        }>;
+        resume: (sessionId: string) => Promise<{
+            session: RuntimeSession;
+        }>;
+        activate: (sessionId: string) => Promise<{
+            session: RuntimeSession;
+        }>;
+        destroy: (sessionId: string) => Promise<{
+            session: RuntimeSession;
+        }>;
+    };
+    workspaces: {
+        create: (input: {
+            name: string;
+            defaultResourceProfile?: "small" | "medium" | "large" | "xl";
+        }) => Promise<{
+            workspace: WorkspaceRuntime;
+        }>;
+        list: () => Promise<WorkspaceRuntime[]>;
+        get: (workspaceId: string) => Promise<{
+            workspace: WorkspaceRuntime;
+        }>;
+        archive: (workspaceId: string) => Promise<{
+            workspace: WorkspaceRuntime;
+        }>;
+        revisions: (workspaceId: string) => Promise<WorkspaceRevision[]>;
+        startBuilder: (workspaceId: string, input?: {
+            baseRevisionId?: string | null;
+        }) => Promise<{
+            build: WorkspaceBuild;
+        }>;
+        getBuild: (buildId: string) => Promise<{
+            build: WorkspaceBuild;
+        }>;
+        exec: (buildId: string, cmd: string, timeoutSeconds?: number) => Promise<{
+            exitCode: number;
+            stdout: string;
+            stderr: string;
+        }>;
+        listFiles: (buildId: string, path?: string) => Promise<{
+            path: string;
+            entries: Array<{
+                name: string;
+                type: "file" | "dir";
+                path: string;
+            }>;
+        }>;
+        readFile: (buildId: string, path: string) => Promise<{
+            path: string;
+            sizeBytes: number;
+            contentBase64: string;
+        }>;
+        writeFile: (buildId: string, path: string, content: string | Uint8Array) => Promise<{
+            ok: boolean;
+            path: string;
+        }>;
+        upload: (buildId: string, path: string, content: Uint8Array) => Promise<{
+            ok: boolean;
+            path: string;
+        }>;
+        download: (buildId: string, path: string) => Promise<Buffer<ArrayBuffer>>;
+        publish: (buildId: string) => Promise<{
+            revision: WorkspaceRevision;
+        }>;
+        destroyBuilder: (buildId: string) => Promise<{
+            build: WorkspaceBuild;
+        }>;
+        createContextUpload: (workspaceId: string) => Promise<{
+            objectKey: string;
+            uploadUrl: string;
+        }>;
+        buildFromDockerfile: (workspaceId: string, input: {
+            contextBlobKey: string;
+            dockerfilePath?: string;
+        }) => Promise<{
+            build: WorkspaceBuild;
+        }>;
+        buildFromContext: (workspaceId: string, input: {
+            contextBlobKey: string;
+            dockerfilePath?: string;
+        }) => Promise<{
+            build: WorkspaceBuild;
+        }>;
+    };
+    desktopRuntimes: {
+        /** options.agentId — only runtimes BOUND to that agent (exact filter). */
+        list: (options?: {
+            agentId?: string;
+        }) => Promise<DesktopRuntime[]>;
+        get: (id: string) => Promise<{
+            desktopRuntime: DesktopRuntime;
+        }>;
+        rename: (id: string, name: string) => Promise<{
+            desktopRuntime: DesktopRuntime;
+        }>;
+        /** Bind the runtime to one agent (null unbinds). While bound, only that
+         * agent's runs/sessions may execute on the runtime. */
+        bind: (id: string, agentId: string | null) => Promise<{
+            desktopRuntime: DesktopRuntime;
+        }>;
+        grants: (id: string) => Promise<{
+            grants: DesktopRuntimeGrant[];
+        }>;
+        grant: (id: string, agentId: string, permission: DesktopRuntimePermission) => Promise<{
+            grant: DesktopRuntimeGrant;
+        }>;
+        revokeGrant: (id: string, agentId: string) => Promise<{
+            ok: boolean;
+        }>;
+        browse: (id: string, input?: {
+            path?: string;
+            dirsOnly?: boolean;
+        }) => Promise<{
+            entries: Array<Record<string, unknown>>;
+        }>;
+        read: (id: string, path: string) => Promise<{
+            path: string;
+            sizeBytes: number;
+            content?: string;
+            contentBase64?: string;
+            mime?: string;
+        }>;
+        ports: (id: string, known?: string) => Promise<{
+            ports?: RuntimePort[];
+            hash: string;
+            unchanged?: boolean;
+        }>;
+        attach: (id: string, input: {
+            name: string;
+            contentBase64: string;
+        }) => Promise<{
+            path: string;
+        }>;
+        terminalTicket: (id: string) => Promise<{
+            ticket: string;
+        }>;
+        reveal: (id: string, input: {
+            path: string;
+            app?: "finder" | "editor" | "terminal";
+        }) => Promise<{
+            exitCode: number;
+            stdout: string;
+            stderr: string;
+        }>;
+        disconnect: (id: string) => Promise<{
+            ok: true;
+        }>;
+    };
+};
+type NodusClient = ReturnType<typeof createNodus>;
+declare const NODUS_SDK_VERSION = "0.4.0-preview.47";
+declare function getNodusFeatureManifest(): {
+    workspaceCredentialFailover: boolean;
+    fixedSessionIdentity: boolean;
+    persistentSessionSnapshots: boolean;
+    runtimeResourceTelemetry: boolean;
+    cliIntrospection: boolean;
+    inlineRunResources: boolean;
+    sessionAttachments: boolean;
+    providers: readonly ["claude", "codex", "grok", "gemini", "cursor", "factory"];
+};
+declare function getNodusCliManifest(): readonly [{
+    readonly command: "nodus login|auth status|logout";
+    readonly description: "Authorize the CLI in a browser and manage local credential profiles.";
+}, {
+    readonly command: "nodus sdk";
+    readonly description: "List installed SDK methods, features, and CLI commands.";
+}, {
+    readonly command: "nodus capabilities";
+    readonly description: "Alias for `nodus sdk`.";
+}, {
+    readonly command: "nodus agents list|quota|configure|concurrency";
+    readonly description: "Inspect and configure every Agent available to the SDK key.";
+}, {
+    readonly command: "nodus agents deploy --provider <provider> --api-key <key> [--name <displayName>] [--owner-tag <tag>]";
+    readonly description: "Create an Agent in the key's Workspace and authenticate it with a provider API key.";
+}, {
+    readonly command: "nodus run --agent <id> --prompt <text> [--goal-file <markdown>] [--attach <file>]... [--wait]";
+    readonly description: "Run one task on a specific Agent. Goal Markdown is stored separately from the initial prompt.";
+}, {
+    readonly command: "nodus run --provider <provider> [--model <model>] --prompt <text> [--goal-file <markdown>] [--attach <file>]... [--wait]";
+    readonly description: "Let a Workspace key route a task; --goal-file enables Codex Goal mode.";
+}, {
+    readonly command: "nodus runs list|get|events|cancel|artifact";
+    readonly description: "Inspect and control existing Agent Runs, including artifact download URLs.";
+}, {
+    readonly command: "nodus session list|create|get|run|exec|events|telemetry|telemetry-history|diff|ports|git|terminal-ticket|pause|resume|destroy";
+    readonly description: "List, create, observe, and control persistent or temporary runtime Sessions.";
+}, {
+    readonly command: "nodus workspace create|list|get|revisions|archive|build";
+    readonly description: "Create, inspect, archive, and build persistent Workspace runtimes.";
+}, {
+    readonly command: "nodus workspace builder start|exec|put|get|files|status|publish|destroy";
+    readonly description: "Build and publish Workspace revisions interactively.";
+}, {
+    readonly command: "nodus desktop connect|list|get|rename|browse|read|ports|attach|reveal|terminal-ticket|disconnect";
+    readonly description: "Attach, inspect, control, or disconnect a local Desktop runtime.";
+}, {
+    readonly command: "nodus desktop bind --desktop <id> [--agent <id>|--none]";
+    readonly description: "Bind a Desktop runtime to one Agent (only that Agent's runs/sessions may use it) or unbind it.";
+}];
+declare function listNodusCapabilities(client: NodusClient): string[];
+
+export { type Agent, type AgentCreateInput, type AgentProvider, type AgentQuota, type AgentRun, type AgentRunArtifact, type AgentRunCreateInput, type AgentRunInputResource, type AgentRunMetadata, type AgentRunMode, type AgentRunResource, type AgentRunStatus, type AgentRunSummary, type AgentRunUsage, type CredentialProvider, type DesktopRuntime, type DesktopRuntimeGrant, type DesktopRuntimePermission, NODUS_SDK_VERSION, type NodusClient, NodusError, type QuotaWindow, type ReasoningEffort, type RuntimeDiff, type RuntimeEvent, type RuntimePort, type RuntimeSession, type RuntimeTelemetry, type RuntimeTelemetryPoint, type RuntimeTurn, type RuntimeTurnResult, type SessionAttachment, type WorkspaceBuild, type WorkspaceRevision, type WorkspaceRuntime, createNodus, getNodusCliManifest, getNodusFeatureManifest, listNodusCapabilities };