@agen-ai/agent-protocol 0.2.4 → 0.3.0

package/dist/environment/parsers.d.ts

@@ -0,0 +1,17 @@
+import type { AgentProtocolParseResult } from '../foundation/index.js';
+import type { AgentEnvironmentCapability, AgentEnvironmentContentResult, AgentEnvironmentCommandsResult, AgentEnvironmentExtensionsResult, AgentEnvironmentIntegrationsResult, AgentEnvironmentInvalidation, AgentEnvironmentSnapshot } from './types.js';
+export declare function parseAgentEnvironmentCapability(input: unknown): AgentEnvironmentCapability;
+export declare function safeParseAgentEnvironmentCapability(input: unknown): AgentProtocolParseResult<AgentEnvironmentCapability>;
+export declare function parseAgentEnvironmentContentResult(input: unknown): AgentEnvironmentContentResult;
+export declare function safeParseAgentEnvironmentContentResult(input: unknown): AgentProtocolParseResult<AgentEnvironmentContentResult>;
+export declare function parseAgentEnvironmentCommandsResult(input: unknown): AgentEnvironmentCommandsResult;
+export declare function safeParseAgentEnvironmentCommandsResult(input: unknown): AgentProtocolParseResult<AgentEnvironmentCommandsResult>;
+export declare function parseAgentEnvironmentExtensionsResult(input: unknown): AgentEnvironmentExtensionsResult;
+export declare function safeParseAgentEnvironmentExtensionsResult(input: unknown): AgentProtocolParseResult<AgentEnvironmentExtensionsResult>;
+export declare function parseAgentEnvironmentIntegrationsResult(input: unknown): AgentEnvironmentIntegrationsResult;
+export declare function safeParseAgentEnvironmentIntegrationsResult(input: unknown): AgentProtocolParseResult<AgentEnvironmentIntegrationsResult>;
+export declare function parseAgentEnvironmentInvalidation(input: unknown): AgentEnvironmentInvalidation;
+export declare function safeParseAgentEnvironmentInvalidation(input: unknown): AgentProtocolParseResult<AgentEnvironmentInvalidation>;
+export declare function parseAgentEnvironmentSnapshot(input: unknown): AgentEnvironmentSnapshot;
+export declare function safeParseAgentEnvironmentSnapshot(input: unknown): AgentProtocolParseResult<AgentEnvironmentSnapshot>;
+//# sourceMappingURL=parsers.d.ts.map

package/dist/environment/parsers.js

@@ -0,0 +1,68 @@
+import { parseWithSchema, safeParseWithSchema } from "../internal/parsers.js";
+import {
+  AgentEnvironmentCapabilitySchema,
+  AgentEnvironmentContentResultSchema,
+  AgentEnvironmentCommandsResultSchema,
+  AgentEnvironmentExtensionsResultSchema,
+  AgentEnvironmentIntegrationsResultSchema,
+  AgentEnvironmentInvalidationSchema,
+  AgentEnvironmentSnapshotSchema
+} from "../zod/environment.js";
+function parseAgentEnvironmentCapability(input) {
+  return parseWithSchema(AgentEnvironmentCapabilitySchema, input);
+}
+function safeParseAgentEnvironmentCapability(input) {
+  return safeParseWithSchema(AgentEnvironmentCapabilitySchema, input);
+}
+function parseAgentEnvironmentContentResult(input) {
+  return parseWithSchema(AgentEnvironmentContentResultSchema, input);
+}
+function safeParseAgentEnvironmentContentResult(input) {
+  return safeParseWithSchema(AgentEnvironmentContentResultSchema, input);
+}
+function parseAgentEnvironmentCommandsResult(input) {
+  return parseWithSchema(AgentEnvironmentCommandsResultSchema, input);
+}
+function safeParseAgentEnvironmentCommandsResult(input) {
+  return safeParseWithSchema(AgentEnvironmentCommandsResultSchema, input);
+}
+function parseAgentEnvironmentExtensionsResult(input) {
+  return parseWithSchema(AgentEnvironmentExtensionsResultSchema, input);
+}
+function safeParseAgentEnvironmentExtensionsResult(input) {
+  return safeParseWithSchema(AgentEnvironmentExtensionsResultSchema, input);
+}
+function parseAgentEnvironmentIntegrationsResult(input) {
+  return parseWithSchema(AgentEnvironmentIntegrationsResultSchema, input);
+}
+function safeParseAgentEnvironmentIntegrationsResult(input) {
+  return safeParseWithSchema(AgentEnvironmentIntegrationsResultSchema, input);
+}
+function parseAgentEnvironmentInvalidation(input) {
+  return parseWithSchema(AgentEnvironmentInvalidationSchema, input);
+}
+function safeParseAgentEnvironmentInvalidation(input) {
+  return safeParseWithSchema(AgentEnvironmentInvalidationSchema, input);
+}
+function parseAgentEnvironmentSnapshot(input) {
+  return parseWithSchema(AgentEnvironmentSnapshotSchema, input);
+}
+function safeParseAgentEnvironmentSnapshot(input) {
+  return safeParseWithSchema(AgentEnvironmentSnapshotSchema, input);
+}
+export {
+  parseAgentEnvironmentCapability,
+  parseAgentEnvironmentCommandsResult,
+  parseAgentEnvironmentContentResult,
+  parseAgentEnvironmentExtensionsResult,
+  parseAgentEnvironmentIntegrationsResult,
+  parseAgentEnvironmentInvalidation,
+  parseAgentEnvironmentSnapshot,
+  safeParseAgentEnvironmentCapability,
+  safeParseAgentEnvironmentCommandsResult,
+  safeParseAgentEnvironmentContentResult,
+  safeParseAgentEnvironmentExtensionsResult,
+  safeParseAgentEnvironmentIntegrationsResult,
+  safeParseAgentEnvironmentInvalidation,
+  safeParseAgentEnvironmentSnapshot
+};

package/dist/environment/types.d.ts

@@ -0,0 +1,61 @@
+import type { AgentCommandCatalog } from '../commands/index.js';
+import type { AgentEffectiveContentCatalog } from '../effectiveContent/index.js';
+import type { AgentExtensionCatalog } from '../extensions/index.js';
+import type { AgentIntegrationCatalog } from '../integrations/index.js';
+import type { AgentEnvironmentId } from '../foundation/index.js';
+import type { AgentEnvironmentReason } from './facts.js';
+export declare const AGENT_ENVIRONMENT_SCHEMA_VERSION: 1;
+export declare const AGENT_ENVIRONMENT_DOMAINS: readonly ["content", "commands", "extensions", "integrations"];
+export declare const AGENT_ENVIRONMENT_EVIDENCE_EXTENTS: readonly ["workspace_discovery", "session"];
+export declare const AGENT_ENVIRONMENT_COMPLETENESSES: readonly ["complete", "partial"];
+export declare const AGENT_ENVIRONMENT_DOMAIN_CATALOG_BYTES_LIMIT: number;
+export declare const AGENT_ENVIRONMENT_SNAPSHOT_BYTES_LIMIT: number;
+export declare const AGENT_ENVIRONMENT_EFFECTIVE_ENTRIES_MAX_LENGTH = 1024;
+export declare const AGENT_ENVIRONMENT_INTEGRATION_CONTRIBUTIONS_MAX_LENGTH = 4096;
+export type AgentEnvironmentDomain = (typeof AGENT_ENVIRONMENT_DOMAINS)[number];
+export type AgentEnvironmentEvidenceExtent = (typeof AGENT_ENVIRONMENT_EVIDENCE_EXTENTS)[number];
+export type AgentEnvironmentCompleteness = (typeof AGENT_ENVIRONMENT_COMPLETENESSES)[number];
+export type AgentEnvironmentAvailableDomainResult<Catalog> = Readonly<{
+    readonly kind: 'available';
+    readonly catalog: Catalog;
+    readonly extent: AgentEnvironmentEvidenceExtent;
+    readonly completeness: AgentEnvironmentCompleteness;
+    readonly reasons: readonly AgentEnvironmentReason[];
+}>;
+export type AgentEnvironmentUnavailableDomainResult = Readonly<{
+    readonly kind: 'unsupported' | 'not_initialized' | 'unavailable';
+    readonly reasons: readonly AgentEnvironmentReason[];
+}>;
+export type AgentEnvironmentDomainResult<Catalog> = AgentEnvironmentAvailableDomainResult<Catalog> | AgentEnvironmentUnavailableDomainResult;
+export type AgentEnvironmentContentResult = AgentEnvironmentDomainResult<AgentEffectiveContentCatalog>;
+export type AgentEnvironmentCommandsResult = AgentEnvironmentDomainResult<AgentCommandCatalog>;
+export type AgentEnvironmentExtensionsResult = AgentEnvironmentDomainResult<AgentExtensionCatalog>;
+export type AgentEnvironmentIntegrationsResult = AgentEnvironmentDomainResult<AgentIntegrationCatalog>;
+export interface AgentEnvironmentSnapshot {
+    readonly schemaVersion: typeof AGENT_ENVIRONMENT_SCHEMA_VERSION;
+    readonly environmentId: AgentEnvironmentId;
+    readonly revision: number;
+    readonly content: AgentEnvironmentContentResult;
+    readonly commands: AgentEnvironmentCommandsResult;
+    readonly extensions: AgentEnvironmentExtensionsResult;
+    readonly integrations: AgentEnvironmentIntegrationsResult;
+}
+export interface AgentEnvironmentInvalidation {
+    readonly environmentId: AgentEnvironmentId;
+    readonly domains: readonly AgentEnvironmentDomain[];
+}
+/** The serializable capability advertised by a provider instance or session. */
+export type AgentEnvironmentReadCapability = Readonly<{
+    readonly kind: 'unsupported';
+}> | Readonly<{
+    readonly kind: 'read';
+    readonly domains: readonly AgentEnvironmentDomain[];
+}> | Readonly<{
+    readonly kind: 'read_and_watch';
+    readonly domains: readonly AgentEnvironmentDomain[];
+}>;
+export interface AgentEnvironmentCapability {
+    readonly instance: AgentEnvironmentReadCapability;
+    readonly session: AgentEnvironmentReadCapability;
+}
+//# sourceMappingURL=types.d.ts.map

package/dist/environment/types.js

@@ -0,0 +1,26 @@
+const AGENT_ENVIRONMENT_SCHEMA_VERSION = 1;
+const AGENT_ENVIRONMENT_DOMAINS = [
+  "content",
+  "commands",
+  "extensions",
+  "integrations"
+];
+const AGENT_ENVIRONMENT_EVIDENCE_EXTENTS = [
+  "workspace_discovery",
+  "session"
+];
+const AGENT_ENVIRONMENT_COMPLETENESSES = ["complete", "partial"];
+const AGENT_ENVIRONMENT_DOMAIN_CATALOG_BYTES_LIMIT = 512 * 1024;
+const AGENT_ENVIRONMENT_SNAPSHOT_BYTES_LIMIT = 2 * 1024 * 1024;
+const AGENT_ENVIRONMENT_EFFECTIVE_ENTRIES_MAX_LENGTH = 1024;
+const AGENT_ENVIRONMENT_INTEGRATION_CONTRIBUTIONS_MAX_LENGTH = 4096;
+export {
+  AGENT_ENVIRONMENT_COMPLETENESSES,
+  AGENT_ENVIRONMENT_DOMAINS,
+  AGENT_ENVIRONMENT_DOMAIN_CATALOG_BYTES_LIMIT,
+  AGENT_ENVIRONMENT_EFFECTIVE_ENTRIES_MAX_LENGTH,
+  AGENT_ENVIRONMENT_EVIDENCE_EXTENTS,
+  AGENT_ENVIRONMENT_INTEGRATION_CONTRIBUTIONS_MAX_LENGTH,
+  AGENT_ENVIRONMENT_SCHEMA_VERSION,
+  AGENT_ENVIRONMENT_SNAPSHOT_BYTES_LIMIT
+};

package/dist/events/types.d.ts

@@ -8,7 +8,7 @@ import type { AgentContentStreamKind, AgentContextUsage, AgentDiffSummary, Agent
 export declare const AGENT_EVENT_TYPES: readonly ["turn.started", "turn.state_changed", "turn.completed", "item.started", "item.updated", "item.completed", "content.delta", "turn.plan.updated", "turn.plan.proposed", "turn.diff.updated", "request.opened", "progress.updated", "context.usage.updated", "artifact.referenced", "operation.updated", "collaboration.updated", "resource.updated", "runtime.warning", "runtime.error", "provider.diagnostic"];
 export type AgentEventType = (typeof AGENT_EVENT_TYPES)[number];
 interface AgentEventBase<Type extends AgentEventType, Payload> {
-    readonly protocolVersion: 8;
+    readonly protocolVersion: 9;
     readonly type: Type;
     readonly sessionId: AgentSessionId;
     readonly providerRefs?: AgentProviderRefs;

package/dist/extensions/index.d.ts

@@ -0,0 +1,3 @@
+export * from './types.js';
+export * from './parsers.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/extensions/index.js

@@ -0,0 +1,2 @@
+export * from "./types.js";
+export * from "./parsers.js";

package/dist/extensions/parsers.d.ts

@@ -0,0 +1,7 @@
+import type { AgentProtocolParseResult } from '../foundation/index.js';
+import type { AgentExtensionCatalog, AgentExtensionDescriptor } from './types.js';
+export declare function parseAgentExtensionDescriptor(input: unknown): AgentExtensionDescriptor;
+export declare function safeParseAgentExtensionDescriptor(input: unknown): AgentProtocolParseResult<AgentExtensionDescriptor>;
+export declare function parseAgentExtensionCatalog(input: unknown): AgentExtensionCatalog;
+export declare function safeParseAgentExtensionCatalog(input: unknown): AgentProtocolParseResult<AgentExtensionCatalog>;
+//# sourceMappingURL=parsers.d.ts.map

package/dist/extensions/parsers.js

@@ -0,0 +1,23 @@
+import { parseWithSchema, safeParseWithSchema } from "../internal/parsers.js";
+import {
+  AgentExtensionCatalogSchema,
+  AgentExtensionDescriptorSchema
+} from "../zod/extensions.js";
+function parseAgentExtensionDescriptor(input) {
+  return parseWithSchema(AgentExtensionDescriptorSchema, input);
+}
+function safeParseAgentExtensionDescriptor(input) {
+  return safeParseWithSchema(AgentExtensionDescriptorSchema, input);
+}
+function parseAgentExtensionCatalog(input) {
+  return parseWithSchema(AgentExtensionCatalogSchema, input);
+}
+function safeParseAgentExtensionCatalog(input) {
+  return safeParseWithSchema(AgentExtensionCatalogSchema, input);
+}
+export {
+  parseAgentExtensionCatalog,
+  parseAgentExtensionDescriptor,
+  safeParseAgentExtensionCatalog,
+  safeParseAgentExtensionDescriptor
+};

package/dist/extensions/types.d.ts

@@ -0,0 +1,73 @@
+import type { AgentCommandId, AgentEffectiveContentId, AgentExtensionId, AgentIntegrationId } from '../foundation/index.js';
+import type { AgentAvailabilityFact, AgentEnvironmentSource } from '../environment/facts.js';
+import type { AgentIsoDateTime } from '../foundation/index.js';
+export declare const AGENT_EXTENSION_COMPONENT_KINDS: readonly ["skill", "rule", "prompt", "agent_definition", "command", "mcp_server", "connector", "hook", "lsp_server", "scheduled_task", "other"];
+export declare const AGENT_EXTENSION_CATALOG_MAX_LENGTH = 256;
+export declare const AGENT_EXTENSION_COMPONENTS_MAX_LENGTH = 4096;
+export declare const AGENT_EXTENSION_CATALOG_BYTES_LIMIT: number;
+export declare const AGENT_EXTENSION_NAME_MAX_LENGTH = 200;
+export declare const AGENT_EXTENSION_SUMMARY_MAX_LENGTH = 2000;
+export declare const AGENT_EXTENSION_VERSION_MAX_LENGTH = 200;
+export declare const AGENT_EXTENSION_COMPONENT_NAME_MAX_LENGTH = 200;
+export type AgentExtensionComponentKind = (typeof AGENT_EXTENSION_COMPONENT_KINDS)[number];
+export type AgentExtensionContentComponentKind = 'skill' | 'rule' | 'prompt' | 'agent_definition';
+export type AgentExtensionContentComponentTarget = Readonly<{
+    readonly domain: 'content';
+    readonly id: AgentEffectiveContentId;
+    readonly revision: number;
+    readonly catalogRevision: number;
+}>;
+export type AgentExtensionCommandComponentTarget = Readonly<{
+    readonly domain: 'commands';
+    readonly id: AgentCommandId;
+    readonly revision: number;
+    readonly catalogRevision: number;
+}>;
+export type AgentExtensionIntegrationComponentTarget = Readonly<{
+    readonly domain: 'integrations';
+    readonly id: AgentIntegrationId;
+    readonly revision: number;
+    readonly catalogRevision: number;
+}>;
+export type AgentExtensionComponentTarget = AgentExtensionContentComponentTarget | AgentExtensionCommandComponentTarget | AgentExtensionIntegrationComponentTarget;
+export type AgentExtensionContentComponent = Readonly<{
+    readonly kind: AgentExtensionContentComponentKind;
+    readonly name: string;
+    readonly target?: AgentExtensionContentComponentTarget;
+}>;
+export type AgentExtensionCommandComponent = Readonly<{
+    readonly kind: 'command';
+    readonly name: string;
+    readonly target?: AgentExtensionCommandComponentTarget;
+}>;
+export type AgentExtensionIntegrationComponent = Readonly<{
+    readonly kind: 'mcp_server' | 'connector';
+    readonly name: string;
+    readonly target?: AgentExtensionIntegrationComponentTarget;
+}>;
+export type AgentExtensionDescriptiveComponent = Readonly<{
+    readonly kind: 'hook' | 'lsp_server' | 'scheduled_task' | 'other';
+    readonly name: string;
+}>;
+export type AgentExtensionComponent = AgentExtensionContentComponent | AgentExtensionCommandComponent | AgentExtensionIntegrationComponent | AgentExtensionDescriptiveComponent;
+export interface AgentExtensionDescriptor {
+    readonly extensionId: AgentExtensionId;
+    readonly revision: number;
+    readonly name: string;
+    readonly summary?: string;
+    /**
+     * Version text reported by the native harness. It is descriptive metadata;
+     * it is not an integrity or trust assertion.
+     */
+    readonly version?: string;
+    readonly installation: AgentAvailabilityFact;
+    readonly enablement: AgentAvailabilityFact;
+    readonly source: AgentEnvironmentSource;
+    readonly components: readonly AgentExtensionComponent[];
+}
+export interface AgentExtensionCatalog {
+    readonly revision: number;
+    readonly observedAt: AgentIsoDateTime;
+    readonly extensions: readonly AgentExtensionDescriptor[];
+}
+//# sourceMappingURL=types.d.ts.map

package/dist/extensions/types.js

@@ -0,0 +1,30 @@
+const AGENT_EXTENSION_COMPONENT_KINDS = [
+  "skill",
+  "rule",
+  "prompt",
+  "agent_definition",
+  "command",
+  "mcp_server",
+  "connector",
+  "hook",
+  "lsp_server",
+  "scheduled_task",
+  "other"
+];
+const AGENT_EXTENSION_CATALOG_MAX_LENGTH = 256;
+const AGENT_EXTENSION_COMPONENTS_MAX_LENGTH = 4096;
+const AGENT_EXTENSION_CATALOG_BYTES_LIMIT = 512 * 1024;
+const AGENT_EXTENSION_NAME_MAX_LENGTH = 200;
+const AGENT_EXTENSION_SUMMARY_MAX_LENGTH = 2e3;
+const AGENT_EXTENSION_VERSION_MAX_LENGTH = 200;
+const AGENT_EXTENSION_COMPONENT_NAME_MAX_LENGTH = 200;
+export {
+  AGENT_EXTENSION_CATALOG_BYTES_LIMIT,
+  AGENT_EXTENSION_CATALOG_MAX_LENGTH,
+  AGENT_EXTENSION_COMPONENTS_MAX_LENGTH,
+  AGENT_EXTENSION_COMPONENT_KINDS,
+  AGENT_EXTENSION_COMPONENT_NAME_MAX_LENGTH,
+  AGENT_EXTENSION_NAME_MAX_LENGTH,
+  AGENT_EXTENSION_SUMMARY_MAX_LENGTH,
+  AGENT_EXTENSION_VERSION_MAX_LENGTH
+};

package/dist/foundation/parsers.d.ts

@@ -1,4 +1,4 @@
-import type { AgentArtifactId, AgentApprovalOptionId, AgentCollaborationId, AgentConfigurationRevisionId, AgentError, AgentGeneratedResourceId, AgentInstanceId, AgentIntegrationId, AgentIntegrationResourceId, AgentIntegrationServerId, AgentIntegrationToolId, AgentIsoDateTime, AgentItemId, AgentJsonValue, AgentManagedContentId, AgentOperationId, AgentOperationInvocationId, AgentProviderConversationId, AgentProviderHistoryAnchor, AgentProviderItemRef, AgentProviderKey, AgentProviderRefs, AgentProviderRequestRef, AgentProviderTurnRef, AgentRequestFieldId, AgentRequestId, AgentSessionId, AgentTurnId } from './types.js';
+import type { AgentArtifactId, AgentApprovalOptionId, AgentCollaborationId, AgentConfigurationRevisionId, AgentError, AgentGeneratedResourceId, AgentInstanceId, AgentIntegrationId, AgentIntegrationResourceId, AgentIntegrationServerId, AgentIntegrationToolId, AgentIsoDateTime, AgentItemId, AgentJsonValue, AgentManagedContentId, AgentEnvironmentId, AgentEffectiveContentId, AgentCommandId, AgentExtensionId, AgentOperationId, AgentOperationInvocationId, AgentProviderConversationId, AgentProviderHistoryAnchor, AgentProviderItemRef, AgentProviderKey, AgentProviderRefs, AgentProviderRequestRef, AgentProviderTurnRef, AgentRequestFieldId, AgentRequestId, AgentSessionId, AgentTurnId } from './types.js';
 import type { AgentProtocolParseResult } from './validation.js';
 export declare const parseAgentInstanceId: (input: unknown) => AgentInstanceId;
 export declare const safeParseAgentInstanceId: (input: unknown) => AgentProtocolParseResult<AgentInstanceId>;
@@ -56,4 +56,12 @@ export declare function parseAgentProviderRefs(input: unknown): AgentProviderRef
 export declare function safeParseAgentProviderRefs(input: unknown): AgentProtocolParseResult<AgentProviderRefs>;
 export declare function parseAgentError(input: unknown): AgentError;
 export declare function safeParseAgentError(input: unknown): AgentProtocolParseResult<AgentError>;
+export declare const parseAgentEnvironmentId: (input: unknown) => AgentEnvironmentId;
+export declare const safeParseAgentEnvironmentId: (input: unknown) => AgentProtocolParseResult<AgentEnvironmentId>;
+export declare const parseAgentEffectiveContentId: (input: unknown) => AgentEffectiveContentId;
+export declare const safeParseAgentEffectiveContentId: (input: unknown) => AgentProtocolParseResult<AgentEffectiveContentId>;
+export declare const parseAgentCommandId: (input: unknown) => AgentCommandId;
+export declare const safeParseAgentCommandId: (input: unknown) => AgentProtocolParseResult<AgentCommandId>;
+export declare const parseAgentExtensionId: (input: unknown) => AgentExtensionId;
+export declare const safeParseAgentExtensionId: (input: unknown) => AgentProtocolParseResult<AgentExtensionId>;
 //# sourceMappingURL=parsers.d.ts.map

package/dist/foundation/parsers.js

@@ -15,6 +15,10 @@ import {
   AgentItemIdSchema,
   AgentJsonValueSchema,
   AgentManagedContentIdSchema,
+  AgentEnvironmentIdSchema,
+  AgentEffectiveContentIdSchema,
+  AgentCommandIdSchema,
+  AgentExtensionIdSchema,
   AgentOperationIdSchema,
   AgentOperationInvocationIdSchema,
   AgentProviderConversationIdSchema,
@@ -166,12 +170,28 @@ function parseAgentError(input) {
 function safeParseAgentError(input) {
   return safeParseWithSchema(AgentErrorSchema, input);
 }
+const environmentIdParser = idParser(AgentEnvironmentIdSchema);
+const parseAgentEnvironmentId = environmentIdParser.parse;
+const safeParseAgentEnvironmentId = environmentIdParser.safeParse;
+const effectiveContentIdParser = idParser(AgentEffectiveContentIdSchema);
+const parseAgentEffectiveContentId = effectiveContentIdParser.parse;
+const safeParseAgentEffectiveContentId = effectiveContentIdParser.safeParse;
+const commandIdParser = idParser(AgentCommandIdSchema);
+const parseAgentCommandId = commandIdParser.parse;
+const safeParseAgentCommandId = commandIdParser.safeParse;
+const extensionIdParser = idParser(AgentExtensionIdSchema);
+const parseAgentExtensionId = extensionIdParser.parse;
+const safeParseAgentExtensionId = extensionIdParser.safeParse;
 export {
   parseAgentApprovalOptionId,
   parseAgentArtifactId,
   parseAgentCollaborationId,
+  parseAgentCommandId,
   parseAgentConfigurationRevisionId,
+  parseAgentEffectiveContentId,
+  parseAgentEnvironmentId,
   parseAgentError,
+  parseAgentExtensionId,
   parseAgentGeneratedResourceId,
   parseAgentInstanceId,
   parseAgentIntegrationId,
@@ -198,8 +218,12 @@ export {
   safeParseAgentApprovalOptionId,
   safeParseAgentArtifactId,
   safeParseAgentCollaborationId,
+  safeParseAgentCommandId,
   safeParseAgentConfigurationRevisionId,
+  safeParseAgentEffectiveContentId,
+  safeParseAgentEnvironmentId,
   safeParseAgentError,
+  safeParseAgentExtensionId,
   safeParseAgentGeneratedResourceId,
   safeParseAgentInstanceId,
   safeParseAgentIntegrationId,

package/dist/foundation/types.d.ts

@@ -1,6 +1,6 @@
 export type { AgentProtocolParseFailure, AgentProtocolParseResult, AgentProtocolParseSuccess, ValidationIssue, ValidationPathSegment, } from './validation.js';
 export { AgentProtocolValidationError } from './validation.js';
-export declare const AGENT_PROTOCOL_VERSION: 8;
+export declare const AGENT_PROTOCOL_VERSION: 9;
 export declare const AGENT_PROTOCOL_ID_MAX_LENGTH = 256;
 export declare const AGENT_PROTOCOL_PROVIDER_REFERENCE_MAX_LENGTH = 512;
 export declare const AGENT_PROTOCOL_PROVIDER_KEY_MAX_LENGTH = 100;
@@ -28,6 +28,10 @@ export type AgentArtifactId = AgentProtocolId<'AgentArtifactId'>;
 export type AgentOperationId = AgentProtocolId<'AgentOperationId'>;
 export type AgentOperationInvocationId = AgentProtocolId<'AgentOperationInvocationId'>;
 export type AgentManagedContentId = AgentProtocolId<'AgentManagedContentId'>;
+export type AgentEnvironmentId = AgentProtocolId<'AgentEnvironmentId'>;
+export type AgentEffectiveContentId = AgentProtocolId<'AgentEffectiveContentId'>;
+export type AgentCommandId = AgentProtocolId<'AgentCommandId'>;
+export type AgentExtensionId = AgentProtocolId<'AgentExtensionId'>;
 export type AgentIntegrationId = AgentProtocolId<'AgentIntegrationId'>;
 export type AgentIntegrationServerId = AgentProtocolId<'AgentIntegrationServerId'>;
 export type AgentIntegrationToolId = AgentProtocolId<'AgentIntegrationToolId'>;

package/dist/foundation/types.js

@@ -1,5 +1,5 @@
 import { AgentProtocolValidationError } from "./validation.js";
-const AGENT_PROTOCOL_VERSION = 8;
+const AGENT_PROTOCOL_VERSION = 9;
 const AGENT_PROTOCOL_ID_MAX_LENGTH = 256;
 const AGENT_PROTOCOL_PROVIDER_REFERENCE_MAX_LENGTH = 512;
 const AGENT_PROTOCOL_PROVIDER_KEY_MAX_LENGTH = 100;

package/dist/integrations/types.d.ts

@@ -1,12 +1,15 @@
+import type { AgentAvailabilityFact, AgentEnvironmentSource } from '../environment/facts.js';
 import type { AgentIntegrationId, AgentIntegrationResourceId, AgentIntegrationServerId, AgentIntegrationToolId, AgentIsoDateTime } from '../foundation/index.js';
 export declare const AGENT_INTEGRATION_STATUSES: readonly ["starting", "ready", "degraded", "unavailable"];
-export declare const AGENT_INTEGRATION_KINDS: readonly ["mcp"];
+export declare const AGENT_INTEGRATION_KINDS: readonly ["mcp", "connector"];
 export declare const AGENT_INTEGRATION_NAME_MAX_LENGTH = 200;
 export declare const AGENT_INTEGRATION_DESCRIPTION_MAX_LENGTH = 2000;
-export declare const AGENT_INTEGRATION_CATALOG_MAX_LENGTH = 32;
+export declare const AGENT_INTEGRATION_CATALOG_MAX_LENGTH = 128;
 export declare const AGENT_INTEGRATION_SERVERS_MAX_LENGTH = 32;
 export declare const AGENT_INTEGRATION_TOOLS_MAX_LENGTH = 100;
 export declare const AGENT_INTEGRATION_RESOURCES_MAX_LENGTH = 100;
+export declare const AGENT_INTEGRATION_CONTRIBUTIONS_MAX_LENGTH = 4096;
+export declare const AGENT_INTEGRATION_CATALOG_BYTES_LIMIT = 524288;
 export type AgentIntegrationStatus = (typeof AGENT_INTEGRATION_STATUSES)[number];
 export type AgentIntegrationKind = (typeof AGENT_INTEGRATION_KINDS)[number];
 export interface AgentIntegrationToolDescriptor {
@@ -27,14 +30,29 @@ export interface AgentIntegrationServerDescriptor {
     readonly tools: readonly AgentIntegrationToolDescriptor[];
     readonly resources: readonly AgentIntegrationResourceDescriptor[];
 }
-export interface AgentIntegrationDescriptor {
+export interface AgentMcpIntegrationDescriptor {
     readonly integrationId: AgentIntegrationId;
     readonly revision: number;
-    readonly kind: AgentIntegrationKind;
+    readonly kind: 'mcp';
     readonly name: string;
     readonly status: AgentIntegrationStatus;
     readonly servers: readonly AgentIntegrationServerDescriptor[];
 }
+export interface AgentConnectorIntegrationDescriptor {
+    readonly integrationId: AgentIntegrationId;
+    readonly revision: number;
+    readonly kind: 'connector';
+    readonly name: string;
+    readonly description?: string;
+    readonly source: AgentEnvironmentSource;
+    readonly installation: AgentAvailabilityFact;
+    readonly enablement: AgentAvailabilityFact;
+    readonly authentication: AgentAvailabilityFact;
+    readonly health: AgentIntegrationStatus;
+    readonly callability: AgentAvailabilityFact;
+    readonly tools?: readonly AgentIntegrationToolDescriptor[];
+}
+export type AgentIntegrationDescriptor = AgentMcpIntegrationDescriptor | AgentConnectorIntegrationDescriptor;
 export interface AgentIntegrationCatalog {
     readonly revision: number;
     readonly observedAt: AgentIsoDateTime;

package/dist/integrations/types.js

@@ -4,15 +4,19 @@ const AGENT_INTEGRATION_STATUSES = [
   "degraded",
   "unavailable"
 ];
-const AGENT_INTEGRATION_KINDS = ["mcp"];
+const AGENT_INTEGRATION_KINDS = ["mcp", "connector"];
 const AGENT_INTEGRATION_NAME_MAX_LENGTH = 200;
 const AGENT_INTEGRATION_DESCRIPTION_MAX_LENGTH = 2e3;
-const AGENT_INTEGRATION_CATALOG_MAX_LENGTH = 32;
+const AGENT_INTEGRATION_CATALOG_MAX_LENGTH = 128;
 const AGENT_INTEGRATION_SERVERS_MAX_LENGTH = 32;
 const AGENT_INTEGRATION_TOOLS_MAX_LENGTH = 100;
 const AGENT_INTEGRATION_RESOURCES_MAX_LENGTH = 100;
+const AGENT_INTEGRATION_CONTRIBUTIONS_MAX_LENGTH = 4096;
+const AGENT_INTEGRATION_CATALOG_BYTES_LIMIT = 524288;
 export {
+  AGENT_INTEGRATION_CATALOG_BYTES_LIMIT,
   AGENT_INTEGRATION_CATALOG_MAX_LENGTH,
+  AGENT_INTEGRATION_CONTRIBUTIONS_MAX_LENGTH,
   AGENT_INTEGRATION_DESCRIPTION_MAX_LENGTH,
   AGENT_INTEGRATION_KINDS,
   AGENT_INTEGRATION_NAME_MAX_LENGTH,