@ixo/oracle-runtime-workers 0.38.0 → 0.40.1

package/src/plugins/flows/types.ts

@@ -98,18 +98,11 @@ export const stepInputsSchema = z
 export const conditionSchema = z.object({
   source: z
     .enum(['configured_input', 'runtime_output'])
-    .describe(
-      'Read authored inputs or successful runtime output. Required for newly authored conditions.',
-    ),
-  fromStep: stepIdSchema.describe(
-    'Id of the upstream step whose value is checked.',
-  ),
-  field: nameSchema.describe('Field on the upstream step to inspect.'),
-  is: z.enum(CONDITION_OPERATORS).describe('Comparison operator.'),
-  value: z
-    .unknown()
-    .optional()
-    .describe('Value to compare against (omit for isEmpty/isNotEmpty).'),
+    .describe('Read authored inputs or successful runtime output.'),
+  fromStep: stepIdSchema.describe('The upstream step.'),
+  field: nameSchema.describe('Its field to inspect.'),
+  is: z.enum(CONDITION_OPERATORS),
+  value: z.unknown().optional().describe('Omit for isEmpty/isNotEmpty.'),
 });
 
 export const semanticGateSchema = z
@@ -128,20 +121,18 @@ export const hookSchema = z.object({
 });
 
 export const dueSchema = z.object({
-  at: nameSchema.optional().describe('Absolute due date (ISO 8601).'),
+  at: nameSchema.optional().describe('Absolute (ISO 8601).'),
   within: nameSchema
     .optional()
-    .describe(
-      'Duration from when the step becomes active (ISO 8601 duration).',
-    ),
+    .describe('ISO 8601 duration from when the step becomes active.'),
   afterCommitment: nameSchema
     .optional()
-    .describe('Duration from commitment (ISO 8601 duration).'),
+    .describe('ISO 8601 duration from commitment.'),
 });
 
 export const onEventSchema = z.object({
-  fromStep: stepIdSchema.describe('Upstream step that emits the event.'),
-  event: nameSchema.describe('Event name the upstream step emits.'),
+  fromStep: stepIdSchema.describe('The upstream step.'),
+  event: nameSchema.describe('The event it emits.'),
 });
 
 /**
@@ -150,38 +141,34 @@ export const onEventSchema = z.object({
  * is only attached on read (see FlowStepRead).
  */
 export const flowStepSchema = z.object({
-  id: stepIdSchema.describe(
-    'Stable, human-readable step id, e.g. "load-batches".',
-  ),
+  id: stepIdSchema.describe('Stable and readable, e.g. "load-batches".'),
   action: nameSchema
     .min(1)
-    .describe('Action name from list_actions (e.g. "qi/email.send").'),
+    .describe('From list_actions, e.g. "qi/email.send".'),
   title: nameSchema.optional(),
   description: descriptionSchema.optional(),
   phase: nameSchema
     .min(1)
     .optional()
-    .describe(
-      'Stable semantic group for this step, such as "discovery" or "deployment".',
-    ),
+    .describe('Stable semantic group, e.g. "discovery".'),
   execution: z
     .enum(['human-only', 'agent-capable'])
     .optional()
     .describe(
-      'Whether only a person may run this step or a suitably skilled, authorised Flow Agent may run it.',
+      'Only a person may run it, or also a suitably skilled, authorised Flow Agent.',
     ),
 
   inputs: stepInputsSchema
     .optional()
     .describe(
-      'Inputs for the action. A value may be a reference to an upstream output, written as "{{step-id.output.field}}". ' +
-        'Never put a PIN, mnemonic, password, token or API key here: the portal collects those when the user runs the step.',
+      'A value may reference upstream output: "{{step-id.output.field}}". ' +
+        'Never a PIN, mnemonic, password, token or API key: the portal collects those at run time.',
     ),
   form: z
     .record(z.string(), z.unknown())
     .optional()
     .describe(
-      'For human form steps: pre-filled answers keyed by question name. Pre-fill only — the user submits in the portal.',
+      'Form steps: pre-filled answers by question name; the user submits in the portal.',
     ),
 
   after: z
@@ -189,13 +176,11 @@ export const flowStepSchema = z.object({
     .max(MAX_FLOW_STEPS)
     .optional()
     .describe(
-      'Order this step after the named steps. Pair with an input reference for a real data dependency. This is ordering only, not an auto-trigger.',
+      'Ordering only, not an auto-trigger; pair with an input reference for a data dependency.',
     ),
   runWhen: conditionSchema
     .optional()
-    .describe(
-      'Gate this step on an upstream configured input or runtime output.',
-    ),
+    .describe('Gate on an upstream configured input or runtime output.'),
   conditions: z
     .array(conditionSchema)
     .max(
@@ -203,7 +188,7 @@ export const flowStepSchema = z.object({
       `A step may have at most ${MAX_CONDITIONS_PER_STEP} conditions.`,
     )
     .optional()
-    .describe('Multiple activation gates (all must pass).'),
+    .describe('Several gates, all must pass.'),
   semanticGate: semanticGateSchema
     .optional()
     .describe(
@@ -212,24 +197,23 @@ export const flowStepSchema = z.object({
   onEvent: onEventSchema
     .optional()
     .describe(
-      'Advanced: auto-trigger this step when an upstream step emits an event. Only valid for event-capable upstream actions; validate_flow enforces this.',
+      'Advanced: run when an upstream step emits an event; event-capable actions only.',
     ),
 
   trigger: z
     .enum(['manual', 'flow-start'])
     .optional()
-    .describe('When the step runs. Default "manual".'),
+    .describe('Default "manual".'),
   due: dueSchema.optional(),
 
   assignTo: didSchema
     .optional()
     .describe(
-      'The DID assigned to this step. Assigning AUTHORISES that DID to run the step (it is written to the ' +
-        "step's authorised actors) — only assign a DID the user named and confirmed.",
+      'Assigning AUTHORISES this DID to run the step: only a DID the user named and confirmed.',
     ),
   commitTo: nameSchema
     .optional()
-    .describe('Commitment window (ISO 8601 duration).'),
+    .describe('Commitment window, ISO 8601 duration.'),
 
   on: z
     .record(z.string(), z.array(hookSchema))
@@ -243,12 +227,12 @@ export const flowStepSchema = z.object({
     )
     .optional()
     .describe(
-      'Governed skill ids required for agent-capable execution. The first is used for Flow Agent matching.',
+      'Governed skill ids for agent-capable execution; the first matches the Flow Agent.',
     ),
   requireConfirmation: z
     .boolean()
     .optional()
-    .describe('Hint the portal to force a confirmation before this step runs.'),
+    .describe('The portal confirms before this step runs.'),
 });
 
 /**
@@ -266,12 +250,7 @@ export const sizedFlowStepSchema = flowStepSchema.refine(
  */
 export const flowSpecSchema = z
   .object({
-    ref: z
-      .string()
-      .optional()
-      .describe(
-        'Opaque flow handle. Omit when creating; the plugin assigns it.',
-      ),
+    ref: z.string().optional().describe('Omit when creating.'),
     title: nameSchema.min(1),
     goal: descriptionSchema.optional(),
     steps: z

package/src/plugins/hub-actions/hub-actions.plugin.ts

@@ -28,6 +28,7 @@ import type {
 } from '../../plugin-api/types';
 import { ixoAddressOf } from '../../core/user-identity';
 import { toolNotRunMessage } from '../../core/tool-not-run';
+import { compactJsonSchema } from '../compact-schema';
 import {
   CHAIN_TX_CATALOG,
   CHAIN_TX_GENERAL_RULES,
@@ -80,8 +81,22 @@ export const requestOperationJsonSchema = {
     (branch) => !RUNTIME_BUILT_KINDS.includes(String(branchKind(branch))),
   ),
 };
-const operationSchema = z.fromJSONSchema(requestOperationJsonSchema);
-const requestSchema = z.strictObject({ operation: operationSchema });
+/**
+ * What the tool binds: each kind's fields, required keys and types, without
+ * the protocol's limits and patterns, over a third of its characters. The
+ * handler checks a call against {@link strictOperations}, then
+ * `parseOperation`.
+ */
+const requestSchema = z.strictObject({
+  operation: z.fromJSONSchema(compactJsonSchema(requestOperationJsonSchema)),
+});
+/** Each requestable kind's whole protocol schema, for a refusal naming the field. */
+const strictOperations = new Map(
+  requestOperationJsonSchema.oneOf.map((branch) => [
+    String(branchKind(branch)),
+    z.fromJSONSchema(branch),
+  ]),
+);
 const statusSchema = z.strictObject({
   actionId: z.string().regex(/^[A-Za-z0-9_-]{32}$/),
 });
@@ -641,6 +656,16 @@ async function requestHubAction(
   const parsed = requestSchema.safeParse(input);
   if (!parsed.success)
     return { status: 'unavailable', reason: 'An operation is required.' };
+  const limits = strictOperations
+    .get(String(kind))
+    ?.safeParse(parsed.data.operation);
+  if (limits && !limits.success)
+    return {
+      status: 'unavailable',
+      reason: `The requested operation is unsupported or incomplete (${limits.error.issues
+        .map((issue) => `${pathText(issue.path)}: ${issue.message}`)
+        .join('; ')}).`,
+    };
   if (ctx.config.HUB_ACTIONS_ENABLED !== 'true' || !ctx.hubActions)
     return {
       status: 'unavailable',
@@ -1179,6 +1204,7 @@ const manifest: PluginManifest = {
   tags: ['actions', 'channels'],
   category: 'integration',
   visibility: 'on-demand',
+  brief: 'prepare chain transactions to sign in Auth Hub',
   stability: 'experimental',
 };
 
@@ -1227,7 +1253,7 @@ export class HubActionsPlugin extends OraclePlugin {
       {
         name: 'hub_action_options',
         description:
-          "Read this authenticated owner’s confirmed Gmail and Calendar connections, requestable documents, action resources and bank tokens (`transfer.tokens`: denom, symbol, decimals, verified, balance in base units). Use each returned service, identifier and label before preparing a related Hub review. A Gmail profile connection does not authorize sending. For a token that is not verified, name its full denom and say it is unverified; its amounts are base units. ownerDid is the authenticated user's DID and ownerAddress their IXO account address.",
+          "Read the owner’s confirmed Gmail and Calendar connections, requestable documents, action resources and bank tokens (`transfer.tokens`: denom, symbol, decimals, verified, balance in base units). Use each returned service, identifier and label to prepare a related Hub review. A Gmail profile connection does not authorize sending. For a token that is not verified, name its full denom and say it is unverified; its amounts are base units. ownerDid is the authenticated user's DID and ownerAddress their IXO account address.",
         schema: discoverSchema,
         effect: 'read',
         handler: hubActionOptions,
@@ -1235,7 +1261,7 @@ export class HubActionsPlugin extends OraclePlugin {
       {
         name: 'request_hub_action',
         description:
-          'Prepare a supported operation for the authenticated channel owner to review in Auth Hub. Never approves, signs, or executes. For email, propose one plain-text message to one recipient using a confirmed Gmail send connection. Supply only the operation candidate; the runtime supplies identity and turn binding. Coin sends and other chain transactions have their own tool (request_chain_transaction). Never prepare a replacement email after an unknown send without the user checking Gmail’s Sent folder and asking again.',
+          'Prepare a supported operation for the authenticated channel owner to review in Auth Hub. Never approves, signs, or executes. For email, propose one plain-text message to one recipient using a confirmed Gmail send connection. Supply only the operation candidate; the runtime supplies identity and turn binding. Coin sends and other chain transactions have their own tool (request_chain_transaction). Never prepare a replacement email after an unknown send without the user checking Gmail’s Sent folder and asking again. Limits are checked on the call; `startsAt` and `endsAt` are ISO 8601 with an offset, a saved `filename` ends in .txt, a form field `id` is lower_snake_case.',
         schema: requestSchema,
         effect: 'write',
         handler: requestHubAction,

package/src/plugins/index.ts

@@ -8,8 +8,8 @@ export { HubActionsPlugin } from './hub-actions/hub-actions.plugin';
  * plugins. Each is gated the same way as on Node: `autoDetect` on its env
  * key where one exists (memory / sandbox / firecrawl / composio), always-on
  * otherwise (domain-indexer; ixo-chain unless `IXO_CHAIN_TOOLS=off`; vfs
- * self-gates on `ctx.ucan.hasSigningKey()`; pod-creator and ixo-chain are
- * on-demand and stay hidden until `load_capability`).
+ * self-gates on `ctx.ucan.hasSigningKey()`; sandbox, vfs, pod-creator and
+ * ixo-chain are on-demand and stay hidden until `load_capability`).
  *
  * A host opts in by spreading `BUNDLED_WORKERS_PLUGINS` into
  * `createOracleWorker({ plugins })` — plugins whose env keys are absent are

package/src/plugins/ixo-chain/ixo-chain.plugin.ts

@@ -23,7 +23,7 @@ import {
   type Source,
 } from './http';
 import { KINDS, kindByName, kindNames } from './kinds/registry';
-import type { KindDef } from './kinds/types';
+import { argKeys, type KindDef } from './kinds/types';
 import {
   chainLookup,
   cutRow,
@@ -426,11 +426,11 @@ const manifest: PluginManifest = {
     {
       user: 'Did I get paid for my claims in collection 8250?',
       thought:
-        "The user's claims there (evaluation and payment status) and the collection's payment terms, in one lookup.",
+        "The user's claims there (agent: their own address; evaluation and payment status) and the collection's payment terms, in one lookup.",
       tool: 'chain_lookup',
       args: {
         requests: [
-          { kind: 'claims', args: { collectionId: '8250' } },
+          { kind: 'claims', args: { agent: 'ixo1…', collectionId: '8250' } },
           { kind: 'claim_collection', args: { id: '8250' } },
         ],
       },
@@ -452,10 +452,11 @@ const manifest: PluginManifest = {
   // Hosts that want it on every turn set `visibility: 'always'` through
   // `manifestOverrides`.
   visibility: 'on-demand',
+  brief: 'read the IXO chain: balances, entities, claims, tokens',
   stability: 'beta',
 };
 
-/** Read-only and transfer rule; also in the tool descriptions, as a capability-router preload shows no operating guide. */
+/** Read-only and transfer rule; also in the tool descriptions, so each tool reads correctly on its own. */
 const READ_ONLY_RULE =
   "Read-only. For a transfer use this turn's transfer tools; on a channel read `hub_action_options` first (the Hub applies the account's limits).";
 /** Chain text is written by anyone; also in the `chain_lookup` description. */
@@ -478,6 +479,29 @@ const LOOKUP_UNITS_RULE =
 const NAMES_RULE =
   'Call people and things by their `names` entry; give an address or DID only when asked; beside a `selfChosen` name the user did not pick, also give the short address (first 12 … last 6 characters).';
 
+/**
+ * What the list of arguments alone would mislead on: `claims` with a
+ * `collectionId` reads as the collection's claims, but it stays one agent's.
+ */
+const ARG_NOTES: Record<string, string> = {
+  claims: ' [default: user]',
+  claim_collection: ' [totals]',
+};
+
+/**
+ * Every kind's arguments besides `address` and `first`, from the kinds' own
+ * schemas: known without a `describe_chain_kinds` round trip, and they cannot
+ * drift.
+ */
+export const KIND_ARGS = KINDS.flatMap((kind) => {
+  const keys = argKeys(kind.args).keys.filter(
+    (key) => key !== 'address' && key !== 'first',
+  );
+  return keys.length
+    ? [`${kind.name}(${keys.join(',')})${ARG_NOTES[kind.name] ?? ''}`]
+    : [];
+}).join(' ');
+
 /** Says the overview is broad and costly; its units, text and names rules are `chain_lookup`'s, bound beside it. */
 const OVERVIEW_DESCRIPTION = [
   "A broad look at an IXO account (default: the user's) by `sections` (default: all): per section: counts, top 3 rows, `more` (the request for the rest).",
@@ -543,7 +567,7 @@ export class IxoChainPlugin extends OraclePlugin {
         name: 'chain_lookup',
         description: [
           'IXO chain data: 1–8 `requests` `{ kind, args }`, each answered on its own (`ok`, or `reason` + `retryable`).',
-          "`describe_chain_kinds` gives a kind's `args`; account args: ixo1… or did:ixo:ixo1… (default: the user); lists: `first` 1–20.",
+          `\`args\`: account args take ixo1… or did:ixo:ixo1… (default: the user); \`address\` on most kinds, \`first\` 1–20 on lists; others: ${KIND_ARGS}. \`describe_chain_kinds\` explains a kind.`,
           '`source`: `chain` live, `blocksync` indexed (seconds behind).',
           LOOKUP_UNITS_RULE,
           NETWORK_RULE,

package/src/plugins/ixo-chain/kinds/core.ts

@@ -63,7 +63,7 @@ const STATUSES =
 const claimsKind = defineKind({
   name: 'claims',
   summary:
-    'Claims an agent submitted (default: the user), newest first, with evaluation and payment status.',
+    "One agent's claims (default: the user; `collectionId` needs `agent`), newest first, with evaluation and payment status. A collection's totals are in `claim_collection`.",
   explain: [
     'Each claim: claimId, collectionId, agent, submissionDate, `evaluation` (status, date) and `paymentsStatus` per payment leg (e.g. `approval: PAID`).',
     STATUSES,
@@ -73,7 +73,7 @@ const claimsKind = defineKind({
   source: 'blocksync',
   list: true,
   args: CORE_ARGS.claims,
-  example: { collectionId: '8250', first: 5 },
+  example: { first: 5 },
   plan: (args, ctx) => blocksyncPlan({ kind: 'claims', ...args }, ctx),
 });
 

package/src/plugins/ixo-chain/kinds/types.ts

@@ -9,7 +9,7 @@
  * {@link defineKind}: `chain_lookup`'s tool schema only names the kind, so
  * the catalogue does not cost context on every turn.
  */
-import type { z } from 'zod';
+import { z } from 'zod';
 import type { UserIdentity } from '../../../core/user-identity';
 import type { TokenDisplay } from '../denoms';
 import type { ChainCall, Failure, Outcome, Source } from '../http';
@@ -109,8 +109,37 @@ export interface KindDef {
   plan(rawArgs: unknown, ctx: KindContext): KindPlan | KindInvalid;
 }
 
-/** The argument problems as one sentence naming what the kind expects. */
-function invalidArgs(name: string, error: z.ZodError): KindInvalid {
+/** The names a kind's arguments take, in schema order, with the required ones. */
+export function argKeys(args: z.ZodType): {
+  keys: string[];
+  required: string[];
+} {
+  const { properties = {}, required = [] } = z.toJSONSchema(args, {
+    io: 'input',
+    unrepresentable: 'any',
+  });
+  return { keys: Object.keys(properties), required };
+}
+
+/** A kind's valid keys as a clause of its refusal. */
+function validKeys(args: z.ZodType): string {
+  const { keys, required } = argKeys(args);
+  if (!keys.length) return 'This kind takes no args.';
+  const list = keys
+    .map((key) => (required.includes(key) ? `${key} (required)` : key))
+    .join(', ');
+  return `Its args: ${list}.`;
+}
+
+/**
+ * The argument problems as one sentence, with the kind's valid keys, so the
+ * model can correct the request without describing the kind first.
+ */
+function invalidArgs(
+  name: string,
+  error: z.ZodError,
+  args: z.ZodType,
+): KindInvalid {
   const issues = error.issues
     .slice(0, 3)
     .map((issue) =>
@@ -120,7 +149,7 @@ function invalidArgs(name: string, error: z.ZodError): KindInvalid {
     )
     .join('; ');
   return {
-    invalid: `Invalid args for kind "${name}" (${issues}). Call describe_chain_kinds with ["${name}"] for its arguments.`,
+    invalid: `Invalid args for kind "${name}" (${issues}). ${validKeys(args)} describe_chain_kinds with ["${name}"] explains them.`,
   };
 }
 
@@ -150,7 +179,7 @@ export function defineKind<S extends z.ZodType>(spec: {
       const parsed = spec.args.safeParse(rawArgs ?? {});
       return parsed.success
         ? spec.plan(parsed.data, ctx)
-        : invalidArgs(spec.name, parsed.error);
+        : invalidArgs(spec.name, parsed.error, spec.args);
     },
   };
 }

package/src/plugins/ixo-chain/queries.ts

@@ -69,7 +69,9 @@ export const CORE_ARGS = {
     collectionId: z
       .string()
       .optional()
-      .describe('Only claims in this collection, e.g. "8250".'),
+      .describe(
+        'Only this agent\'s claims in this collection, e.g. "8250"; needs `agent`.',
+      ),
     first: firstArg,
     after: z
       .string()
@@ -290,6 +292,13 @@ export function requestField(
 ): FieldPlan {
   switch (request.kind) {
     case 'claims': {
+      // A collection alone would quietly mean "the user's claims in it",
+      // which a question about the collection never asks: whose claims is
+      // said, or the collection's own counts are read instead.
+      if (request.collectionId !== undefined && request.agent === undefined)
+        return invalid(
+          `claims lists one agent's claims. For collection ${request.collectionId} as a whole (count, approved, rejected), use claim_collection with id "${request.collectionId}"; for one agent's claims in it, pass agent too (the user's own address for theirs).`,
+        );
       const agent = accountOf(request.agent, identity, 'agent');
       if (!agent.ok) return invalid(agent.detail);
       if (

package/src/plugins/ixo-transaction/ixo-transaction.plugin.ts

@@ -96,6 +96,7 @@ const manifest: PluginManifest = {
   tags: ['ixo', 'transaction', 'wallet', 'portal', 'cosmos'],
   category: 'integration',
   visibility: 'on-demand',
+  brief: 'prepare chain transactions for wallet signing in Portal',
   stability: 'experimental',
 };
 

package/src/plugins/matrix-group-chats/index.ts

@@ -91,6 +91,7 @@ const manifest: PluginManifest = {
   tags: ['matrix', 'group-chat', 'memory'],
   category: 'communication',
   visibility: 'on-demand',
+  brief: 'search what was said in this group room',
   stability: 'beta',
 };
 

package/src/plugins/memory/memory-tools.ts

@@ -30,10 +30,10 @@ export const MEMORY_CLEAR_MCP_NAME = 'memory-engine__clear';
  * knowledge from chat without a per-oracle code change: the Memory Engine
  * itself checks on chain that the caller is a member (controller, owner,
  * Matrix admin or DAO member) of the oracle's domain entity and refuses
- * everyone else, so listing the tool for every user
- * costs one tool description and grants nothing. Forks that want a different
- * surface (drop `clear`, add `delete_edge`) pass an explicit list via plugin
- * options.
+ * everyone else, so offering the tool to every user grants nothing. Forks
+ * that want a different surface (drop `clear`, add `delete_edge`) pass an
+ * explicit list via plugin options. Everything but search and add stays
+ * behind `load_capability` (the plugin manifest's `onDemandTools`).
  */
 export const DEFAULT_MEMORY_TOOLS = [
   MEMORY_SEARCH_MCP_NAME,

package/src/plugins/memory/memory.plugin.ts

@@ -12,10 +12,18 @@ import {
   createDefaultMemoryMcpFactory,
   DEFAULT_MEMORY_TOOLS,
   fetchMemoryTools,
+  MEMORY_ADD_ORACLE_KNOWLEDGE_MCP_NAME,
+  MEMORY_CLEAR_MCP_NAME,
+  MEMORY_DELETE_EDGE_MCP_NAME,
+  MEMORY_DELETE_EPISODE_MCP_NAME,
   type MemoryMcpFactory,
 } from './memory-tools';
 import { oracleEntityDidSchema } from './memory-entity';
-import { createOracleDocumentTools } from './oracle-document-tools';
+import {
+  ADD_ORACLE_DOCUMENT_TOOL_NAME,
+  createOracleDocumentTools,
+  DELETE_ORACLE_DOCUMENT_TOOL_NAME,
+} from './oracle-document-tools';
 
 const configSchema = z.object({
   MEMORY_MCP_URL: z.string().url('MEMORY_MCP_URL must be a valid HTTP(S) URL.'),
@@ -51,6 +59,24 @@ const manifest: PluginManifest = {
   tags: ['memory', 'recall', 'artifacts', 'personalization'],
   category: 'memory',
   visibility: 'always',
+  brief: 'add or delete oracle documents, knowledge; delete memories',
+  // Recall and saving are bound on every call. A message about memory says
+  // "Memory" to the router, and only the rare admin work needs the rest: on
+  // the first full lab run none of its 31 preloads was used.
+  routable: false,
+  // Search and add stay bound: they serve ordinary conversation. So does
+  // `list_oracle_documents`: with the domain's document index in the prompt,
+  // a catalogue line alone did not get a model to look past that index. These
+  // serve a controller curating the oracle, or a user asking to forget, and
+  // carry most of the plugin's tool text.
+  onDemandTools: [
+    MEMORY_ADD_ORACLE_KNOWLEDGE_MCP_NAME,
+    MEMORY_DELETE_EPISODE_MCP_NAME,
+    MEMORY_DELETE_EDGE_MCP_NAME,
+    MEMORY_CLEAR_MCP_NAME,
+    ADD_ORACLE_DOCUMENT_TOOL_NAME,
+    DELETE_ORACLE_DOCUMENT_TOOL_NAME,
+  ],
   stability: 'stable',
   requires: [MEMORY_CAPABILITY],
 };