fix(mcp): preserve default backend for cloud spawn

Use the configured default backend when spawn_cloud_agent has no runtime profile backend, and add a SQLite-backed MCP smoke test covering config bootstrap, dispatch, logs, and results.

Author: vamgan

README.md

@@ -48,7 +48,7 @@ A single MCP server exposes nine tools to your assistant:
 
 | Tool | What it does |
 | --- | --- |
-| `spawn_cloud_agent` | The shortcut. One `instruction`, defaults from a runtime profile, returns a durable `task_id` and optional `cloud_agent` metadata. |
+| `spawn_cloud_agent` | The shortcut. One `instruction`, defaults from a runtime profile, returns a durable `taskId` and optional `cloudAgent` metadata. |
 | `dispatch_task` | The escape hatch. Full control over provider, capability, backend, target, and input. |
 | `get_task_status` | Current status for a dispatched task. |
 | `get_task_logs` | Paginated logs, cursor-based. |
@@ -62,7 +62,7 @@ The model side looks like this:
 
 ```ts
 spawn_cloud_agent({ instruction: "Audit our S3 buckets for public read and report findings." })
-// → { task_id: "task_...", status: "running", cloud_agent: { ... } }
+// → { taskId: "task_...", status: "queued", cloudAgent: { ... } }
 
 get_task_status({ task_id: "task_..." })
 get_task_logs({ task_id: "task_...", cursor: 0, limit: 200 })
@@ -75,6 +75,8 @@ All tool inputs are validated with [Zod](https://zod.dev). See [`src/schemas.ts`
 
 `spawn_cloud_agent` is intentionally small. Runtime profiles supply the provider, account, backend, target mode, framework, model, protocol, and default tools.
 
+Tool inputs use MCP-friendly snake_case. Responses return the same camelCase object shape as the AgentDispatch SDK and core runtime.
+
 ```json
 {
   "runtime": "research-agent",
@@ -91,21 +93,22 @@ Immediate response:
 
 ```json
 {
-  "task_id": "task_...",
-  "status": "running",
+  "taskId": "task_...",
+  "status": "queued",
   "provider": "aws",
-  "account_profile": "dev-aws",
+  "accountProfile": "dev-aws",
   "capability": "agent-runtime",
   "backend": "aws-agentcore",
   "poll": {
-    "status_tool": "get_task_status",
-    "logs_tool": "get_task_logs",
-    "result_tool": "get_task_result"
+    "statusTool": "get_task_status",
+    "logsTool": "get_task_logs",
+    "resultTool": "get_task_result"
   },
-  "cloud_agent": {
+  "cloudAgent": {
     "protocol": "a2a",
     "provider": "aws",
     "backend": "aws-agentcore",
+    "accountProfile": "dev-aws",
     "sessionId": "ad-f7221e93f25499a0a1fc0160f63c7621",
     "invocation": {
       "type": "aws.agentcore.invoke_agent_runtime",
@@ -203,7 +206,7 @@ The defaults come from your runtime profile. From the model side, `spawn_cloud_a
 3. Core picks the capability and adapter, persists the task, dispatches.
 4. Adapter invokes the worker in your cloud.
 5. Worker runs an agent framework on managed cloud infrastructure.
-6. Status, logs, results, and optional `cloud_agent` metadata flow back through the same path.
+6. Status, logs, results, and optional `cloudAgent` metadata flow back through the same path.
 
 ## Configuration
 
@@ -261,7 +264,7 @@ npx agentdispatch-mcp --config agentdispatch.config.json --check
 `spawn_cloud_agent` is the control-plane call. After spawn, the lead agent can:
 
 - Poll via `get_task_status`, `get_task_logs`, and `get_task_result`.
-- Continue native subagent interaction with returned `cloud_agent` protocol metadata.
+- Continue native subagent interaction with returned `cloudAgent` protocol metadata.
 - Use A2A JSON-RPC `message/send` when the runtime protocol is `a2a`.
 - Cancel through AgentDispatch so provider references remain durable.
 

src/index.ts

@@ -76,11 +76,12 @@ function createSpawnCloudAgentRequest(runtime: RuntimeService, input: {
   const targetMode = input.target?.mode ?? profile?.target?.mode ?? defaults.targetMode ?? "session";
   const protocol = input.protocol ?? input.target?.protocol ?? profile?.protocol ?? profile?.target?.protocol ?? defaults.protocol;
   const capability = selectCapability(runtime, account.provider, targetMode, profile?.capability ?? defaults.capability);
+  const backend = profile?.backend ?? defaults.backend;
   return {
     provider: account.provider,
     accountProfile: account.name,
     capability,
-    backend: profile?.backend,
+    backend,
     taskType: "agent.run",
     target: {
       mode: targetMode,

test/e2e.test.ts

@@ -1,8 +1,17 @@
 import { Client } from "@modelcontextprotocol/sdk/client/index.js";
 import { InMemoryTransport } from "@modelcontextprotocol/sdk/inMemory.js";
-import { describe, expect, it } from "vitest";
+import { mkdtemp, rm } from "node:fs/promises";
+import { join } from "node:path";
+import { tmpdir } from "node:os";
+import { afterEach, describe, expect, it } from "vitest";
 import { RuntimeService, type BackendAdapter, type DispatchRequest, type RuntimeEvent, type RuntimeRecord, type TaskStore } from "@agent-dispatch/core";
-import { createAgentDispatchMcpServer } from "../src/index.js";
+import { createAgentDispatchMcpServer, createRuntimeServiceFromConfig } from "../src/index.js";
+
+const tempDirs: string[] = [];
+
+afterEach(async () => {
+  await Promise.all(tempDirs.splice(0).map((dir) => rm(dir, { recursive: true, force: true })));
+});
 
 class MemoryStore implements TaskStore {
   private readonly tasks = new Map<string, any>();
@@ -252,4 +261,77 @@ describe("MCP tool invocation", () => {
       await server.close();
     }
   });
+
+  it("runs spawn_cloud_agent end-to-end through config bootstrap and SQLite state", async () => {
+    const stateDir = await mkdtemp(join(tmpdir(), "agentdispatch-mcp-e2e-"));
+    tempDirs.push(stateDir);
+    const runtime = await createRuntimeServiceFromConfig({
+      stateDir,
+      accounts: {
+        "dev-aws": { provider: "aws", region: "us-west-2", credentialSource: "aws-sdk-default" }
+      },
+      backends: {
+        "mock-backend": {
+          provider: "aws",
+          capability: "agent-runtime",
+          adapter: "mock-agent-runtime",
+          account: "dev-aws"
+        }
+      },
+      defaults: {
+        provider: "aws",
+        accountProfile: "dev-aws",
+        capability: "agent-runtime",
+        backend: "mock-backend",
+        targetMode: "session",
+        protocol: "a2a",
+        framework: "smoke",
+        model: { provider: "test", modelId: "smoke-model" },
+        runtimeTools: { enabled: ["repo-search"] }
+      }
+    }, {
+      adapters: [mockAdapter([{ taskId: "ignored", type: "task.log", message: "sqlite smoke log" }])]
+    });
+    const { client, server } = await createClient(runtime);
+    try {
+      const handle = await callJson(client, "spawn_cloud_agent", {
+        instruction: "run SQLite-backed smoke path",
+        context: { repo: "agent-dispatch" }
+      });
+      expect(handle).toMatchObject({
+        provider: "aws",
+        accountProfile: "dev-aws",
+        capability: "agent-runtime",
+        backend: "mock-agent-runtime",
+        cloudAgent: {
+          protocol: "a2a",
+          sessionId: "agentcore_session_mock"
+        }
+      });
+
+      const task = await waitForTerminalStatus(client, handle.taskId);
+      expect(task).toMatchObject({
+        status: "succeeded",
+        taskType: "agent.run",
+        target: { mode: "session", protocol: "a2a" },
+        input: {
+          instruction: "run SQLite-backed smoke path",
+          context: { repo: "agent-dispatch" },
+          framework: "smoke",
+          model: { provider: "test", modelId: "smoke-model" },
+          runtime_tools: { enabled: ["repo-search"] }
+        }
+      });
+      await expect(callJson(client, "get_task_logs", { task_id: handle.taskId })).resolves.toMatchObject({
+        data: "sqlite smoke log\n"
+      });
+      await expect(callJson(client, "get_task_result", { task_id: handle.taskId })).resolves.toMatchObject({
+        status: "succeeded",
+        result: { ok: true }
+      });
+    } finally {
+      await client.close();
+      await server.close();
+    }
+  });
 });