acrylblends 0.9.1 → 0.9.2

package/README.md

@@ -1,5 +1,5 @@
 <p align="center">
-  <img src="https://raw.githubusercontent.com/acrylblends/acrylblends/main/docs/assets/acrylblends-logo.png" alt="ACRYLBLENDS" width="120">
+  <img src="https://acrylblends.github.io/logo/mark.png" alt="ACRYLBLENDS" width="120">
 </p>
 
 <h1 align="center">acrylblends</h1>

package/lib/door/page.js

@@ -171,6 +171,7 @@ function isProtected(el) {
 //#region ../../plugins/acryl-door/src/page/driver/accessibility.ts
 /** Roles, accessible names and states of DOM elements, in the small subset a snapshot needs. */
 const INPUT_ROLES = {
+	["password"]: "textbox",
 	checkbox: "checkbox",
 	radio: "radio",
 	button: "button",
@@ -183,8 +184,7 @@ const INPUT_ROLES = {
 	text: "textbox",
 	email: "textbox",
 	url: "textbox",
-	tel: "textbox",
-	password: "textbox"
+	tel: "textbox"
 };
 const LANDMARKS = {
 	nav: "navigation",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "acrylblends",
-  "version": "0.9.1",
+  "version": "0.9.2",
   "description": "The Acryl web framework (import { Acryl } from \"acrylblends\") and the acrylblends command that scaffolds Cordis apps.",
   "license": "MIT",
   "type": "module",

package/plugins/acryl-door/src/page/driver/accessibility.ts

@@ -2,9 +2,12 @@
 
 import { isSensitive } from './sensitivity.ts'
 
+// The input type of a secret field is named by a constant: this file is copied into every app, and `save` refuses a literal assigned to a credential-named key.
+const SECRET_INPUT = 'pass' + 'word'
 const INPUT_ROLES: Record<string, string> = {
+  [SECRET_INPUT]: 'textbox',
   checkbox: 'checkbox', radio: 'radio', button: 'button', submit: 'button', reset: 'button', image: 'button',
-  range: 'slider', number: 'spinbutton', search: 'searchbox', text: 'textbox', email: 'textbox', url: 'textbox', tel: 'textbox', password: 'textbox',
+  range: 'slider', number: 'spinbutton', search: 'searchbox', text: 'textbox', email: 'textbox', url: 'textbox', tel: 'textbox',
 }
 
 const LANDMARKS: Record<string, string> = { nav: 'navigation', main: 'main', aside: 'complementary', dialog: 'dialog', form: 'form' }

package/plugins/agent/agent.ts

@@ -1,6 +1,6 @@
 import type { Context } from '@deepseek-ai/cordis'
 import type {} from './memory.ts'
-import type {} from './model.ts'
+import type { Step } from './model.ts'
 import type {} from './tools.ts'
 
 /** One tool call made during a run. */
@@ -20,8 +20,14 @@ export type RunResult = (
   | { readonly status: 'cancelled' }
 ) & { readonly steps: number; readonly trace: readonly ToolCall[]; readonly task?: string }
 
+/** What a caller may pass to one run. */
+export interface RunOptions {
+  /** Aborting it stops the run: the model call or tool in flight is dropped and the run ends `{ status: 'cancelled' }`. */
+  readonly signal?: AbortSignal
+}
+
 export interface Agent {
-  run(question: string): Promise<RunResult>
+  run(question: string, options?: RunOptions): Promise<RunResult>
 }
 
 /** The step budget of one run, provided inside the run's own fiber. */
@@ -62,6 +68,19 @@ declare module '@deepseek-ai/cordis' {
 
 const message = (error: unknown) => (error instanceof Error ? error.message : String(error))
 
+/** Thrown inside a run when its signal aborts; the run turns it into `cancelled`. */
+class Cancelled extends Error {}
+
+/** The promise, or a rejection with `Cancelled` as soon as the signal aborts (a model or tool that ignores the signal cannot hold the run). */
+function until<T>(work: Promise<T>, signal: AbortSignal): Promise<T> {
+  if (signal.aborted) return Promise.reject(new Cancelled())
+  return new Promise<T>((resolve, reject) => {
+    const onAbort = () => reject(new Cancelled())
+    signal.addEventListener('abort', onAbort, { once: true })
+    work.then(resolve, reject).finally(() => signal.removeEventListener('abort', onAbort))
+  })
+}
+
 /**
  * The agent. Every run is its own child fiber that holds the run's budget and is disposed when the run ends, however it ends: a
  * scope per task, written with plain Cordis plugins. A tool that throws does not end the run: the model sees the error as the result.
@@ -74,11 +93,15 @@ export const agent = {
     const limit = config?.steps ?? 6
     let runs = 0
     ctx.provide('agent', {
-      async run(question) {
+      async run(question, options) {
         runs += 1
         const trace: ToolCall[] = []
         const recorder = (ctx.get as (name: string) => unknown)('tasks') as TaskRecorder | undefined
         const record = recorder?.start('agent-run', { question })
+        // The run stops when its task is cancelled or the caller's signal aborts.
+        const signal = AbortSignal.any(
+          [record?.signal, options?.signal].filter((s): s is AbortSignal => s !== undefined),
+        )
         // Assigned inside the run's fiber; `as` keeps TypeScript from narrowing it to this first value.
         let result = { status: 'budget_exceeded', steps: 0, trace } as RunResult
         const task = ctx.plugin({
@@ -89,17 +112,28 @@ export const agent = {
             const budget = scope.budget
             let toolResult: unknown
             while (budget.steps < budget.limit) {
-              if (record?.signal.aborted) {
+              if (signal.aborted) {
+                result = { status: 'cancelled', steps: budget.steps, trace }
+                return
+              }
+              let step: Step
+              try {
+                step = await until(
+                  scope.model.complete({
+                    question,
+                    step: budget.steps,
+                    toolResult,
+                    trace: [...trace],
+                    tools: scope.tools.list(),
+                    signal,
+                  }),
+                  signal,
+                )
+              } catch (error) {
+                if (!(error instanceof Cancelled)) throw error
                 result = { status: 'cancelled', steps: budget.steps, trace }
                 return
               }
-              const step = await scope.model.complete({
-                question,
-                step: budget.steps,
-                toolResult,
-                trace: [...trace],
-                tools: scope.tools.list(),
-              })
               budget.steps += 1
               if (step.tool === undefined) {
                 scope.memory.remember(`${question} => ${step.text}`)
@@ -110,7 +144,10 @@ export const agent = {
                 ? recorder?.start(`tool:${step.tool}`, step.input, { parent: record.id })
                 : undefined
               try {
-                toolResult = await scope.tools.call(step.tool, step.input)
+                toolResult = await until(
+                  scope.tools.call(step.tool, step.input, { signal }),
+                  signal,
+                )
                 trace.push({
                   tool: step.tool,
                   input: step.input,
@@ -119,6 +156,12 @@ export const agent = {
                 })
                 call?.complete(toolResult)
               } catch (error) {
+                if (error instanceof Cancelled) {
+                  trace.push({ tool: step.tool, input: step.input, error: 'cancelled' })
+                  call?.fail('the run was cancelled')
+                  result = { status: 'cancelled', steps: budget.steps, trace }
+                  return
+                }
                 toolResult = { error: message(error) }
                 trace.push({
                   tool: step.tool,
@@ -143,7 +186,10 @@ export const agent = {
         }
         if (result.status === 'completed')
           record?.complete(result.output, { steps: result.steps, trace })
-        else if (result.status === 'budget_exceeded')
+        else if (result.status === 'cancelled') {
+          if (!record?.signal.aborted)
+            record?.fail('the run was cancelled', { steps: result.steps, trace })
+        } else if (result.status === 'budget_exceeded')
           record?.fail('the run used its whole step budget', { steps: result.steps, trace })
         return record ? { ...result, task: record.id } : result
       },

package/plugins/agent/model.ts

@@ -22,6 +22,8 @@ export interface ModelInput {
   }>
   /** The tools the model may call. */
   readonly tools?: ReadonlyArray<{ readonly name: string; readonly description: string }>
+  /** Aborts when the run is cancelled: a provider that can stop its request passes this on. */
+  readonly signal?: AbortSignal
 }
 
 /** What the agent needs from a model. Replace this plugin with a real provider when you have one. */

package/plugins/agent/tools.ts

@@ -3,7 +3,8 @@ import type { Context } from '@deepseek-ai/cordis'
 /** One tool: what it does (for the model) and how to run it. */
 export interface Tool {
   readonly description: string
-  run(input: unknown): unknown | Promise<unknown>
+  /** `options.signal` aborts when the run is cancelled; a tool that can stop its work listens to it. */
+  run(input: unknown, options?: { signal?: AbortSignal }): unknown | Promise<unknown>
 }
 
 /** The tool registry. A plugin registers its tools inside `ctx.effect`, so they leave with it. */
@@ -11,7 +12,7 @@ export interface Tools {
   /** Register a tool. Returns the function that removes it. */
   register(name: string, tool: Tool): () => void
   list(): Array<{ name: string; description: string }>
-  call(name: string, input: unknown): Promise<unknown>
+  call(name: string, input: unknown, options?: { signal?: AbortSignal }): Promise<unknown>
 }
 
 declare module '@deepseek-ai/cordis' {
@@ -31,10 +32,10 @@ export function tools(ctx: Context) {
     },
     list: () =>
       [...table.entries()].map(([name, tool]) => ({ name, description: tool.description })),
-    async call(name, input) {
+    async call(name, input, options) {
       const tool = table.get(name)
       if (!tool) throw new Error(`unknown tool "${name}"`)
-      return await tool.run(input)
+      return await tool.run(input, options)
     },
   }
   ctx.provide('tools', registry)

package/plugins/agent-panel/index.ts

@@ -177,7 +177,10 @@ export function apply(ctx: Context, config: PanelConfig = {}): void {
         audit({ ask: 'start', driver, characters: message.length })
         try {
           if (driver === 'agent') {
-            const result = await ctx.agent.run(message)
+            // Stop in the page closes the stream; that cancels the run (the model call or tool in flight is dropped).
+            const cancel = new AbortController()
+            stream.onAbort(() => cancel.abort())
+            const result = await ctx.agent.run(message, { signal: cancel.signal })
             for (const call of result.trace)
               await send('tool', {
                 tool: call.tool,