@ziggs-ai/agent-sdk 0.1.3 → 0.1.5

package/src/server/ziggspay/ZiggsPayClient.ts

@@ -0,0 +1,193 @@
+import 'dotenv/config';
+
+function getDefaultBaseUrl(): string {
+  return process.env.BACKEND_URL || process.env.ZIGGS_BACKEND_URL || 'http://localhost:3000';
+}
+
+function randomIdempotencyKey(prefix = 'op'): string {
+  return `${prefix}_${Date.now().toString(36)}_${Math.random().toString(36).slice(2, 10)}`;
+}
+
+function parseError(text: string, fallback: string): string {
+  if (!text) return fallback;
+  try {
+    const parsed = JSON.parse(text) as Record<string, unknown>;
+    return (parsed['error'] as string) || (parsed['message'] as string) || text;
+  } catch { return text; }
+}
+
+interface PayError extends Error { status?: number; body?: string; }
+
+export interface ZiggsPayClientOptions {
+  operatorKey: string;
+  actAsAgentId?: string;
+  baseUrl?: string;
+}
+
+export class ZiggsPayClient {
+  private operatorKey: string;
+  private actAsAgentId: string | null;
+  private baseUrl: string;
+
+  constructor({ operatorKey, actAsAgentId, baseUrl }: ZiggsPayClientOptions) {
+    if (!operatorKey || typeof operatorKey !== 'string') throw new Error('ZiggsPayClient requires an operatorKey');
+    this.operatorKey = operatorKey;
+    this.actAsAgentId = actAsAgentId || null;
+    this.baseUrl = baseUrl || getDefaultBaseUrl();
+  }
+
+  async balance(): Promise<{ walletId: string | null; currency: string; balance: number; availableBalance: number }> {
+    const w = await this._get('/payments/wallet') as Record<string, unknown>;
+    const wallet = w['wallet'] as Record<string, unknown> | undefined;
+    return { walletId: (wallet?.['walletId'] as string) || null, currency: (wallet?.['currency'] as string) || 'pez', balance: (w['balance'] as number) ?? 0, availableBalance: (w['availableBalance'] as number) ?? 0 };
+  }
+
+  async resolve({ userId, agentId }: { userId?: string; agentId?: string } = {}): Promise<unknown> {
+    if (!userId && !agentId) throw new Error('resolve: provide userId or agentId');
+    const params = new URLSearchParams();
+    if (userId) params.set('userId', userId);
+    if (agentId) params.set('agentId', agentId);
+    const res = await this._get(`/payments/wallets/resolve?${params}`) as Record<string, unknown>;
+    return res['wallet'] || null;
+  }
+
+  async transfer({ to, amount, idempotencyKey, description, paymentGrantId }: { to: string; amount: number; idempotencyKey?: string; description?: string; paymentGrantId?: string }): Promise<unknown> {
+    if (!to) throw new Error('transfer: `to` is required');
+    if (!(Number.isInteger(amount) && amount > 0)) throw new Error('transfer: `amount` must be a positive integer (cents)');
+    if (this.actAsAgentId && !paymentGrantId) throw new Error('transfer: paymentGrantId is required for agent-impersonated transfers. The wallet owner must have issued a payment grant to this agentId.');
+    let toWalletId = to;
+    if (!to.startsWith('wal_')) {
+      const w = await this.resolve(to.startsWith('agent_') ? { agentId: to } : { userId: to }) as Record<string, unknown> | null;
+      if (!w?.['walletId']) throw new Error(`transfer: could not resolve wallet for "${to}"`);
+      toWalletId = w['walletId'] as string;
+    }
+    const result = await this._post('/payments/transfer', { toWalletId, amount, idempotencyKey: idempotencyKey || randomIdempotencyKey('xfer'), description, paymentGrantId }) as Record<string, unknown>;
+    if (result?.['status'] === 'approval_required') {
+      const approval = (result['approval'] as Record<string, unknown>) || {};
+      return { status: 'approval_required', approvalId: approval['approvalId'] || null, expiresAt: approval['expiresAt'] || null, reason: approval['reason'] || 'Amount exceeds auto-approve threshold', toWalletId, amount };
+    }
+    const tx = result?.['transaction'] as Record<string, unknown> | undefined;
+    return { status: 'transferred', transactionId: tx?.['transactionId'] || null, toWalletId, amount };
+  }
+
+  async hold({ amount, idempotencyKey, description }: { amount: number; idempotencyKey?: string; description?: string }): Promise<unknown> {
+    if (!(Number.isInteger(amount) && amount > 0)) throw new Error('hold: `amount` must be a positive integer (cents)');
+    return this._post('/payments/hold', { amount, idempotencyKey: idempotencyKey || randomIdempotencyKey('hold'), description });
+  }
+
+  async release({ holdId, action = 'complete', toWalletId, idempotencyKey }: { holdId: string; action?: string; toWalletId?: string; idempotencyKey?: string }): Promise<unknown> {
+    return this._post(`/payments/release/${holdId}`, { idempotencyKey: idempotencyKey || randomIdempotencyKey('rel'), action, toWalletId });
+  }
+
+  async history(params: { limit?: number; offset?: number; type?: string } = {}): Promise<unknown> {
+    const q = new URLSearchParams();
+    if (params.limit != null) q.set('limit', String(params.limit));
+    if (params.offset != null) q.set('offset', String(params.offset));
+    if (params.type) q.set('type', params.type);
+    return this._get('/payments/history' + (q.toString() ? `?${q}` : ''));
+  }
+
+  async issueGrant({ holderId, caveats }: { holderId: string; caveats?: unknown }): Promise<unknown> {
+    return this._post('/payments/grants', { holderId, caveats });
+  }
+
+  async attenuateGrant({ grantId, holderId, caveats }: { grantId: string; holderId: string; caveats?: unknown }): Promise<unknown> {
+    return this._post(`/payments/grants/${grantId}/attenuate`, { holderId, caveats });
+  }
+
+  async revokeGrant(grantId: string): Promise<unknown> {
+    return this._request('DELETE', `/payments/grants/${grantId}`, undefined);
+  }
+
+  async listGrants(): Promise<unknown[]> {
+    const res = await this._get('/payments/grants') as Record<string, unknown>;
+    return (res['grants'] as unknown[]) || [];
+  }
+
+  async createTopUpIntent({ amount, description, currency }: { amount?: number; description?: string; currency?: string } = {}): Promise<unknown> {
+    return this._post('/payments/onramp/intent', { amount, description, currency });
+  }
+
+  async confirmMockIntent(intentId: string): Promise<unknown> {
+    return this._post(`/payments/onramp/mock-confirm/${intentId}`, {});
+  }
+
+  async faucet({ amount, description = 'Faucet', idempotencyKey }: { amount?: number; description?: string; idempotencyKey?: string } = {}): Promise<unknown> {
+    return this._post('/payments/wallet/fund', { amount, idempotencyKey: idempotencyKey || randomIdempotencyKey('faucet'), description });
+  }
+
+  async approvals({ status = 'pending' }: { status?: string } = {}): Promise<unknown[]> {
+    const res = await this._get(`/payments/approvals?status=${encodeURIComponent(status)}`) as Record<string, unknown>;
+    return (res['approvals'] as unknown[]) || [];
+  }
+
+  async getApproval(approvalId: string): Promise<unknown | null> {
+    if (!approvalId) throw new Error('getApproval: approvalId is required');
+    try {
+      const res = await this._get(`/payments/approvals/${approvalId}`) as Record<string, unknown>;
+      return res?.['approval'] || null;
+    } catch (err) {
+      if ((err as PayError).status === 404) return null;
+      throw err;
+    }
+  }
+
+  async decide(approvalId: string, decision: string, note = ''): Promise<unknown> {
+    return this._post(`/payments/approvals/${approvalId}/decide`, { decision, note });
+  }
+
+  async waitForApproval(approvalId: string, opts: { pollMs?: number; timeoutMs?: number; signal?: AbortSignal } = {}): Promise<unknown> {
+    const pollMs = Math.max(500, opts.pollMs ?? 3_000);
+    const timeoutMs = Math.max(pollMs, opts.timeoutMs ?? 120_000);
+    const signal = opts.signal;
+    const deadline = Date.now() + timeoutMs;
+
+    const sleep = (ms: number) => new Promise<void>((resolve, reject) => {
+      const timer = setTimeout(resolve, ms);
+      if (signal) {
+        if (signal.aborted) { clearTimeout(timer); reject(new Error('aborted')); return; }
+        signal.addEventListener('abort', () => { clearTimeout(timer); reject(new Error('aborted')); }, { once: true });
+      }
+    });
+
+    while (true) {
+      if (signal?.aborted) throw new Error('aborted');
+      const approval = await this.getApproval(approvalId) as Record<string, unknown> | null;
+      if (!approval) return { status: 'gone' };
+      const s = approval['status'];
+      if (s === 'executed') return { status: 'executed', approval, transactionId: approval['executedTransactionId'] || null };
+      if (s === 'rejected') return { status: 'rejected', approval };
+      if (s === 'expired') return { status: 'expired', approval };
+      const remaining = deadline - Date.now();
+      if (remaining <= 0) return { status: 'timeout', approval };
+      await sleep(Math.min(pollMs, remaining));
+    }
+  }
+
+  private _buildHeaders(extra: Record<string, string> = {}): Record<string, string> {
+    const h: Record<string, string> = { Authorization: `Bearer ${this.operatorKey}`, ...extra };
+    if (this.actAsAgentId) h['X-Agent-Id'] = this.actAsAgentId;
+    return h;
+  }
+
+  private async _request(method: string, path: string, body: unknown): Promise<unknown> {
+    const init: RequestInit = { method, headers: this._buildHeaders(body !== undefined ? { 'content-type': 'application/json' } : {}) };
+    if (body !== undefined) init.body = JSON.stringify(body);
+    const response = await fetch(`${this.baseUrl}${path}`, init);
+    const text = await response.text();
+    if (!response.ok) {
+      const err = new Error(parseError(text, `HTTP ${response.status}`)) as PayError;
+      err.status = response.status;
+      err.body = text;
+      throw err;
+    }
+    return text ? JSON.parse(text) : null;
+  }
+
+  private _get(path: string): Promise<unknown> { return this._request('GET', path, undefined); }
+  private _post(path: string, body: unknown): Promise<unknown> { return this._request('POST', path, body ?? {}); }
+}
+
+export function createZiggsPayClient(opts: ZiggsPayClientOptions): ZiggsPayClient {
+  return new ZiggsPayClient(opts);
+}

package/src/shared/ids.ts

@@ -0,0 +1,3 @@
+export function generateId(): string {
+  return `${Date.now()}_${Math.random().toString(36).substr(2, 9)}`;
+}

package/src/shared/runtimeLog.ts

@@ -0,0 +1,72 @@
+/**
+ * Process-wide log levels for agentplus runtimes. Default is `info` so FSM /
+ * socket chatter stays quiet unless operators opt in.
+ *
+ * Env (first match wins for the debug shortcut):
+ * - `DEBUG_AGENTPLUS=1` or `AGENTPLUS_DEBUG=1` → threshold `debug`
+ * - `LOG_LEVEL` or `AGENTPLUS_LOG_LEVEL` → `debug` | `info` | `warn` | `error` | `silent`
+ *   (`silent` keeps only `error` output)
+ */
+
+export type RuntimeLogLevel = 'debug' | 'info' | 'warn' | 'error';
+
+const SEVERITY: Record<RuntimeLogLevel, number> = {
+  debug: 0,
+  info: 1,
+  warn: 2,
+  error: 3,
+};
+
+function parseThreshold(): number {
+  if (process.env.DEBUG_AGENTPLUS === '1' || process.env.AGENTPLUS_DEBUG === '1') {
+    return SEVERITY.debug;
+  }
+  const raw = (
+    process.env.LOG_LEVEL ||
+    process.env.AGENTPLUS_LOG_LEVEL ||
+    'info'
+  ).toLowerCase();
+  if (raw === 'silent' || raw === 'none') return SEVERITY.error;
+  if (raw === 'debug' || raw === 'trace') return SEVERITY.debug;
+  if (raw === 'warn') return SEVERITY.warn;
+  if (raw === 'error') return SEVERITY.error;
+  return SEVERITY.info;
+}
+
+let cachedThreshold: number | null = null;
+
+function threshold(): number {
+  if (cachedThreshold === null) cachedThreshold = parseThreshold();
+  return cachedThreshold;
+}
+
+/** Test hook: re-read env after `process.env` mutations. */
+export function resetRuntimeLogLevelCache(): void {
+  cachedThreshold = null;
+}
+
+function shouldEmit(level: RuntimeLogLevel): boolean {
+  return SEVERITY[level] >= threshold();
+}
+
+function fmt(scope: string, msg: string): string {
+  return `[${scope}] ${msg}`;
+}
+
+export const runtimeLog = {
+  debug(scope: string, msg: string, ...rest: unknown[]): void {
+    if (!shouldEmit('debug')) return;
+    console.log(fmt(scope, msg), ...rest);
+  },
+  info(scope: string, msg: string, ...rest: unknown[]): void {
+    if (!shouldEmit('info')) return;
+    console.log(fmt(scope, msg), ...rest);
+  },
+  warn(scope: string, msg: string, ...rest: unknown[]): void {
+    if (!shouldEmit('warn')) return;
+    console.warn(fmt(scope, msg), ...rest);
+  },
+  error(scope: string, msg: string, ...rest: unknown[]): void {
+    console.error(fmt(scope, msg), ...rest);
+  },
+};

package/src/shared/types.ts

@@ -0,0 +1,29 @@
+// Inlined from `@ziggs-ai/api-client` so the pure SDK doesn't depend on the
+// Ziggs HTTP client. Both client and server agree on these string constants
+// because the protocol is the same — they're just two views of one schema.
+export const EntryTypes = {
+  MESSAGE:      'message',
+  NOTIFICATION: 'notification',
+  ARTIFACT:     'artifact',
+  TASK_HISTORY: 'task_history',
+} as const;
+
+export type EntryType = (typeof EntryTypes)[keyof typeof EntryTypes];
+
+export const ContentTypes = {
+  TEXT:        'text',
+  OPERATION:   'operation',
+  CONTEXT:     'context',
+  RESULT:      'result',
+  TASK_UPDATE: 'task_update',
+  THOUGHT:     'thought',
+} as const;
+
+export type ContentType = (typeof ContentTypes)[keyof typeof ContentTypes];
+
+export const ContextProperties = {
+  HISTORY:    'history',
+  AGREEMENTS: 'agreements',
+  AGENTS:     'agents',
+  USERS:      'users',
+} as const;

package/src/tasks/protocolRegistry.ts

@@ -0,0 +1,25 @@
+export const PROTOCOL_TOOL_TO_OPERATION = Object.freeze({
+  agreement_propose:                'agreement-propose',
+  agreement_subcontract:            'agreement-subcontract',
+  agreement_respond:                'agreement-respond',
+  agreement_counter_proposal:       'agreement-counter-proposal',
+  agreement_check_proposal:         'agreement-check-proposal',
+  agreement_revoke:                 'agreement-revoke',
+  task_spawn:                       'task-spawn',
+  task_update:                      'task-update',
+  task_update_plan_step:            'task-update-plan-step',
+} as const);
+
+export type ProtocolToolName = keyof typeof PROTOCOL_TOOL_TO_OPERATION;
+export type ProtocolOperation = (typeof PROTOCOL_TOOL_TO_OPERATION)[ProtocolToolName];
+
+export const PROTOCOL_TOOL_NAMES = Object.freeze(Object.keys(PROTOCOL_TOOL_TO_OPERATION)) as readonly ProtocolToolName[];
+
+export function mapProtocolToolToOperation(toolName: string): ProtocolOperation | null {
+  if (!toolName || typeof toolName !== 'string') return null;
+  return (PROTOCOL_TOOL_TO_OPERATION as Record<string, ProtocolOperation>)[toolName] ?? null;
+}
+
+export function isProtocolToolName(toolName: string): toolName is ProtocolToolName {
+  return mapProtocolToolToOperation(toolName) != null;
+}

package/src/tools/ToolManager.ts

@@ -0,0 +1,95 @@
+import AjvModule from 'ajv';
+import { ToolProvider } from './ToolProvider.js';
+import type { ToolDefinition } from './defineTool.js';
+
+// Ajv ships as CJS; handle both ESM default-import shapes
+type ValidateFn = ((data: unknown) => boolean) & { errors?: unknown[] };
+type AjvInstance = { compile: (schema: object) => ValidateFn; errorsText: (errors: unknown) => string };
+const AjvClass = (AjvModule as unknown as { default?: unknown }).default ?? AjvModule;
+const ajv = new (AjvClass as new (opts: object) => AjvInstance)({ allErrors: true, strict: false });
+
+interface ToolError extends Error {
+  type: string;
+  cause?: unknown;
+  data?: unknown;
+}
+
+function makeError(message: string, type: string, extra?: Partial<ToolError>): ToolError {
+  const err = new Error(message) as ToolError;
+  err.type = type;
+  if (extra) Object.assign(err, extra);
+  return err;
+}
+
+function stripNullish(args: Record<string, unknown>): Record<string, unknown> {
+  if (!args || typeof args !== 'object' || Array.isArray(args)) return args;
+  const out: Record<string, unknown> = {};
+  for (const [k, v] of Object.entries(args)) {
+    if (v !== null && v !== undefined) out[k] = v;
+  }
+  return out;
+}
+
+export class ToolManager extends ToolProvider {
+  private tools: Map<string, ToolDefinition>;
+
+  constructor() {
+    super();
+    this.tools = new Map();
+  }
+
+  register(tool: ToolDefinition): string {
+    if (!tool?.schema) throw makeError('Tool must have a schema', 'invalid_tool');
+    if (typeof tool.handler !== 'function') throw makeError('Tool must have a handler function', 'invalid_tool');
+    const name = (tool.schema.function?.['name'] || (tool.schema as unknown as Record<string, unknown>)['name']) as string;
+    if (!name) throw makeError('Tool schema must have a name', 'invalid_tool');
+    this.tools.set(name, tool);
+    return name;
+  }
+
+  registerAll(tools: ToolDefinition[] = []): void {
+    for (const tool of tools) this.register(tool);
+  }
+
+  async getAvailableTools(): Promise<ToolDefinition[]> {
+    return Array.from(this.tools.values());
+  }
+
+  getTool(name: string): ToolDefinition | null {
+    const normalized = this._normalizeName(name) as string;
+    return this.tools.get(normalized) ?? null;
+  }
+
+  async executeTool(
+    name: string,
+    args: Record<string, unknown> = {},
+    context: Record<string, unknown> = {},
+  ): Promise<unknown> {
+    const normalized = this._normalizeName(name) as string;
+    const tool = this.tools.get(normalized);
+    if (!tool) throw makeError(`Tool not found: ${name}`, 'tool_not_found');
+
+    const cleanedArgs = stripNullish(args);
+    this._validateArgs(tool, cleanedArgs);
+
+    try {
+      return await tool.handler(cleanedArgs, context);
+    } catch (error) {
+      throw makeError(`Tool "${name}" failed: ${(error as Error).message}`, 'tool_error', { cause: error });
+    }
+  }
+
+  private _validateArgs(tool: ToolDefinition, args: Record<string, unknown>): void {
+    const parameters = tool.schema.function?.['parameters'] || (tool.schema as unknown as Record<string, unknown>)['parameters'];
+    if (!parameters) return;
+    const validate = ajv.compile(parameters as object);
+    if (!validate(args)) {
+      const name = tool.schema.function?.['name'];
+      throw makeError(
+        `Invalid args for "${name}": ${ajv.errorsText(validate.errors)}`,
+        'validation_error',
+        { data: { errors: validate.errors } },
+      );
+    }
+  }
+}

package/src/tools/{ToolProvider.js → ToolProvider.ts}

@@ -1,28 +1,18 @@
-/**
- * Base class for tool providers.
- * ToolManager and any custom providers extend this.
- */
 export class ToolProvider {
-  async getAvailableTools() {
+  async getAvailableTools(): Promise<unknown[]> {
     throw new Error('getAvailableTools must be implemented');
   }
-
-  async executeTool(name, args = {}, context = {}) {
+  async executeTool(_name: string, _args?: Record<string, unknown>, _context?: Record<string, unknown>): Promise<unknown> {
     throw new Error('executeTool must be implemented');
   }
-
-  getTool(name) {
+  getTool(_name: string): unknown | null {
     throw new Error('getTool must be implemented');
   }
-
-  _normalizeName(name) {
+  _normalizeName(name: unknown): unknown {
     if (!name || typeof name !== 'string') return name;
-
     const prefixes = ['functions.', 'tools.', 'function.', 'tool.'];
     for (const prefix of prefixes) {
-      if (name.startsWith(prefix)) {
-        return name.substring(prefix.length);
-      }
+      if (name.startsWith(prefix)) return name.substring(prefix.length);
     }
     return name;
   }

package/src/tools/defineTool.ts

@@ -0,0 +1,90 @@
+const PRIMITIVES = new Set(['string', 'number', 'boolean', 'integer']);
+
+type FieldDef = string | unknown[] | Record<string, unknown>;
+
+function convertField(value: FieldDef): { schema: Record<string, unknown>; required: boolean } {
+  if (typeof value === 'string') {
+    if (!PRIMITIVES.has(value)) throw new Error(`Unknown type shorthand: "${value}"`);
+    return { schema: { type: value }, required: false };
+  }
+  if (Array.isArray(value)) {
+    if (value.length !== 1) throw new Error('Array shorthand must have exactly one element describing the item type');
+    const inner = value[0] as FieldDef;
+    if (typeof inner === 'string') return { schema: { type: 'array', items: { type: inner } }, required: false };
+    return { schema: { type: 'array', items: convertObject(inner as Record<string, unknown>) }, required: false };
+  }
+  if (typeof value === 'object' && value !== null) {
+    const v = value as Record<string, unknown>;
+    if (v['type'] && PRIMITIVES.has(v['type'] as string)) {
+      const { required: isReq, ...rest } = v;
+      return { schema: rest, required: !!isReq };
+    }
+    if (v['type'] === 'array' || v['type'] === 'object') {
+      const { required: isReq, ...rest } = v;
+      return { schema: rest, required: !!isReq };
+    }
+    return { schema: convertObject(v), required: false };
+  }
+  throw new Error(`Cannot convert field value: ${JSON.stringify(value)}`);
+}
+
+function convertObject(fields: Record<string, unknown>): Record<string, unknown> {
+  const properties: Record<string, unknown> = {};
+  const required: string[] = [];
+  for (const [key, value] of Object.entries(fields)) {
+    if (key === 'required') continue;
+    const { schema, required: isReq } = convertField(value as FieldDef);
+    properties[key] = schema;
+    if (isReq) required.push(key);
+  }
+  const result: Record<string, unknown> = { type: 'object', properties };
+  if (required.length > 0) result['required'] = required;
+  return result;
+}
+
+export interface ToolDefinition {
+  schema: { type: 'function'; function: Record<string, unknown> };
+  handler: (args: Record<string, unknown>, context: Record<string, unknown>) => Promise<unknown>;
+  echoUserSummaryOnSuccess?: boolean;
+  /**
+   * When true, the runtime will skip a second invocation of this tool in
+   * the same assistant message. Use for "create an agreement"-style tools
+   * where the model is prone to fire two near-identical create calls.
+   */
+  isAgreementCreation?: boolean;
+  /**
+   * When true, the runtime will execute this tool even when no state
+   * action is bound to it. Use for discovery tools (e.g. agent search,
+   * task board) that should always be callable.
+   */
+  isGenericFallback?: boolean;
+}
+
+export interface DefineToolOptions {
+  description?: string;
+  echoUserSummaryOnSuccess?: boolean;
+  isAgreementCreation?: boolean;
+  isGenericFallback?: boolean;
+}
+
+export function defineTool(
+  name: string,
+  params: Record<string, unknown>,
+  handler: (args: Record<string, unknown>, context: Record<string, unknown>) => Promise<unknown>,
+  options: DefineToolOptions = {},
+): ToolDefinition {
+  if (!name || typeof name !== 'string') throw new Error('defineTool: name is required');
+  if (!handler || typeof handler !== 'function') throw new Error('defineTool: handler function is required');
+
+  const parameters = convertObject(params || {});
+  const fn: Record<string, unknown> = { name, parameters };
+  if (options.description) fn['description'] = options.description;
+
+  return {
+    schema: { type: 'function', function: fn },
+    handler,
+    ...(options.echoUserSummaryOnSuccess ? { echoUserSummaryOnSuccess: true } : {}),
+    ...(options.isAgreementCreation ? { isAgreementCreation: true } : {}),
+    ...(options.isGenericFallback ? { isGenericFallback: true } : {}),
+  };
+}

package/src/tools/index.ts

@@ -0,0 +1,5 @@
+export { ToolManager } from './ToolManager.js';
+export { ToolProvider } from './ToolProvider.js';
+export { defineTool } from './defineTool.js';
+// Pure protocol-tool name registry (no handlers, no services).
+export { PROTOCOL_TOOL_NAMES, PROTOCOL_TOOL_TO_OPERATION, mapProtocolToolToOperation, isProtocolToolName } from '../tasks/protocolRegistry.js';