@agen-ai/agent-protocol 0.2.2 → 0.2.4

package/dist/managedContent/index.d.ts

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

package/dist/managedContent/index.js

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

package/dist/managedContent/parsers.d.ts

@@ -0,0 +1,7 @@
+import type { AgentProtocolParseResult } from '../foundation/index.js';
+import type { AgentManagedContentCatalog, AgentManagedContentDescriptor } from './types.js';
+export declare function parseAgentManagedContentDescriptor(input: unknown): AgentManagedContentDescriptor;
+export declare function safeParseAgentManagedContentDescriptor(input: unknown): AgentProtocolParseResult<AgentManagedContentDescriptor>;
+export declare function parseAgentManagedContentCatalog(input: unknown): AgentManagedContentCatalog;
+export declare function safeParseAgentManagedContentCatalog(input: unknown): AgentProtocolParseResult<AgentManagedContentCatalog>;
+//# sourceMappingURL=parsers.d.ts.map

package/dist/managedContent/parsers.js

@@ -0,0 +1,23 @@
+import { parseWithSchema, safeParseWithSchema } from "../internal/parsers.js";
+import {
+  AgentManagedContentCatalogSchema,
+  AgentManagedContentDescriptorSchema
+} from "../zod/managedContent.js";
+function parseAgentManagedContentDescriptor(input) {
+  return parseWithSchema(AgentManagedContentDescriptorSchema, input);
+}
+function safeParseAgentManagedContentDescriptor(input) {
+  return safeParseWithSchema(AgentManagedContentDescriptorSchema, input);
+}
+function parseAgentManagedContentCatalog(input) {
+  return parseWithSchema(AgentManagedContentCatalogSchema, input);
+}
+function safeParseAgentManagedContentCatalog(input) {
+  return safeParseWithSchema(AgentManagedContentCatalogSchema, input);
+}
+export {
+  parseAgentManagedContentCatalog,
+  parseAgentManagedContentDescriptor,
+  safeParseAgentManagedContentCatalog,
+  safeParseAgentManagedContentDescriptor
+};

package/dist/managedContent/types.d.ts

@@ -0,0 +1,39 @@
+import type { AgentManagedContentId } from '../foundation/index.js';
+export declare const AGENT_MANAGED_CONTENT_KINDS: readonly ["skill", "rule", "prompt", "agent_definition"];
+export declare const AGENT_MANAGED_CONTENT_SOURCES: readonly ["platform", "team"];
+export declare const AGENT_MANAGED_CONTENT_STATUSES: readonly ["available", "disabled"];
+export declare const AGENT_MANAGED_CONTENT_NAME_MAX_LENGTH = 200;
+export declare const AGENT_MANAGED_CONTENT_SUMMARY_MAX_LENGTH = 2000;
+export declare const AGENT_MANAGED_CONTENT_PROMPT_MAX_LENGTH = 16384;
+export declare const AGENT_MANAGED_CONTENT_CATALOG_MAX_LENGTH = 100;
+export type AgentManagedContentKind = (typeof AGENT_MANAGED_CONTENT_KINDS)[number];
+export type AgentManagedContentSource = (typeof AGENT_MANAGED_CONTENT_SOURCES)[number];
+export type AgentManagedContentStatus = (typeof AGENT_MANAGED_CONTENT_STATUSES)[number];
+export interface AgentManagedContentDigest {
+    readonly algorithm: 'sha256';
+    readonly value: string;
+}
+export type AgentManagedContentInvocation = Readonly<{
+    readonly kind: 'provider_materialization';
+}> | Readonly<{
+    readonly kind: 'prompt_recipe';
+    readonly prompt: string;
+    readonly confirmation: 'none' | 'required';
+}>;
+export interface AgentManagedContentDescriptor {
+    readonly contentId: AgentManagedContentId;
+    readonly revision: number;
+    readonly kind: AgentManagedContentKind;
+    readonly source: AgentManagedContentSource;
+    readonly status: AgentManagedContentStatus;
+    readonly name: string;
+    readonly summary?: string;
+    readonly byteSize: number;
+    readonly digest: AgentManagedContentDigest;
+    readonly invocation: AgentManagedContentInvocation;
+}
+export interface AgentManagedContentCatalog {
+    readonly revision: number;
+    readonly entries: readonly AgentManagedContentDescriptor[];
+}
+//# sourceMappingURL=types.d.ts.map

package/dist/managedContent/types.js

@@ -0,0 +1,21 @@
+const AGENT_MANAGED_CONTENT_KINDS = [
+  "skill",
+  "rule",
+  "prompt",
+  "agent_definition"
+];
+const AGENT_MANAGED_CONTENT_SOURCES = ["platform", "team"];
+const AGENT_MANAGED_CONTENT_STATUSES = ["available", "disabled"];
+const AGENT_MANAGED_CONTENT_NAME_MAX_LENGTH = 200;
+const AGENT_MANAGED_CONTENT_SUMMARY_MAX_LENGTH = 2e3;
+const AGENT_MANAGED_CONTENT_PROMPT_MAX_LENGTH = 16384;
+const AGENT_MANAGED_CONTENT_CATALOG_MAX_LENGTH = 100;
+export {
+  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
+};

package/dist/operations/index.d.ts

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

package/dist/operations/index.js

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

package/dist/operations/parsers.d.ts

@@ -0,0 +1,15 @@
+import { type AgentProtocolParseResult } from '../foundation/index.js';
+import type { AgentOperationCatalog, AgentOperationDescriptor, AgentOperationInvocation, AgentOperationResult } from './types.js';
+export declare function parseAgentOperationDescriptor(input: unknown): AgentOperationDescriptor;
+export declare function safeParseAgentOperationDescriptor(input: unknown): AgentProtocolParseResult<AgentOperationDescriptor>;
+export declare function parseAgentOperationCatalog(input: unknown): AgentOperationCatalog;
+export declare function safeParseAgentOperationCatalog(input: unknown): AgentProtocolParseResult<AgentOperationCatalog>;
+export declare function parseAgentOperationInvocation(input: unknown): AgentOperationInvocation;
+export declare function safeParseAgentOperationInvocation(input: unknown): AgentProtocolParseResult<AgentOperationInvocation>;
+export declare function parseAgentOperationResult(input: unknown): AgentOperationResult;
+export declare function safeParseAgentOperationResult(input: unknown): AgentProtocolParseResult<AgentOperationResult>;
+export declare function safeParseAgentOperationInvocationFor(descriptorInput: unknown, invocationInput: unknown): AgentProtocolParseResult<AgentOperationInvocation>;
+export declare function parseAgentOperationInvocationFor(descriptorInput: unknown, invocationInput: unknown): AgentOperationInvocation;
+export declare function safeParseAgentOperationResultFor(descriptorInput: unknown, invocationInput: unknown, resultInput: unknown): AgentProtocolParseResult<AgentOperationResult>;
+export declare function parseAgentOperationResultFor(descriptorInput: unknown, invocationInput: unknown, resultInput: unknown): AgentOperationResult;
+//# sourceMappingURL=parsers.d.ts.map

package/dist/operations/parsers.js

@@ -0,0 +1,181 @@
+import {
+  AgentProtocolValidationError
+} from "../foundation/index.js";
+import { parseWithSchema, safeParseWithSchema } from "../internal/parsers.js";
+import {
+  AgentOperationCatalogSchema,
+  AgentOperationDescriptorSchema,
+  AgentOperationInvocationSchema,
+  AgentOperationResultSchema
+} from "../zod/operations.js";
+function parseAgentOperationDescriptor(input) {
+  return parseWithSchema(AgentOperationDescriptorSchema, input);
+}
+function safeParseAgentOperationDescriptor(input) {
+  return safeParseWithSchema(AgentOperationDescriptorSchema, input);
+}
+function parseAgentOperationCatalog(input) {
+  return parseWithSchema(AgentOperationCatalogSchema, input);
+}
+function safeParseAgentOperationCatalog(input) {
+  return safeParseWithSchema(AgentOperationCatalogSchema, input);
+}
+function parseAgentOperationInvocation(input) {
+  return parseWithSchema(AgentOperationInvocationSchema, input);
+}
+function safeParseAgentOperationInvocation(input) {
+  return safeParseWithSchema(AgentOperationInvocationSchema, input);
+}
+function parseAgentOperationResult(input) {
+  return parseWithSchema(AgentOperationResultSchema, input);
+}
+function safeParseAgentOperationResult(input) {
+  return safeParseWithSchema(AgentOperationResultSchema, input);
+}
+function issue(path, message) {
+  return { code: "custom", path, message };
+}
+function safeParseAgentOperationInvocationFor(descriptorInput, invocationInput) {
+  const descriptor = safeParseAgentOperationDescriptor(descriptorInput);
+  if (!descriptor.success) return descriptor;
+  const invocation = safeParseAgentOperationInvocation(invocationInput);
+  if (!invocation.success) return invocation;
+  const issues = [];
+  if (invocation.data.operationId !== descriptor.data.operationId) {
+    issues.push(issue(
+      ["operationId"],
+      "Invocation operationId must match the selected operation."
+    ));
+  }
+  if (invocation.data.expectedRevision !== descriptor.data.revision) {
+    issues.push(issue(
+      ["expectedRevision"],
+      "Invocation revision must match the selected operation revision."
+    ));
+  }
+  const values = new Map(
+    invocation.data.values.map((value) => [value.fieldId, value])
+  );
+  for (const [valueIndex, value] of invocation.data.values.entries()) {
+    const field = descriptor.data.fields.find(
+      (candidate) => candidate.fieldId === value.fieldId
+    );
+    if (field === void 0) {
+      issues.push(issue(
+        ["values", valueIndex, "fieldId"],
+        "Invocation fields must be declared by the selected operation."
+      ));
+      continue;
+    }
+    if (field.fieldKind !== value.fieldKind) {
+      issues.push(issue(
+        ["values", valueIndex, "fieldKind"],
+        "Invocation field kind must match the selected operation field."
+      ));
+      continue;
+    }
+    if (field.fieldKind === "text" && value.fieldKind === "text") {
+      if (value.value.length > field.maxLength) {
+        issues.push(issue(
+          ["values", valueIndex, "value"],
+          "Invocation text exceeds the operation field maximum."
+        ));
+      }
+    } else if (field.fieldKind === "single_select" && value.fieldKind === "single_select" && !field.options.some((option) => option.optionId === value.optionId)) {
+      issues.push(issue(
+        ["values", valueIndex, "optionId"],
+        "Invocation selection must reference an offered option."
+      ));
+    } else if (field.fieldKind === "multi_select" && value.fieldKind === "multi_select") {
+      const allowed = new Set(field.options.map((option) => option.optionId));
+      if (value.optionIds.some((optionId) => !allowed.has(optionId))) {
+        issues.push(issue(
+          ["values", valueIndex, "optionIds"],
+          "Invocation selections must reference offered options."
+        ));
+      }
+      if (value.optionIds.length > field.maxSelections) {
+        issues.push(issue(
+          ["values", valueIndex, "optionIds"],
+          "Invocation selections exceed the operation field maximum."
+        ));
+      }
+    } else if (field.fieldKind === "integer" && value.fieldKind === "integer" && (value.value < field.minimum || value.value > field.maximum)) {
+      issues.push(issue(
+        ["values", valueIndex, "value"],
+        "Invocation integer is outside the operation field bounds."
+      ));
+    }
+  }
+  for (const field of descriptor.data.fields) {
+    if (field.required && !values.has(field.fieldId)) {
+      issues.push(issue(
+        ["values"],
+        `Required operation field ${field.fieldId} is missing.`
+      ));
+    }
+  }
+  return issues.length === 0 ? invocation : { success: false, issues };
+}
+function parseAgentOperationInvocationFor(descriptorInput, invocationInput) {
+  const parsed = safeParseAgentOperationInvocationFor(
+    descriptorInput,
+    invocationInput
+  );
+  if (parsed.success) return parsed.data;
+  throw new AgentProtocolValidationError(parsed.issues);
+}
+function safeParseAgentOperationResultFor(descriptorInput, invocationInput, resultInput) {
+  const descriptor = safeParseAgentOperationDescriptor(descriptorInput);
+  if (!descriptor.success) return descriptor;
+  const invocation = safeParseAgentOperationInvocationFor(
+    descriptor.data,
+    invocationInput
+  );
+  if (!invocation.success) return invocation;
+  const result = safeParseAgentOperationResult(resultInput);
+  if (!result.success) return result;
+  const issues = [];
+  if (result.data.invocationId !== invocation.data.invocationId) {
+    issues.push(issue(
+      ["invocationId"],
+      "Operation result invocationId must match the invocation."
+    ));
+  }
+  if (result.data.status === "completed") {
+    const hasArtifacts = (result.data.artifactIds?.length ?? 0) > 0;
+    const hasResources = (result.data.resourceIds?.length ?? 0) > 0;
+    const hasOutputText = result.data.outputText !== void 0;
+    const matchesResultKind = descriptor.data.resultKind === "none" && !hasArtifacts && !hasResources && !hasOutputText || descriptor.data.resultKind === "canonical_output" && hasOutputText && !hasArtifacts && !hasResources || descriptor.data.resultKind === "artifact" && hasArtifacts && !hasResources && !hasOutputText || descriptor.data.resultKind === "resource" && hasResources && !hasArtifacts && !hasOutputText;
+    if (!matchesResultKind) {
+      issues.push(issue(
+        [],
+        "Completed operation result values must match the descriptor result kind."
+      ));
+    }
+  }
+  return issues.length === 0 ? result : { success: false, issues };
+}
+function parseAgentOperationResultFor(descriptorInput, invocationInput, resultInput) {
+  const parsed = safeParseAgentOperationResultFor(
+    descriptorInput,
+    invocationInput,
+    resultInput
+  );
+  if (parsed.success) return parsed.data;
+  throw new AgentProtocolValidationError(parsed.issues);
+}
+export {
+  parseAgentOperationCatalog,
+  parseAgentOperationDescriptor,
+  parseAgentOperationInvocation,
+  parseAgentOperationInvocationFor,
+  parseAgentOperationResult,
+  parseAgentOperationResultFor,
+  safeParseAgentOperationCatalog,
+  safeParseAgentOperationDescriptor,
+  safeParseAgentOperationInvocation,
+  safeParseAgentOperationInvocationFor,
+  safeParseAgentOperationResult,
+  safeParseAgentOperationResultFor
+};

package/dist/operations/types.d.ts

@@ -0,0 +1,112 @@
+import type { AgentArtifactId, AgentError, AgentGeneratedResourceId, AgentOperationId, AgentOperationInvocationId, AgentRequestFieldId } from '../foundation/index.js';
+export declare const AGENT_OPERATION_KINDS: readonly ["session_control", "managed_content_invoke", "configuration_select", "integration_control", "collaboration_control", "resource_generate"];
+export declare const AGENT_OPERATION_CONTEXTS: readonly ["workspace", "session", "turn", "collaboration", "resource"];
+export declare const AGENT_OPERATION_TIMINGS: readonly ["before_session", "idle_session", "active_turn"];
+export declare const AGENT_OPERATION_EXECUTION_MODES: readonly ["immediate", "request_continuation", "durable_job"];
+export declare const AGENT_OPERATION_FIELD_KINDS: readonly ["text", "boolean", "single_select", "multi_select", "integer"];
+export declare const AGENT_OPERATION_RESULT_KINDS: readonly ["none", "canonical_output", "artifact", "resource"];
+export declare const AGENT_OPERATION_IDEMPOTENCY_REQUIREMENTS: readonly ["required", "not_required"];
+export declare const AGENT_OPERATION_TITLE_MAX_LENGTH = 200;
+export declare const AGENT_OPERATION_DESCRIPTION_MAX_LENGTH = 2000;
+export declare const AGENT_OPERATION_TEXT_VALUE_MAX_LENGTH = 4000;
+export declare const AGENT_OPERATION_FIELDS_MAX_LENGTH = 16;
+export declare const AGENT_OPERATION_OPTIONS_MAX_LENGTH = 100;
+export declare const AGENT_OPERATION_CATALOG_MAX_LENGTH = 100;
+export declare const AGENT_OPERATION_RESULT_REFERENCES_MAX_LENGTH = 100;
+export declare const AGENT_OPERATION_OUTPUT_TEXT_MAX_LENGTH = 4000;
+export type AgentOperationKind = (typeof AGENT_OPERATION_KINDS)[number];
+export type AgentOperationContext = (typeof AGENT_OPERATION_CONTEXTS)[number];
+export type AgentOperationTiming = (typeof AGENT_OPERATION_TIMINGS)[number];
+export type AgentOperationExecutionMode = (typeof AGENT_OPERATION_EXECUTION_MODES)[number];
+export type AgentOperationFieldKind = (typeof AGENT_OPERATION_FIELD_KINDS)[number];
+export type AgentOperationResultKind = (typeof AGENT_OPERATION_RESULT_KINDS)[number];
+export type AgentOperationIdempotencyRequirement = (typeof AGENT_OPERATION_IDEMPOTENCY_REQUIREMENTS)[number];
+export interface AgentOperationSelectOption {
+    readonly optionId: string;
+    readonly label: string;
+    readonly description?: string;
+}
+interface AgentOperationFieldBase {
+    readonly fieldId: AgentRequestFieldId;
+    readonly label: string;
+    readonly description?: string;
+    readonly required: boolean;
+    readonly sensitivity: 'ordinary' | 'sensitive';
+}
+export interface AgentOperationTextField extends AgentOperationFieldBase {
+    readonly fieldKind: 'text';
+    readonly multiline: boolean;
+    readonly maxLength: number;
+}
+export interface AgentOperationBooleanField extends AgentOperationFieldBase {
+    readonly fieldKind: 'boolean';
+}
+export interface AgentOperationSingleSelectField extends AgentOperationFieldBase {
+    readonly fieldKind: 'single_select';
+    readonly options: readonly AgentOperationSelectOption[];
+}
+export interface AgentOperationMultiSelectField extends AgentOperationFieldBase {
+    readonly fieldKind: 'multi_select';
+    readonly options: readonly AgentOperationSelectOption[];
+    readonly maxSelections: number;
+}
+export interface AgentOperationIntegerField extends AgentOperationFieldBase {
+    readonly fieldKind: 'integer';
+    readonly minimum: number;
+    readonly maximum: number;
+}
+export type AgentOperationField = AgentOperationTextField | AgentOperationBooleanField | AgentOperationSingleSelectField | AgentOperationMultiSelectField | AgentOperationIntegerField;
+export interface AgentOperationDescriptor {
+    readonly operationId: AgentOperationId;
+    readonly revision: number;
+    readonly kind: AgentOperationKind;
+    readonly title: string;
+    readonly description?: string;
+    readonly context: AgentOperationContext;
+    readonly timing: AgentOperationTiming;
+    readonly executionMode: AgentOperationExecutionMode;
+    readonly fields: readonly AgentOperationField[];
+    readonly confirmation: 'none' | 'required';
+    readonly idempotency: AgentOperationIdempotencyRequirement;
+    readonly resultKind: AgentOperationResultKind;
+}
+export interface AgentOperationCatalog {
+    readonly revision: number;
+    readonly operations: readonly AgentOperationDescriptor[];
+}
+interface AgentOperationValueBase {
+    readonly fieldId: AgentRequestFieldId;
+}
+export type AgentOperationFieldValue = (AgentOperationValueBase & Readonly<{
+    fieldKind: 'text';
+    value: string;
+}>) | (AgentOperationValueBase & Readonly<{
+    fieldKind: 'boolean';
+    value: boolean;
+}>) | (AgentOperationValueBase & Readonly<{
+    fieldKind: 'single_select';
+    optionId: string;
+}>) | (AgentOperationValueBase & Readonly<{
+    fieldKind: 'multi_select';
+    optionIds: readonly string[];
+}>) | (AgentOperationValueBase & Readonly<{
+    fieldKind: 'integer';
+    value: number;
+}>);
+export interface AgentOperationInvocation {
+    readonly invocationId: AgentOperationInvocationId;
+    readonly operationId: AgentOperationId;
+    readonly expectedRevision: number;
+    readonly values: readonly AgentOperationFieldValue[];
+}
+export type AgentOperationResultStatus = 'accepted' | 'completed' | 'failed' | 'canceled' | 'waiting_for_request';
+export interface AgentOperationResult {
+    readonly invocationId: AgentOperationInvocationId;
+    readonly status: AgentOperationResultStatus;
+    readonly artifactIds?: readonly AgentArtifactId[];
+    readonly resourceIds?: readonly AgentGeneratedResourceId[];
+    readonly outputText?: string;
+    readonly error?: AgentError;
+}
+export {};
+//# sourceMappingURL=types.d.ts.map

package/dist/operations/types.js

@@ -0,0 +1,67 @@
+const AGENT_OPERATION_KINDS = [
+  "session_control",
+  "managed_content_invoke",
+  "configuration_select",
+  "integration_control",
+  "collaboration_control",
+  "resource_generate"
+];
+const AGENT_OPERATION_CONTEXTS = [
+  "workspace",
+  "session",
+  "turn",
+  "collaboration",
+  "resource"
+];
+const AGENT_OPERATION_TIMINGS = [
+  "before_session",
+  "idle_session",
+  "active_turn"
+];
+const AGENT_OPERATION_EXECUTION_MODES = [
+  "immediate",
+  "request_continuation",
+  "durable_job"
+];
+const AGENT_OPERATION_FIELD_KINDS = [
+  "text",
+  "boolean",
+  "single_select",
+  "multi_select",
+  "integer"
+];
+const AGENT_OPERATION_RESULT_KINDS = [
+  "none",
+  "canonical_output",
+  "artifact",
+  "resource"
+];
+const AGENT_OPERATION_IDEMPOTENCY_REQUIREMENTS = [
+  "required",
+  "not_required"
+];
+const AGENT_OPERATION_TITLE_MAX_LENGTH = 200;
+const AGENT_OPERATION_DESCRIPTION_MAX_LENGTH = 2e3;
+const AGENT_OPERATION_TEXT_VALUE_MAX_LENGTH = 4e3;
+const AGENT_OPERATION_FIELDS_MAX_LENGTH = 16;
+const AGENT_OPERATION_OPTIONS_MAX_LENGTH = 100;
+const AGENT_OPERATION_CATALOG_MAX_LENGTH = 100;
+const AGENT_OPERATION_RESULT_REFERENCES_MAX_LENGTH = 100;
+const AGENT_OPERATION_OUTPUT_TEXT_MAX_LENGTH = 4e3;
+export {
+  AGENT_OPERATION_CATALOG_MAX_LENGTH,
+  AGENT_OPERATION_CONTEXTS,
+  AGENT_OPERATION_DESCRIPTION_MAX_LENGTH,
+  AGENT_OPERATION_EXECUTION_MODES,
+  AGENT_OPERATION_FIELDS_MAX_LENGTH,
+  AGENT_OPERATION_FIELD_KINDS,
+  AGENT_OPERATION_IDEMPOTENCY_REQUIREMENTS,
+  AGENT_OPERATION_KINDS,
+  AGENT_OPERATION_OPTIONS_MAX_LENGTH,
+  AGENT_OPERATION_OUTPUT_TEXT_MAX_LENGTH,
+  AGENT_OPERATION_RESULT_KINDS,
+  AGENT_OPERATION_RESULT_REFERENCES_MAX_LENGTH,
+  AGENT_OPERATION_TEXT_VALUE_MAX_LENGTH,
+  AGENT_OPERATION_TIMINGS,
+  AGENT_OPERATION_TITLE_MAX_LENGTH
+};

package/dist/public/collaboration.d.ts

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

package/dist/public/collaboration.js

@@ -0,0 +1 @@
+export * from "../collaboration/index.js";

package/dist/public/configuration.d.ts

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

package/dist/public/configuration.js

@@ -0,0 +1 @@
+export * from "../configuration/index.js";

package/dist/public/index.d.ts

@@ -2,6 +2,12 @@ export * from '../foundation/index.js';
 export * from '../sessions/index.js';
 export * from '../turns/index.js';
 export * from '../requests/index.js';
+export * from '../operations/index.js';
+export * from '../managedContent/index.js';
+export * from '../configuration/index.js';
+export * from '../integrations/index.js';
+export * from '../collaboration/index.js';
+export * from '../resources/index.js';
 export * from '../capabilities/index.js';
 export * from '../artifacts/index.js';
 export * from '../events/index.js';

package/dist/public/index.js

@@ -2,6 +2,12 @@ export * from "../foundation/index.js";
 export * from "../sessions/index.js";
 export * from "../turns/index.js";
 export * from "../requests/index.js";
+export * from "../operations/index.js";
+export * from "../managedContent/index.js";
+export * from "../configuration/index.js";
+export * from "../integrations/index.js";
+export * from "../collaboration/index.js";
+export * from "../resources/index.js";
 export * from "../capabilities/index.js";
 export * from "../artifacts/index.js";
 export * from "../events/index.js";

package/dist/public/integrations.d.ts

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

package/dist/public/integrations.js

@@ -0,0 +1 @@
+export * from "../integrations/index.js";

package/dist/public/managedContent.d.ts

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

package/dist/public/managedContent.js

@@ -0,0 +1 @@
+export * from "../managedContent/index.js";

package/dist/public/operations.d.ts

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

package/dist/public/operations.js

@@ -0,0 +1 @@
+export * from "../operations/index.js";

package/dist/public/resources.d.ts

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

package/dist/public/resources.js

@@ -0,0 +1 @@
+export * from "../resources/index.js";

package/dist/requests/parsers.js

@@ -38,20 +38,30 @@ function issue(path, message) {
 function fieldMap(request) {
   return new Map(request.fields.map((field) => [field.fieldId, field]));
 }
-function choiceAnswerIssues(field, answer, answerIndex) {
+function singleSelectAnswerIssues(field, answer, answerIndex) {
   const issues = [];
   const allowedValues = new Set(field.options.map((option) => option.value));
-  if (answer.values.some((value) => !allowedValues.has(value))) {
+  if (answer.value !== void 0 && !allowedValues.has(answer.value)) {
     issues.push(issue(
-      ["answers", answerIndex, "values"],
-      "Choice answers must reference options declared by the request."
+      ["answers", answerIndex, "value"],
+      "Single-select answers must reference an option declared by the request."
     ));
   }
-  const selectionCount = answer.values.length + (answer.other === void 0 ? 0 : 1);
-  if (!field.multiple && selectionCount > 1) {
+  if (answer.other !== void 0 && !field.allowOther) {
     issues.push(issue(
-      ["answers", answerIndex],
-      "This request field accepts only one choice."
+      ["answers", answerIndex, "other"],
+      "This request field does not accept a custom choice."
+    ));
+  }
+  return issues;
+}
+function multiSelectAnswerIssues(field, answer, answerIndex) {
+  const issues = [];
+  const allowedValues = new Set(field.options.map((option) => option.value));
+  if (answer.values.some((value) => !allowedValues.has(value))) {
+    issues.push(issue(
+      ["answers", answerIndex, "values"],
+      "Multi-select answers must reference options declared by the request."
     ));
   }
   if (answer.other !== void 0 && !field.allowOther) {
@@ -60,10 +70,17 @@ function choiceAnswerIssues(field, answer, answerIndex) {
       "This request field does not accept a custom choice."
     ));
   }
-  if (answer.values.length === 0 && answer.other === void 0) {
+  const selectionCount = answer.values.length + (answer.other === void 0 ? 0 : 1);
+  if (field.required && selectionCount === 0) {
+    issues.push(issue(
+      ["answers", answerIndex],
+      "A required multi-select answer needs a declared option or a custom choice."
+    ));
+  }
+  if (selectionCount > field.maxSelections) {
     issues.push(issue(
       ["answers", answerIndex],
-      "A choice answer requires a declared option or a custom choice."
+      "This request field exceeds its maximum selection count."
     ));
   }
   return issues;
@@ -75,7 +92,19 @@ function answerIssues(field, answer, answerIndex) {
       "Answer kind must match the corresponding request field."
     )];
   }
-  return field.kind === "choice" && answer.kind === "choice" ? choiceAnswerIssues(field, answer, answerIndex) : [];
+  if (field.kind === "text" && answer.kind === "text") {
+    return answer.value.length <= field.maxLength ? [] : [issue(
+      ["answers", answerIndex, "value"],
+      "Text answer exceeds the field maximum length."
+    )];
+  }
+  if (field.kind === "single_select" && answer.kind === "single_select") {
+    return singleSelectAnswerIssues(field, answer, answerIndex);
+  }
+  if (field.kind === "multi_select" && answer.kind === "multi_select") {
+    return multiSelectAnswerIssues(field, answer, answerIndex);
+  }
+  return [];
 }
 function resolutionIssues(request, resolution) {
   const issues = [];