---
title: Developer platform Changelog
image: https://edgetunnel-b2h.pages.dev/cf-twitter-card.png
---

> Documentation Index  
> Fetch the complete documentation index at: https://edgetunnel-b2h.pages.dev/changelog/llms.txt  
> Use this file to discover all available pages before exploring further. 

[Skip to content](#%5Ftop) 

# Changelog

New updates and improvements at Cloudflare.

[ Subscribe to RSS ](https://edgetunnel-b2h.pages.dev/changelog/rss/index.xml) [ View RSS feeds ](https://edgetunnel-b2h.pages.dev/fundamentals/new-features/available-rss-feeds/) 

Developer platform

![hero image](https://edgetunnel-b2h.pages.dev/_astro/hero.CVYJHPAd_26AMqX.svg) 

Jan 20, 2026
1. ### [Terraform v5.16.0 now available](https://edgetunnel-b2h.pages.dev/changelog/post/2026-01-20-terraform-v5160-provider/)  
[ Cloudflare Fundamentals ](https://edgetunnel-b2h.pages.dev/fundamentals/)[ Terraform ](https://edgetunnel-b2h.pages.dev/terraform/)  
In January 2025, we announced the launch of the new Terraform v5 Provider. We greatly appreciate the proactive engagement and valuable feedback from the Cloudflare community following the v5 release. In response, we've established a consistent and rapid [2-3 week cadence ↗](https://github.com/cloudflare/terraform-provider-cloudflare/issues/5774) for releasing targeted improvements, demonstrating our commitment to stability and reliability.  
With the help of the community, we have a growing number of resources that we have marked as [stable ↗](https://github.com/cloudflare/terraform-provider-cloudflare/issues/6237), with that list continuing to grow with every release. The most used [resources ↗](https://github.com/cloudflare/terraform-provider-cloudflare/issues/6237) are on track to be stable by the end of March 2026, when we will also be releasing a new migration tool to you migrate from v4 to v5 with ease.  
Thank you for continuing to raise issues. They make our provider stronger and help us build products that reflect your needs.  
This release includes bug fixes, the stabilization of even more popular resources, and more.  
#### Features

  * **custom\_pages:** add "waf\_challenge" as new supported error page type identifier in both resource and data source schemas
  * **list:** enhance CIDR validator to check for normalized CIDR notation requiring network address for IPv4 and IPv6
  * **magic\_wan\_gre\_tunnel:** add automatic\_return\_routing attribute for automatic routing control
  * **magic\_wan\_gre\_tunnel:** add BGP configuration support with new BGP model attribute
  * **magic\_wan\_gre\_tunnel:** add bgp\_status computed attribute for BGP connection status information
  * **magic\_wan\_gre\_tunnel:** enhance schema with BGP-related attributes and validators
  * **magic\_wan\_ipsec\_tunnel:** add automatic\_return\_routing attribute for automatic routing control
  * **magic\_wan\_ipsec\_tunnel:** add BGP configuration support with new BGP model attribute
  * **magic\_wan\_ipsec\_tunnel:** add bgp\_status computed attribute for BGP connection status information
  * **magic\_wan\_ipsec\_tunnel:** add custom\_remote\_identities attribute for custom identity configuration
  * **magic\_wan\_ipsec\_tunnel:** enhance schema with BGP and identity-related attributes
  * **ruleset:** add request body buffering support
  * **ruleset:** enhance ruleset data source with additional configuration options
  * **workers\_script:** add observability logs attributes to list data source model
  * **workers\_script:** enhance list data source schema with additional configuration options  
#### Bug Fixes

  * **account\_member**: fix resource importability issues
  * **dns\_record:** remove unnecessary fmt.Sprintf wrapper around LoadTestCase call in test configuration helper function
  * **load\_balancer:** fix session\_affinity\_ttl type expectations to match Float64 in initial creation and Int64 after migration
  * **workers\_kv:** handle special characters correctly in URL encoding  
#### Documentation

  * **account\_subscription:** update schema description for rate\_plan.sets attribute to clarify it returns an array of strings
  * **api\_shield:** add resource-level description for API Shield management of auth ID characteristics
  * **api\_shield:** enhance auth\_id\_characteristics.name attribute description to include JWT token configuration format requirements
  * **api\_shield:** specify JSONPath expression format for JWT claim locations
  * **hyperdrive\_config:** add description attribute to name attribute explaining its purpose in dashboard and API identification
  * **hyperdrive\_config:** apply description improvements across resource, data source, and list data source schemas
  * **hyperdrive\_config:** improve schema descriptions for cache settings to clarify default values
  * **hyperdrive\_config:** update port description to clarify defaults for different database types  
#### For more information

  * [Terraform Provider ↗](https://registry.terraform.io/providers/cloudflare/cloudflare/latest/docs)
  * [Documentation on using Terraform with Cloudflare](https://edgetunnel-b2h.pages.dev/terraform/)
  * [List of stabilized resources ↗](https://github.com/cloudflare/terraform-provider-cloudflare/issues/6237)

Jan 20, 2026
1. ### [Use auxiliary Workers alongside full-stack frameworks](https://edgetunnel-b2h.pages.dev/changelog/post/2026-01-20-auxiliary-workers/)  
[ Workers ](https://edgetunnel-b2h.pages.dev/workers/)  
Auxiliary Workers are now fully supported when using full-stack frameworks, such as [React Router](https://edgetunnel-b2h.pages.dev/workers/framework-guides/web-apps/react-router/) and [TanStack Start](https://edgetunnel-b2h.pages.dev/workers/framework-guides/web-apps/tanstack-start/), that integrate with the [Cloudflare Vite plugin](https://edgetunnel-b2h.pages.dev/workers/vite-plugin/reference/api/). They are included alongside the framework's build output in the build output directory. Note that this feature requires Vite 7 or above.  
Auxiliary Workers are additional Workers that can be called via [service bindings](https://edgetunnel-b2h.pages.dev/workers/runtime-apis/bindings/service-bindings/) from your main (entry) Worker. They are defined in the plugin config, as in the example below:

**vite.config.ts**  
```ts  
import { defineConfig } from "vite";  
import { tanstackStart } from "@tanstack/react-start/plugin/vite";  
import { cloudflare } from "@cloudflare/vite-plugin";  
export default defineConfig({  
  plugins: [  
    tanstackStart(),  
    cloudflare({  
      viteEnvironment: { name: "ssr" },  
      auxiliaryWorkers: [{ configPath: "./wrangler.aux.jsonc" }],  
    }),  
  ],  
});  
```  
See the Vite plugin [API docs](https://edgetunnel-b2h.pages.dev/workers/vite-plugin/reference/api/) for more info.

Jan 20, 2026
1. ### [Import SQL files as additional modules by default](https://edgetunnel-b2h.pages.dev/changelog/post/2026-01-20-sql-module-rule/)  
[ Workers ](https://edgetunnel-b2h.pages.dev/workers/)  
The `.sql` file extension is now automatically configured to be importable in your Worker code when using [Wrangler](https://edgetunnel-b2h.pages.dev/workers/wrangler/bundling/#including-non-javascript-modules) or the [Cloudflare Vite plugin](https://edgetunnel-b2h.pages.dev/workers/vite-plugin/reference/non-javascript-modules/). This is particular useful for importing migrations in Durable Objects and means you no longer need to configure custom rules when using [Drizzle ↗](https://orm.drizzle.team/docs/connect-cloudflare-do).  
SQL files are imported as JavaScript strings:

**TypeScript**  
```ts  
// `example` will be a JavaScript string  
import example from "./example.sql";  
```

Jan 15, 2026
1. ### [Verify WARP Connector connectivity with a simple ping](https://edgetunnel-b2h.pages.dev/changelog/post/2026-01-15-warp-connector-ping-support/)  
[ Cloudflare Tunnel ](https://edgetunnel-b2h.pages.dev/tunnel/)[ Cloudflare Tunnel for SASE ](https://edgetunnel-b2h.pages.dev/cloudflare-one/networks/connectors/cloudflare-tunnel/)  
We have made it easier to validate connectivity when deploying [WARP Connector](https://edgetunnel-b2h.pages.dev/cloudflare-one/networks/connectors/cloudflare-mesh/) as part of your [software-defined private network](https://edgetunnel-b2h.pages.dev/reference-architecture/architectures/sase/#connecting-networks).  
You can now `ping` the WARP Connector host directly on its LAN IP address immediately after installation. This provides a fast, familiar way to confirm that the Connector is online and reachable within your network before testing access to downstream services.  
Starting with [version 2025.10.186.0](https://edgetunnel-b2h.pages.dev/changelog/2026-01-13-warp-linux-ga/), WARP Connector responds to traffic addressed to its own LAN IP, giving you immediate visibility into Connector reachability.  
Learn more about deploying [WARP Connector](https://edgetunnel-b2h.pages.dev/cloudflare-one/networks/connectors/cloudflare-mesh/) and building private network connectivity with [Cloudflare One](https://edgetunnel-b2h.pages.dev/cloudflare-one/).

Jan 15, 2026
1. ### [Launching FLUX.2 \[klein\] 4B on Workers AI](https://edgetunnel-b2h.pages.dev/changelog/post/2026-01-15-flux-2-klein-4b-workers-ai/)  
[ Workers AI ](https://edgetunnel-b2h.pages.dev/workers-ai/)  
We've partnered with Black Forest Labs (BFL) again to bring their optimized FLUX.2 \[klein\] 4B model to Workers AI! This distilled model offers faster generation and cost-effective pricing, while maintaining great output quality. With a fixed 4-step inference process, Klein 4B is ideal for rapid prototyping and real-time applications where speed matters.  
Read the [BFL blog ↗](https://bfl.ai/blog) to learn more about the model itself, or try it out yourself on our [multi modal playground ↗](https://multi-modal.ai.cloudflare.com/).  
Pricing documentation is available on the [model page](https://edgetunnel-b2h.pages.dev/workers-ai/models/flux-2-klein-4b/) or [pricing page](https://edgetunnel-b2h.pages.dev/workers-ai/platform/pricing/).  
#### Workers AI Platform specifics  
The model hosted on Workers AI is optimized for speed with a **fixed 4-step inference process** and supports up to 4 image inputs. Since this is a distilled model, the `steps` parameter is fixed at 4 and cannot be adjusted. Like FLUX.2 \[dev\], this image model uses multipart form data inputs, even if you just have a prompt.  
With the REST API, the multipart form data input looks like this:  
```bash  
curl --request POST \
  --url 'https://api.cloudflare.com/client/v4/accounts/{ACCOUNT}/ai/run/@cf/black-forest-labs/flux-2-klein-4b' \
  --header 'Authorization: Bearer {TOKEN}' \
  --header 'Content-Type: multipart/form-data' \
  --form 'prompt=a sunset at the alps' \
  --form width=1024 \
  --form height=1024  
```  
With the Workers AI binding, you can use it as such:

**JavaScript**  
```javascript  
const form = new FormData();  
form.append("prompt", "a sunset with a dog");  
form.append("width", "1024");  
form.append("height", "1024");  
// FormData doesn't expose its serialized body or boundary. Passing it to a  
// Request (or Response) constructor serializes it and generates the Content-Type  
// header with the boundary, which is required for the server to parse the multipart fields.  
const formResponse = new Response(form);  
const formStream = formResponse.body;  
const formContentType = formResponse.headers.get('content-type');  
const resp = await env.AI.run("@cf/black-forest-labs/flux-2-klein-4b", {  
  multipart: {  
    body: formStream,  
    contentType: formContentType,  
  },  
});  
```  
The parameters you can send to the model are detailed here:  
JSON Schema for Model **Required Parameters**
  * `prompt` (string) - Text description of the image to generate

**Optional Parameters**

  * `input_image_0` (string) - Binary image
  * `input_image_1` (string) - Binary image
  * `input_image_2` (string) - Binary image
  * `input_image_3` (string) - Binary image
  * `guidance` (float) - Guidance scale for generation. Higher values follow the prompt more closely
  * `width` (integer) - Width of the image, default `1024` Range: 256-1920
  * `height` (integer) - Height of the image, default `768` Range: 256-1920
  * `seed` (integer) - Seed for reproducibility

**Note:** Since this is a distilled model, the `steps` parameter is fixed at 4 and cannot be adjusted.  
```plaintext  
## Multi-Reference Images  
The FLUX.2 klein-4b model supports generating images based on reference images, just like FLUX.2 [dev]. You can use this feature to apply the style of one image to another, add a new character to an image, or iterate on past generated images. You would use it with the same multipart form data structure, with the input images in binary. The model supports up to 4 input images.  
For the prompt, you can reference the images based on the index, like `take the subject of image 1 and style it like image 0` or even use natural language like `place the dog beside the woman`.  
Note: you have to name the input parameter as `input_image_0`, `input_image_1`, `input_image_2`, `input_image_3` for it to work correctly. All input images must be smaller than 512x512.  
```bash  
curl --request POST \
  --url 'https://api.cloudflare.com/client/v4/accounts/{ACCOUNT}/ai/run/@cf/black-forest-labs/flux-2-klein-4b' \
  --header 'Authorization: Bearer {TOKEN}' \
  --header 'Content-Type: multipart/form-data' \
  --form 'prompt=take the subject of image 1 and style it like image 0' \
  --form input_image_0=@/Users/johndoe/Desktop/icedoutkeanu.png \
  --form input_image_1=@/Users/johndoe/Desktop/me.png \
  --form width=1024 \
  --form height=1024  
```  
Through Workers AI Binding:

**JavaScript**  
```javascript  
//helper function to convert ReadableStream to Blob  
async function streamToBlob(stream: ReadableStream, contentType: string): Promise<Blob> {  
  const reader = stream.getReader();  
  const chunks = [];  
  while (true) {  
    const { done, value } = await reader.read();  
    if (done) break;  
    chunks.push(value);  
  }  
  return new Blob(chunks, { type: contentType });  
}  
const image0 = await fetch("http://image-url");  
const image1 = await fetch("http://image-url");  
const form = new FormData();  
const image_blob0 = await streamToBlob(image0.body, "image/png");  
const image_blob1 = await streamToBlob(image1.body, "image/png");  
form.append('input_image_0', image_blob0)  
form.append('input_image_1', image_blob1)  
form.append('prompt', 'take the subject of image 1 and style it like image 0')  
// FormData doesn't expose its serialized body or boundary. Passing it to a  
// Request (or Response) constructor serializes it and generates the Content-Type  
// header with the boundary, which is required for the server to parse the multipart fields.  
const formResponse = new Response(form);  
const formStream = formResponse.body;  
const formContentType = formResponse.headers.get('content-type');  
const resp = await env.AI.run("@cf/black-forest-labs/flux-2-klein-4b", {  
    multipart: {  
        body: formStream,  
        contentType: formContentType  
    }  
})  
```

Jan 13, 2026
1. ### [\`wrangler types\` now generates types for all environments](https://edgetunnel-b2h.pages.dev/changelog/post/2026-01-13-wrangler-types-multi-environment/)  
[ Workers ](https://edgetunnel-b2h.pages.dev/workers/)  
The `wrangler types` command now generates TypeScript types for bindings from **all environments** defined in your Wrangler configuration file by default.  
Previously, `wrangler types` only generated types for bindings in the top-level configuration (or a single environment when using the `--env` flag). This meant that if you had environment-specific bindings — for example, a KV namespace only in production or an R2 bucket only in staging — those bindings would be missing from your generated types, causing TypeScript errors when accessing them.  
Now, running `wrangler types` collects bindings from all environments and includes them in the generated `Env` type. This ensures your types are complete regardless of which environment you deploy to.  
#### Generating types for a specific environment  
If you want the previous behavior of generating types for only a specific environment, you can use the `--env` flag:  
```sh  
wrangler types --env production  
```  
Learn more about [generating types for your Worker](https://edgetunnel-b2h.pages.dev/workers/wrangler/commands/general/#types) in the Wrangler documentation.

Jan 12, 2026
1. ### [Validate your generated types with \`wrangler types --check\`](https://edgetunnel-b2h.pages.dev/changelog/post/2026-01-11-wrangler-types-check/)  
[ Workers ](https://edgetunnel-b2h.pages.dev/workers/)  
Wrangler now supports a `--check` flag for the `wrangler types` command. This flag validates that your generated types are up to date without writing any changes to disk.  
This is useful in CI/CD pipelines where you want to ensure that developers have regenerated their types after making changes to their Wrangler configuration. If the types are out of date, the command will exit with a non-zero status code.  
```sh  
npx wrangler types --check  
```  
If your types are up to date, the command will succeed silently. If they are out of date, you'll see an error message indicating which files need to be regenerated.  
For more information, see the [Wrangler types documentation](https://edgetunnel-b2h.pages.dev/workers/wrangler/commands/general/#types).

Jan 09, 2026
1. ### [Get notified when your Workers builds succeed or fail](https://edgetunnel-b2h.pages.dev/changelog/post/2025-12-11-builds-event-subscriptions/)  
[ Workers ](https://edgetunnel-b2h.pages.dev/workers/)[ Queues ](https://edgetunnel-b2h.pages.dev/queues/)  
You can now receive notifications when your Workers' builds start, succeed, fail, or get cancelled using [Event Subscriptions](https://edgetunnel-b2h.pages.dev/queues/event-subscriptions/).  
[Workers Builds](https://edgetunnel-b2h.pages.dev/workers/ci-cd/builds/) publishes events to a [Queue](https://edgetunnel-b2h.pages.dev/queues/) that your Worker can read messages from, and then send notifications wherever you need — Slack, Discord, email, or any webhook endpoint.  
You can deploy [this Worker ↗](https://github.com/cloudflare/templates/tree/main/workers-builds-notifications-template) to your own Cloudflare account to send build notifications to Slack:  
[![Deploy to Cloudflare](https://deploy.workers.cloudflare.com/button)](https://deploy.workers.cloudflare.com/?url=https://github.com/cloudflare/templates/tree/main/workers-builds-notifications-template)  
The template includes:

  * Build status with Preview/Live URLs for successful deployments
  * Inline error messages for failed builds
  * Branch, commit hash, and author name  
![Slack notifications showing build events](https://edgetunnel-b2h.pages.dev/_astro/builds-notifications-slack.rcRiU95L_169ufw.webp)  
For setup instructions, refer to the [template README ↗](https://github.com/cloudflare/templates/tree/main/workers-builds-notifications-template#readme) or the [Event Subscriptions documentation](https://edgetunnel-b2h.pages.dev/queues/event-subscriptions/manage-event-subscriptions/).

Jan 09, 2026
1. ### [Shell tab completions for Wrangler CLI](https://edgetunnel-b2h.pages.dev/changelog/post/2026-01-09-wrangler-tab-completion/)  
[ Workers ](https://edgetunnel-b2h.pages.dev/workers/)  
Wrangler now includes built-in shell tab completion support, making it faster and easier to navigate commands without memorizing every option. Press Tab as you type to autocomplete commands, subcommands, flags, and even option values like log levels.  
Tab completions are supported for Bash, Zsh, Fish, and PowerShell.  
#### Setup  
Generate the completion script for your shell and add it to your configuration file:  
```sh  
# Bash  
wrangler complete bash >> ~/.bashrc  
# Zsh  
wrangler complete zsh >> ~/.zshrc  
# Fish  
wrangler complete fish >> ~/.config/fish/config.fish  
# PowerShell  
wrangler complete powershell >> $PROFILE  
```  
After adding the script, restart your terminal or source your configuration file for the changes to take effect. Then you can simply press Tab to see available completions:  
```sh  
wrangler d<TAB>          # completes to 'deploy', 'dev', 'd1', etc.  
wrangler kv <TAB>        # shows subcommands: namespace, key, bulk  
```  
Tab completions are dynamically generated from Wrangler's command registry, so they stay up-to-date as new commands and options are added. This feature is powered by [@bomb.sh/tab ↗](https://github.com/bombshell-dev/tab/).  
See the [wrangler complete documentation](https://edgetunnel-b2h.pages.dev/workers/wrangler/commands/general/#complete) for more details.

Jan 07, 2026
1. ### [Workers Analytics Engine SQL now supports filtering using HAVING and LIKE](https://edgetunnel-b2h.pages.dev/changelog/post/2026-01-07-analytics-engine-support-for-like-and-having/)  
[ Workers Analytics Engine ](https://edgetunnel-b2h.pages.dev/analytics/analytics-engine/)[ Workers ](https://edgetunnel-b2h.pages.dev/workers/)  
You can now use the `HAVING` clause and `LIKE` pattern matching operators in [Workers Analytics Engine ↗](https://edgetunnel-b2h.pages.dev/analytics/analytics-engine/).  
Workers Analytics Engine allows you to ingest and store high-cardinality data at scale and query your data through a simple SQL API.  
#### Filtering using `HAVING`  
The `HAVING` clause complements the `WHERE` clause by enabling you to filter groups based on aggregate values. While `WHERE` filters rows before aggregation, `HAVING` filters groups after aggregation is complete.  
You can use `HAVING` to filter groups where the average exceeds a threshold:  
```sql  
SELECT  
    blob1 AS probe_name,  
    avg(double1) AS average_temp  
FROM temperature_readings  
GROUP BY probe_name  
HAVING average_temp > 10  
```  
You can also filter groups based on aggregates such as the number of items in the group:  
```sql  
SELECT  
    blob1 AS probe_name,  
    count() AS num_readings  
FROM temperature_readings  
GROUP BY probe_name  
HAVING num_readings > 100  
```  
#### Pattern matching using `LIKE`  
The new pattern matching operators enable you to search for strings that match specific patterns using wildcard characters:

  * `LIKE` \- case-sensitive pattern matching
  * `NOT LIKE` \- case-sensitive pattern exclusion
  * `ILIKE` \- case-insensitive pattern matching
  * `NOT ILIKE` \- case-insensitive pattern exclusion  
Pattern matching supports two wildcard characters: `%` (matches zero or more characters) and `_` (matches exactly one character).  
You can match strings starting with a prefix:  
```sql  
SELECT *  
FROM logs  
WHERE blob1 LIKE 'error%'  
```  
You can also match file extensions (case-insensitive):  
```sql  
SELECT *  
FROM requests  
WHERE blob2 ILIKE '%.jpg'  
```  
Another example is excluding strings containing specific text:  
```sql  
SELECT *  
FROM events  
WHERE blob3 NOT ILIKE '%debug%'  
```  
#### Ready to get started?  
Learn more about the [HAVING clause](https://edgetunnel-b2h.pages.dev/analytics/analytics-engine/sql-reference/statements/#having-clause) or [pattern matching operators](https://edgetunnel-b2h.pages.dev/analytics/analytics-engine/sql-reference/operators/#pattern-matching-operators) in the Workers Analytics Engine SQL reference documentation.

Jan 05, 2026
1. ### [Custom container instance types now available for all users](https://edgetunnel-b2h.pages.dev/changelog/post/2026-01-05-custom-instance-types/)  
[ Containers ](https://edgetunnel-b2h.pages.dev/containers/)  
Custom instance types are now enabled for all [Cloudflare Containers](https://edgetunnel-b2h.pages.dev/containers) users. You can now specify specific vCPU, memory, and disk amounts, rather than being limited to pre-defined [instance types](https://edgetunnel-b2h.pages.dev/containers/platform-details/limits/#instance-types). Previously, only select Enterprise customers were able to customize their instance type.  
To use a custom instance type, specify the `instance_type` property as an object with `vcpu`, `memory_mib`, and `disk_mb` fields in your Wrangler configuration:

**TOML**  
```toml  
[[containers]]  
image = "./Dockerfile"  
instance_type = { vcpu = 2, memory_mib = 6144, disk_mb = 12000 }  
```  
Individual limits for custom instance types are based on the `standard-4` instance type (4 vCPU, 12 GiB memory, 20 GB disk). You must allocate at least 1 vCPU for custom instance types. For workloads requiring less than 1 vCPU, use the predefined instance types like `lite` or `basic`.  
See the [limits documentation](https://edgetunnel-b2h.pages.dev/containers/platform-details/limits/#custom-instance-types) for the full list of constraints on custom instance types. See the [getting started guide](https://edgetunnel-b2h.pages.dev/containers/get-started/) to deploy your first Container,

Jan 01, 2026
1. ### [Build microfrontend applications on Workers](https://edgetunnel-b2h.pages.dev/changelog/post/2026-01-01-microfrontends/)  
[ Workers ](https://edgetunnel-b2h.pages.dev/workers/)  
You can now deploy microfrontends to Cloudflare, splitting a single application into smaller, independently deployable units that render as one cohesive application. This lets different teams using different frameworks develop, test, and deploy each microfrontend without coordinating releases.  
Microfrontends solve several challenges for large-scale applications:

  * **Independent deployments**: Teams deploy updates on their own schedule without redeploying the entire application
  * **Framework flexibility**: Build multi-framework applications (for example, Astro, Remix, and Next.js in one app)
  * **Gradual migration**: Migrate from a monolith to a distributed architecture incrementally  
Create a microfrontend project:  
[![Deploy to Cloudflare](https://deploy.workers.cloudflare.com/button)](https://dash.cloudflare.com/?to=/:account/workers-and-pages/create?type=vmfe)  
This template automatically creates a router worker with pre-configured routing logic, and lets you configure [Service bindings](https://edgetunnel-b2h.pages.dev/workers/runtime-apis/bindings/service-bindings/) to Workers you have already deployed to your Cloudflare account. The router Worker analyzes incoming requests, matches them against configured routes, and forwards requests to the appropriate microfrontend via service bindings. The router automatically rewrites HTML, CSS, and headers to ensure assets load correctly from each microfrontend's mount path. The router includes advanced features like preloading for faster navigation between microfrontends, smooth page transitions using the View Transitions API, and automatic path rewriting for assets, redirects, and cookies.  
Each microfrontend can be a full-framework application, a static site with Workers Static Assets, or any other Worker-based application.  
Get started with the [microfrontends template ↗](https://dash.cloudflare.com/?to=/:account/workers-and-pages/create?type=vmfe), or read the [microfrontends documentation](https://edgetunnel-b2h.pages.dev/workers/framework-guides/web-apps/microfrontends/) for implementation details.

Dec 22, 2025
1. ### [Agents SDK v0.3.0, workers-ai-provider v3.0.0, and ai-gateway-provider v3.0.0 with AI SDK v6 support](https://edgetunnel-b2h.pages.dev/changelog/post/2025-12-22-agents-sdk-ai-sdk-v6/)  
[ Agents ](https://edgetunnel-b2h.pages.dev/agents/)[ Workers ](https://edgetunnel-b2h.pages.dev/workers/)  
We've shipped a new release for the [Agents SDK ↗](https://github.com/cloudflare/agents) v0.3.0 bringing full compatibility with [AI SDK v6 ↗](https://ai-sdk.dev/docs/introduction) and introducing the unified tool pattern, dynamic tool approval, and enhanced React hooks with improved tool handling.  
This release includes improved streaming and tool support, dynamic tool approval (for "human in the loop" systems), enhanced React hooks with `onToolCall` callback, improved error handling for streaming responses, and seamless migration from v5 patterns.  
This makes it ideal for building production AI chat interfaces with Cloudflare Workers AI models, agent workflows, human-in-the-loop systems, or any application requiring reliable tool execution and approval workflows.  
Additionally, we've updated **workers-ai-provider v3.0.0**, the official provider for Cloudflare Workers AI models, and **ai-gateway-provider v3.0.0**, the provider for Cloudflare AI Gateway, to be compatible with AI SDK v6.  
#### Agents SDK v0.3.0  
#### Unified Tool Pattern  
AI SDK v6 introduces a unified tool pattern where all tools are defined on the server using the `tool()` function. This replaces the previous client-side `AITool` pattern.  
#### Server-Side Tool Definition

**TypeScript**  
```ts  
import { tool } from "ai";  
import { z } from "zod";  
// Server: Define ALL tools on the server  
const tools = {  
  // Server-executed tool  
  getWeather: tool({  
    description: "Get weather for a city",  
    inputSchema: z.object({ city: z.string() }),  
    execute: async ({ city }) => fetchWeather(city)  
  }),  
  // Client-executed tool (no execute = client handles via onToolCall)  
  getLocation: tool({  
    description: "Get user location from browser",  
    inputSchema: z.object({})  
    // No execute function  
  }),  
  // Tool requiring approval (dynamic based on input)  
  processPayment: tool({  
    description: "Process a payment",  
    inputSchema: z.object({ amount: z.number() }),  
    needsApproval: async ({ amount }) => amount > 100,  
    execute: async ({ amount }) => charge(amount)  
  })  
};  
```  
#### Client-Side Tool Handling

**TypeScript**  
```ts  
// Client: Handle client-side tools via onToolCall callback  
import { useAgentChat } from "agents/ai-react";  
const { messages, sendMessage, addToolOutput } = useAgentChat({  
  agent,  
  onToolCall: async ({ toolCall, addToolOutput }) => {  
    if (toolCall.toolName === "getLocation") {  
      const position = await new Promise((resolve, reject) => {  
        navigator.geolocation.getCurrentPosition(resolve, reject);  
      });  
      addToolOutput({  
        toolCallId: toolCall.toolCallId,  
        output: {  
          lat: position.coords.latitude,  
          lng: position.coords.longitude  
        }  
      });  
    }  
  }  
});  
```

**Key benefits of the unified tool pattern:**

  * **Server-defined tools**: All tools are defined in one place on the server
  * **Dynamic approval**: Use `needsApproval` to conditionally require user confirmation
  * **Cleaner client code**: Use `onToolCall` callback instead of managing tool configs
  * **Type safety**: Full TypeScript support with proper tool typing  
#### useAgentChat(options)  
Creates a new chat interface with enhanced v6 capabilities.

**TypeScript**  
```ts  
// Basic chat setup with onToolCall  
const { messages, sendMessage, addToolOutput } = useAgentChat({  
  agent,  
  onToolCall: async ({ toolCall, addToolOutput }) => {  
    // Handle client-side tool execution  
    await addToolOutput({  
      toolCallId: toolCall.toolCallId,  
      output: { result: "success" }  
    });  
  }  
});  
```  
#### Dynamic Tool Approval  
Use `needsApproval` on server tools to conditionally require user confirmation:

**TypeScript**  
```ts  
const paymentTool = tool({  
  description: "Process a payment",  
  inputSchema: z.object({  
    amount: z.number(),  
    recipient: z.string()  
  }),  
  needsApproval: async ({ amount }) => amount > 1000,  
  execute: async ({ amount, recipient }) => {  
    return await processPayment(amount, recipient);  
  }  
});  
```  
#### Tool Confirmation Detection  
The `isToolUIPart` and `getToolName` functions now check both static and dynamic tool parts:

**TypeScript**  
```ts  
import { isToolUIPart, getToolName } from "ai";  
const pendingToolCallConfirmation = messages.some((m) =>  
  m.parts?.some(  
    (part) => isToolUIPart(part) && part.state === "input-available",  
  ),  
);  
// Handle tool confirmation  
if (pendingToolCallConfirmation) {  
  await addToolOutput({  
    toolCallId: part.toolCallId,  
    output: "User approved the action"  
  });  
}  
```  
If you need the v5 behavior (static-only checks), use the new functions:

**TypeScript**  
```ts  
import { isStaticToolUIPart, getStaticToolName } from "ai";  
```  
#### convertToModelMessages() is now async  
The `convertToModelMessages()` function is now asynchronous. Update all calls to await the result:

**TypeScript**  
```ts  
import { convertToModelMessages } from "ai";  
const result = streamText({  
  messages: await convertToModelMessages(this.messages),  
  model: openai("gpt-4o")  
});  
```  
#### ModelMessage type  
The `CoreMessage` type has been removed. Use `ModelMessage` instead:

**TypeScript**  
```ts  
import { convertToModelMessages, type ModelMessage } from "ai";  
const modelMessages: ModelMessage[] = await convertToModelMessages(messages);  
```  
#### generateObject mode option removed  
The `mode` option for `generateObject` has been removed:

**TypeScript**  
```ts  
// Before (v5)  
const result = await generateObject({  
  mode: "json",  
  model,  
  schema,  
  prompt  
});  
// After (v6)  
const result = await generateObject({  
  model,  
  schema,  
  prompt  
});  
```  
#### Structured Output with generateText  
While `generateObject` and `streamObject` are still functional, the recommended approach is to use `generateText`/`streamText` with the `Output.object()` helper:

**TypeScript**  
```ts  
import { generateText, Output, stepCountIs } from "ai";  
const { output } = await generateText({  
  model: openai("gpt-4"),  
  output: Output.object({  
    schema: z.object({ name: z.string() })  
  }),  
  stopWhen: stepCountIs(2),  
  prompt: "Generate a name"  
});  
```  
> **Note**: When using structured output with `generateText`, you must configure multiple steps with `stopWhen` because generating the structured output is itself a step.  
#### workers-ai-provider v3.0.0  
Seamless integration with Cloudflare Workers AI models through the updated workers-ai-provider v3.0.0 with AI SDK v6 support.  
#### Model Setup with Workers AI  
Use Cloudflare Workers AI models directly in your agent workflows:

**TypeScript**  
```ts  
import { createWorkersAI } from "workers-ai-provider";  
import { useAgentChat } from "agents/ai-react";  
// Create Workers AI model (v3.0.0 - enhanced v6 internals)  
const model = createWorkersAI({  
  binding: env.AI,  
})("@cf/meta/llama-3.2-3b-instruct");  
```  
#### Enhanced File and Image Support  
Workers AI models now support v6 file handling with automatic conversion:

**TypeScript**  
```ts  
// Send images and files to Workers AI models  
sendMessage({  
  role: "user",  
  parts: [  
    { type: "text", text: "Analyze this image:" },  
    {  
      type: "file",  
      data: imageBuffer,  
      mediaType: "image/jpeg",  
    },  
  ],  
});  
// Workers AI provider automatically converts to proper format  
```  
#### Streaming with Workers AI  
Enhanced streaming support with automatic warning detection:

**TypeScript**  
```ts  
// Streaming with Workers AI models  
const result = await streamText({  
  model: createWorkersAI({ binding: env.AI })("@cf/meta/llama-3.2-3b-instruct"),  
  messages: await convertToModelMessages(messages),  
  onChunk: (chunk) => {  
    // Enhanced streaming with warning handling  
    console.log(chunk);  
  },  
});  
```  
#### ai-gateway-provider v3.0.0  
The ai-gateway-provider v3.0.0 now supports AI SDK v6, enabling you to use Cloudflare AI Gateway with multiple AI providers including Anthropic, Azure, AWS Bedrock, Google Vertex, and Perplexity.  
#### AI Gateway Setup  
Use Cloudflare AI Gateway to add analytics, caching, and rate limiting to your AI applications:

**TypeScript**  
```ts  
import { createAIGateway } from "ai-gateway-provider";  
// Create AI Gateway provider (v3.0.0 - enhanced v6 internals)  
const model = createAIGateway({  
  gatewayUrl: "https://gateway.ai.cloudflare.com/v1/your-account-id/gateway",  
  headers: {  
    "Authorization": `Bearer ${env.AI_GATEWAY_TOKEN}`  
  }  
})({  
  provider: "openai",  
  model: "gpt-4o"  
});  
```  
#### Migration from v5  
#### Deprecated APIs  
The following APIs are deprecated in favor of the unified tool pattern:

| Deprecated                            | Replacement                                      |
| ------------------------------------- | ------------------------------------------------ |
| AITool type                           | Use AI SDK's tool() function on server           |
| extractClientToolSchemas()            | Define tools on server, no client schemas needed |
| createToolsFromClientSchemas()        | Define tools on server with tool()               |
| toolsRequiringConfirmation option     | Use needsApproval on server tools                |
| experimental\_automaticToolResolution | Use onToolCall callback                          |
| tools option in useAgentChat          | Use onToolCall for client-side execution         |
| addToolResult()                       | Use addToolOutput()                              |  
#### Breaking Changes Summary

  1. **Unified Tool Pattern**: All tools must be defined on the server using `tool()`
  2. **`convertToModelMessages()` is async**: Add `await` to all calls
  3. **`CoreMessage` removed**: Use `ModelMessage` instead
  4. **`generateObject` mode removed**: Remove `mode` option
  5. **`isToolUIPart` behavior changed**: Now checks both static and dynamic tool parts  
#### Installation  
Update your dependencies to use the latest versions:  
```bash  
npm install agents@^0.3.0 workers-ai-provider@^3.0.0 ai-gateway-provider@^3.0.0 ai@^6.0.0 @ai-sdk/react@^3.0.0 @ai-sdk/openai@^3.0.0  
```  
#### Resources

  * [Migration Guide ↗](https://github.com/cloudflare/agents/blob/main/docs/migration-to-ai-sdk-v6.md) \- Comprehensive migration documentation from v5 to v6
  * [AI SDK v6 Documentation ↗](https://ai-sdk.dev/docs/migration-guides/migration-guide-6-0) \- Official AI SDK migration guide
  * [AI SDK v6 Announcement ↗](https://vercel.com/blog/ai-sdk-6) \- Learn about new features in v6
  * [AI SDK Documentation ↗](https://sdk.vercel.ai/docs) \- Complete AI SDK reference
  * [GitHub Issues ↗](https://github.com/cloudflare/agents/issues) \- Report bugs or request features  
#### Feedback Welcome  
We'd love your feedback! We're particularly interested in feedback on:

  * **Migration experience** \- How smooth was the upgrade from v5 to v6?
  * **Unified tool pattern** \- How does the new server-defined tool pattern work for you?
  * **Dynamic tool approval** \- Does the `needsApproval` feature meet your needs?
  * **AI Gateway integration** \- How well does the new provider work with your setup?

Dec 19, 2025
1. ### [Terraform v5.15.0 now available](https://edgetunnel-b2h.pages.dev/changelog/post/2025-12-19-terraform-v5150-provider/)  
[ Cloudflare Fundamentals ](https://edgetunnel-b2h.pages.dev/fundamentals/)[ Terraform ](https://edgetunnel-b2h.pages.dev/terraform/)  
Earlier this year, we announced the launch of the new Terraform v5 Provider. We are aware of the high number of issues reported by the Cloudflare community related to the v5 release. We have committed to releasing improvements on a [2-3 week cadence ↗](https://github.com/cloudflare/terraform-provider-cloudflare/issues/5774) to ensure its stability and reliability, including the v5.15 release. We have also pivoted from an [issue-to-issue approach to a resource-per-resource approach ↗](https://github.com/cloudflare/terraform-provider-cloudflare/issues/6237) \- we will be focusing on specific resources to not only stabilize the resource but also ensure it is migration-friendly for those migrating from v4 to v5.  
Thank you for continuing to raise issues. They make our provider stronger and help us build products that reflect your needs.  
This release includes bug fixes, the stabilization of even more popular resources, and more.  
#### Features

  * **ai\_search:** Add AI Search endpoints ([6f02adb ↗](https://github.com/cloudflare/terraform-provider-cloudflare/commit/6f02adb420e872457f71f95b49cb527663388915))
  * **certificate\_pack:** Ensure proper Terraform resource ID handling for path parameters in API calls ([081f32a ↗](https://github.com/cloudflare/terraform-provider-cloudflare/commit/081f32acab4ce9a194a7ff51c8e9fcabd349895a))
  * **worker\_version:** Support `startup_time_ms` ([286ab55 ↗](https://github.com/cloudflare/terraform-provider-cloudflare/commit/286ab55bea8d5be0faa5a2b5b8b157e4a2214eba))
  * **zero\_trust\_dlp\_custom\_entry:** Support `upload_status` ([7dc0fe3 ↗](https://github.com/cloudflare/terraform-provider-cloudflare/commit/7dc0fe3b23726ead8dc075f86728a0540846d90c))
  * **zero\_trust\_dlp\_entry:** Support `upload_status` ([7dc0fe3 ↗](https://github.com/cloudflare/terraform-provider-cloudflare/commit/7dc0fe3b23726ead8dc075f86728a0540846d90c))
  * **zero\_trust\_dlp\_integration\_entry:** Support `upload_status` ([7dc0fe3 ↗](https://github.com/cloudflare/terraform-provider-cloudflare/commit/7dc0fe3b23726ead8dc075f86728a0540846d90c))
  * **zero\_trust\_dlp\_predefined\_entry:** Support `upload_status` ([7dc0fe3 ↗](https://github.com/cloudflare/terraform-provider-cloudflare/commit/7dc0fe3b23726ead8dc075f86728a0540846d90c))
  * **zero\_trust\_gateway\_policy:** Support `forensic_copy` ([5741fd0 ↗](https://github.com/cloudflare/terraform-provider-cloudflare/commit/5741fd0ed9f7270d20731cc47ec45eb0403a628b))
  * **zero\_trust\_list:** Support additional types (category, location, device) ([5741fd0 ↗](https://github.com/cloudflare/terraform-provider-cloudflare/commit/5741fd0ed9f7270d20731cc47ec45eb0403a628b))  
#### Bug fixes

  * **access\_rules:** Add validation to prevent state drift. Ideally, we'd use Semantic Equality but since that isn't an option, this will remove a foot-gun. ([4457791 ↗](https://github.com/cloudflare/terraform-provider-cloudflare/commit/44577911b3cbe45de6279aefa657bdee73c0794d))
  * **cloudflare\_pages\_project:** Addressing drift issues ([6edffcf ↗](https://github.com/cloudflare/terraform-provider-cloudflare/commit/6edffcfcf187fdc9b10b624b9a9b90aed2fb2b2e)) ([3db318e ↗](https://github.com/cloudflare/terraform-provider-cloudflare/commit/3db318e747423bf10ce587d9149e90edcd8a77b0))
  * **cloudflare\_worker:** Can be cleanly imported ([4859b52 ↗](https://github.com/cloudflare/terraform-provider-cloudflare/commit/4859b52968bb25570b680df9813f8e07fd50728f))
  * **cloudflare\_worker:** Ensure clean imports ([5b525bc ↗](https://github.com/cloudflare/terraform-provider-cloudflare/commit/5b525bc478a4e2c9c0d4fd659b92cc7f7c18016a))
  * **list\_items:** Add validation for IP List items to avoid inconsistent state ([b6733dc ↗](https://github.com/cloudflare/terraform-provider-cloudflare/commit/b6733dc4be909a5ab35895a88e519fc2582ccada))
  * **zero\_trust\_access\_application:** Remove all conditions from sweeper ([3197f1a ↗](https://github.com/cloudflare/terraform-provider-cloudflare/commit/3197f1aed61be326d507d9e9e3b795b9f1d18fd7))
  * **spectrum\_application:** Map missing fields during spectrum resource import ([#6495 ↗](https://github.com/cloudflare/terraform-provider-cloudflare/issues/6495)) ([ddb4e72 ↗](https://github.com/cloudflare/terraform-provider-cloudflare/commit/ddb4e722b82c735825a549d651a9da219c142efa))  
#### Upgrade to newer version  
We suggest waiting to migrate to v5 while we work on stabilization. This helps with avoiding any blocking issues while the Terraform resources are actively being [stabilized ↗](https://github.com/cloudflare/terraform-provider-cloudflare/issues/6237). We will be releasing a new migration tool in March 2026 to help support v4 to v5 transitions for our most popular resources.  
#### For more information

  * [Terraform Provider ↗](https://registry.terraform.io/providers/cloudflare/cloudflare/latest/docs)
  * [Documentation on using Terraform with Cloudflare](https://edgetunnel-b2h.pages.dev/terraform/)

Dec 19, 2025
1. ### [Static prerendering support for TanStack Start](https://edgetunnel-b2h.pages.dev/changelog/post/2025-12-19-tanstack-start-prerendering/)  
[ Workers ](https://edgetunnel-b2h.pages.dev/workers/)  
[TanStack Start ↗](https://tanstack.com/start/) apps can now prerender routes to static HTML at build time with access to build time environment variables and bindings, and serve them as [static assets](https://edgetunnel-b2h.pages.dev/workers/static-assets/). To enable prerendering, configure the `prerender` option of the TanStack Start plugin in your Vite config:

**vite.config.ts**  
```ts  
import { defineConfig } from "vite";  
import { cloudflare } from "@cloudflare/vite-plugin";  
import { tanstackStart } from "@tanstack/react-start/plugin/vite";  
export default defineConfig({  
  plugins: [  
    cloudflare({ viteEnvironment: { name: "ssr" } }),  
    tanstackStart({  
      prerender: {  
        enabled: true,  
      },  
    }),  
  ],  
});  
```  
This feature requires `@tanstack/react-start` v1.138.0 or later. See the [TanStack Start framework guide](https://edgetunnel-b2h.pages.dev/workers/framework-guides/web-apps/tanstack-start/#static-prerendering) for more details.

Dec 18, 2025
1. ### [R2 Data Catalog now supports automatic snapshot expiration](https://edgetunnel-b2h.pages.dev/changelog/post/2025-12-18-r2-data-catalog-snapshot-expiration/)  
[ R2 ](https://edgetunnel-b2h.pages.dev/r2/)  
[R2 Data Catalog](https://edgetunnel-b2h.pages.dev/r2/data-catalog/) now supports automatic snapshot expiration for Apache Iceberg tables.  
In Apache Iceberg, a snapshot is metadata that represents the state of a table at a given point in time. Every mutation creates a new snapshot which enable powerful features like time travel queries and rollback capabilities but will accumulate over time.  
Without regular cleanup, these accumulated snapshots can lead to:

  * Metadata overhead
  * Slower table operations
  * Increased storage costs.  
Snapshot expiration in R2 Data Catalog automatically removes old table snapshots based on your configured retention policy, improving performance and storage costs.  
```bash  
# Enable catalog-level snapshot expiration  
# Expire snapshots older than 7 days, always retain at least 10 recent snapshots  
npx wrangler r2 bucket catalog snapshot-expiration enable my-bucket \
  --older-than-days 7 \
  --retain-last 10  
```  
Snapshot expiration uses two parameters to determine which snapshots to remove:

  * `--older-than-days`: age threshold in days
  * `--retain-last`: minimum snapshot count to retain  
Both conditions must be met before a snapshot is expired, ensuring you always retain recent snapshots even if they exceed the age threshold.  
This feature complements [automatic compaction](https://edgetunnel-b2h.pages.dev/r2/data-catalog/table-maintenance/), which optimizes query performance by combining small data files into larger ones. Together, these automatic maintenance operations keep your Iceberg tables performant and cost-efficient without manual intervention.  
To learn more about snapshot expiration and how to configure it, visit our [table maintenance documentation](https://edgetunnel-b2h.pages.dev/r2/data-catalog/table-maintenance/) or see [how to manage catalogs](https://edgetunnel-b2h.pages.dev/r2/data-catalog/manage-catalogs/).

Dec 18, 2025
1. ### [Workers for Platforms - Dashboard Improvements](https://edgetunnel-b2h.pages.dev/changelog/post/2025-12-18-dashboard-improvements/)  
[ Workers for Platforms ](https://edgetunnel-b2h.pages.dev/cloudflare-for-platforms/workers-for-platforms/)  
[Workers for Platforms](https://edgetunnel-b2h.pages.dev/cloudflare-for-platforms/workers-for-platforms/) lets you build multi-tenant platforms on [Cloudflare Workers](https://edgetunnel-b2h.pages.dev/workers/), allowing your end users to deploy and run their own code on your platform. It's designed for anyone building an AI vibe coding platform, e-commerce platform, website builder, or any product that needs to securely execute user-generated code at scale.  
Previously, setting up Workers for Platforms required using the API. Now, the Workers for Platforms UI supports namespace creation, dispatch worker templates, and tag management, making it easier for Workers for Platforms customers to build and manage multi-tenant platforms directly from the Cloudflare dashboard.  
![Workers for Platforms Dashboard Improvements](https://edgetunnel-b2h.pages.dev/_astro/dashboard-improvements.ChVWUo88_ZNokyq.webp)  
#### Key improvements

  * **Namespace Management:** You can now create and configure [dispatch namespaces](https://edgetunnel-b2h.pages.dev/cloudflare-for-platforms/workers-for-platforms/how-workers-for-platforms-works/#dispatch-namespace) directly within the dashboard to start a new platform setup.
  * **Dispatch Worker Templates:** New Dispatch Worker templates allow you to quickly define how traffic is routed to individual Workers within your namespace. Refer to the [Dynamic Dispatch documentation](https://edgetunnel-b2h.pages.dev/cloudflare-for-platforms/workers-for-platforms/configuration/dynamic-dispatch/) for more examples.
  * **Tag Management:** You can now set and update [tags](https://edgetunnel-b2h.pages.dev/cloudflare-for-platforms/workers-for-platforms/configuration/tags/) on User Workers, making it easier to group and manage your Workers.
  * **Binding Visibility:** [Bindings](https://edgetunnel-b2h.pages.dev/cloudflare-for-platforms/workers-for-platforms/configuration/bindings/) attached to User Workers are now visible directly within the User Worker view.
  * **Deploy Vibe Coding Platform in one-click:** Deploy a [reference implementation](https://edgetunnel-b2h.pages.dev/reference-architecture/diagrams/ai/ai-vibe-coding-platform/) of an AI vibe coding platform directly from the dashboard. Powered by the Cloudflare's [VibeSDK ↗](https://github.com/cloudflare/vibesdk), this starter kit integrates with Workers for Platforms to handle the deployment of AI-generated projects at scale.  
To get started, go to **Workers for Platforms** under **Compute & AI** in the [Cloudflare dashboard ↗](https://dash.cloudflare.com/).

Dec 18, 2025
1. ### [Build image policies for Workers Builds and Cloudflare Pages](https://edgetunnel-b2h.pages.dev/changelog/post/2025-12-01-build-image-policies-dev-plat/)  
[ Workers ](https://edgetunnel-b2h.pages.dev/workers/)  
We've published build image policies for [Workers Builds](https://edgetunnel-b2h.pages.dev/workers/ci-cd/builds/build-image/#build-image-policy) and [Cloudflare Pages](https://edgetunnel-b2h.pages.dev/pages/configuration/build-image/#build-image-policy), which establish:

  * **Minor version updates**: We typically update preinstalled software to the latest available minor version without notice. For tools that don't follow semantic versioning (e.g., Bun or Hugo), we provide 3 months’ notice.
  * **Major version updates**: Before preinstalled software reaches end-of-life, we update to the next stable LTS version with 3 months’ notice.
  * **Build image version deprecation (Pages only)**: We provide 6 months’ notice before deprecation. Projects on v1 or v2 will be automatically moved to v3 on their specified deprecation dates.  
To prepare for updates, monitor the [Cloudflare Changelog ↗](https://edgetunnel-b2h.pages.dev/changelog/), dashboard notifications, and email. You can also [override default versions](https://edgetunnel-b2h.pages.dev/workers/ci-cd/builds/build-image/#overriding-default-versions) to maintain specific versions.

Dec 18, 2025
1. ### [Retrieve your authentication token with \`wrangler auth token\`](https://edgetunnel-b2h.pages.dev/changelog/post/2025-12-18-wrangler-auth-token/)  
[ Workers ](https://edgetunnel-b2h.pages.dev/workers/)  
Wrangler now includes a new [wrangler auth token](https://edgetunnel-b2h.pages.dev/workers/wrangler/commands/general/#auth-token) command that retrieves your current authentication token or credentials for use with other tools and scripts.  
```sh  
wrangler auth token  
```  
The command returns whichever authentication method is currently configured, in priority order: API token from `CLOUDFLARE_API_TOKEN`, or OAuth token from `wrangler login` (automatically refreshed if expired).  
Use the `--json` flag to get structured output including the token type:  
```sh  
wrangler auth token --json  
```  
The JSON output includes the authentication type:

**JSONC**  
```jsonc  
// API token  
{ "type": "api_token", "token": "..." }  
// OAuth token  
{ "type": "oauth", "token": "..." }  
// API key/email (only available with --json)  
{ "type": "api_key", "key": "...", "email": "..." }  
```  
API key/email credentials from `CLOUDFLARE_API_KEY` and `CLOUDFLARE_EMAIL` require the `--json` flag since this method uses two values instead of a single token.

Dec 16, 2025
1. ### [Support for ctx.exports in @cloudflare/vitest-pool-workers](https://edgetunnel-b2h.pages.dev/changelog/post/2025-12-16-vitest-ctx-exports-support/)  
[ Workers ](https://edgetunnel-b2h.pages.dev/workers/)  
The [@cloudflare/vitest-pool-workers](https://edgetunnel-b2h.pages.dev/workers/testing/vitest-integration/) package now supports the [ctx.exports API](https://edgetunnel-b2h.pages.dev/workers/runtime-apis/context/#exports), allowing you to access your Worker's top-level exports during tests.  
You can access `ctx.exports` in unit tests by calling `createExecutionContext()`:

**TypeScript**  
```ts  
import { createExecutionContext } from "cloudflare:test";  
import { it, expect } from "vitest";  
it("can access ctx.exports", async () => {  
  const ctx = createExecutionContext();  
  const result = await ctx.exports.MyEntryPoint.myMethod();  
  expect(result).toBe("expected value");  
});  
```  
Alternatively, you can import `exports` directly from `cloudflare:workers`:

**TypeScript**  
```ts  
import { exports } from "cloudflare:workers";  
import { it, expect } from "vitest";  
it("can access imported exports", async () => {  
  const result = await exports.MyEntryPoint.myMethod();  
  expect(result).toBe("expected value");  
});  
```  
See the [context-exports fixture ↗](https://github.com/cloudflare/workers-sdk/tree/main/fixtures/vitest-pool-workers-examples/context-exports) for a complete example.

Dec 16, 2025
1. ### [Configure your framework for Cloudflare automatically](https://edgetunnel-b2h.pages.dev/changelog/post/2025-12-16-wrangler-autoconfig/)  
[ Workers ](https://edgetunnel-b2h.pages.dev/workers/)  
Wrangler now supports automatic configuration for popular web frameworks in experimental mode, making it even easier to deploy to Cloudflare Workers.  
Previously, if you wanted to deploy an application using a popular web framework like Next.js or Astro, you had to follow tutorials to set up your application for deployment to Cloudflare Workers. This usually involved creating a Wrangler file, installing adapters, or changing configuration options.  
Now `wrangler deploy` does this for you. Starting with Wrangler 4.55, you can use `npx wrangler deploy --x-autoconfig` in the directory of any web application using one of the supported frameworks. Wrangler will then proceed to configure and deploy it to your Cloudflare account.  
You can also configure your application without deploying it by using the new `npx wrangler setup` command. This enables you to easily review what changes we are making so your application is ready for Cloudflare Workers.  
The following application frameworks are supported starting today:

  * Next.js
  * Astro
  * Nuxt
  * TanStack Start
  * SolidStart
  * React Router
  * SvelteKit
  * Docusaurus
  * Qwik
  * Analog  
Automatic configuration also supports static sites by detecting the assets directory and build command. From a single index.html file to the output of a generator like Jekyll or Hugo, you can just run `npx wrangler deploy --x-autoconfig` to upload to Cloudflare.  
We're really excited to bring you automatic configuration so you can do more with Workers. Please let us know if you run into challenges using this experimentally. We’ve opened a [GitHub discussion ↗](https://github.com/cloudflare/workers-sdk/discussions/11667) and would love to hear your feedback.

Dec 15, 2025
1. ### [New Best Practices guide for Durable Objects](https://edgetunnel-b2h.pages.dev/changelog/post/2025-12-15-rules-of-durable-objects/)  
[ Durable Objects ](https://edgetunnel-b2h.pages.dev/durable-objects/)[ Workers ](https://edgetunnel-b2h.pages.dev/workers/)  
A new [Rules of Durable Objects](https://edgetunnel-b2h.pages.dev/durable-objects/best-practices/rules-of-durable-objects/) guide is now available, providing opinionated best practices for building effective Durable Objects applications. This guide covers design patterns, storage strategies, concurrency, and common anti-patterns to avoid.  
Key guidance includes:

  * **Design around your "atom" of coordination** — Create one Durable Object per logical unit (chat room, game session, user) instead of a global singleton that becomes a bottleneck.
  * **Use SQLite storage with RPC methods** — SQLite-backed Durable Objects with typed RPC methods provide the best developer experience and performance.
  * **Understand input and output gates** — Learn how Cloudflare's runtime prevents data races by default, how write coalescing works, and when to use `blockConcurrencyWhile()`.
  * **Leverage Hibernatable WebSockets** — Reduce costs for real-time applications by allowing Durable Objects to sleep while maintaining WebSocket connections.  
The [testing documentation](https://edgetunnel-b2h.pages.dev/durable-objects/examples/testing-with-durable-objects/) has also been updated with modern patterns using `@cloudflare/vitest-pool-workers`, including examples for testing SQLite storage, alarms, and direct instance access:

  * [  JavaScript ](#tab-panel-3541)
  * [  TypeScript ](#tab-panel-3542)

**test/counter.test.js**  
```js  
import { env, runDurableObjectAlarm } from "cloudflare:test";  
import { it, expect } from "vitest";  
it("can test Durable Objects with isolated storage", async () => {  
  const stub = env.COUNTER.getByName("test");  
  // Call RPC methods directly on the stub  
  await stub.increment();  
  expect(await stub.getCount()).toBe(1);  
  // Trigger alarms immediately without waiting  
  await runDurableObjectAlarm(stub);  
});  
```

**test/counter.test.ts**  
```ts  
import { env, runDurableObjectAlarm } from "cloudflare:test";  
import { it, expect } from "vitest";  
it("can test Durable Objects with isolated storage", async () => {  
  const stub = env.COUNTER.getByName("test");  
  // Call RPC methods directly on the stub  
  await stub.increment();  
  expect(await stub.getCount()).toBe(1);  
  // Trigger alarms immediately without waiting  
  await runDurableObjectAlarm(stub);  
});  
```

Dec 12, 2025
1. ### [Billing for SQLite Storage](https://edgetunnel-b2h.pages.dev/changelog/post/2025-12-12-durable-objects-sqlite-storage-billing/)  
[ Durable Objects ](https://edgetunnel-b2h.pages.dev/durable-objects/)[ Workers ](https://edgetunnel-b2h.pages.dev/workers/)  
Storage billing for SQLite-backed Durable Objects will be enabled in January 2026, with a target date of January 7, 2026 (no earlier).  
To view your SQLite storage usage, go to the **Durable Objects** page  
[ Go to **Durable Objects** ](https://dash.cloudflare.com/?to=/:account/workers/durable-objects)  
If you do not want to incur costs, please take action such as optimizing queries or deleting unnecessary stored data in order to reduce your SQLite storage usage ahead of the January 7th target. Only usage on and after the billing target date will incur charges.  
Developers on the Workers Paid plan with Durable Object's SQLite storage usage beyond included limits will incur charges according to [SQLite storage pricing](https://edgetunnel-b2h.pages.dev/durable-objects/platform/pricing/#sqlite-storage-backend) announced in September 2024 with the [public beta ↗](https://blog.cloudflare.com/sqlite-in-durable-objects/). Developers on the Workers Free plan will not be charged.  
Compute billing for SQLite-backed Durable Objects has been enabled since the initial public beta. SQLite-backed Durable Objects currently incur [charges for requests and duration](https://edgetunnel-b2h.pages.dev/durable-objects/platform/pricing/#compute-billing), and no changes are being made to compute billing.  
For more information about SQLite storage pricing and limits, refer to the [Durable Objects pricing documentation](https://edgetunnel-b2h.pages.dev/durable-objects/platform/pricing/#sqlite-storage-backend).

Dec 12, 2025
1. ### [R2 SQL now supports aggregations and schema discovery](https://edgetunnel-b2h.pages.dev/changelog/post/2025-12-12-aggregation-support-and-more/)  
[ R2 SQL ](https://edgetunnel-b2h.pages.dev/r2-sql/)  
R2 SQL now supports aggregation functions, `GROUP BY`, `HAVING`, along with schema discovery commands to make it easy to explore your data catalog.  
#### Aggregation Functions  
You can now perform aggregations on Apache Iceberg tables in [R2 Data Catalog](https://edgetunnel-b2h.pages.dev/r2/data-catalog/) using standard SQL functions including `COUNT(*)`, `SUM()`, `AVG()`, `MIN()`, and `MAX()`. Combine these with `GROUP BY` to analyze data across dimensions, and use `HAVING` to filter aggregated results.  
```sql
-- Calculate average transaction amounts by department  
SELECT department, COUNT(*), AVG(total_amount)  
FROM my_namespace.sales_data  
WHERE region = 'North'  
GROUP BY department  
HAVING COUNT(*) > 50  
ORDER BY AVG(total_amount) DESC  
```  
```sql
-- Find high-value departments  
SELECT department, SUM(total_amount)  
FROM my_namespace.sales_data  
GROUP BY department  
HAVING SUM(total_amount) > 50000  
```  
#### Schema Discovery  
New metadata commands make it easy to explore your data catalog and understand table structures:

  * `SHOW DATABASES` or `SHOW NAMESPACES` \- List all available namespaces
  * `SHOW TABLES IN namespace_name` \- List tables within a namespace
  * `DESCRIBE namespace_name.table_name` \- View table schema and column types  
```bash  
❯ npx wrangler r2 sql query "{ACCOUNT_ID}_{BUCKET_NAME}" "DESCRIBE default.sales_data;"  
 ⛅️ wrangler 4.54.0  
─────────────────────────────────────────────  
┌──────────────────┬────────────────┬──────────┬─────────────────┬───────────────┬───────────────────────────────────────────────────────────────────────────────────────────────────┐  
│ column_name      │ type           │ required │ initial_default │ write_default │ doc                                                                                               │  
├──────────────────┼────────────────┼──────────┼─────────────────┼───────────────┼───────────────────────────────────────────────────────────────────────────────────────────────────┤  
│ sale_id          │ BIGINT         │ false    │                 │               │ Unique identifier for each sales transaction                                                      │  
├──────────────────┼────────────────┼──────────┼─────────────────┼───────────────┼───────────────────────────────────────────────────────────────────────────────────────────────────┤  
│ sale_timestamp   │ TIMESTAMPTZ    │ false    │                 │               │ Exact date and time when the sale occurred (used for partitioning)                                │  
├──────────────────┼────────────────┼──────────┼─────────────────┼───────────────┼───────────────────────────────────────────────────────────────────────────────────────────────────┤  
│ department       │ TEXT           │ false    │                 │               │ Product department (8 categories: Electronics, Beauty, Home, Toys, Sports, Food, Clothing, Books) │  
├──────────────────┼────────────────┼──────────┼─────────────────┼───────────────┼───────────────────────────────────────────────────────────────────────────────────────────────────┤  
│ category         │ TEXT           │ false    │                 │               │ Product category grouping (4 categories: Premium, Standard, Budget, Clearance)                    │  
├──────────────────┼────────────────┼──────────┼─────────────────┼───────────────┼───────────────────────────────────────────────────────────────────────────────────────────────────┤  
│ region           │ TEXT           │ false    │                 │               │ Geographic sales region (5 regions: North, South, East, West, Central)                            │  
├──────────────────┼────────────────┼──────────┼─────────────────┼───────────────┼───────────────────────────────────────────────────────────────────────────────────────────────────┤  
│ product_id       │ INT            │ false    │                 │               │ Unique identifier for the product sold                                                            │  
├──────────────────┼────────────────┼──────────┼─────────────────┼───────────────┼───────────────────────────────────────────────────────────────────────────────────────────────────┤  
│ quantity         │ INT            │ false    │                 │               │ Number of units sold in this transaction (range: 1-50)                                            │  
├──────────────────┼────────────────┼──────────┼─────────────────┼───────────────┼───────────────────────────────────────────────────────────────────────────────────────────────────┤  
│ unit_price       │ DECIMAL(10, 2) │ false    │                 │               │ Price per unit in dollars (range: $5.00-$500.00)                                                  │  
├──────────────────┼────────────────┼──────────┼─────────────────┼───────────────┼───────────────────────────────────────────────────────────────────────────────────────────────────┤  
│ total_amount     │ DECIMAL(10, 2) │ false    │                 │               │ Total sale amount before tax (quantity × unit_price with discounts applied)                       │  
├──────────────────┼────────────────┼──────────┼─────────────────┼───────────────┼───────────────────────────────────────────────────────────────────────────────────────────────────┤  
│ discount_percent │ INT            │ false    │                 │               │ Discount percentage applied to this sale (0-50%)                                                  │  
├──────────────────┼────────────────┼──────────┼─────────────────┼───────────────┼───────────────────────────────────────────────────────────────────────────────────────────────────┤  
│ tax_amount       │ DECIMAL(10, 2) │ false    │                 │               │ Tax amount collected on this sale                                                                 │  
├──────────────────┼────────────────┼──────────┼─────────────────┼───────────────┼───────────────────────────────────────────────────────────────────────────────────────────────────┤  
│ profit_margin    │ DECIMAL(10, 2) │ false    │                 │               │ Profit margin on this sale as a decimal percentage                                                │  
├──────────────────┼────────────────┼──────────┼─────────────────┼───────────────┼───────────────────────────────────────────────────────────────────────────────────────────────────┤  
│ customer_id      │ INT            │ false    │                 │               │ Unique identifier for the customer who made the purchase                                          │  
├──────────────────┼────────────────┼──────────┼─────────────────┼───────────────┼───────────────────────────────────────────────────────────────────────────────────────────────────┤  
│ is_online_sale   │ BOOLEAN        │ false    │                 │               │ Boolean flag indicating if sale was made online (true) or in-store (false)                        │  
├──────────────────┼────────────────┼──────────┼─────────────────┼───────────────┼───────────────────────────────────────────────────────────────────────────────────────────────────┤  
│ sale_date        │ DATE           │ false    │                 │               │ Calendar date of the sale (extracted from sale_timestamp)                                         │  
└──────────────────┴────────────────┴──────────┴─────────────────┴───────────────┴───────────────────────────────────────────────────────────────────────────────────────────────────┘  
Read 0 B across 0 files from R2  
On average, 0 B / s  
```  
To learn more about the new aggregation capabilities and schema discovery commands, check out the [SQL reference](https://edgetunnel-b2h.pages.dev/r2-sql/sql-reference/). If you're new to R2 SQL, visit our [getting started guide](https://edgetunnel-b2h.pages.dev/r2-sql/get-started/) to begin querying your data.

Dec 08, 2025
1. ### [Python cold start improvements](https://edgetunnel-b2h.pages.dev/changelog/post/2025-12-08-python-cold-start-improvements/)  
[ Workers ](https://edgetunnel-b2h.pages.dev/workers/)  
Python Workers now feature improved cold start performance, reducing initialization time for new Worker instances. This improvement is particularly noticeable for Workers with larger dependency sets or complex initialization logic.  
Every time you deploy a Python Worker, a memory snapshot is captured after the top level of the Worker is executed. This snapshot captures all imports, including package imports that are often costly to load. The memory snapshot is loaded when the Worker is first started, avoiding the need to reload the Python runtime and all dependencies on each cold start.  
We set up a benchmark that imports common packages ([httpx ↗](https://www.python-httpx.org/), [fastapi ↗](https://fastapi.tiangolo.com/) and [pydantic ↗](https://docs.pydantic.dev/latest/)) to see how Python Workers stack up against other platforms:

| Platform                  | Mean Cold Start (ms) |
| ------------------------- | -------------------- |
| Cloudflare Python Workers | 1027                 |
| AWS Lambda                | 2502                 |
| Google Cloud Run          | 3069                 |  
These benchmarks run continuously. You can view the results and the methodology on our [benchmark page ↗](https://cold.edgeworker.net).  
In additional testing, we have found that without any memory snapshot, the cold start for this benchmark takes around 10 seconds, so this change improves cold start performance by roughly a factor of 10.  
To get started with Python Workers, check out our [Python Workers overview](https://edgetunnel-b2h.pages.dev/workers/languages/python/).

```json
{"@context":"https://schema.org","@type":"BlogPosting","@id":"https://edgetunnel-b2h.pages.dev/changelog/product-group/developer-platform/10/#page","headline":"Developer platform Changelog | Cloudflare Docs","url":"https://edgetunnel-b2h.pages.dev/changelog/product-group/developer-platform/10/","inLanguage":"en","image":"https://edgetunnel-b2h.pages.dev/cf-twitter-card.png","publisher":{"@type":"Organization","name":"Cloudflare","url":"https://www.cloudflare.com/"},"isPartOf":{"@type":"WebSite","@id":"https://edgetunnel-b2h.pages.dev/#website","name":"Cloudflare Docs","url":"https://edgetunnel-b2h.pages.dev/"}}
```