experimental-ash 0.7.1 → 0.7.3

package/dist/src/runtime/resolve-channel.js

@@ -1,13 +1,18 @@
-import { isCompiledChannel, normalizeChannelDefinition, } from "#internal/authored-definition/channel.js";
+import { normalizeChannelDefinition } from "#internal/authored-definition/channel.js";
 import { toErrorMessage } from "#shared/errors.js";
 import { createResolvedModuleSourceRef, loadResolvedModuleExport, ResolveAgentError, } from "#runtime/resolve-helpers.js";
 /**
  * Resolves one compiled channel entry into a runtime-owned definition
- * with a live `fetch` or `handler` attached from the authored module.
+ * with a live `handler` (the per-route handler authored via `POST` /
+ * `GET` / etc. inside `defineChannel`) and the channel's `receive` hook
+ * if the author declared one.
  *
- * For CompiledChannel values (produced by `defineChannel()`), the
- * resolver finds the matching route by method + path and attaches its
- * `handler`. For old-style Route values, it attaches `fetch` directly.
+ * Every authored channel is a `CompiledChannel` from `defineChannel` —
+ * the bare `{ fetch, receive? }` Route shape is rejected by
+ * {@link normalizeChannelDefinition}. Framework-internal channels
+ * (the connection callback route, the `ash` session channel) build
+ * `ResolvedChannelDefinition` values directly and do not flow through
+ * this resolver.
  */
 export async function resolveChannelDefinition(definition, moduleMap, nodeId) {
     try {
@@ -23,35 +28,23 @@ export async function resolveChannelDefinition(definition, moduleMap, nodeId) {
             logicalPath: definition.logicalPath,
             sourceId: definition.sourceId,
         });
-        if (isCompiledChannel(channelDefinition)) {
-            const matchedRoute = channelDefinition.routes.find((r) => r.method.toUpperCase() === definition.method.toUpperCase() &&
-                r.path === definition.urlPath);
-            const adapter = channelDefinition.adapter;
-            if (adapter && adapter.kind !== "http") {
-                adapter.kind = `channel:${definition.name}`;
-            }
-            return {
-                name: definition.name,
-                method: definition.method,
-                urlPath: definition.urlPath,
-                fetch: async (req, ctx) => {
-                    if (matchedRoute)
-                        return matchedRoute.handler(req, ctx);
-                    return Response.json({ error: "No matching route handler.", ok: false }, { status: 404 });
-                },
-                handler: matchedRoute?.handler,
-                receive: channelDefinition.receive,
-                adapter,
-                ...sourceRef,
-            };
+        const matchedRoute = channelDefinition.routes.find((r) => r.method.toUpperCase() === definition.method.toUpperCase() && r.path === definition.urlPath);
+        const adapter = channelDefinition.adapter;
+        if (adapter && adapter.kind !== "http") {
+            adapter.kind = `channel:${definition.name}`;
         }
         return {
             name: definition.name,
             method: definition.method,
             urlPath: definition.urlPath,
-            fetch: channelDefinition.fetch,
+            fetch: async (req, ctx) => {
+                if (matchedRoute)
+                    return matchedRoute.handler(req, ctx);
+                return Response.json({ error: "No matching route handler.", ok: false }, { status: 404 });
+            },
+            handler: matchedRoute?.handler,
             receive: channelDefinition.receive,
-            adapter: channelDefinition.adapter,
+            adapter,
             ...sourceRef,
         };
     }

package/dist/src/runtime/types.d.ts

@@ -1,7 +1,8 @@
 import type { FlexibleSchema } from "ai";
 import type { ChannelAdapter } from "#channel/adapter.js";
+import type { CompiledChannel } from "#channel/compiled-channel.js";
 import type { DiscoverDiagnosticsSummary } from "#discover/diagnostics.js";
-import type { ChannelMethod, Route, RouteContext } from "#public/definitions/channel.js";
+import type { ChannelMethod, RouteContext } from "#public/definitions/channel.js";
 import type { RouteHandler } from "#channel/routes.js";
 import type { LifecycleHooks, StreamEventHook } from "#public/definitions/hook.js";
 import type { CompactionHookInput, CompactionHookResult, NeedsApprovalContext, ToolRetentionPolicy } from "#public/definitions/tool.js";
@@ -172,16 +173,20 @@ export interface ResolvedChannelDefinition extends ResolvedModuleSourceRef {
     readonly method: ChannelMethod;
     readonly adapter?: ChannelAdapter;
     readonly urlPath: string;
-    readonly fetch: Route["fetch"] | ((req: Request, ctx: RouteContext) => Promise<Response>);
+    readonly fetch: (req: Request, ctx: RouteContext) => Promise<Response>;
     /**
-     * Old-style receive from Route or new-style receive from CompiledChannel.
-     * The schedule dispatcher adapts to whichever shape is present.
+     * Universal entry point for new sessions, called by cross-channel
+     * initiators (the schedule dispatcher today). Typed precisely as
+     * {@link CompiledChannel.receive} — `(input, { send }) => Session` —
+     * so any caller passing the wrong context shape is a typecheck error,
+     * not a runtime crash.
      *
-     * Both signatures accept a first arg with `{ message, args }`. The
-     * second arg differs: old uses `{ agent, waitUntil }`, new uses
-     * `{ send }`. The dispatcher passes the appropriate shape.
+     * Old Route-style channels do not flow `receive` through here. The
+     * resolver sets it to `undefined` for those; callers that need
+     * `receive` then throw with a clear error rather than silently
+     * accepting a different shape.
      */
-    readonly receive?: (...args: any[]) => Promise<any>;
+    readonly receive?: CompiledChannel["receive"];
     /**
      * New-style route handler from CompiledChannel. When present, the
      * dispatch layer uses this instead of `fetch`.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "experimental-ash",
-  "version": "0.7.1",
+  "version": "0.7.3",
   "bin": {
     "ash": "./bin/ash.js",
     "experimental-ash": "./bin/ash.js"
@@ -120,10 +120,10 @@
       "import": "./dist/src/public/channels/index.js",
       "default": "./dist/src/public/channels/index.js"
     },
-    "./channels/http": {
-      "types": "./dist/src/public/channels/http.d.ts",
-      "import": "./dist/src/public/channels/http.js",
-      "default": "./dist/src/public/channels/http.js"
+    "./channels/ash": {
+      "types": "./dist/src/public/channels/ash.d.ts",
+      "import": "./dist/src/public/channels/ash.js",
+      "default": "./dist/src/public/channels/ash.js"
     },
     "./channels/auth": {
       "types": "./dist/src/public/channels/auth.d.ts",

package/dist/src/compiler/channel-url.d.ts

@@ -1,5 +0,0 @@
-/**
- * Translates a filesystem-derived channel name into the URL path the Nitro
- * router mounts.
- */
-export declare function deriveChannelUrlPath(name: string): string;

package/dist/src/compiler/channel-url.js

@@ -1,14 +0,0 @@
-/**
- * Translates a filesystem-derived channel name into the URL path the Nitro
- * router mounts.
- */
-export function deriveChannelUrlPath(name) {
-    const segments = name.split("/").map(translateChannelPathSegment);
-    return `/${segments.join("/")}`;
-}
-function translateChannelPathSegment(segment) {
-    if (segment.startsWith("[") && segment.endsWith("]")) {
-        return `:${segment.slice(1, -1)}`;
-    }
-    return segment;
-}