@talqing/sdk 0.4.1 → 0.4.2

package/dist/esm/gen/sdk.gen.js

@@ -1077,6 +1077,36 @@ export class Avatars extends HeyApiClient {
         });
     }
 }
+export class Models extends HeyApiClient {
+    /**
+     * Search Models
+     *
+     * Search the language models a provider offers too many of to list.
+     *
+     * `GET /catalog` carries every model except these. A provider marked
+     * `browse: "search"` there — OpenRouter — reaches hundreds of models through
+     * one key, so they are searched a page at a time instead. With no `q` the order
+     * is real-world popularity. Everything returned is a valid `llm.model`.
+     */
+    search(parameters, options) {
+        const params = buildClientParams([parameters], [{ args: [
+                    { in: 'query', key: 'q' },
+                    { in: 'query', key: 'limit' },
+                    { in: 'query', key: 'cursor' }
+                ] }]);
+        return (options?.client ?? this.client).get({
+            responseStyle: 'data',
+            security: [{ scheme: 'bearer', type: 'http' }, {
+                    in: 'cookie',
+                    name: 'talqing_session',
+                    type: 'apiKey'
+                }],
+            url: '/v1/catalog/models',
+            ...options,
+            ...params
+        });
+    }
+}
 export class Elevenlabs extends HeyApiClient {
     /**
      * Add Elevenlabs Voice
@@ -1190,6 +1220,10 @@ export class Catalog extends HeyApiClient {
      * `realtime` lists the speech-to-speech models. One of those replaces `stt`,
      * `llm` and `tts` together, so an agent sets either `realtime` or the three
      * cascade slots, never both.
+     *
+     * One provider's models are NOT here: a `providers` entry whose `browse` is
+     * `search` reaches hundreds of them through one key, and they are searched
+     * through `GET /catalog/models` instead.
      */
     get(options) {
         return (options?.client ?? this.client).get({
@@ -1206,6 +1240,9 @@ export class Catalog extends HeyApiClient {
     get avatars() {
         return this._avatars ?? (this._avatars = new Avatars({ client: this.client }));
     }
+    get models() {
+        return this._models ?? (this._models = new Models({ client: this.client }));
+    }
     get voices() {
         return this._voices ?? (this._voices = new Voices({ client: this.client }));
     }
@@ -1777,7 +1814,8 @@ export class Recipients2 extends HeyApiClient {
      * every row it refuses. Rows already sent or queued are never redrafted.
      *
      * This revives a batch that had finished drafting, and a person's edited cells
-     * survive unless you pass `clear_overrides`.
+     * survive unless you pass `clear_overrides` — and are what the task is given.
+     * Refused on a canceled batch, whose rows can never draft again.
      */
     redraft(parameters, options) {
         const params = buildClientParams([parameters], [{ args: [{ in: 'path', key: 'batch_id' }, { key: 'redraftRequest', map: 'body' }] }]);
@@ -1825,11 +1863,10 @@ export class Recipients2 extends HeyApiClient {
     /**
      * Skip Email Batch Recipients
      *
-     * Take drafted rows out of consideration. Reversible with `restore`.
+     * Take rows out of consideration. Reversible with `restore`.
      *
-     * Takes either `recipient_ids` or `selection: "all_eligible"`, which here means
-     * every row that has a draft. The reversible verbs keep that shorthand while
-     * `send` does not, because the rule is about irreversibility rather than bulk.
+     * Accepts drafted rows and rows whose drafting failed. Takes either
+     * `recipient_ids` or `selection: "all_eligible"`, which here means both.
      */
     skip(parameters, options) {
         const params = buildClientParams([parameters], [{ args: [{ in: 'path', key: 'batch_id' }, { key: 'selectRecipientsRequest', map: 'body' }] }]);
@@ -1913,8 +1950,8 @@ export class Sends extends HeyApiClient {
      *
      * One send: where its rows are, and when it next does something.
      *
-     * `next_send_at` covers all three reasons a send waits — a start time, a closed
-     * window, and a daily cap already spent.
+     * `next_send_reason` says which gate is holding it — `start`, `window`,
+     * `daily_cap`, `retry` or `gap`.
      */
     get(parameters, options) {
         const params = buildClientParams([parameters], [{ args: [{ in: 'path', key: 'batch_id' }, { in: 'path', key: 'send_id' }] }]);
@@ -3036,152 +3073,11 @@ export class Secrets extends HeyApiClient {
         });
     }
 }
-export class Runs extends HeyApiClient {
-    /**
-     * List Task Runs
-     *
-     * This task's runs, newest first, each with its output, trace and cost.
-     *
-     * `task_version` says which published definition each one ran, and is null for
-     * a run of the draft.
-     */
-    list(parameters, options) {
-        const params = buildClientParams([parameters], [{ args: [
-                    { in: 'path', key: 'task_id' },
-                    { in: 'query', key: 'limit' },
-                    { in: 'query', key: 'offset' }
-                ] }]);
-        return (options?.client ?? this.client).get({
-            responseStyle: 'data',
-            security: [{ scheme: 'bearer', type: 'http' }, {
-                    in: 'cookie',
-                    name: 'talqing_session',
-                    type: 'apiKey'
-                }],
-            url: '/v1/tasks/{task_id}/runs',
-            ...options,
-            ...params
-        });
-    }
-    /**
-     * Run Task
-     *
-     * Run the task once with the variables you supply, and wait for the result.
-     *
-     * **This executes for real**: the tools call your endpoints with your secrets,
-     * the MCP servers spend your credits, and the model spends your tokens. A task
-     * that books a slot, charges a card or sends a message will do so.
-     *
-     * Runs the published version unless `version` names another one, or `"draft"`
-     * to run the unpublished config. `vars` must match what that version declares
-     * — an unknown name is refused rather than dropped. The response is the whole
-     * run: the structured `output`, a `trace` of every tool call, the steps used
-     * and what the tokens cost. On failure `error.type` says whose problem it is.
-     * Secrets are redacted.
-     */
-    create(parameters, options) {
-        const params = buildClientParams([parameters], [{ args: [{ in: 'path', key: 'task_id' }, { key: 'runTaskRequest', map: 'body' }] }]);
-        return (options?.client ?? this.client).post({
-            responseStyle: 'data',
-            security: [{ scheme: 'bearer', type: 'http' }, {
-                    in: 'cookie',
-                    name: 'talqing_session',
-                    type: 'apiKey'
-                }],
-            url: '/v1/tasks/{task_id}/runs',
-            ...options,
-            ...params,
-            headers: {
-                'Content-Type': 'application/json',
-                ...options?.headers,
-                ...params.headers
-            }
-        });
-    }
-    /**
-     * Get Task Run
-     *
-     * One run in full: what it produced, every tool it called on the way, and
-     * what it cost.
-     *
-     * This is what answers "why did it write that" for a caller holding one run id
-     * — an email batch's review table links each drafted row here. Secret values
-     * are redacted from the trace, and a trace that was cut reports it.
-     */
-    get(parameters, options) {
-        const params = buildClientParams([parameters], [{ args: [{ in: 'path', key: 'task_id' }, { in: 'path', key: 'run_id' }] }]);
-        return (options?.client ?? this.client).get({
-            responseStyle: 'data',
-            security: [{ scheme: 'bearer', type: 'http' }, {
-                    in: 'cookie',
-                    name: 'talqing_session',
-                    type: 'apiKey'
-                }],
-            url: '/v1/tasks/{task_id}/runs/{run_id}',
-            ...options,
-            ...params
-        });
-    }
-}
-export class Versions2 extends HeyApiClient {
-    /**
-     * Get Task Version
-     *
-     * Fetch what one published version of a task actually contains.
-     *
-     * `get_task` lists the versions and when each was published; this returns the
-     * frozen definition itself — prompt, model, output fields and the tool
-     * versions it pinned, exactly as they were at that publish.
-     */
-    get(parameters, options) {
-        const params = buildClientParams([parameters], [{ args: [{ in: 'path', key: 'task_id' }, { in: 'path', key: 'version' }] }]);
-        return (options?.client ?? this.client).get({
-            responseStyle: 'data',
-            security: [{ scheme: 'bearer', type: 'http' }, {
-                    in: 'cookie',
-                    name: 'talqing_session',
-                    type: 'apiKey'
-                }],
-            url: '/v1/tasks/{task_id}/versions/{version}',
-            ...options,
-            ...params
-        });
-    }
-    /**
-     * Rollback Task Version
-     *
-     * Put an earlier published version of a task back into production.
-     *
-     * That version becomes live **immediately** and **replaces the current draft**,
-     * so any unpublished edits are lost. No new version is created. The restored
-     * draft tracks each tool's latest published version, not the ones this version
-     * pinned.
-     */
-    rollback(parameters, options) {
-        const params = buildClientParams([parameters], [{ args: [{ in: 'path', key: 'task_id' }, { in: 'path', key: 'version' }] }]);
-        return (options?.client ?? this.client).post({
-            responseStyle: 'data',
-            security: [{ scheme: 'bearer', type: 'http' }, {
-                    in: 'cookie',
-                    name: 'talqing_session',
-                    type: 'apiKey'
-                }],
-            url: '/v1/tasks/{task_id}/versions/{version}/rollback',
-            ...options,
-            ...params
-        });
-    }
-}
-export class Tasks2 extends HeyApiClient {
+export class Streams extends HeyApiClient {
     /**
-     * List Tasks
-     *
-     * List the workspace's agent tasks.
+     * List Stream Connections
      *
-     * A task is an agent nobody talks to: a prompt, one LLM, tools and MCP
-     * servers, the variables it takes as input, and the typed result it must
-     * produce. Each item carries the full draft config, the published version
-     * number (null while it has never been published), and `last_run`.
+     * List WebSocket media-stream connections a partner can dial.
      */
     list(parameters, options) {
         const params = buildClientParams([parameters], [{ args: [{ in: 'query', key: 'limit' }, { in: 'query', key: 'offset' }] }]);
@@ -3192,24 +3088,21 @@ export class Tasks2 extends HeyApiClient {
                     name: 'talqing_session',
                     type: 'apiKey'
                 }],
-            url: '/v1/tasks',
+            url: '/v1/streams',
             ...options,
             ...params
         });
     }
     /**
-     * Create Task
+     * Create Stream Connection
      *
-     * Create an agent task: an agent nobody talks to, which takes named inputs
-     * and returns a typed result.
+     * Create a connection a streaming partner can dial.
      *
-     * `output` is what makes this a task rather than a chat agent — declare the
-     * fields the model must produce and it is given a `submit_result` tool built
-     * from them. `vars` are its inputs, read as `{{vars.name}}`. The task starts
-     * unpublished; publish it before running it.
+     * One connection per agent per dialect: the URL names both, so a second would
+     * only be the same URL again.
      */
     create(parameters, options) {
-        const params = buildClientParams([parameters], [{ args: [{ key: 'createTaskRequest', map: 'body' }] }]);
+        const params = buildClientParams([parameters], [{ args: [{ key: 'createStreamConnectionRequest', map: 'body' }] }]);
         return (options?.client ?? this.client).post({
             responseStyle: 'data',
             security: [{ scheme: 'bearer', type: 'http' }, {
@@ -3217,7 +3110,7 @@ export class Tasks2 extends HeyApiClient {
                     name: 'talqing_session',
                     type: 'apiKey'
                 }],
-            url: '/v1/tasks',
+            url: '/v1/streams',
             ...options,
             ...params,
             headers: {
@@ -3228,13 +3121,12 @@ export class Tasks2 extends HeyApiClient {
         });
     }
     /**
-     * Delete Task
+     * Delete Stream Connection
      *
-     * Delete a task and its published versions. Its runs survive, still named
-     * after it.
+     * Delete a stream connection. Calls it already carried are kept.
      */
     delete(parameters, options) {
-        const params = buildClientParams([parameters], [{ args: [{ in: 'path', key: 'task_id' }] }]);
+        const params = buildClientParams([parameters], [{ args: [{ in: 'path', key: 'connection_id' }] }]);
         return (options?.client ?? this.client).delete({
             responseStyle: 'data',
             security: [{ scheme: 'bearer', type: 'http' }, {
@@ -3242,18 +3134,18 @@ export class Tasks2 extends HeyApiClient {
                     name: 'talqing_session',
                     type: 'apiKey'
                 }],
-            url: '/v1/tasks/{task_id}',
+            url: '/v1/streams/{connection_id}',
             ...options,
             ...params
         });
     }
     /**
-     * Get Task
+     * Get Stream Connection
      *
-     * Fetch one task's draft config, published version, history and last run.
+     * One stream connection, with the URL to hand the partner.
      */
     get(parameters, options) {
-        const params = buildClientParams([parameters], [{ args: [{ in: 'path', key: 'task_id' }] }]);
+        const params = buildClientParams([parameters], [{ args: [{ in: 'path', key: 'connection_id' }] }]);
         return (options?.client ?? this.client).get({
             responseStyle: 'data',
             security: [{ scheme: 'bearer', type: 'http' }, {
@@ -3261,22 +3153,21 @@ export class Tasks2 extends HeyApiClient {
                     name: 'talqing_session',
                     type: 'apiKey'
                 }],
-            url: '/v1/tasks/{task_id}',
+            url: '/v1/streams/{connection_id}',
             ...options,
             ...params
         });
     }
     /**
-     * Update Task
+     * Patch Stream Connection
      *
-     * Replace the task's draft config with the one supplied.
+     * Rename a connection, point it at another agent, or disable it.
      *
-     * The whole config is sent, so include every field you mean to keep. Writes
-     * land on the draft only — runs and email batches keep using the published
-     * version until you publish again.
+     * Disabling refuses new calls immediately and is the only way to stop a URL
+     * answering; calls already running are untouched.
      */
     update(parameters, options) {
-        const params = buildClientParams([parameters], [{ args: [{ in: 'path', key: 'task_id' }, { key: 'patchTaskRequest', map: 'body' }] }]);
+        const params = buildClientParams([parameters], [{ args: [{ in: 'path', key: 'connection_id' }, { key: 'patchStreamConnectionRequest', map: 'body' }] }]);
         return (options?.client ?? this.client).patch({
             responseStyle: 'data',
             security: [{ scheme: 'bearer', type: 'http' }, {
@@ -3284,7 +3175,7 @@ export class Tasks2 extends HeyApiClient {
                     name: 'talqing_session',
                     type: 'apiKey'
                 }],
-            url: '/v1/tasks/{task_id}',
+            url: '/v1/streams/{connection_id}',
             ...options,
             ...params,
             headers: {
@@ -3294,59 +3185,6 @@ export class Tasks2 extends HeyApiClient {
             }
         });
     }
-    /**
-     * Publish Task
-     *
-     * Freeze the current draft as a new immutable version and make it live.
-     *
-     * Validation must pass. Publishing pins every attached tool to the tool
-     * version live right now, so republishing a tool does not change this task
-     * until the task is published again.
-     */
-    publish(parameters, options) {
-        const params = buildClientParams([parameters], [{ args: [{ in: 'path', key: 'task_id' }] }]);
-        return (options?.client ?? this.client).post({
-            responseStyle: 'data',
-            security: [{ scheme: 'bearer', type: 'http' }, {
-                    in: 'cookie',
-                    name: 'talqing_session',
-                    type: 'apiKey'
-                }],
-            url: '/v1/tasks/{task_id}/publish',
-            ...options,
-            ...params
-        });
-    }
-    /**
-     * Validate Task
-     *
-     * Run publish-grade validation on the draft without publishing it.
-     *
-     * Covers everything a draft write checks plus what publishing adds: a
-     * workspace API key for the model, at least one output field, the operation
-     * trees of the attached tools, and the email batches already drafting with
-     * this task. Returns errors (blocking) and warnings (advisory).
-     */
-    validate(parameters, options) {
-        const params = buildClientParams([parameters], [{ args: [{ in: 'path', key: 'task_id' }] }]);
-        return (options?.client ?? this.client).post({
-            responseStyle: 'data',
-            security: [{ scheme: 'bearer', type: 'http' }, {
-                    in: 'cookie',
-                    name: 'talqing_session',
-                    type: 'apiKey'
-                }],
-            url: '/v1/tasks/{task_id}/validate',
-            ...options,
-            ...params
-        });
-    }
-    get runs() {
-        return this._runs ?? (this._runs = new Runs({ client: this.client }));
-    }
-    get versions() {
-        return this._versions ?? (this._versions = new Versions2({ client: this.client }));
-    }
 }
 export class Accounts extends HeyApiClient {
     /**
@@ -3738,6 +3576,9 @@ export class Providers extends HeyApiClient {
     }
 }
 export class Telephony extends HeyApiClient {
+    get streams() {
+        return this._streams ?? (this._streams = new Streams({ client: this.client }));
+    }
     get accounts() {
         return this._accounts ?? (this._accounts = new Accounts({ client: this.client }));
     }
@@ -3748,17 +3589,329 @@ export class Telephony extends HeyApiClient {
         return this._providers ?? (this._providers = new Providers({ client: this.client }));
     }
 }
-export class Versions3 extends HeyApiClient {
+export class Runs extends HeyApiClient {
     /**
-     * Get Tool Version
+     * List Task Runs
      *
-     * Fetch what one published version of a tool actually contains.
+     * This task's runs, newest first, each with its output, trace and cost.
      *
-     * `get_tool` lists the versions and when each was published; this returns the
-     * frozen definition itself — the arguments, behaviour flags and operation tree
-     * exactly as they were at that publish. Use it to see what changed between two
-     * versions, or between a version and the current draft.
-     */
+     * `task_version` says which published definition each one ran, and is null for
+     * a run of the draft.
+     */
+    list(parameters, options) {
+        const params = buildClientParams([parameters], [{ args: [
+                    { in: 'path', key: 'task_id' },
+                    { in: 'query', key: 'limit' },
+                    { in: 'query', key: 'offset' }
+                ] }]);
+        return (options?.client ?? this.client).get({
+            responseStyle: 'data',
+            security: [{ scheme: 'bearer', type: 'http' }, {
+                    in: 'cookie',
+                    name: 'talqing_session',
+                    type: 'apiKey'
+                }],
+            url: '/v1/tasks/{task_id}/runs',
+            ...options,
+            ...params
+        });
+    }
+    /**
+     * Run Task
+     *
+     * Run the task once with the variables you supply, and wait for the result.
+     *
+     * **This executes for real**: the tools call your endpoints with your secrets,
+     * the MCP servers spend your credits, and the model spends your tokens. A task
+     * that books a slot, charges a card or sends a message will do so.
+     *
+     * Runs the published version unless `version` names another one, or `"draft"`
+     * to run the unpublished config. `vars` must match what that version declares
+     * — an unknown name is refused rather than dropped. The response is the whole
+     * run: the structured `output`, a `trace` of every tool call, the steps used
+     * and what the tokens cost. On failure `error.type` says whose problem it is.
+     * Secrets are redacted.
+     */
+    create(parameters, options) {
+        const params = buildClientParams([parameters], [{ args: [{ in: 'path', key: 'task_id' }, { key: 'runTaskRequest', map: 'body' }] }]);
+        return (options?.client ?? this.client).post({
+            responseStyle: 'data',
+            security: [{ scheme: 'bearer', type: 'http' }, {
+                    in: 'cookie',
+                    name: 'talqing_session',
+                    type: 'apiKey'
+                }],
+            url: '/v1/tasks/{task_id}/runs',
+            ...options,
+            ...params,
+            headers: {
+                'Content-Type': 'application/json',
+                ...options?.headers,
+                ...params.headers
+            }
+        });
+    }
+    /**
+     * Get Task Run
+     *
+     * One run in full: what it produced, every tool it called on the way, and
+     * what it cost.
+     *
+     * This is what answers "why did it write that" for a caller holding one run id
+     * — an email batch's review table links each drafted row here. Secret values
+     * are redacted from the trace, and a trace that was cut reports it.
+     */
+    get(parameters, options) {
+        const params = buildClientParams([parameters], [{ args: [{ in: 'path', key: 'task_id' }, { in: 'path', key: 'run_id' }] }]);
+        return (options?.client ?? this.client).get({
+            responseStyle: 'data',
+            security: [{ scheme: 'bearer', type: 'http' }, {
+                    in: 'cookie',
+                    name: 'talqing_session',
+                    type: 'apiKey'
+                }],
+            url: '/v1/tasks/{task_id}/runs/{run_id}',
+            ...options,
+            ...params
+        });
+    }
+}
+export class Versions2 extends HeyApiClient {
+    /**
+     * Get Task Version
+     *
+     * Fetch what one published version of a task actually contains.
+     *
+     * `get_task` lists the versions and when each was published; this returns the
+     * frozen definition itself — prompt, model, output fields and the tool
+     * versions it pinned, exactly as they were at that publish.
+     */
+    get(parameters, options) {
+        const params = buildClientParams([parameters], [{ args: [{ in: 'path', key: 'task_id' }, { in: 'path', key: 'version' }] }]);
+        return (options?.client ?? this.client).get({
+            responseStyle: 'data',
+            security: [{ scheme: 'bearer', type: 'http' }, {
+                    in: 'cookie',
+                    name: 'talqing_session',
+                    type: 'apiKey'
+                }],
+            url: '/v1/tasks/{task_id}/versions/{version}',
+            ...options,
+            ...params
+        });
+    }
+    /**
+     * Rollback Task Version
+     *
+     * Put an earlier published version of a task back into production.
+     *
+     * That version becomes live **immediately** and **replaces the current draft**,
+     * so any unpublished edits are lost. No new version is created. The restored
+     * draft tracks each tool's latest published version, not the ones this version
+     * pinned.
+     */
+    rollback(parameters, options) {
+        const params = buildClientParams([parameters], [{ args: [{ in: 'path', key: 'task_id' }, { in: 'path', key: 'version' }] }]);
+        return (options?.client ?? this.client).post({
+            responseStyle: 'data',
+            security: [{ scheme: 'bearer', type: 'http' }, {
+                    in: 'cookie',
+                    name: 'talqing_session',
+                    type: 'apiKey'
+                }],
+            url: '/v1/tasks/{task_id}/versions/{version}/rollback',
+            ...options,
+            ...params
+        });
+    }
+}
+export class Tasks2 extends HeyApiClient {
+    /**
+     * List Tasks
+     *
+     * List the workspace's agent tasks.
+     *
+     * A task is an agent nobody talks to: a prompt, one LLM, tools and MCP
+     * servers, the variables it takes as input, and the typed result it must
+     * produce. Each item carries the full draft config, the published version
+     * number (null while it has never been published), and `last_run`.
+     */
+    list(parameters, options) {
+        const params = buildClientParams([parameters], [{ args: [{ in: 'query', key: 'limit' }, { in: 'query', key: 'offset' }] }]);
+        return (options?.client ?? this.client).get({
+            responseStyle: 'data',
+            security: [{ scheme: 'bearer', type: 'http' }, {
+                    in: 'cookie',
+                    name: 'talqing_session',
+                    type: 'apiKey'
+                }],
+            url: '/v1/tasks',
+            ...options,
+            ...params
+        });
+    }
+    /**
+     * Create Task
+     *
+     * Create an agent task: an agent nobody talks to, which takes named inputs
+     * and returns a typed result.
+     *
+     * `output` is what makes this a task rather than a chat agent — declare the
+     * fields the model must produce and it is given a `submit_result` tool built
+     * from them. `vars` are its inputs, read as `{{vars.name}}`. The task starts
+     * unpublished; publish it before running it.
+     */
+    create(parameters, options) {
+        const params = buildClientParams([parameters], [{ args: [{ key: 'createTaskRequest', map: 'body' }] }]);
+        return (options?.client ?? this.client).post({
+            responseStyle: 'data',
+            security: [{ scheme: 'bearer', type: 'http' }, {
+                    in: 'cookie',
+                    name: 'talqing_session',
+                    type: 'apiKey'
+                }],
+            url: '/v1/tasks',
+            ...options,
+            ...params,
+            headers: {
+                'Content-Type': 'application/json',
+                ...options?.headers,
+                ...params.headers
+            }
+        });
+    }
+    /**
+     * Delete Task
+     *
+     * Delete a task and its published versions. Its runs survive, still named
+     * after it.
+     */
+    delete(parameters, options) {
+        const params = buildClientParams([parameters], [{ args: [{ in: 'path', key: 'task_id' }] }]);
+        return (options?.client ?? this.client).delete({
+            responseStyle: 'data',
+            security: [{ scheme: 'bearer', type: 'http' }, {
+                    in: 'cookie',
+                    name: 'talqing_session',
+                    type: 'apiKey'
+                }],
+            url: '/v1/tasks/{task_id}',
+            ...options,
+            ...params
+        });
+    }
+    /**
+     * Get Task
+     *
+     * Fetch one task's draft config, published version, history and last run.
+     */
+    get(parameters, options) {
+        const params = buildClientParams([parameters], [{ args: [{ in: 'path', key: 'task_id' }] }]);
+        return (options?.client ?? this.client).get({
+            responseStyle: 'data',
+            security: [{ scheme: 'bearer', type: 'http' }, {
+                    in: 'cookie',
+                    name: 'talqing_session',
+                    type: 'apiKey'
+                }],
+            url: '/v1/tasks/{task_id}',
+            ...options,
+            ...params
+        });
+    }
+    /**
+     * Update Task
+     *
+     * Replace the task's draft config with the one supplied.
+     *
+     * The whole config is sent, so include every field you mean to keep. Writes
+     * land on the draft only — runs and email batches keep using the published
+     * version until you publish again.
+     */
+    update(parameters, options) {
+        const params = buildClientParams([parameters], [{ args: [{ in: 'path', key: 'task_id' }, { key: 'patchTaskRequest', map: 'body' }] }]);
+        return (options?.client ?? this.client).patch({
+            responseStyle: 'data',
+            security: [{ scheme: 'bearer', type: 'http' }, {
+                    in: 'cookie',
+                    name: 'talqing_session',
+                    type: 'apiKey'
+                }],
+            url: '/v1/tasks/{task_id}',
+            ...options,
+            ...params,
+            headers: {
+                'Content-Type': 'application/json',
+                ...options?.headers,
+                ...params.headers
+            }
+        });
+    }
+    /**
+     * Publish Task
+     *
+     * Freeze the current draft as a new immutable version and make it live.
+     *
+     * Validation must pass. Publishing pins every attached tool to the tool
+     * version live right now, so republishing a tool does not change this task
+     * until the task is published again.
+     */
+    publish(parameters, options) {
+        const params = buildClientParams([parameters], [{ args: [{ in: 'path', key: 'task_id' }] }]);
+        return (options?.client ?? this.client).post({
+            responseStyle: 'data',
+            security: [{ scheme: 'bearer', type: 'http' }, {
+                    in: 'cookie',
+                    name: 'talqing_session',
+                    type: 'apiKey'
+                }],
+            url: '/v1/tasks/{task_id}/publish',
+            ...options,
+            ...params
+        });
+    }
+    /**
+     * Validate Task
+     *
+     * Run publish-grade validation on the draft without publishing it.
+     *
+     * Covers everything a draft write checks plus what publishing adds: a
+     * workspace API key for the model, at least one output field, the operation
+     * trees of the attached tools, and the email batches already drafting with
+     * this task. Returns errors (blocking) and warnings (advisory).
+     */
+    validate(parameters, options) {
+        const params = buildClientParams([parameters], [{ args: [{ in: 'path', key: 'task_id' }] }]);
+        return (options?.client ?? this.client).post({
+            responseStyle: 'data',
+            security: [{ scheme: 'bearer', type: 'http' }, {
+                    in: 'cookie',
+                    name: 'talqing_session',
+                    type: 'apiKey'
+                }],
+            url: '/v1/tasks/{task_id}/validate',
+            ...options,
+            ...params
+        });
+    }
+    get runs() {
+        return this._runs ?? (this._runs = new Runs({ client: this.client }));
+    }
+    get versions() {
+        return this._versions ?? (this._versions = new Versions2({ client: this.client }));
+    }
+}
+export class Versions3 extends HeyApiClient {
+    /**
+     * Get Tool Version
+     *
+     * Fetch what one published version of a tool actually contains.
+     *
+     * `get_tool` lists the versions and when each was published; this returns the
+     * frozen definition itself — the arguments, behaviour flags and operation tree
+     * exactly as they were at that publish. Use it to see what changed between two
+     * versions, or between a version and the current draft.
+     */
     get(parameters, options) {
         const params = buildClientParams([parameters], [{ args: [{ in: 'path', key: 'tool_id' }, { in: 'path', key: 'version' }] }]);
         return (options?.client ?? this.client).get({
@@ -4195,7 +4348,9 @@ export class TalqingApi extends HeyApiClient {
      * Liveness probe: `200` once this process is serving. Unauthenticated.
      *
      * It answers for the API process, not its dependencies — a `200` here does
-     * not promise Postgres, Redis or LiveKit are reachable.
+     * not promise Postgres, Redis or LiveKit are reachable. The one thing it
+     * does report is `model_registry`, because that snapshot lives in this
+     * process's memory and nothing else can see how old it is.
      */
     health(options) {
         return (options?.client ?? this.client).get({
@@ -4243,12 +4398,12 @@ export class TalqingApi extends HeyApiClient {
     get secrets() {
         return this._secrets ?? (this._secrets = new Secrets({ client: this.client }));
     }
-    get tasks() {
-        return this._tasks ?? (this._tasks = new Tasks2({ client: this.client }));
-    }
     get telephony() {
         return this._telephony ?? (this._telephony = new Telephony({ client: this.client }));
     }
+    get tasks() {
+        return this._tasks ?? (this._tasks = new Tasks2({ client: this.client }));
+    }
     get tools() {
         return this._tools ?? (this._tools = new Tools2({ client: this.client }));
     }