@borgee/agents-host 0.2.73 → 0.2.84

package/dist/providers/copilot/sdk-session.d.ts

@@ -0,0 +1,149 @@
+import type { ActiveSession, ContentBlock } from '@agentclientprotocol/sdk';
+import { type MessageOptions, type PermissionHandler, type ResumeSessionConfig, type SessionConfig, type SessionEventHandler } from '@github/copilot-sdk';
+import type { ProviderBackgroundRunProgress } from '../../types.js';
+type CopilotSessionUpdate = Awaited<ReturnType<ActiveSession['nextUpdate']>>;
+type CopilotPromptResponse = Awaited<ReturnType<ActiveSession['prompt']>>;
+interface CopilotSdkTaskInfo {
+    id: string;
+    type: 'agent' | 'shell';
+    status: 'running' | 'idle' | 'completed' | 'failed' | 'cancelled';
+    description?: string;
+    startedAt?: string;
+    completedAt?: string;
+    activeStartedAt?: string;
+    idleSince?: string;
+    executionMode?: 'sync' | 'background';
+    error?: string;
+}
+export interface CopilotBackgroundExecutionState {
+    startedAt: number;
+    terminal: boolean;
+    waiting: boolean;
+    activeStartedAt?: number;
+    terminalAt?: number;
+}
+export interface CopilotSdkSessionLike {
+    readonly sessionId: string;
+    readonly rpc: {
+        interruptMainTurn(params: {
+            flushQueued?: boolean;
+        }): Promise<{
+            interrupted: boolean;
+        }>;
+        cancelAllBackgroundAgents(): Promise<number>;
+        tasks: {
+            list(): Promise<{
+                tasks: CopilotSdkTaskInfo[];
+            }>;
+            cancel(params: {
+                id: string;
+            }): Promise<{
+                cancelled: boolean;
+            }>;
+        };
+        shutdown(params: {
+            type?: 'routine' | 'error';
+            reason?: string;
+        }): Promise<void>;
+    };
+    on(handler: SessionEventHandler): () => void;
+    send(options: MessageOptions): Promise<string>;
+    disconnect(): Promise<void>;
+}
+export interface CopilotSdkClientLike {
+    start(): Promise<void>;
+    stop(): Promise<Error[]>;
+    forceStop(): Promise<void>;
+    createSession(config: SessionConfig): Promise<CopilotSdkSessionLike>;
+    resumeSession(sessionId: string, config: ResumeSessionConfig): Promise<CopilotSdkSessionLike>;
+}
+export type CopilotSdkClientFactory = (command: string, cwd: string, debug: boolean) => CopilotSdkClientLike;
+export declare function resolveCopilotCommandPath(command: string, cwd?: string, env?: NodeJS.ProcessEnv): string;
+export declare function createCopilotSdkRuntimeConnection(commandPath: string): import("@github/copilot-sdk").StdioRuntimeConnection;
+export declare const createCopilotSdkClient: CopilotSdkClientFactory;
+export declare function createCopilotSdkSessionConfig(cwd: string, onPermissionRequest: PermissionHandler): SessionConfig;
+export interface CopilotAutonomousReply {
+    eventId: string;
+    text: string;
+}
+export declare function toCopilotBackgroundRunProgress(task: CopilotSdkTaskInfo, explicitWait?: {
+    reason: string;
+}, executionStartedAt?: number): ProviderBackgroundRunProgress | undefined;
+export declare class CopilotSdkSessionAdapter {
+    private readonly session;
+    private readonly onBackgroundRun;
+    private readonly onBackgroundAgentPresenceChanged;
+    private readonly onBackgroundRunError;
+    private readonly onAutonomousReply;
+    private readonly onAutonomousTurnPresenceChanged;
+    private readonly onBackgroundTaskExecutionsChanged;
+    readonly transport = "sdk";
+    private readonly pendingUpdates;
+    private readonly updateWaiters;
+    private readonly unsubscribe;
+    private activeTurn?;
+    private currentRootTurnId?;
+    private lastRootTurnId?;
+    private backgroundAgentsActive;
+    private backgroundTaskRefresh;
+    private backgroundTaskRefreshFailures;
+    private backgroundTaskRefreshRetry?;
+    private readonly reportedBackgroundTasks;
+    private readonly autonomousTurns;
+    private readonly autonomousTurnIdByRuntimeTurnId;
+    private readonly autonomousTurnIdByInteractionId;
+    private readonly backgroundCompletionSignals;
+    private backgroundCompletionSignalExpiry?;
+    private autonomousTurnPending;
+    private readonly backgroundTaskExecutions;
+    private backgroundTaskExecutionsDirty;
+    private readonly backgroundWaits;
+    private lastSyntheticExecutionStartedAt;
+    private closePromise?;
+    constructor(session: CopilotSdkSessionLike, onBackgroundRun: (run: ProviderBackgroundRunProgress) => void, onBackgroundAgentPresenceChanged: (active: boolean) => void, onBackgroundRunError: (error: Error) => void, onAutonomousReply: (reply: CopilotAutonomousReply) => void, onAutonomousTurnPresenceChanged: (active: boolean) => void, initialBackgroundTaskExecutions?: Readonly<Record<string, CopilotBackgroundExecutionState>>, onBackgroundTaskExecutionsChanged?: (executions: Readonly<Record<string, CopilotBackgroundExecutionState>>) => Promise<void>);
+    get sessionId(): string;
+    prompt(input: string | ContentBlock[]): Promise<CopilotPromptResponse>;
+    nextUpdate(): Promise<CopilotSessionUpdate>;
+    interruptMainTurn(): Promise<boolean>;
+    cancelAllBackgroundWork(): Promise<boolean>;
+    cancelBackgroundRun(providerRunId: string): Promise<boolean>;
+    hasBackgroundAgents(): Promise<boolean>;
+    backgroundTaskExecutionState(): Readonly<Record<string, CopilotBackgroundExecutionState>>;
+    reconcileBackgroundTasks(): Promise<void>;
+    close(reason?: Error): Promise<void>;
+    private emitUpdate;
+    private queueBackgroundTaskRefresh;
+    /**
+     * Completion signals and their autonomous root turns are separate SDK event
+     * streams and may arrive in either order. A short-lived signal confirms an
+     * otherwise unowned root turn; only that root turn's assistant messages are
+     * eligible for delivery outside the foreground prompt.
+     */
+    private noteBackgroundCompletion;
+    private isAutonomousCompletionMessage;
+    private beginAutonomousTurn;
+    private createAutonomousTurn;
+    private bindAutonomousTurn;
+    private findAutonomousTurn;
+    private consumeBackgroundCompletionSignal;
+    private pruneBackgroundCompletionSignals;
+    private scheduleBackgroundCompletionSignalExpiry;
+    private refreshAutonomousTurnPresence;
+    private resolveBackgroundExecutionStartedAt;
+    private handleEvent;
+    private handleAutonomousTurnEvent;
+    private finishAutonomousTurn;
+    private discardAutonomousTurn;
+    private handleBackgroundAgentEvent;
+    private recordBackgroundWait;
+    private resolveBackgroundWait;
+    private backgroundWaitFor;
+    private handleOwnedTurnEvent;
+    private interruptAttachedTurn;
+    private finishActiveTurn;
+    private resolveEventTurnId;
+    private noteTurnBoundary;
+    private isPromptUserMessage;
+    private readUserMessageTurnId;
+}
+export {};