@agen-ai/agent-protocol 0.2.4 → 0.3.0

package/dist/zod/integrations.d.ts

@@ -1,24 +1,24 @@
 import { z } from 'zod/v4';
-import { type AgentIntegrationCatalog, type AgentIntegrationDescriptor } from '../integrations/types.js';
-declare const AgentIntegrationDescriptorPortableSchema: z.ZodReadonly<z.ZodObject<{
+import { type AgentIntegrationCatalog, type AgentIntegrationDescriptor, type AgentMcpIntegrationDescriptor } from '../integrations/types.js';
+declare const AgentIntegrationDescriptorPortableSchema: z.ZodDiscriminatedUnion<[z.ZodReadonly<z.ZodObject<{
     integrationId: z.ZodType<import("../index.js").AgentIntegrationId, unknown, z.core.$ZodTypeInternals<import("../index.js").AgentIntegrationId, unknown>>;
     revision: z.ZodNumber;
     kind: z.ZodLiteral<"mcp">;
     name: z.ZodString;
     status: z.ZodEnum<{
+        unavailable: "unavailable";
         starting: "starting";
         ready: "ready";
         degraded: "degraded";
-        unavailable: "unavailable";
     }>;
     servers: z.ZodReadonly<z.ZodArray<z.ZodReadonly<z.ZodObject<{
         serverId: z.ZodType<import("../index.js").AgentIntegrationServerId, unknown, z.core.$ZodTypeInternals<import("../index.js").AgentIntegrationServerId, unknown>>;
         name: z.ZodString;
         status: z.ZodEnum<{
+            unavailable: "unavailable";
             starting: "starting";
             ready: "ready";
             degraded: "degraded";
-            unavailable: "unavailable";
         }>;
         tools: z.ZodReadonly<z.ZodArray<z.ZodReadonly<z.ZodObject<{
             toolId: z.ZodType<import("../index.js").AgentIntegrationToolId, unknown, z.core.$ZodTypeInternals<import("../index.js").AgentIntegrationToolId, unknown>>;
@@ -32,30 +32,53 @@ declare const AgentIntegrationDescriptorPortableSchema: z.ZodReadonly<z.ZodObjec
             mediaType: z.ZodOptional<z.ZodString>;
         }, z.core.$strict>>>>;
     }, z.core.$strict>>>>;
-}, z.core.$strict>>;
+}, z.core.$strict>>, z.ZodReadonly<z.ZodObject<{
+    integrationId: z.ZodType<import("../index.js").AgentIntegrationId, unknown, z.core.$ZodTypeInternals<import("../index.js").AgentIntegrationId, unknown>>;
+    revision: z.ZodNumber;
+    kind: z.ZodLiteral<"connector">;
+    name: z.ZodString;
+    description: z.ZodOptional<z.ZodString>;
+    source: z.ZodType<import("../index.js").AgentEnvironmentSource, unknown, z.core.$ZodTypeInternals<import("../index.js").AgentEnvironmentSource, unknown>>;
+    installation: z.ZodType<import("../index.js").AgentAvailabilityFact, unknown, z.core.$ZodTypeInternals<import("../index.js").AgentAvailabilityFact, unknown>>;
+    enablement: z.ZodType<import("../index.js").AgentAvailabilityFact, unknown, z.core.$ZodTypeInternals<import("../index.js").AgentAvailabilityFact, unknown>>;
+    authentication: z.ZodType<import("../index.js").AgentAvailabilityFact, unknown, z.core.$ZodTypeInternals<import("../index.js").AgentAvailabilityFact, unknown>>;
+    health: z.ZodEnum<{
+        unavailable: "unavailable";
+        starting: "starting";
+        ready: "ready";
+        degraded: "degraded";
+    }>;
+    callability: z.ZodType<import("../index.js").AgentAvailabilityFact, unknown, z.core.$ZodTypeInternals<import("../index.js").AgentAvailabilityFact, unknown>>;
+    tools: z.ZodOptional<z.ZodReadonly<z.ZodArray<z.ZodReadonly<z.ZodObject<{
+        toolId: z.ZodType<import("../index.js").AgentIntegrationToolId, unknown, z.core.$ZodTypeInternals<import("../index.js").AgentIntegrationToolId, unknown>>;
+        name: z.ZodString;
+        description: z.ZodOptional<z.ZodString>;
+    }, z.core.$strict>>>>>;
+}, z.core.$strict>>], "kind">;
 export declare const AgentIntegrationDescriptorSchema: z.ZodType<AgentIntegrationDescriptor>;
+export declare const AgentMcpIntegrationDescriptorSchema: z.ZodType<AgentMcpIntegrationDescriptor>;
 export declare const AgentIntegrationCatalogPortableSchema: z.ZodReadonly<z.ZodObject<{
     revision: z.ZodNumber;
     observedAt: z.ZodType<import("../index.js").AgentIsoDateTime, unknown, z.core.$ZodTypeInternals<import("../index.js").AgentIsoDateTime, unknown>>;
-    integrations: z.ZodReadonly<z.ZodArray<z.ZodReadonly<z.ZodObject<{
+    integrations: z.ZodReadonly<z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodReadonly<z.ZodObject<{
         integrationId: z.ZodType<import("../index.js").AgentIntegrationId, unknown, z.core.$ZodTypeInternals<import("../index.js").AgentIntegrationId, unknown>>;
         revision: z.ZodNumber;
         kind: z.ZodLiteral<"mcp">;
         name: z.ZodString;
         status: z.ZodEnum<{
+            unavailable: "unavailable";
             starting: "starting";
             ready: "ready";
             degraded: "degraded";
-            unavailable: "unavailable";
         }>;
         servers: z.ZodReadonly<z.ZodArray<z.ZodReadonly<z.ZodObject<{
             serverId: z.ZodType<import("../index.js").AgentIntegrationServerId, unknown, z.core.$ZodTypeInternals<import("../index.js").AgentIntegrationServerId, unknown>>;
             name: z.ZodString;
             status: z.ZodEnum<{
+                unavailable: "unavailable";
                 starting: "starting";
                 ready: "ready";
                 degraded: "degraded";
-                unavailable: "unavailable";
             }>;
             tools: z.ZodReadonly<z.ZodArray<z.ZodReadonly<z.ZodObject<{
                 toolId: z.ZodType<import("../index.js").AgentIntegrationToolId, unknown, z.core.$ZodTypeInternals<import("../index.js").AgentIntegrationToolId, unknown>>;
@@ -69,7 +92,29 @@ export declare const AgentIntegrationCatalogPortableSchema: z.ZodReadonly<z.ZodO
                 mediaType: z.ZodOptional<z.ZodString>;
             }, z.core.$strict>>>>;
         }, z.core.$strict>>>>;
-    }, z.core.$strict>>>>;
+    }, z.core.$strict>>, z.ZodReadonly<z.ZodObject<{
+        integrationId: z.ZodType<import("../index.js").AgentIntegrationId, unknown, z.core.$ZodTypeInternals<import("../index.js").AgentIntegrationId, unknown>>;
+        revision: z.ZodNumber;
+        kind: z.ZodLiteral<"connector">;
+        name: z.ZodString;
+        description: z.ZodOptional<z.ZodString>;
+        source: z.ZodType<import("../index.js").AgentEnvironmentSource, unknown, z.core.$ZodTypeInternals<import("../index.js").AgentEnvironmentSource, unknown>>;
+        installation: z.ZodType<import("../index.js").AgentAvailabilityFact, unknown, z.core.$ZodTypeInternals<import("../index.js").AgentAvailabilityFact, unknown>>;
+        enablement: z.ZodType<import("../index.js").AgentAvailabilityFact, unknown, z.core.$ZodTypeInternals<import("../index.js").AgentAvailabilityFact, unknown>>;
+        authentication: z.ZodType<import("../index.js").AgentAvailabilityFact, unknown, z.core.$ZodTypeInternals<import("../index.js").AgentAvailabilityFact, unknown>>;
+        health: z.ZodEnum<{
+            unavailable: "unavailable";
+            starting: "starting";
+            ready: "ready";
+            degraded: "degraded";
+        }>;
+        callability: z.ZodType<import("../index.js").AgentAvailabilityFact, unknown, z.core.$ZodTypeInternals<import("../index.js").AgentAvailabilityFact, unknown>>;
+        tools: z.ZodOptional<z.ZodReadonly<z.ZodArray<z.ZodReadonly<z.ZodObject<{
+            toolId: z.ZodType<import("../index.js").AgentIntegrationToolId, unknown, z.core.$ZodTypeInternals<import("../index.js").AgentIntegrationToolId, unknown>>;
+            name: z.ZodString;
+            description: z.ZodOptional<z.ZodString>;
+        }, z.core.$strict>>>>>;
+    }, z.core.$strict>>], "kind">>>;
 }, z.core.$strict>>;
 export declare const AgentIntegrationCatalogSchema: z.ZodType<AgentIntegrationCatalog>;
 export { AgentIntegrationDescriptorPortableSchema };

package/dist/zod/integrations.js

@@ -1,7 +1,11 @@
 import { z } from "zod/v4";
+import { AgentAvailabilityFactSchema, AgentEnvironmentSourceSchema } from "./environmentFacts.js";
+import { agentProtocolSerializedJsonBytes } from "../foundation/types.js";
 import { compareStringsByUnicodeCodePoint } from "../foundation/ordering.js";
 import {
   AGENT_INTEGRATION_DESCRIPTION_MAX_LENGTH,
+  AGENT_INTEGRATION_CONTRIBUTIONS_MAX_LENGTH,
+  AGENT_INTEGRATION_CATALOG_BYTES_LIMIT,
   AGENT_INTEGRATION_CATALOG_MAX_LENGTH,
   AGENT_INTEGRATION_NAME_MAX_LENGTH,
   AGENT_INTEGRATION_RESOURCES_MAX_LENGTH,
@@ -15,7 +19,8 @@ import {
   AgentIntegrationServerIdSchema,
   AgentIntegrationToolIdSchema,
   AgentIsoDateTimeSchema,
-  createAgentCanonicalNonBlankStringSchema
+  createAgentCanonicalNonBlankStringSchema,
+  withAcyclicProtocolInput
 } from "./foundation.js";
 const PositiveSafeIntegerSchema = z.number().int().positive().max(Number.MAX_SAFE_INTEGER);
 const NameSchema = createAgentCanonicalNonBlankStringSchema(AGENT_INTEGRATION_NAME_MAX_LENGTH);
@@ -53,7 +58,7 @@ function addOrderedUniqueIssues(values, path, label, context) {
     seen.add(value);
   });
 }
-const AgentIntegrationDescriptorPortableSchema = z.object({
+const McpIntegrationSchema = z.object({
   integrationId: AgentIntegrationIdSchema,
   revision: PositiveSafeIntegerSchema,
   kind: z.literal("mcp"),
@@ -61,19 +66,56 @@ const AgentIntegrationDescriptorPortableSchema = z.object({
   status: z.enum(AGENT_INTEGRATION_STATUSES),
   servers: z.array(ServerSchema).max(AGENT_INTEGRATION_SERVERS_MAX_LENGTH).readonly()
 }).strict().readonly();
-const AgentIntegrationDescriptorSchema = AgentIntegrationDescriptorPortableSchema.superRefine((integration, context) => {
+const ConnectorIntegrationSchema = z.object({
+  integrationId: AgentIntegrationIdSchema,
+  revision: PositiveSafeIntegerSchema,
+  kind: z.literal("connector"),
+  name: NameSchema,
+  description: DescriptionSchema.optional(),
+  source: AgentEnvironmentSourceSchema,
+  installation: AgentAvailabilityFactSchema,
+  enablement: AgentAvailabilityFactSchema,
+  authentication: AgentAvailabilityFactSchema,
+  health: z.enum(AGENT_INTEGRATION_STATUSES),
+  callability: AgentAvailabilityFactSchema,
+  tools: z.array(ToolSchema).max(AGENT_INTEGRATION_TOOLS_MAX_LENGTH).readonly().optional()
+}).strict().readonly();
+const AgentIntegrationDescriptorPortableSchema = z.discriminatedUnion("kind", [
+  McpIntegrationSchema,
+  ConnectorIntegrationSchema
+]);
+function validateIntegrationDescriptor(integration, context) {
+  if (integration.kind === "connector") {
+    addOrderedUniqueIssues((integration.tools ?? []).map((tool) => tool.toolId), ["tools"], "Connector tool IDs", context);
+    if (integration.callability.kind === "known" && integration.callability.value && [integration.installation, integration.enablement, integration.authentication].some((fact) => fact.kind === "known" && !fact.value)) {
+      context.addIssue({ code: "custom", path: ["callability"], message: "A connector cannot be callable when installation, enablement or authentication is denied." });
+    }
+    return;
+  }
   addOrderedUniqueIssues(integration.servers.map((server) => server.serverId), ["servers"], "Integration server IDs", context);
   integration.servers.forEach((server, serverIndex) => {
     addOrderedUniqueIssues(server.tools.map((tool) => tool.toolId), ["servers", serverIndex, "tools"], "Integration tool IDs", context);
     addOrderedUniqueIssues(server.resources.map((resource) => resource.resourceId), ["servers", serverIndex, "resources"], "Integration resource IDs", context);
   });
-});
+}
+const AgentIntegrationDescriptorSchema = AgentIntegrationDescriptorPortableSchema.superRefine(validateIntegrationDescriptor);
+const AgentMcpIntegrationDescriptorSchema = McpIntegrationSchema.superRefine(validateIntegrationDescriptor);
 const AgentIntegrationCatalogPortableSchema = z.object({
   revision: PositiveSafeIntegerSchema,
   observedAt: AgentIsoDateTimeSchema,
   integrations: z.array(AgentIntegrationDescriptorPortableSchema).max(AGENT_INTEGRATION_CATALOG_MAX_LENGTH).readonly()
 }).strict().readonly();
-const AgentIntegrationCatalogSchema = AgentIntegrationCatalogPortableSchema.superRefine((catalog, context) => {
+const AgentIntegrationCatalogSchema = withAcyclicProtocolInput(AgentIntegrationCatalogPortableSchema, {
+  maxDepth: 16,
+  maxCollectionLength: AGENT_INTEGRATION_CONTRIBUTIONS_MAX_LENGTH
+}).superRefine((catalog, context) => {
+  const contributions = catalog.integrations.reduce((count, integration) => count + (integration.kind === "mcp" ? integration.servers.reduce((total, server) => total + server.tools.length + server.resources.length, 0) : integration.tools?.length ?? 0), 0);
+  if (contributions > AGENT_INTEGRATION_CONTRIBUTIONS_MAX_LENGTH) {
+    context.addIssue({ code: "custom", path: ["integrations"], message: "Integration contributions exceed the aggregate limit." });
+  }
+  if (agentProtocolSerializedJsonBytes(catalog) > AGENT_INTEGRATION_CATALOG_BYTES_LIMIT) {
+    context.addIssue({ code: "custom", message: "Integration catalog exceeds its serialized UTF-8 byte limit." });
+  }
   addOrderedUniqueIssues(catalog.integrations.map((integration) => integration.integrationId), ["integrations"], "Integration IDs", context);
   catalog.integrations.forEach((integration, integrationIndex) => {
     const parsed = AgentIntegrationDescriptorSchema.safeParse(integration);
@@ -88,5 +130,6 @@ export {
   AgentIntegrationCatalogPortableSchema,
   AgentIntegrationCatalogSchema,
   AgentIntegrationDescriptorPortableSchema,
-  AgentIntegrationDescriptorSchema
+  AgentIntegrationDescriptorSchema,
+  AgentMcpIntegrationDescriptorSchema
 };

package/dist/zod/resources.d.ts

@@ -8,10 +8,10 @@ export declare const AgentGeneratedResourceDescriptorPortableSchema: z.ZodReadon
         archive: "archive";
     }>;
     status: z.ZodEnum<{
+        unavailable: "unavailable";
+        available: "available";
         pending: "pending";
         expired: "expired";
-        available: "available";
-        unavailable: "unavailable";
     }>;
     displayName: z.ZodString;
     producer: z.ZodDiscriminatedUnion<[z.ZodReadonly<z.ZodObject<{

package/dist/zod/turns.d.ts

@@ -36,6 +36,15 @@ export declare const AgentImageInputSourceSchema: z.ZodDiscriminatedUnion<[z.Zod
     path: z.ZodString;
     sha256: z.ZodString;
 }, z.core.$strict>>], "type">;
+export declare const AgentContentReferenceInputPartSchema: z.ZodReadonly<z.ZodObject<{
+    type: z.ZodLiteral<"content_reference">;
+    environmentId: z.ZodType<import("../index.js").AgentEnvironmentId, unknown, z.core.$ZodTypeInternals<import("../index.js").AgentEnvironmentId, unknown>>;
+    environmentRevision: z.ZodNumber;
+    contentCatalogRevision: z.ZodNumber;
+    contentId: z.ZodType<import("../index.js").AgentEffectiveContentId, unknown, z.core.$ZodTypeInternals<import("../index.js").AgentEffectiveContentId, unknown>>;
+    contentRevision: z.ZodNumber;
+    arguments: z.ZodOptional<z.ZodString>;
+}, z.core.$strict>>;
 export declare const AgentTurnInputPartSchema: z.ZodDiscriminatedUnion<[z.ZodReadonly<z.ZodObject<{
     type: z.ZodLiteral<"text">;
     text: z.ZodString;
@@ -76,6 +85,14 @@ export declare const AgentTurnInputPartSchema: z.ZodDiscriminatedUnion<[z.ZodRea
         path: z.ZodString;
         sha256: z.ZodString;
     }, z.core.$strict>>], "type">;
+}, z.core.$strict>>, z.ZodReadonly<z.ZodObject<{
+    type: z.ZodLiteral<"content_reference">;
+    environmentId: z.ZodType<import("../index.js").AgentEnvironmentId, unknown, z.core.$ZodTypeInternals<import("../index.js").AgentEnvironmentId, unknown>>;
+    environmentRevision: z.ZodNumber;
+    contentCatalogRevision: z.ZodNumber;
+    contentId: z.ZodType<import("../index.js").AgentEffectiveContentId, unknown, z.core.$ZodTypeInternals<import("../index.js").AgentEffectiveContentId, unknown>>;
+    contentRevision: z.ZodNumber;
+    arguments: z.ZodOptional<z.ZodString>;
 }, z.core.$strict>>], "type">;
 export declare const AgentTurnInteractionModeSchema: z.ZodEnum<{
     default: "default";
@@ -126,6 +143,14 @@ export declare const AgentTurnInputContentCompositionSchema: z.ZodObject<{
             path: z.ZodString;
             sha256: z.ZodString;
         }, z.core.$strict>>], "type">;
+    }, z.core.$strict>>, z.ZodReadonly<z.ZodObject<{
+        type: z.ZodLiteral<"content_reference">;
+        environmentId: z.ZodType<import("../index.js").AgentEnvironmentId, unknown, z.core.$ZodTypeInternals<import("../index.js").AgentEnvironmentId, unknown>>;
+        environmentRevision: z.ZodNumber;
+        contentCatalogRevision: z.ZodNumber;
+        contentId: z.ZodType<import("../index.js").AgentEffectiveContentId, unknown, z.core.$ZodTypeInternals<import("../index.js").AgentEffectiveContentId, unknown>>;
+        contentRevision: z.ZodNumber;
+        arguments: z.ZodOptional<z.ZodString>;
     }, z.core.$strict>>], "type">>>;
     summary: z.ZodOptional<z.ZodString>;
 }, z.core.$strict>;
@@ -172,6 +197,14 @@ export declare const AgentTurnRunInputPortableSchema: z.ZodReadonly<z.ZodObject<
             path: z.ZodString;
             sha256: z.ZodString;
         }, z.core.$strict>>], "type">;
+    }, z.core.$strict>>, z.ZodReadonly<z.ZodObject<{
+        type: z.ZodLiteral<"content_reference">;
+        environmentId: z.ZodType<import("../index.js").AgentEnvironmentId, unknown, z.core.$ZodTypeInternals<import("../index.js").AgentEnvironmentId, unknown>>;
+        environmentRevision: z.ZodNumber;
+        contentCatalogRevision: z.ZodNumber;
+        contentId: z.ZodType<import("../index.js").AgentEffectiveContentId, unknown, z.core.$ZodTypeInternals<import("../index.js").AgentEffectiveContentId, unknown>>;
+        contentRevision: z.ZodNumber;
+        arguments: z.ZodOptional<z.ZodString>;
     }, z.core.$strict>>], "type">>>;
     summary: z.ZodOptional<z.ZodString>;
     turnId: z.ZodType<import("../index.js").AgentTurnId, unknown, z.core.$ZodTypeInternals<import("../index.js").AgentTurnId, unknown>>;

package/dist/zod/turns.js

@@ -9,6 +9,8 @@ import {
 import { compareStringsByUnicodeCodePoint } from "../foundation/ordering.js";
 import {
   AGENT_CONTENT_STREAM_KINDS,
+  AGENT_CONTENT_REFERENCES_MAX_LENGTH,
+  AGENT_CONTENT_REFERENCE_ARGUMENT_BYTES_LIMIT,
   AGENT_CONTEXT_COMPACTION_DURATION_MAX_MILLISECONDS,
   AGENT_CONTEXT_COMPACTION_SUMMARY_PREVIEW_MAX_LENGTH,
   AGENT_CONTEXT_COMPACTION_TRIGGERS,
@@ -20,6 +22,8 @@ import {
 import {
   AgentCanonicalIdValueSchema,
   AgentErrorSchema,
+  AgentEnvironmentIdSchema,
+  AgentEffectiveContentIdSchema,
   AgentIsoDateTimeSchema,
   AgentItemIdSchema,
   AgentTurnIdSchema,
@@ -76,9 +80,24 @@ const AgentImageInputPartSchema = z.object({
   type: z.literal("image"),
   source: AgentImageInputSourceSchema
 }).strict().readonly();
+const ContentReferenceRevisionSchema = z.number().int().positive().max(Number.MAX_SAFE_INTEGER);
+const AgentContentReferenceInputPartSchema = z.object({
+  type: z.literal("content_reference"),
+  environmentId: AgentEnvironmentIdSchema,
+  environmentRevision: ContentReferenceRevisionSchema,
+  contentCatalogRevision: ContentReferenceRevisionSchema,
+  contentId: AgentEffectiveContentIdSchema,
+  contentRevision: ContentReferenceRevisionSchema,
+  arguments: z.string().max(AGENT_CONTENT_REFERENCE_ARGUMENT_BYTES_LIMIT).optional()
+}).strict().superRefine((part, context) => {
+  if (part.arguments !== void 0 && new TextEncoder().encode(part.arguments).byteLength > AGENT_CONTENT_REFERENCE_ARGUMENT_BYTES_LIMIT) {
+    context.addIssue({ code: "custom", path: ["arguments"], message: "Content reference arguments exceed their UTF-8 byte limit." });
+  }
+}).readonly();
 const AgentTurnInputPartSchema = z.discriminatedUnion("type", [
   AgentTextInputPartSchema,
-  AgentImageInputPartSchema
+  AgentImageInputPartSchema,
+  AgentContentReferenceInputPartSchema
 ]);
 const AgentTurnInteractionModeSchema = z.enum(
   AGENT_TURN_INTERACTION_MODES
@@ -89,6 +108,19 @@ const AgentTurnInputContentShape = {
 };
 const AgentTurnInputContentObjectSchema = z.object(AgentTurnInputContentShape).strict();
 const AgentTurnInputContentRefinedSchema = AgentTurnInputContentObjectSchema.superRefine((input, context) => {
+  const references = input.parts.filter((part) => part.type === "content_reference");
+  if (references.length > AGENT_CONTENT_REFERENCES_MAX_LENGTH) {
+    context.addIssue({ code: "custom", path: ["parts"], message: "Too many content references." });
+  }
+  const identities = /* @__PURE__ */ new Set();
+  input.parts.forEach((part, index) => {
+    if (part.type !== "content_reference") return;
+    const identity = JSON.stringify([part.environmentId, part.contentId]);
+    if (identities.has(identity)) {
+      context.addIssue({ code: "custom", path: ["parts", index], message: "Content references must be unique." });
+    }
+    identities.add(identity);
+  });
   const content = {
     parts: input.parts,
     ...input.summary === void 0 ? {} : { summary: input.summary }
@@ -408,6 +440,7 @@ export {
   AgentCollaborationToolCallDetailsSchema,
   AgentCommandExecutionDetailsSchema,
   AgentComputerActionDetailsSchema,
+  AgentContentReferenceInputPartSchema,
   AgentContentStreamKindSchema,
   AgentContextCompactionDetailsSchema,
   AgentDiffSummarySchema,

package/dist/zod/typeEquality.generated.d.ts

@@ -1,33 +1,67 @@
 import type { z } from 'zod/v4';
+import type { AgentAccountQuotaSnapshot, AgentAccountQuotaWindow } from '../accountQuota/types.js';
 import type { AgentArtifactDescriptor } from '../artifacts/types.js';
 import type { AgentCapabilities } from '../capabilities/types.js';
 import type { AgentCollaborationControlInput, AgentCollaborationNode, AgentCollaborationSpawnInput } from '../collaboration/types.js';
+import type { AgentCommandCatalog, AgentCommandDescriptor } from '../commands/types.js';
 import type { AgentConfigurationCatalog, AgentConfigurationSelectionInput } from '../configuration/types.js';
+import type { AgentEffectiveContentCatalog, AgentEffectiveContentDescriptor } from '../effectiveContent/types.js';
+import type { AgentEnvironmentCapability, AgentEnvironmentInvalidation, AgentEnvironmentSnapshot } from '../environment/types.js';
 import type { AgentEvent } from '../events/types.js';
+import type { AgentExtensionCatalog, AgentExtensionDescriptor } from '../extensions/types.js';
 import type { AgentError, AgentJsonValue, AgentProviderRefs } from '../foundation/types.js';
-import type { AgentIntegrationCatalog, AgentIntegrationDescriptor } from '../integrations/types.js';
+import type { AgentIntegrationCatalog, AgentIntegrationDescriptor, AgentMcpIntegrationDescriptor } from '../integrations/types.js';
 import type { AgentManagedContentCatalog, AgentManagedContentDescriptor } from '../managedContent/types.js';
 import type { AgentOperationCatalog, AgentOperationDescriptor, AgentOperationInvocation, AgentOperationResult } from '../operations/types.js';
 import type { AgentRequest, AgentRequestResolution } from '../requests/types.js';
 import type { AgentGeneratedResourceDescriptor } from '../resources/types.js';
 import type { AgentSessionBinding, AgentSessionConfiguration, AgentSessionOpenInput } from '../sessions/types.js';
-import type { AgentItemSnapshot, AgentTurnInputContent, AgentTurnInterruptionInput, AgentTurnRunInput } from '../turns/types.js';
+import type { AgentContentReferenceInputPart, AgentItemSnapshot, AgentTurnInputContent, AgentTurnInterruptionInput, AgentTurnRunInput } from '../turns/types.js';
+import { AgentAccountQuotaSnapshotSchema, AgentAccountQuotaWindowSchema } from './accountQuota.js';
 import { AgentArtifactDescriptorSchema } from './artifacts.js';
 import { AgentCapabilitiesSchema } from './capabilities.js';
 import { AgentCollaborationControlInputSchema, AgentCollaborationNodeSchema, AgentCollaborationSpawnInputSchema } from './collaboration.js';
+import { AgentCommandCatalogSchema, AgentCommandDescriptorSchema } from './commands.js';
 import { AgentConfigurationCatalogSchema, AgentConfigurationSelectionInputSchema } from './configuration.js';
+import { AgentEffectiveContentCatalogSchema, AgentEffectiveContentDescriptorSchema } from './effectiveContent.js';
+import { AgentEnvironmentCapabilitySchema, AgentEnvironmentInvalidationSchema, AgentEnvironmentSnapshotSchema } from './environment.js';
 import { AgentEventSchema } from './events.js';
+import { AgentExtensionCatalogSchema, AgentExtensionDescriptorSchema } from './extensions.js';
 import { AgentErrorSchema, AgentJsonValueSchema, AgentProviderRefsSchema } from './foundation.js';
-import { AgentIntegrationCatalogSchema, AgentIntegrationDescriptorSchema } from './integrations.js';
+import { AgentIntegrationCatalogSchema, AgentIntegrationDescriptorSchema, AgentMcpIntegrationDescriptorSchema } from './integrations.js';
 import { AgentManagedContentCatalogSchema, AgentManagedContentDescriptorSchema } from './managedContent.js';
 import { AgentOperationCatalogSchema, AgentOperationDescriptorSchema, AgentOperationInvocationSchema, AgentOperationResultSchema } from './operations.js';
 import { AgentRequestResolutionSchema, AgentRequestSchema } from './requests.js';
 import { AgentGeneratedResourceDescriptorSchema } from './resources.js';
 import { AgentSessionBindingSchema, AgentSessionConfigurationSchema, AgentSessionOpenInputSchema } from './sessions.js';
-import { AgentItemSnapshotSchema, AgentTurnInputContentSchema, AgentTurnInterruptionInputSchema, AgentTurnRunInputSchema } from './turns.js';
+import { AgentContentReferenceInputPartSchema, AgentItemSnapshotSchema, AgentTurnInputContentSchema, AgentTurnInterruptionInputSchema, AgentTurnRunInputSchema } from './turns.js';
 type Extends<Left, Right> = [Left] extends [Right] ? true : false;
 type Assert<Value extends true> = Value;
 export type AgentProtocolSchemaTypeAssertions = readonly [
+    Assert<Extends<z.output<typeof AgentEffectiveContentCatalogSchema>, AgentEffectiveContentCatalog>>,
+    Assert<Extends<AgentEffectiveContentCatalog, z.output<typeof AgentEffectiveContentCatalogSchema>>>,
+    Assert<Extends<z.output<typeof AgentEffectiveContentDescriptorSchema>, AgentEffectiveContentDescriptor>>,
+    Assert<Extends<AgentEffectiveContentDescriptor, z.output<typeof AgentEffectiveContentDescriptorSchema>>>,
+    Assert<Extends<z.output<typeof AgentCommandCatalogSchema>, AgentCommandCatalog>>,
+    Assert<Extends<AgentCommandCatalog, z.output<typeof AgentCommandCatalogSchema>>>,
+    Assert<Extends<z.output<typeof AgentCommandDescriptorSchema>, AgentCommandDescriptor>>,
+    Assert<Extends<AgentCommandDescriptor, z.output<typeof AgentCommandDescriptorSchema>>>,
+    Assert<Extends<z.output<typeof AgentExtensionCatalogSchema>, AgentExtensionCatalog>>,
+    Assert<Extends<AgentExtensionCatalog, z.output<typeof AgentExtensionCatalogSchema>>>,
+    Assert<Extends<z.output<typeof AgentExtensionDescriptorSchema>, AgentExtensionDescriptor>>,
+    Assert<Extends<AgentExtensionDescriptor, z.output<typeof AgentExtensionDescriptorSchema>>>,
+    Assert<Extends<z.output<typeof AgentEnvironmentSnapshotSchema>, AgentEnvironmentSnapshot>>,
+    Assert<Extends<AgentEnvironmentSnapshot, z.output<typeof AgentEnvironmentSnapshotSchema>>>,
+    Assert<Extends<z.output<typeof AgentEnvironmentInvalidationSchema>, AgentEnvironmentInvalidation>>,
+    Assert<Extends<AgentEnvironmentInvalidation, z.output<typeof AgentEnvironmentInvalidationSchema>>>,
+    Assert<Extends<z.output<typeof AgentEnvironmentCapabilitySchema>, AgentEnvironmentCapability>>,
+    Assert<Extends<AgentEnvironmentCapability, z.output<typeof AgentEnvironmentCapabilitySchema>>>,
+    Assert<Extends<z.output<typeof AgentContentReferenceInputPartSchema>, AgentContentReferenceInputPart>>,
+    Assert<Extends<AgentContentReferenceInputPart, z.output<typeof AgentContentReferenceInputPartSchema>>>,
+    Assert<Extends<z.output<typeof AgentAccountQuotaSnapshotSchema>, AgentAccountQuotaSnapshot>>,
+    Assert<Extends<AgentAccountQuotaSnapshot, z.output<typeof AgentAccountQuotaSnapshotSchema>>>,
+    Assert<Extends<z.output<typeof AgentAccountQuotaWindowSchema>, AgentAccountQuotaWindow>>,
+    Assert<Extends<AgentAccountQuotaWindow, z.output<typeof AgentAccountQuotaWindowSchema>>>,
     Assert<Extends<z.output<typeof AgentJsonValueSchema>, AgentJsonValue>>,
     Assert<Extends<AgentJsonValue, z.output<typeof AgentJsonValueSchema>>>,
     Assert<Extends<z.output<typeof AgentProviderRefsSchema>, AgentProviderRefs>>,
@@ -72,6 +106,8 @@ export type AgentProtocolSchemaTypeAssertions = readonly [
     Assert<Extends<AgentIntegrationCatalog, z.output<typeof AgentIntegrationCatalogSchema>>>,
     Assert<Extends<z.output<typeof AgentIntegrationDescriptorSchema>, AgentIntegrationDescriptor>>,
     Assert<Extends<AgentIntegrationDescriptor, z.output<typeof AgentIntegrationDescriptorSchema>>>,
+    Assert<Extends<z.output<typeof AgentMcpIntegrationDescriptorSchema>, AgentMcpIntegrationDescriptor>>,
+    Assert<Extends<AgentMcpIntegrationDescriptor, z.output<typeof AgentMcpIntegrationDescriptorSchema>>>,
     Assert<Extends<z.output<typeof AgentCollaborationNodeSchema>, AgentCollaborationNode>>,
     Assert<Extends<AgentCollaborationNode, z.output<typeof AgentCollaborationNodeSchema>>>,
     Assert<Extends<z.output<typeof AgentCollaborationSpawnInputSchema>, AgentCollaborationSpawnInput>>,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@agen-ai/agent-protocol",
-  "version": "0.2.4",
+  "version": "0.3.0",
   "private": false,
   "description": "Provider-neutral sessions, turns, requests, capabilities, artifacts, and events for coding-agent runtimes.",
   "type": "module",
@@ -76,11 +76,31 @@
       "types": "./dist/jsonSchema/index.d.ts",
       "import": "./dist/jsonSchema/index.js"
     },
-    "./package.json": "./package.json"
+    "./package.json": "./package.json",
+    "./account-quota": {
+      "types": "./dist/public/accountQuota.d.ts",
+      "import": "./dist/public/accountQuota.js"
+    },
+    "./effective-content": {
+      "types": "./dist/public/effectiveContent.d.ts",
+      "import": "./dist/public/effectiveContent.js"
+    },
+    "./commands": {
+      "types": "./dist/public/commands.d.ts",
+      "import": "./dist/public/commands.js"
+    },
+    "./extensions": {
+      "types": "./dist/public/extensions.d.ts",
+      "import": "./dist/public/extensions.js"
+    },
+    "./environment": {
+      "types": "./dist/public/environment.d.ts",
+      "import": "./dist/public/environment.js"
+    }
   },
   "dependencies": {
     "zod": "4.4.3",
-    "@agen-ai/validation": "^0.2.4"
+    "@agen-ai/validation": "^0.3.0"
   },
   "devDependencies": {
     "ajv": "8.17.1",