@wildix/wilma-agents-client 1.0.1 → 1.0.2

package/dist-types/models/models_0.d.ts

@@ -1,23 +1,7 @@
 import type { DocumentType as __DocumentType } from "@smithy/types";
-import type { ActorType, AgentFileScope, AgentGrantPermission, AgentStatus, AgentVariableType, AgentVisibility, AuditAction, AuditResourceType, ChannelType, GuardrailAction, GuardrailContentCategory, GuardrailFilterStrength, GuardrailPiiAction, GuardrailPiiEntityType, SandboxNetworkAccess, SpeechProvider, WebhookMethod, WebSearchContextSize } from "./enums";
-/**
- * Who performed an action: an interactive user, an API key or an internal service.
- * @public
- */
-export interface Actor {
-    type: ActorType;
-    /**
-     * User id, API key id or service name, depending on the actor type.
-     * @public
-     */
-    id: string;
-    /**
-     * Human readable name of the actor at the time of the action.
-     * @public
-     */
-    name?: string | undefined;
-}
+import type { ActorType, AgentDeploymentStatus, AgentHandoverPipelineType, AgentHandoverVariant, AgentHangupPipelineType, AgentStatus, AgentToolPipelineType, AgentTransferPipelineType, AgentTransferVariant, AgentVariableType, AgentVisibility, ChannelType, SandboxNetworkAccess, WebSearchContextSize } from "./enums";
 /**
+ * A user or group that access is granted to.
  * @public
  */
 export type AgentGrantPrincipal = AgentGrantPrincipal.GroupIdMember | AgentGrantPrincipal.UserIdMember | AgentGrantPrincipal.$UnknownMember;
@@ -54,94 +38,48 @@ export declare namespace AgentGrantPrincipal {
     }
 }
 /**
- * @public
- */
-export interface AgentGrant {
-    permission: AgentGrantPermission;
-    principal: AgentGrantPrincipal;
-}
-/**
+ * Who is allowed to use the agent. There is no view/edit dimension — access solely grants the ability to use the agent.
+ *     Per channel: on `chat` and `assistant` agents `grants` govern which colleagues can use the agent; on `voice` agents `grants`
+ *     are ignored (inbound calls are routed by the PBX dialplan, and data ACL is the agent-level `settings.pbxGroupId`); on `autonomous` agents agent-level
+ *     access is not used — invocation access is configured per reference on the calling agent (see AgentCallCapability.access).
  * @public
  */
 export interface AgentAccess {
-    visibility?: AgentVisibility | undefined;
-    grants?: AgentGrant[] | undefined;
-}
-/**
- * @public
- */
-export interface AgentAliasRoute {
-    version: number;
-    /**
-     * Percentage of new sessions routed to this version. Weights of an alias must sum to 100.
-     * @public
-     */
-    weight: number;
-}
-/**
- * @public
- */
-export interface AgentAlias {
-    /**
-     * Alias name, e.g. 'production', 'staging'.
-     * @public
-     */
-    name: string;
-    agentId: string;
-    description?: string | undefined;
-    /**
-     * Weighted routing to published versions. A single route with weight 100 is the common case; two routes make a canary.
-     * @public
-     */
-    routing: AgentAliasRoute[];
     /**
-     * ISO-8601 timestamp, e.g. '2026-07-03T10:15:30.000Z'.
+     * Usage scope. Defaults to `explicit` (only the listed grants).
      * @public
      */
-    updatedAt: string;
+    visibility?: AgentVisibility | undefined;
     /**
-     * Who performed an action: an interactive user, an API key or an internal service.
+     * Users and groups granted the ability to use the agent. Applies when visibility is `explicit`.
      * @public
      */
-    updatedBy: Actor;
-}
-/**
- * @public
- */
-export interface ApiChannelSettings {
-    enabled: boolean;
+    grants?: AgentGrantPrincipal[] | undefined;
 }
 /**
  * @public
  */
 export interface AssistantChannelSettings {
-    enabled: boolean;
     /**
      * Offer this agent as the default assistant for users covered by the agent access settings.
      * @public
      */
     default?: boolean | undefined;
 }
+/**
+ * @public
+ */
+export interface AutonomousChannelSettings {
+}
 /**
  * @public
  */
 export interface ChatChannelSettings {
-    enabled: boolean;
     /**
-     * Whether users can find and add this agent to conversations.
+     * Whether users can find and add this agent to conversations. Maps from the legacy xbees-users bot `searchable`.
      * @public
      */
     discoverable?: boolean | undefined;
-    /**
-     * PBX group used for data ACL (e.g. Sales Intelligence lookups).
-     * @public
-     */
-    pbxGroupId?: string | undefined;
-    /**
-     * Message posted when the agent joins a conversation.
-     * @public
-     */
-    welcomeMessage?: string | undefined;
 }
 /**
  * Caller context injected into the model prompt.
@@ -291,72 +229,134 @@ export interface VoiceSilenceTimeoutSettings {
     action: VoiceTerminateAction;
 }
 /**
+ * Voice channel settings. Note: a voice agent's AgentAccess.grants are ignored — inbound calls are routed by the PBX dialplan and data ACL is the agent-level `settings.pbxGroupId`, not per-user grants.
  * @public
  */
-export interface VoiceSynthesisSettings {
-    provider: SpeechProvider;
+export interface VoiceChannelSettings {
+    /**
+     * Message spoken when the call starts. Maps from the legacy wim-voicebots `message`.
+     * @public
+     */
+    greeting?: string | undefined;
+    interruptions?: VoiceInterruptionSettings | undefined;
+    silenceTimeout?: VoiceSilenceTimeoutSettings | undefined;
+    maxDuration?: VoiceMaxDurationSettings | undefined;
+    endCall?: VoiceEndCallSettings | undefined;
     /**
-     * Provider-specific voice identifier.
+     * Caller context injected into the model prompt.
      * @public
      */
-    voiceId: string;
+    callerMetadata?: VoiceCallerMetadataSettings | undefined;
+}
+/**
+ * The channels an agent serves and their channel-specific settings. Presence of a member enables that channel; at least one must be set. Enabled channels are mirrored as ChannelType values on AgentInfo.
+ * @public
+ */
+export interface AgentChannels {
     /**
-     * Playback speed multiplier.
+     * Voice channel settings. Note: a voice agent's AgentAccess.grants are ignored — inbound calls are routed by the PBX dialplan and data ACL is the agent-level `settings.pbxGroupId`, not per-user grants.
      * @public
      */
-    speed?: number | undefined;
+    voice?: VoiceChannelSettings | undefined;
+    chat?: ChatChannelSettings | undefined;
+    assistant?: AssistantChannelSettings | undefined;
+    autonomous?: AutonomousChannelSettings | undefined;
 }
 /**
+ * Who performed an action: an interactive user, an API key or an internal service.
  * @public
  */
-export interface VoiceChannelSettings {
-    enabled: boolean;
+export interface Actor {
+    type: ActorType;
     /**
-     * BCP-47 language tag used for transcription and synthesis, e.g. 'en-US'.
+     * User id, API key id or service name, depending on the actor type.
      * @public
      */
-    language: string;
-    synthesis: VoiceSynthesisSettings;
+    id: string;
     /**
-     * Message spoken when the call starts.
+     * Human readable name of the actor at the time of the action.
      * @public
      */
-    greeting?: string | undefined;
-    interruptions?: VoiceInterruptionSettings | undefined;
-    silenceTimeout?: VoiceSilenceTimeoutSettings | undefined;
-    maxDuration?: VoiceMaxDurationSettings | undefined;
-    endCall?: VoiceEndCallSettings | undefined;
+    name?: string | undefined;
+}
+/**
+ * @public
+ */
+export interface AgentDeploymentRoute {
     /**
-     * Caller context injected into the model prompt.
+     * Immutable published agent version identifier (nanoid).
      * @public
      */
-    callerMetadata?: VoiceCallerMetadataSettings | undefined;
+    version: string;
+    /**
+     * Percentage of eligible new sessions routed to this version. Percentages in a deployment must sum to 100.
+     * @public
+     */
+    percentage: number;
 }
 /**
+ * Standard audit fields carried by every managed resource.
  * @public
  */
-export interface AgentChannels {
-    assistant?: AssistantChannelSettings | undefined;
-    chat?: ChatChannelSettings | undefined;
-    voice?: VoiceChannelSettings | undefined;
-    api?: ApiChannelSettings | undefined;
+export interface AgentDeployment {
+    /**
+     * ISO-8601 timestamp with millisecond precision, e.g. '2026-07-10T14:12:30.123Z'.
+     * @public
+     */
+    createdAt: string;
+    /**
+     * Who performed an action: an interactive user, an API key or an internal service.
+     * @public
+     */
+    createdBy: Actor;
+    /**
+     * ISO-8601 timestamp with millisecond precision, e.g. '2026-07-10T14:12:30.123Z'.
+     * @public
+     */
+    updatedAt?: string | undefined;
+    /**
+     * Who performed an action: an interactive user, an API key or an internal service.
+     * @public
+     */
+    updatedBy?: Actor | undefined;
+    agentId: string;
+    /**
+     * Deployment name, e.g. 'production' or 'staging'. Sessions default to 'production' when no deployment, version or draft selector is provided.
+     * @public
+     */
+    name: string;
+    description?: string | undefined;
+    status: AgentDeploymentStatus;
+    /**
+     * Weighted routing over distinct published versions. Percentages must sum to 100. Selection is deterministic for a session, and the resolved version is pinned for the session lifetime.
+     * @public
+     */
+    routing: AgentDeploymentRoute[];
+    /**
+     * Monotonic revision incremented on every deployment update. Used for optimistic locking.
+     * @public
+     */
+    revision: number;
 }
 /**
+ * The model fills this variable itself, from conversation context. Included in the tool's input schema.
  * @public
  */
 export interface AgentToolVariableAutoHandler {
 }
 /**
+ * The model fills this variable, guided by this description. Included in the tool's input schema with the description attached.
  * @public
  */
 export interface AgentToolVariableGuidedHandler {
     description: string;
 }
 /**
+ * A fixed value bound to the variable and injected directly into the tool call. Not exposed to the model (excluded from the tool's input schema). Supports handlebars templates resolved against agent variables and session context (e.g. '\{\{callerName\}\}').
  * @public
  */
 export interface AgentToolVariablePredefinedHandler {
-    description: string;
+    value: string;
 }
 /**
  * @public
@@ -366,18 +366,30 @@ export type AgentToolVariableHandler = AgentToolVariableHandler.AutoMember | Age
  * @public
  */
 export declare namespace AgentToolVariableHandler {
+    /**
+     * The model fills this variable itself, from conversation context. Included in the tool's input schema.
+     * @public
+     */
     interface AutoMember {
         auto: AgentToolVariableAutoHandler;
         guided?: never;
         predefined?: never;
         $unknown?: never;
     }
+    /**
+     * The model fills this variable, guided by this description. Included in the tool's input schema with the description attached.
+     * @public
+     */
     interface GuidedMember {
         auto?: never;
         guided: AgentToolVariableGuidedHandler;
         predefined?: never;
         $unknown?: never;
     }
+    /**
+     * A fixed value bound to the variable and injected directly into the tool call. Not exposed to the model (excluded from the tool's input schema). Supports handlebars templates resolved against agent variables and session context (e.g. '\{\{callerName\}\}').
+     * @public
+     */
     interface PredefinedMember {
         auto?: never;
         guided?: never;
@@ -416,84 +428,146 @@ export interface AgentToolVariable {
     handler?: AgentToolVariableHandler | undefined;
 }
 /**
- * Invoke another agent as a dedicated execution with its own state. The called agent runs independently and returns its result.
+ * Invoke another agent (typically an autonomous agent) as a dedicated execution with its own state. The called agent runs independently and returns its result.
  * @public
  */
 export interface AgentCallCapability {
     agentId: string;
+    /**
+     * Pin a specific published version of the called agent. Mutually exclusive with agentDeployment.
+     * @public
+     */
+    agentVersion?: string | undefined;
+    /**
+     * Resolve the called agent through this deployment. When neither agentVersion nor agentDeployment is set, the called agent's 'production' deployment is resolved at invocation time.
+     * @public
+     */
+    agentDeployment?: string | undefined;
+    /**
+     * Who may invoke this sub-agent tool. Evaluated per invoking user when the calling agent (chat / assistant) builds its
+     *         toolset: if the user is not granted, this capability is omitted from the tools offered to the model for that session.
+     *         When omitted, the tool is available to everyone who can use the calling agent. This is where an autonomous agent's
+     *         invocation access is configured, since autonomous agents have no agent-level access of their own.
+     * @public
+     */
+    access?: AgentAccess | undefined;
     variables?: AgentToolVariable[] | undefined;
 }
 /**
- * Delegate the conversation to another agent (max 3 transitions per turn).
+ * Comment annotation emitted after a tool completes.
  * @public
  */
-export interface AgentDelegationCapability {
+export interface AgentToolCommentAnnotation {
     /**
-     * Agents this agent may delegate to. Empty list means any agent of the company.
+     * Static handlebars expression resolved against agent variables and helpers.
      * @public
      */
-    agents?: string[] | undefined;
+    value?: string | undefined;
     /**
-     * Extra instructions for when the agent should delegate.
+     * Apply when the tool succeeds.
      * @public
      */
-    instructions?: string | undefined;
+    applyOnSuccess?: boolean | undefined;
+    /**
+     * Apply when the tool fails.
+     * @public
+     */
+    applyOnFailure?: boolean | undefined;
 }
 /**
+ * Result annotation emitted after a tool completes.
  * @public
  */
-export interface WebhookAuthorizationBasic {
-    username: string;
-    password: string;
+export interface AgentToolResultAnnotation {
 }
 /**
+ * Tag annotation emitted after a tool completes.
  * @public
  */
-export interface WebhookAuthorizationBearer {
-    token: string;
+export interface AgentToolTagAnnotation {
+    /**
+     * Static handlebars expression resolved against agent variables and helpers.
+     * @public
+     */
+    value?: string | undefined;
+    /**
+     * Apply when the tool succeeds.
+     * @public
+     */
+    applyOnSuccess?: boolean | undefined;
+    /**
+     * Apply when the tool fails.
+     * @public
+     */
+    applyOnFailure?: boolean | undefined;
 }
 /**
+ * Variables annotation emitted after a tool completes.
  * @public
  */
-export interface WebhookAuthorizationOAuth {
-    clientId: string;
-    clientSecret: string;
-    endpointUrl: string;
-    scope?: string | undefined;
+export interface AgentToolVariablesAnnotation {
 }
 /**
+ * Configuration for annotations emitted after a tool completes.
  * @public
  */
-export type WebhookAuthorization = WebhookAuthorization.BasicMember | WebhookAuthorization.BearerMember | WebhookAuthorization.OauthMember | WebhookAuthorization.$UnknownMember;
+export type AgentToolAnnotation = AgentToolAnnotation.CommentMember | AgentToolAnnotation.ResultMember | AgentToolAnnotation.TagMember | AgentToolAnnotation.VariablesMember | AgentToolAnnotation.$UnknownMember;
 /**
  * @public
  */
-export declare namespace WebhookAuthorization {
-    interface BearerMember {
-        bearer: WebhookAuthorizationBearer;
-        basic?: never;
-        oauth?: never;
+export declare namespace AgentToolAnnotation {
+    /**
+     * Tag annotation emitted after a tool completes.
+     * @public
+     */
+    interface TagMember {
+        tag: AgentToolTagAnnotation;
+        comment?: never;
+        variables?: never;
+        result?: never;
+        $unknown?: never;
+    }
+    /**
+     * Comment annotation emitted after a tool completes.
+     * @public
+     */
+    interface CommentMember {
+        tag?: never;
+        comment: AgentToolCommentAnnotation;
+        variables?: never;
+        result?: never;
         $unknown?: never;
     }
-    interface BasicMember {
-        bearer?: never;
-        basic: WebhookAuthorizationBasic;
-        oauth?: never;
+    /**
+     * Variables annotation emitted after a tool completes.
+     * @public
+     */
+    interface VariablesMember {
+        tag?: never;
+        comment?: never;
+        variables: AgentToolVariablesAnnotation;
+        result?: never;
         $unknown?: never;
     }
-    interface OauthMember {
-        bearer?: never;
-        basic?: never;
-        oauth: WebhookAuthorizationOAuth;
+    /**
+     * Result annotation emitted after a tool completes.
+     * @public
+     */
+    interface ResultMember {
+        tag?: never;
+        comment?: never;
+        variables?: never;
+        result: AgentToolResultAnnotation;
         $unknown?: never;
     }
     /**
      * @public
      */
     interface $UnknownMember {
-        bearer?: never;
-        basic?: never;
-        oauth?: never;
+        tag?: never;
+        comment?: never;
+        variables?: never;
+        result?: never;
         $unknown: [string, any];
     }
     /**
@@ -501,103 +575,128 @@ export declare namespace WebhookAuthorization {
      *
      */
     interface Visitor<T> {
-        bearer: (value: WebhookAuthorizationBearer) => T;
-        basic: (value: WebhookAuthorizationBasic) => T;
-        oauth: (value: WebhookAuthorizationOAuth) => T;
+        tag: (value: AgentToolTagAnnotation) => T;
+        comment: (value: AgentToolCommentAnnotation) => T;
+        variables: (value: AgentToolVariablesAnnotation) => T;
+        result: (value: AgentToolResultAnnotation) => T;
         _: (name: string, value: any) => T;
     }
 }
 /**
+ * Delegate the conversation to another agent (max 3 transitions per turn). One capability entry per delegate target.
  * @public
  */
-export interface WebhookHeader {
-    name: string;
-    value: string;
-}
-/**
- * @public
- */
-export interface FunctionWebhookIntegration {
-    url: string;
-    method?: WebhookMethod | undefined;
+export interface AgentDelegationCapability {
     /**
-     * Fire-and-forget: do not wait for the webhook response.
+     * Tool name exposed to the model. Auto-generated when omitted.
      * @public
      */
-    async?: boolean | undefined;
-    authorization?: WebhookAuthorization | undefined;
-    headers?: WebhookHeader[] | undefined;
+    name?: string | undefined;
     /**
-     * Timeout in milliseconds for the webhook request.
+     * Description for the model to decide when to delegate.
      * @public
      */
-    timeout?: number | undefined;
+    description?: string | undefined;
+    /**
+     * Agent to delegate to.
+     * @public
+     */
+    id: string;
+    /**
+     * Pin a specific published version of the delegate agent. Mutually exclusive with agentDeployment.
+     * @public
+     */
+    agentVersion?: string | undefined;
     /**
-     * Request payload template (JSON).
+     * Resolve the delegate agent through this deployment. When neither agentVersion nor agentDeployment is set, the delegate's 'production' deployment is resolved at delegation time.
      * @public
      */
-    parameters?: __DocumentType | undefined;
+    agentDeployment?: string | undefined;
+    annotations?: AgentToolAnnotation[] | undefined;
 }
 /**
  * @public
  */
-export type FunctionIntegration = FunctionIntegration.WebhookMember | FunctionIntegration.$UnknownMember;
-/**
- * @public
- */
-export declare namespace FunctionIntegration {
-    interface WebhookMember {
-        webhook: FunctionWebhookIntegration;
-        $unknown?: never;
-    }
+export interface AgentHandoverPipeline {
+    type?: AgentHandoverPipelineType | undefined;
     /**
+     * Instructions for the model reply when type is REPLY_INSTRUCTED_AND_HANDOVER.
      * @public
      */
-    interface $UnknownMember {
-        webhook?: never;
-        $unknown: [string, any];
-    }
-    /**
-     * @deprecated unused in schema-serde mode.
-     *
-     */
-    interface Visitor<T> {
-        webhook: (value: FunctionWebhookIntegration) => T;
-        _: (name: string, value: any) => T;
-    }
+    instructions?: string | undefined;
 }
 /**
+ * Hand the conversation over to a human and leave it. Honoured on conversation channels (chat, assistant).
  * @public
  */
-export interface AgentFunctionTool {
-    name: string;
+export interface AgentHandoverCapability {
+    /**
+     * Tool name exposed to the model. Auto-generated when omitted.
+     * @public
+     */
+    name?: string | undefined;
     /**
-     * Used by the model to decide when to invoke the function.
+     * Description for the model to decide when to hand over.
      * @public
      */
     description?: string | undefined;
+    variant?: AgentHandoverVariant | undefined;
+    /**
+     * Wilma agent to hand over to when variant = AGENT.
+     * @public
+     */
+    agent?: string | undefined;
+    /**
+     * Pin a specific published version of the target agent when variant = AGENT. Mutually exclusive with agentDeployment.
+     * @public
+     */
+    agentVersion?: string | undefined;
+    /**
+     * Resolve the target agent through this deployment when variant = AGENT. When neither agentVersion nor agentDeployment is set, the target's 'production' deployment is resolved at handover time.
+     * @public
+     */
+    agentDeployment?: string | undefined;
     /**
-     * JSON Schema of the function parameters.
+     * x-bees service id to hand over to when variant = SERVICE.
      * @public
      */
-    parameters?: __DocumentType | undefined;
-    integration?: FunctionIntegration | undefined;
+    service?: string | undefined;
+    /**
+     * Hand over without posting a visible message to the user.
+     * @public
+     */
+    silent?: boolean | undefined;
+    pipeline?: AgentHandoverPipeline | undefined;
+    annotations?: AgentToolAnnotation[] | undefined;
 }
 /**
- * Hand the conversation over to a human and leave it. Honoured on conversation channels (chat, assistant).
  * @public
  */
-export interface AgentHandoverCapability {
+export interface AgentHangupPipeline {
+    type?: AgentHangupPipelineType | undefined;
     /**
-     * Extra instructions for when the agent should hand over.
+     * Instructions for the model reply when type is REPLY_INSTRUCTED_AND_HANGUP.
      * @public
      */
     instructions?: string | undefined;
+}
+/**
+ * Let the model end the call. Honoured on the voice channel. Maps from the wim-voicebots HANGUP embedded tool.
+ * @public
+ */
+export interface AgentHangupCapability {
     /**
-     * Message sent to the end user when the handover happens.
+     * Tool name exposed to the model. Auto-generated when omitted.
      * @public
      */
-    message?: string | undefined;
+    name?: string | undefined;
+    /**
+     * Description for the model to decide when to hang up.
+     * @public
+     */
+    description?: string | undefined;
+    pipeline?: AgentHangupPipeline | undefined;
+    annotations?: AgentToolAnnotation[] | undefined;
 }
 /**
  * @public
@@ -609,22 +708,10 @@ export interface AgentKnowledgeBase {
      * @public
      */
     instructions?: string | undefined;
+    annotations?: AgentToolAnnotation[] | undefined;
 }
 /**
- * Remote MCP (Model Context Protocol) server whose tools are exposed to the agent.
- * @public
- */
-export interface AgentMcpServerCapability {
-    url: string;
-    authorization?: WebhookAuthorization | undefined;
-    /**
-     * Restrict the tools exposed from this server. Empty list means all tools.
-     * @public
-     */
-    allowedTools?: string[] | undefined;
-}
-/**
- * Sandbox launched from a pre-built snapshot managed by the wilma-sandbox service.
+ * Sandbox launched from a pre-built snapshot managed by the wilma-sandbox service.
  * @public
  */
 export interface AgentSnapshotSandboxOptions {
@@ -716,10 +803,42 @@ export declare namespace AgentSandboxCapability {
     }
 }
 /**
- * Emit suggested replies for human operators instead of, or in addition to, answering directly. Honoured on the chat channel.
+ * Emit suggested replies for human operators. Honoured on the chat channel.
  * @public
  */
 export interface AgentSuggestionsCapability {
+    /**
+     * Tool name. Auto-generated when omitted.
+     * @public
+     */
+    name?: string | undefined;
+    annotations?: AgentToolAnnotation[] | undefined;
+}
+/**
+ * Human-in-the-loop confirmation for a tool. Presence requires approval: the agent pauses before running the tool and the session user (whoever controls the session) approves or denies inline.
+ * @public
+ */
+export interface AgentToolApproval {
+    /**
+     * Optional message shown in the confirmation prompt. Supports handlebars against agent variables and the pending tool arguments. When omitted, a default prompt is shown.
+     * @public
+     */
+    prompt?: string | undefined;
+}
+/**
+ * @public
+ */
+export interface AgentToolPipeline {
+    /**
+     * How the model waits for a tool and whether it synthesizes a reply from the result. Mirrors the legacy VoiceBot/Bot capability-tool pipeline.
+     * @public
+     */
+    type?: AgentToolPipelineType | undefined;
+    /**
+     * Reply instructions for the *_GUIDED pipeline types. Use \{\{response\}\} to reference the tool result.
+     * @public
+     */
+    instructions?: string | undefined;
 }
 /**
  * @public
@@ -731,19 +850,85 @@ export interface AgentTool {
      */
     id: string;
     variables?: AgentToolVariable[] | undefined;
+    /**
+     * Message spoken when the tool call starts. Honoured on the voice channel. Maps from the legacy wim-voicebots capability-tool `startMessage`.
+     * @public
+     */
+    startMessage?: string | undefined;
+    /**
+     * How the model waits for the tool and whether it synthesizes a reply from the result.
+     * @public
+     */
+    pipeline?: AgentToolPipeline | undefined;
+    /**
+     * When present, the tool requires inline approval from the session user before it runs. New feature; no legacy equivalent.
+     * @public
+     */
+    approval?: AgentToolApproval | undefined;
+    annotations?: AgentToolAnnotation[] | undefined;
 }
 /**
- * Transfer the interaction to a PBX destination. Honoured on the voice channel.
  * @public
  */
-export interface AgentTransferCapability {
-    targets: VoiceTransferTarget[];
+export interface AgentTransferPipeline {
+    type?: AgentTransferPipelineType | undefined;
     /**
-     * Extra instructions for when the agent should transfer.
+     * Instructions for the model reply when type is REPLY_INSTRUCTED_AND_TRANSFER.
      * @public
      */
     instructions?: string | undefined;
 }
+/**
+ * Transfer the call to a PBX destination. Honoured on the voice channel. One capability entry per transfer target.
+ * @public
+ */
+export interface AgentTransferCapability {
+    /**
+     * Tool name exposed to the model. Auto-generated when omitted.
+     * @public
+     */
+    name?: string | undefined;
+    /**
+     * Description for the model to decide when to transfer.
+     * @public
+     */
+    description?: string | undefined;
+    variant?: AgentTransferVariant | undefined;
+    /**
+     * Routing context for PREDEFINED transfers.
+     * @public
+     */
+    context?: string | undefined;
+    /**
+     * Extension or phone number for PREDEFINED transfers.
+     * @public
+     */
+    extension?: string | undefined;
+    pipeline?: AgentTransferPipeline | undefined;
+    annotations?: AgentToolAnnotation[] | undefined;
+}
+/**
+ * Let the model hold the call while it works (e.g. a lookup), keeping the caller on the line. Honoured on the voice channel. Maps from the wim-voicebots WAIT embedded tool.
+ * @public
+ */
+export interface AgentWaitCapability {
+    /**
+     * Tool name exposed to the model. Auto-generated when omitted.
+     * @public
+     */
+    name?: string | undefined;
+    /**
+     * Description for the model to decide when to wait.
+     * @public
+     */
+    description?: string | undefined;
+    /**
+     * Message spoken when entering the wait state.
+     * @public
+     */
+    message?: string | undefined;
+    annotations?: AgentToolAnnotation[] | undefined;
+}
 /**
  * Server-side fetch of a URL, returning its readable text/markdown to the model.
  * @public
@@ -792,54 +977,39 @@ export interface AgentWebSearchCapability {
 /**
  * @public
  */
-export type AgentCapability = AgentCapability.AgentMember | AgentCapability.DelegationMember | AgentCapability.FunctionMember | AgentCapability.HandoverMember | AgentCapability.KbMember | AgentCapability.McpMember | AgentCapability.SandboxMember | AgentCapability.SuggestionsMember | AgentCapability.ToolMember | AgentCapability.TransferMember | AgentCapability.WebFetchMember | AgentCapability.WebSearchMember | AgentCapability.$UnknownMember;
+export type AgentCapability = AgentCapability.AgentMember | AgentCapability.DelegationMember | AgentCapability.HandoverMember | AgentCapability.HangupMember | AgentCapability.KbMember | AgentCapability.SandboxMember | AgentCapability.SuggestionsMember | AgentCapability.ToolMember | AgentCapability.TransferMember | AgentCapability.WaitMember | AgentCapability.WebFetchMember | AgentCapability.WebSearchMember | AgentCapability.$UnknownMember;
 /**
  * @public
  */
 export declare namespace AgentCapability {
     interface ToolMember {
         tool: AgentTool;
-        function?: never;
         kb?: never;
         sandbox?: never;
         webSearch?: never;
         webFetch?: never;
         agent?: never;
-        mcp?: never;
-        handover?: never;
-        delegation?: never;
-        transfer?: never;
-        suggestions?: never;
-        $unknown?: never;
-    }
-    interface FunctionMember {
-        tool?: never;
-        function: AgentFunctionTool;
-        kb?: never;
-        sandbox?: never;
-        webSearch?: never;
-        webFetch?: never;
-        agent?: never;
-        mcp?: never;
         handover?: never;
         delegation?: never;
         transfer?: never;
         suggestions?: never;
+        hangup?: never;
+        wait?: never;
         $unknown?: never;
     }
     interface KbMember {
         tool?: never;
-        function?: never;
         kb: AgentKnowledgeBase;
         sandbox?: never;
         webSearch?: never;
         webFetch?: never;
         agent?: never;
-        mcp?: never;
         handover?: never;
         delegation?: never;
         transfer?: never;
         suggestions?: never;
+        hangup?: never;
+        wait?: never;
         $unknown?: never;
     }
     /**
@@ -848,17 +1018,17 @@ export declare namespace AgentCapability {
      */
     interface SandboxMember {
         tool?: never;
-        function?: never;
         kb?: never;
         sandbox: AgentSandboxCapability;
         webSearch?: never;
         webFetch?: never;
         agent?: never;
-        mcp?: never;
         handover?: never;
         delegation?: never;
         transfer?: never;
         suggestions?: never;
+        hangup?: never;
+        wait?: never;
         $unknown?: never;
     }
     /**
@@ -867,17 +1037,17 @@ export declare namespace AgentCapability {
      */
     interface WebSearchMember {
         tool?: never;
-        function?: never;
         kb?: never;
         sandbox?: never;
         webSearch: AgentWebSearchCapability;
         webFetch?: never;
         agent?: never;
-        mcp?: never;
         handover?: never;
         delegation?: never;
         transfer?: never;
         suggestions?: never;
+        hangup?: never;
+        wait?: never;
         $unknown?: never;
     }
     /**
@@ -886,131 +1056,150 @@ export declare namespace AgentCapability {
      */
     interface WebFetchMember {
         tool?: never;
-        function?: never;
         kb?: never;
         sandbox?: never;
         webSearch?: never;
         webFetch: AgentWebFetchCapability;
         agent?: never;
-        mcp?: never;
         handover?: never;
         delegation?: never;
         transfer?: never;
         suggestions?: never;
+        hangup?: never;
+        wait?: never;
         $unknown?: never;
     }
     /**
-     * Invoke another agent as a dedicated execution with its own state. The called agent runs independently and returns its result.
+     * Invoke another agent (typically an autonomous agent) as a dedicated execution with its own state. The called agent runs independently and returns its result.
      * @public
      */
     interface AgentMember {
         tool?: never;
-        function?: never;
         kb?: never;
         sandbox?: never;
         webSearch?: never;
         webFetch?: never;
         agent: AgentCallCapability;
-        mcp?: never;
         handover?: never;
         delegation?: never;
         transfer?: never;
         suggestions?: never;
+        hangup?: never;
+        wait?: never;
         $unknown?: never;
     }
     /**
-     * Remote MCP (Model Context Protocol) server whose tools are exposed to the agent.
+     * Hand the conversation over to a human and leave it. Honoured on conversation channels (chat, assistant).
      * @public
      */
-    interface McpMember {
+    interface HandoverMember {
         tool?: never;
-        function?: never;
         kb?: never;
         sandbox?: never;
         webSearch?: never;
         webFetch?: never;
         agent?: never;
-        mcp: AgentMcpServerCapability;
-        handover?: never;
+        handover: AgentHandoverCapability;
         delegation?: never;
         transfer?: never;
         suggestions?: never;
+        hangup?: never;
+        wait?: never;
         $unknown?: never;
     }
     /**
-     * Hand the conversation over to a human and leave it. Honoured on conversation channels (chat, assistant).
+     * Delegate the conversation to another agent (max 3 transitions per turn). One capability entry per delegate target.
      * @public
      */
-    interface HandoverMember {
+    interface DelegationMember {
         tool?: never;
-        function?: never;
         kb?: never;
         sandbox?: never;
         webSearch?: never;
         webFetch?: never;
         agent?: never;
-        mcp?: never;
-        handover: AgentHandoverCapability;
-        delegation?: never;
+        handover?: never;
+        delegation: AgentDelegationCapability;
         transfer?: never;
         suggestions?: never;
+        hangup?: never;
+        wait?: never;
         $unknown?: never;
     }
     /**
-     * Delegate the conversation to another agent (max 3 transitions per turn).
+     * Transfer the call to a PBX destination. Honoured on the voice channel. One capability entry per transfer target.
      * @public
      */
-    interface DelegationMember {
+    interface TransferMember {
         tool?: never;
-        function?: never;
         kb?: never;
         sandbox?: never;
         webSearch?: never;
         webFetch?: never;
         agent?: never;
-        mcp?: never;
         handover?: never;
-        delegation: AgentDelegationCapability;
-        transfer?: never;
+        delegation?: never;
+        transfer: AgentTransferCapability;
         suggestions?: never;
+        hangup?: never;
+        wait?: never;
         $unknown?: never;
     }
     /**
-     * Transfer the interaction to a PBX destination. Honoured on the voice channel.
+     * Emit suggested replies for human operators. Honoured on the chat channel.
      * @public
      */
-    interface TransferMember {
+    interface SuggestionsMember {
         tool?: never;
-        function?: never;
         kb?: never;
         sandbox?: never;
         webSearch?: never;
         webFetch?: never;
         agent?: never;
-        mcp?: never;
         handover?: never;
         delegation?: never;
-        transfer: AgentTransferCapability;
+        transfer?: never;
+        suggestions: AgentSuggestionsCapability;
+        hangup?: never;
+        wait?: never;
+        $unknown?: never;
+    }
+    /**
+     * Let the model end the call. Honoured on the voice channel. Maps from the wim-voicebots HANGUP embedded tool.
+     * @public
+     */
+    interface HangupMember {
+        tool?: never;
+        kb?: never;
+        sandbox?: never;
+        webSearch?: never;
+        webFetch?: never;
+        agent?: never;
+        handover?: never;
+        delegation?: never;
+        transfer?: never;
         suggestions?: never;
+        hangup: AgentHangupCapability;
+        wait?: never;
         $unknown?: never;
     }
     /**
-     * Emit suggested replies for human operators instead of, or in addition to, answering directly. Honoured on the chat channel.
+     * Let the model hold the call while it works (e.g. a lookup), keeping the caller on the line. Honoured on the voice channel. Maps from the wim-voicebots WAIT embedded tool.
      * @public
      */
-    interface SuggestionsMember {
+    interface WaitMember {
         tool?: never;
-        function?: never;
         kb?: never;
         sandbox?: never;
         webSearch?: never;
         webFetch?: never;
         agent?: never;
-        mcp?: never;
         handover?: never;
         delegation?: never;
         transfer?: never;
-        suggestions: AgentSuggestionsCapability;
+        suggestions?: never;
+        hangup?: never;
+        wait: AgentWaitCapability;
         $unknown?: never;
     }
     /**
@@ -1018,17 +1207,17 @@ export declare namespace AgentCapability {
      */
     interface $UnknownMember {
         tool?: never;
-        function?: never;
         kb?: never;
         sandbox?: never;
         webSearch?: never;
         webFetch?: never;
         agent?: never;
-        mcp?: never;
         handover?: never;
         delegation?: never;
         transfer?: never;
         suggestions?: never;
+        hangup?: never;
+        wait?: never;
         $unknown: [string, any];
     }
     /**
@@ -1037,20 +1226,37 @@ export declare namespace AgentCapability {
      */
     interface Visitor<T> {
         tool: (value: AgentTool) => T;
-        function: (value: AgentFunctionTool) => T;
         kb: (value: AgentKnowledgeBase) => T;
         sandbox: (value: AgentSandboxCapability) => T;
         webSearch: (value: AgentWebSearchCapability) => T;
         webFetch: (value: AgentWebFetchCapability) => T;
         agent: (value: AgentCallCapability) => T;
-        mcp: (value: AgentMcpServerCapability) => T;
         handover: (value: AgentHandoverCapability) => T;
         delegation: (value: AgentDelegationCapability) => T;
         transfer: (value: AgentTransferCapability) => T;
         suggestions: (value: AgentSuggestionsCapability) => T;
+        hangup: (value: AgentHangupCapability) => T;
+        wait: (value: AgentWaitCapability) => T;
         _: (name: string, value: any) => T;
     }
 }
+/**
+ * Reference to a skill attached to an agent.
+ * @public
+ */
+export interface AgentSkillReference {
+    id: string;
+    /**
+     * Pin a specific published skill version. When omitted, latestVersion is resolved.
+     * @public
+     */
+    skillVersion?: string | undefined;
+    /**
+     * Override access for this skill on this agent. When omitted, the agent's default access policy applies.
+     * @public
+     */
+    access?: AgentAccess | undefined;
+}
 /**
  * @public
  */
@@ -1065,10 +1271,10 @@ export interface AgentVariable {
     description?: string | undefined;
 }
 /**
- * Managed LLM engine: the platform runs the model, tools and knowledge lookups.
+ * Managed AI engine: the platform runs the model, tools and knowledge lookups.
  * @public
  */
-export interface AgentLlmEngine {
+export interface AgentAiEngine {
     instructions: string;
     /**
      * Defaults to the platform default model when omitted.
@@ -1079,7 +1285,7 @@ export interface AgentLlmEngine {
      * Skills attached to this agent (progressive disclosure).
      * @public
      */
-    skills?: string[] | undefined;
+    skills?: AgentSkillReference[] | undefined;
     capabilities?: AgentCapability[] | undefined;
     variables?: AgentVariable[] | undefined;
 }
@@ -1106,19 +1312,20 @@ export interface AgentWebhookEngine {
     timeout?: number | undefined;
 }
 /**
+ * How the agent produces replies. `ai` is the managed engine; `webhook` and `sqs` delegate to an external backend. The legacy Dialogflow CX and OpenAI Assistant backends are intentionally not carried over.
  * @public
  */
-export type AgentEngine = AgentEngine.LlmMember | AgentEngine.SqsMember | AgentEngine.WebhookMember | AgentEngine.$UnknownMember;
+export type AgentEngine = AgentEngine.AiMember | AgentEngine.SqsMember | AgentEngine.WebhookMember | AgentEngine.$UnknownMember;
 /**
  * @public
  */
 export declare namespace AgentEngine {
     /**
-     * Managed LLM engine: the platform runs the model, tools and knowledge lookups.
+     * Managed AI engine: the platform runs the model, tools and knowledge lookups.
      * @public
      */
-    interface LlmMember {
-        llm: AgentLlmEngine;
+    interface AiMember {
+        ai: AgentAiEngine;
         webhook?: never;
         sqs?: never;
         $unknown?: never;
@@ -1128,7 +1335,7 @@ export declare namespace AgentEngine {
      * @public
      */
     interface WebhookMember {
-        llm?: never;
+        ai?: never;
         webhook: AgentWebhookEngine;
         sqs?: never;
         $unknown?: never;
@@ -1138,7 +1345,7 @@ export declare namespace AgentEngine {
      * @public
      */
     interface SqsMember {
-        llm?: never;
+        ai?: never;
         webhook?: never;
         sqs: AgentSqsEngine;
         $unknown?: never;
@@ -1147,7 +1354,7 @@ export declare namespace AgentEngine {
      * @public
      */
     interface $UnknownMember {
-        llm?: never;
+        ai?: never;
         webhook?: never;
         sqs?: never;
         $unknown: [string, any];
@@ -1157,12 +1364,23 @@ export declare namespace AgentEngine {
      *
      */
     interface Visitor<T> {
-        llm: (value: AgentLlmEngine) => T;
+        ai: (value: AgentAiEngine) => T;
         webhook: (value: AgentWebhookEngine) => T;
         sqs: (value: AgentSqsEngine) => T;
         _: (name: string, value: any) => T;
     }
 }
+/**
+ * Agent-level settings shared across all channels.
+ * @public
+ */
+export interface AgentSettings {
+    /**
+     * PBX group used for data ACL (e.g. Sales Intelligence lookups). Maps from the legacy wim-voicebots / xbees-users bot `groupId`.
+     * @public
+     */
+    pbxGroupId?: string | undefined;
+}
 /**
  * The complete, versionable configuration of an agent. This is what gets snapshotted when a version is published.
  * @public
@@ -1180,20 +1398,31 @@ export interface Agent {
      * @public
      */
     picture?: string | undefined;
+    /**
+     * The channels this agent serves and their channel-specific settings. A channel is enabled when its member is present; at least one must be set. An agent may serve multiple channels (e.g. chat + assistant) over the shared engine.
+     * @public
+     */
+    channels: AgentChannels;
+    /**
+     * How the agent produces replies. `ai` is the managed engine; `webhook` and `sqs` delegate to an external backend. The legacy Dialogflow CX and OpenAI Assistant backends are intentionally not carried over.
+     * @public
+     */
     engine: AgentEngine;
     /**
-     * Per-channel deployment settings. An agent is reachable only on channels configured here.
+     * Agent-level settings shared across all channels.
      * @public
      */
-    channels?: AgentChannels | undefined;
+    settings?: AgentSettings | undefined;
     /**
-     * Guardrail policies applied to this agent's inputs and outputs.
+     * Who is allowed to use the agent. There is no view/edit dimension — access solely grants the ability to use the agent.
+     *     Per channel: on `chat` and `assistant` agents `grants` govern which colleagues can use the agent; on `voice` agents `grants`
+     *     are ignored (inbound calls are routed by the PBX dialplan, and data ACL is the agent-level `settings.pbxGroupId`); on `autonomous` agents agent-level
+     *     access is not used — invocation access is configured per reference on the calling agent (see AgentCallCapability.access).
      * @public
      */
-    guardrails?: string[] | undefined;
     access?: AgentAccess | undefined;
     /**
-     * ISO-8601 timestamp, e.g. '2026-07-03T10:15:30.000Z'.
+     * ISO-8601 timestamp with millisecond precision, e.g. '2026-07-10T14:12:30.123Z'.
      * @public
      */
     createdAt: string;
@@ -1203,7 +1432,7 @@ export interface Agent {
      */
     createdBy: Actor;
     /**
-     * ISO-8601 timestamp, e.g. '2026-07-03T10:15:30.000Z'.
+     * ISO-8601 timestamp with millisecond precision, e.g. '2026-07-10T14:12:30.123Z'.
      * @public
      */
     updatedAt?: string | undefined;
@@ -1220,15 +1449,20 @@ export interface Agent {
      */
     revision: number;
     /**
-     * Latest published version number; absent while the agent is still a draft.
+     * Latest published version id; absent while the agent is still a draft.
+     * @public
+     */
+    latestVersion?: string | undefined;
+    /**
+     * Published version from which the current draft originated. Absent before the first version is published.
      * @public
      */
-    latestVersion?: number | undefined;
+    draftBaseVersion?: string | undefined;
     /**
-     * Aliases of this agent with their version routing (e.g. 'production', 'staging').
+     * Named deployment configurations routing new sessions to published versions.
      * @public
      */
-    aliases?: AgentAlias[] | undefined;
+    deployments?: AgentDeployment[] | undefined;
 }
 /**
  * @public
@@ -1242,7 +1476,7 @@ export interface AgentApiKey {
      */
     prefix: string;
     /**
-     * ISO-8601 timestamp, e.g. '2026-07-03T10:15:30.000Z'.
+     * ISO-8601 timestamp with millisecond precision, e.g. '2026-07-10T14:12:30.123Z'.
      * @public
      */
     createdAt: string;
@@ -1252,12 +1486,12 @@ export interface AgentApiKey {
      */
     createdBy: Actor;
     /**
-     * ISO-8601 timestamp, e.g. '2026-07-03T10:15:30.000Z'.
+     * ISO-8601 timestamp with millisecond precision, e.g. '2026-07-10T14:12:30.123Z'.
      * @public
      */
     expiresAt?: string | undefined;
     /**
-     * ISO-8601 timestamp, e.g. '2026-07-03T10:15:30.000Z'.
+     * ISO-8601 timestamp with millisecond precision, e.g. '2026-07-10T14:12:30.123Z'.
      * @public
      */
     lastUsedAt?: string | undefined;
@@ -1279,118 +1513,74 @@ export interface AgentDefinitionSnapshot {
      * @public
      */
     picture?: string | undefined;
-    engine: AgentEngine;
     /**
-     * Per-channel deployment settings. An agent is reachable only on channels configured here.
+     * The channels this agent serves and their channel-specific settings. A channel is enabled when its member is present; at least one must be set. An agent may serve multiple channels (e.g. chat + assistant) over the shared engine.
      * @public
      */
-    channels?: AgentChannels | undefined;
+    channels: AgentChannels;
     /**
-     * Guardrail policies applied to this agent's inputs and outputs.
+     * How the agent produces replies. `ai` is the managed engine; `webhook` and `sqs` delegate to an external backend. The legacy Dialogflow CX and OpenAI Assistant backends are intentionally not carried over.
      * @public
      */
-    guardrails?: string[] | undefined;
-    access?: AgentAccess | undefined;
-}
-/**
- * @public
- */
-export interface AgentExecutionError {
-    message: string;
+    engine: AgentEngine;
     /**
-     * Machine-readable error code, e.g. 'guardrail_blocked', 'engine_error'.
+     * Agent-level settings shared across all channels.
      * @public
      */
-    code?: string | undefined;
+    settings?: AgentSettings | undefined;
+    /**
+     * Who is allowed to use the agent. There is no view/edit dimension — access solely grants the ability to use the agent.
+     *     Per channel: on `chat` and `assistant` agents `grants` govern which colleagues can use the agent; on `voice` agents `grants`
+     *     are ignored (inbound calls are routed by the PBX dialplan, and data ACL is the agent-level `settings.pbxGroupId`); on `autonomous` agents agent-level
+     *     access is not used — invocation access is configured per reference on the calling agent (see AgentCallCapability.access).
+     * @public
+     */
+    access?: AgentAccess | undefined;
 }
 /**
- * A file produced (or shared) by an agent during a session or execution. Content lives in object storage; download via the Files API.
  * @public
  */
-export interface AgentFile {
-    /**
-     * Nano-id file identifier (12 characters).
-     * @public
-     */
+export interface AgentInfo {
     id: string;
     name: string;
+    category?: string | undefined;
+    status: AgentStatus;
     /**
-     * MIME type, e.g. 'text/csv'.
-     * @public
-     */
-    contentType?: string | undefined;
-    /**
-     * Size in bytes.
-     * @public
-     */
-    size?: number | undefined;
-    /**
-     * Intended audience. Defaults to USER.
-     * @public
-     */
-    scope?: AgentFileScope | undefined;
-    /**
-     * Agent that created the file.
-     * @public
-     */
-    agentId?: string | undefined;
-    /**
-     * Session that created the file.
+     * The channels this agent serves (voice / chat / assistant / autonomous).
      * @public
      */
-    sessionId?: string | undefined;
+    channels: ChannelType[];
     /**
-     * ISO-8601 timestamp, e.g. '2026-07-03T10:15:30.000Z'.
+     * Immutable published agent version identifier (nanoid).
      * @public
      */
-    createdAt: string;
+    latestVersion?: string | undefined;
 }
 /**
  * @public
  */
-export interface AgentExecutionResult {
-    /**
-     * Output of the execution.
-     * @public
-     */
-    output?: __DocumentType | undefined;
-    error?: AgentExecutionError | undefined;
+export interface AgentVersion {
+    agentId: string;
     /**
-     * Files created by the agent during execution (downloadable via the Files API).
+     * Immutable published agent version identifier (nanoid).
      * @public
      */
-    files?: AgentFile[] | undefined;
+    version: string;
     /**
-     * Trace produced by this execution, inspectable via the wilma-traces API.
+     * Monotonic sequence within the agent's published version history, starting at 1. Used for human-facing labels such as v13; version remains the stable identifier.
      * @public
      */
-    traceId?: string | undefined;
-}
-/**
- * @public
- */
-export interface AgentInfo {
-    id: string;
-    name: string;
-    category?: string | undefined;
-    status: AgentStatus;
+    sequence: number;
     /**
-     * Channels this agent is deployed to.
+     * Published version from which the draft originated. Absent for the first version of a new agent.
      * @public
      */
-    channels?: ChannelType[] | undefined;
-    latestVersion?: number | undefined;
-}
-/**
- * @public
- */
-export interface AgentVersion {
-    agentId: string;
+    basedOnVersion?: string | undefined;
     /**
-     * Monotonic version number, starting at 1.
+     * Optional human-readable name supplied at publish time.
      * @public
      */
-    version: number;
+    name?: string | undefined;
     /**
      * What changed in this version, provided at publish time.
      * @public
@@ -1402,7 +1592,7 @@ export interface AgentVersion {
      */
     definition: AgentDefinitionSnapshot;
     /**
-     * ISO-8601 timestamp, e.g. '2026-07-03T10:15:30.000Z'.
+     * ISO-8601 timestamp with millisecond precision, e.g. '2026-07-10T14:12:30.123Z'.
      * @public
      */
     publishedAt: string;
@@ -1417,7 +1607,7 @@ export interface AgentVersion {
  */
 export interface AgentVersionChange {
     /**
-     * JSON pointer of the changed field within the agent definition, e.g. '/engine/llm/instructions'.
+     * JSON pointer of the changed field within the agent definition, e.g. '/engine/ai/instructions'.
      * @public
      */
     path: string;
@@ -1438,57 +1628,38 @@ export interface AgentVersionChange {
  */
 export interface AgentVersionInfo {
     agentId: string;
-    version: number;
-    changelog?: string | undefined;
     /**
-     * ISO-8601 timestamp, e.g. '2026-07-03T10:15:30.000Z'.
+     * Immutable published agent version identifier (nanoid).
      * @public
      */
-    publishedAt: string;
+    version: string;
+    sequence: number;
     /**
-     * Who performed an action: an interactive user, an API key or an internal service.
+     * Immutable published agent version identifier (nanoid).
      * @public
      */
-    publishedBy: Actor;
+    basedOnVersion?: string | undefined;
+    name?: string | undefined;
     /**
-     * Names of the aliases currently routing to this version.
+     * Human-readable description of what changed in a published version.
      * @public
      */
-    aliases?: string[] | undefined;
-}
-/**
- * @public
- */
-export interface AuditRecord {
-    id: string;
+    changelog?: string | undefined;
     /**
-     * ISO-8601 timestamp, e.g. '2026-07-03T10:15:30.000Z'.
+     * ISO-8601 timestamp with millisecond precision, e.g. '2026-07-10T14:12:30.123Z'.
      * @public
      */
-    timestamp: string;
+    publishedAt: string;
     /**
      * Who performed an action: an interactive user, an API key or an internal service.
      * @public
      */
-    actor: Actor;
-    action: AuditAction;
-    resourceType: AuditResourceType;
-    resourceId: string;
-    /**
-     * The agent this record relates to, when the resource belongs to an agent.
-     * @public
-     */
-    agentId?: string | undefined;
-    /**
-     * Field-level before/after values for update actions.
-     * @public
-     */
-    changes?: AgentVersionChange[] | undefined;
+    publishedBy: Actor;
     /**
-     * Correlation id of the API request that caused the change.
+     * Names of the deployments currently routing traffic to this version.
      * @public
      */
-    requestId?: string | undefined;
+    deployments?: string[] | undefined;
 }
 /**
  * @public
@@ -1497,15 +1668,25 @@ export interface CompareAgentVersionsInput {
     company?: string | undefined;
     agentId: string;
     /**
-     * Base version. 0 means the current draft.
+     * Base published version id. Omit when fromDraft is true.
+     * @public
+     */
+    from?: string | undefined;
+    /**
+     * Compare against the current draft instead of a published version.
      * @public
      */
-    from: number;
+    fromDraft?: boolean | undefined;
     /**
-     * Target version. 0 means the current draft.
+     * Target published version id. Omit when toDraft is true.
      * @public
      */
-    to: number;
+    to?: string | undefined;
+    /**
+     * Compare against the current draft instead of a published version.
+     * @public
+     */
+    toDraft?: boolean | undefined;
 }
 /**
  * @public
@@ -1530,17 +1711,28 @@ export interface CreateAgentInput {
      * @public
      */
     picture?: string | undefined;
+    /**
+     * The channels this agent serves and their channel-specific settings. A channel is enabled when its member is present; at least one must be set. An agent may serve multiple channels (e.g. chat + assistant) over the shared engine.
+     * @public
+     */
+    channels: AgentChannels;
+    /**
+     * How the agent produces replies. `ai` is the managed engine; `webhook` and `sqs` delegate to an external backend. The legacy Dialogflow CX and OpenAI Assistant backends are intentionally not carried over.
+     * @public
+     */
     engine: AgentEngine;
     /**
-     * Per-channel deployment settings. An agent is reachable only on channels configured here.
+     * Agent-level settings shared across all channels.
      * @public
      */
-    channels?: AgentChannels | undefined;
+    settings?: AgentSettings | undefined;
     /**
-     * Guardrail policies applied to this agent's inputs and outputs.
+     * Who is allowed to use the agent. There is no view/edit dimension — access solely grants the ability to use the agent.
+     *     Per channel: on `chat` and `assistant` agents `grants` govern which colleagues can use the agent; on `voice` agents `grants`
+     *     are ignored (inbound calls are routed by the PBX dialplan, and data ACL is the agent-level `settings.pbxGroupId`); on `autonomous` agents agent-level
+     *     access is not used — invocation access is configured per reference on the calling agent (see AgentCallCapability.access).
      * @public
      */
-    guardrails?: string[] | undefined;
     access?: AgentAccess | undefined;
     company?: string | undefined;
 }
@@ -1581,164 +1773,27 @@ export interface CreateAgentApiKeyOutput {
 /**
  * @public
  */
-export interface GuardrailContentFilter {
-    category: GuardrailContentCategory;
-    /**
-     * Strength applied to user input. Defaults to NONE.
-     * @public
-     */
-    inputStrength?: GuardrailFilterStrength | undefined;
-    /**
-     * Strength applied to agent output. Defaults to NONE.
-     * @public
-     */
-    outputStrength?: GuardrailFilterStrength | undefined;
-}
-/**
- * @public
- */
-export interface GuardrailContentPolicy {
-    filters: GuardrailContentFilter[];
-}
-/**
- * @public
- */
-export interface GuardrailPiiEntity {
-    entityType: GuardrailPiiEntityType;
-    /**
-     * Regex for CUSTOM entities.
-     * @public
-     */
-    pattern?: string | undefined;
-    action: GuardrailPiiAction;
-}
-/**
- * @public
- */
-export interface GuardrailPiiPolicy {
-    entities: GuardrailPiiEntity[];
-}
-/**
- * @public
- */
-export interface GuardrailTopic {
-    /**
-     * Short topic name, e.g. 'investment-advice'.
-     * @public
-     */
-    name: string;
-    /**
-     * Natural-language definition of the topic used by the classifier.
-     * @public
-     */
-    definition: string;
-    /**
-     * Example phrases that belong to the topic, to sharpen classification.
-     * @public
-     */
-    examples?: string[] | undefined;
-    /**
-     * What to do when a policy matches.
-     * @public
-     */
-    action: GuardrailAction;
-}
-/**
- * @public
- */
-export interface GuardrailTopicPolicy {
-    topics: GuardrailTopic[];
-}
-/**
- * @public
- */
-export interface GuardrailWordPolicy {
-    /**
-     * Exact words or phrases to block.
-     * @public
-     */
-    blockedWords?: string[] | undefined;
-    /**
-     * Also block common profanity.
-     * @public
-     */
-    profanity?: boolean | undefined;
-}
-/**
- * Editable guardrail configuration.
- * @public
- */
-export interface CreateGuardrailInput {
-    name: string;
-    description?: string | undefined;
-    topicPolicy?: GuardrailTopicPolicy | undefined;
-    contentPolicy?: GuardrailContentPolicy | undefined;
-    wordPolicy?: GuardrailWordPolicy | undefined;
-    piiPolicy?: GuardrailPiiPolicy | undefined;
-    /**
-     * Answer returned to the end user when input is blocked.
-     * @public
-     */
-    blockedInputMessage?: string | undefined;
+export interface CreateAgentDeploymentInput {
+    company?: string | undefined;
+    agentId: string;
     /**
-     * Answer returned to the end user when the agent output is blocked.
+     * Deployment name, e.g. 'production' or 'staging'. Sessions default to 'production' when no deployment, version or draft selector is provided.
      * @public
      */
-    blockedOutputMessage?: string | undefined;
-    company?: string | undefined;
-}
-/**
- * Editable guardrail configuration.
- * @public
- */
-export interface Guardrail {
     name: string;
     description?: string | undefined;
-    topicPolicy?: GuardrailTopicPolicy | undefined;
-    contentPolicy?: GuardrailContentPolicy | undefined;
-    wordPolicy?: GuardrailWordPolicy | undefined;
-    piiPolicy?: GuardrailPiiPolicy | undefined;
-    /**
-     * Answer returned to the end user when input is blocked.
-     * @public
-     */
-    blockedInputMessage?: string | undefined;
-    /**
-     * Answer returned to the end user when the agent output is blocked.
-     * @public
-     */
-    blockedOutputMessage?: string | undefined;
-    /**
-     * ISO-8601 timestamp, e.g. '2026-07-03T10:15:30.000Z'.
-     * @public
-     */
-    createdAt: string;
-    /**
-     * Who performed an action: an interactive user, an API key or an internal service.
-     * @public
-     */
-    createdBy: Actor;
-    /**
-     * ISO-8601 timestamp, e.g. '2026-07-03T10:15:30.000Z'.
-     * @public
-     */
-    updatedAt?: string | undefined;
-    /**
-     * Who performed an action: an interactive user, an API key or an internal service.
-     * @public
-     */
-    updatedBy?: Actor | undefined;
-    id: string;
+    status: AgentDeploymentStatus;
+    routing: AgentDeploymentRoute[];
 }
 /**
  * @public
  */
-export interface CreateGuardrailOutput {
+export interface CreateAgentDeploymentOutput {
     /**
-     * Editable guardrail configuration.
+     * Standard audit fields carried by every managed resource.
      * @public
      */
-    guardrail: Guardrail;
+    deployment: AgentDeployment;
 }
 /**
  * @public
@@ -1752,23 +1807,6 @@ export interface DeleteAgentInput {
  */
 export interface DeleteAgentOutput {
 }
-/**
- * @public
- */
-export interface DeleteAgentAliasInput {
-    company?: string | undefined;
-    agentId: string;
-    /**
-     * Alias name, e.g. 'production', 'staging'.
-     * @public
-     */
-    aliasName: string;
-}
-/**
- * @public
- */
-export interface DeleteAgentAliasOutput {
-}
 /**
  * @public
  */
@@ -1785,67 +1823,19 @@ export interface DeleteAgentApiKeyOutput {
 /**
  * @public
  */
-export interface DeleteGuardrailInput {
-    company?: string | undefined;
-    guardrailId: string;
-}
-/**
- * @public
- */
-export interface DeleteGuardrailOutput {
-}
-/**
- * @public
- */
-export interface ExecuteAgentInput {
+export interface DeleteAgentDeploymentInput {
     company?: string | undefined;
     agentId: string;
     /**
-     * Message or task for the agent.
-     * @public
-     */
-    input: string;
-    /**
-     * Values for the variables declared by the agent.
-     * @public
-     */
-    variables?: __DocumentType | undefined;
-    /**
-     * Alias to resolve. Defaults to 'production'. Mutually exclusive with version.
-     * @public
-     */
-    alias?: string | undefined;
-    /**
-     * Version to execute. 0 executes the current draft (for testing). Mutually exclusive with alias.
+     * Deployment name, e.g. 'production' or 'staging'. Sessions default to 'production' when no deployment, version or draft selector is provided.
      * @public
      */
-    version?: number | undefined;
-    /**
-     * User on whose behalf the agent is executed, e.g. john.doe@example.com.
-     * @public
-     */
-    user?: string | undefined;
-    /**
-     * Parent agent id that invoked this execution (agent-to-agent calls).
-     * @public
-     */
-    parentAgentId?: string | undefined;
-    /**
-     * Parent trace id, to correlate nested executions.
-     * @public
-     */
-    parentTraceId?: string | undefined;
-    /**
-     * Files (by id) created by another agent to make available to this execution.
-     * @public
-     */
-    files?: string[] | undefined;
+    deploymentName: string;
 }
 /**
  * @public
  */
-export interface ExecuteAgentOutput {
-    result: AgentExecutionResult;
+export interface DeleteAgentDeploymentOutput {
 }
 /**
  * @public
@@ -1867,59 +1857,68 @@ export interface GetAgentOutput {
 /**
  * @public
  */
-export interface GetAgentVersionInput {
+export interface GetAgentDeploymentInput {
     company?: string | undefined;
     agentId: string;
-    version: number;
+    /**
+     * Deployment name, e.g. 'production' or 'staging'. Sessions default to 'production' when no deployment, version or draft selector is provided.
+     * @public
+     */
+    deploymentName: string;
 }
 /**
  * @public
  */
-export interface GetAgentVersionOutput {
-    version: AgentVersion;
+export interface GetAgentDeploymentOutput {
+    /**
+     * Standard audit fields carried by every managed resource.
+     * @public
+     */
+    deployment: AgentDeployment;
 }
 /**
  * @public
  */
-export interface GetGuardrailInput {
+export interface GetAgentVersionInput {
     company?: string | undefined;
-    guardrailId: string;
+    agentId: string;
+    /**
+     * Immutable published agent version identifier (nanoid).
+     * @public
+     */
+    version: string;
 }
 /**
  * @public
  */
-export interface GetGuardrailOutput {
-    /**
-     * Editable guardrail configuration.
-     * @public
-     */
-    guardrail: Guardrail;
+export interface GetAgentVersionOutput {
+    version: AgentVersion;
 }
 /**
  * @public
  */
-export interface ListAgentAliasesInput {
+export interface ListAgentApiKeysInput {
     company?: string | undefined;
     agentId: string;
 }
 /**
  * @public
  */
-export interface ListAgentAliasesOutput {
-    aliases: AgentAlias[];
+export interface ListAgentApiKeysOutput {
+    keys: AgentApiKey[];
 }
 /**
  * @public
  */
-export interface ListAgentApiKeysInput {
+export interface ListAgentDeploymentsInput {
     company?: string | undefined;
     agentId: string;
 }
 /**
  * @public
  */
-export interface ListAgentApiKeysOutput {
-    keys: AgentApiKey[];
+export interface ListAgentDeploymentsOutput {
+    deployments: AgentDeployment[];
 }
 /**
  * @public
@@ -1927,7 +1926,7 @@ export interface ListAgentApiKeysOutput {
 export interface ListAgentsInput {
     company?: string | undefined;
     /**
-     * Only agents deployed to this channel.
+     * Only agents that have this channel enabled (voice / chat / assistant / autonomous).
      * @public
      */
     channel?: ChannelType | undefined;
@@ -1942,7 +1941,7 @@ export interface ListAgentsInput {
      * Opaque cursor returned by a previous page; pass it back to fetch the next page.
      * @public
      */
-    nextToken?: string | undefined;
+    cursor?: string | undefined;
 }
 /**
  * @public
@@ -1953,7 +1952,7 @@ export interface ListAgentsOutput {
      * Opaque cursor returned by a previous page; pass it back to fetch the next page.
      * @public
      */
-    nextToken?: string | undefined;
+    nextCursor?: string | undefined;
 }
 /**
  * @public
@@ -1961,7 +1960,7 @@ export interface ListAgentsOutput {
 export interface ListAgentsNamesInput {
     company?: string | undefined;
     /**
-     * Delivery channel an agent can be deployed to.
+     * A channel an agent can serve (see AgentChannels for enablement). Also the runtime channel recorded by wilma-sessions / wilma-traces.
      * @public
      */
     channel?: ChannelType | undefined;
@@ -1983,7 +1982,7 @@ export interface ListAgentVersionsInput {
      * Opaque cursor returned by a previous page; pass it back to fetch the next page.
      * @public
      */
-    nextToken?: string | undefined;
+    cursor?: string | undefined;
 }
 /**
  * @public
@@ -1994,114 +1993,62 @@ export interface ListAgentVersionsOutput {
      * Opaque cursor returned by a previous page; pass it back to fetch the next page.
      * @public
      */
-    nextToken?: string | undefined;
+    nextCursor?: string | undefined;
 }
 /**
  * @public
  */
-export interface ListAuditRecordsInput {
+export interface PublishAgentVersionInput {
     company?: string | undefined;
-    agentId?: string | undefined;
-    resourceType?: AuditResourceType | undefined;
-    action?: AuditAction | undefined;
-    /**
-     * Filter by the user, API key or service that performed the action.
-     * @public
-     */
-    actorId?: string | undefined;
-    /**
-     * ISO-8601 timestamp, e.g. '2026-07-03T10:15:30.000Z'.
-     * @public
-     */
-    from?: string | undefined;
-    /**
-     * ISO-8601 timestamp, e.g. '2026-07-03T10:15:30.000Z'.
-     * @public
-     */
-    to?: string | undefined;
-    limit?: number | undefined;
+    agentId: string;
     /**
-     * Opaque cursor returned by a previous page; pass it back to fetch the next page.
+     * What changed in this version.
      * @public
      */
-    nextToken?: string | undefined;
-}
-/**
- * @public
- */
-export interface ListAuditRecordsOutput {
-    records: AuditRecord[];
+    changelog?: string | undefined;
     /**
-     * Opaque cursor returned by a previous page; pass it back to fetch the next page.
+     * Optional human-readable name for this version.
      * @public
      */
-    nextToken?: string | undefined;
-}
-/**
- * @public
- */
-export interface ListGuardrailsInput {
-    company?: string | undefined;
-    limit?: number | undefined;
+    name?: string | undefined;
     /**
-     * Opaque cursor returned by a previous page; pass it back to fetch the next page.
+     * Draft revision this publish is based on (optimistic locking).
      * @public
      */
-    nextToken?: string | undefined;
+    revision: number;
 }
 /**
  * @public
  */
-export interface ListGuardrailsOutput {
-    guardrails: Guardrail[];
-    /**
-     * Opaque cursor returned by a previous page; pass it back to fetch the next page.
-     * @public
-     */
-    nextToken?: string | undefined;
+export interface PublishAgentVersionOutput {
+    version: AgentVersion;
 }
 /**
  * @public
  */
-export interface PublishAgentVersionInput {
+export interface RestoreAgentVersionToDraftInput {
     company?: string | undefined;
     agentId: string;
     /**
-     * What changed in this version.
+     * Immutable published agent version identifier (nanoid).
      * @public
      */
-    changelog?: string | undefined;
+    version: string;
     /**
-     * Draft revision this publish is based on (optimistic locking).
+     * Draft revision this restore is based on (optimistic locking).
      * @public
      */
-    revision?: number | undefined;
-}
-/**
- * @public
- */
-export interface PublishAgentVersionOutput {
-    version: AgentVersion;
+    revision: number;
 }
 /**
  * @public
  */
-export interface PutAgentAliasInput {
-    company?: string | undefined;
-    agentId: string;
+export interface RestoreAgentVersionToDraftOutput {
     /**
-     * Alias name, e.g. 'production', 'staging'.
+     * The complete, versionable configuration of an agent. This is what gets snapshotted when a version is published.
      * @public
      */
-    aliasName: string;
-    description?: string | undefined;
-    routing: AgentAliasRoute[];
-}
-/**
- * @public
- */
-export interface PutAgentAliasOutput {
-    alias: AgentAlias;
+    agent: Agent;
 }
 /**
  * The complete, versionable configuration of an agent. This is what gets snapshotted when a version is published.
@@ -2120,17 +2067,28 @@ export interface UpdateAgentInput {
      * @public
      */
     picture?: string | undefined;
+    /**
+     * The channels this agent serves and their channel-specific settings. A channel is enabled when its member is present; at least one must be set. An agent may serve multiple channels (e.g. chat + assistant) over the shared engine.
+     * @public
+     */
+    channels: AgentChannels;
+    /**
+     * How the agent produces replies. `ai` is the managed engine; `webhook` and `sqs` delegate to an external backend. The legacy Dialogflow CX and OpenAI Assistant backends are intentionally not carried over.
+     * @public
+     */
     engine: AgentEngine;
     /**
-     * Per-channel deployment settings. An agent is reachable only on channels configured here.
+     * Agent-level settings shared across all channels.
      * @public
      */
-    channels?: AgentChannels | undefined;
+    settings?: AgentSettings | undefined;
     /**
-     * Guardrail policies applied to this agent's inputs and outputs.
+     * Who is allowed to use the agent. There is no view/edit dimension — access solely grants the ability to use the agent.
+     *     Per channel: on `chat` and `assistant` agents `grants` govern which colleagues can use the agent; on `voice` agents `grants`
+     *     are ignored (inbound calls are routed by the PBX dialplan, and data ACL is the agent-level `settings.pbxGroupId`); on `autonomous` agents agent-level
+     *     access is not used — invocation access is configured per reference on the calling agent (see AgentCallCapability.access).
      * @public
      */
-    guardrails?: string[] | undefined;
     access?: AgentAccess | undefined;
     company?: string | undefined;
     agentId: string;
@@ -2138,7 +2096,7 @@ export interface UpdateAgentInput {
      * Draft revision this update is based on (optimistic locking). When it does not match the current revision, RevisionConflictException is returned.
      * @public
      */
-    revision?: number | undefined;
+    revision: number;
 }
 /**
  * @public
@@ -2151,36 +2109,32 @@ export interface UpdateAgentOutput {
     agent: Agent;
 }
 /**
- * Editable guardrail configuration.
  * @public
  */
-export interface UpdateGuardrailInput {
-    name: string;
-    description?: string | undefined;
-    topicPolicy?: GuardrailTopicPolicy | undefined;
-    contentPolicy?: GuardrailContentPolicy | undefined;
-    wordPolicy?: GuardrailWordPolicy | undefined;
-    piiPolicy?: GuardrailPiiPolicy | undefined;
+export interface UpdateAgentDeploymentInput {
+    company?: string | undefined;
+    agentId: string;
     /**
-     * Answer returned to the end user when input is blocked.
+     * Deployment name, e.g. 'production' or 'staging'. Sessions default to 'production' when no deployment, version or draft selector is provided.
      * @public
      */
-    blockedInputMessage?: string | undefined;
+    deploymentName: string;
+    description?: string | undefined;
+    status: AgentDeploymentStatus;
+    routing: AgentDeploymentRoute[];
     /**
-     * Answer returned to the end user when the agent output is blocked.
+     * Deployment revision this update is based on (optimistic locking).
      * @public
      */
-    blockedOutputMessage?: string | undefined;
-    company?: string | undefined;
-    guardrailId: string;
+    revision: number;
 }
 /**
  * @public
  */
-export interface UpdateGuardrailOutput {
+export interface UpdateAgentDeploymentOutput {
     /**
-     * Editable guardrail configuration.
+     * Standard audit fields carried by every managed resource.
      * @public
      */
-    guardrail: Guardrail;
+    deployment: AgentDeployment;
 }