@audienti/cli 0.1.145 → 0.2.0-exora.10

package/bin/audienti-mcp.mjs

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+import "../cli/mcp.mjs";

package/cli/account-intake-operations.mjs

@@ -0,0 +1,28 @@
+import { z } from 'zod';
+const uuid = z.string().uuid();
+// JSON Schema counts Unicode code points. Domain validation and normalization stay
+// server-owned; z.string().max() would instead reject valid astral text by UTF-16 length.
+const bounded = maxLength => z.string().meta({ maxLength });
+const dateTime = () => z.string().meta({ format: 'date-time' });
+const identity = z.union([
+  z.object({ kind: z.literal('person'), provider: bounded(64), providerId: bounded(256) }).strict(),
+  z.object({ kind: z.literal('person'), provider: bounded(64), url: bounded(2048) }).strict(),
+]);
+const target = z.union([
+  z.object({ kind: z.literal('existing'), prospectId: uuid }).strict(),
+  z.object({ kind: z.literal('create'), identity, displayName: bounded(200).optional(), profileObservedAt: dateTime().nullable().optional() }).strict(),
+]);
+const payload = z.object({
+  direction: z.enum(['inbound', 'outbound']), conversationType: z.enum(['direct', 'public_thread']), occurredAt: dateTime(),
+  subject: bounded(512).nullable(), body: bounded(32000).nullable(),
+  participants: z.array(z.object({ role: z.enum(['sender', 'recipient', 'cc', 'bcc']), value: bounded(320) }).strict()).max(20).nullable(),
+}).strict();
+const item = z.object({ source: z.object({ provider: bounded(64), accountRef: bounded(200), itemId: bounded(256), threadId: bounded(256).nullable().optional() }).strict(), payload }).strict();
+const body = ({ workspaceId, prospectId, ...rest }) => rest;
+const root = a => `/workspaces/${a.workspaceId}/prospects/${a.prospectId}/conversation-evidence`;
+export const accountIntakeOperations = {
+  workspace_prospect_intake: { schema: z.object({ workspaceId: uuid.optional(), requestId: uuid, target, item }).strict(), method: 'POST', scoped: true, path: a => `/workspaces/${a.workspaceId}/prospects/intake`, body },
+  workspace_conversation_append: { schema: z.object({ workspaceId: uuid.optional(), prospectId: uuid, requestId: uuid, item }).strict(), method: 'POST', scoped: true, path: root, body },
+  workspace_conversation_list: { schema: z.object({ workspaceId: uuid.optional(), prospectId: uuid, cursor: uuid.optional(), limit: z.number().int().min(1).max(100).optional() }).strict(), method: 'GET', scoped: true,
+    path: a => { const q = new URLSearchParams(); for (const k of ['cursor', 'limit']) if (a[k] !== undefined) q.set(k, String(a[k])); return root(a) + (q.size ? '?' + q : ''); } },
+};

package/cli/account-intake.mjs

@@ -0,0 +1,33 @@
+import { readFileSync } from 'node:fs';
+import { callWorkspace, configuration } from './workspaces.mjs';
+export async function accountIntakeCli(args) {
+  const flags = {}, positions = [];
+  for (let i = 0; i < args.length; i++) {
+    const arg = args[i]; if (arg === '--json') continue;
+    if (!arg.startsWith('--')) { positions.push(arg); continue; }
+    const key = arg.slice(2);
+    if (!['workspace', 'profile', 'file', 'cursor', 'limit'].includes(key) || Object.hasOwn(flags, key) || !args[i+1] || args[i+1].startsWith('--')) throw Error('Unknown, repeated or incomplete intake option.');
+    flags[key] = args[++i];
+  }
+  const intake = positions[1] === 'intake';
+  const command = intake ? 'intake' : positions[2];
+  if (positions[0] !== 'prospects' || (!intake && positions[1] !== 'conversation') || !['intake', 'append', 'list'].includes(command) || positions.length !== (intake ? 2 : 4)) throw Error('Use prospects intake or prospects conversation append|list PERSON --workspace ID.');
+  const allowed = ['workspace', 'profile', ...(command === 'list' ? ['cursor', 'limit'] : ['file'])];
+  if (Object.keys(flags).some(k => !allowed.includes(k))) throw Error('Option does not apply to this intake command.');
+  let input = {};
+  if (command !== 'list') {
+    if (!flags.file) throw Error('--file INPUT.json is required.');
+    let raw; try { raw = readFileSync(flags.file); } catch { throw Error('Could not read the intake input file.'); }
+    if (raw.length > 65536) throw Error('payload_too_large');
+    try { input = JSON.parse(raw.toString('utf8')); } catch { throw Error('validation_error'); }
+    if (!input || typeof input !== 'object' || Array.isArray(input) || ['workspaceId', 'prospectId'].some(k => Object.hasOwn(input, k))) throw Error('invalid_fields');
+  }
+  input.workspaceId = flags.workspace;
+  if (!intake) input.prospectId = positions[3];
+  if (flags.cursor !== undefined) input.cursor = flags.cursor;
+  if (flags.limit !== undefined) {
+    if (!/^\d+$/.test(flags.limit)) throw Error('invalid_fields');
+    input.limit = Number(flags.limit);
+  }
+  console.log(JSON.stringify(await callWorkspace({ intake: 'workspace_prospect_intake', append: 'workspace_conversation_append', list: 'workspace_conversation_list' }[command], input, configuration(flags.profile))));
+}

package/cli/account-replies.mjs

@@ -0,0 +1,35 @@
+import { readFileSync } from 'node:fs';
+import { callWorkspace, configuration } from './workspaces.mjs';
+export async function accountRepliesCli(args) {
+  const flags = {}, positions = [];
+  for (let i = 0; i < args.length; i++) {
+    const arg = args[i];
+    if (arg === '--json') continue;
+    if (!arg.startsWith('--')) { positions.push(arg); continue; }
+    const key = arg.slice(2);
+    if (!['workspace', 'profile', 'file', 'evidence', 'cursor', 'limit', 'history-cursor', 'history-limit', 'status'].includes(key) || Object.hasOwn(flags, key) || !args[i+1] || args[i+1].startsWith('--')) throw Error('Unknown, repeated or incomplete reply option.');
+    flags[key] = args[++i];
+  }
+  const command = positions[2];
+  if (positions[0] !== 'prospects' || positions[1] !== 'replies' || !['set', 'get', 'list'].includes(command) || positions.length !== 4) throw Error('Use prospects replies set|get|list PERSON --workspace ID.');
+  const allowed = ['workspace', 'profile', ...(command === 'set' ? ['file', 'evidence'] : command === 'get' ? ['evidence', 'history-cursor', 'history-limit'] : ['cursor', 'limit', 'status'])];
+  if (Object.keys(flags).some(k => !allowed.includes(k))) throw Error('Option does not apply to this reply command.');
+  if (command !== 'list' && !flags.evidence) throw Error('--evidence EVIDENCE is required.');
+  let input = {};
+  if (command === 'set') {
+    if (!flags.file) throw Error('--file INPUT.json is required.');
+    let raw; try { raw = readFileSync(flags.file); } catch { throw Error('Could not read the reply input file.'); }
+    if (raw.length > 65536) throw Error('payload_too_large');
+    try { input = JSON.parse(raw.toString('utf8')); } catch { throw Error('validation_error'); }
+    if (!input || typeof input !== 'object' || Array.isArray(input) || ['workspaceId', 'prospectId', 'evidenceId'].some(k => Object.hasOwn(input, k))) throw Error('invalid_fields');
+  }
+  input.workspaceId = flags.workspace;
+  input.prospectId = positions[3];
+  if (flags.evidence !== undefined) input.evidenceId = flags.evidence;
+  for (const [flag, key] of [['cursor', 'cursor'], ['history-cursor', 'historyCursor'], ['status', 'status']]) if (flags[flag] !== undefined) input[key] = flags[flag];
+  for (const [flag, key] of [['limit', 'limit'], ['history-limit', 'historyLimit']]) if (flags[flag] !== undefined) {
+    if (!/^\d+$/.test(flags[flag])) throw Error('invalid_fields');
+    input[key] = Number(flags[flag]);
+  }
+  console.log(JSON.stringify(await callWorkspace(`workspace_reply_${command}`, input, configuration(flags.profile))));
+}

package/cli/account-reply-operations.mjs

@@ -0,0 +1,55 @@
+import { z } from 'zod';
+const uuid = z.string().uuid();
+const scope = { workspaceId: uuid.optional(), prospectId: uuid };
+const item = { ...scope, evidenceId: uuid };
+const status = z.enum(['needs_handling', 'handled', 'not_reply']);
+const outcome = z.enum(['response_recorded', 'closed_without_response', 'suppressed']);
+const limit = z.number().int().min(1).max(100);
+const classification = z.enum(['interested', 'question', 'later', 'out_of_office', 'stop', 'bounce', 'referral', 'wrong_person']);
+const slot = z.object({ start: z.string().describe('UTC start, ending in Z.'), end: z.string().describe('UTC end, ending in Z.'), timeZone: z.string().describe("The user's IANA time zone, for display.") }).strict();
+const draft = z.object({
+  type: z.enum(['email.send', 'linkedin.send']),
+  content: z.record(z.string(), z.unknown()).describe('Email: { subject, body }. LinkedIn: { body }.'),
+  recipient: z.record(z.string(), z.unknown()).describe('Email: { prospectId, email, contactId? }. LinkedIn: { prospectId, profileUrl, contactId? }. Bind contactId and senderAccountId, or the answer waits in Blocked.'),
+  sender: z.record(z.string(), z.unknown()).describe("{ provider, accountRef, senderAccountId? }: the assignee's mailbox or LinkedIn account the inbound came to."),
+  reason: z.string().describe('Why this answer, in one or two sentences.'),
+  slots: z.array(slot).min(1).max(6).optional().describe('Free times from your calendar tool that the answer offers. Leave out without a calendar; the answer then asks for a time.'),
+  skill: z.object({ id: z.string(), version: z.string() }).strict().optional(),
+}).strict();
+// Brief 12: what a stop, bounce or referral means, as a typed detail next to the classification it matches.
+const quote = z.string().meta({ minLength: 1, maxLength: 500 }).describe("The prospect's words, verbatim.");
+const result = z.discriminatedUnion('type', [
+  z.object({ type: z.literal('email.bounce'), address: z.string().meta({ minLength: 3, maxLength: 320 }).describe('The address that bounced.'), kind: z.enum(['hard', 'soft']).describe('hard: the address does not exist or refuses mail. soft: a full mailbox or a temporary failure.'), evidence: z.string().meta({ minLength: 1, maxLength: 2000 }).describe('The bounce message, its status code and diagnostic.') }).strict().describe('Classification bounce. A hard bounce, or a second bounce, marks the address bounced and blocks it in every campaign.'),
+  z.object({ type: z.literal('reply.stop'), scope: z.enum(['person', 'company']).describe('company only when the prospect asked to stop for their whole company.'), quote }).strict().describe('Classification stop, with status handled and outcome suppressed. The person, or everyone at the company, is suppressed for good.'),
+  z.object({ type: z.literal('reply.referral'), name: z.string().meta({ minLength: 1, maxLength: 200 }).describe('The person the prospect named.'), title: z.string().meta({ maxLength: 200 }).optional(), email: z.string().meta({ maxLength: 320 }).optional(), linkedinUrl: z.string().meta({ maxLength: 500 }).optional(), quote }).strict().describe('Classification referral, with status needs_handling and the thank-you as the draft. The named person is checked against the audience before any contact.'),
+]);
+const root = a => `/workspaces/${a.workspaceId}/prospects/${a.prospectId}`;
+const detail = a => `${root(a)}/conversation-evidence/${a.evidenceId}/reply`;
+const query = (path, a, keys) => {
+  const q = new URLSearchParams();
+  for (const key of keys) if (a[key] !== undefined) q.set(key, String(a[key]));
+  return path + (q.size ? `?${q}` : '');
+};
+export const accountReplyOperations = {
+  workspace_reply_set: {
+    schema: z.object({ ...item, requestId: uuid, expectedVersion: z.number().int().min(0).max(Number.MAX_SAFE_INTEGER), status,
+      outcome: outcome.nullable().describe("Null for needs_handling/not_reply; a handling outcome is required for handled."), reason: z.string().meta({ minLength: 1, maxLength: 2000 }).describe("Required trimmed NFC reason, 1–2000 codepoints. Interior control characters including newline and tab are rejected."), responseEvidenceId: uuid.nullable().describe("Required for response_recorded; null otherwise. Must identify matching outbound account evidence."),
+      classification: classification.optional().describe("What the reply is. Records a replied event on the person's active campaigns, except for bounce and out_of_office. An out_of_office reply snoozes the person instead; a wrong_person reply with no name given stops the sends and asks who the right person is. Someone who names the right person is a referral."),
+      returnsOn: z.string().datetime().optional().describe("Only with out_of_office: the date the person is back (UTC, ending in Z). The snooze lasts until then; with no date it follows the playbook's out-of-office rule, 7 days by default."),
+      invite: z.literal(true).optional().describe("The prospect sent a calendar invite you have not processed yet. Requires a classification; a meetings.confirm task follows."),
+      draft: draft.optional().describe("Your drafted answer. Saved as a reply plan revision the user reviews in Operator; requires status needs_handling. Never sent until approved."),
+      result: result.optional().describe("Brief 12: the typed detail for a bounce, stop or referral. Its type must match the classification."),
+      meeting: z.object({ at: z.string().datetime(), source: z.enum(['sent_invite', 'received_invite']) }).strict().optional().describe("A booked meeting: when, and whether the user's calendar sent the invite or the prospect did. Records meeting_booked."),
+      meetingState: z.enum(['requested', 'accepted', 'declined']).optional().describe("Where a meeting that is not booked yet stands after this reply: requested (a time was asked for), accepted (they agreed, no time yet) or declined. Records the matching meeting event once. Ignored once a meeting is booked.") }).strict().describe("Explicit inbound classification. needs_handling/not_reply require null outcome and responseEvidenceId. handled requires an outcome; response_recorded requires matching outbound evidence, closed_without_response an explicit closure reason, and suppressed active DNC or Reject."),
+    method: 'POST', scoped: true, path: detail,
+    body: ({ workspaceId, prospectId, evidenceId, ...rest }) => rest,
+  },
+  workspace_reply_get: {
+    schema: z.object({ ...item, historyCursor: uuid.optional(), historyLimit: limit.optional() }).strict(),
+    method: 'GET', scoped: true, path: a => query(detail(a), a, ['historyCursor', 'historyLimit']),
+  },
+  workspace_reply_list: {
+    schema: z.object({ ...scope, cursor: uuid.optional(), limit: limit.optional(), status: status.optional() }).strict(),
+    method: 'GET', scoped: true, path: a => query(`${root(a)}/replies`, a, ['cursor', 'limit', 'status']),
+  },
+};

package/cli/agents.mjs

@@ -0,0 +1,160 @@
+import { readProfile, writeProfile, validateUrl, configuration, profileFrom, WorkspaceRequestError, errorGuidance } from './workspaces.mjs';
+import { z } from 'zod';
+import {readJsonFile} from './json-file.mjs';
+
+export const agentManagementOperations = ['agent_list','agent_revoke','agent_permission','agent_capabilities_set','agent_capabilities_get','agent_inventory_get','agent_capability_sharing_get','agent_capability_sharing_set','agent_account_authorizations_get','agent_account_authorization_set'];
+// The seven capability groups and the 'approve' guardrail (#120). 'listen' is the retired name of 'research'; the server still accepts it.
+const capabilityKeys=['find','enrich','expand','research','engage','sync','notify','approve','listen'];
+const inventoryLabel=z.string().trim().min(1).max(80);
+// Capability rows (ADR 015). The server checks ids, providers and access against the catalog; the client checks the shape.
+const capabilityRow=z.object({capability:z.string().min(1).max(64),provider:z.string().min(1).max(32).optional(),via:z.string().min(1).max(140),account:z.string().min(1).max(200).optional(),access:z.enum(['read','write','send']),cost:z.enum(['owner','credits']).optional(),status:z.enum(['connected','needs_sign_in','unavailable']),limits:z.object({daily:z.number().int().min(0).max(100000).optional(),hourly:z.number().int().min(0).max(100000).optional()}).strict().optional(),identity:z.object({namespace:z.string().min(1).max(64),accountId:z.string().min(1).max(256)}).strict().optional()}).strict();
+// A LinkedIn seat's cadence, InMail and safe limits (brief 09); the server checks the bounds.
+const seatLimit=z.number().int().min(0).max(100000);
+const seatFacts={checkEverySeconds:z.number().int().min(3600).max(604800).optional(),inmail:z.object({available:z.boolean(),quotaPerMonth:seatLimit.optional(),creditsLeft:seatLimit.optional()}).strict().optional(),plan:z.enum(['free','premium_career','premium_business','premium_all_in_one','sales_navigator_core','sales_navigator_advanced','recruiter_lite']).optional(),limits:z.object({connectionRequestsPerDay:seatLimit.optional(),connectionRequestsPerWeek:seatLimit.optional(),messagesPerDay:seatLimit.optional(),inmailPerMonth:seatLimit.optional()}).strict().optional()};
+const accountEntry=z.object({capability:z.string(),tools:z.array(z.string()).min(1).max(8)}).strict();
+const accountReport=z.object({provider:z.enum(['email','linkedin']),accountRef:z.string().min(1).max(200),status:z.enum(['healthy','unavailable','disconnected']),accountIdentity:z.object({namespace:z.string(),accountId:z.string()}).strict().optional(),capabilities:z.array(accountEntry).max(16),...seatFacts}).strict();
+const capabilityReport=z.object({runtime:z.object({name:z.string().trim().min(1).max(80),model:z.string().trim().min(1).max(80).optional()}).strict(),capabilities:z.array(capabilityRow).max(64),seats:z.array(z.object({provider:z.literal('linkedin'),account:z.string().min(1).max(200),...seatFacts}).strict()).max(50).optional()}).strict();
+const eitherReport=z.union([capabilityReport,accountReport]);
+const inventoryEntry=z.object({category:z.enum(['web_search','web_browse','people_data','company_data','email','linkedin','social','crm','spreadsheet','docs','chat','calendar','tasks','files','code','scheduling','memory','other']),name:inventoryLabel,access:z.array(z.enum(['read','write','send'])).min(1).max(3),status:z.enum(['connected','needs_sign_in','unavailable']),via:inventoryLabel.optional(),tools:z.array(z.string().min(1).max(128)).max(16).optional()}).strict();
+export const agentOperations = {
+ agent_inventory_report:{description:'Older shape, kept for one release; use agent_capabilities_report instead. Reports the tools and connectors this agent already has (search, mailboxes, CRM, sheets, chat, scheduling, memory). Replaces the whole inventory. List only what is already available; never connect anything new and never include credentials. Requires an active agent profile.',schema:z.object({runtime:z.object({name:inventoryLabel,model:inventoryLabel.optional()}).strict(),entries:z.array(inventoryEntry).max(64)}).strict()},
+ agent_inventory_show:{description:'Read this agent\u2019s own reported tool inventory. Requires an active agent profile.',schema:z.object({}).strict()},
+ agent_inventory_get:{schema:z.object({id:z.string().uuid()}).strict()},
+ agent_account_authorizations_get:{schema:z.object({id:z.string().uuid()}).strict()},
+ agent_account_authorizations_show:{schema:z.object({}).strict()},
+ agent_account_authorization_set:{schema:z.object({id:z.string().uuid(),provider:z.enum(['email','linkedin']),accountRef:z.string().min(1).max(200),authorized:z.boolean()}).strict()},
+ agent_capability_sharing_get: {schema:z.object({id:z.string().uuid()}).strict()},
+ agent_capability_sharing_set: {schema:z.object({id:z.string().uuid(),provider:z.enum(['email','linkedin']),accountRef:z.string().min(1).max(200),workspaceId:z.string().uuid(),shared:z.boolean()}).strict()},
+ // One object schema for MCP clients; callAgent then requires exactly one of the two report shapes.
+ agent_capabilities_report: {description:'Getting started step 2: report what this agent can do as capability rows ({ runtime, capabilities: [{ capability, provider?, via, account?, access, cost?, status, limits?, identity? }], seats?: [{ provider: "linkedin", account, checkEverySeconds?, plan?, inmail?, limits? }] }), ids from the capability catalog. A LinkedIn account sends only when its rows carry identity { namespace: "linkedin", accountId: the member id }; a mailbox without one is matched by its address. Replaces the previous report. The old per-account shape (provider, accountRef, status, capabilities) is still accepted. Never use via "audienti" and never include credentials. Requires an active agent profile.',schema:z.object({runtime:capabilityReport.shape.runtime.optional(),provider:accountReport.shape.provider.optional(),accountRef:accountReport.shape.accountRef.optional(),status:accountReport.shape.status.optional(),accountIdentity:accountReport.shape.accountIdentity,capabilities:z.array(z.union([capabilityRow,accountEntry])).max(64),seats:capabilityReport.shape.seats,...seatFacts}).strict(),shape:eitherReport},
+ agent_capabilities_list: {description:'Read what this agent can do now: its own capability rows plus Audienti hosted rows for the workspace (when the workspace has credits and the user approved the group). Uses the profile workspace unless workspaceId is given. Requires an active agent profile.',schema:z.object({workspaceId:z.string().uuid().optional()}).strict()},
+ agent_capabilities_show: {schema:z.object({}).strict()},
+ agent_capabilities_get: {schema:z.object({id:z.string().uuid()}).strict()},
+ agent_permission: {schema:z.object({id:z.string().uuid(),scope:z.enum(['workspace:read','workspace:access'])}).strict()},
+ agent_capabilities_set: {schema:z.object({id:z.string().uuid(),capabilities:z.array(z.enum(capabilityKeys)).min(1).max(9)}).strict()},
+ agent_connect: { schema: z.object({ name: z.string().trim().min(1).max(80), capabilities: z.array(z.enum(capabilityKeys)).max(9).optional(), write: z.boolean().optional() }).strict() },
+ agent_poll: { schema: z.object({}).strict() },
+ agent_cancel: { schema: z.object({}).strict() },
+ agent_list: { schema: z.object({}).strict() },
+ agent_revoke: { schema: z.object({ id: z.string().uuid() }).strict() },
+};
+async function request(config, path, body, authenticated = false, method = body === undefined ? 'GET' : 'POST') {
+ const url = validateUrl(config.url);
+ let response;
+ try { response = await fetch(new URL(`/api/v1${path}`, url), { method, headers: { Accept: 'application/json', 'Content-Type': 'application/json', ...(authenticated ? { Authorization: `Bearer ${config.token ?? ''}` } : {}) }, ...(body === undefined ? {} : { body: JSON.stringify(body) }), redirect: 'error', signal: AbortSignal.timeout(10000) }); }
+ catch { throw new Error('Could not reach the API. Redirects are not followed.'); }
+ let result; try { result = await response.json(); } catch { throw new Error('The API returned an invalid response.'); }
+ if (!response.ok) {
+  const code = typeof result?.error?.code === 'string' && /^[a-z_]+$/.test(result.error.code) ? result.error.code : 'request_failed';
+  // A refused report says why (ADR 015), with the same safety checks as the workspace client.
+  const message = result?.error?.message;
+  const detail = response.status === 400 && (code === 'validation_error' || code === 'hosted_via_reserved') && typeof message === 'string' && message.length <= 300 && !/[\u0000-\u001f\u007f]/.test(message) && !(config.token && message.includes(config.token)) ? ` ${message}` : '';
+  throw new WorkspaceRequestError(response.status, code, `Agent request failed: ${code} (HTTP ${response.status}).${detail}`, undefined, undefined, undefined, errorGuidance(result?.error, config.token));
+ }
+ if (!result || !Object.hasOwn(result, 'data')) throw new Error('The API returned an invalid response.');
+ return result.data;
+}
+export async function callAgent(name, args, config, profilePath) {
+ const input = agentOperations[name]?.schema.safeParse(args);
+ if (!input?.success || (agentOperations[name].shape && !agentOperations[name].shape.safeParse(args).success)) throw new Error('Invalid agent command or arguments.');
+ if (agentManagementOperations.includes(name) && (config.profile?.agent || config.profile?.pendingAgent)) throw new Error('Use a separate user management profile with an agents:manage token.');
+ if(name==='agent_account_authorizations_get') return {data:await request(config,`/agents/${input.data.id}/account-authorizations`,undefined,true)};
+ if(name==='agent_account_authorization_set') {const {id,...body}=input.data;return {data:await request(config,`/agents/${id}/account-authorizations`,body,true)};}
+ if(name==='agent_account_authorizations_show') {
+  if(!config.profile?.agent || !/^agt_/.test(config.token ?? '')) throw new Error('Use an active agent profile for authorization self readback.');
+  return {data:await request(config,'/agent-account-authorizations',undefined,true)};
+ }
+ if (name === 'agent_capability_sharing_get') return {data:await request(config,`/agents/${input.data.id}/capability-sharing`,undefined,true)};
+ if (name === 'agent_capability_sharing_set') {const {id,...body}=input.data;return {data:await request(config,`/agents/${id}/capability-sharing`,body,true)};}
+ if (name === 'agent_inventory_get') return {data:await request(config,`/agents/${input.data.id}/inventory`,undefined,true)};
+ if (name === 'agent_inventory_show' || name === 'agent_inventory_report') {
+  if (!config.profile?.agent || !/^agt_/.test(config.token ?? '')) throw new Error('Use an active agent profile for tool inventory report and self readback.');
+  return {data:await request(config,'/agent-inventory',name==='agent_inventory_report' ? input.data : undefined,true,name==='agent_inventory_report' ? 'PUT' : 'GET')};
+ }
+ if (name === 'agent_capabilities_get') return {data:await request(config,`/agents/${input.data.id}/capabilities`,undefined,true)};
+ if (name === 'agent_capabilities_list') {
+  if (!config.profile?.agent || !/^agt_/.test(config.token ?? '')) throw new Error('Use an active agent profile for capability check-in and self readback.');
+  const workspaceId = input.data.workspaceId ?? config.workspaceId;
+  return {data:await request(config,`/agent-capabilities${workspaceId ? `?workspaceId=${encodeURIComponent(workspaceId)}` : ''}`,undefined,true)};
+ }
+ if (name === 'agent_capabilities_show' || name === 'agent_capabilities_report') {
+  if (!config.profile?.agent || !/^agt_/.test(config.token ?? '')) throw new Error('Use an active agent profile for capability check-in and self readback.');
+  return {data:await request(config,'/agent-capabilities',name==='agent_capabilities_report' ? input.data : undefined,true,name==='agent_capabilities_report' ? 'PUT' : 'GET')};
+ }
+ if (name === 'agent_list') return { data: await request(config, '/agents', undefined, true) };
+ if (name === 'agent_permission') return {data:await request(config, `/agents/${input.data.id}/permission`, {scope:input.data.scope}, true)};
+ if (name === 'agent_capabilities_set') return {data:await request(config, `/agents/${input.data.id}/approved-capabilities`, {capabilities:input.data.capabilities}, true)};
+ if (name === 'agent_revoke') return { data: await request(config, `/agents/${input.data.id}/revoke`, {}, true) };
+ if (!profilePath) throw new Error('Use a separate private --profile PATH for each agent.');
+ const profile = readProfile(profilePath);
+ const url = validateUrl(config.url).toString().replace(/\/$/, '');
+ if (name === 'agent_connect') {
+  if (profile.pendingAgent || profile.agent) throw new Error('This profile already has an agent connection. Poll/cancel the pending connection or choose a new profile.');
+  if (Object.keys(profile.tokens ?? {}).length) throw new Error('Use a new agent profile without user API tokens.');
+  // Prove that private persistence is possible before asking the server for secrets.
+  writeProfile(profilePath, { ...profile, url });
+  const data = await request(config, '/agent-connections', input.data);
+  if (!/^adc_[A-Za-z0-9_-]{43}$/.test(data.secret) || !/^agt_[A-Za-z0-9_-]{43}$/.test(data.credential) || !z.string().uuid().safeParse(data.id).success || !/^[A-F0-9]{4}-[A-F0-9]{4}$/.test(data.code)) throw new Error('Invalid connection response.');
+  writeProfile(profilePath, { ...profile, url, pendingAgent: { id: data.id, secret: data.secret, credential: data.credential, expiresAt: data.expiresAt } });
+  config.token = undefined; config.workspaceId = undefined;
+  return { data: { status: 'pending', id: data.id, code: data.code, approvalUrl: data.approvalUrl, approvalPath: `/agents/connect/${data.id}`, expiresAt: data.expiresAt, interval: 5, instructions: 'Give your user the approval URL and the code, then run agent poll with this profile every interval seconds, in this same turn and without waiting for them to reply, until the status is active, denied or expired.' } };
+ }
+ const secret = profile.pendingAgent?.secret ?? profile.connectionSecret;
+ if (!secret) throw new Error('No connection in this profile.');
+ if (url !== profile.url) throw new Error('The pending connection belongs to a different API host.');
+ const data = await request(config, name === 'agent_poll' ? '/agent-connections/poll' : '/agent-connections/cancel', { secret });
+ if (data.status === 'active') {
+  const credential = profile.pendingAgent?.credential ?? profile.tokens?.['workspace:read'];
+  writeProfile(profilePath, { ...profile, agent: data.agent, connectionSecret: secret, pendingAgent: undefined, tokens: { 'workspace:read': credential } });
+  config.token = credential;
+ } else if (['denied', 'expired'].includes(data.status)) { writeProfile(profilePath, { ...profile, pendingAgent: undefined, agent: undefined, connectionSecret: undefined, tokens: undefined, workspaceId: undefined }); config.token = undefined; config.workspaceId = undefined; }
+ return { data };
+}
+export async function agentCli(args) {
+ const flags = {}; const positions = []; let json = false;
+ for (let i = 0; i < args.length; i++) {
+  if (args[i] === '--json') { json = true; continue; }
+  if (args[i].startsWith('--')) {
+   const key = args[i].slice(2);
+   if (key === 'write') { flags.write = true; continue; }
+   if (!['profile', 'name','capabilities','scope','file','id','provider','account','workspace','shared','authorized','set'].includes(key) || !args[i+1] || args[i+1].startsWith('--')) throw new Error('Unknown or incomplete agent option.');
+   flags[key] = args[++i];
+  } else positions.push(args[i]);
+ }
+ let name = `agent_${positions[1]}`;
+ let input = positions[1] === 'permission' ? {id:positions[2],scope:flags.scope} : positions[1] === 'connect' ? { name: flags.name, ...(flags.write ? { write: true } : {}), ...(flags.capabilities ? { capabilities: flags.capabilities.split(',').map(key => key.trim()).filter(Boolean) } : {}) } : positions[1] === 'revoke' ? { id: positions[2] } : {};
+ if(positions[1]==='accounts') {
+  if(positions[2]==='show') {name=flags.id ? 'agent_account_authorizations_get' : 'agent_account_authorizations_show';input=flags.id ? {id:flags.id} : {};}
+  else if(positions[2]==='authorize' && ['true','false'].includes(flags.authorized)) {name='agent_account_authorization_set';input={id:flags.id,provider:flags.provider,accountRef:flags.account,authorized:flags.authorized==='true'};}
+  else throw new Error('Use agent accounts show [--id ID] or authorize --id ID --provider PROVIDER --account REF --authorized true|false.');
+ }
+ if (positions[1] === 'inventory') {
+  if (positions[2] === 'report' && flags.file && !flags.id) {name='agent_inventory_report';input=readJsonFile(flags.file,32768,'Inventory file');console.error('Notice: agent capabilities report --file PATH is the current command; inventory reports are translated into capability rows.');}
+  else if (positions[2] === 'show' && !flags.file) {name=flags.id ? 'agent_inventory_get' : 'agent_inventory_show';input=flags.id ? {id:flags.id} : {};}
+  else throw new Error('Use agent inventory report --file PATH or show [--id ID].');
+ }
+ if (positions[1] === 'capabilities') {
+  if (flags.set !== undefined && positions[2]) {name='agent_capabilities_set';input={id:positions[2],capabilities:flags.set.split(',').map(key => key.trim()).filter(Boolean)};}
+  else  if (positions[2] === 'sharing' && flags.id) {name='agent_capability_sharing_get';input={id:flags.id};}
+  else if (positions[2] === 'share' && flags.id && ['true','false'].includes(flags.shared)) {name='agent_capability_sharing_set';input={id:flags.id,provider:flags.provider,accountRef:flags.account,workspaceId:flags.workspace,shared:flags.shared==='true'};}
+  else if (positions[2] === 'report'  && flags.file && !flags.id) {name='agent_capabilities_report';input=readCapabilityFile(flags.file);}
+  else if (positions[2] === 'show' && !flags.file) {name=flags.id ? 'agent_capabilities_get' : 'agent_capabilities_show';input=flags.id ? {id:flags.id} : {};}
+  else if (positions[2] === undefined && !flags.file && !flags.id) {name='agent_capabilities_list';input=flags.workspace ? {workspaceId:flags.workspace} : {};}
+  else throw new Error('Use agent capabilities [--workspace ID] [--json], report --file PATH or show [--id ID].');
+ }
+ const result = await callAgent(name, input, configuration(flags.profile, agentManagementOperations.includes(name) ? 'agents:manage' : 'workspace:access'), profileFrom(flags.profile));
+ console.log(name === 'agent_capabilities_list' && !json ? capabilityText(result.data) : JSON.stringify(result));
+}
+
+/** Plain text for agent capabilities: own rows that work now, then rows that work with Audienti hosted tools. */
+export function capabilityText(data) {
+ const rows = Array.isArray(data?.effective) ? data.effective : [];
+ const line = row => `  ${row.capability}${row.provider ? ` (${row.provider})` : ''} via ${row.via}${row.account ? `, account ${row.account}` : ''}${row.status === 'connected' ? '' : `, ${row.status.replaceAll('_', ' ')}`}${row.hostedTool ? `, ${row.hostedTool.id}${row.hostedTool.credits === undefined ? '' : ` about ${row.hostedTool.credits} credits a call`}` : ''}${row.stale ? ', stale' : ''}`;
+ const own = rows.filter(row => row.via !== 'audienti'), hosted = rows.filter(row => row.via === 'audienti');
+ return [
+  `Works now${data?.stale ? ' (report is over seven days old; report again)' : ''}:`, ...(own.length ? own.map(line) : ['  nothing reported yet: audienti agent capabilities report --file CAPABILITIES.json']),
+  'Works with Audienti tools:', ...(hosted.length ? hosted.map(line) : [data?.workspaceId ? '  none: the workspace has no credits or the user has not approved these groups' : '  pick a workspace to see them: --workspace ID']),
+ ].join('\n');
+}
+
+function readCapabilityFile(path) {return readJsonFile(path,32768,'Capability file');}

package/cli/assignment-operations.mjs

@@ -0,0 +1,218 @@
+import { z } from "zod";
+const uuid = z.string().uuid();
+const workspace = { workspaceId: uuid.optional() };
+const request = { ...workspace, requestId: uuid };
+const version = z.number().int().nonnegative();
+const page = z
+  .object({
+    cursor: uuid.optional(),
+    limit: z.number().int().min(1).max(100).optional(),
+  })
+  .strict();
+const location = z
+  .object({
+    key: z.string().nullable().optional(),
+    providerId: z.string().nullable().optional(),
+    name: z.string(),
+  })
+  .strict();
+const criteria = z
+  .object({
+    campaignIds: z.array(uuid).max(50).optional(),
+    companyLocations: z.array(location).max(50).optional(),
+    personLocations: z.array(location).max(50).optional(),
+    personTitles: z.array(z.string()).max(50).optional(),
+  })
+  .strict();
+const rule = z
+  .object({
+    id: uuid,
+    name: z.string(),
+    enabled: z.boolean(),
+    assigneeUserId: uuid,
+    criteria,
+  })
+  .strict();
+const root = (a) => `/workspaces/${a.workspaceId}`;
+const person = (a) => `${root(a)}/prospects/${a.prospectId}`;
+const omit = (a, keys) =>
+  Object.fromEntries(Object.entries(a).filter(([k]) => !keys.includes(k)));
+const body = (a) => omit(a, ["workspaceId", "prospectId"]);
+function qs(a, keys = ["workspaceId", "prospectId", "campaignId"]) {
+  const values = {};
+  for (const [k, v] of Object.entries(omit(a, keys))) {
+    if (v === undefined) continue;
+    if (typeof v === "object" && v !== null)
+      for (const [child, value] of Object.entries(v))
+        values[k + child[0].toUpperCase() + child.slice(1)] = String(value);
+    else values[k] = String(v);
+  }
+  return new URLSearchParams(values).toString();
+}
+export const assignmentOperations = {
+  workspace_prospect_assignments: {
+    schema: z
+      .object({
+        ...workspace,
+        assignedToUserId: uuid.optional(),
+        unassigned: z.boolean().optional(),
+        campaignId: uuid.optional(),
+        search: z.string().optional(),
+        cursor: uuid.optional(),
+        limit: z.number().int().min(1).max(100).optional(),
+      })
+      .strict(),
+    method: "GET",
+    path: (a) => root(a) + "/assignments?" + qs(a, ["workspaceId"]),
+    scoped: true,
+  },
+  workspace_prospect_assignment: {
+    schema: z
+      .object({
+        ...workspace,
+        prospectId: uuid,
+        history: page.optional(),
+        participations: page.optional(),
+        participationEvents: page.optional(),
+        routingReports: page.optional(),
+      })
+      .strict(),
+    method: "GET",
+    path: (a) => person(a) + "/assignment?" + qs(a),
+    scoped: true,
+  },
+  workspace_prospect_campaign_fit: {
+    schema: z
+      .object({
+        ...workspace,
+        prospectId: uuid,
+        campaignId: uuid,
+        overrides: page.optional(),
+      })
+      .strict(),
+    method: "GET",
+    path: (a) => person(a) + `/campaigns/${a.campaignId}/fit?` + qs(a),
+    scoped: true,
+  },
+  workspace_prospect_assignment_set: {
+    schema: z
+      .object({
+        ...request,
+        prospectId: uuid,
+        assigneeUserId: uuid.nullable(),
+        expectedAssignmentVersion: version,
+        reason: z.string(),
+      })
+      .strict(),
+    method: "POST",
+    path: (a) => person(a) + "/assignment",
+    body,
+    scoped: true,
+  },
+  workspace_routing_rules_get: {
+    schema: z.object(workspace).strict(),
+    method: "GET",
+    path: (a) => root(a) + "/routing-rules",
+    scoped: true,
+  },
+  workspace_routing_rules_replace: {
+    schema: z
+      .object({
+        ...request,
+        expectedRulesVersion: version,
+        rules: z.array(rule).max(100),
+      })
+      .strict(),
+    method: "PUT",
+    path: (a) => root(a) + "/routing-rules",
+    body: (a) => omit(a, ["workspaceId"]),
+    scoped: true,
+  },
+  workspace_routing_apply: {
+    schema: z
+      .object({
+        ...request,
+        prospectId: uuid,
+        campaignId: uuid.optional(),
+        expectedAssignmentVersion: version,
+        rulesVersion: version,
+        outcomes: z
+          .array(
+            z
+              .object({
+                ruleId: uuid,
+                result: z.enum(["match", "no_match", "unknown"]),
+                reason: z.string().optional(),
+              })
+              .strict(),
+          )
+          .max(100),
+        skill: z.object({ id: z.string(), version: z.string() }).strict(),
+      })
+      .strict(),
+    method: "POST",
+    path: (a) => person(a) + "/routing",
+    body,
+    scoped: true,
+  },
+  workspace_fit_override_set: {
+    schema: z
+      .object({
+        ...request,
+        prospectId: uuid,
+        campaignId: uuid,
+        campaignRevision: z.number().int().positive(),
+        expectedOverrideVersion: version,
+        action: z.enum(["set", "clear"]),
+        value: z.enum(["high", "moderate", "low", "no_fit"]).optional(),
+        reason: z.string(),
+      })
+      .strict(),
+    method: "POST",
+    path: (a) => person(a) + "/fit-override",
+    body,
+    scoped: true,
+  },
+  workspace_prospect_move: {
+    schema: z
+      .object({
+        ...request,
+        prospectId: uuid,
+        expectedSourceParticipationId: uuid,
+        sourceCampaignId: uuid,
+        destinationCampaignId: uuid,
+        destinationCampaignRevision: z.number().int().positive(),
+        destinationQualificationReceiptId: uuid,
+        expectedAssignmentVersion: version,
+        reason: z.string(),
+      })
+      .strict(),
+    method: "POST",
+    path: (a) => person(a) + "/move",
+    body,
+    scoped: true,
+  },
+  workspace_member_remove: {
+    schema: z
+      .object({
+        ...request,
+        expectedMembershipId: uuid,
+        memberUserId: uuid,
+        reason: z.string(),
+      })
+      .strict(),
+    method: "POST",
+    path: (a) => root(a) + "/members/remove",
+    body: (a) => omit(a, ["workspaceId"]),
+    scoped: true,
+  },
+  workspace_leave: {
+    schema: z
+      .object({ ...request, expectedMembershipId: uuid, reason: z.string() })
+      .strict(),
+    method: "POST",
+    path: (a) => root(a) + "/members/leave",
+    body: (a) => omit(a, ["workspaceId"]),
+    scoped: true,
+  },
+};