fix(mcp): keep openness flag out of field lookup and close empty objects

A declared field named open on an open object resolved to the flag instead of
the field. Open nodes now look fields up in their properties only. A closed
object declaring no properties now rejects every field instead of saving as
untyped. Documents the NDJSON detached frame for waitTimeoutSeconds.

Author: waleedlatif1

apps/docs/openapi-v2-workflows.json

@@ -3701,7 +3701,7 @@
       "post": {
         "operationId": "executeWorkflowV2",
         "summary": "Execute workflow",
-        "description": "Run the active deployment, or set `run.source: \"manual\"` to run the saved draft. Deployed execution requires workspace read access and OAuth `api:write` scope or an API key; public deployments also allow anonymous synchronous or streamed runs. Manual runs require personal-key or OAuth write access and cannot be async.\n\nUse `async: true` for a queue receipt, `waitTimeoutSeconds` to get one when a synchronous run outlasts the wait, or `stream: true` for SSE. For a synchronous run with both flags false, send `Accept: application/x-ndjson` for heartbeat frames and a final frame containing `data`. Timeouts return `200` with `status: \"failed\"` and `error.code: \"TIMEOUT\"`; inspect run status. See [Streaming](/workflows/deployment/api#streaming) for event formats. Input descriptions specify compatible modes; invalid combinations return `400`.\n\nSupply `X-Run-Id` to prevent duplicate execution. Reuse returns `409`, without replaying results. A `503` with `error.details.code: \"ASYNC_ENQUEUE_AMBIGUOUS\"` omits `Retry-After` because the run may already have started. Reconcile using the returned run ID; do not start another run with a new or omitted ID.\n\nOAuth scope: `api:write`.",
+        "description": "Run the active deployment, or set `run.source: \"manual\"` to run the saved draft. Deployed execution requires workspace read access and OAuth `api:write` scope or an API key; public deployments also allow anonymous synchronous or streamed runs. Manual runs require personal-key or OAuth write access and cannot be async.\n\nUse `async: true` for a queue receipt, or `stream: true` for SSE. For a synchronous run with both flags false, send `Accept: application/x-ndjson` for heartbeat frames and a final frame containing `data`. With `waitTimeoutSeconds`, a synchronous run still going when the wait elapses continues in the background and answers with its run receipt instead: `202` on a JSON response, or a closing `detached` frame on an NDJSON stream, which keeps its `200`. Timeouts return `200` with `status: \"failed\"` and `error.code: \"TIMEOUT\"`; inspect run status. See [Streaming](/workflows/deployment/api#streaming) for event formats. Input descriptions specify compatible modes; invalid combinations return `400`.\n\nSupply `X-Run-Id` to prevent duplicate execution. Reuse returns `409`, without replaying results. A `503` with `error.details.code: \"ASYNC_ENQUEUE_AMBIGUOUS\"` omits `Retry-After` because the run may already have started. Reconcile using the returned run ID; do not start another run with a new or omitted ID.\n\nOAuth scope: `api:write`.",
         "x-sim-operation": "workflows.execute",
         "x-oauth-scope": "api:write",
         "tags": ["Workflows"],

apps/sim/executor/utils/block-reference.ts

@@ -74,15 +74,25 @@ function getProperties(schema: unknown): Record<string, unknown> | undefined {
     : undefined
 }
 
+/** A node declaring its fields but allowing others, so a field it does not name is not an error. */
+function isOpenSchemaNode(value: unknown): boolean {
+  return asSchemaNode(value)?.open === true
+}
+
 function lookupField(schema: unknown, fieldName: string): unknown | undefined {
   if (typeof schema !== 'object' || schema === null) return undefined
   const typed = schema as Record<string, unknown>
+  const props = getProperties(schema)
+
+  /** An open node's fields are its `properties`; its own keys are schema metadata, never fields. */
+  if (isOpenSchemaNode(schema)) {
+    return props && fieldName in props ? props[fieldName] : undefined
+  }
 
   if (fieldName in typed) {
     return typed[fieldName]
   }
 
-  const props = getProperties(schema)
   if (props && fieldName in props) {
     return props[fieldName]
   }
@@ -103,11 +113,6 @@ function isOpaqueSchemaNode(value: unknown): boolean {
   return false
 }
 
-/** A node declaring its fields but allowing others, so a field it does not name is not an error. */
-function isOpenSchemaNode(value: unknown): boolean {
-  return asSchemaNode(value)?.open === true
-}
-
 /** Whether `pathParts` names a field the declared output schema has, the check a run makes. */
 export function isPathInSchema(schema: OutputSchema | undefined, pathParts: string[]): boolean {
   if (!schema || pathParts.length === 0) {

apps/sim/lib/api/contracts/v2/openapi/workflows.ts

@@ -1194,7 +1194,7 @@ const declaredRoutes = [
       applicationOperation: workflowOperations.execute,
       operationId: 'executeWorkflowV2',
       summary: 'Execute workflow',
-      description: `Run the active deployment, or set \`run.source: "manual"\` to run the saved draft. Deployed execution requires workspace read access and OAuth \`api:write\` scope or an API key; public deployments also allow anonymous synchronous or streamed runs. Manual runs require personal-key or OAuth write access and cannot be async.\n\nUse \`async: true\` for a queue receipt, \`waitTimeoutSeconds\` to get one when a synchronous run outlasts the wait, or \`stream: true\` for SSE. For a synchronous run with both flags false, send \`Accept: application/x-ndjson\` for heartbeat frames and a final frame containing \`data\`. Timeouts return \`200\` with \`status: "failed"\` and \`error.code: "TIMEOUT"\`; inspect run status. See [Streaming](/workflows/deployment/api#streaming) for event formats. ${EXECUTE_OPTION_CONSTRAINTS}\n\nSupply \`X-Run-Id\` to prevent duplicate execution. Reuse returns \`409\`, without replaying results. A \`503\` with \`error.details.code: "ASYNC_ENQUEUE_AMBIGUOUS"\` omits \`Retry-After\` because the run may already have started. Reconcile using the returned run ID; do not start another run with a new or omitted ID.`,
+      description: `Run the active deployment, or set \`run.source: "manual"\` to run the saved draft. Deployed execution requires workspace read access and OAuth \`api:write\` scope or an API key; public deployments also allow anonymous synchronous or streamed runs. Manual runs require personal-key or OAuth write access and cannot be async.\n\nUse \`async: true\` for a queue receipt, or \`stream: true\` for SSE. For a synchronous run with both flags false, send \`Accept: application/x-ndjson\` for heartbeat frames and a final frame containing \`data\`. With \`waitTimeoutSeconds\`, a synchronous run still going when the wait elapses continues in the background and answers with its run receipt instead: \`202\` on a JSON response, or a closing \`detached\` frame on an NDJSON stream, which keeps its \`200\`. Timeouts return \`200\` with \`status: "failed"\` and \`error.code: "TIMEOUT"\`; inspect run status. See [Streaming](/workflows/deployment/api#streaming) for event formats. ${EXECUTE_OPTION_CONSTRAINTS}\n\nSupply \`X-Run-Id\` to prevent duplicate execution. Reuse returns \`409\`, without replaying results. A \`503\` with \`error.details.code: "ASYNC_ENQUEUE_AMBIGUOUS"\` omits \`Retry-After\` because the run may already have started. Reconcile using the returned run ID; do not start another run with a new or omitted ID.`,
       errors: [
         'BadRequest',
         'Unauthorized',

apps/sim/lib/api/mcp/generated/v2-operations.ts

@@ -1246,7 +1246,7 @@ export const V2_MCP_OPERATIONS = {
     contract: v2ExecuteWorkflowContract,
     summary: 'Execute workflow',
     description:
-      'Run the active deployment, or set `run.source: "manual"` to run the saved draft. Deployed execution requires workspace read access and OAuth `api:write` scope or an API key; public deployments also allow anonymous synchronous or streamed runs. Manual runs require personal-key or OAuth write access and cannot be async.\n\nUse `async: true` for a queue receipt, `waitTimeoutSeconds` to get one when a synchronous run outlasts the wait, or `stream: true` for SSE. For a synchronous run with both flags false, send `Accept: application/x-ndjson` for heartbeat frames and a final frame containing `data`. Timeouts return `200` with `status: "failed"` and `error.code: "TIMEOUT"`; inspect run status. See [Streaming](/workflows/deployment/api#streaming) for event formats. Input descriptions specify compatible modes; invalid combinations return `400`.\n\nSupply `X-Run-Id` to prevent duplicate execution. Reuse returns `409`, without replaying results. A `503` with `error.details.code: "ASYNC_ENQUEUE_AMBIGUOUS"` omits `Retry-After` because the run may already have started. Reconcile using the returned run ID; do not start another run with a new or omitted ID.\n\nOAuth scope: `api:write`.',
+      'Run the active deployment, or set `run.source: "manual"` to run the saved draft. Deployed execution requires workspace read access and OAuth `api:write` scope or an API key; public deployments also allow anonymous synchronous or streamed runs. Manual runs require personal-key or OAuth write access and cannot be async.\n\nUse `async: true` for a queue receipt, or `stream: true` for SSE. For a synchronous run with both flags false, send `Accept: application/x-ndjson` for heartbeat frames and a final frame containing `data`. With `waitTimeoutSeconds`, a synchronous run still going when the wait elapses continues in the background and answers with its run receipt instead: `202` on a JSON response, or a closing `detached` frame on an NDJSON stream, which keeps its `200`. Timeouts return `200` with `status: "failed"` and `error.code: "TIMEOUT"`; inspect run status. See [Streaming](/workflows/deployment/api#streaming) for event formats. Input descriptions specify compatible modes; invalid combinations return `400`.\n\nSupply `X-Run-Id` to prevent duplicate execution. Reuse returns `409`, without replaying results. A `503` with `error.details.code: "ASYNC_ENQUEUE_AMBIGUOUS"` omits `Retry-After` because the run may already have started. Reconcile using the returned run ID; do not start another run with a new or omitted ID.\n\nOAuth scope: `api:write`.',
     handler: () =>
       import('@/app/api/v2/workflows/[workflowId]/execute/route').then((route) => route.POST),
   },

apps/sim/lib/mcp/output-schema.ts

@@ -1,4 +1,4 @@
-import { isRecordLike } from '@sim/utils/object'
+import { isRecordLike, toRecord } from '@sim/utils/object'
 import type { McpToolSchema } from '@/lib/mcp/types'
 
 /**
@@ -73,14 +73,14 @@ function reduceNode(node: unknown, depth: number, budget: { nodes: number }): Mc
 
   switch (declaredType(node)) {
     case 'object': {
-      if (!isRecordLike(node.properties)) return { type: 'object' }
+      const closed = node.additionalProperties === false && node.patternProperties === undefined
+      if (!closed && !isRecordLike(node.properties)) return { type: 'object' }
       const entries: [string, McpToolOutputShape][] = []
-      for (const [name, child] of Object.entries(node.properties)) {
+      for (const [name, child] of Object.entries(toRecord(node.properties))) {
         /** Past the budget the object is saved untyped: any field resolves, none is declared. */
         if (budget.nodes <= 0) return { type: 'object' }
         entries.push([name, reduceNode(child, depth + 1, budget)])
       }
-      const closed = node.additionalProperties === false && node.patternProperties === undefined
       return {
         type: 'object',
         /** `fromEntries` keeps every declared name, `__proto__` included, as an own field. */

apps/sim/serializer/mcp-output-schema.test.ts

@@ -118,6 +118,35 @@ describe('MCP block output typed from a declared output schema', () => {
     expect(resolve(untypedItems, ['structuredContent', 'rows', '0', 'id'])).toBeUndefined()
   })
 
+  it('checks a declared field named like the openness flag as a field', () => {
+    const named = (additionalProperties?: false) =>
+      createMcpToolOutputSnapshot('server-1', 'on_call', {
+        type: 'object',
+        properties: {
+          open: {
+            type: 'object',
+            properties: { id: { type: 'string' } },
+            ...(additionalProperties === false && { additionalProperties }),
+          },
+        },
+        ...(additionalProperties === false && { additionalProperties }),
+      })
+    expect(resolve(named(), ['structuredContent', 'open', 'id'])).toBeUndefined()
+    expect(resolve(named(), ['structuredContent', 'open', 'extra'])).toBeUndefined()
+    expect(resolve(named(false), ['structuredContent', 'open', 'id'])).toBeUndefined()
+    expect(() => resolve(named(false), ['structuredContent', 'open', 'extra'])).toThrow(
+      InvalidFieldError
+    )
+  })
+
+  it('rejects any field of a closed object that declares none', () => {
+    const empty = createMcpToolOutputSnapshot('server-1', 'on_call', {
+      type: 'object',
+      additionalProperties: false,
+    })
+    expect(() => resolve(empty, ['structuredContent', 'onCall'])).toThrow(InvalidFieldError)
+  })
+
   it('keeps a snapshot saved before openness was recorded closed until it is retaken', () => {
     const legacy = {
       server: 'server-1',