twelveai 0.3.0 → 0.4.0

package/dist/client-C5vzks2N.d.ts

@@ -0,0 +1,325 @@
+/** Shared request/response types for the TwelveAI chat API. */
+interface TwelveAIOptions {
+    /** Your workspace API key (sk_live_... / sk_test_...). */
+    apiKey: string;
+    /** Engine base URL. Defaults to the hosted platform. */
+    baseUrl?: string;
+    /**
+     * Auth your server adds when the SDK performs client-fetch hand-offs against
+     * YOUR OWN API (the engine hands the resolved request back without any
+     * credentials). Static headers, or a function returning them per request.
+     */
+    clientAuth?: Record<string, string> | (() => Record<string, string> | Promise<Record<string, string>>);
+    /** Custom fetch implementation (tests, polyfills). Defaults to global fetch. */
+    fetch?: typeof globalThis.fetch;
+    /** Max auto-resume rounds for client-fetch hand-offs per chat() call. Default 3. */
+    maxHandoffRounds?: number;
+}
+interface Attachment {
+    /** Public URL, or a data: URL. */
+    url?: string;
+    /** Base64 content (alternative to url). */
+    data?: string;
+    mediaType?: string;
+    /** A WhatsApp media id, if the engine should fetch it via your connected WhatsApp. */
+    whatsappMediaId?: string;
+}
+interface ChatInput {
+    /** The end user's message. Optional when resuming or sending only attachments. */
+    message?: string;
+    /** Your id for this end user (alias: userId). Required for customer-scoped agents. */
+    customerId?: string;
+    /** Continue an existing conversation with the token from the previous turn. */
+    continuation?: string;
+    /** The user approved a pending action (PIN/OTP collected on your side). */
+    confirmed?: boolean;
+    /** Sandbox: tools return sample data; nothing real is called or moved. */
+    sandbox?: boolean;
+    channel?: string;
+    /** Force a specific agent instead of routing. */
+    intent?: string;
+    /** Customer tier to sync for this turn's caps. */
+    tier?: string;
+    /** Routing reasoning: 'off' | 'auto' (default) | 'always'. */
+    reasoning?: 'off' | 'auto' | 'always';
+    /**
+     * Short-lived end-user session token, forwarded verbatim on tool bindings
+     * with auth type 'customer_token'. Never stored by the engine.
+     */
+    customerToken?: string;
+    /** Images / voice notes attached to this turn. */
+    attachments?: Attachment[];
+    metadata?: Record<string, unknown>;
+}
+interface ToolCall {
+    name: string;
+    arguments: Record<string, unknown>;
+    result: unknown;
+}
+interface HandoffRequest {
+    method: string;
+    url: string;
+    headers?: Record<string, string>;
+    body?: Record<string, unknown>;
+}
+interface PendingToolCall {
+    id: string;
+    name: string;
+    arguments: Record<string, unknown>;
+    /** Client-fetch hand-off: the resolved request your server should perform. */
+    request?: HandoffRequest;
+}
+interface ToolResult {
+    id: string;
+    result: unknown;
+}
+interface ChatResponse {
+    ok: boolean;
+    sandbox?: boolean;
+    /** The assistant's reply to show the user. */
+    message: string | null;
+    intent: string | null;
+    toolCalls: ToolCall[];
+    /** A write awaiting the user's confirmation (resend with confirmed: true). */
+    pendingConfirmation: {
+        tool: string;
+        arguments: Record<string, unknown>;
+    } | null;
+    /**
+     * Client-executed tool calls YOUR system must run. With auto-execution on
+     * (the default), read hand-offs are already completed by the SDK; anything
+     * left here is yours to handle (typically a money move awaiting PIN).
+     */
+    pendingToolCalls: PendingToolCall[] | null;
+    /** Pass this back on the next turn to continue the conversation. */
+    continuation: string | null;
+    escalated?: boolean;
+    policy?: string | null;
+    autonomy?: string | null;
+    fee?: {
+        feeNgn: number;
+        amountNgn: number;
+        totalNgn: number;
+    } | null;
+    usage?: {
+        inputTokens: number;
+        outputTokens: number;
+    };
+    billing?: Record<string, unknown>;
+    latencyMs?: number;
+    metadata?: Record<string, unknown>;
+    error?: string;
+    /** HTTP status of the underlying call. */
+    status: number;
+    /** Hand-offs the SDK auto-executed to complete this turn (for observability). */
+    executedHandoffs?: Array<{
+        name: string;
+        method: string;
+        url: string;
+        ok: boolean;
+    }>;
+}
+/**
+ * Executor for one client-fetch hand-off. Return the tool result the engine
+ * resumes with. The default executor performs `call.request` with your
+ * `clientAuth` headers and returns `{ ok, data }`.
+ */
+type HandoffExecutor = (call: PendingToolCall) => Promise<unknown>;
+interface ClassifyResponse {
+    ok: boolean;
+    /** The winning agent intent, or null when nothing matched. */
+    intent: string | null;
+    label: string | null;
+    /** Deterministic confidence in [0, 0.95]; 0 = no match. */
+    confidence: number;
+    alternatives: Array<{
+        intent: string;
+        label: string;
+        confidence?: number;
+        matchedKeywords?: string[];
+    }>;
+    /** The exact keywords that selected the winning intent (explainability). */
+    matchedKeywords?: string[];
+    /** Raw keyword-hit count for the winner, and its lead over the runner-up. */
+    score?: number;
+    margin?: number;
+    /** True when the winning intent is classifier-only (your systems handle it). */
+    classifyOnly?: boolean;
+    /** Extracted entities: amount, account_number, phone, bank {name, code}, currency. */
+    entities: Record<string, unknown>;
+    status: number;
+    error?: string;
+}
+
+/**
+ * Management API - everything the console can do, callable from code. Thin,
+ * typed-enough wrappers over the engine's management endpoints, all
+ * authenticated with the same x-api-key as chat. Every method resolves to
+ * `{ ok, status, ...payload }` and never throws on HTTP errors.
+ */
+interface ManageResult {
+    ok: boolean;
+    status: number;
+    error?: string;
+    [key: string]: unknown;
+}
+interface CreateAgentInput {
+    intent: string;
+    label?: string;
+    keywords: string[];
+    /** With instructions (and optionally tools) this creates a FULL chat agent; without, a classifier-only intent. */
+    systemPrompt?: string;
+    tools?: string[];
+    requiresCustomer?: boolean;
+}
+interface CreateToolInput {
+    name: string;
+    description: string;
+    sideEffect: 'read' | 'write';
+    method: 'GET' | 'POST' | 'PUT' | 'PATCH' | 'DELETE';
+    /** {placeholders} become the tool's arguments; {customer_id} is filled per turn. */
+    url: string;
+    execution?: 'hosted' | 'client';
+    /** A real example response - drives result parsing and the sandbox. */
+    sampleResponse?: unknown;
+}
+interface BindToolInput {
+    method: 'GET' | 'POST' | 'PUT' | 'PATCH' | 'DELETE';
+    url: string;
+    resultPath?: string | null;
+    sampleResponse?: unknown;
+    execution?: 'hosted' | 'client';
+    auth?: Record<string, unknown>;
+}
+type Request = (method: string, path: string, body?: Record<string, unknown>) => Promise<ManageResult>;
+/** Build the management namespaces over one authenticated request function. */
+declare function buildManage(request: Request): {
+    agents: {
+        list: () => Promise<ManageResult>;
+        create: (input: CreateAgentInput) => Promise<ManageResult>;
+        update: (intent: string, patch: Record<string, unknown>) => Promise<ManageResult>;
+        enable: (intent: string) => Promise<ManageResult>;
+        disable: (intent: string) => Promise<ManageResult>;
+        delete: (intent: string) => Promise<ManageResult>;
+    };
+    tools: {
+        list: () => Promise<ManageResult>;
+        create: (input: CreateToolInput) => Promise<ManageResult>;
+        bind: (name: string, binding: BindToolInput) => Promise<ManageResult>;
+        test: (name: string) => Promise<ManageResult>;
+        importOpenApi: (input: {
+            url?: string;
+            spec?: unknown;
+            execution?: "hosted" | "client";
+            dryRun?: boolean;
+            auth?: Record<string, unknown>;
+        }) => Promise<ManageResult>;
+    };
+    plugins: {
+        list: () => Promise<ManageResult>;
+        install: (id: string) => Promise<ManageResult>;
+        uninstall: (id: string) => Promise<ManageResult>;
+    };
+    customers: {
+        list: (opts?: {
+            limit?: number;
+            range?: string;
+        }) => Promise<ManageResult>;
+        upsert: (input: {
+            externalId: string;
+            tier?: string | null;
+            name?: string;
+            email?: string;
+            status?: string;
+        }) => Promise<ManageResult>;
+        get: (externalId: string) => Promise<ManageResult>;
+    };
+    settings: {
+        get: () => Promise<ManageResult>;
+        update: (patch: Record<string, unknown>) => Promise<ManageResult>;
+    };
+    billing: {
+        get: () => Promise<ManageResult>;
+        topup: (amountNgn: number, email?: string) => Promise<ManageResult>;
+    };
+    usage: {
+        summary: () => Promise<ManageResult>;
+        events: (limit?: number) => Promise<ManageResult>;
+        event: (id: number | string) => Promise<ManageResult>;
+        analytics: (days?: number) => Promise<ManageResult>;
+    };
+    manifest: () => Promise<ManageResult>;
+};
+type Manage = ReturnType<typeof buildManage>;
+
+/**
+ * The TwelveAI client. One call does the whole conversation protocol:
+ *
+ *   const twelve = new TwelveAI({ apiKey: process.env.TWELVE_API_KEY! })
+ *   const res = await twelve.chat({ message: "what's my balance?", customerId: 'cus_123' })
+ *   console.log(res.message)
+ *
+ * Client-fetch hand-offs (tools configured as "my app calls it") are executed
+ * automatically against your own API - the engine never holds your credentials;
+ * you supply them once via `clientAuth` and the SDK completes the loop. Money
+ * moves are never auto-executed: they surface in `pendingToolCalls` /
+ * `pendingConfirmation` for your PIN flow, then you call `confirm()` or
+ * `resume()`.
+ */
+declare class TwelveAI {
+    private readonly apiKey;
+    private readonly baseUrl;
+    private readonly fetchImpl;
+    private readonly clientAuth;
+    private readonly maxHandoffRounds;
+    /**
+     * Everything the console can do, from code: agents, tools, plugins,
+     * customers, settings, billing, usage. `twelve.manage.plugins.install('bills')`.
+     */
+    readonly manage: Manage;
+    constructor(options: TwelveAIOptions);
+    /**
+     * Low-level authenticated call to any engine endpoint. Returns
+     * `{ ok, status, ...payload }`; never throws on HTTP errors.
+     */
+    api(method: string, path: string, body?: Record<string, unknown>): Promise<ManageResult>;
+    /**
+     * Send one chat turn and return the completed result. Read hand-offs are
+     * auto-executed (see class docs); pass `autoExecute: false` to get the raw
+     * paused response instead, or `onHandoff` to execute them yourself.
+     */
+    chat(input: ChatInput, opts?: {
+        autoExecute?: boolean;
+        onHandoff?: HandoffExecutor;
+    }): Promise<ChatResponse>;
+    /** Resume a paused turn with tool results your system produced. */
+    resume(continuation: string, toolResults: ToolResult[], input?: Pick<ChatInput, 'customerId' | 'channel' | 'sandbox' | 'customerToken'>): Promise<ChatResponse>;
+    /**
+     * Approve a pending action (after your PIN/OTP step) - resends the turn with
+     * `confirmed: true` so the engine proceeds.
+     */
+    confirm(continuation: string, input?: Omit<ChatInput, 'continuation' | 'confirmed'>): Promise<ChatResponse>;
+    /**
+     * Level-0 integration: classify a message WITHOUT running the conversation.
+     * Returns the intent, a deterministic confidence score, and cheap extracted
+     * entities (amount / account number / phone) - you keep your existing flows
+     * and make the call yourself. Free: no tools run, nothing is stored.
+     */
+    classify(input: {
+        message: string;
+        reasoning?: 'off' | 'auto' | 'always';
+    }): Promise<ClassifyResponse>;
+    private chatBody;
+    private post;
+    /**
+     * Execute client-fetch hand-offs and resume until the turn completes. Only
+     * calls that carry a resolved `request` are auto-executed - a hand-off
+     * without one (e.g. a money move awaiting your PIN flow) stops the loop and
+     * is returned to you untouched.
+     */
+    private completeHandoffs;
+    /** Default hand-off executor: perform the request with your clientAuth headers. */
+    private performHandoff;
+}
+
+export { type Attachment as A, type BindToolInput as B, type ChatInput as C, type HandoffExecutor as H, type Manage as M, type PendingToolCall as P, TwelveAI as T, type ChatResponse as a, type ClassifyResponse as b, type CreateAgentInput as c, type CreateToolInput as d, type HandoffRequest as e, type ManageResult as f, type ToolCall as g, type ToolResult as h, type TwelveAIOptions as i, buildManage as j };

package/dist/index.cjs

@@ -21,12 +21,59 @@ var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: tru
 var index_exports = {};
 __export(index_exports, {
   TwelveAI: () => TwelveAI,
+  buildManage: () => buildManage,
   createJwksVerifier: () => createJwksVerifier,
   verifySignedRequest: () => verifySignedRequest,
   verifyWebhook: () => verifyWebhook
 });
 module.exports = __toCommonJS(index_exports);
 
+// src/manage.ts
+function buildManage(request) {
+  return {
+    agents: {
+      list: () => request("GET", "/v1/agents"),
+      create: (input) => request("POST", "/v1/agents", { ...input }),
+      update: (intent, patch) => request("PUT", "/v1/agents", { intent, ...patch }),
+      enable: (intent) => request("PUT", "/v1/agents", { intent, enabled: true }),
+      disable: (intent) => request("PUT", "/v1/agents", { intent, enabled: false }),
+      delete: (intent) => request("DELETE", `/v1/agents/${encodeURIComponent(intent)}`)
+    },
+    tools: {
+      list: () => request("GET", "/v1/tools"),
+      create: (input) => request("POST", "/v1/tools", { ...input }),
+      bind: (name, binding) => request("PUT", `/v1/tools/${encodeURIComponent(name)}`, { ...binding }),
+      test: (name) => request("POST", `/v1/tools/${encodeURIComponent(name)}/test`),
+      importOpenApi: (input) => request("POST", "/v1/tools/import", { ...input })
+    },
+    plugins: {
+      list: () => request("GET", "/v1/plugins"),
+      install: (id) => request("POST", `/v1/plugins/${encodeURIComponent(id)}/install`),
+      uninstall: (id) => request("POST", `/v1/plugins/${encodeURIComponent(id)}/uninstall`)
+    },
+    customers: {
+      list: (opts = {}) => request("GET", `/v1/customers?limit=${opts.limit ?? 100}${opts.range ? `&range=${opts.range}` : ""}`),
+      upsert: (input) => request("POST", "/v1/customers", { ...input }),
+      get: (externalId) => request("GET", `/v1/customers/${encodeURIComponent(externalId)}`)
+    },
+    settings: {
+      get: () => request("GET", "/v1/settings"),
+      update: (patch) => request("PUT", "/v1/settings", patch)
+    },
+    billing: {
+      get: () => request("GET", "/v1/billing"),
+      topup: (amountNgn, email) => request("POST", "/v1/billing/topup", { amount: amountNgn, ...email ? { email } : {} })
+    },
+    usage: {
+      summary: () => request("GET", "/v1/usage"),
+      events: (limit = 20) => request("GET", `/v1/usage/events?limit=${limit}`),
+      event: (id) => request("GET", `/v1/usage/events/${id}`),
+      analytics: (days = 30) => request("GET", `/v1/usage/analytics?days=${days}`)
+    },
+    manifest: () => request("GET", "/v1/manifest")
+  };
+}
+
 // src/client.ts
 var DEFAULT_BASE_URL = "https://ai.twelveai.app";
 var TwelveAI = class {
@@ -35,6 +82,11 @@ var TwelveAI = class {
   fetchImpl;
   clientAuth;
   maxHandoffRounds;
+  /**
+   * Everything the console can do, from code: agents, tools, plugins,
+   * customers, settings, billing, usage. `twelve.manage.plugins.install('bills')`.
+   */
+  manage;
   constructor(options) {
     if (!options?.apiKey) throw new Error("TwelveAI: apiKey is required.");
     this.apiKey = options.apiKey;
@@ -45,6 +97,29 @@ var TwelveAI = class {
     if (typeof this.fetchImpl !== "function") {
       throw new Error("TwelveAI: global fetch is unavailable - pass options.fetch (Node 18+ has fetch built in).");
     }
+    this.manage = buildManage((method, path, body) => this.api(method, path, body));
+  }
+  /**
+   * Low-level authenticated call to any engine endpoint. Returns
+   * `{ ok, status, ...payload }`; never throws on HTTP errors.
+   */
+  async api(method, path, body) {
+    try {
+      const res = await this.fetchImpl(`${this.baseUrl}${path}`, {
+        method,
+        headers: { "content-type": "application/json", "x-api-key": this.apiKey },
+        ...body !== void 0 ? { body: JSON.stringify(body) } : {}
+      });
+      const data = await res.json().catch(() => ({}));
+      return {
+        ...data,
+        ok: res.ok && data.ok !== false,
+        status: res.status,
+        ...res.ok ? {} : { error: data.error ?? `Engine returned ${res.status}` }
+      };
+    } catch (error) {
+      return { ok: false, status: 0, error: error?.message || "Could not reach the engine." };
+    }
   }
   /**
    * Send one chat turn and return the completed result. Read hand-offs are
@@ -78,16 +153,18 @@ var TwelveAI = class {
       const res = await this.fetchImpl(`${this.baseUrl}/v1/classify`, {
         method: "POST",
         headers: { "content-type": "application/json", "x-api-key": this.apiKey },
-        body: JSON.stringify({ message: input.message })
+        body: JSON.stringify({ message: input.message, ...input.reasoning ? { reasoning: input.reasoning } : {} })
       });
       const data = await res.json().catch(() => ({}));
       return {
+        intent: null,
+        label: null,
+        confidence: 0,
+        alternatives: [],
+        entities: {},
+        ...data,
+        // pass every field through (matchedKeywords, score, margin, classifyOnly, ...)
         ok: res.ok && data.ok !== false,
-        intent: data.intent ?? null,
-        label: data.label ?? null,
-        confidence: data.confidence ?? 0,
-        alternatives: data.alternatives ?? [],
-        entities: data.entities ?? {},
         status: res.status,
         ...res.ok ? {} : { error: data.error ?? `Engine returned ${res.status}` }
       };
@@ -106,6 +183,7 @@ var TwelveAI = class {
     if (input.channel) body.channel = input.channel;
     if (input.intent) body.intent = input.intent;
     if (input.tier) body.tier = input.tier;
+    if (input.reasoning) body.reasoning = input.reasoning;
     if (input.customerToken) body.customerToken = input.customerToken;
     if (input.attachments?.length) body.attachments = input.attachments;
     if (input.metadata) body.metadata = input.metadata;
@@ -268,6 +346,7 @@ function header(headers, name) {
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   TwelveAI,
+  buildManage,
   createJwksVerifier,
   verifySignedRequest,
   verifyWebhook

package/dist/index.d.cts

@@ -1,203 +1,4 @@
-/** Shared request/response types for the TwelveAI chat API. */
-interface TwelveAIOptions {
-    /** Your workspace API key (sk_live_... / sk_test_...). */
-    apiKey: string;
-    /** Engine base URL. Defaults to the hosted platform. */
-    baseUrl?: string;
-    /**
-     * Auth your server adds when the SDK performs client-fetch hand-offs against
-     * YOUR OWN API (the engine hands the resolved request back without any
-     * credentials). Static headers, or a function returning them per request.
-     */
-    clientAuth?: Record<string, string> | (() => Record<string, string> | Promise<Record<string, string>>);
-    /** Custom fetch implementation (tests, polyfills). Defaults to global fetch. */
-    fetch?: typeof globalThis.fetch;
-    /** Max auto-resume rounds for client-fetch hand-offs per chat() call. Default 3. */
-    maxHandoffRounds?: number;
-}
-interface Attachment {
-    /** Public URL, or a data: URL. */
-    url?: string;
-    /** Base64 content (alternative to url). */
-    data?: string;
-    mediaType?: string;
-    /** A WhatsApp media id, if the engine should fetch it via your connected WhatsApp. */
-    whatsappMediaId?: string;
-}
-interface ChatInput {
-    /** The end user's message. Optional when resuming or sending only attachments. */
-    message?: string;
-    /** Your id for this end user (alias: userId). Required for customer-scoped agents. */
-    customerId?: string;
-    /** Continue an existing conversation with the token from the previous turn. */
-    continuation?: string;
-    /** The user approved a pending action (PIN/OTP collected on your side). */
-    confirmed?: boolean;
-    /** Sandbox: tools return sample data; nothing real is called or moved. */
-    sandbox?: boolean;
-    channel?: string;
-    /** Force a specific agent instead of routing. */
-    intent?: string;
-    /** Customer tier to sync for this turn's caps. */
-    tier?: string;
-    /**
-     * Short-lived end-user session token, forwarded verbatim on tool bindings
-     * with auth type 'customer_token'. Never stored by the engine.
-     */
-    customerToken?: string;
-    /** Images / voice notes attached to this turn. */
-    attachments?: Attachment[];
-    metadata?: Record<string, unknown>;
-}
-interface ToolCall {
-    name: string;
-    arguments: Record<string, unknown>;
-    result: unknown;
-}
-interface HandoffRequest {
-    method: string;
-    url: string;
-    headers?: Record<string, string>;
-    body?: Record<string, unknown>;
-}
-interface PendingToolCall {
-    id: string;
-    name: string;
-    arguments: Record<string, unknown>;
-    /** Client-fetch hand-off: the resolved request your server should perform. */
-    request?: HandoffRequest;
-}
-interface ToolResult {
-    id: string;
-    result: unknown;
-}
-interface ChatResponse {
-    ok: boolean;
-    sandbox?: boolean;
-    /** The assistant's reply to show the user. */
-    message: string | null;
-    intent: string | null;
-    toolCalls: ToolCall[];
-    /** A write awaiting the user's confirmation (resend with confirmed: true). */
-    pendingConfirmation: {
-        tool: string;
-        arguments: Record<string, unknown>;
-    } | null;
-    /**
-     * Client-executed tool calls YOUR system must run. With auto-execution on
-     * (the default), read hand-offs are already completed by the SDK; anything
-     * left here is yours to handle (typically a money move awaiting PIN).
-     */
-    pendingToolCalls: PendingToolCall[] | null;
-    /** Pass this back on the next turn to continue the conversation. */
-    continuation: string | null;
-    escalated?: boolean;
-    policy?: string | null;
-    autonomy?: string | null;
-    fee?: {
-        feeNgn: number;
-        amountNgn: number;
-        totalNgn: number;
-    } | null;
-    usage?: {
-        inputTokens: number;
-        outputTokens: number;
-    };
-    billing?: Record<string, unknown>;
-    latencyMs?: number;
-    metadata?: Record<string, unknown>;
-    error?: string;
-    /** HTTP status of the underlying call. */
-    status: number;
-    /** Hand-offs the SDK auto-executed to complete this turn (for observability). */
-    executedHandoffs?: Array<{
-        name: string;
-        method: string;
-        url: string;
-        ok: boolean;
-    }>;
-}
-/**
- * Executor for one client-fetch hand-off. Return the tool result the engine
- * resumes with. The default executor performs `call.request` with your
- * `clientAuth` headers and returns `{ ok, data }`.
- */
-type HandoffExecutor = (call: PendingToolCall) => Promise<unknown>;
-interface ClassifyResponse {
-    ok: boolean;
-    /** The winning agent intent, or null when nothing matched. */
-    intent: string | null;
-    label: string | null;
-    /** Deterministic confidence in [0, 0.95]; 0 = no match. */
-    confidence: number;
-    alternatives: Array<{
-        intent: string;
-        label: string;
-    }>;
-    /** Cheap extracted entities: amount, account_number, phone (when present). */
-    entities: Record<string, unknown>;
-    status: number;
-    error?: string;
-}
-
-/**
- * The TwelveAI client. One call does the whole conversation protocol:
- *
- *   const twelve = new TwelveAI({ apiKey: process.env.TWELVE_API_KEY! })
- *   const res = await twelve.chat({ message: "what's my balance?", customerId: 'cus_123' })
- *   console.log(res.message)
- *
- * Client-fetch hand-offs (tools configured as "my app calls it") are executed
- * automatically against your own API - the engine never holds your credentials;
- * you supply them once via `clientAuth` and the SDK completes the loop. Money
- * moves are never auto-executed: they surface in `pendingToolCalls` /
- * `pendingConfirmation` for your PIN flow, then you call `confirm()` or
- * `resume()`.
- */
-declare class TwelveAI {
-    private readonly apiKey;
-    private readonly baseUrl;
-    private readonly fetchImpl;
-    private readonly clientAuth;
-    private readonly maxHandoffRounds;
-    constructor(options: TwelveAIOptions);
-    /**
-     * Send one chat turn and return the completed result. Read hand-offs are
-     * auto-executed (see class docs); pass `autoExecute: false` to get the raw
-     * paused response instead, or `onHandoff` to execute them yourself.
-     */
-    chat(input: ChatInput, opts?: {
-        autoExecute?: boolean;
-        onHandoff?: HandoffExecutor;
-    }): Promise<ChatResponse>;
-    /** Resume a paused turn with tool results your system produced. */
-    resume(continuation: string, toolResults: ToolResult[], input?: Pick<ChatInput, 'customerId' | 'channel' | 'sandbox' | 'customerToken'>): Promise<ChatResponse>;
-    /**
-     * Approve a pending action (after your PIN/OTP step) - resends the turn with
-     * `confirmed: true` so the engine proceeds.
-     */
-    confirm(continuation: string, input?: Omit<ChatInput, 'continuation' | 'confirmed'>): Promise<ChatResponse>;
-    /**
-     * Level-0 integration: classify a message WITHOUT running the conversation.
-     * Returns the intent, a deterministic confidence score, and cheap extracted
-     * entities (amount / account number / phone) - you keep your existing flows
-     * and make the call yourself. Free: no tools run, nothing is stored.
-     */
-    classify(input: {
-        message: string;
-    }): Promise<ClassifyResponse>;
-    private chatBody;
-    private post;
-    /**
-     * Execute client-fetch hand-offs and resume until the turn completes. Only
-     * calls that carry a resolved `request` are auto-executed - a hand-off
-     * without one (e.g. a money move awaiting your PIN flow) stops the loop and
-     * is returned to you untouched.
-     */
-    private completeHandoffs;
-    /** Default hand-off executor: perform the request with your clientAuth headers. */
-    private performHandoff;
-}
+export { A as Attachment, B as BindToolInput, C as ChatInput, a as ChatResponse, b as ClassifyResponse, c as CreateAgentInput, d as CreateToolInput, H as HandoffExecutor, e as HandoffRequest, M as Manage, f as ManageResult, P as PendingToolCall, g as ToolCall, h as ToolResult, T as TwelveAI, i as TwelveAIOptions, j as buildManage } from './client-C5vzks2N.cjs';
 
 /** Verify a TwelveAI webhook delivery: the x-webhook-secret header must match your secret. */
 declare function verifyWebhook(secret: string, headers: Record<string, string | string[] | undefined>): boolean;
@@ -252,4 +53,4 @@ declare function createJwksVerifier(options?: JwksVerifierOptions): (input: JwtR
     claims?: Record<string, unknown>;
 }>;
 
-export { type Attachment, type ChatInput, type ChatResponse, type ClassifyResponse, type HandoffExecutor, type HandoffRequest, type JwksVerifierOptions, type JwtRequestInput, type PendingToolCall, type SignedRequestInput, type ToolCall, type ToolResult, TwelveAI, type TwelveAIOptions, createJwksVerifier, verifySignedRequest, verifyWebhook };
+export { type JwksVerifierOptions, type JwtRequestInput, type SignedRequestInput, createJwksVerifier, verifySignedRequest, verifyWebhook };