add provenance linters

Author: icecrasher321

.github/workflows/test-build.yml

@@ -156,6 +156,9 @@ jobs:
       - name: Tool registry client-boundary audit
         run: bun run check:tool-registry-boundary
 
+      - name: Tool request transport boundary audit
+        run: bun run check:tool-request-boundary
+
       - name: Verify generated tool metadata is in sync
         run: bun run tool-metadata:check
 

apps/sim/app/api/knowledge/secret-provenance.ts

@@ -46,7 +46,8 @@ export function resolveKnowledgeWriteSecretProvenance(options: {
   workspaceId?: string
   selectionKeys: readonly string[]
 }): KnowledgeWriteProvenanceResolution {
-  const inspection = inspectPrivateSecretProvenanceRequest(options.request.headers, options.payload)
+  const { request } = options
+  const inspection = inspectPrivateSecretProvenanceRequest(request.headers, options.payload)
   if (inspection.status === 'unsupported') {
     return options.authType === AuthType.INTERNAL_JWT
       ? { success: true }
@@ -142,8 +143,9 @@ export async function createKnowledgeProvenanceResponse(options: {
   body: Record<string, unknown>
   provenances: readonly DurableSecretProvenance[]
 }): Promise<NextResponse> {
+  const { request } = options
   const negotiation = negotiatePrivateToolMetadataResponse(
-    options.request.headers,
+    request.headers,
     RESOLVED_SECRET_PROVENANCE_METADATA_V1,
     options.authType === AuthType.INTERNAL_JWT
   )
@@ -179,8 +181,9 @@ export function createKnowledgeRegistryResponse(options: {
   body: Record<string, unknown>
   registry: ResolvedSecretTraceRegistry
 }): NextResponse {
+  const { request } = options
   const negotiation = negotiatePrivateToolMetadataResponse(
-    options.request.headers,
+    request.headers,
     RESOLVED_SECRET_PROVENANCE_METADATA_V1,
     options.authType === AuthType.INTERNAL_JWT
   )
@@ -213,8 +216,9 @@ export async function createKnowledgePersistedResponse(options: {
     value: unknown
   }[]
 }): Promise<NextResponse> {
+  const { request } = options
   const negotiation = negotiatePrivateToolMetadataResponse(
-    options.request.headers,
+    request.headers,
     RESOLVED_SECRET_PROVENANCE_METADATA_V1,
     options.authType === AuthType.INTERNAL_JWT
   )

apps/sim/app/api/memory/secret-provenance.ts

@@ -47,7 +47,8 @@ export function resolveMemoryWriteSecretProvenance(options: {
 }):
   | { success: true; provenance?: DurableSecretProvenance }
   | { success: false; response: NextResponse } {
-  const inspection = inspectPrivateSecretProvenanceRequest(options.request.headers, options.payload)
+  const { request } = options
+  const inspection = inspectPrivateSecretProvenanceRequest(request.headers, options.payload)
   if (inspection.status === 'unsupported') {
     return options.authType === AuthType.INTERNAL_JWT
       ? { success: true }
@@ -81,8 +82,9 @@ export async function createMemoryResponse(options: {
   body: Record<string, unknown>
   memories: MemoryCrossing[]
 }): Promise<NextResponse> {
+  const { request } = options
   const negotiation = negotiatePrivateToolMetadataResponse(
-    options.request.headers,
+    request.headers,
     RESOLVED_SECRET_PROVENANCE_METADATA_V1,
     options.authType === AuthType.INTERNAL_JWT
   )

apps/sim/app/api/table/row-secret-provenance.ts

@@ -70,7 +70,8 @@ export function resolveTableWriteSecretProvenance(options: {
   targets: TableWriteProvenanceTarget[]
   rowKeys: string[]
 }): TableWriteProvenanceResult {
-  const inspection = inspectPrivateSecretProvenanceRequest(options.request.headers, options.payload)
+  const { request } = options
+  const inspection = inspectPrivateSecretProvenanceRequest(request.headers, options.payload)
   if (inspection.status === 'unsupported') {
     if (options.authType === AuthType.INTERNAL_JWT) {
       return { success: true, provenanceByRowKey: undefined }
@@ -154,8 +155,9 @@ export async function createTableRowsResponse(options: {
   body: Record<string, unknown>
   rows: TableRowCrossing[]
 }): Promise<NextResponse> {
+  const { request } = options
   const negotiation = negotiatePrivateToolMetadataResponse(
-    options.request.headers,
+    request.headers,
     RESOLVED_SECRET_PROVENANCE_METADATA_V1,
     options.authType === AuthType.INTERNAL_JWT
   )

apps/sim/app/workspace/[workspaceId]/w/[workflowId]/hooks/use-workflow-execution.ts

@@ -1692,8 +1692,9 @@ export function useWorkflowExecution() {
     }
 
     let notificationMessage = WORKFLOW_EXECUTION_FAILURE_MESSAGE
-    if (isRecord(error) && isRecord(error.request) && sanitizeMessage(error.request.url)) {
-      notificationMessage += `: Request to ${(error.request.url as string).trim()} failed`
+    const requestError = isRecord(error) && isRecord(error.request) ? error.request : undefined
+    if (requestError && sanitizeMessage(requestError.url)) {
+      notificationMessage += `: Request to ${(requestError.url as string).trim()} failed`
       if ('status' in error && typeof error.status === 'number') {
         notificationMessage += ` (Status: ${error.status})`
       }

apps/sim/executor/handlers/mothership/mothership-handler.test.ts

@@ -72,7 +72,6 @@ vi.mock('@/lib/execution/cancellation', () => ({
 }))
 
 vi.mock('@/lib/execution/payloads/materialization.server', () => ({
-  MAX_INLINE_MATERIALIZATION_BYTES: 50 * 1024 * 1024,
   readUserFileContent: mockReadUserFileContent,
 }))
 

apps/sim/executor/utils/resolved-secret-content-projection.test.ts

@@ -6,6 +6,7 @@ import {
   isResolvedSecretModelContentUnchanged,
   projectResolvedSecretDiagnosticError,
   projectResolvedSecretModelContent,
+  projectResolvedSecretModelJsonContent,
   projectResolvedSecretModelJsonStrings,
 } from '@/executor/utils/resolved-secret-content-projection'
 import { ResolvedSecretTraceRegistry } from '@/executor/utils/resolved-secret-trace-registry'
@@ -288,6 +289,88 @@ describe('projectResolvedSecretModelContent', () => {
   })
 })
 
+describe('projectResolvedSecretModelJsonContent', () => {
+  it('normalizes dates using their JSON wire representation', () => {
+    const registry = new ResolvedSecretTraceRegistry()
+    const createdAt = new Date('2026-08-05T12:34:56.789Z')
+
+    expect(projectResolvedSecretModelJsonContent({ createdAt }, registry)).toEqual({
+      safe: true,
+      value: { createdAt: '2026-08-05T12:34:56.789Z' },
+    })
+    expect(createdAt).toBeInstanceOf(Date)
+  })
+
+  it('projects active secrets emitted by toJSON after materialization', () => {
+    const registry = new ResolvedSecretTraceRegistry([
+      { name: 'TOKEN', plaintext: 'secret-value', encryptedValue: 'ciphertext' },
+    ])
+    registry.recordResolved('TOKEN', 'secret-value')
+
+    expect(
+      projectResolvedSecretModelJsonContent(
+        {
+          toJSON: () => ({ authorization: 'Bearer secret-value' }),
+        },
+        registry
+      )
+    ).toEqual({
+      safe: true,
+      value: { authorization: 'Bearer {{TOKEN}}' },
+    })
+  })
+
+  it('does not invoke JSON serialization when provenance is incomplete', () => {
+    const registry = new ResolvedSecretTraceRegistry()
+    registry.markIncomplete()
+    const toJSON = vi.fn(() => ({ value: 'untrusted' }))
+
+    expect(projectResolvedSecretModelJsonContent({ toJSON }, registry)).toEqual({ safe: false })
+    expect(toJSON).not.toHaveBeenCalled()
+  })
+
+  it('uses native JSON semantics for undefined and non-finite numbers', () => {
+    const registry = new ResolvedSecretTraceRegistry()
+
+    expect(
+      projectResolvedSecretModelJsonContent(
+        {
+          omitted: undefined,
+          undefinedInArray: [undefined],
+          nan: Number.NaN,
+          infinities: [Number.POSITIVE_INFINITY, Number.NEGATIVE_INFINITY],
+        },
+        registry
+      )
+    ).toEqual({
+      safe: true,
+      value: {
+        undefinedInArray: [null],
+        nan: null,
+        infinities: [null, null],
+      },
+    })
+  })
+
+  it('returns a controlled unsafe result for values JSON cannot serialize', () => {
+    const registry = new ResolvedSecretTraceRegistry()
+    const cyclic: Record<string, unknown> = {}
+    cyclic.self = cyclic
+
+    expect(projectResolvedSecretModelJsonContent(cyclic, registry)).toEqual({ safe: false })
+    expect(projectResolvedSecretModelJsonContent({ value: 1n }, registry)).toEqual({ safe: false })
+  })
+
+  it('enforces the byte limit after secret aliases are projected', () => {
+    const registry = new ResolvedSecretTraceRegistry([
+      { name: 'X', plaintext: 'x', encryptedValue: 'ciphertext' },
+    ])
+    registry.recordResolved('X', 'x')
+
+    expect(projectResolvedSecretModelJsonContent({ a: 'x' }, registry, 9)).toEqual({ safe: false })
+  })
+})
+
 describe('projectResolvedSecretDiagnosticError', () => {
   it('projects plaintext and internal aliases without mutating the runtime error', () => {
     const secret = 'diagnostic-secret-value'

apps/sim/executor/utils/resolved-secret-content-projection.ts

@@ -495,10 +495,42 @@ export function projectResolvedSecretModelContent(
   })
 }
 
+/**
+ * Projects content after applying the same normalization as a JSON wire boundary. This converts
+ * values such as dates through their native `toJSON` representation, omits unsupported object
+ * fields, and rejects values that JSON itself cannot serialize.
+ */
+export function projectResolvedSecretModelJsonContent(
+  value: unknown,
+  registry: ResolvedSecretTraceRegistry | undefined,
+  maxBytes = MAX_INLINE_MATERIALIZATION_BYTES,
+  options: ResolvedSecretContentProjectionOptions = {}
+): ResolvedSecretContentProjection {
+  if (!getResolvedSecretModelMatcher(registry).complete) return { safe: false }
+
+  try {
+    const encoded = JSON.stringify(value)
+    if (encoded === undefined || Buffer.byteLength(encoded, 'utf8') > maxBytes) {
+      return { safe: false }
+    }
+    const normalized: unknown = JSON.parse(encoded)
+    const projection = projectResolvedSecretModelContent(normalized, registry, maxBytes, options)
+    if (!projection.safe) return projection
+
+    const projectedEncoding = JSON.stringify(projection.value)
+    return projectedEncoding !== undefined &&
+      Buffer.byteLength(projectedEncoding, 'utf8') <= maxBytes
+      ? projection
+      : { safe: false }
+  } catch {
+    return { safe: false }
+  }
+}
+
 /**
  * Projects logger-visible diagnostics and additionally removes internal-looking runtime names.
- * Model and tool-result boundaries must use `projectResolvedSecretModelContent` so unrelated data
- * remains byte-preserving unless it matches execution provenance.
+ * Non-JSON model boundaries use `projectResolvedSecretModelContent`; JSON tool-result boundaries
+ * use `projectResolvedSecretModelJsonContent` to apply their wire semantics before projection.
  */
 export function projectResolvedSecretDiagnosticContent(
   value: unknown,

apps/sim/lib/copilot/request/tools/resolved-secret-result.test.ts

@@ -226,6 +226,28 @@ describe('projectToolResultForCopilot', () => {
     })
   })
 
+  it('serializes table-style dates for Copilot without mutating the runtime result', () => {
+    const registry = new ResolvedSecretTraceRegistry()
+    const createdAt = new Date('2026-08-05T12:34:56.789Z')
+    const runtimeResult = {
+      success: true,
+      output: {
+        table: { id: 'table-1', createdAt },
+        rows: [{ id: 'row-1', createdAt }],
+      },
+    }
+
+    expect(projectToolResultForCopilot(runtimeResult, registry)).toEqual({
+      success: true,
+      output: {
+        table: { id: 'table-1', createdAt: '2026-08-05T12:34:56.789Z' },
+        rows: [{ id: 'row-1', createdAt: '2026-08-05T12:34:56.789Z' }],
+      },
+    })
+    expect(runtimeResult.output.table.createdAt).toBe(createdAt)
+    expect(runtimeResult.output.rows[0].createdAt).toBe(createdAt)
+  })
+
   it('preserves foreign internal-looking tool output when the registry has no matching alias', () => {
     const registry = new ResolvedSecretTraceRegistry()
 

apps/sim/lib/copilot/request/tools/resolved-secret-result.ts

@@ -5,6 +5,7 @@ import {
   isResolvedSecretModelContentUnchanged,
   projectResolvedSecretModelContent,
   projectResolvedSecretModelControlMessage,
+  projectResolvedSecretModelJsonContent,
 } from '@/executor/utils/resolved-secret-content-projection'
 import type { ResolvedSecretTraceRegistry } from '@/executor/utils/resolved-secret-trace-registry'
 
@@ -124,7 +125,7 @@ export function inspectToolResultForCopilot(
     if (Object.hasOwn(result, 'output')) content.output = result.output
     if (Object.hasOwn(result, 'error')) content.error = result.error
     if (resources !== undefined) content.resources = resourceContent(resources)
-    const projection = projectResolvedSecretModelContent(content, registry)
+    const projection = projectResolvedSecretModelJsonContent(content, registry)
     if (!projection.safe || !projection.value || typeof projection.value !== 'object') {
       return { safe: false, result: omittedResult(result, registry) }
     }