Packages

@flue/runtime

2.3.1 · 18 Nov 2026Apache-2.0524.4k / weekRepositoryHomepagenpmAtom feed

Your version

31 stable releases, newest first, by release line. Notes are quoted as the maintainers published them.

  1. 2.x · latest line
  2. 2.3.1

    18 Nov 2026
    • Updated @earendil-works/pi-ai and @earendil-works/pi-agent-core to 1.5.2, fixing builds that picked up pi-ai 1.5. @flue/runtime 2.3.0 imported TypeBox through @earendil-works/pi-ai, which stopped re-exporting it in 1.5.0, so a fresh install failed vite build. Flue now depends on typebox directly and requires pi ^1.5.0; remove any overrides that held pi at 1.4. If your own code imports Type or Static from @earendil-works/pi-ai, import them from typebox instead. Pi now validates tool arguments with its own JSON Schema validator, which coerces a little more (for example "3" for a number) and words its validation errors differently. OpenAI-compatible requests with no tools no longer send "tools":; set compat.requiresToolsWithToolHistory: true on models behind proxies that require it, such as older LiteLLM versions in front of Anthropic.

    • Workers AI binding models on the Responses API declare tools the way pi's own OpenAI provider does. Since pi 1.4, the binding passed a boolean where pi expected a tool-support mode, so a model without deferred tool loading could leave tools added mid-conversation out of its request. Models that support mid-conversation tool additions now declare every tool through additional_tools input items.

  3. 2.3.0

    12 Oct 2026
    • Updated @earendil-works/pi-ai and @earendil-works/pi-agent-core to 1.1.0. New models resolve with no configuration, including Claude Sonnet 5.5 (anthropic/claude-sonnet-5-5), Claude Haiku 5.5 (anthropic/claude-haiku-5-5), and GPT-6.1 Sol (openai/gpt-6.1-sol). Azure users must update: Pi renamed the Azure provider from azure-openai-responses to azure, so change azure-openai-responses/... model specifiers and providers config entries to azure. The AZURE_OPENAI_* environment variables are unchanged. Tool and turn durationMs values now come from Pi's monotonic timing, so a tool's duration covers only its execution, not Flue's hooks or result storage.

    • useAgentFinish callbacks once again see state written during the response. Since 2.2.0, finish hooks ran against the agent render from before the response's final turn, so a durable guard set by a finish callback — the documented usePersistentState pattern for appending a reminder once — was never observed: the callback re-appended on every cycle until the response failed at the runaway-loop ceiling. The agent now re-renders before each finish-hook cycle (#818).

    • read_skill_resource accepts a packaged skill path without its leading /. Models often echo the advertised /.flue/packaged-skills/... path without the slash, and the read failed as not found (#781).

  4. 2.2.2

    28 Sep 2026
    • Fix Claude models on the cloudflare-ai-gateway provider failing with 404 not_found_error: model: claude-sonnet-4.6 was not found. Since Pi 0.84.3 the gateway catalog lists Claude models with dotted versions (claude-sonnet-4.6), but the gateway's native Anthropic endpoint forwards the model ID to Anthropic, which only accepts dashed IDs. Flue now registers these models under Anthropic's IDs (cloudflare-ai-gateway/claude-sonnet-4-6); dotted specifiers still resolve to them. The cloudflare binding provider, which uses Cloudflare's dotted catalog names, is unchanged.

  5. 2.2.1

    28 Sep 2026
    • Fix model specifiers that stopped resolving after the Pi 0.87.1 upgrade. Pi renamed the cloudflare-ai-gateway Claude model IDs from dashed versions to dotted versions (claude-sonnet-4-6 → claude-sonnet-4.6), so existing specifiers such as cloudflare-ai-gateway/claude-sonnet-4-6 failed with Unknown model ID. When a model ID isn't in the catalog but matches exactly one catalog ID that differs only in - versus . between version digits, Flue now resolves to that model and logs a one-time warning suggesting the current ID.

  6. 2.2.0

    28 Sep 2026
    • Add bounded conversation history reads so long-running chats no longer transfer the whole transcript on every page load or reconnect.

      Unbounded reads are unchanged. @flue/react still observes the whole conversation.

    • Support document attachments (PDFs) on user messages. DeliveredAttachment is now a union of image and document attachments — { type: 'document', data, mimeType: 'application/pdf', filename? } — accepted on dispatch(), the init() handle, and direct HTTP prompts. session.prompt(), skill(), and task() gain a documents option alongside images, and @flue/react's sendMessage() gains a documents option. Documents are forwarded to the model as native document content: Anthropic document blocks, OpenAI (and Azure OpenAI) Responses input_file parts, and Google inlineData. On other model APIs the document is replaced in model context with a text placeholder saying it was omitted. Documents are stored like images — as canonical attachments projected as file parts with mediaType: 'application/pdf' — so existing conversations and persistence adapters need no migration. The SDK also exports DeliveredImageAttachment and DeliveredDocumentAttachment.

    • Conversation messages now carry a server-authored timestamp (ISO 8601 capture time of the underlying durable record) in history(), observe(), and useFlueAgent. It works for every role and for existing conversations. metadata remains entirely agent-authored. Conversation settlements carry the same timestamp for when the submission settled.

  7. 2.1.1

    23 Sep 2026
    • Clarify that a skill's allowed-tools field is guidance. Flue accepts it for Agent Skills spec compatibility and does not enforce it; enforce authorization in your own tools and approval gates.

    • Make trace content truncation scale linearly for long message arrays. Large traced conversations no longer repeatedly serialize the remaining history while fitting gen_ai.input.messages to the attribute budget, avoiding request latency and Cloudflare Durable Object CPU-limit resets.

    • Record tool arguments and results of every payload shape on the standard gen_ai.tool.call.arguments / gen_ai.tool.call.result attributes, so OTel backends can display them. The shape-based diversion to the vendor flue.tool.call.* fallback keys is removed — those keys are no longer emitted, and their constants are retained for source compatibility. Payloads record exactly as before: objects/arrays as JSON strings, strings byte-for-byte within the content budget, other scalars as their JSON form.

  8. 2.1.0

    18 Sep 2026
    • Trace content budgets are now configurable. createCloudflareTracing({ contentBudgetBytes }) and createOpenTelemetryInstrumentation({ contentBudgetBytes }) override the default 56 KiB per-span content pool — raise it (e.g. contentBudgetBytes: 200_000) to ship fuller prompts and tool results to an observability backend that isn't bound by workerd's 64 KiB span-attribute cap, or tighten it. The 128-byte sentinel floor and the shared-pool semantics are unchanged.

    • Tools returned by createMcpConnection() now retain the metadata sent by the MCP server in its tools/list response. The metadata is available on each Flue tool as tool.annotations:

      const connection = await createMcpConnection(definition);
      const deleteIssue = connection.tools.find((tool) => tool.name.endsWith('delete_issue'));
      
      console.log(deleteIssue?.annotations?.destructiveHint); // true

      defineTool() and useTool() also accept annotations, so wrappers can carry the metadata forward. Flue does not automatically change a tool's behavior based on these server-supplied values.

    • Tools can now declare a timeoutMs execution bound: on expiry the harness aborts the tool's context.signal and settles the call with a ToolTimeoutError (the model sees Tool "<name>" timed out after <ms>ms and the conversation continues) instead of letting one hung call consume the submission's durability budget.

      import { defineTool } from '@flue/runtime';
      import * as v from 'valibot';
      
      export const lookupCatalog = defineTool({
        name: 'lookup_catalog',
        description: 'Query the upstream catalog API.',
        input: v.object({ sku: v.string() }),
        timeoutMs: 15_000,
        async run({ data, signal }) {
          // If this call exceeds 15s, `signal` aborts, the call settles with a
          // ToolTimeoutError the model sees, and the conversation continues —
          // the model can retry or change approach.
          const response = await fetch(`https://catalog.example.com/${data.sku}`, { signal });
          return { output: await response.json() };
        },
      });
  9. 2.0.8

    16 Sep 2026
    • Interrupted submissions no longer retry forever when the recovery render throws: once the submission's durability deadline passes, a submission whose classification render keeps failing is settled as timed out instead of being re-rendered on every supervisor wake without ever consuming an attempt.

    • The Cloudflare binding's Anthropic gateway path now maps the agent's thinkingLevel to an adaptive-thinking effort (output_config.effort), so useModel thinking levels take effect on adaptive-thinking models instead of always running at Anthropic's default.

    • The Cloudflare binding provider now accepts a cacheRetention option ('short' or 'long') to enable Anthropic prompt caching for anthropic/… gateway models — repeated prefixes are served from cache at the cached input rate instead of paying full input price every turn. Default 'none' keeps the previous behavior.

  10. 2.0.7

    15 Sep 2026
    • Fix Cloudflare sandbox directory listings collapsing into a single entry — readdir results are now correctly separated.

    • Cloudflare traces now carry submission, operation, and turn identifiers on agent, task, model, tool, and shell spans, so trace fragments can be correlated across durable invocations.

    • Telemetry now marks model requests whose context includes a compaction summary, so compacted turns are distinguishable from ordinary ones.

  11. 2.0.6

    14 Sep 2026
    • Published packages once again include the bundled Flue documentation. The 2.0.4 and 2.0.5 releases omitted the generated docs/ directories from @flue/cli, @flue/runtime, and @flue/sdk, causing commands such as flue docs read guide/sandboxes to fail.

  12. 2.0.5

    11 Sep 2026
    • Published packages once again resolve internal Flue dependencies to the release version. The 2.0.4 release accidentally shipped raw pnpm workspace: dependency specifiers, making affected packages impossible to install outside the workspace. The complete lockstep package set is republished as 2.0.5 through pnpm so every internal dependency resolves to 2.0.5 (#657).

  13. 2.0.4

    9 Sep 2026
    • "Connection error." is now classified as a retryable model error. The retryable-error matcher recognized connection reset/connection refused/connection lost but not a bare connection error — a transient "Connection error." (with its trailing period) fell through the pattern and terminated the submission as a hard failure. The matcher now also accepts connection error and the run retries it under the transient-error budget (#629).

  14. 2.0.3

    5 Aug 2026
    • The Cloudflare Agents SDK (agents) is now a dependency of @flue/vite — projects no longer declare it. The generated Worker entry is the only code that imports the SDK, so the package that generates it ships it, and every project runs the SDK version Flue was tested against instead of whatever a scaffolded range resolves to on install day; flue init --target cloudflare stops writing the dependency, and existing projects can delete theirs. A project that declares its own agents dependency still wins — the plugin only falls back to its bundled copy when the project's node_modules chain has none. This also unbreaks fresh installs, which failed on an ai peer conflict internal to agents@0.14.5, the newest version the scaffolded ^0.14.2 range had come to resolve (reported by Ben Buzbee). The scaffolded wrangler range moves to ^4.113.0.

  15. 2.0.2

    4 Aug 2026
    • Conditional tool additions are now cache-safe on models with deferred tool loading. A tool mounted by the rerender that follows a settled tool batch is anchored to that batch's final tool result, so current first-party Anthropic models (Claude 4.5 and later, excluding Haiku) keep the added definition out of the cached prompt prefix instead of invalidating it; other providers ignore the anchor and their requests are unchanged. The anchor persists with the run and is restored on rehydration, so a rehydrated context matches the live loop exactly (the internal reduced-state format counter bumps to 2). The Tools guide now states the actual cache contract: tool-set changes rewrite the native tools array and invalidate the provider prompt cache, except additions unlocked by a completed tool call on the models above (#545).

    • The cloudflare-shell blueprint is replaced by cloudflare-computer, built on @cloudflare/computer — the successor to @cloudflare/shell that hosts a durable SQLite-backed workspace in the agent's own Durable Object with a just-bash shell backend, and can escalate to a container backend where a JavaScript shell isn't enough. The adapter provides a real exec() and keeps the framework's standard tool set instead of substituting a code tool. flue add cloudflare-shell and the old docs URLs redirect to the successor.

    • Cloudflare trace spans whose terminal event never arrives (their operation orphaned by deadline force-settlement or recovery) are force-closed when the submission settles, so the run's invoke_agent root span no longer vanishes from the trace. Forced closes carry a flue.span.forced_close attribute, and span-close failures are reported instead of swallowed.

  16. 2.0.1

    1 Aug 2026
    • Reasoning effort sent through the Workers AI binding's Responses wire format is now clamped to the /run endpoint's none|low|medium|high ceiling. A gateway model whose catalog maps the xhigh/max thinking levels verbatim (for example openai/gpt-5.6-luna) previously hard-400ed after admission for a thinking level Flue itself accepts — those catalog mappings are written for the model's own API, which does accept them over the HTTP gateway path; the ceiling is the binding transport's, and the chat-completions path already applied it. The emitted effort now always comes from the catalog's own low/medium/high mappings (#544).

    • A durable submission can no longer sit unsettled forever behind a hung await. On Cloudflare the wake handler previously both executed and supervised — it awaited every attempt, so one stalled model stream or sandbox RPC wedged the only loop that evaluates durability timeouts, and a backstop alarm firing mid-drain was silently consumed without re-arming. The coordinator now separates the roles: supervisor passes run bounded and storage-only (arming their successor heartbeat before any failable work, so no pass failure breaks the wake chain), and attempt fibers run detached, settling their own submissions. Deadline enforcement is structural on both targets: each pass fires the attempt's abort controller at timeoutAt (or on an unhonored durable abort) so signal-aware awaits unwind through the normal settle paths, and once the first signal outlives a 60-second grace the pass force-settles the submission over the hung fiber, orphaning it — the Node coordinator gets the same sweep from its lease scan, whose expired-lease branch was previously unreachable while a live process renewed a hung attempt's lease forever. A new FlueEvent operation, enforce_deadline, marks the signaled grace window and the force; the per-drain attempt cap is retired as vestigial (#538).

    • The awaits that could stall an attempt now bound themselves, so a stall recovers in seconds-to-minutes instead of failing at the durability deadline. Model streams on the Workers AI binding provider get an idle deadline: a chunk gap past the cap fails the read as a retryable interruption — the exact reported shape, a 200 that never speaks again, becomes a retried turn under the transient-error budget. The default is 5 minutes (long-thinking models can be legitimately silent), configurable per provider via streamIdleTimeoutMs, with 0 disabling it, and the timer only runs while a source read is outstanding so consumer backpressure never trips it. GatewayOptions.requestTimeoutMs — previously declared but never sent — is now emitted as the cf-aig-request-timeout header, a gateway-enforced bound on time to first response. Tools are abandoned on abort: every tool run races the attempt signal, so a signal-deaf tool (a sandbox file operation with no abort plumbing) rejects at abort instead of wedging the turn past every deadline, under the same orphaned-work contract as an orphaned exec (#538).

  17. 2.0.0

    31 Jul 2026
    • Breaking

      Flue is now a Vite plugin — flue dev and flue build are removed. Adopt Flue by adding flue() from the new @flue/vite package to vite.config.ts; vite dev and vite build own the deployable application. The Node target emits dist/server.mjs (run it with node dist/server.mjs; vite preview for Node is deferred). The Cloudflare target is the official @cloudflare/vite-plugin as an explicit sibling — plugins: [flue(), cloudflare({ config: flueWorkerConfig() })] — with the target auto-detected from cloudflare()'s presence; wrangler.jsonc stays user-owned, and Flue's contributions (the generated Worker entry, served as the virtual:flue/worker module, and the per-agent Durable Object bindings) are applied in memory by the flueWorkerConfig() customizer — nothing is generated into the project tree. flue.config.ts survives as the host-independent project config: defineConfig moves to @flue/runtime/config (the @flue/cli/config export is removed), the accepted fields are target, app, db, cloudflare, agents (a glob narrowing the 'use agent' scan), providers, and tracing, and the root/output fields and named vite export are dropped. See the migration guide for the full before/after.

    • Breaking

      File-based routing is removed — app.ts is the route map. The src/agents/*, src/workflows/*, and src/channels/* directory conventions no longer create routes or registrations. An agent module joins the application through the 'use agent' directive (the module's first statement); the build scans source files for the directive and registers every capitalized exported function as an agent, deriving each agent's durable storage identity from the exported function's name — or an agentName static pinning it — never from the file (on Cloudflare, one generated Flue<PascalName>Agent Durable Object class per exported agent function; renaming an unpinned function is the storage-identity change, expressed with wrangler-native renamed_classes, and colliding identities are a build error — renaming the file changes nothing). Every HTTP route is mounted explicitly in app.ts: app.route('/agents/triage', createAgentRouter(Triage)) for agents (createAgentRouter from @flue/runtime/routing), app.route('/channels/slack', slack.route()) for channels (hand-rolled channels mount via createChannelRouter). The router factory is pure and side-effect-free — registration comes from the scan, so dispatch-only agents need no mount, and the same agent can be mounted at two URLs. The agent module's named exports route (middleware), attachments, and description are removed along with the convention that read them: protect a mount with ordinary middleware layered in app.ts before it, and the attachment byte route is part of every agent router rather than opt-in. createDefaultFlueApp() and the runtime flue() router are removed; a missing app.ts is a build error.

    • Breaking

      Workflows are removed. defineWorkflow, invoke, run stores and run event streams, the /runs/:runId and POST /workflows/:name routes (including ?wait=result), listRuns/getRun, the SDK client.workflows/client.runs namespaces, the React workflow hooks, and the dev-console run UI are all deleted, with no compatibility stubs. Conversations are the only durable unit: a workflow becomes a program that drives an agent — flue run in a shell or CI step, the start()/init() JS API from Node, the Agent SDK over HTTP, or an external durable-workflow engine (Cloudflare Workflows, Inngest, Temporal) that checkpoints the dispatch receipt in one step and reads the settled reply in another. A deterministic code-first entrypoint (the old no-model run() body) has no direct replacement. The migration guide covers the conversion.

  18. 0.11.x
  19. 0.11.1

    11 Jun 2026
    • Direct agent HTTP requests and @flue/sdk prompts can include images with up to 14 MiB of encoded data per image. Node and Cloudflare SQLite persistence stores image data in safe chunks and restores it for future turns and after restarts.

    • The grep tool now uses ripgrep when available, falls back to grep, treats patterns as extended regular expressions by default, and supports literal matching.

    • SQL-backed sessions now store each history entry in its own row instead of rewriting the entire session history as one JSON value. Session saves remain transactional and preserve ordered history across Cloudflare Durable Object SQLite, Node SQLite, and PostgreSQL.

  20. 0.11.0

    10 Jun 2026
    • flue docs browses the documentation offline. The docs markdown already shipped inside @flue/cli is now reachable from the command line: flue docs lists every page, flue docs read <path> prints one page as Markdown, and flue docs search <query> prints ranked JSON results. Content requires no network access and always matches the installed CLI version. Designed for coding agents (search → read), per Documentation.

    • Runtime events no longer carry raw image bytes (#221). Image content blocks in session events (message_*, turn_request, turn_end, agent_end, tool_call) keep their mimeType but have data replaced with the exported IMAGE_DATA_OMITTED sentinel before events reach observers and persisted run history. Model context and persisted session history retain the real bytes. Events persisted before this change are unaffected.

  21. 0.10.x
  22. 0.10.2

    10 Jun 2026
    • Breaking

      Durable Streams protocol replaces WebSocket and SSE transports. Agent instances and workflow runs are now URL-addressable durable event streams. Clients consume events via DS-compliant GET (catch-up, long-poll, SSE) with automatic offset-based reconnection. POST /agents/:name/:id now returns 202 { streamUrl, offset }; add ?wait=result for 200 { result, streamUrl, offset }. GET /agents/:name/:id reads the event stream. GET /runs/:runId replaces both /runs/:runId/events and /runs/:runId/stream. WebSocket transport, AgentSocket, WorkflowSocket, and all socket-related types are removed from @flue/runtime and @flue/sdk.

    • Breaking

      Named sessions removed from agent public API. The session parameter is removed from prompt submission, dispatch, SDK, and CLI. Agent instances always use the "default" session internally. An agent instance is now a single conversation with a single event stream.

    • Breaking

      SDK rewritten with @durable-streams/client. @flue/sdk now exports agents.prompt(), agents.send(), agents.stream(), runs.stream(), runs.events(), and workflows.invoke(). agents.prompt() waits for the result; agents.send() returns stream coordinates immediately. FlueEventStream<T> wraps the DS client's jsonStream() as an async iterable with cancel() and offset support.

  23. 0.10.1

    8 Jun 2026
    • Fixed generated Node and Cloudflare app entrypoints by avoiding collisions with application-owned app bindings.

    • Fixed docs search dialog throwing InvalidStateError when Cmd/Ctrl+K is pressed while already open (#214).

  24. 0.10.0

    8 Jun 2026
    • Breaking

      Cloudflare durable deployments require a migration. Generated Durable Object bindings and class names changed to FLUE_<NAME>_AGENT, FLUE_<NAME>_WORKFLOW, FLUE_REGISTRY, Flue<Name>Agent, Flue<Name>Workflow, and FlueRegistry. Existing deployments must add authored Wrangler renamed_classes migrations for already-deployed agent and workflow classes, update direct binding access such as env.Assistant to env.FLUE_ASSISTANT_AGENT, and introduce fresh SQLite-backed agent classes through new_sqlite_classes; existing KV-backed classes cannot be converted in place. Install agents >=0.14.1 <0.15.0 for the audited Agents SDK behavior used by this release.

    • Breaking

      Runtime surface cleanup. Removed tool_execution_* event types, the @flue/runtime/app, @flue/runtime/client, and @flue/runtime/sandbox compat subpaths, public AgentConfig / DirectAgentPayload exports, public Cloudflare agent WebSocket adapters, store() from @flue/runtime/cloudflare, and the old Cloudflare shell migration stubs.

    • Breaking

      Persistence adapter contracts changed. Custom adapters now implement connectRunStore() and connectRunRegistry() on PersistenceAdapter, use SubmissionClaimRef for claimSubmission(), and provide renewLeases(), listExpiredSubmissions(), and deleteSession() on AgentSubmissionStore.

  25. 0.9.x
  26. 0.9.2

    3 Jun 2026
    • Fixed agents' ability to activate skills autonomously with the activate_skill tool.

  27. 0.9.1

    2 Jun 2026
    • Fixed relative cwd double-scoping in custom sandbox connectors. Flue now applies a created agent's cwd exactly once during init(), relative to the connector's provider-owned base directory. SandboxFactory.createSessionEnv() now receives only { id }; connector implementations should stop consuming cwd there.

    • SDK: Export reusable option types. @flue/sdk now exports option types for direct agent invocation, socket prompts, workflow-run event retrieval and streaming, and admin run listing, plus the RunStatus type.

    • MCP tools discovered through paginated listings now preserve output-schema validation and required task-execution metadata across every page.

  28. 0.9.0

    2 Jun 2026
    • Breaking

      Move application routing imports out of @flue/runtime/app. Import flue, admin, and Fetchable from @flue/runtime/routing. Import provider APIs and observe from @flue/runtime, and Workers AI binding types from @flue/runtime/cloudflare. Rename the ProviderSettings type to ProviderConfiguration.

    • Breaking

      Check your authored source directory. Flue now selects exactly one source directory in priority order: .flue/, src/, then the project root. If your project already has a src/ directory, move root-level agents and workflows into the selected source directory so Flue continues to discover them.

    • Breaking

      Cloudflare: Own Cloudflare Durable Object migrations in your project Wrangler config. Flue still generates classes and bindings, but no longer appends migrations automatically. Before upgrading an existing deployment, copy its complete ordered flue-class-* migration history from the previously generated .flue-vite.wrangler.jsonc or built wrangler.json into the project-root Wrangler config. Keep deployed tags unchanged, and append a uniquely tagged new_sqlite_classes entry whenever you add an agent or workflow class.

  29. 0.8.x
  30. 0.8.1

    28 May 2026
    • OpenTelemetry tracing integration. Added @flue/opentelemetry for tracing Flue model turns through OpenTelemetry-compatible observability tooling.

    • Reduced routine runtime console logging and expanded the published documentation and website guidance.

  31. 0.8.0

    27 May 2026
    • Breaking

      Applications must adopt the agent/workflow split. Move one-shot request/result modules from agents/ to workflows/; long-lived agent modules now default-export createAgent(...). Workflows create harnesses with init(agent) rather than inline init({ ... }) configuration.

    • Breaking

      Routing and run semantics changed. Public HTTP and WebSocket exposure is declared through route and websocket middleware exports. Runs, /runs, and flue logs now describe workflows only; direct or dispatched agent interactions correlate by instance, session, operation, and dispatchId instead of runId.

    • Breaking

      Roles and older agent definitions were replaced. Migrate roles and task({ role }) to named defineAgentProfile(...) subagents and task({ agent }); migrate reusable agent definitions to profiles and ToolDef imports to ToolDefinition.

  32. 0.7.x
  33. 0.7.1

    26 May 2026
    • Cloudflare agent route forwarding preserves the request body. Flue now forwards a cloned request into Cloudflare agent routing, preventing request body consumption from making the original request unreadable after routing.

  34. 0.7.0

    15 May 2026
    • Breaking

      getVirtualSandbox() now throws with a migration message. The previous API described R2 as if it were mounted directly as the harness filesystem, but @cloudflare/shell Workspaces are SQLite-indexed filesystems with optional R2 blob spillover; raw bucket keys uploaded outside Workspace were invisible. Migrate bucket-backed agents to getShellSandbox({ workspace, loader }) plus hydrateFromBucket(workspace, env.BUCKET) before init(). If you used zero-arg getVirtualSandbox(), remove it and omit sandbox from init() to use Flue's default in-memory sandbox.

    • Cloudflare shell sandbox. Added getShellSandbox({ workspace, loader }), getDefaultWorkspace(), and hydrateFromBucket() from @flue/runtime/cloudflare. The new sandbox wires @cloudflare/shell Workspaces into Flue through a codemode code tool backed by a Worker Loader binding. Agents use state.* inside the code tool instead of bash/read/write/grep/glob. Use @cloudflare/shell directly for primitives like Workspace, WorkspaceFileSystem, and createGit.

  35. 0.6.x
  36. 0.6.2

    14 May 2026
    • init({ cwd }) with a relative path now resolves against the sandbox cwd. Previously, init({ cwd: 'relative/path' }) was treated as if absolute against the sandbox root ('relative/path' → /relative/path), so agents ran in the wrong directory — potentially discovering the wrong AGENTS.md, skills, or pointing shell/file operations at unintended paths. Relative cwd values now resolve against the parent SessionEnv's cwd, matching the pattern already used for task sessions. Absolute paths are unchanged. Fixes #152.

    • flue --config <path> resolves against the caller's cwd, not --root. The explicit --config flag was being resolved against searchFrom (effectively --root), contradicting the CLI help text and the config-module doc comment, and diverging from Vite/Astro behavior. Explicit --config paths now resolve against process.cwd(). Auto-discovery (no --config flag) still scans searchFrom, so --root continues to influence where the config is looked up when one wasn't named explicitly. Fixes #152.

    • isBashLike duck-check no longer accepts fs: null. Because typeof null === 'object', an object like { exec, getCwd, fs: null } slipped past assertBashLike / isBashLike and crashed later inside createBashSessionEnv on the first fs.readFile(...) call instead of failing with the clear "BashFactory must return a Bash-like object" validation error. The check now rejects fs: null explicitly, and the predicate is shared between sandbox.ts and client.ts so the two copies can't drift. Fixes #149.

  37. 0.6.1

    14 May 2026
  38. 0.6.0

    14 May 2026
    • Breaking

      sandbox magic strings removed. init({ sandbox }) no longer accepts the literal strings 'empty' or 'local'. The TypeScript union excludes both, and the runtime throws with a migration message for JS callers / any-typed inputs.

      - init({ sandbox: 'empty', model: 'anthropic/claude-sonnet-4-6' });
      + init({ model: 'anthropic/claude-sonnet-4-6' });
      
      - init({ sandbox: 'local', model: 'anthropic/claude-sonnet-4-6' });
      + import { local } from '@flue/runtime/node';
      + init({ sandbox: local({ env: { GH_TOKEN: process.env.GH_TOKEN } }), model: 'anthropic/claude-sonnet-4-6' });
    • Breaking

      Malformed run-event query parameters now return structured 400 errors. GET /runs/<runId>/events validates query params before reading run history. limit must be an integer in [1, 1000]; after must be a non-negative integer; types must be a comma-separated list of known Flue event type names. Previously malformed limit / after values were silently defaulted or ignored.

    • Breaking

      Run-lookup HTTP routes are now identified by runId alone. The previous GET /agents/<name>/<id>/runs/<runId>{,/events,/stream} route family is removed and replaced with GET /runs/<runId>{,/events,/stream}. The new routes work end-to-end on both Node and Cloudflare for any run that exists anywhere in the deployment — the server resolves the owning (agentName, instanceId) via a new internal run registry, so callers no longer need to know which agent or instance ran a given run id. External consumers hitting the old paths will get a 404; update to the bare form. The POST /agents/<name>/<id> invocation route is unchanged.

      - curl http://localhost:3583/agents/hello/inst-1/runs/run_01H...
      + curl http://localhost:3583/runs/run_01H...

A whole project to check? Paste its package.json in the dependency check: every deprecated, outdated or vulnerable dependency, with what to upgrade to. Free, no account.