@cloudflare/think

Minor Changes

• Think's workspace tools are now @cloudflare/computer's createAITools, and exec offers every backend the Workspace has; createWorkspaceTools, workspaceBash, and @cloudflare/think/tools/workspace are removed. See Built-in workspace tools.

• Think's workspace is now a Workspace from @cloudflare/computer, a new peer dependency. See Upgrading to a Computer workspace.

• Think no longer depends on @cloudflare/shell, and the execute tool's state option is removed. See Code Execution Tool.

• deprecated

  createExecuteTool and createExecuteRuntime are deprecated in favour of exec with a ws:tools module. See Calling the agent's tools from code.

Patch Changes

• deprecated

  Chat recovery now seals a turn after chatRecovery.maxInterruptedAttempts interrupted attempts (default 5), so a turn that exceeds the Durable Object memory limit on every run no longer retries forever; maxOomRetries is deprecated. See Stream Recovery.

• Reuse one Intl.DateTimeFormat per timezone when computing wall-clock scheduled task occurrences, cutting the CPU cost of each occurrence substantially. See #2583; thanks @Bowiemb.

Minor Changes

• Require ai@^7 and @ai-sdk/react@^4, because Think bundles providers that return AI SDK v7 models. See Think dependencies.

• breaking

  declared scheduled tasks now run on the root agent only; override getScheduledTasksScope() to return "all" for per-facet scheduling. See Think scheduled tasks.

• Browser chat turns now use the web channel, so its configured tools and turn limit apply. See Think channels.

Patch Changes

• Report a failed agent-tool child as failed even when it was evicted before recording the failure. See Agent tools.

• Fix agent-tool chunks being duplicated or dropped on reconnect, child re-attach, and fiber recovery. See Agent tools.

• Add eventDelivery: "terminal" to runAgentTool to forward only lifecycle, progress, and milestone events for a run. See Agent tools.

• AI Chat and Think send the terminal done frame after persisting and broadcasting the assistant reply, so later sends are not overwritten. See Chat agents.

• Keep a tool call's input when its approval request arrives before the input finishes streaming (#1872). See Human in the loop.

• Fix two Think warnings that fired, or failed to fire, because of a false method-override check. See Think lifecycle hooks.

• Require agents@>=0.25.0 so Think and AI Chat can import the chat helpers provided by that release.

• useAgentChat gains onTurnEnd, and terminal chat frames carry outcomes and user message IDs so clients can settle sends correctly across recovery and reconnects. Replay, tool callbacks, and turn state now remain consistent through terminal delivery; see Chat agents.

• Native RPC calls to async Agent and Think methods now start lifecycle initialization first; address Agents by name because raw IDs from newUniqueId() and idFromString() now fail their first async RPC. See Lifecycle.

• Stop storing compaction summaries that clients echo back, and hide duplicates already stored (#1984). See Sessions.

• Context blocks can set whenChanged: "remind" to send changes as a reminder after the cached prompt instead of rewriting it. See Context.

• Continuation turns that fail before streaming now report an error to clients and onChatResponse instead of appearing to hang (#2381). See Client tools.

• Messenger attachments load when fetchData returns a plain ArrayBuffer. See Messengers.

• Messenger replies now see every message in a quick burst, not just the last one. See Messengers.

• Messenger replies no longer post a ... placeholder on adapters without native streaming. See Messengers.

• A recovered messenger turn delivers its answer to the thread instead of an "interrupted" apology. See Messengers.

• rejectExecution() accepts { autoContinue: false } to record a rejection without starting another turn. See Actions.

• Interfaces can now be used as Props on Agent, AIChatAgent, Think, and routing helpers. See Routing.

• deprecated

  Keep assistant messages and tool outputs attached to the correct turn when a provider reuses a toolCallId; resolveToolMergeId is deprecated in favour of reconcileMessages. See Chat agents.

• useAgentChat keeps messages sent while disconnected when reconnecting, including Think transcripts, instead of erasing them (#1983). See Chat agents.

• Fix text appearing twice when reconnecting during a tool continuation. See Resumable streaming.

• onChatResponse still fires, with recovered: true, for a turn persisted just before a Durable Object reset (#2266, #1842). See Think lifecycle hooks.

• Add session.mirror() to keep an in-memory transcript in sync with a session's change feed. See Sessions.

• Settle approved tool calls that never ran once the conversation moves past them, so later turns don't send unresolved tool calls (#2382). See Human in the loop.

• Think can write server-authored messageMetadata onto assistant messages, per agent or per turn, and recovery preserves metadata even when keys match built-in object properties. See Think lifecycle hooks.

• Recovery continuations extend the interrupted assistant message instead of adding a second one. See Think.

• Resolving a paused execution removes the model's now-stale "waiting for approval" text from the transcript (#2054). See Actions.

• Add getGateway(model) to set AI Gateway options such as metadata and caching for string models (#2262). See Think.

• resolveModel() rejects malformed model ids up front, and @hf/... ids get the same Workers AI settings as @cf/.... See Think.

• Add messengerConcurrency to choose the Chat SDK concurrency strategy for messenger replies (#2313). See Messengers.

• Messenger replies hold the thread lock and retain queued follow-ups during slow delivery; typing updates are serialized and settle before reply text arrives. See Think messengers.

• Fix regenerate continuing the old response instead of replacing it (#2028). See Multi-chat.

• A regeneration interrupted by a restart now recovers on its own branch. See Multi-chat.

• Older-message truncation moves in steps (truncationStep), so the prompt-cache prefix stays stable across turns (#2200). See Think.

• Stream-stall recovery retries stalls before the first chunk and now calls onChatRecovery. See Think lifecycle hooks.

• step.prompt() turns interrupted mid-stream now recover with their structured output instead of failing (#1727). See Workflows.

• Add waitForSubmission() for durable submissions and harden cancellation, status-hook, reset-turn, and paused-tool lifecycle handling so waits settle and terminal status is reported once. See Programmatic submissions.

• telegramMessenger adds a nativeStreaming option and works with verifyWebhook on @chat-adapter/telegram 4.38 (#2397). See Messengers.

• Think hooks and tools can read the running turn identity, and activeChannel stays scoped to its owning turn. See Lifecycle hooks.

• Harden transient chat recovery across Think and AI Chat, including retry budgeting, cancellation, terminal error delivery, and recovery after restarts. See the agents/chat recovery helpers.

• Truncate older tool results after model conversion so toModelOutput and provider-executed tools keep valid outputs (#2014). See Sessions.

• runTurn({ mode: "wait" }) returns the assistant message from its own turn, even if other turns persist in the meantime. See Programmatic submissions.

• Wait-mode TurnResult.output returns the parsed structured output, and submission inspections include the persisted messageId (#2263, #2264). See Programmatic submissions.

Minor Changes

• Add the Queue Lifecycle capability (agents/queue) for durable background work. Each pushed item is a job in the Lifecycle job queue, due immediately, run from the alarm loop one at a time in push order with Lifecycle's retry, deadman, and memory-limit policy. Callbacks are registered in the constructor and typed at declaration and push; push() accepts a stable id (upsert) and per-item retry.

  Agent.queue() and friends now delegate to the capability. Queued callbacks run from the alarm loop in a fresh invocation, so they no longer see the enqueuing request's connection or request through getCurrentAgent() (the agent itself is still available). The cf_agents_queues table and the in-isolate drain are gone; legacy rows migrate into the job queue on the next start. queue() accepts options.id; dequeue, dequeueAll, dequeueAllByCallback, getQueue, and getQueues are now asynchronous; and QueueItem.created_at is renamed createdAt. LifecycleServices.starting() is replaced by status(), which returns "zero" | "starting" | "started".

  Think's workflow-notification outbox and submission drain now run as queue items; the cf_think_workflow_notifications table migrates and is dropped on start.

  Both one-shot migrations (cf_agents_queues in Queue, cf_think_workflow_notifications in Think) are temporary upgrade paths and will be removed in the next minor release, by which point every started object has migrated. Deployments skipping this release should upgrade through it. Workflow-notification delivery retries with backoff capped at ten minutes (previously five) and gives up after twelve hours of continuous failure (previously never), reporting the failure through onError.

Patch Changes

• Require agents >=0.24.0 for Think's background work, which relies on the Queue capability's stable item IDs and alarm-driven execution.

• Recover an interrupted Think turn that had opened its stream but persisted no content by re-running its user message instead of trying to continue it. Think opens the resumable stream row before inference, so a Durable Object reset in the window before the first chunk left a turn with a stream id, no partial, and a user message as the latest leaf; recovery classified it as continue, found no assistant message to continue from, and marked the incident skipped. A parent tailing such a child through agent tools then sealed the run as an error. This mirrors AIChatAgent's empty-partial new-turn rule (#1691).

• Preserve running durable submissions during startup when either a retry or continuation chat-recovery callback is still pending. This applies to both current Tasks recovery attempts and legacy scheduled callbacks, allowing interrupted empty streams to retry and complete after a restart instead of being marked as errors.

  Keep recovery ownership until the successor chat turn is durably accepted, and bind the submission to that successor before handing off. Scope the handoff signal to the successor turn so concurrent turns cannot claim it, including facet-hosted turns after their legacy successor fiber is durably created. New recovery payloads carry stable submission identity; exact submission IDs take precedence over request-ID fallback, preventing collisions from recovering or terminalizing another submission. Record each turn's actual outcome and structured output on the submission row in the same transaction that settles its stream, so a restart between turn completion and ledger settlement records the completed, aborted, or errored outcome from recorded fact instead of inferring from stream state — without rerunning the turn or duplicating response callbacks: aborted turns stay aborted, recovered workflow completions keep their output, an overflow retry segment is never mistaken for an answer, and the recorded fact survives unrelated turns reclaiming stream rows.

Minor Changes

• Replatform Think conversation storage onto agents/sessions and prompt context onto agents/context.

  Existing subclasses keep compiling and running. configureSession(session) still accepts the withContext() / withCachedPrompt() chain, this.session still carries addContext, getContextBlock, replaceContextBlock, refreshSystemPrompt, freezeSystemPrompt, tools(), and the rest, and appendMessage(message, parentId) / getHistory(leafId) still take their positional arguments. Those context methods are deprecated forwards to the new this.context; new code should declare blocks in configureContext() and read this.context directly. withCachedPrompt() is a no-op because the frozen prompt is always persisted now.

  What you may want to change

  • Declare prompt blocks with the new configureContext() hook instead of withContext(). Blocks from both are merged, configureContext() first.

  • Read context through this.context (a ContextBlocks from agents/context) instead of this.session.

  • Import Session from @cloudflare/think when you annotate a configureSession override. The class exported from agents/sessions is the raw storage handle and is not assignable to Think's.

  Behaviour changes on upgrade

  • Storage migrates on first wake and cannot be rolled back. Each Durable Object lifts its assistant_messages, assistant_compactions, and assistant_config rows into the cf_agents_session_* tables, verifies every row landed, and drops the old tables. An object that has woken on this version has an empty conversation if you roll back to the previous release; rolling forward again is safe. Deploy behind a canary if you need a rollback path.

  • hydrationByteBudget defaults to 32 MiB (was 24 MiB) and is now a hard ceiling that charges each row its full stored size, attachments included. There is no message-count floor, so an unusually large recent window can hydrate fewer than four messages. getHistory() still reads the full path.

  • Context blocks load during onStart, as before the replatform, so this.context.getBlock() answers as soon as the object has started.

  • session.search() still works. Its index is now built by the first search on an object rather than maintained on every append, so a Think that never searches stops paying a second billed row per message.

  • Think no longer reads Sessions tables with raw SQL. If you queried assistant_messages yourself, use this.session.history() or getHistory().

  Removed

  • sessionAttachments. There is nothing to configure about how Sessions stores a message: media leaves the row into a content-addressed attachment store and a message larger than one SQLite row is split across continuation rows, losslessly.

  • getRecentHistory(budget, minRecentMessages): the second argument is accepted and ignored.

  • compactAfter(threshold, { tokenCounter }): the counter option is accepted and ignored; the trigger reads the estimate Sessions stamps on each row.

• Lifecycle owns a durable job queue, driven as an alarm event loop.

  The thing in the queue is a job: a serialisable callback address — the
  owning capability plus a function name — with a due time and a payload.
  Capabilities and the host push jobs through the scoped jobs surface;
  Lifecycle drives due jobs in timestamp order when the alarm fires, owns
  dispatch retries and platform-failure deferral, arms a deadman pre-alarm
  before driving so an isolate death mid-drive still wakes the object, and
  derives the physical alarm purely from queue state (queue mutations re-arm
  automatically; an exclusive job suppresses ordinary candidates).

  class Cleanup extends LifecycleCapability {
    async scheduleSweep(time: number) {
      await this.lifecycle.jobs.push({ id: "sweep", fn: "sweep", time });
    }
    onJob({ job }: LifecycleJobContext) {
      // drive result: nothing = complete, { rescheduleAt } = suspend,
      // "yield" = leave due and wake again immediately
    }
  }

  The pull-based alarm-contribution model is removed: capability
  getNextAlarm()/onAlarm(), host getNextAlarm(),
  LifecycleServices.alarms (rearm/disabled), and AlarmContribution
  are gone. Host onAlarm() remains and runs once per alarm invocation
  after due jobs are driven. Terminal application failures reach the
  owner's onJobError(), whose drive result decides advancement.

  The alarm memory-limit circuit breaker (#1825) moves from Agent.alarm()
  into the Lifecycle event loop, targeting the exact executing job; Agent
  contributes domain policy through the new onAlarmMemoryLimit() host
  hook, and Scheduler's __DO_NOT_USE_WILL_BREAK__handleAlarmMemoryLimit
  escape hatch is gone. After recording a strike the breaker now finishes by
  resetting the isolate with ctx.abort(reason, { retryAlarm: false })
  (retry of the handled alarm suppressed; the backoff alarm owns the next
  wake), and Agent.destroy() uses the same no-retry abort so a completed
  teardown's alarm cannot be retried into a fresh constructor that recreates
  the deleted schema.

  Scheduler keeps its entire public API and loses its storage and due-row
  loop: a schedule is one job whose fn is the callback name, and interval
  schedules are single-flight jobs. Existing cf_agents_schedules rows are
  migrated into the cf_agents_jobs queue on startup and the legacy table
  is dropped. Agent's public scheduling and keepAlive() APIs are
  unchanged; its keep-alive, fiber-recovery/facet housekeeping, and
  deferred-destroy wakes are now host jobs, and Think's
  workflow-notification wake replaces the removed _getExtensionAlarm().

• Keep media eviction a context-window technique, separate from how Sessions stores a message.

  How Sessions lays a message out in rows is invisible and lossless: a message too large for one row is split across continuation rows and reassembled byte for byte. Media eviction is a decision about the model's context: once media has aged past mediaEviction.keepRecentMessages on the active path, Think removes it from the conversation so the model stops re-reading a large image every turn, and leaves [evicted image/png, 812004 bytes; preserved at /attachments/evicted/<messageId>-<n>.png] in its place. The raw bytes are written to the Workspace at that path with their real mime type, so the workspace read tool puts the actual image back in context when the agent deliberately reads it. The rewritten message no longer carries the payload, so the bytes live in exactly one place.

  mediaEviction: false now means the model keeps seeing aged media. It no longer changes where Sessions keeps the bytes.

  minPartBytes is Think's context threshold and is no longer passed to Sessions as a storage setting. The marker text and the /attachments/evicted/<id>-<n>.<ext> paths are unchanged, so old markers keep resolving.

  MediaEvictionConfig.externalizeToWorkspace is deprecated and ignored: evicted bytes are always preserved. Existing configurations keep compiling.

  WorkspaceLike.writeFileBytes is optional. Eviction and skills projection need it to write raw bytes; a custom workspace without it keeps working and those two features log once and stand down.

• streams: rollover block log and an atomic stream → message cutover; no more stream-buffer sweeps.

  The Streams chunk log is now mutable rollover blocks: an append grows the open block row (an UPDATE) until it reaches 256 KB, then opens the next. Same one billed row per append as before, but a stream of thousands of chunks is a handful of rows to delete instead of thousands. Existing cf_agents_stream_chunks rows are folded into blocks lazily, one stream at a time on first touch, so startup never reads the whole legacy log; the table is dropped once it is empty.

  writer.close({ commit, discard }) (and error(reason, { … })) settles the stream, runs the caller's synchronous writes and deletes the stream's rows in one SQLite transaction. Session.__DO_NOT_USE_WILL_BREAK__sync().upsert() is the matching synchronous message write; its after() dispatches the change feed and auto-compaction once the transaction commits.

  Chat hosts (AIChatAgent, Think) now persist the finished turn's assistant message inside that cutover: the message, the stream's settlement and the deletion of its temporary rows commit together, so a crash leaves either the live stream (recovery rebuilds the message from it) or the message, never neither. ResumableStream.start() reclaims anything a crash left behind. The _cleanupStreamBuffers alarm is no longer armed (cleanupStreamBuffers and STREAM_CLEANUP_DELAY_SECONDS are removed from agents/chat; the host callback is kept as a no-op so alarms persisted by earlier versions still resolve).

Patch Changes

• Run root-agent chat recovery continuations as chained Tasks instead of schedule rows. Initial recovery attempts deduplicate by incident, delayed retries use durable Task sleeps, and platform failures replay through Task claims. AI Chat and Think share one reserved recovery definition and preserve their existing bounded callback handoff behavior: a failure before handoff stays with the current queue execution, while a detached post-handoff platform failure enqueues exactly one replacement.

  Tasks now propagate condemned-isolate failures out of journaled steps and apply alarm memory-limit backoff and sealing to the run whose wake struck — claim stripped and deadline pushed, so startup reconciliation cannot resurrect it and the reclaim still sees an interrupted attempt. Task wake jobs are pushed with a single dispatch attempt so a platform failure rejects the alarm instead of being retried into a silent reschedule of the still-claimed run. Lifecycle gains trackAlarmWork(): work a job hands off at a bounded return stays inside that alarm's memory-limit breaker domain after the alarm returns, so other jobs stay live while a memory reset from the handoff still records a strike — one strike per reset however many flows observe it — and strikes clear only once no handed-off work is outstanding and the last of it settled clean. retain: false now removes failed and cancelled runs as well as completed runs, releasing journals and idempotency keys after every terminal outcome. Routed dynamic agents temporarily retain the root-owned schedule transport until Tasks supports routed child wakes.

  AI Chat and Think require agents >=0.23.0, the pending release batch containing the shared recovery Task definition and internal enqueue support.

• Replatform chat's resumable streams onto the agents/streams capability.

  ResumableStream is now a thin adapter over Streams: chat's in-flight turn output lives in the shared durable chunk log (cf_agents_streams / cf_agents_stream_chunks), packed ~10 wire chunks per stored segment for write economy, with completion/error mapped onto stream settlement and retention keyed off the stream row's updated_at (sweeps no longer scan the chunk table). Existing cf_ai_chat_stream_* tables migrate wholesale — including an in-flight stream — on first construction after upgrade, then are dropped. AIChatAgent and Think expose the backing capability as readonly streams, so any streams.read() consumer on the same Durable Object can observe chat streams. The chat wire protocol, replay handshake, and recovery behavior are unchanged.

• chat: derive the recovery forward-progress marker from the stream log instead of bumping a KV counter per credited chunk. ResumableStream.progressMarker() counts durably flushed segments — live streams from their log tails, deleted streams from a retired total folded in as their rows are removed — so the marker stays monotonic across cutover and reclaim, never moves on a reconnect replay or a recovery re-persist, and ignores compaction. A parent forwarding a sub-agent's output credits it explicitly through creditProgress(). Nothing is written per chunk any more; one row is written per stream retired. The old KV counter is read once per isolate and seeded into the marker so an in-flight incident never sees it drop, and the hosts mirror the marker's durable part back to that key per stream retired, so a rollback reads no lower either. The Streams sync aperture gains an onDelete hook so a chat row deleted through the public capability is retired like any other. AIChatAgent now flushes a settled tool result to SQLite the moment it is stored, as Think already did, so it is durable before the next packed flush and counts as progress immediately. The work budget's unit is now the durable segment, and DEFAULT_CHAT_RECOVERY_MAX_WORK moves from 1000 to 10000 to stay as generous as before for delta-heavy turns. Two cutover fixes ride along: a Think agent-tool child now keeps its stream rows for the parent to tail after completion, as ai-chat already did, and the Streams capability re-derives its legacy-table flag after a rolled-back cutover.

• think: stop re-reading the transcript during a turn. A tool update (client result, approval, cross-message result, execution outcome) used to read the whole persisted history to find its one target message; it now resolves the owner from the in-flight accumulator and the live cache and reads that row alone, walking storage newest-first only when the cache does not cover the active path. A chat request no longer reads the path twice and upserts every echoed message: the cache is the server transcript, unchanged messages are skipped before Sessions sees them, and only what changed is written. The cache re-windows itself once appends carry it past hydrationByteBudget, and marks itself stale on Sessions import and compaction events. Media eviction is scheduled from an in-memory check on each linear append instead of a stored-path scan after every cache refresh, think_config rewrites of an unchanged request body or client-tool schemas are skipped, and the agent-tool child-run DDL runs once per isolate.

• Make the alarm memory-limit circuit breaker (#1825) a self-contained
  Lifecycle concern instead of an Agent-mediated one.

  Recovery-loop membership is now a property of the job row
  (LifecycleJobPushOptions.recoveryLoop): flagged jobs are backed off by
  the breaker on a strike and purged when it seals at the strike budget,
  without disturbing unrelated rows — a recovery schedule can no longer
  silently escape the breaker. The public ScheduleOptions vocabulary is
  unchanged: schedules only shape future work, and chat recovery reaches the
  flag through internal scaffolding (RecoveryLoopScheduleOptions) retained
  only for legacy rows and routed dynamic agents. Root recovery moves to Tasks;
  the scaffolding can be deleted when Tasks supports routed child wakes.
  Capabilities can react to a strike through the new optional onMemoryLimit
  hook, hosts through onAlarmMemoryLimit, and the context identifies the job
  that was executing when one exists. The strike budget is real Lifecycle
  configuration (Lifecycle.install(host, { maxAlarmMemoryLimitStrikes }))
  rather than a composition-root side channel. Until Tasks supports routed
  child wakes, a sealed recovery schedule also forwards the seal to its owning
  dynamic agent so a chat child under a plain Agent root persists its exhausted
  incident and terminal notification.

  Removed accordingly: Agent.onAlarmMemoryLimit's policy relay, the
  _cf_recoveryAlarmCallbacks template hook, Scheduler.applyMemoryLimitPolicy,
  and
  setLifecycleAlarmMemoryLimitStrikes. AIChatAgent and Think flag their
  routed recovery fallback via chatRecoverySchedulePolicy and seal in-flight
  incidents from their own protected onAlarmMemoryLimit hooks; both now
  require agents >= 0.23.0 from the pending release batch (they consume its
  new agents/chat recovery exports and no longer implement the old
  template-method breaker hooks). Agent retains a
  sealed-only call to _cf_sealMemoryLimitedRecovery so already-published chat
  packages whose peer ranges accept agents 0.23 keep terminal notifications;
  that fallback carries no callback-name or queue policy.

• Pass proactively compacted messages to beforeStep so hooks that append context do not restore the original history. Explicit message overrides still take precedence.

Minor Changes

• Remove the convention-driven Think framework, including the Vite plugin, generated Worker entry and virtual modules, CLI, Studio, framework helpers, and server-entry helpers. Remove the separate create-think scaffolder and its starter templates. Think remains available as an explicit runtime for hand-written Worker entries.

  Migration for existing framework users

  If you only use the Think runtime, React integration, messengers, workflows, extensions, or tools, no migration is required.

  Existing use	Required change
  @cloudflare/think/vite	Use agents/vite for decorators and agents:skills, alongside @cloudflare/vite-plugin.
  virtual:think/entry	Add a real Worker entry, such as src/server.ts, that explicitly exports each Think class.
  Generated bindings, migrations, and routing	Declare top-level Durable Object bindings and migrations in wrangler.jsonc; route with routeAgentRequest() and, for custom sub-agent routing, routeSubAgentRequest().
  @cloudflare/think/framework	Move generated configuration and class exports into application code.
  @cloudflare/think/server-entry	Use Agents SDK routing helpers and application-owned request handlers.
  think types	Use wrangler types.
  think init or create-think	Use npx create-cloudflare@latest --template cloudflare/agents-starter, or manually configure a Think Worker.
  think studio, think state, or think inspect	No direct replacement.

  Existing deployments must preserve generated ThinkAgent_* and ThinkSubAgent_* constructor names and existing migration history. Sub-agent registries use Class.name, so export aliases alone do not preserve compatibility. If renaming classes, use a data-preserving Durable Object rename migration.

• Preserve spacing between streamed text segments separated by tool calls. Think messenger delivery and Voice now share the same boundary-aware text joining logic from agents/chat.

  Existing users must:

  • Replace imports of textDeltaFromStreamChunk() from @cloudflare/think/messengers with TextStreamCallback, passing it the complete structured stream events.

  • Upgrade to agents@0.21.0 when installing @cloudflare/think@0.16.0 or @cloudflare/voice@0.3.6; both now require agents >=0.20.2.

  • Update exact-text expectations if they relied on segments around tool calls being concatenated without a space.

Patch Changes

• Emit workspace image reads as image-data model content so AI SDK v6 routes them as images, while preserving file-data output for PDFs.

  Existing consumers that inspect raw workspace tool content must handle image-data for images; PDFs continue to use file-data. Normal tool callers require no change.

• Treat useAgentChat observer error frames as terminal responses.

  Plain-text error bodies are no longer parsed as stream chunks or merged into an empty assistant message. Error frames now clear observer streaming, replay, recovery, and tool-continuation state even when they omit done, matching the transport-owned stream behavior.

  Existing observer UIs that displayed error bodies as assistant messages must move those diagnostics to a dedicated error surface.

• Update PartyServer and the Cloudflare Workers development toolchain for @cloudflare/workers-types v5 compatibility. New Think projects now use Workers Types v5 with matching Wrangler and Vite plugin versions.

• Expose TurnConfig.repairToolCall so callers can repair malformed tool calls before tool execution.