twelveai 0.3.1 → 0.6.0

package/dist/cli.js

@@ -0,0 +1,204 @@
+#!/usr/bin/env node
+import {
+  TwelveAI
+} from "./chunk-7VVR7AFE.js";
+
+// src/cli.ts
+import { readFileSync } from "fs";
+var HELP = `twelveai <command> [args]
+
+Conversation
+  chat "<message>" [--customer <id>] [--sandbox] [--reasoning off|auto|always]
+  classify "<message>" [--reasoning off|auto|always]
+
+Manage (everything the console does)
+  agents    list | create --file <agent.json> | enable <intent> | disable <intent> | delete <intent>
+  tools     list | create --file <tool.json> | bind <name> --file <binding.json> | test <name>
+  plugins   list | install <id> | uninstall <id>
+  customers list | set <externalId> [--tier <tier>] [--name <name>] [--email <email>]
+  settings  get | set --file <settings.json>
+  billing   (show balance) | topup <amountNgn>
+  usage     (summary) | requests [--limit <n>] | request <id>
+  manifest  (the per-agent tool-call contract)
+
+Auth: set TWELVE_API_KEY (and optionally TWELVE_BASE_URL).`;
+function flag(args, name) {
+  const i = args.indexOf(`--${name}`);
+  return i >= 0 ? args[i + 1] : void 0;
+}
+var has = (args, name) => args.includes(`--${name}`);
+var positional = (args) => args.filter((a, i) => !a.startsWith("--") && !(i > 0 && args[i - 1].startsWith("--")));
+async function runCli(argv, deps) {
+  const [cmd, ...rest] = argv;
+  if (!cmd || cmd === "help" || cmd === "--help" || cmd === "-h") {
+    deps.log(HELP);
+    return 0;
+  }
+  const apiKey = deps.env.TWELVE_API_KEY;
+  if (!apiKey) {
+    deps.error("Set TWELVE_API_KEY to use the CLI (find yours in the console under Settings).");
+    return 1;
+  }
+  const twelve = deps.client ?? new TwelveAI({ apiKey, baseUrl: deps.env.TWELVE_BASE_URL });
+  const m = twelve.manage;
+  const json = (v) => deps.log(JSON.stringify(v, null, 2));
+  const loadJson = (label) => {
+    const file = flag(rest, "file");
+    if (!file) {
+      deps.error(`--file <${label}.json> is required.`);
+      return null;
+    }
+    try {
+      return JSON.parse(deps.readFile(file));
+    } catch (e) {
+      deps.error(`Could not read ${file}: ${e.message}`);
+      return null;
+    }
+  };
+  const done = (r) => r.ok ? 0 : 1;
+  const pos = positional(rest);
+  const sub = pos[0];
+  switch (cmd) {
+    case "chat": {
+      if (!sub) return deps.error('Usage: twelveai chat "<message>"'), 1;
+      const r = await twelve.chat({
+        message: sub,
+        customerId: flag(rest, "customer"),
+        sandbox: has(rest, "sandbox") || void 0,
+        reasoning: flag(rest, "reasoning")
+      });
+      json(r);
+      return done(r);
+    }
+    case "classify": {
+      if (!sub) return deps.error('Usage: twelveai classify "<message>"'), 1;
+      const r = await twelve.classify({ message: sub, reasoning: flag(rest, "reasoning") });
+      json(r);
+      return done(r);
+    }
+    case "agents": {
+      if (sub === "list" || !sub) return json(await m.agents.list()), 0;
+      if (sub === "create") {
+        const b = loadJson("agent");
+        if (!b) return 1;
+        const r = await m.agents.create(b);
+        json(r);
+        return done(r);
+      }
+      if (sub === "enable" && pos[1]) {
+        const r = await m.agents.enable(pos[1]);
+        json(r);
+        return done(r);
+      }
+      if (sub === "disable" && pos[1]) {
+        const r = await m.agents.disable(pos[1]);
+        json(r);
+        return done(r);
+      }
+      if (sub === "delete" && pos[1]) {
+        const r = await m.agents.delete(pos[1]);
+        json(r);
+        return done(r);
+      }
+      deps.error("Usage: twelveai agents list | create --file a.json | enable <intent> | disable <intent> | delete <intent>");
+      return 1;
+    }
+    case "tools": {
+      if (sub === "list" || !sub) return json(await m.tools.list()), 0;
+      if (sub === "create") {
+        const b = loadJson("tool");
+        if (!b) return 1;
+        const r = await m.tools.create(b);
+        json(r);
+        return done(r);
+      }
+      if (sub === "bind" && pos[1]) {
+        const b = loadJson("binding");
+        if (!b) return 1;
+        const r = await m.tools.bind(pos[1], b);
+        json(r);
+        return done(r);
+      }
+      if (sub === "test" && pos[1]) {
+        const r = await m.tools.test(pos[1]);
+        json(r);
+        return done(r);
+      }
+      deps.error("Usage: twelveai tools list | create --file t.json | bind <name> --file b.json | test <name>");
+      return 1;
+    }
+    case "plugins": {
+      if (sub === "list" || !sub) return json(await m.plugins.list()), 0;
+      if (sub === "install" && pos[1]) {
+        const r = await m.plugins.install(pos[1]);
+        json(r);
+        return done(r);
+      }
+      if (sub === "uninstall" && pos[1]) {
+        const r = await m.plugins.uninstall(pos[1]);
+        json(r);
+        return done(r);
+      }
+      deps.error("Usage: twelveai plugins list | install <id> | uninstall <id>");
+      return 1;
+    }
+    case "customers": {
+      if (sub === "list" || !sub) return json(await m.customers.list({ limit: Number(flag(rest, "limit")) || 100 })), 0;
+      if (sub === "set" && pos[1]) {
+        const r = await m.customers.upsert({ externalId: pos[1], tier: flag(rest, "tier"), name: flag(rest, "name"), email: flag(rest, "email") });
+        json(r);
+        return done(r);
+      }
+      deps.error("Usage: twelveai customers list | set <externalId> --tier <tier>");
+      return 1;
+    }
+    case "settings": {
+      if (sub === "get" || !sub) return json(await m.settings.get()), 0;
+      if (sub === "set") {
+        const b = loadJson("settings");
+        if (!b) return 1;
+        const r = await m.settings.update(b);
+        json(r);
+        return done(r);
+      }
+      deps.error("Usage: twelveai settings get | set --file settings.json");
+      return 1;
+    }
+    case "billing":
+      return json(await m.billing.get()), 0;
+    case "topup": {
+      const amount = Number(sub);
+      if (!amount || amount < 5e3) return deps.error("Usage: twelveai topup <amountNgn>  (minimum 5000)"), 1;
+      const r = await m.billing.topup(amount, flag(rest, "email"));
+      json(r);
+      return done(r);
+    }
+    case "usage":
+      return json(await m.usage.summary()), 0;
+    case "requests":
+      return json(await m.usage.events(Number(flag(rest, "limit")) || 20)), 0;
+    case "request": {
+      if (!sub) return deps.error("Usage: twelveai request <id>"), 1;
+      return json(await m.usage.event(sub)), 0;
+    }
+    case "manifest":
+      return json(await m.manifest()), 0;
+    default:
+      deps.error(`Unknown command "${cmd}".
+
+${HELP}`);
+      return 1;
+  }
+}
+var isMain = process.argv[1]?.endsWith("cli.js") || process.argv[1]?.endsWith("twelveai");
+if (isMain) {
+  runCli(process.argv.slice(2), {
+    env: process.env,
+    log: (s) => console.log(s),
+    error: (s) => console.error(s),
+    readFile: (p) => readFileSync(p, "utf8")
+  }).then((code) => process.exit(code));
+}
+export {
+  runCli
+};

package/dist/client-DEsf0_MF.d.cts

@@ -0,0 +1,490 @@
+/** 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;
+    /**
+     * Pin the turn to one agent, skipping the router entirely - no keyword pass,
+     * no AI pass, no mid-conversation switch. Use it when YOU already know the
+     * intent (a deep link, a menu choice, an IVR branch, a batch job), not on a
+     * general chat box: the pinned agent answers whatever the customer says next,
+     * with its own tools. Every pinned response carries `warning` saying so.
+     */
+    agent?: string;
+    /** Alias of `agent`, kept for existing integrations. */
+    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;
+    /** Routing confidence for the intent, same scale as classify. Null on resumes and guide fallback. */
+    confidence?: number | null;
+    /**
+     * Non-fatal advice about how this turn was handled: set when you pinned an
+     * agent (the router was skipped), or when the pin named an agent that could
+     * not run. Never an error - the reply in `message` still stands.
+     */
+    warning?: 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;
+}
+/** A placeholder you may put in a tool's URL; the engine fills it per turn. */
+interface ToolVariable {
+    /** Use it as `{name}` in the URL, path or query. */
+    name: string;
+    type: string;
+    description: string | null;
+    required: boolean;
+}
+/** One tool as GET /v1/tools returns it. */
+interface ToolListItem {
+    name: string;
+    description: string;
+    sideEffect: 'read' | 'write';
+    permission: string | null;
+    kind: 'managed' | 'client' | 'http';
+    execution: 'hosted' | 'client';
+    binding: {
+        method: string;
+        url: string;
+        resultPath: string | null;
+    } | null;
+    hasAuth: boolean;
+    auth: {
+        type: string;
+        header: string | null;
+    } | null;
+    sampleResponse: unknown;
+    tenantSample?: boolean;
+    example: {
+        method: string;
+        url: string;
+    } | null;
+    /** Placeholders this tool understands - the click-to-insert list in the console. */
+    variables: ToolVariable[];
+    agents: string[];
+    editable: boolean;
+}
+interface ToolsResult extends ManageResult {
+    tools: ToolListItem[];
+}
+/** A published version of an agent pack, newest first. */
+interface PluginRelease {
+    version: string;
+    date: string;
+    breaking?: boolean;
+    changes: string[];
+}
+/** Domain vocabulary a pack's tools use, so you can map it to your own API. */
+interface PluginConcept {
+    term: string;
+    meaning: string;
+}
+interface PluginToolSpec {
+    name: string;
+    description: string | null;
+    sideEffect: 'read' | 'write' | null;
+    variables: ToolVariable[];
+}
+interface PluginListItem {
+    id: string;
+    name: string;
+    description: string;
+    category: string;
+    version: string;
+    intent: string;
+    tools: string[];
+    visibility: 'public' | 'private';
+    installed: boolean;
+    configured?: boolean;
+    managedByPlugin?: boolean;
+    installedVersion: string | null;
+    updateAvailable: boolean;
+    /** True when you run this agent outside the marketplace and could follow its releases. */
+    canTrack?: boolean;
+    details: {
+        about: string;
+        examples: string[];
+        dataSource: string;
+        concepts?: PluginConcept[];
+    } | null;
+    /** Per-tool placeholders, visible before you install. */
+    toolSpecs?: PluginToolSpec[];
+    /** Releases between the version you run and the current one. */
+    releases?: PluginRelease[];
+}
+interface PluginsResult extends ManageResult {
+    plugins: PluginListItem[];
+}
+/** One tool in GET /v1/manifest - the contract you code against. */
+interface ManifestTool {
+    name: string;
+    description: string;
+    parameters: Record<string, unknown>;
+    sideEffect: 'read' | 'write';
+    permission: string | null;
+    managed: boolean;
+    execution: 'hosted' | 'client';
+    /** True when the ENGINE invokes this tool itself; it never appears as a model decision. */
+    automatic?: boolean;
+    binding: {
+        method: string;
+        url: string;
+    } | null;
+}
+interface ManifestResult extends ManageResult {
+    agents: Array<{
+        intent: string;
+        label: string;
+        requiresCustomer: boolean;
+        permissions: string[] | null;
+        tools: ManifestTool[];
+    }>;
+}
+/**
+ * Per-tool endpoint auth. A discriminated union on purpose: TypeScript rejects
+ * a bearer without a token, or an api_key missing its header/value, at compile
+ * time rather than at the first live call.
+ */
+type ToolAuth = {
+    type: 'none';
+} | {
+    type: 'bearer';
+    token: string;
+} | {
+    type: 'api_key';
+    header: string;
+    value: string;
+} | {
+    type: 'signed';
+} | {
+    type: 'jwks';
+} | {
+    type: 'customer_token';
+} | {
+    type: 'oauth2';
+    tokenUrl: string;
+    clientId: string;
+    clientSecret: string;
+    scope?: string;
+};
+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;
+    /**
+     * 'internal' makes this your own team's agent: used from the console's agent
+     * page, invisible to the API key your customers talk to. Default 'customer'.
+     */
+    audience?: 'customer' | 'internal';
+    /** An internal agent's remit, in plain words. Put in front of every turn and enforced by refusal. */
+    scope?: string;
+}
+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?: ToolAuth;
+}
+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<ToolsResult>;
+        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?: ToolAuth;
+        }) => Promise<ManageResult>;
+    };
+    plugins: {
+        list: () => Promise<PluginsResult>;
+        install: (id: string) => Promise<PluginsResult>;
+        uninstall: (id: string) => Promise<PluginsResult>;
+        /** Follow a pack's releases for an agent you already run. Changes nothing today. */
+        track: (id: string) => Promise<PluginsResult>;
+    };
+    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<ManifestResult>;
+};
+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 ManifestResult as g, type ManifestTool as h, type PluginConcept as i, type PluginListItem as j, type PluginRelease as k, type PluginToolSpec as l, type PluginsResult as m, type ToolAuth as n, type ToolCall as o, type ToolListItem as p, type ToolResult as q, type ToolVariable as r, type ToolsResult as s, type TwelveAIOptions as t, buildManage as u };