brustjs 0.1.11-alpha → 0.1.13-alpha

package/runtime/mcp/extractor.ts

@@ -1,26 +1,44 @@
+import { existsSync } from 'node:fs'
+import { dirname, join } from 'node:path'
+import { fileURLToPath } from 'node:url'
 import ts from 'typescript'
-import { tsTypeToJsonSchema, type JsonSchema } from './schema.ts'
-import type { McpManifest, ToolSchema, ResourceSchema } from './manifest.ts'
-import type { ActionDef } from '../actions.ts'
 import type { FlatRoute } from '../routes.ts'
+import type { McpManifest, ResourceSchema, ToolSchema } from './manifest.ts'
+import { type JsonSchema, tsTypeToJsonSchema } from './schema.ts'
 
 export interface ExtractOptions {
-  /** Files that have 'use server' directive — provided by scanActions. */
-  serverFiles: string[]
-  /** The routes module file (e.g. example/hello-world/routes.tsx). */
+  /** Module exporting `defineActions(...)`. Convention `<scanRoot>/actions.ts`.
+   * Absent → zero tools (resources still extracted). */
+  actionsFile?: string
+  /** The routes module file. */
   routesFile: string
-  /** The user's source roots. Reserved for future tsconfig/baseUrl/paths
-   * resolution; currently ignored — pass at least one for forward compat. */
+  /** User source roots. Reserved for future tsconfig resolution. */
   sourceRoots: string[]
-  /** Result of `await brust.scanActions(...)` — maps action ids to ActionDef. */
-  actions: ActionDef[]
   /** Result of `defineRoutes(...)`. */
   routes: FlatRoute[]
 }
 
+const METHODS: Record<string, ToolSchema['method']> = {
+  get: 'GET',
+  post: 'POST',
+  put: 'PUT',
+  patch: 'PATCH',
+  delete: 'DELETE',
+  head: 'HEAD',
+}
+
 export async function extractMcpManifest(opts: ExtractOptions): Promise<McpManifest> {
+  const rootNames = [opts.routesFile]
+  if (opts.actionsFile) rootNames.unshift(opts.actionsFile)
+  // Resolve bare specifiers (zod, etc.) that the actions file imports. Normal
+  // walk-up resolution finds the user's own node_modules; the wildcard fallback
+  // points at the brust runtime's node_modules so inferred schema types resolve
+  // even when the actions file lives outside a node_modules tree (e.g. tests).
+  const runtimeNodeModules = findRuntimeNodeModules()
+  const paths: Record<string, string[]> = { '*': ['*'] }
+  if (runtimeNodeModules) paths['*'].push(join(runtimeNodeModules, '*'))
   const program = ts.createProgram({
-    rootNames: [...opts.serverFiles, opts.routesFile],
+    rootNames,
     options: {
       target: ts.ScriptTarget.ES2022,
       module: ts.ModuleKind.ESNext,
@@ -29,6 +47,10 @@ export async function extractMcpManifest(opts: ExtractOptions): Promise<McpManif
       allowJs: false,
       noEmit: true,
       skipLibCheck: true,
+      // The brust runtime imports modules with explicit `.ts` extensions.
+      allowImportingTsExtensions: true,
+      baseUrl: opts.sourceRoots[0] ?? dirname(rootNames[0]),
+      paths,
       // Required: TS 5.x collapses string | null to plain string without strict
       // null checks, which would silently drop the null variant from the schema.
       strictNullChecks: true,
@@ -37,95 +59,235 @@ export async function extractMcpManifest(opts: ExtractOptions): Promise<McpManif
   const checker = program.getTypeChecker()
 
   const tools: ToolSchema[] = []
-  const actionIds = new Set(opts.actions.map((a) => a.id))
-
-  for (const serverFile of opts.serverFiles) {
-    const sf = program.getSourceFile(serverFile)
-    if (!sf) continue
-    ts.forEachChild(sf, (node) => {
-      const tool = extractToolFromNode(checker, node, actionIds)
-      if (tool) tools.push(tool)
-    })
+  if (opts.actionsFile) {
+    const sf = program.getSourceFile(opts.actionsFile)
+    if (sf) extractToolsFromActions(checker, sf, tools)
   }
 
   const resources = extractResources(checker, opts.routes, program.getSourceFile(opts.routesFile))
 
-  // Sort tools/resources alphabetically for stable manifest.
   tools.sort((a, b) => a.name.localeCompare(b.name))
   resources.sort((a, b) => a.uriTemplate.localeCompare(b.uriTemplate))
-
   return { version: 1, tools, resources }
 }
 
-function extractToolFromNode(
+// Walk up from this module's directory to the nearest node_modules that has a
+// resolvable schema dep (zod). Returns the node_modules path or undefined.
+function findRuntimeNodeModules(): string | undefined {
+  let cur = dirname(fileURLToPath(import.meta.url))
+  for (let i = 0; i < 12; i++) {
+    const nm = join(cur, 'node_modules')
+    if (existsSync(join(nm, 'zod'))) return nm
+    const parent = dirname(cur)
+    if (parent === cur) break
+    cur = parent
+  }
+  return undefined
+}
+
+function extractToolsFromActions(
   checker: ts.TypeChecker,
-  node: ts.Node,
-  actionIds: Set<string>,
-): ToolSchema | null {
-  // Case 1: export async function name(req, ...args)
-  if (
-    ts.isFunctionDeclaration(node) &&
-    node.modifiers?.some((m) => m.kind === ts.SyntaxKind.ExportKeyword) &&
-    node.name
-  ) {
-    const name = node.name.text
-    if (!actionIds.has(name)) return null
-    return toolFromSignature(checker, name, node.parameters, node.type, getJsdoc(node))
+  sf: ts.SourceFile,
+  out: ToolSchema[],
+): void {
+  // Find any `defineActions()` method chain anywhere in the file (export const
+  // actions = defineActions()... — but tolerate other shapes).
+  let chainTip: ts.CallExpression | undefined
+  const visit = (node: ts.Node) => {
+    if (!chainTip && ts.isCallExpression(node) && isDefineActionsChain(node)) {
+      chainTip = node
+      return
+    }
+    ts.forEachChild(node, visit)
   }
-  // Case 2: export const name = withMiddleware([...], async (req, ...args) => ...)
-  if (
-    ts.isVariableStatement(node) &&
-    node.modifiers?.some((m) => m.kind === ts.SyntaxKind.ExportKeyword)
-  ) {
-    for (const decl of node.declarationList.declarations) {
-      if (!ts.isIdentifier(decl.name)) continue
-      const name = decl.name.text
-      if (!actionIds.has(name)) continue
-      // Find the function expression inside withMiddleware(...).
-      const init = decl.initializer
-      if (init && ts.isCallExpression(init)) {
-        const fnArg = init.arguments[1]
-        if (fnArg && (ts.isArrowFunction(fnArg) || ts.isFunctionExpression(fnArg))) {
-          return toolFromSignature(checker, name, fnArg.parameters, fnArg.type, getJsdoc(node))
-        }
-      }
+  ts.forEachChild(sf, visit)
+  if (!chainTip) return
+
+  const calls = collectChainCalls(chainTip) // registration order
+  const seen = new Set<string>()
+  for (const call of calls) {
+    // safe: collectChainCalls only enqueues nodes with a PropertyAccessExpression receiver
+    const prop = call.expression as ts.PropertyAccessExpression
+    const method = METHODS[prop.name.text.toLowerCase()]
+    if (!method) continue // .use(...) etc.
+    const pathArg = call.arguments[0]
+    if (!pathArg || !ts.isStringLiteralLike(pathArg)) {
+      console.warn(`[brust mcp] skipping endpoint with non-literal path (.${prop.name.text})`)
+      continue
+    }
+    const path = pathArg.text
+    const handler = call.arguments[1]
+    const optsArg = call.arguments[2]
+    const tool = buildTool(checker, method, path, call, handler, optsArg)
+    if (seen.has(tool.name)) {
+      throw new Error(
+        `[brust mcp] duplicate tool name "${tool.name}" from ${method} ${path}; ` +
+          `another endpoint slugs to the same name. Rename a path.`,
+      )
     }
+    seen.add(tool.name)
+    out.push(tool)
   }
-  return null
 }
 
-function toolFromSignature(
+// True when the innermost receiver of this call chain is `defineActions(...)`.
+function isDefineActionsChain(node: ts.CallExpression): boolean {
+  let cur: ts.Expression = node
+  while (ts.isCallExpression(cur) && ts.isPropertyAccessExpression(cur.expression)) {
+    cur = cur.expression.expression
+  }
+  return (
+    ts.isCallExpression(cur) &&
+    ts.isIdentifier(cur.expression) &&
+    cur.expression.text === 'defineActions'
+  )
+}
+
+// Collect each `.method(...)` CallExpression, outermost→inward, then reverse to
+// registration order.
+function collectChainCalls(node: ts.CallExpression): ts.CallExpression[] {
+  const acc: ts.CallExpression[] = []
+  let cur: ts.Expression = node
+  while (ts.isCallExpression(cur) && ts.isPropertyAccessExpression(cur.expression)) {
+    acc.push(cur)
+    cur = cur.expression.expression
+  }
+  return acc.reverse()
+}
+
+function buildTool(
   checker: ts.TypeChecker,
-  name: string,
-  parameters: ts.NodeArray<ts.ParameterDeclaration>,
-  returnTypeNode: ts.TypeNode | undefined,
-  description: string | undefined,
+  method: ToolSchema['method'],
+  path: string,
+  call: ts.CallExpression,
+  handler: ts.Expression | undefined,
+  optsArg: ts.Expression | undefined,
 ): ToolSchema {
-  // Drop the first parameter (req: BrustRequest).
-  const argParams = parameters.slice(1)
-  const properties: Record<string, JsonSchema> = {}
-  const required: string[] = []
-  const paramOrder: string[] = []
-  for (const p of argParams) {
-    if (!ts.isIdentifier(p.name)) continue
-    const pname = p.name.text
-    paramOrder.push(pname)
-    const t = checker.getTypeAtLocation(p)
-    const schema = tsTypeToJsonSchema(t, { checker }) ?? {}
-    properties[pname] = schema
-    // Rest params (...args) are always optional at the call site — never required.
-    if (!p.questionToken && !p.dotDotDotToken) required.push(pname)
+  const props: Record<string, JsonSchema> = {}
+
+  // params — from path {x}/{*x} segments (always string, required).
+  const paramNames = parsePathParams(path)
+  if (paramNames.length > 0) {
+    const pprops: Record<string, JsonSchema> = {}
+    for (const p of paramNames) pprops[p] = { type: 'string' }
+    props.params = { type: 'object', properties: pprops, required: [...paramNames] }
   }
-  const inputSchema: JsonSchema = { type: 'object', properties }
-  if (required.length > 0) inputSchema.required = required
+
+  // opts literal — detect body/query presence + read description.
+  const optsLit = optsArg && ts.isObjectLiteralExpression(optsArg) ? optsArg : undefined
+  const hasBody = optsLit ? hasProp(optsLit, 'body') : false
+  const hasQuery = optsLit ? hasProp(optsLit, 'query') : false
+  const description = optsLit ? readStringProp(optsLit, 'description') : undefined
+
+  // handler ctx type — for body/query inference. Derived from the builder
+  // call's resolved signature (not the user's arrow) so it works regardless of
+  // whether the handler destructures its ctx param.
+  const ctxType = callCtxType(checker, call)
+  if (hasBody && ctxType) {
+    const s = ctxMemberSchema(checker, ctxType, 'body')
+    if (s) props.body = s
+  }
+  if (hasQuery && ctxType) {
+    const s = ctxMemberSchema(checker, ctxType, 'query')
+    if (s) props.query = s
+  }
+
+  const inputSchema: JsonSchema = { type: 'object', properties: props }
 
   let outputSchema: JsonSchema | undefined
-  if (returnTypeNode) {
-    const returnType = checker.getTypeFromTypeNode(returnTypeNode)
-    outputSchema = tsTypeToJsonSchema(returnType, { checker, unwrapPromise: true })
+  if (handler) {
+    const ret = handlerReturnType(checker, handler)
+    if (ret) outputSchema = tsTypeToJsonSchema(ret, { checker, unwrapPromise: true })
   }
 
-  return { name, description, inputSchema, outputSchema, paramOrder }
+  return { name: toolName(method, path), description, method, path, inputSchema, outputSchema }
+}
+
+function toolName(method: ToolSchema['method'], path: string): string {
+  const slug = path
+    .replace(/^\//, '')
+    .split('/')
+    .filter((s) => s.length > 0)
+    .map((seg) =>
+      seg.startsWith('{') && seg.endsWith('}') ? `by_${seg.slice(1, -1).replace(/^\*/, '')}` : seg,
+    )
+    .join('_')
+    .replace(/[^a-zA-Z0-9_-]/g, '_')
+  // Root path '/' yields an empty slug — name it '<method>_root' so it stays
+  // descriptive and distinct rather than a bare '<method>'.
+  if (slug === '') return `${method.toLowerCase()}_root`
+  return `${method.toLowerCase()}_${slug}`.replace(/_+$/, '')
+}
+
+function parsePathParams(path: string): string[] {
+  const out: string[] = []
+  for (const m of path.matchAll(/\{(\*?)([^}]+)\}/g)) out.push(m[2])
+  return out
+}
+
+function hasProp(lit: ts.ObjectLiteralExpression, name: string): boolean {
+  return lit.properties.some(
+    (p) =>
+      (ts.isPropertyAssignment(p) || ts.isShorthandPropertyAssignment(p)) &&
+      p.name &&
+      ts.isIdentifier(p.name) &&
+      p.name.text === name,
+  )
+}
+
+function readStringProp(lit: ts.ObjectLiteralExpression, name: string): string | undefined {
+  for (const p of lit.properties) {
+    if (
+      ts.isPropertyAssignment(p) &&
+      ts.isIdentifier(p.name) &&
+      p.name.text === name &&
+      ts.isStringLiteralLike(p.initializer)
+    ) {
+      return p.initializer.text
+    }
+  }
+  return undefined
+}
+
+// The handler's ctx (first param) type, via the RESOLVED signature of the
+// builder call (param[1] = handler). Reading the builder's parameter type —
+// not the user's arrow — makes body/query inference independent of whether the
+// handler actually destructures its ctx: a `() => ...` handler that declares a
+// `body` schema still yields a rich body schema.
+function callCtxType(checker: ts.TypeChecker, call: ts.CallExpression): ts.Type | undefined {
+  const rs = checker.getResolvedSignature(call)
+  const handlerParam = rs?.getParameters()[1]
+  if (!handlerParam) return undefined
+  const hd = handlerParam.valueDeclaration ?? handlerParam.declarations?.[0]
+  if (!hd) return undefined
+  const ht = checker.getTypeOfSymbolAtLocation(handlerParam, hd)
+  const sig = ht.getCallSignatures()[0]
+  const p0 = sig?.getParameters()[0]
+  if (!p0) return undefined
+  const pd = p0.valueDeclaration ?? p0.declarations?.[0]
+  if (!pd) return undefined
+  return checker.getTypeOfSymbolAtLocation(p0, pd)
+}
+
+function handlerReturnType(checker: ts.TypeChecker, handler: ts.Expression): ts.Type | undefined {
+  const t = checker.getTypeAtLocation(handler)
+  const sig = t.getCallSignatures()[0]
+  return sig ? checker.getReturnTypeOfSignature(sig) : undefined
+}
+
+function ctxMemberSchema(
+  checker: ts.TypeChecker,
+  ctxType: ts.Type,
+  member: 'body' | 'query',
+): JsonSchema | undefined {
+  const sym = ctxType.getProperty(member)
+  if (!sym) return undefined
+  const decl = sym.valueDeclaration ?? sym.declarations?.[0]
+  const t = decl
+    ? checker.getTypeOfSymbolAtLocation(sym, decl)
+    : (checker as unknown as { getTypeOfSymbol?: (s: ts.Symbol) => ts.Type }).getTypeOfSymbol?.(sym)
+  if (!t) return undefined
+  return tsTypeToJsonSchema(t, { checker })
 }
 
 function extractResources(
@@ -148,13 +310,3 @@ function extractResources(
   }
   return out
 }
-
-function getJsdoc(node: ts.Node): string | undefined {
-  const tags = ts.getJSDocCommentsAndTags(node)
-  if (tags.length === 0) return undefined
-  const first = tags[0]
-  // JSDoc `comment` can be either a string or a NodeArray<JSDocComment> when
-  // inline tags like {@link} are present — ts.getTextOfJSDocComment normalises.
-  if (ts.isJSDoc(first)) return ts.getTextOfJSDocComment(first.comment) ?? undefined
-  return undefined
-}

package/runtime/mcp/manifest.ts

@@ -5,9 +5,10 @@ import type { JsonSchema } from './schema.ts'
 export interface ToolSchema {
   name: string
   description?: string
+  method: 'GET' | 'POST' | 'PUT' | 'PATCH' | 'DELETE' | 'HEAD'
+  path: string
   inputSchema: JsonSchema
   outputSchema?: JsonSchema
-  paramOrder: string[]
 }
 
 export interface ResourceSchema {

package/runtime/mcp/server.ts

@@ -1,10 +1,11 @@
-import type { ActionDef } from '../actions.ts'
+import { dispatchAction } from '../routes.ts'
 import type { FlatRoute, BrustRequest } from '../routes.ts'
+import type { EndpointDef } from '../define-actions.ts'
 import type { McpManifest } from './manifest.ts'
 
 export interface McpServerOptions {
   manifest: McpManifest
-  actions: ActionDef[]
+  endpoints: EndpointDef[]
   routes: FlatRoute[]
   packageVersion?: string
 }
@@ -33,6 +34,8 @@ export interface McpServer {
 }
 
 export function makeMcpServer(opts: McpServerOptions): McpServer {
+  const byId = new Map<string, EndpointDef>()
+  for (const e of opts.endpoints) byId.set(`${e.method} ${e.path}`, e)
   return {
     async handleRequest(jsonRpcBody, req): Promise<string> {
       let rpc: JsonRpcRequest
@@ -52,7 +55,7 @@ export function makeMcpServer(opts: McpServerOptions): McpServer {
         case 'tools/list':
           return handleToolsList(rpc, opts)
         case 'tools/call':
-          return handleToolsCall(rpc, opts, req)
+          return handleToolsCall(rpc, opts, req, byId)
         case 'resources/list':
           return handleResourcesList(rpc, opts)
         case 'resources/read':
@@ -105,6 +108,7 @@ async function handleToolsCall(
   rpc: JsonRpcRequest,
   opts: McpServerOptions,
   req: BrustRequest,
+  byId: Map<string, EndpointDef>,
 ): Promise<string> {
   const params = rpc.params as { name?: string; arguments?: Record<string, unknown> } | undefined
   if (!params || typeof params.name !== 'string') {
@@ -114,43 +118,30 @@ async function handleToolsCall(
   if (!tool) {
     return makeError(rpc.id ?? null, -32601, `unknown tool: ${params.name}`)
   }
-  const action = opts.actions.find((a) => a.id === params.name)
-  if (!action) {
-    return makeError(rpc.id ?? null, -32603, `action not registered: ${params.name}`)
+  const def = byId.get(`${tool.method} ${tool.path}`)
+  if (!def) {
+    return makeError(rpc.id ?? null, -32603, `endpoint not registered: ${tool.name}`)
   }
-  // Map { argsObject } → positional args via paramOrder.
-  const args = (tool.paramOrder ?? []).map((k) => params.arguments?.[k])
-
-  // Run through middleware chain (same shape as actionBranch).
-  const { composeChain } = await import('../routes.ts')
-  const terminal = async () => {
-    try {
-      const result = await action.fn(req, ...args)
-      return {
-        status: 200,
-        body: result === undefined ? '' : JSON.stringify(result),
-        contentType: 'application/json; charset=utf-8',
-      }
-    } catch (err) {
-      const e = err instanceof Error ? err : new Error(String(err))
-      return {
-        status: 500,
-        body: JSON.stringify({ error: { message: e.message, name: e.name } }),
-        contentType: 'application/json; charset=utf-8',
-      }
-    }
-  }
-  const chain = composeChain(req, action.middleware, terminal)
-  const response = await chain()
-  if (response.status >= 400) {
-    return makeResult(rpc.id ?? null, {
-      content: [{ type: 'text', text: response.body }],
-      isError: true,
-    })
+
+  const args = (params.arguments ?? {}) as {
+    params?: Record<string, string>
+    query?: Record<string, string>
+    body?: unknown
   }
+  const resp = await dispatchAction(
+    {
+      kind: 'action',
+      action_id: `${tool.method} ${tool.path}`,
+      content_type: 'application/json',
+      params: args.params ?? {},
+      body_text: args.body === undefined ? '' : JSON.stringify(args.body),
+      req: { ...req, search: args.query ?? {} } as BrustRequest,
+    } as never,
+    byId,
+  )
   return makeResult(rpc.id ?? null, {
-    content: [{ type: 'text', text: response.body || '' }],
-    isError: false,
+    content: [{ type: 'text', text: resp.body || '' }],
+    isError: resp.status >= 400,
   })
 }
 

package/runtime/render/inject-action-prefix.ts

@@ -0,0 +1,60 @@
+const ENC = new TextEncoder()
+
+let warned = false
+
+/** @internal — used by tests to reset the warn-once flag. */
+export function _resetWarnedForTests(): void {
+  warned = false
+}
+
+/** Splice `snippet` (a full `<script>…</script>`) into `body` immediately
+ * before the first `</head>` (case-insensitive on the four ASCII letters
+ * only). Returns the original body untouched if `snippet` is null/empty or if
+ * `</head>` is absent. */
+export function injectActionPrefix(body: Uint8Array, snippet: string | null): Uint8Array {
+  if (!snippet) return body
+  const pos = findHeadCloseTag(body)
+  if (pos < 0) {
+    if (!warned) {
+      console.warn('[brust] action-prefix: no </head> in first chunk; global not injected')
+      warned = true
+    }
+    return body
+  }
+  const tagBytes = ENC.encode(snippet)
+  const out = new Uint8Array(body.length + tagBytes.length)
+  out.set(body.subarray(0, pos), 0)
+  out.set(tagBytes, pos)
+  out.set(body.subarray(pos), pos + tagBytes.length)
+  return out
+}
+
+// Module-scope snippet config: set once by run() when an app uses a custom
+// (non-default) actionPrefix; read by the render stream on both paths.
+let snippet: string | null = null
+export function configureActionPrefixSnippet(s: string | null): void {
+  snippet = s
+}
+export function getActionPrefixSnippet(): string | null {
+  return snippet
+}
+
+function findHeadCloseTag(body: Uint8Array): number {
+  const LT = 0x3c,
+    SL = 0x2f,
+    GT = 0x3e
+  for (let i = 0, max = body.length - 6; i < max; i++) {
+    if (body[i] !== LT || body[i + 1] !== SL) continue
+    if (!isLetter(body[i + 2], 0x48)) continue
+    if (!isLetter(body[i + 3], 0x45)) continue
+    if (!isLetter(body[i + 4], 0x41)) continue
+    if (!isLetter(body[i + 5], 0x44)) continue
+    if (body[i + 6] !== GT) continue
+    return i
+  }
+  return -1
+}
+
+function isLetter(b: number, u: number): boolean {
+  return b === u || b === (u | 0x20)
+}

package/runtime/render/inject-css-link.ts

@@ -13,7 +13,7 @@ export function _resetWarnedForTests(): void {
  * before the first occurrence of `</head>` (case-insensitive). Returns the
  * original body untouched if `hrefs` is empty or if `</head>` is absent
  * (warns once in the latter case). Renderer calls this on the first chunk
- * only — see spec §"SSR <link> injection". */
+ * only — see spec S"SSR <link> injection". */
 export function injectCssLink(body: Uint8Array, hrefs: readonly string[]): Uint8Array {
   if (hrefs.length === 0) return body
   const pos = findHeadCloseTag(body)

package/runtime/render/stream.ts

@@ -9,6 +9,7 @@ import { ISLANDS_IMPORTMAP_AND_BOOTSTRAP } from '../islands/importmap.ts'
 import { injectCssLink } from './inject-css-link.ts'
 import { getCssHrefs, getCssHrefsForRoute } from '../css.ts'
 import { injectDevClient } from './inject-dev-client.ts'
+import { injectActionPrefix, getActionPrefixSnippet } from './inject-action-prefix.ts'
 import { getDevClientSnippet } from '../dev/inject.ts'
 
 export interface RenderBranchStreamingArgs {
@@ -148,6 +149,7 @@ export function renderBranchStreaming(args: RenderBranchStreamingArgs): Promise<
             const perRouteHrefs = args.routePath ? getCssHrefsForRoute(args.routePath) : []
             body = injectCssLink(body, [...getCssHrefs(), ...perRouteHrefs])
             body = injectDevClient(body, getDevClientSnippet())
+            body = injectActionPrefix(body, getActionPrefixSnippet())
             const meta = makeMeta({
               status: successStatus,
               streaming: false,
@@ -208,8 +210,9 @@ export function renderBranchStreaming(args: RenderBranchStreamingArgs): Promise<
               .map((h) => `<link rel="stylesheet" href="${h}">`)
               .join('')
             const devTag = getDevClientSnippet() ?? ''
-            if (linkTagsStr.length > 0 || devTag.length > 0) {
-              const prepend = encoder.encode(linkTagsStr + devTag)
+            const prefixTag = getActionPrefixSnippet() ?? ''
+            if (linkTagsStr.length > 0 || devTag.length > 0 || prefixTag.length > 0) {
+              const prepend = encoder.encode(linkTagsStr + prefixTag + devTag)
               const out = new Uint8Array(flushed.length + prepend.length)
               out.set(flushed, 0)
               out.set(prepend, flushed.length)