hanzoai 8.5.621 → 8.5.640

package/dist/esm/models/task-comment-list.d.ts

@@ -0,0 +1,31 @@
+/**
+ * Hanzo Cloud API
+ * The Hanzo Cloud API as a customer calls it: every operation under /v1/ except the operator\'s admin product, relay routes, legacy spellings and capabilities still reached by flag. Tagged by product: the first path segment after /v1/.
+ *
+ * The version of the OpenAPI document: v1
+ *
+ *
+ * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).
+ * https://openapi-generator.tech
+ * Do not edit the class manually.
+ */
+import type { TaskComment } from './task-comment';
+/**
+ *
+ * @export
+ * @interface TaskCommentList
+ */
+export interface TaskCommentList {
+    /**
+     * Data is the conversation. Empty is an empty array, never null.
+     * @type {Array<TaskComment>}
+     * @memberof TaskCommentList
+     */
+    'data'?: Array<TaskComment>;
+    /**
+     * Home is the GitHub repository (owner/name) the issue lives on when its board mirrors one; its conversation is read there, and Data is then empty.
+     * @type {string}
+     * @memberof TaskCommentList
+     */
+    'home'?: string;
+}

package/dist/esm/models/task-comment-list.js

@@ -0,0 +1,14 @@
+/* tslint:disable */
+/* eslint-disable */
+/**
+ * Hanzo Cloud API
+ * The Hanzo Cloud API as a customer calls it: every operation under /v1/ except the operator\'s admin product, relay routes, legacy spellings and capabilities still reached by flag. Tagged by product: the first path segment after /v1/.
+ *
+ * The version of the OpenAPI document: v1
+ *
+ *
+ * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).
+ * https://openapi-generator.tech
+ * Do not edit the class manually.
+ */
+export {};

package/dist/esm/models/task-comment.d.ts

@@ -0,0 +1,42 @@
+/**
+ * Hanzo Cloud API
+ * The Hanzo Cloud API as a customer calls it: every operation under /v1/ except the operator\'s admin product, relay routes, legacy spellings and capabilities still reached by flag. Tagged by product: the first path segment after /v1/.
+ *
+ * The version of the OpenAPI document: v1
+ *
+ *
+ * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).
+ * https://openapi-generator.tech
+ * Do not edit the class manually.
+ */
+/**
+ *
+ * @export
+ * @interface TaskComment
+ */
+export interface TaskComment {
+    /**
+     * Author is who wrote it: their name, else their forge login.
+     * @type {string}
+     * @memberof TaskComment
+     */
+    'author'?: string;
+    /**
+     * Body is what was written, as markdown.
+     * @type {string}
+     * @memberof TaskComment
+     */
+    'body'?: string;
+    /**
+     * CreatedAt is when it was written, RFC 3339.
+     * @type {string}
+     * @memberof TaskComment
+     */
+    'createdAt'?: string;
+    /**
+     * ID is the forge\'s id for the comment.
+     * @type {number}
+     * @memberof TaskComment
+     */
+    'id'?: number;
+}

package/dist/esm/models/task-comment.js

@@ -0,0 +1,14 @@
+/* tslint:disable */
+/* eslint-disable */
+/**
+ * Hanzo Cloud API
+ * The Hanzo Cloud API as a customer calls it: every operation under /v1/ except the operator\'s admin product, relay routes, legacy spellings and capabilities still reached by flag. Tagged by product: the first path segment after /v1/.
+ *
+ * The version of the OpenAPI document: v1
+ *
+ *
+ * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).
+ * https://openapi-generator.tech
+ * Do not edit the class manually.
+ */
+export {};

package/dist/esm/transport.d.ts

@@ -0,0 +1,4 @@
+import { Configuration as Generated, type ConfigurationParameters } from './configuration';
+export declare class Configuration extends Generated {
+    constructor(param?: ConfigurationParameters);
+}

package/dist/esm/transport.js

@@ -0,0 +1,188 @@
+// transport — the Configuration this package exports.
+//
+// It is the generated Configuration plus one thing: a request a generated *Api
+// class sends with it that comes back 402 or 429 with a usage refusal in the
+// body throws that refusal's typed error (usage.ts). Every other answer passes
+// through untouched — a 400 is still the AxiosError it was.
+//
+// The error path is axios's own: one response interceptor on the axios instance
+// the generated classes use by default, installed by the first Configuration
+// built. It acts only on requests marked as this package's, and the mark rides
+// in `baseOptions`, which the generated client spreads into every request it
+// builds — so the caller's other axios traffic, adapters and transforms are left
+// as they were. An axios instance passed as an *Api's third argument has
+// interceptors of its own, and a refusal through it stays an AxiosError.
+//
+// hanzo.ts exports this class under the generated one's name, so
+// `new Configuration({ accessToken })` from 'hanzoai' is this one, and so is
+// `Client.configuration`.
+import axios from 'axios';
+import { Configuration as Generated } from './configuration';
+import { header, limited } from './usage';
+/**
+ * The request option that marks a request as sent with this Configuration. Its
+ * value is this module's own interceptor, so two copies of the package sharing
+ * one axios each type only their own requests, with their own classes.
+ */
+const MARK = 'hanzoUsage';
+/** A stream body is read this far at most; a refusal is a few hundred bytes of JSON. */
+const CAP = 1 << 16;
+export class Configuration extends Generated {
+    constructor(param = {}) {
+        super(param);
+        this.baseOptions = { ...this.baseOptions, [MARK]: refused };
+        // Checked, not remembered: a test teardown's `interceptors.response.clear()`
+        // removes it, and the next Configuration puts it back.
+        const installed = axios.interceptors.response.handlers?.some((h) => h?.rejected === refused);
+        if (!installed)
+            axios.interceptors.response.use(undefined, refused);
+    }
+}
+/** Rethrow a marked 402 or 429 as the usage refusal its body names; anything else as it came. */
+async function refused(err) {
+    const e = err;
+    const res = e?.response;
+    const config = e?.config;
+    if (!res || config?.[MARK] !== refused || (res.status !== 402 && res.status !== 429))
+        throw err;
+    let parsed;
+    try {
+        parsed = await body(res, config);
+    }
+    catch {
+        // A body that cannot be read names nothing: the answer is the one axios gave.
+        throw err;
+    }
+    throw limited(res.status, parsed, header(res.headers, 'x-request-id'), err) ?? err;
+}
+/**
+ * The body as JSON where it is JSON. axios hands it over parsed by default and
+ * raw when the caller asked for a buffer, a blob or a stream. A stream is read
+ * only when it says it is JSON — a refusal is, an event stream never is — at
+ * most CAP bytes, no longer than the caller's signal and timeout allow, and
+ * without taking it from the caller: `res.data` is left holding a stream of the
+ * same family that yields every byte again.
+ */
+async function body(res, config) {
+    let data = res.data;
+    if (web(data) || node(data)) {
+        if (!/json/i.test(header(res.headers, 'content-type') ?? ''))
+            return undefined;
+        const read = web(data) ? peekWeb(data, config) : peekNode(data, config);
+        const { text, again } = await read;
+        res.data = again;
+        data = text;
+    }
+    else if (typeof Blob !== 'undefined' && data instanceof Blob) {
+        data = await data.text();
+    }
+    else if (data instanceof ArrayBuffer || ArrayBuffer.isView(data)) {
+        data = new TextDecoder().decode(data);
+    }
+    if (typeof data !== 'string')
+        return data;
+    try {
+        return JSON.parse(data);
+    }
+    catch {
+        return data;
+    }
+}
+/** A WHATWG stream: the fetch and xhr adapters' `responseType: 'stream'`. */
+const web = (v) => typeof v?.tee === 'function' && typeof v.getReader === 'function';
+const node = (v) => typeof v?.pipe === 'function' &&
+    typeof v[Symbol.asyncIterator] === 'function' &&
+    typeof v.constructor?.from === 'function';
+/** Read a WHATWG stream through `peek`, and hand back a WHATWG stream that replays it. */
+async function peekWeb(stream, config) {
+    const reader = stream.getReader();
+    const { text, rest } = await peek(() => reader.read(), config);
+    const again = new ReadableStream({
+        async pull(controller) {
+            const step = await rest.next();
+            if (step.done)
+                controller.close();
+            else
+                controller.enqueue(step.value);
+        },
+        cancel: (reason) => reader.cancel(reason),
+    });
+    return { text, again };
+}
+/** Read a Node stream through `peek`; `Readable.from` comes off its own constructor, so no bundle gains node:stream. */
+async function peekNode(stream, config) {
+    const it = stream[Symbol.asyncIterator]();
+    const { text, rest } = await peek(() => it.next(), config);
+    return { text, again: stream.constructor.from(rest) };
+}
+const STOP = Symbol('stop');
+/**
+ * Read chunks until the end, CAP bytes, the caller's abort or its timeout,
+ * whichever comes first. `text` is the whole body only when the end was
+ * reached — anything less names no refusal. `rest` yields every chunk read and
+ * then whatever is left, including a read still in flight and a failure, so the
+ * caller's stream loses nothing.
+ */
+async function peek(next, config) {
+    const seen = [];
+    const decoder = new TextDecoder();
+    let text = '';
+    let done = false;
+    let failed;
+    let pending;
+    let timer;
+    let quit;
+    const stop = new Promise((resolve) => {
+        quit = () => resolve(STOP);
+        const signal = config.signal;
+        if (signal && typeof signal.addEventListener === 'function') {
+            if (signal.aborted)
+                resolve(STOP);
+            signal.addEventListener('abort', () => resolve(STOP), { once: true });
+        }
+        if (config.timeout && config.timeout > 0)
+            timer = setTimeout(() => resolve(STOP), config.timeout);
+    });
+    try {
+        while (text.length < CAP) {
+            pending = next();
+            const step = await Promise.race([pending, stop]);
+            if (step === STOP)
+                break;
+            pending = undefined;
+            if (step.done) {
+                done = true;
+                break;
+            }
+            seen.push(step.value);
+            text += typeof step.value === 'string' ? step.value : decoder.decode(step.value, { stream: true });
+        }
+    }
+    catch (error) {
+        pending = undefined;
+        failed = { error };
+    }
+    finally {
+        if (timer)
+            clearTimeout(timer);
+        quit?.();
+    }
+    async function* rest() {
+        yield* seen;
+        if (failed)
+            throw failed.error;
+        if (pending) {
+            const step = await pending;
+            if (step.done)
+                return;
+            yield step.value;
+        }
+        while (!done) {
+            const step = await next();
+            if (step.done)
+                return;
+            yield step.value;
+        }
+    }
+    return { text: done ? text : undefined, rest: rest() };
+}

package/dist/esm/usage.d.ts

@@ -0,0 +1,98 @@
+import { type Obj } from './read';
+/** One way out of a usage refusal, in the order to offer them. */
+export interface UsageAction {
+    /** upgrade | switch | credits | topup. */
+    kind: string;
+    /** The words to put on the button. */
+    label?: string;
+    /** Where to go: the pay page, or `/v1/ai/limits` for "continue with credits". */
+    url?: string;
+    /** The plan an `upgrade` moves to. */
+    plan?: string;
+    /** The model a `switch` moves to. */
+    model?: string;
+}
+/** A priced request refused because nothing the caller holds may pay for it. */
+export declare class UsageLimitError extends Error {
+    name: string;
+    /** 402 or 429. */
+    readonly status: number;
+    /** The machine code — one per subclass. */
+    readonly code: string;
+    /** `billing_error` or `rate_limit_error`. */
+    readonly type: string | undefined;
+    /** The class of usage refused: premium, ours or free. */
+    readonly usageClass: string | undefined;
+    /** The model the refusal is about. */
+    readonly model: string | undefined;
+    /** The model that answers instead, where there is one. */
+    readonly fallback: string | undefined;
+    /** When the refusal lifts by itself. */
+    readonly resetsAt: Date | undefined;
+    /** The upgrade page. */
+    readonly upgradeUrl: string | undefined;
+    readonly actions: UsageAction[];
+    /** `x-request-id` — the handle that finds this call in the audit trail. */
+    readonly request: string | undefined;
+    /** What the transport raised: the AxiosError on the generated client, nothing on the six. */
+    readonly cause: unknown;
+    constructor(status: number, error: Obj, request?: string, cause?: unknown);
+}
+/** 402 `plan_allowance_used` — the plan's included usage of the class is used, and nothing else may pay. */
+export declare class PlanAllowanceUsedError extends UsageLimitError {
+    name: string;
+}
+/** 402 `paid_plan_required` — the model needs a paid plan or prepaid balance. */
+export declare class PaidPlanRequiredError extends UsageLimitError {
+    name: string;
+}
+/** 429 `free_plan_cap` — the free plan's daily cap on the model is used; it lifts at `resetsAt`. */
+export declare class FreePlanCapError extends UsageLimitError {
+    name: string;
+}
+/** 402 `model_cap` — the model has used its share of the plan; `fallback` answers instead. */
+export declare class ModelCapError extends UsageLimitError {
+    name: string;
+}
+/** 429 `usage_cap_exceeded` — a session or day request window is spent. */
+export declare class UsageCapExceededError extends UsageLimitError {
+    name: string;
+}
+/** 402 `insufficient_balance` — the known wallet balance cannot cover the request. */
+export declare class InsufficientBalanceError extends UsageLimitError {
+    name: string;
+}
+/**
+ * The typed error a refusal names, or undefined: only a 402 or 429 whose
+ * `error.code` is one of the six is one. Anything else stays whatever error its
+ * transport already raises.
+ */
+export declare function limited(status: number, body: unknown, request?: string, cause?: unknown): UsageLimitError | undefined;
+/** What the X-Hanzo-* headers on one answer say. Each is undefined where the header is absent. */
+export interface Usage {
+    /** X-Hanzo-Usage: ok | near | limited — where the class stands. */
+    usage: string | undefined;
+    /** X-Hanzo-Usage-Class: premium | ours | free. */
+    usageClass: string | undefined;
+    /** X-Hanzo-Paid-By: plan | credits | free. Prepaid and granted credit both read `credits`. */
+    paidBy: string | undefined;
+    /** X-Hanzo-Fallback: the model that answered instead (limited mode). */
+    fallback: string | undefined;
+    /** X-Hanzo-Served: the Hanzo SKU that answered. */
+    served: string | undefined;
+    /** X-Hanzo-Usage-Reason: the refusal code that caused a fallback. */
+    reason: string | undefined;
+}
+/** A fetch `Headers`, axios's `AxiosHeaders`, or any record of header name to value. */
+export type HeaderSource = {
+    get(name: string): unknown;
+} | Record<string, unknown>;
+/**
+ * Read the usage headers off one answer: `readUsage(res.headers)` for an axios
+ * response or a fetch Response alike. Names match case-insensitively. A header
+ * that is absent, or present and empty, reads undefined — never 0 or "", which
+ * would claim the server said something it did not.
+ */
+export declare function readUsage(headers: HeaderSource | null | undefined): Usage;
+/** One header by lower-case name, matched case-insensitively; undefined where absent or empty. */
+export declare function header(headers: HeaderSource | null | undefined, name: string): string | undefined;

package/dist/esm/usage.js

@@ -0,0 +1,161 @@
+// usage — how a priced request was paid for, and the refusals when it cannot be.
+//
+// Every AI answer says where the caller's plan stands in six headers, never a
+// figure: X-Hanzo-Usage (ok | near | limited), -Usage-Class (premium | ours |
+// free), -Paid-By (plan | credits | free), -Fallback (the model that answered
+// instead), -Served (the Hanzo SKU that answered) and -Usage-Reason (the refusal
+// code that caused a fallback). `readUsage` reads them off whatever headers the
+// caller holds.
+//
+// A request nothing may pay for is refused in the OpenAI envelope,
+//
+//   {"error": {"message", "type", "code", "class"?, "model"?, "fallback"?,
+//              "resets_at"?, "upgrade_url"?, "actions"?}}
+//
+// and six codes in it are six different facts with six different ways out, so
+// each is a class: a caller tells them apart with `instanceof`, never by parsing
+// the sentence. The names are the Python and Go SDKs' names. Both transports
+// throw them from the error path they already had — an axios response
+// interceptor for the generated client (transport.ts) and the six capabilities'
+// Fault (answer.ts) — through `limited`, the one place a body becomes one.
+import { list, obj } from './read';
+/** A string the server sent, or undefined where it sent none — never "". */
+const text = (v) => (typeof v === 'string' && v !== '' ? v : undefined);
+/** An RFC 3339 instant, or undefined where none was sent or it does not parse. */
+const instant = (v) => {
+    const s = text(v);
+    if (!s)
+        return undefined;
+    const d = new Date(s);
+    return Number.isNaN(d.getTime()) ? undefined : d;
+};
+/** A priced request refused because nothing the caller holds may pay for it. */
+export class UsageLimitError extends Error {
+    constructor(status, error, request, cause) {
+        const code = text(error['code']) ?? '';
+        super(text(error['message']) ?? `HTTP ${status} ${code}`);
+        // Literal, not `new.target.name`, which a minifier renames.
+        this.name = 'UsageLimitError';
+        this.status = status;
+        this.code = code;
+        this.type = text(error['type']);
+        this.usageClass = text(error['class']);
+        this.model = text(error['model']);
+        this.fallback = text(error['fallback']);
+        this.resetsAt = instant(error['resets_at']);
+        this.upgradeUrl = text(error['upgrade_url']);
+        // An entry with no kind is not an action, so it is not offered.
+        this.actions = list(error['actions']).flatMap((a) => {
+            const o = obj(a);
+            const kind = text(o['kind']);
+            if (!kind)
+                return [];
+            const out = { kind };
+            for (const k of ['label', 'url', 'plan', 'model']) {
+                const v = text(o[k]);
+                if (v !== undefined)
+                    out[k] = v;
+            }
+            return [out];
+        });
+        this.request = request;
+        this.cause = cause;
+    }
+}
+/** 402 `plan_allowance_used` — the plan's included usage of the class is used, and nothing else may pay. */
+export class PlanAllowanceUsedError extends UsageLimitError {
+    constructor() {
+        super(...arguments);
+        this.name = 'PlanAllowanceUsedError';
+    }
+}
+/** 402 `paid_plan_required` — the model needs a paid plan or prepaid balance. */
+export class PaidPlanRequiredError extends UsageLimitError {
+    constructor() {
+        super(...arguments);
+        this.name = 'PaidPlanRequiredError';
+    }
+}
+/** 429 `free_plan_cap` — the free plan's daily cap on the model is used; it lifts at `resetsAt`. */
+export class FreePlanCapError extends UsageLimitError {
+    constructor() {
+        super(...arguments);
+        this.name = 'FreePlanCapError';
+    }
+}
+/** 402 `model_cap` — the model has used its share of the plan; `fallback` answers instead. */
+export class ModelCapError extends UsageLimitError {
+    constructor() {
+        super(...arguments);
+        this.name = 'ModelCapError';
+    }
+}
+/** 429 `usage_cap_exceeded` — a session or day request window is spent. */
+export class UsageCapExceededError extends UsageLimitError {
+    constructor() {
+        super(...arguments);
+        this.name = 'UsageCapExceededError';
+    }
+}
+/** 402 `insufficient_balance` — the known wallet balance cannot cover the request. */
+export class InsufficientBalanceError extends UsageLimitError {
+    constructor() {
+        super(...arguments);
+        this.name = 'InsufficientBalanceError';
+    }
+}
+// A Map, not an object literal: a code of "constructor" must find nothing.
+const classes = new Map([
+    ['plan_allowance_used', PlanAllowanceUsedError],
+    ['paid_plan_required', PaidPlanRequiredError],
+    ['free_plan_cap', FreePlanCapError],
+    ['model_cap', ModelCapError],
+    ['usage_cap_exceeded', UsageCapExceededError],
+    ['insufficient_balance', InsufficientBalanceError],
+]);
+/**
+ * The typed error a refusal names, or undefined: only a 402 or 429 whose
+ * `error.code` is one of the six is one. Anything else stays whatever error its
+ * transport already raises.
+ */
+export function limited(status, body, request, cause) {
+    if (status !== 402 && status !== 429)
+        return undefined;
+    const error = obj(obj(body)['error']);
+    const Class = classes.get(text(error['code']) ?? '');
+    return Class ? new Class(status, error, request, cause) : undefined;
+}
+/**
+ * Read the usage headers off one answer: `readUsage(res.headers)` for an axios
+ * response or a fetch Response alike. Names match case-insensitively. A header
+ * that is absent, or present and empty, reads undefined — never 0 or "", which
+ * would claim the server said something it did not.
+ */
+export function readUsage(headers) {
+    return {
+        usage: header(headers, 'x-hanzo-usage'),
+        usageClass: header(headers, 'x-hanzo-usage-class'),
+        paidBy: header(headers, 'x-hanzo-paid-by'),
+        fallback: header(headers, 'x-hanzo-fallback'),
+        served: header(headers, 'x-hanzo-served'),
+        reason: header(headers, 'x-hanzo-usage-reason'),
+    };
+}
+/** One header by lower-case name, matched case-insensitively; undefined where absent or empty. */
+export function header(headers, name) {
+    const h = headers ?? {};
+    let v;
+    if (typeof h.get === 'function') {
+        v = h.get(name);
+    }
+    else {
+        for (const [k, value] of Object.entries(h))
+            if (k.toLowerCase() === name)
+                v = value;
+    }
+    if (Array.isArray(v))
+        v = v[0];
+    if (typeof v === 'number' || typeof v === 'boolean')
+        v = String(v);
+    return typeof v === 'string' ? text(v.trim()) : undefined;
+}

package/dist/hanzo.d.ts

@@ -1,6 +1,9 @@
 export * from './index';
+export { Configuration } from './transport';
 export { Client } from './client';
 export type { Options } from './client';
+export { readUsage, UsageLimitError, PlanAllowanceUsedError, PaidPlanRequiredError, FreePlanCapError, ModelCapError, UsageCapExceededError, InsufficientBalanceError, } from './usage';
+export type { Usage, UsageAction, HeaderSource } from './usage';
 export * as answer from './answer';
 export * as budget from './budget';
 export * as policy from './policy';

package/dist/hanzo.js

@@ -58,10 +58,25 @@ var __importStar = (this && this.__importStar) || (function () {
     };
 })();
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.graph = exports.kb = exports.search = exports.audit = exports.policy = exports.budget = exports.answer = exports.Client = void 0;
+exports.graph = exports.kb = exports.search = exports.audit = exports.policy = exports.budget = exports.answer = exports.InsufficientBalanceError = exports.UsageCapExceededError = exports.ModelCapError = exports.FreePlanCapError = exports.PaidPlanRequiredError = exports.PlanAllowanceUsedError = exports.UsageLimitError = exports.readUsage = exports.Client = exports.Configuration = void 0;
 __exportStar(require("./index"), exports);
+// The generated Configuration, plus typed usage refusals on every *Api call
+// made with it. Named here, it shadows the one `./index` exports.
+var transport_1 = require("./transport");
+Object.defineProperty(exports, "Configuration", { enumerable: true, get: function () { return transport_1.Configuration; } });
 var client_1 = require("./client");
 Object.defineProperty(exports, "Client", { enumerable: true, get: function () { return client_1.Client; } });
+// What a priced answer's headers say, and the six refusals a caller can act on —
+// the same names as the Python and Go SDKs.
+var usage_1 = require("./usage");
+Object.defineProperty(exports, "readUsage", { enumerable: true, get: function () { return usage_1.readUsage; } });
+Object.defineProperty(exports, "UsageLimitError", { enumerable: true, get: function () { return usage_1.UsageLimitError; } });
+Object.defineProperty(exports, "PlanAllowanceUsedError", { enumerable: true, get: function () { return usage_1.PlanAllowanceUsedError; } });
+Object.defineProperty(exports, "PaidPlanRequiredError", { enumerable: true, get: function () { return usage_1.PaidPlanRequiredError; } });
+Object.defineProperty(exports, "FreePlanCapError", { enumerable: true, get: function () { return usage_1.FreePlanCapError; } });
+Object.defineProperty(exports, "ModelCapError", { enumerable: true, get: function () { return usage_1.ModelCapError; } });
+Object.defineProperty(exports, "UsageCapExceededError", { enumerable: true, get: function () { return usage_1.UsageCapExceededError; } });
+Object.defineProperty(exports, "InsufficientBalanceError", { enumerable: true, get: function () { return usage_1.InsufficientBalanceError; } });
 exports.answer = __importStar(require("./answer"));
 exports.budget = __importStar(require("./budget"));
 exports.policy = __importStar(require("./policy"));

package/dist/models/agent-target-view.d.ts

@@ -71,6 +71,12 @@ export interface AgentTargetView {
      * @memberof AgentTargetView
      */
     'running'?: number;
+    /**
+     * Serving says whether a run the caller sends here now would be taken: the machine is the caller\'s (or the caller is an org admin), and it is online with a runner that polled for work within the last 90 seconds — the online and runner half is what dispatch checks (TargetDispatchable). A heartbeat alone keeps a machine online, not serving, and a colleague\'s machine never serves the caller.
+     * @type {boolean}
+     * @memberof AgentTargetView
+     */
+    'serving'?: boolean;
     /**
      * Sessions is how many of the org\'s sessions are mapped to this machine, by target id OR by matching Host. All of them, whatever their status.
      * @type {number}

package/dist/models/ai-chat-in.d.ts

@@ -0,0 +1,42 @@
+/**
+ * Hanzo Cloud API
+ * The Hanzo Cloud API as a customer calls it: every operation under /v1/ except the operator\'s admin product, relay routes, legacy spellings and capabilities still reached by flag. Tagged by product: the first path segment after /v1/.
+ *
+ * The version of the OpenAPI document: v1
+ *
+ *
+ * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).
+ * https://openapi-generator.tech
+ * Do not edit the class manually.
+ */
+/**
+ *
+ * @export
+ * @interface AiChatIn
+ */
+export interface AiChatIn {
+    /**
+     * MaxTokens bounds the answer in tokens; 0 leaves it to the model.
+     * @type {number}
+     * @memberof AiChatIn
+     */
+    'max_tokens'?: number;
+    /**
+     * Model is the model to answer, by id (zen5, enso, kai, anthropic/claude-sonnet-4.5 — aiModels lists them). Empty asks the deployment\'s default Hanzo model.
+     * @type {string}
+     * @memberof AiChatIn
+     */
+    'model'?: string;
+    /**
+     * Prompt is what to ask.
+     * @type {string}
+     * @memberof AiChatIn
+     */
+    'prompt'?: string;
+    /**
+     * System is the system message ahead of the prompt, when set.
+     * @type {string}
+     * @memberof AiChatIn
+     */
+    'system'?: string;
+}