chub-dev 0.2.0-beta.3 → 0.3.0

package/dist/anthropic/docs/sdk/python/DOC.md

@@ -1,382 +0,0 @@
----
-name: sdk
-description: "Claude AI assistant API for text generation, analysis, conversation, streaming, tool use, vision, and batch processing"
-metadata:
-  languages: "python"
-  versions: "0.71.0"
-  updated-on: "2025-10-24"
-  source: maintainer
-  tags: "anthropic,sdk,llm,ai,claude"
----
-
-
-# Anthropic Python SDK Guidelines
-
-You are an Anthropic API coding expert. Help me with writing code using the Anthropic API calling the official libraries and SDKs.
-
-You can find the official SDK documentation and code samples here:
-https://docs.anthropic.com/claude/reference/
-
-## Golden Rule: Use the Correct and Current SDK
-
-Always use the Anthropic Python SDK to call Claude models, which is the standard library for all Anthropic API interactions.
-
-- **Library Name:** Anthropic Python SDK
-- **Python Package:** `anthropic`
-- **Installation:** `pip install anthropic`
-
-**APIs and Usage:**
-
-- **Correct:** `from anthropic import Anthropic`
-- **Correct:** `from anthropic import AsyncAnthropic` (for async usage)
-- **Correct:** `client = Anthropic(api_key="...")`
-- **Correct:** `client.messages.create(...)`
-
-## Initialization and API Key
-
-The `anthropic` library requires creating a client object for all API calls.
-
-- Always use `client = Anthropic()` to create a client object.
-- Set `ANTHROPIC_API_KEY` environment variable, which will be picked up automatically.
-- Alternatively, pass the API key directly: `client = Anthropic(api_key="your-key-here")`
-
-## Models
-
-By default, use the following models when using the Anthropic SDK:
-
-- **Latest High-Performance Model:** `claude-sonnet-4-20250514` or `claude-4-sonnet-20250514`
-- **Latest Balanced Model:** `claude-3-7-sonnet-latest` or `claude-3-7-sonnet-20250219`
-- **Fast and Efficient Model:** `claude-3-5-haiku-latest` or `claude-3-5-haiku-20241022`
-- **Legacy High-Quality Model:** `claude-3-5-sonnet-latest` or `claude-3-opus-latest`
-
-```python
-# List all available models
-models = client.models.list()
-```
-```python
-# List all deprecated models
-from anthropic.resources.messages.messages import DEPRECATED_MODELS
-for model, deprecation_date in DEPRECATED_MODELS.items():
-    print(f"{model}: deprecated {deprecation_date}")
-```
-
-- It is acceptable to use specific dated versions if consistency is required.
-- Avoid using deprecated models - check the SDK documentation for deprecation notices.
-
-## Basic Inference (Text Generation)
-
-```python
-from anthropic import Anthropic
-
-client = Anthropic()
-
-message = client.messages.create(
-    model="claude-sonnet-4-20250514",
-    max_tokens=1024,
-    messages=[
-        {
-            "role": "user",
-            "content": "Hello, Claude"
-        }
-    ]
-)
-print(message.content)
-```
-
-## Multimodal Inputs
-
-### Image Inputs
-
-```python
-message = client.messages.create(
-    model="claude-sonnet-4-20250514",
-    max_tokens=1024,
-    messages=[
-        {
-            "role": "user",
-            "content": [
-                {
-                    "type": "image",
-                    "source": {
-                        "type": "base64",
-                        "media_type": "image/jpeg",
-                        "data": "/9j/4AAQSkZJRgABAQ..."
-                    }
-                },
-                {
-                    "type": "text",
-                    "text": "What's in this image?"
-                }
-            ]
-        }
-    ]
-)
-```
-
-### File Uploads
-
-```python
-from pathlib import Path
-
-client.beta.files.upload(
-    file=Path("/path/to/file"),
-)
-```
-
-## Async Usage
-
-```python
-import asyncio
-from anthropic import AsyncAnthropic
-
-client = AsyncAnthropic()
-
-async def main():
-    message = await client.messages.create(
-        model="claude-sonnet-4-20250514",
-        max_tokens=1024,
-        messages=[
-            {
-                "role": "user",
-                "content": "Hello, Claude"
-            }
-        ]
-    )
-    print(message.content)
-
-asyncio.run(main())
-```
-
-## Advanced Capabilities and Configurations
-
-### System Instructions
-
-```python
-message = client.messages.create(
-    model="claude-sonnet-4-20250514",
-    max_tokens=1024,
-    system="You are a helpful assistant that speaks like a pirate.",
-    messages=[
-        {
-            "role": "user",
-            "content": "Hello!"
-        }
-    ]
-)
-```
-
-### Thinking Configuration
-
-```python
-message = client.messages.create(
-    model="claude-sonnet-4-20250514",
-    max_tokens=1024,
-    messages=[
-        {
-            "role": "user",
-            "content": "Solve this complex problem step by step."
-        }
-    ],
-    thinking={
-        "type": "enabled",
-        "budget_tokens": 1024
-    }
-)
-```
-
-### Tool Use (Function Calling)
-
-```python
-def get_weather(location: str) -> str:
-    return f"Weather in {location}: 72°F and sunny"
-
-message = client.messages.create(
-    model="claude-sonnet-4-20250514",
-    max_tokens=1024,
-    messages=[
-        {
-            "role": "user",
-            "content": "What's the weather in San Francisco?"
-        }
-    ],
-    tools=[
-        {
-            "type": "custom",
-            "name": "get_weather",
-            "description": "Get current weather for a location",
-            "input_schema": {
-                "type": "object",
-                "properties": {
-                    "location": {
-                        "type": "string",
-                        "description": "The city and state, e.g. San Francisco, CA"
-                    }
-                },
-                "required": ["location"]
-            }
-        }
-    ]
-)
-```
-
-### Streaming Responses
-
-```python
-stream = client.messages.create(
-    model="claude-sonnet-4-20250514",
-    max_tokens=1024,
-    messages=[
-        {
-            "role": "user",
-            "content": "Tell me a story"
-        }
-    ],
-    stream=True
-)
-
-for event in stream:
-    if event.type == "content_block_delta":
-        print(event.delta.text, end="", flush=True)
-```
-
-### Streaming Helpers
-
-```python
-async with client.messages.stream(
-    model="claude-sonnet-4-20250514",
-    max_tokens=1024,
-    messages=[
-        {
-            "role": "user",
-            "content": "Say hello there!"
-        }
-    ]
-) as stream:
-    async for text in stream.text_stream:
-        print(text, end="", flush=True)
-    print()
-
-message = await stream.get_final_message()
-```
-
-### Token Counting
-
-```python
-count = client.messages.count_tokens(
-    model="claude-sonnet-4-20250514",
-    messages=[
-        {"role": "user", "content": "Hello, world"}
-    ]
-)
-print(f"Input tokens: {count.input_tokens}")
-```
-
-### Message Batches
-
-```python
-batch = await client.messages.batches.create(
-    requests=[
-        {
-            "custom_id": "request-1",
-            "params": {
-                "model": "claude-sonnet-4-20250514",
-                "max_tokens": 1024,
-                "messages": [{"role": "user", "content": "Hello"}]
-            }
-        }
-    ]
-)
-```
-
-## Specialized Deployments
-
-### AWS Bedrock
-
-```python
-from anthropic import AnthropicBedrock
-
-client = AnthropicBedrock(
-    aws_region="us-east-1",
-    aws_profile="default"
-)
-
-message = client.messages.create(
-    model="anthropic.claude-sonnet-4-20250514-v1:0",
-    max_tokens=1024,
-    messages=[
-        {
-            "role": "user",
-            "content": "Hello!"
-        }
-    ]
-)
-```
-
-### Google Vertex AI
-
-```python
-from anthropic import AnthropicVertex
-
-client = AnthropicVertex()
-
-message = client.messages.create(
-    model="claude-sonnet-4@20250514",
-    max_tokens=1024,
-    messages=[
-        {
-            "role": "user",
-            "content": "Hello!"
-        }
-    ]
-)
-```
-
-## Error Handling
-
-```python
-import anthropic
-
-try:
-    message = client.messages.create(
-        model="claude-sonnet-4-20250514",
-        max_tokens=1024,
-        messages=[
-            {
-                "role": "user",
-                "content": "Hello, Claude"
-            }
-        ]
-    )
-except anthropic.APIConnectionError as e:
-    print("Connection error occurred")
-except anthropic.RateLimitError as e:
-    print("Rate limit exceeded")
-except anthropic.APIStatusError as e:
-    print(f"API error: {e.status_code}")
-```
-
-## Configuration Options
-
-### Retries
-
-```python
-client = Anthropic(max_retries=3)
-
-client.with_options(max_retries=5).messages.create(...)
-```
-
-### Timeouts
-
-```python
-client = Anthropic(timeout=30.0)
-
-client.with_options(timeout=60.0).messages.create(...)
-```
-
-## Useful Links
-
-- **Documentation:** https://docs.anthropic.com/claude/reference/
-- **API Keys:** https://console.anthropic.com/
-- **SDK Repository:** https://github.com/anthropics/anthropic-sdk-python
-- **Rate Limits:** https://docs.anthropic.com/claude/reference/rate-limits
-- **Error Codes:** https://docs.anthropic.com/claude/reference/errors

package/dist/openai/docs/chat/javascript/DOC.md

@@ -1,350 +0,0 @@
----
-name: chat
-description: "GPT-4 and ChatGPT API for text generation, chat completions, streaming, function calling, vision, embeddings, and assistants"
-metadata:
-  languages: "javascript"
-  versions: "6.7.0"
-  updated-on: "2025-10-24"
-  source: maintainer
-  tags: "openai,chat,llm,ai"
----
-
-# OpenAI API Coding Guidelines (JavaScript/TypeScript)
-
-You are an OpenAI API coding expert. Help me with writing code using the OpenAI API calling the official libraries and SDKs.
-
-## Golden Rule: Use the Correct and Current SDK
-
-Always use the official OpenAI Node.js SDK for all OpenAI API interactions.
-
-- **Library Name:** OpenAI Node.js SDK
-- **NPM Package:** `openai`
-- **JSR Package:** `@openai/openai`
-
-**Installation:**
-
-```bash
-# NPM
-npm install openai
-
-# JSR (Deno/Node.js)
-deno add jsr:@openai/openai
-npx jsr add @openai/openai
-```
-
-**Import Patterns:**
-
-```typescript
-// Correct - ES6 import
-import OpenAI from 'openai';
-
-// Correct - with additional utilities
-import OpenAI, { toFile } from 'openai';
-
-// JSR import for Deno
-import OpenAI from 'jsr:@openai/openai';
-```
-
-## Initialization and API Key
-
-The OpenAI library requires creating an `OpenAI` client instance for all API calls.
-
-```typescript
-import OpenAI from 'openai';
-
-// Uses OPENAI_API_KEY environment variable automatically
-const client = new OpenAI({
-  apiKey: process.env['OPENAI_API_KEY'], // This is the default and can be omitted
-});
-
-// Or pass API key directly
-const client = new OpenAI({
-  apiKey: 'your-api-key-here'
-});
-```
-
-## Primary APIs
-
-### Responses API (Recommended)
-
-The Responses API is the primary interface for text generation.
-
-```typescript
-import OpenAI from 'openai';
-
-const client = new OpenAI({
-  apiKey: process.env['OPENAI_API_KEY'],
-});
-
-const response = await client.responses.create({
-  model: 'gpt-4o',
-  instructions: 'You are a coding assistant that talks like a pirate',
-  input: 'Are semicolons optional in JavaScript?',
-});
-
-console.log(response.output_text);
-```
-
-### Chat Completions API (Legacy but Supported)
-
-The Chat Completions API remains fully supported for existing applications.
-
-```typescript
-import OpenAI from 'openai';
-
-const client = new OpenAI({
-  apiKey: process.env['OPENAI_API_KEY'],
-});
-
-const completion = await client.chat.completions.create({
-  model: 'gpt-4o',
-  messages: [
-    { role: 'developer', content: 'Talk like a pirate.' },
-    { role: 'user', content: 'Are semicolons optional in JavaScript?' },
-  ],
-});
-
-console.log(completion.choices[0].message.content);
-```
-
-## API Resources Structure
-
-The OpenAI client organizes endpoints into logical resource groupings:
-
-```typescript
-// Core API resources available on client
-client.completions     // Text completions
-client.chat           // Chat completions
-client.embeddings     // Text embeddings
-client.files          // File management
-client.images         // Image generation
-client.audio          // Audio processing
-client.moderations    // Content moderation
-client.models         // Model information
-client.fineTuning     // Fine-tuning jobs
-client.graders        // Model evaluation
-```
-
-## Streaming Responses
-
-Both Responses and Chat Completions APIs support streaming for real-time output.
-
-### Responses API Streaming
-
-```typescript
-import OpenAI from 'openai';
-
-const client = new OpenAI();
-
-const stream = await client.responses.create({
-  model: 'gpt-4o',
-  input: 'Say "Sheep sleep deep" ten times fast!',
-  stream: true,
-});
-
-for await (const event of stream) {
-  console.log(event);
-}
-```
-
-### Chat Completions Streaming
-
-```typescript
-const stream = await client.chat.completions.create({
-  model: 'gpt-4o',
-  messages: [{ role: 'user', content: 'Count to 10' }],
-  stream: true,
-});
-
-for await (const chunk of stream) {
-  process.stdout.write(chunk.choices[0]?.delta?.content || '');
-}
-```
-
-## File Uploads
-
-The library supports multiple file upload formats for various use cases.
-
-```typescript
-import fs from 'fs';
-import OpenAI, { toFile } from 'openai';
-
-const client = new OpenAI();
-
-// Method 1: Node.js fs.ReadStream (recommended for Node.js)
-await client.files.create({
-  file: fs.createReadStream('input.jsonl'),
-  purpose: 'fine-tune'
-});
-
-// Method 2: Web File API
-await client.files.create({
-  file: new File(['my bytes'], 'input.jsonl'),
-  purpose: 'fine-tune'
-});
-
-// Method 3: Fetch Response
-await client.files.create({
-  file: await fetch('https://somesite/input.jsonl'),
-  purpose: 'fine-tune'
-});
-
-// Method 4: toFile helper utility
-await client.files.create({
-  file: await toFile(Buffer.from('my bytes'), 'input.jsonl'),
-  purpose: 'fine-tune',
-});
-```
-
-## Advanced Configuration
-
-### Function Calling (Tools)
-
-```typescript
-const completion = await client.chat.completions.create({
-  model: 'gpt-4o',
-  messages: [{ role: 'user', content: 'What is the weather like today?' }],
-  tools: [
-    {
-      type: 'function',
-      function: {
-        name: 'get_current_weather',
-        description: 'Get the current weather in a given location',
-        parameters: {
-          type: 'object',
-          properties: {
-            location: {
-              type: 'string',
-              description: 'The city and state, e.g. San Francisco, CA',
-            },
-            unit: { type: 'string', enum: ['celsius', 'fahrenheit'] },
-          },
-          required: ['location'],
-        },
-      },
-    },
-  ],
-  tool_choice: 'auto',
-});
-```
-
-### Temperature and Sampling Parameters
-
-Configure model behavior using parameters in the chat completions API:
-
-```typescript
-const completion = await client.chat.completions.create({
-  model: 'gpt-4o',
-  messages: [{ role: 'user', content: 'Write a creative story' }],
-  temperature: 0.8,        // Higher = more creative (0-2)
-  max_tokens: 1000,        // Maximum response length
-  top_p: 0.9,             // Nucleus sampling
-  frequency_penalty: 0.1,  // Reduce repetition
-  presence_penalty: 0.1,   // Encourage new topics
-});
-```
-
-### Structured Outputs (JSON Mode)
-
-```typescript
-const completion = await client.chat.completions.create({
-  model: 'gpt-4o',
-  messages: [
-    { role: 'user', content: 'Extract the name and age from: "John is 30 years old"' }
-  ],
-  response_format: {
-    type: 'json_object'
-  },
-});
-
-const result = JSON.parse(completion.choices[0].message.content);
-```
-
-## Error Handling
-
-The library provides specific error types for different failure scenarios:
-
-```typescript
-import OpenAI from 'openai';
-
-const client = new OpenAI();
-
-try {
-  const completion = await client.chat.completions.create({
-    model: 'gpt-4o',
-    messages: [{ role: 'user', content: 'Hello!' }],
-  });
-} catch (error) {
-  if (error instanceof OpenAI.APIError) {
-    console.log(error.status);  // HTTP status code
-    console.log(error.name);    // Error name
-    console.log(error.headers); // Response headers
-  } else if (error instanceof OpenAI.RateLimitError) {
-    console.log('Rate limit exceeded');
-  } else if (error instanceof OpenAI.AuthenticationError) {
-    console.log('Invalid API key');
-  } else {
-    console.log('Unexpected error:', error);
-  }
-}
-```
-
-## Common Patterns
-
-### Retry Logic with Exponential Backoff
-
-```typescript
-async function createCompletionWithRetry(messages: any[], maxRetries = 3) {
-  for (let attempt = 1; attempt <= maxRetries; attempt++) {
-    try {
-      return await client.chat.completions.create({
-        model: 'gpt-4o',
-        messages,
-      });
-    } catch (error) {
-      if (error instanceof OpenAI.RateLimitError && attempt < maxRetries) {
-        const delay = Math.pow(2, attempt) * 1000; // Exponential backoff
-        await new Promise(resolve => setTimeout(resolve, delay));
-        continue;
-      }
-      throw error;
-    }
-  }
-}
-```
-
-### Conversation Management
-
-```typescript
-class ChatSession {
-  private messages: OpenAI.Chat.ChatCompletionMessageParam[] = [];
-
-  constructor(private client: OpenAI, systemPrompt?: string) {
-    if (systemPrompt) {
-      this.messages.push({ role: 'system', content: systemPrompt });
-    }
-  }
-
-  async sendMessage(content: string) {
-    this.messages.push({ role: 'user', content });
-
-    const completion = await this.client.chat.completions.create({
-      model: 'gpt-4o',
-      messages: this.messages,
-    });
-
-    const response = completion.choices[0].message;
-    this.messages.push(response);
-
-    return response.content;
-  }
-}
-```
-
-## Useful Links
-
-- **Documentation:** https://platform.openai.com/docs/api-reference
-- **API Keys:** https://platform.openai.com/api-keys
-- **Models:** https://platform.openai.com/docs/models
-- **Pricing:** https://openai.com/pricing
-- **Rate Limits:** https://platform.openai.com/docs/guides/rate-limits