acrylblends 0.2.0 → 0.3.0

package/plugins/acryl-state/tests/service.spec.ts

@@ -0,0 +1,132 @@
+/**
+ * The state service through a real Cordis `Context`: cells are owned by the plugin that made them, readable and
+ * subscribable in process, and streamed through the router as server-sent events, with cancellation and disposal.
+ */
+
+import { Context } from '@deepseek-ai/cordis'
+import { apply as routerApply, name as routerName } from '../../acryl-router/src/index.ts'
+import { afterEach, describe, expect, it } from 'vitest'
+import { apply, name } from '../src/index.ts'
+
+const contexts: Context[] = []
+const settle = (ms = 0): Promise<void> => new Promise(resolve => setTimeout(resolve, ms))
+afterEach(async () => {
+  while (contexts.length > 0) await contexts.pop()?.fiber.dispose()
+})
+
+async function system(withRouter = true): Promise<Context> {
+  const ctx = new Context()
+  contexts.push(ctx)
+  if (withRouter) ctx.plugin({ name: routerName, apply: routerApply }, { trailingSlash: 'strict' })
+  ctx.plugin({ name, apply })
+  await settle()
+  return ctx
+}
+
+/** A tiny SSE reader over a Response body. */
+async function events(response: Response, count: number): Promise<string[]> {
+  const reader = response.body!.getReader()
+  const decoder = new TextDecoder()
+  let buffer = ''
+  const out: string[] = []
+  while (out.length < count) {
+    const { done, value } = await reader.read()
+    if (done) break
+    buffer += decoder.decode(value, { stream: true })
+    for (let at = buffer.indexOf('\n\n'); at !== -1; at = buffer.indexOf('\n\n')) {
+      out.push(buffer.slice(0, at))
+      buffer = buffer.slice(at + 2)
+    }
+  }
+  reader.releaseLock()
+  return out
+}
+
+describe('acryl-state', () => {
+  it('creates cells owned by the calling plugin and removes them when it unloads', async () => {
+    const ctx = await system()
+    const fiber = ctx.plugin({ name: 'owner', inject: ['state'], apply(c: Context) { c.state.cell('owner.count', 1) } })
+    await settle()
+    expect(ctx.state.keys()).toEqual(['owner.count'])
+    expect(ctx.state.find<number>('owner.count')?.get()).toBe(1)
+    await fiber.dispose()
+    await settle()
+    expect(ctx.state.keys()).toEqual([])
+    expect(ctx.state.find('owner.count')).toBeUndefined()
+  })
+
+  it('rejects a bad or duplicate key', async () => {
+    const ctx = await system()
+    ctx.state.cell('ok.key', 0)
+    expect(() => ctx.state.cell('ok.key', 1)).toThrow(/already in use/)
+    expect(() => ctx.state.cell('Bad Key', 1)).toThrow(/dotted lowercase/)
+    expect(() => ctx.state.derive('ok.key', [], () => 1)).toThrow(/already in use/)
+  })
+
+  it('derives a cell from others and detaches it when its owner unloads', async () => {
+    const ctx = await system()
+    const a = ctx.state.cell<number>('n.a', 1)
+    const fiber = ctx.plugin({ name: 'deriver', inject: ['state'], apply(c: Context) { c.state.derive('n.double', [a] as const, x => x * 2) } })
+    await settle()
+    expect(ctx.state.find<number>('n.double')?.get()).toBe(2)
+    a.set(5)
+    expect(ctx.state.find<number>('n.double')?.get()).toBe(10)
+    await fiber.dispose()
+    await settle()
+    expect(ctx.state.find('n.double')).toBeUndefined()
+  })
+
+  it('serves keys and values as JSON on the router, read-only', async () => {
+    const ctx = await system()
+    ctx.state.cell('app.title', 'hello')
+    const keys = await ctx.router.fetch(new Request('http://acryl.test/api/state'))
+    expect(await keys.json()).toEqual({ keys: ['app.title'] })
+    const one = await ctx.router.fetch(new Request('http://acryl.test/api/state/app.title'))
+    expect(await one.json()).toEqual({ key: 'app.title', value: 'hello' })
+    expect((await ctx.router.fetch(new Request('http://acryl.test/api/state/none'))).status).toBe(404)
+    expect((await ctx.router.fetch(new Request('http://acryl.test/api/state/app.title', { method: 'PUT', body: '"x"' }))).status).toBe(405)
+    expect(ctx.state.find('app.title')?.get()).toBe('hello')
+  })
+
+  it('streams the value now and every change as server-sent events, and ends when the caller aborts', async () => {
+    const ctx = await system()
+    const cell = ctx.state.cell<number>('app.count', 0)
+    const controller = new AbortController()
+    const response = await ctx.router.fetch(new Request('http://acryl.test/api/state/app.count/events', { signal: controller.signal }))
+    expect(response.headers.get('content-type')).toContain('text/event-stream')
+    const reading = events(response, 3)
+    await settle(5)
+    cell.set(1)
+    cell.set(2)
+    expect(await reading).toEqual(['event: value\ndata: 0', 'event: value\ndata: 1', 'event: value\ndata: 2'])
+    controller.abort()
+    await settle(5)
+    // After the abort the stream no longer holds a subscription on the cell.
+    let notified = 0
+    const probe = ctx.state.find<number>('app.count')!.subscribe(() => { notified += 1 })
+    cell.set(3)
+    probe()
+    expect(notified).toBe(1)
+  })
+
+  it('closes every open stream when the router is disposed', async () => {
+    const ctx = await system()
+    ctx.state.cell<number>('app.count', 0)
+    const routerFiber = [...[...ctx.registry.values()].find(runtime => runtime.name === routerName)!.fibers][0]!
+    const response = await ctx.router.fetch(new Request('http://acryl.test/api/state/app.count/events'))
+    const reader = response.body!.getReader()
+    await reader.read()
+    const ended = reader.read()
+    await routerFiber.dispose()
+    await expect(ended).resolves.toMatchObject({ done: true })
+  })
+
+  it('works with no router: cells and subscriptions only, no routes', async () => {
+    const ctx = await system(false)
+    const cell = ctx.state.cell<string>('plain.value', 'a')
+    const seen: string[] = []
+    cell.subscribe(value => seen.push(value))
+    cell.set('b')
+    expect(seen).toEqual(['b'])
+  })
+})

package/plugins/acryl-state/upstream.json

@@ -0,0 +1,20 @@
+{
+  "source": {
+    "repo": "acryldev/acryl",
+    "path": "plugins/acryl-state",
+    "commit": "11fed295161c0282d144b5ac62616988b58d8189"
+  },
+  "vendored": [
+    "src",
+    "tests",
+    "LICENSE"
+  ],
+  "rewrittenSpecifiers": 4,
+  "digest": "sha256:528bdc35dbbe22dfae8822fe054cfbfccae9554b9e06089dd7e269f44e27add4",
+  "testsNotRun": {
+    "tests/react.spec.ts": "needs react and @testing-library/react, which generated apps do not install"
+  },
+  "notice": [
+    "LICENSE"
+  ]
+}

package/plugins/builder/script.ts

@@ -21,21 +21,20 @@ export function routeSource(name: string, path: string, text: string): string {
 
 /** Written by the builder: answers GET ${path}, and checks that it does before the install counts. */
 export const name = '${name}'
-export const inject = ['http']
+export const inject = ['router']
 
-interface Http {
-  route(method: string, path: string, handler: () => { body: unknown }): () => void
-  handle(request: { method: string; path: string; body: unknown }): Promise<{ status: number; body: unknown }>
+interface Router {
+  get(path: string, handler: (c: { json(body: unknown, status?: number): Response }) => Response): unknown
+  request(path: string): Promise<Response>
 }
-
 export function apply(ctx: Context) {
-  const http = ctx.get('http') as Http
-  ctx.effect(() => http.route('GET', ${JSON.stringify(path)}, () => ({ body: { text: ${JSON.stringify(text)} } })))
+  // A route registered through this plugin's context is removed when the plugin is unloaded.
+  (ctx as unknown as { router: Router }).router.get(${JSON.stringify(path)}, (c) => c.json({ text: ${JSON.stringify(text)} }))
 }
 
 export async function check(ctx: Context) {
-  const reply = await (ctx.get('http') as Http).handle({ method: 'GET', path: ${JSON.stringify(path)}, body: undefined })
-  if (reply.status !== 200) throw new Error(\`GET ${path} answered \${reply.status}\`)
+  const reply = await (ctx.get('router') as Router).request(${JSON.stringify(path)})
+  if (!reply.ok) throw new Error(\`GET ${path} answered \${reply.status}\`)
 }
 `
 }

package/plugins/extensions/index.ts

@@ -181,6 +181,11 @@ function injected(module: PluginModule): string[] {
 }
 
 /** The service. One instance serves one app home. */
+/** The slice of the state service this plugin uses, by name, so it imports nothing from acryl-state. */
+interface StateService {
+  cell<T>(key: string, initial: T): { set(value: T): void }
+}
+
 export class Extensions extends Service {
   readonly sources: readonly ExtensionSource[]
   readonly stageRoot: string
@@ -195,9 +200,15 @@ export class Extensions extends Service {
   private readonly requests = new Map<string, { dir: string; version: string }>()
   private tail: Promise<unknown> = Promise.resolve()
   private disposed = false
+  /**
+   * The context the service was constructed with. Inside a service method `this.ctx` is Cordis's shadow context, which resolves services as the
+   * service's own fiber, so a plugin mounted from it would read `ctx.router` from the installer's fiber and fail. Extensions mount from this one.
+   */
+  private readonly owner: Context
 
   constructor(ctx: Context, config: ExtensionsConfig = {}) {
     super(ctx, 'extensions')
+    this.owner = ctx
     const { home, root } = ctx.appInstance
     this.sources = (config.sources ?? [{ dir: join(home, 'extensions'), trust: 'install' }]).map(
       (source) => ({
@@ -228,6 +239,12 @@ export class Extensions extends Service {
       },
       'extensions: settle pending operations',
     )
+    // With the state service mounted, what is installed is also a cell: any surface reads it as JSON or streams its changes (`/api/state/extensions`).
+    ctx.inject(['state'], (inner) => {
+      const state = (inner as unknown as { state: StateService }).state
+      const cell = state.cell('extensions', this.list())
+      inner.on('extensions/changed', () => cell.set(this.list()))
+    })
     this.ready = this.serial(() => this.startup())
   }
 
@@ -512,7 +529,7 @@ export class Extensions extends Service {
   /** Mount a module as a child fiber and wait until it settles. */
   private async mount(module: PluginModule): Promise<{ fiber: Fiber; error?: unknown }> {
     // An extension is a plugin module whose config, if any, comes from its own defaults.
-    const fiber = this.ctx.plugin(module as unknown as Parameters<Context['plugin']>[0])
+    const fiber = this.owner.plugin(module as unknown as Parameters<Context['plugin']>[0])
     try {
       await fiber.await()
       return { fiber }

package/plugins/openai/prompt.ts

@@ -11,16 +11,20 @@ A plugin's index.ts is TypeScript that Node runs directly (erasable syntax only:
 
   import type { Context } from '@deepseek-ai/cordis'
   export const name = 'hello'            // must equal the folder name
-  export const inject = ['http']          // services it needs; it waits (pending) until they exist
+  export const inject = ['router']        // services it needs; it waits (pending) until they exist
+  interface Router { get(path: string, handler: (c: { json(body: unknown, status?: number): Response }) => Response): unknown; request(path: string): Promise<Response> }
   export function apply(ctx: Context) {
-    const http = ctx.get('http') as { route(method: string, path: string, handler: (request: { body: unknown }) => { status?: number; body: unknown }): () => void }
-    ctx.effect(() => http.route('GET', '/hello', () => ({ body: { text: 'Hello' } })))   // in ctx.effect: removed when the plugin is
+    ;(ctx as unknown as { router: Router }).router.get('/hello', (c) => c.json({ text: 'Hello' }))   // removed when the plugin is unloaded
   }
   export async function check(ctx: Context) {   // optional: must pass, or the install is rolled back
-    const http = ctx.get('http') as { handle(r: { method: string; path: string; body: unknown }): Promise<{ status: number }> }
-    if ((await http.handle({ method: 'GET', path: '/hello', body: undefined })).status !== 200) throw new Error('GET /hello failed')
+    const reply = await (ctx.get('router') as Router).request('/hello')
+    if (!reply.ok) throw new Error('GET /hello failed')
   }
 
+The router: router.get/post/put/delete(path, handler), a path parameter is :id and is read with c.param('id'), c.json(body, status)
+answers JSON, c.text(...) answers text, c.req.json() reads a JSON body, and router.request('/path', { method: 'POST', body: ... }) calls a route in
+process (use it in check). Every registration made from a plugin's own context goes away when the plugin is unloaded.
+
 For a capability that is a pure function of data (parse, convert, compute), write a sandboxed TOOL instead of a plugin. It cannot touch the
 host: it runs in a separate process that can read only its own folder. Files: index.ts exporting  run(input)  and  tool.json:
   { "description": "what it does and its input", "examples": [ { "input": {...}, "output": {...} } ] }

package/plugins/tasks/index.ts

@@ -69,6 +69,14 @@ declare module '@deepseek-ai/cordis' {
 type Change = Partial<TaskRecord> & { readonly id: string }
 const changeOf = (change: TaskChange) => change as unknown as Change
 
+/** The slice of the state service the tasks plugin uses, by name, so it imports nothing from acryl-state. */
+interface StateService {
+  cell<T>(key: string, initial: T): { set(value: T): void }
+}
+
+/** How many of the newest tasks the state cell holds. */
+const STATE_LIMIT = 100
+
 const FINAL: ReadonlySet<TaskStatus> = new Set(['completed', 'failed', 'cancelled', 'interrupted'])
 const message = (error: unknown) => (error instanceof Error ? error.message : String(error))
 
@@ -111,6 +119,12 @@ export class Tasks extends Service {
       },
       'tasks: cancel running work',
     )
+    // With the state service mounted, the latest tasks are also a cell: any surface reads them as JSON or streams their changes (`/api/state/tasks`).
+    ctx.inject(['state'], (inner) => {
+      const state = (inner as unknown as { state: StateService }).state
+      const cell = state.cell('tasks', this.list().slice(0, STATE_LIMIT))
+      inner.on('tasks/changed', () => cell.set(this.list().slice(0, STATE_LIMIT)))
+    })
   }
 
   /** Start a task. The record is written before this returns. */

package/plugins/tsconfig.json

@@ -15,5 +15,13 @@
     "skipLibCheck": true,
     "types": ["node"]
   },
-  "include": ["*/**/*.ts"]
+  "include": ["*/**/*.ts"],
+  "exclude": [
+    "acryl-router/tests/loader.spec.ts",
+    "acryl-state/src/react.ts",
+    "acryl-state/tests/react.spec.ts",
+    "acryl-router-http/tests/adapter.spec.ts",
+    "acryl-router-http/tests/stream.spec.ts",
+    "acryl-router-http/tests/surfaces.spec.ts"
+  ]
 }

package/templates/agent/blend.yaml

@@ -34,12 +34,10 @@ spec:
       name: agent
       config:
         steps: "{{parameters.steps}}"
-    - id: http
-      name: http
-    - id: events
-      name: events
-      config:
-        topics: [tasks/changed, extensions/changed]
+    - id: router
+      name: acryl-router
+    - id: state
+      name: acryl-state
     - id: sandbox
       name: sandbox
     - id: extensions
@@ -53,6 +51,6 @@ spec:
     - id: routes
       name: routes
     - id: server
-      name: server
+      name: acryl-node-server
       config:
         hostname: "{{parameters.hostname}}"

package/templates/agent/src/app.ts

@@ -1,11 +1,12 @@
 import { join } from 'node:path'
 import { fileURLToPath } from 'node:url'
 import { Context, type Fiber } from '@deepseek-ai/cordis'
+import * as nodeServer from './plugins/acryl-node-server/src/index.ts'
+import * as router from './plugins/acryl-router/src/index.ts'
+import * as state from './plugins/acryl-state/src/index.ts'
 import { agent, memory, model, tools } from './plugins/agent/index.ts'
 import { builder } from './plugins/builder/index.ts'
-import { events } from './plugins/events/index.ts'
 import { extensions } from './plugins/extensions/index.ts'
-import { http } from './plugins/http/index.ts'
 import { type AppInstance, instance } from './plugins/instance/index.ts'
 import {
   blueprintsIn,
@@ -16,7 +17,6 @@ import {
 import { type OpenAIConfig, openai } from './plugins/openai/index.ts'
 import { sandboxPlugin } from './plugins/sandbox/index.ts'
 import { save } from './plugins/save/index.ts'
-import { server } from './plugins/server/index.ts'
 import { tasks } from './plugins/tasks/index.ts'
 import { routes } from './routes.ts'
 
@@ -27,14 +27,14 @@ export const registry = {
   tools,
   memory,
   agent,
-  http,
-  events,
+  'acryl-router': router,
+  'acryl-state': state,
   extensions,
   builder,
   save,
   sandbox: sandboxPlugin,
   routes,
-  server,
+  'acryl-node-server': nodeServer,
 }
 
 /** The manifest next to this app's source. */
@@ -85,12 +85,12 @@ export async function createApp(
       // The `approval` parameter in blend.yaml (the extensions row) turns this source into one that asks.
       extensions: { sources: [{ dir: extensionsDir, trust: 'install' }] },
       builder: { dir: extensionsDir },
-      server: { port: chosen.port.start, scan: chosen.port.scan, hostname: chosen.host },
+      server: { port: chosen.port.start, scan: chosen.port.scan ? 20 : 0, hostname: chosen.host },
     })),
   ]
   return {
     root,
-    url: root.server.url,
+    url: root.nodeServer.url,
     async stop() {
       for (const fiber of [...fibers].reverse()) await fiber.dispose()
     },

package/templates/agent/src/routes.ts

@@ -1,62 +1,53 @@
 import type { Context } from '@deepseek-ai/cordis'
+import { readJson } from './plugins/acryl-router/src/helpers/index.ts'
+import type {} from './plugins/acryl-router/src/index.ts'
 import type {} from './plugins/agent/index.ts'
 import type {} from './plugins/extensions/index.ts'
-import type {} from './plugins/http/index.ts'
 import type {} from './plugins/tasks/index.ts'
 
 export const APP_NAME = '__APP_NAME__'
 
 /**
- * The app's own routes: `POST /ask` for the agent; `GET /extensions` and `GET /tasks` to observe what it did (every run is a durable
- * task owning one task per tool call); `POST /tasks/cancel`. Each route lives in a `ctx.effect`.
+ * The app's own routes on the router: `POST /ask` for the agent; `GET /extensions` and `GET /tasks` to observe what it did (every run is a
+ * durable task owning one task per tool call); `POST /tasks/cancel`. What changes is also streamed: `GET /api/state/tasks/events` and
+ * `GET /api/state/extensions/events`. A route registered from this plugin's context is removed when the plugin is disposed.
  */
 export const routes = {
   name: 'routes',
-  inject: ['http', 'agent', 'extensions', 'tasks'],
+  inject: ['router', 'agent', 'extensions', 'tasks'],
   apply(ctx: Context) {
-    ctx.effect(() => ctx.http.route('GET', '/', () => ({ body: { app: APP_NAME, ok: true } })))
-    ctx.effect(() => ctx.http.route('GET', '/health', () => ({ body: { ok: true } })))
-    ctx.effect(() =>
-      ctx.http.route('GET', '/extensions', () => ({
-        body: {
-          installed: ctx.extensions.list(),
-          notInstalled: ctx.extensions.pending(),
-          waitingForApproval: ctx.extensions.approvals(),
-        },
-      })),
+    const { router } = ctx
+    router.get('/', (c) => c.json({ app: APP_NAME, ok: true }))
+    router.get('/health', (c) => c.json({ ok: true }))
+    router.get('/extensions', (c) =>
+      c.json({
+        installed: ctx.extensions.list(),
+        notInstalled: ctx.extensions.pending(),
+        waitingForApproval: ctx.extensions.approvals(),
+      }),
     )
     // The owner's decision on an install that is waiting (the `approval` parameter in blend.yaml).
     for (const [path, decide] of [
       ['/extensions/approve', (name: string) => ctx.extensions.approve(name)],
       ['/extensions/deny', (name: string) => ctx.extensions.deny(name)],
     ] as const) {
-      ctx.effect(() =>
-        ctx.http.route('POST', path, async ({ body }) => {
-          const name = (body as { name?: unknown } | undefined)?.name
-          if (typeof name !== 'string')
-            return { status: 400, body: { error: 'name must be a string' } }
-          return { body: await decide(name) }
-        }),
-      )
+      router.post(path, async (c) => {
+        const name = ((await readJson(c)) as { name?: unknown } | undefined)?.name
+        if (typeof name !== 'string') return c.json({ error: 'name must be a string' }, 400)
+        return c.json(await decide(name))
+      })
     }
-    ctx.effect(() =>
-      ctx.http.route('GET', '/tasks', () => ({ body: ctx.tasks.list().slice(0, 100) })),
-    )
-    ctx.effect(() =>
-      ctx.http.route('POST', '/tasks/cancel', ({ body }) => {
-        const id = (body as { id?: unknown } | undefined)?.id
-        if (typeof id !== 'string' || !ctx.tasks.get(id))
-          return { status: 404, body: { error: 'no such task' } }
-        return { body: { cancelled: ctx.tasks.cancel(id) } }
-      }),
-    )
-    ctx.effect(() =>
-      ctx.http.route('POST', '/ask', async ({ body }) => {
-        const question = (body as { question?: unknown } | undefined)?.question
-        if (typeof question !== 'string')
-          return { status: 400, body: { error: 'question must be a string' } }
-        return { body: await ctx.agent.run(question) }
-      }),
-    )
+    router.get('/tasks', (c) => c.json(ctx.tasks.list().slice(0, 100)))
+    router.post('/tasks/cancel', async (c) => {
+      const id = ((await readJson(c)) as { id?: unknown } | undefined)?.id
+      if (typeof id !== 'string' || !ctx.tasks.get(id))
+        return c.json({ error: 'no such task' }, 404)
+      return c.json({ cancelled: ctx.tasks.cancel(id) })
+    })
+    router.post('/ask', async (c) => {
+      const question = ((await readJson(c)) as { question?: unknown } | undefined)?.question
+      if (typeof question !== 'string') return c.json({ error: 'question must be a string' }, 400)
+      return c.json(await ctx.agent.run(question))
+    })
   },
 }

package/templates/agent/template.json

@@ -1,9 +1,9 @@
 {
   "plugins": [
     "instance",
-    "http",
-    "events",
-    "server",
+    "acryl-router",
+    "acryl-state",
+    "acryl-node-server",
     "tasks",
     "agent",
     "openai",

package/templates/agent/test/builder.test.ts

@@ -134,51 +134,59 @@ test('the agent builds a sandboxed tool, calls it, and the sandbox refuses a too
   }
 })
 
-test('GET /events streams what happens: the run as a task, and the install as an extension change', async () => {
+test('what happens is streamed from the state cells: the run as a task, and the install as an extension', async () => {
   const project = await mkdtemp(join(tmpdir(), 'events-project-'))
   const chosen = withPort(pinnedInstance(join(project, '.acrylblends'), { root: project }), 0)
   const app = await createApp(chosen)
   const controller = new AbortController()
-  try {
-    const stream = await fetch(`${app.url}/events`, { signal: controller.signal })
+  /** Follow one server-sent stream: its text so far. */
+  const follow = async (path: string) => {
+    const stream = await fetch(`${app.url}${path}`, { signal: controller.signal })
+    assert.equal(stream.status, 200, path)
     const reader = stream.body!.getReader()
     const decoder = new TextDecoder()
-    let text = ''
-    const seen = (what: RegExp) => what.test(text)
+    const seen = { text: '' }
     const pump = (async () => {
       for (;;) {
         const { value, done } = await reader.read()
         if (done) return
-        text += decoder.decode(value, { stream: true })
+        seen.text += decoder.decode(value, { stream: true })
       }
     })().catch(() => undefined)
+    return { seen, pump }
+  }
+  try {
+    const tasksStream = await follow('/api/state/tasks/events')
+    const extensionsStream = await follow('/api/state/extensions/events')
     await fetch(`${app.url}/ask`, {
       method: 'POST',
       headers: { 'content-type': 'application/json' },
       body: JSON.stringify({ question: 'create route hello /hello Hello' }),
     })
+    const arrived = (stream: { text: string }, what: RegExp) => what.test(stream.text)
     for (
       let waited = 0;
-      waited < 3000 && !seen(/event: extensions\/changed\ndata: [^\n]*"installed"/);
+      waited < 3000 && !arrived(extensionsStream.seen, /"name":"hello"[^\n]*"state":"active"/);
       waited += 25
     ) {
       await new Promise((done) => setTimeout(done, 25))
     }
-    assert.ok(seen(/event: connected/), 'connected')
     assert.ok(
-      seen(/event: tasks\/changed\ndata: [^\n]*"kind":"agent-run"[^\n]*"status":"running"/),
-      'the run starts as a task',
+      arrived(tasksStream.seen, /event: value\ndata: \[\]/),
+      'the stream starts with the current value',
     )
     assert.ok(
-      seen(/event: tasks\/changed\ndata: [^\n]*"kind":"tool:install_plugin"/),
-      'the install is a task',
+      arrived(tasksStream.seen, /"kind":"agent-run"[^\n]*"status":"running"/) ||
+        arrived(tasksStream.seen, /"kind":"agent-run"/),
+      'the run is a task',
     )
+    assert.ok(arrived(tasksStream.seen, /"kind":"tool:install_plugin"/), 'the install is a task')
     assert.ok(
-      seen(/event: extensions\/changed\ndata: \{"args":\["hello","installed"\]\}/),
+      arrived(extensionsStream.seen, /"name":"hello"[^\n]*"state":"active"/),
       'the extension is reported',
     )
     controller.abort()
-    await pump
+    await Promise.all([tasksStream.pump, extensionsStream.pump])
   } finally {
     await app.stop()
     await rm(project, { recursive: true, force: true })

package/templates/agent/test/model.test.ts

@@ -11,11 +11,10 @@ import { pinnedInstance, withPort } from '../src/plugins/instance/index.ts'
 /** A plugin no scripted command knows: the model writes it from scratch. */
 const COUNTER = `import type { Context } from '@deepseek-ai/cordis'
 export const name = 'counter'
-export const inject = ['http']
+export const inject = ['router']
 export function apply(ctx: Context) {
   let count = 0
-  const http = ctx.get('http') as { route(m: string, p: string, h: () => { body: unknown }): () => void }
-  ctx.effect(() => http.route('GET', '/count', () => ({ body: { count: ++count } })))
+  ctx.router.get('/count', (c) => c.json({ count: ++count }))
 }
 `
 

package/templates/{app → blank}/blend.yaml

@@ -13,11 +13,11 @@ spec:
     # The address the server listens on.
     hostname: { type: string, default: 127.0.0.1 }
   rows:
-    - id: http
-      name: http
+    - id: router
+      name: acryl-router
     - id: routes
       name: routes
     - id: server
-      name: server
+      name: acryl-node-server
       config:
         hostname: "{{parameters.hostname}}"

package/templates/{app → blank}/src/app.ts

@@ -1,7 +1,8 @@
 import { join } from 'node:path'
 import { fileURLToPath } from 'node:url'
 import { Context, type Fiber } from '@deepseek-ai/cordis'
-import { http } from './plugins/http/index.ts'
+import * as nodeServer from './plugins/acryl-node-server/src/index.ts'
+import * as router from './plugins/acryl-router/src/index.ts'
 import { type AppInstance, instance } from './plugins/instance/index.ts'
 import {
   blueprintsIn,
@@ -9,11 +10,10 @@ import {
   loadManifest,
   type ParameterValue,
 } from './plugins/manifest/index.ts'
-import { server } from './plugins/server/index.ts'
 import { routes } from './routes.ts'
 
 /** The plugins this app's code provides. `blend.yaml` chooses, orders and configures them. */
-export const registry = { http, routes, server }
+export const registry = { 'acryl-router': router, 'acryl-node-server': nodeServer, routes }
 
 /** The manifest next to this app's source. */
 export const MANIFEST = join(fileURLToPath(new URL('..', import.meta.url)), 'blend.yaml')
@@ -48,12 +48,12 @@ export async function createApp(
   const fibers: Fiber[] = [
     first,
     ...(await compose(root, manifest, registry, {
-      server: { port: chosen.port.start, scan: chosen.port.scan },
+      server: { port: chosen.port.start, scan: chosen.port.scan ? 20 : 0 },
     })),
   ]
   return {
     root,
-    url: root.server.url,
+    url: root.nodeServer.url,
     async stop() {
       for (const fiber of [...fibers].reverse()) await fiber.dispose()
     },