@dypai-ai/mcp 1.6.20 → 1.7.1

package/src/tools/sync/planner.js

@@ -8,7 +8,7 @@
  * trigger blocks, and other noise don't show up as false-positive diffs.
  */
 
-import { readFile, readdir } from "fs/promises"
+import { readFile, readdir, mkdir, writeFile } from "fs/promises"
 import { join } from "path"
 import YAML from "yaml"
 import { proxyToolCall } from "../proxy.js"
@@ -71,6 +71,33 @@ export async function readLocalStateSnapshot(rootDir) {
   }
 }
 
+/**
+ * Refresh .dypai/state.json from live remote endpoint timestamps.
+ * Call after publish/deploy so the next push does not see phantom conflicts.
+ */
+export async function refreshLocalStateSnapshot({ projectId, rootDir }) {
+  if (!projectId || !rootDir) return null
+  const rows = await execSql(projectId, `
+      SELECT id, name, updated_at
+      FROM system.endpoints
+      ORDER BY name
+    `)
+  const successfullyPulledIds = new Set(rows.map((row) => row.id))
+  const state = {
+    pulled_at: new Date().toISOString(),
+    project_id: projectId,
+    endpoints: Object.fromEntries(
+      rows
+        .filter((row) => successfullyPulledIds.has(row.id))
+        .map((row) => [row.name, { id: row.id, updated_at: row.updated_at }]),
+    ),
+  }
+  const statePath = join(rootDir, ".dypai", "state.json")
+  await mkdir(join(rootDir, ".dypai"), { recursive: true })
+  await writeFile(statePath, `${JSON.stringify(state, null, 2)}\n`, "utf8")
+  return state
+}
+
 /**
  * Load dypai.config.yaml if it exists. This is the committed identity of the
  * project (project_id, project_name). Used to auto-resolve project_id and to
@@ -138,7 +165,8 @@ export async function fetchRemoteState(projectId) {
   // same session concurrently, especially right after a local restart.
   const endpoints = await execSql(projectId, `
       SELECT id, name, method, description, workflow_code, input, output,
-             allowed_roles, is_tool, tool_description, group_id, is_active, updated_at
+             allowed_roles, is_tool, tool_description, group_id, is_active,
+             response_cardinality, updated_at
       FROM system.endpoints
       ORDER BY name
     `)
@@ -571,11 +599,20 @@ function inlineFileRefs(node, fileMap) {
  * are brought to this shape so file contents are part of the comparison
  * (otherwise identical file paths would mask content changes).
  */
+function normalizeComparableDoc(doc) {
+  if (!doc || typeof doc !== "object" || Array.isArray(doc)) return doc
+  const copy = { ...doc }
+  if (copy.response_cardinality == null || copy.response_cardinality === "") {
+    delete copy.response_cardinality
+  }
+  return copy
+}
+
 function remoteToComparable(row, mapsCtx) {
   const { doc, extractedFiles } = serializeEndpoint(row, mapsCtx)
   const fileMap = Object.fromEntries(extractedFiles.map(f => [f.path, f.content]))
   inlineFileRefs(doc, fileMap)
-  return doc
+  return normalizeComparableDoc(doc)
 }
 
 function flowPayloadToRow(payload) {

package/src/tools/sync/push.js

@@ -264,6 +264,20 @@ function endpointPayload(row) {
   return p
 }
 
+function splitBlockingConflicts(plan, conflicts) {
+  const touched = new Set([
+    ...(plan.update || []).map((item) => item.name),
+    ...(plan.delete || []).map((item) => item.name),
+  ])
+  const blocking = []
+  const non_blocking = []
+  for (const conflict of conflicts || []) {
+    if (touched.has(conflict.endpoint)) blocking.push(conflict)
+    else non_blocking.push(conflict)
+  }
+  return { blocking, non_blocking }
+}
+
 /**
  * Treat a remote tool response as a definite success only when it has at
  * least one of the markers we expect from a real mutation. Anything else
@@ -631,13 +645,15 @@ export const dypaiPushTool = {
 
     // Block push on conflicts unless forced
     const conflicts = (plan.warnings || []).filter(w => w.type === "remote_changed_since_pull")
-    if (conflicts.length && !force) {
+    const conflictSplit = splitBlockingConflicts(plan, conflicts)
+    if (conflictSplit.blocking.length && !force) {
       return {
         success: false,
         applied: false,
         reason: "conflicts_detected",
-        conflicts,
-        hint: "Run dypai_pull to refresh local state, resolve any overlap, then push again. To override, pass force=true.",
+        conflicts: conflictSplit.blocking,
+        non_blocking_conflicts: conflictSplit.non_blocking.length ? conflictSplit.non_blocking : undefined,
+        hint: "Remote changes overlap endpoints this push would update/delete. Run dypai_pull to refresh local state, resolve the overlap, then push again. To override, pass force=true.",
       }
     }
 
@@ -663,6 +679,7 @@ export const dypaiPushTool = {
             : totalChanges === 0 ? "no_changes" : "dry_run",
         summary: summaryFromPlan(plan),
         plan,
+        non_blocking_conflicts: conflictSplit.non_blocking.length ? conflictSplit.non_blocking : undefined,
         types: typesGenerated,
         automation_sync: automationSync,
         source_checkpoint: sourceCheckpoint || undefined,
@@ -861,6 +878,7 @@ export const dypaiPushTool = {
       },
       details: applied,
       endpoint_results,
+      non_blocking_conflicts: conflictSplit.non_blocking.length ? conflictSplit.non_blocking : undefined,
       errors: errors.length ? errors : undefined,
       types: typesGenerated,
       automation_sync: automationSync,
@@ -907,6 +925,7 @@ function summaryFromPlan(plan) {
 export const __testing = {
   normalizeResponseCardinality,
   endpointPayload,
+  splitBlockingConflicts,
   collectBackendSourceCheckpointFiles,
   deletedBackendSourcePathsFromPlan,
   syncAutomationMetadata,

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

@@ -424,8 +424,8 @@ export const dypaiTestEndpointTool = {
       },
       trace_mode: {
         type: "string",
-        enum: ["smart", "full", "minimal"],
-        description: "How to summarize the returned trace. 'smart' (default) surfaces the failing node in detail; with stop_at_step, includes outputs for all completed steps. 'full' returns everything; 'minimal' returns only status + duration.",
+        enum: ["smart", "output_only", "full", "minimal"],
+        description: "How to summarize the returned trace. 'smart' (default) surfaces the failing node in detail; 'output_only' returns final endpoint output + compact timings without prompts/inputs; with stop_at_step, includes outputs for completed steps. 'full' returns everything; 'minimal' returns only status + duration.",
         default: "smart",
       },
       root_dir: {
@@ -611,17 +611,18 @@ export const dypaiTestEndpointTool = {
         : undefined
       const summarized = summarizeTestWorkflowResponse(result, trace_mode, traceOptions)
       const safeSummary = (summarized && typeof summarized === "object" && !Array.isArray(summarized)) ? summarized : { result: summarized }
+      const compactTrace = trace_mode === "minimal"
 
       return {
         operation: "run",
         endpoint,
         source: sourceMetaRun,
         as_user: as_user || null,
-        sdk_format_note: SDK_RESPONSE_FORMAT_NOTE,
-        sdk_response: sdkResponseFromEndpointTest(result),
-        frontend_usage: frontendUsageForEndpoint({ endpoint, method: sourceMetaRun.method, input }),
+        ...(compactTrace ? {} : { sdk_format_note: SDK_RESPONSE_FORMAT_NOTE }),
+        ...(compactTrace ? {} : { sdk_response: sdkResponseFromEndpointTest(result) }),
+        ...(compactTrace ? {} : { frontend_usage: frontendUsageForEndpoint({ endpoint, method: sourceMetaRun.method, input }) }),
         ...(stopAtStep ? { stop_at_step: stopAtStep } : {}),
-        ...(step_outputs && Object.keys(step_outputs).length ? { step_outputs } : {}),
+        ...(compactTrace || !step_outputs || !Object.keys(step_outputs).length ? {} : { step_outputs }),
         ...safeSummary,
         ...(stopAtStep && !step_outputs ? {
           hint: "No per-step outputs in trace. Try trace_mode:'full' or inspect execution_id with search_logs(include_trace:true).",

package/src/tools/sync/validate.js

@@ -932,6 +932,15 @@ function buildNodeOutputContracts(nodes, fileMap, ctx) {
       continue
     }
 
+    if (op === "semantic_search") {
+      contracts.set(node.id, {
+        type: "object",
+        properties: new Set(["ok", "operation", "table", "query", "results_count", "matches", "semantic_index"]),
+        strict: true,
+      })
+      continue
+    }
+
     if (op === "insert") {
       const bulk = nodeField(node, params, "mode") === "bulk" || Array.isArray(nodeField(node, params, "data"))
       contracts.set(node.id, {
@@ -1429,6 +1438,9 @@ function validateEndpoint(entry, ctx) {
       if (op === "mutation" && typeof table === "string") {
         referencedTables.add(table)
       }
+      if (op === "semantic_search" && typeof table === "string") {
+        referencedTables.add(table)
+      }
       // Legacy ops like `select` / `insert` / `update` / `delete` use `table:`
       // as the target table directly.
       if (op && LEGACY_OPS_THAT_USE_TABLE_FIELD.has(op) && typeof table === "string") {
@@ -1549,6 +1561,41 @@ function validateEndpoint(entry, ctx) {
           })
         }
       }
+
+      // ── operation: semantic_search coherence ─────────────────────────────
+      // Runtime semantic search is read-only over tables enabled through
+      // manage_table_semantics. It uses `search_query` rather than `query`
+      // because SQL query fields are rendered raw by the engine.
+      if (op === "semantic_search") {
+        const searchQuery = nodeField(node, params, "search_query")
+        if (!table) {
+          diagnostics.push({
+            severity: "error",
+            rule: "semantic_search_missing_table",
+            endpoint: name, file, loc: `workflow.nodes[${node.id}]`,
+            message: `Node '${node.id}' uses 'operation: semantic_search' but is missing 'table_name:'.`,
+            fix_hint: `Add 'table_name: <public_table>' and enable the table with manage_table_semantics(operation:"enable").`,
+          })
+        }
+        if (!searchQuery && !query) {
+          diagnostics.push({
+            severity: "error",
+            rule: "semantic_search_missing_query",
+            endpoint: name, file, loc: `workflow.nodes[${node.id}]`,
+            message: `Node '${node.id}' uses 'operation: semantic_search' but is missing 'search_query:'.`,
+            fix_hint: `Add 'search_query: \${input.query}'. Do not use hand-written pgvector SQL.`,
+          })
+        }
+        if (!searchQuery && query) {
+          diagnostics.push({
+            severity: "warn",
+            rule: "semantic_search_legacy_query_field",
+            endpoint: name, file, loc: `workflow.nodes[${node.id}].query`,
+            message: `Node '${node.id}' uses 'query:' for semantic_search. Prefer 'search_query:' so placeholders are template-rendered.`,
+            fix_hint: `Rename 'query:' to 'search_query:'.`,
+          })
+        }
+      }
     }
     if (node.tool_ids !== undefined && node.tools === undefined) {
       const toolIds = Array.isArray(node.tool_ids) ? node.tool_ids : []
@@ -1898,7 +1945,13 @@ function validateEndpoint(entry, ctx) {
 
     // Agent structured output + tools — engine uses generateObject OR generateText+tools, not both.
     if (nodeType === "agent") {
-      const tools = Array.isArray(node.tools) ? node.tools : []
+      const tools = Array.isArray(node.tools)
+        ? node.tools
+        : Array.isArray(node.parameters?.tool_ids)
+          ? node.parameters.tool_ids
+          : Array.isArray(node.tool_ids)
+            ? node.tool_ids
+            : []
       const hasTools = tools.length > 0
       const hasOutputSchema =
         node.output_schema != null &&
@@ -1917,6 +1970,26 @@ function validateEndpoint(entry, ctx) {
           fix_hint: "search_docs('document extraction ocr')",
         })
       }
+
+      const activeWorkspace = node.active_workspace_id ?? node.parameters?.active_workspace_id
+      const usesWorkspaceTools = tools.some((toolName) => String(toolName).startsWith("workspace-"))
+      const hasActiveWorkspace =
+        typeof activeWorkspace === "string"
+          ? activeWorkspace.trim().length > 0
+          : activeWorkspace != null && typeof activeWorkspace === "object"
+      if (usesWorkspaceTools && !hasActiveWorkspace) {
+        diagnostics.push({
+          severity: "error",
+          rule: "agent_workspace_binding_missing",
+          endpoint: name,
+          file,
+          loc: `workflow.nodes[${node.id}]`,
+          message:
+            "agent uses workspace-* tools but active_workspace_id / activeWorkspace is not configured.",
+          fix_hint:
+            "Create a workspace step, then bind it with .agent({ activeWorkspace: ref.step('workspace', 'workspace_id'), tools: [...] }).",
+        })
+      }
     }
   }
 

package/src/tools/trace-summarize.js

@@ -11,6 +11,7 @@
  *   - "smart" (default) — success → minimal; failure → focused on failing node
  *   - "full"            — raw trace (opt-in, for deep dives)
  *   - "minimal"         — just success/failure + duration + execution_order
+ *   - "output_only"     — final endpoint output + compact node timings, no inputs/snapshots
  *
  * The raw `events[]` array (node-scoped event log) is always dropped from
  * "smart" and "minimal" — it's redundant with the parsed fields.
@@ -18,11 +19,14 @@
 
 const MAX_FIELD_CHARS = 2000   // per-string truncation threshold
 const MAX_SNAPSHOT_KEYS = 6    // summarize large snapshots into a key outline
+const MAX_OUTPUT_CHARS = 8000
+const MAX_OUTPUT_KEYS = 40
+const MAX_OUTPUT_ITEMS = 30
 
 function truncateString(s, max = MAX_FIELD_CHARS) {
   if (typeof s !== "string") return s
   if (s.length <= max) return s
-  return s.slice(0, max) + `... [truncated ${s.length - max} chars, call dypai_trace with full=true]`
+  return s.slice(0, max) + `... [truncated ${s.length - max} chars, use trace_mode:'full' or search_logs(include_trace:true)]`
 }
 
 function summarizeValue(v) {
@@ -49,6 +53,41 @@ function summarizeValue(v) {
   return v
 }
 
+function summarizeOutputValue(v) {
+  if (v == null) return v
+  if (typeof v === "string") return truncateString(v, MAX_OUTPUT_CHARS)
+  if (Array.isArray(v)) {
+    const items = v.slice(0, MAX_OUTPUT_ITEMS).map(summarizeOutputValue)
+    if (v.length > MAX_OUTPUT_ITEMS) {
+      items.push(`... ${v.length - MAX_OUTPUT_ITEMS} more items`)
+    }
+    return items
+  }
+  if (typeof v === "object") {
+    const keys = Object.keys(v)
+    const out = {}
+    for (const k of keys.slice(0, MAX_OUTPUT_KEYS)) {
+      out[k] = summarizeOutputValue(v[k])
+    }
+    if (keys.length > MAX_OUTPUT_KEYS) out._truncated_keys = keys.length - MAX_OUTPUT_KEYS
+    return out
+  }
+  return v
+}
+
+function hasOwn(obj, key) {
+  return Object.prototype.hasOwnProperty.call(obj, key)
+}
+
+function extractEndpointOutput(response) {
+  if (!response || typeof response !== "object" || Array.isArray(response)) return undefined
+  if (hasOwn(response, "result")) return response.result
+  if (hasOwn(response, "output")) return response.output
+  if (hasOwn(response, "data")) return response.data
+  if (hasOwn(response, "response")) return response.response
+  return undefined
+}
+
 /** Build a hint string from the error message based on common patterns. */
 function hintFromError(err) {
   const m = String(err?.message || "")
@@ -81,6 +120,45 @@ export function summarizeTrace(trace, mode = "smart", options = {}) {
     }
   }
 
+  if (mode === "output_only") {
+    let failedAt = null
+    const nodeSummaries = []
+
+    for (const id of execOrder) {
+      const n = nodes[id]
+      if (!n) continue
+      const node = {
+        id: n.node_id,
+        type: n.node_type,
+        status: n.status,
+        duration_ms: n.duration_ms,
+      }
+      if (n.status === "failed") {
+        failedAt = failedAt || n.node_id
+        node.error = {
+          message: truncateString(n.error?.message),
+          type: n.error?.type,
+        }
+        if (n.fix_hint || n.error?.fix_hint) {
+          node.fix_hint = truncateString(n.fix_hint || n.error?.fix_hint)
+        }
+      }
+      nodeSummaries.push(node)
+      if (stopAtStep && id === stopAtStep) break
+    }
+
+    return {
+      execution_id: trace.execution_id,
+      success: wf.status === "completed",
+      status: wf.status,
+      duration_ms: wf.duration_ms,
+      failed_at: failedAt || undefined,
+      execution_order: execOrder,
+      nodes: nodeSummaries,
+      hint: "Compact trace only. Use trace_mode:'smart' for failing-node context or trace_mode:'full' for raw inputs/snapshots.",
+    }
+  }
+
   // "smart" mode
   const failed = wf.status === "failed"
   const failedNodeId = failed
@@ -170,6 +248,36 @@ export function summarizeTrace(trace, mode = "smart", options = {}) {
  */
 export function summarizeTestWorkflowResponse(response, mode = "smart", options = {}) {
   if (!response || typeof response !== "object") return response
+  if (mode === "minimal") {
+    const trace = response.trace ? summarizeTrace(response.trace, mode, options) : undefined
+    const output = extractEndpointOutput(response)
+    const out = {
+      success: trace?.status ? trace.status === "completed" : (response.error ? false : undefined),
+      execution_id: response.execution_id || trace?.execution_id,
+      status: trace?.status || response.status,
+      duration_ms: trace?.duration_ms || response.duration_ms,
+      ...(output !== undefined ? { result: summarizeOutputValue(output) } : {}),
+      ...(response.error ? { error: summarizeOutputValue(response.error) } : {}),
+      ...(trace ? { trace } : {}),
+      hint: "Returned endpoint result only. Use trace_mode:'smart' for failure context or trace_mode:'full' for raw execution snapshots.",
+    }
+    return Object.fromEntries(Object.entries(out).filter(([, v]) => v !== undefined))
+  }
+  if (mode === "output_only") {
+    const trace = response.trace ? summarizeTrace(response.trace, mode, options) : undefined
+    const output = extractEndpointOutput(response)
+    const out = {
+      success: trace?.success ?? (response.error ? false : undefined),
+      execution_id: response.execution_id || trace?.execution_id,
+      status: trace?.status || response.status,
+      duration_ms: trace?.duration_ms || response.duration_ms,
+      ...(output !== undefined ? { result: summarizeOutputValue(output) } : {}),
+      ...(response.error ? { error: summarizeOutputValue(response.error) } : {}),
+      ...(trace ? { trace } : {}),
+      hint: "Returned final endpoint output only. Use trace_mode:'smart' for failure context, stop_at_step for per-step outputs, or trace_mode:'full' for raw trace.",
+    }
+    return Object.fromEntries(Object.entries(out).filter(([, v]) => v !== undefined))
+  }
   if (!response.trace) return response
   return {
     ...response,