@tangle-network/agent-provider-cli-bridge 0.5.0 → 0.6.1

package/dist/provider-options.d.ts

@@ -0,0 +1,26 @@
+import type { AgentEnvironmentCapabilities } from "@tangle-network/agent-interface/environment-provider";
+export interface CliBridgeProviderOptions {
+    baseUrl: string;
+    bearerToken?: string;
+    defaultModel?: string;
+    defaultMode?: "byob" | "hosted-safe" | "hosted-sandboxed";
+    defaultExecution?: {
+        kind: "host";
+    } | {
+        kind: "sandbox";
+        repoUrl?: string;
+        gitRef?: string;
+        capability?: string;
+        ttlSeconds?: number;
+    };
+    /** Maximum wait for response headers. Defaults to no timeout. */
+    headersTimeoutMs?: number;
+    /** Maximum idle time between response body chunks. Defaults to no timeout. */
+    bodyTimeoutMs?: number;
+    /** Maximum wait for cli-bridge to confirm cancellation. Defaults to 30 seconds. */
+    cancelWaitMs?: number;
+    fetch?: typeof fetch;
+    name?: string;
+    capabilities?: AgentEnvironmentCapabilities;
+}
+export declare function assertCliBridgeProviderOptions(options: CliBridgeProviderOptions): void;

package/dist/provider-options.js

@@ -0,0 +1,10 @@
+export function assertCliBridgeProviderOptions(options) {
+    assertTimeout(options.headersTimeoutMs, "headersTimeoutMs");
+    assertTimeout(options.bodyTimeoutMs, "bodyTimeoutMs");
+    assertTimeout(options.cancelWaitMs, "cancelWaitMs");
+}
+function assertTimeout(value, name) {
+    if (value !== undefined && (!Number.isInteger(value) || value < 0)) {
+        throw new Error(`createCliBridgeProvider ${name} must be a non-negative integer`);
+    }
+}

package/dist/retained-control.d.ts

@@ -0,0 +1,11 @@
+import { type AgentRunCancellationAcknowledgement, type AgentRunCancellationRequest } from "@tangle-network/agent-interface";
+import type { AgentSessionStatus } from "@tangle-network/agent-interface/environment-provider";
+import type { CliBridgeProviderOptions } from "./provider-options.js";
+import type { CliBridgeRun, CliBridgeRunSnapshot } from "./retained-run-state.js";
+import type { CliBridgeResponse, CliBridgeTransport } from "./transport.js";
+export declare function captureCliBridgeRunIdentity(response: CliBridgeResponse, run: CliBridgeRun, required: boolean): void;
+export declare function detachCliBridgeReader(body: AsyncIterable<Uint8Array>): Promise<void>;
+export declare function cancelCliBridgeRun(options: CliBridgeProviderOptions, transport: CliBridgeTransport, run: CliBridgeRun, signal?: AbortSignal): Promise<CliBridgeRunSnapshot>;
+export declare function cancelExactCliBridgeRun(options: CliBridgeProviderOptions, transport: CliBridgeTransport, run: CliBridgeRun, request: AgentRunCancellationRequest, signal?: AbortSignal): Promise<AgentRunCancellationAcknowledgement>;
+export declare function getCliBridgeRun(options: CliBridgeProviderOptions, transport: CliBridgeTransport, run: CliBridgeRun, waitMs?: number, signal?: AbortSignal): Promise<CliBridgeRunSnapshot | null>;
+export declare function agentSessionStatusFromRun(snapshot: CliBridgeRunSnapshot): AgentSessionStatus;

package/dist/retained-control.js

@@ -0,0 +1,170 @@
+import { AgentExactRunControlRefSchema, AgentRunCancellationAcknowledgementSchema, AgentRunCancellationRequestSchema, agentRunCancellationAcknowledgementMatchesRequest, } from "@tangle-network/agent-interface";
+import { requestHeaders, trimSlash } from "./transport.js";
+import { cancelSnapshot, runSnapshot } from "./wire.js";
+export function captureCliBridgeRunIdentity(response, run, required) {
+    const responseRunId = response.headers.get("x-run-id");
+    const requestDigestHeader = response.headers.get("x-run-request-digest");
+    const requestDigest = requestDigestHeader === null
+        ? null
+        : AgentExactRunControlRefSchema.shape.requestDigest.parse(requestDigestHeader);
+    if (responseRunId !== null && responseRunId !== run.id) {
+        throw new Error(`cli-bridge accepted run "${responseRunId}" for requested run "${run.id}"`);
+    }
+    if ((required || run.requestDigest !== undefined) && responseRunId === null) {
+        throw new Error("cli-bridge response omitted X-Run-Id");
+    }
+    if (required && requestDigest === null) {
+        throw new Error("cli-bridge dispatch response omitted X-Run-Request-Digest");
+    }
+    if (requestDigest !== null &&
+        run.requestDigest !== undefined &&
+        requestDigest !== run.requestDigest) {
+        throw new Error(`cli-bridge changed request digest for run "${run.id}" from "${run.requestDigest}" to "${requestDigest}"`);
+    }
+    if (run.requestDigest !== undefined && requestDigest === null) {
+        throw new Error(`cli-bridge replay response omitted X-Run-Request-Digest for run "${run.id}"`);
+    }
+    if (requestDigest !== null)
+        run.requestDigest = requestDigest;
+}
+export async function detachCliBridgeReader(body) {
+    const cancellable = body;
+    if (cancellable.cancel) {
+        await cancellable.cancel();
+        return;
+    }
+    const iterator = body[Symbol.asyncIterator]();
+    if (!iterator.return) {
+        throw new Error("cli-bridge response body cannot detach its reader");
+    }
+    await iterator.return();
+}
+export async function cancelCliBridgeRun(options, transport, run, signal) {
+    if (!run.cancellation) {
+        const cancellation = performCliBridgeCancellation(options, transport, run);
+        run.cancellation = cancellation;
+        void cancellation.then(() => clearCancellation(run, cancellation), () => clearCancellation(run, cancellation));
+    }
+    return waitForOperation(run.cancellation, signal);
+}
+async function performCliBridgeCancellation(options, transport, run) {
+    const response = await transport.fetch(`${trimSlash(options.baseUrl)}/v1/runs/${encodeURIComponent(run.id)}/cancel`, {
+        method: "POST",
+        headers: requestHeaders(options),
+        body: "{}",
+    });
+    if (!response.ok) {
+        throw new Error(`cli-bridge cancel ${response.status}: ${await response.text()}`);
+    }
+    let snapshot = cancelSnapshot(await response.text());
+    assertCliBridgeRunSnapshotIdentity(snapshot, run.id);
+    const waitBudgetMs = options.cancelWaitMs ?? 30_000;
+    const deadline = Date.now() + waitBudgetMs;
+    while (!snapshot.terminal) {
+        const remainingMs = deadline - Date.now();
+        if (remainingMs <= 0)
+            break;
+        snapshot = await getCliBridgeRun(options, transport, run, Math.min(remainingMs, 30_000));
+        if (snapshot === null) {
+            throw new Error(`cli-bridge lost run "${run.id}" before confirming cancellation`);
+        }
+    }
+    if (!snapshot?.terminal) {
+        throw new Error(`cli-bridge run "${run.id}" did not confirm terminal cancellation`);
+    }
+    for (const reader of run.readers) {
+        reader.abort(new DOMException(`cli-bridge run ended ${snapshot.status}`, "AbortError"));
+    }
+    return snapshot;
+}
+function clearCancellation(run, cancellation) {
+    if (run.cancellation === cancellation)
+        run.cancellation = undefined;
+}
+function waitForOperation(operation, signal) {
+    if (!signal)
+        return operation;
+    signal.throwIfAborted();
+    return new Promise((resolve, reject) => {
+        const abort = () => reject(signal.reason);
+        signal.addEventListener("abort", abort, { once: true });
+        void operation.then((value) => {
+            signal.removeEventListener("abort", abort);
+            resolve(value);
+        }, (error) => {
+            signal.removeEventListener("abort", abort);
+            reject(error);
+        });
+    });
+}
+export async function cancelExactCliBridgeRun(options, transport, run, request, signal) {
+    const exactRequest = AgentRunCancellationRequestSchema.parse(request);
+    if (!run.controlRef || !sameControlRef(run.controlRef, exactRequest.run)) {
+        throw new Error("cli-bridge cancellation targets another retained run");
+    }
+    const response = await transport.fetch(`${trimSlash(options.baseUrl)}/v1/runs/${encodeURIComponent(run.id)}/cancel`, {
+        method: "POST",
+        headers: requestHeaders(options),
+        body: JSON.stringify(exactRequest),
+        ...(signal ? { signal } : {}),
+    });
+    const responseText = await response.text();
+    if (!response.ok && response.status !== 409) {
+        throw new Error(`cli-bridge cancel ${response.status}: ${responseText}`);
+    }
+    let acknowledgement;
+    try {
+        acknowledgement = AgentRunCancellationAcknowledgementSchema.parse(JSON.parse(responseText));
+    }
+    catch (error) {
+        throw new Error("cli-bridge returned an invalid exact cancellation acknowledgement", {
+            cause: error,
+        });
+    }
+    if (!agentRunCancellationAcknowledgementMatchesRequest(exactRequest, acknowledgement)) {
+        throw new Error("cli-bridge returned a cancellation acknowledgement for another request");
+    }
+    return acknowledgement;
+}
+function sameControlRef(left, right) {
+    return left.runId === right.runId &&
+        left.provider === right.provider &&
+        left.environmentId === right.environmentId &&
+        left.sessionId === right.sessionId &&
+        left.executionId === right.executionId &&
+        left.requestDigest === right.requestDigest;
+}
+export async function getCliBridgeRun(options, transport, run, waitMs, signal) {
+    const query = waitMs === undefined ? "" : `?wait_ms=${waitMs}`;
+    const response = await transport.fetch(`${trimSlash(options.baseUrl)}/v1/runs/${encodeURIComponent(run.id)}${query}`, {
+        method: "GET",
+        headers: requestHeaders(options),
+        ...(signal ? { signal } : {}),
+    });
+    if (response.status === 404)
+        return null;
+    if (!response.ok) {
+        throw new Error(`cli-bridge run status ${response.status}: ${await response.text()}`);
+    }
+    const snapshot = runSnapshot(await response.text());
+    assertCliBridgeRunSnapshotIdentity(snapshot, run.id, run.requestDigest);
+    return snapshot;
+}
+function assertCliBridgeRunSnapshotIdentity(snapshot, expectedRunId, expectedRequestDigest) {
+    if (snapshot.id !== expectedRunId) {
+        throw new Error(`cli-bridge returned run "${snapshot.id}" for requested run "${expectedRunId}"`);
+    }
+    if (expectedRequestDigest !== undefined &&
+        snapshot.requestDigest !== expectedRequestDigest) {
+        throw new Error(`cli-bridge returned request digest "${snapshot.requestDigest}" for run "${expectedRunId}"`);
+    }
+}
+export function agentSessionStatusFromRun(snapshot) {
+    if (snapshot.status === "done")
+        return "completed";
+    if (snapshot.status === "error")
+        return "failed";
+    if (snapshot.status === "cancelled")
+        return "cancelled";
+    return "running";
+}

package/dist/retained-environment.d.ts

@@ -0,0 +1,11 @@
+import type { AgentEnvironment, CreateAgentEnvironmentInput } from "@tangle-network/agent-interface/environment-provider";
+import type { CliBridgeProviderOptions } from "./provider-options.js";
+export interface CreateCliBridgeEnvironmentArgs {
+    readonly options: CliBridgeProviderOptions;
+    readonly providerName: string;
+    readonly environmentInput: CreateAgentEnvironmentInput;
+    readonly environmentId: string;
+    readonly allowDispatch: boolean;
+    readonly cancelRunsOnDestroy: boolean;
+}
+export declare function createCliBridgeEnvironment(args: CreateCliBridgeEnvironmentArgs): AgentEnvironment;

package/dist/retained-environment.js

@@ -0,0 +1,189 @@
+import { agentSessionStatusFromRun, cancelCliBridgeRun, cancelExactCliBridgeRun, getCliBridgeRun, } from "./retained-control.js";
+import { collectCliBridgeTurnResult, dispatchCliBridgeTurn, streamCliBridgeSessionEvents, streamTrackedCliBridgeTurn, } from "./retained-execution.js";
+import { assertRunMatchesControlRef, exactControlRefForSession, prepareCliBridgeRun, runFromControlRef, } from "./retained-run-state.js";
+import { createCliBridgeTransport } from "./transport.js";
+export function createCliBridgeEnvironment(args) {
+    const { options, providerName, environmentInput, environmentId } = args;
+    const transport = createCliBridgeTransport(options);
+    const runs = new Map();
+    const sessions = new Map();
+    const readers = new Set();
+    let destroyed = false;
+    let closePromise;
+    const stream = async function* (turn) {
+        if (destroyed)
+            throw new Error("cli-bridge environment is destroyed");
+        if (!args.allowDispatch) {
+            throw new Error("a reconstructed cli-bridge environment can only control an existing run");
+        }
+        const prepared = prepareCliBridgeRun(options, environmentInput, turn, environmentId, false);
+        yield* streamTrackedCliBridgeTurn(options, environmentInput, prepared, transport, runs, sessions, readers);
+    };
+    return {
+        id: environmentId,
+        provider: providerName,
+        ...(environmentInput.name ? { name: environmentInput.name } : {}),
+        status: async (statusOptions) => {
+            statusOptions?.signal?.throwIfAborted();
+            return destroyed ? "stopped" : "running";
+        },
+        stream,
+        async dispatch(turn) {
+            if (destroyed)
+                throw new Error("cli-bridge environment is destroyed");
+            if (!args.allowDispatch) {
+                throw new Error("a reconstructed cli-bridge environment cannot dispatch new work");
+            }
+            const prepared = prepareCliBridgeRun(options, environmentInput, turn, environmentId, true);
+            return dispatchCliBridgeTurn(options, environmentInput, prepared, transport, providerName, runs, sessions);
+        },
+        session(id, sessionOptions) {
+            sessionOptions?.signal?.throwIfAborted();
+            return createCliBridgeSession({
+                id,
+                providerName,
+                options,
+                environmentInput,
+                environmentId,
+                transport,
+                runs,
+                sessions,
+                readers,
+                allowPrompt: args.allowDispatch,
+                requestedControlRef: sessionOptions?.controlRef,
+                isDestroyed: () => destroyed,
+            });
+        },
+        placement: async (placementOptions) => {
+            placementOptions?.signal?.throwIfAborted();
+            return {
+                kind: options.defaultExecution?.kind === "sandbox" ? "sandbox" : "local",
+                providerMetadata: { baseUrl: options.baseUrl },
+            };
+        },
+        async destroy(destroyOptions) {
+            if (closePromise)
+                return closePromise;
+            destroyOptions?.signal?.throwIfAborted();
+            destroyed = true;
+            let cleanupConfirmed = false;
+            const attempt = (async () => {
+                if (args.cancelRunsOnDestroy) {
+                    const cancellations = await Promise.allSettled(Array.from(runs.values()).map(async (run) => {
+                        const snapshot = await cancelCliBridgeRun(options, transport, run, destroyOptions?.signal);
+                        if (runs.get(run.id) === run)
+                            runs.delete(run.id);
+                        return snapshot;
+                    }));
+                    const failures = cancellations.flatMap((result) => result.status === "rejected" ? [result.reason] : []);
+                    if (failures.length === 1)
+                        throw failures[0];
+                    if (failures.length > 1) {
+                        throw new AggregateError(failures, "cli-bridge environment cancellation failed");
+                    }
+                }
+                cleanupConfirmed = true;
+                for (const reader of readers) {
+                    reader.abort(new DOMException("cli-bridge environment was destroyed", "AbortError"));
+                }
+                await transport.close();
+                sessions.clear();
+                runs.clear();
+            })();
+            closePromise = attempt;
+            try {
+                await attempt;
+            }
+            catch (error) {
+                closePromise = undefined;
+                if (!cleanupConfirmed)
+                    destroyed = false;
+                throw error;
+            }
+        },
+    };
+}
+function createCliBridgeSession(args) {
+    const requestedControlRef = args.requestedControlRef === undefined
+        ? undefined
+        : exactControlRefForSession(args.requestedControlRef, args.providerName, args.environmentId, args.id);
+    if (requestedControlRef) {
+        const current = args.sessions.get(args.id)?.current;
+        if (current) {
+            assertRunMatchesControlRef(current, requestedControlRef);
+            const indexed = args.runs.get(requestedControlRef.runId);
+            if (indexed)
+                assertRunMatchesControlRef(indexed, requestedControlRef);
+            else
+                args.runs.set(current.id, current);
+        }
+        else {
+            const existing = args.runs.get(requestedControlRef.runId);
+            if (existing) {
+                assertRunMatchesControlRef(existing, requestedControlRef);
+                args.sessions.set(args.id, { id: args.id, current: existing });
+            }
+            else {
+                const reconstructed = runFromControlRef(requestedControlRef);
+                args.runs.set(reconstructed.id, reconstructed);
+                args.sessions.set(args.id, { id: args.id, current: reconstructed });
+            }
+        }
+    }
+    const currentRun = () => {
+        if (args.isDestroyed())
+            throw new Error("cli-bridge environment is destroyed");
+        return args.sessions.get(args.id)?.current;
+    };
+    const requireCurrentRun = () => {
+        const run = currentRun();
+        if (!run)
+            throw new Error(`cli-bridge session "${args.id}" has no run`);
+        return run;
+    };
+    return {
+        id: args.id,
+        get controlRef() {
+            return currentRun()?.controlRef;
+        },
+        async status(statusOptions) {
+            const run = currentRun();
+            if (!run)
+                return null;
+            const snapshot = await getCliBridgeRun(args.options, args.transport, run, undefined, statusOptions?.signal);
+            if (!snapshot)
+                return null;
+            return agentSessionStatusFromRun(snapshot);
+        },
+        async *events(eventOptions) {
+            const run = requireCurrentRun();
+            yield* streamCliBridgeSessionEvents(args.options, args.environmentInput, run, args.transport, args.runs, args.readers, eventOptions);
+        },
+        async result(resultOptions) {
+            const run = requireCurrentRun();
+            return collectCliBridgeTurnResult(streamCliBridgeSessionEvents(args.options, args.environmentInput, run, args.transport, args.runs, args.readers, { since: "0", signal: resultOptions?.signal }), run, args.options, args.transport, resultOptions?.signal);
+        },
+        async prompt(input) {
+            if (!args.allowPrompt) {
+                throw new Error("a reconstructed cli-bridge session cannot start another turn");
+            }
+            if (input.sessionId && input.sessionId !== args.id) {
+                throw new Error(`cli-bridge session "${args.id}" cannot prompt session "${input.sessionId}"`);
+            }
+            const prepared = prepareCliBridgeRun(args.options, args.environmentInput, {
+                ...input,
+                sessionId: args.id,
+            }, args.environmentId, false);
+            const result = await collectCliBridgeTurnResult(streamTrackedCliBridgeTurn(args.options, args.environmentInput, prepared, args.transport, args.runs, args.sessions, args.readers), prepared.run, args.options, args.transport, input.signal);
+            return { ...result, sessionId: args.id };
+        },
+        async cancel(cancelOptions) {
+            const run = requireCurrentRun();
+            await cancelCliBridgeRun(args.options, args.transport, run, cancelOptions?.signal);
+        },
+        async cancelRun(request, cancelOptions) {
+            const run = requireCurrentRun();
+            return cancelExactCliBridgeRun(args.options, args.transport, run, request, cancelOptions?.signal);
+        },
+    };
+}

package/dist/retained-event-cursor.d.ts

@@ -0,0 +1,18 @@
+import type { AgentEnvironmentEvent } from "@tangle-network/agent-interface/environment-provider";
+interface RetainedReplayAnchor {
+    readonly frameId: string;
+    readonly eventIndex: number;
+}
+export interface RetainedReplayRequest {
+    readonly serverCursor?: string;
+    readonly anchor?: RetainedReplayAnchor;
+}
+/**
+ * Translate one provider event cursor into the frame cursor understood by
+ * cli-bridge. A composite cursor replays its source frame, then filters the
+ * canonical events that the caller already committed.
+ */
+export declare function retainedReplayRequest(cursor?: string): RetainedReplayRequest;
+/** Add exact per-event identity to all canonical events from one SSE frame. */
+export declare function retainedEventsWithIdentity(events: readonly AgentEnvironmentEvent[], frameId?: string, runId?: string, sessionId?: string, executionId?: string, replayAnchor?: RetainedReplayAnchor): Iterable<AgentEnvironmentEvent>;
+export {};

package/dist/retained-event-cursor.js

@@ -0,0 +1,68 @@
+/**
+ * Translate one provider event cursor into the frame cursor understood by
+ * cli-bridge. A composite cursor replays its source frame, then filters the
+ * canonical events that the caller already committed.
+ */
+export function retainedReplayRequest(cursor) {
+    if (cursor === undefined)
+        return {};
+    if (isBaseTenInteger(cursor)) {
+        assertSafeInteger(cursor, "cli-bridge replay cursor");
+        return { serverCursor: cursor };
+    }
+    const match = /^(0|[1-9][0-9]*):(0|[1-9][0-9]*)$/u.exec(cursor);
+    if (!match)
+        throw new Error("cli-bridge replay cursor is invalid");
+    const frameId = match[1];
+    const eventIndexText = match[2];
+    const frameSequence = assertSafeInteger(frameId, "cli-bridge replay frame");
+    const eventIndex = assertSafeInteger(eventIndexText, "cli-bridge replay event index");
+    if (frameSequence === 0) {
+        throw new Error("cli-bridge retained event frame must be positive");
+    }
+    return {
+        serverCursor: String(frameSequence - 1),
+        anchor: { frameId, eventIndex },
+    };
+}
+/** Add exact per-event identity to all canonical events from one SSE frame. */
+export function* retainedEventsWithIdentity(events, frameId, runId, sessionId, executionId, replayAnchor) {
+    if (frameId === undefined) {
+        yield* events;
+        return;
+    }
+    const frameSequence = assertSafeInteger(frameId, "cli-bridge retained event id");
+    if (frameSequence === 0) {
+        throw new Error("cli-bridge retained event id must be positive");
+    }
+    for (let index = 0; index < events.length; index += 1) {
+        if (replayAnchor?.frameId === frameId &&
+            index <= replayAnchor.eventIndex) {
+            continue;
+        }
+        const event = events[index];
+        const cursor = `${frameId}:${index}`;
+        yield {
+            ...event,
+            id: cursor,
+            data: {
+                ...event.data,
+                cursor,
+                ...(runId === undefined ? {} : { runId }),
+                ...(sessionId === undefined ? {} : { sessionId }),
+                ...(executionId === undefined ? {} : { executionId }),
+            },
+        };
+    }
+}
+function isBaseTenInteger(value) {
+    return /^(0|[1-9][0-9]*)$/u.test(value);
+}
+function assertSafeInteger(value, label) {
+    if (!isBaseTenInteger(value))
+        throw new Error(`${label} must be a base-10 integer`);
+    const parsed = Number(value);
+    if (!Number.isSafeInteger(parsed))
+        throw new Error(`${label} exceeds the supported range`);
+    return parsed;
+}

package/dist/retained-execution.d.ts

@@ -0,0 +1,12 @@
+import type { AgentEnvironmentEvent, AgentSessionRef, AgentTurnResult, CreateAgentEnvironmentInput } from "@tangle-network/agent-interface/environment-provider";
+import type { CliBridgeProviderOptions } from "./provider-options.js";
+import { type CliBridgeRun, type CliBridgeSessionState, type PreparedCliBridgeRun } from "./retained-run-state.js";
+import type { CliBridgeTransport } from "./transport.js";
+export declare function streamTrackedCliBridgeTurn(options: CliBridgeProviderOptions, environmentInput: CreateAgentEnvironmentInput, prepared: PreparedCliBridgeRun, transport: CliBridgeTransport, runs: Map<string, CliBridgeRun>, sessions: Map<string, CliBridgeSessionState>, readers: Set<AbortController>): AsyncIterable<AgentEnvironmentEvent>;
+export declare function dispatchCliBridgeTurn(options: CliBridgeProviderOptions, environmentInput: CreateAgentEnvironmentInput, prepared: PreparedCliBridgeRun, transport: CliBridgeTransport, providerName: string, runs: Map<string, CliBridgeRun>, sessions: Map<string, CliBridgeSessionState>): Promise<AgentSessionRef>;
+export declare function streamCliBridgeSessionEvents(options: CliBridgeProviderOptions, environmentInput: CreateAgentEnvironmentInput, run: CliBridgeRun, transport: CliBridgeTransport, runs: Map<string, CliBridgeRun>, readers: Set<AbortController>, eventOptions?: {
+    since?: string;
+    executionId?: string;
+    signal?: AbortSignal;
+}): AsyncIterable<AgentEnvironmentEvent>;
+export declare function collectCliBridgeTurnResult(source: AsyncIterable<AgentEnvironmentEvent>, run: CliBridgeRun, options: CliBridgeProviderOptions, transport: CliBridgeTransport, signal?: AbortSignal): Promise<AgentTurnResult>;