@agent-native/agentkit 0.1.0

package/dist/client/client.js

@@ -0,0 +1,1605 @@
+import { AgentProtocolValidationError, AgentKitProtocolError, createRequestAbortedError, createAgentKitProtocolVersionOffer, parseAgentEvent, projectAgentCapabilities, resumeEntryFromApproval, } from "../protocol/index.js";
+import { classifyAgentEvent, createAgentThreadState, reduceAgentEvent, } from "./state.js";
+/**
+ * Creates the deterministic AgentKit controller used by every UI binding.
+ * Prefer this factory at application boundaries; the class remains public for
+ * dependency injection, extension, and test harnesses.
+ */
+export function createAgentKitClient(options) {
+    return new AgentKitClient(options);
+}
+function defaultCreateId(prefix) {
+    if (typeof crypto !== "undefined" && crypto.randomUUID) {
+        return `${prefix}-${crypto.randomUUID()}`;
+    }
+    return `${prefix}-${Date.now()}-${Math.random().toString(36).slice(2, 10)}`;
+}
+function errorProperty(error, property) {
+    return typeof error === "object" && error !== null
+        ? error[property]
+        : undefined;
+}
+function errorIsRetryable(error, fallback = true) {
+    const explicit = errorProperty(error, "retryable");
+    if (typeof explicit === "boolean")
+        return explicit;
+    if (error instanceof AgentKitCapabilityError ||
+        error instanceof AgentKitOperationError ||
+        error instanceof AgentKitDisposedError ||
+        error instanceof AgentProtocolValidationError ||
+        (error instanceof Error && error.name === "AbortError")) {
+        return false;
+    }
+    const status = errorProperty(error, "status");
+    if (typeof status === "number") {
+        return (status === 408 ||
+            status === 425 ||
+            status === 429 ||
+            (status >= 500 && status !== 501 && status !== 505));
+    }
+    return fallback;
+}
+function isAbortFailure(error) {
+    return error instanceof Error && error.name === "AbortError";
+}
+function toError(error, code = "agentkit_client_error") {
+    const errorCode = errorProperty(error, "code");
+    const correlationId = errorProperty(error, "correlationId");
+    const details = errorProperty(error, "details");
+    return {
+        code: typeof errorCode === "string" ? errorCode : code,
+        message: error instanceof Error ? error.message : String(error),
+        retryable: errorIsRetryable(error),
+        ...(typeof correlationId === "string" ? { correlationId } : {}),
+        ...(details === undefined ? {} : { details }),
+    };
+}
+export class AgentKitCapabilityError extends Error {
+    capability;
+    state;
+    correlationId;
+    details;
+    code;
+    retryable;
+    constructor(capability, state = "unsupported", message, retryable = state === "unavailable", correlationId, details) {
+        super(message ??
+            `This AgentKit controller does not support the ${capability} capability.`);
+        this.capability = capability;
+        this.state = state;
+        this.correlationId = correlationId;
+        this.details = details;
+        this.name = "AgentKitCapabilityError";
+        this.code =
+            state === "unavailable"
+                ? "capability_unavailable"
+                : "capability_unsupported";
+        this.retryable = retryable;
+    }
+}
+export class AgentKitOperationError extends Error {
+    operation;
+    code = "operation_unsupported";
+    retryable = false;
+    constructor(operation) {
+        super(`This AgentKit controller does not support ${operation}.`);
+        this.operation = operation;
+        this.name = "AgentKitOperationError";
+    }
+}
+export class AgentKitDisposedError extends Error {
+    code = "client_disposed";
+    retryable = false;
+    constructor() {
+        super("This AgentKit client has been disposed.");
+        this.name = "AgentKitDisposedError";
+    }
+}
+export class AgentKitHandshakeError extends Error {
+    code;
+    details;
+    correlationId;
+    retryable = false;
+    constructor(code, message, details, correlationId) {
+        super(message);
+        this.code = code;
+        this.details = details;
+        this.correlationId = correlationId;
+        this.name = "AgentKitHandshakeError";
+    }
+}
+class AgentKitConsumerStoppedError extends Error {
+    reason;
+    constructor(reason) {
+        super(`AgentKit run subscription stopped: ${reason}.`);
+        this.reason = reason;
+        this.name = "AgentKitConsumerStoppedError";
+    }
+}
+async function defaultUploadDriver(target, file, context) {
+    const body = target.fields
+        ? (() => {
+            const data = new FormData();
+            for (const [key, value] of Object.entries(target.fields)) {
+                data.set(key, value);
+            }
+            data.set("file", file.body, file.name);
+            return data;
+        })()
+        : file.body;
+    const response = await fetch(target.url, {
+        method: target.method,
+        headers: target.headers,
+        body,
+        signal: context?.signal,
+    });
+    if (!response.ok) {
+        throw new Error(`Upload failed with ${response.status}.`);
+    }
+}
+export class AgentKitClient {
+    transport;
+    createId;
+    now;
+    reconnectAttempts;
+    reconnectDelay;
+    onError;
+    onIntegrityReport;
+    upload;
+    ownsTransport;
+    retainActiveRunsOnThreadRelease;
+    listeners = new Set();
+    consumers = new Map();
+    consumerAbortControllers = new Map();
+    threadLoads = new Map();
+    threadLeaseCounts = new Map();
+    queuePromotions = new Set();
+    requestAbortController = new AbortController();
+    capabilitiesLoad;
+    shutdownPromise;
+    disposed = false;
+    snapshot;
+    constructor(options) {
+        this.transport = options.transport;
+        this.ownsTransport = options.transportOwnership === "owned";
+        this.retainActiveRunsOnThreadRelease =
+            options.retainActiveRunsOnThreadRelease ?? false;
+        this.createId = options.createId ?? defaultCreateId;
+        this.now = options.now ?? (() => new Date().toISOString());
+        this.reconnectAttempts = options.reconnect?.attempts ?? 3;
+        this.reconnectDelay =
+            options.reconnect?.delayMs ??
+                ((attempt) => Math.min(250 * 2 ** attempt, 4_000));
+        this.onError = options.onError;
+        this.onIntegrityReport = options.onIntegrityReport;
+        this.upload = options.upload ?? defaultUploadDriver;
+        this.snapshot = {
+            connection: "idle",
+            capabilities: options.transport.capabilities ?? {},
+            capabilitiesStatus: options.transport.discoverCapabilities
+                ? "unknown"
+                : "ready",
+            threads: {},
+            revision: 0,
+        };
+    }
+    createRequestContext(context) {
+        const lifetimeSignal = this.requestAbortController.signal;
+        const signal = context?.signal
+            ? context.signal === lifetimeSignal
+                ? lifetimeSignal
+                : AbortSignal.any([lifetimeSignal, context.signal])
+            : lifetimeSignal;
+        const requestContext = {
+            signal,
+            correlationId: context?.correlationId ?? defaultCreateId("request"),
+        };
+        this.assertRequestActive(requestContext);
+        return requestContext;
+    }
+    assertRequestActive(context) {
+        if (context.signal?.aborted) {
+            throw new AgentKitProtocolError(createRequestAbortedError({ correlationId: context.correlationId }));
+        }
+    }
+    invokeRequest(context, operation) {
+        this.assertRequestActive(context);
+        const signal = context.signal;
+        return new Promise((resolve, reject) => {
+            let settled = false;
+            const finish = (callback) => {
+                if (settled)
+                    return;
+                settled = true;
+                signal?.removeEventListener("abort", onAbort);
+                callback();
+            };
+            const abortError = () => new AgentKitProtocolError(createRequestAbortedError({ correlationId: context.correlationId }));
+            const onAbort = () => finish(() => reject(abortError()));
+            signal?.addEventListener("abort", onAbort, { once: true });
+            void Promise.resolve()
+                .then(() => operation(context))
+                .then((value) => {
+                if (signal?.aborted)
+                    onAbort();
+                else
+                    finish(() => resolve(value));
+            }, (error) => {
+                if (signal?.aborted || isAbortFailure(error)) {
+                    finish(() => reject(abortError()));
+                }
+                else {
+                    finish(() => reject(error));
+                }
+            });
+        });
+    }
+    getSnapshot = () => this.snapshot;
+    subscribe = (listener) => {
+        this.listeners.add(listener);
+        return () => this.listeners.delete(listener);
+    };
+    getThread(threadId) {
+        return this.snapshot.threads[threadId] ?? createAgentThreadState(threadId);
+    }
+    async openThread(threadId, context) {
+        this.assertActive();
+        this.threadLeaseCounts.set(threadId, (this.threadLeaseCounts.get(threadId) ?? 0) + 1);
+        let released = false;
+        const release = () => {
+            if (released)
+                return;
+            released = true;
+            this.releaseThreadLease(threadId);
+        };
+        try {
+            await this.loadThread(threadId, context);
+            this.assertActive();
+            return {
+                threadId,
+                getSnapshot: () => this.getThread(threadId),
+                release,
+                dispose: release,
+            };
+        }
+        catch (error) {
+            release();
+            throw error;
+        }
+    }
+    async loadThread(threadId, context) {
+        this.assertActive();
+        const requestContext = this.createRequestContext(context);
+        const existing = this.threadLoads.get(threadId);
+        if (existing) {
+            return this.invokeRequest(requestContext, () => existing);
+        }
+        const load = this.loadThreadProjection(threadId, requestContext);
+        this.threadLoads.set(threadId, load);
+        try {
+            return await load;
+        }
+        finally {
+            if (this.threadLoads.get(threadId) === load) {
+                this.threadLoads.delete(threadId);
+            }
+        }
+    }
+    async loadThreadProjection(threadId, requestContext, preserveRuntimeProjection = false) {
+        const baseline = this.snapshot.threads[threadId] ?? createAgentThreadState(threadId);
+        if (!this.snapshot.threads[threadId])
+            this.setThread(threadId, baseline);
+        this.setConnection("connecting");
+        try {
+            await this.ensureCapabilities(requestContext);
+            this.assertActive();
+            if (!this.transport.getThreadSnapshot && !this.transport.getThread) {
+                throw new AgentKitOperationError("thread reads");
+            }
+            const getThreadSnapshot = this.transport.getThreadSnapshot;
+            const snapshot = getThreadSnapshot
+                ? await this.invokeRequest(requestContext, (context) => getThreadSnapshot({ threadId }, context))
+                : undefined;
+            this.assertActive();
+            const runSnapshots = new Map((snapshot?.runs ?? []).map((run) => [run.id, run]));
+            const missingRunIds = (snapshot?.activeRunIds ?? []).filter((runId) => !runSnapshots.has(runId));
+            const getRun = this.transport.getRun;
+            const activeRuns = missingRunIds.length
+                ? await Promise.all(missingRunIds.map(async (runId) => getRun
+                    ? await this.invokeRequest(requestContext, (context) => getRun({ threadId, runId }, context))
+                    : undefined))
+                : [];
+            this.assertActive();
+            missingRunIds.forEach((runId, index) => {
+                const run = activeRuns[index];
+                runSnapshots.set(runId, run ?? this.runSnapshot(threadId, runId));
+            });
+            const hydratedRuns = Object.fromEntries([...runSnapshots.entries()].map(([runId, run]) => [
+                runId,
+                this.runState(runId, run),
+            ]));
+            const activeRunIds = Array.from(new Set([
+                ...(snapshot?.activeRunIds ?? []),
+                ...Object.values(hydratedRuns)
+                    .filter((run) => !this.isTerminalStatus(run.status))
+                    .map((run) => run.id),
+            ])).filter((runId) => !this.isTerminalStatus(hydratedRuns[runId]?.status ?? "running"));
+            let thread;
+            if (snapshot) {
+                thread = this.hydrateThread(snapshot, hydratedRuns, activeRunIds);
+            }
+            else if (getThreadSnapshot) {
+                // A null durable snapshot is an authoritative missing thread, which is
+                // also the expected initial state for a client-generated new-chat id.
+                // Only transports without snapshot support need the legacy split reads.
+                thread = createAgentThreadState(threadId);
+            }
+            else {
+                const listQueuedMessages = this.transport.listQueuedMessages;
+                const getThread = this.transport.getThread;
+                const [queuedMessages, loadedThread] = await Promise.all([
+                    listQueuedMessages
+                        ? this.invokeRequest(requestContext, (context) => listQueuedMessages({ threadId }, context))
+                        : Promise.resolve([]),
+                    getThread
+                        ? this.invokeRequest(requestContext, (context) => getThread({ threadId }, context))
+                        : Promise.resolve(undefined),
+                ]);
+                this.assertActive();
+                thread = {
+                    ...createAgentThreadState(threadId),
+                    thread: loadedThread === null ? undefined : loadedThread,
+                    queuedMessages,
+                };
+            }
+            if (preserveRuntimeProjection) {
+                const reconciliation = this.reconcileMessages(baseline.messages, thread.messages);
+                const runtimeProjection = this.remapThreadMessageReferences(baseline, reconciliation.idRemap);
+                const authoritative = {
+                    thread: thread.thread,
+                    messages: reconciliation.messages,
+                    // Queue mutations are already optimistic and independently durable.
+                    // A completed-run snapshot can lag the accepted steer/remove write,
+                    // so it must not resurrect work the client has already promoted.
+                    queuedMessages: baseline.queuedMessages,
+                };
+                thread = {
+                    ...this.mergeLoadedThread(createAgentThreadState(threadId), runtimeProjection, thread),
+                    ...authoritative,
+                };
+            }
+            const current = this.getThread(threadId);
+            if (current !== baseline) {
+                thread = this.mergeLoadedThread(baseline, current, thread);
+            }
+            this.setThread(threadId, thread);
+            this.setConnection("connected");
+            for (const runId of thread.activeRunIds) {
+                void this.resubscribeRun(threadId, runId).catch(() => {
+                    // The consumer records the typed stream error in the client snapshot.
+                });
+            }
+            return thread;
+        }
+        catch (error) {
+            if (this.disposed)
+                throw error;
+            if (this.snapshot.capabilitiesStatus === "loading") {
+                this.patch({ capabilitiesStatus: "error" });
+            }
+            this.fail(error, "thread_load_failed");
+            throw error;
+        }
+    }
+    async getCapabilities(context) {
+        this.assertActive();
+        return this.ensureCapabilities(this.createRequestContext(context));
+    }
+    async createThread(input, context) {
+        this.assertActive();
+        const requestContext = this.createRequestContext(context);
+        await this.ensureCapabilities(requestContext);
+        const createThread = this.transport.createThread;
+        if (!createThread) {
+            throw new AgentKitOperationError("thread creation");
+        }
+        const thread = await this.invokeRequest(requestContext, (context) => createThread(input, context));
+        this.assertActive();
+        const current = this.getThread(thread.id);
+        this.setThread(thread.id, { ...current, thread });
+        return thread;
+    }
+    async listThreads(input, context) {
+        this.assertActive();
+        const requestContext = this.createRequestContext(context);
+        await this.ensureCapabilities(requestContext);
+        const listThreads = this.transport.listThreads;
+        if (!listThreads) {
+            throw new AgentKitOperationError("thread listing");
+        }
+        const result = await this.invokeRequest(requestContext, (context) => listThreads(input, context));
+        this.assertActive();
+        return result;
+    }
+    async sendMessage(input, context) {
+        this.assertActive();
+        const requestContext = this.createRequestContext(context);
+        await this.ensureCapabilities(requestContext);
+        if (input.attachments?.length) {
+            await this.requireCapability("attachments", requestContext);
+        }
+        if (input.options?.model) {
+            await this.requireCapability("modelSelection", requestContext);
+        }
+        if (input.options?.toolChoice) {
+            await this.requireCapability("toolSelection", requestContext);
+        }
+        this.assertActive();
+        const message = {
+            id: this.createId("message"),
+            role: "user",
+            createdAt: this.now(),
+            status: "complete",
+            parts: [{ type: "text", text: input.text }, ...(input.attachments ?? [])],
+            metadata: input.metadata,
+        };
+        const current = this.getThread(input.threadId);
+        this.setThread(input.threadId, {
+            ...current,
+            messages: [...current.messages, message],
+            suggestions: [],
+        });
+        this.setConnection("connecting");
+        try {
+            const result = await this.invokeRequest(requestContext, (context) => this.transport.startRun({
+                threadId: input.threadId,
+                messages: [...current.messages, message],
+                options: input.options,
+                metadata: input.metadata,
+            }, context));
+            this.assertActive();
+            if (result.capabilities) {
+                this.patch({
+                    capabilities: result.capabilities,
+                    capabilitiesStatus: "ready",
+                });
+            }
+            this.markRunStarted(input.threadId, result.runId);
+            const completed = this.consume(input.threadId, result.runId);
+            this.trackConsumer(input.threadId, result.runId, completed);
+            return {
+                runId: result.runId,
+                completed,
+                cancel: () => this.cancelRun(input.threadId, result.runId),
+            };
+        }
+        catch (error) {
+            if (this.disposed)
+                throw error;
+            const failed = this.getThread(input.threadId);
+            this.setThread(input.threadId, {
+                ...failed,
+                messages: failed.messages.map((candidate) => candidate.id === message.id
+                    ? { ...candidate, status: "error" }
+                    : candidate),
+            });
+            this.fail(error, "run_start_failed");
+            throw error;
+        }
+    }
+    resubscribeRun(threadId, runId) {
+        this.assertActive();
+        const status = this.getThread(threadId).runs[runId]?.status;
+        if (status && this.isTerminalStatus(status))
+            return Promise.resolve();
+        const key = this.runKey(threadId, runId);
+        const existing = this.consumers.get(key);
+        if (existing)
+            return existing;
+        const consumer = this.consume(threadId, runId);
+        this.trackConsumer(threadId, runId, consumer);
+        return consumer;
+    }
+    async resolveApproval(input, context) {
+        this.assertActive();
+        const requestContext = this.createRequestContext(context);
+        await this.requireCapability("approvals", requestContext);
+        const resumeRun = this.transport.resumeRun;
+        const resolveApproval = this.transport.resolveApproval;
+        if (!resumeRun && !resolveApproval) {
+            throw new AgentKitCapabilityError("approvals");
+        }
+        if (!resumeRun) {
+            await this.invokeRequest(requestContext, (context) => resolveApproval(input, context));
+            this.assertActive();
+            return;
+        }
+        const result = await this.invokeRequest(requestContext, (context) => resumeRun({
+            threadId: input.threadId,
+            runId: input.runId,
+            resume: [resumeEntryFromApproval(input)],
+        }, context));
+        this.assertActive();
+        if (result.runId !== input.runId) {
+            this.retireInterruptedRun(input.threadId, input.runId);
+        }
+        // A runtime that suspends rather than terminates answers with the run that
+        // was already streaming, so adopting it blindly would open a second reader
+        // on one stream.
+        const key = this.runKey(input.threadId, result.runId);
+        if (this.consumers.has(key))
+            return;
+        this.markRunStarted(input.threadId, result.runId);
+        this.trackConsumer(input.threadId, result.runId, this.consume(input.threadId, result.runId));
+    }
+    async resolveConnectionRequest(input, context) {
+        this.assertActive();
+        const requestContext = this.createRequestContext(context);
+        await this.requireCapability("connectionRequests", requestContext);
+        const resolveConnectionRequest = this.transport.resolveConnectionRequest;
+        if (!resolveConnectionRequest) {
+            throw new AgentKitCapabilityError("connectionRequests");
+        }
+        await this.invokeRequest(requestContext, (context) => resolveConnectionRequest(input, context));
+        this.assertActive();
+        const key = this.runKey(input.threadId, input.runId);
+        const existingConsumer = this.consumers.get(key);
+        if (existingConsumer)
+            await existingConsumer.catch(() => undefined);
+        if (this.consumers.has(key))
+            return;
+        this.trackConsumer(input.threadId, input.runId, this.consume(input.threadId, input.runId));
+    }
+    async invokeAction(invocation, context) {
+        this.assertActive();
+        const requestContext = this.createRequestContext(context);
+        await this.requireCapability("actions", requestContext);
+        const invokeAction = this.transport.invokeAction;
+        if (!invokeAction) {
+            throw new AgentKitCapabilityError("actions");
+        }
+        const thread = this.getThread(invocation.threadId);
+        this.setThread(invocation.threadId, {
+            ...thread,
+            actions: {
+                ...thread.actions,
+                [invocation.id]: { invocation },
+            },
+        });
+        try {
+            const result = await this.invokeRequest(requestContext, (context) => invokeAction({ invocation }, context));
+            this.assertActive();
+            const current = this.getThread(invocation.threadId);
+            this.setThread(invocation.threadId, {
+                ...current,
+                actions: {
+                    ...current.actions,
+                    [invocation.id]: {
+                        ...current.actions[invocation.id],
+                        invocation,
+                        result,
+                    },
+                },
+            });
+            return result;
+        }
+        catch (error) {
+            if (this.disposed)
+                throw error;
+            const current = this.getThread(invocation.threadId);
+            this.setThread(invocation.threadId, {
+                ...current,
+                actions: {
+                    ...current.actions,
+                    [invocation.id]: {
+                        ...current.actions[invocation.id],
+                        invocation,
+                        result: {
+                            invocationId: invocation.id,
+                            status: "failed",
+                            error: toError(error, "action_failed"),
+                        },
+                    },
+                },
+            });
+            throw error;
+        }
+    }
+    async uploadFiles(threadId, files, context) {
+        this.assertActive();
+        const requestContext = this.createRequestContext(context);
+        await this.requireCapability("uploads", requestContext);
+        return Promise.all(files.map(async (file) => {
+            const target = await this.createUpload(threadId, {
+                name: file.name,
+                mediaType: file.mediaType,
+                size: file.size,
+                purpose: "message",
+            }, requestContext);
+            try {
+                await this.invokeRequest(requestContext, (context) => this.upload(target, file, context));
+                this.assertActive();
+                return await this.completeUpload(threadId, target.uploadId, requestContext);
+            }
+            catch (error) {
+                if (this.transport.cancelUpload) {
+                    const cleanupContext = this.createRequestContext();
+                    await Promise.allSettled([
+                        this.transport.cancelUpload({
+                            threadId,
+                            uploadId: target.uploadId,
+                        }, cleanupContext),
+                    ]);
+                }
+                throw error;
+            }
+        }));
+    }
+    async createUpload(threadId, descriptor, context) {
+        this.assertActive();
+        const requestContext = this.createRequestContext(context);
+        await this.requireCapability("uploads", requestContext);
+        const createUpload = this.transport.createUpload;
+        if (!createUpload) {
+            throw new AgentKitCapabilityError("uploads");
+        }
+        const target = await this.invokeRequest(requestContext, (context) => createUpload({ threadId, descriptor }, context));
+        this.assertActive();
+        return target;
+    }
+    async completeUpload(threadId, uploadId, context) {
+        this.assertActive();
+        const requestContext = this.createRequestContext(context);
+        await this.requireCapability("uploads", requestContext);
+        const completeUpload = this.transport.completeUpload;
+        if (!completeUpload) {
+            throw new AgentKitCapabilityError("uploads");
+        }
+        const file = await this.invokeRequest(requestContext, (context) => completeUpload({ threadId, uploadId }, context));
+        this.assertActive();
+        return file;
+    }
+    async cancelUpload(threadId, uploadId, context) {
+        this.assertActive();
+        const requestContext = this.createRequestContext(context);
+        await this.requireCapability("uploads", requestContext);
+        const cancelUpload = this.transport.cancelUpload;
+        if (!cancelUpload) {
+            throw new AgentKitCapabilityError("uploads");
+        }
+        await this.invokeRequest(requestContext, (context) => cancelUpload({ threadId, uploadId }, context));
+        this.assertActive();
+    }
+    async queueMessage(input, context) {
+        this.assertActive();
+        const requestContext = this.createRequestContext(context);
+        await this.requireCapability("messageQueue", requestContext);
+        if (input.attachments?.length) {
+            await this.requireCapability("attachments", requestContext);
+        }
+        const queueMessage = this.transport.queueMessage;
+        if (!queueMessage) {
+            throw new AgentKitCapabilityError("messageQueue");
+        }
+        const result = await this.invokeRequest(requestContext, (context) => queueMessage({
+            threadId: input.threadId,
+            text: input.text,
+            attachments: input.attachments,
+            metadata: input.metadata,
+        }, context));
+        this.assertActive();
+        const thread = this.getThread(input.threadId);
+        this.setThread(input.threadId, {
+            ...thread,
+            queuedMessages: [...thread.queuedMessages, result.message],
+        });
+        return result.message;
+    }
+    async removeQueuedMessage(threadId, messageId, context) {
+        this.assertActive();
+        const requestContext = this.createRequestContext(context);
+        await this.requireCapability("messageQueue", requestContext);
+        const removeQueuedMessage = this.transport.removeQueuedMessage;
+        if (!removeQueuedMessage) {
+            throw new AgentKitCapabilityError("messageQueue");
+        }
+        const previous = this.getThread(threadId);
+        const removedIndex = previous.queuedMessages.findIndex((message) => message.id === messageId);
+        const removed = previous.queuedMessages[removedIndex];
+        this.setThread(threadId, {
+            ...previous,
+            queuedMessages: previous.queuedMessages.filter((message) => message.id !== messageId),
+        });
+        try {
+            await this.invokeRequest(requestContext, (context) => removeQueuedMessage({ threadId, messageId }, context));
+            this.assertActive();
+        }
+        catch (error) {
+            if (this.disposed)
+                throw error;
+            if (removed) {
+                const current = this.getThread(threadId);
+                if (!current.queuedMessages.some((message) => message.id === messageId)) {
+                    const queuedMessages = [...current.queuedMessages];
+                    queuedMessages.splice(Math.min(removedIndex, queuedMessages.length), 0, removed);
+                    this.setThread(threadId, { ...current, queuedMessages });
+                }
+            }
+            throw error;
+        }
+    }
+    async steerQueuedMessage(threadId, messageId, context) {
+        this.assertActive();
+        const requestContext = this.createRequestContext(context);
+        await this.requireCapability("messageQueue", requestContext);
+        const steerQueuedMessage = this.transport.steerQueuedMessage;
+        if (!steerQueuedMessage) {
+            throw new AgentKitCapabilityError("messageQueue");
+        }
+        const previous = this.getThread(threadId);
+        const queued = previous.queuedMessages.find((message) => message.id === messageId);
+        if (!queued)
+            throw new Error(`Unknown queued message: ${messageId}`);
+        const message = {
+            id: queued.id,
+            role: "user",
+            createdAt: queued.createdAt,
+            status: "complete",
+            parts: [
+                { type: "text", text: queued.text },
+                ...(queued.attachments ?? []),
+            ],
+            metadata: queued.metadata,
+        };
+        const previousConnection = this.snapshot.connection;
+        const previousError = this.snapshot.error;
+        this.setThread(threadId, {
+            ...previous,
+            messages: [...previous.messages, message],
+            queuedMessages: previous.queuedMessages.filter((candidate) => candidate.id !== messageId),
+            suggestions: [],
+        });
+        this.setConnection("connecting");
+        try {
+            const result = await this.invokeRequest(requestContext, (context) => steerQueuedMessage({ threadId, messageId }, context));
+            this.assertActive();
+            if (!result) {
+                this.setConnection("connected");
+                return;
+            }
+            if (result.capabilities) {
+                this.patch({
+                    capabilities: result.capabilities,
+                    capabilitiesStatus: "ready",
+                });
+            }
+            this.markRunStarted(threadId, result.runId);
+            const completed = this.consume(threadId, result.runId);
+            this.trackConsumer(threadId, result.runId, completed);
+            return {
+                runId: result.runId,
+                completed,
+                cancel: () => this.cancelRun(threadId, result.runId),
+            };
+        }
+        catch (error) {
+            if (this.disposed)
+                throw error;
+            const current = this.getThread(threadId);
+            const queuedMessages = current.queuedMessages.some((candidate) => candidate.id === queued.id)
+                ? current.queuedMessages
+                : [queued, ...current.queuedMessages];
+            this.setThread(threadId, {
+                ...current,
+                messages: current.messages.filter((candidate) => candidate.id !== message.id),
+                queuedMessages,
+            });
+            this.patch({ connection: previousConnection, error: previousError });
+            this.report(error, "queue_steer_failed");
+            throw error;
+        }
+    }
+    async cancelRun(threadId, runId, context) {
+        this.assertActive();
+        const requestContext = this.createRequestContext(context);
+        await this.invokeRequest(requestContext, (context) => this.transport.cancelRun({ threadId, runId }, context));
+        this.assertActive();
+        const status = this.getThread(threadId).runs[runId]?.status;
+        if (status && this.isTerminalStatus(status))
+            return;
+        this.markRunCancelled(threadId, runId);
+        const key = this.runKey(threadId, runId);
+        const hasOtherConsumers = [...this.consumers.keys()].some((candidate) => candidate !== key);
+        this.stopConsumer(threadId, runId, "cancelled");
+        if (!hasOtherConsumers)
+            this.setConnection("connected");
+    }
+    async submitFeedback(threadId, messageId, value, options, context) {
+        this.assertActive();
+        const requestContext = this.createRequestContext(context);
+        await this.requireCapability("feedback", requestContext);
+        const submitFeedback = this.transport.submitFeedback;
+        if (!submitFeedback) {
+            throw new AgentKitCapabilityError("feedback");
+        }
+        await this.invokeRequest(requestContext, (context) => submitFeedback({
+            threadId,
+            messageId,
+            value,
+            ...options,
+        }, context));
+        this.assertActive();
+    }
+    async forkThread(threadId, fromMessageId, options, context) {
+        this.assertActive();
+        const requestContext = this.createRequestContext(context);
+        await this.requireCapability("threadForking", requestContext);
+        const forkThread = this.transport.forkThread;
+        if (!forkThread) {
+            throw new AgentKitCapabilityError("threadForking");
+        }
+        const forked = await this.invokeRequest(requestContext, (context) => forkThread({
+            threadId,
+            fromMessageId,
+            ...options,
+        }, context));
+        this.assertActive();
+        const current = this.getThread(forked.id);
+        this.setThread(forked.id, { ...current, thread: forked });
+        return forked;
+    }
+    async updateThread(threadId, patch, context) {
+        this.assertActive();
+        const requestContext = this.createRequestContext(context);
+        await this.ensureCapabilities(requestContext);
+        const updateThread = this.transport.updateThread;
+        if (!updateThread) {
+            throw new AgentKitOperationError("thread updates");
+        }
+        const updated = await this.invokeRequest(requestContext, (context) => updateThread({ ...patch, threadId }, context));
+        this.assertActive();
+        const current = this.getThread(threadId);
+        this.setThread(threadId, { ...current, thread: updated });
+        return updated;
+    }
+    async deleteThread(threadId, context) {
+        this.assertActive();
+        const requestContext = this.createRequestContext(context);
+        await this.ensureCapabilities(requestContext);
+        const deleteThread = this.transport.deleteThread;
+        if (!deleteThread) {
+            throw new AgentKitOperationError("thread deletion");
+        }
+        await this.invokeRequest(requestContext, (context) => deleteThread({ threadId }, context));
+        this.assertActive();
+        this.stopThreadConsumers(threadId, "deleted");
+        const threads = { ...this.snapshot.threads };
+        delete threads[threadId];
+        this.patch({ threads });
+    }
+    shutdown() {
+        if (this.shutdownPromise)
+            return this.shutdownPromise;
+        this.disposed = true;
+        this.requestAbortController.abort(new AgentKitDisposedError());
+        for (const controller of this.consumerAbortControllers.values()) {
+            controller.abort(new AgentKitConsumerStoppedError("disposed"));
+        }
+        this.consumerAbortControllers.clear();
+        this.threadLeaseCounts.clear();
+        this.patch({ connection: "offline" });
+        this.listeners.clear();
+        this.consumers.clear();
+        this.shutdownPromise = this.ownsTransport
+            ? (async () => {
+                await this.transport.dispose?.();
+            })()
+            : Promise.resolve();
+        return this.shutdownPromise;
+    }
+    dispose() {
+        return this.shutdown();
+    }
+    trackConsumer(threadId, runId, completed) {
+        this.consumers.set(this.runKey(threadId, runId), completed);
+        // `consume` reports failures through snapshot state and `onError` before it
+        // rejects. Observe internally-owned continuations here so a caller that
+        // cannot receive their completion promise never triggers an unhandled
+        // rejection; APIs that return `completed` still expose the original promise.
+        void completed.catch(() => undefined);
+    }
+    async consume(threadId, runId) {
+        const key = this.runKey(threadId, runId);
+        const abortController = new AbortController();
+        this.consumerAbortControllers.set(key, abortController);
+        let attempt = 0;
+        let interruptedForContinuation = [
+            "awaiting_approval",
+            "awaiting_input",
+        ].includes(this.getThread(threadId).runs[runId]?.status ?? "");
+        try {
+            while (true) {
+                const afterSequence = this.getThread(threadId).runs[runId]?.lastSequence ?? 0;
+                let terminalEvent;
+                try {
+                    this.setConnection(attempt === 0 ? "connected" : "reconnecting");
+                    for await (const value of this.transport.subscribeToRun({
+                        threadId,
+                        runId,
+                        afterSequence,
+                        signal: abortController.signal,
+                    })) {
+                        if (abortController.signal.reason instanceof
+                            AgentKitConsumerStoppedError) {
+                            return;
+                        }
+                        const event = parseAgentEvent(value);
+                        if (event.threadId !== threadId) {
+                            throw new AgentProtocolValidationError("event.threadId", "must match the subscribed thread");
+                        }
+                        if (event.runId !== runId) {
+                            throw new AgentProtocolValidationError("event.runId", "must match the subscribed run");
+                        }
+                        this.applyEvent(event);
+                        if (event.type === "approval.requested" ||
+                            event.type === "connection.requested") {
+                            interruptedForContinuation = true;
+                        }
+                        else if (event.type === "approval.resolved") {
+                            interruptedForContinuation = false;
+                        }
+                        else if (event.type === "connection.updated" &&
+                            (event.request.status === "connected" ||
+                                event.request.status === "declined" ||
+                                event.request.status === "failed")) {
+                            interruptedForContinuation = false;
+                        }
+                        if (event.type === "run.completed" ||
+                            event.type === "run.failed" ||
+                            event.type === "run.cancelled") {
+                            terminalEvent = event;
+                        }
+                    }
+                    if (!terminalEvent) {
+                        if (interruptedForContinuation) {
+                            this.setConnection("connected");
+                            return;
+                        }
+                        this.reportIntegrity({
+                            code: "run_missing_terminal",
+                            threadId,
+                            runId,
+                        });
+                        throw new Error(`AgentKit run ${runId} ended without a terminal event.`);
+                    }
+                    this.setConnection("connected");
+                    if (terminalEvent.type === "run.completed") {
+                        if (!this.threadLoads.has(threadId) &&
+                            (this.transport.getThreadSnapshot || this.transport.getThread)) {
+                            await this.loadThreadProjection(threadId, this.createRequestContext(), true);
+                        }
+                        this.scheduleQueuePromotion(threadId);
+                    }
+                    return;
+                }
+                catch (error) {
+                    if (abortController.signal.reason instanceof
+                        AgentKitConsumerStoppedError) {
+                        return;
+                    }
+                    if (abortController.signal.aborted ||
+                        !errorIsRetryable(error) ||
+                        attempt >= this.reconnectAttempts) {
+                        throw error;
+                    }
+                    attempt += 1;
+                    this.setConnection("reconnecting");
+                    await this.waitForReconnect(this.reconnectDelay(attempt), abortController.signal);
+                }
+            }
+        }
+        catch (error) {
+            if (abortController.signal.reason instanceof AgentKitConsumerStoppedError) {
+                return;
+            }
+            this.fail(error, "run_stream_failed");
+            throw error;
+        }
+        finally {
+            this.consumers.delete(key);
+            this.consumerAbortControllers.delete(key);
+        }
+    }
+    waitForReconnect(duration, signal) {
+        return new Promise((resolve, reject) => {
+            const onAbort = () => {
+                clearTimeout(timeout);
+                reject(signal.reason ?? this.abortError());
+            };
+            const timeout = setTimeout(() => {
+                signal.removeEventListener("abort", onAbort);
+                resolve();
+            }, duration);
+            signal.addEventListener("abort", onAbort, { once: true });
+        });
+    }
+    abortError() {
+        const error = new Error("Aborted");
+        error.name = "AbortError";
+        return error;
+    }
+    async ensureCapabilities(context) {
+        this.assertRequestActive(context);
+        if (this.snapshot.capabilitiesStatus === "ready" &&
+            !this.capabilitiesExpired()) {
+            return this.snapshot.capabilities;
+        }
+        if (this.capabilitiesLoad) {
+            return this.invokeRequest(context, () => this.capabilitiesLoad);
+        }
+        this.patch({ capabilitiesStatus: "loading" });
+        const loadContext = this.createRequestContext({
+            correlationId: context.correlationId,
+        });
+        const load = (async () => {
+            if (this.transport.discoverCapabilities) {
+                const discoverCapabilities = this.transport.discoverCapabilities;
+                const discovery = await this.invokeRequest(loadContext, (requestContext) => discoverCapabilities({ protocol: createAgentKitProtocolVersionOffer() }, requestContext));
+                if (discovery.protocol.status === "incompatible") {
+                    throw new AgentKitHandshakeError(discovery.protocol.error.code, discovery.protocol.error.message, discovery.protocol.error.details, discovery.protocol.error.correlationId);
+                }
+                const capabilities = discovery.legacy ?? projectAgentCapabilities(discovery);
+                this.patch({
+                    capabilities,
+                    capabilityDiscovery: discovery,
+                    capabilitiesStatus: "ready",
+                });
+                return capabilities;
+            }
+            const capabilities = this.transport.capabilities ?? {};
+            this.patch({ capabilities, capabilitiesStatus: "ready" });
+            return capabilities;
+        })().catch((error) => {
+            if (!this.disposed)
+                this.patch({ capabilitiesStatus: "error" });
+            throw error;
+        });
+        this.capabilitiesLoad = load;
+        try {
+            return await this.invokeRequest(context, () => load);
+        }
+        finally {
+            if (this.capabilitiesLoad === load)
+                this.capabilitiesLoad = undefined;
+        }
+    }
+    capabilitiesExpired() {
+        const expiresAt = this.snapshot.capabilityDiscovery?.expiresAt;
+        if (!expiresAt)
+            return false;
+        const expiration = Date.parse(expiresAt);
+        const current = Date.parse(this.now());
+        return (Number.isFinite(expiration) &&
+            Number.isFinite(current) &&
+            expiration <= current);
+    }
+    hydrateThread(snapshot, runs, activeRunIds) {
+        let hydrated = createAgentThreadState(snapshot.id);
+        for (const event of snapshot.events ?? []) {
+            hydrated = reduceAgentEvent(hydrated, event);
+        }
+        const snapshotApprovals = Object.fromEntries((snapshot.approvals ?? [])
+            .filter((approval) => approval.status === "pending")
+            .map((approval) => [approval.request.id, approval.request]));
+        const snapshotApprovalRunIds = Object.fromEntries((snapshot.approvals ?? [])
+            .filter((approval) => approval.status === "pending" && approval.runId !== undefined)
+            .map((approval) => [approval.request.id, approval.runId]));
+        const snapshotConnectionRequests = Object.fromEntries((snapshot.connectionRequests ?? []).map((entry) => [
+            entry.request.id,
+            entry.request,
+        ]));
+        const snapshotConnectionRequestRunIds = Object.fromEntries((snapshot.connectionRequests ?? [])
+            .filter((entry) => entry.runId !== undefined)
+            .map((entry) => [entry.request.id, entry.runId]));
+        const snapshotWidgets = Object.fromEntries((snapshot.widgets ?? []).map((entry) => [entry.widget.id, entry.widget]));
+        const snapshotWidgetMessageIds = Object.fromEntries((snapshot.widgets ?? []).map((entry) => [
+            entry.widget.id,
+            entry.messageId,
+        ]));
+        const mergedRuns = this.mergeRuns(hydrated.runs, runs);
+        const currentActiveRunIds = activeRunIds.filter((runId) => !this.isTerminalStatus(mergedRuns[runId]?.status ?? "running"));
+        return {
+            ...hydrated,
+            thread: snapshot,
+            // The snapshot projection is authoritative. The event log rebuilds all
+            // rich, non-message state without replaying text deltas twice.
+            messages: snapshot.messages,
+            queuedMessages: snapshot.queuedMessages ?? hydrated.queuedMessages,
+            runs: mergedRuns,
+            activeRunIds: currentActiveRunIds,
+            tools: {
+                ...hydrated.tools,
+                ...Object.fromEntries((snapshot.toolCalls ?? []).map((tool) => [tool.id, tool])),
+            },
+            activities: {
+                ...hydrated.activities,
+                ...Object.fromEntries((snapshot.activities ?? []).map((activity) => [
+                    activity.id,
+                    activity,
+                ])),
+            },
+            tasks: {
+                ...hydrated.tasks,
+                ...Object.fromEntries((snapshot.tasks ?? []).map((task) => [task.id, task])),
+            },
+            approvals: { ...hydrated.approvals, ...snapshotApprovals },
+            approvalRunIds: {
+                ...hydrated.approvalRunIds,
+                ...snapshotApprovalRunIds,
+            },
+            connectionRequests: {
+                ...hydrated.connectionRequests,
+                ...snapshotConnectionRequests,
+            },
+            connectionRequestRunIds: {
+                ...hydrated.connectionRequestRunIds,
+                ...snapshotConnectionRequestRunIds,
+            },
+            widgets: { ...hydrated.widgets, ...snapshotWidgets },
+            widgetMessageIds: {
+                ...hydrated.widgetMessageIds,
+                ...snapshotWidgetMessageIds,
+            },
+            agents: {
+                ...hydrated.agents,
+                ...Object.fromEntries((snapshot.agents ?? []).map((agent) => [agent.id, agent])),
+            },
+            agentInteractions: snapshot.interactions ?? hydrated.agentInteractions,
+            artifacts: snapshot.artifacts ?? hydrated.artifacts,
+            suggestions: snapshot.suggestions ?? hydrated.suggestions,
+        };
+    }
+    async requireCapability(capability, context) {
+        const capabilities = await this.ensureCapabilities(context);
+        this.assertActive();
+        const descriptor = this.snapshot.capabilityDiscovery?.capabilities.find((candidate) => candidate.id === capability);
+        if (descriptor?.state === "unsupported") {
+            throw this.capabilityError(descriptor);
+        }
+        if (descriptor?.state === "unavailable") {
+            throw this.capabilityError(descriptor);
+        }
+        if (this.snapshot.capabilityDiscovery && !descriptor) {
+            throw new AgentKitCapabilityError(capability, "unavailable", `The ${JSON.stringify(capability)} capability was not included in discovery.`, true);
+        }
+        if (capabilities[capability] === false) {
+            throw new AgentKitCapabilityError(capability);
+        }
+    }
+    capabilityError(descriptor) {
+        const unavailable = descriptor.state === "unavailable";
+        return new AgentKitCapabilityError(descriptor.id, unavailable ? "unavailable" : "unsupported", descriptor.error?.message ?? descriptor.description, descriptor.error?.retryable ?? unavailable, descriptor.error?.correlationId, descriptor.error?.details);
+    }
+    mergeLoadedThread(baseline, current, loaded) {
+        const runs = current.runs === baseline.runs
+            ? loaded.runs
+            : this.mergeRuns(loaded.runs, current.runs);
+        const activeRunIds = Array.from(new Set([...loaded.activeRunIds, ...current.activeRunIds])).filter((runId) => !this.isTerminalStatus(runs[runId]?.status ?? "running"));
+        return {
+            ...loaded,
+            thread: current.thread === baseline.thread ? loaded.thread : current.thread,
+            messages: current.messages === baseline.messages
+                ? loaded.messages
+                : this.mergeItemsById(loaded.messages, current.messages),
+            queuedMessages: current.queuedMessages === baseline.queuedMessages
+                ? loaded.queuedMessages
+                : this.mergeQueuedMessages(baseline.queuedMessages, loaded.queuedMessages, current.queuedMessages),
+            runs,
+            activeRunIds,
+            events: current.events === baseline.events
+                ? loaded.events
+                : this.mergeEvents(loaded.events, current.events),
+            agents: current.agents === baseline.agents
+                ? loaded.agents
+                : { ...loaded.agents, ...current.agents },
+            agentInteractions: current.agentInteractions === baseline.agentInteractions
+                ? loaded.agentInteractions
+                : this.mergeItemsById(loaded.agentInteractions, current.agentInteractions),
+            activities: current.activities === baseline.activities
+                ? loaded.activities
+                : { ...loaded.activities, ...current.activities },
+            tasks: current.tasks === baseline.tasks
+                ? loaded.tasks
+                : { ...loaded.tasks, ...current.tasks },
+            tools: current.tools === baseline.tools
+                ? loaded.tools
+                : { ...loaded.tools, ...current.tools },
+            approvals: current.approvals === baseline.approvals
+                ? loaded.approvals
+                : current.approvals,
+            approvalRunIds: current.approvalRunIds === baseline.approvalRunIds
+                ? loaded.approvalRunIds
+                : current.approvalRunIds,
+            connectionRequests: current.connectionRequests === baseline.connectionRequests
+                ? loaded.connectionRequests
+                : { ...loaded.connectionRequests, ...current.connectionRequests },
+            connectionRequestRunIds: current.connectionRequestRunIds === baseline.connectionRequestRunIds
+                ? loaded.connectionRequestRunIds
+                : {
+                    ...loaded.connectionRequestRunIds,
+                    ...current.connectionRequestRunIds,
+                },
+            artifacts: current.artifacts === baseline.artifacts
+                ? loaded.artifacts
+                : this.mergeItemsById(loaded.artifacts, current.artifacts),
+            widgets: current.widgets === baseline.widgets
+                ? loaded.widgets
+                : { ...loaded.widgets, ...current.widgets },
+            widgetMessageIds: current.widgetMessageIds === baseline.widgetMessageIds
+                ? loaded.widgetMessageIds
+                : { ...loaded.widgetMessageIds, ...current.widgetMessageIds },
+            annotations: current.annotations === baseline.annotations
+                ? loaded.annotations
+                : { ...loaded.annotations, ...current.annotations },
+            annotationMessageIds: current.annotationMessageIds === baseline.annotationMessageIds
+                ? loaded.annotationMessageIds
+                : {
+                    ...loaded.annotationMessageIds,
+                    ...current.annotationMessageIds,
+                },
+            suggestions: current.suggestions === baseline.suggestions
+                ? loaded.suggestions
+                : current.suggestions,
+            actions: current.actions === baseline.actions
+                ? loaded.actions
+                : { ...loaded.actions, ...current.actions },
+            uploads: current.uploads === baseline.uploads
+                ? loaded.uploads
+                : { ...loaded.uploads, ...current.uploads },
+        };
+    }
+    mergeRuns(first, second) {
+        const merged = { ...first };
+        for (const [runId, run] of Object.entries(second)) {
+            const existing = merged[runId];
+            if (!existing || run.lastSequence >= existing.lastSequence) {
+                merged[runId] = run;
+            }
+        }
+        return merged;
+    }
+    mergeQueuedMessages(baseline, loaded, current) {
+        const currentIds = new Set(current.map((message) => message.id));
+        const removedIds = new Set(baseline
+            .filter((message) => !currentIds.has(message.id))
+            .map((message) => message.id));
+        return this.mergeItemsById(loaded.filter((message) => !removedIds.has(message.id)), current);
+    }
+    mergeItemsById(first, second) {
+        const merged = [...first];
+        const indexById = new Map(merged.map((item, index) => [item.id, index]));
+        for (const item of second) {
+            const index = indexById.get(item.id);
+            if (index === undefined) {
+                indexById.set(item.id, merged.length);
+                merged.push(item);
+            }
+            else {
+                merged[index] = item;
+            }
+        }
+        return merged;
+    }
+    reconcileMessages(current, durable) {
+        if (durable.length === 0) {
+            return { messages: current, idRemap: new Map() };
+        }
+        const durableIds = new Set(durable.map((message) => message.id));
+        const currentIds = new Set(current.map((message) => message.id));
+        const unmatchedContent = new Map();
+        for (const message of durable) {
+            // An explicit durable identity already present in the local projection
+            // owns its match. Content fallback is only for still-unidentified work.
+            if (currentIds.has(message.id))
+                continue;
+            const key = this.messageContentKey(message);
+            unmatchedContent.set(key, [
+                ...(unmatchedContent.get(key) ?? []),
+                message,
+            ]);
+        }
+        const optimistic = [];
+        const idRemap = new Map();
+        for (const message of current) {
+            if (durableIds.has(message.id))
+                continue;
+            const key = this.messageContentKey(message);
+            const matches = unmatchedContent.get(key);
+            const durableMatch = matches?.shift();
+            if (durableMatch) {
+                idRemap.set(message.id, durableMatch.id);
+            }
+            else {
+                optimistic.push(message);
+            }
+        }
+        return { messages: [...durable, ...optimistic], idRemap };
+    }
+    remapThreadMessageReferences(thread, idRemap) {
+        if (idRemap.size === 0)
+            return thread;
+        const remap = (messageId) => messageId ? (idRemap.get(messageId) ?? messageId) : undefined;
+        const events = thread.events.map((event) => {
+            switch (event.type) {
+                case "message.created":
+                case "message.completed":
+                    return {
+                        ...event,
+                        message: {
+                            ...event.message,
+                            id: remap(event.message.id),
+                        },
+                    };
+                case "message.delta":
+                case "reasoning.delta":
+                    return { ...event, messageId: remap(event.messageId) };
+                case "tool.started":
+                case "tool.updated":
+                    return {
+                        ...event,
+                        toolCall: {
+                            ...event.toolCall,
+                            ...(event.toolCall.messageId
+                                ? { messageId: remap(event.toolCall.messageId) }
+                                : {}),
+                        },
+                    };
+                case "widget.created":
+                case "widget.updated":
+                case "annotation.created":
+                case "annotation.updated":
+                    return event.messageId
+                        ? { ...event, messageId: remap(event.messageId) }
+                        : event;
+                case "action.started":
+                    return event.invocation.messageId
+                        ? {
+                            ...event,
+                            invocation: {
+                                ...event.invocation,
+                                messageId: remap(event.invocation.messageId),
+                            },
+                        }
+                        : event;
+                default:
+                    return event;
+            }
+        });
+        const remapRecord = (record) => Object.fromEntries(Object.entries(record).map(([id, messageId]) => [
+            id,
+            remap(messageId),
+        ]));
+        return {
+            ...thread,
+            events,
+            tools: Object.fromEntries(Object.entries(thread.tools).map(([id, tool]) => [
+                id,
+                tool.messageId ? { ...tool, messageId: remap(tool.messageId) } : tool,
+            ])),
+            widgetMessageIds: remapRecord(thread.widgetMessageIds),
+            annotationMessageIds: remapRecord(thread.annotationMessageIds),
+            actions: Object.fromEntries(Object.entries(thread.actions).map(([id, action]) => [
+                id,
+                action.invocation?.messageId
+                    ? {
+                        ...action,
+                        invocation: {
+                            ...action.invocation,
+                            messageId: remap(action.invocation.messageId),
+                        },
+                    }
+                    : action,
+            ])),
+        };
+    }
+    messageContentKey(message) {
+        const text = message.parts
+            .filter((part) => part.type === "text")
+            .map((part) => part.text)
+            .join("");
+        return text
+            ? JSON.stringify([message.role, "text", text])
+            : JSON.stringify([message.role, "parts", message.parts]);
+    }
+    mergeEvents(first, second) {
+        const merged = [...first];
+        const keys = new Set(first.map((event) => `${event.threadId}\u0000${event.runId}\u0000${event.sequence}`));
+        for (const event of second) {
+            const key = `${event.threadId}\u0000${event.runId}\u0000${event.sequence}`;
+            if (!keys.has(key)) {
+                keys.add(key);
+                merged.push(event);
+            }
+        }
+        return merged;
+    }
+    releaseThreadLease(threadId) {
+        const count = this.threadLeaseCounts.get(threadId) ?? 0;
+        if (count <= 1) {
+            this.threadLeaseCounts.delete(threadId);
+            if (!this.retainActiveRunsOnThreadRelease) {
+                this.stopThreadConsumers(threadId, "released");
+            }
+            return;
+        }
+        this.threadLeaseCounts.set(threadId, count - 1);
+    }
+    stopThreadConsumers(threadId, reason) {
+        for (const [key, controller] of this.consumerAbortControllers) {
+            if (key.startsWith(`${threadId}\u0000`)) {
+                controller.abort(new AgentKitConsumerStoppedError(reason));
+            }
+        }
+    }
+    stopConsumer(threadId, runId, reason) {
+        this.consumerAbortControllers
+            .get(this.runKey(threadId, runId))
+            ?.abort(new AgentKitConsumerStoppedError(reason));
+    }
+    markRunCancelled(threadId, runId) {
+        const thread = this.getThread(threadId);
+        const run = thread.runs[runId] ?? this.runState(runId);
+        const activeRunIds = thread.activeRunIds.filter((id) => id !== runId);
+        this.setThread(threadId, {
+            ...thread,
+            runs: {
+                ...thread.runs,
+                [runId]: {
+                    ...run,
+                    status: "cancelled",
+                    completedAt: this.now(),
+                },
+            },
+            activeRunIds,
+        });
+    }
+    markRunStarted(threadId, runId) {
+        const thread = this.getThread(threadId);
+        const run = thread.runs[runId] ?? this.runState(runId);
+        const activeRunIds = Array.from(new Set([...thread.activeRunIds, runId]));
+        this.setThread(threadId, {
+            ...thread,
+            runs: {
+                ...thread.runs,
+                [runId]: { ...run, status: "running" },
+            },
+            activeRunIds,
+        });
+    }
+    retireInterruptedRun(threadId, runId) {
+        const thread = this.getThread(threadId);
+        this.setThread(threadId, {
+            ...thread,
+            activeRunIds: thread.activeRunIds.filter((id) => id !== runId),
+        });
+    }
+    runKey(threadId, runId) {
+        return `${threadId}\u0000${runId}`;
+    }
+    runState(runId, run) {
+        return {
+            id: runId,
+            status: run?.status ?? "running",
+            lastSequence: run?.lastSequence ?? 0,
+            startedAt: run?.startedAt,
+            completedAt: run?.completedAt,
+            usage: run?.usage,
+            error: run?.error,
+        };
+    }
+    runSnapshot(threadId, runId) {
+        return {
+            id: runId,
+            threadId,
+            status: "running",
+            lastSequence: 0,
+        };
+    }
+    isTerminalStatus(status) {
+        return ["completed", "failed", "cancelled"].includes(status);
+    }
+    scheduleQueuePromotion(threadId) {
+        const thread = this.getThread(threadId);
+        if (this.queuePromotions.has(threadId))
+            return;
+        const queued = thread.queuedMessages[0];
+        if (!queued)
+            return;
+        // Reached only after a terminal event, so a queued follow-up that cannot
+        // be promoted here is stranded rather than merely waiting.
+        if (!this.transport.steerQueuedMessage) {
+            this.reportIntegrity({
+                code: "queue_promotion_dropped",
+                threadId,
+                reason: "transport-cannot-steer",
+            });
+            return;
+        }
+        if (thread.activeRunIds.length > 0) {
+            this.reportIntegrity({
+                code: "queue_promotion_dropped",
+                threadId,
+                reason: "run-still-active",
+            });
+            return;
+        }
+        this.queuePromotions.add(threadId);
+        void this.steerQueuedMessage(threadId, queued.id)
+            .catch(() => {
+            // `steerQueuedMessage` already restores state and reports the failure.
+        })
+            .finally(() => this.queuePromotions.delete(threadId));
+    }
+    assertActive() {
+        if (this.disposed) {
+            throw new AgentKitDisposedError();
+        }
+    }
+    applyEvent(event) {
+        const thread = this.getThread(event.threadId);
+        const admission = classifyAgentEvent(thread, event);
+        if (admission.status === "duplicate") {
+            this.reportIntegrity({
+                code: "duplicate_event",
+                threadId: event.threadId,
+                runId: event.runId,
+                expectedSequence: admission.lastSequence + 1,
+                receivedSequence: event.sequence,
+            });
+        }
+        if (admission.status === "gap") {
+            this.reportIntegrity({
+                code: "sequence_gap",
+                threadId: event.threadId,
+                runId: event.runId,
+                expectedSequence: admission.expectedSequence,
+                receivedSequence: admission.receivedSequence,
+            });
+        }
+        this.setThread(event.threadId, reduceAgentEvent(thread, event));
+    }
+    setThread(threadId, thread) {
+        this.patch({
+            threads: { ...this.snapshot.threads, [threadId]: thread },
+            error: undefined,
+        });
+    }
+    setConnection(connection) {
+        if (this.snapshot.connection !== connection)
+            this.patch({ connection });
+    }
+    fail(error, code) {
+        const agentError = toError(error, code);
+        this.patch({ connection: "error", error: agentError });
+        this.onError?.(agentError);
+    }
+    report(error, code) {
+        this.onError?.(toError(error, code));
+    }
+    reportIntegrity(report) {
+        try {
+            this.onIntegrityReport?.(report);
+            // coercion-ok: a counter must never affect the stream it counts.
+        }
+        catch { }
+    }
+    patch(patch) {
+        this.snapshot = {
+            ...this.snapshot,
+            ...patch,
+            revision: this.snapshot.revision + 1,
+        };
+        for (const listener of this.listeners)
+            listener();
+    }
+}
+//# sourceMappingURL=client.js.map