experimental-a2 0.12.0 → 0.13.0

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

@@ -1,3 +1,49 @@
 import { agent } from 'experimental-a2/ai'
+import type { ContractEvent } from 'experimental-a2'
+import type { AutomaticCompaction } from 'experimental-a2/ai/server'
+import { z } from 'zod'
 
-export const demoAgent = agent({ name: 'agent' })
+export const agentModel = 'openai/gpt-5.6-luna'
+
+export const compactionSettingsSchema = z.discriminatedUnion('mode', [
+  z.strictObject({ mode: z.literal('automatic') }),
+  z.strictObject({
+    mode: z.literal('manual'),
+    thresholdTokens: z.number().int().min(1).max(Number.MAX_SAFE_INTEGER),
+  }),
+  z.strictObject({ mode: z.literal('disabled') }),
+])
+
+export type CompactionSettings = z.infer<typeof compactionSettingsSchema>
+
+export const demoAgent = agent({
+  name: 'agent',
+  events: { 'compaction.settings.updated': compactionSettingsSchema },
+})
+
+export type AgentEvent = ContractEvent<typeof demoAgent.contract.events>
+
+const automatic: CompactionSettings = { mode: 'automatic' }
+
+export function latestCompactionSettings(history: readonly AgentEvent[]): {
+  settings: CompactionSettings
+  id: string
+} {
+  const event = history.findLast(
+    (candidate) => candidate.type === 'compaction.settings.updated',
+  )
+  return event
+    ? { settings: event.payload, id: event.id }
+    : { settings: automatic, id: 'default' }
+}
+
+export function compactionOptions(
+  history: readonly AgentEvent[],
+): AutomaticCompaction | false {
+  const { settings } = latestCompactionSettings(history)
+  return settings.mode === 'disabled'
+    ? false
+    : settings.mode === 'manual'
+      ? { thresholdTokens: settings.thresholdTokens }
+      : {}
+}

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

@@ -8,7 +8,7 @@ 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'
+import { agentModel, compactionOptions, demoAgent } from './model'
 
 const maxReminderDelaySeconds = 6 * 24 * 60 * 60
 const bashTimeoutMs = 120_000
@@ -131,7 +131,8 @@ export const agentServer = createAgentServer({
   ...(store ? { store } : {}),
   ...(agentScheduler ? { scheduler: agentScheduler } : {}),
   agent: demoAgent,
-  model: 'openai/gpt-5.6-luna',
+  model: agentModel,
+  compaction: ({ history }) => compactionOptions(history),
   tools,
   instructions: `You are an incident-response agent for the playground.
 When responding to an incident, inspect checkout-api before taking action. Its

package/examples/playground/app/globals.css

@@ -1489,6 +1489,160 @@ button.danger {
 
 /* ── durable agent ──────────────────────────────────────────────── */
 
+.agent-compaction {
+  margin: 1rem 0;
+  padding: 0.75rem 1rem;
+  border: 1px solid var(--line);
+  border-radius: 12px;
+  background: var(--surface);
+}
+
+.compaction-marker {
+  display: flex;
+  align-items: center;
+  justify-content: space-between;
+  flex-wrap: wrap;
+  gap: 0.5rem;
+}
+
+.agent-compaction > summary {
+  display: flex;
+  align-items: center;
+  gap: 0.5rem;
+  cursor: pointer;
+  list-style: none;
+}
+
+.agent-compaction > summary::-webkit-details-marker {
+  display: none;
+}
+
+.compaction-chevron {
+  color: var(--muted);
+}
+
+.agent-compaction[open] .compaction-chevron {
+  transform: rotate(90deg);
+}
+
+.agent-compaction > summary > strong {
+  flex: 1;
+  font-size: 0.9rem;
+}
+
+.compaction-controls {
+  margin-top: 0.75rem;
+  padding-top: 0.75rem;
+  border-top: 1px solid var(--line);
+}
+
+.agent-compaction code {
+  overflow-wrap: anywhere;
+}
+
+.compaction-metrics {
+  display: grid;
+  grid-template-columns: repeat(auto-fit, minmax(12rem, 1fr));
+  gap: 0.8rem;
+  margin: 1rem 0;
+}
+
+.compaction-metrics dt {
+  color: var(--muted);
+  font-size: 0.8rem;
+}
+
+.compaction-metrics dd {
+  margin: 0.2rem 0 0;
+  font-weight: 600;
+  font-variant-numeric: tabular-nums;
+}
+
+.compaction-form {
+  margin: 0;
+  padding: 0;
+  border: 0;
+}
+
+.compaction-form fieldset {
+  margin: 0;
+  padding: 0;
+  border: 0;
+}
+
+.compaction-fields {
+  display: grid;
+  grid-template-columns: repeat(auto-fit, minmax(12rem, 1fr));
+  gap: 0.75rem;
+}
+
+.compaction-actions {
+  display: flex;
+  flex-wrap: wrap;
+  gap: 0.5rem;
+  margin-top: 0.75rem;
+}
+
+.compaction-history {
+  margin-top: 1rem;
+  padding-top: 0.75rem;
+  border-top: 1px solid var(--line);
+}
+
+.compaction-history summary {
+  cursor: pointer;
+  font-size: 0.9rem;
+}
+
+.compaction-history ol {
+  padding: 0;
+  list-style: none;
+}
+
+.compaction-history li + li {
+  border-top: 1px solid var(--line);
+  margin-top: 0.75rem;
+  padding-top: 0.75rem;
+}
+
+.compaction-marker {
+  font-size: 0.85rem;
+}
+
+.compaction-marker time {
+  color: var(--muted);
+}
+
+.compaction-history pre,
+.agent-compaction-event pre {
+  white-space: pre-wrap;
+  overflow-wrap: anywhere;
+  max-height: 20rem;
+  overflow: auto;
+}
+
+.agent-compaction-event {
+  padding: 0.65rem 0.85rem;
+  border: 1px dashed var(--line);
+  border-radius: 9px;
+  background: var(--code-bg);
+}
+
+.agent-compaction-event summary {
+  cursor: pointer;
+  font-size: 0.85rem;
+  color: var(--muted);
+}
+
+.agent-compaction-event summary > span {
+  font-weight: 600;
+}
+
+.agent-compaction-event time {
+  display: inline-block;
+  margin-left: 0.75rem;
+}
+
 .agent-conversation {
   display: grid;
   overflow: hidden;

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.12.0",
+    "experimental-a2": "0.13.0",
     "ioredis": "^5.9.0",
     "next": "^16.3.0",
     "pg": "^8.16.0",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "experimental-a2",
-  "version": "0.12.0",
+  "version": "0.13.0",
   "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-model-metadata.ts

@@ -0,0 +1,108 @@
+import type { LanguageModel } from 'ai'
+import type { ModelLimits } from './ai.ts'
+
+const catalogUrl = 'https://ai-gateway.vercel.sh/v1/models'
+const catalogLifetimeMs = 60 * 60 * 1_000
+const catalogTimeoutMs = 5_000
+
+let catalog:
+  | {
+      expiresAt: number
+      promise: Promise<ReadonlyMap<string, ModelLimits>>
+    }
+  | undefined
+
+export const gatewayModelId = (model: LanguageModel): string | undefined => {
+  if (typeof model === 'string') {
+    return globalThis.AI_SDK_DEFAULT_PROVIDER === undefined ? model : undefined
+  }
+  return model.provider === 'gateway' ? model.modelId : undefined
+}
+
+const readCatalog = (): Promise<ReadonlyMap<string, ModelLimits>> => {
+  if (catalog && catalog.expiresAt > Date.now()) return catalog.promise
+  const entry = {
+    expiresAt: Number.POSITIVE_INFINITY,
+    promise: (async () => {
+      const controller = new AbortController()
+      const timeout = setTimeout(
+        () => controller.abort(new Error('model catalog request timed out')),
+        catalogTimeoutMs,
+      )
+      timeout.unref?.()
+      try {
+        const response = await fetch(catalogUrl, { signal: controller.signal })
+        if (!response.ok)
+          throw new Error(
+            `model catalog request failed: HTTP ${response.status}`,
+          )
+        const body: unknown = await response.json()
+        if (
+          typeof body !== 'object' ||
+          body === null ||
+          !('data' in body) ||
+          !Array.isArray(body.data)
+        ) {
+          throw new Error('model catalog response must contain a data array')
+        }
+        const models = new Map<string, ModelLimits>()
+        for (const row of body.data as unknown[]) {
+          if (
+            typeof row !== 'object' ||
+            row === null ||
+            !('type' in row) ||
+            !('id' in row) ||
+            !('context_window' in row) ||
+            !('max_tokens' in row) ||
+            row.type !== 'language' ||
+            typeof row.id !== 'string' ||
+            typeof row.context_window !== 'number' ||
+            typeof row.max_tokens !== 'number' ||
+            !Number.isSafeInteger(row.context_window) ||
+            row.context_window <= 0 ||
+            !Number.isSafeInteger(row.max_tokens) ||
+            row.max_tokens <= 0
+          )
+            continue
+          models.set(row.id, {
+            contextWindow: row.context_window,
+            maxOutputTokens: row.max_tokens,
+          })
+        }
+        return models
+      } finally {
+        clearTimeout(timeout)
+      }
+    })(),
+  }
+  catalog = entry
+  entry.promise = entry.promise.then(
+    (models) => {
+      entry.expiresAt = Date.now() + catalogLifetimeMs
+      return models
+    },
+    (error: unknown) => {
+      if (catalog === entry) catalog = undefined
+      throw error
+    },
+  )
+  return entry.promise
+}
+
+export const readModelLimits = async (options: {
+  modelId: string
+  signal: AbortSignal
+}): Promise<ModelLimits | null> => {
+  options.signal.throwIfAborted()
+  let onAbort!: () => void
+  const aborted = new Promise<never>((_resolve, reject) => {
+    onAbort = () => reject(options.signal.reason)
+    options.signal.addEventListener('abort', onAbort, { once: true })
+  })
+  try {
+    const models = await Promise.race([readCatalog(), aborted])
+    return models.get(options.modelId) ?? null
+  } finally {
+    options.signal.removeEventListener('abort', onAbort)
+  }
+}

package/src/ai-sdk-step.ts

@@ -10,6 +10,7 @@ import type {
   Instructions,
   LanguageModel,
   LanguageModelUsage,
+  ModelMessage,
   TextStreamPart,
   ToolSet,
   UIMessage,
@@ -127,6 +128,7 @@ export type AISDKStepInput<M extends UIMessage, T extends ToolSet> = {
   model: LanguageModel
   tools: T
   messages: M[]
+  modelMessages?: ModelMessage[]
   responseMessageId: string
   abortSignal: AbortSignal
   instructions?: Instructions
@@ -201,7 +203,9 @@ export async function generateAISDKStep<M extends UIMessage, T extends ToolSet>(
 ): Promise<AISDKStepResult<M>> {
   const settings = safeSettings(input.settings)
   const tools = modelToolSet(input.tools)
-  const messages = await convertToModelMessages(input.messages, { tools })
+  const messages =
+    input.modelMessages ??
+    (await convertToModelMessages(input.messages, { tools }))
   const streamOptions = {
     ...settings,
     model: input.model,