@agen-ai/agent-runtime 0.3.1 → 0.4.1

package/README.md

@@ -8,8 +8,11 @@ sessions; each returned session owns its binding and conversation-local operatio
 
 The runtime depends only on `@agen-ai/agent-protocol`. It has no concept of tenants, SaaS
 workspaces, assigned users, database rows, persistence sequence, visibility, billing, host boots,
-leases, or storage policy. A host must authorize and select an instance before calling this SPI.
-This source package implements Agent Protocol V9 as part of the coordinated SDK `0.3.1` contract.
+distributed leases, or storage policy. A host must authorize and select an instance before calling this SPI.
+This source package implements Agent Protocol V11 at coordinated SDK version `0.4.1`,
+which remains unpublished. The published release remains `0.4.0` with V10. The source candidate
+also includes the additive session-interaction API.
+Upgrade consumers from `0.3.1` using the coordinated release and its migration guide.
 The SDK contract version is independent of private transport and product persistence versions. This
 is intentionally one coordinated tuple rather than a deployable mixed-version graph.
 
@@ -17,7 +20,7 @@ is intentionally one coordinated tuple rather than a deployable mixed-version gr
 
 - `@agen-ai/agent-runtime` exports the public driver, instance, adapter, session, output,
   readiness, account-quota port validation, bounded-evidence, artifact-candidate,
-  capability-bound interaction validation, and registry APIs.
+  capability-bound interaction validation, session-lifetime interaction and cleanup APIs, and registry APIs.
 - `@agen-ai/agent-runtime/environment` exports the instance discovery and session observation ports.
 - `@agen-ai/agent-runtime/testing` exports the deterministic fake provider and reusable
   conformance runner.
@@ -27,8 +30,10 @@ is intentionally one coordinated tuple rather than a deployable mixed-version gr
 1. Define an `AgentProviderDriver` with `defineAgentProviderDriver`.
 2. Give caller-owned instance definitions to `createAgentProviderRegistry`.
 3. Select a materialized instance by opaque `instanceId`.
-4. Create, resume, or branch a provider session through its adapter.
-5. Consume each `runTurn` or `resolveRequest` output stream incrementally. Neutral `AgentEvent`
+4. Create, resume, or branch a provider session through its adapter. If supported and needed,
+   supply the session-interaction handler on that opening input before calling the adapter.
+5. Call `startTurn` and consume its single `outputs` stream incrementally. Submit human answers with
+   the same execution's `resolveRequest`, which returns an independent delivery receipt. Neutral `AgentEvent`
    output carries bounded provider source evidence atomically. A `request.opened` output may also
    carry separately bounded, non-truncated provider request context for continuation; lifecycle,
    authentication, artifact, and standalone diagnostic evidence remain separate output variants.
@@ -70,33 +75,91 @@ Explicit iterator return and normal end join native cleanup for at most 1,000 ms
 Approval continuations are refusal-first. Before delegating to the candidate adapter, the
 validated session proves that the request is still pending and unexpired and that a selected
 `optionId` was offered by that exact request. Provider-emitted approval requests must correlate to
-a live item or exact proposed-plan artifact, and every option must fit an advertised
-persistence/scope mode. Item identities are monotonic throughout a turn, including every request
+a live item or exact proposed-plan artifact. A scoped consequence must fit an exact advertised
+persistence/scope mode; a provider-managed remembrance consequence requires
+`providerManagedRemembrance: true` and retains explicit unknown duration and applicability.
+A delivered answer does not prove that a provider wrote a remembered rule. Exact offered IDs,
+once-only response entry, and uncertain-delivery fencing remain unchanged.
+Present every offered option's decision and consequence, then return the exact option chosen by
+the caller; options with the same immediate decision can have different consequences. A human
+handler should run independently while the original `execution.outputs` reader keeps consuming
+progress. Resolve on that same execution, inspect its receipt, and retain its output and cleanup
+owners through terminal settlement. A remembered answer creates no SDK rule or future automatic
+answer; later requests still need their own offered choice. An uncertain answer must not be replayed.
+
+Item identities are monotonic throughout a turn, including every request
 continuation: an adapter cannot restart an observed identity, change its kind, erase prior progress
 through an unknown-status update, regress it from in-progress to pending, or revive it after a
 terminal event or status. An `item.completed` event must carry `completed`, `failed`, or `canceled`
 status. Completion-only snapshots remain valid when no earlier lifecycle event was observed.
 
-The host should serialize mutating operations for a given session. Separate session objects may
-run concurrently, so provider implementations must isolate their conversation-local state.
+A session reserves one turn execution synchronously at `startTurn`. Native execution stays lazy until
+its first output pull; an unused handle has no provider effects. Separate sessions run concurrently.
+The execution's `outputs` has exactly one consumer and one outstanding pull. Its ownership continues
+across human requests until native terminal output, entered response/control settlement, and cleanup.
 
 Materialization-scoped context usage remains monotonic only within one native provider process. A
 provider that replaces that process emits a `process.started` lifecycle output as the explicit
 boundary before reporting usage from the replacement. Validation then clears only the
 `materialization` occupancy, cumulative counters, and compaction allowance; logical `session`
 measurements remain continuous.
-`runTurn` and `resolveRequest` both preserve consumer backpressure: the provider does not resume
-until the consumer requests the next output. Each stream must end at a completed turn or exactly
-one newly pending request. If a consumer abandons a stream, a provider throws, or either stream
-ends before that stable boundary, the validated session becomes unusable and must be closed rather
-than retried. The validated `runTurn` input may observe `onProviderExecutionStarted`; validation
-invokes it exactly at candidate-port delegation, after runtime prechecks pass, and never forwards it
-to the candidate adapter. A delegated mutating operation that throws or returns an invalid result
-has the same effect. Pre-aborted operations fail with `AbortError`; close and disposal must be safe
-to call repeatedly. An accepted interruption of an already-waiting turn does not prove that the
-turn terminalized; unless the result also carries a terminal event, the validated session becomes
-unusable and must be closed and rematerialized. A close failure makes the session unusable while
-leaving close itself retryable.
+`startTurn(input)` returns `{ turnId, outputs, resolveRequest }`. `outputs` preserves per-output
+backpressure and stays open during `waiting_for_request`; the consumer can call
+`execution.resolveRequest({ resolution })` as soon as it receives `request.opened`, before its next
+pull. A later queued waiting observation cannot revive an already answered request. No response
+creates or acquires another output stream.
+
+`resolveRequest` returns one of these delivery receipts:
+
+- `{ status: "delivered" }`: the provider-owned handler accepted the exact canonical answer or step.
+  This includes a mapped form-intent step whose later field answer is still pending. It does not
+  establish a universal transport write, model consumption, effect completion, or turn success.
+- `{ status: "rejected", requestState: "pending" | "unavailable", error }`: the provider definitively
+  refused this answer. Only `pending` preserves that exact callback's answerability; `unavailable`
+  retires it. Neither value terminalizes the original output owner.
+- `{ status: "delivery_uncertain", error }`: native delivery started without definitive acceptance
+  or refusal. Further mutation and replay are forbidden; the original output/cleanup owner remains.
+
+Local parsing, request correlation, expiry, and pre-abort failures reject with their precise original
+errors before candidate entry. Validation atomically claims an answer before invoking the optional
+synchronous `onProviderExecutionStarted` observer and then the candidate. The runtime strips this
+observer from candidate input. A throwing observer prevents native entry and preserves the request
+only while it remains answerable. An unexpected candidate response exception carries
+`AgentProviderDelegatedOperationError` with `operation: "resolve_request"` and started-execution evidence;
+it also forbids further mutation. Concurrent duplicate answers cannot enter the provider twice.
+
+The turn input has the same synchronous start observer at its lazy candidate-entry boundary, after
+prechecks pass. Abort or iterator return before the first pull releases the reservation without
+poisoning the session. An aborted old handle rejects on a later pull. Abandoning an entered output
+consumer stops admission and closes its native owner; an incomplete stream makes the session unusable.
+Interruption remains a session control: dispatch acceptance leaves the original stream open to
+observe actual native cancellation completion. Its `AgentProviderTurnInterruptionResult` carries only
+status and optional error; interruption cannot return turn output. A reserved turn rejects interruption
+with `active_turn_mismatch`, including after iterator acquisition; the first pull must enter the provider.
+Abort or return cancels a reservation locally. Admitted interruption suspends exact request admission;
+definitive failed interruptions restore only the unchanged live callback after every overlapping
+interruption fails. A concurrent response refusal with `requestState: "pending"` retains that callback
+through suspension; an accepted interruption withdraws it regardless of response completion order.
+
+Close first stops admission, signals cancellation, and initiates native quiescence; it then joins
+entered output/response work and drains host callbacks before releasing resources. Native close is
+initiated before joining acknowledgments that depend on it. A failed close keeps the stopped owner
+and host binding retained while close remains retryable. Successful close and disposal are idempotent.
+
+Ordinary answers past a request's `expiresAt` fail locally. A canonical `canceled` resolution still
+checks the live handler's availability; expiry alone cannot establish delivery. Terminal observation
+fences new answers even while an entered response is settling, and waiting observations cannot
+reopen an older request. A host must cancel human decisions when their execution ends and join
+those tasks during cleanup. Keep the session or exact opening-cleanup receipt if cleanup fails;
+disposing its registry or host resources before quiescence would lose the retained owner.
+
+`runtime.retrying` reports a retry already owned by the provider on the active turn. It preserves
+turn ownership, pending requests, and per-output backpressure; it neither starts another execution
+nor completes the turn. It is rejected before `turn.started`, after `turn.completed`, after a
+`final_diff` terminal materialization, and from session-operation observations. The event's neutral
+failure category and recovery hint describe the observed condition. A recovery hint never authorizes
+replaying work or changes an uncertain execution outcome. Contract failures, delegated-operation
+started evidence, and retained cleanup responsibilities remain separate from those failure values.
 
 When context usage is advertised, the validated session enforces the declared measurement scopes
 and cumulative fields across turns. Identical consecutive samples and decreasing cumulative
@@ -104,13 +167,19 @@ counters are rejected. Occupancy may decrease only after a completed advertised
 the next accepted sample consumes that allowance. Context output remains subject to the same
 per-output backpressure and terminal ordering as every other provider event.
 
-When `capabilities.turns.steer` is true, the session exposes `steering.steerTurn`. Steering accepts
+When `capabilities.turns.steer.kind` is `supported`, the session exposes `steering.steerTurn`. Steering accepts
 the existing turn ID plus the same canonical `parts` and optional `summary` used to start a turn.
-It does not create or own an output stream: model output continues on the original `runTurn`
-iterator. The receipt is exactly `delivered`, `rejected` with a bounded neutral error, or
+It requires provider entry on the first output pull; a reserved or merely acquired execution rejects
+steering with `active_turn_mismatch` without calling the provider.
+It does not create or own an output stream: model output continues on the original execution's
+`outputs` iterator. The receipt is exactly `delivered`, `rejected` with a bounded neutral error, or
 `delivery_uncertain` with a bounded neutral error. A provider must use uncertainty when delivery
 may have started but its authoritative acknowledgement was lost; callers cannot safely replay that
-result. The validated runtime preserves pre-delegation validation and abort errors unchanged, while
+result. A returned `delivery_uncertain` makes the validated session unusable for further mutation.
+Keep its original output reader owned while it drains toward terminality; a pending request does not
+end that stream or restore mutation authority. Close the unusable session to quiesce work that cannot
+finish without another response, then rematerialize before further work. The validated runtime preserves pre-delegation
+validation and abort errors unchanged, while
 provider-delegated steering failures throw `AgentProviderDelegatedOperationError` with the original
 cause and explicit started-execution evidence so a host can retire the unusable session. Platform
 scheduling and provider-native queue modes are intentionally outside this SPI.
@@ -128,6 +197,167 @@ identity, declared bounds, forward-only lifecycle transitions, and per-output ba
 the operation result may settle. Collaboration and generated-resource observations retain the
 same correlation and lifecycle validation at their respective ports.
 
+## Session-lifetime interactions
+
+An adapter can offer a decision outside any model turn through `sessionInteractions`.
+Its support declaration is separate from V11 turn capabilities: absence means
+`{ kind: 'unsupported' }`; supported adapters name exact `openingOperations`, declare
+`requestKinds: ['decision']` and require `producerOwnership: 'exclusive'`. Supplying
+`interactions` for an unsupported opening raises `session_interactions_unsupported` before
+delegating that opening. An adapter's create support does not imply resume or branch support.
+
+Install `interactions.onRequest` before opening. The callback receives a bound
+`AgentSessionInteraction` containing the portable request, an eligibility signal, a
+terminal promise and `respond({ choiceId, signal? })`. The handler can return immediately
+after handing the capability to an owned UI, or return the promise for its work. Opening
+may return while the decision remains pending; questions can also arrive after return.
+Do not block session creation waiting for every human decision or route these decisions
+through `startTurn`, `AgentEvent`, or an execution's `resolveRequest`.
+
+For an already selected `adapter`, host-owned `openingInput` and UI-owned map, register early:
+
+```ts
+import type { AgentProviderCreateSessionInput, AgentSessionInteraction } from '@agen-ai/agent-runtime';
+
+const pending = new Map<string, AgentSessionInteraction>();
+const input: AgentProviderCreateSessionInput = {
+  ...openingInput,
+  interactions: {
+    onRequest(interaction) {
+      pending.set(interaction.request.requestId, interaction);
+    },
+  },
+};
+const session = await adapter.createSession(input);
+// Present the request target and every choice consequence before selecting a choice.
+// Answer using that retained interaction's respond({ choiceId }) capability.
+// The UI retires terminal entries and observes interaction.signal.
+```
+
+The complete public [lifecycle example](../../examples/lifecycle-interactions.ts) uses a
+consumer-owned adapter, opens with a pending decision, selects a synthetic decline and joins
+cleanup without a model turn. It needs only the core protocol/runtime dependency closure.
+For an ordinary noninteractive opening, omit `interactions` from the input. The runtime
+does not install an automatic answer policy; a provider requiring a handler must reject that
+opening. Keep authentication and interactive materialization in their existing owners.
+
+`respond` validates the choice against this exact request and allows one active response:
+
+| Receipt | Meaning |
+| --- | --- |
+| `delivered` | The provider-owned handler accepted the exact choice. The interaction becomes `answered`; this does not prove a wire write, native consumption, effect completion or persistent storage. |
+| `rejected` with `requestState: 'pending'` | Definitive refusal preserves this request's eligibility. A second response while one is active also receives pending refusal; it cannot start overlapping native delivery. |
+| `rejected` with `requestState: 'unavailable'` | The request has retired and the capability cannot answer it again. |
+| `delivery_uncertain` | Entered delivery did not establish acceptance or refusal. The session is fenced against further mutation; close it without replaying the choice. |
+
+Malformed choices and pre-aborted response inputs preserve their original errors before provider
+entry. An entered response that throws or exceeds its response deadline returns uncertainty,
+even if the provider later settles. Closing or aborting does not make an entered answer safe
+to repeat. Successful cleanup never resolves that uncertainty or authorizes replay.
+
+Terminal variants are `answered`, `rejected`, `delivery_uncertain`, `withdrawn`, `expired`,
+`session_closed`, and `failed`. `interaction.signal` controls answer eligibility and UI
+presentation; terminal settlement records the decision lifecycle. Neither means the native
+producer, entered response or callback has stopped. Close first fences admission and starts
+native shutdown, then joins the actual response, terminal and callback work. A callback that
+ignores abort remains owned. Request expiry or handler failure fails the interaction owner;
+cleanup and its original failure remain observable through the owning session.
+
+The runtime validates integer overrides once on the opening context:
+
+| Limit | Default | Allowed override |
+| --- | --- | --- |
+| `maxRetainedRequests` | 8 | 1 to 32 |
+| `maxRetainedBytes` | 524,288 bytes | 65,536 to 2,097,152 bytes |
+| `requestTimeoutMs` | 300,000 ms | 1,000 to 1,800,000 ms |
+| `responseTimeoutMs` | 30,000 ms | 1,000 to 120,000 ms |
+| `cleanupTimeoutMs` | 30,000 ms | 1,000 to 120,000 ms |
+
+Request eligibility uses the earlier provider expiry or runtime request deadline. Retained
+capacity includes terminal requests whose native terminal, response or callback has not drained.
+Unknown fields, fractional values and values outside the bounds reject the opening context.
+The opening signal applies until the session is adopted; later cancellation belongs to the
+returned session or a specific response rather than the completed opening call.
+
+If an opening fails with incomplete cleanup, use
+`isAgentProviderSessionCleanupErrorFor(error, openingInput)` with the exact input object
+passed to the adapter, such as `input` above.
+Retain that `AgentProviderSessionCleanupError` and its bound `retryCleanup()`; keep the
+registry, instance, host resources and installation references owned until it succeeds.
+A returned session with failed close likewise retains cleanup through the session and any
+returned cleanup error. An observation timeout does not detach the actual work. Retry joins
+the same owner and never opens another session or resends a choice. Serialized errors and
+request IDs cannot restore callable cleanup or response authority. Adapter authors use
+`createAgentProviderSessionCleanupError({ openingInput, providerKey, errors, retryCleanup })`
+to preserve a failed opening's exact cleanup owner.
+
+## Session-local host tools and instructions
+
+A host can pass an optional `AgentSessionHostBinding` when creating, resuming or branching a
+session. The binding contains tool definitions, an invocation callback, optional instructions and
+an idempotent `release` callback. Its callbacks close over host authorization; model arguments do
+not supply that authority. This is an additive runtime SPI. It does not enable managed delegation
+or change native collaboration by itself.
+
+The optional `@agen-ai/agent-orchestration` package sits above this SPI. It owns managed target policy,
+scoped tools and generated delegation guidance; the runtime has no dependency on that package or
+its explicit MCP transport. A parent's end-turn boundary leaves its session binding alive and does
+not cancel independently owned children. AgenAI Workspaces preferences and Hostd production
+integration remain separate product work.
+
+An adapter declares `hostBinding` support, its `callback` or `mcp` transport, and the instruction
+placements it can materialize. Missing support means unsupported. `system` and `developer`
+placements require the corresponding trusted native channels; `tool_context` means tool/server
+guidance. The runtime rejects unsupported requests before native session creation. Adapter authors
+must reject collisions with their native tools and actually install the requested binding.
+
+Tools use a bounded, closed JSON Schema 2020-12 subset: objects with declared properties and no
+additional properties, bounded arrays and strings, finite numbers, safe integers, booleans and
+null. Root schemas declare the dialect. References, remote loading, regular expressions, coercion
+and executable validation are unsupported. A binding allows up to 32 tools, 64 KiB of definition
+data, 32 KiB argument/result envelopes and 16 concurrent callbacks. Runtime validation precedes
+callback entry and validates returned results; callback exceptions become sanitized tool errors.
+
+Every opening needs a fresh binding object, including resume and branch. The validated opening
+claims a minimally valid binding before other opening checks. After that claim, opening failures
+own cleanup; malformed minimal bindings remain caller-owned and a duplicate claim cannot release
+the original session's binding. `validateAgentSessionHostBinding` validates metadata without claiming it. Explicit transport
+adapters can reuse `validateAgentHostToolInvocation({ binding, invocation })` against that validated
+metadata and `validateAgentHostToolResult(value)` without duplicating the bounded schema interpreter.
+These pure validators do not invoke callbacks, claim leases or provide lifecycle ownership.
+
+If a provider opening fails before returning a session and native resources are still pending,
+throw `createAgentProviderSessionCleanupError({ providerKey, openingInput, errors, retryCleanup })`.
+`openingInput` must be the exact context object received by the create/resume/branch port. The
+validated adapter adopts only that exact identity and provider key, stops new host callbacks, and
+retains the original binding. Explicit cleanup retry first quiesces provider resources and then
+releases the binding; propagation does not add another native cleanup attempt. Successful native
+cleanup is retained when only host release needs retry. A plain or foreign cleanup error cannot
+claim the current opening. Callers can use `isAgentProviderSessionCleanupErrorFor(error, input)`
+against their original opening object to identify the retained responsibility.
+
+Closing stops new invocations and aborts active callback signals, then joins provider cleanup and
+callback settlement before releasing the host binding. Ending a turn does not release it. Providers
+must quiesce their output/control producers before their close succeeds and clean up partial native
+resources before throwing an opening error without a session. Preserve callback method receivers.
+Hosts must close their sessions before disposing the instance or registry. Registry disposal retains
+its existing instance ownership and does not inventory or close caller-owned session bindings.
+
+Cleanup failure leaves authority closed and cleanup retryable. An opened session retries through
+`session.close`. If opening fails and cleanup also fails, catch
+`AgentProviderSessionCleanupError` and check
+`isAgentProviderSessionCleanupErrorFor(error, originalOpeningInput)` before assigning its retained
+handle to an opening. Use a distinct input object for each opening and preserve the exact object
+passed to create, resume or branch; copied inputs
+and constructed errors do not match the runtime's private ownership evidence. This also covers
+invalid candidates without host tools. `AgentProviderHostBindingCleanupError` remains the compatible
+subclass for failures involving a claimed host binding. A provider can propagate another opening's
+error, so `instanceof` alone does not establish ownership. Call the matching error's single-flight
+`retryCleanup()` to finish retained cleanup. It closes the exact rejected session before releasing
+the binding; a completed close is not repeated when only host release failed. Keep this error and
+its diagnostic causes on the trusted host boundary. Never serialize its handle or raw diagnostics
+into a model tool result.
+
 ## Minimal driver
 
 ```ts
@@ -178,6 +408,19 @@ The runtime distinguishes programmer/contract failures from provider failures:
 Provider-native exceptions should be normalized or safely wrapped at the provider boundary. Do
 not attach credentials, raw prompts, product identities, or unbounded output to public errors.
 
+Use `AgentError.category`, `code` and `recovery` to describe an expected operational condition.
+They do not replace `AgentProviderContractError`, delegated-operation start evidence, or cleanup
+exceptions. A `runtime.error` observation is not a terminal event; `runtime.retrying` keeps the same
+turn active. Render a definitive failed turn from its `turn.completed` result instead of counting
+each error observation as another failure. A transient classification or a quota reset never proves
+that prior tool effects can be repeated.
+
+Cancellation must retain the current stream and resource owners until native settlement and callback
+quiescence are established. An accepted interruption acknowledges dispatch; it does not establish
+cancellation completion. If the outcome remains unknown, preserve that uncertainty, close the unusable
+session and retain any failed cleanup handle for explicit retry. Successful cleanup does not settle
+the uncertain operation or authorize resending it.
+
 ## Scoped environment observation
 
 `MaterializedAgentProviderInstance.environment` discovers a caller-selected workspace and
@@ -207,11 +450,13 @@ turn/request ordering, request resolution, steering, interruption, configuration
 close, and idempotent disposal. Unsupported operations must remain explicit discriminants and
 must not expose handlers.
 
-The coordinated SDK version for this source is `0.3.1`, and the source implements Agent Protocol
-V9. The earlier public `0.3.0` release implemented the same protocol and remains historical.
-Upgrade all three SDK packages together. Every materialized instance requires `environment` and
+The coordinated source SDK version is `0.4.1`, remains unpublished and implements Agent Protocol V11.
+The published coordinated release remains `0.4.0` with V10.
+The earlier public `0.3.0` and `0.3.1` releases implemented V9 and remain historical.
+Keep installed packages in the seven-package SDK release family on the coordinated version; the
+orchestration and ACP packages remain optional. Every materialized instance requires `environment` and
 `accountQuota`; every session requires `environment`. The former standalone `integrations`
-observation port is removed. The public runtime implements Agent Protocol V9 with one current
+observation port is removed. The public runtime implements Agent Protocol V11 with one current
 adapter/session surface. Package versions remain independent of private transport and product
 persistence versions.
 
@@ -222,3 +467,17 @@ From the public repository root, run `pnpm check`.
 It installs tarballs into a temporary project outside the workspace, typechecks every documented
 entrypoint, runs the fake provider and parser flow, and removes the temporary directory. It never
 publishes or accesses release credentials.
+
+The public repository also contains `examples/delegation`: a shared host composition with direct
+and credentialless ACP workflows plus a separately qualified SQLite/inbox CLI. From that root,
+`pnpm examples:delegation` exercises real steering, queued resume, cancellation and live approval;
+`pnpm examples:delegation:acp` invokes scoped MCP tools and demonstrates a child surviving its
+parent's end-turn boundary. The installed-tarball consumer runs the same source. Synthetic evidence
+does not certify native agents or authorize replay of an uncertain turn.
+
+For the smallest runnable lifecycle example, use
+[`examples/live-request-output.ts`](../../examples/live-request-output.ts) in the public repository
+with `pnpm examples:live-request-output`. It observes unrelated output before answering an exact
+request, with one reader and joined cleanup. The public
+[migration guide](../../MIGRATING-TO-0.4.md#continuous-turn-output-and-independent-answers) shows the
+published-`0.3.1` before-example and an independent human-handler pattern for `0.4.0`.

package/dist/adapterValidation.d.ts

@@ -1,4 +1,4 @@
 import { type AgentCapabilities } from "@agen-ai/agent-protocol";
 import type { AgentProviderAdapter } from "./sessions.js";
-export declare function validateAgentProviderAdapter(capabilityInput: AgentCapabilities, adapter: AgentProviderAdapter): AgentProviderAdapter;
+export declare function validateAgentProviderAdapter(capabilityInput: AgentCapabilities, adapterInput: AgentProviderAdapter): AgentProviderAdapter;
 //# sourceMappingURL=adapterValidation.d.ts.map