@agen-ai/agent-protocol 0.2.2 → 0.2.4

package/dist/zod/integrations.d.ts

@@ -0,0 +1,76 @@
+import { z } from 'zod/v4';
+import { type AgentIntegrationCatalog, type AgentIntegrationDescriptor } from '../integrations/types.js';
+declare const AgentIntegrationDescriptorPortableSchema: 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<{
+        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<{
+            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>>;
+            name: z.ZodString;
+            description: z.ZodOptional<z.ZodString>;
+        }, z.core.$strict>>>>;
+        resources: z.ZodReadonly<z.ZodArray<z.ZodReadonly<z.ZodObject<{
+            resourceId: z.ZodType<import("../index.js").AgentIntegrationResourceId, unknown, z.core.$ZodTypeInternals<import("../index.js").AgentIntegrationResourceId, unknown>>;
+            name: z.ZodString;
+            description: z.ZodOptional<z.ZodString>;
+            mediaType: z.ZodOptional<z.ZodString>;
+        }, z.core.$strict>>>>;
+    }, z.core.$strict>>>>;
+}, z.core.$strict>>;
+export declare const AgentIntegrationDescriptorSchema: z.ZodType<AgentIntegrationDescriptor>;
+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<{
+        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<{
+            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<{
+                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>>;
+                name: z.ZodString;
+                description: z.ZodOptional<z.ZodString>;
+            }, z.core.$strict>>>>;
+            resources: z.ZodReadonly<z.ZodArray<z.ZodReadonly<z.ZodObject<{
+                resourceId: z.ZodType<import("../index.js").AgentIntegrationResourceId, unknown, z.core.$ZodTypeInternals<import("../index.js").AgentIntegrationResourceId, unknown>>;
+                name: z.ZodString;
+                description: z.ZodOptional<z.ZodString>;
+                mediaType: z.ZodOptional<z.ZodString>;
+            }, z.core.$strict>>>>;
+        }, z.core.$strict>>>>;
+    }, z.core.$strict>>>>;
+}, z.core.$strict>>;
+export declare const AgentIntegrationCatalogSchema: z.ZodType<AgentIntegrationCatalog>;
+export { AgentIntegrationDescriptorPortableSchema };
+//# sourceMappingURL=integrations.d.ts.map

package/dist/zod/integrations.js

@@ -0,0 +1,92 @@
+import { z } from "zod/v4";
+import { compareStringsByUnicodeCodePoint } from "../foundation/ordering.js";
+import {
+  AGENT_INTEGRATION_DESCRIPTION_MAX_LENGTH,
+  AGENT_INTEGRATION_CATALOG_MAX_LENGTH,
+  AGENT_INTEGRATION_NAME_MAX_LENGTH,
+  AGENT_INTEGRATION_RESOURCES_MAX_LENGTH,
+  AGENT_INTEGRATION_SERVERS_MAX_LENGTH,
+  AGENT_INTEGRATION_STATUSES,
+  AGENT_INTEGRATION_TOOLS_MAX_LENGTH
+} from "../integrations/types.js";
+import {
+  AgentIntegrationIdSchema,
+  AgentIntegrationResourceIdSchema,
+  AgentIntegrationServerIdSchema,
+  AgentIntegrationToolIdSchema,
+  AgentIsoDateTimeSchema,
+  createAgentCanonicalNonBlankStringSchema
+} from "./foundation.js";
+const PositiveSafeIntegerSchema = z.number().int().positive().max(Number.MAX_SAFE_INTEGER);
+const NameSchema = createAgentCanonicalNonBlankStringSchema(AGENT_INTEGRATION_NAME_MAX_LENGTH);
+const DescriptionSchema = createAgentCanonicalNonBlankStringSchema(
+  AGENT_INTEGRATION_DESCRIPTION_MAX_LENGTH
+);
+const MediaTypeSchema = z.string().min(1).max(200).regex(/^[a-z0-9!#$&^_.+-]+\/[a-z0-9!#$&^_.+-]+$/u);
+const ToolSchema = z.object({
+  toolId: AgentIntegrationToolIdSchema,
+  name: NameSchema,
+  description: DescriptionSchema.optional()
+}).strict().readonly();
+const ResourceSchema = z.object({
+  resourceId: AgentIntegrationResourceIdSchema,
+  name: NameSchema,
+  description: DescriptionSchema.optional(),
+  mediaType: MediaTypeSchema.optional()
+}).strict().readonly();
+const ServerSchema = z.object({
+  serverId: AgentIntegrationServerIdSchema,
+  name: NameSchema,
+  status: z.enum(AGENT_INTEGRATION_STATUSES),
+  tools: z.array(ToolSchema).max(AGENT_INTEGRATION_TOOLS_MAX_LENGTH).readonly(),
+  resources: z.array(ResourceSchema).max(AGENT_INTEGRATION_RESOURCES_MAX_LENGTH).readonly()
+}).strict().readonly();
+function addOrderedUniqueIssues(values, path, label, context) {
+  const seen = /* @__PURE__ */ new Set();
+  values.forEach((value, index) => {
+    if (seen.has(value)) {
+      context.addIssue({ code: "custom", path: [...path, index], message: `${label} must be unique.` });
+    }
+    if (index > 0 && compareStringsByUnicodeCodePoint(values[index - 1], value) >= 0) {
+      context.addIssue({ code: "custom", path: [...path, index], message: `${label} must use canonical ID order.` });
+    }
+    seen.add(value);
+  });
+}
+const AgentIntegrationDescriptorPortableSchema = z.object({
+  integrationId: AgentIntegrationIdSchema,
+  revision: PositiveSafeIntegerSchema,
+  kind: z.literal("mcp"),
+  name: NameSchema,
+  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) => {
+  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 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) => {
+  addOrderedUniqueIssues(catalog.integrations.map((integration) => integration.integrationId), ["integrations"], "Integration IDs", context);
+  catalog.integrations.forEach((integration, integrationIndex) => {
+    const parsed = AgentIntegrationDescriptorSchema.safeParse(integration);
+    if (!parsed.success) {
+      for (const issue of parsed.error.issues) {
+        context.addIssue({ code: "custom", path: ["integrations", integrationIndex, ...issue.path], message: issue.message });
+      }
+    }
+  });
+});
+export {
+  AgentIntegrationCatalogPortableSchema,
+  AgentIntegrationCatalogSchema,
+  AgentIntegrationDescriptorPortableSchema,
+  AgentIntegrationDescriptorSchema
+};

package/dist/zod/managedContent.d.ts

@@ -0,0 +1,9 @@
+import { z } from 'zod/v4';
+import { type AgentManagedContentCatalog, type AgentManagedContentDescriptor } from '../managedContent/types.js';
+export declare const AgentManagedContentDescriptorSchema: z.ZodType<AgentManagedContentDescriptor>;
+export declare const AgentManagedContentCatalogPortableSchema: z.ZodReadonly<z.ZodObject<{
+    revision: z.ZodNumber;
+    entries: z.ZodReadonly<z.ZodArray<z.ZodType<AgentManagedContentDescriptor, unknown, z.core.$ZodTypeInternals<AgentManagedContentDescriptor, unknown>>>>;
+}, z.core.$strict>>;
+export declare const AgentManagedContentCatalogSchema: z.ZodType<AgentManagedContentCatalog>;
+//# sourceMappingURL=managedContent.d.ts.map

package/dist/zod/managedContent.js

@@ -0,0 +1,70 @@
+import { z } from "zod/v4";
+import { AGENT_ARTIFACT_BYTE_SIZE_MAX } from "../artifacts/types.js";
+import { compareStringsByUnicodeCodePoint } from "../foundation/ordering.js";
+import {
+  AGENT_MANAGED_CONTENT_CATALOG_MAX_LENGTH,
+  AGENT_MANAGED_CONTENT_KINDS,
+  AGENT_MANAGED_CONTENT_NAME_MAX_LENGTH,
+  AGENT_MANAGED_CONTENT_PROMPT_MAX_LENGTH,
+  AGENT_MANAGED_CONTENT_SOURCES,
+  AGENT_MANAGED_CONTENT_STATUSES,
+  AGENT_MANAGED_CONTENT_SUMMARY_MAX_LENGTH
+} from "../managedContent/types.js";
+import {
+  AgentManagedContentIdSchema,
+  createAgentCanonicalNonBlankStringSchema
+} from "./foundation.js";
+const PositiveSafeIntegerSchema = z.number().int().positive().max(Number.MAX_SAFE_INTEGER);
+const Sha256Schema = z.string().regex(/^[a-f0-9]{64}$/u);
+const AgentManagedContentDescriptorSchema = z.object({
+  contentId: AgentManagedContentIdSchema,
+  revision: PositiveSafeIntegerSchema,
+  kind: z.enum(AGENT_MANAGED_CONTENT_KINDS),
+  source: z.enum(AGENT_MANAGED_CONTENT_SOURCES),
+  status: z.enum(AGENT_MANAGED_CONTENT_STATUSES),
+  name: createAgentCanonicalNonBlankStringSchema(AGENT_MANAGED_CONTENT_NAME_MAX_LENGTH),
+  summary: createAgentCanonicalNonBlankStringSchema(AGENT_MANAGED_CONTENT_SUMMARY_MAX_LENGTH).optional(),
+  byteSize: z.number().int().positive().max(AGENT_ARTIFACT_BYTE_SIZE_MAX),
+  digest: z.object({ algorithm: z.literal("sha256"), value: Sha256Schema }).strict().readonly(),
+  invocation: z.discriminatedUnion("kind", [
+    z.object({ kind: z.literal("provider_materialization") }).strict().readonly(),
+    z.object({
+      kind: z.literal("prompt_recipe"),
+      prompt: createAgentCanonicalNonBlankStringSchema(
+        AGENT_MANAGED_CONTENT_PROMPT_MAX_LENGTH
+      ),
+      confirmation: z.enum(["none", "required"])
+    }).strict().readonly()
+  ]).readonly()
+}).strict().superRefine((descriptor, context) => {
+  if (descriptor.kind === "prompt" !== (descriptor.invocation.kind === "prompt_recipe")) {
+    context.addIssue({
+      code: "custom",
+      path: ["invocation", "kind"],
+      message: "Prompt content must be a prompt recipe and only prompt content may be one."
+    });
+  }
+}).readonly();
+const AgentManagedContentCatalogPortableSchema = z.object({
+  revision: PositiveSafeIntegerSchema,
+  entries: z.array(AgentManagedContentDescriptorSchema).max(AGENT_MANAGED_CONTENT_CATALOG_MAX_LENGTH).readonly()
+}).strict().readonly();
+const AgentManagedContentCatalogSchema = AgentManagedContentCatalogPortableSchema.superRefine((catalog, context) => {
+  let previous = "";
+  const ids = /* @__PURE__ */ new Set();
+  catalog.entries.forEach((entry, entryIndex) => {
+    if (ids.has(entry.contentId)) {
+      context.addIssue({ code: "custom", path: ["entries", entryIndex, "contentId"], message: "Managed content IDs must be unique." });
+    }
+    if (entryIndex > 0 && compareStringsByUnicodeCodePoint(previous, entry.contentId) >= 0) {
+      context.addIssue({ code: "custom", path: ["entries", entryIndex, "contentId"], message: "Managed content must be ordered by contentId." });
+    }
+    ids.add(entry.contentId);
+    previous = entry.contentId;
+  });
+});
+export {
+  AgentManagedContentCatalogPortableSchema,
+  AgentManagedContentCatalogSchema,
+  AgentManagedContentDescriptorSchema
+};

package/dist/zod/operations.d.ts

@@ -0,0 +1,339 @@
+import { z } from 'zod/v4';
+import { type AgentOperationCatalog, type AgentOperationDescriptor, type AgentOperationInvocation, type AgentOperationResult } from '../operations/types.js';
+export declare const AgentOperationFieldSchema: z.ZodDiscriminatedUnion<[z.ZodReadonly<z.ZodObject<{
+    fieldKind: z.ZodLiteral<"text">;
+    multiline: z.ZodBoolean;
+    maxLength: z.ZodNumber;
+    fieldId: z.ZodType<import("../index.js").AgentRequestFieldId, unknown, z.core.$ZodTypeInternals<import("../index.js").AgentRequestFieldId, unknown>>;
+    label: z.ZodString;
+    description: z.ZodOptional<z.ZodString>;
+    required: z.ZodBoolean;
+    sensitivity: z.ZodEnum<{
+        ordinary: "ordinary";
+        sensitive: "sensitive";
+    }>;
+}, z.core.$strict>>, z.ZodReadonly<z.ZodObject<{
+    fieldKind: z.ZodLiteral<"boolean">;
+    fieldId: z.ZodType<import("../index.js").AgentRequestFieldId, unknown, z.core.$ZodTypeInternals<import("../index.js").AgentRequestFieldId, unknown>>;
+    label: z.ZodString;
+    description: z.ZodOptional<z.ZodString>;
+    required: z.ZodBoolean;
+    sensitivity: z.ZodEnum<{
+        ordinary: "ordinary";
+        sensitive: "sensitive";
+    }>;
+}, z.core.$strict>>, z.ZodReadonly<z.ZodObject<{
+    fieldKind: z.ZodLiteral<"single_select">;
+    options: z.ZodReadonly<z.ZodArray<z.ZodReadonly<z.ZodObject<{
+        optionId: z.ZodString;
+        label: z.ZodString;
+        description: z.ZodOptional<z.ZodString>;
+    }, z.core.$strict>>>>;
+    fieldId: z.ZodType<import("../index.js").AgentRequestFieldId, unknown, z.core.$ZodTypeInternals<import("../index.js").AgentRequestFieldId, unknown>>;
+    label: z.ZodString;
+    description: z.ZodOptional<z.ZodString>;
+    required: z.ZodBoolean;
+    sensitivity: z.ZodEnum<{
+        ordinary: "ordinary";
+        sensitive: "sensitive";
+    }>;
+}, z.core.$strict>>, z.ZodReadonly<z.ZodObject<{
+    fieldKind: z.ZodLiteral<"multi_select">;
+    options: z.ZodReadonly<z.ZodArray<z.ZodReadonly<z.ZodObject<{
+        optionId: z.ZodString;
+        label: z.ZodString;
+        description: z.ZodOptional<z.ZodString>;
+    }, z.core.$strict>>>>;
+    maxSelections: z.ZodNumber;
+    fieldId: z.ZodType<import("../index.js").AgentRequestFieldId, unknown, z.core.$ZodTypeInternals<import("../index.js").AgentRequestFieldId, unknown>>;
+    label: z.ZodString;
+    description: z.ZodOptional<z.ZodString>;
+    required: z.ZodBoolean;
+    sensitivity: z.ZodEnum<{
+        ordinary: "ordinary";
+        sensitive: "sensitive";
+    }>;
+}, z.core.$strict>>, z.ZodReadonly<z.ZodObject<{
+    fieldKind: z.ZodLiteral<"integer">;
+    minimum: z.ZodNumber;
+    maximum: z.ZodNumber;
+    fieldId: z.ZodType<import("../index.js").AgentRequestFieldId, unknown, z.core.$ZodTypeInternals<import("../index.js").AgentRequestFieldId, unknown>>;
+    label: z.ZodString;
+    description: z.ZodOptional<z.ZodString>;
+    required: z.ZodBoolean;
+    sensitivity: z.ZodEnum<{
+        ordinary: "ordinary";
+        sensitive: "sensitive";
+    }>;
+}, z.core.$strict>>], "fieldKind">;
+declare const AgentOperationDescriptorPortableSchema: z.ZodReadonly<z.ZodObject<{
+    operationId: z.ZodType<import("../index.js").AgentOperationId, unknown, z.core.$ZodTypeInternals<import("../index.js").AgentOperationId, unknown>>;
+    revision: z.ZodNumber;
+    kind: z.ZodEnum<{
+        session_control: "session_control";
+        managed_content_invoke: "managed_content_invoke";
+        configuration_select: "configuration_select";
+        integration_control: "integration_control";
+        collaboration_control: "collaboration_control";
+        resource_generate: "resource_generate";
+    }>;
+    title: z.ZodString;
+    description: z.ZodOptional<z.ZodString>;
+    context: z.ZodEnum<{
+        session: "session";
+        workspace: "workspace";
+        turn: "turn";
+        collaboration: "collaboration";
+        resource: "resource";
+    }>;
+    timing: z.ZodEnum<{
+        before_session: "before_session";
+        idle_session: "idle_session";
+        active_turn: "active_turn";
+    }>;
+    executionMode: z.ZodEnum<{
+        immediate: "immediate";
+        request_continuation: "request_continuation";
+        durable_job: "durable_job";
+    }>;
+    fields: z.ZodReadonly<z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodReadonly<z.ZodObject<{
+        fieldKind: z.ZodLiteral<"text">;
+        multiline: z.ZodBoolean;
+        maxLength: z.ZodNumber;
+        fieldId: z.ZodType<import("../index.js").AgentRequestFieldId, unknown, z.core.$ZodTypeInternals<import("../index.js").AgentRequestFieldId, unknown>>;
+        label: z.ZodString;
+        description: z.ZodOptional<z.ZodString>;
+        required: z.ZodBoolean;
+        sensitivity: z.ZodEnum<{
+            ordinary: "ordinary";
+            sensitive: "sensitive";
+        }>;
+    }, z.core.$strict>>, z.ZodReadonly<z.ZodObject<{
+        fieldKind: z.ZodLiteral<"boolean">;
+        fieldId: z.ZodType<import("../index.js").AgentRequestFieldId, unknown, z.core.$ZodTypeInternals<import("../index.js").AgentRequestFieldId, unknown>>;
+        label: z.ZodString;
+        description: z.ZodOptional<z.ZodString>;
+        required: z.ZodBoolean;
+        sensitivity: z.ZodEnum<{
+            ordinary: "ordinary";
+            sensitive: "sensitive";
+        }>;
+    }, z.core.$strict>>, z.ZodReadonly<z.ZodObject<{
+        fieldKind: z.ZodLiteral<"single_select">;
+        options: z.ZodReadonly<z.ZodArray<z.ZodReadonly<z.ZodObject<{
+            optionId: z.ZodString;
+            label: z.ZodString;
+            description: z.ZodOptional<z.ZodString>;
+        }, z.core.$strict>>>>;
+        fieldId: z.ZodType<import("../index.js").AgentRequestFieldId, unknown, z.core.$ZodTypeInternals<import("../index.js").AgentRequestFieldId, unknown>>;
+        label: z.ZodString;
+        description: z.ZodOptional<z.ZodString>;
+        required: z.ZodBoolean;
+        sensitivity: z.ZodEnum<{
+            ordinary: "ordinary";
+            sensitive: "sensitive";
+        }>;
+    }, z.core.$strict>>, z.ZodReadonly<z.ZodObject<{
+        fieldKind: z.ZodLiteral<"multi_select">;
+        options: z.ZodReadonly<z.ZodArray<z.ZodReadonly<z.ZodObject<{
+            optionId: z.ZodString;
+            label: z.ZodString;
+            description: z.ZodOptional<z.ZodString>;
+        }, z.core.$strict>>>>;
+        maxSelections: z.ZodNumber;
+        fieldId: z.ZodType<import("../index.js").AgentRequestFieldId, unknown, z.core.$ZodTypeInternals<import("../index.js").AgentRequestFieldId, unknown>>;
+        label: z.ZodString;
+        description: z.ZodOptional<z.ZodString>;
+        required: z.ZodBoolean;
+        sensitivity: z.ZodEnum<{
+            ordinary: "ordinary";
+            sensitive: "sensitive";
+        }>;
+    }, z.core.$strict>>, z.ZodReadonly<z.ZodObject<{
+        fieldKind: z.ZodLiteral<"integer">;
+        minimum: z.ZodNumber;
+        maximum: z.ZodNumber;
+        fieldId: z.ZodType<import("../index.js").AgentRequestFieldId, unknown, z.core.$ZodTypeInternals<import("../index.js").AgentRequestFieldId, unknown>>;
+        label: z.ZodString;
+        description: z.ZodOptional<z.ZodString>;
+        required: z.ZodBoolean;
+        sensitivity: z.ZodEnum<{
+            ordinary: "ordinary";
+            sensitive: "sensitive";
+        }>;
+    }, z.core.$strict>>], "fieldKind">>>;
+    confirmation: z.ZodEnum<{
+        required: "required";
+        none: "none";
+    }>;
+    idempotency: z.ZodEnum<{
+        required: "required";
+        not_required: "not_required";
+    }>;
+    resultKind: z.ZodEnum<{
+        resource: "resource";
+        none: "none";
+        canonical_output: "canonical_output";
+        artifact: "artifact";
+    }>;
+}, z.core.$strict>>;
+export declare const AgentOperationDescriptorSchema: z.ZodType<AgentOperationDescriptor>;
+export declare const AgentOperationCatalogPortableSchema: z.ZodReadonly<z.ZodObject<{
+    revision: z.ZodNumber;
+    operations: z.ZodReadonly<z.ZodArray<z.ZodReadonly<z.ZodObject<{
+        operationId: z.ZodType<import("../index.js").AgentOperationId, unknown, z.core.$ZodTypeInternals<import("../index.js").AgentOperationId, unknown>>;
+        revision: z.ZodNumber;
+        kind: z.ZodEnum<{
+            session_control: "session_control";
+            managed_content_invoke: "managed_content_invoke";
+            configuration_select: "configuration_select";
+            integration_control: "integration_control";
+            collaboration_control: "collaboration_control";
+            resource_generate: "resource_generate";
+        }>;
+        title: z.ZodString;
+        description: z.ZodOptional<z.ZodString>;
+        context: z.ZodEnum<{
+            session: "session";
+            workspace: "workspace";
+            turn: "turn";
+            collaboration: "collaboration";
+            resource: "resource";
+        }>;
+        timing: z.ZodEnum<{
+            before_session: "before_session";
+            idle_session: "idle_session";
+            active_turn: "active_turn";
+        }>;
+        executionMode: z.ZodEnum<{
+            immediate: "immediate";
+            request_continuation: "request_continuation";
+            durable_job: "durable_job";
+        }>;
+        fields: z.ZodReadonly<z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodReadonly<z.ZodObject<{
+            fieldKind: z.ZodLiteral<"text">;
+            multiline: z.ZodBoolean;
+            maxLength: z.ZodNumber;
+            fieldId: z.ZodType<import("../index.js").AgentRequestFieldId, unknown, z.core.$ZodTypeInternals<import("../index.js").AgentRequestFieldId, unknown>>;
+            label: z.ZodString;
+            description: z.ZodOptional<z.ZodString>;
+            required: z.ZodBoolean;
+            sensitivity: z.ZodEnum<{
+                ordinary: "ordinary";
+                sensitive: "sensitive";
+            }>;
+        }, z.core.$strict>>, z.ZodReadonly<z.ZodObject<{
+            fieldKind: z.ZodLiteral<"boolean">;
+            fieldId: z.ZodType<import("../index.js").AgentRequestFieldId, unknown, z.core.$ZodTypeInternals<import("../index.js").AgentRequestFieldId, unknown>>;
+            label: z.ZodString;
+            description: z.ZodOptional<z.ZodString>;
+            required: z.ZodBoolean;
+            sensitivity: z.ZodEnum<{
+                ordinary: "ordinary";
+                sensitive: "sensitive";
+            }>;
+        }, z.core.$strict>>, z.ZodReadonly<z.ZodObject<{
+            fieldKind: z.ZodLiteral<"single_select">;
+            options: z.ZodReadonly<z.ZodArray<z.ZodReadonly<z.ZodObject<{
+                optionId: z.ZodString;
+                label: z.ZodString;
+                description: z.ZodOptional<z.ZodString>;
+            }, z.core.$strict>>>>;
+            fieldId: z.ZodType<import("../index.js").AgentRequestFieldId, unknown, z.core.$ZodTypeInternals<import("../index.js").AgentRequestFieldId, unknown>>;
+            label: z.ZodString;
+            description: z.ZodOptional<z.ZodString>;
+            required: z.ZodBoolean;
+            sensitivity: z.ZodEnum<{
+                ordinary: "ordinary";
+                sensitive: "sensitive";
+            }>;
+        }, z.core.$strict>>, z.ZodReadonly<z.ZodObject<{
+            fieldKind: z.ZodLiteral<"multi_select">;
+            options: z.ZodReadonly<z.ZodArray<z.ZodReadonly<z.ZodObject<{
+                optionId: z.ZodString;
+                label: z.ZodString;
+                description: z.ZodOptional<z.ZodString>;
+            }, z.core.$strict>>>>;
+            maxSelections: z.ZodNumber;
+            fieldId: z.ZodType<import("../index.js").AgentRequestFieldId, unknown, z.core.$ZodTypeInternals<import("../index.js").AgentRequestFieldId, unknown>>;
+            label: z.ZodString;
+            description: z.ZodOptional<z.ZodString>;
+            required: z.ZodBoolean;
+            sensitivity: z.ZodEnum<{
+                ordinary: "ordinary";
+                sensitive: "sensitive";
+            }>;
+        }, z.core.$strict>>, z.ZodReadonly<z.ZodObject<{
+            fieldKind: z.ZodLiteral<"integer">;
+            minimum: z.ZodNumber;
+            maximum: z.ZodNumber;
+            fieldId: z.ZodType<import("../index.js").AgentRequestFieldId, unknown, z.core.$ZodTypeInternals<import("../index.js").AgentRequestFieldId, unknown>>;
+            label: z.ZodString;
+            description: z.ZodOptional<z.ZodString>;
+            required: z.ZodBoolean;
+            sensitivity: z.ZodEnum<{
+                ordinary: "ordinary";
+                sensitive: "sensitive";
+            }>;
+        }, z.core.$strict>>], "fieldKind">>>;
+        confirmation: z.ZodEnum<{
+            required: "required";
+            none: "none";
+        }>;
+        idempotency: z.ZodEnum<{
+            required: "required";
+            not_required: "not_required";
+        }>;
+        resultKind: z.ZodEnum<{
+            resource: "resource";
+            none: "none";
+            canonical_output: "canonical_output";
+            artifact: "artifact";
+        }>;
+    }, z.core.$strict>>>>;
+}, z.core.$strict>>;
+export declare const AgentOperationCatalogSchema: z.ZodType<AgentOperationCatalog>;
+export declare const AgentOperationInvocationPortableSchema: z.ZodReadonly<z.ZodObject<{
+    invocationId: z.ZodType<import("../index.js").AgentOperationInvocationId, unknown, z.core.$ZodTypeInternals<import("../index.js").AgentOperationInvocationId, unknown>>;
+    operationId: z.ZodType<import("../index.js").AgentOperationId, unknown, z.core.$ZodTypeInternals<import("../index.js").AgentOperationId, unknown>>;
+    expectedRevision: z.ZodNumber;
+    values: z.ZodReadonly<z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodReadonly<z.ZodObject<{
+        fieldId: z.ZodType<import("../index.js").AgentRequestFieldId, unknown, z.core.$ZodTypeInternals<import("../index.js").AgentRequestFieldId, unknown>>;
+        fieldKind: z.ZodLiteral<"text">;
+        value: z.ZodString;
+    }, z.core.$strict>>, z.ZodReadonly<z.ZodObject<{
+        fieldId: z.ZodType<import("../index.js").AgentRequestFieldId, unknown, z.core.$ZodTypeInternals<import("../index.js").AgentRequestFieldId, unknown>>;
+        fieldKind: z.ZodLiteral<"boolean">;
+        value: z.ZodBoolean;
+    }, z.core.$strict>>, z.ZodReadonly<z.ZodObject<{
+        fieldId: z.ZodType<import("../index.js").AgentRequestFieldId, unknown, z.core.$ZodTypeInternals<import("../index.js").AgentRequestFieldId, unknown>>;
+        fieldKind: z.ZodLiteral<"single_select">;
+        optionId: z.ZodString;
+    }, z.core.$strict>>, z.ZodReadonly<z.ZodObject<{
+        fieldId: z.ZodType<import("../index.js").AgentRequestFieldId, unknown, z.core.$ZodTypeInternals<import("../index.js").AgentRequestFieldId, unknown>>;
+        fieldKind: z.ZodLiteral<"multi_select">;
+        optionIds: z.ZodReadonly<z.ZodArray<z.ZodString>>;
+    }, z.core.$strict>>, z.ZodReadonly<z.ZodObject<{
+        fieldId: z.ZodType<import("../index.js").AgentRequestFieldId, unknown, z.core.$ZodTypeInternals<import("../index.js").AgentRequestFieldId, unknown>>;
+        fieldKind: z.ZodLiteral<"integer">;
+        value: z.ZodNumber;
+    }, z.core.$strict>>], "fieldKind">>>;
+}, z.core.$strict>>;
+export declare const AgentOperationInvocationSchema: z.ZodType<AgentOperationInvocation>;
+export declare const AgentOperationResultPortableSchema: z.ZodReadonly<z.ZodObject<{
+    invocationId: z.ZodType<import("../index.js").AgentOperationInvocationId, unknown, z.core.$ZodTypeInternals<import("../index.js").AgentOperationInvocationId, unknown>>;
+    status: z.ZodEnum<{
+        completed: "completed";
+        failed: "failed";
+        canceled: "canceled";
+        waiting_for_request: "waiting_for_request";
+        accepted: "accepted";
+    }>;
+    artifactIds: z.ZodOptional<z.ZodReadonly<z.ZodArray<z.ZodType<import("../index.js").AgentArtifactId, unknown, z.core.$ZodTypeInternals<import("../index.js").AgentArtifactId, unknown>>>>>;
+    resourceIds: z.ZodOptional<z.ZodReadonly<z.ZodArray<z.ZodType<import("../index.js").AgentGeneratedResourceId, unknown, z.core.$ZodTypeInternals<import("../index.js").AgentGeneratedResourceId, unknown>>>>>;
+    outputText: z.ZodOptional<z.ZodString>;
+    error: z.ZodOptional<z.ZodType<import("../index.js").AgentError, unknown, z.core.$ZodTypeInternals<import("../index.js").AgentError, unknown>>>;
+}, z.core.$strict>>;
+export declare const AgentOperationResultSchema: z.ZodType<AgentOperationResult>;
+export { AgentOperationDescriptorPortableSchema };
+//# sourceMappingURL=operations.d.ts.map