@dypai-ai/mcp 1.4.3 → 1.4.5

package/src/tools/sync/test-endpoint.js

@@ -1,12 +1,19 @@
 /**
- * dypai_test_endpoint — test an endpoint by name using its LOCAL YAML.
+ * dypai_test_endpoint — test an endpoint by name from one of three sources.
  *
- * Pre-git-first world: the agent had to pass workflow_code or endpoint_id to
- * the remote test_workflow. Now the YAML lives on disk — so we just take a
- * name + input, read the file, deserialize via the codec, and execute.
+ * Modes:
+ *   - 'local' (default): read & deserialize the LOCAL YAML on disk. Tight
+ *     iteration loop — test edits BEFORE dypai_push.
+ *   - 'draft': fetch the pending draft from the engine (via manage_drafts(list))
+ *     and run it. Use this AFTER dypai_push to verify exactly what
+ *     manage_drafts(operation:'publish') will ship.
+ *   - 'live': fetch the currently-deployed workflow_code from system.endpoints.
+ *     Use this to repro a live bug or sanity-check what's serving traffic.
  *
- * The big win: you're testing the EDITED version before pushing. Tight
- * iteration loop without round-tripping through dypai_push + remote lookup.
+ * All three modes funnel into the same remote test_workflow (workflow_code
+ * passed inline) so impersonation, trace summarization, and trace_mode work
+ * uniformly. mode:'draft' and mode:'live' skip pre-flight validation — the
+ * source isn't local YAML, so there's nothing to lint.
  */
 
 import { readFile, readdir } from "fs/promises"
@@ -75,20 +82,160 @@ async function findEndpointByName(rootDir, name) {
 
 // ─── Tool ───────────────────────────────────────────────────────────────────
 
+// ─── Source resolvers (one per mode) ────────────────────────────────────────
+//
+// Each resolver returns either:
+//   { workflow_code, source: { mode, ...metadata } }
+// or:
+//   { error, hint?, ...debug }   (caller short-circuits with success:false)
+
+async function resolveLocal(rootDir, endpoint, mapsCtx) {
+  const found = await findEndpointByName(rootDir, endpoint)
+  if (!found) {
+    return {
+      error: `Endpoint '${endpoint}' not found under dypai/endpoints/.`,
+      hint: "Run dypai_pull to refresh, or check that the YAML's top-level `name` matches. " +
+            "If you want to test a draft or live version that isn't on disk, pass mode:'draft' or mode:'live'.",
+    }
+  }
+
+  const refs = collectFileRefs(found.doc)
+  const fileMap = {}
+  for (const ref of refs) {
+    try {
+      fileMap[ref] = await readFile(join(rootDir, ref), "utf8")
+    } catch (e) {
+      return {
+        error: `Referenced file not readable: ${ref} (${e.message})`,
+        hint: "The YAML points to a *_file that doesn't exist on disk. Run dypai_pull or create the missing file.",
+      }
+    }
+  }
+
+  const deserCtx = { ...mapsCtx, readFile: (p) => fileMap[p] ?? "" }
+  let row
+  try {
+    row = deserializeEndpoint(found.doc, deserCtx)
+  } catch (e) {
+    return {
+      error: `Failed to deserialize '${endpoint}' from its YAML: ${e.message}`,
+      hint: "Run dypai_validate to surface the specific problem.",
+    }
+  }
+
+  return {
+    workflow_code: row.workflow_code,
+    source: {
+      mode: "local",
+      file: found.full.replace(rootDir + "/", ""),
+      doc: found.doc,
+    },
+  }
+}
+
+async function resolveDraft(projectId, endpoint) {
+  const result = await proxyToolCall("manage_drafts", { operation: "list", project_id: projectId })
+  if (result?.error) {
+    return { error: `manage_drafts(list) failed: ${result.error}` }
+  }
+  const drafts = Array.isArray(result?.drafts) ? result.drafts : []
+  const match = drafts.find(d => d?.resource_type === "endpoint" && d?.resource_name === endpoint)
+  if (!match) {
+    const otherEndpointDrafts = drafts.filter(d => d?.resource_type === "endpoint").map(d => d.resource_name)
+    return {
+      error: `No pending draft for endpoint '${endpoint}'.`,
+      hint: otherEndpointDrafts.length
+        ? `Pending endpoint drafts: ${otherEndpointDrafts.join(", ")}. ` +
+          `If you wanted to test the LOCAL YAML use mode:'local' (default), or mode:'live' for the deployed version.`
+        : "No endpoint drafts at all. Use mode:'local' to test your YAML or mode:'live' for the deployed version.",
+    }
+  }
+  if (match.pending_deletion) {
+    return {
+      error: `Draft for '${endpoint}' is a deletion (pending_deletion=true) — there's no workflow_code to test.`,
+      hint: "If you want to test what's currently live, use mode:'live'.",
+    }
+  }
+  const payload = match.payload || {}
+  const workflow_code = payload.workflow_code
+  if (!workflow_code || typeof workflow_code !== "object") {
+    return {
+      error: `Draft for '${endpoint}' has no workflow_code in its payload — cannot test.`,
+      raw_draft: match,
+    }
+  }
+  return {
+    workflow_code,
+    source: {
+      mode: "draft",
+      draft_id: match.id,
+      created_at: match.created_at,
+      created_by: match.created_by,
+    },
+  }
+}
+
+async function resolveLive(projectId, endpoint) {
+  // Look up the deployed row directly. system.endpoints.workflow_code is jsonb.
+  const sql = `SELECT id, name, workflow_code, updated_at
+               FROM system.endpoints
+               WHERE name = '${endpoint.replace(/'/g, "''")}'
+               LIMIT 1`
+  const result = await proxyToolCall("execute_sql", { project_id: projectId, sql })
+  if (result?.error) {
+    return { error: `execute_sql failed: ${result.error}` }
+  }
+  const rows = Array.isArray(result?.rows) ? result.rows : []
+  if (rows.length === 0) {
+    return {
+      error: `No live endpoint named '${endpoint}' is deployed.`,
+      hint: "If it only exists locally, use mode:'local'. If it was just pushed it may still be a pending draft — try mode:'draft' (then publish with manage_drafts).",
+    }
+  }
+  const row = rows[0]
+  let workflow_code = row.workflow_code
+  if (typeof workflow_code === "string") {
+    try { workflow_code = JSON.parse(workflow_code) } catch { /* leave as-is */ }
+  }
+  if (!workflow_code || typeof workflow_code !== "object") {
+    return {
+      error: `Live endpoint '${endpoint}' has empty/malformed workflow_code.`,
+      raw_row: row,
+    }
+  }
+  return {
+    workflow_code,
+    source: {
+      mode: "live",
+      endpoint_id: row.id,
+      updated_at: row.updated_at,
+    },
+  }
+}
+
+// ─── Tool ───────────────────────────────────────────────────────────────────
+
 export const dypaiTestEndpointTool = {
   name: "dypai_test_endpoint",
   description:
-    "Test an endpoint using its LOCAL YAML (dypai/endpoints/<name>.yaml, any group). " +
-    "You only pass the endpoint name + input — the tool reads the YAML, inlines referenced SQL/code/prompt files, " +
-    "and runs a debug execution against the engine. Use this to iterate BEFORE dypai_push. " +
-    "For jwt endpoints, pass as_user with the UUID to impersonate. " +
-    "Returns a summarized per-node trace by default; pass trace_mode: 'full' for the unabbreviated view.",
+    "Test an endpoint by name. Three sources via `mode`: " +
+    "'local' (default) reads dypai/endpoints/<name>.yaml from disk and inlines referenced SQL/code/prompt files — use BEFORE dypai_push to iterate; " +
+    "'draft' fetches the pending draft staged by dypai_push — use AFTER dypai_push to verify exactly what manage_drafts(operation:'publish') will ship; " +
+    "'live' fetches the currently-deployed workflow_code from system.endpoints — use to repro a live bug or check what's serving traffic. " +
+    "All modes execute via the engine's debug runner with full impersonation (as_user for jwt) and trace summarization. " +
+    "Pre-flight YAML validation only runs in mode:'local'.",
   inputSchema: {
     type: "object",
     properties: {
       endpoint: {
         type: "string",
-        description: "Endpoint name as declared in its YAML (e.g. 'create-order'). Looked up in dypai/endpoints/** by matching doc.name.",
+        description: "Endpoint name (e.g. 'create-order'). For mode:'local' looked up by doc.name in dypai/endpoints/**; for 'draft'/'live' looked up by name on the engine.",
+      },
+      mode: {
+        type: "string",
+        enum: ["local", "draft", "live"],
+        description: "Source of the workflow_code: 'local' (default, reads YAML on disk), 'draft' (pending changes staged by dypai_push), or 'live' (currently deployed version).",
+        default: "local",
       },
       input: {
         type: "object",
@@ -106,7 +253,7 @@ export const dypaiTestEndpointTool = {
       },
       root_dir: {
         type: "string",
-        description: "Path to the dypai/ folder (default: ./dypai).",
+        description: "Path to the dypai/ folder (default: ./dypai). Only used in mode:'local'.",
         default: "./dypai",
       },
       project_id: {
@@ -115,89 +262,85 @@ export const dypaiTestEndpointTool = {
       },
       skip_validation: {
         type: "boolean",
-        description: "Skip the pre-flight validate pass. Default false — useful only when you intentionally want to send a malformed YAML to the engine to inspect its raw error.",
+        description: "Skip the pre-flight validate pass (mode:'local' only). Default false — useful only when you intentionally want to send a malformed YAML to the engine to inspect its raw error.",
         default: false,
       },
     },
     required: ["endpoint"],
   },
 
-  async execute({ endpoint, input = {}, as_user, trace_mode = "smart", root_dir = "./dypai", project_id, skip_validation = false } = {}) {
+  async execute({ endpoint, mode = "local", input = {}, as_user, trace_mode = "smart", root_dir = "./dypai", project_id, skip_validation = false } = {}) {
     const rootDir = resolvePath(process.cwd(), root_dir)
 
     if (!endpoint) {
       return { success: false, error: "endpoint name is required." }
     }
+    if (!["local", "draft", "live"].includes(mode)) {
+      return { success: false, error: `Unknown mode '${mode}'. Use 'local', 'draft' or 'live'.` }
+    }
 
-    const found = await findEndpointByName(rootDir, endpoint)
-    if (!found) {
+    // Resolve project_id (needed by all three modes — local needs it to look
+    // up credential/tool UUID maps for the codec).
+    const config = await readLocalConfig(rootDir)
+    const targetProjectId = project_id || config?.project_id
+    if (!targetProjectId) {
       return {
         success: false,
-        error: `Endpoint '${endpoint}' not found under dypai/endpoints/.`,
-        hint: "Run dypai_pull to refresh, or check that the YAML's top-level `name` matches.",
+        error: "project_id required (set it in dypai.config.yaml or pass it explicitly).",
       }
     }
 
-    // Pre-read any *_file references so the codec can inline them
-    const refs = collectFileRefs(found.doc)
-    const fileMap = {}
-    for (const ref of refs) {
+    // ── Source resolution per mode ──────────────────────────────────────────
+    let resolved
+    if (mode === "local") {
+      // Local needs the codec context (credential/tool name → UUID).
+      let mapsCtx
       try {
-        fileMap[ref] = await readFile(join(rootDir, ref), "utf8")
+        const remote = await fetchRemoteState(targetProjectId)
+        mapsCtx = remote?.mapsCtx
       } catch (e) {
         return {
           success: false,
-          error: `Referenced file not readable: ${ref} (${e.message})`,
-          hint: "The YAML points to a *_file that doesn't exist on disk. Run dypai_pull or create the missing file.",
+          error: `Could not fetch remote state to resolve credential/tool references: ${e.message}`,
         }
       }
-    }
-
-    // Resolve project + credential/tool UUID maps for the codec
-    const config = await readLocalConfig(rootDir)
-    const targetProjectId = project_id || config?.project_id
-    if (!targetProjectId) {
-      return {
-        success: false,
-        error: "project_id required (set it in dypai.config.yaml or pass it explicitly).",
+      if (!mapsCtx) {
+        return {
+          success: false,
+          error: "Remote state returned without mapsCtx — cannot resolve credential/tool references.",
+          hint: "Check your DYPAI_TOKEN and that the project_id is correct.",
+        }
       }
+      resolved = await resolveLocal(rootDir, endpoint, mapsCtx)
+    } else if (mode === "draft") {
+      resolved = await resolveDraft(targetProjectId, endpoint)
+    } else {
+      resolved = await resolveLive(targetProjectId, endpoint)
     }
 
-    let mapsCtx
-    try {
-      const remote = await fetchRemoteState(targetProjectId)
-      mapsCtx = remote?.mapsCtx
-    } catch (e) {
-      return {
-        success: false,
-        error: `Could not fetch remote state to resolve credential/tool references: ${e.message}`,
-      }
-    }
-    if (!mapsCtx) {
-      return {
-        success: false,
-        error: "Remote state returned without mapsCtx — cannot resolve credential/tool references.",
-        hint: "Check your DYPAI_TOKEN and that the project_id is correct.",
-      }
+    if (resolved.error) {
+      return { success: false, mode, endpoint, ...resolved }
     }
 
-    // ── Pre-flight validation (skippable) ────────────────────────────────────
+    // ── Pre-flight validation (mode:'local' only, skippable) ────────────────
     // Run the same linter dypai_push uses, but filter to errors that affect THIS
     // endpoint only — warnings and other-endpoint diagnostics shouldn't block
     // a focused test. Catches things like mutation+query_file, missing where,
     // unknown node types, placeholder typos, etc. before the engine sees them.
-    if (!skip_validation) {
+    // Skipped for 'draft'/'live': source is the engine itself, nothing to lint.
+    if (mode === "local" && !skip_validation) {
       try {
         const valResult = await runValidation(rootDir, targetProjectId)
         const relevantErrors = (valResult.diagnostics || []).filter(d =>
-          d.severity === "error" && d.endpoint === found.doc.name
+          d.severity === "error" && d.endpoint === resolved.source.doc?.name
         )
         if (relevantErrors.length > 0) {
           return {
             success: false,
             phase: "pre_flight_validation",
+            mode,
             endpoint,
-            file: found.full.replace(rootDir + "/", ""),
+            file: resolved.source.file,
             error: `${relevantErrors.length} validation error(s) in this endpoint — fix them before testing.`,
             errors: relevantErrors,
             hint: "Each error includes a fix_hint. Address them and re-run dypai_test_endpoint. Pass skip_validation: true if you want to bypass this and see the raw engine response.",
@@ -210,29 +353,29 @@ export const dypaiTestEndpointTool = {
       }
     }
 
-    // Deserialize the local YAML to the engine-shaped workflow_code
-    const deserCtx = { ...mapsCtx, readFile: (p) => fileMap[p] ?? "" }
-    let row
-    try {
-      row = deserializeEndpoint(found.doc, deserCtx)
-    } catch (e) {
-      return {
-        success: false,
-        error: `Failed to deserialize '${endpoint}' from its YAML: ${e.message}`,
-        hint: "Run dypai_validate to surface the specific problem.",
-      }
-    }
-
     // Build the call to the remote test_workflow (pass workflow_code inline so
-    // we test the LOCAL version, not whatever is currently deployed).
+    // we test the resolved source, regardless of what's currently deployed).
     const execArgs = {
       project_id: targetProjectId,
-      workflow_code: row.workflow_code,
+      workflow_code: resolved.workflow_code,
       data: input,
       trace_mode,  // used by the local MCP enrichment layer
     }
     if (as_user) execArgs.impersonated_user_id = as_user
 
+    // Build a compact source-meta block for the response so the agent can see
+    // which version was actually executed (file path, draft id, or endpoint id).
+    const sourceMeta = { mode }
+    if (mode === "local") sourceMeta.file = resolved.source.file
+    else if (mode === "draft") {
+      sourceMeta.draft_id = resolved.source.draft_id
+      sourceMeta.created_at = resolved.source.created_at
+      if (resolved.source.created_by) sourceMeta.created_by = resolved.source.created_by
+    } else {
+      sourceMeta.endpoint_id = resolved.source.endpoint_id
+      sourceMeta.updated_at = resolved.source.updated_at
+    }
+
     try {
       const result = await proxyToolCall("test_workflow", execArgs)
 
@@ -245,7 +388,7 @@ export const dypaiTestEndpointTool = {
         return {
           success: false,
           endpoint,
-          file: found.full.replace(rootDir + "/", ""),
+          source: sourceMeta,
           as_user: as_user || null,
           error: result.length > 2000 ? result.slice(0, 2000) + "...[truncated]" : result,
           hint: "The remote returned a raw error string (no per-node trace available). Read the error above for the root cause.",
@@ -255,7 +398,7 @@ export const dypaiTestEndpointTool = {
         return {
           success: false,
           endpoint,
-          file: found.full.replace(rootDir + "/", ""),
+          source: sourceMeta,
           as_user: as_user || null,
           error: `Unexpected response type from remote test_workflow: ${typeof result}`,
           raw_response: result,
@@ -267,7 +410,7 @@ export const dypaiTestEndpointTool = {
       const safeSummary = (summarized && typeof summarized === "object" && !Array.isArray(summarized)) ? summarized : { result: summarized }
       return {
         endpoint,
-        file: found.full.replace(rootDir + "/", ""),
+        source: sourceMeta,
         as_user: as_user || null,
         ...safeSummary,
       }
@@ -276,6 +419,7 @@ export const dypaiTestEndpointTool = {
         success: false,
         error: `Execution failed: ${e.message}`,
         endpoint,
+        source: sourceMeta,
         hint: "If the error is cryptic, try trace_mode: 'full' or use dypai_trace with the execution_id from the response.",
       }
     }