subharness 0.0.4 → 0.0.7

package/dist/adapters/copilot.d.ts

@@ -0,0 +1,108 @@
+import type { CopilotClientOptions, CurrentModel, GetAuthStatusResponse, ModelInfo, SessionConfig, SessionEvent } from "@github/copilot-sdk";
+import type { AdapterOptions, NativeSession } from "./types.js";
+type PermissionResult = {
+    readonly kind: string;
+};
+type AllowedModels = {
+    readonly allowedModels?: string[];
+    readonly effectiveAllowedModels?: string[];
+    readonly fallbackModel?: string;
+    readonly modelId?: string;
+};
+type CopilotEndpoint = {
+    readonly type: string;
+    readonly wireApi?: string;
+    readonly transport?: string;
+    readonly baseUrl: string;
+    readonly apiKey?: string;
+    readonly headers: Record<string, string | undefined>;
+    readonly sessionToken?: unknown;
+};
+export interface CopilotNativeSession {
+    readonly sessionId: string;
+    readonly rpc: {
+        readonly model: {
+            getCurrent(): Promise<CurrentModel>;
+            setAllowedModels(params: {
+                allowedModels: string[];
+            }): Promise<AllowedModels>;
+        };
+        readonly provider: {
+            getEndpoint(params?: {
+                modelId?: string;
+            }): Promise<CopilotEndpoint>;
+        };
+        readonly permissions: {
+            setMode(params: {
+                mode: "manual";
+            }): Promise<{
+                success: boolean;
+                mode: string;
+            }>;
+            setRequired(params: {
+                required: boolean;
+            }): Promise<{
+                success: boolean;
+            }>;
+            handlePendingPermissionRequest(params: {
+                requestId: string;
+                result: {
+                    kind: string;
+                };
+            }): Promise<PermissionResult>;
+        };
+        readonly metadata: {
+            isProcessing(): Promise<{
+                processing: boolean;
+            }>;
+            activity(): Promise<{
+                abortable: boolean;
+                hasActiveWork: boolean;
+            }>;
+        };
+        readonly tools: {
+            getBuiltinDescriptors(params: Record<string, never>): Promise<{
+                tools: Array<{
+                    name: string;
+                }>;
+            }>;
+            initializeAndValidate(): Promise<Record<string, never>>;
+            getCurrentMetadata(): Promise<{
+                tools: Array<{
+                    name: string;
+                }> | null;
+            }>;
+        };
+        abort(params?: Record<string, never>): Promise<{
+            success: boolean;
+        }>;
+    };
+    on(handler: (event: SessionEvent) => void): () => void;
+    send(options: unknown): Promise<string>;
+    disconnect(): Promise<void>;
+}
+export interface CopilotNativeClient {
+    start(): Promise<void>;
+    createSession(config: SessionConfig): Promise<CopilotNativeSession>;
+    deleteSession(sessionId: string): Promise<void>;
+    stop(): Promise<Error[]>;
+    forceStop(): Promise<void>;
+    ping(message?: string): Promise<{
+        message: string;
+        timestamp: string;
+        protocolVersion?: number;
+    }>;
+    getAuthStatus(): Promise<GetAuthStatusResponse>;
+    listModels(): Promise<ModelInfo[]>;
+}
+export interface CopilotDependencies {
+    createClient(options: CopilotClientOptions): CopilotNativeClient;
+    cancellationTimeoutMs?: number;
+    cleanupTimeoutMs?: number;
+    healthIntervalMs?: number;
+    healthTimeoutMs?: number;
+}
+export declare const openCopilot: (options: AdapterOptions) => Promise<NativeSession>;
+/** Dependency injection replaces only the native SDK/runtime boundary in tests. */
+export declare function createCopilotOpener(deps: CopilotDependencies): (options: AdapterOptions) => Promise<NativeSession>;
+export {};