@absolutejs/absolute 0.19.0-beta.264 → 0.19.0-beta.266

package/ROADMAP.md

@@ -512,306 +512,6 @@ Elysia POST handlers work for form processing, but there's no convention for pro
 
 ---
 
-## 7. P1 — AI/LLM Streaming Helpers
-
-**What exists today in the ecosystem:**
-Vercel's `ai` SDK (`npm install ai`) provides React hooks and server utilities for streaming LLM responses. It works with Next.js, SvelteKit, and Nuxt. But it uses Server-Sent Events (SSE) because Next.js has no native WebSocket support. SSE is one-directional (server → client only) — the client can't send messages mid-stream (cancel, follow-up, branch conversation) without opening a new HTTP request.
-
-**What AbsoluteJS has today:**
-Native bidirectional WebSocket via Elysia. The HMR system already proves the WebSocket infrastructure works at scale with reconnection, message typing, and broadcast. But there are no helpers for connecting an LLM API to a WebSocket channel.
-
-**Why this is a killer feature:**
-AI-powered apps are the dominant use case for new web projects in 2025-2026. Every chat interface, AI assistant, code editor, and content generator needs LLM streaming. The current state of the art (Vercel AI SDK over SSE) has real limitations:
-- SSE is one-directional — canceling a generation requires a separate abort request
-- SSE connections can't be reused — each message opens a new HTTP connection
-- No native support for branching conversations, tool use feedback, or multi-turn streaming
-- WebSocket solves all of these: bidirectional, persistent, multiplexed
-
-AbsoluteJS has WebSocket built in. Adding thin helpers on top makes it the best framework for AI apps with zero additional infrastructure.
-
-**What needs to be built:**
-
-*Server side — `streamAI()` utility:*
-```ts
-import { streamAI } from 'absolutejs'
-
-app.ws('/chat', {
-  message: async (ws, { prompt, conversationId }) => {
-    // streamAI connects to the LLM provider, pipes token chunks
-    // over the WebSocket, and handles backpressure/cancellation
-    await streamAI(ws, {
-      provider: 'anthropic',
-      model: 'claude-sonnet-4-5-20250514',
-      messages: [{ role: 'user', content: prompt }],
-      // Optional: called for each token chunk before sending
-      onChunk: (chunk) => {
-        // Transform, log, filter, or store chunks
-        saveToConversation(conversationId, chunk)
-        return chunk
-      },
-      // Optional: called when the stream completes
-      onComplete: (fullResponse) => {
-        saveMessage(conversationId, fullResponse)
-      }
-    })
-  }
-})
-```
-
-- `streamAI()` is provider-agnostic — supports Anthropic, OpenAI, and any provider that returns a `ReadableStream` or async iterator
-- Handles backpressure — if the client is slow to consume, the server buffers appropriately
-- Handles cancellation — if the client disconnects or sends a cancel message, the LLM request is aborted
-- Handles errors — if the LLM API errors mid-stream, sends a typed error message to the client
-- The `onChunk` callback enables middleware-like processing: content filtering, token counting, database persistence, RAG augmentation
-
-*Provider adapters:*
-```ts
-// Built-in adapters for common providers
-import { anthropic, openai, ollama } from 'absolutejs/ai'
-
-// Each adapter normalizes the provider's streaming API into a common interface
-await streamAI(ws, {
-  provider: anthropic({ apiKey: env.ANTHROPIC_API_KEY }),
-  // or: provider: openai({ apiKey: env.OPENAI_API_KEY }),
-  // or: provider: ollama({ baseUrl: 'http://localhost:11434' }),
-  model: 'claude-sonnet-4-5-20250514',
-  messages,
-})
-```
-
-- Adapters handle provider-specific auth, endpoints, and stream formats
-- Common interface: `{ stream: AsyncIterable<{ type: 'text' | 'tool_use' | 'error', content: string }> }`
-- Easy to add new providers — just implement the adapter interface
-
-*Client side — per-framework hooks:*
-
-**React:**
-```tsx
-import { useAIStream } from 'absolutejs/react'
-
-const Chat = () => {
-  const {
-    messages,     // Message[] — full conversation history
-    send,         // (content: string) => void — send a message
-    cancel,       // () => void — cancel current generation
-    isStreaming,  // boolean — true while LLM is generating
-    error,        // string | null — last error
-  } = useAIStream('/chat')
-
-  return (
-    <div>
-      {messages.map(m => (
-        <div key={m.id} data-role={m.role}>
-          {m.content}
-          {m.isStreaming && <span className="cursor" />}
-        </div>
-      ))}
-      <form onSubmit={(e) => {
-        e.preventDefault()
-        send(e.currentTarget.input.value)
-      }}>
-        <input name="input" disabled={isStreaming} />
-        {isStreaming
-          ? <button type="button" onClick={cancel}>Stop</button>
-          : <button type="submit">Send</button>
-        }
-      </form>
-    </div>
-  )
-}
-```
-
-**Svelte:**
-```svelte
-<script lang="ts">
-  import { createAIStream } from 'absolutejs/svelte'
-
-  const { messages, send, cancel, isStreaming, error } = createAIStream('/chat')
-</script>
-
-{#each $messages as message}
-  <div data-role={message.role}>
-    {message.content}
-    {#if message.isStreaming}<span class="cursor" />{/if}
-  </div>
-{/each}
-
-<form on:submit|preventDefault={(e) => send(e.currentTarget.input.value)}>
-  <input name="input" disabled={$isStreaming} />
-  {#if $isStreaming}
-    <button type="button" on:click={cancel}>Stop</button>
-  {:else}
-    <button type="submit">Send</button>
-  {/if}
-</form>
-```
-
-**Vue:**
-```vue
-<script setup lang="ts">
-import { useAIStream } from 'absolutejs/vue'
-
-const { messages, send, cancel, isStreaming, error } = useAIStream('/chat')
-</script>
-
-<template>
-  <div v-for="m in messages" :key="m.id" :data-role="m.role">
-    {{ m.content }}
-    <span v-if="m.isStreaming" class="cursor" />
-  </div>
-  <form @submit.prevent="send($event.target.input.value)">
-    <input name="input" :disabled="isStreaming" />
-    <button v-if="isStreaming" type="button" @click="cancel">Stop</button>
-    <button v-else type="submit">Send</button>
-  </form>
-</template>
-```
-
-**Angular:**
-```typescript
-import { Component, inject } from '@angular/core'
-import { AIStreamService } from 'absolutejs/angular'
-
-@Component({
-  selector: 'app-chat',
-  template: `
-    @for (m of ai.messages(); track m.id) {
-      <div [attr.data-role]="m.role">
-        {{ m.content }}
-        @if (m.isStreaming) { <span class="cursor"></span> }
-      </div>
-    }
-    <form (submit)="onSubmit($event)">
-      <input name="input" [disabled]="ai.isStreaming()" />
-      @if (ai.isStreaming()) {
-        <button type="button" (click)="ai.cancel()">Stop</button>
-      } @else {
-        <button type="submit">Send</button>
-      }
-    </form>
-  `
-})
-export class ChatComponent {
-  ai = inject(AIStreamService).connect('/chat')
-
-  onSubmit(e: Event) {
-    e.preventDefault()
-    const input = (e.target as HTMLFormElement).input as HTMLInputElement
-    this.ai.send(input.value)
-  }
-}
-```
-
-*WebSocket message protocol for AI streaming:*
-```ts
-// Client → Server
-type AIClientMessage =
-  | { type: 'message', content: string, conversationId?: string }
-  | { type: 'cancel' }
-
-// Server → Client
-type AIServerMessage =
-  | { type: 'chunk', content: string, messageId: string }
-  | { type: 'tool_use', name: string, input: unknown, messageId: string }
-  | { type: 'complete', messageId: string, usage?: { inputTokens: number, outputTokens: number } }
-  | { type: 'error', message: string }
-```
-
-*Advanced features:*
-- **Tool use / function calling**: When the LLM calls a tool, the server sends a `tool_use` message. The client can display a "searching..." or "running code..." UI. The server executes the tool and feeds the result back to the LLM, continuing the stream.
-- **Conversation branching**: The client sends a `conversationId` — the server maintains conversation state and supports branching (edit a previous message, regenerate from a point).
-- **Multi-model routing**: `streamAI` could accept a `router` function that picks the model based on the message (simple questions → Haiku, complex → Opus).
-- **Token counting**: The `onChunk` callback can count tokens for usage tracking / rate limiting.
-- **Reconnection**: If the WebSocket drops mid-stream, the client hook reconnects and requests the remaining content from the server (using the `messageId` as a cursor).
-
-**Design considerations:**
-- The AI helpers should be optional — users who don't build AI features never import them and they're tree-shaken from the bundle.
-- Provider API keys should come from environment variables, never sent to the client.
-- The client hooks manage the WebSocket connection lifecycle — connect on mount, disconnect on unmount, reconnect on drop. Same patterns as the HMR client.
-- The message protocol should be extensible — providers may add new message types (images, audio) and the protocol should handle unknown types gracefully.
-- SSR: the chat component renders empty on the server (no messages). Conversation history loads on hydration from the server or local storage.
-
-**Files likely involved:**
-- New: `src/ai/streamAI.ts` — core streaming utility that pipes LLM responses to WebSocket
-- New: `src/ai/providers/anthropic.ts` — Anthropic adapter
-- New: `src/ai/providers/openai.ts` — OpenAI adapter
-- New: `src/ai/providers/ollama.ts` — Ollama adapter (local LLMs)
-- New: `src/react/hooks/useAIStream.ts` — React hook
-- New: `src/svelte/createAIStream.ts` — Svelte store-based hook
-- New: `src/vue/useAIStream.ts` — Vue composable
-- New: `src/angular/ai-stream.service.ts` — Angular service
-- New: `types/ai.ts` — message protocol types, provider interface, hook return types
-- Package exports: `absolutejs/ai` for server utilities, per-framework exports for client hooks
-
----
-
-## 8. P1 — Type-Safe Environment Variables (`defineEnv`)
-
-**The problem:**
-`process.env.DATABASE_URL` is always `string | undefined` in TypeScript. Typos are silent (`process.env.DATABSE_URL` → `undefined`, no error). Missing vars cause runtime crashes in production. Numeric vars like `PORT` come back as strings and need manual parsing. There's no single place to see what env vars an app requires.
-
-**What AbsoluteJS has today:**
-`getEnv(key)` — a runtime helper that throws if the variable is missing. But it's one-variable-at-a-time, returns `string` always, and provides no type narrowing or compile-time safety.
-
-**What needs to be built:**
-
-```ts
-// env.ts — the single source of truth for all environment variables
-import { defineEnv } from 'absolutejs'
-import { t } from 'elysia'
-
-export const env = defineEnv({
-  DATABASE_URL: t.String({ format: 'url' }),
-  PORT: t.Number({ default: 3000 }),
-  NODE_ENV: t.Union([t.Literal('development'), t.Literal('production')]),
-  STRIPE_SECRET: t.String(),
-  ENABLE_LOGGING: t.Boolean({ default: true }),
-  MAX_UPLOAD_MB: t.Number({ default: 10 }),
-})
-```
-
-**How `defineEnv` works:**
-- Called once at app startup (in `server.ts` or imported by `prepare()`)
-- Reads all declared vars from `process.env` / `Bun.env`
-- Validates each var against its schema using Elysia's `t` (TypeBox) — same type system used everywhere else in AbsoluteJS
-- Parses types: `"3000"` → `3000` for numbers, `"true"` → `true` for booleans
-- Applies defaults for missing optional vars
-- **Fails fast** on startup if any required var is missing or fails validation — clear error message listing every problem:
-  ```
-  Environment validation failed:
-    ✗ DATABASE_URL — required but not set
-    ✗ PORT — expected number, got "not-a-number"
-    ✓ NODE_ENV — "production"
-    ✓ STRIPE_SECRET — set
-  ```
-- Returns a fully typed, frozen object — `env.PORT` is `number`, `env.NODE_ENV` is `'development' | 'production'`, `env.TYPO` is a TypeScript error
-
-**Usage throughout the app:**
-```ts
-// server.ts
-import { env } from './env'
-
-app.listen(env.PORT)  // number, not string
-
-// any file
-import { env } from './env'
-if (env.NODE_ENV === 'development') { ... }  // narrowed union
-```
-
-**Design considerations:**
-- Uses Elysia's `t` (TypeBox) for schemas — same system developers already use for route validation. No new schema library to learn.
-- The returned `env` object is `Object.freeze()`'d — env vars don't change at runtime.
-- Sensitive vars (containing `SECRET`, `KEY`, `TOKEN`, `PASSWORD` in the name) are redacted in error messages and logs — `"STRIPE_SECRET — set"` not `"STRIPE_SECRET — sk_live_..."`.
-- `.env` file support via Bun's built-in dotenv — `defineEnv` validates after Bun loads the `.env` file.
-- Warn if a `.env` file contains vars with `SECRET`/`KEY` in the name and the file isn't in `.gitignore`.
-
-**Files likely involved:**
-- New: `src/utils/defineEnv.ts` — the `defineEnv` function with TypeBox validation, parsing, and error formatting
-- New: `types/env.ts` — type utilities for extracting the typed env object from a schema
-- `src/utils/getEnv.ts` — deprecate in favor of `defineEnv`, or keep as a lightweight alternative for simple cases
-
----
-
 ## 9. P1 — Security Headers + CSP Nonce Injection
 
 **The problem:**

package/dist/ai/index.js

@@ -588,6 +588,12 @@ var buildRequestBody2 = (params, isImageModel) => {
   if (tools) {
     body.tools = tools;
   }
+  if (params.thinking) {
+    body.reasoning = {
+      effort: "high",
+      summary: "auto"
+    };
+  }
   return body;
 };
 var parseJSON = (data) => {
@@ -719,6 +725,16 @@ var processCompleted = function* (parsed) {
 };
 var processSSEEvent = function* (eventType, parsed, pendingCalls) {
   switch (eventType) {
+    case "response.reasoning_summary_text.delta": {
+      const delta = typeof parsed.delta === "string" ? parsed.delta : "";
+      if (delta) {
+        yield {
+          content: delta,
+          type: "thinking"
+        };
+      }
+      break;
+    }
     case "response.output_text.delta":
       yield* processTextDelta(parsed);
       break;
@@ -1776,5 +1792,5 @@ export {
   aiChat
 };
 
-//# debugId=B9E25972E76C002A64756E2164756E21
+//# debugId=9D42156228088F4264756E2164756E21
 //# sourceMappingURL=index.js.map