experimental-a2 0.7.0 → 0.8.1

package/examples/playground/app/agent/server.ts

@@ -0,0 +1,153 @@
+import 'server-only'
+import { Buffer } from 'node:buffer'
+import { createHash } from 'node:crypto'
+import { Sandbox } from '@vercel/sandbox'
+import { tool } from 'ai'
+import { handlerContext, inputs } from 'experimental-a2/ai'
+import { createAgentServer } from 'experimental-a2/ai/server'
+import { vercelQueues } from 'experimental-a2/scheduler-vercel'
+import { z } from 'zod'
+import { store } from '@/lib/store'
+import { demoAgent } from './model'
+
+const maxReminderDelaySeconds = 6 * 24 * 60 * 60
+const bashTimeoutMs = 120_000
+const maxBashOutputBytes = 64 * 1024
+
+const sandboxName = (sessionId: string): string =>
+  `a2-playground-agent-${createHash('sha256').update(sessionId).digest('hex').slice(0, 32)}`
+
+const tools = {
+  inspectService: tool({
+    description: 'Inspect the current health and runbook for a service.',
+    inputSchema: z.object({ service: z.string() }),
+    execute: ({ service }) => ({
+      service,
+      errorRate: '12.4%',
+      runbook: 'restart after sustained 10%',
+    }),
+  }),
+  restartService: tool({
+    description: 'Restart every instance of a service.',
+    inputSchema: z.object({ service: z.string() }),
+    execute: ({ service }) => ({
+      service,
+      status: 'restarted',
+      instances: 3,
+    }),
+  }),
+  bash: tool({
+    description:
+      "Execute a Bash command in this session's persistent Vercel Sandbox. Files created by one command are available to later commands in the same session.",
+    inputSchema: z.object({
+      command: z.string().min(1).describe('The Bash command to execute.'),
+    }),
+    execute: async ({ command }) => {
+      const context = handlerContext(demoAgent)
+      const sandbox = await Sandbox.getOrCreate({
+        name: sandboxName(context.session.id),
+        persistent: true,
+        signal: context.signal,
+      })
+      const running = await sandbox.runCommand({
+        cmd: '/bin/bash',
+        args: ['-lc', command],
+        detached: true,
+        signal: context.signal,
+        timeoutMs: bashTimeoutMs,
+      })
+      const logs = running.logs({ signal: context.signal })
+      let stdout = ''
+      let stderr = ''
+      let remainingBytes = maxBashOutputBytes
+      let truncated = false
+      try {
+        for await (const log of logs) {
+          const bytes = Buffer.from(log.data)
+          const retained = bytes.subarray(0, remainingBytes)
+          const text =
+            retained.byteLength === bytes.byteLength
+              ? log.data
+              : new TextDecoder().decode(retained, { stream: true })
+          if (log.stream === 'stdout') stdout += text
+          else stderr += text
+          remainingBytes -= retained.byteLength
+          if (retained.byteLength < bytes.byteLength) {
+            truncated = true
+            break
+          }
+        }
+      } catch (error) {
+        try {
+          await running.kill('SIGKILL')
+        } catch {}
+        throw error
+      } finally {
+        logs.close()
+      }
+      if (truncated) {
+        try {
+          await running.kill('SIGKILL')
+        } catch {}
+      }
+      const result = await running.wait({ signal: context.signal })
+      return { exitCode: result.exitCode, stdout, stderr, truncated }
+    },
+  }),
+  setReminder: tool({
+    description:
+      'Set a reminder for yourself after any delay up to six days. When it is due, it arrives as a new user message.',
+    inputSchema: z.object({
+      delaySeconds: z
+        .number()
+        .int()
+        .min(1)
+        .max(maxReminderDelaySeconds)
+        .describe('Seconds from now, from 1 through 518400'),
+      reminder: z.string().min(1).max(500),
+    }),
+    execute: async ({ delaySeconds, reminder }, { toolCallId }) => {
+      const context = handlerContext(demoAgent)
+      await context.session.schedule(
+        `reminder:${toolCallId}`,
+        { delay: `${delaySeconds}s` },
+        ...inputs.message({
+          id: `reminder:${context.event.id}`,
+          role: 'user',
+          parts: [{ type: 'text', text: `Reminder: ${reminder}` }],
+        }),
+      )
+      return { scheduled: true, delaySeconds, reminder }
+    },
+  }),
+}
+
+export const agentScheduler =
+  process.env.VERCEL || process.env.A2_QUEUES
+    ? vercelQueues({ topic: 'a2-agent' })
+    : undefined
+
+export const agentServer = createAgentServer({
+  ...(store ? { store } : {}),
+  ...(agentScheduler ? { scheduler: agentScheduler } : {}),
+  agent: demoAgent,
+  model: 'openai/gpt-5.6-luna',
+  tools,
+  instructions: `You are an incident-response agent for the playground.
+When responding to an incident, inspect checkout-api before taking action. Its
+runbook says to restart when the error rate remains above 10%. If it does,
+immediately call restartService. Do not ask for approval in prose: that tool
+automatically creates the built-in approval. After the operator responds,
+continue and report the result.
+
+When the operator asks for a reminder, always call setReminder and only say it
+was scheduled after the tool succeeds. A user message beginning with
+"Reminder:" is a reminder that is now due: respond to it, and do not schedule
+it again.
+
+When the operator asks you to run a shell command, call bash. Make one bash call
+at a time and wait for its result before calling it again. Be concise.`,
+  generation: {
+    toolApproval: { restartService: 'user-approval' },
+  },
+})

package/examples/playground/app/agent/session.ts

@@ -0,0 +1,13 @@
+'use client'
+import { createClient } from 'experimental-a2/client'
+import { createReact } from 'experimental-a2/react'
+import { demoAgent } from './model'
+
+export const agentClient = createClient({
+  reducer: demoAgent.reducer,
+  api: '/agent/events',
+})
+
+export const { SessionProvider, useSession } = createReact({
+  client: agentClient,
+})