@indemn/cli 1.7.1 → 1.7.3

package/src/sdk/config-change.ts

@@ -10,12 +10,16 @@ export interface ConfigChange {
   system_prompt?: string;
   greeting?: string;
   model?: { provider: string; model: string };
+  /** Model settings the dashboard exposes (temperature, …), merged into the saved ones. */
+  parameters?: Record<string, unknown>;
 }
 
 interface Snapshot {
   system_prompt: string;
   greeting: string;
   model: string;
+  /** The model's settings as JSON, so a settings-only change is a change. */
+  parameters: string;
 }
 
 export interface ConfigPlan {
@@ -33,11 +37,12 @@ export interface ConfigPlan {
 }
 
 function snapshot(cfg: BotConfiguration): Snapshot {
-  const llm = (cfg as { llm_config?: { provider?: string; model?: string } }).llm_config;
+  const llm = (cfg as { llm_config?: { provider?: string; model?: string; parameters?: Record<string, unknown> } }).llm_config;
   return {
     system_prompt: cfg.ai_config?.system_prompt ?? '',
     greeting: cfg.first_message?.text ?? '',
     model: llm?.model ? `${llm.provider ?? '?'}/${llm.model}` : '',
+    parameters: JSON.stringify(llm?.parameters ?? {}),
   };
 }
 
@@ -69,17 +74,27 @@ function channelTypes(agent: { channels?: unknown }): string[] {
 export async function planConfigChange(client: IndemnClient, agentId: string, change: ConfigChange): Promise<ConfigPlan> {
   const raw = await new ConfigSDK(client).getConfig(agentId);
   const current = snapshot(raw);
+  const savedLlm = (raw as { llm_config?: { provider?: string; model?: string; parameters?: Record<string, unknown> } }).llm_config;
+  const saved = savedLlm?.parameters ?? {};
+  const wanted = change.parameters ? { ...saved, ...change.parameters } : saved;
   const next: Snapshot = {
     system_prompt: change.system_prompt ?? current.system_prompt,
     greeting: change.greeting ?? current.greeting,
     model: change.model ? `${change.model.provider}/${change.model.model}` : current.model,
+    parameters: JSON.stringify(wanted),
   };
   const changes = (Object.keys(next) as Array<keyof Snapshot>).filter((k) => next[k] !== current[k]);
   let llm: ConfigPlan['llm'];
-  if (change.model && changes.includes('model')) {
+  if ((change.model && changes.includes('model')) || (change.parameters && changes.includes('parameters'))) {
+    const model = change.model ?? (savedLlm?.provider && savedLlm.model ? { provider: savedLlm.provider, model: savedLlm.model } : undefined);
+    if (!model) throw new CliError('The agent has no model yet; set one before changing its settings.');
     const agent = await new AgentsSDK(client).getAgent(agentId);
-    const saved = ((raw as { llm_config?: { parameters?: Record<string, unknown> } }).llm_config?.parameters) ?? {};
-    llm = await modelForAgent(client, change.model, channelTypes(agent), saved);
+    // The catalog decides which settings the model takes; a wanted value the model does not expose is refused.
+    llm = await modelForAgent(client, model, channelTypes(agent), wanted);
+    const unknown = Object.keys(change.parameters ?? {}).filter((k) => !(k in llm!.parameters));
+    if (unknown.length) throw new CliError(`${model.provider}/${model.model} has no setting named ${unknown.join(', ')}.`);
+    next.parameters = JSON.stringify(llm.parameters);
+    if (next.parameters === current.parameters) changes.splice(changes.indexOf('parameters'), changes.includes('parameters') ? 1 : 0);
   }
   let lifecycle = 'unknown';
   try {
@@ -110,6 +125,12 @@ export function describePlan(plan: ConfigPlan, opts: { maxDiffLines?: number } =
   }
   if (plan.changes.includes('greeting')) parts.push(`Greeting: "${plan.current.greeting}" -> "${plan.next.greeting}".`);
   if (plan.changes.includes('model')) parts.push(`Model: ${plan.current.model || '(none)'} -> ${plan.next.model}.`);
+  if (plan.changes.includes('parameters')) {
+    const before = JSON.parse(plan.current.parameters) as Record<string, unknown>;
+    const after = JSON.parse(plan.next.parameters) as Record<string, unknown>;
+    const changed = Object.keys(after).filter((k) => JSON.stringify(after[k]) !== JSON.stringify(before[k]));
+    parts.push(`Model settings: ${changed.map((k) => `${k} ${before[k] === undefined ? '(unset)' : JSON.stringify(before[k])} -> ${JSON.stringify(after[k])}`).join(', ')}.`);
+  }
   return parts.join('\n');
 }
 
@@ -130,7 +151,8 @@ export async function applyConfigChange(client: IndemnClient, plan: ConfigPlan,
   if (plan.changes.includes('greeting')) {
     input.first_message = JSON.stringify({ ...(plan.raw.first_message ?? {}), text: change.greeting });
   }
-  if (plan.changes.includes('model') && change.model) input.llm_config = plan.llm ?? { provider: change.model.provider, model: change.model.model };
+  if ((plan.changes.includes('model') || plan.changes.includes('parameters')) && plan.llm) input.llm_config = plan.llm;
+  else if (plan.changes.includes('model') && change.model) input.llm_config = { provider: change.model.provider, model: change.model.model };
   if (Object.keys(input).length === 0) return { applied: [], mismatched: [] };
   const sdk = new ConfigSDK(client);
   await sdk.setConfig(plan.agentId, input);

package/src/sdk/kb.ts

@@ -1,4 +1,5 @@
 import type { IndemnClient } from './client.js';
+import { CliError, EXIT } from '../core/runtime.js';
 import type {
   KnowledgeBase,
   CreateKBInput,
@@ -121,14 +122,8 @@ export class KBSDK {
       throw new Error(`${fileName} is ${(size / 1024 / 1024).toFixed(1)} MB; the limit is 10 MB.`);
     }
 
-    const formData = new FormData();
-    formData.append('file', new Blob([fs.readFileSync(filePath)]), fileName);
-    const stored = await this.client.copilotPostForm<{ url?: string; signedUrl?: string; data?: { url?: string; signedUrl?: string } }>(
-      '/organization/:org_id/files/upload-org?generateSignedUrl=true',
-      formData,
-    );
     // The import service must fetch the file, so it needs the signed link.
-    const url = stored?.signedUrl ?? stored?.data?.signedUrl ?? stored?.url ?? stored?.data?.url;
+    const { signedUrl: url } = await this.storeFile(filePath);
     if (!url) throw new Error(`Uploading ${fileName} returned no file link; nothing was imported.`);
 
     return this.importKB(kbId, {
@@ -138,17 +133,63 @@ export class KBSDK {
     });
   }
 
+  /** Put a local file into the organization's file store; its stored link and a signed link to download it. */
+  async storeFile(filePath: string): Promise<{ url?: string; signedUrl?: string }> {
+    const fs = await import('fs');
+    const path = await import('path');
+    const formData = new FormData();
+    formData.append('file', new Blob([fs.readFileSync(filePath)]), path.basename(filePath));
+    const stored = await this.client.copilotPostForm<{ url?: string; signedUrl?: string; data?: { url?: string; signedUrl?: string } }>(
+      '/organization/:org_id/files/upload-org?generateSignedUrl=true',
+      formData,
+    );
+    return { url: stored?.url ?? stored?.data?.url, signedUrl: stored?.signedUrl ?? stored?.data?.signedUrl ?? stored?.url ?? stored?.data?.url };
+  }
+
+  /**
+   * A signed download link for a file in the organization's file store, given its stored (unsigned) link.
+   * Exports return unsigned links that the browser refuses (403); the file store signs them on request.
+   */
+  async signedLink(storedUrl: string): Promise<string | undefined> {
+    const key = storedUrl.replace(/^https?:\/\/[^/]+\//, '').split('?')[0];
+    if (!key) return undefined;
+    const res = await this.client.copilotGet<{ signedUrl?: string; url?: string; download_url?: string; data?: { signedUrl?: string; url?: string } }>(
+      '/organization/:org_id/files/signed-url', { filename: key },
+    ).catch(() => undefined);
+    return res?.signedUrl ?? res?.download_url ?? res?.data?.signedUrl ?? res?.url ?? res?.data?.url;
+  }
+
   async updateDataSource(
     kbId: string,
     sourceId: string,
     input: Partial<AddDataSourceInput>,
   ): Promise<DataSource> {
+    // copilot needs both fields on every update (and answers 500, not 400, when one is missing): fill the
+    // one the caller left out from the saved entry.
+    let { question, answer } = input;
+    if (question === undefined || answer === undefined) {
+      const saved = await this.findDataSource(kbId, sourceId);
+      question ??= saved?.question;
+      answer ??= saved?.answer;
+    }
+    if (!question || !answer) throw new CliError('A question/answer entry needs both its question and its answer.', EXIT.NEEDS_INPUT);
     return this.client.copilotPut<DataSource>(
       `/organization/:org_id/knowledge-bases/${kbId}/data-source/${sourceId}`,
-      { payload: { question: input.question, answer: input.answer, isManual: true } },
+      { payload: { question, answer, isManual: true } },
     );
   }
 
+  /** One entry of a knowledge base by id, or undefined (the API lists entries by page only). */
+  async findDataSource(kbId: string, sourceId: string): Promise<DataSource | undefined> {
+    for (let page = 1; page <= 50; page++) {
+      const res = await this.listDataSources(kbId, { page: String(page), limit: '100' });
+      const hit = (res.dataSources ?? []).find((d) => d._id === sourceId);
+      if (hit) return hit;
+      if (!res.pages || page >= res.pages || !(res.dataSources ?? []).length) return undefined;
+    }
+    return undefined;
+  }
+
   async deleteDataSource(kbId: string, sourceId: string): Promise<void> {
     await this.client.copilotDelete(
       `/organization/:org_id/knowledge-bases/${kbId}/data-source/${sourceId}`,
@@ -223,11 +264,13 @@ export class KBSDK {
    * Crawl and file-import status. copilot has no status route, so this reads
    * the KB's non-manual sources and their scrape jobs.
    */
-  async scrapeStatus(kbId: string): Promise<Array<{ id?: string; source?: string; status?: string; job_status?: string; error?: string; completed_at?: string }>> {
+  async scrapeStatus(kbId: string): Promise<Array<{ id?: string; name?: string; source?: string; status?: string; job_status?: string; error?: string; completed_at?: string }>> {
     const kb = await this.getKB(kbId) as unknown as { fileWebSources?: Array<Record<string, any>> };
     return (kb.fileWebSources ?? []).map((s) => ({
       id: s._id ? String(s._id) : undefined,
-      source: s.source,
+      // An uploaded file's source is its signed storage link: name it by its file name (as the dashboard does)
+      // and keep the link without its signature.
+      ...(s.type === 'file' ? { name: s.source_details?.file_name ?? undefined, source: s.source ? String(s.source).split('?')[0] : undefined } : { source: s.source }),
       status: s.status,
       job_status: s.source_details?.id_scrape_request?.status,
       error: s.error_message ?? s.source_details?.id_scrape_request?.message,

package/src/sdk/voice.ts

@@ -116,7 +116,7 @@ export class VoiceSDK {
   /** The agent's voice settings. Voice settings live on its phone number, so an agent without one has none. */
   async getAgentVoice(agentId: string): Promise<Record<string, unknown>> {
     const numbers = await this.agentNumbers(agentId);
-    if (!numbers.length) throw new CliError(`Agent ${agentId} has no phone number, so it has no voice settings yet. Attach one with \`indemn agents numbers attach\`.`, EXIT.NEEDS_INPUT);
+    if (!numbers.length) throw new CliError(`Agent ${agentId} has no phone number, so it has no voice settings yet. Attach a phone number to it first.`, EXIT.NEEDS_INPUT);
     return (numbers[0].modelSettings ?? {}) as Record<string, unknown>;
   }
 
@@ -191,7 +191,7 @@ export class VoiceSDK {
   /** The agent's phone number with its location and a summary of its voice settings. */
   async numberDetails(agentId: string): Promise<Record<string, unknown>> {
     const [num] = await this.agentNumbers(agentId);
-    if (!num) throw new CliError(`Agent ${agentId} has no phone number. Find one with \`indemn agents numbers search\`.`, EXIT.NEEDS_INPUT);
+    if (!num) throw new CliError(`Agent ${agentId} has no phone number. Search for one and attach it first.`, EXIT.NEEDS_INPUT);
     const d = (num.additionalDetails ?? {}) as AvailableNumber;
     const m = (num.modelSettings ?? {}) as { tts?: { provider?: string; name?: string; settings?: { speed?: number } }; stt?: { provider?: string; model?: string; language?: string } };
     return {
@@ -218,13 +218,13 @@ export class VoiceSDK {
     const existing = await this.agentNumbers(agentId);
     if (existing.length) throw new CliError(`"${agent.name}" already has ${existing[0].phoneNumber}. Nothing was bought.`);
     if ((await this.orgNumbers()).some((o) => o.phoneNumber === phoneNumber)) {
-      throw new CliError(`The org already owns ${phoneNumber}; attach it with \`indemn agents numbers attach\` instead of buying it. Nothing was bought.`);
+      throw new CliError(`The org already owns ${phoneNumber}; attach it instead of buying it. Nothing was bought.`);
     }
     const digits = phoneNumber.replace(/\D/g, '');
     const offered = await this.searchNumbers({ country, tollFree: opts.tollFree, contains: digits.slice(-7), limit: 20,
       ...((country === 'US' || country === 'CA') && !opts.tollFree ? { areaCode: digits.slice(1, 4) } : {}) });
     const pick = offered.find((o) => o.phoneNumber === phoneNumber);
-    if (!pick) throw new CliError(`${phoneNumber} is no longer available. Search again with \`indemn agents numbers search\`. Nothing was bought.`);
+    if (!pick) throw new CliError(`${phoneNumber} is no longer available. Search again. Nothing was bought.`);
     await this.client.copilotPost(`/organization/:org_id/ai-studio/bots/${agentId}/configurations/voice/numbers`, {
       type: opts.tollFree ? 'toll-free' : 'local', friendlyName: pick.friendlyName ?? phoneNumber, phoneNumber, payload: pick,
     });
@@ -249,7 +249,7 @@ export class VoiceSDK {
   async voicePreview(agentId: string): Promise<{ server_url: string; room_name: string; token: string; join_url: string }> {
     // The call service finds the agent by its phone number: without one the agent never joins the room.
     const numbers = await this.agentNumbers(agentId);
-    if (!numbers.length) throw new CliError(`Agent ${agentId} has no phone number, so it cannot take a test call. Attach one with \`indemn agents numbers attach\`.`, EXIT.NEEDS_INPUT);
+    if (!numbers.length) throw new CliError(`Agent ${agentId} has no phone number, so it cannot take a test call. Attach a phone number to it first.`, EXIT.NEEDS_INPUT);
     const res = await this.client.copilotPost<{ token: string; server_url: string; room_name: string }>('/livekit/token', {
       bot_id: agentId,
       user_attributes: { 'sip.twilio.callSid': callSid(), isTestMode: 'true', ...(numbers[0].phoneNumber ? { 'sip.trunkPhoneNumber': numbers[0].phoneNumber } : {}) },

package/test/mcp/__snapshots__/tools-snapshot.test.ts.snap

@@ -111,6 +111,7 @@ exports[`MCP tool list > gives every tool a title and annotations 1`] = `
   "platform_save",
   "promote_prod_call",
   "reimport_kb_source",
+  "remove_holiday",
   "run_evaluation",
   "run_simulation",
   "save_ticket_rule",

package/test/mcp/darwin-fixes.test.ts

@@ -0,0 +1,249 @@
+// Fixes from the Darwin end-to-end run of 2026-10-01: each test fails on the code before the fix.
+import { afterEach, beforeEach, describe, expect, it } from 'vitest';
+import { on, recordFetch, type RecordedCall } from '../helpers/fetch-recorder.js';
+import { cleanEnv } from '../helpers/config-home.js';
+import { connectPair } from '../helpers/mcp-pair.js';
+import { IndemnClient } from '../../src/sdk/client.js';
+import { registerTools } from '../../src/mcp/tools.js';
+import { assetsDir } from '../../src/report/styles.js';
+import { existsSync } from 'fs';
+import { join } from 'path';
+
+const ORG = 'aaaaaaaaaaaaaaaaaaaaaaaa';
+const AGENT = 'bbbbbbbbbbbbbbbbbbbbbbbb';
+const approve = () => ({ action: 'accept' as const, content: { confirm: true } });
+const ok = (data: unknown) => ({ json: { success: true, data } });
+
+async function pair(elicit = approve) {
+  cleanEnv();
+  const client = new IndemnClient({ apiKey: `ind_dev_${'a'.repeat(64)}`, orgId: ORG, environment: 'dev' });
+  return connectPair((server) => { registerTools(server, client); }, { elicit });
+}
+const bodyOf = (calls: RecordedCall[], method: string, part: string) => calls.find((c) => c.method === method && c.url.includes(part))?.body as any;
+
+describe('Darwin E2E fixes', () => {
+  let p: Awaited<ReturnType<typeof pair>> | undefined;
+  beforeEach(() => { p = undefined; });
+  afterEach(async () => { await p?.close(); });
+
+  it('import_kb takes the import as JSON text and refuses a shape the import service would ignore', async () => {
+    const { calls } = recordFetch([
+      on('GET', '/knowledge-bases/kb1', ok({ _id: 'kb1', name: 'Roadside' })),
+      on('POST', '/knowledge-bases/kb1/import', ok({ status: 'started', message: 'file import has been initiated' })),
+    ]);
+    p = await pair();
+    const text = JSON.stringify({ type: 'file', sources: [{ url: 'https://store.test/org/1790869827796.txt', name: 'Battery jump starts.txt' }] });
+    const res = await p.call('import_kb', { kb_id: 'kb1', data: text });
+    expect(res.isError).toBe(false);
+    expect(bodyOf(calls, 'POST', '/import')).toEqual({ type: 'file', sources: [{ url: 'https://store.test/org/1790869827796.txt', name: 'Battery jump starts.txt', file_type: 'txt' }] });
+    expect(res.body.data.imported).toEqual(['Battery jump starts.txt']);
+    expect(p.questions[0].message).toContain('"Battery jump starts.txt"'); // the card names the file
+
+    const wrong = await p.call('import_kb', { kb_id: 'kb1', data: { files: [{ url: 'https://store.test/x.txt' }] } });
+    expect(wrong.isError).toBe(true);
+    expect(calls.filter((c) => c.method === 'POST' && c.url.includes('/import'))).toHaveLength(1); // nothing sent for the wrong shape
+  });
+
+  it('update_ticket adds a note to the notes instead of dropping it', async () => {
+    const { calls } = recordFetch([
+      on('GET', '/tickets/t1', ok({ _id: 't1', ticket_ref: 'TKT-1', notes: 'Old note' })),
+      on('PUT', '/tickets/t1', ok({ _id: 't1', notes: 'Old note\nChecked with towing partner.', status: 'in_progress' })),
+    ]);
+    p = await pair();
+    const res = await p.call('update_ticket', { ticket_id: 't1', status: 'in_progress', note: 'Checked with towing partner.' });
+    expect(res.isError).toBe(false);
+    expect(bodyOf(calls, 'PUT', '/tickets/t1')).toEqual({ status: 'in_progress', notes: 'Old note\nChecked with towing partner.' });
+  });
+
+  it('eval_gate_verdict judges against 80% when no threshold is given', async () => {
+    recordFetch([on('GET', '/api/v1/runs/r1', { json: { run_id: 'r1', status: 'completed', total: 3, passed: 1 } })]);
+    p = await pair();
+    const res = await p.call('eval_gate_verdict', { run_id: 'r1' });
+    expect(res.body.data).toMatchObject({ finished: true, pass: false, min_pass_rate: 0.8 });
+    expect(res.body.data.reasons.join(' ')).toContain('< 0.8');
+  });
+
+  it('add_holiday fills the type and the closed message the server requires', async () => {
+    const { calls } = recordFetch([on('PATCH', '/configurations/holidays', ok({ saved: true }))]);
+    p = await pair();
+    const res = await p.call('add_holiday', { date: '2026-12-31', name: "New Year's Eve" });
+    expect(res.isError).toBe(false);
+    expect(bodyOf(calls, 'PATCH', '/holidays').holidays[0]).toEqual({
+      name: "New Year's Eve", date: '2026-12-31', type: 'custom', holidayFallbackUtterance: "Our offices are currently closed on account of New Year's Eve.",
+    });
+    const gone = await p.call('remove_holiday', { date: '2026-12-31' });
+    expect(gone.isError).toBe(false);
+    expect(bodyOf(calls, 'DELETE', '/holidays')).toEqual({ holidays: [{ date: '2026-12-31' }] });
+  });
+
+  it('list_agent_numbers (org-wide) includes the numbers attached to agents', async () => {
+    recordFetch([
+      on('GET', '/ai-studio/v2/bots', ok([{ _id: AGENT, name: 'Rudra-voice-3', channels: ['VOICE'], connected_phone: '+12562897334' }, { _id: 'c', name: 'Web', channels: ['WEB'] }])),
+      on('GET', '/voice/configurations/numbers', ok([{ phoneNumber: '+18664857140', friendlyName: '(866) 485-7140', type: 'tollfree' }])),
+    ]);
+    p = await pair();
+    const res = await p.call('list_agent_numbers');
+    expect(res.body.data).toEqual([
+      { phone_number: '+12562897334', attached: true, agent_id: AGENT, agent_name: 'Rudra-voice-3' },
+      { phone_number: '+18664857140', attached: false, name: '(866) 485-7140', type: 'tollfree' },
+    ]);
+  });
+
+  it('create_function saves the parameters it is given', async () => {
+    const { calls } = recordFetch([
+      on('GET', `/bots/${AGENT}/functions/f1/parameters`, ok([])),
+      on('GET', `/bots/${AGENT}/functions`, ok([])),
+      on('POST', `/bots/${AGENT}/functions/f1/parameters`, ok([{ _id: 'p1', name: 'zip_code', type: 'string', is_required: true }])),
+      on('PUT', `/bots/${AGENT}/functions/f1`, ok({ _id: 'f1', name: 'Weather', type: 'rest_api' })),
+      on('POST', `/bots/${AGENT}/functions`, ok({ _id: 'f1', name: 'Weather', type: 'rest_api' })),
+    ]);
+    p = await pair();
+    const res = await p.call('create_function', {
+      agent_id: AGENT, type: 'rest_api', name: 'Weather', url: 'https://httpbin.org/get?zip={{zip_code}}', method: 'GET',
+      parameters: [{ name: 'zip_code', type: 'string', description: 'ZIP code', required: true }],
+    });
+    expect(res.isError).toBe(false);
+    expect(bodyOf(calls, 'POST', '/functions/f1/parameters')).toEqual([{ name: 'zip_code', type: 'string', description: 'ZIP code', is_required: true }]);
+    expect(res.body.data.parameters).toHaveLength(1);
+  });
+
+  it('keeps the server\'s reason on a 403 instead of "Access denied"', async () => {
+    recordFetch([on('GET', '/tickets', { status: 403, json: { success: false, error: 'Tickets are not enabled for this organization.' } })]);
+    p = await pair();
+    const res = await p.call('list_tickets');
+    expect(res.isError).toBe(true);
+    expect(res.body).toContain('Tickets are not enabled for this organization.');
+  });
+
+  it('set_business_hours replaces every day and rebuilds the hours message', async () => {
+    const { calls } = recordFetch([
+      on('GET', '/configurations', ok({ businessHoursConfig: { businessHoursEnabled: false } })),
+      on('PATCH', '/configurations/business-hours', ok({ success: true })),
+    ]);
+    p = await pair();
+    const hours = [1, 2, 3, 4, 5].map((day) => ({ day, slots: [{ start: '08:00', end: '18:00' }] }));
+    const res = await p.call('set_business_hours', { hours: JSON.stringify(hours) });
+    expect(res.isError).toBe(false);
+    const body = bodyOf(calls, 'PATCH', '/business-hours');
+    expect(body.businessHoursEnabled).toBe(false); // unchanged: not asked to enforce them
+    expect(body.businessHours).toHaveLength(7);
+    expect(body.businessHours.find((d: { day: number }) => d.day === 6).slots).toEqual([]); // Saturday closed now
+    expect(body.businessHoursUtterance).toBe("We're open Monday 8am to 6pm; Tuesday 8am to 6pm; Wednesday 8am to 6pm; Thursday 8am to 6pm; Friday 8am to 6pm.");
+    expect(p.questions[0].message).toContain('Monday 8am to 6pm');
+  });
+
+  it('evaluate_transcript accepts "agent" turns, needs an evaluator and a different replay', async () => {
+    const { calls } = recordFetch([
+      on('GET', `/ai-studio/v2/bots/${AGENT}`, ok([{ _id: AGENT, name: 'Voice Test Agent' }])),
+      on('GET', '/evaluator-configs', { json: { items: [{ config_id: 'c1' }] } }),
+      on('POST', '/api/v1/evaluate-transcript', { json: { success: true, score: 0.9 } }),
+    ]);
+    p = await pair();
+    const baseline = [{ sender: 'user', text: 'Hi' }, { sender: 'agent', text: 'Hello' }, { sender: 'system', text: 'ended' }];
+    const same = await p.call('evaluate_transcript', { agent_id: AGENT, baseline_transcript: baseline, replay_transcript: baseline });
+    expect(same.isError).toBe(true);
+    expect(String(same.body)).toContain('same conversation');
+    expect(p.questions).toHaveLength(0); // no card for something that cannot run
+
+    const res = await p.call('evaluate_transcript', { agent_id: AGENT, baseline_transcript: baseline, replay_transcript: [{ sender: 'user', text: 'Hi' }, { sender: 'agent', text: 'Hey there' }] });
+    expect(res.isError).toBe(false);
+    expect(bodyOf(calls, 'POST', '/evaluate-transcript').baseline_transcript).toEqual([{ sender: 'user', text: 'Hi' }, { sender: 'bot', text: 'Hello' }]);
+  });
+
+  it('list_kb_data leaves the chunks out unless asked', async () => {
+    recordFetch([on('GET', '/knowledge-bases/kb1/data-source', ok({
+      dataSources: [{ _id: 's1', type: 'text', question: 'Do you tow motorcycles?', answer: 'Yes', trained: true, chunks: [{ text: 'x' }], chunks_text: ['x'] }], total: 1, page: 1, pages: 1,
+    }))]);
+    p = await pair();
+    const slim = await p.call('list_kb_data', { kb_id: 'kb1' });
+    expect(slim.body.data.dataSources[0]).toEqual({ _id: 's1', type: 'text', question: 'Do you tow motorcycles?', answer: 'Yes', trained: true });
+    const full = await p.call('list_kb_data', { kb_id: 'kb1', full: true });
+    expect(full.body.data.dataSources[0].chunks).toHaveLength(1);
+    // Results are compact JSON (no pretty-printing) to save the model tokens.
+    expect((slim.raw.content as Array<{ text: string }>)[0].text.startsWith('{"context"')).toBe(true);
+  });
+
+  it('export_kb hands out a signed download link', async () => {
+    recordFetch([
+      on('POST', '/knowledge-bases/kb1/export', ok({ fileUrl: 'https://indemn-dev-attachments.s3.us-east-1.amazonaws.com/org/1790869575391.csv', fileType: 'csv' })),
+      on('GET', '/files/signed-url', (c) => (c.url.includes('filename=org%2F1790869575391.csv') || c.url.includes('filename=org/1790869575391.csv')
+        ? { json: { success: true, data: { signedUrl: 'https://indemn-dev-attachments.s3.us-east-1.amazonaws.com/org/1790869575391.csv?X-Amz-Signature=abc' } } }
+        : { status: 404, json: { success: false } })),
+    ]);
+    p = await pair();
+    const res = await p.call('export_kb', { kb_id: 'kb1' });
+    expect(res.body.data.download_url).toContain('X-Amz-Signature=abc');
+  });
+
+  it('finds the report fonts (the published package carries them under src/)', () => {
+    expect(existsSync(join(assetsDir, 'fonts', 'Barlow-Regular.ttf'))).toBe(true);
+  });
+  it('clone_agent carries the description over to the copy, which copilot answers as new_agent_id', async () => {
+    const COPY = 'cccccccccccccccccccccccc';
+    const { calls } = recordFetch([
+      on('GET', `/ai-studio/v2/bots/${AGENT}`, ok([{ _id: AGENT, name: 'Darwin QA Agent', description: 'Roadside help, short answers.' }])),
+      on('POST', '/ai-studio/v2/bots/clone', ok({ new_agent_id: COPY, new_agent_name: 'Darwin QA Clone', new_kb_ids: [] })),
+      on('PUT', `/ai-studio/bots/${COPY}`, ok({ _id: COPY, name: 'Darwin QA Clone', description: 'Roadside help, short answers.' })),
+    ]);
+    p = await pair();
+    const res = await p.call('clone_agent', { agent_id: AGENT, name: 'Darwin QA Clone' });
+    expect(res.isError).toBe(false);
+    expect(bodyOf(calls, 'PUT', `/ai-studio/bots/${COPY}`)).toEqual({ description: 'Roadside help, short answers.' });
+    expect(res.body.data).toMatchObject({ new_agent_id: COPY, description: 'Roadside help, short answers.' });
+  });
+  it('update_kb_data asks first, naming the entry and the knowledge base', async () => {
+    const { calls } = recordFetch([
+      on('GET', '/knowledge-bases/kb1/data-source', ok({ dataSources: [{ _id: 's1', question: 'How late can I buy a policy?', answer: 'Up to 14 days before.' }], total: 1, page: 1, pages: 1 })),
+      on('GET', '/knowledge-bases/kb1', ok({ _id: 'kb1', name: 'Darwin KB Test' })),
+      on('PUT', '/knowledge-bases/kb1/data-source/s1', ok({ _id: 's1', question: 'How late can I buy a policy?', answer: 'Up to 7 days before.' })),
+    ]);
+    p = await pair();
+    const res = await p.call('update_kb_data', { kb_id: 'kb1', source_id: 's1', answer: 'Up to 7 days before.' });
+    expect(res.isError).toBe(false);
+    expect(p.questions).toHaveLength(1);
+    expect(p.questions[0].message).toContain('"How late can I buy a policy?"');
+    expect(p.questions[0].message).toContain('Up to 7 days before.');
+    expect(bodyOf(calls, 'PUT', '/data-source/s1')).toEqual({ payload: { question: 'How late can I buy a policy?', answer: 'Up to 7 days before.', isManual: true } });
+  });
+  it('list_audit_logs names the person behind each entry from the member list', async () => {
+    recordFetch([
+      on('GET', '/audit-logs', ok([{ _id: 'a1', id_user: 'u1', action: 'update', resource_type: 'bot', resource_display: 'Darwin QA Agent', createdAt: '2026-10-01T10:00:00Z' }, { _id: 'a2', id_user: 'u9', action: 'create', createdAt: '2026-10-01T09:00:00Z' }])),
+      on('GET', '/projects-users', ok({ projectUsers: [{ role: 'owner', status: 'active', id_user: { _id: 'u1', email: 'ana@acme.com', firstname: 'Ana', lastname: 'Diaz' }, id_project: { name: 'default' } }] })),
+    ]);
+    p = await pair();
+    const res = await p.call('list_audit_logs', {});
+    expect(res.isError).toBe(false);
+    expect(res.body.data[0]).toMatchObject({ id_user: 'u1', user_name: 'Ana Diaz', user_email: 'ana@acme.com' });
+    expect(res.body.data[1].user_name).toBeUndefined(); // not a member any more: the id stays as it is
+  });
+
+  it('transfer_agent_owner names the new owner on its card', async () => {
+    const { calls } = recordFetch([
+      on('GET', `/ai-studio/v2/bots/${AGENT}`, ok([{ _id: AGENT, name: 'Darwin QA Agent' }])),
+      on('GET', '/projects-users', ok({ projectUsers: [{ role: 'admin', status: 'active', id_user: { _id: 'cccccccccccccccccccccccc', email: 'ana@acme.com', firstname: 'Ana', lastname: 'Diaz' }, id_project: { name: 'default' } }] })),
+    ]);
+    p = await pair(() => ({ action: 'decline' as const }));
+    await p.call('transfer_agent_owner', { agent_id: AGENT, owner_id: 'cccccccccccccccccccccccc' });
+    expect(calls.filter((c) => c.method !== 'GET')).toHaveLength(0); // declined: nothing transferred
+    expect(p.questions[0].message).toContain('"Ana Diaz"');
+    expect(p.questions[0].message).toContain('"Darwin QA Agent"');
+  });
+  it('delete_kb_data names an uploaded file on its card, and the knowledge base status hides the signed link', async () => {
+    const signed = 'https://store.test/org/1790918471122.txt?X-Amz-Signature=deadbeef';
+    recordFetch([
+      on('GET', '/knowledge-bases/kb1/data-source', ok({ dataSources: [], total: 0, page: 1, pages: 1 })),
+      on('GET', '/knowledge-bases/kb1', ok({ _id: 'kb1', name: 'Darwin KB Test', fileWebSources: [
+        { _id: 'f1', type: 'file', source: signed, status: 'success', source_details: { file_name: 'Battery jump starts.txt' } },
+        { _id: 'u1', type: 'url', source: 'https://www.indemn.ai/?ref=1', status: 'success' },
+      ] })),
+    ]);
+    p = await pair(() => ({ action: 'decline' as const }));
+    await p.call('delete_kb_data', { kb_id: 'kb1', source_id: 'f1' });
+    expect(p.questions[0].message).toContain('"Battery jump starts.txt"');
+    expect(p.questions[0].message).not.toContain('f1');
+
+    const status = await p.call('kb_scrape_status', { kb_id: 'kb1' });
+    expect(status.body.data[0]).toMatchObject({ id: 'f1', name: 'Battery jump starts.txt', source: 'https://store.test/org/1790918471122.txt' });
+    expect(status.body.data[1].source).toBe('https://www.indemn.ai/?ref=1'); // a web page keeps its address
+  });
+});

package/test/mcp/tools-snapshot.test.ts

@@ -16,7 +16,7 @@ describe('MCP tool list', () => {
       expect(typeof tool.annotations?.readOnlyHint, tool.name).toBe('boolean');
     }
     expect(tools.map((t) => t.name).sort()).toMatchSnapshot();
-    expect(tools).toHaveLength(139); // +numbers // +set_agent_transcriber // +set_org_admin_settings
+    expect(tools).toHaveLength(140); // +numbers // +set_agent_transcriber // +set_org_admin_settings // +remove_holiday
     const props = (name: string) => Object.keys((tools.find((t) => t.name === name)!.inputSchema as { properties?: object }).properties ?? {});
     for (const name of ['list_agents', 'delete_agent', 'set_prompt', 'list_org_members', 'list_channels', 'chat_with_agent']) {
       expect(props(name), name).toContain('org_id');