@dangao/bun-server 2.1.0 → 2.3.0

package/dist/mcp/server.d.ts

@@ -20,8 +20,11 @@ export declare class McpServer {
      */
     handleHttp(req: Request): Promise<Response>;
     /**
-     * Create an SSE response that keeps the connection open for streaming
-     * This is the SSE transport endpoint
+     * Create an SSE response that keeps the connection open for streaming.
+     *
+     * Heartbeat / keep-alive pings are handled automatically by the framework's
+     * SSE post-processor (`sseKeepAlive`), so this method no longer injects its
+     * own `setInterval`.
      */
     createSseResponse(): Response;
     private dispatch;

package/dist/mcp/server.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"server.d.ts","sourceRoot":"","sources":["../../src/mcp/server.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,aAAa,EAAE,cAAc,EAAE,eAAe,EAAE,MAAM,SAAS,CAAC;AAC9E,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,YAAY,CAAC;AAE9C;;;;;GAKG;AACH,qBAAa,SAAS;IACpB,OAAO,CAAC,QAAQ,CAAC,QAAQ,CAAc;IACvC,OAAO,CAAC,QAAQ,CAAC,UAAU,CAAgB;gBAExB,QAAQ,EAAE,WAAW,EAAE,UAAU,EAAE,aAAa;IAKnE;;OAEG;IACU,MAAM,CAAC,OAAO,EAAE,cAAc,GAAG,OAAO,CAAC,eAAe,CAAC;IAgBtE;;;OAGG;IACU,UAAU,CAAC,GAAG,EAAE,OAAO,GAAG,OAAO,CAAC,QAAQ,CAAC;IAQxD;;;OAGG;IACI,iBAAiB,IAAI,QAAQ;YAmCtB,QAAQ;CAkEvB"}
+{"version":3,"file":"server.d.ts","sourceRoot":"","sources":["../../src/mcp/server.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,aAAa,EAAE,cAAc,EAAE,eAAe,EAAE,MAAM,SAAS,CAAC;AAC9E,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,YAAY,CAAC;AAE9C;;;;;GAKG;AACH,qBAAa,SAAS;IACpB,OAAO,CAAC,QAAQ,CAAC,QAAQ,CAAc;IACvC,OAAO,CAAC,QAAQ,CAAC,UAAU,CAAgB;gBAExB,QAAQ,EAAE,WAAW,EAAE,UAAU,EAAE,aAAa;IAKnE;;OAEG;IACU,MAAM,CAAC,OAAO,EAAE,cAAc,GAAG,OAAO,CAAC,eAAe,CAAC;IAgBtE;;;OAGG;IACU,UAAU,CAAC,GAAG,EAAE,OAAO,GAAG,OAAO,CAAC,QAAQ,CAAC;IAQxD;;;;;;OAMG;IACI,iBAAiB,IAAI,QAAQ;YAuBtB,QAAQ;CAkEvB"}

package/docs/idle-timeout.md

@@ -1,22 +1,33 @@
-# idleTimeout
+# idleTimeout & SSE Keep-Alive
 
-`idleTimeout` now supports both global and per-route configuration.
+## Two layers of timeout
+
+Bun Server has **two independent timeout mechanisms** — understanding their difference is critical for SSE / streaming use cases.
+
+| Layer | Config | Scope | Mechanism |
+|-------|--------|-------|-----------|
+| **TCP connection** | `Application({ idleTimeout })` | Bun.serve level | Bun kernel closes the TCP socket when no bytes flow for N seconds |
+| **Handler logic** | `@IdleTimeout(ms)` decorator | Per-route `Promise.race` | Returns `408 Request Timeout` if the handler doesn't resolve in time |
+
+> **Key point:** For SSE responses the handler returns a `Response` immediately (with a streaming body). The handler-level `@IdleTimeout` has already resolved at that point and will **not** protect or kill the stream. Only the TCP-level `idleTimeout` can break an SSE connection.
+
+---
 
 ## Global idle timeout (milliseconds)
 
-Set in `Application` options using milliseconds.  
-Framework converts internally before passing to `Bun.serve`.
+Set in `Application` options using milliseconds.
+Framework converts internally before passing to `Bun.serve` (`Math.ceil(ms / 1000)` → seconds).
 
 ```ts
 const app = new Application({
   port: 3000,
-  idleTimeout: 15000, // ms
+  idleTimeout: 15000, // 15 s — applies to all non-SSE connections
 });
 ```
 
-## Per-route timeout (milliseconds)
+## Per-route timeout — `@IdleTimeout(ms)`
 
-Use `@IdleTimeout(ms)` on controller class or handler method.
+Use `@IdleTimeout(ms)` on a controller class or a handler method.
 
 ```ts
 import { Controller, GET, IdleTimeout } from '@dangao/bun-server';
@@ -38,5 +49,85 @@ class ApiController {
 }
 ```
 
-When timeout is reached, Bun Server throws `HttpException(408, "Request Timeout")`.
+### Matching & precedence
+
+1. **Method-level** `@IdleTimeout` is checked first — if present, it wins.
+2. **Class-level** `@IdleTimeout` is used as fallback.
+3. If neither is set, no handler-level timeout is applied (the route runs until the TCP timeout or until it completes).
+
+When the handler-level timeout fires, the framework throws `HttpException(408, "Request Timeout")`.
+
+---
+
+## SSE Keep-Alive (automatic)
+
+When the framework detects a response with `Content-Type: text/event-stream`, it automatically:
+
+1. **Disables the TCP idle timeout** for that request via `server.timeout(req, 0)`, preventing Bun from killing the long-lived connection.
+2. **Injects SSE comment heartbeats** (`: keepalive\n\n`) at a configurable interval, preventing intermediate proxies (nginx, cloud load balancers) from closing the connection due to inactivity.
+
+### Configuration
+
+```ts
+const app = new Application({
+  port: 3000,
+  idleTimeout: 10000, // normal requests: 10 s
+
+  // SSE keep-alive — defaults shown below
+  sseKeepAlive: {
+    enabled: true,      // auto-detect SSE and inject heartbeat
+    intervalMs: 15000,  // heartbeat every 15 s
+  },
+});
+```
+
+| Option | Type | Default | Description |
+|--------|------|---------|-------------|
+| `sseKeepAlive.enabled` | `boolean` | `true` | Enable automatic SSE detection, TCP timeout reset, and heartbeat injection |
+| `sseKeepAlive.intervalMs` | `number` | `15000` | Heartbeat interval in milliseconds |
+
+When `enabled` is `true` (default), any response whose `Content-Type` header contains `text/event-stream` triggers the SSE post-processor. You do **not** need any special decorator or annotation — detection is purely based on the response header.
+
+When `enabled` is `false`, no SSE-specific processing is applied. You would need to manage keep-alive and `server.timeout` yourself.
+
+---
+
+## Signal cascading (`ctx.signal`)
+
+`Context` exposes the client's `AbortSignal` via `ctx.signal`. When the client disconnects (network failure, browser tab closed, `curl` interrupted), this signal aborts.
+
+For AI streaming endpoints, pass `ctx.signal` to `AiService` so the upstream API request is cancelled immediately — **stopping token consumption**:
+
+```ts
+import { Controller, GET, Context as Ctx } from '@dangao/bun-server';
+import type { Context } from '@dangao/bun-server';
+
+@Controller('/chat')
+class ChatController {
+  constructor(private readonly ai: AiService) {}
+
+  @GET('/stream')
+  public stream(@Ctx() ctx: Context) {
+    const stream = this.ai.stream({
+      messages: [{ role: 'user', content: 'Hello' }],
+      signal: ctx.signal, // ← cascade client disconnect
+    });
+    return new Response(stream, {
+      headers: { 'Content-Type': 'text/event-stream' },
+    });
+  }
+}
+```
+
+> **Note:** The `Context` parameter decorator is exported as both `Context` (from `'./controller'`) and `ContextParam` (from the package root). Use whichever alias avoids name collision with the `Context` type.
+
+The full cancellation chain:
 
+```
+Client disconnects
+  → request.signal aborts
+    → heartbeat timer cleared
+      → wrapped stream cancelled
+        → AI provider fetch() aborted
+          → upstream API connection closed (tokens saved)
+```

package/docs/lifecycle.md

@@ -1,21 +1,29 @@
 # Lifecycle Hooks
 
-Bun Server supports lifecycle hooks that let providers participate in application startup and shutdown. Implement the appropriate interface on your injectable services.
+Bun Server supports lifecycle hooks that let components (`@Injectable` / `@Controller`) participate from creation to destruction.
 
 ## Interfaces
 
 | Interface | Method | When Called |
 |-----------|--------|-------------|
+| `ComponentClassBeforeCreate` | `static onBeforeCreate()` | Right before the component instance is created |
+| `OnAfterCreate` | `onAfterCreate()` | Right after instance creation and post processors |
 | `OnModuleInit` | `onModuleInit()` | After all module providers are registered |
 | `OnModuleDestroy` | `onModuleDestroy()` | During shutdown (reverse order) |
+| `OnBeforeDestroy` | `onBeforeDestroy()` | Before `onModuleDestroy` during shutdown (reverse order) |
+| `OnAfterDestroy` | `onAfterDestroy()` | After `onModuleDestroy` during shutdown (reverse order) |
 | `OnApplicationBootstrap` | `onApplicationBootstrap()` | After all modules init, before server listens |
 | `OnApplicationShutdown` | `onApplicationShutdown(signal?)` | When graceful shutdown begins |
 
 ## Execution Order
 
+**Creation (per component instance)**: `onBeforeCreate` (static) -> instantiate -> `onAfterCreate`
+
 **Startup**: `onModuleInit` (all modules) -> `onApplicationBootstrap` (all modules) -> server starts
 
-**Shutdown**: `onApplicationShutdown` (reverse order) -> `onModuleDestroy` (reverse order)
+**Shutdown**: `onApplicationShutdown` (reverse order) -> `onBeforeDestroy` (reverse order) -> `onModuleDestroy` (reverse order) -> `onAfterDestroy` (reverse order)
+
+For `Lifecycle.Scoped` components, destroy hooks are executed automatically at the end of each request context.
 
 ## Provider Deduplication
 
@@ -23,19 +31,41 @@ When the same provider instance is exported or registered by multiple tokens,
 `onModuleInit` now runs only once for that instance. This avoids duplicate
 initialization side effects in shared singleton objects.
 
-## Example: DatabaseService with init/destroy
+## Example: Component hooks from create to destroy
 
 ```ts
 import {
   Injectable,
+  Controller,
+  GET,
+  Module,
   OnModuleInit,
   OnModuleDestroy,
+  type ComponentClassBeforeCreate,
+  OnAfterCreate,
+  OnBeforeDestroy,
+  OnAfterDestroy,
 } from '@dangao/bun-server';
 
 @Injectable()
-class DatabaseService implements OnModuleInit, OnModuleDestroy {
+class DatabaseService
+  implements
+    OnAfterCreate,
+    OnModuleInit,
+    OnBeforeDestroy,
+    OnModuleDestroy,
+    OnAfterDestroy
+{
   private connected = false;
 
+  public static onBeforeCreate(): void {
+    console.log('[DatabaseService] Before create');
+  }
+
+  public onAfterCreate(): void {
+    console.log('[DatabaseService] After create');
+  }
+
   public async onModuleInit(): Promise<void> {
     console.log('[DatabaseService] Connecting...');
     await this.connect();
@@ -48,6 +78,14 @@ class DatabaseService implements OnModuleInit, OnModuleDestroy {
     this.connected = false;
   }
 
+  public onBeforeDestroy(): void {
+    console.log('[DatabaseService] Before destroy');
+  }
+
+  public onAfterDestroy(): void {
+    console.log('[DatabaseService] After destroy');
+  }
+
   public isConnected(): boolean {
     return this.connected;
   }
@@ -60,6 +98,36 @@ class DatabaseService implements OnModuleInit, OnModuleDestroy {
     // Close DB connection
   }
 }
+
+@Controller('/health')
+class HealthController implements OnAfterCreate, OnBeforeDestroy, OnAfterDestroy {
+  public static onBeforeCreate(): void {
+    console.log('[HealthController] Before create');
+  }
+
+  public onAfterCreate(): void {
+    console.log('[HealthController] After create');
+  }
+
+  public onBeforeDestroy(): void {
+    console.log('[HealthController] Before destroy');
+  }
+
+  public onAfterDestroy(): void {
+    console.log('[HealthController] After destroy');
+  }
+
+  @GET('/')
+  public get(): object {
+    return { ok: true };
+  }
+}
+
+@Module({
+  controllers: [HealthController],
+  providers: [DatabaseService],
+})
+class AppModule {}
 ```
 
 ## Example: Application-level hooks
@@ -75,4 +143,6 @@ class AppService implements OnApplicationBootstrap, OnApplicationShutdown {
     console.log(`Shutting down (signal: ${signal ?? 'none'})`);
   }
 }
+
+const _beforeCreateHook: ComponentClassBeforeCreate = DatabaseService;
 ```

package/docs/zh/idle-timeout.md

@@ -1,19 +1,30 @@
-# idleTimeout
+# idleTimeout 与 SSE 保活
 
-`idleTimeout` 现已支持全局与路由级两种配置方式。
+## 两层超时机制
+
+Bun Server 有**两套独立的超时机制**——理解它们的区别对 SSE / 流式场景至关重要。
+
+| 层面 | 配置方式 | 作用域 | 机制 |
+|------|----------|--------|------|
+| **TCP 连接级** | `Application({ idleTimeout })` | Bun.serve 底层 | Bun 内核在连接无数据流动 N 秒后直接断开 socket |
+| **Handler 逻辑级** | `@IdleTimeout(ms)` 装饰器 | 路由粒度的 `Promise.race` | handler 未在指定时间内 resolve 则返回 `408 Request Timeout` |
+
+> **关键：** 对于 SSE 响应，handler 会立即返回一个带流式 body 的 `Response`。此时 handler 层面的 `@IdleTimeout` 已经 resolve，**不会**保护或终止该流。只有 TCP 级别的 `idleTimeout` 才能断开 SSE 连接。
+
+---
 
 ## 全局 idleTimeout（毫秒）
 
-在 `Application` 中直接按毫秒设置，框架内部会转换后传给 `Bun.serve`。
+在 `Application` 中按毫秒设置，框架内部自动转换后传给 `Bun.serve`（`Math.ceil(ms / 1000)` → 秒）。
 
 ```ts
 const app = new Application({
   port: 3000,
-  idleTimeout: 15000, // ms
+  idleTimeout: 15000, // 15 秒 — 对所有非 SSE 连接生效
 });
 ```
 
-## 路由级超时（毫秒）
+## 路由级超时 — `@IdleTimeout(ms)`
 
 使用 `@IdleTimeout(ms)` 装饰器配置控制器级或方法级超时。
 
@@ -37,5 +48,85 @@ class ApiController {
 }
 ```
 
-超时后会抛出 `HttpException(408, "Request Timeout")`。
+### 匹配与生效规则
+
+1. **方法级** `@IdleTimeout` 优先检测——存在即生效。
+2. **类级** `@IdleTimeout` 作为兜底。
+3. 若均未设置，则不应用 handler 级超时（路由将持续运行直到 TCP 超时或自然完成）。
+
+handler 级超时触发时，框架抛出 `HttpException(408, "Request Timeout")`。
+
+---
+
+## SSE 保活（自动）
+
+当框架检测到响应的 `Content-Type` 包含 `text/event-stream` 时，会自动执行：
+
+1. **禁用该请求的 TCP 空闲超时** —— 通过 `server.timeout(req, 0)` 阻止 Bun 断开长连接。
+2. **注入 SSE 注释心跳** —— 按配置间隔发送 `: keepalive\n\n`，防止中间代理（nginx、云 LB）因空闲而断连。
+
+### 配置
+
+```ts
+const app = new Application({
+  port: 3000,
+  idleTimeout: 10000, // 普通请求：10 秒
+
+  // SSE 保活 — 以下为默认值
+  sseKeepAlive: {
+    enabled: true,      // 自动检测 SSE 并注入心跳
+    intervalMs: 15000,  // 每 15 秒一次心跳
+  },
+});
+```
+
+| 选项 | 类型 | 默认值 | 说明 |
+|------|------|--------|------|
+| `sseKeepAlive.enabled` | `boolean` | `true` | 启用 SSE 自动检测、TCP 超时解除和心跳注入 |
+| `sseKeepAlive.intervalMs` | `number` | `15000` | 心跳间隔（毫秒） |
+
+当 `enabled` 为 `true`（默认）时，任何 `Content-Type` 头包含 `text/event-stream` 的响应都会触发 SSE 后处理器。**无需任何特殊装饰器或注解**——纯粹基于响应头自动检测。
+
+当 `enabled` 为 `false` 时，框架不做任何 SSE 特殊处理。你需要自行管理 keep-alive 和 `server.timeout`。
+
+---
+
+## 信号级联（`ctx.signal`）
+
+`Context` 通过 `ctx.signal` 暴露客户端的 `AbortSignal`。当客户端断连（网络故障、关闭浏览器标签、中断 `curl`）时，该信号会 abort。
+
+对于 AI 流式端点，将 `ctx.signal` 传递给 `AiService`，可立即取消上游 API 请求——**停止 token 消耗**：
+
+```ts
+import { Controller, GET, Context as Ctx } from '@dangao/bun-server';
+import type { Context } from '@dangao/bun-server';
+
+@Controller('/chat')
+class ChatController {
+  constructor(private readonly ai: AiService) {}
+
+  @GET('/stream')
+  public stream(@Ctx() ctx: Context) {
+    const stream = this.ai.stream({
+      messages: [{ role: 'user', content: 'Hello' }],
+      signal: ctx.signal, // ← 级联客户端断连
+    });
+    return new Response(stream, {
+      headers: { 'Content-Type': 'text/event-stream' },
+    });
+  }
+}
+```
+
+> **注意：** `Context` 参数装饰器既可通过 `Context`（从 `'./controller'`）导入，也可通过包根导出的别名 `ContextParam` 导入。推荐使用 `ContextParam` 或 `Context as Ctx` 以避免与 `Context` 类型名冲突。
+
+完整取消链路：
 
+```
+客户端断连
+  → request.signal abort
+    → 心跳定时器清理
+      → 包裹流取消
+        → AI Provider 内部 fetch() abort
+          → 上游 API 连接关闭（节省 token）
+```

package/docs/zh/lifecycle.md

@@ -1,24 +1,31 @@
 # 生命周期钩子
 
-Bun Server 提供四个生命周期接口，用于在模块和应用启动、关闭时执行初始化或清理逻辑。
+Bun Server 支持组件级生命周期钩子，可让 `@Injectable` / `@Controller` 从创建前到销毁后执行自定义逻辑。
 
 ## 接口定义
 
-- **OnModuleInit**：`onModuleInit()`，在模块所有 providers 注册完成后调用
-- **OnModuleDestroy**：`onModuleDestroy()`，在应用关闭时调用（反向顺序）
+- **ComponentClassBeforeCreate**：`static onBeforeCreate()`，组件实例创建前调用
+- **OnAfterCreate**：`onAfterCreate()`，组件实例创建并完成后处理后调用
+- **OnModuleInit**：`onModuleInit()`，在模块所有组件初始化阶段调用
 - **OnApplicationBootstrap**：`onApplicationBootstrap()`，在所有模块初始化完成后、服务器开始监听前调用
 - **OnApplicationShutdown**：`onApplicationShutdown(signal?)`，在优雅停机开始时调用
+- **OnBeforeDestroy**：`onBeforeDestroy()`，在 `onModuleDestroy()` 前调用（反向顺序）
+- **OnModuleDestroy**：`onModuleDestroy()`，在应用关闭时调用（反向顺序）
+- **OnAfterDestroy**：`onAfterDestroy()`，在 `onModuleDestroy()` 后调用（反向顺序）
 
 ## 执行顺序
 
+**创建阶段（每个组件实例）**：`onBeforeCreate`（静态）→ 实例化 → `onAfterCreate`
+
 **启动阶段**：`onModuleInit` → `onApplicationBootstrap`
 
-**关闭阶段**：`onApplicationShutdown` → `onModuleDestroy`（均为反向顺序，即后注册的先执行）
+**关闭阶段**：`onApplicationShutdown` → `onBeforeDestroy` → `onModuleDestroy` → `onAfterDestroy`（均为反向顺序，即后注册的先执行）
 
-## Provider 去重行为
+对于 `Lifecycle.Scoped` 组件，请求上下文结束时会自动触发其销毁钩子。
 
-当同一个 provider 实例通过多个 token 重复注册/导出时，`onModuleInit`
-现只会执行一次，避免共享单例出现重复初始化副作用。
+## 组件去重行为
+
+当同一个组件实例通过多个 token 重复注册/导出时，生命周期钩子只会执行一次，避免共享单例出现重复副作用。
 
 ## 示例：DatabaseService 的初始化和销毁
 
@@ -41,6 +48,14 @@ import type {
 class DatabaseService implements OnModuleInit, OnModuleDestroy {
   private connected = false;
 
+  public static onBeforeCreate(): void {
+    console.log('[DatabaseService] 创建前');
+  }
+
+  public onAfterCreate(): void {
+    console.log('[DatabaseService] 创建后');
+  }
+
   public async onModuleInit(): Promise<void> {
     console.log('[DatabaseService] 正在连接数据库...');
     await new Promise((resolve) => setTimeout(resolve, 100));
@@ -54,6 +69,14 @@ class DatabaseService implements OnModuleInit, OnModuleDestroy {
     console.log('[DatabaseService] 已断开');
   }
 
+  public onBeforeDestroy(): void {
+    console.log('[DatabaseService] 销毁前');
+  }
+
+  public onAfterDestroy(): void {
+    console.log('[DatabaseService] 销毁后');
+  }
+
   public isConnected(): boolean {
     return this.connected;
   }
@@ -72,6 +95,22 @@ class AppService implements OnApplicationBootstrap, OnApplicationShutdown {
 
 @Controller('/api')
 class AppController {
+  public static onBeforeCreate(): void {
+    console.log('[AppController] 创建前');
+  }
+
+  public onAfterCreate(): void {
+    console.log('[AppController] 创建后');
+  }
+
+  public onBeforeDestroy(): void {
+    console.log('[AppController] 销毁前');
+  }
+
+  public onAfterDestroy(): void {
+    console.log('[AppController] 销毁后');
+  }
+
   @GET('/status')
   public status(): object {
     return { status: 'running', timestamp: Date.now() };
@@ -89,4 +128,4 @@ app.registerModule(AppModule);
 await app.listen();
 ```
 
-按 Ctrl+C 触发关闭时，将依次执行 `onApplicationShutdown` 和 `onModuleDestroy`。
+按 Ctrl+C 触发关闭时，将依次执行 `onApplicationShutdown`、`onBeforeDestroy`、`onModuleDestroy`、`onAfterDestroy`。

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@dangao/bun-server",
-  "version": "2.1.0",
+  "version": "2.3.0",
   "type": "module",
   "main": "./dist/index.js",
   "types": "./dist/index.d.ts",

package/src/ai/providers/anthropic-provider.ts

@@ -56,7 +56,7 @@ export class AnthropicProvider implements LlmProvider {
       }));
     }
 
-    const response = await this.post('/v1/messages', body);
+    const response = await this.post('/v1/messages', body, request.signal);
     const usage = (response['usage'] as { input_tokens: number; output_tokens: number }) ?? { input_tokens: 0, output_tokens: 0 };
 
     let content = '';
@@ -108,6 +108,7 @@ export class AnthropicProvider implements LlmProvider {
     const baseUrl = this.baseUrl;
     const anthropicVersion = this.anthropicVersion;
     const encoder = new TextEncoder();
+    const signal = request.signal;
 
     return new ReadableStream<Uint8Array>({
       async start(controller) {
@@ -120,6 +121,7 @@ export class AnthropicProvider implements LlmProvider {
               'anthropic-version': anthropicVersion,
             },
             body: JSON.stringify(body),
+            signal,
           });
 
           if (!res.ok || !res.body) {
@@ -170,7 +172,7 @@ export class AnthropicProvider implements LlmProvider {
     return Math.ceil(messages.reduce((sum, m) => sum + m.content.length, 0) / 4);
   }
 
-  private async post(path: string, body: Record<string, unknown>): Promise<Record<string, unknown>> {
+  private async post(path: string, body: Record<string, unknown>, signal?: AbortSignal): Promise<Record<string, unknown>> {
     const res = await fetch(`${this.baseUrl}${path}`, {
       method: 'POST',
       headers: {
@@ -179,6 +181,7 @@ export class AnthropicProvider implements LlmProvider {
         'anthropic-version': this.anthropicVersion,
       },
       body: JSON.stringify(body),
+      signal,
     });
 
     if (res.status === 429) throw new AiRateLimitError(this.name);

package/src/ai/providers/google-provider.ts

@@ -50,6 +50,7 @@ export class GoogleProvider implements LlmProvider {
         method: 'POST',
         headers: { 'Content-Type': 'application/json' },
         body: JSON.stringify(body),
+        signal: request.signal,
       },
     );
 
@@ -95,6 +96,7 @@ export class GoogleProvider implements LlmProvider {
     const apiKey = this.apiKey;
     const baseUrl = this.baseUrl;
     const encoder = new TextEncoder();
+    const signal = request.signal;
 
     const body: Record<string, unknown> = {
       contents,
@@ -111,6 +113,7 @@ export class GoogleProvider implements LlmProvider {
               method: 'POST',
               headers: { 'Content-Type': 'application/json' },
               body: JSON.stringify(body),
+              signal,
             },
           );
 

package/src/ai/providers/ollama-provider.ts

@@ -33,6 +33,7 @@ export class OllamaProvider implements LlmProvider {
           num_predict: request.maxTokens,
         },
       }),
+      signal: request.signal,
     });
 
     if (!res.ok) {
@@ -61,6 +62,7 @@ export class OllamaProvider implements LlmProvider {
     const model = request.model ?? this.defaultModel;
     const baseUrl = this.baseUrl;
     const encoder = new TextEncoder();
+    const signal = request.signal;
 
     return new ReadableStream<Uint8Array>({
       async start(controller) {
@@ -77,6 +79,7 @@ export class OllamaProvider implements LlmProvider {
                 num_predict: request.maxTokens,
               },
             }),
+            signal,
           });
 
           if (!res.ok || !res.body) {

package/src/ai/providers/openai-provider.ts

@@ -79,7 +79,7 @@ export class OpenAIProvider implements LlmProvider {
       }));
     }
 
-    const response = await this.post('/chat/completions', body);
+    const response = await this.post('/chat/completions', body, request.signal);
     const choice = response.choices?.[0];
     const usage = response.usage ?? { prompt_tokens: 0, completion_tokens: 0, total_tokens: 0 };
     const message = choice?.message;
@@ -127,6 +127,7 @@ export class OpenAIProvider implements LlmProvider {
     const encoder = new TextEncoder();
     const apiKey = this.apiKey;
     const baseUrl = this.baseUrl;
+    const signal = request.signal;
 
     return new ReadableStream<Uint8Array>({
       async start(controller) {
@@ -138,6 +139,7 @@ export class OpenAIProvider implements LlmProvider {
               'Authorization': `Bearer ${apiKey}`,
             },
             body: JSON.stringify(body),
+            signal,
           });
 
           if (!res.ok || !res.body) {
@@ -191,7 +193,7 @@ export class OpenAIProvider implements LlmProvider {
     return Math.ceil(messages.reduce((sum, m) => sum + m.content.length, 0) / 4);
   }
 
-  private async post(path: string, body: Record<string, unknown>): Promise<OpenAiChatCompletionResponse> {
+  private async post(path: string, body: Record<string, unknown>, signal?: AbortSignal): Promise<OpenAiChatCompletionResponse> {
     const res = await fetch(`${this.baseUrl}${path}`, {
       method: 'POST',
       headers: {
@@ -199,6 +201,7 @@ export class OpenAIProvider implements LlmProvider {
         'Authorization': `Bearer ${this.apiKey}`,
       },
       body: JSON.stringify(body),
+      signal,
     });
 
     if (res.status === 429) {