@harness-control/runner 0.1.0

package/dist/harnesses/index.d.ts

@@ -0,0 +1,93 @@
+import type { HcpHarnessEventPayload, HcpHostReplayUnavailablePayload, HcpSessionSnapshotPayload, HostResumeCursor, HostRetainedEventRanges, HcpSessionStartPayload, HcpTurnSendPayload, LocalActionRequestPayload, LocalCapabilityLease, StreamableHttpMcpServerAttachment } from "@harness-control/protocol";
+import type { AuditLogger } from "../audit/index.js";
+import type { RunnerConfig } from "../config/index.js";
+import type { ProviderDriverStatus } from "../host/provider-registry.js";
+import { LocalCapabilityEngine } from "../local-actions/index.js";
+import type { LocalCapabilityExecutionContext, LocalCapabilityExecutionEvent } from "../local-actions/executors.js";
+import { type McpProofSigner, type McpToolDescriptor } from "../mcp/McpAttachmentClient.js";
+import { type RunnerStateStore } from "../state/index.js";
+import { HarnessAdapterRegistry, type HarnessAdapter, type HarnessAdapterMcpServer, type HarnessAdapterSession } from "./adapters.js";
+export type HarnessLaunchRequest = {
+    sessionId: string;
+    providerInstanceId: string;
+    cwd: string;
+};
+export type HarnessDriver = {
+    kind: string;
+    launch(request: HarnessLaunchRequest): Promise<void>;
+};
+export type HarnessSession = {
+    sessionId: string;
+    workspaceId: string;
+    providerInstanceId: string;
+    driverKind: string;
+    cwd: string;
+    startPayload: HcpSessionStartPayload;
+    adapter: HarnessAdapter;
+    adapterSession: HarnessAdapterSession;
+    localCapabilityLease?: LocalCapabilityLease;
+    mcpClients: HarnessMcpClient[];
+    mcpServers: HarnessAdapterMcpServer[];
+};
+export type HarnessMcpClient = {
+    readonly adapterAttachment?: HarnessAdapterMcpServer | undefined;
+    connect(): Promise<void>;
+    listTools?(): Promise<McpToolDescriptor[]>;
+    close(): Promise<void>;
+};
+export type HarnessMcpClientRequest = {
+    attachment: StreamableHttpMcpServerAttachment;
+    sessionId: string;
+    hostId: string;
+    providerInstanceId: string;
+    workspaceId: string;
+    driverKind: string;
+    proofSigner?: McpProofSigner;
+};
+export type HarnessMcpClientFactory = (request: HarnessMcpClientRequest) => HarnessMcpClient;
+export type HarnessMcpAttachmentResult = {
+    clients: HarnessMcpClient[];
+    adapterAttachments: HarnessAdapterMcpServer[];
+    discoveredTools: HarnessMcpToolDiscovery[];
+};
+export type HarnessMcpToolDiscovery = {
+    attachmentName: string;
+    tools: McpToolDescriptor[];
+};
+export type HarnessSessionManagerOptions = {
+    hostId?: string;
+    mcpProofSigner?: McpProofSigner;
+    mcpClientFactory?: HarnessMcpClientFactory;
+    auditLogger?: AuditLogger;
+    replayRetentionEventsPerSession?: number;
+    stateStore?: RunnerStateStore;
+    adapterRegistry?: HarnessAdapterRegistry;
+};
+export type HarnessReplayResult = {
+    events: HcpHarnessEventPayload[];
+    unavailable: HcpHostReplayUnavailablePayload[];
+};
+export declare class HarnessSessionError extends Error {
+    readonly code: string;
+    constructor(code: string, message: string);
+}
+export declare class HarnessSessionManager {
+    #private;
+    constructor(config: RunnerConfig, options?: string | HarnessSessionManagerOptions);
+    updateWorkspaceConfiguration<T>(operation: () => Promise<T>): Promise<T>;
+    activeSessionCount(): number;
+    providerDriverStatuses(): Promise<ProviderDriverStatus[]>;
+    localCapabilityEngine(): LocalCapabilityEngine;
+    stateStore(): RunnerStateStore;
+    retainedEventRanges(): HostRetainedEventRanges | undefined;
+    replayEventsAfter(cursor: HostResumeCursor): HarnessReplayResult;
+    sessionSnapshot(commandId: string, sessionId: string): HcpSessionSnapshotPayload;
+    resolveLocalActionContext(payload: LocalActionRequestPayload): Promise<LocalCapabilityExecutionContext>;
+    recordLocalActionEvents(sessionId: string, turnId: string, events: LocalCapabilityExecutionEvent[]): HcpHarnessEventPayload[];
+    startSession(payload: HcpSessionStartPayload): Promise<HcpHarnessEventPayload[]>;
+    sendTurn(payload: HcpTurnSendPayload, onEvent?: (event: HcpHarnessEventPayload) => void): Promise<HcpHarnessEventPayload[]>;
+    recordTurnFailure(sessionId: string, turnId: string, error: unknown): HcpHarnessEventPayload;
+    cancelTurn(sessionId: string, turnId: string): Promise<HcpHarnessEventPayload[]>;
+    stopSession(sessionId: string, reason: string | undefined): Promise<HcpHarnessEventPayload[]>;
+}
+//# sourceMappingURL=index.d.ts.map