@makaio/framework 1.0.0-dev-1785407933303 → 1.0.0-dev-1786014320559

package/dist/adapters/index.d.mts

@@ -1,5 +1,5 @@
-import { $ as NormalizedMessageInput, C as NormalizedCallUsage, D as AdapterAuthLeaseHandle, E as StartAgentOptions, J as IAdapterConfigFactory, K as AdapterProviderDefinition, O as AdapterAuthRuntimePreparer, Q as markCompletedWithFinalResult, S as GetCapabilitiesResponsePayload, T as SendMessageResponsePayload, X as MessageDeliveryMode, Y as AIAgentConnector, Z as MessageHandle, _ as BaseAgentConnectorConfig, a as AgentCredentialChangeResponsePayload, at as AIModel, b as ContextWindowInput, c as AgentIdentity, ct as ISessionToolLedger, d as AgentMcpServersSetRequestPayload, dt as ToolLedgerEntry, et as normalizeMessageInput, f as AgentMcpServersSetResponsePayload, g as AgentStartResult, h as AgentSendMessageOptions, i as AgentCredentialChangeRequestPayload, it as SendMessageOptions, j as ResolvedAdapterRuntimeConfig, k as BoundAdapterRuntimeConfig, l as AgentInterruptRequestPayload, lt as LedgerSessionContext, m as AgentModelChangeResponsePayload, n as AgentConnectorConfigOverrides, nt as MessageState, o as AgentCwdChangeRequestPayload, ot as AIReasoningLevel, p as AgentModelChangeRequestPayload, q as ConfigFactoryInput, r as AgentContext, rt as ProcessingState, s as AgentCwdChangeResponsePayload, st as ReasoningLevelMap, t as AIAgentConfig, tt as MessageResult, u as AgentInterruptResponsePayload, ut as SessionToolLedger, v as ConnectorSendMessageOptions, w as SendMessageRequestPayload, x as ExecutionContext, y as ConnectorStartOptions } from "../types-CJ_QZ1yW.mjs";
-import { S as toImportSegment, _ as LogImporter, a as CompactionMetadata, b as ProcessLogFileResult, c as ExternalToolIdentifiers, d as ImportMetadata, f as ImportSegment, g as LogImportTestConfig, h as LogImportSessionContext, l as ExternalToolMeta, m as ImportSegmentTurn, n as LogOrchestratorConfig, o as DiscoveryMetadata, p as ImportSegmentLineage, r as ParseFileResult, s as ExternalToolIdentifier, u as ImportCursorPosition, v as LogImporterConfig, x as StorageMessagePayload, y as NormalizedEvent } from "../base-orchestrator-BilsQNW1.mjs";
+import { $t as SessionToolLedger, A as AgentTeardownArbiter, At as runBestEffortStage, Bt as MessageHandle, C as NormalizedCallUsage, Ct as ObservedExitOptions, D as AdapterProviderDefinition, Dt as reportBestEffortStages, E as StartAgentOptions, Et as exitWasObserved, F as TeardownSubject, Ft as unknownTeardown, Gt as MessageState, Ht as NormalizedMessageInput, I as CreateConnectorRuntimeOptions, It as CONNECTOR_EXIT_OBSERVATION_MS, Jt as AIModel, Kt as ProcessingState, Lt as SWAP_SETTLEMENT_WAIT_MS, M as ConnectorReplacementSettlement, Mt as TeardownReport, N as ConnectorSwapAdmission, Nt as aggregateTeardownReports, O as ConfigFactoryInput, Ot as reportObservedExit, P as ConnectorSwapHandover, Pt as rethrowTeardownFailure, Qt as LedgerSessionContext, R as AdapterAuthRuntimePreparer, Rt as AIAgentConnector, S as GetCapabilitiesResponsePayload, St as SupersededGeneration, T as SendMessageResponsePayload, Tt as describeTeardownFailure, Ut as normalizeMessageInput, Vt as markCompletedWithFinalResult, Wt as MessageResult, Xt as ReasoningLevelMap, Yt as AIReasoningLevel, Zt as ISessionToolLedger, _ as BaseAgentConnectorConfig, _t as BaseConnectorTurn, a as AgentCredentialChangeResponsePayload, at as WireSessionSubjects, b as ContextWindowInput, bt as ConnectorSessionConfig, c as AgentIdentity, ct as QueueableTurn, d as AgentMcpServersSetRequestPayload, dt as rejectQueuedHandles, en as ToolLedgerEntry, f as AgentMcpServersSetResponsePayload, ft as UserMessageQueue, g as AgentStartResult, gt as TurnSubjects, h as AgentSendMessageOptions, ht as ProceduralTurnState, i as AgentCredentialChangeRequestPayload, it as WireSessionConfig, j as ClosableConnectorRuntime, jt as stageFailure, k as IAdapterConfigFactory, kt as reportRepeatTeardown, l as AgentInterruptRequestPayload, lt as SESSION_CLOSED_QUEUE_ERROR, m as AgentModelChangeResponsePayload, mt as ProceduralTurnConfig, n as AgentConnectorConfigOverrides, nt as ProceduralAgentConnector, o as AgentCwdChangeRequestPayload, ot as MergeResult, p as AgentModelChangeRequestPayload, pt as ProceduralConnectorTurn, qt as SendMessageOptions, r as AgentContext, rt as ProceduralConnectorSession, s as AgentCwdChangeResponsePayload, st as ProcessQueueCallbacks, t as AIAgentConfig, u as AgentInterruptResponsePayload, ut as processQueueMessages, v as ConnectorSendMessageOptions, vt as PauseResult, w as SendMessageRequestPayload, wt as capTeardownEvidence, x as ExecutionContext, xt as GenerationRetirementLedger, y as ConnectorStartOptions, yt as BaseConnectorSession, zt as MessageDeliveryMode } from "../types-ClpEaoAm.mjs";
+import { S as toImportSegment, _ as LogImporter, a as CompactionMetadata, b as ProcessLogFileResult, c as ExternalToolIdentifiers, d as ImportMetadata, f as ImportSegment, g as LogImportTestConfig, h as LogImportSessionContext, l as ExternalToolMeta, m as ImportSegmentTurn, n as LogOrchestratorConfig, o as DiscoveryMetadata, p as ImportSegmentLineage, r as ParseFileResult, s as ExternalToolIdentifier, u as ImportCursorPosition, v as LogImporterConfig, x as StorageMessagePayload, y as NormalizedEvent } from "../base-orchestrator-D9u4NyiM.mjs";
 import { z } from "zod";
 import * as _$_makaio_core0 from "@makaio/framework/core";
 import { CreateBusNamespaceOptions, ExtractSubjectPayload, FilterablePayloadIntersection, HandlerForSubjectDefinition, RegistrableBusNamespaceDefinition, RequestContext, SchemaRecord, ScopedSubjectDefinition, SubjectDefinition, SubjectRecordFromSchemaRecord } from "@makaio/framework/core";
@@ -144,6 +144,30 @@ interface AIAdapterInitOptions {
  */
 declare function safeJsonStringify(value: unknown): string;
 //#endregion
+//#region adapters/core/src/utils/withTimeout.d.ts
+/**
+ * Bounding helper for awaits that would otherwise have no end.
+ * @packageDocumentation
+ */
+/**
+ * Race a promise against a timeout, clearing the timer when either settles.
+ *
+ * Exists so an adapter that declares a budget can actually honour it: an
+ * unbounded await on a provider handshake is indistinguishable from a hang, and
+ * a caller waiting behind it inherits that hang. The timer is always cleared, so
+ * bounding a promise never keeps the event loop alive past its settlement.
+ *
+ * The bound applies to the *wait*, not to the work. A rejected race leaves the
+ * underlying operation running; callers that own a resource behind the promise
+ * are responsible for releasing it.
+ * @param promise - Promise to bound.
+ * @param ms - Milliseconds to wait before rejecting.
+ * @param message - Error message used when the bound expires.
+ * @returns The promise's resolved value.
+ * @throws Error with `message` when the bound expires first.
+ */
+declare function withTimeout<T>(promise: Promise<T>, ms: number, message: string): Promise<T>;
+//#endregion
 //#region adapters/core/src/utils/serializeTurnContext.d.ts
 /**
  * A single serialized context entry ready for adapter-specific formatting.
@@ -719,657 +743,6 @@ declare function formatMessageHistoryAsTranscript(history: Message[]): string;
  */
 declare function serializeBlockToText(block: MessageBlock$1): string;
 //#endregion
-//#region adapters/core/src/connector/base-connector-session.d.ts
-/**
- * Configuration for a connector session.
- * @typeParam TBus - Scoped bus type for adapter namespace
- */
-interface ConnectorSessionConfig<TBus extends ScopedBus<string> = ScopedBus<string>> {
-  bus: TBus;
-  adapterId: string;
-  adapterName: string;
-  cwd: string;
-  model: string;
-  env: Record<string, string>;
-  /** Auth-free environment safe for bus-routable tool and MCP contexts. */
-  contextEnv?: Readonly<Record<string, string>>;
-}
-/**
- * Interface for turn-like objects that support pause/abort operations.
- * Allows base session class to work with different turn implementations.
- */
-interface PausableTurn {
-  pause(): Promise<unknown>;
-}
-/**
- * Base abstract class for connector session implementations.
- *
- * Sessions manage SDK query lifecycle across multiple turns:
- * - SDK connection management
- * - Turn creation and coordination
- * - Session ID management
- *
- * Each adapter implements its own session subclass.
- * @typeParam TConfig - Configuration type extending ConnectorSessionConfig
- */
-declare abstract class BaseConnectorSession<TConfig extends ConnectorSessionConfig = ConnectorSessionConfig> {
-  protected readonly config: TConfig;
-  protected readonly bus: TConfig['bus'];
-  protected sessionId?: string;
-  protected currentTurn?: PausableTurn;
-  /**
-   * True once `close()` or `abort()` has begun; gates queue processing.
-   *
-   * ## Shutdown vs queue processing invariant
-   *
-   * Once `close()` or `abort()` begins, no new turn may start.
-   * `processQueue` implementations must refuse to dequeue or start turns
-   * when `this.closing` is `true`, and drain all remaining queued handles
-   * with an error outcome so that callers awaiting `waitForCompletion()`
-   * resolve deterministically instead of hanging.
-   *
-   * A dequeued handle that has entered the start-turn path either starts
-   * its turn before `close()` begins, or is completed with the closing
-   * error at every await point where `close()` can interleave. This is
-   * enforced by {@link completeHandleIfClosing}, which rechecks the flag
-   * after each awaited setup step and completes the handle with the same
-   * error contract used by {@link rejectQueuedHandles}.
-   */
-  protected closing: boolean;
-  constructor(config: TConfig);
-  /**
-   * Recheck the shutdown flag after an awaited setup step in the start path.
-   *
-   * When `close()` sets `this.closing` while the subclass start-turn method
-   * is awaiting an async setup step (schema rotation, query creation, MCP
-   * registration, env resolution), the dequeued handle is no longer in the
-   * queue and {@link rejectQueuedHandles} cannot reach it. This helper
-   * completes the handle with the same error contract so callers see a
-   * consistent shutdown outcome.
-   * @param handle - Dequeued message handle currently being set up
-   * @returns `true` when the session is closing and the handle was completed
-   */
-  protected completeHandleIfClosing(handle: MessageHandle): boolean;
-  /**
-   * Abort the session and cleanup resources.
-   * Pauses the current turn if one is active.
-   */
-  abort(): Promise<void>;
-  /**
-   * Send a message to the provider.
-   * Not used - subclasses should implement processQueue instead.
-   * @param _message - Unused message parameter
-   * @param _options - Unused options parameter
-   */
-  sendMessage(_message: unknown, _options?: unknown): Promise<void>;
-  /**
-   * Get the adapter session ID.
-   * @returns The session ID from the provider
-   */
-  getAdapterSessionId(): Promise<string>;
-}
-//#endregion
-//#region adapters/core/src/connector/base-connector-turn.d.ts
-/**
- * Result of pausing a turn.
- * @typeParam TState - Turn state type
- */
-interface PauseResult<TState = string> {
-  /** The state the turn was in before pausing */
-  stateBeforePause: TState;
-  /** Whether the turn had already ended when pause was requested */
-  turnEnded: boolean;
-}
-/**
- * Base abstract class for connector turn implementations.
- *
- * Turns manage the state machine for a single user message:
- * - State transitions (idle to turn_started to step_started to ...)
- * - Pause/resume mechanics
- * - Safe boundary detection for immediate messages
- * - Message handle delegation (acknowledgment, completion)
- *
- * Each adapter implements its own turn subclass with adapter-specific
- * state handling and SDK integration.
- * @typeParam TState - Turn state enum type (string union)
- */
-declare abstract class BaseConnectorTurn<TState extends string = string> {
-  protected state: TState;
-  protected readonly bus: ScopedBus<string>;
-  protected readonly adapterId: string;
-  protected readonly adapterName: string;
-  protected stateChangedCallback?: (oldState: TState, newState: TState) => Promise<void> | void;
-  /**
-   * Active message handle for this turn.
-   * Subclasses must provide this handle for message lifecycle management.
-   */
-  protected abstract activeMessageHandle: MessageHandle;
-  constructor(bus: ScopedBus<string>, adapterId: string, adapterName: string, initialState: TState);
-  /**
-   * Pause the turn at next safe boundary.
-   * @returns Pause result indicating whether turn already ended
-   */
-  abstract pause(): Promise<PauseResult<TState>>;
-  /**
-   * Resume the paused turn with optional additional message.
-   * @param message - Optional message to inject when resuming
-   */
-  abstract resume(message?: unknown): Promise<void>;
-  /**
-   * Check if turn is currently paused.
-   */
-  abstract isPaused(): boolean;
-  /**
-   * Register callback for state changes.
-   * @param cb - Callback to invoke on state transitions
-   */
-  onStateChanged(cb: (oldState: TState, newState: TState) => Promise<void> | void): void;
-  /**
-   * Transition to new state and notify listeners.
-   * Template method for shared state transition pattern.
-   *
-   * NOTE: Subclasses should use their typed namespace subjects for emission.
-   * This is a template - concrete implementation in adapter-specific Turn classes.
-   * @param newState - New state to transition to
-   */
-  protected transitionTo(newState: TState): Promise<void>;
-  /**
-   * Emit state change event - implemented by subclass with typed subjects.
-   * @param oldState - Previous state
-   * @param newState - New state
-   */
-  protected abstract emitStateChange(oldState: TState, newState: TState): Promise<void>;
-  /**
-   * Get current turn state.
-   * @returns Current turn state
-   */
-  getState(): TState;
-  /**
-   * Get the message handle for this turn.
-   * @returns The message handle for this turn
-   */
-  getMessageHandle(): MessageHandle;
-  /**
-   * Mark message handle as acknowledged.
-   */
-  markAcknowledged(): void;
-  /**
-   * Mark message handle as completed.
-   * @param result - The completion result with outcome and optional result/error
-   */
-  markCompleted(result: {
-    outcome: string;
-    result?: unknown;
-    error?: unknown;
-  }): void;
-}
-//#endregion
-//#region adapters/core/src/connector/procedural-connector-turn.d.ts
-/**
- * Typed subject references for turn lifecycle events.
- *
- * Each adapter provides its namespace-specific subjects when constructing
- * a ProceduralConnectorTurn. The subjects must all accept the same
- * TurnStateChangedPayload shape.
- * @typeParam TSubject - The subject definition type for the adapter's bus
- */
-interface TurnSubjects<TSubject = ScopedSubjectDefinition> {
-  state_changed: TSubject;
-  turn_started: TSubject;
-  step_started: TSubject;
-  step_finished: TSubject;
-  turn_finished: TSubject;
-}
-/**
- * Standard turn state type for procedural adapters.
- *
- * Procedural adapters (Gemini, OpenAI, Copilot) use abort+restart
- * rather than true pause/resume. Their state machine is:
- * idle to turn_started to step_started to step_finished to turn_finished
- */
-type ProceduralTurnState = 'idle' | 'turn_started' | 'step_started' | 'step_finished' | 'turn_finished';
-/**
- * Configuration for ProceduralConnectorTurn.
- * @typeParam TBus - Scoped bus type for the adapter
- * @typeParam TSubject - Subject definition type
- */
-interface ProceduralTurnConfig<TBus extends ScopedBus<string>, TSubject> {
-  bus: TBus;
-  adapterId: string;
-  adapterName: string;
-  agentId: string;
-  messageHandle: MessageHandle;
-  turnSubjects: TurnSubjects<TSubject>;
-}
-/**
- * Base turn implementation for procedural adapters (Gemini, OpenAI, Copilot).
- *
- * These adapters share an abort+restart pattern rather than true pause/resume.
- * This class extracts the common state machine, lifecycle methods, and
- * message handle delegation that was duplicated across all three.
- *
- * Subclasses only need to add adapter-specific behavior:
- * - Gemini: AbortController for SDK cancellation
- * - OpenAI: AbortController for SDK cancellation
- * - Copilot: SDK event handling (handleSdkEvent)
- * @typeParam TState - Turn state type (defaults to ProceduralTurnState)
- * @typeParam TBus - Scoped bus type for the adapter
- * @typeParam TSubject - Subject definition type for emit calls
- */
-declare class ProceduralConnectorTurn<TState extends string = ProceduralTurnState, TBus extends ScopedBus<string> = ScopedBus<string>, TSubject extends ScopedSubjectDefinition = ScopedSubjectDefinition> extends BaseConnectorTurn<TState> {
-  protected activeMessageHandle: MessageHandle;
-  protected readonly connectorBus: TBus;
-  protected readonly agentId: string;
-  protected readonly turnSubjects: TurnSubjects<TSubject>;
-  protected aborted: boolean;
-  constructor(config: ProceduralTurnConfig<TBus, TSubject>, initialState: TState);
-  /**
-   * Emit state change using adapter-provided turn subjects.
-   * @param oldState - Previous state before transition
-   * @param newState - New state after transition
-   */
-  protected emitStateChange(oldState: TState, newState: TState): Promise<void>;
-  /**
-   * Start the turn.
-   */
-  start(): Promise<void>;
-  /**
-   * Transition to step_started (called when first content arrives).
-   * Allows turn_started to step_started AND step_finished to step_started
-   * (for tool recursion).
-   */
-  markStepStarted(): Promise<void>;
-  /**
-   * Transition to step_finished (called after content block completes).
-   */
-  markStepFinished(): Promise<void>;
-  /**
-   * Mark turn as finished.
-   */
-  markTurnFinished(): Promise<void>;
-  /**
-   * Pause (abort) at next opportunity.
-   * Procedural adapters don't support true pause - caller creates a new turn
-   * with merged content instead.
-   * @returns Pause result indicating turn state
-   */
-  pause(): Promise<PauseResult<TState>>;
-  /**
-   * Resume is not supported for procedural adapters - caller creates new turn.
-   * @param _message - Unused
-   * @throws Error always
-   */
-  resume(_message?: unknown): Promise<void>;
-  /**
-   * Check if turn was aborted.
-   * @returns True if turn was aborted
-   */
-  isPaused(): boolean;
-  /**
-   * Check if turn is completed.
-   * @returns True if turn has finished
-   */
-  isCompleted(): boolean;
-  /**
-   * Check if turn can accept immediate message.
-   * True if turn is active (not finished, not aborted).
-   * @returns True if turn can accept an immediate message
-   */
-  canAcceptImmediate(): boolean;
-}
-//#endregion
-//#region adapters/core/src/session/user-message-queue.d.ts
-/**
- * Simple FIFO queue for user messages with delivery mode support.
- *
- * This queue is owned by adapter Connectors and passed to Sessions for processing.
- *
- * Delivery modes:
- * - 'enqueue': Add to end of queue (default); internal retries are prioritized
- *   ahead of already queued user turns.
- * - 'replace': Supersede all unacknowledged messages, add to queue
- * - 'immediate': Handled by Session (abort/restart), not queue
- *
- * Design:
- * - Connector enqueues messages as they arrive
- * - Session dequeues messages when ready to process
- * - Peek allows Session to inspect next message without removing
- */
-declare class UserMessageQueue {
-  private readonly queue;
-  /**
-   * Add message to queue based on delivery mode.
-   * @param handle - Message handle to enqueue
-   */
-  enqueue(handle: MessageHandle): void;
-  /**
-   * Enqueue an internal retry before ordinary queued user turns while preserving
-   * immediate-mode ordering and FIFO ordering among retries.
-   * @param handle - Internal retry handle to enqueue
-   */
-  private enqueueInternalRetry;
-  /**
-   * Remove all superseded messages from queue.
-   */
-  private removeSuperseded;
-  /**
-   * Remove and return first message from queue.
-   * @returns First message or undefined if queue empty
-   */
-  dequeue(): MessageHandle | undefined;
-  /**
-   * Look at first message without removing.
-   * @returns First message or undefined if queue empty
-   */
-  peek(): MessageHandle | undefined;
-  /**
-   * Check if queue is empty.
-   * @returns True if queue has no messages
-   */
-  isEmpty(): boolean;
-  /**
-   * Get current queue size.
-   * @returns Number of messages in queue
-   */
-  size(): number;
-  /**
-   * Clear all messages from queue.
-   */
-  clear(): void;
-  /**
-   * Find the first immediate message in the queue.
-   * @returns First immediate message or undefined
-   */
-  findImmediate(): MessageHandle | undefined;
-  /**
-   * Remove a specific immediate message from the queue.
-   * @param handle - Handle to remove
-   */
-  removeImmediate(handle: MessageHandle): void;
-  /**
-   * Remove and return all enqueued (non-immediate) messages.
-   * Used when immediate arrives to merge their content.
-   * @returns Array of enqueued message handles in FIFO order
-   */
-  drainEnqueued(): MessageHandle[];
-}
-//#endregion
-//#region adapters/core/src/session/process-queue.d.ts
-/**
- * Canonical error message used when a queued message cannot be processed
- * because the session has entered the shutdown path.
- *
- * Shared between {@link rejectQueuedHandles} (queue drain) and the per-handle
- * shutdown gate ({@link BaseConnectorSession.completeHandleIfClosing}) so that
- * callers see a consistent error contract regardless of whether the handle was
- * still in the queue or had already been dequeued when `close()` interleaved.
- */
-declare const SESSION_CLOSED_QUEUE_ERROR = "Session closed before queued message could be processed";
-/**
- * Minimal turn interface required by processQueue orchestration.
- *
- * Any turn implementation (Claude, Gemini, OpenAI, Copilot) that exposes
- * these methods can participate in the shared processQueue flow.
- */
-interface QueueableTurn {
-  canAcceptImmediate(): boolean;
-  isCompleted(): boolean;
-  getMessageHandle(): MessageHandle;
-  pause(): Promise<PauseResult>;
-}
-/**
- * Result of processing an immediate message merge.
- *
- * Returned by the `extractMergeContent` callback so that adapters
- * can collect adapter-specific content (e.g., Gemini collects non-text parts).
- * The `mergedContent` array is always present; `extra` is an opaque bag
- * for adapter-specific data that flows through to `startNewTurn`.
- */
-interface MergeResult {
-  /** Text content collected from superseded/merged messages */
-  mergedContent: string[];
-  /** Adapter-specific merge data (e.g., non-text parts for Gemini) */
-  extra?: unknown;
-}
-/**
- * Callbacks for adapter-specific behavior during queue processing.
- * @typeParam TExtra - Type of adapter-specific extra merge data
- */
-interface ProcessQueueCallbacks<TExtra = unknown> {
-  /**
-   * Get the current turn, if any.
-   * @returns The current turn or undefined
-   */
-  getCurrentTurn: () => QueueableTurn | undefined;
-  /**
-   * Extract text content from a message handle for merge.
-   * Default: `handle.message.message as string`
-   * @param handle - The message handle to extract content from
-   * @returns The text content
-   */
-  extractContent?: (handle: MessageHandle) => string;
-  /**
-   * Called after merge content is collected from superseded/enqueued messages.
-   * Allows adapters to collect additional content (e.g., Gemini's non-text parts).
-   *
-   * If not provided, only text content is collected using `extractContent`.
-   * @param currentHandle - The in-flight message handle being superseded (or undefined)
-   * @param enqueuedHandles - The enqueued handles being merged
-   * @returns Extra merge data to pass through to startNewTurn
-   */
-  collectMergeExtra?: (currentHandle: MessageHandle | undefined, enqueuedHandles: MessageHandle[]) => TExtra;
-  /**
-   * Hook called after merge is collected but before starting the new turn.
-   * Used by Claude to create a fresh query instance.
-   */
-  onBeforeImmediateTurn?: () => Promise<void>;
-  /**
-   * Start a new turn with the given message and optional merge data.
-   *
-   * Returns `void` (or `undefined`) when the turn was started normally.
-   * Returns `false` explicitly when the turn was **not** started (e.g.,
-   * shutdown interleaved during setup and the handle was completed with
-   * an error). `processQueueMessages` propagates this so callers see an
-   * accurate "no turn started" result and can transition to idle.
-   * @param handle - The message handle to process
-   * @param mergedContent - Text content from superseded/merged messages
-   * @param extra - Adapter-specific extra merge data
-   * @returns `false` when the turn was skipped; `void` otherwise
-   */
-  startNewTurn: (handle: MessageHandle, mergedContent?: string[], extra?: TExtra) => Promise<void | false>;
-}
-/**
- * Shared processQueue orchestration for all session implementations.
- *
- * Handles the complete immediate-mode flow:
- * 1. Detect immediate message while a turn is active
- * 2. Pause the active turn
- * 3. Supersede the in-flight message and drain enqueued messages
- * 4. Collect merged content from all superseded/merged messages
- * 5. Start a new turn with the immediate message and merged context
- *
- * Also handles the normal queue flow:
- * - Late immediate rejection (immediate arrives after turn finishes)
- * - Normal enqueue/replace message processing
- *
- * Returns `true` when a new turn was started, `false` otherwise.
- * Callers can use this to decide whether to transition to idle when
- * the queue drains without starting a new turn (e.g., all-rejection case).
- * @param queue - The user message queue to process
- * @param callbacks - Adapter-specific callbacks
- * @returns True if a new turn was started, false otherwise
- * @typeParam TExtra - Type of adapter-specific extra merge data
- */
-declare function processQueueMessages<TExtra = unknown>(queue: UserMessageQueue, callbacks: ProcessQueueCallbacks<TExtra>): Promise<boolean>;
-/**
- * Drain all remaining handles from the queue and complete each with an error
- * outcome so callers awaiting `waitForCompletion()` resolve deterministically.
- *
- * Used by session implementations during shutdown to prevent queued messages
- * from hanging indefinitely when the session refuses to start new turns.
- * @param queue - User message queue to drain
- * @param message - Error message to attach to each rejected handle
- */
-declare function rejectQueuedHandles(queue: UserMessageQueue, message?: string): void;
-//#endregion
-//#region adapters/core/src/connector/procedural-agent-connector.d.ts
-/**
- * Minimal session interface required by ProceduralAgentConnector.
- *
- * Any session implementation (OpenAI, Copilot, Gemini) that exposes
- * these methods can be used with ProceduralAgentConnector's default
- * wireSessionEvents / processUserMessages / acceptsImmediate.
- */
-interface ProceduralConnectorSession {
-  /** Process messages from the queue. */
-  processQueue(queue: UserMessageQueue): Promise<void>;
-  /** Get the current turn for state inspection. */
-  getCurrentTurn(): QueueableTurn | undefined;
-}
-/**
- * Turn subject references for wireSessionEvents.
- *
- * Each adapter provides its namespace-specific subjects. The subjects
- * must accept TurnStateChangedPayload (or compatible shape).
- * @typeParam TNamespace - The bus namespace string for subject typing
- */
-interface WireSessionSubjects<TNamespace extends string = string> {
-  turn_started: ScopedSubjectDefinition<TNamespace>;
-  step_started: ScopedSubjectDefinition<TNamespace>;
-  step_finished: ScopedSubjectDefinition<TNamespace>;
-  turn_finished: ScopedSubjectDefinition<TNamespace>;
-}
-/**
- * Configuration for ProceduralAgentConnector's wireSessionEvents behavior.
- *
- * The `onTurnStarted` and `onTurnFinished` hooks allow adapters to inject
- * logic at turn boundaries. By default both are no-ops.
- */
-interface WireSessionConfig {
-  /**
-   * Called when a new turn starts (turn_started bus event).
-   *
-   * Executes before the default `updateProcessingState('turn_started')` so
-   * the connector state machine is always updated regardless of this hook.
-   *
-   * Supports async so that turn-start operations with I/O — such as a pending
-   * MCP tool refresh via the bus — can complete before the API call is made.
-   * In-memory operations (recordInjection, consumeTurnNumber) are not affected
-   * by the async signature.
-   */
-  onTurnStarted?: () => Promise<void> | void;
-  /**
-   * Custom handler for turn_finished events.
-   *
-   * When provided, replaces the default turn_finished behavior entirely.
-   * The handler receives a callback to process the queue, which it should
-   * call when the message is considered complete and the queue should drain.
-   * @param drainQueue - Callback that processes the queue or goes idle
-   */
-  onTurnFinished?: (drainQueue: () => Promise<void>) => Promise<void>;
-}
-/**
- * Abstract base class for procedural (non-event-driven) agent connectors.
- *
- * Procedural adapters (OpenAI, Copilot, Gemini) share common patterns:
- * - wireSessionEvents: subscribe to turn lifecycle events and update processing state
- * - processUserMessages: initialize session, enqueue, transition to active, process queue
- * - complete: poll processing state until idle/paused
- * - start: delegate to sendMessage and return AgentStartResult
- * - acceptsImmediate: delegate to session's current turn
- *
- * Subclasses must implement:
- * - `getSession()` / `ensureSession()` for session access and lazy initialization
- * - `getSessionQueue()` for the adapter's UserMessageQueue instance
- * - `getTurnSubjects()` for namespace-specific turn subjects
- * - `sendMessage()`, `abort()`, `close()`, `interrupt()`, `getAdapterSessionId()`
- *
- * Subclasses may override:
- * - `getWireSessionConfig()` for custom turn_finished behavior (e.g., Copilot multi-turn)
- * @typeParam TBus - Scoped bus type for adapter namespace
- * @typeParam TConfig - Configuration type extending BaseAgentConnectorConfig
- */
-declare abstract class ProceduralAgentConnector<TBus extends ScopedBus<string> = ScopedBus<string>, TConfig extends BaseAgentConnectorConfig<TBus> = BaseAgentConnectorConfig<TBus>> extends AIAgentConnector<TBus, TConfig> {
-  /** Whether turn event wiring has been setup. */
-  private turnEventsWired;
-  /**
-   * Get the adapter's session instance (may be undefined if not yet initialized).
-   * @returns The session or undefined
-   */
-  protected abstract getSession(): ProceduralConnectorSession | undefined;
-  /**
-   * Initialize and return the adapter's session.
-   * Must be idempotent (no-op if already initialized).
-   * @returns The initialized session
-   */
-  protected abstract ensureSession(): Promise<ProceduralConnectorSession>;
-  /**
-   * Get the adapter's UserMessageQueue instance.
-   * @returns The message queue
-   */
-  protected abstract getSessionQueue(): UserMessageQueue;
-  /**
-   * Get the adapter's namespace-specific turn subjects for wireSessionEvents.
-   * @returns Turn subject definitions
-   */
-  protected abstract getTurnSubjects(): WireSessionSubjects<TBus['namespace']>;
-  /**
-   * Get optional wire session configuration for custom turn_finished behavior.
-   * Override in subclasses that need non-standard turn_finished handling
-   * (e.g., Copilot multi-turn message completion).
-   * @returns Wire session configuration, or undefined for default behavior
-   */
-  protected getWireSessionConfig(): WireSessionConfig | undefined;
-  /**
-   * Wire Session turn events to Connector state updates.
-   *
-   * Session emits typed events, Connector subscribes and updates processing state.
-   * This maintains separation of concerns - Session does not know about Connector state.
-   *
-   * Default turn_finished behavior: transition through processing_finished to idle,
-   * or drain the queue if messages are pending. Override via `getWireSessionConfig()`.
-   */
-  protected wireSessionEvents(): void;
-  /**
-   * Process queued user messages by delegating to Session.
-   *
-   * Shared flow:
-   * 1. Initialize session if not yet created
-   * 2. Enqueue the message
-   * 3. Set adapterSessionId on handle
-   * 4. Transition to active if currently idle/paused
-   * 5. Process queue via session
-   * @param messageHandles - Array of message handles to process
-   * @returns Set of message handles that were processed
-   */
-  protected processUserMessages(messageHandles: MessageHandle[]): Promise<Set<MessageHandle>>;
-  /**
-   * Initialize the connector's SDK session without sending a message.
-   * Must set adapterSessionId before returning.
-   * Called by createAgent for idle agent setup.
-   * Implementations MUST be idempotent (no-op if already initialized).
-   * @param options - Optional start options (e.g., systemPrompt)
-   */
-  initialize(options?: ConnectorStartOptions): Promise<void>;
-  /**
-   * Start session with initial message.
-   * @param message - The initial message to send
-   * @param options - Optional send message options
-   * @returns The agent start result with session ID and message handle
-   */
-  start(message: NormalizedMessageInput, options?: ConnectorSendMessageOptions): Promise<AgentStartResult>;
-  /**
-   * Complete the agent session by waiting for all messages to finish.
-   * @returns Last message result or null if no messages processed
-   */
-  complete(): Promise<MessageResult | null>;
-  /**
-   * Returns true if current turn can accept immediate messages.
-   * @returns True if turn can accept immediate, false otherwise
-   */
-  protected acceptsImmediate(): boolean;
-}
-//#endregion
 //#region adapters/core/src/utils/tool-approval.d.ts
 /**
  * Context required to complete a global tool approval request.
@@ -1976,6 +1349,60 @@ declare class AgentEventBridge {
   private emitOwnedStepFinished;
 }
 //#endregion
+//#region adapters/core/src/adapter/adapter-provider-key-publication.d.ts
+/**
+ * The one gate a provider session passes before it leaves this adapter.
+ *
+ * **A provider key has one publisher per attempt: the party that claims it.**
+ * For a start or rehydrate the adapter owns, that is the adapter — it announces
+ * the movement and stamps the key on what it emits, and the movement observer
+ * settles the currency. For a **caller-owned** one it is the caller: it reserved
+ * the provider session before dispatching, and it settles the key its connector
+ * confirms, under a generation token it minted and can give back. Until that
+ * caller has been handed the key, nothing here may put it where somebody else
+ * can act on it — an event field a consumer writes onto a session row, a durable
+ * row write, an announcement the observer turns into a second generation.
+ *
+ * The rule was enforced per route before this module: the row write knew it, the
+ * `agent.added` field knew it, enrichment knew it, and each new route had to be
+ * found by a reviewer before it learned it. Two were missed that way. So the
+ * question moves here, and every route asks it the same way — by taking the key
+ * it publishes from {@link publishedProviderKey} rather than from the connector,
+ * the registry or the start result.
+ *
+ * ## What the window is
+ *
+ * It opens with the attempt and closes when the adapter has **handed the key
+ * over**: for a start, the last act of the start itself, after which the key
+ * travels in the response and the caller settles it; for a rehydrate, the whole
+ * call, since its answer *is* the hand-over. A caller-owned attempt that
+ * confirms no key hands over nothing and still closes its window, because
+ * nothing is waiting to be settled and the movement observer is that agent's
+ * only publisher from then on.
+ *
+ * ## What it does not cover
+ *
+ * The window ends where the adapter's knowledge does. Between the hand-over and
+ * the caller's settlement the adapter has no way to observe that the generation
+ * exists — `startAgent`'s contract carries no settlement signal back — so a key
+ * published in that gap is published before it is claimed. The gap is a few
+ * statements of the caller's own (nothing fallible runs between a live connector
+ * and its settlement), and closing it needs an adapter-contract change, which
+ * this wave does not make.
+ */
+/**
+ * Whether this attempt may publish the provider session it confirmed.
+ *
+ * Mutable, with exactly one writer — {@link releaseProviderKeyPublication}, at
+ * the point the attempt hands its key over. A start carries one of these for its
+ * whole duration; a rehydrate builds one that never opens, because its response
+ * is the hand-over and there is nothing after it.
+ */
+interface ProviderKeyPublication {
+  /** Whether the key is still the caller's to publish first. */
+  deferred: boolean;
+}
+//#endregion
 //#region adapters/core/src/factory/create-adapter-namespace.d.ts
 /**
  * Adapter namespace extends BusNamespace with additional metadata for adapters.
@@ -2071,6 +1498,22 @@ interface AgentTurnExecutorConfig {
    * @param mode - Derived start mode for this turn
    */
   setPendingStartMode: (mode: StartMode) => void;
+  /**
+   * Report that this dispatch discards the pending start-time resume target,
+   * moving the provider session before any provider confirmation.
+   *
+   * Mirrors the precondition every adapter session applies in its own
+   * `suppressStartResumeIfRequested`: the caller disabled native resume, a
+   * concrete resume target is still armed, and the provider has not confirmed
+   * a session for the current connector generation. Under those conditions the
+   * adapter drops the target and mints a fresh identity, so the previously
+   * advertised provider session stops being valid resume currency.
+   *
+   * Awaited before the dispatch it describes, so the session row stops
+   * advertising the abandoned provider session before the provider is asked to
+   * start a new one.
+   */
+  onNativeResumeSuppressed?: () => void | Promise<void>;
   /** Completion/lifecycle tracker hook. */
   onMessageHandle: AgentMessageHandleCallback;
   /** Side-effect callback to mark agent status active before dispatch. */
@@ -2097,6 +1540,7 @@ declare class AgentTurnExecutor {
   private readonly shouldUseNativeResume;
   private readonly hasResumeTarget;
   private readonly setPendingStartMode;
+  private readonly onNativeResumeSuppressed?;
   private readonly onMessageHandle;
   private readonly onBeforeDispatch?;
   private readonly runDispatch;
@@ -2137,10 +1581,39 @@ declare class AgentTurnExecutor {
    * Derive the start mode for the given resolved session context, stash it
    * as the pending mode for the next lifecycle start emission, and return
    * the native-resume decision shared by the dispatch that follows.
+   *
+   * Async because a suppressed resume target moves the provider session: the
+   * movement is recorded before this returns, so the dispatch that abandons the
+   * old provider session cannot be preceded by a resume that still targets it.
    * @param sessionContext - Session context after pre-user-message hooks
    * @returns Whether the connector should rely on native resume
    */
   private deriveAndSetPendingStartMode;
+  /**
+   * Whether this dispatch will move the provider session without confirmation.
+   *
+   * The armed target is abandoned unless the connector holds a *provider-committed*
+   * session that carries continuity forward, which is what
+   * `providerCommittedAdapterSessionId` resolves — the same sampling rule payload
+   * enrichment applies, expressed once. It collapses the two reasons a reported
+   * ID does not prove continuity: a fork awaiting `system.init` reports no
+   * authoritative session at all, and a seeded resume the provider has not echoed
+   * yet reports the very target this dispatch discards. Inferring "no movement"
+   * from the raw accessor left the session row advertising an abandoned provider
+   * thread until a later confirmation — or indefinitely, if the process died
+   * first.
+   *
+   * Effectively one-shot per armed target, so this signal is not a retry clock:
+   * the dispatch it precedes consumes the resume target, after which the
+   * connector reports no pending rotation and mints its own identity — both
+   * reasons stop matching. Re-delivering an announcement no consumer accepted is
+   * therefore owned by `ConfirmedAdapterSessionTracker`, which parks the
+   * undelivered movement and re-drives it from payload enrichment; this method
+   * only has to report the movement honestly once.
+   * @param useNativeResume - Native-resume decision for this dispatch
+   * @returns `true` when the armed resume target is about to be discarded
+   */
+  private movesProviderSession;
   /**
    * Execute the turn pipeline for agent.sendMessage.
    * @param payload - agent.sendMessage request payload
@@ -2179,24 +1652,46 @@ declare class AgentTurnExecutor {
   private assertCanonicalMessageId;
 }
 //#endregion
-//#region adapters/core/src/agent/connector-runtime.d.ts
-/** Connector instance paired with its explicit client config lease. */
-interface ConnectorRuntimeHandle<TConnector extends Pick<AIAgentConnector, 'close'>> {
-  /** Live connector instance. */
-  readonly connector: TConnector;
-  /** Lease whose lifetime exactly matches this connector. */
-  readonly lease?: AdapterAuthLeaseHandle;
-}
-/** Dependencies for creating one managed connector runtime. */
-interface CreateConnectorRuntimeOptions<TBus extends ScopedBus<string>, TConnector extends AIAgentConnector<TBus>, TConfig extends BaseAgentConnectorConfig<TBus> = BaseAgentConnectorConfig<TBus>> {
-  /** Refs-only config emitted by the common adapter factory. */
-  readonly config: BoundAdapterRuntimeConfig<TBus, TConfig>;
-  /** Adapter connector constructor. */
-  readonly connectorFactory: (config: ResolvedAdapterRuntimeConfig<TBus, TConfig>) => TConnector | Promise<TConnector>;
-  /** Optional user-message callback attached only after auth preparation. */
-  readonly onMessageSent?: (handle: MessageHandle) => void;
-  /** Trusted host-local auth preparer; defaults to DirectChannel + client lease. */
-  readonly prepareAuthRuntime?: AdapterAuthRuntimePreparer<TBus, TConfig>;
+//#region adapters/core/src/agent/connector-swap-vetoed-error.d.ts
+/**
+ * The typed refusal a connector replacement receives at the arbitration door.
+ * @packageDocumentation
+ */
+/** Why a replacement was refused before it produced any effect. */
+type ConnectorSwapVetoReason = /** A teardown of this agent was already in flight when the door was reached. */'teardown-in-flight'
+/**
+ * The agent holds no connector runtime any more.
+ *
+ * Permanent rather than transient: the runtime reference is cleared before the
+ * teardown's close is awaited, and only a start or a published replacement ever
+ * sets it — so "the runtime is gone" is exactly the fact a post-teardown
+ * replacement must not proceed on.
+ */
+| 'no-runtime';
+/**
+ * A connector replacement refused by the arbitration door.
+ *
+ * **Typed because the distinction it carries is not derivable from anything
+ * else.** The door refuses before any replacement effect has occurred, so the
+ * one path with a modelled answer for that — a warm rehydrate — may report
+ * `not-dispatched` instead of leaving its caller uncertain. An untyped throw
+ * lands in the generic replacement rollback and becomes "something failed,
+ * possibly after reaching the provider", which is the strictly worse answer the
+ * door exists to avoid.
+ *
+ * A compound failure is **never** this type. When a producer's own rollback also
+ * fails, the veto is known but whether a replacement connector actually closed is
+ * not, so that case stays an aggregate and keeps the uncertain classification.
+ */
+declare class ConnectorSwapVetoedError extends Error {
+  readonly agentId: string;
+  readonly reason: ConnectorSwapVetoReason;
+  /**
+   * Build the refusal.
+   * @param agentId - Agent whose replacement was refused
+   * @param reason - Which of the door's two preconditions failed
+   */
+  constructor(agentId: string, reason: ConnectorSwapVetoReason);
 }
 //#endregion
 //#region adapters/core/src/agent/agent-lifecycle-emitter.d.ts
@@ -2282,8 +1777,23 @@ interface AgentPayloadEmitterConfig {
   getConnectorAdapterSessionId: () => string | undefined;
   /** Last known adapterSessionId cached across connector swaps. */
   getLastKnownAdapterSessionId: () => string | undefined;
-  /** Persist latest adapterSessionId after resolution. */
-  setLastKnownAdapterSessionId: (adapterSessionId: string | undefined) => void;
+  /**
+   * Persist latest adapterSessionId after resolution.
+   *
+   * May be asynchronous: the owning agent uses this sink to announce a moved
+   * provider identity, and enrichment awaits it so no event carrying the new ID
+   * is published before the movement is recorded.
+   */
+  setLastKnownAdapterSessionId: (adapterSessionId: string | undefined) => void | Promise<void>;
+  /**
+   * Whether the agent's provider session is this adapter's to publish yet.
+   *
+   * Absent means yes. While it answers `false` the enriched event carries no
+   * provider session at all — a caller-owned start's key is the caller's to
+   * publish, and a consumer that writes it onto a session row would advertise a
+   * key no generation holds yet.
+   */
+  isProviderKeyPublishable?: () => boolean;
   /** Live event metadata defaults resolved from current runtime state. */
   getEventMetadataDefaults: () => AgentPayloadEventMetadata;
 }
@@ -2306,14 +1816,20 @@ declare class AgentPayloadEmitter {
    * non-Claude adapters) the locally-determined ID is authoritative and returned
    * immediately.
    *
-   * The `lastKnownAdapterSessionId` bridges connector swaps: when the old
-   * connector is gone and the new one is not yet wired, the cached value carries
-   * the confirmed ID from the previous connector.
+   * The `lastKnownAdapterSessionId` bridges connector swaps *for stamping only*:
+   * when the old connector is gone and the new one is not yet wired, the cached
+   * value carries the confirmed ID from the previous connector. The recording
+   * sink is deliberately not given that fallback — see the inline note.
+   *
+   * No async *resolution* fallback is used. `connector.getAdapterSessionId()`
+   * may resolve with a provisional placeholder for fork sessions. Enrichment
+   * must never stamp unconfirmed IDs — omitting the field is safe since R8
+   * schemas allow it optional.
    *
-   * No async fallback is used. `connector.getAdapterSessionId()` may resolve
-   * with a provisional placeholder for fork sessions. Enrichment must never
-   * stamp unconfirmed IDs — omitting the field is safe since R8 schemas allow
-   * it optional.
+   * The recording sink is awaited even though resolution stays synchronous: it
+   * announces a moved provider identity, and that movement must be recorded
+   * before this event advertises the new ID. Recording an unchanged ID — the
+   * case for all but the first event of a generation — resolves without I/O.
    * @returns Confirmed adapter session ID or `undefined`
    */
   private resolveConfirmedAdapterSessionId;
@@ -2558,7 +2074,16 @@ type StartAgentRequestPayload = ExtractSubjectPayload<typeof AdapterSubjects.sta
  */
 type AgentCreationOptions = Omit<Partial<Pick<StartAgentRequestPayload, 'model' | 'cwd' | 'env' | 'allowedTools' | 'disallowedTools' | 'allowedDirectories' | 'reasoningEffort' | 'adapterConfig' | 'mode' | 'mcpSessionContext' | 'harnessId' | 'clientId' | 'clientProfileName' | 'providerContext' | 'ephemeral'>>, 'providerContext'> & {
   adapterSessionId?: string;
-  resumeAdapterSessionId?: string; /** Unresolved provider context (credential refs, not plaintext). */
+  resumeAdapterSessionId?: string;
+  /**
+   * The attempt's provider-key publication gate.
+   *
+   * Carried into the agent because the routes inside it — the identity
+   * enrichment stamps on every emitted event, the movement its tracker
+   * announces — are publication routes like the start's own, and every route
+   * asks one gate. See {@link ProviderKeyPublication}.
+   */
+  providerKeyPublication?: ProviderKeyPublication; /** Unresolved provider context (credential refs, not plaintext). */
   providerContext?: ProviderContext;
   /**
    * Source Makaio session ID when mode is 'fork'.
@@ -2616,6 +2141,18 @@ interface AgentUsageTotals {
   totalOutputTokens: number;
   totalCalls: number;
 }
+/**
+ * In-process handle for an active agent and its registry-owned session metadata.
+ * @typeParam TAgent - Live agent implementation exposed to local callers
+ */
+interface ActiveAgentHandle<TAgent = AIAgent> {
+  /** Live agent instance with its prototype and runtime state intact. */
+  readonly agent: TAgent;
+  /** Makaio session ID associated with the registry entry. */
+  readonly sessionId: string;
+  /** Provider-specific session ID, unavailable until the provider confirms it. */
+  readonly adapterSessionId: string | undefined;
+}
 /** Result from creating an agent runtime. */
 interface AgentRuntimeCreationResult {
   cleanup: () => void;
@@ -2676,113 +2213,35 @@ interface AIAdapterConstructorConfig<TBus extends ScopedBus<string>, TConnector
   definitionProviders?: readonly AdapterProviderDefinition[];
 }
 //#endregion
-//#region adapters/core/src/agent/agent-connector-lifecycle-manager.d.ts
-/** Sanitized lifecycle diagnostic emitted after a replacement became primary. */
-interface ConnectorCleanupDiagnostic {
-  /** Stable machine-readable failure category. */
-  readonly code: 'previous-connector-cleanup-failed';
-  /** Lifecycle stage whose cleanup failed. */
-  readonly stage: 'swap-old-runtime';
-  /** Agent owning the replacement connector. */
-  readonly agentId: string;
-}
-/** Final async guard run after the replacement is ready but before it becomes primary. */
-type ConnectorSwapCommitGuard = () => void | Promise<void>;
-/**
- * Dependencies for connector lifecycle management.
- */
-interface AgentConnectorLifecycleManagerConfig<TBus extends ScopedBus<string>, TConnector extends AIAgentConnector<TBus>> {
-  /** Stable agent identifier (used for diagnostics). */
-  agentId: string;
-  /** Create config input for connector/config factories. */
-  buildConfigInput: (overrides?: AgentConnectorConfigOverrides) => ConfigFactoryInput<TBus>;
-  /** Adapter config factory from AIAgent config. */
-  configFactory: (input: ConfigFactoryInput<TBus>) => Promise<BaseAgentConnectorConfig<TBus> & {
-    adapterId: string;
-  }>;
-  /** Connector factory from AIAgent config. */
-  connectorFactory: (config: BaseAgentConnectorConfig<TBus> & {
-    adapterId: string;
-  }) => Promise<TConnector> | TConnector;
-  /** Trusted host-local auth preparer shared by every connector generation. */
-  prepareAuthRuntime?: AdapterAuthRuntimePreparer<TBus>;
-  /** Build onMessageSent callback for connector creation. */
-  createOnMessageSent: () => (handle: MessageHandle) => void;
-  /** Wire adapter-specific events on a connector instance. */
-  wireEvents: (connector: TConnector) => void | Promise<void>;
-  /** Emit idle lifecycle event on processing-state idle transitions. */
-  emitIdle: () => Promise<void>;
-  /** Get current connector plus its explicit client config lease. */
-  getConnectorRuntime: () => ConnectorRuntimeHandle<TConnector>;
-  /** Replace active connector and lease together on successful swap. */
-  setConnectorRuntime: (runtime: ConnectorRuntimeHandle<TConnector>) => void;
-  /** Get runtime system prompt to preserve across swaps. */
-  getRuntimeSystemPrompt: () => SystemPrompt | undefined;
-  /** Store latest adapter session ID for enrichment after swaps. */
-  setLastKnownAdapterSessionId: (adapterSessionId: string | undefined) => void;
-  /** Publish a sanitized cleanup diagnostic without exposing connector errors. */
-  reportCleanupFailure: (diagnostic: ConnectorCleanupDiagnostic) => void | Promise<void>;
-}
-/**
- * Manages connector lifecycle for AIAgent.
- *
- * Owns per-connector wiring cleanup registration and swap lifecycle choreography.
- */
-declare class AgentConnectorLifecycleManager<TBus extends ScopedBus<string>, TConnector extends AIAgentConnector<TBus>> {
-  /** Cleanup functions for connector event wiring (cleared on each connector swap) */
-  private connectorWiringCleanups;
-  private readonly config;
-  constructor(config: AgentConnectorLifecycleManagerConfig<TBus, TConnector>);
-  /**
-   * Register a cleanup function for connector wiring.
-   * @param cleanup - Cleanup function to register
-   */
-  addConnectorWiringCleanup(cleanup: () => void): void;
-  /**
-   * Clear connector wiring cleanups.
-   */
-  clearConnectorWiring(): void;
+//#region adapters/core/src/adapter/agent-registry.d.ts
+/** What one agent teardown observed, plus whether there was an agent at all. */
+interface AgentDisposalReport extends TeardownReport {
   /**
-   * Wire base and adapter-specific connector events.
-   * @param connector - Connector instance to wire
-   */
-  wireAllConnectorEvents(connector: TConnector): Promise<void>;
-  /**
-   * Replace the active connector with a fresh instance.
+   * Whether a live agent was found and its teardown attempted.
    *
-   * Uses create-before-close pattern with rollback to preserve availability.
-   * @param configOverrides - Optional runtime override fields
-   * @param beforeCommit - Final guard after replacement initialization and before publication
-   * @returns The replacement's provider-confirmed session ID, when it has one
-   */
-  swapConnector(configOverrides?: AgentConnectorConfigOverrides, beforeCommit?: ConnectorSwapCommitGuard): Promise<string | undefined>;
-  /**
-   * Build and materialize the replacement connector runtime.
-   * @param currentConnector - Active connector whose runtime values provide defaults
-   * @param configOverrides - Optional requested runtime changes
-   * @returns Prepared replacement connector and auth lease
+   * True for a teardown this call joined as well as one it started: an agent *was*
+   * found, by whichever caller got there first, and both callers are answered with
+   * the same evidence.
    */
-  private createReplacementRuntime;
-  /**
-   * Wire and initialize a replacement, restoring the current wiring on failure.
-   * @param newRuntime - Replacement connector and auth lease
-   * @param oldWiringCleanups - Wiring still owned by the active connector
-   * @param beforeCommit - Optional final publication guard
-   * @returns Provider-confirmed session ID, when the replacement has one
-   */
-  private initializeReplacement;
-  /**
-   * Run superseded connector wiring cleanups without failing the committed swap.
-   * @param cleanups - Previous connector wiring cleanups
-   */
-  private runWiringCleanups;
+  readonly found: boolean;
+}
+/** Options a teardown entry point accepts from the request that drove it. */
+interface AgentTeardownOptions {
   /**
-   * Close the superseded runtime and publish only a sanitized diagnostic on failure.
-   * @param currentRuntime - Superseded connector and auth lease
+   * Absolute deadline of the request driving this teardown, when it has one.
+   *
+   * Passed through so a teardown that must wait for a connector replacement ends
+   * its wait inside the deadline of whoever is waiting on it. Absent for
+   * fan-out teardowns with no request behind them, where the policy ceiling stands
+   * alone.
    */
-  private closePreviousRuntime;
+  readonly deadline?: number | undefined;
 }
 //#endregion
+//#region adapters/core/src/agent/agent-connector-lifecycle-manager.d.ts
+/** Final async guard run after the replacement is ready but before it becomes primary. */
+type ConnectorSwapCommitGuard = () => void | Promise<void>;
+//#endregion
 //#region adapters/core/src/agent/ai-agent.d.ts
 /**
  * Abstract base class for AI agents.
@@ -2798,10 +2257,8 @@ declare abstract class AIAgent<TBus extends ScopedBus<string> = ScopedBus<string
   private connectorRuntime;
   protected confirmedModel?: string;
   protected initialModel?: string;
-  /** Cached adapterSessionId from the last connector that had a session — survives connector swaps. */
-  private lastKnownAdapterSessionId?;
-  /** Cleanup functions for bus subscriptions (stable, survive connector swap) */
-  private busHandlerCleanups;
+  /** Owns the confirmed provider-session identity cache and the movement seam. */
+  private readonly adapterSessionTracker;
   /** Whether init() has been called */
   private initialized;
   /** Runtime system prompt captured from start/initialize, preserved across connector swaps. */
@@ -2820,6 +2277,10 @@ declare abstract class AIAgent<TBus extends ScopedBus<string> = ScopedBus<string
   private readonly connectorLifecycleManager;
   /** Serialized connector replacement and runtime-config publication owner. */
   private readonly connectorSwapCoordinator;
+  /** Classes of closes performed for this agent that no teardown waiter reported. */
+  private readonly closeReportLedger;
+  /** Callback every connector generation reports a submitted message through. */
+  private readonly onMessageSent;
   /** Payload enrichment and global emission helper. */
   private readonly payloadEmitter;
   /** Stateful lifecycle emitter for start/complete/error/session.closed. */
@@ -2853,11 +2314,9 @@ declare abstract class AIAgent<TBus extends ScopedBus<string> = ScopedBus<string
   /**
    * Create the connector lifecycle collaborator bound to this agent instance.
    * @param emitGlobal - Enriched global event emitter
-   * @param setLastKnownAdapterSessionId - Sink for the latest confirmed provider session
    * @returns Connector lifecycle manager for this agent
    */
   private createConnectorLifecycleManager;
-  private getEventMetadataDefaults;
   /** @returns Unique agent identifier */
   get agentId(): string;
   /** @returns Adapter instance identifier */
@@ -3031,9 +2490,12 @@ declare abstract class AIAgent<TBus extends ScopedBus<string> = ScopedBus<string
    * as baseline for non-overridden fields.
    * @param configOverrides - Optional config overrides (e.g., new cwd, model)
    * @param beforeCommit - Optional guard executed before replacing the active connector
+   * @param settledByCaller - Whether the caller writes the replacement's durable
+   *   currency itself, in which case the swap records the confirmed session
+   *   without announcing it as a movement
    * @throws Error if connector is currently processing a turn
    */
-  swapConnector(configOverrides?: AgentConnectorConfigOverrides, beforeCommit?: ConnectorSwapCommitGuard): Promise<void>;
+  swapConnector(configOverrides?: AgentConnectorConfigOverrides, beforeCommit?: ConnectorSwapCommitGuard, settledByCaller?: boolean): Promise<void>;
   /**
    * Build config factory input from agent config with optional overrides.
    *
@@ -3043,13 +2505,6 @@ declare abstract class AIAgent<TBus extends ScopedBus<string> = ScopedBus<string
    * @returns ConfigFactoryInput ready for config factory
    */
   private buildConfigInput;
-  /**
-   * Create the onMessageSent callback for connector factories.
-   *
-   * Returns a callback that emits user_message.sent events to the global bus.
-   * @returns Callback function for connector config
-   */
-  private createOnMessageSent;
   /**
    * Wire adapter-specific connector events.
    * Called automatically during init() and connector swap.
@@ -3073,11 +2528,53 @@ declare abstract class AIAgent<TBus extends ScopedBus<string> = ScopedBus<string
    *
    * Emits session.closed event (once per session) unless explicitly suppressed,
    * then unsubscribes from all bus handlers and aborts the connector if available.
+   * Reports the class the connector runtime observed, or `released` when there was
+   * no runtime — provably nothing is speaking in that case.
+   *
+   * **A bus-handler cleanup failure does not downgrade the class**, because a local
+   * listener that refuses to unsubscribe cannot keep a provider conversation alive.
+   * A failed lease release *does* downgrade, because the lease is a resource this
+   * runtime held; that asymmetry is the whole distinction.
+   *
+   * **The report is for the agent, not only for the runtime it is holding now.** A
+   * connector replacement closes runtimes on this agent's behalf, and when no
+   * teardown was waiting to receive what those closes observed, the classes are
+   * booked on the agent — so they are aggregated here rather than lost, and a
+   * runtime that was superseded unobserved cannot be answered for as if it had
+   * never existed.
    * @param options - Cleanup options; ephemeral agents suppress session-close lifecycle events because they never join a session.
+   * @returns What this agent observed about the end of its resources
    */
   close(options?: {
     emitSessionClosed?: boolean;
-  }): Promise<void>;
+  }): Promise<TeardownReport>;
+  /**
+   * Give this agent's identity up, closing nothing.
+   *
+   * **For the teardown that abandons its wait on a connector replacement.** From
+   * the instant that wait expires this agent is no longer the instance answering
+   * for its ID — the registry entry is dropped in the same arm, so a successor may
+   * claim the ID immediately — while the runtimes stay with the replacement until
+   * it settles, which can be a whole wait later. Waiting for that settlement to
+   * unsubscribe leaves both agents answering for one identity in between.
+   *
+   * It closes nothing, reports nothing and emits nothing: the expiry arm's
+   * `unknown` is the honest statement about the runtimes, and this changes none of
+   * it. Safe to call twice — the cleanups are taken off their list, not merely run.
+   */
+  releaseIdentityWiring(): void;
+  /**
+   * Take this agent's connector runtime away from it.
+   *
+   * Clearing the reference **before** the close is awaited is what makes "the
+   * runtime is gone" permanent: only a start or a published replacement ever sets
+   * it, so a replacement arriving after a teardown began finds the absence and is
+   * refused instead of building onto a dying agent. The abandoned-waiter path in
+   * the replacement coordinator needs the same guarantee, which is why this is one
+   * method and not two copies of a two-line sequence.
+   * @returns The runtime this agent held, or `undefined` when it held none
+   */
+  private detachConnectorRuntime;
   /**
    * Ensure the connector is initialized, throwing if not.
    * @returns The initialized connector instance
@@ -3139,6 +2636,44 @@ declare abstract class AIAgent<TBus extends ScopedBus<string> = ScopedBus<string
    * @throws Error if connector is not initialized
    */
   getAdapterSessionId(): Promise<string>;
+  /**
+   * Announce the provider session this generation resolved to, through the
+   * agent's own movement tracker.
+   *
+   * For producers outside the turn pipeline — cold rehydration resolves an
+   * identity before the agent has emitted anything, so payload enrichment has
+   * not run yet. Routing through the tracker rather than emitting on the seam
+   * directly is what keeps an undelivered announcement retryable: the tracker's
+   * acknowledged-announcement marker is the retry anchor, and the agent's next
+   * emitted event re-drives the announcement. It also makes the announcement
+   * idempotent against that first enrichment call instead of duplicating it.
+   * **Who writes the durable currency is a parameter, not a second method.**
+   * A start or rehydrate whose caller owns the agent row settles the confirmed
+   * key itself, under a generation token that caller minted and can give back;
+   * announcing the same movement would make the observer a second settle
+   * producer for one identity, and its generation would be held under a token
+   * nobody in that caller's failure paths can name. One entry point keeps that
+   * choice explicit at every call site rather than letting a future producer
+   * pick the announcing variant by not knowing there is another — see
+   * {@link ConfirmedAdapterSessionTracker.recordCallerSettled}.
+   * @param adapterSessionId - Provider session ID this generation is current on
+   * @param settledByCaller - Whether the caller writes this movement's currency itself
+   * @returns Promise resolving once the announcement attempt completed
+   */
+  recordConfirmedAdapterSession(adapterSessionId: string, settledByCaller?: boolean): Promise<void>;
+  /**
+   * Provider session this agent is currently the live writer of.
+   *
+   * The occupancy authority for the adapter's registry. Synchronous on purpose:
+   * the claim check serializing two concurrent resume attaches reads it inside a
+   * critical section, which {@link getAdapterSessionId} — awaiting the connector —
+   * cannot serve. Current before any movement is announced, because the tracker
+   * caches a confirmed identity before announcing it; that ordering is what lets a
+   * concurrent attach see this agent occupying the session the same announcement
+   * publishes as resume currency.
+   * @returns Last provider-confirmed session ID, or `undefined` before the first confirmation
+   */
+  get currentAdapterSessionId(): string | undefined;
   /**
    * Complete the agent session by waiting for all messages to finish.
    *
@@ -3217,6 +2752,14 @@ declare abstract class AIAdapter<TBus extends ScopedBus<string> = ScopedBus<stri
   protected readonly globalBus: IMakaioBus;
   /** Scoped bus for adapter-specific communication. Created in init(). */
   protected adapterBus: TBus;
+  /**
+   * The one place a teardown and a connector replacement meet on this instance.
+   *
+   * Constructed here because one adapter instance is exactly its scope, and
+   * declared before the registry so it can be handed to it as a required
+   * dependency — see {@link AgentTeardownArbiter}.
+   */
+  private readonly teardownArbiter;
   /** Registry of active agents with session info and usage totals. */
   private readonly registry;
   /** Cleanup functions for bus subscriptions. */
@@ -3298,30 +2841,27 @@ declare abstract class AIAdapter<TBus extends ScopedBus<string> = ScopedBus<stri
   /** Hook for subclass cleanup. Override to perform async teardown (close connections, etc.). */
   protected onClose(): Promise<void>;
   /**
-   * Get an agent by ID with session info.
+   * Get a live agent and its registry-owned session metadata.
    * @param agentId - Agent identifier
-   * @returns Agent with session info, or undefined if not found
+   * @returns Active agent handle, or undefined if not found
    */
-  getAgent(agentId: string): (TAgent & {
-    sessionId: string;
-    adapterSessionId: string;
-  }) | undefined;
+  getAgent(agentId: string): ActiveAgentHandle<TAgent> | undefined;
   /**
-   * Dispose resources for an agent.
+   * Dispose resources for an agent and report what the teardown observed.
    *
-   * Aborts the agent and removes it from the tracking map.
+   * `found` answers the question the boolean return always answered — was there an
+   * agent here — and the class answers the one it could not: whether anything of
+   * ours provably stopped speaking to the provider.
    * @param agentId - Agent identifier
-   * @returns true if agent was found and disposed, false otherwise
+   * @param options - The driving request's deadline, when there is one
+   * @returns Whether an agent was found, and what its teardown observed
    */
-  disposeAgent(agentId: string): boolean;
+  disposeAgent(agentId: string, options?: AgentTeardownOptions): Promise<AgentDisposalReport>;
   /**
    * Get all active agents managed by this adapter.
-   * @returns Array of active agents with session info
+   * @returns Active agent handles
    */
-  getActiveAgents(): Array<TAgent & {
-    sessionId: string;
-    adapterSessionId: string;
-  }>;
+  getActiveAgents(): Array<ActiveAgentHandle<TAgent>>;
   /**
    * Check if the adapter has been initialized.
    * @returns true if init() has been called successfully
@@ -3509,6 +3049,24 @@ interface TestModelRef {
   /** Default reasoning effort for tests that exercise reasoning. */
   reasoningEffort?: AIReasoningLevel$1;
 }
+/**
+ * Which of an adapter's declared authentication methods a conformance config
+ * should select.
+ *
+ * `config-default` is the live-harness order: a config picks whatever it would
+ * pick for a real conformance run, including an `inferred` method that inherits
+ * a developer's native client login.
+ *
+ * `declared-credentials` forbids that inheritance. It asks the config for a
+ * method whose credentials come from declared sources, so that a caller which
+ * supplies those sources can construct the connector identically on every
+ * machine. Cases in the default test run need this: an `inferred` method is only
+ * materializable where somebody has logged the vendor client in, and a gate that
+ * is green only on a logged-in developer machine is not a gate. Configs whose
+ * adapters declare nothing but credential-backed methods already satisfy it and
+ * may ignore it.
+ */
+type ConformanceAuthSelection = 'config-default' | 'declared-credentials';
 /**
  * Provider definitions supplied by the conformance harness.
  *
@@ -3518,6 +3076,11 @@ interface TestModelRef {
 interface CreateConformanceTestConfigOptions {
   /** Full provider definitions available to conformance tests. */
   providerDefinitions?: readonly ProviderDefinitionInput[];
+  /**
+   * Auth-method selection policy for this config. Defaults to
+   * `config-default` when the harness expresses no requirement.
+   */
+  authSelection?: ConformanceAuthSelection;
 }
 /**
  * Options for creating test agent instances.
@@ -3856,6 +3419,10 @@ declare class ConformanceConnectorRuntimeRegistry<TBus extends ScopedBus<string>
   create<TConfig extends BaseAgentConnectorConfig<TBus>>(options: CreateConnectorRuntimeOptions<TBus, TConnector, TConfig>): Promise<TConnector>;
   /**
    * Close every connector still owned by this configuration.
+   *
+   * The managed close reports instead of rejecting, so the failures are read out
+   * of the reports; a suite teardown that swallowed them would hide exactly the
+   * lease leak this registry exists to catch.
    * @throws The single close failure, or an AggregateError containing all failures
    */
   closeAll(): Promise<void>;
@@ -4577,4 +4144,4 @@ declare const ToolCompletedEventSchema: z.ZodObject<{
 type ToolStartedEvent = z.infer<typeof ToolStartedEventSchema>;
 type ToolCompletedEvent = z.infer<typeof ToolCompletedEventSchema>;
 //#endregion
-export { AIAdapter, type AIAdapterCapabilities, type AIAdapterCapability, type AIAdapterCapabilityRegistry, type AIAdapterConfig, type AIAdapterConstructorConfig, type AIAdapterContext, type AIAdapterDefinition, type AIAdapterInitOptions, type AIAdapterPromptFailureResult, type AIAdapterPromptOptions, type AIAdapterPromptResult, type AIAdapterPromptSuccessResult, AIAgent, type AIAgentConfig, AIAgentConnector, type AIModel, type AIReasoningLevel, type AdapterNamespace, type AdapterProviderDefinition, type AgentBusHandlerRegistrarConfig, type AgentCompleteEvent, AgentCompleteEventSchema, AgentConnectorLifecycleManager, type AgentConnectorLifecycleManagerConfig, type AgentContext, AgentEventBridge, type AgentEventBridgeConfig, type AgentIdentity, AgentLifecycleEmitter, type AgentLifecycleEmitterConfig, AgentPayloadEmitter, type AgentPayloadEmitterConfig, type AgentRuntimeCreationResult, AgentRuntimeMutationManager, type AgentRuntimeMutationManagerConfig, type AgentSendMessageOptions, type AgentStartResult, type AgentStartedEvent, AgentStartedEventSchema, AgentTurnExecutor, type AgentTurnExecutorConfig, type AgentUsageTotals, type BaseAgentConnectorConfig, BaseConnectorSession, BaseConnectorTurn, BaseLogImporter, type CompactionMetadata, type ConfigFactoryInput, ConformanceConnectorRuntimeRegistry, type ConformanceEnvReader, type ConformanceTestConfig, type ConnectorSendMessageOptions, type ConnectorSessionConfig, type ConnectorStartOptions, type CreateConformanceTestConfigOptions, type CreateTestAgentOptions, type DiscoveryMetadata, type DiscriminatedHandler, type DiscriminatedHandlersConfig, type DiscriminatedHandlersMap, type ErrorEvent, ErrorEventSchema, type ExecutionContext, type ExternalToolIdentifier, type ExternalToolIdentifiers, type ExternalToolMeta, FactoryUsageCorrelationHeaders, type FromGlobalToolApprovalFn, type GeneratedCapabilityProperties, type HarnessRequester, type IAdapterConfigFactory, type ISessionToolLedger, type ImportCursorPosition, ImportCursorPositionSchema, ImportCursorStorageNamespace, ImportCursorStorageSubjects, type ImportMetadata, type ImportSegment, type ImportSegmentLineage, type ImportSegmentTurn, type LedgerSessionContext, type LogImportConfig, type LogImportOrchestrator, type LogImportRegistration, type LogImportSessionContext, type LogImportTestConfig, type LogImporter, type LogImporterConfig, type LogImporterConstructor, type LogOrchestratorConfig, type LogOrchestratorConstructor, MAKAIO_CONFORMANCE_PRIMARY_MODEL_ENV, MAKAIO_CONFORMANCE_PROVIDER_DEFINITIONS_ENV, MAKAIO_CONFORMANCE_PROVIDER_ENV, MAKAIO_CONFORMANCE_SECONDARY_MODEL_ENV, type McpIntegrationStrategy, type McpSessionResources, type McpToolChange, type MergeResult, type MergeScopedToolApprovalOptions, type MessageDeliveryMode, MessageHandle, MessageLifecycleTracker, type MessageResult, type MessageState, type NormalizedCallUsage, type NormalizedEvent, type NormalizedMessageInput, type ParseFileResult, type PauseResult, type PlatformDefaults, ProceduralAgentConnector, type ProceduralConnectorSession, ProceduralConnectorTurn, type ProceduralTurnConfig, type ProceduralTurnState, type ProcessLogFileResult, type ProcessQueueCallbacks, type ProcessingState, type ProviderRequestCorrelation, type QueueableTurn, type ReasoningLevelMap, type ResolveConformanceDefinitionProvidersOptions, type ResolveConformanceTestPresetOptions, type ResolveHints, type ResolvedConformanceTestPreset, SESSION_CLOSED_QUEUE_ERROR, type ScopedBusFor, type ScopedToolApprovalRequest, type ScopedToolApprovalResponse, ScopedToolApprovalSchema, type SendMessageOptions, type SendMessageRequest, type SendMessageResponse, type SerializedContextBlock, SessionLifecycle, SessionToolLedger, type ShouldUseNativeResumeFn, type StartAgentOptions, type StartAgentRequest, type StartAgentResponse, type StorageMessagePayload, type SyncDiscriminatedHandler, type SyncDiscriminatedHandlersConfig, type SyncDiscriminatedHandlersMap, type SyncTypedEmitFn, type TestModelRef, type ToGlobalToolApprovalFn, type ToolApprovalContext, ToolCallTracker, type ToolCompletedEvent, ToolCompletedEventSchema, type ToolLedgerEntry, type ToolStartedEvent, ToolStartedEventSchema, type TurnEvent, type TurnState, type TurnSubjects, TurnTracker, type TurnTrackerOptions, type TurnTrackerSerializedState, TurnTrackerSerializedStateSchema, type TypedEmitFn, UserMessageQueue, type ValidCapability, type WireSessionConfig, type WireSessionSubjects, bindProviderRequestCorrelation, buildFactoryUsageCorrelationHeaders, cleanEnvForAdapter, createAdapterNamespace, createNoAuthTestProviderContext, createTestProviderContext, createToolApprovalHandler, defineDiscriminatedHandlers, defineDiscriminatedHandlersSync, extractMcpCallTarget, formatContextBlockAsText, formatContextBlocksAsText, formatMessageHistoryAsTranscript, isMcpCallTool, isTextLikeMimeType, markCompletedWithFinalResult, mergeScopedToolApproval, normalizeEnvValue, normalizeMessageInput, normalizeMimeType, parseAIAdapterCapabilities, processDiscriminatedItems, processDiscriminatedItemsSync, processQueueMessages, registerAgentBusHandlers, registerMemoryImportCursorStorage, rejectQueuedHandles, resolveConformanceDefinitionProviders, resolveConformanceTestPreset, resolveDisabledNativeTools, resolveRequiredSessionId, resolveTestConfig, safeJsonStringify, serializeBlockToText, serializeTurnContext, toImportSegment };
+export { AIAdapter, type AIAdapterCapabilities, type AIAdapterCapability, type AIAdapterCapabilityRegistry, type AIAdapterConfig, type AIAdapterConstructorConfig, type AIAdapterContext, type AIAdapterDefinition, type AIAdapterInitOptions, type AIAdapterPromptFailureResult, type AIAdapterPromptOptions, type AIAdapterPromptResult, type AIAdapterPromptSuccessResult, AIAgent, type AIAgentConfig, AIAgentConnector, type AIModel, type AIReasoningLevel, type ActiveAgentHandle, type AdapterNamespace, type AdapterProviderDefinition, type AgentBusHandlerRegistrarConfig, type AgentCompleteEvent, AgentCompleteEventSchema, type AgentContext, type AgentDisposalReport, AgentEventBridge, type AgentEventBridgeConfig, type AgentIdentity, AgentLifecycleEmitter, type AgentLifecycleEmitterConfig, AgentPayloadEmitter, type AgentPayloadEmitterConfig, type AgentRuntimeCreationResult, AgentRuntimeMutationManager, type AgentRuntimeMutationManagerConfig, type AgentSendMessageOptions, type AgentStartResult, type AgentStartedEvent, AgentStartedEventSchema, AgentTeardownArbiter, type AgentTeardownOptions, AgentTurnExecutor, type AgentTurnExecutorConfig, type AgentUsageTotals, type BaseAgentConnectorConfig, BaseConnectorSession, BaseConnectorTurn, BaseLogImporter, CONNECTOR_EXIT_OBSERVATION_MS, type ClosableConnectorRuntime, type CompactionMetadata, type ConfigFactoryInput, type ConformanceAuthSelection, ConformanceConnectorRuntimeRegistry, type ConformanceEnvReader, type ConformanceTestConfig, type ConnectorReplacementSettlement, type ConnectorSendMessageOptions, type ConnectorSessionConfig, type ConnectorStartOptions, type ConnectorSwapAdmission, type ConnectorSwapHandover, type ConnectorSwapVetoReason, ConnectorSwapVetoedError, type CreateConformanceTestConfigOptions, type CreateTestAgentOptions, type DiscoveryMetadata, type DiscriminatedHandler, type DiscriminatedHandlersConfig, type DiscriminatedHandlersMap, type ErrorEvent, ErrorEventSchema, type ExecutionContext, type ExternalToolIdentifier, type ExternalToolIdentifiers, type ExternalToolMeta, FactoryUsageCorrelationHeaders, type FromGlobalToolApprovalFn, type GeneratedCapabilityProperties, GenerationRetirementLedger, type HarnessRequester, type IAdapterConfigFactory, type ISessionToolLedger, type ImportCursorPosition, ImportCursorPositionSchema, ImportCursorStorageNamespace, ImportCursorStorageSubjects, type ImportMetadata, type ImportSegment, type ImportSegmentLineage, type ImportSegmentTurn, type LedgerSessionContext, type LogImportConfig, type LogImportOrchestrator, type LogImportRegistration, type LogImportSessionContext, type LogImportTestConfig, type LogImporter, type LogImporterConfig, type LogImporterConstructor, type LogOrchestratorConfig, type LogOrchestratorConstructor, MAKAIO_CONFORMANCE_PRIMARY_MODEL_ENV, MAKAIO_CONFORMANCE_PROVIDER_DEFINITIONS_ENV, MAKAIO_CONFORMANCE_PROVIDER_ENV, MAKAIO_CONFORMANCE_SECONDARY_MODEL_ENV, type McpIntegrationStrategy, type McpSessionResources, type McpToolChange, type MergeResult, type MergeScopedToolApprovalOptions, type MessageDeliveryMode, MessageHandle, MessageLifecycleTracker, type MessageResult, type MessageState, type NormalizedCallUsage, type NormalizedEvent, type NormalizedMessageInput, type ObservedExitOptions, type ParseFileResult, type PauseResult, type PlatformDefaults, ProceduralAgentConnector, type ProceduralConnectorSession, ProceduralConnectorTurn, type ProceduralTurnConfig, type ProceduralTurnState, type ProcessLogFileResult, type ProcessQueueCallbacks, type ProcessingState, type ProviderRequestCorrelation, type QueueableTurn, type ReasoningLevelMap, type ResolveConformanceDefinitionProvidersOptions, type ResolveConformanceTestPresetOptions, type ResolveHints, type ResolvedConformanceTestPreset, SESSION_CLOSED_QUEUE_ERROR, SWAP_SETTLEMENT_WAIT_MS, type ScopedBusFor, type ScopedToolApprovalRequest, type ScopedToolApprovalResponse, ScopedToolApprovalSchema, type SendMessageOptions, type SendMessageRequest, type SendMessageResponse, type SerializedContextBlock, SessionLifecycle, SessionToolLedger, type ShouldUseNativeResumeFn, type StartAgentOptions, type StartAgentRequest, type StartAgentResponse, type StorageMessagePayload, type SupersededGeneration, type SyncDiscriminatedHandler, type SyncDiscriminatedHandlersConfig, type SyncDiscriminatedHandlersMap, type SyncTypedEmitFn, type TeardownReport, type TeardownSubject, type TestModelRef, type ToGlobalToolApprovalFn, type ToolApprovalContext, ToolCallTracker, type ToolCompletedEvent, ToolCompletedEventSchema, type ToolLedgerEntry, type ToolStartedEvent, ToolStartedEventSchema, type TurnEvent, type TurnState, type TurnSubjects, TurnTracker, type TurnTrackerOptions, type TurnTrackerSerializedState, TurnTrackerSerializedStateSchema, type TypedEmitFn, UserMessageQueue, type ValidCapability, type WireSessionConfig, type WireSessionSubjects, aggregateTeardownReports, bindProviderRequestCorrelation, buildFactoryUsageCorrelationHeaders, capTeardownEvidence, cleanEnvForAdapter, createAdapterNamespace, createNoAuthTestProviderContext, createTestProviderContext, createToolApprovalHandler, defineDiscriminatedHandlers, defineDiscriminatedHandlersSync, describeTeardownFailure, exitWasObserved, extractMcpCallTarget, formatContextBlockAsText, formatContextBlocksAsText, formatMessageHistoryAsTranscript, isMcpCallTool, isTextLikeMimeType, markCompletedWithFinalResult, mergeScopedToolApproval, normalizeEnvValue, normalizeMessageInput, normalizeMimeType, parseAIAdapterCapabilities, processDiscriminatedItems, processDiscriminatedItemsSync, processQueueMessages, registerAgentBusHandlers, registerMemoryImportCursorStorage, rejectQueuedHandles, reportBestEffortStages, reportObservedExit, reportRepeatTeardown, resolveConformanceDefinitionProviders, resolveConformanceTestPreset, resolveDisabledNativeTools, resolveRequiredSessionId, resolveTestConfig, rethrowTeardownFailure, runBestEffortStage, safeJsonStringify, serializeBlockToText, serializeTurnContext, stageFailure, toImportSegment, unknownTeardown, withTimeout };