@wildix/wilma-agents-client 1.0.24 → 1.0.26

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

@@ -1,5 +1,5 @@
 import type { DocumentType as __DocumentType } from "@smithy/types";
-import type { ActorType, AgentHandoverPipelineType, AgentHandoverVariant, AgentHangupPipelineType, AgentStatus, AgentToolPipelineType, AgentTransferPipelineType, AgentTransferVariant, AgentVariableType, AgentVisibility, ChannelType, SandboxNetworkAccess, SandboxSize, VoicePronunciationEncoding, VoiceSpeechProvider, VoiceTranscriptionVendor, WebSearchContextSize } from "./enums";
+import type { ActorType, AgentHandoverPipelineType, AgentHandoverVariant, AgentHangupPipelineType, AgentStatus, AgentToolPipelineType, AgentTransferPipelineType, AgentTransferVariant, AgentVariableType, AgentVisibility, AgentWorkflowEntryBehavior, AgentWorkflowFailureKind, AgentWorkflowLayout, AgentWorkflowMessageButtonVariant, ChannelType, SandboxNetworkAccess, SandboxSize, WebSearchContextSize } from "./enums";
 /**
  * A user or group that access is granted to.
  * @public
@@ -218,255 +218,6 @@ export interface VoiceSilenceTimeoutSettings {
     seconds: number;
     action: VoiceTerminateAction;
 }
-/**
- * A reference to a stored secret, held by other services in place of the value.
- * Resolved server-to-server via GetSecretValue at execution time — always to the current value.
- * @public
- */
-export interface SecretRef {
-    /**
-     * Unique identifier of a secret.
-     * @public
-     */
-    id: string;
-}
-/**
- * A pronunciation rule for one phrase. Belongs to a LANGUAGE, not to the agent: 'Wildix' is
- *     respelled differently for an Italian and a German voice. A dictionary shared ACROSS languages
- *     would fight itself, which is why the company dictionary is keyed by language too — see
- *     PronunciationDictionary.
- * @public
- */
-export interface VoicePronunciation {
-    /**
-     * The phrase as it appears in the text, e.g. 'Wildix'. Bounded because every rule is compiled into ONE regular expression — see the list below.
-     * @public
-     */
-    phrase: string;
-    /**
-     * Respelling (ALIAS) or phonetic transcription (IPA), e.g. 'Wil-dix'.
-     * @public
-     */
-    as: string;
-    /**
-     * Defaults to ALIAS.
-     * @public
-     */
-    encoding?: VoicePronunciationEncoding | undefined;
-}
-/**
- * Synthesis options, used at two levels: as provider-level defaults on VoiceSpeechSettings and as
- *     per-language overrides on VoiceLanguage. Absent means inherit; there is no way to express
- *     'explicitly the same as the parent', which is the intended simplification — the merged result is
- *     identical either way. Which members apply is a property of the provider AND the model (Chirp 3:
- *     HD documents only speakingRate; eleven_v3 carries no stability, similarity or speaker boost), so
- *     the console renders them from a catalog rather than unconditionally.
- * @public
- */
-export interface VoiceSynthesisOptions {
-    /**
-     * Provider model id, e.g. 'eleven_flash_v2_5'.
-     * @public
-     */
-    model?: string | undefined;
-    /**
-     * Speaking rate. ElevenLabs 0.7-1.2 (default 1.0); Google 0.25-2.0 (default 1.0).
-     * @public
-     */
-    speed?: number | undefined;
-    /**
-     * ElevenLabs stability, 0-1 (default 0.5). Our clamp, not a vendor-stated bound.
-     * @public
-     */
-    stability?: number | undefined;
-    /**
-     * ElevenLabs similarity boost, 0-1 (default 0.75). Our clamp.
-     * @public
-     */
-    similarity?: number | undefined;
-    /**
-     * ElevenLabs style exaggeration, 0-1 (default 0). Our clamp.
-     * @public
-     */
-    style?: number | undefined;
-    /**
-     * ElevenLabs speaker boost (default true).
-     * @public
-     */
-    speakerBoost?: boolean | undefined;
-    /**
-     * Google pitch in semitones, -20 to 20. Not offered for Chirp 3: HD voices.
-     * @public
-     */
-    pitch?: number | undefined;
-    /**
-     * Google volume gain in dB, -96 to 16 (default 0); the vendor recommends staying under +10. Not offered for Chirp 3: HD voices.
-     * @public
-     */
-    volumeGain?: number | undefined;
-}
-/**
- * One configured language: its voice, its initial phrase and its overrides.
- * @public
- */
-export interface VoiceLanguage {
-    /**
-     * BCP-47 code with locale, e.g. 'en-US', 'it-IT'.
-     * @public
-     */
-    code: string;
-    /**
-     * Text-to-speech provider for THIS language. Absent falls back to
-     *         VoiceSpeechSettings.provider, which is what records written before this member
-     *         existed rely on. The console writes it on every language it creates.
-     *
-     *         Per language rather than per bot because provider quality is not uniform across
-     *         languages, and because a single bot-wide provider made changing it invalidate
-     *         every configured voice at once: a voice id belongs to one provider, so switching
-     *         the bot meant reselecting a speaker for every language.
-     * @public
-     */
-    provider?: VoiceSpeechProvider | undefined;
-    /**
-     * Provider voice id (ElevenLabs voice_id, Google voice name, Polly Id).
-     *   A CR OR LF IS REFUSED BY THE PATTERN, and the reason is not tidiness: this value reaches the
-     *   PBX as an AMI action parameter, and AMI frames on CRLF, so a newline inside it closes the
-     *   action and starts another one on a local, already-authenticated manager connection. Whoever
-     *   configures a voice agent in the cloud needs no PBX credential, so the model is the first place
-     *   that can refuse it. `pbx-data-engine` refuses it again on the send path — two layers, because
-     *   the AMI serializer is out of tree and neither layer can promise the other's behaviour.
-     * @public
-     */
-    voice: string;
-    /**
-     * Initial phrase spoken when the call starts in this language. Absent or empty means
-     *         the agent says nothing and waits — it does NOT fall back to VoiceChannelSettings.greeting,
-     *         which would speak one language's text in another language's voice.
-     * @public
-     */
-    greeting?: string | undefined;
-    /**
-     * Marks the language a caller hears when their own matches nothing configured.
-     *
-     *         THE FULL RESOLUTION ORDER, since a client author reading only this contract cannot
-     *         otherwise find it: an exact match on the call's language, then a match on its primary
-     *         subtag (`fr` finds `fr-FR`), then the language marked here, then a language whose
-     *         primary subtag is `en`, then the first entry in the list.
-     *
-     *         Marked is consulted BEFORE the English step, so a record with none marked resolves
-     *         exactly as it did before this member existed. English is deliberate rather than
-     *         arbitrary — it is the language a caller the agent was not built for is likeliest to
-     *         understand — and the last step exists only to keep the rule total, which is why list
-     *         order should not be treated as configuration.
-     *
-     *         At most one language may carry it. A record with two — reachable through the API or
-     *         the CLI, where no form prevents it — resolves to the first marked one in list order,
-     *         because refusing a call over configuration drift is worse than serving it and saying
-     *         so in the trace.
-     * @public
-     */
-    isDefault?: boolean | undefined;
-    /**
-     * Extra instructions active only while the conversation runs in this language.
-     * @public
-     */
-    instructions?: string | undefined;
-    /**
-     * Overrides VoiceSpeechSettings.synthesis member by member.
-     * @public
-     */
-    synthesis?: VoiceSynthesisOptions | undefined;
-    /**
-     * The company's own credential for THIS language's provider (secret variant
-     *         `auth_bearer`). Absent falls back to VoiceSpeechSettings.credential, then to the
-     *         platform key.
-     *
-     *         It lives beside the provider because a credential belongs to one: a company's
-     *         ElevenLabs key cannot serve a language synthesized by Google, and a single
-     *         bot-wide credential would have been silently inapplicable to some languages.
-     * @public
-     */
-    credential?: SecretRef | undefined;
-    /**
-     * This agent's OWN rules for this language. A rule whose phrase also exists in the
-     *         company dictionary replaces it; a rule whose phrase does not is simply an addition —
-     *         the two are the same member because they are the same act.
-     * @public
-     */
-    pronunciations?: VoicePronunciation[] | undefined;
-    /**
-     * Company-dictionary phrases this agent declines. See VoicePronunciationSuppressionList.
-     * @public
-     */
-    pronunciationSuppressions?: string[] | undefined;
-}
-/**
- * Speech-to-text configuration. Vendor-specific recognition options — term hints, custom
- *     vocabulary — land here alongside the vendors that take them; nothing writes them today.
- * @public
- */
-export interface VoiceTranscriptionSettings {
-    /**
-     * Recognition vendor. Absent resolves to the platform default (`aws` today), resolved by the server so exactly one component decides it.
-     * @public
-     */
-    vendor: VoiceTranscriptionVendor;
-}
-/**
- * Speech configuration for the voice channel. When present it WINS over the dialplan's `voice` and
- *     `initialMessage` connect parameters; `language` is the single exception, because it is the
- *     channel's own input signal and the feature has no starting point without it.
- * @public
- */
-export interface VoiceSpeechSettings {
-    /**
-     * DEFAULT text-to-speech provider, used by a language that names none of its own.
-     *         Still required, so a record always answers 'which provider' — but the console now
-     *         writes `provider` on every language, so this is what pre-existing records and API
-     *         callers fall back to rather than the primary control.
-     * @public
-     */
-    provider: VoiceSpeechProvider;
-    /**
-     * Configured languages. The @length bound is a STORAGE ceiling, not the product rule: the real
-     *         cap is the selected transcription vendor's `maxCandidates` (five for Amazon Transcribe),
-     *         enforced in the service from its catalog so a vendor with a different limit needs no model
-     *         change.
-     * @public
-     */
-    languages: VoiceLanguage[];
-    /**
-     * Identify the caller's language automatically and switch voice and reply language mid-call. Requires at least two languages and a vendor that can identify languages; the server clamps it to false otherwise.
-     * @public
-     */
-    autoDetect?: boolean | undefined;
-    /**
-     * Speak the first message of every configured language in turn when the call is answered, each
-     *         in the voice, provider account and pronunciation rules of its own language, instead of only the
-     *         language the call resolved to. Languages whose first message is empty, and languages the PBX
-     *         synthesizes itself, are skipped. Absent means off. Requires at least two languages carrying a
-     *         first message; below that the runtime speaks only the resolved language's phrase, and the
-     *         console clamps the member on save.
-     * @public
-     */
-    greetEveryLanguage?: boolean | undefined;
-    /**
-     * Speech-to-text configuration. Vendor-specific recognition options — term hints, custom
-     *     vocabulary — land here alongside the vendors that take them; nothing writes them today.
-     * @public
-     */
-    transcription?: VoiceTranscriptionSettings | undefined;
-    /**
-     * Provider-level synthesis defaults, inherited by every language.
-     * @public
-     */
-    synthesis?: VoiceSynthesisOptions | undefined;
-    /**
-     * The company's own provider credential (secret variant `auth_bearer`). Absent means the platform key. Has no counterpart in wim-voicebots — a deliberate parity gap.
-     * @public
-     */
-    credential?: SecretRef | undefined;
-}
 /**
  * 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
@@ -477,25 +228,6 @@ export interface VoiceChannelSettings {
      * @public
      */
     greeting?: string | undefined;
-    /**
-     * Ambient background played under the call, as a music-on-hold class name.
-     *
-     *         ABSENT MEANS OFF. There is no value meaning 'none': the member is simply not sent, which is
-     *         exactly the state every call was in before this setting existed, so a bot that never touches
-     *         it behaves as it always did and the PBX needs no new case.
-     *
-     *         It belongs to the CHANNEL rather than to `speech`, even though the console shows the control
-     *         under the automatic-language switch. `speech` is the recognition and synthesis
-     *         configuration and is sent only when languages are configured — background audio has nothing
-     *         to do with either, and a bot with no languages must still be able to have it.
-     * @public
-     */
-    backgroundSound?: string | undefined;
-    /**
-     * Provider, languages, voices, initial phrases and pronunciation. Absent means the legacy behavior: voice URI from the dialplan connect parameter, one voice, language as prompt context only.
-     * @public
-     */
-    speech?: VoiceSpeechSettings | undefined;
     interruptions?: VoiceInterruptionSettings | undefined;
     silenceTimeout?: VoiceSilenceTimeoutSettings | undefined;
     maxDuration?: VoiceMaxDurationSettings | undefined;
@@ -1631,107 +1363,1180 @@ export interface AgentVariable {
     description?: string | undefined;
 }
 /**
- * Managed AI engine: the platform runs the model, tools and knowledge lookups.
+ * The capability a step performs, run by the runtime rather than chosen by the model. A subset of
+ *     AgentCapability, reusing its structures verbatim: these are the members that describe a single action with a
+ *     beginning and an end. The rest of AgentCapability (`kb`, `webSearch`, `webFetch`, `sandbox`, `suggestions`)
+ *     describes reach the model draws on while it talks, so it belongs on a conversation step's `capabilities`
+ *     rather than on a step of its own.
+ *
+ *     Configuration comes from the capability itself and nothing is added here: a tool step's fixed arguments are
+ *     `AgentTool.fields` predefined handlers, its spoken lead-in is `AgentTool.startMessage`, a transfer's line
+ *     before the hand-off is `AgentTransferPipeline.instructions`, an invoked agent's inputs are
+ *     `AgentCallCapability.variables`. Anything left unpinned is filled by the model at the step, per the tool's
+ *     input schema.
  * @public
  */
-export interface AgentAiEngine {
-    instructions: string;
-    /**
-     * Defaults to the platform default model when omitted.
-     * @public
-     */
-    model?: string | undefined;
-    /**
-     * IANA timezone the agent reasons about time in: it anchors the current date and time given to the model and how times are read from and written to tool arguments and replies. Shared by every channel the agent serves. Defaults to 'UTC'.
-     * @public
-     */
-    timeZone?: string | undefined;
-    /**
-     * Whether the agent can produce artifacts (wilma-artifacts): documents, code files, HTML pages or diagrams it writes and shares back during a session, on any channel it serves. When an artifact is created the channel runtime shares it company-wide by link, so every signed-in colleague can open it. Artifacts are company-internal: recipients on external transports (sms / whatsapp) or outside the company cannot open the links, so keep this disabled for customer-facing agents. Defaults to false.
-     * @public
-     */
-    artifacts?: boolean | undefined;
-    /**
-     * Skills attached to this agent (progressive disclosure). A skill may carry its own tools, which join this agent's toolset while that skill is active.
-     * @public
-     */
-    skills?: AgentSkillReference[] | undefined;
-    capabilities?: AgentCapability[] | undefined;
-    variables?: AgentVariable[] | undefined;
-}
+export type AgentWorkflowAction = AgentWorkflowAction.AgentMember | AgentWorkflowAction.ConnectorMember | AgentWorkflowAction.DelegationMember | AgentWorkflowAction.HandoverMember | AgentWorkflowAction.HangupMember | AgentWorkflowAction.ToolMember | AgentWorkflowAction.TransferMember | AgentWorkflowAction.WaitMember | AgentWorkflowAction.$UnknownMember;
 /**
- * Bring-your-own backend over SQS: turns are forwarded to the queue, replies are posted back via the API.
  * @public
  */
-export interface AgentSqsEngine {
-    url: string;
-    key: string;
+export declare namespace AgentWorkflowAction {
     /**
-     * Reference to the SQS secret access key in wilma-secrets.
+     * Call a tool. Continues to the step's transitions when the call completes.
      * @public
      */
-    secret: SecretRef;
-}
-/**
- * Bring-your-own backend over HTTPS: each turn is POSTed to the URL, the response is the reply.
- * @public
- */
-export interface AgentWebhookEngine {
-    url: string;
+    interface ToolMember {
+        tool: AgentTool;
+        connector?: never;
+        agent?: never;
+        handover?: never;
+        delegation?: never;
+        transfer?: never;
+        hangup?: never;
+        wait?: never;
+        $unknown?: never;
+    }
     /**
-     * Shared secret used to sign requests (HMAC).
+     * Dispatch a connector action. Continues to the step's transitions when the action completes.
      * @public
      */
-    secret: string;
-    timeout?: number | undefined;
-}
-/**
- * How the agent produces replies. `ai` is the managed engine; `webhook` and `sqs` delegate to an external backend.
- * @public
- */
-export type AgentEngine = AgentEngine.AiMember | AgentEngine.SqsMember | AgentEngine.WebhookMember | AgentEngine.$UnknownMember;
-/**
- * @public
- */
-export declare namespace AgentEngine {
+    interface ConnectorMember {
+        tool?: never;
+        connector: AgentConnectorCapability;
+        agent?: never;
+        handover?: never;
+        delegation?: never;
+        transfer?: never;
+        hangup?: never;
+        wait?: never;
+        $unknown?: never;
+    }
     /**
-     * Managed AI engine: the platform runs the model, tools and knowledge lookups.
+     * Invoke another agent — typically a workflow-channel agent — as its own execution, and continue when it returns. Its result is captured by `output`.
      * @public
      */
-    interface AiMember {
-        ai: AgentAiEngine;
-        webhook?: never;
-        sqs?: never;
+    interface AgentMember {
+        tool?: never;
+        connector?: never;
+        agent: AgentCallCapability;
+        handover?: never;
+        delegation?: never;
+        transfer?: never;
+        hangup?: never;
+        wait?: never;
         $unknown?: never;
     }
     /**
-     * Bring-your-own backend over HTTPS: each turn is POSTed to the URL, the response is the reply.
+     * Hand the conversation to a human or another agent and leave it. Terminal: the session is no longer this workflow's.
      * @public
      */
-    interface WebhookMember {
-        ai?: never;
-        webhook: AgentWebhookEngine;
-        sqs?: never;
+    interface HandoverMember {
+        tool?: never;
+        connector?: never;
+        agent?: never;
+        handover: AgentHandoverCapability;
+        delegation?: never;
+        transfer?: never;
+        hangup?: never;
+        wait?: never;
         $unknown?: never;
     }
     /**
-     * Bring-your-own backend over SQS: turns are forwarded to the queue, replies are posted back via the API.
+     * Delegate the conversation to another agent. Terminal for this workflow.
      * @public
      */
-    interface SqsMember {
-        ai?: never;
-        webhook?: never;
-        sqs: AgentSqsEngine;
+    interface DelegationMember {
+        tool?: never;
+        connector?: never;
+        agent?: never;
+        handover?: never;
+        delegation: AgentDelegationCapability;
+        transfer?: never;
+        hangup?: never;
+        wait?: never;
         $unknown?: never;
     }
     /**
+     * Transfer the call to a PBX destination. Terminal. Honoured on the voice channel.
      * @public
      */
-    interface $UnknownMember {
-        ai?: never;
-        webhook?: never;
-        sqs?: never;
-        $unknown: [string, any];
+    interface TransferMember {
+        tool?: never;
+        connector?: never;
+        agent?: never;
+        handover?: never;
+        delegation?: never;
+        transfer: AgentTransferCapability;
+        hangup?: never;
+        wait?: never;
+        $unknown?: never;
+    }
+    /**
+     * End the call. Terminal. Honoured on the voice channel; on conversation channels use the `end` handler.
+     * @public
+     */
+    interface HangupMember {
+        tool?: never;
+        connector?: never;
+        agent?: never;
+        handover?: never;
+        delegation?: never;
+        transfer?: never;
+        hangup: AgentHangupCapability;
+        wait?: never;
+        $unknown?: never;
+    }
+    /**
+     * Hold the call while something runs, keeping the caller on the line. Continues to the step's transitions.
+     * @public
+     */
+    interface WaitMember {
+        tool?: never;
+        connector?: never;
+        agent?: never;
+        handover?: never;
+        delegation?: never;
+        transfer?: never;
+        hangup?: never;
+        wait: AgentWaitCapability;
+        $unknown?: never;
+    }
+    /**
+     * @public
+     */
+    interface $UnknownMember {
+        tool?: never;
+        connector?: never;
+        agent?: never;
+        handover?: never;
+        delegation?: never;
+        transfer?: never;
+        hangup?: never;
+        wait?: never;
+        $unknown: [string, any];
+    }
+    /**
+     * @deprecated unused in schema-serde mode.
+     *
+     */
+    interface Visitor<T> {
+        tool: (value: AgentTool) => T;
+        connector: (value: AgentConnectorCapability) => T;
+        agent: (value: AgentCallCapability) => T;
+        handover: (value: AgentHandoverCapability) => T;
+        delegation: (value: AgentDelegationCapability) => T;
+        transfer: (value: AgentTransferCapability) => T;
+        hangup: (value: AgentHangupCapability) => T;
+        wait: (value: AgentWaitCapability) => T;
+        _: (name: string, value: any) => T;
+    }
+}
+/**
+ * A step that performs one capability. The runtime performs it on arrival — no model decision about *whether*
+ *     to act, and no tool offered to the model for it. Which is the point: an action the graph reached is an action
+ *     that happens, at the cost of nothing.
+ * @public
+ */
+export interface AgentWorkflowActionHandler {
+    /**
+     * The capability a step performs, run by the runtime rather than chosen by the model. A subset of
+     *     AgentCapability, reusing its structures verbatim: these are the members that describe a single action with a
+     *     beginning and an end. The rest of AgentCapability (`kb`, `webSearch`, `webFetch`, `sandbox`, `suggestions`)
+     *     describes reach the model draws on while it talks, so it belongs on a conversation step's `capabilities`
+     *     rather than on a step of its own.
+     *
+     *     Configuration comes from the capability itself and nothing is added here: a tool step's fixed arguments are
+     *     `AgentTool.fields` predefined handlers, its spoken lead-in is `AgentTool.startMessage`, a transfer's line
+     *     before the hand-off is `AgentTransferPipeline.instructions`, an invoked agent's inputs are
+     *     `AgentCallCapability.variables`. Anything left unpinned is filled by the model at the step, per the tool's
+     *     input schema.
+     * @public
+     */
+    capability: AgentWorkflowAction;
+    /**
+     * Run the step as one model call with the tool choice pinned to this capability, instead of calling it
+     *         straight from the runtime. The model still cannot decide *whether* to call it — only what to put in the
+     *         arguments left unpinned, which is what a lookup keyed on something nobody can template ('the symptom the
+     *         caller just described') needs.
+     *
+     *         Costs one model call where the default costs none, so it is opt-in. Honoured where the action has
+     *         arguments a model can write — `tool`, `connector`, `agent`, and a `transfer` whose target the model
+     *         chooses; ignored elsewhere. Leaving it false while a required argument is unpinned is an authoring error,
+     *         not a runtime one: nothing would be there to fill it.
+     * @public
+     */
+    forceToolCall?: boolean | undefined;
+    /**
+     * Workflow variable the action's result is written to, so later `expression` conditions can branch on it and
+     *         later steps can template it (e.g. capture a lookup into `policy`, then branch on
+     *         `\{ "==": [\{ "var": "policy.status" \}, "active"] \}`). Absent means the result is not captured; the
+     *         model still sees it in the conversation per the capability's own pipeline.
+     *
+     *         Written on success only. A failed action leaves the variable as it was and takes a `failure` transition
+     *         instead — see AgentWorkflowFailureCondition — so a graph can never mistake an error for a result.
+     * @public
+     */
+    output?: string | undefined;
+}
+/**
+ * Voice-channel settings for a conversation step, overriding VoiceChannelSettings while it is live. Ignored on other channels.
+ * @public
+ */
+export interface AgentWorkflowConversationVoiceSettings {
+    /**
+     * Override the voice channel's `interruptions` setting for this step, e.g. while working through a scripted verification the caller should not talk over. Defaults to the channel setting.
+     * @public
+     */
+    interruptions?: VoiceInterruptionSettings | undefined;
+}
+/**
+ * Per-channel settings of a conversation step. Only voice has anything to say about a stretch of conversation today; the chat and assistant surfaces deliver it as they deliver every other reply.
+ * @public
+ */
+export interface AgentWorkflowConversationChannelsSettings {
+    /**
+     * Voice-channel settings for a conversation step, overriding VoiceChannelSettings while it is live. Ignored on other channels.
+     * @public
+     */
+    voice?: AgentWorkflowConversationVoiceSettings | undefined;
+}
+/**
+ * A stretch of conversation with a goal: the model talks, may use the capabilities in scope, and the step's
+ *     transitions are evaluated against what happens. This is the only handler that leaves control where it is
+ *     until a transition matches — a step whose conditions all stay false simply keeps talking.
+ *
+ *     Deliberately not configurable per step: the model, and how readily the step is left. The model is the
+ *     agent's (`engine.ai.model`) because a session that swaps models mid-conversation swaps voice, latency and
+ *     tool-calling behaviour with it. How readily a step is left is decided by how its transitions are worded —
+ *     conditions describing what the *caller* has done keep a model on the step, and no eagerness dial moves that
+ *     number.
+ * @public
+ */
+export interface AgentWorkflowConversationHandler {
+    /**
+     * What the agent is trying to achieve here, appended to the agent's `engine.ai.instructions`. Never a replacement for them: identity, tone and standing rules hold across every step, and a step that needs different ones is a different agent.
+     * @public
+     */
+    goal: string;
+    /**
+     * How the step starts. Defaults to `auto`.
+     * @public
+     */
+    entry?: AgentWorkflowEntryBehavior | undefined;
+    /**
+     * Per-channel settings for the stretch of conversation this step covers. Defaults to the agent's channel settings.
+     * @public
+     */
+    channels?: AgentWorkflowConversationChannelsSettings | undefined;
+    /**
+     * Capabilities offered to the model *in addition* to `engine.ai.capabilities` while this step runs,
+     *         configured exactly as they are there — the same union, the same structures. Use it to give a step reach
+     *         it should not have everywhere: authoring the refund tool on the refund step, rather than on the agent, is
+     *         also what keeps it out of every other step.
+     *
+     *         Additive only, by design. A step cannot drop an agent-level capability, so it cannot strand a session by
+     *         taking away the `handover` or `transfer` its channel needs, and the runtime keeps one rule for the turn's
+     *         tool set. Skills the model loads (`engine.ai.skills`) and the channel's own built-ins join it either way.
+     * @public
+     */
+    capabilities?: AgentCapability[] | undefined;
+}
+/**
+ * The session is over. Terminal and configuration-free by design: a closing line is a `message` step in front of it, and releasing a call is the `hangup` action — both already exist, and neither needs restating here.
+ * @public
+ */
+export interface AgentWorkflowEndHandler {
+}
+/**
+ * Tapping the button opens a URL. The session stays where it is — a link is not an answer, so it cannot satisfy a transition on its own.
+ * @public
+ */
+export interface AgentWorkflowMessageButtonLinkHandler {
+    url: string;
+}
+/**
+ * Tapping the button sends a reply on the user's behalf, which then drives this step's transitions like anything else the user says.
+ * @public
+ */
+export interface AgentWorkflowMessageButtonReplyHandler {
+    /**
+     * The text sent as the user's reply. Defaults to the button's own `text`.
+     * @public
+     */
+    text?: string | undefined;
+}
+/**
+ * What tapping a button does.
+ * @public
+ */
+export type AgentWorkflowMessageButtonHandler = AgentWorkflowMessageButtonHandler.LinkMember | AgentWorkflowMessageButtonHandler.ReplyMember | AgentWorkflowMessageButtonHandler.$UnknownMember;
+/**
+ * @public
+ */
+export declare namespace AgentWorkflowMessageButtonHandler {
+    /**
+     * Tapping the button sends a reply on the user's behalf, which then drives this step's transitions like anything else the user says.
+     * @public
+     */
+    interface ReplyMember {
+        reply: AgentWorkflowMessageButtonReplyHandler;
+        link?: never;
+        $unknown?: never;
+    }
+    /**
+     * Tapping the button opens a URL. The session stays where it is — a link is not an answer, so it cannot satisfy a transition on its own.
+     * @public
+     */
+    interface LinkMember {
+        reply?: never;
+        link: AgentWorkflowMessageButtonLinkHandler;
+        $unknown?: never;
+    }
+    /**
+     * @public
+     */
+    interface $UnknownMember {
+        reply?: never;
+        link?: never;
+        $unknown: [string, any];
+    }
+    /**
+     * @deprecated unused in schema-serde mode.
+     *
+     */
+    interface Visitor<T> {
+        reply: (value: AgentWorkflowMessageButtonReplyHandler) => T;
+        link: (value: AgentWorkflowMessageButtonLinkHandler) => T;
+        _: (name: string, value: any) => T;
+    }
+}
+/**
+ * One button offered under the step's line.
+ * @public
+ */
+export interface AgentWorkflowMessageButton {
+    /**
+     * Label shown on the button. Supports handlebars resolved against workflow variables, agent variables and session context.
+     * @public
+     */
+    text: string;
+    /**
+     * What tapping a button does.
+     * @public
+     */
+    handler: AgentWorkflowMessageButtonHandler;
+    /**
+     * How a reply button is rendered. Matches the x-bees `ButtonVariant`. Defaults to the client's own default.
+     * @public
+     */
+    variant?: AgentWorkflowMessageButtonVariant | undefined;
+}
+/**
+ * Chat-channel settings for a message step, honoured where a line is posted rather than spoken. Ignored on voice.
+ * @public
+ */
+export interface AgentWorkflowMessageChatSettings {
+    /**
+     * Reply buttons posted with the line, e.g. 'Yes, go ahead' / 'No, not now' under a confirmation. Delivered
+     *         as an x-bees `actions` element of `button` elements, so a tap either sends a reply — which the step's
+     *         transitions then read like any other user message — or opens a link. Only offered on a fixed line: a
+     *         conversation step is the model's to word, and buttons authored under words it has not chosen yet would
+     *         contradict each other.
+     * @public
+     */
+    suggestions?: AgentWorkflowMessageButton[] | undefined;
+}
+/**
+ * Voice-channel settings for a message step, honoured while the line is spoken. Ignored on other channels.
+ * @public
+ */
+export interface AgentWorkflowMessageVoiceSettings {
+    /**
+     * Override the voice channel's `interruptions` setting while the line is spoken, e.g. to protect a legally required disclosure from being talked over. Defaults to the channel setting.
+     * @public
+     */
+    interruptions?: VoiceInterruptionSettings | undefined;
+}
+/**
+ * Per-channel settings of a message step: how the line is protected when spoken, and what is offered with it when posted.
+ * @public
+ */
+export interface AgentWorkflowMessageChannelsSettings {
+    /**
+     * Voice-channel settings for a message step, honoured while the line is spoken. Ignored on other channels.
+     * @public
+     */
+    voice?: AgentWorkflowMessageVoiceSettings | undefined;
+    /**
+     * Chat-channel settings for a message step, honoured where a line is posted rather than spoken. Ignored on voice.
+     * @public
+     */
+    chat?: AgentWorkflowMessageChatSettings | undefined;
+}
+/**
+ * A line the model writes at this step, from the conversation and whatever the graph has gathered — 'greet the
+ *     caller by the name on the contact record and mention any open orders'. One model call, no tools offered, no
+ *     waiting for a reply: the agent says exactly one thing and the step's transitions are evaluated.
+ *
+ *     The difference from a conversation step is that this is a *speech act*, not a stretch of conversation: the
+ *     model cannot decide to stay quiet, cannot act, and cannot keep the step. Use it where the words must fit the
+ *     data but the shape of the session must not depend on how they came out.
+ * @public
+ */
+export interface AgentWorkflowMessageGeneration {
+    /**
+     * What to say, as an instruction to the model rather than the words themselves. Supports handlebars resolved against workflow variables, agent variables and session context, so an action's `output` captured a step earlier is available verbatim (e.g. 'Greet \{\{contact.firstName\}\} and mention their \{\{contact.openOrders\}\} open orders').
+     * @public
+     */
+    instructions: string;
+}
+/**
+ * Where the step's line comes from. Exactly one member is set: `text` is authored, `generate` is written by the model at the step.
+ * @public
+ */
+export type AgentWorkflowMessageContent = AgentWorkflowMessageContent.GenerateMember | AgentWorkflowMessageContent.TextMember | AgentWorkflowMessageContent.$UnknownMember;
+/**
+ * @public
+ */
+export declare namespace AgentWorkflowMessageContent {
+    /**
+     * The line, verbatim. No model in the loop, which is what makes it the right content for a disclosure, a policy sentence or a legally worded confirmation.
+     * @public
+     */
+    interface TextMember {
+        text: string;
+        generate?: never;
+        $unknown?: never;
+    }
+    /**
+     * Instructions the model turns into one line at this step. Costs one model call where `text` costs none.
+     * @public
+     */
+    interface GenerateMember {
+        text?: never;
+        generate: AgentWorkflowMessageGeneration;
+        $unknown?: never;
+    }
+    /**
+     * @public
+     */
+    interface $UnknownMember {
+        text?: never;
+        generate?: never;
+        $unknown: [string, any];
+    }
+    /**
+     * @deprecated unused in schema-serde mode.
+     *
+     */
+    interface Visitor<T> {
+        text: (value: string) => T;
+        generate: (value: AgentWorkflowMessageGeneration) => T;
+        _: (name: string, value: any) => T;
+    }
+}
+/**
+ * Say one thing — spoken on voice, posted on chat / assistant — then move on. The line is either authored verbatim or generated at the step; either way the agent says it once and the transitions are evaluated, with no turn handed to the user.
+ * @public
+ */
+export interface AgentWorkflowMessageHandler {
+    /**
+     * Where the step's line comes from. Exactly one member is set: `text` is authored, `generate` is written by the model at the step.
+     * @public
+     */
+    content: AgentWorkflowMessageContent;
+    /**
+     * Per-channel settings for delivering the line: protecting it from interruption when it is spoken, offering reply buttons with it when it is posted. Defaults to the agent's channel settings.
+     * @public
+     */
+    channels?: AgentWorkflowMessageChannelsSettings | undefined;
+}
+/**
+ * End this workflow and hand control back to whatever invoked it.
+ *
+ *     In a nested workflow the invoking step resumes and branches on which result was reached (see
+ *     AgentWorkflowResultCondition). In the main graph of a workflow-channel agent the run finishes and the result
+ *     is returned to the caller — the agent, automation or API request that started it. In the main graph of a
+ *     voice / chat / assistant agent there is no invoker, so it behaves as `end`.
+ * @public
+ */
+export interface AgentWorkflowResultHandler {
+    /**
+     * What this result returns to the invoker. Supports handlebars resolved against workflow variables, agent variables and session context (e.g. '\{\{policy.number\}\}'). Absent returns the result's id alone, which is enough when the caller only branches on which result was reached.
+     * @public
+     */
+    value?: string | undefined;
+}
+/**
+ * One `name = value` write. Exactly one of `value` or `expression` is set: `value` renders text, `expression` computes.
+ * @public
+ */
+export interface AgentWorkflowAssignment {
+    name: string;
+    /**
+     * Text written to the variable, with handlebars resolved against workflow variables, agent variables and session context (e.g. '\{\{lookup.status\}\}'). Empty clears the variable.
+     * @public
+     */
+    value?: string | undefined;
+    /**
+     * A JsonLogic expression computing the value instead of rendering it, which is what makes arithmetic possible: `\{ "+": [\{ "var": "attempts" \}, 1] \}` is the retry counter a bounded loop needs, written with no model in the loop.
+     * @public
+     */
+    expression?: __DocumentType | undefined;
+}
+/**
+ * Write workflow variables. The step nobody asks for until the first time a graph has to remember something between two branches.
+ * @public
+ */
+export interface AgentWorkflowVariablesHandler {
+    assignments: AgentWorkflowAssignment[];
+}
+/**
+ * Run a nested workflow and continue once it returns.
+ *
+ *     The unit of decomposition: a twelve-step identity check is called from the front door, from the booking flow
+ *     and from the complaints line, so it is authored once and referenced by a single step at each call site. The
+ *     nested workflow shares this session and its variables; it returns through its `result` steps, which is what
+ *     the calling step's `result` transitions branch on. A nested workflow that instead reaches an `end` or a
+ *     terminal action does what it says — the session is over and nothing comes back.
+ * @public
+ */
+export interface AgentWorkflowInvokeHandler {
+    /**
+     * The nested workflow to run. Must be declared in `AgentWorkflow.nested`, and must not run itself directly or through a ring of nested workflows.
+     * @public
+     */
+    workflow: string;
+    /**
+     * Workflow variable the nested workflow's result `value` is written to. Absent means the value is discarded — which is the usual case when the branch taken is the whole answer.
+     * @public
+     */
+    output?: string | undefined;
+}
+/**
+ * What a step does. Exactly one member is set. `action` carries a capability; the others are workflow-only handlers with no capability equivalent.
+ * @public
+ */
+export type AgentWorkflowHandler = AgentWorkflowHandler.ActionMember | AgentWorkflowHandler.ConversationMember | AgentWorkflowHandler.EndMember | AgentWorkflowHandler.MessageMember | AgentWorkflowHandler.ResultMember | AgentWorkflowHandler.VariablesMember | AgentWorkflowHandler.WorkflowMember | AgentWorkflowHandler.$UnknownMember;
+/**
+ * @public
+ */
+export declare namespace AgentWorkflowHandler {
+    /**
+     * A stretch of conversation with a goal: the model talks, may use the capabilities in scope, and the step's
+     *     transitions are evaluated against what happens. This is the only handler that leaves control where it is
+     *     until a transition matches — a step whose conditions all stay false simply keeps talking.
+     *
+     *     Deliberately not configurable per step: the model, and how readily the step is left. The model is the
+     *     agent's (`engine.ai.model`) because a session that swaps models mid-conversation swaps voice, latency and
+     *     tool-calling behaviour with it. How readily a step is left is decided by how its transitions are worded —
+     *     conditions describing what the *caller* has done keep a model on the step, and no eagerness dial moves that
+     *     number.
+     * @public
+     */
+    interface ConversationMember {
+        conversation: AgentWorkflowConversationHandler;
+        message?: never;
+        action?: never;
+        variables?: never;
+        workflow?: never;
+        result?: never;
+        end?: never;
+        $unknown?: never;
+    }
+    /**
+     * Say one thing — spoken on voice, posted on chat / assistant — then move on. The line is either authored verbatim or generated at the step; either way the agent says it once and the transitions are evaluated, with no turn handed to the user.
+     * @public
+     */
+    interface MessageMember {
+        conversation?: never;
+        message: AgentWorkflowMessageHandler;
+        action?: never;
+        variables?: never;
+        workflow?: never;
+        result?: never;
+        end?: never;
+        $unknown?: never;
+    }
+    /**
+     * A step that performs one capability. The runtime performs it on arrival — no model decision about *whether*
+     *     to act, and no tool offered to the model for it. Which is the point: an action the graph reached is an action
+     *     that happens, at the cost of nothing.
+     * @public
+     */
+    interface ActionMember {
+        conversation?: never;
+        message?: never;
+        action: AgentWorkflowActionHandler;
+        variables?: never;
+        workflow?: never;
+        result?: never;
+        end?: never;
+        $unknown?: never;
+    }
+    /**
+     * Write workflow variables. The step nobody asks for until the first time a graph has to remember something between two branches.
+     * @public
+     */
+    interface VariablesMember {
+        conversation?: never;
+        message?: never;
+        action?: never;
+        variables: AgentWorkflowVariablesHandler;
+        workflow?: never;
+        result?: never;
+        end?: never;
+        $unknown?: never;
+    }
+    /**
+     * Run a nested workflow and continue once it returns.
+     *
+     *     The unit of decomposition: a twelve-step identity check is called from the front door, from the booking flow
+     *     and from the complaints line, so it is authored once and referenced by a single step at each call site. The
+     *     nested workflow shares this session and its variables; it returns through its `result` steps, which is what
+     *     the calling step's `result` transitions branch on. A nested workflow that instead reaches an `end` or a
+     *     terminal action does what it says — the session is over and nothing comes back.
+     * @public
+     */
+    interface WorkflowMember {
+        conversation?: never;
+        message?: never;
+        action?: never;
+        variables?: never;
+        workflow: AgentWorkflowInvokeHandler;
+        result?: never;
+        end?: never;
+        $unknown?: never;
+    }
+    /**
+     * End this workflow and hand control back to whatever invoked it.
+     *
+     *     In a nested workflow the invoking step resumes and branches on which result was reached (see
+     *     AgentWorkflowResultCondition). In the main graph of a workflow-channel agent the run finishes and the result
+     *     is returned to the caller — the agent, automation or API request that started it. In the main graph of a
+     *     voice / chat / assistant agent there is no invoker, so it behaves as `end`.
+     * @public
+     */
+    interface ResultMember {
+        conversation?: never;
+        message?: never;
+        action?: never;
+        variables?: never;
+        workflow?: never;
+        result: AgentWorkflowResultHandler;
+        end?: never;
+        $unknown?: never;
+    }
+    /**
+     * The session is over. Terminal and configuration-free by design: a closing line is a `message` step in front of it, and releasing a call is the `hangup` action — both already exist, and neither needs restating here.
+     * @public
+     */
+    interface EndMember {
+        conversation?: never;
+        message?: never;
+        action?: never;
+        variables?: never;
+        workflow?: never;
+        result?: never;
+        end: AgentWorkflowEndHandler;
+        $unknown?: never;
+    }
+    /**
+     * @public
+     */
+    interface $UnknownMember {
+        conversation?: never;
+        message?: never;
+        action?: never;
+        variables?: never;
+        workflow?: never;
+        result?: never;
+        end?: never;
+        $unknown: [string, any];
+    }
+    /**
+     * @deprecated unused in schema-serde mode.
+     *
+     */
+    interface Visitor<T> {
+        conversation: (value: AgentWorkflowConversationHandler) => T;
+        message: (value: AgentWorkflowMessageHandler) => T;
+        action: (value: AgentWorkflowActionHandler) => T;
+        variables: (value: AgentWorkflowVariablesHandler) => T;
+        workflow: (value: AgentWorkflowInvokeHandler) => T;
+        result: (value: AgentWorkflowResultHandler) => T;
+        end: (value: AgentWorkflowEndHandler) => T;
+        _: (name: string, value: any) => T;
+    }
+}
+/**
+ * Canvas coordinates of a step in the builder. Authoring metadata: the runtime ignores it, and a workflow that arrives without positions is laid out automatically.
+ * @public
+ */
+export interface AgentWorkflowStepPosition {
+    x: number;
+    y: number;
+}
+/**
+ * Unconditional. Only legal as a step's single transition: two unconditional exits are a coin toss, not a routing decision.
+ * @public
+ */
+export interface AgentWorkflowAlwaysCondition {
+}
+/**
+ * A branch taken when workflow state satisfies the condition — no model judgement involved, which is what makes it the right condition after an `action` or `variables` step.
+ * @public
+ */
+export interface AgentWorkflowExpressionCondition {
+    /**
+     * A JsonLogic condition tree evaluated against workflow state, e.g.
+     *     `\{ "==": [ \{ "var": "lookup.status" \}, "found" ] \}`. The `var` namespace is the workflow variables
+     *     written by `variables` steps and action `output` captures, the agent's input variables
+     *     (`engine.ai.variables`), and the session context. An empty tree always matches. Same convention as
+     *     AutomationConditions (wilma-workflows) and CopilotConditions (wilma-copilot).
+     * @public
+     */
+    conditions: __DocumentType;
+}
+/**
+ * A branch taken when the step's action fails. Only meaningful on an `action` step, and the only condition a
+ *     terminal action may carry: a transfer that finds the extension busy has not left the session, so a graph that
+ *     cannot say what happens next simply drops the caller.
+ *
+ *     Failure short-circuits — when an action fails, only `failure` transitions are considered, never the
+ *     `expression` or `prompt` branches that were written for its result. If none matches, the session fails with
+ *     the action's error, so a step whose capability can fail wants a catch-all last in the list.
+ * @public
+ */
+export interface AgentWorkflowFailureCondition {
+    /**
+     * Kinds this branch handles, evaluated as a set. Absent or empty catches **any** failure — the catch-all, which the list order must therefore place after the specific branches.
+     * @public
+     */
+    kinds?: AgentWorkflowFailureKind[] | undefined;
+}
+/**
+ * The else-branch, taken when no sibling matched. At most one per step, and reached last regardless of where it sits in the list.
+ * @public
+ */
+export interface AgentWorkflowFallbackCondition {
+}
+/**
+ * A condition the model judges against the conversation, e.g. 'the caller has said they will try the fix'.
+ *
+ *     Phrase it as something the **caller** has done. A condition describing what the *agent* has done — 'the
+ *     caller has a next step to try' — is true the instant the agent names one, so the model leaves before the
+ *     caller has answered, and one early exit cascades through the rest of the graph. Rewording the same exits from
+ *     agent actions to caller actions, changing nothing else, moved three models from 58–64 % of turns on the right
+ *     step to 96–100 %, and removed every stray move. It is the single largest effect measured on this contract, so
+ *     an authoring surface that accepts an agent-action condition is the defect, not the wording.
+ * @public
+ */
+export interface AgentWorkflowPromptCondition {
+    instructions: string;
+}
+/**
+ * A branch on which result a nested workflow returned. Only meaningful on a `workflow` step; the referenced step must be a `result` step of the nested workflow that step runs.
+ * @public
+ */
+export interface AgentWorkflowResultCondition {
+    /**
+     * Id of the `result` step reached inside the nested workflow. An id rather than a name, so renaming a result from 'failed' to 'gave up' does not unwire every step that handles it.
+     * @public
+     */
+    result: string;
+}
+/**
+ * How the runtime decides to take a transition. Exactly one member is set.
+ * @public
+ */
+export type AgentWorkflowCondition = AgentWorkflowCondition.AlwaysMember | AgentWorkflowCondition.ExpressionMember | AgentWorkflowCondition.FailureMember | AgentWorkflowCondition.FallbackMember | AgentWorkflowCondition.PromptMember | AgentWorkflowCondition.ResultMember | AgentWorkflowCondition.$UnknownMember;
+/**
+ * @public
+ */
+export declare namespace AgentWorkflowCondition {
+    /**
+     * Unconditional. Only legal as a step's single transition: two unconditional exits are a coin toss, not a routing decision.
+     * @public
+     */
+    interface AlwaysMember {
+        always: AgentWorkflowAlwaysCondition;
+        prompt?: never;
+        expression?: never;
+        result?: never;
+        failure?: never;
+        fallback?: never;
+        $unknown?: never;
+    }
+    /**
+     * A condition the model judges against the conversation, e.g. 'the caller has said they will try the fix'.
+     *
+     *     Phrase it as something the **caller** has done. A condition describing what the *agent* has done — 'the
+     *     caller has a next step to try' — is true the instant the agent names one, so the model leaves before the
+     *     caller has answered, and one early exit cascades through the rest of the graph. Rewording the same exits from
+     *     agent actions to caller actions, changing nothing else, moved three models from 58–64 % of turns on the right
+     *     step to 96–100 %, and removed every stray move. It is the single largest effect measured on this contract, so
+     *     an authoring surface that accepts an agent-action condition is the defect, not the wording.
+     * @public
+     */
+    interface PromptMember {
+        always?: never;
+        prompt: AgentWorkflowPromptCondition;
+        expression?: never;
+        result?: never;
+        failure?: never;
+        fallback?: never;
+        $unknown?: never;
+    }
+    /**
+     * A branch taken when workflow state satisfies the condition — no model judgement involved, which is what makes it the right condition after an `action` or `variables` step.
+     * @public
+     */
+    interface ExpressionMember {
+        always?: never;
+        prompt?: never;
+        expression: AgentWorkflowExpressionCondition;
+        result?: never;
+        failure?: never;
+        fallback?: never;
+        $unknown?: never;
+    }
+    /**
+     * A branch on which result a nested workflow returned. Only meaningful on a `workflow` step; the referenced step must be a `result` step of the nested workflow that step runs.
+     * @public
+     */
+    interface ResultMember {
+        always?: never;
+        prompt?: never;
+        expression?: never;
+        result: AgentWorkflowResultCondition;
+        failure?: never;
+        fallback?: never;
+        $unknown?: never;
+    }
+    /**
+     * A branch taken when the step's action fails. Only meaningful on an `action` step, and the only condition a
+     *     terminal action may carry: a transfer that finds the extension busy has not left the session, so a graph that
+     *     cannot say what happens next simply drops the caller.
+     *
+     *     Failure short-circuits — when an action fails, only `failure` transitions are considered, never the
+     *     `expression` or `prompt` branches that were written for its result. If none matches, the session fails with
+     *     the action's error, so a step whose capability can fail wants a catch-all last in the list.
+     * @public
+     */
+    interface FailureMember {
+        always?: never;
+        prompt?: never;
+        expression?: never;
+        result?: never;
+        failure: AgentWorkflowFailureCondition;
+        fallback?: never;
+        $unknown?: never;
+    }
+    /**
+     * The else-branch, taken when no sibling matched. At most one per step, and reached last regardless of where it sits in the list.
+     * @public
+     */
+    interface FallbackMember {
+        always?: never;
+        prompt?: never;
+        expression?: never;
+        result?: never;
+        failure?: never;
+        fallback: AgentWorkflowFallbackCondition;
+        $unknown?: never;
+    }
+    /**
+     * @public
+     */
+    interface $UnknownMember {
+        always?: never;
+        prompt?: never;
+        expression?: never;
+        result?: never;
+        failure?: never;
+        fallback?: never;
+        $unknown: [string, any];
+    }
+    /**
+     * @deprecated unused in schema-serde mode.
+     *
+     */
+    interface Visitor<T> {
+        always: (value: AgentWorkflowAlwaysCondition) => T;
+        prompt: (value: AgentWorkflowPromptCondition) => T;
+        expression: (value: AgentWorkflowExpressionCondition) => T;
+        result: (value: AgentWorkflowResultCondition) => T;
+        failure: (value: AgentWorkflowFailureCondition) => T;
+        fallback: (value: AgentWorkflowFallbackCondition) => T;
+        _: (name: string, value: any) => T;
+    }
+}
+/**
+ * One way out of a step.
+ * @public
+ */
+export interface AgentWorkflowTransition {
+    /**
+     * Step to move to. Must be a step of the same workflow — a nested workflow is entered through a `workflow` step, not by pointing a transition into it.
+     * @public
+     */
+    target: string;
+    /**
+     * How the runtime decides to take a transition. Exactly one member is set.
+     * @public
+     */
+    condition: AgentWorkflowCondition;
+}
+/**
+ * @public
+ */
+export interface AgentWorkflowStep {
+    /**
+     * Identifier of a step within its workflow, unique per workflow (the main graph and each nested workflow are separate scopes). Stable and machine-facing: transitions reference it, and a result step's id is the name a caller branches on, so renaming a step's `label` never unwires the graph.
+     * @public
+     */
+    id: string;
+    /**
+     * Human readable name of a step, shown in the builder and in traces. Never a routing key — see AgentWorkflowStepId — but it is read by the model as the fallback preview of an exit that leads here when the step carries no `summary`.
+     * @public
+     */
+    label: string;
+    /**
+     * One line saying what happens here, shown to the model as the preview of any exit that leads to this step.
+     * @public
+     */
+    summary?: string | undefined;
+    /**
+     * The phase this step belongs to. Inherited by steps downstream, so a handful of tags organise a long graph.
+     * @public
+     */
+    stage?: string | undefined;
+    /**
+     * What a step does. Exactly one member is set. `action` carries a capability; the others are workflow-only handlers with no capability equivalent.
+     * @public
+     */
+    handler: AgentWorkflowHandler;
+    /**
+     * The ways out of this step. Must be non-empty on every step that stays in the session, since a step the
+     *         runtime cannot leave is a dead end.
+     *
+     *         On `result` and `end` it must be empty. On the `action` members that leave the session (`handover`,
+     *         `delegation`, `transfer`, `hangup`) it may carry `failure` transitions and nothing else: an action that
+     *         was supposed to leave and failed — a busy extension, a service desk with nobody on it — has not left, and
+     *         a graph with no answer for that drops the caller.
+     * @public
+     */
+    transitions?: AgentWorkflowTransition[] | undefined;
+    /**
+     * Canvas coordinates of a step in the builder. Authoring metadata: the runtime ignores it, and a workflow that arrives without positions is laid out automatically.
+     * @public
+     */
+    position?: AgentWorkflowStepPosition | undefined;
+}
+/**
+ * A named graph the main workflow — or another nested workflow — can run, referenced by AgentWorkflowInvokeHandler.
+ * @public
+ */
+export interface AgentWorkflowNested {
+    /**
+     * Step the graph starts at. Must be one of `steps`.
+     * @public
+     */
+    entry: string;
+    /**
+     * Steps of one graph. Ids are unique within it.
+     * @public
+     */
+    steps: AgentWorkflowStep[];
+    /**
+     * Identifier of a nested workflow within the agent's workflow.
+     * @public
+     */
+    id: string;
+    name: string;
+    /**
+     * One line saying what the nested workflow is for, shown on the step that runs it.
+     * @public
+     */
+    description?: string | undefined;
+}
+/**
+ * @public
+ */
+export interface AgentWorkflowSettings {
+    /**
+     * Give up after this many step transitions, so a cycle whose conditions all keep matching cannot run
+     *         forever. Absent means no limit, which is the default: a deliberate loop — 'keep asking until you have the
+     *         postcode' — is a normal shape, and silently capping it would be worse than making the author say so.
+     * @public
+     */
+    maxTransitions?: number | undefined;
+    /**
+     * Workflow variables seeded before the first step runs. Agent input variables (`engine.ai.variables`) are already in scope and need no entry here.
+     * @public
+     */
+    variables?: AgentWorkflowAssignment[] | undefined;
+    /**
+     * How the builder arranges the graph. Authoring metadata: the runtime ignores it. `stages` bands the graph by `stage`, which is what a forty-step workflow needs.
+     * @public
+     */
+    layout?: AgentWorkflowLayout | undefined;
+}
+/**
+ * The agent's conversation as a graph: which step runs first, what each step does, and on what condition
+ *     control moves on. Optional on AgentAiEngine — without one the agent is prompt-driven, steered by
+ *     `instructions` and free to use its capabilities in any order.
+ *
+ *     Versioned with the rest of the agent definition: publishing a version snapshots the graph, and a draft edit
+ *     reaches no session until it is published and routed.
+ * @public
+ */
+export interface AgentWorkflow {
+    /**
+     * Step the graph starts at. Must be one of `steps`.
+     * @public
+     */
+    entry: string;
+    /**
+     * Steps of one graph. Ids are unique within it.
+     * @public
+     */
+    steps: AgentWorkflowStep[];
+    /**
+     * Graphs the main workflow can run, referenced by `workflow` steps.
+     * @public
+     */
+    nested?: AgentWorkflowNested[] | undefined;
+    settings?: AgentWorkflowSettings | undefined;
+}
+/**
+ * Managed AI engine: the platform runs the model, tools and knowledge lookups.
+ * @public
+ */
+export interface AgentAiEngine {
+    instructions: string;
+    /**
+     * The session as a graph of steps, when the agent is meant to follow one. Sits next to `instructions`
+     *         because the two are the same decision from opposite ends: what the agent is told, and how the session is
+     *         steered. Optional — without it the agent is prompt-driven and free to use its capabilities in any order,
+     *         which stays the right shape for open-ended assistants. What a step *does* is one of the capabilities
+     *         below, configured identically; see AgentWorkflow.
+     * @public
+     */
+    workflow?: AgentWorkflow | undefined;
+    /**
+     * Defaults to the platform default model when omitted.
+     * @public
+     */
+    model?: string | undefined;
+    /**
+     * IANA timezone the agent reasons about time in: it anchors the current date and time given to the model and how times are read from and written to tool arguments and replies. Shared by every channel the agent serves. Defaults to 'UTC'.
+     * @public
+     */
+    timeZone?: string | undefined;
+    /**
+     * Whether the agent can produce artifacts (wilma-artifacts): documents, code files, HTML pages or diagrams it writes and shares back during a session, on any channel it serves. When an artifact is created the channel runtime shares it company-wide by link, so every signed-in colleague can open it. Artifacts are company-internal: recipients on external transports (sms / whatsapp) or outside the company cannot open the links, so keep this disabled for customer-facing agents. Defaults to false.
+     * @public
+     */
+    artifacts?: boolean | undefined;
+    /**
+     * Skills attached to this agent (progressive disclosure). A skill may carry its own tools, which join this agent's toolset while that skill is active.
+     * @public
+     */
+    skills?: AgentSkillReference[] | undefined;
+    /**
+     * Everything the agent can do. When a `workflow` is set these are the capabilities in scope at every step, and a step may add to them or narrow them with its own list of the same shape.
+     * @public
+     */
+    capabilities?: AgentCapability[] | undefined;
+    variables?: AgentVariable[] | undefined;
+}
+/**
+ * A reference to a stored secret, held by other services in place of the value.
+ * Resolved server-to-server via GetSecretValue at execution time — always to the current value.
+ * @public
+ */
+export interface SecretRef {
+    /**
+     * Unique identifier of a secret.
+     * @public
+     */
+    id: string;
+}
+/**
+ * Bring-your-own backend over SQS: turns are forwarded to the queue, replies are posted back via the API.
+ * @public
+ */
+export interface AgentSqsEngine {
+    url: string;
+    key: string;
+    /**
+     * Reference to the SQS secret access key in wilma-secrets.
+     * @public
+     */
+    secret: SecretRef;
+}
+/**
+ * Bring-your-own backend over HTTPS: each turn is POSTed to the URL, the response is the reply.
+ * @public
+ */
+export interface AgentWebhookEngine {
+    url: string;
+    /**
+     * Shared secret used to sign requests (HMAC).
+     * @public
+     */
+    secret: string;
+    timeout?: number | undefined;
+}
+/**
+ * How the agent produces replies. `ai` is the managed engine; `webhook` and `sqs` delegate to an external backend.
+ * @public
+ */
+export type AgentEngine = AgentEngine.AiMember | AgentEngine.SqsMember | AgentEngine.WebhookMember | AgentEngine.$UnknownMember;
+/**
+ * @public
+ */
+export declare namespace AgentEngine {
+    /**
+     * Managed AI engine: the platform runs the model, tools and knowledge lookups.
+     * @public
+     */
+    interface AiMember {
+        ai: AgentAiEngine;
+        webhook?: never;
+        sqs?: never;
+        $unknown?: never;
+    }
+    /**
+     * Bring-your-own backend over HTTPS: each turn is POSTed to the URL, the response is the reply.
+     * @public
+     */
+    interface WebhookMember {
+        ai?: never;
+        webhook: AgentWebhookEngine;
+        sqs?: never;
+        $unknown?: never;
+    }
+    /**
+     * Bring-your-own backend over SQS: turns are forwarded to the queue, replies are posted back via the API.
+     * @public
+     */
+    interface SqsMember {
+        ai?: never;
+        webhook?: never;
+        sqs: AgentSqsEngine;
+        $unknown?: never;
+    }
+    /**
+     * @public
+     */
+    interface $UnknownMember {
+        ai?: never;
+        webhook?: never;
+        sqs?: never;
+        $unknown: [string, any];
     }
     /**
      * @deprecated unused in schema-serde mode.
@@ -1924,11 +2729,6 @@ export interface AgentInfo {
      * @public
      */
     channels: ChannelType[];
-    /**
-     * Whether the agent's voice channel has at least one configured speech language. A dialplan form partitions its application lists on this, so the answer has to travel with the list rather than cost one lookup per entry. Absent is read as false.
-     * @public
-     */
-    speechConfigured?: boolean | undefined;
     /**
      * Published agent version number. Monotonic within an agent's version history, starting at 1.
      * @public
@@ -2163,25 +2963,6 @@ export interface DeleteAgentApiKeyInput {
  */
 export interface DeleteAgentApiKeyOutput {
 }
-/**
- * @public
- */
-export interface DeletePronunciationDictionaryInput {
-    company?: string | undefined;
-    /**
-     * BCP-47 language tag, optionally with a region subtag: 'en', 'en-US', 'pt-BR'. Deliberately a
-     *     constrained string rather than an enum: the offerable set is a property of the selected
-     *     transcription vendor and changes with it, so an enumeration here would cap the set at whatever
-     *     was known when the model was released.
-     * @public
-     */
-    code: string;
-}
-/**
- * @public
- */
-export interface DeletePronunciationDictionaryOutput {
-}
 /**
  * @public
  */
@@ -2322,57 +3103,6 @@ export interface ListAgentVersionsOutput {
      */
     nextCursor?: string | undefined;
 }
-/**
- * @public
- */
-export interface ListPronunciationDictionariesInput {
-    company?: string | undefined;
-}
-/**
- * Every pronunciation rule a company has written for one language.
- * @public
- */
-export interface PronunciationDictionary {
-    id: string;
-    /**
-     * BCP-47 code with locale, e.g. 'en-US'. Unique per company — this is the link.
-     * @public
-     */
-    code: string;
-    /**
-     * Pronunciation rules for one language.
-     *
-     *     BOUNDED, and the bound is not decoration. Both runtimes compile every rule of a language into
-     *     a SINGLE alternating regular expression, so the cost is the pattern's total size: measured
-     *     against the real escaping and matching logic, 1,000 rules cost ~0.9 s of CPU per synthesized
-     *     sentence, 5,000 cost ~4.9 s, and around 10,000 `new RegExp` throws V8's pattern-size error.
-     *
-     *     200 is far above any real use — a product glossary is a handful of names — and far below where
-     *     either cost begins. Found by a security review.
-     *     NO LOWER BOUND on `phrase` or `as`, deliberately. Both consoles add an EMPTY rule row the
-     *     moment someone clicks 'Add pronunciation', so a `min: 1` would make saving an agent with a
-     *     half-typed row fail entirely — and the runtime already ignores a rule with no phrase. Dropping
-     *     blank rows belongs in the consoles' save filters, not in a refusal here.
-     * @public
-     */
-    rules: VoicePronunciation[];
-    /**
-     * ISO-8601 timestamp with millisecond precision, e.g. '2026-07-10T14:12:30.123Z'.
-     * @public
-     */
-    updatedAt: string;
-    /**
-     * Who performed an action: an interactive user, an API key or an internal service.
-     * @public
-     */
-    updatedBy: Actor;
-}
-/**
- * @public
- */
-export interface ListPronunciationDictionariesOutput {
-    dictionaries: PronunciationDictionary[];
-}
 /**
  * @public
  */
@@ -2423,47 +3153,6 @@ export interface PutAgentDeploymentOutput {
      */
     deployment: AgentDeploymentRoute[];
 }
-/**
- * @public
- */
-export interface PutPronunciationDictionaryInput {
-    company?: string | undefined;
-    /**
-     * BCP-47 language tag, optionally with a region subtag: 'en', 'en-US', 'pt-BR'. Deliberately a
-     *     constrained string rather than an enum: the offerable set is a property of the selected
-     *     transcription vendor and changes with it, so an enumeration here would cap the set at whatever
-     *     was known when the model was released.
-     * @public
-     */
-    code: string;
-    /**
-     * Pronunciation rules for one language.
-     *
-     *     BOUNDED, and the bound is not decoration. Both runtimes compile every rule of a language into
-     *     a SINGLE alternating regular expression, so the cost is the pattern's total size: measured
-     *     against the real escaping and matching logic, 1,000 rules cost ~0.9 s of CPU per synthesized
-     *     sentence, 5,000 cost ~4.9 s, and around 10,000 `new RegExp` throws V8's pattern-size error.
-     *
-     *     200 is far above any real use — a product glossary is a handful of names — and far below where
-     *     either cost begins. Found by a security review.
-     *     NO LOWER BOUND on `phrase` or `as`, deliberately. Both consoles add an EMPTY rule row the
-     *     moment someone clicks 'Add pronunciation', so a `min: 1` would make saving an agent with a
-     *     half-typed row fail entirely — and the runtime already ignores a rule with no phrase. Dropping
-     *     blank rows belongs in the consoles' save filters, not in a refusal here.
-     * @public
-     */
-    rules: VoicePronunciation[];
-}
-/**
- * @public
- */
-export interface PutPronunciationDictionaryOutput {
-    /**
-     * Every pronunciation rule a company has written for one language.
-     * @public
-     */
-    dictionary: PronunciationDictionary;
-}
 /**
  * @public
  */