@botozap/cli 0.1.4 → 0.2.0

package/README.md

@@ -206,3 +206,28 @@ pnpm --filter @botozap/cli test        # vitest
 pnpm --filter @botozap/cli build       # tsc -> dist/
 node packages/cli/dist/index.js --help
 ```
+
+## Atendimento, CRM e Agenda
+
+Comandos: `saved-replies`, `inbox-tools`, `opportunities`, `demands`, `radar`,
+`journeys`, `appointments`, `calendar`, `assignments`, `contact-stages` e
+`contact-fields`. Cada subcomando mostra campos e CAS em `--help`; os campos e
+filtros são lidos de `--input-file arquivo.json`. Use `-o json` para scripts.
+O arquivo mantém listas, objetos, null e timestamps precisos sem escape de shell.
+
+```sh
+botozap saved-replies list --input-file filtros.json -o json
+botozap opportunities create --input-file oportunidade.json -o json
+botozap appointments availability --input-file disponibilidade.json -o json
+```
+
+[Contratos e exemplos dos arquivos JSON](https://github.com/bytecraft-fernando/botozap-js/blob/main/docs/attendance-release.md).
+
+IA usa exclusivamente credenciais próprias (BYOK): SDK `client.ai`, CLI `botozap ai`
+e ferramentas MCP `ai_*`. Agentes versionados, provedores, credenciais, conhecimento,
+memória, skills, follow-ups e retornos prometidos, roteadores, casos, alertas,
+avisos, propostas de aprendizado e comerciais, controle de acesso (elegibilidade),
+inferências, promessas do operador, catálogo de modelos, execuções e uso. Scopes
+`agents:read/write`; aprovação exige chave criada por
+owner/admin ainda autorizado. Prévia não envia WhatsApp. Não há carteira, créditos
+ou compra de vagas de IA. [Contratos e exemplos IA](https://github.com/bytecraft-fernando/botozap-js/blob/main/docs/ai.md).

package/dist/commands/agenda.js

@@ -0,0 +1,58 @@
+import { operation } from "./attendance.js";
+export function registerAgenda(program) {
+    const group = program
+        .command("appointments")
+        .description("Agenda completa; scopes appointments:read/write");
+    operation(group, "list", "Filtros: customer_id,contact_id,owner_user_id,service_id,status,from,to,date(UTC),page,per_page", (c, _id, p) => c.appointments.list(p));
+    operation(group, "get <id>", "Detalha compromisso e revision", (c, id) => c.appointments.get(id));
+    operation(group, "create", "Cria compromisso; idempotency_key opcional no header; title,ends_at,time_zone,owner_user_id,service_id,links CRM e meeting_requested opcionais", (c, _id, p) => {
+        const { idempotency_key, ...body } = p;
+        return c.appointments.create(body, {
+            idempotencyKey: idempotency_key,
+        });
+    }, ["contact_id", "scheduled_at"]);
+    operation(group, "update <id>", "Edita compromisso com expected_revision; legado scheduled_at/note continua aceito", (c, id, p) => c.appointments.update(id, p));
+    operation(group, "delete <id>", "Exclui compromisso; Google deve estar cancelado e sincronizado antes", (c, id) => c.appointments.delete(id));
+    operation(group, "history <id>", "Histórico paginado (page)", (c, id, p) => c.appointments.history(id, p));
+    operation(group, "availability", "Horários livres calculados incluindo jornadas, exceções, buffers e calendários", (c, _id, p) => c.appointments.availability(p), ["customer_id", "owner_user_id", "service_id", "from", "to"]);
+    for (const kind of ["services", "schedules", "exceptions"]) {
+        const configuration = group
+            .command(kind)
+            .description(`Configuração de ${kind}`);
+        operation(configuration, "list", "customer_id e page", (c, _id, p) => c.appointments[kind].list(p), ["customer_id"]);
+        const required = kind === "services"
+            ? [
+                "customer_id",
+                "name",
+                "duration_minutes",
+                "slot_minutes",
+                "buffer_before_minutes",
+                "buffer_after_minutes",
+                "minimum_notice_minutes",
+                "booking_horizon_days",
+                "active",
+            ]
+            : kind === "schedules"
+                ? ["customer_id", "owner_user_id", "time_zone", "windows"]
+                : [
+                    "customer_id",
+                    "owner_user_id",
+                    "local_date",
+                    "start_minute",
+                    "end_minute",
+                    "kind",
+                ];
+        operation(configuration, "create", "Cria configuração completa; consulte tipos públicos do SDK", (c, _id, p) => kind === "services"
+            ? c.appointments.services.create(p)
+            : kind === "schedules"
+                ? c.appointments.schedules.create(p)
+                : c.appointments.exceptions.create(p), required);
+        operation(configuration, "update <id>", "Altera campos da configuração com expected_revision", (c, id, p) => kind === "services"
+            ? c.appointments.services.update(id, p)
+            : kind === "schedules"
+                ? c.appointments.schedules.update(id, p)
+                : c.appointments.exceptions.update(id, p), ["expected_revision"]);
+        if (kind === "exceptions")
+            operation(configuration, "delete <id>", "Exclui exceção com expected_revision", (c, id, p) => c.appointments.exceptions.delete(id, Number(p.expected_revision)), ["expected_revision"]);
+    }
+}

package/dist/commands/ai.js

@@ -0,0 +1,73 @@
+import { readFile, stat } from "node:fs/promises";
+import { basename } from "node:path";
+import { AI_CONFIGURABLE_PURPOSES, AI_OPERATIONS } from "@botozap/sdk";
+import { operation } from "./attendance.js";
+const kebab = (value) => value.replace(/[A-Z]/g, (c) => `-${c.toLowerCase()}`);
+/** Every command maps to one declared /ai endpoint; inputs preserve exact revisions. */
+export function registerAi(program) {
+    const root = program
+        .command("ai")
+        .description("IA BYOK: agentes, bibliotecas, roteamento e operação; agents:read/write");
+    operation(root, "conversation-control <id>", "Pausa/retoma agente na conversa; resume pode gerar respostas.", (client, id, input) => client.conversations.controlAgent(id, input.action), ["action"]);
+    for (const group of new Set(AI_OPERATIONS.map((o) => o.group))) {
+        const command = root
+            .command(kebab(group))
+            .description(`Operações de ${group}`);
+        for (const op of AI_OPERATIONS.filter((o) => o.group === group)) {
+            const required = Object.entries(op.fields)
+                .filter(([, v]) => !v.optional)
+                .map(([k]) => k);
+            const fields = op.shape === "multipart"
+                ? required
+                    .filter((k) => k !== "file" && k !== "file_name")
+                    .concat("file_path")
+                : required;
+            operation(command, kebab(op.name), `${op.method} ${op.path}. ${op.description} Campos: ${Object.keys(op.fields)
+                .filter((k) => k !== "file")
+                .join(", ")}${op.shape === "multipart" ? ", file_path (arquivo local)" : ""}.`, async (client, _id, raw) => {
+                const input = { ...raw };
+                if (op.shape === "multipart") {
+                    const path = String(input.file_path);
+                    const limit = op.group === "skills" ? 5 * 1024 * 1024 : 20 * 1024 * 1024;
+                    const size = (await stat(path)).size;
+                    if (!size || size > limit)
+                        throw new Error("Arquivo vazio ou acima do limite de upload.");
+                    const bytes = await readFile(path);
+                    if (!bytes.length || bytes.length > limit)
+                        throw new Error("Arquivo vazio ou acima do limite de upload.");
+                    delete input.file_path;
+                    input.file = new Blob([bytes], {
+                        type: typeof input.mime_type === "string"
+                            ? input.mime_type
+                            : /\.pdf$/i.test(String(input.file_name ?? path))
+                                ? "application/pdf"
+                                : "application/octet-stream",
+                    });
+                    delete input.mime_type;
+                    input.file_name ??= basename(path);
+                }
+                return client.ai.invoke(group, op.name, input);
+            }, fields, {
+                maxBytes: 1024 * 1024,
+                validate(input) {
+                    for (const [name, field] of Object.entries(op.fields)) {
+                        const value = input[name];
+                        if (value === undefined)
+                            continue;
+                        if (field.type === "configurablePurpose" &&
+                            !AI_CONFIGURABLE_PURPOSES.includes(String(value)))
+                            throw new Error("Esta finalidade é configurada na versão do agente ou no roteador.");
+                        if ((field.type === "revision" || field.type === "revisionZero") &&
+                            (typeof value !== "string" || !/^\d+$/.test(value)))
+                            throw new Error(`${name} deve ser a string de revisão recebida da API.`);
+                        if (field.type === "number" &&
+                            (typeof value !== "number" || !Number.isFinite(value)))
+                            throw new Error(`${name} deve ser número.`);
+                        if (field.type === "true" && value !== true)
+                            throw new Error(`${name} exige confirmação true.`);
+                    }
+                },
+            });
+        }
+    }
+}

package/dist/commands/attendance.js

@@ -0,0 +1,139 @@
+import { readFile } from "node:fs/promises";
+import { context } from "./shared.js";
+import { printJson, printDetail, printTable, printLine } from "../output.js";
+/** JSON files preserve nested fields, null, Unicode and microsecond CAS timestamps. */
+export async function readInput(path, maxBytes = 256 * 1024) {
+    if (!path)
+        return {};
+    const raw = await readFile(path, "utf8");
+    if (Buffer.byteLength(raw) > maxBytes)
+        throw new Error(`JSON excede ${maxBytes} bytes.`);
+    const value = JSON.parse(raw);
+    if (!value || typeof value !== "object" || Array.isArray(value))
+        throw new Error("O arquivo deve conter um objeto JSON.");
+    return value;
+}
+function display(value, format) {
+    if (format === "json")
+        return printJson(value ?? { success: true });
+    if (value === undefined)
+        return printLine("Operação concluída.");
+    if (Array.isArray(value))
+        return printTable(value, [
+            { header: "ID", key: "id" },
+            { header: "NOME", key: "name" },
+            { header: "TÍTULO", key: "title" },
+        ]);
+    if (value && typeof value === "object") {
+        const row = value;
+        if (Array.isArray(row.data)) {
+            printTable(row.data, [
+                { header: "ID", key: "id" },
+                { header: "NOME", key: "name" },
+                { header: "TÍTULO", key: "title" },
+                { header: "ESTADO", key: "status" },
+            ]);
+            if (row.meta)
+                printDetail(row.meta);
+            if (row.paging)
+                printDetail(row.paging);
+            return;
+        }
+        return printDetail(row);
+    }
+    printJson(value);
+}
+export function operation(parent, signature, description, run, required = [], inputOptions) {
+    const cmd = parent
+        .command(signature)
+        .description(description)
+        .option("--input-file <path>", "arquivo JSON com campos/filtros da operação; consulte --help");
+    if (required.length)
+        cmd.addHelpText("after", `\nCampos obrigatórios no JSON: ${required.join(", ")}.`);
+    cmd.action(async (...args) => {
+        const command = args.at(-1);
+        const opts = command.opts();
+        const data = await readInput(opts.inputFile, inputOptions?.maxBytes);
+        for (const key of required)
+            if (data[key] === undefined)
+                throw new Error(`Campo obrigatório no JSON: ${key}.`);
+        if (inputOptions)
+            inputOptions.validate(data);
+        else
+            for (const key of ["expected_version", "version", "expected_revision"])
+                if (data[key] !== undefined &&
+                    (!Number.isInteger(data[key]) ||
+                        Number(data[key]) < (signature.startsWith("stage-rule") ? 0 : 1)))
+                    throw new Error(`${key} deve ser inteiro positivo.`);
+        const { client, format } = context(command);
+        const id = signature.includes("<id>") ? String(args[0]) : undefined;
+        display(await run(client, id, data), format);
+    });
+    return cmd;
+}
+export function registerAttendance(program) {
+    const saved = program
+        .command("saved-replies")
+        .description("Respostas compartilhadas (scope saved_replies:read/write); pessoais pertencem à sessão");
+    operation(saved, "list", "Filtros: query, customer_id (UUID ou account), include_account, page, per_page", (c, _id, p) => c.savedReplies.list(p));
+    operation(saved, "get <id>", "Lê resposta e updated_at para edição", (c, id) => c.savedReplies.get(id));
+    operation(saved, "create", "Cria resposta: title, body, shortcut, customer_id", (c, _id, p) => c.savedReplies.create(p), ["title", "body"]);
+    operation(saved, "update <id>", "Atualiza campos com CAS (expected_updated_at exato, sem arredondar)", (c, id, p) => c.savedReplies.update(id, p), ["expected_updated_at"]);
+    operation(saved, "delete <id>", "Exclui resposta com CAS", (c, id, p) => c.savedReplies.delete(id, p), ["expected_updated_at"]);
+    const inbox = program
+        .command("inbox-tools")
+        .description("Notas, retornos, arquivo e adiamento; scopes inbox:read/write");
+    operation(inbox, "get <id>", "Ferramentas da conversa; page/per_page para notas e retornos", (c, id, p) => c.inbox.get(id, p));
+    operation(inbox, "mutate <id>", "operation: archive, unarchive, snooze, unsnooze, note_create/update/delete, reminder_create/update; CAS expected_version nas alterações", (c, id, p) => c.inbox.mutate(id, p), ["operation"]);
+    for (const resource of ["opportunities", "demands"]) {
+        const group = program
+            .command(resource)
+            .description(`${resource === "opportunities" ? "Oportunidades" : "Demandas"} do CRM; scopes crm:read/write`);
+        operation(group, "list", "customer_id obrigatório; q,status,contact_id,owner_user_id,stage_id,page,per_page", (c, _id, p) => c[resource].list(p), ["customer_id"]);
+        operation(group, "get <id>", "Lê registro e versão", (c, id) => c[resource].get(id));
+        operation(group, "create", "Cria registro completo; campos conforme SDK", (c, _id, p) => resource === "opportunities"
+            ? c.opportunities.create(p)
+            : c.demands.create(p), ["customer_id", "contact_id", "title"]);
+        operation(group, "update <id>", "Altera campos, responsável, estado e próximo passo com CAS", (c, id, p) => c[resource].update(id, p), ["expected_version"]);
+        operation(group, "activities <id>", "Histórico paginado (page)", (c, id, p) => c[resource].activities(id, p));
+        operation(group, "conversations <id>", "Conversas vinculadas (page)", (c, id, p) => c[resource].conversations(id, p));
+        operation(group, "link-conversation <id>", "Vincula conversa do mesmo contato", (c, id, p) => c[resource].linkConversation(id, String(p.conversation_id)), ["conversation_id"]);
+        operation(group, "unlink-conversation <id>", "Remove vínculo com conversa", (c, id, p) => c[resource].unlinkConversation(id, String(p.conversation_id)), ["conversation_id"]);
+    }
+    const radar = program
+        .command("radar")
+        .description("Pendências do CRM; scopes crm:read/write");
+    operation(radar, "list", "customer_id; filtros bucket,entity_type,owner_user_id,reason,page,per_page", (c, _id, p) => c.radar.list(p), ["customer_id"]);
+    operation(radar, "stage-rules", "Critérios das etapas do Cliente", (c, _id, p) => c.radar.stageRules(String(p.customer_id)), ["customer_id"]);
+    operation(radar, "stage-rule <id>", "Configura critério: expected_version=0 cria; cold_hours,critical_hours,require_owner,require_next_step", (c, id, p) => c.radar.configureStageRule(id, p), [
+        "customer_id",
+        "expected_version",
+        "cold_hours",
+        "critical_hours",
+        "require_owner",
+        "require_next_step",
+    ]);
+    const journey = program
+        .command("journeys")
+        .description("Réguas e execuções; scopes journeys:read/write; ambiente live");
+    operation(journey, "list", "Filtros customer_id,limit,after", (c, _id, p) => c.journeys.list(p));
+    operation(journey, "get <id>", "Definição e passos da régua", (c, id, p) => c.journeys.get(id, p));
+    operation(journey, "create", "Configuração completa da régua; steps é lista de template_id,delay_minutes,variable_map", (c, _id, p) => c.journeys.create(p), ["customer_id", "name", "steps"]);
+    operation(journey, "update <id>", "Substitui configuração completa com CAS version", (c, id, p) => c.journeys.update(id, p), ["customer_id", "name", "steps", "version"]);
+    operation(journey, "delete <id>", "Arquiva régua com CAS version (preserva histórico)", (c, id, p) => c.journeys.delete(id, Number(p.version)), ["version"]);
+    operation(journey, "control <id>", "action: pause/resume/archive e version", (c, id, p) => c.journeys.control(id, p), ["action", "version"]);
+    operation(journey, "runs <id>", "Lista execuções da régua; customer_id,limit,after", (c, id, p) => c.journeys.runs(id, p));
+    operation(journey, "enroll <id>", "Programa ocorrência única para contato (pode gerar envio automático)", (c, id, p) => c.journeys.enroll(id, p), ["contact_id", "occurrence_key"]);
+    operation(journey, "get-run <id>", "Execução com passos, falhas e comprovantes", (c, id) => c.journeys.getRun(id));
+    operation(journey, "control-run <id>", "action: stop ou acknowledge (com note)", (c, id, p) => c.journeys.controlRun(id, p), ["action"]);
+    const assignments = program
+        .command("assignments")
+        .description("Atribuições de conversas a membros da Conta");
+    operation(assignments, "list <id>", "Atribuições da conversa; page,per_page", (c, id, p) => c.conversations.listAssignments(id, p));
+    operation(assignments, "create <id>", "Atribui conversa a user_id; notes opcional", (c, id, p) => c.conversations.createAssignment(id, p), ["user_id"]);
+    operation(assignments, "get <id>", "Lê assignment_id da conversa", (c, id, p) => c.conversations.getAssignment(id, String(p.assignment_id)), ["assignment_id"]);
+    operation(assignments, "update <id>", "Atualiza atribuição: assignment_id + campos permitidos pela API", (c, id, p) => {
+        const { assignment_id, ...patch } = p;
+        return c.conversations.updateAssignment(id, String(assignment_id), patch);
+    }, ["assignment_id"]);
+}

package/dist/commands/calendar.js

@@ -0,0 +1,14 @@
+import { operation } from "./attendance.js";
+export function registerCalendar(program) {
+    const group = program
+        .command("calendar")
+        .description("Google Calendar: autorize primeiro em /calendarios no Painel; scopes calendar:read/write");
+    operation(group, "connections", "Lista conexões (page,per_page)", (c, _id, p) => c.calendar.connections(p));
+    operation(group, "disconnect <id>", "Desconecta conta Google e seus calendários", (c, id) => c.calendar.disconnect(id));
+    operation(group, "calendars <id>", "Lista calendários da conexão", (c, id) => c.calendar.calendars(id));
+    operation(group, "refresh <id>", "Atualiza catálogo de calendários Google da conexão", (c, id) => c.calendar.refresh(id));
+    operation(group, "select <id>", "Configura destino/ocupação com CAS expected_revision", (c, id, p) => c.calendar.select(id, p), ["destination", "include_busy", "expected_revision"]);
+    operation(group, "jobs", "Lista sincronizações (connection_id,page,per_page)", (c, _id, p) => c.calendar.jobs(p));
+    operation(group, "retry-job <id>", "Reagenda sincronização com falha", (c, id) => c.calendar.retryJob(id));
+    operation(group, "resolve-conflict <id>", "ID do compromisso; choice local/remote e expected_revision", (c, id, p) => c.calendar.resolveConflict(id, p), ["choice", "expected_revision"]);
+}

package/dist/commands/contact-configuration.js

@@ -0,0 +1,18 @@
+import { operation } from "./attendance.js";
+export function registerContactConfiguration(program) {
+    const stages = program
+        .command("contact-stages")
+        .description("Etapas do funil por Cliente; contacts:read/write");
+    operation(stages, "list", "customer_id recomendado; omitir só em Conta com exatamente um Cliente", (c, _id, p) => c.contactStages.list(p));
+    operation(stages, "create", "label e color (zinc,green,amber,pink); customer_id recomendado", (c, _id, p) => c.contactStages.create(p), ["label", "color"]);
+    operation(stages, "update <id>", "Altera label,color,position; customer_id recomendado", (c, id, p) => c.contactStages.update(id, p));
+    operation(stages, "delete <id>", "Exclui etapa do Cliente; customer_id recomendado", (c, id, p) => c.contactStages.delete(id, p));
+    operation(stages, "reorder", "stage_ids deve conter todas as etapas exatamente uma vez; customer_id recomendado", (c, _id, p) => c.contactStages.reorder(p), ["stage_ids"]);
+    const fields = program
+        .command("contact-fields")
+        .description("Campos personalizados da Conta; contacts:read/write");
+    operation(fields, "list", "Lista definições e tipos de campos disponíveis", (c) => c.contactFields.list());
+    operation(fields, "create", "label; type text/number/boolean/date e key opcionais", (c, _id, p) => c.contactFields.create(p), ["label"]);
+    operation(fields, "update <id>", "Altera label e position; tipo e chave são imutáveis", (c, id, p) => c.contactFields.update(id, p));
+    operation(fields, "delete <id>", "Exclui definição do campo", (c, id) => c.contactFields.delete(id));
+}

package/dist/commands/contacts.js

@@ -1,5 +1,8 @@
 import { context, toInt, toBool } from "./shared.js";
 import { printJson, printTable, printDetail, printCursorFooter, printLine, } from "../output.js";
+function collect(value, previous) {
+    return [...(previous ?? []), value];
+}
 export function registerContacts(program) {
     const contacts = program
         .command("contacts")
@@ -60,6 +63,7 @@ export function registerContacts(program) {
         .option("--username <username>", "username")
         .option("--customer-id <id>", "cliente vinculado")
         .option("--phone-number-id <id>", "número vinculado")
+        .option("--tag <tag>", "tag do contato (repetível; até 20 × 40 caracteres)", collect)
         .action(async (opts, cmd) => {
         const { client, format } = context(cmd);
         const data = await client.contacts.create({
@@ -70,6 +74,7 @@ export function registerContacts(program) {
             username: opts.username,
             customer_id: opts.customerId,
             phone_number_id: opts.phoneNumberId,
+            ...(opts.tag ? { tags: opts.tag } : {}),
         });
         if (format === "json")
             return printJson(data);
@@ -81,6 +86,9 @@ export function registerContacts(program) {
         .description("Atualiza um contato")
         .option("--profile-name <nome>", "novo nome do perfil")
         .option("--username <username>", "novo username")
+        .option("--tag <tag>", "substitui todas as tags (repetível)", collect)
+        .option("--add-tag <tag>", "acrescenta tag (repetível)", collect)
+        .option("--remove-tag <tag>", "remove tag (repetível)", collect)
         .action(async (id, opts, cmd) => {
         const { client, format } = context(cmd);
         const body = {};
@@ -88,8 +96,17 @@ export function registerContacts(program) {
             body.profile_name = opts.profileName;
         if (opts.username !== undefined)
             body.username = opts.username;
+        if (opts.tag)
+            body.tags = opts.tag;
+        if (opts.addTag)
+            body.add_tags = opts.addTag;
+        if (opts.removeTag)
+            body.remove_tags = opts.removeTag;
+        if (opts.tag && (opts.addTag || opts.removeTag)) {
+            throw new Error("Use --tag para substituir a lista ou --add-tag/--remove-tag para alterá-la, não os dois.");
+        }
         if (Object.keys(body).length === 0) {
-            throw new Error("Informe ao menos --profile-name ou --username.");
+            throw new Error("Informe ao menos --profile-name, --username, --tag, --add-tag ou --remove-tag.");
         }
         const data = await client.contacts.update(id, body);
         if (format === "json")

package/dist/index.js

@@ -4,6 +4,11 @@ import { Command } from "commander";
 import pc from "picocolors";
 import { resolveFormat } from "./output.js";
 import { renderErrorText, renderErrorJson } from "./render-error.js";
+import { registerContactConfiguration } from "./commands/contact-configuration.js";
+import { registerCalendar } from "./commands/calendar.js";
+import { registerAi } from "./commands/ai.js";
+import { registerAgenda } from "./commands/agenda.js";
+import { registerAttendance } from "./commands/attendance.js";
 import { registerMessages } from "./commands/messages.js";
 import { registerConversations } from "./commands/conversations.js";
 import { registerContacts } from "./commands/contacts.js";
@@ -38,6 +43,11 @@ program.hook("preAction", (_thisCommand, actionCommand) => {
     selectedFormat = resolveFormat(actionCommand.optsWithGlobals().output);
 });
 // Recursos
+registerAttendance(program);
+registerAgenda(program);
+registerAi(program);
+registerCalendar(program);
+registerContactConfiguration(program);
 registerMessages(program);
 registerConversations(program);
 registerContacts(program);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@botozap/cli",
-  "version": "0.1.4",
+  "version": "0.2.0",
   "description": "CLI dev-first para a API pública do BotoZap (WhatsApp Cloud API multi-tenant).",
   "license": "MIT",
   "type": "module",
@@ -30,7 +30,7 @@
   "dependencies": {
     "commander": "^12.1.0",
     "picocolors": "^1.1.1",
-    "@botozap/sdk": "0.3.2"
+    "@botozap/sdk": "0.4.0"
   },
   "devDependencies": {
     "@types/node": "^20.19.0",