@astrale-os/sdk 0.4.9 → 0.4.11

package/src/server/auxiliary-routes.ts

@@ -18,10 +18,15 @@ import type { AuthContext } from '@astrale-os/kernel-core'
 import type { Context, Hono } from 'hono'
 
 import {
+  decodeKernelRequest,
   isKernelErrorClassifiable,
+  KERNEL_CONTENT_TYPE_JSON,
+  KERNEL_CONTENT_TYPE_MSGPACK,
   KERNEL_ERROR_CODES,
   kernelErrorHttpStatus,
+  resolveCodec,
   type KernelErrorPayload,
+  type RequestId,
 } from '@astrale-os/kernel-api'
 import {
   isSubdomainOf,
@@ -41,6 +46,7 @@ import type { AuxIdentityMap } from '../dispatch/identity'
 import { makeFunctionContext } from '../auth/function-context'
 import { makeDomainAuthority } from '../auth/issuer-mint'
 import { resolveInboundAuth } from '../auth/resolve'
+import { createHandlerLifecycle, executionLifetime } from '../defer'
 import { runAuthorize } from '../dispatch/authorize'
 import { SdkResultValidationError, SdkValidationError } from '../dispatch/errors'
 import { validateParams, validateResult } from '../dispatch/validate'
@@ -137,11 +143,8 @@ export function mountAuxiliaryRoutes<TDeps>(config: AuxiliaryRoutesConfig<TDeps>
         identity,
         corsHeaders,
         run: async ({ c, auth, kernel }) => {
-          const rawBody: unknown = await c.req.raw
-            .clone()
-            .json()
-            .catch(() => ({}))
-          const validation = validateParams(def.inputSchema, rawBody)
+          const input = await readRemoteFunctionInput(c)
+          const validation = validateParams(def.inputSchema, input.params)
           if (!validation.ok) {
             throw new SdkValidationError(validation.issues as SdkValidationError['issues'])
           }
@@ -169,10 +172,20 @@ export function mountAuxiliaryRoutes<TDeps>(config: AuxiliaryRoutesConfig<TDeps>
             }),
           }
           if (def.authorize) await runAuthorize(def.authorize, ctx)
-          const result = await def.execute({
-            ...ctx,
-            step: createInlineStep({ scope: { kind: 'function', ref: `function.${slug}`, slug } }),
-          })
+          const lifecycle = createHandlerLifecycle(executionLifetime(c))
+          const result = await (async () => {
+            try {
+              return await def.execute({
+                ...ctx,
+                step: createInlineStep({
+                  scope: { kind: 'function', ref: `function.${slug}`, slug },
+                }),
+                defer: lifecycle.defer,
+              })
+            } finally {
+              await lifecycle.settle()
+            }
+          })()
           const outValidation = validateResult(def.outputSchema, result)
           if (!outValidation.ok) {
             throw new SdkResultValidationError(
@@ -180,7 +193,10 @@ export function mountAuxiliaryRoutes<TDeps>(config: AuxiliaryRoutesConfig<TDeps>
               `function.${slug}`,
             )
           }
-          return c.json({ result: outValidation.data })
+          return c.json({
+            result: outValidation.data,
+            ...(input.enveloped ? { id: input.id ?? null } : {}),
+          })
         },
       })
     }
@@ -306,6 +322,39 @@ function mountEntry(args: MountEntryArgs): void {
   })
 }
 
+type RemoteFunctionInput = {
+  params: unknown
+  enveloped: boolean
+  id?: RequestId
+}
+
+/**
+ * A Function binding is reached in two legitimate ways:
+ * - kernel-client follows a graph redirect and sends the canonical kernel envelope;
+ * - an external webhook caller POSTs its raw JSON contract directly.
+ *
+ * The vendor content type is the discriminator. Shape-sniffing would break a valid
+ * webhook whose own payload happens to contain `method` and `params` fields.
+ */
+async function readRemoteFunctionInput(c: Context): Promise<RemoteFunctionInput> {
+  const contentType = c.req.header('content-type') ?? ''
+  const isJsonEnvelope = contentType.includes(KERNEL_CONTENT_TYPE_JSON)
+  const isMsgpackEnvelope = contentType.includes(KERNEL_CONTENT_TYPE_MSGPACK)
+
+  if (isJsonEnvelope || isMsgpackEnvelope) {
+    const bytes = new Uint8Array(await c.req.raw.clone().arrayBuffer())
+    const codec = resolveCodec(isMsgpackEnvelope ? 'msgpack' : 'json')
+    const request = decodeKernelRequest(codec.decode(bytes))
+    return { params: request.params, enveloped: true, id: request.id }
+  }
+
+  const params: unknown = await c.req.raw
+    .clone()
+    .json()
+    .catch(() => ({}))
+  return { params, enveloped: false }
+}
+
 function applyCorsToContext(c: Context, headers: Record<string, string>): void {
   for (const [name, value] of Object.entries(headers)) c.header(name, value)
 }

package/src/server/worker-entry.ts

@@ -22,6 +22,8 @@
  * The worker file is then just schema + methods + a `build(url, env)` callback.
  */
 
+import type { ExecutionContext } from 'hono'
+
 import type { RemoteServerConfig } from './config'
 
 import { createRemoteServer } from './create'
@@ -29,7 +31,13 @@ import { requireEnv } from './require-env'
 import { canonicalizeServingUrl } from './serving-url'
 
 type Fetcher = { fetch(request: Request): Response | Promise<Response> }
-type App = { fetch(request: Request): Response | Promise<Response> }
+type App = {
+  fetch(
+    request: Request,
+    env?: unknown,
+    executionCtx?: ExecutionContext,
+  ): Response | Promise<Response>
+}
 
 /** A built app cached by its serving URL: `origin` for same-origin matching,
  * `app` for in-process self-dispatch. */
@@ -130,7 +138,7 @@ export interface WorkerEntryConfig<TDeps> {
 }
 
 export interface WorkerEntry<TDeps> {
-  fetch(request: Request, env: TDeps): Response | Promise<Response>
+  fetch(request: Request, env: TDeps, executionCtx?: ExecutionContext): Response | Promise<Response>
 }
 
 /**
@@ -243,7 +251,7 @@ export function createWorkerEntry<TDeps>(config: WorkerEntryConfig<TDeps>): Work
   }
 
   return {
-    async fetch(request: Request, env: TDeps): Promise<Response> {
+    async fetch(request: Request, env: TDeps, executionCtx?: ExecutionContext): Promise<Response> {
       if (config.selfBinding) self ??= config.selfBinding(env) ?? null
       if (config.routeSubrequest) routeEnv = env
       // Only parse the request URL when a hook actually needs it.
@@ -259,7 +267,7 @@ export function createWorkerEntry<TDeps>(config: WorkerEntryConfig<TDeps>): Work
         : requireEnv(env, 'WORKER_URL', "the worker's public serving URL (its iss identity)")
       const url = canonicalizeServingUrl(raw)
       const dispatched = config.rewriteRequest ? config.rewriteRequest(env, request) : request
-      return getApp(url, env).fetch(dispatched)
+      return getApp(url, env).fetch(dispatched, env, executionCtx)
     },
   }
 }