@dypai-ai/mcp 1.0.9 → 1.1.0

package/src/tools/codegen.js

@@ -0,0 +1,362 @@
+/**
+ * Codegen — generates TypeScript types + a typed api wrapper from the
+ * local dypai/ folder. Output lives inside src/ (by default src/dypai/)
+ * so it plays nicely with the user's tsconfig / bundler / `@/` alias.
+ *
+ * Reads:
+ *   dypai/schema.sql              → src/dypai/database.ts
+ *   dypai/endpoints/**.yaml       → src/dypai/api.ts
+ *
+ * Re-run is idempotent and cheap (<1s for typical projects). Auto-fired by
+ * pull / push / DDL so frontend types stay in sync without manual steps.
+ */
+
+import { readFile, readdir, mkdir, writeFile, access } from "fs/promises"
+import { join, resolve as resolvePath, dirname } from "path"
+import YAML from "yaml"
+import { readLocalConfig } from "./sync/planner.js"
+
+// ─── Naming helpers ─────────────────────────────────────────────────────────
+
+export function toCamel(name) {
+  return String(name).replace(/[-_](\w)/g, (_, c) => c.toUpperCase())
+    .replace(/^\w/, c => c.toLowerCase())
+}
+
+export function toPascal(name) {
+  const c = toCamel(name)
+  return c.charAt(0).toUpperCase() + c.slice(1)
+}
+
+// ─── SQL → TS type mapping ──────────────────────────────────────────────────
+
+function sqlTypeToTs(sqlType) {
+  const t = String(sqlType).toLowerCase().trim()
+  if (/^(uuid|text|varchar|char|character|citext|name)/.test(t)) return "string"
+  if (/^(timestamp|date|time|interval)/.test(t)) return "string"
+  if (/^(int|smallint|bigint|integer|numeric|decimal|real|double|serial|bigserial|float|money)/.test(t)) return "number"
+  if (/^(boolean|bool)/.test(t)) return "boolean"
+  if (/^(json|jsonb)/.test(t)) return "unknown"
+  if (/^bytea/.test(t)) return "string"
+  if (/\[\]$/.test(t)) {
+    const inner = sqlTypeToTs(t.replace(/\[\]$/, ""))
+    return `${inner}[]`
+  }
+  // Enums and user-defined types → string at MVP (could be refined later)
+  return "string"
+}
+
+// ─── Generate database.ts from schema.sql ───────────────────────────────────
+
+function parseCreateTable(ddl) {
+  // Extracts { table, columns: [{name, type, nullable, hasDefault}] }
+  const m = ddl.match(/CREATE\s+TABLE\s+public\.(\w+)\s*\(([\s\S]*?)\);/i)
+  if (!m) return null
+  const table = m[1]
+  const body = m[2]
+  const lines = body.split(/,\s*\n/).map(l => l.trim()).filter(Boolean)
+  const columns = []
+  for (const line of lines) {
+    // Skip constraint lines (PRIMARY KEY (...), FOREIGN KEY...)
+    if (/^(CONSTRAINT|PRIMARY KEY|UNIQUE|FOREIGN KEY|CHECK)\b/i.test(line)) continue
+    const colMatch = line.match(/^(\w+)\s+([^,]+?)(?:\s+(NOT NULL|NULL))?(?:\s+(PRIMARY KEY))?(?:\s+(DEFAULT\s+.+))?$/i)
+    if (!colMatch) {
+      const simple = line.match(/^(\w+)\s+(\w+(?:\s*\(\d+(?:\s*,\s*\d+)?\))?(?:\[\])?)\b/)
+      if (simple) {
+        columns.push({
+          name: simple[1],
+          type: simple[2],
+          nullable: !/NOT NULL/i.test(line),
+          hasDefault: /DEFAULT/i.test(line),
+        })
+      }
+      continue
+    }
+    columns.push({
+      name: colMatch[1],
+      type: colMatch[2].trim(),
+      nullable: !/NOT NULL/i.test(line),
+      hasDefault: /DEFAULT/i.test(line),
+    })
+  }
+  return { table, columns }
+}
+
+export function generateDatabaseTypes(schemaSql) {
+  // Split on the CREATE TABLE boundaries (keeping the "CREATE" prefix)
+  const tables = []
+  const re = /CREATE\s+TABLE\s+public\.\w+\s*\([\s\S]*?\);/gi
+  let m
+  while ((m = re.exec(schemaSql)) !== null) {
+    const parsed = parseCreateTable(m[0])
+    if (parsed) tables.push(parsed)
+  }
+
+  const lines = [
+    "// Auto-generated by dypai. Do NOT edit by hand — regenerated on every pull / push / DDL.",
+    "// Derived from dypai/schema.sql.",
+    "",
+    "export interface Database {",
+    "  public: {",
+    "    Tables: {",
+  ]
+
+  for (const t of tables) {
+    lines.push(`      ${t.table}: {`)
+    // Row = exactly what comes out of SELECT
+    lines.push(`        Row: {`)
+    for (const c of t.columns) {
+      const ts = sqlTypeToTs(c.type)
+      const opt = c.nullable ? " | null" : ""
+      lines.push(`          ${c.name}: ${ts}${opt}`)
+    }
+    lines.push(`        }`)
+    // Insert = what you can pass to INSERT (optional for nullable or with default)
+    lines.push(`        Insert: {`)
+    for (const c of t.columns) {
+      const ts = sqlTypeToTs(c.type)
+      const optional = c.nullable || c.hasDefault ? "?" : ""
+      const or = c.nullable ? " | null" : ""
+      lines.push(`          ${c.name}${optional}: ${ts}${or}`)
+    }
+    lines.push(`        }`)
+    // Update = partial of Insert
+    lines.push(`        Update: Partial<Database["public"]["Tables"]["${t.table}"]["Insert"]>`)
+    lines.push(`      }`)
+  }
+
+  lines.push("    }")
+  lines.push("  }")
+  lines.push("}")
+  lines.push("")
+  return lines.join("\n")
+}
+
+// ─── JSON Schema → TS inline ────────────────────────────────────────────────
+
+function jsonSchemaToTs(schema, indent = "") {
+  if (!schema || typeof schema !== "object") return "unknown"
+  if (Array.isArray(schema.enum) && schema.enum.length) {
+    return schema.enum.map(v => typeof v === "string" ? JSON.stringify(v) : String(v)).join(" | ")
+  }
+  const type = schema.type
+  if (type === "string") return "string"
+  if (type === "number" || type === "integer") return "number"
+  if (type === "boolean") return "boolean"
+  if (type === "null") return "null"
+  if (type === "array") {
+    const inner = jsonSchemaToTs(schema.items, indent)
+    return `Array<${inner}>`
+  }
+  if (type === "object" || schema.properties) {
+    const props = schema.properties || {}
+    const required = new Set(schema.required || [])
+    const keys = Object.keys(props)
+    if (!keys.length) return "Record<string, unknown>"
+    const next = indent + "  "
+    const body = keys.map(k => {
+      const opt = required.has(k) ? "" : "?"
+      return `${next}${JSON.stringify(k)}${opt}: ${jsonSchemaToTs(props[k], next)}`
+    }).join("\n")
+    return `{\n${body}\n${indent}}`
+  }
+  // Union of types (e.g. ["object","string"])
+  if (Array.isArray(type)) {
+    return type.map(t => jsonSchemaToTs({ ...schema, type: t }, indent)).join(" | ")
+  }
+  return "unknown"
+}
+
+// ─── Generate api.ts from endpoint YAMLs ────────────────────────────────────
+
+async function collectEndpoints(rootDir) {
+  const endpointsDir = join(rootDir, "endpoints")
+  const results = []
+  async function walk(dir) {
+    const entries = await readdir(dir, { withFileTypes: true }).catch(() => [])
+    for (const e of entries) {
+      const full = join(dir, e.name)
+      if (e.isDirectory()) await walk(full)
+      else if (e.isFile() && (e.name.endsWith(".yaml") || e.name.endsWith(".yml"))) {
+        try {
+          const raw = await readFile(full, "utf8")
+          const doc = YAML.parse(raw) || {}
+          if (doc.name) results.push(doc)
+        } catch { /* skip malformed */ }
+      }
+    }
+  }
+  await walk(endpointsDir)
+  return results
+}
+
+function isBodyMethod(m) {
+  return ["POST", "PUT", "PATCH"].includes(String(m || "GET").toUpperCase())
+}
+
+export function generateApiTypes(endpoints, sdkImport = "../lib/dypai") {
+  const methods = []
+  const usedNames = new Set()
+
+  for (const ep of endpoints) {
+    let methodName = toCamel(ep.name)
+    // Ensure JS-safe identifier
+    if (!/^[a-z][A-Za-z0-9]*$/.test(methodName)) {
+      methodName = methodName.replace(/[^A-Za-z0-9]/g, "_")
+    }
+    let unique = methodName
+    let i = 2
+    while (usedNames.has(unique)) {
+      unique = `${methodName}${i++}`
+    }
+    usedNames.add(unique)
+
+    const http = String(ep.method || "GET").toUpperCase()
+    const hasBody = isBodyMethod(http)
+    const inputTs = ep.input ? jsonSchemaToTs(ep.input, "  ") : "void"
+    const outputTs = ep.output ? jsonSchemaToTs(ep.output, "  ") : "unknown"
+
+    const inputParam = hasBody
+      ? (inputTs === "void" ? "body?: Record<string, unknown>" : `body: ${inputTs}`)
+      : (inputTs === "void" ? "params?: Record<string, unknown>" : `params?: ${inputTs}`)
+
+    const callArg = hasBody ? "body" : "params"
+    const httpLower = http.toLowerCase()
+
+    // Short JSDoc header
+    const desc = (ep.description || "").replace(/\*\//g, "* /")
+
+    methods.push([
+      `  /**`,
+      `   * ${http} /${ep.name}`,
+      desc ? `   * ${desc}` : null,
+      `   */`,
+      `  ${unique}: (${inputParam}) =>`,
+      `    dypai.api.${httpLower}<${outputTs}>(${JSON.stringify(ep.name)}, ${callArg}),`,
+      ``,
+    ].filter(Boolean).join("\n"))
+  }
+
+  return [
+    "// Auto-generated by dypai. Do NOT edit by hand — regenerated on every pull / push.",
+    "// Derived from dypai/endpoints/*.yaml.",
+    "",
+    `import { dypai } from ${JSON.stringify(sdkImport)}`,
+    "",
+    "export const api = {",
+    ...methods,
+    "} as const",
+    "",
+  ].join("\n")
+}
+
+// ─── Orchestrator ───────────────────────────────────────────────────────────
+
+async function ensureDir(p) {
+  await mkdir(p, { recursive: true })
+}
+
+async function fileExists(p) {
+  try { await access(p); return true } catch { return false }
+}
+
+/**
+ * Main entry: regenerate types from the dypai/ folder into the configured
+ * output directory (defaults to src/dypai/ inside the same workspace).
+ *
+ * Non-destructive when the workspace structure can't be resolved (e.g. no
+ * src/ folder) — skips silently so the action that triggered it doesn't fail.
+ */
+export async function regenerateTypes(rootDir, opts = {}) {
+  const config = await readLocalConfig(rootDir)
+  const codegenCfg = config?.codegen || {}
+  // Resolution: output_dir is relative to the WORKSPACE (parent of dypai/),
+  // not to dypai/ itself.
+  const workspace = dirname(rootDir)
+  const outputDir = resolvePath(workspace, codegenCfg.output_dir || "src/dypai")
+  const sdkImport = codegenCfg.sdk_import || "../lib/dypai"
+
+  const files_written = []
+  const skipped = []
+
+  // Ensure src/ exists — if not, skip with a note (probably not a typical web project)
+  const srcDir = resolvePath(workspace, "src")
+  if (!(await fileExists(srcDir)) && !codegenCfg.output_dir) {
+    return {
+      skipped: true,
+      reason: "no src/ folder found — skipping codegen. Set codegen.output_dir in dypai.config.yaml to override.",
+    }
+  }
+
+  await ensureDir(outputDir)
+
+  // database.ts (only if schema.sql exists)
+  const schemaPath = join(rootDir, "schema.sql")
+  if (await fileExists(schemaPath)) {
+    const schema = await readFile(schemaPath, "utf8")
+    const dbTs = generateDatabaseTypes(schema)
+    const dbPath = join(outputDir, "database.ts")
+    await writeFile(dbPath, dbTs, "utf8")
+    files_written.push(dbPath)
+  } else {
+    skipped.push("database.ts (no schema.sql)")
+  }
+
+  // api.ts (only if endpoints/ has at least one yaml)
+  const endpoints = await collectEndpoints(rootDir)
+  if (endpoints.length > 0) {
+    const apiTs = generateApiTypes(endpoints, sdkImport)
+    const apiPath = join(outputDir, "api.ts")
+    await writeFile(apiPath, apiTs, "utf8")
+    files_written.push(apiPath)
+  } else {
+    skipped.push("api.ts (no endpoint YAMLs)")
+  }
+
+  // index.ts
+  if (files_written.length > 0) {
+    const exports = []
+    if (files_written.some(f => f.endsWith("database.ts"))) exports.push('export type { Database } from "./database"')
+    if (files_written.some(f => f.endsWith("api.ts"))) exports.push('export { api } from "./api"')
+    const indexPath = join(outputDir, "index.ts")
+    await writeFile(indexPath, exports.join("\n") + "\n", "utf8")
+    files_written.push(indexPath)
+  }
+
+  return {
+    regenerated: true,
+    output_dir: outputDir,
+    files_written,
+    endpoints_count: endpoints.length,
+    skipped: skipped.length ? skipped : undefined,
+  }
+}
+
+// ─── Standalone tool ────────────────────────────────────────────────────────
+
+export const dypaiCodegenTool = {
+  name: "dypai_codegen",
+  description:
+    "Regenerate TypeScript types from dypai/schema.sql + dypai/endpoints/*.yaml into src/dypai/ (default). " +
+    "Produces: database.ts (Database interface for tables), api.ts (typed wrapper around dypai.api.*), index.ts (re-exports). " +
+    "Auto-runs after dypai_pull, dypai_push, and DDL via execute_sql — this tool is for manual/CI regeneration. " +
+    "Configure output location via dypai.config.yaml codegen.output_dir and codegen.sdk_import.",
+  inputSchema: {
+    type: "object",
+    properties: {
+      root_dir: { type: "string", default: "./dypai", description: "Path to the dypai/ folder." },
+    },
+  },
+  async execute({ root_dir = "./dypai" } = {}) {
+    const rootDir = resolvePath(process.cwd(), root_dir)
+    const result = await regenerateTypes(rootDir)
+    if (result.skipped) {
+      return { success: true, ...result, hint: result.reason }
+    }
+    return {
+      success: true,
+      ...result,
+      hint: `Import from '@/dypai' (or relative): \`import { api } from '@/dypai'\`. Types regenerate automatically on pull/push/DDL.`,
+    }
+  },
+}

package/src/tools/deploy.js

@@ -129,34 +129,12 @@ function detectFramework(dir) {
   } catch { return null }
 }
 
-export const deployTool = {
-  name: "deploy_frontend",
-  description: `Deploy frontend source code from a local directory.
-
-Reads all source files from the specified directory and uploads them to DYPAI.
-The build runs in the cloud — no local Node.js or npm required.
-
-Supports: React, Vite, Next.js, Astro, SvelteKit, Nuxt, Vue, CRA, and more.
-DYPAI auto-detects the framework and routes to the optimal backend.
-
-After deploying, the site is live at https://{slug}.dypai.app within ~30s.`,
-
-  inputSchema: {
-    type: "object",
-    properties: {
-      sourceDirectory: {
-        type: "string",
-        description: "Absolute path to the project source directory (e.g. /Users/me/my-app). Must contain a package.json.",
-      },
-      project_id: {
-        type: "string",
-        description: "Project UUID. Required.",
-      },
-    },
-    required: ["sourceDirectory", "project_id"],
-  },
-
-  async execute({ sourceDirectory, project_id }) {
+/**
+ * Pure deploy function — used by the consolidated `manage_frontend` tool.
+ * Reads the source directory, uploads to the API, returns a structured
+ * response the caller can hand back to the agent.
+ */
+export async function deployFromSource({ sourceDirectory, project_id }) {
     if (!existsSync(sourceDirectory)) {
       return { error: `Directory not found: ${sourceDirectory}` }
     }
@@ -180,88 +158,40 @@ After deploying, the site is live at https://{slug}.dypai.app within ~30s.`,
 
       const label = framework?.label ?? "Project"
 
-      // ── Wait for CF Pages build (poll up to ~2 min) ──────────────────────
-      let buildResult = null
-      const maxAttempts = 12       // 12 × 10s = 2 min max
-      const pollInterval = 10_000  // 10 seconds
-
-      for (let i = 0; i < maxAttempts; i++) {
-        await new Promise(r => setTimeout(r, pollInterval))
-        try {
-          const status = await api.get(`/api/engine/${project_id}/frontend/build-status`)
-          const s = status?.status
-          if (s === "success") {
-            buildResult = { status: "success", url: result.url, duration: status.duration_seconds }
-            break
-          }
-          if (s === "failure") {
-            // Fetch build logs for error context
-            let logs = status.build_error || null
-            if (!logs) {
-              try {
-                const deployments = await api.get(`/api/engine/${project_id}/frontend/deployments?limit=1`)
-                const depId = deployments?.deployments?.[0]?.id
-                if (depId) {
-                  const logRes = await api.get(`/api/engine/${project_id}/frontend/deployments/${depId}/logs`)
-                  if (logRes?.logs) {
-                    const lines = logRes.logs.split("\n")
-                    logs = lines.slice(-30).join("\n")
-                  }
-                }
-              } catch {}
-            }
-            buildResult = { status: "failure", error: logs || "Build failed — check logs with get_deployment_logs" }
-            break
-          }
-          // still queued/building — keep polling
-        } catch {
-          // build-status not available yet, keep polling
-        }
-      }
-
-      if (!buildResult) {
-        // Timed out — build still in progress
-        return {
-          success: true,
-          url: result.url,
-          files_pushed: files.length,
-          size_bytes: total,
-          framework: label,
-          build_status: "building",
-          message: `Deployed ${files.length} files (${Math.round(total / 1024)} KB). ${label} build still in progress at ${result.url} — use get_build_status to check progress.`,
-        }
-      }
-
-      if (buildResult.status === "failure") {
-        return {
-          success: false,
-          url: result.url,
-          files_pushed: files.length,
-          framework: label,
-          build_status: "failure",
-          build_error: buildResult.error,
-          message: `Deploy pushed ${files.length} files but the ${label} build FAILED. Build error:\n${buildResult.error}`,
-        }
-      }
-
+      // Fire-and-forget: return immediately with "queued" status. The agent
+      // is expected to call `get_build_status` to poll progress until the
+      // terminal "success" / "failure" is reached. Blocking here would stall
+      // the agent for up to 2 minutes and prevent it from doing anything
+      // else in parallel.
       const skippedMsg = skipped.length > 0
         ? `\n\nSkipped ${skipped.length} file(s):\n${skipped.map(s => `  - ${s.path}: ${s.reason}`).join("\n")}`
         : ""
 
       return {
         success: true,
-        url: result.url,
+        deployed: false,  // explicit: not live yet, still building
+        url: result.url,  // final URL once success
         files_pushed: files.length,
         files_skipped: skipped.length,
         skipped_files: skipped.length > 0 ? skipped : undefined,
         size_bytes: total,
         framework: label,
-        build_status: "success",
-        build_duration: buildResult.duration,
-        message: `Deployed ${files.length} files (${Math.round(total / 1024)} KB). ${label} build succeeded${buildResult.duration ? ` in ${buildResult.duration}s` : ""}. Live at ${result.url}${skippedMsg}`,
+        build_status: "queued",
+        next_step: {
+          action: "poll_build_status",
+          tool: "manage_frontend",
+          arg: { operation: "build_status", project_id },
+          interval_seconds: 5,
+          expected_total_seconds: 60,
+          terminal_statuses: ["success", "failure"],
+        },
+        message:
+          `Deploy accepted — ${files.length} files (${Math.round(total / 1024)} KB) queued. ` +
+          `The build is running in the cloud (${label}, typically 20–60s). ` +
+          `Call manage_frontend({operation:"build_status", project_id:"${project_id}"}) every ~5s until status is "success" or "failure" ` +
+          `before reporting completion to the user. The site is NOT live yet.${skippedMsg}`,
       }
     } catch (e) {
       return { error: `Deploy failed: ${e.message}` }
     }
-  },
 }

package/src/tools/domains.js

@@ -1,73 +1,70 @@
 /**
- * Domain management tools — add, list, remove custom domains.
+ * manage_domain — single entry point for custom-domain operations.
+ *
+ * Consolidates what used to be add_domain / list_domains / remove_domain into
+ * one `operation`-dispatched tool (same pattern as manage_users / manage_roles).
+ * `verify` is also included so the agent can trigger an on-demand DNS/SSL
+ * check after the user configures their CNAME.
  */
 
 import { api } from "../api.js"
 
-export const addDomainTool = {
-  name: "add_domain",
-  description: `Add a custom domain to your project's frontend.
-
-Returns DNS instructions (CNAME record) that the user needs to configure
-at their domain registrar. SSL is automatic once DNS propagates.`,
+export const manageDomainTool = {
+  name: "manage_domain",
+  description:
+    "Manage custom domains for the project's frontend. " +
+    "Operations: list (all domains + DNS/SSL status), add (returns the CNAME the user must configure at their registrar — SSL is automatic), " +
+    "remove (disconnect a domain), verify (force an on-demand DNS/SSL re-check for a domain). " +
+    "The platform polls DNS automatically in the background, so `verify` is only needed when the user just updated their DNS and wants immediate feedback.",
 
   inputSchema: {
     type: "object",
     properties: {
-      project_id: { type: "string", description: "Project UUID." },
-      domain: { type: "string", description: "Domain to add (e.g. www.example.com)" },
+      operation: {
+        type: "string",
+        enum: ["list", "add", "remove", "verify"],
+        description: "Which action to run.",
+      },
+      project_id: {
+        type: "string",
+        description: "Project UUID. Auto-injected from dypai.config.yaml when omitted.",
+      },
+      domain: {
+        type: "string",
+        description: "Domain name (required for add, remove, verify). E.g. 'www.example.com'.",
+      },
     },
-    required: ["project_id", "domain"],
+    required: ["operation"],
   },
 
-  async execute({ project_id, domain }) {
-    try {
-      return await api.post(`/api/engine/${project_id}/frontend/domains`, { domain })
-    } catch (e) {
-      return { error: e.message }
+  async execute({ operation, project_id, domain } = {}) {
+    if (!operation) {
+      return { success: false, error: "operation is required (list | add | remove | verify)." }
     }
-  },
-}
-
-export const listDomainsTool = {
-  name: "list_domains",
-  description: "List all custom domains configured for the project's frontend.",
-
-  inputSchema: {
-    type: "object",
-    properties: {
-      project_id: { type: "string", description: "Project UUID." },
-    },
-    required: ["project_id"],
-  },
-
-  async execute({ project_id }) {
-    try {
-      return await api.get(`/api/engine/${project_id}/frontend/domains`)
-    } catch (e) {
-      return { error: e.message }
+    if (!project_id) {
+      return { success: false, error: "project_id is required. Set it in dypai.config.yaml or pass it explicitly." }
     }
-  },
-}
-
-export const removeDomainTool = {
-  name: "remove_domain",
-  description: "Remove a custom domain from the project's frontend.",
 
-  inputSchema: {
-    type: "object",
-    properties: {
-      project_id: { type: "string", description: "Project UUID." },
-      domain: { type: "string", description: "Domain to remove." },
-    },
-    required: ["project_id", "domain"],
-  },
+    const needsDomain = ["add", "remove", "verify"]
+    if (needsDomain.includes(operation) && !domain) {
+      return { success: false, error: `operation '${operation}' requires a 'domain' argument.` }
+    }
 
-  async execute({ project_id, domain }) {
     try {
-      return await api.delete(`/api/engine/${project_id}/frontend/domains/${domain}`)
+      switch (operation) {
+        case "list":
+          return await api.get(`/api/engine/${project_id}/frontend/domains`)
+        case "add":
+          return await api.post(`/api/engine/${project_id}/frontend/domains`, { domain })
+        case "remove":
+          return await api.delete(`/api/engine/${project_id}/frontend/domains/${encodeURIComponent(domain)}`)
+        case "verify":
+          return await api.get(`/api/engine/${project_id}/frontend/domains/${encodeURIComponent(domain)}/verify`)
+        default:
+          return { success: false, error: `Unknown operation '${operation}'. Use list | add | remove | verify.` }
+      }
     } catch (e) {
-      return { error: e.message }
+      return { success: false, error: e.message, operation, domain: domain || null }
     }
   },
 }

package/src/tools/enrich.js

@@ -0,0 +1,17 @@
+/**
+ * Client-side enrichment pass-through.
+ *
+ * Response enrichment (hints on errors, next_step on non-obvious success) lives
+ * on the REMOTE MCP server now (dypai-mcp, Python) so every client — local
+ * MCP, dashboard, direct curl — gets the same agent-UX treatment. Keeping
+ * this file as a no-op stub lets us re-introduce client-only enrichment
+ * later (e.g. for local filesystem context) without touching index.js.
+ */
+
+export function enrichSuccess(_toolName, result) {
+  return result
+}
+
+export function enrichError(_toolName, error) {
+  return error
+}