@economic/agents 2.2.3 → 2.3.0

package/README.md

@@ -4,27 +4,28 @@ Our agents SDK for building AI agents on Cloudflare Workers. Each agent is a Dur
 
 React client: [`@economic/agents-react`](../react/README.md).
 
-> The v1 (`@economic/agents/v1`) API (`ChatAgentHarness`, `buildLLMParams`) is deprecated, kept only for migration, and removed in v3.
+> The v1 (`@economic/agents/v1`) API (`ChatAgentHarness`, `buildLLMParams`) is deprecated, kept only for migration, and will be removed in v3.
 
 ## The three classes
 
 - **`Agent`** — the core. Runs the agent loop and keeps message history. Drive it over a WebSocket or programmatically (schedule, alarm, RPC). Most agents stop here.
-- **`ChatAgent`** — `Agent` plus conversation features: compaction and message feedback.
-- **`Assistant`** — per-user shell over `ChatAgent`: create/list/delete conversations, titles, summaries, retention.
+- **`ChatAgent`** — `Agent` plus chat features: compaction and message feedback.
+- **`Assistant`** — per-user shell over `ChatAgent`: create/list/delete chats, titles, summaries, retention.
 
 ```
 Agent            ← LLM + tools + skills (most agents stop here)
- └─ ChatAgent     ← one persistent conversation
-     └─ Assistant ← one user, many conversations
+ └─ ChatAgent     ← one persistent chat
+     └─ Assistant ← one user, many chats
 ```
 
 ## Install
 
 ```sh
-npm install @economic/agents ai
+npm install @economic/agents @cloudflare/think agents
+npm install -D wrangler vite @cloudflare/vite-plugin @cloudflare/worker-bundler
 ```
 
-`jose` is an optional peer dependency, needed only for JWT auth.
+`@economic/agents` provides the agent runtime. Worker apps install the Cloudflare/Agents host packages they import directly, including the Vite plugin stack used by native skills.
 
 ## Quick start: an agent
 
@@ -125,7 +126,7 @@ You can also drive turns server-side — call `saveMessages` from a schedule or
 
 ## A chat agent
 
-For a chat UI, extend `ChatAgent` instead of `Agent`. It adds compaction and message feedback, and connects to a browser with [`useChat`](../react/README.md#usechat) — no `Assistant` required. The DO name is the conversation; address one per user, ticket, or whatever fits.
+For a chat UI, extend `ChatAgent` instead of `Agent`. It adds compaction and message feedback, and connects to a browser with [`useChat`](../react/README.md#usechat) — no `Assistant` required. The DO name is the chat; address one per user, ticket, or whatever fits.
 
 ```typescript
 import { openai } from "@ai-sdk/openai";
@@ -158,18 +159,18 @@ const { chat } = useChat({
 What `ChatAgent` adds over `Agent`:
 
 - **Compaction** — past 100,000 tokens, older messages are summarised (with `getModel()`) while recent ones are kept verbatim. Storage keeps the full history.
-- **Message feedback** — thumbs up/down with an optional comment, in the conversation's SQLite (`assistant_messages_feedback`, created automatically):
+- **Message feedback** — thumbs up/down with an optional comment, in the chat's SQLite (`assistant_messages_feedback`, created automatically):
 
   | Method                                               | Description                                                  |
   | ---------------------------------------------------- | ------------------------------------------------------------ |
   | `submitMessageFeedback(messageId, rating, comment?)` | `rating` is `1` (up) or `-1` (down). Upserts on the message. |
-  | `getMessageFeedback()`                               | All feedback for the conversation, keyed by message id.      |
+  | `getMessageFeedback()`                               | All feedback for the chat, keyed by message id.              |
 
   Surfaced by the client as `chat.submitMessageFeedback` / `chat.getMessageFeedback`.
 
 ## Many chats per user: Assistant
 
-When one user needs a list of conversations — a sidebar, titles, summaries — add an `Assistant`. It owns the chat list and routes to a `ChatAgent` per conversation.
+When one user needs a list of chats — a sidebar, titles, summaries — add an `Assistant`. It owns the chat list and routes to a `ChatAgent` per chat.
 
 ```typescript
 import { openai } from "@ai-sdk/openai";
@@ -182,7 +183,7 @@ export class MyAssistant extends Assistant {
 }
 ```
 
-Bind both classes (binding name = class name) with a `new_sqlite_classes` migration each. On the client, use [`useAssistant`](../react/README.md#useassistant) — it manages the chat list and connects to the active conversation:
+Bind both classes (binding name = class name) with a `new_sqlite_classes` migration each. On the client, use [`useAssistant`](../react/README.md#useassistant) — it manages the chat list and connects to the active chat:
 
 ```tsx
 const { status, chats, assistant, chat } = useAssistant({
@@ -194,14 +195,14 @@ const { status, chats, assistant, chat } = useAssistant({
 
 The `Assistant` keeps the chat list in its own SQLite (a `chats` table, created automatically) and exposes three callable methods:
 
-| Method           | Returns  | Description                                            |
-| ---------------- | -------- | ------------------------------------------------------ |
-| `createChat()`   | `string` | Creates a conversation and returns its id.             |
-| `getChats()`     | `Chat[]` | The user's conversations, most recently updated first. |
-| `deleteChat(id)` | `void`   | Deletes a conversation and its record.                 |
+| Method           | Returns  | Description                                    |
+| ---------------- | -------- | ---------------------------------------------- |
+| `createChat()`   | `string` | Creates a chat and returns its id.             |
+| `getChats()`     | `Chat[]` | The user's chats, most recently updated first. |
+| `deleteChat(id)` | `void`   | Deletes a chat and its record.                 |
 
-- **Titles and summaries** — generated with `fastModel` after each turn (on the first turn, then refreshed as the conversation grows).
-- **Retention** — inactive conversations are deleted after 90 days, via a Durable Object alarm.
+- **Titles and summaries** — generated with `fastModel` after each turn (on the first turn, then refreshed as the chat grows).
+- **Retention** — inactive chats are deleted after 90 days, via a Durable Object alarm.
 
 ## Bindings
 
@@ -212,6 +213,7 @@ Checked in `Agent.onStart` when a connection opens:
 | `AGENTS_AUDIT_LOGS` | R2               | Yes      | Connection rejected if missing. One [audit log](#observability) per turn. |
 | `AGENTS_ANALYTICS`  | Analytics Engine | No       | Per-turn/per-tool [analytics](#observability). Warns if missing.          |
 | `SKILLS_BUCKET`     | R2               | No       | Source for [remote skills](#remote-skills).                               |
+| `LOADER`            | Worker Loader    | No       | Enables [native skill scripts](#skill-scripts) when bound.                |
 
 ## Tools
 
@@ -261,7 +263,16 @@ const call_api = tool({
 
 ## Skills
 
-A skill bundles markdown `instructions` with optional tools. Only `description` sits in the system prompt; the model loads the instructions and tools on demand via the built-in `load_context` tool.
+The SDK supports two skill styles:
+
+- **Code-defined skills** with the local `skill()` helper.
+- **Native Agent Skills** loaded from `SKILL.md` folders via `agents:skills` or remote sources.
+
+Use skills when a capability should be loaded on demand instead of living in the always-on system prompt.
+
+### Code-defined skills
+
+A code-defined skill bundles markdown `instructions` with optional tools. Only `description` sits in the system prompt; the model loads the instructions and tools on demand.
 
 ```typescript
 import { skill, tool } from "@economic/agents";
@@ -293,17 +304,119 @@ Use this skill whenever the user asks about current conditions or a forecast.
 
 Return skills from `getSkills()`. Add `authorize(ctx)` to gate a skill (and its tools). `skill()` throws if `description` or `instructions` is missing.
 
+### Native Agent Skills
+
+Native Agent Skills are folders containing a `SKILL.md` file, with optional references and scripts:
+
+```text
+src/skills/top-customers-by-revenue/
+├── SKILL.md
+└── scripts/
+    └── top-customers.py
+
+src/skills/vat-code-review/
+├── SKILL.md
+├── references/
+│   └── accounting-rules.md
+└── scripts/
+    └── review-invoice-vat.ts
+```
+
+Load bundled skills with the Agents Vite plugin:
+
+```typescript
+import bundledSkills from "agents:skills";
+
+getSkills() {
+  return [bundledSkills];
+}
+```
+
+`SKILL.md` should describe the business workflow, not the implementation mechanism:
+
+```md
+---
+name: top-customers-by-revenue
+description: Find the top customers by revenue from customer and sales data.
+---
+
+# Top Customers By Revenue
+
+1. Call `request` with `{ "endpoint": "customers" }`.
+2. Call `request` with `{ "endpoint": "sales" }`.
+3. Run `scripts/top-customers.py` with the returned customer and sales arrays.
+4. Summarize the top customers by revenue.
+```
+
+### Skill scripts
+
+Skill scripts are enabled when a Worker Loader binding named `LOADER` is present:
+
+```jsonc
+{
+  "worker_loaders": [{ "binding": "LOADER" }],
+}
+```
+
+`Agent` automatically creates a script runner when `env.LOADER` is bound. Without the binding, script execution is unavailable.
+
+TypeScript scripts use the function-style contract:
+
+```typescript
+import type { SkillRunContext } from "@cloudflare/think";
+
+export default async function run(input: unknown, ctx: SkillRunContext) {
+  const rules = ctx.files["references/accounting-rules.md"];
+
+  return {
+    ok: true,
+    rulesLoaded: Boolean(rules),
+  };
+}
+```
+
+Python scripts use the path-based Dynamic Workers contract:
+
+```python
+import json
+from pathlib import Path
+
+input_data = json.loads(Path("/input.json").read_text())
+
+print(json.dumps({
+    "ok": True,
+    "result": input_data,
+}))
+```
+
+Use tools for I/O and scripts for deterministic processing. For example, a skill can call a shared `request` tool to fetch customers and sales, then pass the returned arrays into a Python script that ranks customers by revenue.
+
 ### Remote skills
 
-Store skills in R2 to edit without redeploying and share across agents. Return keys from `getRemoteSkills()`:
+Store skills in R2 to edit without redeploying and share complex skills across agents. Add an R2 skill source from `getSkills()`:
 
 ```typescript
-protected getRemoteSkills() {
-  return ["billing.md", "tax.md"];
+import { skills } from "@cloudflare/think";
+
+getSkills() {
+  return [
+    skills.r2(this.env.SKILLS_BUCKET, {
+      skills: ["top-customers-by-revenue", "vat-code-review"],
+    }),
+  ];
 }
 ```
 
-Loaded from `SKILLS_BUCKET` under the `skills/` prefix — the object's `description` metadata shows up front, the body loads on demand. Skipped (with a logged error) if `SKILLS_BUCKET` isn't bound.
+Remote skills use the same folder shape as bundled skills under the configured R2 prefix:
+
+```text
+skills/top-customers-by-revenue/
+├── SKILL.md
+└── scripts/
+    └── top-customers.py
+```
+
+Source order matters: if two sources define the same skill name, the first source wins.
 
 ## Authentication
 
@@ -359,7 +472,7 @@ Imported from `@economic/agents` unless noted.
 | ----------- | -------------------------------------------------------- |
 | `Agent`     | Core agent base. Implement `getModel`/`getSystemPrompt`. |
 | `ChatAgent` | `Agent` + compaction and message feedback.               |
-| `Assistant` | Per-user manager of `ChatAgent` conversations.           |
+| `Assistant` | Per-user manager of `ChatAgent` chats.                   |
 
 ### Helpers and types
 
@@ -379,13 +492,12 @@ Imported from `@economic/agents` unless noted.
 | `getSystemPrompt(ctx?)`                        | `Agent`     | Required. System prompt.                    |
 | `getTools()`                                   | `Agent`     | Always-on tools (default `{}`).             |
 | `getSkills()`                                  | `Agent`     | Local skills (default `[]`).                |
-| `getRemoteSkills()`                            | `Agent`     | R2 skill keys (default `[]`).               |
 | `static getJwtAuthConfig(env)`                 | `Agent`     | Optional JWT verification config.           |
 | `getUserContext(jwtToken)`                     | `Agent`     | Optional per-user context after auth.       |
 | `submitMessageFeedback` / `getMessageFeedback` | `ChatAgent` | Callable message feedback.                  |
 | `agent`                                        | `Assistant` | Required. Your `ChatAgent` subclass.        |
 | `fastModel`                                    | `Assistant` | Required. Cheap model for titles/summaries. |
-| `createChat` / `getChats` / `deleteChat`       | `Assistant` | Callable conversation management.           |
+| `createChat` / `getChats` / `deleteChat`       | `Assistant` | Callable chat management.                   |
 
 ### Package root (`@economic/agents`)
 

package/dist/index.d.mts

@@ -1,7 +1,10 @@
-import { n as JwtAuthConfig, t as routeAgentRequest } from "./route-agent-request-DmwIOBJS.mjs";
+import { n as JwtAuthConfig, t as routeAgentRequest } from "./route-agent-request-CbjgNl2B.mjs";
 import { Agent as Agent$1, Connection, ConnectionContext, SubAgentClass } from "agents";
-import { ChatResponseResult, Session, StepConfig, Think, ToolCallContext, ToolCallDecision, TurnConfig, TurnContext } from "@cloudflare/think";
+import { ChatResponseResult, PrepareStepContext, Session, Think, ToolCallContext, ToolCallDecision, TurnConfig, TurnContext, skills } from "@cloudflare/think";
 import { JSONValue, LanguageModel, Tool as Tool$1, UIMessage } from "ai";
+import { createCompactFunction } from "agents/experimental/memory/utils";
+import { SkillSource as SkillSource$1 } from "agents/skills";
+
 //#region src/server/types.d.ts
 /**
  * The context object available throughout an agent's lifetime — passed via
@@ -31,20 +34,10 @@ type AgentConnectionState = {
 //#region src/server/util/tools.d.ts
 type ToolSet = Record<string, Tool>;
 type Tool<Context extends Record<string, unknown> = Record<string, unknown>, INPUT extends JSONValue | unknown | never = any, OUTPUT extends JSONValue | unknown | never = any> = Tool$1<INPUT, OUTPUT> & {
-  authorize?: (ctx: Context) => boolean;
+  authorize?: (ctx?: Context) => boolean;
 };
 declare function tool<Context extends Record<string, unknown> = Record<string, unknown>, INPUT extends JSONValue | unknown | never = any, OUTPUT extends JSONValue | unknown | never = any>(tool: Tool<Context, INPUT, OUTPUT>): Tool$1<INPUT, OUTPUT>;
 //#endregion
-//#region src/server/util/skills.d.ts
-interface Skill<Context extends Record<string, unknown> = Record<string, unknown>> {
-  name: string;
-  description: string;
-  instructions: string;
-  tools?: Record<string, Tool<Context>>;
-  authorize?: (ctx: Context) => boolean;
-}
-declare function skill<Context extends Record<string, unknown> = Record<string, unknown>>(definition: Skill<Context>): Skill<Context>;
-//#endregion
 //#region src/server/agents/Agent.d.ts
 declare abstract class Agent<RequestContext extends Record<string, unknown> = Record<string, unknown>, UserContext extends Record<string, unknown> = Record<string, unknown>> extends Think<Cloudflare.Env & AgentEnv, AgentConnectionState> {
   initialState: AgentConnectionState;
@@ -61,6 +54,8 @@ declare abstract class Agent<RequestContext extends Record<string, unknown> = Re
   onClose(): Promise<void>;
   onConnect(connection: Connection, ctx: ConnectionContext): Promise<void>;
   configureSession(session: Session): Session;
+  private _toolsForCurrentTurn;
+  private _toolContextForCurrentTurn?;
   /**
    * Merges the client request `body` into `experimental_context` for tools
    * returned from {@link getTools} only (Think-internal tools are unchanged).
@@ -70,28 +65,29 @@ declare abstract class Agent<RequestContext extends Record<string, unknown> = Re
    */
   beforeTurn(ctx: TurnContext): Promise<void | TurnConfig>;
   /**
-   * Sets active tools based on skills that might be loaded in the current turn.
+   * Sets active tools based on skills that might be loaded during the current turn.
    *
    * @param ctx - The prepare step context.
    * @returns The step config.
    */
-  beforeStep(): Promise<StepConfig | void>;
+  beforeStep(ctx: PrepareStepContext): Promise<{
+    experimental_context: {};
+    activeTools?: undefined;
+  } | {
+    activeTools: string[];
+    experimental_context: {};
+  }>;
   beforeToolCall(ctx: ToolCallContext): Promise<ToolCallDecision | void>;
-  private _buildToolContext;
   getTools(): ToolSet;
+  workspaceBash: boolean;
+  getSkillScriptRunner(): skills.SkillScriptRunner | null;
   /**
    * Returns the remote skills to be loaded from SKILLS_BUCKET.
    * @returns The remote skills to be loaded from SKILLS_BUCKET.
    */
-  /**
-   * Returns the skills to load for the agent.
-   * @returns The skills to load for the agent.
-   */
-  protected getSkills(): Skill[];
+  protected getRemoteSkills(): string[];
   private _getAuthorizedTools;
-  private _getAuthorizedSkills;
-  /** Store the pending user context request to defer awaiting it until after the connection is established */
-  private _requestContext?;
+  private _getLastActivatedSkillName;
   /**
    * Override to enable JWT authentication on WebSocket connections.
    * Return the auth config based on the incoming request, or undefined to skip auth.
@@ -235,16 +231,31 @@ declare abstract class Assistant extends Agent$1<Cloudflare.Env & AgentEnv, Agen
   onStart(): void;
   onClose(): Promise<void>;
   onConnect(connection: Connection, ctx: ConnectionContext): Promise<void>;
+  createChat(): Promise<string>;
+  deleteChat(id: string): Promise<void>;
+  getChats(): Promise<Chat[]>;
+  recordChatTurn(durableObjectName: string, messages: UIMessage[]): Promise<void>;
+  private [DELETE_CHAT_CALLBACK];
+  private scheduleChatForAutoDeletion;
+  /**
+   * Self-registers this Assistant in the global `agent_registry`. An Assistant
+   * is a top-level DO keyed directly by user id, so the DO name *is* the actor.
+   *
+   * Runs pre-auth in onStart (the DO has already persisted state by this point,
+   * so it must be tracked regardless of whether auth later succeeds).
+   * Best-effort and idempotent: no-ops on conflict, retried on the next start.
+   */
+  private registerInstance;
   /**
    * Binding of the legacy v1 chat Durable Object class, used to migrate a
    * user's v1 chats into facets the first time they connect. Set this on the
    * concrete subclass to enable lazy v1 -> v2 migration; leave undefined to
    * disable it (e.g. for greenfield deployments with no v1 data).
    */
-  protected migrationBinding?: {
+  protected getMigrationBinding(_env: Cloudflare.Env & AgentEnv): {
     binding: DurableObjectNamespace;
     db: D1Database;
-  };
+  } | undefined;
   /** In-flight migration, shared across concurrent connections to this DO. */
   private _migrationPromise?;
   /**
@@ -255,24 +266,23 @@ declare abstract class Assistant extends Agent$1<Cloudflare.Env & AgentEnv, Agen
    */
   private ensureMigrated;
   private runMigration;
-  createChat(): Promise<string>;
-  deleteChat(id: string): Promise<void>;
-  getChats(): Promise<Chat[]>;
-  recordChatTurn(durableObjectName: string, messages: UIMessage[]): Promise<void>;
-  private [DELETE_CHAT_CALLBACK];
-  private scheduleChatForAutoDeletion;
-  /**
-   * Self-registers this Assistant in the global `agent_registry`. An Assistant
-   * is a top-level DO keyed directly by user id, so the DO name *is* the actor.
-   *
-   * Runs pre-auth in onStart (the DO has already persisted state by this point,
-   * so it must be tracked regardless of whether auth later succeeds).
-   * Best-effort and idempotent: no-ops on conflict, retried on the next start.
-   */
-  private registerInstance;
 }
 //#endregion
+//#region src/server/util/skills.d.ts
+interface Skill<Context extends Record<string, unknown> = Record<string, unknown>> {
+  name: string;
+  description: string;
+  instructions: string;
+  tools?: Record<string, Tool<Context>>;
+  authorize?: (ctx?: Context) => boolean;
+}
+interface SkillSource<Context extends Record<string, unknown> = Record<string, unknown>> extends SkillSource$1 {
+  tools?: Record<string, Tool<Context>>;
+  authorize?: (ctx?: Context | undefined) => boolean;
+}
+declare function skill<Context extends Record<string, unknown> = Record<string, unknown>>(definition: Skill<Context>): SkillSource<Context>;
+//#endregion
 //#region src/server/index.d.ts
 declare function getCurrentToolContext(): any;
 //#endregion
-export { Agent, type AgentConnectionState, type AgentConnectionStatus, type AgentConnectionType, type AgentEnv, Assistant, ChatAgent, type FacetStub, type LegacyChatStub, type LegacyMessageFeedback, type MigrationDeps, type Skill, type Tool, type ToolContext, type ToolSet, getCurrentToolContext, migrateUserFromV1, routeAgentRequest, skill, tool };
+export { Agent, type AgentConnectionState, type AgentConnectionStatus, type AgentConnectionType, type AgentEnv, Assistant, ChatAgent, type FacetStub, type LegacyChatStub, type LegacyMessageFeedback, type MigrationDeps, type Skill, type SkillSource, type Tool, type ToolContext, type ToolSet, getCurrentToolContext, migrateUserFromV1, routeAgentRequest, skill, tool };

package/dist/index.mjs

@@ -1,6 +1,6 @@
-import { i as verifyJwt, n as createAgentTracer, r as extractTokenFromConnectRequest, t as routeAgentRequest } from "./route-agent-request-DKDvDYnR.mjs";
+import { i as verifyJwt, n as createAgentTracer, r as extractTokenFromConnectRequest, t as routeAgentRequest } from "./route-agent-request-lVm3eus2.mjs";
 import { Agent as Agent$1, callable, getCurrentAgent } from "agents";
-import { Think } from "@cloudflare/think";
+import { Think, skills } from "@cloudflare/think";
 import { Output, convertToModelMessages, generateText, jsonSchema, pruneMessages, tool as tool$1 } from "ai";
 import { nanoid } from "nanoid";
 import { createCompactFunction } from "agents/experimental/memory/utils";
@@ -23,24 +23,6 @@ const TURN_PROTOCOL_RULES_PROMPT = `These rules are specific for responding to u
 - Prefer direct tools over code execution. Never use code execution for a single API call — that always belongs in the direct request tool. A small number of sequential direct calls (typically one to three) is also preferred over code execution. Use code execution only when direct tools cannot satisfy the request, for example variable-length loops, pagination across many calls, substantial joining/grouping/calculation, or transformation that would be unreliable to do mentally.
 - Default to making a fresh data call for every new data request, even if similar data was just fetched — data may have changed and freshness matters more than saving a call. Only reuse earlier tool results when the user is explicitly referring back to a specific prior result, for example asking to summarize it or asking about a specific value inside it ("what was the third one called?", "show that as a table"). Any rephrasing, filter, count, or related follow-up that asks for data is a new data request and requires a fresh call.`;
 //#endregion
-//#region src/server/features/session.ts
-var LocalSkillProvider = class {
-	skills;
-	constructor(skills) {
-		this.skills = new Map(skills.map((skill) => [skill.name, skill]));
-	}
-	async get() {
-		const entries = [...this.skills.values()].map((skill) => `- ${skill.name}: ${skill.description}`);
-		if (entries.length === 0) return null;
-		return entries.join("\n");
-	}
-	async load(key) {
-		const skill = this.skills.get(key);
-		if (!skill) return null;
-		return skill.instructions;
-	}
-};
-//#endregion
 //#region src/server/features/registry.ts
 /**
 * Registers a top-level DO in the global registry.
@@ -48,7 +30,7 @@ var LocalSkillProvider = class {
 * Idempotent: keyed on `(agent_name, durable_object_name)`, so repeated calls
 * across cold starts no-op and `created_at` reflects the first registration.
 */
-async function registerAgent(db, input) {
+async function registerAgentInstance(db, input) {
 	await db.prepare(`INSERT INTO agent_registry (agent_name, durable_object_name, actor_id, created_at)
        VALUES (?, ?, ?, ?)
        ON CONFLICT (agent_name, durable_object_name) DO NOTHING`).bind(input.agentName, input.durableObjectName, input.actorId, input.createdAt).run();
@@ -149,13 +131,12 @@ var Agent = class extends Think {
 		});
 	}
 	configureSession(session) {
-		let configuredSession = session.withContext("soul", { provider: { get: async () => {
-			return this.getSystemPrompt(this._requestContext !== void 0 ? this._buildToolContext() : void 0);
-		} } }).withContext("critical-rules", { provider: { get: async () => SECURITY_RULES_PROMPT } }).withContext("turn-protocol-rules", { provider: { get: async () => TURN_PROTOCOL_RULES_PROMPT } });
-		const localSkills = this.getSkills();
-		if (localSkills.length) configuredSession = configuredSession.withContext("local-skills", { provider: new LocalSkillProvider(localSkills) });
-		return configuredSession.withCachedPrompt();
+		return session.withContext("soul", { provider: { get: async () => {
+			return this.getSystemPrompt(this._toolContextForCurrentTurn !== void 0 ? this._toolContextForCurrentTurn : void 0);
+		} } }).withContext("critical-rules", { provider: { get: async () => SECURITY_RULES_PROMPT } }).withContext("turn-protocol-rules", { provider: { get: async () => TURN_PROTOCOL_RULES_PROMPT } }).withCachedPrompt();
 	}
+	_toolsForCurrentTurn = {};
+	_toolContextForCurrentTurn;
 	/**
 	* Merges the client request `body` into `experimental_context` for tools
 	* returned from {@link getTools} only (Think-internal tools are unchanged).
@@ -165,11 +146,16 @@ var Agent = class extends Think {
 	*/
 	async beforeTurn(ctx) {
 		if (this._pendingUserContextRequest) await this._pendingUserContextRequest;
-		this._requestContext = ctx.body ?? {};
+		this._toolContextForCurrentTurn = {
+			...ctx.body ?? {},
+			_userContext: this._userContext
+		};
 		await this.session.refreshSystemPrompt();
-		const { tools, activeTools } = await this._getAuthorizedTools();
+		this._toolsForCurrentTurn = ctx.tools;
+		const activeSkillName = this._getLastActivatedSkillName(ctx.messages);
+		const { tools, activeTools } = await this._getAuthorizedTools(ctx.tools, activeSkillName);
 		return {
-			model: this.getModel(this._buildToolContext()),
+			model: this.getModel(this._toolContextForCurrentTurn),
 			messages: pruneMessages({
 				messages: ctx.messages,
 				toolCalls: [{
@@ -177,7 +163,7 @@ var Agent = class extends Think {
 					tools: []
 				}, {
 					type: "before-last-5-messages",
-					tools: ["load_context"]
+					tools: ["activate_skill"]
 				}]
 			}),
 			tools,
@@ -201,72 +187,81 @@ var Agent = class extends Think {
 		};
 	}
 	/**
-	* Sets active tools based on skills that might be loaded in the current turn.
+	* Sets active tools based on skills that might be loaded during the current turn.
 	*
 	* @param ctx - The prepare step context.
 	* @returns The step config.
 	*/
-	async beforeStep() {
-		const { activeTools } = await this._getAuthorizedTools();
+	async beforeStep(ctx) {
+		const activeSkillName = this._getLastActivatedSkillName(ctx.steps);
+		if (!activeSkillName) return { experimental_context: this._toolContextForCurrentTurn ?? {} };
+		const { activeTools } = await this._getAuthorizedTools(this._toolsForCurrentTurn, activeSkillName);
 		return {
 			activeTools,
-			experimental_context: this._buildToolContext()
+			experimental_context: this._toolContextForCurrentTurn ?? {}
 		};
 	}
 	async beforeToolCall(ctx) {
-		if (ctx.toolName === "load_context" && ctx.input["label"] === "local-skills") {
-			if (!this._getAuthorizedSkills().some((skill) => skill.name === ctx.input["key"])) return {
+		if (ctx.toolName === "activate_skill") {
+			if ((await this.getSkills()).find((source) => source.id === ctx.input["name"])?.authorize?.(this._toolContextForCurrentTurn ?? {}) === false) return {
 				action: "block",
 				reason: "Unauthorized skill"
 			};
 		}
 	}
-	_buildToolContext() {
-		return {
-			...this._requestContext,
-			_userContext: this._userContext
-		};
-	}
 	getTools() {
 		return {};
 	}
+	workspaceBash = false;
+	getSkillScriptRunner() {
+		if (!("LOADER" in this.env)) return null;
+		return skills.runner({ loader: this.env.LOADER });
+	}
 	/**
 	* Returns the remote skills to be loaded from SKILLS_BUCKET.
 	* @returns The remote skills to be loaded from SKILLS_BUCKET.
 	*/
-	/**
-	* Returns the skills to load for the agent.
-	* @returns The skills to load for the agent.
-	*/
-	getSkills() {
+	getRemoteSkills() {
 		return [];
 	}
-	async _getAuthorizedTools() {
-		const sessionTools = await this.session.tools();
-		const agentTools = this.getTools();
-		const tools = {
-			...sessionTools,
-			...agentTools
-		};
-		const activeTools = [...Object.keys(sessionTools), ...Object.keys(agentTools)];
-		const skills = this._getAuthorizedSkills();
-		const activeSkills = await this.session.getLoadedSkillKeys();
-		for (const skill of skills) {
+	async _getAuthorizedTools(availableTools, activeSkillName) {
+		const tools = { ...availableTools };
+		const activeTools = Object.keys(availableTools);
+		const authorizedSkills = (await this.getSkills()).filter((skill) => !skill.authorize || skill.authorize?.(this._toolContextForCurrentTurn) !== false);
+		for (const skill of authorizedSkills) {
 			if (!skill.tools || Object.keys(skill.tools).length === 0) continue;
 			Object.assign(tools, skill.tools);
-			if (activeSkills.has(`local-skills:${skill.name}`)) activeTools.push(...Object.keys(skill.tools));
+			if (skill.id === activeSkillName) activeTools.push(...Object.keys(skill.tools));
 		}
 		return {
 			tools,
-			activeTools: activeTools.filter((toolName) => tools[toolName]?.authorize?.(this._buildToolContext()) !== false)
+			activeTools: activeTools.filter((toolName) => tools[toolName]?.authorize?.(this._toolContextForCurrentTurn) !== false)
 		};
 	}
-	_getAuthorizedSkills() {
-		return this.getSkills().filter((skill) => skill.authorize?.(this._buildToolContext()) !== false);
+	_getLastActivatedSkillName(items = []) {
+		for (let index = items.length - 1; index >= 0; index--) {
+			const item = items[index];
+			if (!item || typeof item !== "object") continue;
+			const record = item;
+			const input = record.input;
+			if ((record.toolName === "activate_skill" || record.type === "tool-activate_skill") && input && typeof input === "object") {
+				const { name } = input;
+				if (typeof name === "string") return name;
+			}
+			for (const key of [
+				"toolResults",
+				"parts",
+				"content"
+			]) {
+				const nestedItems = record[key];
+				if (Array.isArray(nestedItems)) {
+					const skillName = this._getLastActivatedSkillName(nestedItems);
+					if (skillName) return skillName;
+				}
+			}
+		}
 	}
 	/** Store the pending user context request to defer awaiting it until after the connection is established */
-	_requestContext;
-	/** Store the pending user context request to defer awaiting it until after the connection is established */
 	_pendingUserContextRequest;
 	/**
 	* The user context for the session.
@@ -285,7 +280,7 @@ var Agent = class extends Think {
 	async registerInstance() {
 		if (this.parentPath.length > 0) return;
 		try {
-			await registerAgent(this.env.AGENTS_DB, {
+			await registerAgentInstance(this.env.AGENTS_DB, {
 				agentName: this.constructor.name,
 				durableObjectName: this.name,
 				actorId: this.getActorIdFromDurableObjectName(),
@@ -367,7 +362,7 @@ async function summariseChatWithAI(sql, durableObjectName, messages, model) {
 		const { output: { title, summary } } = await generateText({
 			model,
 			system: systemPrompt,
-			messages: await convertToModelMessages(messages.slice(-CHAT_RECENT_MESSAGES_COUNT)),
+			messages: await convertToModelMessages(messages.slice(-20)),
 			output: Output.object({ schema: jsonSchema({
 				type: "object",
 				properties: {
@@ -559,51 +554,6 @@ var Assistant = class extends Agent$1 {
 			subAgentName: this.agent.name
 		});
 	}
-	/**
-	* Binding of the legacy v1 chat Durable Object class, used to migrate a
-	* user's v1 chats into facets the first time they connect. Set this on the
-	* concrete subclass to enable lazy v1 -> v2 migration; leave undefined to
-	* disable it (e.g. for greenfield deployments with no v1 data).
-	*/
-	migrationBinding;
-	/** In-flight migration, shared across concurrent connections to this DO. */
-	_migrationPromise;
-	/**
-	* Runs the lazy v1 -> v2 migration for this user. Concurrent connections to
-	* this DO share a single in-flight run. Idempotency across runs/restarts is
-	* handled by `migrateUserFromV1` deleting each chat's v1 `conversations` row,
-	* so an already-migrated chat is never re-enumerated.
-	*/
-	async ensureMigrated() {
-		if (!this.migrationBinding) return;
-		this._migrationPromise ??= this.runMigration().finally(() => {
-			this._migrationPromise = void 0;
-		});
-		await this._migrationPromise;
-	}
-	async runMigration() {
-		if (!this.migrationBinding) return;
-		try {
-			const result = await migrateUserFromV1({
-				sql: this.sql.bind(this),
-				db: this.migrationBinding.db,
-				userId: this.name,
-				durableObjectBinding: this.migrationBinding.binding,
-				createFacet: async (chatId) => {
-					return await this.subAgent(this.agent, chatId);
-				}
-			});
-			if (result.migrated > 0 || result.failed > 0) console.info("[Assistant] v1 -> v2 migration complete", {
-				userId: this.name,
-				...result
-			});
-		} catch (error) {
-			console.error("[Assistant] v1 -> v2 migration failed", {
-				userId: this.name,
-				error
-			});
-		}
-	}
 	@callable() async createChat() {
 		const id = nanoid();
 		const now = Date.now();
@@ -642,7 +592,7 @@ var Assistant = class extends Agent$1 {
 	*/
 	async registerInstance() {
 		try {
-			await registerAgent(this.env.AGENTS_DB, {
+			await registerAgentInstance(this.env.AGENTS_DB, {
 				agentName: this.constructor.name,
 				durableObjectName: this.name,
 				actorId: this.name,
@@ -652,6 +602,52 @@ var Assistant = class extends Agent$1 {
 			console.error("[Assistant] Failed to register in agent_registry", error);
 		}
 	}
+	/**
+	* Binding of the legacy v1 chat Durable Object class, used to migrate a
+	* user's v1 chats into facets the first time they connect. Set this on the
+	* concrete subclass to enable lazy v1 -> v2 migration; leave undefined to
+	* disable it (e.g. for greenfield deployments with no v1 data).
+	*/
+	getMigrationBinding(_env) {}
+	/** In-flight migration, shared across concurrent connections to this DO. */
+	_migrationPromise;
+	/**
+	* Runs the lazy v1 -> v2 migration for this user. Concurrent connections to
+	* this DO share a single in-flight run. Idempotency across runs/restarts is
+	* handled by `migrateUserFromV1` deleting each chat's v1 `conversations` row,
+	* so an already-migrated chat is never re-enumerated.
+	*/
+	async ensureMigrated() {
+		if (!this.getMigrationBinding(this.env)) return;
+		this._migrationPromise ??= this.runMigration().finally(() => {
+			this._migrationPromise = void 0;
+		});
+		await this._migrationPromise;
+	}
+	async runMigration() {
+		const migrationBinding = this.getMigrationBinding(this.env);
+		if (!migrationBinding) return;
+		try {
+			const result = await migrateUserFromV1({
+				sql: this.sql.bind(this),
+				db: migrationBinding.db,
+				userId: this.name,
+				durableObjectBinding: migrationBinding.binding,
+				createFacet: async (chatId) => {
+					return await this.subAgent(this.agent, chatId);
+				}
+			});
+			if (result.migrated > 0 || result.failed > 0) console.info("[Assistant] v1 -> v2 migration complete", {
+				userId: this.name,
+				...result
+			});
+		} catch (error) {
+			console.error("[Assistant] v1 -> v2 migration failed", {
+				userId: this.name,
+				error
+			});
+		}
+	}
 };
 //#endregion
 //#region src/server/features/messages.ts
@@ -771,7 +767,26 @@ function skill(definition) {
 	if (!definition.name) throw new Error("Skill name is required");
 	if (!definition.description) throw new Error("Skill description is required");
 	if (!definition.instructions) throw new Error("Skill content is required");
-	return definition;
+	return {
+		id: definition.name,
+		fingerprint: definition.name,
+		async list() {
+			return [{
+				name: definition.name,
+				description: definition.description
+			}];
+		},
+		async load(name) {
+			if (name !== definition.name) return null;
+			return {
+				name: definition.name,
+				description: definition.description,
+				body: definition.instructions
+			};
+		},
+		tools: definition.tools,
+		authorize: definition.authorize
+	};
 }
 //#endregion
 //#region src/server/index.ts

package/dist/providers.d.mts

@@ -0,0 +1,36 @@
+import * as _$_ai_sdk_anthropic_internal0 from "@ai-sdk/anthropic/internal";
+import { AnthropicMessagesLanguageModel } from "@ai-sdk/anthropic/internal";
+import * as _$_ai_sdk_google0 from "@ai-sdk/google";
+import { GoogleGenerativeAIProvider } from "@ai-sdk/google";
+import { AnthropicProvider } from "@ai-sdk/anthropic";
+
+//#region src/providers/anthropic.d.ts
+type AnthropicVertexModelId = Parameters<AnthropicProvider>[0];
+interface AnthropicVertexProviderOptions {
+  cloudflareAccountId: string;
+  cloudflareAiGatewayId: string;
+  cloudflareApiToken: string;
+  googleCloudProjectId: string;
+  location?: string;
+  anthropicVersion?: string;
+}
+declare function createAnthropicVertexProvider(options: AnthropicVertexProviderOptions): (modelId: AnthropicVertexModelId) => AnthropicMessagesLanguageModel;
+//#endregion
+//#region src/providers/gemini.d.ts
+type GeminiModelId = Parameters<GoogleGenerativeAIProvider>[0];
+interface GeminiProviderOptions {
+  cloudflareAccountId: string;
+  cloudflareAiGatewayId: string;
+  cloudflareApiToken: string;
+  googleApiKey?: string;
+}
+declare function createGeminiProvider(options: GeminiProviderOptions): GoogleGenerativeAIProvider;
+//#endregion
+//#region src/providers/index.d.ts
+interface AiGatewayVertexProvidersOptions extends AnthropicVertexProviderOptions, GeminiProviderOptions {}
+declare function createAiGatewayVertexProviders(options: AiGatewayVertexProvidersOptions): {
+  anthropic: (modelId: AnthropicVertexModelId) => _$_ai_sdk_anthropic_internal0.AnthropicMessagesLanguageModel;
+  gemini: _$_ai_sdk_google0.GoogleGenerativeAIProvider;
+};
+//#endregion
+export { AiGatewayVertexProvidersOptions, type AnthropicVertexModelId, type AnthropicVertexProviderOptions, type GeminiModelId, type GeminiProviderOptions, createAiGatewayVertexProviders, createAnthropicVertexProvider, createGeminiProvider };

package/dist/providers.mjs

@@ -0,0 +1,46 @@
+import { AnthropicMessagesLanguageModel } from "@ai-sdk/anthropic/internal";
+import { createGoogleGenerativeAI } from "@ai-sdk/google";
+//#region src/providers/anthropic.ts
+function createAnthropicVertexProvider(options) {
+	const { anthropicVersion = "vertex-2023-10-16", cloudflareAccountId, cloudflareAiGatewayId, cloudflareApiToken, googleCloudProjectId, location = "europe-west1" } = options;
+	const anthropicBaseURL = `${`${`https://gateway.ai.cloudflare.com/v1/${cloudflareAccountId}/${cloudflareAiGatewayId}/`}google-vertex-ai/v1/projects/${googleCloudProjectId}/locations/${location}/publishers/`}anthropic/models/`;
+	return function anthropic(modelId) {
+		return new AnthropicMessagesLanguageModel(modelId, {
+			provider: "vertex.anthropic.messages",
+			baseURL: anthropicBaseURL,
+			headers: { "cf-aig-authorization": `Bearer ${cloudflareApiToken}` },
+			buildRequestUrl: (baseURL, isStreaming) => `${baseURL}${modelId}:${isStreaming ? "streamRawPredict" : "rawPredict"}`,
+			transformRequestBody: (args) => {
+				const { model, ...rest } = args;
+				return {
+					...rest,
+					anthropic_version: anthropicVersion
+				};
+			},
+			supportedUrls: () => ({}),
+			supportsNativeStructuredOutput: false,
+			supportsStrictTools: false
+		});
+	};
+}
+//#endregion
+//#region src/providers/gemini.ts
+function createGeminiProvider(options) {
+	const { cloudflareAccountId, cloudflareAiGatewayId, cloudflareApiToken, googleApiKey } = options;
+	return createGoogleGenerativeAI({
+		apiKey: googleApiKey ?? "unused",
+		baseURL: `https://gateway.ai.cloudflare.com/v1/${cloudflareAccountId}/${cloudflareAiGatewayId}/google-ai-studio/v1beta`,
+		headers: { "cf-aig-authorization": `Bearer ${cloudflareApiToken}` },
+		name: "gateway.google.generative-ai"
+	});
+}
+//#endregion
+//#region src/providers/index.ts
+function createAiGatewayVertexProviders(options) {
+	return {
+		anthropic: createAnthropicVertexProvider(options),
+		gemini: createGeminiProvider(options)
+	};
+}
+//#endregion
+export { createAiGatewayVertexProviders, createAnthropicVertexProvider, createGeminiProvider };

package/dist/v1.d.mts

@@ -1,9 +1,9 @@
-import { n as JwtAuthConfig, t as routeAgentRequest } from "./route-agent-request-DmwIOBJS.mjs";
+import { n as JwtAuthConfig, t as routeAgentRequest } from "./route-agent-request-CbjgNl2B.mjs";
 import { Agent as Agent$1, Connection, ConnectionContext } from "agents";
 import { LanguageModel, StreamTextOnFinishCallback, ToolSet, UIMessage, generateText, streamText } from "ai";
 import { AIChatAgent, ChatResponseResult, OnChatMessageOptions } from "@cloudflare/ai-chat";
 
-//#region src/server/features/skills/index.d.ts
+//#region src/server/v1/features/skills/index.d.ts
 /**
  * A named group of related tools that can be loaded together on demand.
  *
@@ -25,7 +25,7 @@ interface Skill {
   tools: ToolSet;
 }
 //#endregion
-//#region src/server/util/llm.d.ts
+//#region src/server/v1/util/llm.d.ts
 type LLMParams = Parameters<typeof streamText>[0] & Parameters<typeof generateText>[0];
 type BuildLLMParamsConfig = Omit<LLMParams, "prompt"> & {
   /** Skill names loaded in previous turns. Pass `await this.getLoadedSkills()`. */activeSkills?: string[]; /** Skills available for on-demand loading this turn. */

package/dist/v1.mjs

@@ -1,10 +1,10 @@
-import { i as verifyJwt, n as createAgentTracer, r as extractTokenFromConnectRequest, t as routeAgentRequest } from "./route-agent-request-DKDvDYnR.mjs";
+import { i as verifyJwt, n as createAgentTracer, r as extractTokenFromConnectRequest, t as routeAgentRequest } from "./route-agent-request-lVm3eus2.mjs";
 import { Agent as Agent$1, callable, getCurrentAgent } from "agents";
 import { Output, convertToModelMessages, generateText, jsonSchema, stepCountIs, streamText, tool } from "ai";
 import { AIChatAgent } from "@cloudflare/ai-chat";
-//#region src/server/features/skills/index.ts
-const TOOL_NAME_ACTIVATE_SKILL = "activate_skill";
-const TOOL_NAME_LIST_CAPABILITIES = "list_capabilities";
+//#region src/server/v1/features/skills/index.ts
+const TOOL_NAME_ACTIVATE_SKILL$1 = "activate_skill";
+const TOOL_NAME_LIST_CAPABILITIES$1 = "list_capabilities";
 const SKILL_STATE_SENTINEL = "\n__SKILLS_STATE__:";
 function buildActivateSkillDescription(skills) {
 	return [
@@ -37,8 +37,8 @@ function createSkills(config) {
 	for (const skill of skills) Object.assign(allTools, skill.tools);
 	function getActiveToolNames() {
 		const names = [
-			TOOL_NAME_ACTIVATE_SKILL,
-			TOOL_NAME_LIST_CAPABILITIES,
+			TOOL_NAME_ACTIVATE_SKILL$1,
+			TOOL_NAME_LIST_CAPABILITIES$1,
 			...Object.keys(alwaysOnTools)
 		];
 		for (const skillName of loadedSkills) {
@@ -57,7 +57,7 @@ function createSkills(config) {
 		if (sections.length === 0) return "";
 		return sections.join("\n\n");
 	}
-	allTools[TOOL_NAME_ACTIVATE_SKILL] = tool({
+	allTools[TOOL_NAME_ACTIVATE_SKILL$1] = tool({
 		description: buildActivateSkillDescription(skills),
 		inputSchema: jsonSchema({
 			type: "object",
@@ -83,7 +83,7 @@ function createSkills(config) {
 			return "All requested skills were already loaded.";
 		}
 	});
-	allTools[TOOL_NAME_LIST_CAPABILITIES] = tool({
+	allTools[TOOL_NAME_LIST_CAPABILITIES$1] = tool({
 		description: LIST_CAPABILITIES_DESCRIPTION,
 		inputSchema: jsonSchema({
 			type: "object",
@@ -115,11 +115,6 @@ function createSkills(config) {
 		}
 	};
 }
-function isEphemeralSkillToolPart(part) {
-	if (!part || typeof part !== "object" || !("toolCallId" in part) || !("type" in part)) return false;
-	const { type } = part;
-	return type === `tool-list_capabilities` || type === `tool-activate_skill`;
-}
 /** Creates the `skill_state` table in DO SQLite if it does not exist yet. */
 function ensureSkillTable(sql) {
 	sql`CREATE TABLE IF NOT EXISTS skill_state (id INTEGER PRIMARY KEY, active_skills TEXT NOT NULL DEFAULT '[]')`;
@@ -161,7 +156,7 @@ function saveSkillStateFromMessages(sql, messages) {
 	sql`INSERT OR REPLACE INTO skill_state(id, active_skills) VALUES(1, ${JSON.stringify(latestSkillState)})`;
 }
 //#endregion
-//#region src/server/util/llm.ts
+//#region src/server/v1/util/llm.ts
 function buildSystemPromptWithSkills(basePrompt, availableSkillList, loadedGuidance) {
 	let prompt = `${basePrompt}
 
@@ -556,7 +551,7 @@ async function updateConversationSummary(db, durableObjectName, title, summary)
 * prompt bounded regardless of total conversation length.
 */
 async function generateTitleAndSummary(messages, model, existingSummary) {
-	const recentMessages = await convertToModelMessages(messages.slice(-SUMMARY_CONTEXT_MESSAGES));
+	const recentMessages = await convertToModelMessages(messages.slice(-15));
 	const previousContext = existingSummary ? `Previous summary:\n${existingSummary}\n\nMost recent messages:` : "Conversation:";
 	const { output } = await generateText({
 		model,
@@ -610,7 +605,12 @@ function getDeleteConversationScheduleIds(schedules) {
 	return schedules.filter((schedule) => schedule.callback === DELETE_CONVERSATION_CALLBACK).map((schedule) => schedule.id);
 }
 //#endregion
-//#region src/server/util/messages.ts
+//#region src/server/v1/util/messages.ts
+function isEphemeralSkillToolPart(part) {
+	if (!part || typeof part !== "object" || !("toolCallId" in part) || !("type" in part)) return false;
+	const { type } = part;
+	return type === `tool-list_capabilities` || type === `tool-activate_skill`;
+}
 function filterEphemeralMessages(messages) {
 	return messages.flatMap((message) => {
 		if (message.role !== "assistant" || !message.parts?.length) return [message];

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@economic/agents",
-  "version": "2.2.3",
+  "version": "2.3.0",
   "description": "A starter for creating a TypeScript package.",
   "license": "MIT",
   "bin": {
@@ -15,6 +15,7 @@
   "exports": {
     ".": "./dist/index.mjs",
     "./cli": "./dist/cli.mjs",
+    "./providers": "./dist/providers.mjs",
     "./v1": "./dist/v1.mjs",
     "./package.json": "./package.json"
   },
@@ -26,30 +27,30 @@
     "prepublishOnly": "npm run build"
   },
   "dependencies": {
+    "@ai-sdk/anthropic": "^3.0.77",
+    "@ai-sdk/google": "^3.0.73",
     "@clack/prompts": "^1.2.0",
-    "@cloudflare/ai-chat": "^0.7.2",
-    "@cloudflare/think": "^0.7.3",
+    "@cloudflare/ai-chat": "^0.8.3",
+    "@cloudflare/think": "^0.8.4",
     "@opentelemetry/sdk-trace-base": "^2.7.1",
-    "agents": "^0.13.3",
+    "agents": "^0.14.3",
+    "ai": "^6.0.197",
+    "jose": "^6.2.3",
     "nanoid": "^5.1.11"
   },
   "devDependencies": {
     "@cloudflare/workers-types": "^4.20260527.1",
     "@types/node": "^25.6.0",
     "@typescript/native-preview": "7.0.0-dev.20260412.1",
-    "ai": "^6.0.175",
-    "jose": "^6.2.2",
     "tsdown": "^0.22.0",
     "typescript": "^6.0.2",
     "vitest": "^4.1.4"
   },
   "peerDependencies": {
-    "ai": "^6.0.0",
-    "jose": "^6.0.0"
-  },
-  "peerDependenciesMeta": {
-    "jose": {
-      "optional": true
-    }
+    "@cloudflare/think": "^0.8.4",
+    "@cloudflare/vite-plugin": "^1.40.0",
+    "@cloudflare/worker-bundler": "^0.2.0",
+    "agents": "^0.14.3",
+    "vite": "^8.0.0"
   }
 }