experimental-a2 0.13.0 → 0.14.1

package/examples/playground/package.json

@@ -22,7 +22,7 @@
     "@vercel/sandbox": "^3.0.0",
     "ai": "^7.0.58",
     "codemirror": "^6.0.2",
-    "experimental-a2": "0.13.0",
+    "experimental-a2": "0.14.1",
     "ioredis": "^5.9.0",
     "next": "^16.3.0",
     "pg": "^8.16.0",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "experimental-a2",
-  "version": "0.13.0",
+  "version": "0.14.1",
   "description": "Durable sync and reactions for things with a lifecycle: one event log, derived state, and live client per session.",
   "license": "MIT",
   "type": "module",

package/src/ai-client-state.ts

@@ -0,0 +1,185 @@
+import type { UIMessage } from 'ai'
+import type { AIState } from './ai.ts'
+import type { ControlCommand, InboxItem } from './ai-control.ts'
+
+export type QueueCommand<M extends UIMessage> = Extract<
+  ControlCommand<M>,
+  {
+    action:
+      | 'send'
+      | 'edit'
+      | 'move'
+      | 'remove'
+      | 'send-now'
+      | 'steer'
+      | 'pause'
+      | 'resume'
+  }
+>
+export type PendingQueueCommand<M extends UIMessage> = {
+  commandId: string
+  command: QueueCommand<M>
+}
+
+export const isQueueCommand = <M extends UIMessage>(
+  command: ControlCommand<M>,
+): command is QueueCommand<M> =>
+  command.action === 'send' ||
+  command.action === 'edit' ||
+  command.action === 'move' ||
+  command.action === 'remove' ||
+  command.action === 'send-now' ||
+  command.action === 'steer' ||
+  command.action === 'pause' ||
+  command.action === 'resume'
+
+const moveItem = <M extends UIMessage>({
+  items,
+  inputId,
+  beforeId,
+}: {
+  items: InboxItem<M>[]
+  inputId: string
+  beforeId: string | null
+}): InboxItem<M>[] => {
+  const from = items.findIndex((item) => item.id === inputId)
+  if (
+    from < 0 ||
+    inputId === beforeId ||
+    (beforeId !== null && !items.some((item) => item.id === beforeId))
+  )
+    return items
+  const next = [...items]
+  const [item] = next.splice(from, 1)
+  const to =
+    beforeId === null
+      ? next.length
+      : next.findIndex((entry) => entry.id === beforeId)
+  next.splice(to, 0, item!)
+  return next
+}
+
+export function projectAIClientState<M extends UIMessage>(
+  state: AIState<M>,
+): AIState<M> {
+  const pending = state.pendingQueueCommands ?? []
+  if (state.status === 'closed') return state
+  if (
+    pending.length === 0 &&
+    !state.inbox.items.some((item) => item.afterStepOf !== undefined)
+  )
+    return state
+  let messages = state.messages
+  let { items, paused } = state.inbox
+  let turnId = state.active?.turnId ?? null
+  let starting = false
+  let suspended =
+    state.active?.phase === 'paused' || state.active?.phase === 'pausing'
+  let messageIds: Set<string> | undefined
+  const show = (message: M): void => {
+    messageIds ??= new Set(messages.map((item) => item.id))
+    if (messageIds.has(message.id)) return
+    if (messages === state.messages) messages = state.messages.slice()
+    messages.push(message)
+    messageIds.add(message.id)
+  }
+  const admit = (): void => {
+    if (turnId !== null || paused || items.length === 0) return
+    let count = 0
+    for (const item of items) {
+      count += 1
+      show(item.message)
+      if (item.generate) {
+        turnId = item.id
+        starting = true
+        suspended = false
+        break
+      }
+    }
+    if (count > 0) items = items.slice(count)
+  }
+  for (const { command } of pending) {
+    switch (command.action) {
+      case 'send':
+      case 'steer': {
+        if (
+          items.some((item) => item.id === command.message.id) ||
+          turnId === command.message.id
+        )
+          break
+        const item = {
+          ...(command.action === 'steer'
+            ? { afterStepOf: command.turnId }
+            : {}),
+          id: command.message.id,
+          revision: 0,
+          message: command.message,
+          generate:
+            command.message.role === 'user' &&
+            (command.action === 'steer' || command.generate !== false),
+        }
+        items = command.action === 'steer' ? [item, ...items] : [...items, item]
+        break
+      }
+      case 'edit':
+        items = items.map((item) =>
+          item.id === command.message.id &&
+          item.revision === command.expectedRevision &&
+          item.message.role === command.message.role
+            ? { ...item, message: command.message }
+            : item,
+        )
+        break
+      case 'move':
+        items = moveItem({
+          items,
+          inputId: command.inputId,
+          beforeId: command.beforeId,
+        })
+        break
+      case 'remove':
+        items = items.filter((item) => item.id !== command.inputId)
+        break
+      case 'send-now': {
+        if (turnId !== command.turnId) break
+        const selected = items.find((item) => item.id === command.inputId)
+        if (!selected || selected.message.role !== 'user') break
+        items = items.map((item) =>
+          item.id === selected.id
+            ? {
+                ...item,
+                generate: true,
+                ...(turnId === null ? {} : { afterStepOf: turnId }),
+              }
+            : item,
+        )
+        items = moveItem({
+          items,
+          inputId: command.inputId,
+          beforeId: items[0]?.id ?? null,
+        })
+        break
+      }
+      case 'pause':
+        paused = true
+        if (command.when === 'now') suspended = true
+        break
+      case 'resume':
+        paused = false
+        suspended = false
+        break
+    }
+    admit()
+  }
+  items = items.filter((item) => {
+    if (item.afterStepOf === undefined) return true
+    show(item.message)
+    return false
+  })
+  return {
+    ...state,
+    messages,
+    inbox: { items, paused },
+    starting: starting && !suspended,
+  }
+}