@cuylabs/agent-server 0.10.0

package/dist/index.d.ts

@@ -0,0 +1,893 @@
+import * as _cuylabs_agent_core from '@cuylabs/agent-core';
+import { PluginCommandMetadata, FileEntry, Message, TokenUsage, QueuedFollowUpRecord, FollowUpStatus, AgentEvent, ApprovalAction, ApprovalRememberScope, HumanInputResponse, ApprovalRequest, HumanInputRequest, SteeringResponse, FollowUpResponse, FollowUpDecisionAction, FollowUpPolicy, PendingIntervention, SessionInfo, SessionStorage, Agent } from '@cuylabs/agent-core';
+import { CoordinatorNotificationKind, CoordinatorNotification } from '@cuylabs/agent-core/team';
+import { EventBus } from '@cuylabs/agent-core/events';
+import { Readable, Writable } from 'node:stream';
+import { Server } from 'node:http';
+import { Server as Server$1 } from 'node:https';
+
+type Unsubscribe = () => void;
+type AgentServerTransportKind = "in-process" | "stdio" | "websocket" | "http";
+type AgentServerExecutionMode = "local" | "remote" | "hybrid";
+type AgentServerDurabilityMode = "process" | "workflow";
+type AgentServerOrchestrationBackend = "direct" | "agent-runtime" | "agent-runtime-dapr";
+interface AppPluginCommandInfo {
+    pluginId?: string;
+    name: string;
+    alias: string[];
+    summary: string;
+    metadata?: PluginCommandMetadata;
+}
+interface AgentServerPluginCommand extends AppPluginCommandInfo {
+    execute(args: string): Promise<string | null> | string | null;
+}
+interface AppToolInfo {
+    id: string;
+}
+interface AppSkillInfo {
+    name: string;
+    description: string;
+    scope: string;
+    filePath?: string;
+    tags: string[];
+}
+interface AppSubAgentProfileInfo {
+    name: string;
+    description: string;
+    source: "builtin" | "user" | "project" | "config";
+    filePath?: string;
+    maxSteps?: number;
+    allowFurtherDispatch?: boolean;
+}
+interface AppModelState {
+    label: string;
+    switchable: boolean;
+}
+interface AppWorkspaceSummarySnapshot {
+    workspace: {
+        cwd: string;
+        sessionCount: number;
+    };
+    agent: {
+        modelLabel: string;
+        switchable: boolean;
+        toolCount: number;
+        skillCount: number;
+        subAgentCount: number;
+    };
+}
+interface AppRuntimeStatusSnapshot {
+    session: {
+        selectedId: string;
+        loadedId?: string;
+        messageCount: number;
+        leafId?: string;
+        cwd?: string;
+        title?: string;
+    };
+    model: {
+        id: string;
+        provider?: string;
+    };
+    context: {
+        tokens: number;
+        limit: number;
+        available: number;
+        utilizationPercent: number;
+        isOverflowing: boolean;
+        shouldPrune: boolean;
+    };
+}
+type AppModelSwitchResult = {
+    ok: true;
+    label: string;
+} | {
+    ok: false;
+    error?: string;
+};
+interface AppContextCompactionResult {
+    removedCount: number;
+    tokensRemoved: number;
+    summarized: boolean;
+    summary?: string;
+}
+interface AppUndoFailure {
+    path: string;
+    reason: string;
+}
+interface AppUndoResult {
+    restored: string[];
+    failed: AppUndoFailure[];
+}
+type AppSessionRuntimeStatus = "idle" | "running";
+type AppTurnStatus = "running" | "completed" | "failed" | "interrupted";
+interface AppSessionRuntime {
+    status: AppSessionRuntimeStatus;
+    activeTurnCount: number;
+    activeTurnIds: string[];
+    lastTurnId?: string;
+}
+interface AppSessionSummary {
+    id: string;
+    cwd: string;
+    createdAt: string;
+    updatedAt: string;
+    messageCount: number;
+    title?: string;
+    name?: string;
+    parentSessionId?: string;
+    preview?: string;
+    runtime: AppSessionRuntime;
+}
+interface AppSessionDetail extends AppSessionSummary {
+    leafId?: string;
+    entries: FileEntry[];
+    messages: Message[];
+}
+interface AppTurnEventRecord {
+    sequence: number;
+    timestamp: string;
+    event: AgentEvent;
+}
+interface AppTurnSnapshot {
+    id: string;
+    sessionId: string;
+    message: string;
+    startedAt: string;
+    status: AppTurnStatus;
+    completedAt?: string;
+    output?: string;
+    usage?: TokenUsage;
+    error?: string;
+    queuedFollowUps?: QueuedFollowUpRecord[];
+}
+interface AppTurnDetail extends AppTurnSnapshot {
+    events: AppTurnEventRecord[];
+}
+interface CreateSessionOptions {
+    id?: string;
+    cwd?: string;
+    title?: string;
+}
+interface BranchSessionOptions {
+    leafId?: string;
+    summary?: string;
+}
+interface StartTurnOptions {
+    system?: string;
+}
+interface AppApprovalInputRequest {
+    id: string;
+    kind: "approval";
+    sessionId: string;
+    turnId?: string;
+    createdAt: string;
+    request: ApprovalRequest;
+}
+interface AppHumanInputRequest {
+    id: string;
+    kind: "human";
+    sessionId: string;
+    turnId?: string;
+    createdAt: string;
+    request: HumanInputRequest;
+}
+interface ResolveApprovalInputPayload {
+    kind: "approval";
+    action: ApprovalAction;
+    feedback?: string;
+    rememberScope?: ApprovalRememberScope;
+}
+interface ResolveHumanInputPayload {
+    kind: "human";
+    response: HumanInputResponse;
+}
+type AppInputRequest = AppApprovalInputRequest | AppHumanInputRequest;
+type ResolveInputRequestPayload = ResolveApprovalInputPayload | ResolveHumanInputPayload;
+type AppTeamNotification = CoordinatorNotification;
+interface AppTeamNotificationListOptions {
+    teamId?: string;
+    memberId?: string;
+    kind?: CoordinatorNotificationKind | CoordinatorNotificationKind[];
+}
+interface WaitForTurnOptions {
+    timeoutMs?: number;
+}
+interface AppFollowUpListOptions {
+    sessionId?: string;
+    sourceTurnId?: string;
+    status?: FollowUpStatus | FollowUpStatus[];
+}
+
+interface AgentServerCapabilities {
+    protocol: {
+        version: 1;
+        transport: AgentServerTransportKind;
+        reconnectable: boolean;
+        multiClient: boolean;
+    };
+    sessions: {
+        persistent: boolean;
+        list: boolean;
+        create: boolean;
+        read: boolean;
+        delete: boolean;
+        branch: boolean;
+    };
+    turns: {
+        start: boolean;
+        wait: boolean;
+        interrupt: boolean;
+        steer: boolean;
+        followUp: boolean;
+        followUpManagement: boolean;
+        eventStreaming: boolean;
+        concurrentTurnsPerSession: boolean;
+    };
+    interactive: {
+        approvalRequests: boolean;
+        humanRequests: boolean;
+    };
+    runtime: {
+        execution: AgentServerExecutionMode;
+        orchestration: AgentServerOrchestrationBackend;
+        durability: AgentServerDurabilityMode;
+        dapr: {
+            available: boolean;
+            delegatedTurns: boolean;
+            workflowBacked: boolean;
+        };
+    };
+    agent: {
+        workspaceSummary: boolean;
+        toolInventory: boolean;
+        skillInspection: boolean;
+        subAgentInspection: boolean;
+        modelInspection: boolean;
+        modelSwitch: boolean;
+        runtimeStatus: boolean;
+        contextCompaction: boolean;
+        turnUndo: boolean;
+        turnDiff: boolean;
+    };
+    plugins: {
+        headlessOnly: boolean;
+        commandMetadata: boolean;
+        commandDiscovery: boolean;
+        commandExecution: boolean;
+        clientExtensions: boolean;
+    };
+    events: {
+        eventBus: boolean;
+        pubSubBridge: boolean;
+        sseStreaming: boolean;
+        eventReplay: boolean;
+    };
+}
+interface AgentServerCapabilitiesPatch {
+    protocol?: Partial<AgentServerCapabilities["protocol"]>;
+    sessions?: Partial<AgentServerCapabilities["sessions"]>;
+    turns?: Partial<AgentServerCapabilities["turns"]>;
+    interactive?: Partial<AgentServerCapabilities["interactive"]>;
+    runtime?: Partial<Omit<AgentServerCapabilities["runtime"], "dapr">> & {
+        dapr?: Partial<AgentServerCapabilities["runtime"]["dapr"]>;
+    };
+    agent?: Partial<AgentServerCapabilities["agent"]>;
+    plugins?: Partial<AgentServerCapabilities["plugins"]>;
+    events?: Partial<AgentServerCapabilities["events"]>;
+}
+declare function createDefaultAgentServerCapabilities(): AgentServerCapabilities;
+declare function mergeAgentServerCapabilities(base: AgentServerCapabilities, override?: AgentServerCapabilitiesPatch): AgentServerCapabilities;
+
+interface AgentServerSubscriptionOptions {
+    sessionId?: string;
+    turnId?: string;
+    teamId?: string;
+}
+type AgentServerNotification = {
+    type: "session/created";
+    session: AppSessionSummary;
+} | {
+    type: "session/deleted";
+    sessionId: string;
+} | {
+    type: "session/branched";
+    sessionId: string;
+    leafId: string;
+    summary?: string;
+} | {
+    type: "session/runtime";
+    sessionId: string;
+    runtime: AppSessionRuntime;
+} | {
+    type: "turn/started";
+    turn: AppTurnSnapshot;
+} | {
+    type: "turn/event";
+    sessionId: string;
+    turnId: string;
+    sequence: number;
+    timestamp: string;
+    event: AgentEvent;
+} | {
+    type: "input/request";
+    request: AppInputRequest;
+} | {
+    type: "input/resolved";
+    requestId: string;
+    sessionId: string;
+    turnId?: string;
+} | {
+    type: "team/notification";
+    teamId: string;
+    notification: AppTeamNotification;
+} | {
+    type: "turn/completed";
+    turn: AppTurnSnapshot;
+};
+/**
+ * Returns true when `notification` matches the given subscription filter.
+ * Used by both the in-process server and the remote client.
+ */
+declare function matchesNotificationSubscription(notification: AgentServerNotification, options?: AgentServerSubscriptionOptions): boolean;
+
+interface AgentServerAdapter {
+    readonly cwd: string;
+    getCapabilities?(): AgentServerCapabilitiesPatch;
+    getModelState?(): Promise<AppModelState> | AppModelState;
+    switchModel?(spec: string): Promise<AppModelSwitchResult> | AppModelSwitchResult;
+    getSessionRuntimeStatus?(sessionId: string): Promise<AppRuntimeStatusSnapshot> | AppRuntimeStatusSnapshot;
+    listTools?(): Promise<AppToolInfo[]> | AppToolInfo[];
+    listSkills?(): Promise<AppSkillInfo[]> | AppSkillInfo[];
+    listSubAgents?(): Promise<AppSubAgentProfileInfo[]> | AppSubAgentProfileInfo[];
+    compactSessionContext?(sessionId: string): Promise<AppContextCompactionResult> | AppContextCompactionResult;
+    undoSessionTurn?(sessionId: string): Promise<AppUndoResult> | AppUndoResult;
+    getSessionTurnDiff?(sessionId: string): Promise<string | null> | string | null;
+    chat(sessionId: string, message: string, options?: StartTurnOptions & {
+        abort?: AbortSignal;
+    }): AsyncGenerator<AgentEvent>;
+    followUpPolicy?: FollowUpPolicy;
+    steer?(request: {
+        sessionId: string;
+        turnId: string;
+        message: string;
+    }): SteeringResponse;
+    followUp?(request: {
+        sessionId: string;
+        turnId: string;
+        message: string;
+    }): FollowUpResponse;
+    interruptTurn?(request: {
+        sessionId: string;
+        turnId: string;
+    }): void | Promise<void>;
+    respondToInputRequest?(requestId: string, payload: ResolveInputRequestPayload): void | Promise<void>;
+    drainQueuedFollowUps?(): PendingIntervention[];
+    listFollowUps?(options?: AppFollowUpListOptions): Promise<QueuedFollowUpRecord[]> | QueuedFollowUpRecord[];
+    getFollowUp?(followUpId: string): Promise<QueuedFollowUpRecord | null> | QueuedFollowUpRecord | null;
+    resolveFollowUp?(followUpId: string, action: FollowUpDecisionAction): Promise<QueuedFollowUpRecord | null> | QueuedFollowUpRecord | null;
+    listTeamNotifications?(options?: AppTeamNotificationListOptions): Promise<AppTeamNotification[]> | AppTeamNotification[];
+    subscribeTeamNotifications?(listener: (notification: AppTeamNotification) => void): Unsubscribe;
+    listSessions(): Promise<SessionInfo[]>;
+    deleteSession(sessionId: string): Promise<boolean>;
+    getSessionStorage(): SessionStorage;
+    listPluginCommands?(): Promise<AppPluginCommandInfo[]> | AppPluginCommandInfo[];
+    executePluginCommand?(name: string, args: string): Promise<string | null> | string | null;
+}
+interface AgentServer {
+    getCapabilities(): AgentServerCapabilities;
+    getWorkspaceSummary(): Promise<AppWorkspaceSummarySnapshot>;
+    getModelState(): Promise<AppModelState>;
+    switchModel(spec: string): Promise<AppModelSwitchResult>;
+    getSessionRuntimeStatus(sessionId: string): Promise<AppRuntimeStatusSnapshot>;
+    listTools(): Promise<AppToolInfo[]>;
+    listSkills(): Promise<AppSkillInfo[]>;
+    listSubAgents(): Promise<AppSubAgentProfileInfo[]>;
+    compactSessionContext(sessionId: string): Promise<AppContextCompactionResult>;
+    undoSessionTurn(sessionId: string): Promise<AppUndoResult>;
+    getSessionTurnDiff(sessionId: string): Promise<string | null>;
+    listPluginCommands(): Promise<AppPluginCommandInfo[]>;
+    executePluginCommand(name: string, args: string): Promise<string | null>;
+    listSessions(): Promise<AppSessionSummary[]>;
+    createSession(options?: CreateSessionOptions): Promise<AppSessionDetail>;
+    readSession(sessionId: string): Promise<AppSessionDetail | null>;
+    deleteSession(sessionId: string): Promise<boolean>;
+    branchSession(sessionId: string, options?: BranchSessionOptions): Promise<{
+        sessionId: string;
+        leafId: string;
+    }>;
+    startTurn(sessionId: string, message: string, options?: StartTurnOptions): Promise<AppTurnSnapshot>;
+    steerTurn(turnId: string, message: string): SteeringResponse;
+    followUpTurn(turnId: string, message: string): FollowUpResponse;
+    listFollowUps(options?: AppFollowUpListOptions): Promise<QueuedFollowUpRecord[]>;
+    getFollowUp(followUpId: string): Promise<QueuedFollowUpRecord | null>;
+    resolveFollowUp(followUpId: string, action: FollowUpDecisionAction): Promise<QueuedFollowUpRecord | null>;
+    listTeamNotifications(options?: AppTeamNotificationListOptions): Promise<AppTeamNotification[]>;
+    getTurn(turnId: string): AppTurnDetail | null;
+    waitForTurn(turnId: string, options?: WaitForTurnOptions): Promise<AppTurnSnapshot>;
+    interruptTurn(turnId: string): boolean;
+    respondToInputRequest(requestId: string, payload: ResolveInputRequestPayload): boolean;
+    subscribe(listener: (notification: AgentServerNotification) => void, options?: AgentServerSubscriptionOptions): Unsubscribe;
+    close(): Promise<void>;
+}
+interface AgentServerClient extends AgentServer {
+    disconnect(): Promise<void>;
+}
+
+declare function createAgentServerAdapter(agent: Agent, options?: {
+    pluginCommands?: AgentServerPluginCommand[];
+    currentModelLabel?: string;
+    switchModel?: (spec: string) => Promise<AppModelSwitchResult> | AppModelSwitchResult;
+    listSkills?: () => Promise<AppSkillInfo[]> | AppSkillInfo[];
+    listSubAgents?: () => Promise<AppSubAgentProfileInfo[]> | AppSubAgentProfileInfo[];
+    listTeamNotifications?: (options?: AppTeamNotificationListOptions) => Promise<AppTeamNotification[]> | AppTeamNotification[];
+    subscribeTeamNotifications?: (listener: (notification: AppTeamNotification) => void) => Unsubscribe;
+    capabilities?: AgentServerCapabilitiesPatch;
+}): AgentServerAdapter;
+
+type AgentServerWireRequestMethod = "initialize" | "capabilities/get" | "workspace/summary" | "agent/model/get" | "agent/model/switch" | "session/status" | "agent/tools" | "agent/skills" | "agent/sub-agents" | "plugin-command/list" | "plugin-command/execute" | "session/compact" | "session/undo" | "session/diff" | "session/list" | "session/create" | "session/read" | "session/delete" | "session/branch" | "turn/start" | "turn/get" | "turn/wait" | "turn/interrupt" | "turn/steer" | "turn/follow-up" | "follow-up/list" | "follow-up/get" | "follow-up/resolve" | "team/notification/list" | "input/respond";
+type AgentServerWireRequest = {
+    method: "initialize";
+    params?: Record<string, never>;
+} | {
+    method: "capabilities/get";
+    params?: Record<string, never>;
+} | {
+    method: "workspace/summary";
+    params?: Record<string, never>;
+} | {
+    method: "agent/model/get";
+    params?: Record<string, never>;
+} | {
+    method: "agent/model/switch";
+    params: {
+        spec: string;
+    };
+} | {
+    method: "session/status";
+    params: {
+        sessionId: string;
+    };
+} | {
+    method: "agent/tools";
+    params?: Record<string, never>;
+} | {
+    method: "agent/skills";
+    params?: Record<string, never>;
+} | {
+    method: "agent/sub-agents";
+    params?: Record<string, never>;
+} | {
+    method: "plugin-command/list";
+    params?: Record<string, never>;
+} | {
+    method: "plugin-command/execute";
+    params: {
+        name: string;
+        args?: string;
+    };
+} | {
+    method: "session/compact";
+    params: {
+        sessionId: string;
+    };
+} | {
+    method: "session/undo";
+    params: {
+        sessionId: string;
+    };
+} | {
+    method: "session/diff";
+    params: {
+        sessionId: string;
+    };
+} | {
+    method: "session/list";
+    params?: Record<string, never>;
+} | {
+    method: "session/create";
+    params?: CreateSessionOptions;
+} | {
+    method: "session/read";
+    params: {
+        sessionId: string;
+    };
+} | {
+    method: "session/delete";
+    params: {
+        sessionId: string;
+    };
+} | {
+    method: "session/branch";
+    params: {
+        sessionId: string;
+        options?: BranchSessionOptions;
+    };
+} | {
+    method: "turn/start";
+    params: {
+        sessionId: string;
+        message: string;
+        options?: StartTurnOptions;
+    };
+} | {
+    method: "turn/get";
+    params: {
+        turnId: string;
+    };
+} | {
+    method: "turn/wait";
+    params: {
+        turnId: string;
+        options?: WaitForTurnOptions;
+    };
+} | {
+    method: "turn/interrupt";
+    params: {
+        turnId: string;
+    };
+} | {
+    method: "turn/steer";
+    params: {
+        turnId: string;
+        message: string;
+    };
+} | {
+    method: "turn/follow-up";
+    params: {
+        turnId: string;
+        message: string;
+    };
+} | {
+    method: "follow-up/list";
+    params?: {
+        options?: AppFollowUpListOptions;
+    };
+} | {
+    method: "follow-up/get";
+    params: {
+        followUpId: string;
+    };
+} | {
+    method: "follow-up/resolve";
+    params: {
+        followUpId: string;
+        action: _cuylabs_agent_core.FollowUpDecisionAction;
+    };
+} | {
+    method: "team/notification/list";
+    params?: {
+        options?: AppTeamNotificationListOptions;
+    };
+} | {
+    method: "input/respond";
+    params: {
+        requestId: string;
+        payload: ResolveInputRequestPayload;
+    };
+};
+interface AgentServerInitializeResponse {
+    protocolVersion: 1;
+    capabilities: AgentServerCapabilities;
+}
+type AgentServerWireResponse = AgentServerInitializeResponse | AgentServerCapabilities | Awaited<ReturnType<AgentServer["getWorkspaceSummary"]>> | Awaited<ReturnType<AgentServer["getModelState"]>> | Awaited<ReturnType<AgentServer["switchModel"]>> | Awaited<ReturnType<AgentServer["getSessionRuntimeStatus"]>> | Awaited<ReturnType<AgentServer["listTools"]>> | Awaited<ReturnType<AgentServer["listSkills"]>> | Awaited<ReturnType<AgentServer["listSubAgents"]>> | Awaited<ReturnType<AgentServer["listPluginCommands"]>> | Awaited<ReturnType<AgentServer["executePluginCommand"]>> | Awaited<ReturnType<AgentServer["compactSessionContext"]>> | Awaited<ReturnType<AgentServer["undoSessionTurn"]>> | Awaited<ReturnType<AgentServer["getSessionTurnDiff"]>> | Awaited<ReturnType<AgentServer["listSessions"]>> | Awaited<ReturnType<AgentServer["createSession"]>> | Awaited<ReturnType<AgentServer["readSession"]>> | Awaited<ReturnType<AgentServer["deleteSession"]>> | Awaited<ReturnType<AgentServer["branchSession"]>> | Awaited<ReturnType<AgentServer["startTurn"]>> | ReturnType<AgentServer["getTurn"]> | Awaited<ReturnType<AgentServer["waitForTurn"]>> | ReturnType<AgentServer["interruptTurn"]> | ReturnType<AgentServer["steerTurn"]> | ReturnType<AgentServer["followUpTurn"]> | Awaited<ReturnType<AgentServer["listFollowUps"]>> | Awaited<ReturnType<AgentServer["getFollowUp"]>> | Awaited<ReturnType<AgentServer["resolveFollowUp"]>> | Awaited<ReturnType<AgentServer["listTeamNotifications"]>> | ReturnType<AgentServer["respondToInputRequest"]>;
+interface AgentServerWireRequestEnvelope {
+    kind: "request";
+    id: string;
+    method: AgentServerWireRequestMethod;
+    params?: unknown;
+}
+interface AgentServerWireResponseEnvelope {
+    kind: "response";
+    id: string;
+    ok: boolean;
+    result?: AgentServerWireResponse;
+    error?: {
+        message: string;
+    };
+}
+interface AgentServerWireNotificationEnvelope {
+    kind: "notification";
+    notification: AgentServerNotification;
+}
+type AgentServerWireEnvelope = AgentServerWireRequestEnvelope | AgentServerWireResponseEnvelope | AgentServerWireNotificationEnvelope;
+declare function isAgentServerWireEnvelope(value: unknown): value is AgentServerWireEnvelope;
+
+interface ResolvedApprovalDecision$1 {
+    action: ApprovalAction;
+    feedback?: string;
+    rememberScope?: ApprovalRememberScope;
+}
+
+interface InProcessAgentServerOptions {
+    followUpPolicy?: FollowUpPolicy;
+    eventBus?: EventBus;
+}
+declare class InProcessAgentServer implements AgentServer {
+    private readonly adapter;
+    private readonly capabilities;
+    private readonly followUpPolicy;
+    private readonly eventBus;
+    private readonly turns;
+    private readonly followUps;
+    private readonly sessionRuntime;
+    private readonly listeners;
+    private readonly pendingInputs;
+    private teamNotificationUnsubscribe;
+    constructor(adapter: AgentServerAdapter, options?: InProcessAgentServerOptions);
+    getCapabilities(): AgentServerCapabilities;
+    getWorkspaceSummary(): Promise<AppWorkspaceSummarySnapshot>;
+    getSessionRuntimeStatus(sessionId: string): Promise<AppRuntimeStatusSnapshot>;
+    getModelState(): Promise<AppModelState>;
+    switchModel(spec: string): Promise<AppModelSwitchResult>;
+    listTools(): Promise<AppToolInfo[]>;
+    listSkills(): Promise<AppSkillInfo[]>;
+    listSubAgents(): Promise<AppSubAgentProfileInfo[]>;
+    listPluginCommands(): Promise<AppPluginCommandInfo[]>;
+    executePluginCommand(name: string, args: string): Promise<string | null>;
+    compactSessionContext(sessionId: string): Promise<AppContextCompactionResult>;
+    undoSessionTurn(sessionId: string): Promise<AppUndoResult>;
+    getSessionTurnDiff(sessionId: string): Promise<string | null>;
+    listSessions(): Promise<AppSessionSummary[]>;
+    createSession(options?: CreateSessionOptions): Promise<AppSessionDetail>;
+    readSession(sessionId: string): Promise<AppSessionDetail | null>;
+    deleteSession(sessionId: string): Promise<boolean>;
+    branchSession(sessionId: string, options?: BranchSessionOptions): Promise<{
+        sessionId: string;
+        leafId: string;
+    }>;
+    startTurn(sessionId: string, message: string, options?: StartTurnOptions): Promise<AppTurnSnapshot>;
+    getTurn(turnId: string): AppTurnDetail | null;
+    waitForTurn(turnId: string, options?: WaitForTurnOptions): Promise<AppTurnSnapshot>;
+    steerTurn(turnId: string, message: string): SteeringResponse;
+    followUpTurn(turnId: string, message: string): FollowUpResponse;
+    listFollowUps(options?: AppFollowUpListOptions): Promise<QueuedFollowUpRecord[]>;
+    getFollowUp(followUpId: string): Promise<QueuedFollowUpRecord | null>;
+    resolveFollowUp(followUpId: string, action: FollowUpDecisionAction): Promise<QueuedFollowUpRecord | null>;
+    listTeamNotifications(options?: AppTeamNotificationListOptions): Promise<AppTeamNotification[]>;
+    interruptTurn(turnId: string): boolean;
+    respondToInputRequest(requestId: string, payload: ResolveInputRequestPayload): boolean;
+    subscribe(listener: (notification: AgentServerNotification) => void, options?: AgentServerSubscriptionOptions): Unsubscribe;
+    close(): Promise<void>;
+    requestApproval(request: ApprovalRequest): Promise<ResolvedApprovalDecision$1>;
+    requestHumanInput(request: HumanInputRequest): Promise<HumanInputResponse>;
+    private runTurn;
+    private ensureSessionExists;
+    private getOrCreateRuntimeRecord;
+    private getRuntimeSnapshot;
+    private hasRunningTurnForSession;
+    private findRunningTurnIdForSession;
+    private resolveInteractiveRequestRoute;
+    private findSessionInfo;
+    private readSessionOrThrow;
+    private emit;
+    private captureDeferredFollowUps;
+    private seedQueuedFollowUps;
+    private toTurnSnapshot;
+    private toTurnDetail;
+    private resolvePendingInputsForTurn;
+    private resolveAllPendingInputs;
+    private resolveMatchingApprovalRequests;
+    private resolvePendingInput;
+    private registerEventInputRequest;
+    private resolveEventInputRequest;
+}
+
+interface ResolvedApprovalDecision {
+    action: "allow" | "deny" | "remember";
+    feedback?: string;
+    rememberScope?: ApprovalRememberScope;
+}
+interface InteractiveRequestBridge {
+    requestApproval?(request: ApprovalRequest): Promise<ResolvedApprovalDecision>;
+    requestHumanInput?(request: HumanInputRequest): Promise<HumanInputResponse>;
+}
+declare function createServerApprovalRequestHandler(bridge: InteractiveRequestBridge): (request: ApprovalRequest) => Promise<ResolvedApprovalDecision>;
+declare function createServerHumanInputRequestHandler(bridge: InteractiveRequestBridge): (request: HumanInputRequest) => Promise<HumanInputResponse>;
+declare function createServerInteractiveHandlers(bridge: InteractiveRequestBridge): {
+    approval: (request: ApprovalRequest) => Promise<ResolvedApprovalDecision>;
+    humanInput: (request: HumanInputRequest) => Promise<HumanInputResponse>;
+};
+
+interface AgentServerRpcConnectionOptions {
+    server: AgentServer;
+    send: (envelope: AgentServerWireEnvelope) => void | Promise<void>;
+    capabilityOverride?: AgentServerCapabilitiesPatch;
+}
+declare class AgentServerRpcConnection {
+    private readonly server;
+    private readonly capabilities;
+    private readonly sendEnvelope;
+    private unsubscribe;
+    constructor(options: AgentServerRpcConnectionOptions);
+    close(): Promise<void>;
+    handleRequest(envelope: AgentServerWireRequestEnvelope): Promise<void>;
+    private dispatchRequest;
+}
+
+interface RemoteAgentServerTransport {
+    connect(): Promise<void>;
+    send(envelope: AgentServerWireEnvelope): void | Promise<void>;
+    close(): Promise<void>;
+    setMessageHandler(handler: (envelope: AgentServerWireEnvelope) => void): void;
+    setCloseHandler(handler: (error?: Error) => void): void;
+}
+declare class RemoteAgentServerClient implements AgentServerClient {
+    private readonly transport;
+    private readonly requestTimeoutMs;
+    private readonly pending;
+    private readonly listeners;
+    private readonly turns;
+    private capabilities;
+    private counter;
+    private connected;
+    constructor(transport: RemoteAgentServerTransport, options?: {
+        requestTimeoutMs?: number;
+    });
+    connect(): Promise<void>;
+    getCapabilities(): AgentServerCapabilities;
+    getWorkspaceSummary(): Promise<AppWorkspaceSummarySnapshot>;
+    getSessionRuntimeStatus(sessionId: string): Promise<AppRuntimeStatusSnapshot>;
+    getModelState(): Promise<AppModelState>;
+    switchModel(spec: string): Promise<AppModelSwitchResult>;
+    listTools(): Promise<AppToolInfo[]>;
+    listSkills(): Promise<AppSkillInfo[]>;
+    listSubAgents(): Promise<AppSubAgentProfileInfo[]>;
+    listPluginCommands(): Promise<AppPluginCommandInfo[]>;
+    executePluginCommand(name: string, args: string): Promise<string | null>;
+    compactSessionContext(sessionId: string): Promise<AppContextCompactionResult>;
+    undoSessionTurn(sessionId: string): Promise<AppUndoResult>;
+    getSessionTurnDiff(sessionId: string): Promise<string | null>;
+    listSessions(): Promise<AppSessionSummary[]>;
+    createSession(options?: CreateSessionOptions): Promise<AppSessionDetail>;
+    readSession(sessionId: string): Promise<AppSessionDetail | null>;
+    deleteSession(sessionId: string): Promise<boolean>;
+    branchSession(sessionId: string, options?: BranchSessionOptions): Promise<{
+        sessionId: string;
+        leafId: string;
+    }>;
+    startTurn(sessionId: string, message: string, options?: StartTurnOptions): Promise<AppTurnSnapshot>;
+    steerTurn(turnId: string, message: string): SteeringResponse;
+    followUpTurn(turnId: string, message: string): FollowUpResponse;
+    listFollowUps(options?: AppFollowUpListOptions): Promise<QueuedFollowUpRecord[]>;
+    getFollowUp(followUpId: string): Promise<QueuedFollowUpRecord | null>;
+    resolveFollowUp(followUpId: string, action: FollowUpDecisionAction): Promise<QueuedFollowUpRecord | null>;
+    listTeamNotifications(options?: AppTeamNotificationListOptions): Promise<AppTeamNotification[]>;
+    getTurn(turnId: string): AppTurnDetail | null;
+    waitForTurn(turnId: string, options?: WaitForTurnOptions): Promise<AppTurnSnapshot>;
+    interruptTurn(turnId: string): boolean;
+    respondToInputRequest(requestId: string, payload: ResolveInputRequestPayload): boolean;
+    subscribe(listener: (notification: AgentServerNotification) => void, options?: AgentServerSubscriptionOptions): Unsubscribe;
+    close(): Promise<void>;
+    disconnect(): Promise<void>;
+    private request;
+    private handleEnvelope;
+    private failPending;
+    private trackNotification;
+}
+
+interface StdioAgentServerOptions {
+    input?: Readable;
+    output?: Writable;
+    onError?: (error: Error) => void;
+}
+interface SpawnStdioAgentServerClientOptions {
+    command: string;
+    args?: string[];
+    cwd?: string;
+    env?: NodeJS.ProcessEnv;
+    requestTimeoutMs?: number;
+}
+declare function attachAgentServerStdio(server: AgentServer, options?: StdioAgentServerOptions): {
+    close: () => Promise<void>;
+};
+declare function connectStdioAgentServerClient(options: SpawnStdioAgentServerClientOptions): Promise<RemoteAgentServerClient>;
+
+interface AgentServerWebSocketServerOptions {
+    /**
+     * TCP port for the WebSocket server.
+     * Required when `httpServer` is not provided.
+     */
+    port?: number;
+    /** Bind hostname. Only used with `port`. */
+    host?: string;
+    /**
+     * Attach to an existing HTTP/S server instead of binding a new port.
+     * When set, `port` and `host` are ignored.
+     *
+     * This enables running WebSocket alongside REST/SSE on the same port,
+     * e.g. when composing with `@cuylabs/agent-runtime-dapr`.
+     */
+    httpServer?: Server | Server$1;
+}
+interface ConnectWebSocketAgentServerClientOptions {
+    url: string;
+    headers?: Record<string, string>;
+    requestTimeoutMs?: number;
+}
+declare function startAgentServerWebSocketServer(server: AgentServer, options: AgentServerWebSocketServerOptions): {
+    ready: Promise<void>;
+    close: () => Promise<void>;
+    address: () => string;
+};
+declare function connectWebSocketAgentServerClient(options: ConnectWebSocketAgentServerClientOptions): Promise<RemoteAgentServerClient>;
+
+/**
+ * Create an SSE `ReadableStream` that yields server notifications
+ * for a specific session as `text/event-stream` frames.
+ *
+ * Use the returned stream as the body of an HTTP `Response`:
+ *
+ * ```ts
+ * new Response(createAgentServerSSEStream(server, sessionId), {
+ *   headers: { "Content-Type": "text/event-stream", "Cache-Control": "no-cache" },
+ * });
+ * ```
+ */
+declare function createAgentServerSSEStream(server: AgentServer, sessionId: string, options?: {
+    signal?: AbortSignal;
+}): ReadableStream<Uint8Array>;
+/**
+ * Create an SSE `ReadableStream` backed by an `EventBus` channel.
+ *
+ * Supports replay via `lastEventId` — messages with a sequence
+ * number greater than `lastEventId` are replayed from the channel
+ * history before live events begin.
+ */
+declare function createEventBusSSEStream(eventBus: EventBus, channel: string, options?: {
+    lastEventId?: string;
+    signal?: AbortSignal;
+}): ReadableStream<Uint8Array>;
+/**
+ * Convenience: build a standard `Response` for an SSE endpoint.
+ */
+declare function createAgentServerSSEResponse(server: AgentServer, sessionId: string, options?: {
+    signal?: AbortSignal;
+    headers?: Record<string, string>;
+}): Response;
+
+declare function streamTurn(client: AgentServerClient, sessionId: string, message: string, options?: StartTurnOptions): AsyncGenerator<AgentServerNotification>;
+
+declare class InProcessAgentServerClient implements AgentServerClient {
+    private readonly server;
+    constructor(server: AgentServer);
+    getCapabilities(): AgentServerCapabilities;
+    getWorkspaceSummary(): Promise<AppWorkspaceSummarySnapshot>;
+    getSessionRuntimeStatus(sessionId: string): Promise<AppRuntimeStatusSnapshot>;
+    getModelState(): Promise<AppModelState>;
+    switchModel(spec: string): Promise<AppModelSwitchResult>;
+    listTools(): Promise<AppToolInfo[]>;
+    listSkills(): Promise<AppSkillInfo[]>;
+    listSubAgents(): Promise<AppSubAgentProfileInfo[]>;
+    listPluginCommands(): Promise<AppPluginCommandInfo[]>;
+    executePluginCommand(name: string, args: string): Promise<string | null>;
+    compactSessionContext(sessionId: string): Promise<AppContextCompactionResult>;
+    undoSessionTurn(sessionId: string): Promise<AppUndoResult>;
+    getSessionTurnDiff(sessionId: string): Promise<string | null>;
+    listSessions(): Promise<AppSessionSummary[]>;
+    createSession(options?: CreateSessionOptions): Promise<AppSessionDetail>;
+    readSession(sessionId: string): Promise<AppSessionDetail | null>;
+    deleteSession(sessionId: string): Promise<boolean>;
+    branchSession(sessionId: string, options?: BranchSessionOptions): Promise<{
+        sessionId: string;
+        leafId: string;
+    }>;
+    startTurn(sessionId: string, message: string, options?: StartTurnOptions): Promise<AppTurnSnapshot>;
+    steerTurn(turnId: string, message: string): SteeringResponse;
+    followUpTurn(turnId: string, message: string): FollowUpResponse;
+    listFollowUps(options?: AppFollowUpListOptions): Promise<QueuedFollowUpRecord[]>;
+    getFollowUp(followUpId: string): Promise<QueuedFollowUpRecord | null>;
+    resolveFollowUp(followUpId: string, action: FollowUpDecisionAction): Promise<QueuedFollowUpRecord | null>;
+    listTeamNotifications(options?: AppTeamNotificationListOptions): Promise<AppTeamNotification[]>;
+    getTurn(turnId: string): AppTurnDetail | null;
+    waitForTurn(turnId: string, options?: WaitForTurnOptions): Promise<AppTurnSnapshot>;
+    interruptTurn(turnId: string): boolean;
+    respondToInputRequest(requestId: string, payload: ResolveInputRequestPayload): boolean;
+    subscribe(listener: (notification: AgentServerNotification) => void, options?: AgentServerSubscriptionOptions): Unsubscribe;
+    close(): Promise<void>;
+    disconnect(): Promise<void>;
+}
+declare function createInProcessAgentServer(agent: Agent): InProcessAgentServer;
+declare function createInProcessAgentServerClient(agent: Agent): InProcessAgentServerClient;
+
+export { type AgentServer, type AgentServerAdapter, type AgentServerCapabilities, type AgentServerCapabilitiesPatch, type AgentServerClient, type AgentServerDurabilityMode, type AgentServerExecutionMode, type AgentServerInitializeResponse, type AgentServerNotification, type AgentServerOrchestrationBackend, type AgentServerPluginCommand, AgentServerRpcConnection, type AgentServerRpcConnectionOptions, type AgentServerSubscriptionOptions, type AgentServerTransportKind, type AgentServerWebSocketServerOptions, type AgentServerWireEnvelope, type AgentServerWireNotificationEnvelope, type AgentServerWireRequest, type AgentServerWireRequestEnvelope, type AgentServerWireRequestMethod, type AgentServerWireResponse, type AgentServerWireResponseEnvelope, type AppApprovalInputRequest, type AppContextCompactionResult, type AppFollowUpListOptions, type AppHumanInputRequest, type AppInputRequest, type AppModelState, type AppModelSwitchResult, type AppPluginCommandInfo, type AppRuntimeStatusSnapshot, type AppSessionDetail, type AppSessionRuntime, type AppSessionRuntimeStatus, type AppSessionSummary, type AppSkillInfo, type AppSubAgentProfileInfo, type AppTeamNotification, type AppTeamNotificationListOptions, type AppToolInfo, type AppTurnDetail, type AppTurnEventRecord, type AppTurnSnapshot, type AppTurnStatus, type AppUndoFailure, type AppUndoResult, type AppWorkspaceSummarySnapshot, type BranchSessionOptions, type ConnectWebSocketAgentServerClientOptions, type CreateSessionOptions, InProcessAgentServer, InProcessAgentServerClient, type InProcessAgentServerOptions, type InteractiveRequestBridge, RemoteAgentServerClient, type RemoteAgentServerTransport, type ResolveApprovalInputPayload, type ResolveHumanInputPayload, type ResolveInputRequestPayload, type SpawnStdioAgentServerClientOptions, type StartTurnOptions, type StdioAgentServerOptions, type Unsubscribe, type WaitForTurnOptions, attachAgentServerStdio, connectStdioAgentServerClient, connectWebSocketAgentServerClient, createAgentServerAdapter, createAgentServerSSEResponse, createAgentServerSSEStream, createDefaultAgentServerCapabilities, createEventBusSSEStream, createInProcessAgentServer, createInProcessAgentServerClient, createServerApprovalRequestHandler, createServerHumanInputRequestHandler, createServerInteractiveHandlers, isAgentServerWireEnvelope, matchesNotificationSubscription, mergeAgentServerCapabilities, startAgentServerWebSocketServer, streamTurn };