@apicircle/mcp-server 1.0.0

package/dist/index.cjs

@@ -0,0 +1,2527 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  FileBackedWorkspaceProvider: () => FileBackedWorkspaceProvider,
+  InMemoryWorkspaceProvider: () => InMemoryWorkspaceProvider,
+  InProcessMockController: () => InProcessMockController,
+  McpHost: () => McpHost,
+  TOOL_REGISTRY: () => TOOL_REGISTRY,
+  createMcpServer: () => createMcpServer,
+  getTool: () => getTool
+});
+module.exports = __toCommonJS(index_exports);
+
+// src/host/McpHost.ts
+var import_mcp = require("@modelcontextprotocol/sdk/server/mcp.js");
+var import_stdio = require("@modelcontextprotocol/sdk/server/stdio.js");
+var import_zod = require("zod");
+var PACKAGE_NAME = "apicircle-mcp";
+var PACKAGE_VERSION = "1.0.0";
+var McpHost = class {
+  server;
+  tools;
+  context;
+  constructor(options) {
+    this.server = new import_mcp.McpServer({
+      name: options.serverInfo?.name ?? PACKAGE_NAME,
+      version: options.serverInfo?.version ?? PACKAGE_VERSION
+    });
+    this.tools = options.tools;
+    this.context = options.context;
+    this.registerAll();
+  }
+  registerAll() {
+    for (const tool of this.tools) {
+      const shape = isZodObject(tool.inputSchema) ? tool.inputSchema.shape : void 0;
+      this.server.registerTool(
+        tool.name,
+        {
+          description: tool.description,
+          ...shape ? { inputSchema: shape } : {}
+        },
+        async (args) => {
+          try {
+            const parsed = tool.inputSchema.parse(args ?? {});
+            const result = await tool.handler(parsed, this.context);
+            return {
+              content: [
+                {
+                  type: "text",
+                  text: JSON.stringify(result, null, 2)
+                }
+              ]
+            };
+          } catch (err) {
+            return {
+              isError: true,
+              content: [
+                {
+                  type: "text",
+                  text: formatError(err)
+                }
+              ]
+            };
+          }
+        }
+      );
+    }
+  }
+  /** Connect the underlying server to a transport (defaults to stdio). */
+  async connect(transport) {
+    await this.server.connect(transport ?? new import_stdio.StdioServerTransport());
+  }
+  async close() {
+    await this.server.close();
+  }
+};
+function isZodObject(schema) {
+  return schema instanceof import_zod.z.ZodObject;
+}
+function formatError(err) {
+  if (err instanceof import_zod.z.ZodError) {
+    return `Validation failed: ${err.issues.map((i) => `${i.path.join(".") || "<root>"}: ${i.message}`).join("; ")}`;
+  }
+  if (err instanceof Error) return err.message;
+  return String(err);
+}
+
+// src/tools/imports.ts
+var import_zod2 = require("zod");
+var import_shared = require("@apicircle/shared");
+var import_core = require("@apicircle/core");
+var import_mock_server_core = require("@apicircle/mock-server-core");
+var FALLBACK_NAME = (idx, fallback) => fallback || `Imported request ${idx + 1}`;
+function blankRequest() {
+  return {
+    name: "Imported request",
+    folderId: null,
+    method: "GET",
+    url: "",
+    headers: [],
+    query: [],
+    body: { type: "none", content: "" },
+    auth: { type: "none" },
+    contextVars: [],
+    extractions: [],
+    assertions: []
+  };
+}
+var importCurlTool = {
+  name: "import.curl",
+  description: "Parse a `curl ...` command into a Request and persist it to the workspace.",
+  inputSchema: import_zod2.z.object({
+    curl: import_zod2.z.string().min(1, "curl command is required"),
+    name: import_zod2.z.string().optional(),
+    folderId: import_zod2.z.string().nullable().optional()
+  }),
+  async handler(input, ctx) {
+    const parsed = (0, import_core.parseCurl)(input.curl);
+    const now = (/* @__PURE__ */ new Date()).toISOString();
+    const request = {
+      ...blankRequest(),
+      id: (0, import_shared.generateId)(),
+      name: input.name?.trim() || `cURL ${parsed.method} ${parsed.url}`.slice(0, 80),
+      method: parsed.method,
+      url: parsed.url,
+      headers: parsed.headers,
+      query: parsed.query,
+      body: parsed.body,
+      auth: parsed.auth,
+      folderId: input.folderId ?? null,
+      createdAt: now,
+      updatedAt: now
+    };
+    const out = await ctx.workspace.apply({ kind: "request.create", request });
+    return {
+      id: request.id,
+      warnings: parsed.warnings,
+      changedIds: out.changedIds
+    };
+  }
+};
+var importOpenApiTool = {
+  name: "import.openapi",
+  description: "Parse an OpenAPI / Swagger spec (YAML or JSON) and create one Request per operation. Returns the list of created request ids.",
+  inputSchema: import_zod2.z.object({
+    spec: import_zod2.z.string().min(1),
+    format: import_zod2.z.enum(["json", "yaml"]).default("json"),
+    folderId: import_zod2.z.string().nullable().optional()
+  }),
+  async handler(input, ctx) {
+    const parsed = await (0, import_mock_server_core.parseOpenApiToEndpoints)(input.spec, input.format);
+    const ids = [];
+    for (let i = 0; i < parsed.endpoints.length; i++) {
+      const ep = parsed.endpoints[i];
+      const now = (/* @__PURE__ */ new Date()).toISOString();
+      const req = {
+        ...blankRequest(),
+        id: (0, import_shared.generateId)(),
+        name: FALLBACK_NAME(i, ep.example ?? `${ep.method} ${ep.pathPattern}`),
+        method: ep.method,
+        url: ep.pathPattern,
+        folderId: input.folderId ?? null,
+        createdAt: now,
+        updatedAt: now
+      };
+      await ctx.workspace.apply({ kind: "request.create", request: req });
+      ids.push(req.id);
+    }
+    return { createdIds: ids, warnings: parsed.warnings };
+  }
+};
+var importPostmanTool = {
+  name: "import.postman",
+  description: "Parse a Postman v2/v2.1 collection JSON and create one Request per item.",
+  inputSchema: import_zod2.z.object({
+    collection: import_zod2.z.string().min(1),
+    folderId: import_zod2.z.string().nullable().optional()
+  }),
+  async handler(input, ctx) {
+    const parsed = (0, import_mock_server_core.parsePostmanToEndpoints)(input.collection);
+    const ids = [];
+    for (let i = 0; i < parsed.endpoints.length; i++) {
+      const ep = parsed.endpoints[i];
+      const now = (/* @__PURE__ */ new Date()).toISOString();
+      const req = {
+        ...blankRequest(),
+        id: (0, import_shared.generateId)(),
+        name: FALLBACK_NAME(i, ep.example ?? `${ep.method} ${ep.pathPattern}`),
+        method: ep.method,
+        url: ep.pathPattern,
+        folderId: input.folderId ?? null,
+        createdAt: now,
+        updatedAt: now
+      };
+      await ctx.workspace.apply({ kind: "request.create", request: req });
+      ids.push(req.id);
+    }
+    return { createdIds: ids, warnings: parsed.warnings };
+  }
+};
+var importInsomniaTool = {
+  name: "import.insomnia",
+  description: 'Parse an Insomnia v4 export and create one Request per resource of type "request".',
+  inputSchema: import_zod2.z.object({
+    export: import_zod2.z.string().min(1),
+    folderId: import_zod2.z.string().nullable().optional()
+  }),
+  async handler(input, ctx) {
+    const parsed = (0, import_mock_server_core.parseInsomniaToEndpoints)(input.export);
+    const ids = [];
+    for (let i = 0; i < parsed.endpoints.length; i++) {
+      const ep = parsed.endpoints[i];
+      const now = (/* @__PURE__ */ new Date()).toISOString();
+      const req = {
+        ...blankRequest(),
+        id: (0, import_shared.generateId)(),
+        name: FALLBACK_NAME(i, ep.example ?? `${ep.method} ${ep.pathPattern}`),
+        method: ep.method,
+        url: ep.pathPattern,
+        folderId: input.folderId ?? null,
+        createdAt: now,
+        updatedAt: now
+      };
+      await ctx.workspace.apply({ kind: "request.create", request: req });
+      ids.push(req.id);
+    }
+    return { createdIds: ids, warnings: parsed.warnings };
+  }
+};
+var importHarTool = {
+  name: "import.har",
+  description: "Parse an HTTP Archive (.har) JSON and create one Request per recorded entry. Cookies, response, and timings are dropped.",
+  inputSchema: import_zod2.z.object({
+    har: import_zod2.z.string().min(1),
+    folderId: import_zod2.z.string().nullable().optional()
+  }),
+  async handler(input, ctx) {
+    let parsed;
+    try {
+      parsed = JSON.parse(input.har);
+    } catch (err) {
+      return { createdIds: [], warnings: [`HAR parse error: ${err.message}`] };
+    }
+    const entries = parsed.log?.entries ?? [];
+    const ids = [];
+    const warnings = [];
+    for (let i = 0; i < entries.length; i++) {
+      const e = entries[i].request;
+      if (!e || !e.url || !e.method) {
+        warnings.push(`Entry #${i} missing method/url; skipped`);
+        continue;
+      }
+      const url = new URL(e.url);
+      const now = (/* @__PURE__ */ new Date()).toISOString();
+      const req = {
+        ...blankRequest(),
+        id: (0, import_shared.generateId)(),
+        name: `${e.method} ${url.pathname}`,
+        method: e.method,
+        url: e.url,
+        headers: (e.headers ?? []).map((h) => ({
+          key: h.name,
+          value: h.value,
+          enabled: true
+        })),
+        query: (e.queryString ?? []).map((q) => ({
+          key: q.name,
+          value: q.value,
+          enabled: true
+        })),
+        body: e.postData ? { type: "text", content: e.postData.text ?? "" } : { type: "none", content: "" },
+        folderId: input.folderId ?? null,
+        createdAt: now,
+        updatedAt: now
+      };
+      await ctx.workspace.apply({ kind: "request.create", request: req });
+      ids.push(req.id);
+    }
+    return { createdIds: ids, warnings };
+  }
+};
+
+// src/tools/codegen.ts
+var import_zod3 = require("zod");
+var TARGET = import_zod3.z.enum(["curl", "fetch", "node-axios", "python-requests", "go", "rust"]);
+var generateCodeTool = {
+  name: "generate.code",
+  description: "Generate runnable code (curl / JavaScript fetch / Node Axios / Python requests / Go net/http / Rust reqwest) that reproduces a workspace request.",
+  inputSchema: import_zod3.z.object({
+    requestId: import_zod3.z.string(),
+    target: TARGET
+  }),
+  async handler(input, ctx) {
+    const state = await ctx.workspace.read();
+    const req = state.synced.collections.requests[input.requestId];
+    if (!req) return { ok: false, error: "request not found" };
+    const code = renderCode(req, input.target);
+    return { ok: true, target: input.target, code };
+  }
+};
+function renderCode(req, target) {
+  switch (target) {
+    case "curl":
+      return renderCurl(req);
+    case "fetch":
+      return renderFetch(req);
+    case "node-axios":
+      return renderAxios(req);
+    case "python-requests":
+      return renderPython(req);
+    case "go":
+      return renderGo(req);
+    case "rust":
+      return renderRust(req);
+  }
+}
+function fullUrl(req) {
+  if (!req.query.length) return req.url;
+  const enabled = req.query.filter((q) => q.enabled !== false);
+  if (!enabled.length) return req.url;
+  const sep = req.url.includes("?") ? "&" : "?";
+  return req.url + sep + enabled.map((q) => `${encodeURIComponent(q.key)}=${encodeURIComponent(q.value)}`).join("&");
+}
+function bodyContent(req) {
+  if (req.body.type === "none") return null;
+  if (req.body.type === "json" || req.body.type === "text" || req.body.type === "xml") {
+    return req.body.content;
+  }
+  if (req.body.type === "graphql") {
+    return JSON.stringify({ query: req.body.content, variables: req.body.variables ?? null });
+  }
+  if (req.body.type === "urlencoded") return req.body.content;
+  return null;
+}
+function renderCurl(req) {
+  const parts = [`curl -X ${req.method} '${fullUrl(req)}'`];
+  for (const h of req.headers.filter((x) => x.enabled !== false)) {
+    parts.push(`-H '${h.key}: ${h.value}'`);
+  }
+  const body = bodyContent(req);
+  if (body !== null) {
+    parts.push(`--data-raw '${body.replace(/'/g, "'\\''")}'`);
+  }
+  return parts.join(" \\\n  ");
+}
+function renderFetch(req) {
+  const headers = Object.fromEntries(
+    req.headers.filter((h) => h.enabled !== false).map((h) => [h.key, h.value])
+  );
+  const body = bodyContent(req);
+  const init = { method: req.method };
+  if (Object.keys(headers).length) init.headers = headers;
+  if (body !== null) init.body = body;
+  return `await fetch(${JSON.stringify(fullUrl(req))}, ${JSON.stringify(init, null, 2)})`;
+}
+function renderAxios(req) {
+  const config = {
+    method: req.method.toLowerCase(),
+    url: fullUrl(req)
+  };
+  const headers = req.headers.filter((h) => h.enabled !== false);
+  if (headers.length) config.headers = Object.fromEntries(headers.map((h) => [h.key, h.value]));
+  const body = bodyContent(req);
+  if (body !== null) config.data = body;
+  return `import axios from 'axios';
+
+const response = await axios(${JSON.stringify(
+    config,
+    null,
+    2
+  )});`;
+}
+function renderPython(req) {
+  const headers = req.headers.filter((h) => h.enabled !== false);
+  const body = bodyContent(req);
+  const lines = ["import requests", ""];
+  lines.push(`response = requests.request(`);
+  lines.push(`    method=${JSON.stringify(req.method)},`);
+  lines.push(`    url=${JSON.stringify(fullUrl(req))},`);
+  if (headers.length) {
+    lines.push(
+      `    headers=${JSON.stringify(Object.fromEntries(headers.map((h) => [h.key, h.value])))},`
+    );
+  }
+  if (body !== null) lines.push(`    data=${JSON.stringify(body)},`);
+  lines.push(")");
+  return lines.join("\n");
+}
+function renderGo(req) {
+  const headers = req.headers.filter((h) => h.enabled !== false);
+  const body = bodyContent(req);
+  const lines = [
+    "package main",
+    "",
+    "import (",
+    '    "io"',
+    '    "net/http"',
+    '    "strings"',
+    ")",
+    "",
+    "func main() {"
+  ];
+  if (body !== null) {
+    lines.push(`    body := strings.NewReader(${JSON.stringify(body)})`);
+    lines.push(
+      `    req, _ := http.NewRequest(${JSON.stringify(req.method)}, ${JSON.stringify(fullUrl(req))}, body)`
+    );
+  } else {
+    lines.push(
+      `    req, _ := http.NewRequest(${JSON.stringify(req.method)}, ${JSON.stringify(fullUrl(req))}, nil)`
+    );
+  }
+  for (const h of headers) {
+    lines.push(`    req.Header.Set(${JSON.stringify(h.key)}, ${JSON.stringify(h.value)})`);
+  }
+  lines.push("    resp, _ := http.DefaultClient.Do(req)");
+  lines.push("    defer resp.Body.Close()");
+  lines.push("    out, _ := io.ReadAll(resp.Body)");
+  lines.push("    _ = out");
+  lines.push("}");
+  return lines.join("\n");
+}
+function renderRust(req) {
+  const headers = req.headers.filter((h) => h.enabled !== false);
+  const body = bodyContent(req);
+  const lines = [
+    "use reqwest::Client;",
+    "",
+    "#[tokio::main]",
+    "async fn main() -> Result<(), Box<dyn std::error::Error>> {",
+    `    let client = Client::new();`,
+    `    let mut req = client.request(reqwest::Method::${req.method}, ${JSON.stringify(
+      fullUrl(req)
+    )});`
+  ];
+  for (const h of headers) {
+    lines.push(`    req = req.header(${JSON.stringify(h.key)}, ${JSON.stringify(h.value)});`);
+  }
+  if (body !== null) lines.push(`    req = req.body(${JSON.stringify(body)});`);
+  lines.push("    let _resp = req.send().await?;");
+  lines.push("    Ok(())");
+  lines.push("}");
+  return lines.join("\n");
+}
+
+// src/tools/crud.ts
+var import_zod4 = require("zod");
+var import_shared2 = require("@apicircle/shared");
+var HTTP_METHOD = import_zod4.z.enum(["GET", "POST", "PUT", "PATCH", "DELETE", "HEAD", "OPTIONS"]);
+var requestCreateTool = {
+  name: "request.create",
+  description: "Create a new request from explicit fields and persist it.",
+  inputSchema: import_zod4.z.object({
+    name: import_zod4.z.string().default("New request"),
+    method: HTTP_METHOD.default("GET"),
+    url: import_zod4.z.string().default(""),
+    folderId: import_zod4.z.string().nullable().optional()
+  }),
+  async handler(input, ctx) {
+    const now = (/* @__PURE__ */ new Date()).toISOString();
+    const request = {
+      id: (0, import_shared2.generateId)(),
+      name: input.name,
+      folderId: input.folderId ?? null,
+      method: input.method,
+      url: input.url,
+      headers: [],
+      query: [],
+      body: { type: "none", content: "" },
+      // Default to `inherit` so requests created via MCP inside a folder
+      // pick up folder auth automatically. Mirrors editorActions.createRequest.
+      auth: { type: "inherit" },
+      contextVars: [],
+      extractions: [],
+      assertions: [],
+      createdAt: now,
+      updatedAt: now
+    };
+    const out = await ctx.workspace.apply({ kind: "request.create", request });
+    return { id: request.id, changedIds: out.changedIds };
+  }
+};
+var requestReadTool = {
+  name: "request.read",
+  description: "Read a request by id, or list summaries (id, name, method, url) when no id is provided.",
+  inputSchema: import_zod4.z.object({ id: import_zod4.z.string().optional() }),
+  async handler(input, ctx) {
+    const state = await ctx.workspace.read();
+    if (input.id) {
+      const req = state.synced.collections.requests[input.id];
+      if (!req) return { found: false };
+      return { found: true, request: req };
+    }
+    const list = Object.values(state.synced.collections.requests).map((r) => ({
+      id: r.id,
+      name: r.name,
+      method: r.method,
+      url: r.url,
+      folderId: r.folderId
+    }));
+    return { count: list.length, requests: list };
+  }
+};
+var requestUpdateTool = {
+  name: "request.update",
+  description: "Patch fields on an existing request.",
+  inputSchema: import_zod4.z.object({
+    id: import_zod4.z.string(),
+    patch: import_zod4.z.object({
+      name: import_zod4.z.string().optional(),
+      method: HTTP_METHOD.optional(),
+      url: import_zod4.z.string().optional(),
+      folderId: import_zod4.z.string().nullable().optional()
+    }).strict()
+  }),
+  async handler(input, ctx) {
+    const out = await ctx.workspace.apply({
+      kind: "request.update",
+      id: input.id,
+      patch: input.patch
+    });
+    return { changedIds: out.changedIds };
+  }
+};
+var requestDeleteTool = {
+  name: "request.delete",
+  description: "Delete a request by id.",
+  inputSchema: import_zod4.z.object({ id: import_zod4.z.string() }),
+  async handler(input, ctx) {
+    const out = await ctx.workspace.apply({ kind: "request.delete", id: input.id });
+    return { changedIds: out.changedIds };
+  }
+};
+var folderCreateTool = {
+  name: "folder.create",
+  description: "Create a folder under an optional parent folder.",
+  inputSchema: import_zod4.z.object({
+    name: import_zod4.z.string().default("New folder"),
+    parentId: import_zod4.z.string().nullable().optional()
+  }),
+  async handler(input, ctx) {
+    const folder = {
+      id: (0, import_shared2.generateId)(),
+      name: input.name,
+      parentId: input.parentId ?? null
+    };
+    const out = await ctx.workspace.apply({ kind: "folder.create", folder });
+    return { id: folder.id, changedIds: out.changedIds };
+  }
+};
+var folderReadTool = {
+  name: "folder.read",
+  description: "Read a folder by id, or list all folders when no id is provided.",
+  inputSchema: import_zod4.z.object({ id: import_zod4.z.string().optional() }),
+  async handler(input, ctx) {
+    const state = await ctx.workspace.read();
+    if (input.id) {
+      const folder = state.synced.collections.folders[input.id];
+      return folder ? { found: true, folder } : { found: false };
+    }
+    return {
+      count: Object.keys(state.synced.collections.folders).length,
+      folders: Object.values(state.synced.collections.folders)
+    };
+  }
+};
+var folderUpdateTool = {
+  name: "folder.update",
+  description: "Move a folder to a new parent (or to root with parentId: null).",
+  inputSchema: import_zod4.z.object({
+    id: import_zod4.z.string(),
+    parentId: import_zod4.z.string().nullable()
+  }),
+  async handler(input, ctx) {
+    const out = await ctx.workspace.apply({
+      kind: "folder.move",
+      id: input.id,
+      newParentId: input.parentId
+    });
+    return { changedIds: out.changedIds };
+  }
+};
+var folderDeleteTool = {
+  name: "folder.delete",
+  description: "Delete a folder. Direct children (sub-folders + requests) are reparented to the deleted folder's parent.",
+  inputSchema: import_zod4.z.object({ id: import_zod4.z.string() }),
+  async handler(input, ctx) {
+    const out = await ctx.workspace.apply({ kind: "folder.delete", id: input.id });
+    return { changedIds: out.changedIds };
+  }
+};
+var VARIABLE = import_zod4.z.object({
+  key: import_zod4.z.string(),
+  value: import_zod4.z.string(),
+  encrypted: import_zod4.z.boolean().default(false)
+});
+var environmentCreateTool = {
+  name: "environment.create",
+  description: "Create a new environment (or upsert one with the same name).",
+  inputSchema: import_zod4.z.object({
+    name: import_zod4.z.string(),
+    variables: import_zod4.z.array(VARIABLE).default([])
+  }),
+  async handler(input, ctx) {
+    const env = { name: input.name, variables: input.variables };
+    const out = await ctx.workspace.apply({ kind: "environment.upsert", environment: env });
+    return { name: env.name, changedIds: out.changedIds };
+  }
+};
+var environmentReadTool = {
+  name: "environment.read",
+  description: "Read environments \u2014 pass `name` for one, or omit for the full list.",
+  inputSchema: import_zod4.z.object({ name: import_zod4.z.string().optional() }),
+  async handler(input, ctx) {
+    const state = await ctx.workspace.read();
+    if (input.name) {
+      const env = state.synced.environments.items[input.name];
+      return env ? { found: true, environment: env } : { found: false };
+    }
+    return {
+      activeName: state.synced.environments.activeName,
+      priorityOrder: state.synced.environments.priorityOrder,
+      environments: Object.values(state.synced.environments.items)
+    };
+  }
+};
+var environmentUpdateTool = {
+  name: "environment.update",
+  description: "Replace the variables list of an environment.",
+  inputSchema: import_zod4.z.object({
+    name: import_zod4.z.string(),
+    variables: import_zod4.z.array(VARIABLE)
+  }),
+  async handler(input, ctx) {
+    const out = await ctx.workspace.apply({
+      kind: "environment.upsert",
+      environment: { name: input.name, variables: input.variables }
+    });
+    return { changedIds: out.changedIds };
+  }
+};
+var environmentDeleteTool = {
+  name: "environment.delete",
+  description: "Delete an environment by name.",
+  inputSchema: import_zod4.z.object({ name: import_zod4.z.string() }),
+  async handler(input, ctx) {
+    const out = await ctx.workspace.apply({ kind: "environment.delete", name: input.name });
+    return { changedIds: out.changedIds };
+  }
+};
+var environmentSetActiveTool = {
+  name: "environment.set_active",
+  description: "Set (or clear) the active environment. Pass `name: null` to deactivate the current environment.",
+  inputSchema: import_zod4.z.object({ name: import_zod4.z.string().nullable() }),
+  async handler(input, ctx) {
+    const out = await ctx.workspace.apply({
+      kind: "environment.setActive",
+      name: input.name
+    });
+    return { changedIds: out.changedIds };
+  }
+};
+var environmentSetPriorityTool = {
+  name: "environment.set_priority",
+  description: 'Replace the global environment priority order (highest priority first). Strings are interpreted as local env names. To target a linked env, pass `{ kind: "linked", linkedWorkspaceId, envName }` instead.',
+  inputSchema: import_zod4.z.object({
+    order: import_zod4.z.array(
+      import_zod4.z.union([
+        import_zod4.z.string(),
+        import_zod4.z.object({
+          kind: import_zod4.z.literal("local"),
+          name: import_zod4.z.string()
+        }),
+        import_zod4.z.object({
+          kind: import_zod4.z.literal("linked"),
+          linkedWorkspaceId: import_zod4.z.string(),
+          envName: import_zod4.z.string()
+        })
+      ])
+    )
+  }),
+  async handler(input, ctx) {
+    const order = input.order.map((entry) => typeof entry === "string" ? { kind: "local", name: entry } : entry);
+    const out = await ctx.workspace.apply({
+      kind: "environment.setPriority",
+      order
+    });
+    return { changedIds: out.changedIds };
+  }
+};
+var environmentExportTool = {
+  name: "environment.export",
+  description: "Serialize an environment to a portable JSON string. Encrypted variables drop their value (only `secretKeyId` survives) so the export can be safely pasted elsewhere \u2014 re-attach secrets locally on the receiving side.",
+  inputSchema: import_zod4.z.object({ name: import_zod4.z.string() }),
+  async handler(input, ctx) {
+    const state = await ctx.workspace.read();
+    const env = state.synced.environments.items[input.name];
+    if (!env) return { ok: false, error: "environment not found" };
+    const payload = {
+      apicircleEnvironment: 1,
+      name: env.name,
+      variables: env.variables.map(
+        (v) => v.encrypted && v.secretKeyId ? { key: v.key, encrypted: true, secretKeyId: v.secretKeyId } : { key: v.key, value: v.value, encrypted: false }
+      )
+    };
+    return { ok: true, json: JSON.stringify(payload, null, 2) };
+  }
+};
+var environmentImportTool = {
+  name: "environment.import",
+  description: "Import an environment from the JSON shape produced by `environment.export`. When a target with the same name exists, pass `overwrite: true` to replace it, otherwise the import is rejected.",
+  inputSchema: import_zod4.z.object({
+    json: import_zod4.z.string().min(1),
+    overwrite: import_zod4.z.boolean().default(false)
+  }),
+  async handler(input, ctx) {
+    let parsed;
+    try {
+      parsed = JSON.parse(input.json);
+    } catch {
+      return { ok: false, error: "invalid JSON" };
+    }
+    const obj = parsed;
+    if (obj.apicircleEnvironment !== 1 || typeof obj.name !== "string" || !Array.isArray(obj.variables)) {
+      return { ok: false, error: "unsupported export shape" };
+    }
+    const state = await ctx.workspace.read();
+    if (state.synced.environments.items[obj.name] && !input.overwrite) {
+      return {
+        ok: false,
+        error: "environment already exists; pass overwrite:true"
+      };
+    }
+    const env = {
+      name: obj.name,
+      variables: obj.variables.map(
+        (v) => v.encrypted ? { key: v.key, value: "", encrypted: true, secretKeyId: v.secretKeyId } : { key: v.key, value: v.value, encrypted: false }
+      )
+    };
+    const out = await ctx.workspace.apply({ kind: "environment.upsert", environment: env });
+    return { ok: true, name: env.name, changedIds: out.changedIds };
+  }
+};
+var PLAN_STEP = import_zod4.z.object({
+  requestId: import_zod4.z.string(),
+  linkedWorkspaceId: import_zod4.z.string().optional()
+});
+var planCreateTool = {
+  name: "plan.create",
+  description: "Create a new execution plan (sequence of request steps).",
+  inputSchema: import_zod4.z.object({
+    name: import_zod4.z.string().default("New plan"),
+    steps: import_zod4.z.array(PLAN_STEP).default([]),
+    envPriorityOrder: import_zod4.z.array(import_zod4.z.string()).default([])
+  }),
+  async handler(input, ctx) {
+    const id = (0, import_shared2.generateId)();
+    const now = (/* @__PURE__ */ new Date()).toISOString();
+    const plan = {
+      id,
+      name: input.name,
+      steps: input.steps,
+      envPriorityOrder: input.envPriorityOrder,
+      createdAt: now,
+      updatedAt: now
+    };
+    const out = await ctx.workspace.apply({ kind: "plan.upsert", plan });
+    return { id, changedIds: out.changedIds };
+  }
+};
+var planReadTool = {
+  name: "plan.read",
+  description: "Read a plan by id, or list all plans when no id is provided.",
+  inputSchema: import_zod4.z.object({ id: import_zod4.z.string().optional() }),
+  async handler(input, ctx) {
+    const state = await ctx.workspace.read();
+    if (input.id) {
+      const plan = state.local.executionPlans[input.id];
+      return plan ? { found: true, plan } : { found: false };
+    }
+    return {
+      count: Object.keys(state.local.executionPlans).length,
+      plans: Object.values(state.local.executionPlans)
+    };
+  }
+};
+var planUpdateTool = {
+  name: "plan.update",
+  description: "Patch fields on an existing plan.",
+  inputSchema: import_zod4.z.object({
+    id: import_zod4.z.string(),
+    patch: import_zod4.z.object({
+      name: import_zod4.z.string().optional(),
+      steps: import_zod4.z.array(PLAN_STEP).optional(),
+      envPriorityOrder: import_zod4.z.array(import_zod4.z.string()).optional()
+    }).strict()
+  }),
+  async handler(input, ctx) {
+    const state = await ctx.workspace.read();
+    const existing = state.local.executionPlans[input.id];
+    if (!existing) return { changedIds: [] };
+    const merged = {
+      ...existing,
+      ...input.patch,
+      id: existing.id,
+      createdAt: existing.createdAt,
+      updatedAt: (/* @__PURE__ */ new Date()).toISOString()
+    };
+    const out = await ctx.workspace.apply({ kind: "plan.upsert", plan: merged });
+    return { changedIds: out.changedIds };
+  }
+};
+var planDeleteTool = {
+  name: "plan.delete",
+  description: "Delete a plan by id. Drops history rows referencing this plan.",
+  inputSchema: import_zod4.z.object({ id: import_zod4.z.string() }),
+  async handler(input, ctx) {
+    const out = await ctx.workspace.apply({ kind: "plan.delete", id: input.id });
+    return { changedIds: out.changedIds };
+  }
+};
+var planAddStepTool = {
+  name: "plan.add_step",
+  description: "Append a step to an execution plan. Optional `position` (0-based) inserts at that index instead.",
+  inputSchema: import_zod4.z.object({
+    planId: import_zod4.z.string(),
+    requestId: import_zod4.z.string(),
+    linkedWorkspaceId: import_zod4.z.string().optional(),
+    position: import_zod4.z.number().int().nonnegative().optional()
+  }),
+  async handler(input, ctx) {
+    const state = await ctx.workspace.read();
+    const plan = state.local.executionPlans[input.planId];
+    if (!plan) return { ok: false, error: "plan not found" };
+    const step = {
+      requestId: input.requestId,
+      ...input.linkedWorkspaceId ? { linkedWorkspaceId: input.linkedWorkspaceId } : {}
+    };
+    const steps = [...plan.steps];
+    if (input.position !== void 0 && input.position <= steps.length) {
+      steps.splice(input.position, 0, step);
+    } else {
+      steps.push(step);
+    }
+    const out = await ctx.workspace.apply({
+      kind: "plan.upsert",
+      plan: { ...plan, steps, updatedAt: (/* @__PURE__ */ new Date()).toISOString() }
+    });
+    return { ok: true, changedIds: out.changedIds };
+  }
+};
+var planRemoveStepTool = {
+  name: "plan.remove_step",
+  description: "Remove a step from a plan by 0-based index.",
+  inputSchema: import_zod4.z.object({
+    planId: import_zod4.z.string(),
+    index: import_zod4.z.number().int().nonnegative()
+  }),
+  async handler(input, ctx) {
+    const state = await ctx.workspace.read();
+    const plan = state.local.executionPlans[input.planId];
+    if (!plan) return { ok: false, error: "plan not found" };
+    if (input.index >= plan.steps.length) {
+      return { ok: false, error: "index out of range" };
+    }
+    const steps = plan.steps.filter((_, i) => i !== input.index);
+    const out = await ctx.workspace.apply({
+      kind: "plan.upsert",
+      plan: { ...plan, steps, updatedAt: (/* @__PURE__ */ new Date()).toISOString() }
+    });
+    return { ok: true, changedIds: out.changedIds };
+  }
+};
+var planReorderStepsTool = {
+  name: "plan.reorder_steps",
+  description: "Replace the plan steps with a new permutation. The supplied indices must reference valid current step indices.",
+  inputSchema: import_zod4.z.object({
+    planId: import_zod4.z.string(),
+    order: import_zod4.z.array(import_zod4.z.number().int().nonnegative())
+  }),
+  async handler(input, ctx) {
+    const state = await ctx.workspace.read();
+    const plan = state.local.executionPlans[input.planId];
+    if (!plan) return { ok: false, error: "plan not found" };
+    if (input.order.length !== plan.steps.length) {
+      return { ok: false, error: "order length must equal step count" };
+    }
+    const order = input.order;
+    const seen = new Set(order);
+    if (seen.size !== order.length || order.some((i) => i >= plan.steps.length)) {
+      return { ok: false, error: "order must be a permutation of step indices" };
+    }
+    const steps = order.map((i) => plan.steps[i]);
+    const out = await ctx.workspace.apply({
+      kind: "plan.upsert",
+      plan: { ...plan, steps, updatedAt: (/* @__PURE__ */ new Date()).toISOString() }
+    });
+    return { ok: true, changedIds: out.changedIds };
+  }
+};
+var PLAN_VARIABLE = import_zod4.z.object({ key: import_zod4.z.string(), value: import_zod4.z.string() });
+var planSetVariablesTool = {
+  name: "plan.set_variables",
+  description: "Replace the plan-scoped variables. These live highest-priority during plan runs (above environment vars, below context vars).",
+  inputSchema: import_zod4.z.object({
+    planId: import_zod4.z.string(),
+    variables: import_zod4.z.array(PLAN_VARIABLE)
+  }),
+  async handler(input, ctx) {
+    const state = await ctx.workspace.read();
+    const plan = state.local.executionPlans[input.planId];
+    if (!plan) return { ok: false, error: "plan not found" };
+    const out = await ctx.workspace.apply({
+      kind: "plan.upsert",
+      plan: { ...plan, variables: input.variables, updatedAt: (/* @__PURE__ */ new Date()).toISOString() }
+    });
+    return { ok: true, changedIds: out.changedIds };
+  }
+};
+var planRunTool = {
+  name: "plan.run",
+  description: "Run a plan headlessly (server-side). Currently returns a not-implemented marker \u2014 full execution requires the Desktop or browser runtime which the MCP host does not own. The Desktop integration overrides this tool with a real runner.",
+  inputSchema: import_zod4.z.object({
+    id: import_zod4.z.string(),
+    withAssertions: import_zod4.z.boolean().default(true)
+  }),
+  async handler(input, ctx) {
+    const state = await ctx.workspace.read();
+    const plan = state.local.executionPlans[input.id];
+    if (!plan) return { ok: false, error: "plan not found" };
+    return {
+      ok: false,
+      error: "Plan execution is only available in the Desktop app (or once a hosted runtime is wired). The plan exists and is ready to run from the UI.",
+      planId: plan.id,
+      stepCount: plan.steps.length
+    };
+  }
+};
+var ASSERTION = import_zod4.z.object({
+  id: import_zod4.z.string().optional(),
+  kind: import_zod4.z.enum(["status", "header", "json-path", "duration"]),
+  op: import_zod4.z.enum(["equals", "not-equals", "contains", "lt", "gt", "matches"]),
+  target: import_zod4.z.string().optional(),
+  expected: import_zod4.z.union([import_zod4.z.string(), import_zod4.z.number()])
+});
+var assertionCreateTool = {
+  name: "assertion.create",
+  description: "Add an assertion to a request.",
+  inputSchema: import_zod4.z.object({
+    requestId: import_zod4.z.string(),
+    assertion: ASSERTION
+  }),
+  async handler(input, ctx) {
+    const assertion = {
+      ...input.assertion,
+      id: input.assertion.id ?? (0, import_shared2.generateId)()
+    };
+    const out = await ctx.workspace.apply({
+      kind: "assertion.upsert",
+      requestId: input.requestId,
+      assertion
+    });
+    return { id: assertion.id, changedIds: out.changedIds };
+  }
+};
+var assertionReadTool = {
+  name: "assertion.read",
+  description: "List assertions for a request, or fetch a single assertion by id.",
+  inputSchema: import_zod4.z.object({
+    requestId: import_zod4.z.string(),
+    assertionId: import_zod4.z.string().optional()
+  }),
+  async handler(input, ctx) {
+    const state = await ctx.workspace.read();
+    const req = state.synced.collections.requests[input.requestId];
+    if (!req) return { found: false };
+    if (input.assertionId) {
+      const a = req.assertions.find((x) => x.id === input.assertionId);
+      return a ? { found: true, assertion: a } : { found: false };
+    }
+    return { count: req.assertions.length, assertions: req.assertions };
+  }
+};
+var assertionUpdateTool = {
+  name: "assertion.update",
+  description: "Replace an existing assertion (matched by `assertion.id`).",
+  inputSchema: import_zod4.z.object({
+    requestId: import_zod4.z.string(),
+    assertion: ASSERTION.required({ id: true })
+  }),
+  async handler(input, ctx) {
+    const out = await ctx.workspace.apply({
+      kind: "assertion.upsert",
+      requestId: input.requestId,
+      assertion: input.assertion
+    });
+    return { changedIds: out.changedIds };
+  }
+};
+var assertionDeleteTool = {
+  name: "assertion.delete",
+  description: "Remove an assertion from a request.",
+  inputSchema: import_zod4.z.object({
+    requestId: import_zod4.z.string(),
+    assertionId: import_zod4.z.string()
+  }),
+  async handler(input, ctx) {
+    const out = await ctx.workspace.apply({
+      kind: "assertion.delete",
+      requestId: input.requestId,
+      assertionId: input.assertionId
+    });
+    return { changedIds: out.changedIds };
+  }
+};
+var workspaceReadTool = {
+  name: "workspace.read",
+  description: "Return the full `{ synced, local }` workspace pair. Use sparingly \u2014 entity-specific tools are more efficient for small reads.",
+  inputSchema: import_zod4.z.object({}),
+  async handler(_input, ctx) {
+    return await ctx.workspace.read();
+  }
+};
+var workspaceWriteTool = {
+  name: "workspace.write",
+  description: "Bulk-replace the workspace. Pass `synced` and/or `local` to overwrite either side. Mutating tools are preferred \u2014 this is for full-doc imports/exports.",
+  inputSchema: import_zod4.z.object({
+    synced: import_zod4.z.unknown().optional(),
+    local: import_zod4.z.unknown().optional()
+  }),
+  async handler(input, ctx) {
+    const next = await ctx.workspace.write({
+      synced: input.synced,
+      local: input.local
+    });
+    return { workspaceId: next.synced.workspaceId, ok: true };
+  }
+};
+
+// src/tools/history.ts
+var import_zod5 = require("zod");
+var historyListRunsTool = {
+  name: "history.list_runs",
+  description: "List request-run history rows in reverse-chronological order. Filter by `requestId`, `ok` (success/failure), or `since`/`until` ISO timestamps. `limit` caps the result set; default 100.",
+  inputSchema: import_zod5.z.object({
+    requestId: import_zod5.z.string().optional(),
+    ok: import_zod5.z.boolean().optional(),
+    since: import_zod5.z.string().optional(),
+    until: import_zod5.z.string().optional(),
+    limit: import_zod5.z.number().int().positive().max(500).default(100)
+  }),
+  async handler(input, ctx) {
+    const state = await ctx.workspace.read();
+    const sinceMs = input.since ? Date.parse(input.since) : -Infinity;
+    const untilMs = input.until ? Date.parse(input.until) : Infinity;
+    const filtered = state.local.history.requestRuns.filter((r) => {
+      if (input.requestId && r.requestId !== input.requestId) return false;
+      if (input.ok !== void 0 && r.ok !== input.ok) return false;
+      const t = Date.parse(r.startedAt);
+      if (!Number.isFinite(t)) return true;
+      return t >= sinceMs && t <= untilMs;
+    });
+    const sorted = [...filtered].sort((a, b) => b.startedAt.localeCompare(a.startedAt));
+    const limited = sorted.slice(0, input.limit);
+    return {
+      total: filtered.length,
+      returned: limited.length,
+      runs: limited.map((r) => ({
+        id: r.id,
+        requestId: r.requestId,
+        method: r.method,
+        url: r.url,
+        status: r.status,
+        ok: r.ok,
+        startedAt: r.startedAt,
+        durationMs: r.durationMs
+      }))
+    };
+  }
+};
+var historyGetRunTool = {
+  name: "history.get_run",
+  description: "Fetch a single history row in full (headers, body preview, assertion results).",
+  inputSchema: import_zod5.z.object({ id: import_zod5.z.string() }),
+  async handler(input, ctx) {
+    const state = await ctx.workspace.read();
+    const run = state.local.history.requestRuns.find((r) => r.id === input.id);
+    if (!run) return { found: false };
+    return { found: true, run };
+  }
+};
+var historyDeleteRunTool = {
+  name: "history.delete_run",
+  description: "Delete a single request-run row by id.",
+  inputSchema: import_zod5.z.object({ id: import_zod5.z.string() }),
+  async handler(input, ctx) {
+    const out = await ctx.workspace.apply({ kind: "history.delete_run", runId: input.id });
+    return { deleted: out.changedIds.length, changedIds: out.changedIds };
+  }
+};
+var historyPurgeTool = {
+  name: "history.purge_by_age",
+  description: "Drop every request-run + plan-run older than `olderThanDays` days. Pass 0 to clear all history.",
+  inputSchema: import_zod5.z.object({
+    olderThanDays: import_zod5.z.number().nonnegative()
+  }),
+  async handler(input, ctx) {
+    const olderThanMs = input.olderThanDays * 24 * 60 * 60 * 1e3;
+    const out = await ctx.workspace.apply({ kind: "history.purge", olderThanMs });
+    return { purgedCount: out.changedIds.length, changedIds: out.changedIds };
+  }
+};
+
+// src/tools/codebase.ts
+var import_zod6 = require("zod");
+var HTTP_METHODS = ["get", "post", "put", "patch", "delete", "options", "head"];
+var codebaseExtractCollectionTool = {
+  name: "codebase.extract_collection",
+  description: "Scan source code for HTTP route definitions (Express, FastAPI, NestJS, Spring) and return candidate requests for the user to confirm before import.",
+  inputSchema: import_zod6.z.object({
+    source: import_zod6.z.string().min(1),
+    /** Hint to limit which framework patterns to apply. Empty = try all. */
+    frameworks: import_zod6.z.array(import_zod6.z.enum(["express", "fastapi", "nest", "spring"])).default([])
+  }),
+  async handler(input) {
+    const enabled = new Set(
+      input.frameworks.length ? input.frameworks : ["express", "fastapi", "nest", "spring"]
+    );
+    const candidates = [];
+    const lines = input.source.split(/\r?\n/);
+    for (let i = 0; i < lines.length; i++) {
+      const line = lines[i];
+      if (enabled.has("express")) {
+        const m = /(?:^|[\s\b])(?:app|router)\.(get|post|put|patch|delete|options|head)\s*\(\s*['"`]([^'"`]+)['"`]/i.exec(
+          line
+        );
+        if (m) {
+          candidates.push({
+            method: m[1].toUpperCase(),
+            path: m[2],
+            framework: "express",
+            line: i + 1
+          });
+          continue;
+        }
+      }
+      if (enabled.has("fastapi")) {
+        const m = /@(?:app|router)\.(get|post|put|patch|delete|options|head)\s*\(\s*['"`]([^'"`]+)['"`]/i.exec(
+          line
+        );
+        if (m) {
+          candidates.push({
+            method: m[1].toUpperCase(),
+            path: m[2],
+            framework: "fastapi",
+            line: i + 1
+          });
+          continue;
+        }
+      }
+      if (enabled.has("nest")) {
+        const m = /@(Get|Post|Put|Patch|Delete|Options|Head)\s*\(\s*['"`]([^'"`]*)['"`]\s*\)/i.exec(
+          line
+        );
+        if (m) {
+          candidates.push({
+            method: m[1].toUpperCase(),
+            path: m[2] || "/",
+            framework: "nest",
+            line: i + 1
+          });
+          continue;
+        }
+      }
+      if (enabled.has("spring")) {
+        const verb = /@(Get|Post|Put|Patch|Delete)Mapping\s*\(?\s*['"`]?([^'"`)\s]*)/i.exec(line);
+        if (verb && HTTP_METHODS.includes(verb[1].toLowerCase())) {
+          candidates.push({
+            method: verb[1].toUpperCase(),
+            path: verb[2] || "/",
+            framework: "spring",
+            line: i + 1
+          });
+          continue;
+        }
+        const generic = /@RequestMapping\s*\(\s*[^)]*method\s*=\s*RequestMethod\.(GET|POST|PUT|PATCH|DELETE)[^)]*?(?:value|path)?\s*=?\s*['"`]?([^'"`)\s,]*)/i.exec(
+          line
+        );
+        if (generic) {
+          candidates.push({
+            method: generic[1].toUpperCase(),
+            path: generic[2] || "/",
+            framework: "spring",
+            line: i + 1
+          });
+        }
+      }
+    }
+    return { count: candidates.length, candidates };
+  }
+};
+
+// src/tools/prompt.ts
+var import_zod7 = require("zod");
+var import_shared3 = require("@apicircle/shared");
+var promptCreateEnvironmentTool = {
+  name: "prompt.create_environment",
+  description: "Create a new environment from an LLM-shaped JSON envelope. The model produces { name, variables: [{ key, value, encrypted }] }; this tool validates and persists it.",
+  inputSchema: import_zod7.z.object({
+    name: import_zod7.z.string(),
+    variables: import_zod7.z.array(
+      import_zod7.z.object({
+        key: import_zod7.z.string(),
+        value: import_zod7.z.string(),
+        encrypted: import_zod7.z.boolean().default(false)
+      })
+    )
+  }),
+  async handler(input, ctx) {
+    const env = { name: input.name, variables: input.variables };
+    const out = await ctx.workspace.apply({ kind: "environment.upsert", environment: env });
+    return { name: env.name, changedIds: out.changedIds };
+  }
+};
+var promptCreateAssertionTool = {
+  name: "prompt.create_assertion",
+  description: 'Add an assertion to a request from an LLM-shaped JSON envelope. Useful when the user asks "assert that the response status is 200 and body.id matches".',
+  inputSchema: import_zod7.z.object({
+    requestId: import_zod7.z.string(),
+    assertion: import_zod7.z.object({
+      kind: import_zod7.z.enum(["status", "header", "json-path", "duration"]),
+      op: import_zod7.z.enum(["equals", "not-equals", "contains", "lt", "gt", "matches"]),
+      target: import_zod7.z.string().optional(),
+      expected: import_zod7.z.union([import_zod7.z.string(), import_zod7.z.number()])
+    })
+  }),
+  async handler(input, ctx) {
+    const assertion = {
+      ...input.assertion,
+      id: (0, import_shared3.generateId)()
+    };
+    const out = await ctx.workspace.apply({
+      kind: "assertion.upsert",
+      requestId: input.requestId,
+      assertion
+    });
+    return { id: assertion.id, changedIds: out.changedIds };
+  }
+};
+var promptCreatePlanTool = {
+  name: "prompt.create_plan",
+  description: "Create an execution plan from an LLM-shaped JSON envelope. The model produces { name, stepRequestIds: [...] } and the tool validates that each id exists in the workspace before persisting.",
+  inputSchema: import_zod7.z.object({
+    name: import_zod7.z.string(),
+    stepRequestIds: import_zod7.z.array(import_zod7.z.string()).default([]),
+    envPriorityOrder: import_zod7.z.array(import_zod7.z.string()).default([])
+  }),
+  async handler(input, ctx) {
+    const state = await ctx.workspace.read();
+    const missing = [];
+    for (const rid of input.stepRequestIds) {
+      if (!state.synced.collections.requests[rid]) missing.push(rid);
+    }
+    if (missing.length) {
+      return {
+        ok: false,
+        error: `Unknown request ids: ${missing.join(", ")}`,
+        missing
+      };
+    }
+    const id = (0, import_shared3.generateId)();
+    const now = (/* @__PURE__ */ new Date()).toISOString();
+    const plan = {
+      id,
+      name: input.name,
+      steps: input.stepRequestIds.map((requestId) => ({ requestId })),
+      envPriorityOrder: input.envPriorityOrder,
+      createdAt: now,
+      updatedAt: now
+    };
+    const out = await ctx.workspace.apply({ kind: "plan.upsert", plan });
+    return { ok: true, id, changedIds: out.changedIds };
+  }
+};
+var HTTP_METHOD2 = import_zod7.z.enum(["GET", "POST", "PUT", "PATCH", "DELETE", "HEAD", "OPTIONS"]);
+var HEADER_OR_QUERY = import_zod7.z.object({
+  key: import_zod7.z.string(),
+  value: import_zod7.z.string(),
+  enabled: import_zod7.z.boolean().default(true)
+});
+var REQUEST_BODY = import_zod7.z.object({
+  type: import_zod7.z.enum(["none", "json", "text", "xml", "graphql", "urlencoded"]).default("none"),
+  content: import_zod7.z.string().default(""),
+  variables: import_zod7.z.string().optional()
+});
+var PROMPT_AUTH = import_zod7.z.discriminatedUnion("type", [
+  import_zod7.z.object({ type: import_zod7.z.literal("none") }),
+  import_zod7.z.object({ type: import_zod7.z.literal("inherit") }),
+  import_zod7.z.object({ type: import_zod7.z.literal("bearer"), token: import_zod7.z.string().default("") }),
+  import_zod7.z.object({
+    type: import_zod7.z.literal("basic"),
+    username: import_zod7.z.string().default(""),
+    password: import_zod7.z.string().default("")
+  }),
+  import_zod7.z.object({
+    type: import_zod7.z.literal("api-key"),
+    key: import_zod7.z.string().default(""),
+    value: import_zod7.z.string().default(""),
+    addTo: import_zod7.z.enum(["header", "query", "cookie"]).default("header")
+  }),
+  import_zod7.z.object({
+    type: import_zod7.z.literal("custom-header"),
+    key: import_zod7.z.string().default(""),
+    value: import_zod7.z.string().default("")
+  })
+]);
+var PROMPT_ASSERTION = import_zod7.z.object({
+  kind: import_zod7.z.enum(["status", "header", "json-path", "duration"]),
+  op: import_zod7.z.enum(["equals", "not-equals", "contains", "lt", "gt", "matches"]),
+  target: import_zod7.z.string().optional(),
+  expected: import_zod7.z.union([import_zod7.z.string(), import_zod7.z.number()])
+});
+var ENDPOINT_RESPONSE = import_zod7.z.object({
+  status: import_zod7.z.number().int().min(100).max(599).default(200),
+  jsonBody: import_zod7.z.string().default("{}"),
+  contentType: import_zod7.z.string().default("application/json")
+});
+var VALIDATION_RULE_NL = import_zod7.z.object({
+  kind: import_zod7.z.enum([
+    "header-required",
+    "header-equals",
+    "header-matches",
+    "query-required",
+    "query-equals",
+    "query-matches",
+    "cookie-required",
+    "body-required",
+    "content-type-equals"
+  ]),
+  target: import_zod7.z.string().default(""),
+  expected: import_zod7.z.string().optional(),
+  message: import_zod7.z.string().optional(),
+  enabled: import_zod7.z.boolean().default(true),
+  failResponse: import_zod7.z.object({
+    status: import_zod7.z.number().int().min(100).max(599).default(400),
+    jsonBody: import_zod7.z.string().default('{"error":"validation failed"}')
+  }).default({})
+});
+var CONDITION_CLAUSE_NL = import_zod7.z.object({
+  scope: import_zod7.z.enum(["query", "pathParam", "header", "cookie", "body-json-path"]),
+  target: import_zod7.z.string(),
+  op: import_zod7.z.enum(["equals", "not-equals", "matches", "gt", "lt", "gte", "lte", "present", "absent"]),
+  value: import_zod7.z.string().optional()
+});
+var RESPONSE_RULE_NL = import_zod7.z.object({
+  name: import_zod7.z.string(),
+  enabled: import_zod7.z.boolean().default(true),
+  when: import_zod7.z.array(CONDITION_CLAUSE_NL).default([]),
+  response: import_zod7.z.object({
+    status: import_zod7.z.number().int().min(100).max(599).default(200),
+    jsonBody: import_zod7.z.string().default("{}")
+  }).default({})
+});
+var MULTIPLIER_NL = import_zod7.z.object({
+  name: import_zod7.z.string().optional(),
+  source: import_zod7.z.object({
+    kind: import_zod7.z.enum(["query", "pathParam", "header", "body-json-path"]),
+    key: import_zod7.z.string()
+  }),
+  targetJsonPath: import_zod7.z.string(),
+  defaultCount: import_zod7.z.number().int().nonnegative().default(0),
+  min: import_zod7.z.number().int().nonnegative().optional(),
+  max: import_zod7.z.number().int().nonnegative().optional()
+});
+var ENDPOINT_INPUT = import_zod7.z.object({
+  method: HTTP_METHOD2,
+  pathPattern: import_zod7.z.string().min(1),
+  name: import_zod7.z.string().optional(),
+  description: import_zod7.z.string().optional(),
+  response: ENDPOINT_RESPONSE.optional(),
+  validationRules: import_zod7.z.array(VALIDATION_RULE_NL).default([]),
+  responseRules: import_zod7.z.array(RESPONSE_RULE_NL).default([]),
+  multipliers: import_zod7.z.array(MULTIPLIER_NL).default([])
+});
+function buildRequestBody(input) {
+  if (!input) return { type: "none", content: "" };
+  const body = { type: input.type, content: input.content };
+  if (input.variables !== void 0 && input.type === "graphql") {
+    body.variables = input.variables;
+  }
+  return body;
+}
+function buildEndpoint(input) {
+  const response = input.response ?? {
+    status: 200,
+    jsonBody: "{}",
+    contentType: "application/json"
+  };
+  const headers = [{ key: "Content-Type", value: response.contentType, enabled: true }];
+  const defaultResponse = {
+    ...(0, import_shared3.makeDefaultMockResponse)(),
+    status: response.status,
+    headers,
+    body: { type: "json", content: response.jsonBody }
+  };
+  const validationRules = input.validationRules ?? [];
+  const responseRules = input.responseRules ?? [];
+  const multipliers = input.multipliers ?? [];
+  if (multipliers.length > 0) {
+    defaultResponse.multipliers = multipliers.map((m) => ({
+      id: (0, import_shared3.generateId)(),
+      name: m.name,
+      source: { kind: m.source.kind, key: m.source.key },
+      targetJsonPath: m.targetJsonPath,
+      defaultCount: m.defaultCount,
+      min: m.min,
+      max: m.max
+    }));
+  }
+  return {
+    id: (0, import_shared3.generateId)(),
+    name: input.name ?? `${input.method} ${input.pathPattern}`,
+    method: input.method,
+    pathPattern: input.pathPattern,
+    description: input.description,
+    requestSchema: (0, import_shared3.makeDefaultRequestSchema)(),
+    requestValidation: validationRules.map((r) => ({
+      id: (0, import_shared3.generateId)(),
+      kind: r.kind,
+      target: r.target,
+      expected: r.expected,
+      message: r.message,
+      enabled: r.enabled,
+      failResponse: {
+        status: r.failResponse.status,
+        headers: [{ key: "Content-Type", value: "application/json", enabled: true }],
+        body: { type: "json", content: r.failResponse.jsonBody }
+      }
+    })),
+    responseRules: responseRules.map((r) => ({
+      id: (0, import_shared3.generateId)(),
+      name: r.name,
+      enabled: r.enabled,
+      when: (r.when ?? []).map((c) => ({
+        id: (0, import_shared3.generateId)(),
+        scope: c.scope,
+        target: c.target,
+        op: c.op,
+        value: c.value
+      })),
+      response: {
+        status: r.response.status,
+        headers: [{ key: "Content-Type", value: "application/json", enabled: true }],
+        body: { type: "json", content: r.response.jsonBody }
+      }
+    })),
+    defaultResponse
+  };
+}
+function patchEndpoint(mock, endpointId, patcher) {
+  const idx = mock.endpoints.findIndex((e) => e.id === endpointId);
+  if (idx === -1) return null;
+  const nextEndpoints = [...mock.endpoints];
+  nextEndpoints[idx] = patcher(mock.endpoints[idx]);
+  const source = mock.source.kind === "manual" ? { kind: "manual", endpoints: nextEndpoints } : mock.source;
+  return {
+    ...mock,
+    source,
+    endpoints: nextEndpoints,
+    updatedAt: (/* @__PURE__ */ new Date()).toISOString()
+  };
+}
+var promptCreateRequestTool = {
+  name: "prompt.create_request",
+  description: "Create a fully-shaped request from an LLM-shaped JSON envelope: method, url, headers, query params, body, auth, and inline assertions. The model produces a flat object; this tool generates the request id, normalizes auth (defaults to `inherit` so folder auth wins), and persists.",
+  inputSchema: import_zod7.z.object({
+    name: import_zod7.z.string().default("New request"),
+    method: HTTP_METHOD2.default("GET"),
+    url: import_zod7.z.string().default(""),
+    folderId: import_zod7.z.string().nullable().optional(),
+    headers: import_zod7.z.array(HEADER_OR_QUERY).default([]),
+    queryParams: import_zod7.z.array(HEADER_OR_QUERY).default([]),
+    pathParams: import_zod7.z.record(import_zod7.z.string(), import_zod7.z.string()).optional(),
+    body: REQUEST_BODY.optional(),
+    auth: PROMPT_AUTH.optional(),
+    assertions: import_zod7.z.array(PROMPT_ASSERTION).default([])
+  }),
+  async handler(input, ctx) {
+    const now = (/* @__PURE__ */ new Date()).toISOString();
+    const auth = input.auth ?? { type: "inherit" };
+    const assertions = input.assertions ?? [];
+    const request = {
+      id: (0, import_shared3.generateId)(),
+      name: input.name ?? "New request",
+      folderId: input.folderId ?? null,
+      method: input.method ?? "GET",
+      url: input.url ?? "",
+      headers: input.headers ?? [],
+      query: input.queryParams ?? [],
+      pathParams: input.pathParams,
+      body: buildRequestBody(input.body),
+      auth,
+      contextVars: [],
+      extractions: [],
+      assertions: assertions.map((a) => ({ ...a, id: (0, import_shared3.generateId)() })),
+      createdAt: now,
+      updatedAt: now
+    };
+    const out = await ctx.workspace.apply({ kind: "request.create", request });
+    return { id: request.id, changedIds: out.changedIds };
+  }
+};
+var promptUpdateRequestTool = {
+  name: "prompt.update_request",
+  description: "Patch an existing request from an LLM-shaped JSON envelope. Provided fields replace the existing values; omitted fields are left untouched. Arrays (headers, queryParams, assertions) are full replacements when supplied. Returns `{ ok: false, error }` when the id does not resolve.",
+  inputSchema: import_zod7.z.object({
+    id: import_zod7.z.string(),
+    patch: import_zod7.z.object({
+      name: import_zod7.z.string().optional(),
+      method: HTTP_METHOD2.optional(),
+      url: import_zod7.z.string().optional(),
+      folderId: import_zod7.z.string().nullable().optional(),
+      headers: import_zod7.z.array(HEADER_OR_QUERY).optional(),
+      queryParams: import_zod7.z.array(HEADER_OR_QUERY).optional(),
+      pathParams: import_zod7.z.record(import_zod7.z.string(), import_zod7.z.string()).optional(),
+      body: REQUEST_BODY.optional(),
+      auth: PROMPT_AUTH.optional(),
+      assertions: import_zod7.z.array(PROMPT_ASSERTION).optional()
+    }).strict()
+  }),
+  async handler(input, ctx) {
+    const state = await ctx.workspace.read();
+    if (!state.synced.collections.requests[input.id]) {
+      return { ok: false, error: "request not found" };
+    }
+    const patch = {};
+    if (input.patch.name !== void 0) patch.name = input.patch.name;
+    if (input.patch.method !== void 0) patch.method = input.patch.method;
+    if (input.patch.url !== void 0) patch.url = input.patch.url;
+    if (input.patch.folderId !== void 0) patch.folderId = input.patch.folderId ?? null;
+    if (input.patch.headers !== void 0) patch.headers = input.patch.headers;
+    if (input.patch.queryParams !== void 0) patch.query = input.patch.queryParams;
+    if (input.patch.pathParams !== void 0) patch.pathParams = input.patch.pathParams;
+    if (input.patch.body !== void 0) patch.body = buildRequestBody(input.patch.body);
+    if (input.patch.auth !== void 0) patch.auth = input.patch.auth;
+    if (input.patch.assertions !== void 0) {
+      patch.assertions = input.patch.assertions.map((a) => ({
+        ...a,
+        id: (0, import_shared3.generateId)()
+      }));
+    }
+    const out = await ctx.workspace.apply({ kind: "request.update", id: input.id, patch });
+    return { ok: true, changedIds: out.changedIds };
+  }
+};
+var FOLDER_TREE_NODE = import_zod7.z.lazy(
+  () => import_zod7.z.object({
+    name: import_zod7.z.string(),
+    children: import_zod7.z.array(FOLDER_TREE_NODE).optional()
+  })
+);
+var promptCreateFolderTreeTool = {
+  name: "prompt.create_folder_tree",
+  description: "Create a recursive folder hierarchy from an LLM-shaped JSON envelope. The model produces `{ parentId?, tree: { name, children?: [...] } }` and this tool walks the tree, generating ids and persisting one folder per node. Returns the list of created ids in pre-order.",
+  inputSchema: import_zod7.z.object({
+    parentId: import_zod7.z.string().nullable().optional(),
+    tree: FOLDER_TREE_NODE
+  }),
+  async handler(input, ctx) {
+    const createdIds = [];
+    const allChangedIds = [];
+    const walk = async (node, parentId) => {
+      const folder = {
+        id: (0, import_shared3.generateId)(),
+        name: node.name,
+        parentId
+      };
+      const out = await ctx.workspace.apply({ kind: "folder.create", folder });
+      createdIds.push(folder.id);
+      allChangedIds.push(...out.changedIds);
+      for (const child of node.children ?? []) {
+        await walk(child, folder.id);
+      }
+    };
+    await walk(input.tree, input.parentId ?? null);
+    return { createdIds, changedIds: allChangedIds };
+  }
+};
+var promptAddPlanStepsTool = {
+  name: "prompt.add_plan_steps",
+  description: "Append one or more steps to an existing execution plan from an LLM-shaped JSON envelope. The model produces `{ planId, requestIds: [...] }`; each id is validated against the workspace before any step is appended. Order in the input list is preserved.",
+  inputSchema: import_zod7.z.object({
+    planId: import_zod7.z.string(),
+    requestIds: import_zod7.z.array(import_zod7.z.string()).min(1)
+  }),
+  async handler(input, ctx) {
+    const state = await ctx.workspace.read();
+    const plan = state.local.executionPlans[input.planId];
+    if (!plan) return { ok: false, error: "plan not found" };
+    const requestIds = input.requestIds;
+    const missing = requestIds.filter((rid) => !state.synced.collections.requests[rid]);
+    if (missing.length) {
+      return {
+        ok: false,
+        error: `Unknown request ids: ${missing.join(", ")}`,
+        missing
+      };
+    }
+    const newSteps = requestIds.map((requestId) => ({ requestId }));
+    const out = await ctx.workspace.apply({
+      kind: "plan.upsert",
+      plan: {
+        ...plan,
+        steps: [...plan.steps, ...newSteps],
+        updatedAt: (/* @__PURE__ */ new Date()).toISOString()
+      }
+    });
+    return { ok: true, addedCount: newSteps.length, changedIds: out.changedIds };
+  }
+};
+var promptSetPlanVariablesTool = {
+  name: "prompt.set_plan_variables",
+  description: "Replace the plan-scoped variables on an execution plan from an LLM-shaped JSON envelope. The model produces `{ planId, variables: [{ key, value }] }`. Empty array clears all plan variables.",
+  inputSchema: import_zod7.z.object({
+    planId: import_zod7.z.string(),
+    variables: import_zod7.z.array(import_zod7.z.object({ key: import_zod7.z.string(), value: import_zod7.z.string() }))
+  }),
+  async handler(input, ctx) {
+    const state = await ctx.workspace.read();
+    const plan = state.local.executionPlans[input.planId];
+    if (!plan) return { ok: false, error: "plan not found" };
+    const out = await ctx.workspace.apply({
+      kind: "plan.upsert",
+      plan: { ...plan, variables: input.variables, updatedAt: (/* @__PURE__ */ new Date()).toISOString() }
+    });
+    return { ok: true, changedIds: out.changedIds };
+  }
+};
+var promptCreateMockServerTool = {
+  name: "prompt.create_mock_server",
+  description: "Create a manual-mode mock server with optional inline endpoints from an LLM-shaped JSON envelope. The model produces `{ name, defaultPort?, endpoints: [{ method, pathPattern, name?, response?, validationRules?, responseRules?, multipliers? }] }`; this tool generates ids for the server and every endpoint / rule, then persists in one shot.",
+  inputSchema: import_zod7.z.object({
+    name: import_zod7.z.string().min(1),
+    defaultPort: import_zod7.z.number().int().positive().nullable().optional(),
+    endpoints: import_zod7.z.array(ENDPOINT_INPUT).default([])
+  }),
+  async handler(input, ctx) {
+    const now = (/* @__PURE__ */ new Date()).toISOString();
+    const endpointInputs = input.endpoints ?? [];
+    const endpoints = endpointInputs.map((e) => buildEndpoint(e));
+    const mock = {
+      id: (0, import_shared3.generateId)(),
+      name: input.name,
+      source: { kind: "manual", endpoints },
+      endpoints,
+      defaultPort: input.defaultPort ?? null,
+      cors: { enabled: true, origins: ["*"] },
+      createdAt: now,
+      updatedAt: now
+    };
+    const out = await ctx.workspace.apply({ kind: "mock.upsert", mock });
+    return {
+      id: mock.id,
+      endpointIds: endpoints.map((e) => e.id),
+      changedIds: out.changedIds
+    };
+  }
+};
+var promptAddMockEndpointTool = {
+  name: "prompt.add_mock_endpoint",
+  description: "Append a new endpoint (with optional inline validation rules, response rules, and multipliers) to an existing mock server from an LLM-shaped JSON envelope. All ids are auto-generated; the existing endpoints stay in place.",
+  inputSchema: import_zod7.z.object({
+    mockId: import_zod7.z.string(),
+    method: HTTP_METHOD2,
+    pathPattern: import_zod7.z.string().min(1),
+    name: import_zod7.z.string().optional(),
+    description: import_zod7.z.string().optional(),
+    response: ENDPOINT_RESPONSE.optional(),
+    validationRules: import_zod7.z.array(VALIDATION_RULE_NL).default([]),
+    responseRules: import_zod7.z.array(RESPONSE_RULE_NL).default([]),
+    multipliers: import_zod7.z.array(MULTIPLIER_NL).default([])
+  }),
+  async handler(input, ctx) {
+    const state = await ctx.workspace.read();
+    const mock = state.synced.mockServers[input.mockId];
+    if (!mock) return { ok: false, error: "mock not found" };
+    const endpoint = buildEndpoint(input);
+    const nextEndpoints = [...mock.endpoints, endpoint];
+    const source = mock.source.kind === "manual" ? { kind: "manual", endpoints: nextEndpoints } : mock.source;
+    const next = {
+      ...mock,
+      source,
+      endpoints: nextEndpoints,
+      updatedAt: (/* @__PURE__ */ new Date()).toISOString()
+    };
+    const out = await ctx.workspace.apply({ kind: "mock.upsert", mock: next });
+    return { ok: true, endpointId: endpoint.id, changedIds: out.changedIds };
+  }
+};
+var promptSetEndpointValidationRulesTool = {
+  name: "prompt.set_endpoint_validation_rules",
+  description: "Replace an endpoint's validation rules with an LLM-shaped list. Every rule gets a fresh id; the existing rules are dropped. Empty array clears all validation rules.",
+  inputSchema: import_zod7.z.object({
+    mockId: import_zod7.z.string(),
+    endpointId: import_zod7.z.string(),
+    rules: import_zod7.z.array(VALIDATION_RULE_NL)
+  }),
+  async handler(input, ctx) {
+    const state = await ctx.workspace.read();
+    const mock = state.synced.mockServers[input.mockId];
+    if (!mock) return { ok: false, error: "mock not found" };
+    const rules = input.rules;
+    const next = patchEndpoint(mock, input.endpointId, (e) => ({
+      ...e,
+      requestValidation: rules.map((r) => ({
+        id: (0, import_shared3.generateId)(),
+        kind: r.kind,
+        target: r.target,
+        expected: r.expected,
+        message: r.message,
+        enabled: r.enabled,
+        failResponse: {
+          status: r.failResponse.status,
+          headers: [{ key: "Content-Type", value: "application/json", enabled: true }],
+          body: { type: "json", content: r.failResponse.jsonBody }
+        }
+      }))
+    }));
+    if (!next) return { ok: false, error: "endpoint not found" };
+    const out = await ctx.workspace.apply({ kind: "mock.upsert", mock: next });
+    return { ok: true, changedIds: out.changedIds };
+  }
+};
+var promptSetEndpointResponseRulesTool = {
+  name: "prompt.set_endpoint_response_rules",
+  description: "Replace an endpoint's conditional response rules with an LLM-shaped list. Rules fire in order, first match wins. Every rule + clause gets a fresh id. Empty array falls back to defaultResponse.",
+  inputSchema: import_zod7.z.object({
+    mockId: import_zod7.z.string(),
+    endpointId: import_zod7.z.string(),
+    rules: import_zod7.z.array(RESPONSE_RULE_NL)
+  }),
+  async handler(input, ctx) {
+    const state = await ctx.workspace.read();
+    const mock = state.synced.mockServers[input.mockId];
+    if (!mock) return { ok: false, error: "mock not found" };
+    const rules = input.rules;
+    const next = patchEndpoint(mock, input.endpointId, (e) => ({
+      ...e,
+      responseRules: rules.map((r) => ({
+        id: (0, import_shared3.generateId)(),
+        name: r.name,
+        enabled: r.enabled,
+        when: r.when.map((c) => ({
+          id: (0, import_shared3.generateId)(),
+          scope: c.scope,
+          target: c.target,
+          op: c.op,
+          value: c.value
+        })),
+        response: {
+          status: r.response.status,
+          headers: [{ key: "Content-Type", value: "application/json", enabled: true }],
+          body: { type: "json", content: r.response.jsonBody }
+        }
+      }))
+    }));
+    if (!next) return { ok: false, error: "endpoint not found" };
+    const out = await ctx.workspace.apply({ kind: "mock.upsert", mock: next });
+    return { ok: true, changedIds: out.changedIds };
+  }
+};
+var promptSetEndpointMultipliersTool = {
+  name: "prompt.set_endpoint_multipliers",
+  description: "Replace the response multipliers on an endpoint's defaultResponse with an LLM-shaped list. Multipliers expand an array at `targetJsonPath` to a count derived from a request value. Every multiplier gets a fresh id. Empty array clears all multipliers.",
+  inputSchema: import_zod7.z.object({
+    mockId: import_zod7.z.string(),
+    endpointId: import_zod7.z.string(),
+    multipliers: import_zod7.z.array(MULTIPLIER_NL)
+  }),
+  async handler(input, ctx) {
+    const state = await ctx.workspace.read();
+    const mock = state.synced.mockServers[input.mockId];
+    if (!mock) return { ok: false, error: "mock not found" };
+    const multipliers = input.multipliers;
+    const next = patchEndpoint(mock, input.endpointId, (e) => ({
+      ...e,
+      defaultResponse: {
+        ...e.defaultResponse,
+        multipliers: multipliers.length === 0 ? void 0 : multipliers.map((m) => ({
+          id: (0, import_shared3.generateId)(),
+          name: m.name,
+          source: { kind: m.source.kind, key: m.source.key },
+          targetJsonPath: m.targetJsonPath,
+          defaultCount: m.defaultCount,
+          min: m.min,
+          max: m.max
+        }))
+      }
+    }));
+    if (!next) return { ok: false, error: "endpoint not found" };
+    const out = await ctx.workspace.apply({ kind: "mock.upsert", mock: next });
+    return { ok: true, changedIds: out.changedIds };
+  }
+};
+
+// src/tools/mocks.ts
+var import_zod8 = require("zod");
+var import_shared4 = require("@apicircle/shared");
+var import_mock_server_core2 = require("@apicircle/mock-server-core");
+async function ingestSource(source, name) {
+  const { endpoints, warnings } = await (0, import_mock_server_core2.parseSourceToEndpoints)(source);
+  const now = (/* @__PURE__ */ new Date()).toISOString();
+  const mock = {
+    id: (0, import_shared4.generateId)(),
+    name,
+    source,
+    endpoints,
+    defaultPort: null,
+    // Off by default — match UI-created mocks. User opts in via cors.enabled=true
+    // after explicitly listing origins (see CorsSection in MockServersPanel).
+    cors: { enabled: false, origins: [] },
+    createdAt: now,
+    updatedAt: now
+  };
+  return { mock, warnings };
+}
+var mockCreateFromOpenApiTool = {
+  name: "mock.create_from_openapi",
+  description: "Create a mock server from an OpenAPI / Swagger spec (YAML or JSON).",
+  inputSchema: import_zod8.z.object({
+    name: import_zod8.z.string(),
+    spec: import_zod8.z.string().min(1),
+    format: import_zod8.z.enum(["json", "yaml"]).default("json")
+  }),
+  async handler(input, ctx) {
+    const { mock, warnings } = await ingestSource(
+      { kind: "openapi", spec: input.spec, format: input.format },
+      input.name
+    );
+    const out = await ctx.workspace.apply({ kind: "mock.upsert", mock });
+    return {
+      id: mock.id,
+      endpointCount: mock.endpoints.length,
+      changedIds: out.changedIds,
+      warnings
+    };
+  }
+};
+var mockCreateFromPostmanTool = {
+  name: "mock.create_from_postman",
+  description: "Create a mock server from a Postman v2/v2.1 collection.",
+  inputSchema: import_zod8.z.object({ name: import_zod8.z.string(), collection: import_zod8.z.string().min(1) }),
+  async handler(input, ctx) {
+    const { mock, warnings } = await ingestSource(
+      { kind: "postman", collection: input.collection },
+      input.name
+    );
+    const out = await ctx.workspace.apply({ kind: "mock.upsert", mock });
+    return {
+      id: mock.id,
+      endpointCount: mock.endpoints.length,
+      changedIds: out.changedIds,
+      warnings
+    };
+  }
+};
+var mockCreateFromInsomniaTool = {
+  name: "mock.create_from_insomnia",
+  description: "Create a mock server from an Insomnia v4 export.",
+  inputSchema: import_zod8.z.object({ name: import_zod8.z.string(), export: import_zod8.z.string().min(1) }),
+  async handler(input, ctx) {
+    const { mock, warnings } = await ingestSource(
+      { kind: "insomnia", export: input.export },
+      input.name
+    );
+    const out = await ctx.workspace.apply({ kind: "mock.upsert", mock });
+    return {
+      id: mock.id,
+      endpointCount: mock.endpoints.length,
+      changedIds: out.changedIds,
+      warnings
+    };
+  }
+};
+var mockImportPostmanMockCollectionTool = {
+  name: "mock.import_postman_mock_collection",
+  description: "Import a Postman Mock Collection (collections previously hosted on Postman's mock service). Same parser as a regular Postman collection but marked as a mock import.",
+  inputSchema: import_zod8.z.object({ name: import_zod8.z.string(), collection: import_zod8.z.string().min(1) }),
+  async handler(input, ctx) {
+    const { mock, warnings } = await ingestSource(
+      { kind: "postman", collection: input.collection },
+      input.name
+    );
+    const out = await ctx.workspace.apply({ kind: "mock.upsert", mock });
+    return {
+      id: mock.id,
+      endpointCount: mock.endpoints.length,
+      changedIds: out.changedIds,
+      warnings
+    };
+  }
+};
+var mockListTool = {
+  name: "mock.list",
+  description: "List all mock servers in the workspace plus their runtime status (running / stopped, port).",
+  inputSchema: import_zod8.z.object({}),
+  async handler(_input, ctx) {
+    const state = await ctx.workspace.read();
+    const running = await ctx.mock.list();
+    const runningById = new Map(running.map((r) => [r.serverId, r.runtime]));
+    const items = Object.values(state.synced.mockServers).map((m) => {
+      const runtime = runningById.get(m.id);
+      return {
+        id: m.id,
+        name: m.name,
+        endpointCount: m.endpoints.length,
+        defaultPort: m.defaultPort,
+        running: !!runtime,
+        port: runtime?.port ?? null
+      };
+    });
+    return { count: items.length, mocks: items };
+  }
+};
+var mockStartTool = {
+  name: "mock.start",
+  description: "Start a mock server by id. Returns the bound port. Errors if the mock is already running or the requested port is in use.",
+  inputSchema: import_zod8.z.object({
+    id: import_zod8.z.string(),
+    port: import_zod8.z.number().int().positive().optional()
+  }),
+  async handler(input, ctx) {
+    const state = await ctx.workspace.read();
+    const mock = state.synced.mockServers[input.id];
+    if (!mock) return { ok: false, error: "mock not found" };
+    try {
+      const result = await ctx.mock.start(mock, { port: input.port });
+      return { ok: true, port: result.port, pid: result.pid, startedAt: result.startedAt };
+    } catch (err) {
+      return { ok: false, error: err instanceof Error ? err.message : "mock.start failed" };
+    }
+  }
+};
+var mockStopTool = {
+  name: "mock.stop",
+  description: "Stop a running mock server by id (no-op if not running).",
+  inputSchema: import_zod8.z.object({ id: import_zod8.z.string() }),
+  async handler(input, ctx) {
+    try {
+      await ctx.mock.stop(input.id);
+      return { ok: true };
+    } catch (err) {
+      return { ok: false, error: err instanceof Error ? err.message : "mock.stop failed" };
+    }
+  }
+};
+var mockDeleteTool = {
+  name: "mock.delete",
+  description: "Delete a mock server definition. Stops it first if it's running.",
+  inputSchema: import_zod8.z.object({ id: import_zod8.z.string() }),
+  async handler(input, ctx) {
+    try {
+      await ctx.mock.stop(input.id);
+    } catch {
+    }
+    const out = await ctx.workspace.apply({ kind: "mock.delete", id: input.id });
+    return { ok: true, changedIds: out.changedIds };
+  }
+};
+var HTTP_METHOD3 = import_zod8.z.enum(["GET", "POST", "PUT", "PATCH", "DELETE", "HEAD", "OPTIONS"]);
+var mockCreateManualTool = {
+  name: "mock.create_manual",
+  description: "Create an empty manual-mode mock server. Use `mock.add_endpoint` afterward to populate it. CORS defaults to off (same-origin only); enable + list explicit origins via `mock.update_cors` if cross-origin access is needed.",
+  inputSchema: import_zod8.z.object({
+    name: import_zod8.z.string().min(1),
+    defaultPort: import_zod8.z.number().int().positive().nullable().optional()
+  }),
+  async handler(input, ctx) {
+    const now = (/* @__PURE__ */ new Date()).toISOString();
+    const mock = {
+      id: (0, import_shared4.generateId)(),
+      name: input.name,
+      source: { kind: "manual", endpoints: [] },
+      endpoints: [],
+      defaultPort: input.defaultPort ?? null,
+      // Off by default — match UI-created mocks. Caller opts in via
+      // explicit origins; we never silently wildcard.
+      cors: { enabled: false, origins: [] },
+      createdAt: now,
+      updatedAt: now
+    };
+    const out = await ctx.workspace.apply({ kind: "mock.upsert", mock });
+    return { id: mock.id, changedIds: out.changedIds };
+  }
+};
+var mockListEndpointsTool = {
+  name: "mock.list_endpoints",
+  description: "List endpoints for a mock server (id, method, path, name).",
+  inputSchema: import_zod8.z.object({ mockId: import_zod8.z.string() }),
+  async handler(input, ctx) {
+    const state = await ctx.workspace.read();
+    const mock = state.synced.mockServers[input.mockId];
+    if (!mock) return { ok: false, error: "mock not found" };
+    return {
+      ok: true,
+      count: mock.endpoints.length,
+      endpoints: mock.endpoints.map((e) => ({
+        id: e.id,
+        method: e.method,
+        pathPattern: e.pathPattern,
+        name: e.name,
+        validationCount: e.requestValidation.length,
+        responseRuleCount: e.responseRules.length
+      }))
+    };
+  }
+};
+var ENDPOINT_RESPONSE2 = import_zod8.z.object({
+  status: import_zod8.z.number().int().min(100).max(599).default(200),
+  jsonBody: import_zod8.z.string().default("{}"),
+  contentType: import_zod8.z.string().default("application/json")
+});
+function buildDefaultEndpoint(args) {
+  const response = args.response ?? {
+    status: 200,
+    jsonBody: "{}",
+    contentType: "application/json"
+  };
+  const headers = [{ key: "Content-Type", value: response.contentType, enabled: true }];
+  return {
+    id: (0, import_shared4.generateId)(),
+    name: args.name ?? `${args.method} ${args.pathPattern}`,
+    method: args.method,
+    pathPattern: args.pathPattern,
+    description: args.description,
+    requestSchema: (0, import_shared4.makeDefaultRequestSchema)(),
+    requestValidation: [],
+    responseRules: [],
+    defaultResponse: {
+      ...(0, import_shared4.makeDefaultMockResponse)(),
+      status: response.status,
+      headers,
+      body: { type: "json", content: response.jsonBody }
+    }
+  };
+}
+var mockAddEndpointTool = {
+  name: "mock.add_endpoint",
+  description: "Append a new endpoint to a mock server. Defaults to a 200 JSON response of `{}`. Returns the new endpoint id.",
+  inputSchema: import_zod8.z.object({
+    mockId: import_zod8.z.string(),
+    method: HTTP_METHOD3,
+    pathPattern: import_zod8.z.string().min(1),
+    name: import_zod8.z.string().optional(),
+    description: import_zod8.z.string().optional(),
+    response: ENDPOINT_RESPONSE2.optional()
+  }),
+  async handler(input, ctx) {
+    const state = await ctx.workspace.read();
+    const mock = state.synced.mockServers[input.mockId];
+    if (!mock) return { ok: false, error: "mock not found" };
+    const endpoint = buildDefaultEndpoint(input);
+    const nextEndpoints = [...mock.endpoints, endpoint];
+    const source = mock.source.kind === "manual" ? { kind: "manual", endpoints: nextEndpoints } : mock.source;
+    const next = {
+      ...mock,
+      source,
+      endpoints: nextEndpoints,
+      updatedAt: (/* @__PURE__ */ new Date()).toISOString()
+    };
+    const out = await ctx.workspace.apply({ kind: "mock.upsert", mock: next });
+    return { ok: true, endpointId: endpoint.id, changedIds: out.changedIds };
+  }
+};
+var mockUpdateEndpointTool = {
+  name: "mock.update_endpoint",
+  description: "Patch fields on a single mock endpoint (method, pathPattern, name, description, defaultResponse status / contentType / json body). Pass only the fields you want to change.",
+  inputSchema: import_zod8.z.object({
+    mockId: import_zod8.z.string(),
+    endpointId: import_zod8.z.string(),
+    method: HTTP_METHOD3.optional(),
+    pathPattern: import_zod8.z.string().optional(),
+    name: import_zod8.z.string().optional(),
+    description: import_zod8.z.string().optional(),
+    response: ENDPOINT_RESPONSE2.partial().optional()
+  }),
+  async handler(input, ctx) {
+    const state = await ctx.workspace.read();
+    const mock = state.synced.mockServers[input.mockId];
+    if (!mock) return { ok: false, error: "mock not found" };
+    const idx = mock.endpoints.findIndex((e) => e.id === input.endpointId);
+    if (idx === -1) return { ok: false, error: "endpoint not found" };
+    const existing = mock.endpoints[idx];
+    const nextEndpoint = {
+      ...existing,
+      method: input.method ?? existing.method,
+      pathPattern: input.pathPattern ?? existing.pathPattern,
+      name: input.name ?? existing.name,
+      description: input.description ?? existing.description,
+      defaultResponse: input.response ? {
+        ...existing.defaultResponse,
+        status: input.response.status ?? existing.defaultResponse.status,
+        headers: input.response.contentType ? existing.defaultResponse.headers.map(
+          (h) => h.key.toLowerCase() === "content-type" ? { ...h, value: input.response.contentType } : h
+        ) : existing.defaultResponse.headers,
+        body: input.response.jsonBody !== void 0 ? { type: "json", content: input.response.jsonBody } : existing.defaultResponse.body
+      } : existing.defaultResponse
+    };
+    const nextEndpoints = [...mock.endpoints];
+    nextEndpoints[idx] = nextEndpoint;
+    const source = mock.source.kind === "manual" ? { kind: "manual", endpoints: nextEndpoints } : mock.source;
+    const next = {
+      ...mock,
+      source,
+      endpoints: nextEndpoints,
+      updatedAt: (/* @__PURE__ */ new Date()).toISOString()
+    };
+    const out = await ctx.workspace.apply({ kind: "mock.upsert", mock: next });
+    return { ok: true, changedIds: out.changedIds };
+  }
+};
+var mockDeleteEndpointTool = {
+  name: "mock.delete_endpoint",
+  description: "Remove an endpoint from a mock server.",
+  inputSchema: import_zod8.z.object({ mockId: import_zod8.z.string(), endpointId: import_zod8.z.string() }),
+  async handler(input, ctx) {
+    const state = await ctx.workspace.read();
+    const mock = state.synced.mockServers[input.mockId];
+    if (!mock) return { ok: false, error: "mock not found" };
+    const nextEndpoints = mock.endpoints.filter((e) => e.id !== input.endpointId);
+    if (nextEndpoints.length === mock.endpoints.length) {
+      return { ok: false, error: "endpoint not found" };
+    }
+    const source = mock.source.kind === "manual" ? { kind: "manual", endpoints: nextEndpoints } : mock.source;
+    const next = {
+      ...mock,
+      source,
+      endpoints: nextEndpoints,
+      updatedAt: (/* @__PURE__ */ new Date()).toISOString()
+    };
+    const out = await ctx.workspace.apply({ kind: "mock.upsert", mock: next });
+    return { ok: true, changedIds: out.changedIds };
+  }
+};
+var VALIDATION_RULE = import_zod8.z.object({
+  id: import_zod8.z.string().optional(),
+  kind: import_zod8.z.enum([
+    "header-required",
+    "header-equals",
+    "header-matches",
+    "query-required",
+    "query-equals",
+    "query-matches",
+    "cookie-required",
+    "body-required",
+    "content-type-equals"
+  ]),
+  target: import_zod8.z.string().default(""),
+  expected: import_zod8.z.string().optional(),
+  message: import_zod8.z.string().optional(),
+  enabled: import_zod8.z.boolean().default(true),
+  failResponse: import_zod8.z.object({
+    status: import_zod8.z.number().int().min(100).max(599).default(400),
+    jsonBody: import_zod8.z.string().default('{"error":"validation failed"}')
+  }).default({})
+});
+var CONDITION_CLAUSE = import_zod8.z.object({
+  id: import_zod8.z.string().optional(),
+  scope: import_zod8.z.enum(["query", "pathParam", "header", "cookie", "body-json-path"]),
+  target: import_zod8.z.string(),
+  op: import_zod8.z.enum(["equals", "not-equals", "matches", "gt", "lt", "gte", "lte", "present", "absent"]),
+  value: import_zod8.z.string().optional()
+});
+var RESPONSE_RULE = import_zod8.z.object({
+  id: import_zod8.z.string().optional(),
+  name: import_zod8.z.string(),
+  enabled: import_zod8.z.boolean().default(true),
+  when: import_zod8.z.array(CONDITION_CLAUSE).default([]),
+  response: import_zod8.z.object({
+    status: import_zod8.z.number().int().min(100).max(599).default(200),
+    jsonBody: import_zod8.z.string().default("{}")
+  }).default({})
+});
+var MULTIPLIER = import_zod8.z.object({
+  id: import_zod8.z.string().optional(),
+  name: import_zod8.z.string().optional(),
+  source: import_zod8.z.object({
+    kind: import_zod8.z.enum(["query", "pathParam", "header", "body-json-path"]),
+    key: import_zod8.z.string()
+  }),
+  targetJsonPath: import_zod8.z.string(),
+  defaultCount: import_zod8.z.number().int().nonnegative().default(0),
+  min: import_zod8.z.number().int().nonnegative().optional(),
+  max: import_zod8.z.number().int().nonnegative().optional()
+});
+function defaultJsonResponseConfig(args) {
+  return {
+    status: args.status,
+    headers: [{ key: "Content-Type", value: "application/json", enabled: true }],
+    body: { type: "json", content: args.jsonBody }
+  };
+}
+function patchEndpoint2(mock, endpointId, patcher) {
+  const idx = mock.endpoints.findIndex((e) => e.id === endpointId);
+  if (idx === -1) return null;
+  const nextEndpoints = [...mock.endpoints];
+  nextEndpoints[idx] = patcher(mock.endpoints[idx]);
+  const source = mock.source.kind === "manual" ? { kind: "manual", endpoints: nextEndpoints } : mock.source;
+  return {
+    ...mock,
+    source,
+    endpoints: nextEndpoints,
+    updatedAt: (/* @__PURE__ */ new Date()).toISOString()
+  };
+}
+var mockSetValidationRulesTool = {
+  name: "mock.set_validation_rules",
+  description: "Replace an endpoint's validation rules. Rules without an `id` get a fresh one; existing rules can keep theirs to preserve client-side selection state. Empty array clears all rules.",
+  inputSchema: import_zod8.z.object({
+    mockId: import_zod8.z.string(),
+    endpointId: import_zod8.z.string(),
+    rules: import_zod8.z.array(VALIDATION_RULE)
+  }),
+  async handler(input, ctx) {
+    const state = await ctx.workspace.read();
+    const mock = state.synced.mockServers[input.mockId];
+    if (!mock) return { ok: false, error: "mock not found" };
+    const rules = input.rules;
+    const next = patchEndpoint2(mock, input.endpointId, (e) => ({
+      ...e,
+      requestValidation: rules.map((r) => ({
+        id: r.id ?? (0, import_shared4.generateId)(),
+        kind: r.kind,
+        target: r.target,
+        expected: r.expected,
+        message: r.message,
+        enabled: r.enabled,
+        failResponse: defaultJsonResponseConfig(r.failResponse)
+      }))
+    }));
+    if (!next) return { ok: false, error: "endpoint not found" };
+    const out = await ctx.workspace.apply({ kind: "mock.upsert", mock: next });
+    return { ok: true, changedIds: out.changedIds };
+  }
+};
+var mockSetResponseRulesTool = {
+  name: "mock.set_response_rules",
+  description: "Replace an endpoint's conditional response rules. Rules fire in order; the first whose every clause matches wins. Disabled rules are skipped. Empty array falls back to defaultResponse.",
+  inputSchema: import_zod8.z.object({
+    mockId: import_zod8.z.string(),
+    endpointId: import_zod8.z.string(),
+    rules: import_zod8.z.array(RESPONSE_RULE)
+  }),
+  async handler(input, ctx) {
+    const state = await ctx.workspace.read();
+    const mock = state.synced.mockServers[input.mockId];
+    if (!mock) return { ok: false, error: "mock not found" };
+    const rules = input.rules;
+    const next = patchEndpoint2(mock, input.endpointId, (e) => ({
+      ...e,
+      responseRules: rules.map((r) => ({
+        id: r.id ?? (0, import_shared4.generateId)(),
+        name: r.name,
+        enabled: r.enabled,
+        when: r.when.map((c) => ({
+          id: c.id ?? (0, import_shared4.generateId)(),
+          scope: c.scope,
+          target: c.target,
+          op: c.op,
+          value: c.value
+        })),
+        response: defaultJsonResponseConfig(r.response)
+      }))
+    }));
+    if (!next) return { ok: false, error: "endpoint not found" };
+    const out = await ctx.workspace.apply({ kind: "mock.upsert", mock: next });
+    return { ok: true, changedIds: out.changedIds };
+  }
+};
+var mockSetMultipliersTool = {
+  name: "mock.set_multipliers",
+  description: "Replace the response multipliers on an endpoint's defaultResponse. Multipliers expand an array at `targetJsonPath` to a count derived from a request value. Empty array clears all multipliers.",
+  inputSchema: import_zod8.z.object({
+    mockId: import_zod8.z.string(),
+    endpointId: import_zod8.z.string(),
+    multipliers: import_zod8.z.array(MULTIPLIER)
+  }),
+  async handler(input, ctx) {
+    const state = await ctx.workspace.read();
+    const mock = state.synced.mockServers[input.mockId];
+    if (!mock) return { ok: false, error: "mock not found" };
+    const multipliers = input.multipliers;
+    const next = patchEndpoint2(mock, input.endpointId, (e) => ({
+      ...e,
+      defaultResponse: {
+        ...e.defaultResponse,
+        multipliers: multipliers.length === 0 ? void 0 : multipliers.map((m) => ({
+          id: m.id ?? (0, import_shared4.generateId)(),
+          name: m.name,
+          source: { kind: m.source.kind, key: m.source.key },
+          targetJsonPath: m.targetJsonPath,
+          defaultCount: m.defaultCount,
+          min: m.min,
+          max: m.max
+        }))
+      }
+    }));
+    if (!next) return { ok: false, error: "endpoint not found" };
+    const out = await ctx.workspace.apply({ kind: "mock.upsert", mock: next });
+    return { ok: true, changedIds: out.changedIds };
+  }
+};
+
+// src/tools/registry.ts
+var TOOL_REGISTRY = [
+  importCurlTool,
+  importOpenApiTool,
+  importPostmanTool,
+  importInsomniaTool,
+  importHarTool,
+  generateCodeTool,
+  workspaceReadTool,
+  workspaceWriteTool,
+  requestCreateTool,
+  requestReadTool,
+  requestUpdateTool,
+  requestDeleteTool,
+  folderCreateTool,
+  folderReadTool,
+  folderUpdateTool,
+  folderDeleteTool,
+  environmentCreateTool,
+  environmentReadTool,
+  environmentUpdateTool,
+  environmentDeleteTool,
+  environmentSetActiveTool,
+  environmentSetPriorityTool,
+  environmentExportTool,
+  environmentImportTool,
+  planCreateTool,
+  planRunTool,
+  planReadTool,
+  planUpdateTool,
+  planDeleteTool,
+  planAddStepTool,
+  planRemoveStepTool,
+  planReorderStepsTool,
+  planSetVariablesTool,
+  assertionCreateTool,
+  assertionReadTool,
+  assertionUpdateTool,
+  assertionDeleteTool,
+  historyListRunsTool,
+  historyGetRunTool,
+  historyDeleteRunTool,
+  historyPurgeTool,
+  codebaseExtractCollectionTool,
+  promptCreateEnvironmentTool,
+  promptCreateAssertionTool,
+  promptCreatePlanTool,
+  promptCreateRequestTool,
+  promptUpdateRequestTool,
+  promptCreateFolderTreeTool,
+  promptAddPlanStepsTool,
+  promptSetPlanVariablesTool,
+  promptCreateMockServerTool,
+  promptAddMockEndpointTool,
+  promptSetEndpointValidationRulesTool,
+  promptSetEndpointResponseRulesTool,
+  promptSetEndpointMultipliersTool,
+  mockCreateFromOpenApiTool,
+  mockCreateFromPostmanTool,
+  mockCreateFromInsomniaTool,
+  mockCreateManualTool,
+  mockListTool,
+  mockListEndpointsTool,
+  mockStartTool,
+  mockStopTool,
+  mockDeleteTool,
+  mockAddEndpointTool,
+  mockUpdateEndpointTool,
+  mockDeleteEndpointTool,
+  mockSetValidationRulesTool,
+  mockSetResponseRulesTool,
+  mockSetMultipliersTool,
+  mockImportPostmanMockCollectionTool
+];
+function getTool(name) {
+  return TOOL_REGISTRY.find((t) => t.name === name);
+}
+
+// src/providers/InMemoryWorkspaceProvider.ts
+var import_core2 = require("@apicircle/core");
+var InMemoryWorkspaceProvider = class {
+  state;
+  constructor(initial) {
+    this.state = initial;
+  }
+  async read() {
+    return this.state;
+  }
+  async apply(patch) {
+    const out = (0, import_core2.applyMutation)(this.state, patch);
+    this.state = out.next;
+    return { state: this.state, changedIds: out.changedIds };
+  }
+  async write(next) {
+    this.state = {
+      synced: next.synced ?? this.state.synced,
+      local: next.local ?? this.state.local
+    };
+    return this.state;
+  }
+};
+
+// src/providers/FileBackedWorkspaceProvider.ts
+var import_core3 = require("@apicircle/core");
+var import_file_backed = require("@apicircle/core/workspace/file-backed");
+var FileBackedWorkspaceProvider = class {
+  constructor(dir) {
+    this.dir = dir;
+  }
+  dir;
+  async read() {
+    const out = await (0, import_file_backed.loadFromFile)(this.dir);
+    if (!out) {
+      throw new Error(`No workspace found at ${this.dir}`);
+    }
+    return out;
+  }
+  async apply(patch) {
+    let captured = null;
+    await (0, import_file_backed.withWorkspace)(this.dir, async (state) => {
+      const result = (0, import_core3.applyMutation)(state, patch);
+      captured = { state: result.next, changedIds: result.changedIds };
+      return { next: result.next };
+    });
+    if (!captured) throw new Error("apply did not run");
+    return captured;
+  }
+  async write(next) {
+    const current = await this.read();
+    const merged = {
+      synced: next.synced ?? current.synced,
+      local: next.local ?? current.local
+    };
+    await (0, import_file_backed.saveToFile)(this.dir, merged);
+    return merged;
+  }
+};
+
+// src/providers/InProcessMockController.ts
+var import_mock_server_core3 = require("@apicircle/mock-server-core");
+var InProcessMockController = class {
+  handles = /* @__PURE__ */ new Map();
+  meta = /* @__PURE__ */ new Map();
+  async start(server, opts = {}) {
+    if (this.handles.has(server.id)) {
+      throw new Error(`Mock '${server.id}' is already running`);
+    }
+    const handle = await (0, import_mock_server_core3.startMockServer)(server, {
+      port: opts.port ?? server.defaultPort ?? void 0
+    });
+    const runtime = {
+      port: handle.port,
+      pid: process.pid,
+      startedAt: (/* @__PURE__ */ new Date()).toISOString(),
+      lastError: null,
+      requestCount: 0
+    };
+    this.handles.set(server.id, handle);
+    this.meta.set(server.id, runtime);
+    return { port: handle.port, pid: runtime.pid, startedAt: runtime.startedAt };
+  }
+  async stop(serverId) {
+    const handle = this.handles.get(serverId);
+    if (!handle) return;
+    await (0, import_mock_server_core3.stopMockServer)(handle);
+    this.handles.delete(serverId);
+    this.meta.delete(serverId);
+  }
+  async list() {
+    return Array.from(this.meta.entries()).map(([serverId, runtime]) => ({
+      serverId,
+      runtime
+    }));
+  }
+};
+
+// src/index.ts
+function createMcpServer(options) {
+  return new McpHost({
+    serverInfo: options.serverInfo,
+    tools: options.tools ?? TOOL_REGISTRY,
+    context: { workspace: options.workspace, mock: options.mock }
+  });
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  FileBackedWorkspaceProvider,
+  InMemoryWorkspaceProvider,
+  InProcessMockController,
+  McpHost,
+  TOOL_REGISTRY,
+  createMcpServer,
+  getTool
+});
+//# sourceMappingURL=index.cjs.map