@teleporthq/teleport-plugin-next-workflows 0.43.53 → 0.43.55

package/__tests__/ai-provider-coverage.test.ts

@@ -0,0 +1,183 @@
+import * as fs from 'fs'
+import * as path from 'path'
+import { generateAIStreamingProviderUtils } from '../src/nodes/ai/ai-provider-utils'
+import { nodeRegistry } from '../src/nodes'
+
+/**
+ * Answers "if a user picks any provider/model in the editor, does the generated
+ * app actually call it correctly?"
+ *
+ * Two independent guarantees are needed:
+ *  1. every provider the editor can emit reaches a working branch, in BOTH the
+ *     streaming and non-streaming paths;
+ *  2. every SDK those branches `require()` is declared as a dependency, or the
+ *     generated project fails at import time rather than at request time.
+ */
+
+const EDITOR_PROVIDERS = [
+  'openai',
+  'anthropic',
+  'google',
+  'cohere',
+  'mistral',
+  'meta',
+  'perplexity',
+] as const
+
+/** SDK a provider's branch loads. Providers absent here go through OpenAI's. */
+const PROVIDER_SDK: Record<string, string> = {
+  openai: 'openai',
+  anthropic: '@anthropic-ai/sdk',
+  google: '@google/generative-ai',
+  cohere: 'cohere-ai',
+  mistral: '@mistralai/mistralai',
+  meta: 'openai',
+  perplexity: 'openai',
+}
+
+function loadUtils() {
+  const source = generateAIStreamingProviderUtils()
+  // eslint-disable-next-line no-new-func
+  return new Function(
+    `${source}
+    return {
+      resolveProvider: __ai_resolveProvider,
+      providerBaseURL: __ai_providerBaseURL,
+      modelCapabilities: __ai_modelCapabilities,
+    };`
+  )() as {
+    resolveProvider: (config: unknown) => string
+    providerBaseURL: (provider: string) => string | undefined
+    modelCapabilities: (provider: string, model: string, maxTokens?: number) => any
+  }
+}
+
+/** Model ids the editor offers, read from the GUI catalogue when it is a sibling checkout. */
+function readEditorCatalogue(): Array<[string, string]> | null {
+  const catalogue = path.resolve(
+    __dirname,
+    '../../../../teleport-gui/apps/gui/app/project-page/features/workflows/constants/ai-providers/catalog.ts'
+  )
+  if (!fs.existsSync(catalogue)) {
+    return null
+  }
+  const source = fs.readFileSync(catalogue, 'utf8')
+  const models: Array<[string, string]> = []
+  const blockRe = /\{\s*\n\s*id: '([^']+)',([\s\S]*?)\n {6}\}/g
+  let match = blockRe.exec(source)
+  while (match !== null) {
+    const provider = /provider: '([^']+)'/.exec(match[2])
+    if (provider) {
+      models.push([match[1], provider[1]])
+    }
+    match = blockRe.exec(source)
+  }
+  return models.length > 0 ? models : null
+}
+
+describe('every editor provider reaches a working branch', () => {
+  const utils = loadUtils()
+  const source = generateAIStreamingProviderUtils()
+  const nonStreaming = source.slice(source.indexOf('function __ai_callProvider'))
+  const streaming = source.slice(source.indexOf('__ai_callProviderStreaming'))
+
+  it.each(EDITOR_PROVIDERS)('%s resolves to itself when stored explicitly', (provider) => {
+    expect(utils.resolveProvider({ provider, model: 'anything' })).toBe(provider)
+  })
+
+  it.each(EDITOR_PROVIDERS)('%s is handled in both call paths', (provider) => {
+    const hasExplicit = (body: string) => body.includes(`provider === '${provider}'`)
+    // A provider without its own branch must be OpenAI-compatible, and then it
+    // needs a base URL unless it IS OpenAI — otherwise it would silently post
+    // to api.openai.com with someone else's key.
+    for (const [label, body] of [
+      ['non-streaming', nonStreaming],
+      ['streaming', streaming],
+    ] as const) {
+      if (!hasExplicit(body)) {
+        const baseURL = utils.providerBaseURL(provider)
+        const reachable = provider === 'openai' || !!baseURL
+        if (!reachable) {
+          throw new Error(`${provider} has no ${label} branch and no base URL`)
+        }
+      }
+    }
+  })
+
+  it('routes the OpenAI-compatible providers to their own hosts', () => {
+    expect(utils.providerBaseURL('meta')).toBe('https://api.together.xyz/v1')
+    expect(utils.providerBaseURL('perplexity')).toBe('https://api.perplexity.ai')
+    expect(utils.providerBaseURL('openai')).toBeUndefined()
+  })
+})
+
+describe('every provider SDK is declared as a dependency', () => {
+  // The provider is a runtime value, so an AI node must declare every SDK any
+  // branch could load — not just the one selected when the project was built.
+  const aiNodeTypes = Object.keys(nodeRegistry).filter(
+    (nodeType) => nodeType.startsWith('ai-') && nodeType !== 'ai-generate-text-embedding'
+  )
+
+  it('covers all AI chat nodes', () => {
+    expect(aiNodeTypes.length).toBeGreaterThanOrEqual(6)
+  })
+
+  it.each(aiNodeTypes)('%s declares every provider SDK', (nodeType) => {
+    const declared = nodeRegistry[nodeType].dependencies || {}
+    const missing = EDITOR_PROVIDERS.filter(
+      (provider) => !Object.keys(declared).includes(PROVIDER_SDK[provider])
+    )
+    expect(missing).toEqual([])
+  })
+
+  it('embedding node needs only the OpenAI SDK, since embeddings are OpenAI-only', () => {
+    const declared = nodeRegistry['ai-generate-text-embedding'].dependencies || {}
+    expect(Object.keys(declared)).toEqual(['openai'])
+  })
+
+  it('similarity scoring declares the OpenAI SDK for its semantic algorithm', () => {
+    const declared = nodeRegistry['utility-similarity-scoring'].dependencies || {}
+    expect(Object.keys(declared)).toContain('openai')
+  })
+})
+
+describe('the editor catalogue routes correctly end to end', () => {
+  const catalogue = readEditorCatalogue()
+  const utils = loadUtils()
+
+  it('finds the GUI catalogue', () => {
+    // Skips gracefully in a packaged release where the sibling checkout is absent.
+    if (!catalogue) {
+      // eslint-disable-next-line no-console
+      console.warn('skipping catalogue cross-check — teleport-gui not a sibling checkout')
+    }
+    expect(true).toBe(true)
+  })
+
+  it('routes every offered model to the provider that owns it', () => {
+    if (!catalogue) {
+      return
+    }
+    expect(catalogue.length).toBeGreaterThan(40)
+    const mismatches = catalogue.filter(
+      ([model, provider]) => utils.resolveProvider({ provider, model }) !== provider
+    )
+    expect(mismatches).toEqual([])
+  })
+
+  it('never produces an unusable request shape for an offered model', () => {
+    if (!catalogue) {
+      return
+    }
+    // Anthropic rejects a request with no max_tokens at all, so every model
+    // must come out with a positive budget whichever branch runs.
+    const broken = catalogue.filter(([model, provider]) => {
+      const caps = utils.modelCapabilities(provider, model, 500)
+      return (
+        !(caps.maxTokens > 0) ||
+        !['max_tokens', 'max_completion_tokens'].includes(caps.maxTokensParam)
+      )
+    })
+    expect(broken).toEqual([])
+  })
+})

package/__tests__/cart-clear-db-mirror.test.ts

@@ -0,0 +1,45 @@
+import { cartClear } from '../src/nodes/cart/cart-clear'
+
+// Regression: after a cash-on-delivery order the buyer's cart came back.
+//
+// `cart-clear` only emptied `localStorage.workflow_cart`. The database copy
+// (`teleport_cart` / `teleport_cart_items`) stayed active, and
+// `EcommerceProvider` re-hydrates from `/api/cart/load` on any mount where the
+// local cart is empty — so the very next full page load (the post-order
+// redirect, or a plain refresh) restored the cart the shopper had just ordered
+// and wrote it straight back into localStorage.
+
+describe('cart-clear mirrors the empty cart into the database cart', () => {
+  const handlerCode = cartClear.generateHandler()
+
+  it('still clears localStorage first — the DB mirror is best-effort on top', () => {
+    expect(handlerCode).toContain("localStorage.setItem('workflow_cart'")
+    expect(handlerCode).toContain("dispatchEvent(new CustomEvent('teleport:cart-changed'))")
+  })
+
+  it('pushes an empty cart through /api/cart/sync with the guest session id', () => {
+    expect(handlerCode).toContain("'/api/cart/sync'")
+    expect(handlerCode).toContain("localStorage.getItem('workflow_cart_session_id')")
+    expect(handlerCode).toMatch(/items:\s*\[\s*\]/)
+  })
+
+  it('never awaits the sync and never lets it fail the node', () => {
+    // The route only exists for Postgres datasources, so a 404 here is a
+    // normal outcome — it must not surface to the shopper or abort the
+    // workflow (which would strand the order mid-chain).
+    const syncSection = handlerCode.slice(handlerCode.indexOf("'/api/cart/sync'"))
+    expect(syncSection).not.toMatch(/await\s+fetch/)
+    expect(syncSection).toContain('.catch(')
+  })
+
+  it('does NOT mark the cart as ordered — this handler also backs "Clear cart"', () => {
+    // `mark-ordered` is the checkout-only signal and stays owned by
+    // data-create-item. Flipping the status here would mislabel a cart the
+    // shopper simply emptied by hand.
+    expect(handlerCode).not.toContain('mark-ordered')
+  })
+
+  it('stamps the clear so the provider can tell it apart from a first visit', () => {
+    expect(handlerCode).toContain("localStorage.setItem('workflow_cart_cleared_at'")
+  })
+})

package/__tests__/cart-get-total-storefront-tax.test.ts

@@ -0,0 +1,165 @@
+/* tslint:disable:no-eval */
+import { cartGetTotal } from '../src/nodes/cart/cart-get-total'
+
+/**
+ * The merchant's "Invoices → Tax → Added on top" setting decides what a buyer
+ * actually pays. `teleport_products.price` is the NET price in that mode, so
+ * the storefront has to add the tax at every point a price is shown or charged
+ * — and `cart-get-total` is the point the PLACE-ORDER workflow charges from.
+ *
+ * Three contracts are locked in here, each of which silently breaks money:
+ *
+ *  1. `subtotal` stays NET. Two generations of baked place-order workflows read
+ *     it and add shipping to produce `teleport_orders.total_amount`. If a NEW
+ *     handler made it gross, an OLD baked workflow would write a taxed order
+ *     total while still emitting untaxed payment line items — and Stripe
+ *     Checkout totals `line_items` and ignores the top-level amount, so the
+ *     buyer would be undercharged.
+ *  2. `tax` is `gross − net`, never a fresh percentage of the sum, so
+ *     `net line items + tax` reconciles to `total` to the cent.
+ *  3. Rounding is PER UNIT, matching `EcommerceProvider`'s
+ *     `cartItemDisplayPrice`, so the amount charged equals the Subtotal the
+ *     cart page printed.
+ */
+
+function evalHandler(code: string): any {
+  return eval('(' + code + ')')
+}
+
+interface StoredSettings {
+  maxQuantityPerProduct?: number | null
+  deliveryConfig?: unknown
+  taxConfig?: { storefrontTaxRate: number }
+}
+
+function withLocalStorage(cart: unknown, settings: StoredSettings | null): void {
+  const store: Record<string, string> = { workflow_cart: JSON.stringify(cart) }
+  if (settings) {
+    store.workflow_cart_settings = JSON.stringify(settings)
+  }
+  ;(global as any).localStorage = {
+    getItem: (key: string) => (key in store ? store[key] : null),
+  }
+}
+
+const runHandler = async () => evalHandler(cartGetTotal.generateHandler())()
+
+afterEach(() => {
+  delete (global as any).localStorage
+})
+
+describe('cart-get-total — storefront tax', () => {
+  it('leaves every total untouched when no tax config is stored (legacy storefront)', async () => {
+    withLocalStorage([{ price: 100, quantity: 2 }], { maxQuantityPerProduct: null })
+
+    const out = await runHandler()
+
+    expect(out.subtotal).toBe(200)
+    expect(out.tax).toBe(0)
+    expect(out.total).toBe(200)
+    expect(out.itemCount).toBe(2)
+    expect(out.taxConfig).toEqual({ storefrontTaxRate: 0 })
+  })
+
+  it('leaves every total untouched when the rate is zero', async () => {
+    withLocalStorage([{ price: 100, quantity: 2 }], { taxConfig: { storefrontTaxRate: 0 } })
+
+    const out = await runHandler()
+
+    expect(out.subtotal).toBe(200)
+    expect(out.tax).toBe(0)
+    expect(out.total).toBe(200)
+  })
+
+  it('keeps subtotal NET and reports the tax separately', async () => {
+    withLocalStorage([{ price: 100, quantity: 2 }], { taxConfig: { storefrontTaxRate: 19 } })
+
+    const out = await runHandler()
+
+    expect(out.subtotal).toBe(200)
+    expect(out.tax).toBe(38)
+    expect(out.total).toBe(238)
+  })
+
+  it('rounds per unit, so the charge matches the cart page line by line', async () => {
+    // 19.99 net → 23.79 gross per unit → 71.37 for three.
+    // Rounding the SUM instead would give 71.36 and disagree with the page.
+    withLocalStorage([{ price: 19.99, quantity: 3 }], { taxConfig: { storefrontTaxRate: 19 } })
+
+    const out = await runHandler()
+
+    expect(out.subtotal).toBe(59.97)
+    expect(out.total).toBe(71.37)
+    expect(out.tax).toBe(11.4)
+  })
+
+  it('reconciles: net line items + tax === total, for a mixed basket', async () => {
+    withLocalStorage(
+      [
+        { price: 19.99, quantity: 3 },
+        { price: 5.5, quantity: 1 },
+        { price: 100, quantity: 2 },
+      ],
+      { taxConfig: { storefrontTaxRate: 7.5 } }
+    )
+
+    const out = await runHandler()
+
+    // This is the invariant the payment line items depend on: the provider is
+    // sent NET item lines plus one "Tax" line, and their sum has to be the
+    // order's goods total to the cent.
+    expect(out.subtotal + out.tax).toBeCloseTo(out.total, 10)
+    // net 59.97 + 5.50 + 200.00
+    expect(out.subtotal).toBe(265.47)
+    // per-unit gross 21.49×3 + 5.91 + 107.50×2
+    expect(out.total).toBe(285.38)
+    expect(out.tax).toBe(19.91)
+  })
+
+  it('still surfaces the delivery config alongside the tax config', async () => {
+    withLocalStorage([{ price: 10, quantity: 1 }], {
+      deliveryConfig: { deliveryPrice: 15, freeDeliveryEnabled: true, freeDeliveryThreshold: 50 },
+      taxConfig: { storefrontTaxRate: 19 },
+    })
+
+    const out = await runHandler()
+
+    expect(out.deliveryConfig).toEqual({
+      deliveryPrice: 15,
+      freeDeliveryEnabled: true,
+      freeDeliveryThreshold: 50,
+    })
+    expect(out.taxConfig).toEqual({ storefrontTaxRate: 19 })
+  })
+
+  it('ignores a malformed or negative rate instead of corrupting the charge', async () => {
+    withLocalStorage([{ price: 100, quantity: 1 }], {
+      taxConfig: { storefrontTaxRate: -5 },
+    })
+    expect((await runHandler()).total).toBe(100)
+
+    withLocalStorage([{ price: 100, quantity: 1 }], {
+      taxConfig: { storefrontTaxRate: 'nonsense' as unknown as number },
+    })
+    expect((await runHandler()).total).toBe(100)
+  })
+
+  it('returns a fully zeroed shape when localStorage is unreadable', async () => {
+    ;(global as any).localStorage = {
+      getItem: () => {
+        throw new Error('denied')
+      },
+    }
+
+    const out = await runHandler()
+
+    expect(out).toEqual({
+      subtotal: 0,
+      tax: 0,
+      total: 0,
+      itemCount: 0,
+      deliveryConfig: null,
+      taxConfig: { storefrontTaxRate: 0 },
+    })
+  })
+})

package/__tests__/cron-route-loop-templateparams.test.ts

@@ -4,6 +4,7 @@
 // into its component body — the cron route previously used a naive inline loop
 // that did neither, so a per-cart reminder email would ship raw {{token}} merge
 // fields and its loop body would never run.
+import { generateSharedRuntimeUtilsCode } from '../src/executor-generator'
 import { generateCronAPIRoute } from '../src/api-route-generator'
 
 const TRIGGER_ID = 'cron-1'
@@ -123,12 +124,20 @@ describe('generateCronAPIRoute — loop + templateParams support', () => {
   })
 
   it('merges templateParams into email body + subject', () => {
-    // Both the top-level and loop-body execution paths apply the merge; the
-    // email node lives in the loop body here.
-    expect(route).toContain('utils.applyTemplateParams(bResolved.body, bResolved.templateParams)')
-    expect(route).toContain(
-      'utils.applyTemplateParams(bResolved.subject, bResolved.templateParams)'
-    )
+    // The merge lives in the SHARED runtime's `resolveConfig`, not pasted at
+    // each call site. That is the whole point: `resolveConfig` is the single
+    // function every execution path — main loop, loop body, parallel branch,
+    // error branch, across all four route generators and the client executor —
+    // funnels a node config through. Pasting it per site is what left the main
+    // loop of `generateServerSegmentAPIRoute` (where every ordinary page
+    // workflow's email node runs) without it, shipping literal `{{token}}`s.
+    const runtime = generateSharedRuntimeUtilsCode()
+    expect(runtime).toContain('applyTemplateParams(resolved.body, resolved.templateParams)')
+    expect(runtime).toContain('applyTemplateParams(resolved.subject, resolved.templateParams)')
+    // …and the route reaches it simply by calling resolveConfig.
+    expect(route).toContain('const resolveConfig = utils.resolveConfig')
+    // No stale per-site copy left behind to drift out of sync.
+    expect(route).not.toContain('utils.applyTemplateParams(')
   })
 
   it('bakes the scan + loop + email nodes into the server WORKFLOW_CONFIG', () => {

package/__tests__/data-create-item-order-notification.test.ts

@@ -106,3 +106,36 @@ describe('data_create_item — order-notification piggyback payload', () => {
 // cover the contract (which fields are read, where they default,
 // fire-and-forget shape, etc.). The full integration is exercised
 // by the existing end-to-end test in the dist project.
+
+describe('data-create-item stands down when the workflow owns the send', () => {
+  const suppressionHandlerCode = dataCreateItem.generateHandler()
+
+  it('gates the auto-fire on the builder-set suppressOrderNotification flag', () => {
+    // The place-order workflow sets this on its create-order node whenever it
+    // also carries a "Send Order-Notification Email" node. Without the gate
+    // the merchant receives the SAME order twice — once from here with a NULL
+    // order_number (rendered as the raw UUID) and a flat-filled body, once
+    // from the workflow with the real order number and the fully expanded
+    // template.
+    expect(suppressionHandlerCode).toContain('suppressOrderNotification')
+    expect(suppressionHandlerCode).toMatch(/suppressOrderNotification\s*!==\s*true/)
+  })
+
+  it('keeps firing when the flag is absent, so exported projects are unaffected', () => {
+    // `!== true` (not a truthiness check) is what makes "flag missing" mean
+    // "behave exactly as before".
+    expect(suppressionHandlerCode).not.toMatch(/config\.suppressOrderNotification\s*\)/)
+  })
+
+  it('sends both the {{itemsList}} and the array-mapper row keys per item', () => {
+    // One payload feeds the endpoint's own <ul> builder AND a builder email
+    // template's `tq:each` row block, so neither renderer needs to know which
+    // template style the merchant is on.
+    for (const key of ['product_name', 'unit_price', 'line_total', 'image_url']) {
+      expect(suppressionHandlerCode).toContain(key)
+    }
+    expect(suppressionHandlerCode).toMatch(
+      /it\.image \|\| it\.image_url \|\| it\.imageUrl \|\| it\.thumbnail/
+    )
+  })
+})

package/__tests__/ecommerce-customhandler-rewriter.test.ts

@@ -373,7 +373,7 @@ describe('buildPaymentMetadataBuilder — runtime semantics', () => {
   // Build a synthetic params array that mirrors the workflow context:
   // a mix of unrelated nodes plus an order-create-item-shaped result.
   const fn = (() => {
-    const code = buildPaymentMetadataBuilder()
+    const code = buildPaymentMetadataBuilder('/order-details')
     return new Function(code + '\nreturn customHandler;')() as any
   })()
 

package/__tests__/internal-request-headers.test.ts

@@ -0,0 +1,159 @@
+import { generateSharedRuntimeUtilsCode } from '../src/executor-generator'
+import {
+  generateServerSegmentAPIRoute,
+  generateStreamingServerSegmentAPIRoute,
+} from '../src/api-route-generator'
+import { nodeRegistry } from '../src/nodes'
+import type { WorkflowSegment } from '../src/types'
+
+/**
+ * A generated app's data nodes reach the database by having the server call its
+ * OWN `/api/data/<id>/<op>` route over HTTP. On a deployment behind Vercel
+ * Deployment Protection that self-call is answered with 401 "Protected
+ * deployment" — the page still renders (the visitor's browser holds the bypass
+ * cookie) but every data node returns `{ rows: [] }`, so the app looks alive
+ * while nothing reads or writes.
+ *
+ * Measured on a published AI-chat store: all four RAG queries came back empty
+ * with `error: { message: 'Protected deployment', code: '401' }`, and the
+ * assistant answered "I don't have enough information in my knowledge base" to
+ * every question — with a fully populated knowledge base sitting in the
+ * database.
+ */
+
+function loadRuntime() {
+  const source = generateSharedRuntimeUtilsCode()
+  const fn = source.match(/function internalRequestHeaders[\s\S]*?\n\}/)
+  if (!fn) {
+    throw new Error('internalRequestHeaders not found in the generated runtime')
+  }
+  // eslint-disable-next-line @typescript-eslint/no-implied-eval
+  return {
+    internalRequestHeaders: new Function(`${fn[0]}\nreturn internalRequestHeaders;`)() as (
+      req: unknown
+    ) => Record<string, string>,
+  }
+}
+
+describe('internalRequestHeaders', () => {
+  const utils = loadRuntime()
+  const originalBypass = process.env.VERCEL_AUTOMATION_BYPASS_SECRET
+
+  afterEach(() => {
+    if (originalBypass === undefined) {
+      delete process.env.VERCEL_AUTOMATION_BYPASS_SECRET
+    } else {
+      process.env.VERCEL_AUTOMATION_BYPASS_SECRET = originalBypass
+    }
+  })
+
+  it('forwards the caller cookie that already passed the protection', () => {
+    delete process.env.VERCEL_AUTOMATION_BYPASS_SECRET
+    const headers = utils.internalRequestHeaders({
+      headers: { cookie: '_vercel_jwt=abc; next-auth.session-token=xyz' },
+    })
+    expect(headers.cookie).toBe('_vercel_jwt=abc; next-auth.session-token=xyz')
+  })
+
+  it('sends the automation bypass secret when the project configured one', () => {
+    // The only credential available when no browser sits behind the request.
+    process.env.VERCEL_AUTOMATION_BYPASS_SECRET = 'sekret'
+    const headers = utils.internalRequestHeaders({ headers: {} })
+    expect(headers['x-vercel-protection-bypass']).toBe('sekret')
+    expect(headers['x-vercel-set-bypass-cookie']).toBe('false')
+  })
+
+  it('returns an empty object rather than throwing on a request with no headers', () => {
+    delete process.env.VERCEL_AUTOMATION_BYPASS_SECRET
+    expect(utils.internalRequestHeaders(undefined)).toEqual({})
+    expect(utils.internalRequestHeaders({})).toEqual({})
+  })
+
+  it('invents no cookie when the caller sent none', () => {
+    delete process.env.VERCEL_AUTOMATION_BYPASS_SECRET
+    expect(utils.internalRequestHeaders({ headers: {} }).cookie).toBeUndefined()
+  })
+})
+
+describe('every data node forwards the internal headers on its self-call', () => {
+  const DATA_NODES = [
+    'data-raw-query',
+    'data-select',
+    'data-count',
+    'data-create-item',
+    'data-update-item',
+    'data-delete-item',
+  ]
+
+  it.each(DATA_NODES)('%s reads context.__internalHeaders', (nodeType) => {
+    const source = nodeRegistry[nodeType].generateHandler()
+    expect(source).toContain('context.__internalHeaders')
+  })
+
+  it.each(DATA_NODES)('%s merges them into every self-call it makes', (nodeType) => {
+    const source = nodeRegistry[nodeType].generateHandler()
+    // A bare `headers: { 'Content-Type': … }` on a call to this deployment's own
+    // API is the shape that 401s; every one must be an Object.assign that folds
+    // the internal headers in.
+    const selfCalls = source.split('fetch(baseUrl').slice(1)
+    expect(selfCalls.length).toBeGreaterThan(0)
+    for (const call of selfCalls) {
+      const headersAt = call.indexOf('headers:')
+      expect(headersAt).toBeGreaterThan(-1)
+      expect(call.slice(headersAt, headersAt + 60)).toContain('Object.assign')
+    }
+  })
+})
+
+describe('the segment routes supply the headers but never echo them back', () => {
+  const segment: WorkflowSegment = {
+    id: 'seg-server-1',
+    workflowId: 'wf-1',
+    executionEnv: 'server',
+    nodes: [
+      {
+        id: 'n1',
+        type: 'data-raw-query',
+        config: { dataSourceId: 'ds-1', query: 'SELECT 1' },
+        stepNumber: 1,
+        label: 'Probe',
+      },
+    ],
+    edges: [],
+  } as unknown as WorkflowSegment
+
+  const routes = [
+    ['non-streaming', generateServerSegmentAPIRoute(segment)],
+    ['streaming', generateStreamingServerSegmentAPIRoute(segment)],
+  ] as const
+
+  it.each(routes)('%s route puts the headers on the execution context', (_label, route) => {
+    expect(route).toContain('context.__internalHeaders = utils.internalRequestHeaders(req)')
+  })
+
+  it.each(routes)('%s route deletes them before serializing the context', (_label, route) => {
+    // ⛔ `results` in the response IS this context. The forwarded cookie carries
+    // the visitor's session token; writing it into a JS-readable response body
+    // would undo the httpOnly flag it was set with.
+    const deleteAt = route.indexOf('delete context.__internalHeaders')
+    expect(deleteAt).toBeGreaterThan(-1)
+    const firstEcho = route.indexOf('results: context')
+    expect(firstEcho).toBeGreaterThan(-1)
+    expect(deleteAt).toBeLessThan(firstEcho)
+  })
+
+  it.each(routes)('%s route echoes the context exactly once per exit path', (_label, route) => {
+    // Guards the assertion above: a second `results: context` added later would
+    // sit outside the delete's reach unless it is also after it.
+    const positions: number[] = []
+    let idx = route.indexOf('results: context')
+    while (idx !== -1) {
+      positions.push(idx)
+      idx = route.indexOf('results: context', idx + 1)
+    }
+    const deleteAt = route.indexOf('delete context.__internalHeaders')
+    for (const position of positions) {
+      expect(position).toBeGreaterThan(deleteAt)
+    }
+  })
+})