@dotdrelle/wiki-manager 0.15.66 → 0.15.71

package/src/orchestrator/dispatcher.test.js

@@ -1,6 +1,95 @@
 import assert from 'node:assert/strict';
 import test from 'node:test';
-import { createDispatcher, normalizeTaskError } from './dispatcher.js';
+import { activeProfileMcp, createDispatcher, normalizeTaskError } from './dispatcher.js';
+
+test('activeProfileMcp forwards only the read-only wiki tools to the external runtime', () => {
+  const session = {
+    mcp: {
+      wiki: {
+        url: 'http://wiki:3000/mcp',
+        status: 'connected',
+        token: 't',
+        tools: [
+          { name: 'wiki_read_page' },
+          { name: 'wiki_search_context' },
+          { name: 'wiki_workspace_status' },
+          { name: 'help_read' },
+          // every mutation tool must be dropped, including the ones the old
+          // substring denylist ("write_page|add_source|…") let through:
+          { name: 'wiki_write_page' },
+          { name: 'wiki_add_source' },
+          { name: 'profile_update' },
+          { name: 'template_write' },
+          { name: 'build_context_write' },
+          // and a hypothetical future mutation tool the denylist could not know:
+          { name: 'wiki_delete_page' },
+          { name: 'wiki_move_page' },
+        ],
+      },
+    },
+  };
+  const [pool] = activeProfileMcp(session);
+  assert.deepEqual(
+    [...pool.tools].sort(),
+    ['help_read', 'wiki_read_page', 'wiki_search_context', 'wiki_workspace_status'],
+  );
+});
+
+test('activeProfileMcp hands the external runtime a safe connector\'s read tools by word-boundary verb', () => {
+  const session = {
+    mcp: {
+      wiki: {
+        url: 'http://wiki:3000/mcp', status: 'connected',
+        tools: [{ name: 'wiki_read_page' }],
+      },
+      exa: {
+        url: 'https://exa/mcp', status: 'connected', external: true,
+        tools: [
+          { name: 'web_search_exa' },
+          { name: 'research_paper_search' },
+          // a raw substring denylist wrongly dropped these safe reads:
+          { name: 'list_recent_updates' },
+          { name: 'get_created_items' },
+          // …and wrongly kept these, which use a verb it did not enumerate:
+          { name: 'crawl_site' },
+          { name: 'post_message' },
+          { name: 'run_report' },
+          { name: 'send_email' },
+        ],
+      },
+    },
+  };
+  const exaBlock = activeProfileMcp(session).find((block) => block.name === 'exa');
+  assert.deepEqual(
+    [...exaBlock.tools].sort(),
+    ['get_created_items', 'list_recent_updates', 'research_paper_search', 'web_search_exa'],
+  );
+});
+
+test('activeProfileMcp drops an external connector that is approval-gated or workspace-mutating', () => {
+  const session = {
+    mcp: {
+      wiki: { url: 'http://wiki:3000/mcp', status: 'connected', tools: [{ name: 'wiki_read_page' }] },
+      gated: { url: 'https://g/mcp', status: 'connected', external: true, requireApproval: ['search'], tools: [{ name: 'search' }] },
+      documents: { url: 'https://d/mcp', status: 'connected', external: true, tools: [{ name: 'get_document' }] },
+    },
+  };
+  const names = activeProfileMcp(session).map((block) => block.name);
+  assert.deepEqual(names, ['wiki']);
+});
+
+test('activeProfileMcp tolerates namespaced tool names', () => {
+  const session = {
+    mcp: {
+      wiki: {
+        url: 'http://wiki:3000/mcp',
+        status: 'connected',
+        tools: [{ name: 'wiki__wiki_read_page' }, { name: 'wiki__wiki_write_page' }],
+      },
+    },
+  };
+  assert.deepEqual(activeProfileMcp(session)[0].tools, ['wiki__wiki_read_page']);
+});
 
 test('dispatcher returns a retryable logical failure when agent_execute reports workspace_busy', async () => {
   const session = {
@@ -197,13 +286,13 @@ test('normalizeTaskError keeps the agent reason as the message, never the fallba
   // Regression: the fallback describes only WHERE the failure was seen
   // ("agent_execute rejected task"). Letting it win discarded the one
   // actionable sentence — and left Donna to invent a cause.
-  const error = normalizeTaskError("Error: source 'acpi' not found", {
+  const error = normalizeTaskError("Error: source 'acme' not found", {
     fallbackCode: 'execution_rejected',
     fallbackMessage: 'agent_execute rejected task',
   });
 
-  assert.equal(error.code, "Error: source 'acpi' not found");
-  assert.equal(error.message, "Error: source 'acpi' not found");
+  assert.equal(error.code, "Error: source 'acme' not found");
+  assert.equal(error.message, "Error: source 'acme' not found");
 });
 
 test('normalizeTaskError falls back only when the agent reports no reason at all', () => {
@@ -215,3 +304,68 @@ test('normalizeTaskError falls back only when the agent reports no reason at all
   assert.equal(error.code, 'execution_rejected');
   assert.equal(error.message, 'agent_execute rejected task');
 });
+
+test('dispatcher passes confirm=true to agent_execute for an approval-gated task', async () => {
+  let executeArgs;
+  const session = {
+    workspace: 'test',
+    mcp: {
+      production: {
+        tools: [{ name: 'agent_execute' }, { name: 'agent_status' }, { name: 'agent_cancel' }],
+      },
+    },
+    activities: {},
+  };
+  const dispatcher = createDispatcher({
+    session,
+    pollIntervalMs: 1,
+    callTool: async (_mcp, _server, tool, args) => {
+      if (tool === 'agent_execute') {
+        executeArgs = args;
+        return { accepted: true, jobId: 'job-ingest', status: 'queued' };
+      }
+      return { jobId: 'job-ingest', status: 'succeeded', terminal: true, result: { status: 'succeeded' } };
+    },
+  });
+
+  await dispatcher.execute(
+    { id: 'ingest-a', requiredCapability: 'knowledge.update', operation: 'ingest_apply', arguments: {}, requiresApproval: true },
+    { serverName: 'production', agentInstanceId: 'production-main' },
+    { runId: 'run-donna-confirm', attempt: { attemptId: 'ingest-a:attempt-1', locks: [], release() {} } },
+  );
+
+  assert.equal(executeArgs.arguments.confirm, true, 'covered mutating task must carry confirm=true');
+  assert.equal(executeArgs.constraints.requireApprovalForMutations, true);
+});
+
+test('dispatcher does not invent confirm=true for a non-gated task', async () => {
+  let executeArgs;
+  const session = {
+    workspace: 'test',
+    mcp: {
+      production: {
+        tools: [{ name: 'agent_execute' }, { name: 'agent_status' }, { name: 'agent_cancel' }],
+      },
+    },
+    activities: {},
+  };
+  const dispatcher = createDispatcher({
+    session,
+    pollIntervalMs: 1,
+    callTool: async (_mcp, _server, tool, args) => {
+      if (tool === 'agent_execute') {
+        executeArgs = args;
+        return { accepted: true, jobId: 'job-doctor', status: 'queued' };
+      }
+      return { jobId: 'job-doctor', status: 'succeeded', terminal: true, result: { status: 'succeeded' } };
+    },
+  });
+
+  await dispatcher.execute(
+    { id: 'doctor-a', requiredCapability: 'workspace.diagnose', operation: 'doctor', arguments: {} },
+    { serverName: 'production', agentInstanceId: 'production-main' },
+    { runId: 'run-donna-doctor', attempt: { attemptId: 'doctor-a:attempt-1', locks: [], release() {} } },
+  );
+
+  assert.equal(executeArgs.arguments.confirm, undefined);
+});

package/src/orchestrator/objectiveResolver.js

@@ -113,11 +113,10 @@ function resolveMentionedRegistryOperation(objective, candidates) {
       // A capability with more than one operation may declare
       // aliasOperations, mapping the specific alias phrase that matched to
       // the operation it actually names. Without it, operations[0]
-      // (alphabetical) is a silent guess: for knowledge.concepts this always
-      // picked the destructive grid-rebuild "concepts" operation, even when
-      // the matched alias ("reclassify concepts", "file unclassified
-      // concepts") named the safe, mechanical "reclassify-concepts" one —
-      // making that operation structurally unreachable from natural language.
+      // (alphabetical) is a silent guess — a multi-operation capability's
+      // other operations become structurally unreachable from natural
+      // language, and the alphabetical first one may well be the destructive
+      // one.
       const operation = candidate.aliasOperations?.[matchedAlias] ?? candidate.operations[0];
       return { capability: candidate.id, operation };
     })
@@ -176,7 +175,10 @@ function registrySnapshot(session) {
   const registry = session?.capabilityRegistry;
   if (registry?.snapshot) return registry.snapshot();
   if (registry && typeof registry === 'object') return registry;
-  const agents = session?.agentRegistry?.snapshot?.() ?? session?.agentRegistrySnapshot ?? [];
+  const agents = [
+    ...(session?.agentRegistry?.snapshot?.() ?? session?.agentRegistrySnapshot ?? []),
+    ...(session?.runtimeProviderAgents ?? []),
+  ];
   const snapshot = {};
   for (const agent of agents) {
     for (const capability of agent?.description?.capabilities ?? []) {
@@ -187,6 +189,8 @@ function registrySnapshot(session) {
         capability,
         description: agent.description,
         health: agent.health,
+        providerKind: agent.providerKind ?? null,
+        runtimeProvider: agent.runtimeProvider ?? null,
       });
     }
   }

package/src/orchestrator/objectiveResolver.test.js

@@ -122,53 +122,52 @@ test('resolveObjective resolves diagnose via alias despite the notification "sen
   assert.equal(result.operation, 'doctor');
 });
 
-const concepts = makeCapability('knowledge.concepts', {
-  operations: ['concepts', 'reclassify-concepts'],
-  aliases: ['concept grid', 'reclassify concepts', 'file unclassified concepts'],
+const snapshot = makeCapability('data.snapshot', {
+  operations: ['snapshot', 'prune'],
+  aliases: ['take a snapshot', 'prune snapshots', 'clean old snapshots'],
   aliasOperations: {
-    'concept grid': 'concepts',
-    'reclassify concepts': 'reclassify-concepts',
-    'file unclassified concepts': 'reclassify-concepts',
+    'take a snapshot': 'snapshot',
+    'prune snapshots': 'prune',
+    'clean old snapshots': 'prune',
   },
-  description: 'Synthesize the concept grid or file unclassified pages into it.',
+  description: 'Take a snapshot of the workspace or prune old snapshots.',
 });
 
 /*
  Regression: with two operations, [...new Set(supportedOperations)].sort()
- alphabetizes to ["concepts", "reclassify-concepts"], so a naive alias hit
- defaulting to operations[0] would ALWAYS resolve to "concepts" — the
- destructive grid rebuild — even for aliases explicitly authored to reach the
- safe "reclassify-concepts" operation. aliasOperations must be consulted
- first.
+ alphabetizes to ["prune", "snapshot"], so a naive alias hit defaulting to
+ operations[0] would ALWAYS resolve to "prune" — the destructive operation —
+ even for aliases explicitly authored to reach the safe "snapshot" one.
+ aliasOperations must be consulted first.
 */
-test('resolveObjective routes "reclassify concepts" to reclassify-concepts, not operations[0]', async () => {
-  const session = sessionWith([provider('production-1', concepts)]);
+test('resolveObjective routes "prune snapshots" to prune, not operations[0]', async () => {
+  const session = sessionWith([provider('production-1', snapshot)]);
   session.llm.completeWithTools = async () => {
     throw new Error('the aliased operation must not depend on LLM selection');
   };
-  const result = await resolveObjective('Please reclassify concepts in the workspace', session);
-  assert.equal(result.capability, 'knowledge.concepts');
-  assert.equal(result.operation, 'reclassify-concepts');
+  const result = await resolveObjective('Please prune the old snapshots', session);
+  assert.equal(result.capability, 'data.snapshot');
+  assert.equal(result.operation, 'prune');
 });
 
-test('resolveObjective routes "file unclassified concepts" to reclassify-concepts', async () => {
-  const session = sessionWith([provider('production-1', concepts)]);
+test('resolveObjective routes "clean old snapshots" to prune', async () => {
+  const session = sessionWith([provider('production-1', snapshot)]);
   session.llm.completeWithTools = async () => {
     throw new Error('the aliased operation must not depend on LLM selection');
   };
-  const result = await resolveObjective('File unclassified concepts into the grid', session);
-  assert.equal(result.capability, 'knowledge.concepts');
-  assert.equal(result.operation, 'reclassify-concepts');
+  const result = await resolveObjective('Clean old snapshots of the workspace', session);
+  assert.equal(result.capability, 'data.snapshot');
+  assert.equal(result.operation, 'prune');
 });
 
-test('resolveObjective routes "concept grid" to the concepts operation', async () => {
-  const session = sessionWith([provider('production-1', concepts)]);
+test('resolveObjective routes "take a snapshot" to the snapshot operation', async () => {
+  const session = sessionWith([provider('production-1', snapshot)]);
   session.llm.completeWithTools = async () => {
     throw new Error('the aliased operation must not depend on LLM selection');
   };
-  const result = await resolveObjective('Rebuild the concept grid', session);
-  assert.equal(result.capability, 'knowledge.concepts');
-  assert.equal(result.operation, 'concepts');
+  const result = await resolveObjective('Take a snapshot of the workspace', session);
+  assert.equal(result.capability, 'data.snapshot');
+  assert.equal(result.operation, 'snapshot');
 });
 
 test('resolveObjective falls back to operations[0] when a matched alias has no aliasOperations entry', async () => {

package/src/orchestrator/providers/deepAgentsProvider.js

@@ -0,0 +1,168 @@
+import {
+  RUNTIME_PROTOCOL_VERSION,
+  RuntimeProviderUnavailableError,
+  normalizeRuntimeEvent,
+} from './runtimeProvider.js';
+
+/**
+ * DeepAgentsProvider — client HTTP vers un runtime Deep Agents externe
+ * (RFC § 11, option A). Implémente le contrat RuntimeProvider :
+ *
+ *   GET  {endpoint}/health             -> { ok, version? }       (describe)
+ *   GET  {endpoint}/capabilities       -> [{ name, operations }] (discover)
+ *   POST {endpoint}/runs               -> { runId, status }      (execute)
+ *   GET  {endpoint}/runs/:id           -> { runId, status, result? } (status)
+ *   POST {endpoint}/runs/:id/cancel    -> { ok }                 (cancel)
+ *   GET  {endpoint}/runs/:id/events    -> SSE `data: {json}`     (subscribe)
+ *
+ * `fetchImpl` est injectable pour les tests ; par défaut `globalThis.fetch`
+ * (Node 22 / Bun). Un runtime injoignable se manifeste par une `describe()`
+ * qui retourne `health: 'unavailable'` (jamais une exception) : l'isolation de
+ * panne du discovery s'appuie dessus.
+ */
+export function createDeepAgentsProvider({
+  id = 'deepagents',
+  endpoint = 'http://agent-runtime:7789',
+  capabilities = null,
+  fetchImpl = globalThis.fetch,
+  headers = {},
+  version = null,
+  timeoutMs = 10_000,
+} = {}) {
+  const base = String(endpoint).replace(/\/+$/, '');
+
+  async function httpJson(path, { method = 'GET', body = null, signal = null } = {}) {
+    const controller = new AbortController();
+    const timer = setTimeout(() => controller.abort(new Error(`timeout after ${timeoutMs}ms`)), timeoutMs);
+    const onAbort = () => controller.abort();
+    signal?.addEventListener?.('abort', onAbort, { once: true });
+    try {
+      const response = await fetchImpl(`${base}${path}`, {
+        method,
+        headers: { 'content-type': 'application/json', accept: 'application/json', ...headers },
+        ...(body !== null ? { body: JSON.stringify(body) } : {}),
+        signal: controller.signal,
+      });
+      if (!response.ok) {
+        throw new RuntimeProviderUnavailableError(id, `HTTP ${response.status} on ${method} ${path}`);
+      }
+      return await response.json();
+    } catch (error) {
+      if (error instanceof RuntimeProviderUnavailableError) throw error;
+      throw new RuntimeProviderUnavailableError(id, error instanceof Error ? error.message : String(error));
+    } finally {
+      clearTimeout(timer);
+      signal?.removeEventListener?.('abort', onAbort);
+    }
+  }
+
+  return {
+    async describe() {
+      let health = 'available';
+      let runtimeVersion = version ?? null;
+      let lastError = null;
+      try {
+        const info = await httpJson('/health');
+        runtimeVersion = info?.version ?? runtimeVersion;
+        health = info?.ok === false ? 'unavailable' : 'available';
+      } catch (error) {
+        health = 'unavailable';
+        lastError = error?.reason ?? (error instanceof Error ? error.message : String(error));
+      }
+      return {
+        runtime: id,
+        version: runtimeVersion ?? 'unknown',
+        protocolVersion: RUNTIME_PROTOCOL_VERSION,
+        health,
+        ...(lastError ? { error: lastError } : {}),
+      };
+    },
+    async discoverCapabilities() {
+      if (Array.isArray(capabilities)) return capabilities;
+      const list = await httpJson('/capabilities');
+      return Array.isArray(list) ? list : [];
+    },
+    async execute(request = {}) {
+      const accepted = await httpJson('/runs', {
+        method: 'POST',
+        body: {
+          objective: request.objective ?? request.input ?? null,
+          operation: request.operation ?? null,
+          capability: request.capability ?? null,
+          arguments: request.arguments ?? {},
+          workspace: request.workspace ?? null,
+          model: request.model ?? null,
+          language: request.language ?? null,
+          mcp: Array.isArray(request.mcp) ? request.mcp : [],
+          systemPrompt: request.systemPrompt ?? null,
+        },
+      });
+      const runId = String(accepted?.runId ?? '');
+      if (!runId) throw new RuntimeProviderUnavailableError(id, 'execute did not return runId');
+      return { runId, status: String(accepted?.status ?? 'running') };
+    },
+    async status(runId) {
+      const state = await httpJson(`/runs/${encodeURIComponent(String(runId))}`);
+      return {
+        runId: String(state?.runId ?? runId),
+        status: String(state?.status ?? 'running'),
+        ...(state?.result ? { result: state.result } : {}),
+        // The gateway reports its failure at the TOP level; dropping it here
+        // swallowed the only actionable sentence ("Unable to infer model
+        // provider…") and left the manager to invent a cause.
+        ...(state?.error ? { error: state.error } : {}),
+      };
+    },
+    async cancel(runId) {
+      await httpJson(`/runs/${encodeURIComponent(String(runId))}/cancel`, { method: 'POST' });
+    },
+    async approve(runId, { approved = true, reason = null, scope = null } = {}) {
+      await httpJson(`/runs/${encodeURIComponent(String(runId))}/approve`, {
+        method: 'POST',
+        body: {
+          approved: approved === true,
+          ...(reason ? { reason } : {}),
+          ...(scope ? { scope } : {}),
+        },
+      });
+    },
+    subscribe(runId, listener) {
+      const controller = new AbortController();
+      const url = `${base}/runs/${encodeURIComponent(String(runId))}/events`;
+      void (async () => {
+        try {
+          const response = await fetchImpl(url, {
+            headers: { accept: 'text/event-stream', ...headers },
+            signal: controller.signal,
+          });
+          if (!response.ok) throw new Error(`HTTP ${response.status}`);
+          const reader = response.body.getReader();
+          const decoder = new TextDecoder();
+          let buffer = '';
+          while (true) {
+            const { done, value } = await reader.read();
+            if (done) break;
+            buffer += decoder.decode(value, { stream: true });
+            const blocks = buffer.split('\n\n');
+            buffer = blocks.pop() ?? '';
+            for (const block of blocks) {
+              let data = '';
+              for (const line of block.split('\n')) {
+                if (line.startsWith('data: ')) data += line.slice(6);
+              }
+              if (!data) continue;
+              try {
+                listener(normalizeRuntimeEvent(JSON.parse(data)));
+              } catch {
+                // malformed or out-of-contract frame — skip
+              }
+            }
+          }
+        } catch {
+          // stream ended or aborted — the unsubscribe path is a no-op
+        }
+      })();
+      return () => controller.abort();
+    },
+  };
+}

package/src/orchestrator/providers/deepAgentsProvider.test.js

@@ -0,0 +1,178 @@
+import assert from 'node:assert/strict';
+import test from 'node:test';
+import { createDeepAgentsProvider } from './deepAgentsProvider.js';
+import { RUNTIME_PROTOCOL_VERSION, assertRuntimeProvider } from './runtimeProvider.js';
+import { resolveRuntimeProviders } from './runtimeProviders.js';
+
+function jsonResponse(status, data, ok = status < 400) {
+  return { ok, status, json: async () => data };
+}
+
+function mockFetch(routes) {
+  const calls = [];
+  const fetchImpl = async (url, options = {}) => {
+    const parsed = new URL(url);
+    const key = `${options.method ?? 'GET'} ${parsed.pathname}`;
+    calls.push({ method: options.method ?? 'GET', path: parsed.pathname, body: options.body, url });
+    const handler = routes[key];
+    if (!handler) return { ok: false, status: 404, json: async () => ({}) };
+    return handler(parsed, options);
+  };
+  fetchImpl.calls = calls;
+  return fetchImpl;
+}
+
+function sseBody(events) {
+  const encoder = new TextEncoder();
+  const chunks = events.map((event) => encoder.encode(`data: ${JSON.stringify(event)}\n\n`));
+  return new ReadableStream({
+    start(controller) {
+      for (const chunk of chunks) controller.enqueue(chunk);
+      controller.close();
+    },
+  });
+}
+
+async function waitFor(predicate, { timeoutMs = 1000 } = {}) {
+  const deadline = Date.now() + timeoutMs;
+  while (Date.now() < deadline) {
+    if (predicate()) return;
+    await new Promise((resolveDelay) => setTimeout(resolveDelay, 2));
+  }
+  throw new Error('condition not met in time');
+}
+
+test('describe reports available and reads the version from /health', async () => {
+  const fetchImpl = mockFetch({
+    'GET /health': () => jsonResponse(200, { ok: true, version: '0.6.10' }),
+  });
+  const provider = createDeepAgentsProvider({ id: 'deepagents', endpoint: 'http://agent-runtime:8080', fetchImpl });
+  assertRuntimeProvider(provider);
+
+  const description = await provider.describe();
+  assert.equal(description.runtime, 'deepagents');
+  assert.equal(description.version, '0.6.10');
+  assert.equal(description.protocolVersion, RUNTIME_PROTOCOL_VERSION);
+  assert.equal(description.health, 'available');
+});
+
+test('describe reports unavailable when /health fails, without throwing', async () => {
+  const fetchImpl = mockFetch({}); // every route 404
+  const provider = createDeepAgentsProvider({ id: 'deepagents', endpoint: 'http://agent-runtime:8080', fetchImpl });
+
+  const description = await provider.describe();
+  assert.equal(description.health, 'unavailable');
+  assert.ok(description.error, 'the reason is carried');
+});
+
+test('discoverCapabilities fetches /capabilities', async () => {
+  const fetchImpl = mockFetch({
+    'GET /capabilities': () => jsonResponse(200, [{ name: 'agent.review', operations: ['run'] }]),
+  });
+  const provider = createDeepAgentsProvider({ endpoint: 'http://agent-runtime:8080', fetchImpl });
+
+  assert.deepEqual(await provider.discoverCapabilities(), [{ name: 'agent.review', operations: ['run'] }]);
+});
+
+test('discoverCapabilities uses the static config when provided', async () => {
+  const fetchImpl = mockFetch({});
+  const provider = createDeepAgentsProvider({
+    endpoint: 'http://agent-runtime:8080',
+    capabilities: [{ name: 'agent.review', operations: ['run'] }],
+    fetchImpl,
+  });
+
+  assert.deepEqual(await provider.discoverCapabilities(), [{ name: 'agent.review', operations: ['run'] }]);
+  assert.equal(fetchImpl.calls.length, 0, 'no HTTP call when capabilities are static');
+});
+
+test('execute POSTs /runs and returns the runId', async () => {
+  const fetchImpl = mockFetch({
+    'POST /runs': () => jsonResponse(200, { runId: 'run-1', status: 'running' }),
+  });
+  const provider = createDeepAgentsProvider({ endpoint: 'http://agent-runtime:8080', fetchImpl });
+
+  const run = await provider.execute({
+    objective: 'analyze the demo workspace',
+    operation: 'run',
+    arguments: {},
+    model: { baseUrl: 'http://llm:11434/v1', model: 'qwen3:14b', apiKey: 'secret' },
+  });
+  assert.deepEqual(run, { runId: 'run-1', status: 'running' });
+  assert.equal(fetchImpl.calls[0].path, '/runs');
+  const sent = JSON.parse(fetchImpl.calls[0].body);
+  assert.equal(sent.objective, 'analyze the demo workspace');
+  assert.deepEqual(sent.model, { baseUrl: 'http://llm:11434/v1', model: 'qwen3:14b', apiKey: 'secret' });
+});
+
+test('status and cancel hit the run-scoped routes', async () => {
+  const fetchImpl = mockFetch({
+    'GET /runs/run-1': () => jsonResponse(200, { runId: 'run-1', status: 'completed', result: { status: 'completed' } }),
+    'POST /runs/run-1/cancel': () => jsonResponse(200, { ok: true }),
+  });
+  const provider = createDeepAgentsProvider({ endpoint: 'http://agent-runtime:8080', fetchImpl });
+
+  const status = await provider.status('run-1');
+  assert.equal(status.status, 'completed');
+  assert.equal(status.result.status, 'completed');
+
+  await provider.cancel('run-1');
+  assert.equal(fetchImpl.calls.at(-1).path, '/runs/run-1/cancel');
+});
+
+test('status forwards the top-level error reported by the gateway', async () => {
+  const fetchImpl = mockFetch({
+    'GET /runs/run-2': () => jsonResponse(200, { runId: 'run-2', status: 'failed', error: 'Unable to infer model provider' }),
+  });
+  const provider = createDeepAgentsProvider({ endpoint: 'http://agent-runtime:8080', fetchImpl });
+
+  const status = await provider.status('run-2');
+  assert.equal(status.status, 'failed');
+  assert.equal(status.error, 'Unable to infer model provider');
+});
+
+test('subscribe parses the SSE stream and forwards normalized events', async () => {
+  const fetchImpl = mockFetch({
+    'GET /runs/run-1/events': () => ({
+      ok: true,
+      status: 200,
+      body: sseBody([
+        { type: 'tool_started', tool: 'wiki_search' },
+        { type: 'tool_finished', tool: 'wiki_search', resultSummary: '17 found' },
+      ]),
+    }),
+  });
+  const provider = createDeepAgentsProvider({ endpoint: 'http://agent-runtime:8080', fetchImpl });
+
+  const events = [];
+  provider.subscribe('run-1', (event) => events.push(event));
+
+  await waitFor(() => events.length === 2);
+  assert.deepEqual(events.map((event) => event.type), ['tool_started', 'tool_finished']);
+  assert.equal(events[0].tool, 'wiki_search');
+});
+
+test('approve posts the decision to the run approval route', async () => {
+  const fetchImpl = mockFetch({
+    'POST /runs/run-1/approve': () => jsonResponse(200, { ok: true }),
+  });
+  const provider = createDeepAgentsProvider({ endpoint: 'http://agent-runtime:8080', fetchImpl });
+
+  await provider.approve('run-1', { approved: true, scope: ['email'] });
+
+  assert.equal(fetchImpl.calls.at(-1).path, '/runs/run-1/approve');
+  const sent = JSON.parse(fetchImpl.calls.at(-1).body);
+  assert.equal(sent.approved, true);
+  assert.deepEqual(sent.scope, ['email']);
+});
+
+test('the deepagents factory is reachable from the agentRuntimes config', () => {
+  const { providers, skipped } = resolveRuntimeProviders([
+    { id: 'deepagents', type: 'deepagents', endpoint: 'http://agent-runtime:8080', capabilities: [{ name: 'agent.review', operations: ['run'] }] },
+  ]);
+
+  assert.equal(skipped.length, 0);
+  assert.equal(providers.length, 1);
+  assert.equal(providers[0].type, 'deepagents');
+  assertRuntimeProvider(providers[0].provider);
+});