lua-cli 3.18.0 → 3.21.0

package/dist/api-exports.d.ts

@@ -27,6 +27,10 @@ declare interface AgentInvocationInput {
     systemPrompt?: string;
     /** Additional runtime context attached to the request. */
     runtimeContext?: string;
+    /** Client-side context (e.g. the caller's IANA timezone) for this invocation. */
+    clientContext?: {
+        timezone?: string;
+    };
     /**
      * Optional thread ID suffix for conversation scoping. When omitted, the
      * invocation flows into the caller-user's default chat thread with the
@@ -55,6 +59,9 @@ declare interface AgentInvocationInput {
      * the original BAC-107 spec; wired through as part of PRO-186.
      */
     webhookPayload?: unknown;
+    /** Per-call timeout in ms. Absent ⇒ the client default (120s). Set by scheduled agent jobs
+     *  to 180s so the cloud tier cuts off at the same point the desktop's local runner does. */
+    timeoutMs?: number;
 }
 
 /**
@@ -86,11 +93,19 @@ declare interface AgentInvocationOutput {
 }
 
 /**
- * Per-agent LLM call settings. Maps directly onto Mastra's
+ * Per-agent LLM call settings PLUS normalized reasoning config. The
+ * `CallSettings` leafs (`temperature`, `topP`, …) map directly onto Mastra's
  * `agent.stream({ modelSettings })` / `agent.generate({ modelSettings })`,
- * which in turn maps onto the AI SDK's `CallSettings`. Pass-through:
- * we don't validate ranges here; the provider will reject invalid combos
- * (e.g. topP > 1, presencePenalty out of provider range).
+ * which in turn maps onto the AI SDK's `CallSettings` — pass-through, we
+ * don't validate ranges here; the provider will reject invalid combos (e.g.
+ * topP > 1, presencePenalty out of provider range).
+ *
+ * `reasoning` is NOT a `CallSettings` key — it's the agent-level tier of the
+ * `ModelRequestOptions` precedence chain (request > agent `reasoning` >
+ * per-model DB `modelOptions` > code defaults). lua-core splits this bag
+ * before calling Mastra: `reasoning` is stripped and merged into the
+ * provider-options resolution seam instead of being passed through as a
+ * `CallSettings` field.
  *
  * Deliberately excludes `abortSignal` (not serializable), `headers`
  * (security — could exfiltrate credentials), and `maxRetries` (platform
@@ -113,6 +128,17 @@ export declare interface AgentModelSettings {
     stopSequences?: string[];
     /** Random seed for deterministic sampling (provider support varies). */
     seed?: number;
+    /**
+     * Per-agent reasoning default. Lower precedence than a per-request
+     * `options.reasoning` override; higher precedence than the per-model DB
+     * `modelOptions.reasoning` override. Verbosity is deliberately NOT
+     * available here — it stays request-level only (`ModelRequestOptions.verbosity`).
+     */
+    reasoning?: {
+        effort?: ReasoningEffort;
+        /** Whether to surface the reasoning trace to the caller. Default true. */
+        show?: boolean;
+    };
 }
 
 export declare const Agents: AgentsApi;
@@ -634,6 +660,23 @@ declare interface BatchingConfig {
     serializeProcessing?: boolean;
 }
 
+/**
+ * Browser switch config (LuaBrowser). `browser: true` is the zero-code form —
+ * the agent gets browser tools injected, like `searchWeb`, routed to the user's
+ * local browser (desktop) or the Browser-Use cloud fallback. The object form
+ * adds optional policy.
+ */
+declare interface BrowserSwitchConfig {
+    /** Preferred engine; 'auto' lets the platform pick local (desktop) vs cloud. */
+    engine?: 'auto' | 'browser-use' | 'agent-browser';
+    /** Egress allowlist — domains the browser may navigate/sub-request. */
+    allowedDomains?: string[];
+    /** Names of vault credential entries the agent may use (never raw secrets). */
+    credentials?: string[];
+    /** Hard cap on a single browser session's duration (cost control). */
+    maxSessionMinutes?: number;
+}
+
 /**
  * CDN API
  * Upload and retrieve files from the Lua CDN
@@ -727,6 +770,13 @@ export declare const Channels: ChannelsApi;
  *   languageCode: 'en',
  * });
  *
+ * // React to a WhatsApp message
+ * await Channels.whatsapp.sendReaction({
+ *   to: { phoneNumber: '+15551234567' },
+ *   messageId: 'wamid.HBgL...',
+ *   emoji: '👍',
+ * });
+ *
  * // Send an email
  * await Channels.email.send({
  *   to: { email: 'customer@example.com' },
@@ -767,6 +817,23 @@ export declare interface ChannelsApi {
          * ```
          */
         sendTemplate(input: WhatsAppTemplateSendInput): Promise<ChannelSendOutput>;
+        /**
+         * React to a WhatsApp message with a single emoji.
+         *
+         * `messageId` is the vendor message id (`wamid...`) — e.g. read it off an
+         * inbound message from the channel webhook/history — and must be ≤30 days
+         * old (Meta limit). Pass `emoji: ''` to remove an existing reaction.
+         *
+         * @example
+         * ```typescript
+         * await Channels.whatsapp.sendReaction({
+         *   to: { phoneNumber: '+447551166594' },
+         *   messageId: 'wamid.HBgL...',
+         *   emoji: '👍',
+         * });
+         * ```
+         */
+        sendReaction(input: WhatsAppReactionSendInput): Promise<ChannelSendOutput>;
     };
     /** Email-specific send operations. */
     email: {
@@ -859,12 +926,27 @@ export declare interface ChannelSendTarget {
 /**
  * One content part of a chat-history message.
  *
- * `text` parts carry plain text. Media parts (`image` / `video` / `audio`
- * / `file`) carry a URL or base64 payload in `data` (or `image` / `video`
- * for legacy reasons) plus a `mediaType` MIME string.
+ * `text` parts carry plain text. `reasoning` parts carry the model's
+ * chain-of-thought in the `text` field so a history reload can re-render the
+ * reasoning component (PRO-391). `tool` parts carry a persisted tool
+ * invocation (`toolName`, `toolCallId`, `input` args, and — on a terminal
+ * turn — the `output` result and `toolState`) so a reloaded turn can
+ * re-render its tool-call cards. `source` parts carry a web-search citation
+ * (`url` + optional `title`/`sourceId`) so a reloaded turn keeps its sources
+ * footer — the persisted twin of the live stream's `source-url` parts.
+ * Media parts (`image` / `video` / `audio` / `file`) carry a URL or base64
+ * payload in `data` (or `image` / `video` for legacy reasons) plus a
+ * `mediaType` MIME string.
+ * `source-url` / `source-document` parts carry a persisted citation
+ * (web-search grounding / document citation, PRO-430): `url` + `title` for
+ * URLs; `mediaType` + `title` + `filename` (+ citation offsets inside
+ * `providerMetadata`) for documents; both keyed by `sourceId`.
+ * `data-lua-*` parts carry a persisted enriched stream part (e.g. a
+ * sub-agent delegation card) with its original data object in `payload`
+ * (`data` is reserved for media payload strings).
  */
 export declare interface ChatHistoryContent {
-    type: 'text' | 'image' | 'video' | 'audio' | 'file';
+    type: 'text' | 'reasoning' | 'tool' | 'image' | 'video' | 'audio' | 'file' | 'source-url' | 'source-document' | `data-lua-${string}`;
     text?: string;
     image?: string;
     video?: string;
@@ -872,6 +954,17 @@ export declare interface ChatHistoryContent {
     mediaType?: string;
     latitude?: number;
     longitude?: number;
+    toolName?: string;
+    toolCallId?: string;
+    input?: unknown;
+    output?: unknown;
+    toolState?: string;
+    sourceId?: string;
+    url?: string;
+    title?: string;
+    filename?: string;
+    providerMetadata?: Record<string, unknown>;
+    payload?: unknown;
 }
 
 /**
@@ -886,6 +979,24 @@ export declare interface ChatHistoryMessage {
     /** ISO-8601 timestamp string. */
     createdAt: string;
     content: ChatHistoryContent[];
+    /**
+     * Origin of the message, derived from the `mastra_messages.type` column:
+     * `'voice'` for turns mirrored from a finished LiveKit voice call, `'chat'`
+     * for everything else. Additive/optional — absent on rows written before this
+     * landed and on call sites that don't select the `type` column. Clients use it
+     * to render a "Voice call" divider in the thread.
+     */
+    source?: 'voice' | 'chat';
+    /**
+     * Permanent recording for a voice-note turn (Lua Desktop). Populated by the
+     * admin threads history endpoint from the row's `content.metadata.audio` — a
+     * sibling of the model content, so the url is NEVER part of the LLM prompt.
+     * Present only on desktop voice-note user turns; clients render an audio
+     * player / voice bubble off `audio.url`. Absent on all other messages.
+     */
+    audio?: {
+        url: string;
+    };
 }
 
 /**
@@ -1268,6 +1379,37 @@ export declare interface DeviceTriggerConfig {
     }) => Promise<any>;
 }
 
+/** A matched org member and their shareable channel targets (empty when none shared). */
+export declare interface DirectoryMatch {
+    userId: string;
+    fullName?: string;
+    primaryEmail?: string;
+    targets: DirectoryTarget[];
+}
+
+/** Result of POST /developer/agents/:agentId/directory/resolve. */
+export declare interface DirectoryResolveResult {
+    query: string;
+    matches: DirectoryMatch[];
+}
+
+/**
+ * Wire contracts for the workspace directory resolve endpoint.
+ *
+ * lua-cli `Team.findMember(name)` ↔ lua-api `POST /developer/agents/:agentId/directory/resolve`.
+ * Resolves a teammate by name within the AGENT's organization (the org is derived
+ * server-side from the agent), returning only the channel handles each member opted
+ * to share. Returns a list — the caller disambiguates when more than one matches.
+ */
+/** A channel the teammate opted to be reachable on within the workspace. */
+export declare interface DirectoryTarget {
+    channel: 'whatsapp' | 'sms' | 'email';
+    /** E.164 for whatsapp/sms; address for email. */
+    value: string;
+    label?: string;
+    validated: boolean;
+}
+
 /** A single email attachment, referenced by URL — lua-email fetches the bytes
  * server-side and attaches them, keeping large files off the SDK→API hops. */
 declare interface EmailAttachmentInput {
@@ -1278,16 +1420,38 @@ declare interface EmailAttachmentInput {
 
 /** Body of POST /developer/agents/:agentId/channels/email/send */
 export declare interface EmailSendInput {
+    /** Recipient — `email` (cold) or `userId` (resolved to the user's email
+     * address from their channel history). At least one must be set. */
     to: {
         userId?: string;
         email?: string;
     };
     subject?: string;
+    /** Plain-text body, sent as-is (the MIME text/plain part). */
     text?: string;
+    /** Exact HTML body, sent as-is (the MIME text/html part) — no template wrap. */
     html?: string;
+    /**
+     * Rich body — markdown and `:::` component markers, rendered server-side into
+     * the branded email template (the same rendering the agent's own replies use).
+     * Use this for "send this message as a nice email"; use `html` instead when you
+     * want to control the exact markup. Mutually exclusive with `html`/`text`.
+     */
+    richBody?: string;
     cc?: string[];
     bcc?: string[];
     attachments?: EmailAttachmentInput[];
+    /**
+     * RFC 5322 threading: the `Message-ID` of the email this one replies to. Set
+     * `In-Reply-To` (and append to `References`) so mail clients thread the reply
+     * into the right conversation — e.g. a per-ticket thread. The value is the
+     * inbound email's Message-ID, surfaced to agent code as `webhookPayload.messageId`.
+     * Angle brackets are optional; lua-email wraps bare ids. Honoured on the SES
+     * (branded/`existing`) email channel.
+     */
+    inReplyTo?: string;
+    /** RFC 5322 `References` chain — the accumulated Message-IDs of the thread. */
+    references?: string[];
     options?: ChannelSendOptions;
 }
 
@@ -1361,9 +1525,20 @@ declare interface GovernanceConfig {
      * `rules`/`injection` on top. `'security'` = block dangerous tools + requireLevel(2).
      */
     preset?: 'security';
-    /** SDK mode — prompt-injection scan on inputs (maps to the SDK's `createInjectionGuard`). */
+    /**
+     * SDK mode — prompt-injection scan on inputs (maps to the SDK's `createInjectionGuard`).
+     * `ml: true` additionally runs the Governance Cloud ML ensemble (regex+DeBERTa) per
+     * message and adds the SDK's `mlInjectionGuard` rule — a hybrid that blocks when EITHER
+     * the regex score crosses `threshold` OR the ML score crosses `mlThreshold`. The two are
+     * scored independently: `threshold` (~0.8) suits the regex weights, while the ML score is
+     * a calibrated model confidence with its own tuned operating point (`mlThreshold`, default
+     * 0.95 — the ensemble's confirmation gate). Requires GOVERNANCE_ML_URL / GOVERNANCE_ML_API_KEY
+     * on the platform; falls back to regex-only when unset or on error.
+     */
     injection?: {
         threshold: number;
+        ml?: boolean;
+        mlThreshold?: number;
     };
     /** SDK mode — local in-memory policy rules layered on top of any `preset`. */
     rules?: {
@@ -1633,7 +1808,7 @@ declare class JobApi extends HttpClient {
      * @returns Promise resolving to an ApiResponse containing the full updated job
      * @throws Error if the job or version is not found or the publish operation fails
      */
-    publishJobVersion(jobId: string, version: string): Promise<ApiResponse<Job>>;
+    publishJobVersion(jobId: string, version: string): Promise<ApiResponse<Job & ScopedPromoteFields>>;
     /**
      * Deletes a job and all its versions, or deactivates it if it has versions
      * @param jobId - The unique identifier of the job to delete
@@ -2055,6 +2230,7 @@ export declare class LuaAgent {
     private readonly voices?;
     private readonly batching?;
     private readonly governance?;
+    private readonly browser?;
     /**
      * Creates a new LuaAgent instance.
      *
@@ -2073,6 +2249,8 @@ export declare class LuaAgent {
      */
     constructor(config: LuaAgentConfig);
     getName(): string;
+    /** Browser switch (LuaBrowser) — `true`/config when the agent can browse. */
+    getBrowser(): LuaAgentConfig['browser'];
     getPersona(): PersonaText;
     getModel(): LuaAgentModel | undefined;
     getModelSettings(): AgentModelSettings | undefined;
@@ -2100,8 +2278,12 @@ export declare interface LuaAgentConfig {
      * Passed straight through to Mastra / AI SDK on every `chat/stream` and
      * `chat/generate`. Undefined leaves provider defaults in place.
      *
+     * `reasoning` is the exception — it's not a sampling setting. It sets this
+     * agent's default reasoning effort/visibility across providers (Claude,
+     * GPT, Gemini, …); a per-request `options.reasoning` override always wins.
+     *
      * @example
-     * modelSettings: { temperature: 0.2, maxOutputTokens: 4096 }
+     * modelSettings: { temperature: 0.2, maxOutputTokens: 4096, reasoning: { effort: 'low' } }
      */
     modelSettings?: AgentModelSettings;
     /** Array of skills (each with tools) */
@@ -2133,6 +2315,13 @@ export declare interface LuaAgentConfig {
     batching?: BatchingConfig;
     /** Governance policy configuration. When set, tool calls, preprocessors, and postprocessors are governed. */
     governance?: GovernanceConfig;
+    /**
+     * Browser switch (LuaBrowser). `true` turns on browser tools with platform
+     * defaults; an object adds policy (engine, allowedDomains, credentials,
+     * maxSessionMinutes). Off by default — a browser session costs money and
+     * carries risk, so it's opt-in (unlike always-on searchWeb).
+     */
+    browser?: boolean | BrowserSwitchConfig;
 }
 
 /**
@@ -2863,11 +3052,11 @@ declare const LuaVoiceConfigSchema: z.ZodEffects<z.ZodObject<{
     }, "strip", z.ZodTypeAny, {
         options?: Record<string, unknown>;
         kind?: "realtime";
-        provider?: "openai" | "google" | "xai";
+        provider?: "google" | "xai" | "openai";
     }, {
         options?: Record<string, unknown>;
         kind?: "realtime";
-        provider?: "openai" | "google" | "xai";
+        provider?: "google" | "xai" | "openai";
     }>]>;
     stt: z.ZodOptional<z.ZodDiscriminatedUnion<"kind", [z.ZodObject<{
         kind: z.ZodLiteral<"inference">;
@@ -2929,11 +3118,11 @@ declare const LuaVoiceConfigSchema: z.ZodEffects<z.ZodObject<{
     }, "strip", z.ZodTypeAny, {
         options?: Record<string, unknown>;
         kind?: "realtime";
-        provider?: "openai" | "google" | "xai";
+        provider?: "google" | "xai" | "openai";
     }, {
         options?: Record<string, unknown>;
         kind?: "realtime";
-        provider?: "openai" | "google" | "xai";
+        provider?: "google" | "xai" | "openai";
     }>]>>;
     tts: z.ZodOptional<z.ZodDiscriminatedUnion<"kind", [z.ZodObject<{
         kind: z.ZodLiteral<"inference">;
@@ -2995,11 +3184,11 @@ declare const LuaVoiceConfigSchema: z.ZodEffects<z.ZodObject<{
     }, "strip", z.ZodTypeAny, {
         options?: Record<string, unknown>;
         kind?: "realtime";
-        provider?: "openai" | "google" | "xai";
+        provider?: "google" | "xai" | "openai";
     }, {
         options?: Record<string, unknown>;
         kind?: "realtime";
-        provider?: "openai" | "google" | "xai";
+        provider?: "google" | "xai" | "openai";
     }>]>>;
     vad: z.ZodOptional<z.ZodString>;
     vadOptions: z.ZodOptional<z.ZodObject<{
@@ -3032,28 +3221,28 @@ declare const LuaVoiceConfigSchema: z.ZodEffects<z.ZodObject<{
         maxDelay: z.ZodOptional<z.ZodNumber>;
     }, "strip", z.ZodTypeAny, {
         enabled?: boolean;
-        mode?: "vad" | "adaptive";
+        mode?: "adaptive" | "vad";
         falseInterruptionTimeout?: number;
         resumeFalseInterruption?: boolean;
         minDelay?: number;
         maxDelay?: number;
     }, {
         enabled?: boolean;
-        mode?: "vad" | "adaptive";
+        mode?: "adaptive" | "vad";
         falseInterruptionTimeout?: number;
         resumeFalseInterruption?: boolean;
         minDelay?: number;
         maxDelay?: number;
     }>, {
         enabled?: boolean;
-        mode?: "vad" | "adaptive";
+        mode?: "adaptive" | "vad";
         falseInterruptionTimeout?: number;
         resumeFalseInterruption?: boolean;
         minDelay?: number;
         maxDelay?: number;
     }, {
         enabled?: boolean;
-        mode?: "vad" | "adaptive";
+        mode?: "adaptive" | "vad";
         falseInterruptionTimeout?: number;
         resumeFalseInterruption?: boolean;
         minDelay?: number;
@@ -3157,6 +3346,7 @@ declare const LuaVoiceConfigSchema: z.ZodEffects<z.ZodObject<{
     onToolFailureSay: z.ZodOptional<z.ZodString>;
     excludeTools: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
 }, "strip", z.ZodTypeAny, {
+    name?: string;
     vad?: string;
     stt?: {
         voice?: string;
@@ -3171,10 +3361,9 @@ declare const LuaVoiceConfigSchema: z.ZodEffects<z.ZodObject<{
     } | {
         options?: Record<string, unknown>;
         kind?: "realtime";
-        provider?: "openai" | "google" | "xai";
+        provider?: "google" | "xai" | "openai";
     };
     volume?: number;
-    name?: string;
     llm?: {
         voice?: string;
         options?: Record<string, unknown>;
@@ -3188,7 +3377,7 @@ declare const LuaVoiceConfigSchema: z.ZodEffects<z.ZodObject<{
     } | {
         options?: Record<string, unknown>;
         kind?: "realtime";
-        provider?: "openai" | "google" | "xai";
+        provider?: "google" | "xai" | "openai";
     };
     tts?: {
         voice?: string;
@@ -3203,7 +3392,7 @@ declare const LuaVoiceConfigSchema: z.ZodEffects<z.ZodObject<{
     } | {
         options?: Record<string, unknown>;
         kind?: "realtime";
-        provider?: "openai" | "google" | "xai";
+        provider?: "google" | "xai" | "openai";
     };
     vadOptions?: {
         minSpeechDuration?: number;
@@ -3218,7 +3407,7 @@ declare const LuaVoiceConfigSchema: z.ZodEffects<z.ZodObject<{
     preemptiveGeneration?: boolean;
     interruption?: {
         enabled?: boolean;
-        mode?: "vad" | "adaptive";
+        mode?: "adaptive" | "vad";
         falseInterruptionTimeout?: number;
         resumeFalseInterruption?: boolean;
         minDelay?: number;
@@ -3251,6 +3440,7 @@ declare const LuaVoiceConfigSchema: z.ZodEffects<z.ZodObject<{
     onToolFailureSay?: string;
     excludeTools?: string[];
 }, {
+    name?: string;
     vad?: string;
     stt?: {
         voice?: string;
@@ -3265,10 +3455,9 @@ declare const LuaVoiceConfigSchema: z.ZodEffects<z.ZodObject<{
     } | {
         options?: Record<string, unknown>;
         kind?: "realtime";
-        provider?: "openai" | "google" | "xai";
+        provider?: "google" | "xai" | "openai";
     };
     volume?: number;
-    name?: string;
     llm?: {
         voice?: string;
         options?: Record<string, unknown>;
@@ -3282,7 +3471,7 @@ declare const LuaVoiceConfigSchema: z.ZodEffects<z.ZodObject<{
     } | {
         options?: Record<string, unknown>;
         kind?: "realtime";
-        provider?: "openai" | "google" | "xai";
+        provider?: "google" | "xai" | "openai";
     };
     tts?: {
         voice?: string;
@@ -3297,7 +3486,7 @@ declare const LuaVoiceConfigSchema: z.ZodEffects<z.ZodObject<{
     } | {
         options?: Record<string, unknown>;
         kind?: "realtime";
-        provider?: "openai" | "google" | "xai";
+        provider?: "google" | "xai" | "openai";
     };
     vadOptions?: {
         minSpeechDuration?: number;
@@ -3312,7 +3501,7 @@ declare const LuaVoiceConfigSchema: z.ZodEffects<z.ZodObject<{
     preemptiveGeneration?: boolean;
     interruption?: {
         enabled?: boolean;
-        mode?: "vad" | "adaptive";
+        mode?: "adaptive" | "vad";
         falseInterruptionTimeout?: number;
         resumeFalseInterruption?: boolean;
         minDelay?: number;
@@ -3345,6 +3534,7 @@ declare const LuaVoiceConfigSchema: z.ZodEffects<z.ZodObject<{
     onToolFailureSay?: string;
     excludeTools?: string[];
 }>, {
+    name?: string;
     vad?: string;
     stt?: {
         voice?: string;
@@ -3359,10 +3549,9 @@ declare const LuaVoiceConfigSchema: z.ZodEffects<z.ZodObject<{
     } | {
         options?: Record<string, unknown>;
         kind?: "realtime";
-        provider?: "openai" | "google" | "xai";
+        provider?: "google" | "xai" | "openai";
     };
     volume?: number;
-    name?: string;
     llm?: {
         voice?: string;
         options?: Record<string, unknown>;
@@ -3376,7 +3565,7 @@ declare const LuaVoiceConfigSchema: z.ZodEffects<z.ZodObject<{
     } | {
         options?: Record<string, unknown>;
         kind?: "realtime";
-        provider?: "openai" | "google" | "xai";
+        provider?: "google" | "xai" | "openai";
     };
     tts?: {
         voice?: string;
@@ -3391,7 +3580,7 @@ declare const LuaVoiceConfigSchema: z.ZodEffects<z.ZodObject<{
     } | {
         options?: Record<string, unknown>;
         kind?: "realtime";
-        provider?: "openai" | "google" | "xai";
+        provider?: "google" | "xai" | "openai";
     };
     vadOptions?: {
         minSpeechDuration?: number;
@@ -3406,7 +3595,7 @@ declare const LuaVoiceConfigSchema: z.ZodEffects<z.ZodObject<{
     preemptiveGeneration?: boolean;
     interruption?: {
         enabled?: boolean;
-        mode?: "vad" | "adaptive";
+        mode?: "adaptive" | "vad";
         falseInterruptionTimeout?: number;
         resumeFalseInterruption?: boolean;
         minDelay?: number;
@@ -3439,6 +3628,7 @@ declare const LuaVoiceConfigSchema: z.ZodEffects<z.ZodObject<{
     onToolFailureSay?: string;
     excludeTools?: string[];
 }, {
+    name?: string;
     vad?: string;
     stt?: {
         voice?: string;
@@ -3453,10 +3643,9 @@ declare const LuaVoiceConfigSchema: z.ZodEffects<z.ZodObject<{
     } | {
         options?: Record<string, unknown>;
         kind?: "realtime";
-        provider?: "openai" | "google" | "xai";
+        provider?: "google" | "xai" | "openai";
     };
     volume?: number;
-    name?: string;
     llm?: {
         voice?: string;
         options?: Record<string, unknown>;
@@ -3470,7 +3659,7 @@ declare const LuaVoiceConfigSchema: z.ZodEffects<z.ZodObject<{
     } | {
         options?: Record<string, unknown>;
         kind?: "realtime";
-        provider?: "openai" | "google" | "xai";
+        provider?: "google" | "xai" | "openai";
     };
     tts?: {
         voice?: string;
@@ -3485,7 +3674,7 @@ declare const LuaVoiceConfigSchema: z.ZodEffects<z.ZodObject<{
     } | {
         options?: Record<string, unknown>;
         kind?: "realtime";
-        provider?: "openai" | "google" | "xai";
+        provider?: "google" | "xai" | "openai";
     };
     vadOptions?: {
         minSpeechDuration?: number;
@@ -3500,7 +3689,7 @@ declare const LuaVoiceConfigSchema: z.ZodEffects<z.ZodObject<{
     preemptiveGeneration?: boolean;
     interruption?: {
         enabled?: boolean;
-        mode?: "vad" | "adaptive";
+        mode?: "adaptive" | "vad";
         falseInterruptionTimeout?: number;
         resumeFalseInterruption?: boolean;
         minDelay?: number;
@@ -4793,6 +4982,29 @@ declare interface PushJobVersionDTO {
     metadata?: Record<string, any>;
 }
 
+/**
+ * Normalized, provider-agnostic model request options.
+ *
+ * This is the shape clients (Lua Desktop, lua-cli, admin overrides) use to
+ * ask for a reasoning effort / output verbosity without knowing which
+ * provider dialect (Anthropic `thinking`, OpenAI `reasoningEffort`, Google
+ * `thinkingConfig`, …) the resolved model actually speaks. lua-core's
+ * `buildProviderOptions` translates this into the wire-level
+ * `providerOptions` shape per model.
+ */
+declare const REASONING_EFFORT_VALUES: readonly ["off", "minimal", "low", "medium", "high", "max"];
+
+declare type ReasoningEffort = (typeof REASONING_EFFORT_VALUES)[number];
+
+/**
+ * Additive field on primitive publish responses. When the agent is under
+ * versioning the server performs a scoped promote and returns the newly
+ * minted + promoted agent version here; absent when the agent has no versions.
+ */
+declare interface ScopedPromoteFields {
+    agentVersion?: number;
+}
+
 /**
  * Response from product search.
  */
@@ -4843,6 +5055,33 @@ declare type SkillContextText = string | {
     text?: string;
 };
 
+export declare const Team: TeamApi;
+
+/**
+ * Team API — resolve a teammate by name within the agent's organization and get
+ * the channel handles they opted to share. Pair with `Channels.send` to message a
+ * colleague without typing their number.
+ *
+ * The org is derived server-side from the agent; you can only resolve members of
+ * your own org. Returns a list — disambiguate when more than one member matches.
+ *
+ * @example
+ * ```typescript
+ * const { matches } = await Team.findMember('Stefan');
+ * const wa = matches[0]?.targets.find((t) => t.channel === 'whatsapp');
+ * if (wa) {
+ *   await Channels.send({ channel: 'whatsapp', to: { phoneNumber: wa.value }, text: 'Hi Stefan!' });
+ * }
+ * ```
+ */
+export declare interface TeamApi {
+    /**
+     * Resolve teammates whose name matches, each with their shareable channel
+     * targets (empty `targets[]` when the member shared nothing).
+     */
+    findMember(name: string): Promise<DirectoryResolveResult>;
+}
+
 /**
  * Templates API
  *
@@ -5403,6 +5642,20 @@ export declare interface WebhookRequest {
     payload: any;
 }
 
+/** Body of POST /developer/agents/:agentId/channels/whatsapp/reaction */
+export declare interface WhatsAppReactionSendInput {
+    to: {
+        userId?: string;
+        phoneNumber?: string;
+    };
+    /** Vendor id (`wamid...`) of the message to react to — e.g. an inbound
+     * message's id from the conversation history, ≤30 days old per Meta. */
+    messageId: string;
+    /** A single emoji. An empty string removes the agent's existing reaction. */
+    emoji: string;
+    options?: ChannelSendOptions;
+}
+
 export declare interface WhatsAppTemplate {
     id: string;
     name: string;