@agen-ai/agent-runtime 0.2.1 → 0.2.3

package/README.md

@@ -9,12 +9,14 @@ its binding and conversation-local operations.
 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.
-The current coordinated deployment tuple is Agent Protocol V7, private host V15/catalog V9, and Workspaces event V9.
+This source package implements Agent Protocol V8. Agent Protocol V8, private host V16/catalog V10, and Workspaces event V10.
+This is intentionally one coordinated tuple rather than a deployable mixed-version graph.
 
 ## Entrypoints
 
 - `@agen-ai/agent-runtime` exports the public driver, instance, adapter, session, output,
-  readiness, bounded-evidence, artifact-candidate, and registry APIs.
+  readiness, bounded-evidence, artifact-candidate, capability-bound interaction validation,
+  and registry APIs.
 - `@agen-ai/agent-runtime/testing` exports the deterministic fake provider and reusable
   conformance runner.
 
@@ -39,14 +41,31 @@ exactly once before returning the matching session. Capability-dependent operati
 `supported`/`unsupported` discriminants, and the runtime rejects handlers that disagree with the
 instance capability declaration.
 
+V8 replaces interaction-extension booleans with cohesive capability-matched session ports:
+configuration inventory and selection, typed operation inventory and invocation, managed-content
+inventory, integration observation, collaboration spawn/control, and generated-resource access.
+An unsupported declaration exposes exactly `{ kind: "unsupported" }`; a supported declaration must
+expose exactly its typed handlers. Catalogs and results are parsed again at the runtime boundary,
+bounded by the declaration, and correlated to the offered revision and caller-owned identity.
+
 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.
+persistence/scope mode. 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.
+
+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
@@ -77,6 +96,14 @@ provider-delegated steering failures throw `AgentProviderDelegatedOperationError
 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.
 
+Configuration selection, operation invocation, and collaboration mutation use the same execution
+receipt rule: stale or malformed input fails before provider delegation, while any failure after
+the candidate reports execution start is wrapped as `AgentProviderDelegatedOperationError` and
+makes the session unusable. The start boundary commits only after the host observer returns
+successfully; an observer failure remains a pre-delegation error and leaves the session reusable.
+Operation, collaboration, and generated-resource observations also
+enforce correlation, immutable identity, declared bounds, and forward-only lifecycle transitions.
+
 ## Minimal driver
 
 ```ts
@@ -136,13 +163,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 package is at `0.2.1` while the public SPI is being proven with external adapters. Minor
-releases may include breaking changes during this beta period, and those changes will be called out
-in the release notes.
+The package is at `0.2.3` while the public SPI is being proven with external adapters. Pre-1.0
+releases may include breaking changes during this beta period, and those changes are called out in
+the release notes.
 
-The public runtime implements Agent Protocol V7. Its package version remains independent of private
-host, catalog, persistence, and member-projection versions. Version `0.2.0` directly replaces the
-V6/`0.1.0` API; see the repository `MIGRATING-TO-0.2.md` guide.
+The public runtime implements Agent Protocol V8. Its package version remains independent of private
+host, catalog, persistence, and member-projection versions. V8 directly replaces V7; there is no
+runtime shim or dual-protocol session surface.
 
 Run the clean packed-consumer proof before any release:
 

package/dist/configurationValidation.js

@@ -1,31 +1,26 @@
 import { throwAgentProviderContractError } from "./contractErrors.js";
 function assertAgentSessionConfigurationSupported(capabilities, configuration) {
-  const entries = Object.entries(configuration.values);
   if (capabilities.configuration.kind === "managed") {
-    if (entries.length === 0) return;
+    if (configuration.kind === "managed") return;
     throwAgentProviderContractError(
       capabilities.providerKey,
       "configuration_key_unsupported",
-      "Managed provider configuration values must be empty."
+      "Managed providers require a managed session configuration."
     );
   }
-  const fields = new Map(
-    capabilities.configuration.fields.map((field) => [field.key, field])
-  );
-  for (const [key, value] of entries) {
-    const field = fields.get(key);
-    if (!field) {
-      throwAgentProviderContractError(
-        capabilities.providerKey,
-        "configuration_key_unsupported",
-        "Provider configuration contains a key not declared by its capabilities."
-      );
-    }
-    if (typeof value !== "string" || !field.optionIds.includes(value)) {
+  if (configuration.kind !== "selected" || configuration.selections.length > capabilities.configuration.maxFields) {
+    throwAgentProviderContractError(
+      capabilities.providerKey,
+      "configuration_key_unsupported",
+      "Selectable providers require a bounded selected session configuration."
+    );
+  }
+  for (const selection of configuration.selections) {
+    if (!capabilities.configuration.fieldKinds.includes(selection.value.fieldKind)) {
       throwAgentProviderContractError(
         capabilities.providerKey,
         "configuration_value_unsupported",
-        "Provider configuration contains an option not declared by its capabilities."
+        "Provider configuration contains a field kind outside its declared capability."
       );
     }
   }

package/dist/contractErrors.d.ts

@@ -1,7 +1,7 @@
 import type { AgentProviderKey } from "@agen-ai/agent-protocol";
-export declare const AGENT_PROVIDER_CONTRACT_ERROR_CODES: readonly ["capability_port_mismatch", "invalid_adapter", "invalid_session", "invalid_binding", "binding_callback_missing", "binding_callback_repeated", "binding_callback_mismatch", "resume_binding_mismatch", "branch_binding_reused", "session_closed", "session_unusable", "concurrent_turn", "active_turn_mismatch", "invalid_operation_result", "output_session_mismatch", "output_turn_mismatch", "output_authentication_attempt_mismatch", "output_capability_mismatch", "input_capability_mismatch", "invalid_turn_sequence", "request_resolution_mismatch", "configuration_key_unsupported", "configuration_value_unsupported", "request_pending"];
+export declare const AGENT_PROVIDER_CONTRACT_ERROR_CODES: readonly ["capability_port_mismatch", "invalid_adapter", "invalid_session", "invalid_binding", "binding_callback_missing", "binding_callback_repeated", "binding_callback_mismatch", "resume_binding_mismatch", "branch_binding_reused", "session_closed", "session_unusable", "concurrent_turn", "active_turn_mismatch", "invalid_operation_result", "invalid_inventory", "invalid_collaboration_transition", "input_operation_mismatch", "output_session_mismatch", "output_turn_mismatch", "output_authentication_attempt_mismatch", "output_operation_mismatch", "output_collaboration_mismatch", "output_resource_mismatch", "output_capability_mismatch", "input_capability_mismatch", "invalid_turn_sequence", "request_resolution_mismatch", "configuration_key_unsupported", "configuration_value_unsupported", "request_pending"];
 export type AgentProviderContractErrorCode = (typeof AGENT_PROVIDER_CONTRACT_ERROR_CODES)[number];
-export type AgentProviderDelegatedOperation = "steer_turn";
+export type AgentProviderDelegatedOperation = "steer_turn" | "invoke_operation" | "apply_configuration" | "spawn_collaboration" | "control_collaboration";
 export declare class AgentProviderContractError extends Error {
     readonly providerKey: AgentProviderKey;
     readonly code: AgentProviderContractErrorCode;

package/dist/contractErrors.js

@@ -13,9 +13,15 @@ const AGENT_PROVIDER_CONTRACT_ERROR_CODES = [
   "concurrent_turn",
   "active_turn_mismatch",
   "invalid_operation_result",
+  "invalid_inventory",
+  "invalid_collaboration_transition",
+  "input_operation_mismatch",
   "output_session_mismatch",
   "output_turn_mismatch",
   "output_authentication_attempt_mismatch",
+  "output_operation_mismatch",
+  "output_collaboration_mismatch",
+  "output_resource_mismatch",
   "output_capability_mismatch",
   "input_capability_mismatch",
   "invalid_turn_sequence",

package/dist/index.d.ts

@@ -3,6 +3,7 @@ export * from "./artifacts.js";
 export * from "./contractErrors.js";
 export * from "./evidence.js";
 export * from "./foundation.js";
+export * from "./interactionValidation.js";
 export * from "./outputs.js";
 export * from "./providerCatalog.js";
 export * from "./providerDriver.js";

package/dist/index.js

@@ -3,6 +3,7 @@ export * from "./artifacts.js";
 export * from "./contractErrors.js";
 export * from "./evidence.js";
 export * from "./foundation.js";
+export * from "./interactionValidation.js";
 export * from "./outputs.js";
 export * from "./providerCatalog.js";
 export * from "./providerDriver.js";

package/dist/interactionValidation.d.ts

@@ -0,0 +1,23 @@
+import { type AgentCapabilities, type AgentCollaborationNode, type AgentConfigurationCatalog, type AgentGeneratedResourceDescriptor, type AgentIntegrationCatalog, type AgentManagedContentCatalog, type AgentOperationCatalog, type AgentOperationInvocation, type AgentOperationDescriptor, type AgentOperationResult, type AgentProviderKey } from "@agen-ai/agent-protocol";
+export declare function validateAgentOperationCatalogForCapabilities(capabilities: AgentCapabilities, candidate: unknown): AgentOperationCatalog;
+export declare function validateAgentManagedContentCatalogForCapabilities(capabilities: AgentCapabilities, candidate: unknown): AgentManagedContentCatalog;
+export declare function validateAgentConfigurationCatalogForCapabilities(capabilities: AgentCapabilities, candidate: unknown): AgentConfigurationCatalog;
+export declare function validateAgentIntegrationCatalogForCapabilities(capabilities: AgentCapabilities, candidate: unknown): AgentIntegrationCatalog;
+export declare function validateAgentOperationResultForInvocation(providerKey: AgentProviderKey, descriptor: AgentOperationDescriptor, invocation: AgentOperationInvocation, candidate: unknown): AgentOperationResult;
+export declare function validateAgentOperationResultTransition(input: {
+    readonly providerKey: AgentProviderKey;
+    readonly candidate: AgentOperationResult;
+    readonly previous?: AgentOperationResult;
+}): AgentOperationResult;
+export declare function validateAgentCollaborationNodeForCapabilities(input: {
+    readonly capabilities: AgentCapabilities;
+    readonly candidate: unknown;
+    readonly previous?: AgentCollaborationNode;
+}): AgentCollaborationNode;
+export declare function validateAgentGeneratedResourceForCapabilities(input: {
+    readonly capabilities: AgentCapabilities;
+    readonly candidate: unknown;
+    readonly expectedResourceId: string;
+    readonly previous?: AgentGeneratedResourceDescriptor;
+}): AgentGeneratedResourceDescriptor;
+//# sourceMappingURL=interactionValidation.d.ts.map

package/dist/interactionValidation.js

@@ -0,0 +1,238 @@
+import { isDeepStrictEqual } from "node:util";
+import {
+  parseAgentCollaborationNode,
+  parseAgentConfigurationCatalog,
+  parseAgentGeneratedResourceDescriptor,
+  parseAgentIntegrationCatalog,
+  parseAgentManagedContentCatalog,
+  parseAgentOperationCatalog,
+  parseAgentOperationResultFor
+} from "@agen-ai/agent-protocol";
+import { throwAgentProviderContractError } from "./contractErrors.js";
+function invalidInventory(providerKey, message) {
+  return throwAgentProviderContractError(providerKey, "invalid_inventory", message);
+}
+function validateAgentOperationCatalogForCapabilities(capabilities, candidate) {
+  let catalog;
+  try {
+    catalog = parseAgentOperationCatalog(candidate);
+  } catch {
+    return invalidInventory(capabilities.providerKey, "Provider returned an invalid operation catalog.");
+  }
+  const capability = capabilities.operations;
+  if (capability.kind !== "supported" || catalog.operations.length > capability.maxOperations || catalog.operations.some(
+    (operation) => !capability.operationKinds.includes(operation.kind) || !capability.executionModes.includes(operation.executionMode) || operation.fields.length > capability.maxFieldsPerOperation || operation.fields.some(
+      (field) => !capability.fieldKinds.includes(field.fieldKind)
+    )
+  )) {
+    return invalidInventory(
+      capabilities.providerKey,
+      "Operation catalog exceeds the provider's declared capability."
+    );
+  }
+  return catalog;
+}
+function validateAgentManagedContentCatalogForCapabilities(capabilities, candidate) {
+  let catalog;
+  try {
+    catalog = parseAgentManagedContentCatalog(candidate);
+  } catch {
+    return invalidInventory(capabilities.providerKey, "Provider returned an invalid managed-content catalog.");
+  }
+  const capability = capabilities.managedContent;
+  if (capability.kind !== "supported" || catalog.entries.length > capability.maxEntries || catalog.entries.some(
+    (entry) => !capability.contentKinds.includes(entry.kind)
+  )) {
+    return invalidInventory(
+      capabilities.providerKey,
+      "Managed-content catalog exceeds the provider's declared capability."
+    );
+  }
+  return catalog;
+}
+function validateAgentConfigurationCatalogForCapabilities(capabilities, candidate) {
+  let catalog;
+  try {
+    catalog = parseAgentConfigurationCatalog(candidate);
+  } catch {
+    return invalidInventory(capabilities.providerKey, "Provider returned an invalid configuration catalog.");
+  }
+  const capability = capabilities.configuration;
+  if (capability.kind !== "selectable" || catalog.fields.length > capability.maxFields || catalog.fields.some(
+    (field) => !capability.fieldKinds.includes(field.fieldKind)
+  )) {
+    return invalidInventory(
+      capabilities.providerKey,
+      "Configuration catalog exceeds the provider's declared capability."
+    );
+  }
+  return catalog;
+}
+function validateAgentIntegrationCatalogForCapabilities(capabilities, candidate) {
+  let catalog;
+  try {
+    catalog = parseAgentIntegrationCatalog(candidate);
+  } catch {
+    return invalidInventory(capabilities.providerKey, "Provider returned an invalid integration catalog.");
+  }
+  const capability = capabilities.integrations;
+  if (capability.kind !== "supported" || catalog.integrations.length > capability.maxIntegrations || catalog.integrations.some(
+    (integration) => !capability.integrationKinds.includes(integration.kind) || integration.servers.length > capability.maxServersPerIntegration || integration.servers.some(
+      (server) => server.tools.length > capability.maxToolsPerServer || server.resources.length > capability.maxResourcesPerServer
+    )
+  )) {
+    return invalidInventory(
+      capabilities.providerKey,
+      "Integration catalog exceeds the provider's declared capability."
+    );
+  }
+  return catalog;
+}
+function validateAgentOperationResultForInvocation(providerKey, descriptor, invocation, candidate) {
+  try {
+    return parseAgentOperationResultFor(descriptor, invocation, candidate);
+  } catch {
+    return throwAgentProviderContractError(
+      providerKey,
+      "invalid_operation_result",
+      "Provider returned an invalid or uncorrelated operation result."
+    );
+  }
+}
+const OPERATION_RESULT_TRANSITIONS = {
+  accepted: ["accepted", "waiting_for_request", "completed", "failed", "canceled"],
+  waiting_for_request: ["waiting_for_request", "accepted", "completed", "failed", "canceled"],
+  completed: ["completed"],
+  failed: ["failed"],
+  canceled: ["canceled"]
+};
+function validateAgentOperationResultTransition(input) {
+  if (input.previous !== void 0 && !OPERATION_RESULT_TRANSITIONS[input.previous.status].includes(
+    input.candidate.status
+  )) {
+    return throwAgentProviderContractError(
+      input.providerKey,
+      "invalid_operation_result",
+      "Provider returned an invalid operation lifecycle transition."
+    );
+  }
+  if (input.previous !== void 0 && ["completed", "failed", "canceled"].includes(input.previous.status) && JSON.stringify(input.previous) !== JSON.stringify(input.candidate)) {
+    return throwAgentProviderContractError(
+      input.providerKey,
+      "invalid_operation_result",
+      "Provider changed a terminal operation result."
+    );
+  }
+  return input.candidate;
+}
+const COLLABORATION_TRANSITIONS = {
+  queued: ["queued", "starting", "running", "waiting", "completed", "failed", "canceled"],
+  starting: ["starting", "running", "waiting", "completed", "failed", "canceled"],
+  running: ["running", "waiting", "completed", "failed", "canceled"],
+  waiting: ["waiting", "running", "completed", "failed", "canceled"],
+  completed: ["completed"],
+  failed: ["failed"],
+  canceled: ["canceled"]
+};
+function collaborationUsageIsMonotonic(previous, next) {
+  if (previous.kind === "unavailable") return true;
+  if (next.kind === "unavailable") return false;
+  const fields = [
+    "inputTokens",
+    "outputTokens",
+    "reasoningTokens",
+    "totalTokens",
+    "modelCalls"
+  ];
+  return fields.every(
+    (field) => previous[field] === void 0 || next[field] !== void 0 && next[field] >= previous[field]
+  );
+}
+function validateAgentCollaborationNodeForCapabilities(input) {
+  let node;
+  try {
+    node = parseAgentCollaborationNode(input.candidate);
+  } catch {
+    return throwAgentProviderContractError(
+      input.capabilities.providerKey,
+      "output_collaboration_mismatch",
+      "Provider returned an invalid collaboration node."
+    );
+  }
+  const capability = input.capabilities.collaboration;
+  if (capability.kind !== "supported" || !capability.roles.includes(node.role)) {
+    return throwAgentProviderContractError(
+      input.capabilities.providerKey,
+      "output_capability_mismatch",
+      "Provider returned collaboration state outside its declared capability."
+    );
+  }
+  if (input.previous !== void 0 && !COLLABORATION_TRANSITIONS[input.previous.status].includes(node.status)) {
+    return throwAgentProviderContractError(
+      input.capabilities.providerKey,
+      "invalid_collaboration_transition",
+      "Provider returned an invalid collaboration lifecycle transition."
+    );
+  }
+  if (input.previous !== void 0 && Date.parse(node.updatedAt) === Date.parse(input.previous.updatedAt) && !isDeepStrictEqual(node, input.previous)) {
+    return throwAgentProviderContractError(
+      input.capabilities.providerKey,
+      "invalid_collaboration_transition",
+      "Provider changed collaboration state without advancing its observation timestamp."
+    );
+  }
+  if (input.previous !== void 0 && (node.collaborationId !== input.previous.collaborationId || node.rootCollaborationId !== input.previous.rootCollaborationId || node.parentCollaborationId !== input.previous.parentCollaborationId || node.role !== input.previous.role || node.title !== input.previous.title || node.objective !== input.previous.objective || node.createdAt !== input.previous.createdAt || Date.parse(node.updatedAt) < Date.parse(input.previous.updatedAt) || !collaborationUsageIsMonotonic(input.previous.usage, node.usage) || input.previous.terminalAt !== void 0 && node.terminalAt !== input.previous.terminalAt || input.previous.closedAt !== void 0 && node.closedAt !== input.previous.closedAt || input.previous.outcome !== void 0 && !isDeepStrictEqual(node.outcome, input.previous.outcome) || input.previous.artifactIds !== void 0 && !isDeepStrictEqual(node.artifactIds, input.previous.artifactIds) || input.previous.resourceIds !== void 0 && !isDeepStrictEqual(node.resourceIds, input.previous.resourceIds))) {
+    return throwAgentProviderContractError(
+      input.capabilities.providerKey,
+      "output_collaboration_mismatch",
+      "Provider changed immutable collaboration identity."
+    );
+  }
+  return node;
+}
+function validateAgentGeneratedResourceForCapabilities(input) {
+  let resource;
+  try {
+    resource = parseAgentGeneratedResourceDescriptor(input.candidate);
+  } catch {
+    return throwAgentProviderContractError(
+      input.capabilities.providerKey,
+      "output_resource_mismatch",
+      "Provider returned an invalid generated resource."
+    );
+  }
+  const capability = input.capabilities.generatedResources;
+  if (capability.kind !== "supported" || resource.resourceId !== input.expectedResourceId || !capability.resourceKinds.includes(resource.kind) || resource.byteSize !== void 0 && resource.byteSize > capability.maxBytesPerResource) {
+    return throwAgentProviderContractError(
+      input.capabilities.providerKey,
+      "output_resource_mismatch",
+      "Provider returned a generated resource outside its declared capability or correlation."
+    );
+  }
+  if (input.previous !== void 0) {
+    const transitions = {
+      pending: ["pending", "available", "unavailable", "expired"],
+      available: ["available", "expired"],
+      unavailable: ["unavailable", "expired"],
+      expired: ["expired"]
+    };
+    if (resource.kind !== input.previous.kind || resource.displayName !== input.previous.displayName || !isDeepStrictEqual(resource.producer, input.previous.producer) || resource.createdAt !== input.previous.createdAt || !transitions[input.previous.status].includes(resource.status) || input.previous.status !== "pending" && input.previous.status === resource.status && !isDeepStrictEqual(resource, input.previous)) {
+      return throwAgentProviderContractError(
+        input.capabilities.providerKey,
+        "output_resource_mismatch",
+        "Provider changed immutable resource identity or returned an invalid lifecycle transition."
+      );
+    }
+  }
+  return resource;
+}
+export {
+  validateAgentCollaborationNodeForCapabilities,
+  validateAgentConfigurationCatalogForCapabilities,
+  validateAgentGeneratedResourceForCapabilities,
+  validateAgentIntegrationCatalogForCapabilities,
+  validateAgentManagedContentCatalogForCapabilities,
+  validateAgentOperationCatalogForCapabilities,
+  validateAgentOperationResultForInvocation,
+  validateAgentOperationResultTransition
+};

package/dist/outputValidation.d.ts

@@ -1,4 +1,4 @@
-import { type AgentCapabilities, type AgentProviderKey, type AgentSessionId, type AgentTurnId } from "@agen-ai/agent-protocol";
+import { type AgentCapabilities, type AgentCollaborationId, type AgentGeneratedResourceId, type AgentOperationInvocationId, type AgentProviderKey, type AgentSessionId, type AgentTurnId } from "@agen-ai/agent-protocol";
 import { type AgentProviderOutput } from "./outputs.js";
 import type { AgentProviderOperationResult } from "./sessions.js";
 export interface AgentProviderOutputValidationContext {
@@ -7,6 +7,9 @@ export interface AgentProviderOutputValidationContext {
     readonly sessionId?: AgentSessionId;
     readonly turnId?: AgentTurnId;
     readonly authenticationAttemptId?: string;
+    readonly operationInvocationId?: AgentOperationInvocationId;
+    readonly collaborationId?: AgentCollaborationId;
+    readonly generatedResourceId?: AgentGeneratedResourceId;
 }
 export declare function validateAgentProviderOutputForContext(candidate: AgentProviderOutput, context: AgentProviderOutputValidationContext): AgentProviderOutput;
 export declare function validateAgentProviderOperationResult(candidate: AgentProviderOperationResult, context: AgentProviderOutputValidationContext): AgentProviderOperationResult;

package/dist/outputValidation.js

@@ -17,9 +17,9 @@ function isItemKindCapabilitySupported(capabilities, itemKind) {
     case "file_change":
       return capabilities.output.fileChanges === "structured";
     case "mcp_tool_call":
-      return capabilities.interactionExtensions.mcp;
+      return capabilities.integrations.kind === "supported";
     case "collaboration_tool_call":
-      return capabilities.interactionExtensions.subagents;
+      return capabilities.collaboration.kind === "supported";
     case "user_message":
     case "assistant_message":
     case "reasoning":
@@ -102,9 +102,20 @@ function isEventCapabilitySupported(capabilities, event) {
       return capabilities.output.artifactKinds.includes(
         event.payload.artifact.kind
       );
+    case "operation.updated":
+      return capabilities.operations.kind === "supported";
+    case "collaboration.updated":
+      return capabilities.collaboration.kind === "supported" && capabilities.collaboration.roles.includes(event.payload.node.role);
+    case "resource.updated":
+      return capabilities.generatedResources.kind === "supported" && capabilities.generatedResources.resourceKinds.includes(
+        event.payload.resource.kind
+      ) && (event.payload.resource.byteSize === void 0 || event.payload.resource.byteSize <= capabilities.generatedResources.maxBytesPerResource);
     case "request.opened":
-      return event.payload.request.requestKind === "approval" ? isApprovalRequestCapabilitySupported(capabilities, event) : capabilities.requests.elicitation.kind === "structured" || capabilities.requests.elicitation.kind === "text" && event.payload.request.fields.every(
-        (field) => field.kind === "text"
+      if (event.payload.request.requestKind === "approval") {
+        return isApprovalRequestCapabilitySupported(capabilities, event);
+      }
+      return capabilities.requests.elicitation.kind === "supported" && event.payload.request.fields.length <= capabilities.requests.elicitation.maxFields && event.payload.request.fields.every(
+        (field) => capabilities.requests.elicitation.kind === "supported" && capabilities.requests.elicitation.fieldKinds.includes(field.kind) && (field.sensitivity === "ordinary" || capabilities.requests.elicitation.sensitiveFields)
       );
     case "context.usage.updated":
       return isContextUsageCapabilitySupported(capabilities, event);
@@ -139,6 +150,33 @@ function assertOutputCapability(context, output) {
       `Provider ${context.providerKey} emitted ${output.event.type} without advertising support.`
     );
   }
+  if (output.kind === "event" && output.event.type === "operation.updated") {
+    if (context.operationInvocationId !== void 0 && output.event.payload.result.invocationId !== context.operationInvocationId) {
+      throwAgentProviderContractError(
+        context.providerKey,
+        "output_operation_mismatch",
+        `Provider ${context.providerKey} emitted an update for another operation invocation.`
+      );
+    }
+  }
+  if (output.kind === "event" && output.event.type === "collaboration.updated") {
+    if (context.collaborationId !== void 0 && output.event.payload.node.collaborationId !== context.collaborationId) {
+      throwAgentProviderContractError(
+        context.providerKey,
+        "output_collaboration_mismatch",
+        `Provider ${context.providerKey} emitted an update for another collaboration.`
+      );
+    }
+  }
+  if (output.kind === "event" && output.event.type === "resource.updated") {
+    if (context.generatedResourceId !== void 0 && output.event.payload.resource.resourceId !== context.generatedResourceId) {
+      throwAgentProviderContractError(
+        context.providerKey,
+        "output_resource_mismatch",
+        `Provider ${context.providerKey} emitted an update for another generated resource.`
+      );
+    }
+  }
 }
 function validateAgentProviderOutputForContext(candidate, context) {
   const output = validateAgentProviderOutput(candidate);