@indemn/cli 1.7.4 → 1.7.6

package/test/sdk/skills.test.ts

@@ -13,6 +13,7 @@ import { registerTools } from '../../src/mcp/tools.js';
 
 const ORG = 'aaaaaaaaaaaaaaaaaaaaaaaa';
 const AGENT = '111111111111111111111111';
+const agentFound = on('GET', `/v2/bots/${AGENT}`, { json: { success: true, data: [{ _id: AGENT, name: 'Bot' }] } });  // named in approvals
 
 describe('skill names', () => {
   it('reduces spelling variants of the FAQ retriever to one key, like copilot', () => {
@@ -64,9 +65,9 @@ describe('skills SDK and tools', () => {
       on('GET', `/bots/${AGENT}/functions`, { json: { success: true, data: [{ _id: 'f1', type: 'rest_api',
         configurationSchema: { endpoint: 'https://x/date', method: 'POST', payload: '{"date_str":"{{event_date}}","n":"{{other}}"}', authorization: { type: 'no-auth' } } }] } }),
       on('POST', '/functions/f1/test-rest-api', { json: { statusCode: 200, response: { valid: true } } }),
-    ]);
+     agentFound]);
     const pair = await connectPair((server) => { registerTools(server, new IndemnClient()); });
-    await pair.call('test_function', { agent_id: AGENT, function_id: 'f1', params: { event_date: '2027-06-12' } });
+    await pair.call('test_function', { confirm: true, agent_id: AGENT, function_id: 'f1', params: { event_date: '2027-06-12' } });
     expect(calls.find((c) => c.url.endsWith('/test-rest-api'))?.body).toEqual({ endpoint: 'https://x/date', method: 'POST',
       payload: '{"date_str":"2027-06-12","n":"{{other}}"}', authorization: { type: 'no-auth' } });
     await pair.close();
@@ -78,7 +79,7 @@ describe('skills SDK and tools', () => {
     const { calls } = recordFetch([
       on('GET', '/functions/f1/parameters', { json: { success: true, data: [saved] } }),
       on('POST', '/functions/f1/parameters', { json: { success: true, data: [saved] } }),
-    ]);
+     agentFound]);
     const sdk = new FunctionsSDK(new IndemnClient());
     await sdk.addParameter(AGENT, 'f1', { name: 'coverage', type: 'string', required: true, allowedValues: ['Liability', 'Both'] });
     const posts = () => calls.filter((c) => c.method === 'POST').map((c) => (c.body as unknown[])[0]);
@@ -100,7 +101,7 @@ describe('skills SDK and tools', () => {
   });
 
   it('bulk-creates with the body copilot expects', async () => {
-    const { calls } = recordFetch([on('POST', '/functions/bulk-create', { json: { success: true, data: [{ _id: 'f1' }] } })]);
+    const { calls } = recordFetch([on('POST', '/functions/bulk-create', { json: { success: true, data: [{ _id: 'f1' }] } }), agentFound]);
     await new FunctionsSDK(new IndemnClient()).bulkCreate(AGENT, [{ type: 'rest_api', name: 'quote', description: 'q' }]);
     expect(calls[0].body).toEqual({ functions: [{ type: 'rest_api', name: 'quote', description: 'q' }] });
   });
@@ -116,31 +117,32 @@ describe('skills SDK and tools', () => {
       on('GET', `/bots/${AGENT}/functions`, { json: { success: true, data: [{ _id: 'f1', type: 'rest_api', description: 'Checks a date',
         configurationSchema: { endpoint: 'https://x/date', method: 'POST', authorization: { type: 'bearer-token', token: 't' } } }] } }),
       on('PUT', `/bots/${AGENT}/functions/f1`, { json: { success: true, data: { _id: 'f1' } } }),
-    ]);
+      on('GET', `/v1-agents/${AGENT}`, { json: { id: AGENT, lifecycle: 'prototype' } }),  // not live: no approval asked
+    , agentFound]);
     const pair = await connectPair((server) => { registerTools(server, new IndemnClient()); });
-    await pair.call('create_function', { agent_id: AGENT, type: 'rest_api', name: 'validate_date', description: 'Checks a date', url: 'https://x/date', method: 'post', payload: { date_str: '{{event_date}}' } });
+    await pair.call('create_function', { confirm: true, agent_id: AGENT, type: 'rest_api', name: 'validate_date', description: 'Checks a date', url: 'https://x/date', method: 'post', payload: { date_str: '{{event_date}}' } });
     expect(calls.find((c) => c.method === 'POST')?.body).toEqual({ type: 'rest_api', name: 'validate_date', description: 'Checks a date' });
     expect(calls.filter((c) => c.method === 'PUT')[0].body).toEqual({ type: 'rest_api', description: 'Checks a date',
       configurationSchema: { endpoint: 'https://x/date', method: 'POST', payload: '{"date_str":"{{event_date}}"}', authorization: { type: 'no-auth' }, craftResponse: true } });
     await pair.call('update_function', { agent_id: AGENT, function_id: 'f1', response_field: 'data.valid' });
     expect(calls.filter((c) => c.method === 'PUT')[1].body).toEqual({ type: 'rest_api', description: 'Checks a date',
       configurationSchema: { endpoint: 'https://x/date', method: 'POST', authorization: { type: 'bearer-token', token: 't' }, responseField: 'data.valid' } });
-    await pair.call('create_function', { agent_id: AGENT, type: 'rest_api', name: 'said', url: 'https://x/a', method: 'GET', output_instructions: 'Your quote is {{response.total}}.' });
+    await pair.call('create_function', { confirm: true, agent_id: AGENT, type: 'rest_api', name: 'said', url: 'https://x/a', method: 'GET', output_instructions: 'Your quote is {{response.total}}.' });
     expect(calls.filter((c) => c.method === 'PUT')[2].body.configurationSchema).toMatchObject({ outputInstructions: 'Your quote is {{response.total}}.' });
     expect(calls.filter((c) => c.method === 'PUT')[2].body.configurationSchema.craftResponse).toBeUndefined();
-    const missing = await pair.call('create_function', { agent_id: AGENT, type: 'rest_api', name: 'no_url' });
+    const missing = await pair.call('create_function', { confirm: true, agent_id: AGENT, type: 'rest_api', name: 'no_url' });
     expect(missing.isError).toBe(true);
     await pair.close();
-  });
+  }, 30_000);  // four skill changes, each previewed before it is confirmed
 
   it('MCP skill tools take typed REST auth and JSON text for free-form objects (as Gemini sends them)', async () => {
     const NEW = 'fn-new';
     const { calls } = recordFetch([
       on('POST', `/ai-studio/bots/${AGENT}/functions`, { json: { success: true, data: { _id: NEW, type: 'rest_api', name: 'get_quote' } } }),
       on('PUT', `/functions/${NEW}`, { json: { success: true, data: {} } }),
-    ]);
+     agentFound]);
     const pair = await connectPair((server) => { registerTools(server, new IndemnClient()); });
-    const res = await pair.call('create_function', {
+    const res = await pair.call('create_function', { confirm: true,
       agent_id: AGENT, type: 'rest_api', name: 'get_quote', url: 'https://api.example.com/quote', method: 'POST',
       auth_type: 'bearer-token', auth_token: 'abc', auth_key: '', auth_username: '',
       payload: '{"event_date": "{{event_date}}", "guests": {{guests}}}',
@@ -160,9 +162,9 @@ describe('skills SDK and tools', () => {
       on('GET', `/v2/bots/${AGENT}`, { json: [{ _id: AGENT, name: 'Bot' }] }),
       on('GET', `/ai-studio/bots/${AGENT}/functions`, { json: { success: true, data: [existing] } }),
       on('DELETE', '/functions/f1', { json: { success: true } }),
-    ]);
+     agentFound]);
     const pair = await connectPair((server) => { registerTools(server, new IndemnClient()); });
-    const dup = await pair.call('create_function', { agent_id: AGENT, type: 'rest_api', name: 'Get_Quote', url: 'https://y', method: 'POST' });
+    const dup = await pair.call('create_function', { confirm: true, agent_id: AGENT, type: 'rest_api', name: 'Get_Quote', url: 'https://y', method: 'POST' });
     expect(dup.isError).toBe(true);
     expect(String(dup.body)).toMatch(/already has a skill named "Get_Quote" \(function_id f1\)\. Change it with update_function/);
     expect(calls.some((c) => c.method === 'POST')).toBe(false);
@@ -180,20 +182,20 @@ describe('skills SDK and tools', () => {
       on('POST', `/ai-studio/bots/${AGENT}/functions`, { json: { success: true, data: { _id: 'fx', type: 'rest_api', name: 'quote' } } }),
       on('PUT', '/functions/fx', { status: 500, json: { error: 'Payload must be a valid JSON string.' } }),
       on('DELETE', '/functions/fx', { json: { success: true } }),
-    ]);
+     agentFound]);
     const pair = await connectPair((server) => { registerTools(server, new IndemnClient()); });
-    const bad = await pair.call('create_function', { agent_id: AGENT, type: 'rest_api', name: 'quote', url: 'https://x', method: 'POST', payload: '{"a": 1,}' });
+    const bad = await pair.call('create_function', { confirm: true, agent_id: AGENT, type: 'rest_api', name: 'quote', url: 'https://x', method: 'POST', payload: '{"a": 1,}' });
     expect(bad.isError).toBe(true);
     expect(String(bad.body)).toMatch(/request body is not valid JSON.*Nothing was saved/);
     expect(calls.some((c) => c.method === 'POST')).toBe(false);
-    const refused = await pair.call('create_function', { agent_id: AGENT, type: 'rest_api', name: 'quote', url: 'https://x', method: 'POST' });
+    const refused = await pair.call('create_function', { confirm: true, agent_id: AGENT, type: 'rest_api', name: 'quote', url: 'https://x', method: 'POST' });
     expect(String(refused.body)).toMatch(/Nothing was saved: the skill's configuration was refused/);
     expect(calls.filter((c) => c.method === 'DELETE').map((c) => c.url)).toEqual([expect.stringContaining('/functions/fx')]);
     await pair.close();
   });
 
   it('MCP import_functions warns that everything is replaced and waits for confirmation', async () => {
-    const { calls } = recordFetch([on('GET', `/v2/bots/${AGENT}`, { json: [{ _id: AGENT, name: 'Bot' }] })]);
+    const { calls } = recordFetch([on('GET', `/v2/bots/${AGENT}`, { json: [{ _id: AGENT, name: 'Bot' }] }), agentFound]);
     const pair = await connectPair((server) => { registerTools(server, new IndemnClient()); });
     const res = await pair.call('import_functions', { agent_id: AGENT, url: 'https://x/skills.json' });
     expect(res.body).toMatchObject({ dry_run: true });
@@ -212,7 +214,7 @@ describe('skills SDK and tools', () => {
       on('PUT', `/bots/${AGENT}/functions/f1`, { json: { success: true, data: { _id: 'f1' } } }),
       on('PUT', `/bots/${AGENT}`, { json: { success: true, data: { _id: AGENT } } }),
       on('PATCH', `/bots/${AGENT}`, { json: { success: true, data: { _id: AGENT } } }),
-    ]);
+     agentFound]);
     const pair = await connectPair((server) => { registerTools(server, new IndemnClient()); });
     const writes = () => calls.filter((c) => c.method === 'PUT' || c.method === 'PATCH').length;
 

package/test/sdk/test-chat.test.ts

@@ -70,6 +70,35 @@ describe('CLI chats are always test conversations', () => {
     expect(mw.userMessages).toHaveLength(0);
   });
 
+  it("never sends to, or ends, a conversation named by the caller that is a customer's live one", async () => {
+    recordFetch([agentOk, stored({ isTestMode: false })]);
+    await expect(openTestChat(new IndemnClient(), AGENT, { sessionId: 'cust-1' })).rejects.toThrow(/stored as a live conversation/);
+    await new Promise((r) => setTimeout(r, 50));
+    expect(mw.sessionRequests).toHaveLength(0);  // checked before connecting
+    expect(mw.closed).toHaveLength(0);
+  });
+
+  it('sends nothing until the greeting has finished', async () => {
+    const send = vi.fn();
+    const chat = { resumed: false, transcript: [] as string[], isReceiving: () => false, session: { send } } as unknown as Parameters<typeof exchange>[0];
+    await expect(exchange(chat, 'hi', { greetingWaitMs: 30 })).rejects.toThrow(/greeting.*nothing was sent/i);
+    expect(send).not.toHaveBeenCalled();
+  });
+
+  it('a reply that never finishes streaming still returns by the deadline', async () => {
+    const transcript = ['Hello there'];
+    let checks = 0;
+    const chat = {
+      resumed: true, transcript,
+      isReceiving: () => ++checks > 1,  // the reply arrives, then a stream starts that never ends
+      session: { send: () => { transcript.push('echo: hi'); } },
+    } as unknown as Parameters<typeof exchange>[0];
+    const started = Date.now();
+    const out = await exchange(chat, 'hi', { timeoutMs: 300, settleMs: 20 });
+    expect(out.response).toBe('echo: hi');
+    expect(Date.now() - started).toBeLessThan(2_000);
+  });
+
   it('waits for the conversation to appear, then accepts it', async () => {
     let tries = 0;
     recordFetch([on('GET', '/requests/', () => (++tries < 3 ? { status: 404, text: 'nope' } : { json: { request_id: 's', isTestMode: true, id_organization: ORG } }))]);