@agen-ai/agent-protocol 0.2.5 → 0.3.0

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/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

@@ -3,33 +3,61 @@ import type { AgentAccountQuotaSnapshot, AgentAccountQuotaWindow } from '../acco
 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>>,
@@ -78,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.5",
+  "version": "0.3.0",
   "private": false,
   "description": "Provider-neutral sessions, turns, requests, capabilities, artifacts, and events for coding-agent runtimes.",
   "type": "module",
@@ -80,11 +80,27 @@
     "./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.5"
+    "@agen-ai/validation": "^0.3.0"
   },
   "devDependencies": {
     "ajv": "8.17.1",