@providerprotocol/ai 0.0.38 → 0.0.40

package/README.md

@@ -29,9 +29,10 @@ console.log(turn.response.text);
 | OpenRouter | `@providerprotocol/ai/openrouter` | ✓ | ✓ | ✓ |
 | Groq | `@providerprotocol/ai/groq` | ✓ | | |
 | Cerebras | `@providerprotocol/ai/cerebras` | ✓ | | |
+| Moonshot | `@providerprotocol/ai/moonshot` | ✓ | | |
 | OpenResponses | `@providerprotocol/ai/responses` | ✓ | | |
 
-API keys are loaded automatically from environment variables (`ANTHROPIC_API_KEY`, `OPENAI_API_KEY`, `GROQ_API_KEY`, `CEREBRAS_API_KEY`, etc.).
+API keys are loaded automatically from environment variables (`ANTHROPIC_API_KEY`, `OPENAI_API_KEY`, `GROQ_API_KEY`, `CEREBRAS_API_KEY`, `MOONSHOT_API_KEY`, etc.).
 
 ## LLM
 
@@ -91,6 +92,21 @@ const t2 = await claude.generate(history, 'What is my name?');
 // Response: "Your name is Alice"
 ```
 
+### System-Only Inference
+
+Both `generate()` and `stream()` can be called with no arguments for system-prompt-only inference:
+
+```typescript
+const assistant = llm({
+  model: anthropic('claude-sonnet-4-20250514'),
+  system: 'You are a haiku generator. Generate a haiku about coding.',
+});
+
+// No user input needed
+const turn = await assistant.generate();
+console.log(turn.response.text);
+```
+
 ### Tools
 
 ```typescript
@@ -108,6 +124,27 @@ const turn = await claude.generate({
 }, 'What is the weather in Tokyo?');
 ```
 
+#### Tools with Zod Parameters
+
+Tool parameters also accept Zod schemas:
+
+```typescript
+import { z } from 'zod';
+
+const model = llm({
+  model: anthropic('claude-sonnet-4-20250514'),
+  tools: [{
+    name: 'get_weather',
+    description: 'Get weather for a location',
+    parameters: z.object({
+      location: z.string().describe('City name'),
+      units: z.enum(['celsius', 'fahrenheit']).optional(),
+    }),
+    run: async ({ location, units }) => fetchWeather(location, units),
+  }],
+});
+```
+
 ### Structured Output
 
 ```typescript
@@ -130,6 +167,37 @@ const turn = await extractor.generate('John is 30 years old');
 console.log(turn.data); // { name: 'John', age: 30 }
 ```
 
+#### Zod Schema Support
+
+Structured output and tool parameters accept Zod schemas directly, with automatic conversion to JSON Schema:
+
+```typescript
+import { llm } from '@providerprotocol/ai';
+import { anthropic } from '@providerprotocol/ai/anthropic';
+import { z } from 'zod';
+
+const extractor = llm({
+  model: anthropic('claude-sonnet-4-20250514'),
+  structure: z.object({
+    name: z.string(),
+    age: z.number(),
+    tags: z.array(z.string()),
+  }),
+});
+
+const turn = await extractor.generate('Extract: John Doe, 30 years old, likes coding');
+console.log(turn.data); // { name: "John Doe", age: 30, tags: ["coding"] }
+```
+
+**Requirements:**
+- Zod schemas must be object schemas (`z.object()`). Non-object schemas will throw an error.
+- Zod is an optional peer dependency - install only if using Zod schemas:
+
+```bash
+bun add zod                    # v4+ for native JSON Schema conversion
+bun add zod zod-to-json-schema # v3 requires additional package
+```
+
 ### Multimodal Input
 
 ```typescript
@@ -162,6 +230,9 @@ const videoTurn = await gemini.generate([video.toBlock(), 'Describe this video']
 | OpenRouter | ✓ | PDF, Text | ✓ | ✓ |
 | xAI | ✓ | | | |
 | Groq | ✓ | | | |
+| Moonshot | ✓ | | | ✓* |
+
+\* Moonshot video input is experimental.
 
 ## Anthropic Beta Features
 
@@ -435,16 +506,15 @@ const result = await editor.edit({
 ## Configuration
 
 ```typescript
-import { llm } from '@providerprotocol/ai';
+import { llm, exponentialBackoff, roundRobinKeys } from '@providerprotocol/ai';
 import { openai } from '@providerprotocol/ai/openai';
-import { ExponentialBackoff, RoundRobinKeys } from '@providerprotocol/ai/http';
 
 const instance = llm({
   model: openai('gpt-4o'),
   config: {
-    apiKey: new RoundRobinKeys(['sk-key1', 'sk-key2']),
+    apiKey: roundRobinKeys(['sk-key1', 'sk-key2']),
     timeout: 30000,
-    retryStrategy: new ExponentialBackoff({ maxAttempts: 3 }),
+    retryStrategy: exponentialBackoff({ maxAttempts: 3 }),
   },
   params: {
     temperature: 0.7,
@@ -502,34 +572,33 @@ interface ProviderConfig {
 ### Key Strategies
 
 ```typescript
-import { RoundRobinKeys, WeightedKeys, DynamicKey } from '@providerprotocol/ai/http';
+import { roundRobinKeys, weightedKeys, dynamicKey } from '@providerprotocol/ai/http';
 
 // Cycle through keys evenly
-new RoundRobinKeys(['sk-1', 'sk-2', 'sk-3'])
+roundRobinKeys(['sk-1', 'sk-2', 'sk-3'])
 
 // Weighted selection (70% key1, 30% key2)
-new WeightedKeys([
+weightedKeys([
   { key: 'sk-1', weight: 70 },
   { key: 'sk-2', weight: 30 },
 ])
 
 // Dynamic fetching (secrets manager, etc.)
-new DynamicKey(async () => fetchKeyFromVault())
+dynamicKey(async () => fetchKeyFromVault())
 ```
 
 ### Retry Strategies
 
 ```typescript
 import {
-  ExponentialBackoff,
-  LinearBackoff,
-  NoRetry,
-  TokenBucket,
-  RetryAfterStrategy,
-} from '@providerprotocol/ai/http';
+  exponentialBackoff,
+  linearBackoff,
+  noRetry,
+  retryAfterStrategy,
+} from '@providerprotocol/ai';
 
 // Exponential: 1s, 2s, 4s...
-new ExponentialBackoff({
+exponentialBackoff({
   maxAttempts: 5,
   baseDelay: 1000,
   maxDelay: 30000,
@@ -537,20 +606,19 @@ new ExponentialBackoff({
 })
 
 // Linear: 1s, 2s, 3s...
-new LinearBackoff({ maxAttempts: 3, delay: 1000 })
-
-// Rate limiting with token bucket
-new TokenBucket({ maxTokens: 10, refillRate: 1 })
+linearBackoff({ maxAttempts: 3, delay: 1000 })
 
 // Respect server Retry-After headers
-new RetryAfterStrategy({ maxAttempts: 3, fallbackDelay: 5000 })
+retryAfterStrategy({ maxAttempts: 3, fallbackDelay: 5000 })
 
 // No retries
-new NoRetry()
+noRetry()
 ```
 
 **Retryable Errors:** `RATE_LIMITED`, `NETWORK_ERROR`, `TIMEOUT`, `PROVIDER_ERROR`
 
+**Streaming Retry:** Retry strategies work with both `.generate()` and `.stream()`. During streaming, `stream_retry` events are emitted to notify consumers of retry attempts, and middleware can use the `onRetry` hook to reset accumulated state.
+
 ## Tool Execution Control
 
 ```typescript
@@ -719,22 +787,55 @@ Bun.serve({
 ```typescript
 // Express
 import { express } from '@providerprotocol/ai/middleware/pubsub/server';
-app.post('/api/ai/reconnect', (req, res) => {
-  const { streamId } = req.body;
+
+app.post('/api/ai', async (req, res) => {
+  const { messages, streamId } = req.body;
+
+  // Guard: prevent duplicate generations on reconnect
+  if (!await adapter.exists(streamId)) {
+    const model = llm({
+      model: anthropic('claude-sonnet-4-20250514'),
+      middleware: [pubsubMiddleware({ adapter, streamId })],
+    });
+    model.stream(messages).then(turn => { /* save to DB */ });
+  }
+
   express.streamSubscriber(streamId, adapter, res);
 });
 
 // Fastify
 import { fastify } from '@providerprotocol/ai/middleware/pubsub/server';
-app.post('/api/ai/reconnect', (request, reply) => {
-  const { streamId } = request.body;
+
+app.post('/api/ai', async (request, reply) => {
+  const { messages, streamId } = request.body;
+
+  // Guard: prevent duplicate generations on reconnect
+  if (!await adapter.exists(streamId)) {
+    const model = llm({
+      model: anthropic('claude-sonnet-4-20250514'),
+      middleware: [pubsubMiddleware({ adapter, streamId })],
+    });
+    model.stream(messages).then(turn => { /* save to DB */ });
+  }
+
   return fastify.streamSubscriber(streamId, adapter, reply);
 });
 
 // H3/Nuxt
 import { h3 } from '@providerprotocol/ai/middleware/pubsub/server';
+
 export default defineEventHandler(async (event) => {
-  const { streamId } = await readBody(event);
+  const { messages, streamId } = await readBody(event);
+
+  // Guard: prevent duplicate generations on reconnect
+  if (!await adapter.exists(streamId)) {
+    const model = llm({
+      model: anthropic('claude-sonnet-4-20250514'),
+      middleware: [pubsubMiddleware({ adapter, streamId })],
+    });
+    model.stream(messages).then(turn => { /* save to DB */ });
+  }
+
   return h3.streamSubscriber(streamId, adapter, event);
 });
 ```
@@ -750,9 +851,10 @@ const redisAdapter: PubSubAdapter = {
   async exists(streamId) { /* check if stream exists */ },
   async append(streamId, event) { /* append event, create lazily */ },
   async getEvents(streamId) { /* return events or [] */ },
-  subscribe(streamId, onEvent, onComplete) { /* subscribe to live events */ },
+  subscribe(streamId, onEvent, onComplete, onFinalData) { /* subscribe to live events */ },
   publish(streamId, event) { /* broadcast to subscribers */ },
-  async remove(streamId) { /* notify onComplete then delete */ },
+  setFinalData(streamId, data) { /* store final Turn data */ },
+  async remove(streamId) { /* notify onFinalData, onComplete, then delete */ },
 };
 ```
 
@@ -774,6 +876,89 @@ const model = llm({
 });
 ```
 
+### Pipeline Middleware (Post-Turn Processing)
+
+Run async tasks (image generation, embeddings, slug creation, etc.) after the LLM completes, with progress events streamed to connected clients:
+
+```typescript
+import { llm } from '@providerprotocol/ai';
+import { anthropic } from '@providerprotocol/ai/anthropic';
+import { pubsubMiddleware, memoryAdapter } from '@providerprotocol/ai/middleware/pubsub';
+import { pipelineMiddleware, isPipelineStageEvent } from '@providerprotocol/ai/middleware/pipeline';
+
+const adapter = memoryAdapter();
+
+const model = llm({
+  model: anthropic('claude-sonnet-4-20250514'),
+  structure: BlogPostSchema,
+  middleware: [
+    pubsubMiddleware({ adapter, streamId: postId }),
+    pipelineMiddleware<BlogPost>({
+      stages: [
+        {
+          type: 'slug',
+          run: (turn, emit) => {
+            const slug = turn.data!.title.toLowerCase().replace(/\s+/g, '-');
+            (turn as { slug?: string }).slug = slug;
+            emit({ slug });
+          },
+        },
+        {
+          type: 'embedding',
+          run: async (turn, emit) => {
+            await vectorize(turn.data!);
+            emit({ embedded: true });
+          },
+        },
+      ],
+      parallel: false,        // Run stages sequentially (default)
+      continueOnError: false, // Stop on first error (default)
+      onStageError: ({ stage, error }) => {
+        console.error(`Stage ${stage.type} failed:`, error);
+      },
+    }),
+  ],
+});
+
+// Stages run after streaming completes
+model.stream(prompt).then(turn => {
+  const extended = turn as typeof turn & { slug?: string };
+  console.log(extended.slug);
+});
+```
+
+**Consuming Pipeline Events:**
+
+```typescript
+for await (const event of model.stream(prompt)) {
+  if (isPipelineStageEvent(event)) {
+    console.log(event.delta.stage, event.delta.payload);
+    // 'slug' { slug: 'my-blog-post' }
+    // 'embedding' { embedded: true }
+  }
+}
+```
+
+**Middleware Order:** Place `pipelineMiddleware` after `pubsubMiddleware` in the array:
+
+```typescript
+middleware: [
+  pubsubMiddleware({ ... }),  // Setup runs first in onStart
+  pipelineMiddleware({ ... }),    // Events run first in onTurn (reverse order)
+]
+```
+
+This ensures pubsub sets up before pipeline stages execute, and pipeline events emit before pubsub cleanup.
+
+**Pipeline Configuration:**
+
+| Option | Type | Default | Description |
+|--------|------|---------|-------------|
+| `stages` | `PipelineStage[]` | required | Stages to run after turn completion |
+| `parallel` | `boolean` | `false` | Run stages in parallel instead of sequential |
+| `continueOnError` | `boolean` | `false` | Continue running subsequent stages if one fails |
+| `onStageError` | `function` | - | Called when a stage throws an error |
+
 ## Error Handling
 
 All errors are normalized to `UPPError` with consistent error codes:
@@ -820,17 +1005,16 @@ Build AI API gateways with your own authentication. Users authenticate with your
 ### Server (Bun/Deno/Cloudflare Workers)
 
 ```typescript
-import { llm } from '@providerprotocol/ai';
+import { llm, exponentialBackoff, roundRobinKeys } from '@providerprotocol/ai';
 import { anthropic } from '@providerprotocol/ai/anthropic';
-import { ExponentialBackoff, RoundRobinKeys } from '@providerprotocol/ai/http';
 import { parseBody, toJSON, toSSE, toError } from '@providerprotocol/ai/proxy';
 
 // Server manages AI provider keys - users never see them
 const claude = llm({
   model: anthropic('claude-sonnet-4-20250514'),
   config: {
-    apiKey: new RoundRobinKeys([process.env.ANTHROPIC_KEY_1!, process.env.ANTHROPIC_KEY_2!]),
-    retryStrategy: new ExponentialBackoff({ maxAttempts: 3 }),
+    apiKey: roundRobinKeys([process.env.ANTHROPIC_KEY_1!, process.env.ANTHROPIC_KEY_2!]),
+    retryStrategy: exponentialBackoff({ maxAttempts: 3 }),
   },
 });
 
@@ -860,15 +1044,14 @@ Bun.serve({
 Clients authenticate with your platform token. They get automatic retry on network failures to your proxy.
 
 ```typescript
-import { llm } from '@providerprotocol/ai';
+import { llm, exponentialBackoff } from '@providerprotocol/ai';
 import { proxy } from '@providerprotocol/ai/proxy';
-import { ExponentialBackoff } from '@providerprotocol/ai/http';
 
 const claude = llm({
   model: proxy('https://api.yourplatform.com/ai'),
   config: {
     headers: { 'Authorization': 'Bearer user-platform-token' },
-    retryStrategy: new ExponentialBackoff({ maxAttempts: 3 }),
+    retryStrategy: exponentialBackoff({ maxAttempts: 3 }),
     timeout: 30000,
   },
 });
@@ -903,11 +1086,12 @@ app.post('/ai', async (request, reply) => {
 });
 
 // Nuxt/H3 (server/api/ai.post.ts)
+import { sendStream } from 'h3';
 import { h3 as h3Adapter, parseBody } from '@providerprotocol/ai/proxy';
 export default defineEventHandler(async (event) => {
   const { messages, system, params } = parseBody(await readBody(event));
   if (params?.stream) {
-    return h3Adapter.streamSSE(claude.stream(messages, { system }), event);
+    return sendStream(event, h3Adapter.createSSEStream(claude.stream(messages, { system })));
   }
   return h3Adapter.sendJSON(await claude.generate(messages, { system }), event);
 });
@@ -1084,6 +1268,85 @@ const model = llm({
 
 **Environment:** `CEREBRAS_API_KEY`
 
+## Moonshot
+
+Kimi K2.5 with 256K context, thinking mode, vision, and server-side builtin tools:
+
+```typescript
+import { llm } from '@providerprotocol/ai';
+import { moonshot, tools } from '@providerprotocol/ai/moonshot';
+
+const model = llm({
+  model: moonshot('kimi-k2.5'),
+  params: { max_tokens: 1000 },
+});
+
+const turn = await model.generate('Hello!');
+```
+
+**With thinking mode (default for K2.5):**
+
+```typescript
+const model = llm({
+  model: moonshot('kimi-k2.5'),
+  params: {
+    max_tokens: 2000,
+    temperature: 1.0,
+    thinking: { type: 'enabled' },
+  },
+});
+
+// Response includes reasoning in turn.response.reasoning
+const turn = await model.generate('Solve step by step: 2x + 5 = 13');
+```
+
+**With instant mode (disabled thinking):**
+
+```typescript
+const model = llm({
+  model: moonshot('kimi-k2.5'),
+  params: {
+    temperature: 0.6,
+    thinking: { type: 'disabled' },
+  },
+});
+```
+
+**With builtin tools:**
+
+```typescript
+const model = llm({
+  model: moonshot('kimi-k2.5'),
+  params: {
+    tools: [
+      tools.webSearch(),
+      tools.codeRunner(),
+      tools.date(),
+    ],
+  },
+});
+```
+
+**Available Builtin Tools:**
+
+| Tool | Description |
+|------|-------------|
+| `tools.webSearch()` | Real-time internet search |
+| `tools.codeRunner()` | Python code execution with matplotlib/pandas |
+| `tools.quickjs()` | JavaScript execution via QuickJS engine |
+| `tools.fetch()` | URL content fetching with markdown extraction |
+| `tools.convert()` | Unit conversion (length, mass, temperature, currency) |
+| `tools.date()` | Date/time processing and timezone conversion |
+| `tools.base64Encode()` | Base64 encoding |
+| `tools.base64Decode()` | Base64 decoding |
+| `tools.memory()` | Memory storage and retrieval system |
+| `tools.rethink()` | Intelligent reasoning/reflection tool |
+| `tools.randomChoice()` | Random selection with optional weights |
+
+**Capabilities:** Streaming, tool calling, structured output, thinking mode, image input, video input (experimental).
+
+**Environment:** `MOONSHOT_API_KEY` or `KIMI_API_KEY`
+
 ## OpenResponses Provider
 
 Connect to any server implementing the [OpenResponses specification](https://www.openresponses.org):
@@ -1140,8 +1403,10 @@ Full type safety with no `any` types. All provider parameters are typed:
 import type {
   // Core types
   Turn,
+  TurnJSON,
   Message,
   Tool,
+  ToolInput,
   TokenUsage,
 
   // Streaming
@@ -1174,9 +1439,70 @@ import type {
   Middleware,
   MiddlewareContext,
   StreamContext,
+
+  // Schema types (Zod support)
+  Structure,
+  ZodLike,
 } from '@providerprotocol/ai';
 ```
 
+**Zod Utilities:**
+
+```typescript
+import {
+  isZodSchema,
+  isZodV4,
+  zodToJSONSchema,
+  zodToJSONSchemaSync,
+  resolveStructure,
+  resolveTools,
+} from '@providerprotocol/ai/utils';
+
+// Type guard for Zod schemas
+if (isZodSchema(schema)) {
+  const jsonSchema = zodToJSONSchemaSync(schema);
+}
+```
+
+**Error & ID Utilities:**
+
+```typescript
+import {
+  toError,
+  isCancelledError,
+  generateId,
+  generateShortId,
+} from '@providerprotocol/ai/utils';
+
+// Convert unknown thrown values to Error instances
+const error = toError(unknownValue);
+
+// Check if an error is a cancellation/abort error
+if (isCancelledError(error)) {
+  console.log('Request was cancelled');
+}
+
+// Generate IDs
+const uuid = generateId();                    // UUID v4: "a1b2c3d4-..."
+const shortId = generateShortId('req');       // "req_abc123xyz789"
+```
+
+**Provider-Specific Types:**
+
+```typescript
+// OpenAI
+import type { OpenAIHeaders, OpenAIImageParams } from '@providerprotocol/ai/openai';
+
+// Google
+import type { GoogleImagenParams } from '@providerprotocol/ai/google';
+
+// Ollama
+import type { OllamaHeaders } from '@providerprotocol/ai/ollama';
+
+// OpenRouter
+import type { OpenRouterProviderOptions } from '@providerprotocol/ai/openrouter';
+```
+
 **Type-Safe Enums:**
 
 ```typescript

package/dist/anthropic/index.d.ts

@@ -1,5 +1,6 @@
-import { e as Provider } from '../llm-DS_-l71X.js';
-import '../stream-sXhBtWjl.js';
+import { e as Provider } from '../llm-BWLaTzzY.js';
+import '../stream-bBd_4Ipu.js';
+import '../tool-BmAfKNBq.js';
 
 /**
  * @fileoverview Anthropic API type definitions.

package/dist/anthropic/index.js

@@ -6,7 +6,7 @@ import {
 } from "../chunk-TUTYMOBL.js";
 import {
   resolveApiKey
-} from "../chunk-ARVM24K2.js";
+} from "../chunk-EY2LLDGY.js";
 import {
   createProvider
 } from "../chunk-JA3UZALR.js";
@@ -14,18 +14,20 @@ import {
   doFetch,
   doStreamFetch,
   normalizeHttpError
-} from "../chunk-SBGZJVTJ.js";
+} from "../chunk-VQZPADW6.js";
 import {
   StreamEventType,
   objectDelta
-} from "../chunk-MJI74VEJ.js";
+} from "../chunk-F5ENANMJ.js";
 import {
   AssistantMessage,
-  generateId,
   isAssistantMessage,
   isToolResultMessage,
   isUserMessage
-} from "../chunk-WU4U6IHF.js";
+} from "../chunk-6QCV4WXF.js";
+import {
+  generateId
+} from "../chunk-U2G5PHHL.js";
 import {
   toError
 } from "../chunk-GIDT7C6I.js";