chatbase 0.1.0 → 0.1.1

package/README.md

@@ -56,6 +56,7 @@ calls you invoke.
 * [`chatbase conversations export`](#chatbase-conversations-export)
 * [`chatbase conversations get [CONVERSATIONID]`](#chatbase-conversations-get-conversationid)
 * [`chatbase conversations list`](#chatbase-conversations-list)
+* [`chatbase conversations tool-result [CONVERSATIONID]`](#chatbase-conversations-tool-result-conversationid)
 * [`chatbase health`](#chatbase-health)
 * [`chatbase help [COMMAND]`](#chatbase-help-command)
 * [`chatbase helpdesk statuses`](#chatbase-helpdesk-statuses)
@@ -76,6 +77,8 @@ calls you invoke.
 * [`chatbase tickets reply [TICKETNUMBER]`](#chatbase-tickets-reply-ticketnumber)
 * [`chatbase tickets search QUERY`](#chatbase-tickets-search-query)
 * [`chatbase tickets update TICKETNUMBER`](#chatbase-tickets-update-ticketnumber)
+* [`chatbase whatsapp send-template TEMPLATE`](#chatbase-whatsapp-send-template-template)
+* [`chatbase whatsapp templates`](#chatbase-whatsapp-templates)
 
 ## `chatbase agents auto-retrain [AGENTID]`
 
@@ -817,6 +820,50 @@ EXAMPLES
 
 _See code: [src/commands/conversations/list.ts](https://github.com/Chatbase-co/chatbase-cli/blob/v0.1.0/src/commands/conversations/list.ts)_
 
+## `chatbase conversations tool-result [CONVERSATIONID]`
+
+Submit a client-side tool result to a chat turn
+
+```
+USAGE
+  $ chatbase conversations tool-result [CONVERSATIONID] --tool-call-id <value> [--json] [--plain] [-q] [--verbose] [--no-input]
+    [--no-color] [--agent-name <value> | -a <value>] [--conversation <value>] [--output <value>]
+
+ARGUMENTS
+  [CONVERSATIONID]  Conversation ID (alternative to --conversation)
+
+FLAGS
+  -a, --agent=<value>         Agent ID (or set CHATBASE_AGENT_ID)
+  -q, --quiet                 Suppress non-essential output
+      --agent-name=<value>    Agent display name (looked up to an ID)
+      --conversation=<value>  Conversation ID
+      --no-color              Disable colored output
+      --no-input              Never prompt; fail instead
+      --output=<value>        Result of executing the tool (inline JSON, @file, or @-); a value that is not valid JSON
+                              is sent as a plain string
+      --tool-call-id=<value>  (required) The toolCallId from the tool-call part in the chat response
+      --verbose               Verbose diagnostics
+
+OUTPUT FLAGS
+  --json   Output raw API JSON
+  --plain  Tab-separated output for scripts
+
+DESCRIPTION
+  Submit a client-side tool result to a chat turn
+
+  Submit the result of a client-side tool call so the paused chat turn can continue. The tool call ID comes from the
+  tool-call part of the chat response that requested the execution.
+
+EXAMPLES
+  $ chatbase conversations tool-result conv_123 --tool-call-id tc_1 --output '{"temperature": 72}' -a agt_123
+
+  $ chatbase conversations tool-result conv_123 --tool-call-id tc_1 --output @result.json -a agt_123
+
+  $ chatbase conversations tool-result conv_123 --tool-call-id tc_1 -a agt_123
+```
+
+_See code: [src/commands/conversations/tool-result.ts](https://github.com/Chatbase-co/chatbase-cli/blob/v0.1.0/src/commands/conversations/tool-result.ts)_
+
 ## `chatbase health`
 
 Check that the Chatbase API is reachable
@@ -1526,4 +1573,84 @@ EXAMPLES
 ```
 
 _See code: [src/commands/tickets/update.ts](https://github.com/Chatbase-co/chatbase-cli/blob/v0.1.0/src/commands/tickets/update.ts)_
+
+## `chatbase whatsapp send-template TEMPLATE`
+
+Send an approved WhatsApp template message
+
+```
+USAGE
+  $ chatbase whatsapp send-template TEMPLATE --to <value> [--json] [--plain] [-q] [--verbose] [--no-input] [--no-color]
+    [--agent-name <value> | -a <value>] [--from <value>] [--language <value>] [--variables <value>]
+
+ARGUMENTS
+  TEMPLATE  Name of the approved template
+
+FLAGS
+  -a, --agent=<value>       Agent ID (or set CHATBASE_AGENT_ID)
+  -q, --quiet               Suppress non-essential output
+      --agent-name=<value>  Agent display name (looked up to an ID)
+      --from=<value>        Which connected WhatsApp number to send from — optional when the agent has exactly one
+      --language=<value>    Template language code (e.g. en_US) — optional when the template exists in a single language
+      --no-color            Disable colored output
+      --no-input            Never prompt; fail instead
+      --to=<value>          (required) Recipient phone number in international format (digits with country code)
+      --variables=<value>   Template variable values as JSON grouped by component (@file, @-, or inline), e.g.
+                            '{"body":{"1":"Jane"}}'
+      --verbose             Verbose diagnostics
+
+OUTPUT FLAGS
+  --json   Output raw API JSON
+  --plain  Tab-separated output for scripts
+
+DESCRIPTION
+  Send an approved WhatsApp template message
+
+  Send an approved WhatsApp template to a phone number from one of the agent’s connected numbers. No user ID is needed —
+  a Chatbase user is resolved or created from the recipient number, and replies flow through the agent’s regular
+  WhatsApp pipeline. Use `whatsapp templates` to see available templates and the variables each expects.
+
+EXAMPLES
+  $ chatbase whatsapp send-template order_update --to 14155552671 -a agt_123
+
+  $ chatbase whatsapp send-template order_update --to 14155552671 --language en_US --variables '{"header":{"1":"#1042"},"body":{"1":"Jane","2":"Friday"}}' -a agt_123
+```
+
+_See code: [src/commands/whatsapp/send-template.ts](https://github.com/Chatbase-co/chatbase-cli/blob/v0.1.0/src/commands/whatsapp/send-template.ts)_
+
+## `chatbase whatsapp templates`
+
+List approved WhatsApp templates for an agent
+
+```
+USAGE
+  $ chatbase whatsapp templates [--json] [--plain] [-q] [--verbose] [--no-input] [--no-color] [--agent-name <value> | -a
+    <value>]
+
+FLAGS
+  -a, --agent=<value>       Agent ID (or set CHATBASE_AGENT_ID)
+  -q, --quiet               Suppress non-essential output
+      --agent-name=<value>  Agent display name (looked up to an ID)
+      --no-color            Disable colored output
+      --no-input            Never prompt; fail instead
+      --verbose             Verbose diagnostics
+
+OUTPUT FLAGS
+  --json   Output raw API JSON
+  --plain  Tab-separated output for scripts
+
+DESCRIPTION
+  List approved WhatsApp templates for an agent
+
+  List the approved WhatsApp templates available to the agent, across all of its connected WhatsApp Business Accounts. A
+  template can only be sent from a number on its own Business Account — pick a sender whose WABA matches the template’s
+  WABA column.
+
+EXAMPLES
+  $ chatbase whatsapp templates -a agt_123
+
+  $ chatbase whatsapp templates -a agt_123 --json
+```
+
+_See code: [src/commands/whatsapp/templates.ts](https://github.com/Chatbase-co/chatbase-cli/blob/v0.1.0/src/commands/whatsapp/templates.ts)_
 <!-- commandsstop -->

package/dist/base/body-input.js

@@ -72,6 +72,6 @@ export async function readBodyData(data, fields) {
     return { ...base, ...parseFields(fields) };
 }
 /** Resolve a flag value via the same @file/@- indirection, without JSON parsing. */
-export async function readTextInput(value) {
-    return resolveInput(value, '--content');
+export async function readTextInput(value, flagName = '--content') {
+    return resolveInput(value, flagName);
 }

package/dist/client/pairing.js

@@ -5,13 +5,12 @@
  *   3. Poll POST /api/cli-pairing/exchange until approved
  *   4. Receive the minted API key + workspace info
  *
- * These endpoints are internal (not under /api/v2) and unauthenticated.
  */
 import os from 'node:os';
 import { parseErrorResponse, UsageError } from '../errors/errors.js';
 import { rawApiFetch, resolveBaseUrl } from './client.js';
 import { wasInterrupted } from './signals.js';
-function pairingBaseUrl(baseUrl) {
+export function pairingBaseUrl(baseUrl) {
     return new URL(resolveBaseUrl(baseUrl)).origin;
 }
 export async function startPairing(opts) {

package/dist/commands/auth/login.js

@@ -3,7 +3,7 @@ import { Flags } from '@oclif/core';
 import { BaseCommand } from '../../base/base-command.js';
 import { readStdinToEnd } from '../../base/body-input.js';
 import { rawApiFetch } from '../../client/client.js';
-import { pollExchange, startPairing } from '../../client/pairing.js';
+import { pairingBaseUrl, pollExchange, startPairing } from '../../client/pairing.js';
 import { configFile } from '../../config/paths.js';
 import { writeUserConfig } from '../../config/store.js';
 import { parseErrorResponse, UsageError } from '../../errors/errors.js';
@@ -107,7 +107,10 @@ export default class AuthLogin extends BaseCommand {
         this.note(flags, `Saved to ${configFile()}`);
     }
     async verifyAndStore(flags, key) {
-        const res = await rawApiFetch('GET', '/me', { apiKey: key });
+        const res = await rawApiFetch('GET', '/api/cli-pairing/me', {
+            apiKey: key,
+            baseUrl: pairingBaseUrl()
+        });
         if (res.status === 200) {
             const body = res.body;
             writeUserConfig({ apiKey: key });

package/dist/commands/auth/logout.js

@@ -1,6 +1,7 @@
 import fs from 'node:fs';
 import { BaseCommand } from '../../base/base-command.js';
 import { rawApiFetch } from '../../client/client.js';
+import { pairingBaseUrl } from '../../client/pairing.js';
 import { configFile } from '../../config/paths.js';
 import { readUserConfig } from '../../config/store.js';
 export default class AuthLogout extends BaseCommand {
@@ -17,8 +18,9 @@ export default class AuthLogout extends BaseCommand {
         }
         if (config.apiKeySource === 'pairing') {
             try {
-                const res = await rawApiFetch('DELETE', '/me/credential', {
-                    apiKey: config.apiKey
+                const res = await rawApiFetch('DELETE', '/api/cli-pairing/me', {
+                    apiKey: config.apiKey,
+                    baseUrl: pairingBaseUrl()
                 });
                 if (res.status >= 200 && res.status < 300) {
                     this.note(flags, 'CLI session revoked server-side.');

package/dist/commands/auth/status.js

@@ -1,5 +1,6 @@
 import { BaseCommand } from '../../base/base-command.js';
 import { DEFAULT_BASE_URL, rawApiFetch, resolveBaseUrl } from '../../client/client.js';
+import { pairingBaseUrl } from '../../client/pairing.js';
 import { resolveApiKey } from '../../config/resolve.js';
 export default class AuthStatus extends BaseCommand {
     static description = 'Show the active credential and where it comes from';
@@ -18,8 +19,9 @@ export default class AuthStatus extends BaseCommand {
         }
         const tail = resolved.value.length > 8 ? `…${resolved.value.slice(-4)}` : '…****';
         this.note(flags, `Credential: ${tail} (from ${resolved.source})`);
-        const res = await rawApiFetch('GET', '/me', {
-            apiKey: resolved.value
+        const res = await rawApiFetch('GET', '/api/cli-pairing/me', {
+            apiKey: resolved.value,
+            baseUrl: pairingBaseUrl()
         });
         if (res.status === 200) {
             this.renderMe(flags, res.body);

package/dist/commands/conversations/tool-result.js

@@ -0,0 +1,74 @@
+import { Args, Flags } from '@oclif/core';
+import { AgentCommand } from '../../base/agent-command.js';
+import { readTextInput } from '../../base/body-input.js';
+import { throwIfError } from '../../client/client.js';
+import { UsageError } from '../../errors/errors.js';
+export default class ConversationsToolResult extends AgentCommand {
+    static summary = 'Submit a client-side tool result to a chat turn';
+    static description = 'Submit the result of a client-side tool call so the paused chat ' +
+        'turn can continue. The tool call ID comes from the tool-call part ' +
+        'of the chat response that requested the execution.';
+    static examples = [
+        '<%= config.bin %> conversations tool-result conv_123 --tool-call-id tc_1 --output \'{"temperature": 72}\' -a agt_123',
+        '<%= config.bin %> conversations tool-result conv_123 --tool-call-id tc_1 --output @result.json -a agt_123',
+        '<%= config.bin %> conversations tool-result conv_123 --tool-call-id tc_1 -a agt_123'
+    ];
+    static args = {
+        conversationId: Args.string({
+            required: false,
+            description: 'Conversation ID (alternative to --conversation)'
+        })
+    };
+    static flags = {
+        ...AgentCommand.baseFlags,
+        conversation: Flags.string({
+            description: 'Conversation ID'
+        }),
+        'tool-call-id': Flags.string({
+            required: true,
+            description: 'The toolCallId from the tool-call part in the chat response'
+        }),
+        output: Flags.string({
+            description: 'Result of executing the tool (inline JSON, @file, or @-); ' +
+                'a value that is not valid JSON is sent as a plain string'
+        })
+    };
+    async run() {
+        const { args, flags } = await this.parse(ConversationsToolResult);
+        // Positional and flag are alternatives — `agents get <id>` set the
+        // positional convention, the flag predates it and stays supported.
+        const conversationId = args.conversationId ?? flags.conversation;
+        if (!conversationId) {
+            throw new UsageError('Missing conversation ID. Pass it positionally (`conversations tool-result <id> ...`) or via --conversation.');
+        }
+        if (args.conversationId && flags.conversation) {
+            throw new UsageError('Pass the conversation ID either positionally or via --conversation, not both.');
+        }
+        const body = {
+            toolCallId: flags['tool-call-id']
+        };
+        if (flags.output !== undefined) {
+            const raw = await readTextInput(flags.output, '--output');
+            // Tool outputs are arbitrary values in the spec: parse JSON when
+            // it is JSON, otherwise pass the text through as a string.
+            try {
+                body.output = JSON.parse(raw);
+            }
+            catch {
+                body.output = raw;
+            }
+        }
+        const client = this.apiClient(flags);
+        const agentId = await this.agentId(flags, client);
+        const { data, error, response } = await client.POST('/agents/{agentId}/conversations/{conversationId}/tool-result', {
+            params: { path: { agentId, conversationId } },
+            body
+        });
+        throwIfError(response, error);
+        if (flags.json) {
+            process.stdout.write(`${JSON.stringify(data, null, 2)}\n`);
+            return;
+        }
+        this.success(flags, `Tool result submitted for ${flags['tool-call-id']}`);
+    }
+}

package/dist/commands/whatsapp/send-template.js

@@ -0,0 +1,94 @@
+import { Args, Flags } from '@oclif/core';
+import { AgentCommand } from '../../base/agent-command.js';
+import { readTextInput } from '../../base/body-input.js';
+import { throwIfError } from '../../client/client.js';
+import { UsageError } from '../../errors/errors.js';
+/** Parse --variables: a JSON object grouped by component, the exact shape
+ * `whatsapp templates` reports per template. Leaf validation is the API's
+ * job — it returns field-level errors for bad keys or non-string values. */
+async function parseVariables(value) {
+    const raw = await readTextInput(value, '--variables');
+    let parsed;
+    try {
+        parsed = JSON.parse(raw);
+    }
+    catch {
+        throw new UsageError('--variables must be valid JSON (inline, @file, or @-).');
+    }
+    if (typeof parsed !== 'object' ||
+        parsed === null ||
+        Array.isArray(parsed)) {
+        throw new UsageError('--variables must be a JSON object grouped by component, e.g. \'{"body":{"1":"Jane"}}\'.');
+    }
+    return parsed;
+}
+export default class WhatsappSendTemplate extends AgentCommand {
+    static summary = 'Send an approved WhatsApp template message';
+    static description = 'Send an approved WhatsApp template to a phone number from one of the ' +
+        'agent’s connected numbers. No user ID is needed — a Chatbase user is ' +
+        'resolved or created from the recipient number, and replies flow ' +
+        'through the agent’s regular WhatsApp pipeline. Use `whatsapp ' +
+        'templates` to see available templates and the variables each expects.';
+    static examples = [
+        '<%= config.bin %> whatsapp send-template order_update --to 14155552671 -a agt_123',
+        '<%= config.bin %> whatsapp send-template order_update --to 14155552671 --language en_US --variables \'{"header":{"1":"#1042"},"body":{"1":"Jane","2":"Friday"}}\' -a agt_123'
+    ];
+    static args = {
+        template: Args.string({
+            required: true,
+            description: 'Name of the approved template'
+        })
+    };
+    static flags = {
+        ...AgentCommand.baseFlags,
+        to: Flags.string({
+            required: true,
+            description: 'Recipient phone number in international format (digits with country code)'
+        }),
+        from: Flags.string({
+            description: 'Which connected WhatsApp number to send from — optional when the agent has exactly one'
+        }),
+        language: Flags.string({
+            description: 'Template language code (e.g. en_US) — optional when the template exists in a single language'
+        }),
+        variables: Flags.string({
+            description: 'Template variable values as JSON grouped by component (@file, @-, or inline), e.g. \'{"body":{"1":"Jane"}}\''
+        })
+    };
+    async run() {
+        const { args, flags } = await this.parse(WhatsappSendTemplate);
+        const variables = flags.variables
+            ? await parseVariables(flags.variables)
+            : undefined;
+        const client = this.apiClient(flags);
+        const agentId = await this.agentId(flags, client);
+        const body = {
+            to: flags.to,
+            ...(flags.from ? { from: flags.from } : {}),
+            template: {
+                name: args.template,
+                ...(flags.language ? { language: flags.language } : {}),
+                // The spec defaults variables to {} and the generated type
+                // makes it required — send the default explicitly.
+                variables: variables ?? {}
+            }
+        };
+        const { data, error, response } = await client.POST('/agents/{agentId}/whatsapp/messages/template', {
+            params: { path: { agentId } },
+            body
+        });
+        throwIfError(response, error);
+        const sent = data;
+        if (flags.json) {
+            process.stdout.write(`${JSON.stringify(sent, null, 2)}\n`);
+            return;
+        }
+        this.success(flags, `Sent template "${args.template}" to ${sent.to}`);
+        if (sent.conversationId) {
+            this.note(flags, `Conversation: ${sent.conversationId}`);
+        }
+        if (sent.messageId) {
+            process.stdout.write(`${sent.messageId}\n`);
+        }
+    }
+}

package/dist/commands/whatsapp/templates.js

@@ -0,0 +1,55 @@
+import { AgentCommand } from '../../base/agent-command.js';
+import { throwIfError } from '../../client/client.js';
+const COLUMNS = [
+    { key: 'name', header: 'NAME' },
+    { key: 'language', header: 'LANGUAGE' },
+    { key: 'category', header: 'CATEGORY' },
+    { key: 'format', header: 'FORMAT' },
+    { key: 'wabaId', header: 'WABA' },
+    { key: 'variables', header: 'VARIABLES' }
+];
+/** {header: ["1"], body: ["1","2"]} → "header:1 body:1,2" — the keys a send
+ * must supply, in the grouping `send-template --variables` expects. */
+function variablesSummary(variables) {
+    return Object.entries(variables)
+        .map(([component, keys]) => `${component}:${keys.join(',')}`)
+        .join(' ');
+}
+export default class WhatsappTemplates extends AgentCommand {
+    static summary = 'List approved WhatsApp templates for an agent';
+    static description = 'List the approved WhatsApp templates available to the agent, across ' +
+        'all of its connected WhatsApp Business Accounts. A template can only ' +
+        'be sent from a number on its own Business Account — pick a sender ' +
+        'whose WABA matches the template’s WABA column.';
+    static examples = [
+        '<%= config.bin %> whatsapp templates -a agt_123',
+        '<%= config.bin %> whatsapp templates -a agt_123 --json'
+    ];
+    static flags = { ...AgentCommand.baseFlags };
+    async run() {
+        const { flags } = await this.parse(WhatsappTemplates);
+        const client = this.apiClient(flags);
+        const agentId = await this.agentId(flags, client);
+        const { data, error, response } = await client.GET('/agents/{agentId}/whatsapp/templates', { params: { path: { agentId } } });
+        throwIfError(response, error);
+        const result = data;
+        const rows = result.templates.map((t) => ({
+            name: t.name,
+            language: t.language,
+            category: t.category,
+            format: t.parameterFormat,
+            wabaId: t.wabaId,
+            variables: variablesSummary(t.variables)
+        }));
+        this.printData(flags, result, rows, COLUMNS);
+        if (result.senders.length > 0) {
+            const senders = result.senders
+                .map((s) => `${s.from}${s.verifiedName ? ` (${s.verifiedName})` : ''} — waba ${s.wabaId}`)
+                .join('; ');
+            this.note(flags, `Senders: ${senders}`);
+        }
+        if (!result.complete) {
+            this.note(flags, `Warning: partial list — could not read WABA(s): ${result.unavailableWabaIds.join(', ')}. Retry to pick them up.`);
+        }
+    }
+}