From 05ca1919687662136182748988c281e307b4acb4 Mon Sep 17 00:00:00 2001
From: Peter Steinberger <steipete@gmail.com>
Date: Sat, 2 Aug 2025 22:49:53 +0200
Subject: [PATCH] Complete Tachikoma Swift Package with logo header

- Add complete Swift package implementation from vendored version
- All providers: OpenAI, Anthropic, Grok, Ollama with type separation
- Swift 6 strict concurrency support
- Comprehensive test suite
- Complete documentation (README, ARCHITECTURE, CHANGELOG)
- Add centered logo header to README for GitHub presentation
- Unified API for AI model integration
- Tool calling, streaming, and multimodal support
---
 .DS_Store                                     | Bin 0 -> 6148 bytes
 ARCHITECTURE.md                               | 476 ++++++++++++
 CHANGELOG.md                                  | 173 +++++
 Package.resolved                              |  15 +
 Package.swift                                 |  65 ++
 README.md                                     | 431 ++++++++++-
 Sources/Core/MessageTypes.swift               | 366 ++++++++++
 Sources/Core/ModelInterface.swift             | 424 +++++++++++
 Sources/Core/ModelParameters.swift            | 240 +++++++
 Sources/Core/ModelProvider.swift              | 650 +++++++++++++++++
 Sources/Core/StreamingTypes.swift             | 381 ++++++++++
 Sources/Core/TachikomaError.swift             | 202 ++++++
 Sources/Core/ToolDefinitions.swift            | 597 +++++++++++++++
 .../Providers/Anthropic/AnthropicModel.swift  | 642 +++++++++++++++++
 .../Providers/Anthropic/AnthropicTypes.swift  | 678 ++++++++++++++++++
 Sources/Providers/Grok/GrokModel.swift        | 479 +++++++++++++
 Sources/Providers/Grok/GrokTypes.swift        | 346 +++++++++
 Sources/Providers/Ollama/OllamaModel.swift    | 336 +++++++++
 Sources/Providers/Ollama/OllamaTypes.swift    |  69 ++
 Sources/Providers/OpenAI/OpenAIModel.swift    | 516 +++++++++++++
 Sources/Providers/OpenAI/OpenAITypes.swift    | 481 +++++++++++++
 Sources/Tachikoma.swift                       |  87 +++
 .../TachikomaTests/AnthropicModelTests.swift  | 373 ++++++++++
 Tests/TachikomaTests/GrokModelTests.swift     | 331 +++++++++
 Tests/TachikomaTests/OllamaModelTests.swift   | 611 ++++++++++++++++
 Tests/TachikomaTests/OpenAIModelTests.swift   | 475 ++++++++++++
 .../StreamingAndToolTests.swift               | 439 ++++++++++++
 Tests/TachikomaTests/TachikomaCoreTests.swift | 507 +++++++++++++
 assets/logo.png                               | Bin 0 -> 341825 bytes
 29 files changed, 10388 insertions(+), 2 deletions(-)
 create mode 100644 .DS_Store
 create mode 100644 ARCHITECTURE.md
 create mode 100644 CHANGELOG.md
 create mode 100644 Package.resolved
 create mode 100644 Package.swift
 create mode 100644 Sources/Core/MessageTypes.swift
 create mode 100644 Sources/Core/ModelInterface.swift
 create mode 100644 Sources/Core/ModelParameters.swift
 create mode 100644 Sources/Core/ModelProvider.swift
 create mode 100644 Sources/Core/StreamingTypes.swift
 create mode 100644 Sources/Core/TachikomaError.swift
 create mode 100644 Sources/Core/ToolDefinitions.swift
 create mode 100644 Sources/Providers/Anthropic/AnthropicModel.swift
 create mode 100644 Sources/Providers/Anthropic/AnthropicTypes.swift
 create mode 100644 Sources/Providers/Grok/GrokModel.swift
 create mode 100644 Sources/Providers/Grok/GrokTypes.swift
 create mode 100644 Sources/Providers/Ollama/OllamaModel.swift
 create mode 100644 Sources/Providers/Ollama/OllamaTypes.swift
 create mode 100644 Sources/Providers/OpenAI/OpenAIModel.swift
 create mode 100644 Sources/Providers/OpenAI/OpenAITypes.swift
 create mode 100644 Sources/Tachikoma.swift
 create mode 100644 Tests/TachikomaTests/AnthropicModelTests.swift
 create mode 100644 Tests/TachikomaTests/GrokModelTests.swift
 create mode 100644 Tests/TachikomaTests/OllamaModelTests.swift
 create mode 100644 Tests/TachikomaTests/OpenAIModelTests.swift
 create mode 100644 Tests/TachikomaTests/StreamingAndToolTests.swift
 create mode 100644 Tests/TachikomaTests/TachikomaCoreTests.swift
 create mode 100644 assets/logo.png

diff --git a/.DS_Store b/.DS_Store
new file mode 100644
index 0000000000000000000000000000000000000000..ff30e0c302c8b3f6585895c75e1d9250bab482eb
GIT binary patch
literal 6148
zcmeHKOHKko5PgkAK{qVj5a$AtaDxGd1&O+l4NC<Knm~pGbZ0VG@FX6?W4Q7h_^PXe
zG>A(>OckkmJ@x6HeltvW190u9Q4^>Es89t<Rhl0};-Xtp3Z7%4lRhTnW^b5JXIq)(
z*jEPR*_F}27>`)Q&+qkPJvPm=Y%s|O^i}HB<#Ye+y%ontzs6?|Yww1>IfuBzoWFZ4
zFptM(&p;GkAOG{b{u0LD$oam9T{+Qx_+fB_OLTF84zAHdr#s1qVW#r8kXbgCUVM5L
zH_U7y!xgcCDMlL=ZyOc9%#1N$3>X7@!~oZ9k;;jpS!2K$Fa}l($oC<k3Z?-IMgQrb
z@f$f}nQkv^%ce<cl7MNzLXi=Q(^8_Ax^TpBT26lw^3s5XqL#zy77{Lu?7|7f`O(>b
z;?v<$MYG0$F%UCwpqDjS|2w<S|8bFB83V?^zhc0ZvtHKbl)~D&H91*p6Y4EhMDhy7
kRS6q@DQ2!L#ivv+^e56FrU45@dMLIL@HCh)2L6<RFUqD|p8x;=

literal 0
HcmV?d00001

diff --git a/ARCHITECTURE.md b/ARCHITECTURE.md
new file mode 100644
index 0000000..2bbd4ec
--- /dev/null
+++ b/ARCHITECTURE.md
@@ -0,0 +1,476 @@
+# Tachikoma Architecture
+
+This document provides a detailed technical overview of the Tachikoma AI integration library architecture.
+
+## Overview
+
+Tachikoma is designed as a modular, type-safe Swift package that abstracts AI provider differences behind a unified interface. The architecture emphasizes Swift 6 concurrency safety, performance, and extensibility.
+
+## Core Architecture Principles
+
+### 1. Protocol-Oriented Design
+All AI providers implement the `ModelInterface` protocol, ensuring consistent behavior across different services while allowing provider-specific optimizations.
+
+### 2. Swift 6 Strict Concurrency
+- All public APIs are actor-safe
+- Sendable conformance throughout the type system
+- `@MainActor` isolation where appropriate
+- No data races or concurrency issues
+
+### 3. Type Safety
+- Strongly-typed message system with enum-based content types
+- Compile-time verification of tool parameters
+- Generic tool system with context type safety
+
+### 4. Performance First
+- Intelligent caching with configurable policies
+- Streaming responses with minimal memory overhead
+- Lazy provider initialization
+- Efficient JSON handling without reflection
+
+## Module Structure
+
+```
+Tachikoma/
+├── Sources/Tachikoma/
+│   ├── Tachikoma.swift              # Main API entry point
+│   ├── Core/                        # Core abstractions
+│   │   ├── ModelInterface.swift     # Provider protocol
+│   │   ├── ModelProvider.swift      # Provider registry & management
+│   │   ├── MessageTypes.swift       # Message type system
+│   │   ├── StreamingTypes.swift     # Streaming event system
+│   │   ├── ModelParameters.swift    # Request/response parameters
+│   │   ├── ToolDefinitions.swift    # Tool calling system
+│   │   └── TachikomaError.swift     # Error handling
+│   └── Providers/                   # Provider implementations
+│       ├── OpenAI/
+│       │   ├── OpenAIModel.swift    # OpenAI implementation
+│       │   └── OpenAITypes.swift    # OpenAI-specific types
+│       ├── Anthropic/
+│       │   ├── AnthropicModel.swift # Anthropic implementation
+│       │   └── AnthropicTypes.swift # Anthropic-specific types
+│       ├── Grok/
+│       │   ├── GrokModel.swift      # Grok implementation
+│       │   └── GrokTypes.swift      # Grok-specific types
+│       └── Ollama/
+│           ├── OllamaModel.swift    # Ollama implementation
+│           └── OllamaTypes.swift    # Ollama-specific types
+```
+
+## Core Components
+
+### ModelInterface Protocol
+
+The central abstraction that all providers implement:
+
+```swift
+@available(macOS 14.0, iOS 17.0, watchOS 10.0, tvOS 17.0, *)
+public protocol ModelInterface: Sendable {
+    /// Masked API key for debugging
+    var maskedApiKey: String { get }
+    
+    /// Get a single response
+    func getResponse(request: ModelRequest) async throws -> ModelResponse
+    
+    /// Get streaming response
+    func getStreamedResponse(request: ModelRequest) async throws -> AsyncThrowingStream<StreamEvent, any Error>
+}
+```
+
+**Key Design Decisions:**
+- `Sendable` conformance ensures thread safety
+- Async/await for all network operations
+- Streaming uses `AsyncThrowingStream` for memory efficiency
+- Availability annotations ensure compatibility
+
+### Message Type System
+
+Hierarchical message types that handle all AI interaction patterns:
+
+```swift
+public enum Message: Codable, Sendable {
+    case system(id: String? = nil, content: String)
+    case user(id: String? = nil, content: MessageContent)
+    case assistant(id: String? = nil, content: [AssistantContent], status: MessageStatus = .completed)
+    case tool(id: String? = nil, toolCallId: String, content: String)
+    case reasoning(id: String? = nil, content: String)
+}
+```
+
+**Content Type Hierarchy:**
+- `MessageContent`: Text, images, multimodal, files, audio
+- `AssistantContent`: Text output, refusals, tool calls
+- `ImageContent`: URLs, base64 data, detail levels
+- `AudioContent`: Transcripts, durations, metadata
+
+**Benefits:**
+- Type safety prevents invalid message construction
+- Codable conformance for persistence
+- Sendable for concurrency safety
+- Extensible for new content types
+
+### Streaming System
+
+Real-time event processing with comprehensive event types:
+
+```swift
+public enum StreamEvent {
+    case responseStarted(StreamResponseStarted)
+    case textDelta(StreamTextDelta)
+    case toolCallDelta(StreamToolCallDelta)
+    case toolCallCompleted(StreamToolCallCompleted)
+    case responseCompleted(StreamResponseCompleted)
+    case error(StreamError)
+}
+```
+
+**Stream Processing Flow:**
+1. `responseStarted` - Metadata and initialization
+2. `textDelta` - Incremental text content
+3. `toolCallDelta` - Incremental tool call construction
+4. `toolCallCompleted` - Complete tool call available
+5. `responseCompleted` - Stream finished with final metadata
+6. `error` - Error events for handling failures
+
+**Implementation Details:**
+- Each provider converts its streaming format to unified events
+- Back-pressure handling through `AsyncThrowingStream`
+- Automatic event ordering and consistency validation
+
+### Tool Calling System
+
+Generic, type-safe tool execution with context support:
+
+```swift
+public struct Tool<Context> {
+    public let execute: (ToolInput, Context) async throws -> ToolOutput
+    
+    public func toToolDefinition() -> ToolDefinition {
+        // Convert to provider-agnostic definition
+    }
+}
+```
+
+**Type Safety Features:**
+- Generic context ensures compile-time type checking
+- Parameter validation through JSON Schema
+- Async execution for I/O operations
+- Error handling with structured failures
+
+**Tool Definition System:**
+```swift
+public struct ToolDefinition {
+    public let function: FunctionDefinition
+    public let type: ToolType = .function
+}
+
+public struct FunctionDefinition {
+    public let name: String
+    public let description: String?
+    public let parameters: ToolParameters
+}
+```
+
+### Error Handling
+
+Comprehensive error system with recovery guidance:
+
+```swift
+public enum TachikomaError: Error, LocalizedError {
+    case modelNotFound(String)
+    case authenticationFailed
+    case invalidConfiguration(String)
+    case networkError(underlying: any Error)
+    case rateLimited
+    case insufficientQuota
+    case contextLengthExceeded
+    // ... more cases
+    
+    public var isRetryable: Bool { /* logic */ }
+    public var recoverySuggestion: String? { /* guidance */ }
+}
+```
+
+**Error Categories:**
+- **Client Errors**: Invalid requests, configuration issues
+- **Authentication Errors**: API key problems, quota issues
+- **Network Errors**: Connectivity, timeouts, server errors
+- **Provider Errors**: Model-specific limitations
+
+## Provider Implementations
+
+### OpenAI Provider
+
+**Dual API Support:**
+- Chat Completions API (`/v1/chat/completions`) for standard models
+- Responses API (`/v1/responses`) for o3/o4 reasoning models
+
+**Key Features:**
+- Automatic API selection based on model capabilities
+- Parameter filtering (o3/o4 models don't support temperature)
+- Reasoning summary handling for thinking models
+- Complete streaming support for both APIs
+
+**Implementation Highlights:**
+```swift
+private func convertToOpenAIRequest(_ request: ModelRequest, stream: Bool) throws -> OpenAIRequest {
+    // Convert unified request to OpenAI format
+    // Handle parameter filtering
+    // Support both API formats
+}
+```
+
+### Anthropic Provider
+
+**Native Claude Integration:**
+- Direct Claude API with proper message formatting
+- Content blocks for multimodal inputs
+- System prompt separation
+- Tool result handling as user messages
+
+**Streaming Implementation:**
+- Server-Sent Events (SSE) processing
+- Delta accumulation for tool calls
+- Proper handling of Claude's content block structure
+
+**Claude 4 Features:**
+- Extended thinking modes
+- Long-running task support
+- Advanced reasoning capabilities
+
+### Grok Provider
+
+**OpenAI Compatibility:**
+- Uses OpenAI-compatible Chat Completions API
+- Parameter filtering for Grok 3/4 models
+- Standard streaming implementation
+
+**Optimizations:**
+- Efficient parameter encoding
+- Proper error response handling
+- Rate limiting awareness
+
+### Ollama Provider
+
+**Local Inference:**
+- HTTP API for local models
+- Custom timeout handling (5 minutes for model loading)
+- Tool calling detection for compatible models
+
+**Model Support:**
+- Language models: llama3.3, mistral, etc.
+- Vision models: llava, bakllava (no tool calling)
+- Custom model endpoints
+
+## Provider Registry & Management
+
+### ModelProvider (Actor)
+
+Central registry for all model factories and instances:
+
+```swift
+@MainActor
+public final class ModelProvider {
+    public static let shared = ModelProvider()
+    
+    private var modelFactories: [String: @Sendable () throws -> any ModelInterface] = [:]
+    private var modelCache: [String: any ModelInterface] = [:]
+    
+    public func getModel(_ modelName: String) async throws -> any ModelInterface
+    public func register(modelName: String, factory: @escaping @Sendable () throws -> any ModelInterface)
+}
+```
+
+**Registration System:**
+- Default model registration at startup
+- Custom factory registration
+- Lenient name matching (e.g., "gpt" → "gpt-4.1")
+- Provider/model path resolution ("openai/gpt-4")
+
+**Caching Strategy:**
+- Model instances cached after first creation
+- Cache invalidation on registration changes
+- Memory-efficient with weak references where appropriate
+
+## Concurrency & Threading
+
+### Actor Usage
+
+**ModelProvider as MainActor:**
+- Centralizes model management
+- Ensures thread-safe registration
+- Coordinates provider initialization
+
+**Sendable Conformance:**
+- All message types are Sendable
+- Model instances are Sendable
+- Error types are Sendable
+- Tool definitions are Sendable
+
+**Async/Await Integration:**
+- All network operations are async
+- Streaming uses AsyncThrowingStream
+- No blocking operations on main thread
+
+### Memory Management
+
+**Streaming Efficiency:**
+- Events processed incrementally
+- No accumulation of entire responses
+- Automatic memory cleanup
+
+**Cache Management:**
+- Model instances cached intelligently
+- Configurable cache policies
+- Weak references for large objects
+
+## Security Considerations
+
+### API Key Handling
+
+**Environment Variables:**
+- Support for multiple key formats
+- Secure key storage recommendations
+- Masked keys in debug output
+
+**Key Security:**
+- Never log full API keys
+- Secure transmission only
+- No persistence of keys in plain text
+
+### Input Validation
+
+**Parameter Validation:**
+- Type-safe parameter construction
+- Range validation for numeric parameters
+- Required field enforcement
+
+**Content Filtering:**
+- Provider-specific content policies
+- Error handling for filtered content
+- Transparent policy communication
+
+## Performance Characteristics
+
+### Network Efficiency
+
+**Connection Management:**
+- URLSession with appropriate timeouts
+- HTTP/2 support where available
+- Connection pooling
+
+**Request Optimization:**
+- Minimal payload size
+- Efficient JSON encoding
+- Compression support
+
+### Memory Usage
+
+**Streaming Responses:**
+- Constant memory usage regardless of response size
+- Incremental processing
+- Automatic garbage collection
+
+**Object Creation:**
+- Minimal allocations in hot paths
+- Reuse of formatter objects
+- Efficient string handling
+
+## Testing Strategy
+
+### Unit Tests
+
+**Provider Tests:**
+- Mock network responses
+- Error condition testing
+- Parameter validation tests
+
+**Integration Tests:**
+- End-to-end flow testing
+- Streaming behavior validation
+- Tool calling integration
+
+**Performance Tests:**
+- Memory usage profiling
+- Response time benchmarks
+- Concurrent request handling
+
+## Extension Points
+
+### Custom Providers
+
+Implement `ModelInterface` to add new providers:
+
+```swift
+class CustomProvider: ModelInterface {
+    var maskedApiKey: String { "custom-***" }
+    
+    func getResponse(request: ModelRequest) async throws -> ModelResponse {
+        // Custom implementation
+    }
+    
+    func getStreamedResponse(request: ModelRequest) async throws -> AsyncThrowingStream<StreamEvent, Error> {
+        // Custom streaming
+    }
+}
+```
+
+### Message Type Extensions
+
+Add new content types by extending `MessageContent`:
+
+```swift
+extension MessageContent {
+    case customType(CustomData)
+}
+```
+
+### Tool System Extensions
+
+Create specialized tool contexts:
+
+```swift
+struct DatabaseContext {
+    let connection: DatabaseConnection
+    let schema: Schema
+}
+
+let dbTool = Tool<DatabaseContext> { input, context in
+    // Database operations with type-safe context
+}
+```
+
+## Future Considerations
+
+### Planned Features
+
+**Enhanced Caching:**
+- Persistent cache with TTL
+- Smart cache invalidation
+- Distributed caching support
+
+**Advanced Streaming:**
+- Bidirectional streaming
+- Stream multiplexing
+- Custom event types
+
+**Provider Enhancements:**
+- More granular configuration
+- Provider-specific optimizations
+- Enhanced error recovery
+
+### Scalability
+
+**High-Volume Usage:**
+- Connection pooling improvements
+- Request batching
+- Rate limiting integration
+
+**Enterprise Features:**
+- Audit logging
+- Metrics collection
+- Custom authentication
+
+---
+
+This architecture provides a solid foundation for AI integration while maintaining flexibility for future enhancements and provider additions.
\ No newline at end of file
diff --git a/CHANGELOG.md b/CHANGELOG.md
new file mode 100644
index 0000000..d05c911
--- /dev/null
+++ b/CHANGELOG.md
@@ -0,0 +1,173 @@
+# Changelog
+
+All notable changes to the Tachikoma project will be documented in this file.
+
+The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),
+and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
+
+## [1.0.0] - 2025-01-XX
+
+### Added
+
+#### Core Framework
+- Initial release of Tachikoma AI integration library
+- Unified `ModelInterface` protocol for all AI providers
+- Comprehensive message type system with multimodal support
+- Real-time streaming response handling with `AsyncThrowingStream`
+- Type-safe tool calling system with generic context support
+- Actor-based provider registry with intelligent caching
+- Swift 6 strict concurrency compliance throughout
+
+#### Provider Support
+- **OpenAI Provider**: Complete integration with dual API support
+  - Chat Completions API for standard models (GPT-4o, GPT-4.1)
+  - Responses API for reasoning models (o3, o4 series)
+  - Automatic API selection based on model capabilities
+  - Parameter filtering for reasoning models
+  - Full streaming support for both APIs
+  - Reasoning summary handling for thinking models
+
+- **Anthropic Provider**: Native Claude API integration
+  - Support for Claude 4 (Opus, Sonnet) with thinking modes
+  - Claude 3.5/3.7 series compatibility
+  - Content block handling for multimodal inputs
+  - System prompt separation
+  - Server-Sent Events streaming
+  - Extended reasoning capabilities
+
+- **Grok Provider**: xAI integration with OpenAI compatibility
+  - Grok 4, Grok 3, Grok 2 series support
+  - Vision model capabilities
+  - Parameter filtering for Grok 3/4 models
+  - Standard streaming implementation
+  - OpenAI-compatible Chat Completions API
+
+- **Ollama Provider**: Local model inference support
+  - Support for Llama 3.3 (recommended), Mistral, CodeLlama
+  - Vision models (llava, bakllava) without tool calling
+  - Configurable endpoints for self-hosted deployments
+  - Extended timeouts for local model loading
+  - Tool calling detection for compatible models
+
+#### Message System
+- **Unified Message Types**: Support for system, user, assistant, tool, and reasoning messages
+- **Content Types**: Text, images (URL/base64), multimodal, files, audio with transcripts
+- **Assistant Content**: Text output, refusals, tool calls with proper typing
+- **Image Support**: High/low detail levels, multiple formats, base64 encoding
+- **Audio Support**: Transcript extraction, duration metadata
+
+#### Streaming System
+- **Event-Based Architecture**: Comprehensive streaming event types
+- **Real-Time Processing**: Incremental text deltas, tool call construction
+- **Memory Efficiency**: Constant memory usage regardless of response size
+- **Error Handling**: Structured error events with recovery information
+- **Provider Abstraction**: Unified events across different provider formats
+
+#### Tool Calling
+- **Generic Tool System**: Type-safe tool execution with context support
+- **Parameter Validation**: JSON Schema-based parameter validation
+- **Async Execution**: Non-blocking tool execution with proper error handling
+- **Tool Definitions**: Provider-agnostic tool definition format
+- **Context Management**: Type-safe context passing to tool functions
+
+#### Error Handling
+- **Comprehensive Error Types**: Structured error hierarchy with recovery guidance
+- **Provider-Specific Errors**: Tailored error handling for each provider
+- **Retry Logic**: Built-in retry detection with exponential backoff support
+- **Error Categories**: Client, authentication, network, and provider errors
+- **Localized Descriptions**: User-friendly error messages with recovery suggestions
+
+#### Configuration System
+- **Environment Variables**: Support for standard API key environment variables
+- **Provider Configuration**: Flexible configuration for custom endpoints
+- **Model Registration**: Runtime model factory registration
+- **Lenient Matching**: Intelligent model name resolution
+- **Cache Management**: Configurable caching policies
+
+### Technical Features
+
+#### Swift 6 Compliance
+- **Strict Concurrency**: Full Swift 6 strict concurrency mode compliance
+- **Sendable Conformance**: All public types conform to Sendable protocol
+- **Actor Safety**: Thread-safe operations with proper isolation
+- **Memory Safety**: No data races or concurrency issues
+- **Performance**: Optimized for concurrent execution
+
+#### Performance Optimizations
+- **Intelligent Caching**: Model instance caching with smart invalidation
+- **Connection Pooling**: Efficient network connection management
+- **Memory Management**: Minimal allocations and efficient garbage collection
+- **Streaming Efficiency**: Incremental processing without accumulation
+- **JSON Optimization**: Fast encoding/decoding without reflection
+
+#### Type Safety
+- **Compile-Time Verification**: Strong typing throughout the API
+- **Generic Constraints**: Type-safe tool contexts and parameters
+- **Enum-Based Design**: Exhaustive pattern matching for robustness
+- **Protocol-Oriented**: Clean abstractions with concrete implementations
+
+### Documentation
+- Comprehensive README with quick start guide
+- Detailed architecture documentation
+- API reference documentation
+- Code examples for common usage patterns
+- Migration guide from PeekabooCore
+- Performance optimization guidelines
+
+### Testing
+- Unit tests for all core components
+- Integration tests for provider functionality
+- Mock providers for testing scenarios
+- Performance benchmarks
+- Concurrency safety tests
+
+### Platform Support
+- macOS 14.0+
+- iOS 17.0+
+- watchOS 10.0+
+- tvOS 17.0+
+- Swift 6.0+
+- Xcode 16.0+
+
+## [Unreleased]
+
+### Planned Features
+- Enhanced caching with persistence and TTL
+- Bidirectional streaming support
+- Request batching for high-volume usage
+- Advanced error recovery mechanisms
+- Metrics collection and monitoring
+- Distributed caching support
+
+---
+
+## Version History
+
+- **v1.0.0**: Initial release extracted from PeekabooCore with Swift 6 compliance
+- **v0.x.x**: Development versions (internal)
+
+## Migration Notes
+
+### From PeekabooCore
+When migrating from PeekabooCore's AI system:
+
+1. **Error Types**: Replace `PeekabooError` with `TachikomaError`
+2. **Import Statements**: Update to `import Tachikoma`
+3. **Model Creation**: Use `Tachikoma.shared.getModel()` instead of direct instantiation
+4. **Streaming Events**: Update event handling for new event type hierarchy
+5. **Message Types**: Adopt new unified message type system
+6. **Tool Calling**: Update to generic tool system with context support
+
+### Breaking Changes
+This is the initial release, so no breaking changes from previous versions.
+
+## Contributors
+
+- **Extraction Lead**: AI Assistant
+- **Original Code**: Peekaboo project contributors
+- **Architecture Design**: Based on proven patterns from PeekabooCore
+- **Swift 6 Migration**: Complete rewrite for strict concurrency compliance
+
+## License
+
+This project is licensed under the MIT License. See LICENSE file for details.
\ No newline at end of file
diff --git a/Package.resolved b/Package.resolved
new file mode 100644
index 0000000..f2401e3
--- /dev/null
+++ b/Package.resolved
@@ -0,0 +1,15 @@
+{
+  "originHash" : "3929c9b9fd81518c26df5464b3e6a459042d74460f8bfd7fb79e21dc5c507bdf",
+  "pins" : [
+    {
+      "identity" : "swift-log",
+      "kind" : "remoteSourceControl",
+      "location" : "https://github.com/apple/swift-log.git",
+      "state" : {
+        "revision" : "ce592ae52f982c847a4efc0dd881cc9eb32d29f2",
+        "version" : "1.6.4"
+      }
+    }
+  ],
+  "version" : 3
+}
diff --git a/Package.swift b/Package.swift
new file mode 100644
index 0000000..e820da2
--- /dev/null
+++ b/Package.swift
@@ -0,0 +1,65 @@
+// swift-tools-version: 6.0
+// The swift-tools-version declares the minimum version of Swift required to build this package.
+
+import PackageDescription
+
+let package = Package(
+    name: "Tachikoma",
+    platforms: [
+        .macOS(.v14),
+        .iOS(.v17),
+        .watchOS(.v10),
+        .tvOS(.v17)
+    ],
+    products: [
+        .library(
+            name: "Tachikoma",
+            targets: ["Tachikoma"]
+        ),
+    ],
+    dependencies: [
+        .package(url: "https://github.com/apple/swift-log.git", from: "1.0.0"),
+    ],
+    targets: [
+        .target(
+            name: "Tachikoma",
+            dependencies: [
+                .product(name: "Logging", package: "swift-log"),
+            ],
+            path: "Sources",
+            swiftSettings: [
+                .enableExperimentalFeature("StrictConcurrency"),
+                .enableUpcomingFeature("BareSlashRegexLiterals"),
+                .enableUpcomingFeature("ConciseMagicFile"),
+                .enableUpcomingFeature("ForwardTrailingClosures"),
+                .enableUpcomingFeature("ImportObjcForwardDeclarations"),
+                .enableUpcomingFeature("DisableOutwardActorInference"),
+                .enableUpcomingFeature("ExistentialAny"),
+                .enableUpcomingFeature("DeprecateApplicationMain"),
+                .enableUpcomingFeature("GlobalConcurrency"),
+                .enableUpcomingFeature("IsolatedDefaultValues"),
+                .enableUpcomingFeature("InternalImportsByDefault"),
+            ]
+        ),
+        .testTarget(
+            name: "TachikomaTests",
+            dependencies: [
+                "Tachikoma",
+                .product(name: "Logging", package: "swift-log"),
+            ],
+            swiftSettings: [
+                .enableExperimentalFeature("StrictConcurrency"),
+                .enableUpcomingFeature("BareSlashRegexLiterals"),
+                .enableUpcomingFeature("ConciseMagicFile"),
+                .enableUpcomingFeature("ForwardTrailingClosures"),
+                .enableUpcomingFeature("ImportObjcForwardDeclarations"),
+                .enableUpcomingFeature("DisableOutwardActorInference"),
+                .enableUpcomingFeature("ExistentialAny"),
+                .enableUpcomingFeature("DeprecateApplicationMain"),
+                .enableUpcomingFeature("GlobalConcurrency"),
+                .enableUpcomingFeature("IsolatedDefaultValues"),
+                .enableUpcomingFeature("InternalImportsByDefault"),
+            ]
+        ),
+    ]
+)
\ No newline at end of file
diff --git a/README.md b/README.md
index 14aa939..76b6d7a 100644
--- a/README.md
+++ b/README.md
@@ -1,2 +1,429 @@
-# Tachikoma
-One interface, every AI model. A Swift SDK to interface with AI providers.
+<div align="center">
+  <img src="assets/logo.png" alt="Tachikoma Logo" width="200">
+  <h1>Tachikoma</h1>
+</div>
+
+A comprehensive Swift package for AI model integration, providing a unified interface for multiple AI providers including OpenAI, Anthropic, Grok (xAI), and Ollama.
+
+Named after the spider-tank AI from Ghost in the Shell, Tachikoma provides an intelligent, adaptable interface for AI services.
+
+## Features
+
+- **Unified API**: Single interface for multiple AI providers
+- **Swift 6 Compliant**: Built with Swift 6 strict concurrency mode for maximum safety
+- **Streaming Support**: Real-time streaming responses for all supported providers
+- **Tool Calling**: Complete function calling support for AI agent workflows
+- **Multimodal**: Support for text, images, audio, and file inputs
+- **Type Safety**: Strongly-typed message handling and error management
+- **Performance**: Optimized for efficiency with intelligent caching and resource management
+
+## Supported Providers
+
+### OpenAI
+- **Models**: GPT-4o, GPT-4.1, o3, o4 series with full parameter support
+- **Features**: Chat Completions API, Responses API, streaming, tool calling, multimodal
+- **API Types**: Automatic selection between Chat Completions and Responses APIs
+
+### Anthropic (Claude)
+- **Models**: Claude 4 (Opus, Sonnet), Claude 3.5/3.7 series with thinking modes
+- **Features**: Native streaming, tool calling, multimodal, extended reasoning
+- **Capabilities**: Long-running tasks, system prompts, safety filtering
+
+### Grok (xAI)
+- **Models**: Grok 4, Grok 3, Grok 2 series with vision capabilities
+- **Features**: OpenAI-compatible API, streaming, tool calling, parameter filtering
+- **Performance**: High-speed inference with competitive pricing
+
+### Ollama
+- **Models**: Llama 3.3 (recommended), Mistral, CodeLlama, and vision models
+- **Features**: Local inference, tool calling (select models), streaming
+- **Deployment**: Self-hosted with configurable endpoints
+
+## Installation
+
+### Swift Package Manager
+
+Add Tachikoma as a dependency in your `Package.swift`:
+
+```swift
+dependencies: [
+    .package(url: "https://github.com/steipete/Tachikoma", from: "1.0.0")
+]
+```
+
+### Requirements
+
+- macOS 14.0+, iOS 17.0+, watchOS 10.0+, tvOS 17.0+
+- Swift 6.0+
+- Xcode 16.0+
+
+## Quick Start
+
+### Basic Usage
+
+```swift
+import Tachikoma
+
+// Get a model instance
+let tachikoma = Tachikoma.shared
+let model = try await tachikoma.getModel("claude-opus-4")
+
+// Create a simple request
+let request = ModelRequest(
+    messages: [
+        .user(content: .text("What is the capital of France?"))
+    ]
+)
+
+// Get response
+let response = try await model.getResponse(request: request)
+print(response.content.first?.text ?? "No response")
+```
+
+### Streaming Responses
+
+```swift
+let request = ModelRequest(
+    messages: [.user(content: .text("Write a story about AI"))],
+    settings: ModelSettings(temperature: 0.7)
+)
+
+for try await event in try await model.getStreamedResponse(request: request) {
+    switch event {
+    case .textDelta(let delta):
+        print(delta.delta, terminator: "")
+    case .responseCompleted:
+        print("\n[Stream completed]")
+    default:
+        break
+    }
+}
+```
+
+### Tool Calling
+
+```swift
+// Define a tool
+let weatherTool = ToolDefinition(
+    function: FunctionDefinition(
+        name: "get_weather",
+        description: "Get current weather for a location",
+        parameters: ToolParameters(
+            type: "object",
+            properties: [
+                "location": ParameterSchema(
+                    type: .string,
+                    description: "City name"
+                )
+            ],
+            required: ["location"]
+        )
+    )
+)
+
+let request = ModelRequest(
+    messages: [.user(content: .text("What's the weather in Tokyo?"))],
+    tools: [weatherTool],
+    settings: ModelSettings(toolChoice: .auto)
+)
+
+let response = try await model.getResponse(request: request)
+// Handle tool calls in response.content
+```
+
+### Multimodal Inputs
+
+```swift
+let imageData = Data(contentsOf: imageURL)
+let base64Image = imageData.base64EncodedString()
+
+let request = ModelRequest(
+    messages: [
+        .user(content: .multimodal([
+            .text("What do you see in this image?"),
+            .imageUrl(ImageUrl(
+                base64: base64Image,
+                detail: .high
+            ))
+        ]))
+    ]
+)
+
+let response = try await model.getResponse(request: request)
+```
+
+## Configuration
+
+### Environment Variables
+
+```bash
+# OpenAI
+export OPENAI_API_KEY="sk-..."
+
+# Anthropic
+export ANTHROPIC_API_KEY="sk-ant-..."
+
+# Grok (xAI)
+export X_AI_API_KEY="xai-..."
+# or
+export XAI_API_KEY="xai-..."
+
+# Ollama (optional, defaults to localhost:11434)
+export PEEKABOO_OLLAMA_BASE_URL="http://localhost:11434"
+```
+
+### Provider Configuration
+
+```swift
+// Configure custom provider settings
+let openAIConfig = ProviderConfiguration.openAI(
+    apiKey: "your-api-key",
+    baseURL: URL(string: "https://api.openai.com/v1"),
+    organizationId: "org-id"
+)
+
+try await Tachikoma.shared.configureProvider(openAIConfig)
+
+// Register custom model
+await Tachikoma.shared.registerModel(name: "custom-gpt") {
+    OpenAIModel(
+        apiKey: "your-key",
+        modelName: "gpt-4-custom"
+    )
+}
+```
+
+## Architecture
+
+### Core Components
+
+#### ModelInterface
+The unified protocol that all AI providers implement:
+
+```swift
+protocol ModelInterface: Sendable {
+    var maskedApiKey: String { get }
+    func getResponse(request: ModelRequest) async throws -> ModelResponse
+    func getStreamedResponse(request: ModelRequest) async throws -> AsyncThrowingStream<StreamEvent, Error>
+}
+```
+
+#### Message System
+Type-safe message handling with support for all content types:
+
+```swift
+public enum Message: Codable, Sendable {
+    case system(id: String? = nil, content: String)
+    case user(id: String? = nil, content: MessageContent)
+    case assistant(id: String? = nil, content: [AssistantContent], status: MessageStatus = .completed)
+    case tool(id: String? = nil, toolCallId: String, content: String)
+    case reasoning(id: String? = nil, content: String)
+}
+```
+
+#### Streaming System
+Real-time event handling for streaming responses:
+
+```swift
+public enum StreamEvent {
+    case responseStarted(StreamResponseStarted)
+    case textDelta(StreamTextDelta)
+    case toolCallDelta(StreamToolCallDelta)
+    case toolCallCompleted(StreamToolCallCompleted)
+    case responseCompleted(StreamResponseCompleted)
+    case error(StreamError)
+}
+```
+
+#### Tool System
+Comprehensive function calling with generic context support:
+
+```swift
+public struct Tool<Context> {
+    public let execute: (ToolInput, Context) async throws -> ToolOutput
+    public func toToolDefinition() -> ToolDefinition
+}
+```
+
+### Provider Architecture
+
+Each provider implements the `ModelInterface` with provider-specific optimizations:
+
+- **OpenAI**: Dual API support (Chat Completions + Responses API)
+- **Anthropic**: Native SSE streaming with content blocks
+- **Grok**: OpenAI-compatible with parameter filtering
+- **Ollama**: Local inference with tool calling detection
+
+### Error Handling
+
+Comprehensive error types with recovery suggestions:
+
+```swift
+public enum TachikomaError: Error, LocalizedError {
+    case modelNotFound(String)
+    case authenticationFailed
+    case rateLimited
+    case insufficientQuota
+    case contextLengthExceeded
+    // ... more cases with detailed descriptions
+    
+    public var isRetryable: Bool { /* ... */ }
+    public var recoverySuggestion: String? { /* ... */ }
+}
+```
+
+## Advanced Usage
+
+### Custom Providers
+
+```swift
+class CustomAIModel: ModelInterface {
+    var maskedApiKey: String { "custom-***" }
+    
+    func getResponse(request: ModelRequest) async throws -> ModelResponse {
+        // Custom implementation
+    }
+    
+    func getStreamedResponse(request: ModelRequest) async throws -> AsyncThrowingStream<StreamEvent, Error> {
+        // Custom streaming implementation
+    }
+}
+
+// Register the custom provider
+await Tachikoma.shared.registerModel(name: "custom-ai") {
+    CustomAIModel()
+}
+```
+
+### Batch Processing
+
+```swift
+let requests = [
+    ModelRequest(messages: [.user(content: .text("Question 1"))]),
+    ModelRequest(messages: [.user(content: .text("Question 2"))]),
+    ModelRequest(messages: [.user(content: .text("Question 3"))])
+]
+
+let responses = try await withThrowingTaskGroup(of: ModelResponse.self) { group in
+    for request in requests {
+        group.addTask {
+            try await model.getResponse(request: request)
+        }
+    }
+    
+    var results: [ModelResponse] = []
+    for try await response in group {
+        results.append(response)
+    }
+    return results
+}
+```
+
+### Tool Context Management
+
+```swift
+struct WeatherContext {
+    let apiKey: String
+    let units: String
+}
+
+let weatherTool = Tool<WeatherContext> { input, context in
+    let location = input.parameters["location"] as? String ?? ""
+    // Use context.apiKey and context.units for API call
+    return ToolOutput(content: "Weather data for \(location)")
+}
+
+// Use with context
+let context = WeatherContext(apiKey: "weather-key", units: "metric")
+let toolDefinition = weatherTool.toToolDefinition()
+```
+
+## Testing
+
+Tachikoma includes comprehensive test coverage:
+
+```bash
+# Run tests
+swift test
+
+# Run with verbose output
+swift test --verbose
+
+# Run specific test suites
+swift test --filter "ModelProviderTests"
+```
+
+### Mock Providers
+
+```swift
+class MockModel: ModelInterface {
+    var maskedApiKey: String = "mock-***"
+    var responses: [ModelResponse] = []
+    
+    func getResponse(request: ModelRequest) async throws -> ModelResponse {
+        return responses.removeFirst()
+    }
+}
+
+// Use in tests
+let mockModel = MockModel()
+mockModel.responses = [/* test responses */]
+await Tachikoma.shared.registerModel(name: "mock") { mockModel }
+```
+
+## Performance Considerations
+
+### Caching
+- Model instances are cached by default
+- Clear cache with `ModelProvider.shared.clearCache()`
+- Disable caching for specific models if needed
+
+### Memory Management
+- Streaming responses use `AsyncThrowingStream` for memory efficiency
+- Large responses are processed incrementally
+- Tool contexts should be lightweight for optimal performance
+
+### Concurrency
+- All APIs are actor-safe and Swift 6 compliant
+- Use `TaskGroup` for parallel processing
+- Respect rate limits with proper error handling
+
+## Migration Guide
+
+### From PeekabooCore
+
+If migrating from PeekabooCore's AI system:
+
+1. Replace `PeekabooError` with `TachikomaError`
+2. Update import statements
+3. Use `Tachikoma.shared.getModel()` instead of direct model creation
+4. Update streaming event handling for new event types
+
+### Version History
+
+- **v1.0.0**: Initial release with Swift 6 support
+- Core providers: OpenAI, Anthropic, Grok, Ollama
+- Complete tool calling and streaming support
+
+## Contributing
+
+1. Fork the repository
+2. Create a feature branch
+3. Ensure Swift 6 strict mode compliance
+4. Add comprehensive tests
+5. Update documentation
+6. Submit a pull request
+
+## License
+
+Tachikoma is available under the MIT License. See LICENSE for details.
+
+## Support
+
+- **Issues**: [GitHub Issues](https://github.com/steipete/Tachikoma/issues)
+- **Discussions**: [GitHub Discussions](https://github.com/steipete/Tachikoma/discussions)
+- **Documentation**: [API Reference](https://steipete.github.io/Tachikoma/)
+
+---
+
+Built with ❤️ for the Swift AI community.
diff --git a/Sources/Core/MessageTypes.swift b/Sources/Core/MessageTypes.swift
new file mode 100644
index 0000000..f364eb6
--- /dev/null
+++ b/Sources/Core/MessageTypes.swift
@@ -0,0 +1,366 @@
+import Foundation
+
+// MARK: - Unified Message Type
+
+/// Unified message enum that provides type-safe message handling
+public enum Message: Codable, Sendable {
+    case system(id: String? = nil, content: String)
+    case user(id: String? = nil, content: MessageContent)
+    case assistant(id: String? = nil, content: [AssistantContent], status: MessageStatus = .completed)
+    case tool(id: String? = nil, toolCallId: String, content: String)
+    case reasoning(id: String? = nil, content: String)
+
+    // MARK: - Properties
+
+    /// Get the message type
+    public var type: MessageType {
+        switch self {
+        case .system: .system
+        case .user: .user
+        case .assistant: .assistant
+        case .tool: .tool
+        case .reasoning: .reasoning
+        }
+    }
+
+    /// Get the message ID
+    public var id: String? {
+        switch self {
+        case let .system(id, _), let .user(id, _), let .assistant(id, _, _),
+             let .tool(id, _, _), let .reasoning(id, _):
+            id
+        }
+    }
+
+    // MARK: - Codable Implementation
+
+    private enum CodingKeys: String, CodingKey {
+        case type, id, content, status, toolCallId
+    }
+
+    public enum MessageType: String, Codable {
+        case system, user, assistant, tool, reasoning
+    }
+
+    public init(from decoder: any Decoder) throws {
+        let container = try decoder.container(keyedBy: CodingKeys.self)
+        let type = try container.decode(MessageType.self, forKey: .type)
+        let id = try container.decodeIfPresent(String.self, forKey: .id)
+
+        switch type {
+        case .system:
+            let content = try container.decode(String.self, forKey: .content)
+            self = .system(id: id, content: content)
+
+        case .user:
+            let content = try container.decode(MessageContent.self, forKey: .content)
+            self = .user(id: id, content: content)
+
+        case .assistant:
+            let content = try container.decode([AssistantContent].self, forKey: .content)
+            let status = try container.decodeIfPresent(MessageStatus.self, forKey: .status) ?? .completed
+            self = .assistant(id: id, content: content, status: status)
+
+        case .tool:
+            let toolCallId = try container.decode(String.self, forKey: .toolCallId)
+            let content = try container.decode(String.self, forKey: .content)
+            self = .tool(id: id, toolCallId: toolCallId, content: content)
+
+        case .reasoning:
+            let content = try container.decode(String.self, forKey: .content)
+            self = .reasoning(id: id, content: content)
+        }
+    }
+
+    public func encode(to encoder: any Encoder) throws {
+        var container = encoder.container(keyedBy: CodingKeys.self)
+        try container.encode(self.type, forKey: .type)
+
+        switch self {
+        case let .system(id, content):
+            try container.encodeIfPresent(id, forKey: .id)
+            try container.encode(content, forKey: .content)
+
+        case let .user(id, content):
+            try container.encodeIfPresent(id, forKey: .id)
+            try container.encode(content, forKey: .content)
+
+        case let .assistant(id, content, status):
+            try container.encodeIfPresent(id, forKey: .id)
+            try container.encode(content, forKey: .content)
+            try container.encode(status, forKey: .status)
+
+        case let .tool(id, toolCallId, content):
+            try container.encodeIfPresent(id, forKey: .id)
+            try container.encode(toolCallId, forKey: .toolCallId)
+            try container.encode(content, forKey: .content)
+
+        case let .reasoning(id, content):
+            try container.encodeIfPresent(id, forKey: .id)
+            try container.encode(content, forKey: .content)
+        }
+    }
+}
+
+// MARK: - Content Types
+
+/// User message content variants
+public enum MessageContent: Codable, Sendable {
+    case text(String)
+    case image(ImageContent)
+    case file(FileContent)
+    case audio(AudioContent)
+    case multimodal([MessageContentPart])
+
+    // Custom coding for enum
+    enum CodingKeys: String, CodingKey {
+        case type, value
+    }
+
+    enum ContentType: String, Codable {
+        case text, image, file, audio, multimodal
+    }
+
+    public init(from decoder: any Decoder) throws {
+        let container = try decoder.container(keyedBy: CodingKeys.self)
+        let type = try container.decode(ContentType.self, forKey: .type)
+
+        switch type {
+        case .text:
+            let value = try container.decode(String.self, forKey: .value)
+            self = .text(value)
+        case .image:
+            let value = try container.decode(ImageContent.self, forKey: .value)
+            self = .image(value)
+        case .file:
+            let value = try container.decode(FileContent.self, forKey: .value)
+            self = .file(value)
+        case .audio:
+            let value = try container.decode(AudioContent.self, forKey: .value)
+            self = .audio(value)
+        case .multimodal:
+            let value = try container.decode([MessageContentPart].self, forKey: .value)
+            self = .multimodal(value)
+        }
+    }
+
+    public func encode(to encoder: any Encoder) throws {
+        var container = encoder.container(keyedBy: CodingKeys.self)
+
+        switch self {
+        case let .text(value):
+            try container.encode(ContentType.text, forKey: .type)
+            try container.encode(value, forKey: .value)
+        case let .image(value):
+            try container.encode(ContentType.image, forKey: .type)
+            try container.encode(value, forKey: .value)
+        case let .file(value):
+            try container.encode(ContentType.file, forKey: .type)
+            try container.encode(value, forKey: .value)
+        case let .audio(value):
+            try container.encode(ContentType.audio, forKey: .type)
+            try container.encode(value, forKey: .value)
+        case let .multimodal(value):
+            try container.encode(ContentType.multimodal, forKey: .type)
+            try container.encode(value, forKey: .value)
+        }
+    }
+}
+
+/// Image content for messages
+public struct ImageContent: Codable, Sendable {
+    public let url: String?
+    public let base64: String?
+    public let detail: ImageDetail?
+
+    public enum ImageDetail: String, Codable, Sendable {
+        case auto, low, high
+    }
+
+    public init(url: String? = nil, base64: String? = nil, detail: ImageDetail? = nil) {
+        self.url = url
+        self.base64 = base64
+        self.detail = detail
+    }
+}
+
+/// File content for messages
+public struct FileContent: Codable, Sendable {
+    public let id: String?
+    public let url: String?
+    public let name: String?
+    public let filename: String?
+    public let content: String?
+    public let mimeType: String?
+
+    public init(
+        id: String? = nil,
+        url: String? = nil,
+        name: String? = nil,
+        filename: String? = nil,
+        content: String? = nil,
+        mimeType: String? = nil)
+    {
+        self.id = id
+        self.url = url
+        self.name = name
+        self.filename = filename
+        self.content = content
+        self.mimeType = mimeType
+    }
+    
+    // Convenience constructor for test compatibility
+    public init(filename: String, content: String, mimeType: String) {
+        self.init(name: filename, filename: filename, content: content, mimeType: mimeType)
+    }
+}
+
+/// Audio content for messages
+public struct AudioContent: Codable, Sendable {
+    public let url: String?
+    public let base64: String?
+    public let transcript: String?
+    public let duration: TimeInterval?
+    public let mimeType: String?
+
+    public init(
+        url: String? = nil,
+        base64: String? = nil,
+        transcript: String? = nil,
+        duration: TimeInterval? = nil,
+        mimeType: String? = nil)
+    {
+        self.url = url
+        self.base64 = base64
+        self.transcript = transcript
+        self.duration = duration
+        self.mimeType = mimeType
+    }
+}
+
+/// Multimodal content part
+public struct MessageContentPart: Codable, Sendable {
+    public let type: String
+    public let text: String?
+    public let imageUrl: ImageContent?
+
+    public init(type: String, text: String? = nil, imageUrl: ImageContent? = nil) {
+        self.type = type
+        self.text = text
+        self.imageUrl = imageUrl
+    }
+}
+
+/// Assistant response content variants
+public enum AssistantContent: Codable, Sendable {
+    case outputText(String)
+    case refusal(String)
+    case toolCall(ToolCallItem)
+
+    // Custom coding
+    enum CodingKeys: String, CodingKey {
+        case type, value
+    }
+
+    enum ContentType: String, Codable {
+        case text, refusal, toolCall
+    }
+
+    public init(from decoder: any Decoder) throws {
+        let container = try decoder.container(keyedBy: CodingKeys.self)
+        let type = try container.decode(ContentType.self, forKey: .type)
+
+        switch type {
+        case .text:
+            let value = try container.decode(String.self, forKey: .value)
+            self = .outputText(value)
+        case .refusal:
+            let value = try container.decode(String.self, forKey: .value)
+            self = .refusal(value)
+        case .toolCall:
+            let value = try container.decode(ToolCallItem.self, forKey: .value)
+            self = .toolCall(value)
+        }
+    }
+
+    public func encode(to encoder: any Encoder) throws {
+        var container = encoder.container(keyedBy: CodingKeys.self)
+
+        switch self {
+        case let .outputText(value):
+            try container.encode(ContentType.text, forKey: .type)
+            try container.encode(value, forKey: .value)
+        case let .refusal(value):
+            try container.encode(ContentType.refusal, forKey: .type)
+            try container.encode(value, forKey: .value)
+        case let .toolCall(value):
+            try container.encode(ContentType.toolCall, forKey: .type)
+            try container.encode(value, forKey: .value)
+        }
+    }
+}
+
+// MARK: - Tool Call Types
+
+/// Tool call item representing a function invocation
+public struct ToolCallItem: Codable, Sendable {
+    public let id: String
+    public let type: ToolCallType
+    public let function: FunctionCall
+    public let status: ToolCallStatus?
+
+    public init(id: String, type: ToolCallType = .function, function: FunctionCall, status: ToolCallStatus? = nil) {
+        self.id = id
+        self.type = type
+        self.function = function
+        self.status = status
+    }
+}
+
+/// Types of tool calls
+public enum ToolCallType: String, Codable, Sendable {
+    case function
+    case hosted = "hosted_tool"
+    case computer
+}
+
+/// Function call details
+public struct FunctionCall: Codable, Sendable {
+    public let name: String
+    public let arguments: String
+
+    public init(name: String, arguments: String) {
+        self.name = name
+        self.arguments = arguments
+    }
+}
+
+/// Tool call execution status
+public enum ToolCallStatus: String, Codable, Sendable {
+    case inProgress = "in_progress"
+    case completed
+    case failed
+}
+
+/// Message processing status
+public enum MessageStatus: String, Codable, Sendable {
+    case inProgress = "in_progress"
+    case completed
+    case incomplete
+}
+
+// MARK: - Helper Extensions
+
+extension AssistantContent {
+    /// Extract text content if available
+    public var textContent: String? {
+        switch self {
+        case let .outputText(text):
+            text
+        case let .refusal(text):
+            text
+        case .toolCall:
+            nil
+        }
+    }
+}
\ No newline at end of file
diff --git a/Sources/Core/ModelInterface.swift b/Sources/Core/ModelInterface.swift
new file mode 100644
index 0000000..c1eb5ca
--- /dev/null
+++ b/Sources/Core/ModelInterface.swift
@@ -0,0 +1,424 @@
+import Foundation
+
+// MARK: - Model Interface Protocol
+
+/// Protocol defining the interface for AI model providers
+@available(macOS 14.0, iOS 17.0, watchOS 10.0, tvOS 17.0, *)
+public protocol ModelInterface: Sendable {
+    /// Get a non-streaming response from the model
+    /// - Parameter request: The model request containing messages, tools, and settings
+    /// - Returns: The model response
+    func getResponse(request: ModelRequest) async throws -> ModelResponse
+
+    /// Get a streaming response from the model
+    /// - Parameter request: The model request containing messages, tools, and settings
+    /// - Returns: An async stream of events
+    func getStreamedResponse(request: ModelRequest) async throws -> AsyncThrowingStream<StreamEvent, any Error>
+
+    /// Get a masked version of the API key for debugging
+    /// Returns the first 6 and last 2 characters of the API key
+    /// - Returns: Masked API key string (e.g., "sk-ant...AA")
+    var maskedApiKey: String { get }
+}
+
+// MARK: - Model Request & Response Types
+
+/// Request to send to a model
+public struct ModelRequest: Codable, Sendable {
+    /// The messages to send to the model
+    public let messages: [Message]
+
+    /// Available tools for the model to use
+    public let tools: [ToolDefinition]?
+
+    /// Model-specific settings
+    public let settings: ModelSettings
+
+    /// System instructions (some models support this separately from messages)
+    public let systemInstructions: String?
+
+    public init(
+        messages: [Message],
+        tools: [ToolDefinition]? = nil,
+        settings: ModelSettings,
+        systemInstructions: String? = nil)
+    {
+        self.messages = messages
+        self.tools = tools
+        self.settings = settings
+        self.systemInstructions = systemInstructions
+    }
+}
+
+/// Response from a model
+public struct ModelResponse: Codable, Sendable {
+    /// Unique identifier for the response
+    public let id: String
+
+    /// The model that generated the response
+    public let model: String?
+
+    /// Content returned by the model
+    public let content: [AssistantContent]
+
+    /// Token usage statistics
+    public let usage: Usage?
+
+    /// Whether the response was flagged for safety
+    public let flagged: Bool
+
+    /// Reason for flagging if applicable
+    public let flaggedCategories: [String]?
+
+    /// Finish reason
+    public let finishReason: FinishReason?
+
+    public init(
+        id: String,
+        model: String? = nil,
+        content: [AssistantContent],
+        usage: Usage? = nil,
+        flagged: Bool = false,
+        flaggedCategories: [String]? = nil,
+        finishReason: FinishReason? = nil)
+    {
+        self.id = id
+        self.model = model
+        self.content = content
+        self.usage = usage
+        self.flagged = flagged
+        self.flaggedCategories = flaggedCategories
+        self.finishReason = finishReason
+    }
+}
+
+// MARK: - Model Settings
+
+/// Settings for model behavior
+public struct ModelSettings: Codable, Sendable {
+    /// The model name/identifier
+    public let modelName: String
+
+    /// Temperature for randomness (0.0 to 2.0)
+    public let temperature: Double?
+
+    /// Top-p sampling parameter
+    public let topP: Double?
+
+    /// Maximum tokens to generate
+    public let maxTokens: Int?
+
+    /// Frequency penalty (-2.0 to 2.0)
+    public let frequencyPenalty: Double?
+
+    /// Presence penalty (-2.0 to 2.0)
+    public let presencePenalty: Double?
+
+    /// Stop sequences
+    public let stopSequences: [String]?
+
+    /// Tool choice setting
+    public let toolChoice: ToolChoice?
+
+    /// Whether to use parallel tool calls
+    public let parallelToolCalls: Bool?
+
+    /// Response format
+    public let responseFormat: ResponseFormat?
+
+    /// Seed for deterministic generation
+    public let seed: Int?
+
+    /// User identifier for tracking
+    public let user: String?
+
+    /// Additional provider-specific parameters
+    public let additionalParameters: ModelParameters?
+
+    public init(
+        modelName: String,
+        temperature: Double? = nil,
+        topP: Double? = nil,
+        maxTokens: Int? = nil,
+        frequencyPenalty: Double? = nil,
+        presencePenalty: Double? = nil,
+        stopSequences: [String]? = nil,
+        toolChoice: ToolChoice? = nil,
+        parallelToolCalls: Bool? = nil,
+        responseFormat: ResponseFormat? = nil,
+        seed: Int? = nil,
+        user: String? = nil,
+        additionalParameters: ModelParameters? = nil)
+    {
+        self.modelName = modelName
+        self.temperature = temperature
+        self.topP = topP
+        self.maxTokens = maxTokens
+        self.frequencyPenalty = frequencyPenalty
+        self.presencePenalty = presencePenalty
+        self.stopSequences = stopSequences
+        self.toolChoice = toolChoice
+        self.parallelToolCalls = parallelToolCalls
+        self.responseFormat = responseFormat
+        self.seed = seed
+        self.user = user
+        self.additionalParameters = additionalParameters
+    }
+
+    /// Default settings for Claude Opus 4
+    public static var `default`: ModelSettings {
+        ModelSettings(modelName: "claude-opus-4-20250514")
+    }
+    
+    // MARK: - Convenience Constructors
+    
+    /// Create settings with just specified parameters, using Claude Opus 4 as default model
+    public init(
+        temperature: Double? = nil,
+        topP: Double? = nil,
+        maxTokens: Int? = nil,
+        frequencyPenalty: Double? = nil,
+        presencePenalty: Double? = nil,
+        stopSequences: [String]? = nil,
+        toolChoice: ToolChoice? = nil,
+        parallelToolCalls: Bool? = nil,
+        responseFormat: ResponseFormat? = nil,
+        seed: Int? = nil,
+        user: String? = nil,
+        additionalParameters: ModelParameters? = nil)
+    {
+        self.init(
+            modelName: "claude-opus-4-20250514",
+            temperature: temperature,
+            topP: topP,
+            maxTokens: maxTokens,
+            frequencyPenalty: frequencyPenalty,
+            presencePenalty: presencePenalty,
+            stopSequences: stopSequences,
+            toolChoice: toolChoice,
+            parallelToolCalls: parallelToolCalls,
+            responseFormat: responseFormat,
+            seed: seed,
+            user: user,
+            additionalParameters: additionalParameters
+        )
+    }
+    
+    /// Convenience constructors for specific API types and reasoning parameters
+    public init(
+        apiType: String,
+        modelName: String = "claude-opus-4-20250514")
+    {
+        let params = ModelParameters([
+            "apiType": ModelParameters.Value.string(apiType)
+        ])
+        self.init(modelName: modelName, additionalParameters: params)
+    }
+    
+    public init(
+        reasoningEffort: String,
+        reasoning: [String: String]? = nil,
+        temperature: Double? = nil,
+        modelName: String = "o3")
+    {
+        var params: [String: ModelParameters.Value] = [
+            "reasoningEffort": ModelParameters.Value.string(reasoningEffort)
+        ]
+        if let reasoning = reasoning {
+            let reasoningValue = reasoning.mapValues { ModelParameters.Value.string($0) }
+            params["reasoning"] = ModelParameters.Value.dictionary(reasoningValue)
+        }
+        let modelParams = ModelParameters(params)
+        self.init(
+            modelName: modelName,
+            temperature: temperature,
+            additionalParameters: modelParams
+        )
+    }
+
+    // Custom coding for additionalParameters
+    enum CodingKeys: String, CodingKey {
+        case modelName, temperature, topP, maxTokens
+        case frequencyPenalty, presencePenalty, stopSequences
+        case toolChoice, parallelToolCalls, responseFormat
+        case seed, user, additionalParameters
+    }
+
+    public init(from decoder: any Decoder) throws {
+        let container = try decoder.container(keyedBy: CodingKeys.self)
+
+        self.modelName = try container.decode(String.self, forKey: .modelName)
+        self.temperature = try container.decodeIfPresent(Double.self, forKey: .temperature)
+        self.topP = try container.decodeIfPresent(Double.self, forKey: .topP)
+        self.maxTokens = try container.decodeIfPresent(Int.self, forKey: .maxTokens)
+        self.frequencyPenalty = try container.decodeIfPresent(Double.self, forKey: .frequencyPenalty)
+        self.presencePenalty = try container.decodeIfPresent(Double.self, forKey: .presencePenalty)
+        self.stopSequences = try container.decodeIfPresent([String].self, forKey: .stopSequences)
+        self.toolChoice = try container.decodeIfPresent(ToolChoice.self, forKey: .toolChoice)
+        self.parallelToolCalls = try container.decodeIfPresent(Bool.self, forKey: .parallelToolCalls)
+        self.responseFormat = try container.decodeIfPresent(ResponseFormat.self, forKey: .responseFormat)
+        self.seed = try container.decodeIfPresent(Int.self, forKey: .seed)
+        self.user = try container.decodeIfPresent(String.self, forKey: .user)
+
+        // Decode additional parameters
+        self.additionalParameters = try container.decodeIfPresent(ModelParameters.self, forKey: .additionalParameters)
+    }
+
+    public func encode(to encoder: any Encoder) throws {
+        var container = encoder.container(keyedBy: CodingKeys.self)
+
+        try container.encode(self.modelName, forKey: .modelName)
+        try container.encodeIfPresent(self.temperature, forKey: .temperature)
+        try container.encodeIfPresent(self.topP, forKey: .topP)
+        try container.encodeIfPresent(self.maxTokens, forKey: .maxTokens)
+        try container.encodeIfPresent(self.frequencyPenalty, forKey: .frequencyPenalty)
+        try container.encodeIfPresent(self.presencePenalty, forKey: .presencePenalty)
+        try container.encodeIfPresent(self.stopSequences, forKey: .stopSequences)
+        try container.encodeIfPresent(self.toolChoice, forKey: .toolChoice)
+        try container.encodeIfPresent(self.parallelToolCalls, forKey: .parallelToolCalls)
+        try container.encodeIfPresent(self.responseFormat, forKey: .responseFormat)
+        try container.encodeIfPresent(self.seed, forKey: .seed)
+        try container.encodeIfPresent(self.user, forKey: .user)
+
+        // Encode additional parameters
+        try container.encodeIfPresent(self.additionalParameters, forKey: .additionalParameters)
+    }
+}
+
+// MARK: - Tool Choice
+
+/// Tool choice setting for models
+public enum ToolChoice: Codable, Sendable, Equatable {
+    case auto
+    case none
+    case required
+    case specific(toolName: String)
+
+    // Custom coding
+    enum CodingKeys: String, CodingKey {
+        case type, toolName
+    }
+
+    enum ChoiceType: String, Codable {
+        case auto, none, required, specific
+    }
+
+    public init(from decoder: any Decoder) throws {
+        let container = try decoder.container(keyedBy: CodingKeys.self)
+        let type = try container.decode(ChoiceType.self, forKey: .type)
+
+        switch type {
+        case .auto:
+            self = .auto
+        case .none:
+            self = .none
+        case .required:
+            self = .required
+        case .specific:
+            let toolName = try container.decode(String.self, forKey: .toolName)
+            self = .specific(toolName: toolName)
+        }
+    }
+
+    public func encode(to encoder: any Encoder) throws {
+        var container = encoder.container(keyedBy: CodingKeys.self)
+
+        switch self {
+        case .auto:
+            try container.encode(ChoiceType.auto, forKey: .type)
+        case .none:
+            try container.encode(ChoiceType.none, forKey: .type)
+        case .required:
+            try container.encode(ChoiceType.required, forKey: .type)
+        case let .specific(toolName):
+            try container.encode(ChoiceType.specific, forKey: .type)
+            try container.encode(toolName, forKey: .toolName)
+        }
+    }
+}
+
+// MARK: - Response Format
+
+/// Response format specification
+public struct ResponseFormat: Codable, Sendable {
+    public let type: ResponseFormatType
+    public let jsonSchema: JSONSchema?
+
+    public init(type: ResponseFormatType, jsonSchema: JSONSchema? = nil) {
+        self.type = type
+        self.jsonSchema = jsonSchema
+    }
+
+    /// Plain text response
+    public static var text: ResponseFormat {
+        ResponseFormat(type: .text)
+    }
+
+    /// JSON object response
+    public static var jsonObject: ResponseFormat {
+        ResponseFormat(type: .jsonObject)
+    }
+}
+
+/// Response format types
+public enum ResponseFormatType: String, Codable, Sendable {
+    case text
+    case jsonObject = "json_object"
+    case jsonSchema = "json_schema"
+}
+
+/// JSON schema specification
+public struct JSONSchema: Codable, Sendable {
+    public let name: String
+    public let strict: Bool
+    private let schemaData: Data // Store as raw JSON data
+
+    // Custom coding for schema
+    enum CodingKeys: String, CodingKey {
+        case name, strict, schema
+    }
+
+    public init(name: String, strict: Bool = true, schema: [String: Any]) throws {
+        self.name = name
+        self.strict = strict
+        self.schemaData = try JSONSerialization.data(withJSONObject: schema)
+    }
+
+    public init(from decoder: any Decoder) throws {
+        let container = try decoder.container(keyedBy: CodingKeys.self)
+        self.name = try container.decode(String.self, forKey: .name)
+        self.strict = try container.decode(Bool.self, forKey: .strict)
+        self.schemaData = try container.decode(Data.self, forKey: .schema)
+    }
+
+    public func encode(to encoder: any Encoder) throws {
+        var container = encoder.container(keyedBy: CodingKeys.self)
+        try container.encode(self.name, forKey: .name)
+        try container.encode(self.strict, forKey: .strict)
+        try container.encode(self.schemaData, forKey: .schema)
+    }
+
+    /// Get the schema as a dictionary
+    public func getSchema() throws -> [String: Any] {
+        guard let dict = try JSONSerialization.jsonObject(with: schemaData) as? [String: Any] else {
+            throw TachikomaError.invalidConfiguration("Invalid JSON schema data")
+        }
+        return dict
+    }
+}
+
+// MARK: - Model Provider Protocol
+
+/// Protocol for model provider factories
+@available(macOS 14.0, iOS 17.0, watchOS 10.0, tvOS 17.0, *)
+public protocol ModelProviderProtocol {
+    /// Get a model by name
+    /// - Parameter modelName: The name of the model to retrieve
+    /// - Returns: A model instance conforming to ModelInterface
+    func getModel(modelName: String) throws -> any ModelInterface
+}
+
+// MARK: - Model Errors
+
+// MARK: - Note
+// ModelError is defined in TachikomaError.swift to avoid duplication
\ No newline at end of file
diff --git a/Sources/Core/ModelParameters.swift b/Sources/Core/ModelParameters.swift
new file mode 100644
index 0000000..d0f9175
--- /dev/null
+++ b/Sources/Core/ModelParameters.swift
@@ -0,0 +1,240 @@
+import Foundation
+
+// MARK: - Model Parameters
+
+/// Type-safe representation of additional model parameters
+@available(macOS 14.0, iOS 17.0, watchOS 10.0, tvOS 17.0, *)
+public struct ModelParameters: Codable, Sendable {
+    private let storage: [String: Value]
+
+    /// Supported parameter value types
+    public enum Value: Codable, Sendable {
+        case string(String)
+        case int(Int)
+        case double(Double)
+        case bool(Bool)
+        case dictionary([String: Value])
+        case array([Value])
+
+        // MARK: - Codable
+
+        public init(from decoder: any Decoder) throws {
+            let container = try decoder.singleValueContainer()
+
+            if let intValue = try? container.decode(Int.self) {
+                self = .int(intValue)
+            } else if let doubleValue = try? container.decode(Double.self) {
+                self = .double(doubleValue)
+            } else if let boolValue = try? container.decode(Bool.self) {
+                self = .bool(boolValue)
+            } else if let stringValue = try? container.decode(String.self) {
+                self = .string(stringValue)
+            } else if let dictValue = try? container.decode([String: Value].self) {
+                self = .dictionary(dictValue)
+            } else if let arrayValue = try? container.decode([Value].self) {
+                self = .array(arrayValue)
+            } else {
+                throw DecodingError.dataCorruptedError(
+                    in: container,
+                    debugDescription: "Unable to decode ModelParameters.Value")
+            }
+        }
+
+        public func encode(to encoder: any Encoder) throws {
+            var container = encoder.singleValueContainer()
+
+            switch self {
+            case let .string(value):
+                try container.encode(value)
+            case let .int(value):
+                try container.encode(value)
+            case let .double(value):
+                try container.encode(value)
+            case let .bool(value):
+                try container.encode(value)
+            case let .dictionary(value):
+                try container.encode(value)
+            case let .array(value):
+                try container.encode(value)
+            }
+        }
+
+        /// Convert to raw value for JSON serialization
+        public var rawValue: Any {
+            switch self {
+            case let .string(value):
+                value
+            case let .int(value):
+                value
+            case let .double(value):
+                value
+            case let .bool(value):
+                value
+            case let .dictionary(dict):
+                dict.mapValues { $0.rawValue }
+            case let .array(array):
+                array.map(\.rawValue)
+            }
+        }
+    }
+
+    // MARK: - Initialization
+
+    public init(_ storage: [String: Value] = [:]) {
+        self.storage = storage
+    }
+
+    /// Initialize from a dictionary of raw values
+    public init(from rawValues: [String: Any]) {
+        var convertedStorage: [String: Value] = [:]
+        for (key, value) in rawValues {
+            if let converted = Self.convertToValue(value) {
+                convertedStorage[key] = converted
+            }
+        }
+        self.storage = convertedStorage
+    }
+
+    /// Convert any value to our Value enum
+    private static func convertToValue(_ value: Any) -> Value? {
+        switch value {
+        case let string as String:
+            return .string(string)
+        case let int as Int:
+            return .int(int)
+        case let double as Double:
+            return .double(double)
+        case let bool as Bool:
+            return .bool(bool)
+        case let dict as [String: Any]:
+            var converted: [String: Value] = [:]
+            for (k, v) in dict {
+                if let convertedValue = convertToValue(v) {
+                    converted[k] = convertedValue
+                }
+            }
+            return .dictionary(converted)
+        case let array as [Any]:
+            let converted = array.compactMap { self.convertToValue($0) }
+            return .array(converted)
+        default:
+            return nil
+        }
+    }
+
+    // MARK: - Access Methods
+
+    public subscript(key: String) -> Value? { self.storage[key] }
+
+    public func string(_ key: String) -> String? {
+        guard case let .string(value) = storage[key] else { return nil }
+        return value
+    }
+
+    public func int(_ key: String) -> Int? {
+        guard case let .int(value) = storage[key] else { return nil }
+        return value
+    }
+
+    public func double(_ key: String) -> Double? {
+        guard case let .double(value) = storage[key] else { return nil }
+        return value
+    }
+
+    public func bool(_ key: String) -> Bool? {
+        guard case let .bool(value) = storage[key] else { return nil }
+        return value
+    }
+
+    /// Get the raw dictionary for JSON serialization
+    public var rawDictionary: [String: Any] {
+        self.storage.mapValues { $0.rawValue }
+    }
+
+    /// Check if empty
+    public var isEmpty: Bool {
+        self.storage.isEmpty
+    }
+
+    // MARK: - Mutating Methods
+    
+    /// Set a parameter value
+    public mutating func set(_ key: String, value: Any) {
+        if let converted = Self.convertToValue(value) {
+            var newStorage = self.storage
+            newStorage[key] = converted
+            self = ModelParameters(newStorage)
+        }
+    }
+    
+    /// Get a parameter value
+    public func get(_ key: String) -> Any? {
+        return self.storage[key]?.rawValue
+    }
+
+    // MARK: - Builder Methods
+
+    public func with(_ key: String, value: String) -> ModelParameters {
+        var newStorage = self.storage
+        newStorage[key] = .string(value)
+        return ModelParameters(newStorage)
+    }
+
+    public func with(_ key: String, value: Int) -> ModelParameters {
+        var newStorage = self.storage
+        newStorage[key] = .int(value)
+        return ModelParameters(newStorage)
+    }
+
+    public func with(_ key: String, value: Double) -> ModelParameters {
+        var newStorage = self.storage
+        newStorage[key] = .double(value)
+        return ModelParameters(newStorage)
+    }
+
+    public func with(_ key: String, value: Bool) -> ModelParameters {
+        var newStorage = self.storage
+        newStorage[key] = .bool(value)
+        return ModelParameters(newStorage)
+    }
+
+    public func with(_ key: String, value: [String: Any]) -> ModelParameters {
+        guard let converted = Self.convertToValue(value) else { return self }
+        var newStorage = self.storage
+        newStorage[key] = converted
+        return ModelParameters(newStorage)
+    }
+
+    // MARK: - Codable
+
+    public init(from decoder: any Decoder) throws {
+        let container = try decoder.singleValueContainer()
+        self.storage = try container.decode([String: Value].self)
+    }
+
+    public func encode(to encoder: any Encoder) throws {
+        var container = encoder.singleValueContainer()
+        try container.encode(self.storage)
+    }
+}
+
+// MARK: - Convenience Builders
+
+@available(macOS 14.0, iOS 17.0, watchOS 10.0, tvOS 17.0, *)
+extension ModelParameters {
+    /// Create parameters for OpenAI o3/o4 models
+    public static func o3Parameters(
+        reasoningEffort: String = "medium",
+        maxCompletionTokens: Int = 32768) -> ModelParameters
+    {
+        ModelParameters()
+            .with("reasoning_effort", value: reasoningEffort)
+            .with("max_completion_tokens", value: maxCompletionTokens)
+            .with("reasoning", value: ["summary": "detailed"])
+    }
+
+    /// Create parameters with API type
+    public static func withAPIType(_ apiType: String) -> ModelParameters {
+        ModelParameters().with("apiType", value: apiType)
+    }
+}
\ No newline at end of file
diff --git a/Sources/Core/ModelProvider.swift b/Sources/Core/ModelProvider.swift
new file mode 100644
index 0000000..487ee4e
--- /dev/null
+++ b/Sources/Core/ModelProvider.swift
@@ -0,0 +1,650 @@
+import Foundation
+
+// MARK: - Model Provider
+
+/// Singleton provider for managing model instances in Tachikoma
+@available(macOS 14.0, iOS 17.0, watchOS 10.0, tvOS 17.0, *)
+public actor ModelProvider {
+    /// Shared instance
+    public static let shared = ModelProvider()
+
+    /// Registered model factories
+    private var modelFactories: [String: @Sendable () throws -> any ModelInterface] = [:]
+
+    /// Model instance cache
+    private var modelCache: [String: any ModelInterface] = [:]
+
+    private init() {
+        // Register default models when initialized
+        Task {
+            await self.registerDefaultModels()
+        }
+    }
+
+    // MARK: - Public Methods
+
+    /// Register a model factory
+    /// - Parameters:
+    ///   - name: The model name
+    ///   - factory: Factory closure that creates the model
+    public func register(
+        modelName: String,
+        factory: @escaping @Sendable () throws -> any ModelInterface)
+    {
+        self.modelFactories[modelName] = factory
+        // Clear cache for this model
+        self.modelCache.removeValue(forKey: modelName)
+    }
+
+    /// Get a model by name
+    /// - Parameter modelName: The name of the model
+    /// - Returns: A model instance
+    /// - Throws: TachikomaError if model not found
+    public func getModel(modelName: String) throws -> any ModelInterface {
+        // Check cache first
+        if let cached = modelCache[modelName] {
+            return cached
+        }
+
+        // Check for custom provider first (format: provider-id/model-path)
+        if let slashIndex = modelName.firstIndex(of: "/") {
+            let providerId = String(modelName[..<slashIndex])
+            let modelPath = String(modelName[modelName.index(after: slashIndex)...])
+            
+            if let model = try? createCustomProviderModel(providerId: providerId, modelPath: modelPath) {
+                self.modelCache[modelName] = model
+                return model
+            }
+        }
+
+        // Try exact match for built-in models
+        if let factory = modelFactories[modelName] {
+            let model = try factory()
+            self.modelCache[modelName] = model
+            return model
+        }
+
+        // Try lenient matching for shortened names
+        if let resolvedName = resolveLenientModelName(modelName),
+           let factory = modelFactories[resolvedName]
+        {
+            let model = try factory()
+            // Cache with both original and resolved names
+            self.modelCache[modelName] = model
+            self.modelCache[resolvedName] = model
+            return model
+        }
+
+        // Model not found in registry
+        throw TachikomaError.modelNotFound(modelName)
+    }
+
+    /// List all registered models
+    public func listModels() -> [String] {
+        Array(self.modelFactories.keys).sorted()
+    }
+
+    /// Clear model cache
+    public func clearCache() {
+        self.modelCache.removeAll()
+    }
+
+    /// Clear all model registrations and cache (useful for testing)
+    public func clearAll() async {
+        self.modelCache.removeAll()
+        self.modelFactories.removeAll()
+        // Re-register default models
+        await self.registerDefaultModels()
+    }
+
+    /// Unregister a model
+    public func unregister(modelName: String) {
+        self.modelFactories.removeValue(forKey: modelName)
+        self.modelCache.removeValue(forKey: modelName)
+    }
+
+    // MARK: - Private Methods
+
+    private func registerDefaultModels() async {
+        // Register OpenAI models
+        self.registerOpenAIModels()
+
+        // Register Anthropic models
+        self.registerAnthropicModels()
+
+        // Register Grok models
+        self.registerGrokModels()
+
+        // Register Ollama models
+        self.registerOllamaModels()
+    }
+
+    /// Resolve lenient model names to their full versions
+    private func resolveLenientModelName(_ modelName: String) -> String? {
+        let lowercased = modelName.lowercased()
+
+        // Claude model shortcuts
+        if lowercased == "claude-4-opus" || lowercased == "claude-opus-4" || lowercased == "claude-opus" {
+            return "claude-opus-4-20250514"
+        }
+        if lowercased == "claude-4-sonnet" || lowercased == "claude-sonnet-4" || lowercased == "claude-sonnet" {
+            return "claude-sonnet-4-20250514"
+        }
+        if lowercased == "claude-3.7-sonnet" || lowercased == "claude-3-7-sonnet" || lowercased == "claude-sonnet-3.7" {
+            return "claude-3-7-sonnet"
+        }
+        if lowercased == "claude-3.5-sonnet" || lowercased == "claude-3-5-sonnet" || lowercased == "claude-sonnet-3.5" {
+            return "claude-3-5-sonnet"
+        }
+        if lowercased == "claude-3.5-haiku" || lowercased == "claude-3-5-haiku" || lowercased == "claude-haiku-3.5" {
+            return "claude-3-5-haiku"
+        }
+        if lowercased == "claude-3.5-opus" || lowercased == "claude-3-5-opus" || lowercased == "claude-opus-3.5" {
+            return "claude-3-5-opus"
+        }
+        if lowercased == "claude" {
+            return "claude-opus-4-20250514" // Default to Claude Opus 4
+        }
+
+        // OpenAI model shortcuts
+        if lowercased == "gpt4" || lowercased == "gpt-4" {
+            return "gpt-4.1"
+        }
+        if lowercased == "gpt4-mini" || lowercased == "gpt-4-mini" {
+            return "gpt-4.1-mini"
+        }
+        if lowercased == "gpt" {
+            return "gpt-4.1" // Default to latest GPT
+        }
+
+        // Grok model shortcuts
+        if lowercased == "grok" || lowercased == "grok4" || lowercased == "grok-4" {
+            return "grok-4-0709"
+        }
+        if lowercased == "grok3" || lowercased == "grok-3" {
+            return "grok-3"
+        }
+        if lowercased == "grok2" || lowercased == "grok-2" {
+            return "grok-2-vision-1212"
+        }
+
+        // Ollama model shortcuts
+        if lowercased == "ollama" || lowercased == "llama" {
+            return "llama3.3" // Default to llama3.3 - best for agent tasks with tool support
+        }
+        if lowercased == "llama3" || lowercased == "llama-3" {
+            return "llama3.3" // Default to latest llama 3.x
+        }
+
+        // Check if it's a partial match for any registered model
+        let registeredModels = Array(modelFactories.keys)
+        for model in registeredModels {
+            if model.lowercased().contains(lowercased) || lowercased.contains(model.lowercased()) {
+                return model
+            }
+        }
+
+        return nil
+    }
+
+    private func registerOpenAIModels() {
+        let models = [
+            // GPT-4o series
+            "gpt-4o",
+            "gpt-4o-mini",
+
+            // GPT-4.1 series
+            "gpt-4.1",
+            "gpt-4.1-mini",
+
+            // o3 series (Responses API only)
+            "o3",
+            "o3-mini",
+            "o3-pro",
+
+            // o4 series (Responses API only)
+            "o4-mini",
+        ]
+
+        for modelName in models {
+            self.register(modelName: modelName) {
+                guard let apiKey = self.getOpenAIAPIKey() else {
+                    throw TachikomaError.authenticationFailed
+                }
+
+                return OpenAIModel(apiKey: apiKey, modelName: modelName)
+            }
+        }
+    }
+
+    nonisolated private func getOpenAIAPIKey() -> String? {
+        // Check environment variable
+        if let apiKey = ProcessInfo.processInfo.environment["OPENAI_API_KEY"] {
+            return apiKey
+        }
+
+        // Check standard configuration directory
+        let configPath = FileManager.default.homeDirectoryForCurrentUser
+            .appendingPathComponent(".tachikoma")
+            .appendingPathComponent("credentials")
+
+        if let credentials = try? String(contentsOf: configPath) {
+            for line in credentials.components(separatedBy: .newlines) {
+                let trimmed = line.trimmingCharacters(in: .whitespaces)
+                if trimmed.hasPrefix("OPENAI_API_KEY=") {
+                    return String(trimmed.dropFirst("OPENAI_API_KEY=".count))
+                }
+            }
+        }
+
+        return nil
+    }
+
+    private func registerAnthropicModels() {
+        // Map of model names to their actual IDs
+        let modelMappings: [String: String] = [
+            // Claude 4 series (Latest - May 2025)
+            "claude-opus-4-20250514": "claude-opus-4-20250514",
+            "claude-opus-4-20250514-thinking": "claude-opus-4-20250514-thinking",
+            "claude-sonnet-4-20250514": "claude-sonnet-4-20250514",
+            "claude-sonnet-4-20250514-thinking": "claude-sonnet-4-20250514-thinking",
+
+            // Claude 3.7 series (February 2025)
+            "claude-3-7-sonnet": "claude-3-7-sonnet",
+
+            // Claude 3.5 series (Still available)
+            "claude-3-5-haiku": "claude-3-5-haiku",
+            "claude-3-5-sonnet": "claude-3-5-sonnet",
+            "claude-3-5-opus": "claude-3-5-opus",
+        ]
+
+        for (alias, actualModelId) in modelMappings {
+            self.register(modelName: alias) {
+                guard let apiKey = self.getAnthropicAPIKey() else {
+                    throw TachikomaError.authenticationFailed
+                }
+
+                return AnthropicModel(apiKey: apiKey, modelName: actualModelId)
+            }
+        }
+    }
+
+    nonisolated private func getAnthropicAPIKey() -> String? {
+        // Check environment variable
+        if let apiKey = ProcessInfo.processInfo.environment["ANTHROPIC_API_KEY"] {
+            return apiKey
+        }
+
+        // Check standard configuration directory
+        let configPath = FileManager.default.homeDirectoryForCurrentUser
+            .appendingPathComponent(".tachikoma")
+            .appendingPathComponent("credentials")
+
+        if let credentials = try? String(contentsOf: configPath) {
+            for line in credentials.components(separatedBy: .newlines) {
+                let trimmed = line.trimmingCharacters(in: .whitespaces)
+                if trimmed.hasPrefix("ANTHROPIC_API_KEY=") {
+                    return String(trimmed.dropFirst("ANTHROPIC_API_KEY=".count))
+                }
+            }
+        }
+
+        return nil
+    }
+
+    private func registerGrokModels() {
+        let models = [
+            // Grok 4 series
+            "grok-4",
+            "grok-4-0709",
+            "grok-4-latest",
+
+            // Grok 3 series
+            "grok-3",
+            "grok-3-mini",
+            "grok-3-fast",
+            "grok-3-mini-fast",
+
+            // Grok 2 series
+            "grok-2-1212",
+            "grok-2-vision-1212",
+            "grok-2-image-1212",
+
+            // Beta models
+            "grok-beta",
+            "grok-vision-beta",
+        ]
+
+        for modelName in models {
+            self.register(modelName: modelName) {
+                guard let apiKey = self.getGrokAPIKey() else {
+                    throw TachikomaError.authenticationFailed
+                }
+
+                return GrokModel(apiKey: apiKey, modelName: modelName)
+            }
+        }
+    }
+
+    nonisolated private func getGrokAPIKey() -> String? {
+        // Check environment variables (both variants)
+        if let apiKey = ProcessInfo.processInfo.environment["X_AI_API_KEY"] {
+            return apiKey
+        }
+        if let apiKey = ProcessInfo.processInfo.environment["XAI_API_KEY"] {
+            return apiKey
+        }
+
+        // Check standard configuration directory
+        let configPath = FileManager.default.homeDirectoryForCurrentUser
+            .appendingPathComponent(".tachikoma")
+            .appendingPathComponent("credentials")
+
+        if let credentials = try? String(contentsOf: configPath) {
+            for line in credentials.components(separatedBy: .newlines) {
+                let trimmed = line.trimmingCharacters(in: .whitespaces)
+                if trimmed.hasPrefix("X_AI_API_KEY=") {
+                    return String(trimmed.dropFirst("X_AI_API_KEY=".count))
+                }
+                if trimmed.hasPrefix("XAI_API_KEY=") {
+                    return String(trimmed.dropFirst("XAI_API_KEY=".count))
+                }
+            }
+        }
+
+        return nil
+    }
+
+    private func registerOllamaModels() {
+        // Common Ollama models
+        let models = [
+            // Language models with tool support (recommended for agent tasks)
+            "llama3.3",
+            "llama3.3:latest",
+            "llama3.2",
+            "llama3.2:latest",
+
+            // Vision models (NOTE: These do NOT support tool calling)
+            "llava:latest",
+            "llava",
+            "bakllava:latest",
+            "bakllava",
+            "llama3.2-vision:11b",
+            "llama3.2-vision:90b",
+            "qwen2.5vl:7b",
+            "qwen2.5vl:32b",
+
+            // Other language models (tool support varies)
+            "llama2",
+            "llama2:latest",
+            "llama4",
+            "llama4:latest",
+            "codellama",
+            "codellama:latest",
+            "mistral",
+            "mistral:latest",
+            "mixtral",
+            "mixtral:latest",
+            "neural-chat",
+            "neural-chat:latest",
+            "gemma",
+            "gemma:latest",
+            "devstral",
+            "devstral:latest",
+            "deepseek-r1:8b",
+            "deepseek-r1:671b",
+        ]
+
+        // Get base URL from environment or default
+        let baseURLString = ProcessInfo.processInfo.environment["TACHIKOMA_OLLAMA_BASE_URL"] ?? "http://localhost:11434"
+        guard let baseURL = URL(string: baseURLString) else { return }
+
+        for modelName in models {
+            self.register(modelName: modelName) {
+                OllamaModel(modelName: modelName, baseURL: baseURL)
+            }
+        }
+    }
+
+    // MARK: - Custom Provider Support
+
+    /// Create a model instance for a custom provider
+    /// - Parameters:
+    ///   - providerId: The custom provider ID
+    ///   - modelPath: The model path within the provider
+    /// - Returns: A model instance
+    /// - Throws: TachikomaError if provider not found or configuration invalid
+    private func createCustomProviderModel(providerId: String, modelPath: String) throws -> any ModelInterface {
+        // For now, return a basic implementation
+        // This can be extended with a configuration system later
+        throw TachikomaError.modelNotFound("Custom providers not yet implemented")
+    }
+}
+
+// MARK: - Model Provider Configuration
+
+/// Configuration for model providers
+@available(macOS 14.0, iOS 17.0, watchOS 10.0, tvOS 17.0, *)
+public enum ProviderConfiguration {
+    /// OpenAI configuration
+    public struct OpenAI: Sendable {
+        public let apiKey: String
+        public let organizationId: String?
+        public let baseURL: URL?
+
+        public init(
+            apiKey: String,
+            organizationId: String? = nil,
+            baseURL: URL? = nil)
+        {
+            self.apiKey = apiKey
+            self.organizationId = organizationId
+            self.baseURL = baseURL
+        }
+    }
+
+    /// Anthropic configuration
+    public struct Anthropic: Sendable {
+        public let apiKey: String
+        public let baseURL: URL?
+
+        public init(
+            apiKey: String,
+            baseURL: URL? = nil)
+        {
+            self.apiKey = apiKey
+            self.baseURL = baseURL
+        }
+    }
+
+    /// Ollama configuration
+    public struct Ollama: Sendable {
+        public let baseURL: URL
+
+        public init(baseURL: URL = URL(string: "http://localhost:11434")!) {
+            self.baseURL = baseURL
+        }
+    }
+
+    /// Grok/xAI configuration
+    public struct Grok: Sendable {
+        public let apiKey: String
+        public let baseURL: URL?
+
+        public init(
+            apiKey: String,
+            baseURL: URL? = nil)
+        {
+            self.apiKey = apiKey
+            self.baseURL = baseURL
+        }
+    }
+}
+
+// MARK: - Model Provider Extensions
+
+@available(macOS 14.0, iOS 17.0, watchOS 10.0, tvOS 17.0, *)
+extension ModelProvider {
+    /// Configure OpenAI models with specific settings
+    public func configureOpenAI(_ config: ProviderConfiguration.OpenAI) {
+        let models = [
+            // GPT-4o series
+            "gpt-4o",
+            "gpt-4o-mini",
+
+            // GPT-4.1 series
+            "gpt-4.1",
+            "gpt-4.1-mini",
+
+            // o3 series (Responses API only)
+            "o3",
+            "o3-mini",
+            "o3-pro",
+
+            // o4 series (Responses API only)
+            "o4-mini",
+        ]
+
+        for modelName in models {
+            self.register(modelName: modelName) {
+                OpenAIModel(
+                    apiKey: config.apiKey,
+                    baseURL: config.baseURL ?? URL(string: "https://api.openai.com/v1")!,
+                    organizationId: config.organizationId,
+                    modelName: modelName)
+            }
+        }
+    }
+
+    /// Configure Anthropic models with specific settings
+    public func configureAnthropic(_ config: ProviderConfiguration.Anthropic) {
+        // Map of model names to their actual IDs
+        let modelMappings: [String: String] = [
+            // Claude 4 series (Latest - May 2025)
+            "claude-opus-4-20250514": "claude-opus-4-20250514",
+            "claude-opus-4-20250514-thinking": "claude-opus-4-20250514-thinking",
+            "claude-sonnet-4-20250514": "claude-sonnet-4-20250514",
+            "claude-sonnet-4-20250514-thinking": "claude-sonnet-4-20250514-thinking",
+
+            // Claude 3.7 series (February 2025)
+            "claude-3-7-sonnet": "claude-3-7-sonnet",
+
+            // Claude 3.5 series (Still available)
+            "claude-3-5-haiku": "claude-3-5-haiku",
+            "claude-3-5-sonnet": "claude-3-5-sonnet",
+            "claude-3-5-opus": "claude-3-5-opus",
+        ]
+
+        for (alias, actualModelId) in modelMappings {
+            self.register(modelName: alias) {
+                AnthropicModel(
+                    apiKey: config.apiKey,
+                    baseURL: config.baseURL ?? URL(string: "https://api.anthropic.com/v1")!,
+                    modelName: actualModelId)
+            }
+        }
+    }
+
+    /// Configure Ollama models with specific settings
+    public func configureOllama(_ config: ProviderConfiguration.Ollama) {
+        let models = [
+            // Vision models
+            "llava:latest",
+            "llava",
+            "bakllava:latest",
+            "bakllava",
+            "llama3.2-vision:11b",
+            "llama3.2-vision:90b",
+            "qwen2.5vl:7b",
+            "qwen2.5vl:32b",
+
+            // Language models
+            "llama2",
+            "llama2:latest",
+            "llama3.2",
+            "llama3.2:latest",
+            "llama3.3",
+            "llama3.3:latest",
+            "llama4",
+            "llama4:latest",
+            "codellama",
+            "codellama:latest",
+            "mistral",
+            "mistral:latest",
+            "mixtral",
+            "mixtral:latest",
+            "neural-chat",
+            "neural-chat:latest",
+            "gemma",
+            "gemma:latest",
+            "devstral",
+            "devstral:latest",
+            "deepseek-r1:8b",
+            "deepseek-r1:671b",
+        ]
+
+        for modelName in models {
+            self.register(modelName: modelName) {
+                OllamaModel(modelName: modelName, baseURL: config.baseURL)
+            }
+        }
+    }
+
+    /// Configure Grok models with specific settings
+    public func configureGrok(_ config: ProviderConfiguration.Grok) {
+        let models = [
+            // Grok 4 series
+            "grok-4",
+            "grok-4-0709",
+            "grok-4-latest",
+
+            // Grok 3 series
+            "grok-3",
+            "grok-3-mini",
+            "grok-3-fast",
+            "grok-3-mini-fast",
+
+            // Grok 2 series
+            "grok-2-1212",
+            "grok-2-vision-1212",
+            "grok-2-image-1212",
+
+            // Beta models
+            "grok-beta",
+            "grok-vision-beta",
+        ]
+
+        for modelName in models {
+            self.register(modelName: modelName) {
+                GrokModel(
+                    apiKey: config.apiKey,
+                    modelName: modelName,
+                    baseURL: config.baseURL ?? URL(string: "https://api.x.ai/v1")!)
+            }
+        }
+    }
+
+    /// Quick setup with API key from environment
+    public func setupFromEnvironment() async throws {
+        if let apiKey = ProcessInfo.processInfo.environment["OPENAI_API_KEY"] {
+            self.configureOpenAI(ProviderConfiguration.OpenAI(apiKey: apiKey))
+        }
+
+        if let apiKey = ProcessInfo.processInfo.environment["ANTHROPIC_API_KEY"] {
+            self.configureAnthropic(ProviderConfiguration.Anthropic(apiKey: apiKey))
+        }
+
+        // Configure Ollama (no API key needed)
+        let ollamaBaseURL = ProcessInfo.processInfo.environment["TACHIKOMA_OLLAMA_BASE_URL"] ?? "http://localhost:11434"
+        if let baseURL = URL(string: ollamaBaseURL) {
+            self.configureOllama(ProviderConfiguration.Ollama(baseURL: baseURL))
+        }
+
+        // Configure Grok with various API key options
+        if let apiKey = ProcessInfo.processInfo.environment["X_AI_API_KEY"] ??
+            ProcessInfo.processInfo.environment["XAI_API_KEY"]
+        {
+            self.configureGrok(ProviderConfiguration.Grok(apiKey: apiKey))
+        }
+    }
+}
\ No newline at end of file
diff --git a/Sources/Core/StreamingTypes.swift b/Sources/Core/StreamingTypes.swift
new file mode 100644
index 0000000..66202f4
--- /dev/null
+++ b/Sources/Core/StreamingTypes.swift
@@ -0,0 +1,381 @@
+import Foundation
+
+// MARK: - Streaming Event Types
+
+/// Base protocol for all streaming events
+@available(macOS 14.0, iOS 17.0, watchOS 10.0, tvOS 17.0, *)
+public protocol StreamingEvent: Codable, Sendable {
+    var type: StreamEventType { get }
+}
+
+/// Types of streaming events
+@available(macOS 14.0, iOS 17.0, watchOS 10.0, tvOS 17.0, *)
+public enum StreamEventType: String, Codable, Sendable {
+    case textDelta = "text_delta"
+    case responseStarted = "response_started"
+    case responseCompleted = "response_completed"
+    case toolCallDelta = "tool_call_delta"
+    case toolCallCompleted = "tool_call_completed"
+    case functionCallArgumentsDelta = "function_call_arguments_delta"
+    case error
+    case unknown
+    case reasoningSummaryDelta = "reasoning_summary_delta"
+    case reasoningSummaryCompleted = "reasoning_summary_completed"
+}
+
+/// Main streaming event enum that encompasses all event types
+@available(macOS 14.0, iOS 17.0, watchOS 10.0, tvOS 17.0, *)
+public enum StreamEvent: Codable, Sendable {
+    case textDelta(StreamTextDelta)
+    case responseStarted(StreamResponseStarted)
+    case responseCompleted(StreamResponseCompleted)
+    case toolCallDelta(StreamToolCallDelta)
+    case toolCallCompleted(StreamToolCallCompleted)
+    case functionCallArgumentsDelta(StreamFunctionCallArgumentsDelta)
+    case error(StreamError)
+    case unknown(StreamUnknown)
+    case reasoningSummaryDelta(StreamReasoningSummaryDelta)
+    case reasoningSummaryCompleted(StreamReasoningSummaryCompleted)
+
+    // Custom coding for the enum
+    enum CodingKeys: String, CodingKey {
+        case type, data
+    }
+
+    public init(from decoder: any Decoder) throws {
+        let container = try decoder.container(keyedBy: CodingKeys.self)
+        let type = try container.decode(StreamEventType.self, forKey: .type)
+
+        switch type {
+        case .textDelta:
+            let data = try container.decode(StreamTextDelta.self, forKey: .data)
+            self = .textDelta(data)
+        case .responseStarted:
+            let data = try container.decode(StreamResponseStarted.self, forKey: .data)
+            self = .responseStarted(data)
+        case .responseCompleted:
+            let data = try container.decode(StreamResponseCompleted.self, forKey: .data)
+            self = .responseCompleted(data)
+        case .toolCallDelta:
+            let data = try container.decode(StreamToolCallDelta.self, forKey: .data)
+            self = .toolCallDelta(data)
+        case .toolCallCompleted:
+            let data = try container.decode(StreamToolCallCompleted.self, forKey: .data)
+            self = .toolCallCompleted(data)
+        case .functionCallArgumentsDelta:
+            let data = try container.decode(StreamFunctionCallArgumentsDelta.self, forKey: .data)
+            self = .functionCallArgumentsDelta(data)
+        case .error:
+            let data = try container.decode(StreamError.self, forKey: .data)
+            self = .error(data)
+        case .unknown:
+            let data = try container.decode(StreamUnknown.self, forKey: .data)
+            self = .unknown(data)
+        case .reasoningSummaryDelta:
+            let data = try container.decode(StreamReasoningSummaryDelta.self, forKey: .data)
+            self = .reasoningSummaryDelta(data)
+        case .reasoningSummaryCompleted:
+            let data = try container.decode(StreamReasoningSummaryCompleted.self, forKey: .data)
+            self = .reasoningSummaryCompleted(data)
+        }
+    }
+
+    public func encode(to encoder: any Encoder) throws {
+        var container = encoder.container(keyedBy: CodingKeys.self)
+
+        switch self {
+        case let .textDelta(data):
+            try container.encode(StreamEventType.textDelta, forKey: .type)
+            try container.encode(data, forKey: .data)
+        case let .responseStarted(data):
+            try container.encode(StreamEventType.responseStarted, forKey: .type)
+            try container.encode(data, forKey: .data)
+        case let .responseCompleted(data):
+            try container.encode(StreamEventType.responseCompleted, forKey: .type)
+            try container.encode(data, forKey: .data)
+        case let .toolCallDelta(data):
+            try container.encode(StreamEventType.toolCallDelta, forKey: .type)
+            try container.encode(data, forKey: .data)
+        case let .toolCallCompleted(data):
+            try container.encode(StreamEventType.toolCallCompleted, forKey: .type)
+            try container.encode(data, forKey: .data)
+        case let .functionCallArgumentsDelta(data):
+            try container.encode(StreamEventType.functionCallArgumentsDelta, forKey: .type)
+            try container.encode(data, forKey: .data)
+        case let .error(data):
+            try container.encode(StreamEventType.error, forKey: .type)
+            try container.encode(data, forKey: .data)
+        case let .unknown(data):
+            try container.encode(StreamEventType.unknown, forKey: .type)
+            try container.encode(data, forKey: .data)
+        case let .reasoningSummaryDelta(data):
+            try container.encode(StreamEventType.reasoningSummaryDelta, forKey: .type)
+            try container.encode(data, forKey: .data)
+        case let .reasoningSummaryCompleted(data):
+            try container.encode(StreamEventType.reasoningSummaryCompleted, forKey: .type)
+            try container.encode(data, forKey: .data)
+        }
+    }
+}
+
+// MARK: - Concrete Streaming Event Types
+
+/// Text delta event containing incremental text output
+@available(macOS 14.0, iOS 17.0, watchOS 10.0, tvOS 17.0, *)
+public struct StreamTextDelta: StreamingEvent, Codable, Sendable {
+    public var type = StreamEventType.textDelta
+    public let delta: String
+    public let index: Int?
+
+    public init(delta: String, index: Int? = nil) {
+        self.delta = delta
+        self.index = index
+    }
+}
+
+/// Response started event
+@available(macOS 14.0, iOS 17.0, watchOS 10.0, tvOS 17.0, *)
+public struct StreamResponseStarted: StreamingEvent, Codable, Sendable {
+    public var type = StreamEventType.responseStarted
+    public let id: String
+    public let model: String?
+    public let systemFingerprint: String?
+
+    public init(id: String, model: String? = nil, systemFingerprint: String? = nil) {
+        self.id = id
+        self.model = model
+        self.systemFingerprint = systemFingerprint
+    }
+}
+
+/// Response completed event with final metadata
+@available(macOS 14.0, iOS 17.0, watchOS 10.0, tvOS 17.0, *)
+public struct StreamResponseCompleted: StreamingEvent, Codable, Sendable {
+    public var type = StreamEventType.responseCompleted
+    public let id: String
+    public let usage: Usage?
+    public let finishReason: FinishReason?
+
+    public init(id: String, usage: Usage? = nil, finishReason: FinishReason? = nil) {
+        self.id = id
+        self.usage = usage
+        self.finishReason = finishReason
+    }
+}
+
+/// Tool call delta event for incremental tool call information
+@available(macOS 14.0, iOS 17.0, watchOS 10.0, tvOS 17.0, *)
+public struct StreamToolCallDelta: StreamingEvent, Codable, Sendable {
+    public var type = StreamEventType.toolCallDelta
+    public let id: String
+    public let index: Int
+    public let function: FunctionCallDelta
+
+    public init(id: String, index: Int, function: FunctionCallDelta) {
+        self.id = id
+        self.index = index
+        self.function = function
+    }
+}
+
+/// Tool call completed event
+@available(macOS 14.0, iOS 17.0, watchOS 10.0, tvOS 17.0, *)
+public struct StreamToolCallCompleted: StreamingEvent, Codable, Sendable {
+    public var type = StreamEventType.toolCallCompleted
+    public let id: String
+    public let function: FunctionCall
+
+    public init(id: String, function: FunctionCall) {
+        self.id = id
+        self.function = function
+    }
+}
+
+/// Function call arguments delta event for incremental function call argument information
+@available(macOS 14.0, iOS 17.0, watchOS 10.0, tvOS 17.0, *)
+public struct StreamFunctionCallArgumentsDelta: StreamingEvent, Codable, Sendable {
+    public var type = StreamEventType.functionCallArgumentsDelta
+    public let id: String
+    public let arguments: String
+
+    public init(id: String, arguments: String) {
+        self.id = id
+        self.arguments = arguments
+    }
+}
+
+/// Error event for stream errors
+@available(macOS 14.0, iOS 17.0, watchOS 10.0, tvOS 17.0, *)
+public struct StreamError: StreamingEvent, Codable, Sendable {
+    public var type = StreamEventType.error
+    public let error: ErrorDetail
+
+    public init(error: ErrorDetail) {
+        self.error = error
+    }
+}
+
+/// Unknown event for forward compatibility
+@available(macOS 14.0, iOS 17.0, watchOS 10.0, tvOS 17.0, *)
+public struct StreamUnknown: StreamingEvent, Codable, Sendable {
+    public var type = StreamEventType.unknown
+    public let eventType: String
+    public let rawJSON: [UInt8]
+
+    public init(eventType: String, rawJSON: [UInt8]) {
+        self.eventType = eventType
+        self.rawJSON = rawJSON
+    }
+
+    /// Get the raw data as a dictionary if possible
+    public func getRawData() throws -> [String: Any]? {
+        let data = Data(self.rawJSON)
+        return try JSONSerialization.jsonObject(with: data) as? [String: Any]
+    }
+
+    /// Get the raw data as a pretty-printed JSON string
+    public func getRawJSONString() -> String? {
+        let data = Data(self.rawJSON)
+        if let json = try? JSONSerialization.jsonObject(with: data),
+           let prettyData = try? JSONSerialization.data(withJSONObject: json, options: .prettyPrinted)
+        {
+            return String(data: prettyData, encoding: .utf8)
+        }
+        return String(data: data, encoding: .utf8)
+    }
+}
+
+/// Reasoning summary delta event for o3 models
+@available(macOS 14.0, iOS 17.0, watchOS 10.0, tvOS 17.0, *)
+public struct StreamReasoningSummaryDelta: StreamingEvent, Codable, Sendable {
+    public var type = StreamEventType.reasoningSummaryDelta
+    public let delta: String
+    public let index: Int?
+
+    public init(delta: String, index: Int? = nil) {
+        self.delta = delta
+        self.index = index
+    }
+}
+
+/// Reasoning summary completed event for o3 models
+@available(macOS 14.0, iOS 17.0, watchOS 10.0, tvOS 17.0, *)
+public struct StreamReasoningSummaryCompleted: StreamingEvent, Codable, Sendable {
+    public var type = StreamEventType.reasoningSummaryCompleted
+    public let summary: String
+    public let reasoningTokens: Int?
+
+    public init(summary: String, reasoningTokens: Int? = nil) {
+        self.summary = summary
+        self.reasoningTokens = reasoningTokens
+    }
+}
+
+// MARK: - Supporting Types
+
+/// Function call delta for incremental function information
+@available(macOS 14.0, iOS 17.0, watchOS 10.0, tvOS 17.0, *)
+public struct FunctionCallDelta: Codable, Sendable {
+    public let name: String?
+    public let arguments: String?
+
+    public init(name: String? = nil, arguments: String? = nil) {
+        self.name = name
+        self.arguments = arguments
+    }
+}
+
+/// Token usage information
+@available(macOS 14.0, iOS 17.0, watchOS 10.0, tvOS 17.0, *)
+public struct Usage: Codable, Sendable {
+    public let promptTokens: Int
+    public let completionTokens: Int
+    public let totalTokens: Int
+    public let promptTokensDetails: TokenDetails?
+    public let completionTokensDetails: TokenDetails?
+
+    public init(
+        promptTokens: Int,
+        completionTokens: Int,
+        totalTokens: Int,
+        promptTokensDetails: TokenDetails? = nil,
+        completionTokensDetails: TokenDetails? = nil)
+    {
+        self.promptTokens = promptTokens
+        self.completionTokens = completionTokens
+        self.totalTokens = totalTokens
+        self.promptTokensDetails = promptTokensDetails
+        self.completionTokensDetails = completionTokensDetails
+    }
+}
+
+/// Detailed token usage breakdown
+@available(macOS 14.0, iOS 17.0, watchOS 10.0, tvOS 17.0, *)
+public struct TokenDetails: Codable, Sendable {
+    public let cachedTokens: Int?
+    public let audioTokens: Int?
+    public let reasoningTokens: Int?
+
+    public init(cachedTokens: Int? = nil, audioTokens: Int? = nil, reasoningTokens: Int? = nil) {
+        self.cachedTokens = cachedTokens
+        self.audioTokens = audioTokens
+        self.reasoningTokens = reasoningTokens
+    }
+}
+
+/// Reason why the response finished
+@available(macOS 14.0, iOS 17.0, watchOS 10.0, tvOS 17.0, *)
+public enum FinishReason: String, Codable, Sendable {
+    case stop
+    case length
+    case toolCalls = "tool_calls"
+    case contentFilter = "content_filter"
+    case functionCall = "function_call"
+}
+
+/// Error detail information
+@available(macOS 14.0, iOS 17.0, watchOS 10.0, tvOS 17.0, *)
+public struct ErrorDetail: Codable, Sendable {
+    public let message: String
+    public let type: String?
+    public let code: String?
+    public let param: String?
+
+    public init(message: String, type: String? = nil, code: String? = nil, param: String? = nil) {
+        self.message = message
+        self.type = type
+        self.code = code
+        self.param = param
+    }
+}
+
+// MARK: - Stream Event Extensions
+
+@available(macOS 14.0, iOS 17.0, watchOS 10.0, tvOS 17.0, *)
+extension StreamEvent {
+    /// Check if this is a final event
+    public var isFinal: Bool {
+        switch self {
+        case .responseCompleted, .error, .reasoningSummaryCompleted:
+            true
+        default:
+            false
+        }
+    }
+
+    /// Extract any text content from the event
+    public var textContent: String? {
+        switch self {
+        case let .textDelta(delta):
+            delta.delta
+        case let .reasoningSummaryDelta(delta):
+            delta.delta
+        case let .reasoningSummaryCompleted(completed):
+            completed.summary
+        case let .error(error):
+            error.error.message
+        default:
+            nil
+        }
+    }
+}
\ No newline at end of file
diff --git a/Sources/Core/TachikomaError.swift b/Sources/Core/TachikomaError.swift
new file mode 100644
index 0000000..871d9d2
--- /dev/null
+++ b/Sources/Core/TachikomaError.swift
@@ -0,0 +1,202 @@
+@_exported import Foundation
+
+// MARK: - Tachikoma Error Types
+
+/// Main error type for the Tachikoma library
+@available(macOS 14.0, iOS 17.0, watchOS 10.0, tvOS 17.0, *)
+public enum TachikomaError: Error, LocalizedError, Sendable {
+    case modelNotFound(String)
+    case authenticationFailed
+    case invalidConfiguration(String)
+    case networkError(underlying: any Error)
+    case decodingError(underlying: any Error)
+    case invalidRequest(String)
+    case apiError(message: String, code: String? = nil)
+    case timeout
+    case rateLimited
+    case insufficientQuota
+    case modelOverloaded
+    case contextLengthExceeded
+    case contentFiltered
+    case invalidToolCall(String)
+    case streamingError(String)
+    case configurationError(String)
+
+    public var errorDescription: String? {
+        switch self {
+        case let .modelNotFound(model):
+            "Model not found: \(model)"
+        case .authenticationFailed:
+            "Authentication failed - check your API key"
+        case let .invalidConfiguration(message):
+            "Invalid configuration: \(message)"
+        case let .networkError(underlying):
+            "Network error: \(underlying.localizedDescription)"
+        case let .decodingError(underlying):
+            "Failed to decode response: \(underlying.localizedDescription)"
+        case let .invalidRequest(message):
+            "Invalid request: \(message)"
+        case let .apiError(message, code):
+            if let code {
+                "API error (\(code)): \(message)"
+            } else {
+                "API error: \(message)"
+            }
+        case .timeout:
+            "Request timed out"
+        case .rateLimited:
+            "Rate limited - please slow down requests"
+        case .insufficientQuota:
+            "Insufficient quota - check your billing"
+        case .modelOverloaded:
+            "Model is currently overloaded - try again later"
+        case .contextLengthExceeded:
+            "Context length exceeded - reduce input size"
+        case .contentFiltered:
+            "Content was filtered by safety systems"
+        case let .invalidToolCall(message):
+            "Invalid tool call: \(message)"
+        case let .streamingError(message):
+            "Streaming error: \(message)"
+        case let .configurationError(message):
+            "Configuration error: \(message)"
+        }
+    }
+
+    public var recoverySuggestion: String? {
+        switch self {
+        case .modelNotFound:
+            "Check available models with listModels() or verify the model name is correct"
+        case .authenticationFailed:
+            "Verify your API key is set correctly in environment variables or credentials file"
+        case .rateLimited:
+            "Wait a moment before making another request"
+        case .insufficientQuota:
+            "Check your billing settings and account quota"
+        case .modelOverloaded:
+            "Try using a different model or retry after a delay"
+        case .contextLengthExceeded:
+            "Reduce the length of your input messages or use a model with larger context"
+        case .contentFiltered:
+            "Modify your input to comply with content policies"
+        case .timeout:
+            "Check your network connection and try again"
+        default:
+            nil
+        }
+    }
+
+    /// Check if this error indicates a temporary condition that might resolve with retry
+    public var isRetryable: Bool {
+        switch self {
+        case .rateLimited, .modelOverloaded, .timeout, .networkError:
+            true
+        default:
+            false
+        }
+    }
+
+    /// Check if this error indicates an authentication issue
+    public var isAuthenticationError: Bool {
+        switch self {
+        case .authenticationFailed, .insufficientQuota:
+            true
+        default:
+            false
+        }
+    }
+
+    /// Check if this error indicates a client-side issue
+    public var isClientError: Bool {
+        switch self {
+        case .invalidRequest, .invalidConfiguration, .contextLengthExceeded, .contentFiltered, .invalidToolCall:
+            true
+        default:
+            false
+        }
+    }
+}
+
+// MARK: - Model Request/Response Errors
+
+/// Specific errors for model requests and responses
+@available(macOS 14.0, iOS 17.0, watchOS 10.0, tvOS 17.0, *)
+public enum ModelError: Error, LocalizedError, Sendable {
+    case invalidInput(String)
+    case missingRequiredParameter(String)
+    case unsupportedParameter(String)
+    case invalidParameterValue(String, value: String)
+    case responseTooLarge
+    case emptyResponse
+    case malformedResponse(String)
+
+    public var errorDescription: String? {
+        switch self {
+        case let .invalidInput(message):
+            "Invalid input: \(message)"
+        case let .missingRequiredParameter(param):
+            "Missing required parameter: \(param)"
+        case let .unsupportedParameter(param):
+            "Unsupported parameter: \(param)"
+        case let .invalidParameterValue(param, value):
+            "Invalid value for parameter '\(param)': \(value)"
+        case .responseTooLarge:
+            "Response exceeds maximum size limit"
+        case .emptyResponse:
+            "Received empty response from API"
+        case let .malformedResponse(message):
+            "Malformed response: \(message)"
+        }
+    }
+}
+
+// MARK: - Streaming Errors
+
+/// Errors specific to streaming operations
+@available(macOS 14.0, iOS 17.0, watchOS 10.0, tvOS 17.0, *)
+public enum StreamingError: Error, LocalizedError, Sendable {
+    case streamClosed
+    case invalidEventFormat(String)
+    case bufferOverflow
+    case connectionLost
+
+    public var errorDescription: String? {
+        switch self {
+        case .streamClosed:
+            "Stream was closed unexpectedly"
+        case let .invalidEventFormat(format):
+            "Invalid event format: \(format)"
+        case .bufferOverflow:
+            "Stream buffer overflow"
+        case .connectionLost:
+            "Connection to stream was lost"
+        }
+    }
+}
+
+// MARK: - Tool Execution Errors
+
+/// Errors for tool execution
+@available(macOS 14.0, iOS 17.0, watchOS 10.0, tvOS 17.0, *)
+public enum ToolExecutionError: Error, LocalizedError, Sendable {
+    case toolNotFound(String)
+    case invalidArguments(String)
+    case executionFailed(String)
+    case timeout
+    case missingContext
+
+    public var errorDescription: String? {
+        switch self {
+        case let .toolNotFound(name):
+            "Tool not found: \(name)"
+        case let .invalidArguments(message):
+            "Invalid tool arguments: \(message)"
+        case let .executionFailed(message):
+            "Tool execution failed: \(message)"
+        case .timeout:
+            "Tool execution timed out"
+        case .missingContext:
+            "Required context is missing for tool execution"
+        }
+    }
+}
\ No newline at end of file
diff --git a/Sources/Core/ToolDefinitions.swift b/Sources/Core/ToolDefinitions.swift
new file mode 100644
index 0000000..3fd2969
--- /dev/null
+++ b/Sources/Core/ToolDefinitions.swift
@@ -0,0 +1,597 @@
+import Foundation
+
+// MARK: - Tool Definition
+
+/// A tool that can be used by an agent to perform actions
+@available(macOS 14.0, iOS 17.0, watchOS 10.0, tvOS 17.0, *)
+public struct Tool<Context> {
+    /// Unique name of the tool
+    public let name: String
+
+    /// Description of what the tool does
+    public let description: String
+
+    /// Parameters the tool accepts
+    public let parameters: ToolParameters
+
+    /// Whether to use strict parameter validation
+    public let strict: Bool
+
+    /// The function to execute when the tool is called
+    public let execute: (ToolInput, Context) async throws -> ToolOutput
+
+    public init(
+        name: String,
+        description: String,
+        parameters: ToolParameters,
+        strict: Bool = true,
+        execute: @escaping (ToolInput, Context) async throws -> ToolOutput)
+    {
+        self.name = name
+        self.description = description
+        self.parameters = parameters
+        self.strict = strict
+        self.execute = execute
+    }
+
+    /// Convert to a tool definition for the model
+    public func toToolDefinition() -> ToolDefinition {
+        ToolDefinition(
+            type: .function,
+            function: FunctionDefinition(
+                name: self.name,
+                description: self.description,
+                parameters: self.parameters,
+                strict: self.strict))
+    }
+}
+
+// MARK: - Tool Definition Types
+
+/// Definition of a tool that can be sent to a model
+public struct ToolDefinition: Codable, Sendable {
+    public let type: ToolType
+    public let function: FunctionDefinition
+
+    public init(type: ToolType = .function, function: FunctionDefinition) {
+        self.type = type
+        self.function = function
+    }
+}
+
+/// Type of tool
+public enum ToolType: String, Codable, Sendable {
+    case function
+}
+
+/// Function definition for a tool
+public struct FunctionDefinition: Codable, Sendable {
+    public let name: String
+    public let description: String
+    public let parameters: ToolParameters
+    public let strict: Bool?
+
+    public init(
+        name: String,
+        description: String,
+        parameters: ToolParameters,
+        strict: Bool? = nil)
+    {
+        self.name = name
+        self.description = description
+        self.parameters = parameters
+        self.strict = strict
+    }
+}
+
+// MARK: - Tool Parameters
+
+/// Parameters schema for a tool
+public struct ToolParameters: Codable, Sendable {
+    public let type: String
+    public let properties: [String: ParameterSchema]
+    public let required: [String]
+    public let additionalProperties: Bool
+
+    public init(
+        type: String = "object",
+        properties: [String: ParameterSchema] = [:],
+        required: [String] = [],
+        additionalProperties: Bool = false)
+    {
+        self.type = type
+        self.properties = properties
+        self.required = required
+        self.additionalProperties = additionalProperties
+    }
+
+    /// Create parameters from a dictionary of property definitions
+    public static func object(
+        properties: [String: ParameterSchema],
+        required: [String] = []) -> ToolParameters
+    {
+        ToolParameters(
+            type: "object",
+            properties: properties,
+            required: required,
+            additionalProperties: false)
+    }
+}
+
+/// Schema for a single parameter
+public struct ParameterSchema: Codable, Sendable {
+    public let type: ParameterType
+    public let description: String?
+    public let enumValues: [String]?
+    public let items: Box<ParameterSchema>?
+    public let properties: [String: ParameterSchema]?
+    public let minimum: Double?
+    public let maximum: Double?
+    public let pattern: String?
+
+    public init(
+        type: ParameterType,
+        description: String? = nil,
+        enumValues: [String]? = nil,
+        items: ParameterSchema? = nil,
+        properties: [String: ParameterSchema]? = nil,
+        minimum: Double? = nil,
+        maximum: Double? = nil,
+        pattern: String? = nil)
+    {
+        self.type = type
+        self.description = description
+        self.enumValues = enumValues
+        self.items = items.map(Box.init)
+        self.properties = properties
+        self.minimum = minimum
+        self.maximum = maximum
+        self.pattern = pattern
+    }
+
+    // Convenience initializers
+    public static func string(description: String? = nil, pattern: String? = nil) -> ParameterSchema {
+        ParameterSchema(type: .string, description: description, pattern: pattern)
+    }
+
+    public static func number(
+        description: String? = nil,
+        minimum: Double? = nil,
+        maximum: Double? = nil) -> ParameterSchema
+    {
+        ParameterSchema(type: .number, description: description, minimum: minimum, maximum: maximum)
+    }
+
+    public static func integer(
+        description: String? = nil,
+        minimum: Double? = nil,
+        maximum: Double? = nil) -> ParameterSchema
+    {
+        ParameterSchema(type: .integer, description: description, minimum: minimum, maximum: maximum)
+    }
+
+    public static func boolean(description: String? = nil) -> ParameterSchema {
+        ParameterSchema(type: .boolean, description: description)
+    }
+
+    public static func array(of items: ParameterSchema, description: String? = nil) -> ParameterSchema {
+        ParameterSchema(type: .array, description: description, items: items)
+    }
+
+    public static func object(properties: [String: ParameterSchema], description: String? = nil) -> ParameterSchema {
+        ParameterSchema(type: .object, description: description, properties: properties)
+    }
+
+    public static func enumeration(_ values: [String], description: String? = nil) -> ParameterSchema {
+        ParameterSchema(type: .string, description: description, enumValues: values)
+    }
+
+    // Custom coding keys
+    enum CodingKeys: String, CodingKey {
+        case type, description
+        case enumValues = "enum"
+        case items, properties
+        case minimum, maximum, pattern
+    }
+}
+
+/// Parameter types
+public enum ParameterType: String, Codable, Sendable {
+    case string
+    case number
+    case integer
+    case boolean
+    case array
+    case object
+    case null
+}
+
+// MARK: - Tool Input/Output
+
+/// Input provided to a tool
+public enum ToolInput {
+    case string(String)
+    case dictionary([String: Any])
+    case array([Any])
+    case null
+
+    /// Parse from a JSON string
+    public init(jsonString: String) throws {
+        // Handle empty string as empty dictionary
+        if jsonString.isEmpty {
+            self = .dictionary([:])
+            return
+        }
+
+        guard let data = jsonString.data(using: .utf8) else {
+            throw ToolError.invalidInput("Invalid JSON string")
+        }
+
+        let parsed = try JSONSerialization.jsonObject(with: data)
+
+        if let dict = parsed as? [String: Any] {
+            self = .dictionary(dict)
+        } else if let array = parsed as? [Any] {
+            self = .array(array)
+        } else if let string = parsed as? String {
+            self = .string(string)
+        } else {
+            self = .null
+        }
+    }
+
+    /// Get value for a specific key (for dictionary inputs)
+    public func value<T>(for key: String) -> T? {
+        guard case let .dictionary(dict) = self else { return nil }
+        return dict[key] as? T
+    }
+
+    /// Get the raw string value
+    public var stringValue: String? {
+        switch self {
+        case let .string(str):
+            return str
+        case .dictionary, .array:
+            if let data = try? JSONSerialization.data(withJSONObject: rawValue),
+               let str = String(data: data, encoding: .utf8)
+            {
+                return str
+            }
+            return nil
+        case .null:
+            return nil
+        }
+    }
+
+    /// Get the raw value
+    public var rawValue: Any {
+        switch self {
+        case let .string(str):
+            str
+        case let .dictionary(dict):
+            dict
+        case let .array(array):
+            array
+        case .null:
+            NSNull()
+        }
+    }
+}
+
+/// Strongly-typed output from a tool
+public enum ToolOutput: Codable, Sendable {
+    case string(String)
+    case number(Double)
+    case boolean(Bool)
+    case object([String: ToolOutput])
+    case array([ToolOutput])
+    case null
+    case error(message: String, code: String? = nil)
+
+    // MARK: - Codable Implementation
+
+    private enum CodingKeys: String, CodingKey {
+        case type, value, message, code
+    }
+
+    private enum OutputType: String, Codable {
+        case string, number, boolean, object, array, null, error
+    }
+
+    public init(from decoder: any Decoder) throws {
+        let container = try decoder.container(keyedBy: CodingKeys.self)
+        let type = try container.decode(OutputType.self, forKey: .type)
+
+        switch type {
+        case .string:
+            let value = try container.decode(String.self, forKey: .value)
+            self = .string(value)
+        case .number:
+            let value = try container.decode(Double.self, forKey: .value)
+            self = .number(value)
+        case .boolean:
+            let value = try container.decode(Bool.self, forKey: .value)
+            self = .boolean(value)
+        case .object:
+            let value = try container.decode([String: ToolOutput].self, forKey: .value)
+            self = .object(value)
+        case .array:
+            let value = try container.decode([ToolOutput].self, forKey: .value)
+            self = .array(value)
+        case .null:
+            self = .null
+        case .error:
+            let message = try container.decode(String.self, forKey: .message)
+            let code = try container.decodeIfPresent(String.self, forKey: .code)
+            self = .error(message: message, code: code)
+        }
+    }
+
+    public func encode(to encoder: any Encoder) throws {
+        var container = encoder.container(keyedBy: CodingKeys.self)
+
+        switch self {
+        case let .string(value):
+            try container.encode(OutputType.string, forKey: .type)
+            try container.encode(value, forKey: .value)
+        case let .number(value):
+            try container.encode(OutputType.number, forKey: .type)
+            try container.encode(value, forKey: .value)
+        case let .boolean(value):
+            try container.encode(OutputType.boolean, forKey: .type)
+            try container.encode(value, forKey: .value)
+        case let .object(value):
+            try container.encode(OutputType.object, forKey: .type)
+            try container.encode(value, forKey: .value)
+        case let .array(value):
+            try container.encode(OutputType.array, forKey: .type)
+            try container.encode(value, forKey: .value)
+        case .null:
+            try container.encode(OutputType.null, forKey: .type)
+        case let .error(message, code):
+            try container.encode(OutputType.error, forKey: .type)
+            try container.encode(message, forKey: .message)
+            try container.encodeIfPresent(code, forKey: .code)
+        }
+    }
+
+    // MARK: - Conversion Methods
+
+    /// Convert to JSON string for the model
+    public func toJSONString() throws -> String {
+        switch self {
+        case let .string(str):
+            return str // Return string directly for text output
+        case let .error(message, code):
+            // Special handling for errors to match expected format
+            var errorDict: [String: ToolOutput] = ["error": .string(message)]
+            if let code {
+                errorDict["error_code"] = .string(code)
+            }
+            let data = try JSONEncoder().encode(ToolOutput.object(errorDict))
+            guard let string = String(data: data, encoding: .utf8) else {
+                throw ToolError.serializationFailed
+            }
+            return string
+        default:
+            // For all other types, encode normally
+            let encoder = JSONEncoder()
+            encoder.outputFormatting = .prettyPrinted
+            let data = try encoder.encode(self)
+            guard let string = String(data: data, encoding: .utf8) else {
+                throw ToolError.serializationFailed
+            }
+            return string
+        }
+    }
+
+    /// Convert to a dictionary representation (for compatibility)
+    public func toDictionary() -> [String: Any]? {
+        switch self {
+        case let .object(dict):
+            var result: [String: Any] = [:]
+            for (key, value) in dict {
+                if let converted = value.toAny() {
+                    result[key] = converted
+                }
+            }
+            return result
+        default:
+            return nil
+        }
+    }
+
+    /// Convert to Any (for legacy compatibility)
+    private func toAny() -> Any? {
+        switch self {
+        case let .string(value):
+            return value
+        case let .number(value):
+            return value
+        case let .boolean(value):
+            return value
+        case let .object(dict):
+            var result: [String: Any] = [:]
+            for (key, value) in dict {
+                if let converted = value.toAny() {
+                    result[key] = converted
+                }
+            }
+            return result
+        case let .array(array):
+            return array.compactMap { $0.toAny() }
+        case .null:
+            return NSNull()
+        case let .error(message, _):
+            return ["error": message]
+        }
+    }
+}
+
+// MARK: - Builder Methods
+
+extension ToolOutput {
+    /// Create a dictionary/object output using a builder pattern
+    public static func dictionary(_ builder: () -> [String: ToolOutput]) -> ToolOutput {
+        .object(builder())
+    }
+
+    /// Create a dictionary/object output from key-value pairs
+    public static func dictionary(_ pairs: (String, ToolOutput)...) -> ToolOutput {
+        var dict: [String: ToolOutput] = [:]
+        for (key, value) in pairs {
+            dict[key] = value
+        }
+        return .object(dict)
+    }
+
+    /// Create from a Swift dictionary with automatic type conversion
+    public static func from(_ dict: [String: Any]) -> ToolOutput {
+        var result: [String: ToolOutput] = [:]
+        for (key, value) in dict {
+            result[key] = self.from(value)
+        }
+        return .object(result)
+    }
+
+    /// Create from any Swift value with automatic type conversion
+    public static func from(_ value: Any) -> ToolOutput {
+        switch value {
+        case let str as String:
+            .string(str)
+        case let num as Int:
+            .number(Double(num))
+        case let num as Double:
+            .number(num)
+        case let bool as Bool:
+            .boolean(bool)
+        case let dict as [String: Any]:
+            self.from(dict)
+        case let array as [Any]:
+            .array(array.map { self.from($0) })
+        case is NSNull:
+            .null
+        default:
+            // Fallback to string representation
+            .string(String(describing: value))
+        }
+    }
+
+    /// Convenience method for success results
+    public static func success(_ message: String, metadata: (String, ToolOutput)...) -> ToolOutput {
+        var dict: [String: ToolOutput] = ["result": .string(message)]
+        for (key, value) in metadata {
+            dict[key] = value
+        }
+        return .object(dict)
+    }
+}
+
+// MARK: - Tool Errors
+
+/// Errors that can occur during tool execution
+public enum ToolError: Error, LocalizedError, Sendable {
+    case invalidInput(String)
+    case executionFailed(String)
+    case serializationFailed
+    case contextMissing
+    case toolNotFound(String)
+
+    public var errorDescription: String? {
+        switch self {
+        case let .invalidInput(message):
+            "Invalid tool input: \(message)"
+        case let .executionFailed(message):
+            "Tool execution failed: \(message)"
+        case .serializationFailed:
+            "Failed to serialize tool output"
+        case .contextMissing:
+            "Required context is missing"
+        case let .toolNotFound(name):
+            "Tool not found: \(name)"
+        }
+    }
+}
+
+// MARK: - Helper Types
+
+/// Box type for recursive data structures
+public final class Box<T: Codable & Sendable>: Codable, Sendable {
+    public let value: T
+
+    public init(_ value: T) {
+        self.value = value
+    }
+
+    public init(from decoder: any Decoder) throws {
+        let container = try decoder.singleValueContainer()
+        self.value = try container.decode(T.self)
+    }
+
+    public func encode(to encoder: any Encoder) throws {
+        var container = encoder.singleValueContainer()
+        try container.encode(self.value)
+    }
+}
+
+// MARK: - Tool Builder
+
+/// Builder pattern for creating tools
+@available(macOS 14.0, iOS 17.0, watchOS 10.0, tvOS 17.0, *)
+public struct ToolBuilder<Context> {
+    private var name: String = ""
+    private var description: String = ""
+    private var parameters: ToolParameters = .init()
+    private var strict: Bool = true
+    private var execute: ((ToolInput, Context) async throws -> ToolOutput)?
+
+    public init() {}
+
+    public func withName(_ name: String) -> ToolBuilder<Context> {
+        var builder = self
+        builder.name = name
+        return builder
+    }
+
+    public func withDescription(_ description: String) -> ToolBuilder<Context> {
+        var builder = self
+        builder.description = description
+        return builder
+    }
+
+    public func withParameters(_ parameters: ToolParameters) -> ToolBuilder<Context> {
+        var builder = self
+        builder.parameters = parameters
+        return builder
+    }
+
+    public func withStrict(_ strict: Bool) -> ToolBuilder<Context> {
+        var builder = self
+        builder.strict = strict
+        return builder
+    }
+
+    public func withExecution(_ execute: @escaping (ToolInput, Context) async throws -> ToolOutput)
+    -> ToolBuilder<Context> {
+        var builder = self
+        builder.execute = execute
+        return builder
+    }
+
+    public func build() throws -> Tool<Context> {
+        guard !self.name.isEmpty else {
+            throw ToolError.invalidInput("Tool name is required")
+        }
+
+        guard let execute else {
+            throw ToolError.invalidInput("Tool execution function is required")
+        }
+
+        return Tool(
+            name: self.name,
+            description: self.description,
+            parameters: self.parameters,
+            strict: self.strict,
+            execute: execute)
+    }
+}
\ No newline at end of file
diff --git a/Sources/Providers/Anthropic/AnthropicModel.swift b/Sources/Providers/Anthropic/AnthropicModel.swift
new file mode 100644
index 0000000..151106a
--- /dev/null
+++ b/Sources/Providers/Anthropic/AnthropicModel.swift
@@ -0,0 +1,642 @@
+import Foundation
+
+/// Anthropic model implementation conforming to ModelInterface
+@available(macOS 14.0, iOS 17.0, watchOS 10.0, tvOS 17.0, *)
+public final class AnthropicModel: ModelInterface, Sendable {
+    private let apiKey: String
+    private let baseURL: URL
+    private let session: URLSession
+    private let anthropicVersion: String
+    private let modelName: String?
+    private let customHeaders: [String: String]?
+
+    public init(
+        apiKey: String,
+        baseURL: URL = URL(string: "https://api.anthropic.com/v1")!,
+        anthropicVersion: String = "2023-06-01",
+        modelName: String? = nil,
+        session: URLSession? = nil)
+    {
+        self.apiKey = apiKey
+        self.baseURL = baseURL
+        self.anthropicVersion = anthropicVersion
+        self.modelName = modelName
+        self.customHeaders = nil
+        
+        if let session {
+            self.session = session
+        } else {
+            let config = URLSessionConfiguration.default
+            config.timeoutIntervalForRequest = 120 // 2 minutes
+            config.timeoutIntervalForResource = 120
+            self.session = URLSession(configuration: config)
+        }
+    }
+    
+    /// Initialize with custom provider configuration
+    public init(
+        apiKey: String,
+        baseURL: String,
+        modelName: String? = nil,
+        headers: [String: String]? = nil,
+        anthropicVersion: String = "2023-06-01",
+        session: URLSession? = nil)
+    {
+        self.apiKey = apiKey
+        self.baseURL = URL(string: baseURL) ?? URL(string: "https://api.anthropic.com/v1")!
+        self.anthropicVersion = anthropicVersion
+        self.modelName = modelName
+        self.customHeaders = headers
+        
+        if let session {
+            self.session = session
+        } else {
+            let config = URLSessionConfiguration.default
+            config.timeoutIntervalForRequest = 120 // 2 minutes
+            config.timeoutIntervalForResource = 120
+            self.session = URLSession(configuration: config)
+        }
+    }
+
+    // MARK: - ModelInterface Implementation
+
+    public var maskedApiKey: String {
+        guard self.apiKey.count > 8 else { return "***" }
+        let start = self.apiKey.prefix(6)
+        let end = self.apiKey.suffix(2)
+        return "\(start)...\(end)"
+    }
+
+    public func getResponse(request: ModelRequest) async throws -> ModelResponse {
+        let anthropicRequest = try convertToAnthropicRequest(request, stream: false)
+        let urlRequest = try createURLRequest(endpoint: "messages", body: anthropicRequest)
+
+        let (data, response) = try await session.data(for: urlRequest)
+
+        guard let httpResponse = response as? HTTPURLResponse else {
+            throw TachikomaError.networkError(underlying: URLError(.badServerResponse))
+        }
+
+        if httpResponse.statusCode != 200 {
+            try handleErrorResponse(data: data, response: httpResponse)
+        }
+
+        do {
+            let anthropicResponse = try JSONDecoder().decode(AnthropicResponse.self, from: data)
+            return try self.convertFromAnthropicResponse(anthropicResponse)
+        } catch {
+            throw TachikomaError.decodingError(underlying: error)
+        }
+    }
+
+    public func getStreamedResponse(request: ModelRequest) async throws -> AsyncThrowingStream<StreamEvent, any Error> {
+        let anthropicRequest = try convertToAnthropicRequest(request, stream: true)
+        let urlRequest = try createURLRequest(endpoint: "messages", body: anthropicRequest)
+
+        return AsyncThrowingStream { continuation in
+            Task {
+                do {
+                    let (bytes, response) = try await session.bytes(for: urlRequest)
+
+                    guard let httpResponse = response as? HTTPURLResponse else {
+                        continuation.finish(throwing: TachikomaError.networkError(underlying: URLError(.badServerResponse)))
+                        return
+                    }
+
+                    if httpResponse.statusCode != 200 {
+                        var errorData = Data()
+                        for try await byte in bytes.prefix(1024) {
+                            errorData.append(byte)
+                        }
+                        try self.handleErrorResponse(data: errorData, response: httpResponse)
+                    }
+
+                    // Process SSE stream
+                    var currentToolCalls: [String: PartialToolCall] = [:]
+                    var responseId: String?
+                    var accumulatedText = ""
+                    var currentContentIndex = 0
+                    var pendingUsage: Usage?
+
+                    for try await line in bytes.lines {
+                        // Skip empty lines
+                        if line.isEmpty {
+                            continue
+                        }
+
+                        // Handle SSE format
+                        if line.hasPrefix("data: ") {
+                            let data = String(line.dropFirst(6))
+
+                            // Parse the event
+                            if let eventData = data.data(using: .utf8) {
+                                do {
+                                    let event = try JSONDecoder().decode(
+                                        AnthropicStreamEvent.self,
+                                        from: eventData)
+
+                                    switch event.type {
+                                    case "message_start":
+                                        if let message = event.message {
+                                            responseId = message.id
+                                            continuation.yield(.responseStarted(StreamResponseStarted(
+                                                id: message.id,
+                                                model: message.model,
+                                                systemFingerprint: nil)))
+                                        }
+
+                                    case "content_block_start":
+                                        currentContentIndex = event.index ?? 0
+                                        if let block = event.contentBlock {
+                                            if block.type == "tool_use", let id = block.id, let name = block.name {
+                                                // Start tracking this tool call
+                                                let partialCall = PartialToolCall(
+                                                    id: id,
+                                                    name: name,
+                                                    index: currentContentIndex)
+                                                currentToolCalls[id] = partialCall
+                                            }
+                                        }
+
+                                    case "content_block_delta":
+                                        if let delta = event.delta {
+                                            if let text = delta.text {
+                                                // Text delta
+                                                continuation.yield(.textDelta(StreamTextDelta(
+                                                    delta: text,
+                                                    index: currentContentIndex)))
+                                                accumulatedText += text
+                                            } else if let partialJson = delta.partialJson {
+                                                // Tool use arguments delta
+                                                // Find the tool call being updated
+                                                if let toolCall = currentToolCalls.values
+                                                    .first(where: { $0.index == currentContentIndex })
+                                                {
+                                                    toolCall.appendArguments(partialJson)
+                                                    continuation.yield(.toolCallDelta(StreamToolCallDelta(
+                                                        id: toolCall.id,
+                                                        index: toolCall.index,
+                                                        function: FunctionCallDelta(
+                                                            name: toolCall.name,
+                                                            arguments: partialJson))))
+                                                }
+                                            }
+                                        }
+
+                                    case "content_block_stop":
+                                        // Complete any tool calls at this index
+                                        for (id, toolCall) in currentToolCalls {
+                                            if toolCall.index == currentContentIndex {
+                                                if let completed = toolCall.toCompleted() {
+                                                    continuation.yield(.toolCallCompleted(
+                                                        StreamToolCallCompleted(id: id, function: completed)))
+                                                }
+                                            }
+                                        }
+
+                                    case "message_delta":
+                                        // Skip regular parsing - will handle in catch block for usage data
+                                        break
+
+                                    case "message_stop":
+                                        // Final completion - emit responseCompleted with usage if available
+                                        if let id = responseId {
+                                            continuation.yield(.responseCompleted(StreamResponseCompleted(
+                                                id: id,
+                                                usage: pendingUsage,
+                                                finishReason: .stop)))
+                                        }
+                                        continuation.finish()
+                                        return
+
+                                    case "error":
+                                        if let error = event.error {
+                                            continuation.finish(throwing: TachikomaError.apiError(
+                                                message: error.message))
+                                            return
+                                        }
+
+                                    default:
+                                        // Unknown event type, ignore
+                                        break
+                                    }
+                                } catch {
+                                    // Special handling for message_delta events with usage
+                                    if let jsonData = data.data(using: .utf8) {
+                                        do {
+                                            if let json = try JSONSerialization
+                                                .jsonObject(with: jsonData) as? [String: Any]
+                                            {
+                                                if json["type"] as? String == "message_delta" {
+                                                    if let usage = json["usage"] as? [String: Any] {
+                                                        if let outputTokens = usage["output_tokens"] as? Int {
+                                                            // Extract input tokens if available
+                                                            let inputTokens = usage["input_tokens"] as? Int ?? 0
+
+                                                            // Create Usage object
+                                                            let tokenUsage = Usage(
+                                                                promptTokens: inputTokens,
+                                                                completionTokens: outputTokens,
+                                                                totalTokens: inputTokens + outputTokens,
+                                                                promptTokensDetails: nil,
+                                                                completionTokensDetails: nil)
+
+                                                            // Store the usage for later
+                                                            pendingUsage = tokenUsage
+                                                        }
+                                                    }
+                                                }
+                                            }
+                                        } catch {
+                                            // Failed to parse JSON, ignore
+                                        }
+                                    }
+                                }
+                            }
+                        }
+                    }
+
+                    continuation.finish()
+                } catch {
+                    continuation.finish(throwing: TachikomaError.streamingError(error.localizedDescription))
+                }
+            }
+        }
+    }
+
+    // MARK: - Private Methods
+
+    private func createURLRequest(endpoint: String, body: any Encodable) throws -> URLRequest {
+        let url = self.baseURL.appendingPathComponent(endpoint)
+        var request = URLRequest(url: url)
+        request.httpMethod = "POST"
+        request.setValue(self.apiKey, forHTTPHeaderField: "x-api-key")
+        request.setValue(self.anthropicVersion, forHTTPHeaderField: "anthropic-version")
+        request.setValue("application/json", forHTTPHeaderField: "Content-Type")
+        
+        // Add custom headers from provider configuration
+        customHeaders?.forEach { key, value in
+            request.setValue(value, forHTTPHeaderField: key)
+        }
+
+        let encoder = JSONEncoder()
+        encoder.outputFormatting = .sortedKeys
+
+        do {
+            request.httpBody = try encoder.encode(body)
+        } catch {
+            throw TachikomaError.configurationError("Failed to encode Anthropic request: \(error.localizedDescription)")
+        }
+
+        request.timeoutInterval = 120
+
+        return request
+    }
+
+    private func convertToAnthropicRequest(_ request: ModelRequest, stream: Bool) throws -> AnthropicRequest {
+        var anthropicMessages: [AnthropicMessage] = []
+        var systemPrompt: String? = nil
+
+        // Convert messages
+        for message in request.messages {
+            switch message {
+            case let .system(_, content):
+                // Anthropic uses a separate system parameter
+                if systemPrompt == nil {
+                    systemPrompt = content
+                } else {
+                    systemPrompt = (systemPrompt ?? "") + "\n\n" + content
+                }
+
+            case let .user(_, content):
+                let anthropicMessage = try convertUserMessage(content)
+                anthropicMessages.append(anthropicMessage)
+
+            case let .assistant(_, content, status):
+                let anthropicMessage = try convertAssistantMessage(content, status: status)
+                anthropicMessages.append(anthropicMessage)
+
+            case let .tool(_, toolCallId, content):
+                // Convert tool result to user message with tool_result content block
+                let toolResultBlock = AnthropicContentBlock.toolResult(
+                    toolUseId: toolCallId,
+                    content: content)
+                anthropicMessages.append(AnthropicMessage(
+                    role: .user,
+                    content: .array([toolResultBlock])))
+
+            case let .reasoning(_, content):
+                // Treat reasoning as a system message for now
+                if systemPrompt == nil {
+                    systemPrompt = "[Reasoning] " + content
+                } else {
+                    systemPrompt = (systemPrompt ?? "") + "\n\n[Reasoning] " + content
+                }
+            }
+        }
+
+        // Convert tools
+        let tools = request.tools?.map { toolDef -> AnthropicTool in
+            AnthropicTool(
+                name: toolDef.function.name,
+                description: toolDef.function.description,
+                inputSchema: self.convertToolParameters(toolDef.function.parameters))
+        }
+
+        // Convert tool choice
+        let toolChoice = self.convertToolChoice(request.settings.toolChoice)
+
+        // Create system content with cache control
+        let systemContent: AnthropicSystemContent? = if let systemPrompt {
+            // Use array format with cache control for system prompt
+            .array([
+                AnthropicSystemBlock(
+                    type: "text",
+                    text: systemPrompt,
+                    cacheControl: AnthropicCacheControl(type: "ephemeral")),
+            ])
+        } else {
+            nil
+        }
+
+        return AnthropicRequest(
+            model: self.modelName ?? request.settings.modelName,
+            messages: anthropicMessages,
+            system: systemContent,
+            maxTokens: request.settings.maxTokens ?? 4096,
+            temperature: request.settings.temperature,
+            topP: request.settings.topP,
+            topK: request.settings.additionalParameters?.int("top_k"),
+            stream: stream,
+            stopSequences: request.settings.stopSequences,
+            tools: tools,
+            toolChoice: toolChoice,
+            metadata: request.settings.user.map { AnthropicMetadata(userId: $0) })
+    }
+
+    private func convertUserMessage(_ content: MessageContent) throws -> AnthropicMessage {
+        switch content {
+        case let .text(text):
+            return AnthropicMessage(role: .user, content: .string(text))
+
+        case let .image(imageContent):
+            var blocks: [AnthropicContentBlock] = []
+
+            if let base64 = imageContent.base64 {
+                blocks.append(.image(base64: base64, mediaType: "image/jpeg"))
+            } else if imageContent.url != nil {
+                // For URLs, we'd need to download and convert to base64
+                // For now, throw an error
+                throw TachikomaError.invalidRequest("Image URLs not supported - please provide base64 data")
+            }
+
+            return AnthropicMessage(role: .user, content: .array(blocks))
+
+        case let .multimodal(parts):
+            let blocks = try parts.compactMap { part -> AnthropicContentBlock? in
+                if let text = part.text {
+                    return .text(text)
+                } else if let image = part.imageUrl {
+                    if let base64 = image.base64 {
+                        return .image(base64: base64, mediaType: "image/jpeg")
+                    } else if image.url != nil {
+                        throw TachikomaError.invalidRequest("Image URLs not supported - please provide base64 data")
+                    }
+                }
+                return nil
+            }
+            return AnthropicMessage(role: .user, content: .array(blocks))
+
+        case .file:
+            throw TachikomaError.invalidRequest("File content not supported in Anthropic API")
+
+        case let .audio(audioContent):
+            // Claude doesn't support native audio, so we need to use the transcript
+            if let transcript = audioContent.transcript {
+                // Include metadata about the audio source
+                var text = transcript
+                if let duration = audioContent.duration {
+                    text = "[Audio transcript, duration: \(Int(duration))s] \(transcript)"
+                } else {
+                    text = "[Audio transcript] \(transcript)"
+                }
+                return AnthropicMessage(role: .user, content: .string(text))
+            } else {
+                throw TachikomaError.invalidRequest("Audio content must be transcribed before sending to Claude. Please ensure transcript is provided.")
+            }
+        }
+    }
+
+    private func convertAssistantMessage(
+        _ content: [AssistantContent],
+        status: MessageStatus) throws -> AnthropicMessage
+    {
+        var blocks: [AnthropicContentBlock] = []
+
+        for content in content {
+            switch content {
+            case let .outputText(text):
+                blocks.append(.text(text))
+
+            case let .refusal(refusal):
+                blocks.append(.text(refusal))
+
+            case let .toolCall(toolCall):
+                // Parse arguments as JSON
+                let arguments: [String: Any] = if let data = toolCall.function.arguments.data(using: .utf8),
+                                                  let json = try? JSONSerialization
+                                                      .jsonObject(with: data) as? [String: Any]
+                {
+                    json
+                } else {
+                    [:]
+                }
+
+                blocks.append(.toolUse(
+                    id: toolCall.id,
+                    name: toolCall.function.name,
+                    input: arguments))
+            }
+        }
+
+        return AnthropicMessage(role: .assistant, content: .array(blocks))
+    }
+
+    private func convertToolParameters(_ params: ToolParameters) -> AnthropicJSONSchema {
+        var properties: [String: AnthropicPropertySchema] = [:]
+
+        for (key, schema) in params.properties {
+            properties[key] = self.convertParameterSchema(schema)
+        }
+
+        return AnthropicJSONSchema(
+            type: params.type,
+            properties: properties,
+            required: params.required)
+    }
+
+    private func convertParameterSchema(_ schema: ParameterSchema) -> AnthropicPropertySchema {
+        // Handle nested items for arrays
+        let items: AnthropicPropertySchema? = if schema.type == .array, let schemaItems = schema.items {
+            self.convertParameterSchema(schemaItems.value)
+        } else {
+            nil
+        }
+
+        // Handle nested properties for objects
+        let properties: [String: AnthropicPropertySchema]?
+        if schema.type == .object, let schemaProps = schema.properties {
+            var convertedProps: [String: AnthropicPropertySchema] = [:]
+            for (key, nestedSchema) in schemaProps {
+                convertedProps[key] = self.convertParameterSchema(nestedSchema)
+            }
+            properties = convertedProps
+        } else {
+            properties = nil
+        }
+
+        return AnthropicPropertySchema(
+            type: schema.type.rawValue,
+            description: schema.description,
+            enum: schema.enumValues,
+            items: items,
+            properties: properties,
+            required: nil // ParameterSchema doesn't have required field at this level
+        )
+    }
+
+    private func convertToolChoice(_ toolChoice: ToolChoice?) -> AnthropicToolChoice? {
+        guard let toolChoice else { return nil }
+
+        switch toolChoice {
+        case .auto:
+            return .auto
+        case .none:
+            return nil // Anthropic doesn't have a "none" option
+        case .required:
+            return .any
+        case let .specific(toolName):
+            return .tool(name: toolName)
+        }
+    }
+
+    private func convertFromAnthropicResponse(_ response: AnthropicResponse) throws -> ModelResponse {
+        var content: [AssistantContent] = []
+
+        // Convert content blocks
+        for block in response.content {
+            switch block.type {
+            case "text":
+                if let text = block.text {
+                    content.append(.outputText(text))
+                }
+
+            case "tool_use":
+                if let id = block.id,
+                   let name = block.name,
+                   let input = block.input
+                {
+                    // Convert input dictionary to JSON string
+                    let arguments: String = if let data = try? JSONSerialization.data(withJSONObject: input.mapValues { $0.toAny() }),
+                                               let json = String(data: data, encoding: .utf8)
+                    {
+                        json
+                    } else {
+                        "{}"
+                    }
+
+                    content.append(.toolCall(ToolCallItem(
+                        id: id,
+                        type: .function,
+                        function: FunctionCall(
+                            name: name,
+                            arguments: arguments))))
+                }
+
+            default:
+                // Unknown content block type, ignore
+                break
+            }
+        }
+
+        let usage = Usage(
+            promptTokens: response.usage.inputTokens,
+            completionTokens: response.usage.outputTokens,
+            totalTokens: response.usage.inputTokens + response.usage.outputTokens,
+            promptTokensDetails: nil,
+            completionTokensDetails: nil)
+
+        return ModelResponse(
+            id: response.id,
+            model: response.model,
+            content: content,
+            usage: usage,
+            flagged: false,
+            finishReason: self.convertStopReason(response.stopReason))
+    }
+
+    private func convertStopReason(_ reason: String?) -> FinishReason? {
+        guard let reason else { return nil }
+
+        switch reason {
+        case "end_turn":
+            return .stop
+        case "max_tokens":
+            return .length
+        case "stop_sequence":
+            return .stop
+        case "tool_use":
+            return .toolCalls
+        default:
+            return .stop
+        }
+    }
+
+    private func handleErrorResponse(data: Data, response: HTTPURLResponse) throws {
+        if let errorResponse = try? JSONDecoder().decode(AnthropicErrorResponse.self, from: data) {
+            let message = errorResponse.error.message
+            
+            switch response.statusCode {
+            case 401:
+                throw TachikomaError.authenticationFailed
+            case 429:
+                throw TachikomaError.rateLimited
+            case 400:
+                if message.contains("credit") || message.contains("usage") {
+                    throw TachikomaError.insufficientQuota
+                } else {
+                    throw TachikomaError.invalidRequest(message)
+                }
+            case 500...599:
+                throw TachikomaError.modelOverloaded
+            default:
+                throw TachikomaError.apiError(message: message)
+            }
+        } else {
+            throw TachikomaError.apiError(message: "HTTP \(response.statusCode)")
+        }
+    }
+}
+
+// MARK: - Helper Types
+
+private class PartialToolCall {
+    let id: String
+    let name: String
+    let index: Int
+    var arguments: String = ""
+
+    init(id: String, name: String, index: Int) {
+        self.id = id
+        self.name = name
+        self.index = index
+    }
+
+    func appendArguments(_ args: String) {
+        self.arguments += args
+    }
+
+    func toCompleted() -> FunctionCall? {
+        FunctionCall(name: self.name, arguments: self.arguments)
+    }
+}
\ No newline at end of file
diff --git a/Sources/Providers/Anthropic/AnthropicTypes.swift b/Sources/Providers/Anthropic/AnthropicTypes.swift
new file mode 100644
index 0000000..1e91af9
--- /dev/null
+++ b/Sources/Providers/Anthropic/AnthropicTypes.swift
@@ -0,0 +1,678 @@
+import Foundation
+
+// MARK: - Anthropic API Request Types
+
+/// Cache control configuration
+@available(macOS 14.0, iOS 17.0, watchOS 10.0, tvOS 17.0, *)
+public struct AnthropicCacheControl: Codable, Sendable {
+    public let type: String // "ephemeral"
+
+    public init(type: String = "ephemeral") {
+        self.type = type
+    }
+}
+
+/// System content that can be cached
+@available(macOS 14.0, iOS 17.0, watchOS 10.0, tvOS 17.0, *)
+public enum AnthropicSystemContent: Codable, Sendable {
+    case string(String)
+    case array([AnthropicSystemBlock])
+
+    // Custom encoding/decoding
+    public init(from decoder: any Decoder) throws {
+        let container = try decoder.singleValueContainer()
+
+        if let stringValue = try? container.decode(String.self) {
+            self = .string(stringValue)
+        } else if let arrayValue = try? container.decode([AnthropicSystemBlock].self) {
+            self = .array(arrayValue)
+        } else {
+            throw DecodingError.typeMismatch(
+                AnthropicSystemContent.self,
+                DecodingError.Context(
+                    codingPath: decoder.codingPath,
+                    debugDescription: "Expected String or Array of system blocks"))
+        }
+    }
+
+    public func encode(to encoder: any Encoder) throws {
+        var container = encoder.singleValueContainer()
+        switch self {
+        case let .string(value):
+            try container.encode(value)
+        case let .array(blocks):
+            try container.encode(blocks)
+        }
+    }
+}
+
+/// System block that can contain cache control
+@available(macOS 14.0, iOS 17.0, watchOS 10.0, tvOS 17.0, *)
+public struct AnthropicSystemBlock: Codable, Sendable {
+    public let type: String // "text"
+    public let text: String
+    public let cacheControl: AnthropicCacheControl?
+
+    enum CodingKeys: String, CodingKey {
+        case type, text
+        case cacheControl = "cache_control"
+    }
+
+    public init(type: String = "text", text: String, cacheControl: AnthropicCacheControl? = nil) {
+        self.type = type
+        self.text = text
+        self.cacheControl = cacheControl
+    }
+}
+
+/// Main request structure for Anthropic's Messages API
+@available(macOS 14.0, iOS 17.0, watchOS 10.0, tvOS 17.0, *)
+public struct AnthropicRequest: Codable, Sendable {
+    /// ID of the model to use (e.g., "claude-3-opus-20240229")
+    public let model: String
+
+    /// Input messages
+    public let messages: [AnthropicMessage]
+
+    /// System prompt (separate from messages)
+    public let system: AnthropicSystemContent?
+
+    /// Maximum number of tokens to generate
+    public let maxTokens: Int
+
+    /// Temperature for randomness (0.0 to 1.0)
+    public let temperature: Double?
+
+    /// Top-p sampling parameter
+    public let topP: Double?
+
+    /// Top-k sampling parameter
+    public let topK: Int?
+
+    /// Whether to stream the response
+    public let stream: Bool?
+
+    /// Stop sequences
+    public let stopSequences: [String]?
+
+    /// Available tools
+    public let tools: [AnthropicTool]?
+
+    /// Tool choice configuration
+    public let toolChoice: AnthropicToolChoice?
+
+    /// Metadata about the request
+    public let metadata: AnthropicMetadata?
+
+    enum CodingKeys: String, CodingKey {
+        case model, messages, system
+        case maxTokens = "max_tokens"
+        case temperature
+        case topP = "top_p"
+        case topK = "top_k"
+        case stream
+        case stopSequences = "stop_sequences"
+        case tools
+        case toolChoice = "tool_choice"
+        case metadata
+    }
+}
+
+/// Anthropic message structure
+@available(macOS 14.0, iOS 17.0, watchOS 10.0, tvOS 17.0, *)
+public struct AnthropicMessage: Codable, Sendable {
+    /// Role of the message sender
+    public let role: AnthropicRole
+
+    /// Content of the message
+    public let content: AnthropicContent
+
+    public init(role: AnthropicRole, content: AnthropicContent) {
+        self.role = role
+        self.content = content
+    }
+}
+
+/// Message roles in Anthropic API
+@available(macOS 14.0, iOS 17.0, watchOS 10.0, tvOS 17.0, *)
+public enum AnthropicRole: String, Codable, Sendable {
+    case user
+    case assistant
+}
+
+/// Content types for Anthropic messages
+@available(macOS 14.0, iOS 17.0, watchOS 10.0, tvOS 17.0, *)
+public enum AnthropicContent: Codable, Sendable {
+    case string(String)
+    case array([AnthropicContentBlock])
+
+    // Custom encoding/decoding
+    public init(from decoder: any Decoder) throws {
+        let container = try decoder.singleValueContainer()
+
+        if let stringValue = try? container.decode(String.self) {
+            self = .string(stringValue)
+        } else if let arrayValue = try? container.decode([AnthropicContentBlock].self) {
+            self = .array(arrayValue)
+        } else {
+            throw DecodingError.typeMismatch(
+                AnthropicContent.self,
+                DecodingError.Context(
+                    codingPath: decoder.codingPath,
+                    debugDescription: "Expected String or Array of content blocks"))
+        }
+    }
+
+    public func encode(to encoder: any Encoder) throws {
+        var container = encoder.singleValueContainer()
+        switch self {
+        case let .string(value):
+            try container.encode(value)
+        case let .array(blocks):
+            try container.encode(blocks)
+        }
+    }
+}
+
+/// Content block for multimodal messages
+@available(macOS 14.0, iOS 17.0, watchOS 10.0, tvOS 17.0, *)
+public struct AnthropicContentBlock: Codable, Sendable {
+    public let type: String
+
+    // Text content
+    public let text: String?
+
+    // Image content
+    public let source: AnthropicImageSource?
+
+    // Tool use content
+    public let id: String?
+    public let name: String?
+    public let input: [String: AnthropicInputValue]?
+
+    // Tool result content
+    public let toolUseId: String?
+    public let content: AnthropicContent?
+    public let isError: Bool?
+
+    // Cache control
+    public let cacheControl: AnthropicCacheControl?
+
+    enum CodingKeys: String, CodingKey {
+        case type, text, source, id, name, input
+        case toolUseId = "tool_use_id"
+        case content
+        case isError = "is_error"
+        case cacheControl = "cache_control"
+    }
+}
+
+/// Image source for content blocks
+@available(macOS 14.0, iOS 17.0, watchOS 10.0, tvOS 17.0, *)
+public struct AnthropicImageSource: Codable, Sendable {
+    public let type: String // "base64"
+    public let mediaType: String // "image/jpeg", "image/png", etc.
+    public let data: String // base64 encoded image data
+
+    enum CodingKeys: String, CodingKey {
+        case type
+        case mediaType = "media_type"
+        case data
+    }
+}
+
+// MARK: - Tool Definitions
+
+/// Tool definition for Anthropic
+@available(macOS 14.0, iOS 17.0, watchOS 10.0, tvOS 17.0, *)
+public struct AnthropicTool: Codable, Sendable {
+    public let name: String
+    public let description: String
+    public let inputSchema: AnthropicJSONSchema
+    public let cacheControl: AnthropicCacheControl?
+
+    enum CodingKeys: String, CodingKey {
+        case name, description
+        case inputSchema = "input_schema"
+        case cacheControl = "cache_control"
+    }
+
+    public init(
+        name: String,
+        description: String,
+        inputSchema: AnthropicJSONSchema,
+        cacheControl: AnthropicCacheControl? = nil)
+    {
+        self.name = name
+        self.description = description
+        self.inputSchema = inputSchema
+        self.cacheControl = cacheControl
+    }
+}
+
+/// JSON Schema for tool parameters
+@available(macOS 14.0, iOS 17.0, watchOS 10.0, tvOS 17.0, *)
+public struct AnthropicJSONSchema: Codable, Sendable {
+    public let type: String
+    public let properties: [String: AnthropicPropertySchema]?
+    public let required: [String]?
+    public let description: String?
+
+    public init(
+        type: String = "object",
+        properties: [String: AnthropicPropertySchema]? = nil,
+        required: [String]? = nil,
+        description: String? = nil)
+    {
+        self.type = type
+        self.properties = properties
+        self.required = required
+        self.description = description
+    }
+}
+
+/// Tool choice configuration
+@available(macOS 14.0, iOS 17.0, watchOS 10.0, tvOS 17.0, *)
+public enum AnthropicToolChoice: Codable, Sendable {
+    case auto
+    case any
+    case tool(name: String)
+
+    // Custom encoding/decoding
+    enum CodingKeys: String, CodingKey {
+        case type, name
+    }
+
+    public init(from decoder: any Decoder) throws {
+        let container = try decoder.container(keyedBy: CodingKeys.self)
+        let type = try container.decode(String.self, forKey: .type)
+
+        switch type {
+        case "auto":
+            self = .auto
+        case "any":
+            self = .any
+        case "tool":
+            let name = try container.decode(String.self, forKey: .name)
+            self = .tool(name: name)
+        default:
+            throw DecodingError.dataCorruptedError(
+                forKey: .type,
+                in: container,
+                debugDescription: "Unknown tool choice type: \(type)")
+        }
+    }
+
+    public func encode(to encoder: any Encoder) throws {
+        var container = encoder.container(keyedBy: CodingKeys.self)
+
+        switch self {
+        case .auto:
+            try container.encode("auto", forKey: .type)
+        case .any:
+            try container.encode("any", forKey: .type)
+        case let .tool(name):
+            try container.encode("tool", forKey: .type)
+            try container.encode(name, forKey: .name)
+        }
+    }
+}
+
+/// Metadata for requests
+@available(macOS 14.0, iOS 17.0, watchOS 10.0, tvOS 17.0, *)
+public struct AnthropicMetadata: Codable, Sendable {
+    public let userId: String?
+
+    enum CodingKeys: String, CodingKey {
+        case userId = "user_id"
+    }
+}
+
+// MARK: - Response Types
+
+/// Response from Anthropic's Messages API
+@available(macOS 14.0, iOS 17.0, watchOS 10.0, tvOS 17.0, *)
+public struct AnthropicResponse: Codable, Sendable {
+    public let id: String
+    public let type: String
+    public let role: AnthropicRole
+    public let content: [AnthropicContentBlock]
+    public let model: String
+    public let stopReason: String?
+    public let stopSequence: String?
+    public let usage: AnthropicUsage
+
+    enum CodingKeys: String, CodingKey {
+        case id, type, role, content, model
+        case stopReason = "stop_reason"
+        case stopSequence = "stop_sequence"
+        case usage
+    }
+}
+
+/// Usage statistics
+@available(macOS 14.0, iOS 17.0, watchOS 10.0, tvOS 17.0, *)
+public struct AnthropicUsage: Codable, Sendable {
+    public let inputTokens: Int
+    public let outputTokens: Int
+
+    enum CodingKeys: String, CodingKey {
+        case inputTokens = "input_tokens"
+        case outputTokens = "output_tokens"
+    }
+}
+
+// MARK: - Streaming Types
+
+/// Server-sent event for streaming
+@available(macOS 14.0, iOS 17.0, watchOS 10.0, tvOS 17.0, *)
+public struct AnthropicStreamEvent: Codable, Sendable {
+    public let type: String
+
+    // Common fields
+    public let index: Int?
+    public let delta: AnthropicDelta?
+
+    // Message start
+    public let message: AnthropicStreamMessage?
+
+    // Content block start
+    public let contentBlock: AnthropicContentBlock?
+
+    // Message complete
+    public let usage: AnthropicUsage?
+    public let stopReason: String?
+    public let stopSequence: String?
+
+    // Error
+    public let error: AnthropicError?
+
+    enum CodingKeys: String, CodingKey {
+        case type, index, delta, message
+        case contentBlock = "content_block"
+        case usage
+        case stopReason = "stop_reason"
+        case stopSequence = "stop_sequence"
+        case error
+    }
+}
+
+/// Stream message metadata
+@available(macOS 14.0, iOS 17.0, watchOS 10.0, tvOS 17.0, *)
+public struct AnthropicStreamMessage: Codable, Sendable {
+    public let id: String
+    public let type: String
+    public let role: AnthropicRole
+    public let content: [AnthropicContentBlock]
+    public let model: String
+    public let usage: AnthropicUsage
+
+    enum CodingKeys: String, CodingKey {
+        case id, type, role, content, model, usage
+    }
+}
+
+/// Delta updates for streaming
+@available(macOS 14.0, iOS 17.0, watchOS 10.0, tvOS 17.0, *)
+public struct AnthropicDelta: Codable, Sendable {
+    // Text delta
+    public let text: String?
+
+    // Message delta fields
+    public let stopReason: String?
+    public let stopSequence: String?
+
+    // Tool use delta
+    public let type: String?
+    public let partialJson: String?
+
+    enum CodingKeys: String, CodingKey {
+        case text
+        case stopReason = "stop_reason"
+        case stopSequence = "stop_sequence"
+        case type
+        case partialJson = "partial_json"
+    }
+}
+
+// MARK: - Error Types
+
+/// Anthropic error response
+@available(macOS 14.0, iOS 17.0, watchOS 10.0, tvOS 17.0, *)
+public struct AnthropicErrorResponse: Codable, Sendable {
+    public let error: AnthropicError
+
+    public var message: String {
+        self.error.message
+    }
+
+    public var code: String? {
+        nil // Anthropic doesn't provide error codes
+    }
+
+    public var type: String? {
+        self.error.type
+    }
+}
+
+/// Error details
+@available(macOS 14.0, iOS 17.0, watchOS 10.0, tvOS 17.0, *)
+public struct AnthropicError: Codable, Sendable {
+    public let type: String
+    public let message: String
+}
+
+// MARK: - Helper Extensions
+
+@available(macOS 14.0, iOS 17.0, watchOS 10.0, tvOS 17.0, *)
+extension AnthropicContentBlock {
+    /// Create a text content block
+    public static func text(_ text: String, cacheControl: AnthropicCacheControl? = nil) -> AnthropicContentBlock {
+        AnthropicContentBlock(
+            type: "text",
+            text: text,
+            source: nil,
+            id: nil,
+            name: nil,
+            input: nil,
+            toolUseId: nil,
+            content: nil,
+            isError: nil,
+            cacheControl: cacheControl)
+    }
+
+    /// Create an image content block
+    public static func image(
+        base64: String,
+        mediaType: String,
+        cacheControl: AnthropicCacheControl? = nil) -> AnthropicContentBlock
+    {
+        AnthropicContentBlock(
+            type: "image",
+            text: nil,
+            source: AnthropicImageSource(
+                type: "base64",
+                mediaType: mediaType,
+                data: base64),
+            id: nil,
+            name: nil,
+            input: nil,
+            toolUseId: nil,
+            content: nil,
+            isError: nil,
+            cacheControl: cacheControl)
+    }
+
+    /// Create a tool use content block
+    public static func toolUse(id: String, name: String, input: [String: Any]) -> AnthropicContentBlock {
+        AnthropicContentBlock(
+            type: "tool_use",
+            text: nil,
+            source: nil,
+            id: id,
+            name: name,
+            input: input.compactMapValues { AnthropicInputValue(from: $0) },
+            toolUseId: nil,
+            content: nil,
+            isError: nil,
+            cacheControl: nil)
+    }
+
+    /// Create a tool result content block
+    public static func toolResult(toolUseId: String, content: String, isError: Bool = false) -> AnthropicContentBlock {
+        AnthropicContentBlock(
+            type: "tool_result",
+            text: nil,
+            source: nil,
+            id: nil,
+            name: nil,
+            input: nil,
+            toolUseId: toolUseId,
+            content: .string(content),
+            isError: isError,
+            cacheControl: nil)
+    }
+}
+
+// MARK: - Input Value Types
+
+/// Type-safe input value for Anthropic tool use
+@available(macOS 14.0, iOS 17.0, watchOS 10.0, tvOS 17.0, *)
+public enum AnthropicInputValue: Codable, Sendable {
+    case string(String)
+    case int(Int)
+    case double(Double)
+    case bool(Bool)
+    case array([AnthropicInputValue])
+    case object([String: AnthropicInputValue])
+    case null
+
+    // MARK: - Codable
+
+    public init(from decoder: any Decoder) throws {
+        let container = try decoder.singleValueContainer()
+
+        if container.decodeNil() {
+            self = .null
+        } else if let string = try? container.decode(String.self) {
+            self = .string(string)
+        } else if let int = try? container.decode(Int.self) {
+            self = .int(int)
+        } else if let double = try? container.decode(Double.self) {
+            self = .double(double)
+        } else if let bool = try? container.decode(Bool.self) {
+            self = .bool(bool)
+        } else if let array = try? container.decode([AnthropicInputValue].self) {
+            self = .array(array)
+        } else if let dict = try? container.decode([String: AnthropicInputValue].self) {
+            self = .object(dict)
+        } else {
+            throw DecodingError.dataCorruptedError(in: container, debugDescription: "Cannot decode AnthropicInputValue")
+        }
+    }
+
+    public func encode(to encoder: any Encoder) throws {
+        var container = encoder.singleValueContainer()
+
+        switch self {
+        case let .string(value):
+            try container.encode(value)
+        case let .int(value):
+            try container.encode(value)
+        case let .double(value):
+            try container.encode(value)
+        case let .bool(value):
+            try container.encode(value)
+        case let .array(values):
+            try container.encode(values)
+        case let .object(dict):
+            try container.encode(dict)
+        case .null:
+            try container.encodeNil()
+        }
+    }
+
+    // MARK: - Conversion
+
+    /// Convert from Any value (for migration)
+    public init?(from value: Any) {
+        switch value {
+        case let string as String:
+            self = .string(string)
+        case let int as Int:
+            self = .int(int)
+        case let double as Double:
+            self = .double(double)
+        case let bool as Bool:
+            self = .bool(bool)
+        case let array as [Any]:
+            let values = array.compactMap { AnthropicInputValue(from: $0) }
+            if values.count == array.count {
+                self = .array(values)
+            } else {
+                return nil
+            }
+        case let dict as [String: Any]:
+            var values: [String: AnthropicInputValue] = [:]
+            for (key, val) in dict {
+                if let inputValue = AnthropicInputValue(from: val) {
+                    values[key] = inputValue
+                } else {
+                    return nil
+                }
+            }
+            self = .object(values)
+        case is NSNull:
+            self = .null
+        default:
+            return nil
+        }
+    }
+
+    /// Convert to Any (for JSON serialization)
+    public func toAny() -> Any {
+        switch self {
+        case let .string(value):
+            value
+        case let .int(value):
+            value
+        case let .double(value):
+            value
+        case let .bool(value):
+            value
+        case let .array(values):
+            values.map { $0.toAny() }
+        case let .object(dict):
+            dict.mapValues { $0.toAny() }
+        case .null:
+            NSNull()
+        }
+    }
+}
+
+/// Type-safe property schema for Anthropic JSON Schema
+@available(macOS 14.0, iOS 17.0, watchOS 10.0, tvOS 17.0, *)
+public struct AnthropicPropertySchema: Codable, Sendable {
+    public let type: String
+    public let description: String?
+    public let `enum`: [String]?
+    public let items: Box<AnthropicPropertySchema>?
+    public let properties: [String: AnthropicPropertySchema]?
+    public let required: [String]?
+
+    public init(
+        type: String,
+        description: String? = nil,
+        enum enumValues: [String]? = nil,
+        items: AnthropicPropertySchema? = nil,
+        properties: [String: AnthropicPropertySchema]? = nil,
+        required: [String]? = nil)
+    {
+        self.type = type
+        self.description = description
+        self.enum = enumValues
+        self.items = items.map(Box.init)
+        self.properties = properties
+        self.required = required
+    }
+}
\ No newline at end of file
diff --git a/Sources/Providers/Grok/GrokModel.swift b/Sources/Providers/Grok/GrokModel.swift
new file mode 100644
index 0000000..d397ece
--- /dev/null
+++ b/Sources/Providers/Grok/GrokModel.swift
@@ -0,0 +1,479 @@
+import Foundation
+
+/// Grok model implementation using OpenAI-compatible Chat Completions API
+@available(macOS 14.0, iOS 17.0, watchOS 10.0, tvOS 17.0, *)
+public final class GrokModel: ModelInterface, Sendable {
+    private let apiKey: String
+    private let modelName: String
+    private let baseURL: URL
+    private let session: URLSession
+
+    public init(
+        apiKey: String,
+        modelName: String = "grok-4-0709",
+        baseURL: URL = URL(string: "https://api.x.ai/v1")!,
+        session: URLSession? = nil)
+    {
+        self.apiKey = apiKey
+        self.modelName = modelName
+        self.baseURL = baseURL
+
+        // Create custom session with appropriate timeout
+        if let session {
+            self.session = session
+        } else {
+            let config = URLSessionConfiguration.default
+            config.timeoutIntervalForRequest = 300 // 5 minutes
+            config.timeoutIntervalForResource = 300
+            self.session = URLSession(configuration: config)
+        }
+    }
+
+    // MARK: - ModelInterface Implementation
+
+    public var maskedApiKey: String {
+        guard self.apiKey.count > 8 else { return "***" }
+        let start = self.apiKey.prefix(6)
+        let end = self.apiKey.suffix(2)
+        return "\(start)...\(end)"
+    }
+
+    public func getResponse(request: ModelRequest) async throws -> ModelResponse {
+        let grokRequest = try convertToGrokRequest(request, stream: false)
+        let urlRequest = try createURLRequest(endpoint: "chat/completions", body: grokRequest)
+
+        let (data, response) = try await session.data(for: urlRequest)
+
+        guard let httpResponse = response as? HTTPURLResponse else {
+            throw TachikomaError.networkError(underlying: URLError(.badServerResponse))
+        }
+
+        if httpResponse.statusCode != 200 {
+            try handleErrorResponse(data: data, response: httpResponse)
+        }
+
+        let chatResponse = try JSONDecoder().decode(GrokChatCompletionResponse.self, from: data)
+        return try self.convertFromGrokResponse(chatResponse)
+    }
+
+    public func getStreamedResponse(request: ModelRequest) async throws -> AsyncThrowingStream<StreamEvent, any Error> {
+        let grokRequest = try convertToGrokRequest(request, stream: true)
+        let urlRequest = try createURLRequest(endpoint: "chat/completions", body: grokRequest)
+
+        return AsyncThrowingStream { continuation in
+            Task {
+                do {
+                    let (bytes, response) = try await session.bytes(for: urlRequest)
+
+                    guard let httpResponse = response as? HTTPURLResponse else {
+                        continuation.finish(throwing: TachikomaError.networkError(underlying: URLError(.badServerResponse)))
+                        return
+                    }
+
+                    if httpResponse.statusCode != 200 {
+                        var errorData = Data()
+                        for try await byte in bytes.prefix(1024) {
+                            errorData.append(byte)
+                        }
+                        try self.handleErrorResponse(data: errorData, response: httpResponse)
+                    }
+
+                    // Process SSE stream
+                    var currentToolCalls: [String: GrokPartialToolCall] = [:]
+
+                    for try await line in bytes.lines {
+                        // Handle SSE format
+                        if line.hasPrefix("data: ") {
+                            let data = String(line.dropFirst(6))
+
+                            if data == "[DONE]" {
+                                // Send any pending tool calls
+                                for (id, toolCall) in currentToolCalls {
+                                    if let completed = toolCall.toCompleted() {
+                                        continuation.yield(.toolCallCompleted(
+                                            StreamToolCallCompleted(id: id, function: completed)))
+                                    }
+                                }
+                                continuation.finish()
+                                return
+                            }
+
+                            // Parse chunk
+                            if let chunkData = data.data(using: .utf8),
+                               let chunk = try? JSONDecoder().decode(
+                                   GrokChatCompletionChunk.self,
+                                   from: chunkData)
+                            {
+                                if let events = self.processGrokChunk(chunk, toolCalls: &currentToolCalls) {
+                                    for event in events {
+                                        continuation.yield(event)
+                                    }
+                                }
+                            }
+                        }
+                    }
+
+                    continuation.finish()
+                } catch {
+                    continuation.finish(throwing: TachikomaError.streamingError(error.localizedDescription))
+                }
+            }
+        }
+    }
+
+    // MARK: - Private Helper Methods
+
+    private func createURLRequest(endpoint: String, body: any Encodable) throws -> URLRequest {
+        let url = self.baseURL.appendingPathComponent(endpoint)
+        var request = URLRequest(url: url)
+        request.httpMethod = "POST"
+        request.setValue("Bearer \(self.apiKey)", forHTTPHeaderField: "Authorization")
+        request.setValue("application/json", forHTTPHeaderField: "Content-Type")
+
+        let encoder = JSONEncoder()
+        encoder.outputFormatting = .sortedKeys
+
+        do {
+            request.httpBody = try encoder.encode(body)
+        } catch {
+            throw TachikomaError.configurationError("Failed to encode Grok request: \(error.localizedDescription)")
+        }
+
+        request.timeoutInterval = 300 // 5 minutes for Grok
+
+        return request
+    }
+
+    private func convertToGrokRequest(_ request: ModelRequest, stream: Bool) throws -> GrokChatCompletionRequest {
+        // Convert messages to OpenAI-compatible format
+        let messages = try request.messages.map { message -> GrokMessage in
+            switch message {
+            case let .system(_, content):
+                return GrokMessage(role: "system", content: .string(content), toolCalls: nil, toolCallId: nil)
+
+            case let .user(_, content):
+                return try self.convertUserMessageContent(content)
+
+            case let .assistant(_, content, _):
+                return try self.convertAssistantMessageContent(content)
+
+            case let .tool(_, toolCallId, content):
+                return GrokMessage(
+                    role: "tool",
+                    content: .string(content),
+                    toolCalls: nil,
+                    toolCallId: toolCallId)
+
+            case .reasoning:
+                throw TachikomaError.invalidRequest("Reasoning messages not supported in Grok")
+            }
+        }
+
+        // Convert tools to OpenAI-compatible format if present
+        let tools = request.tools?.map { toolDef -> GrokTool in
+            GrokTool(
+                type: "function",
+                function: GrokTool.Function(
+                    name: toolDef.function.name,
+                    description: toolDef.function.description,
+                    parameters: self.convertToolParameters(toolDef.function.parameters)))
+        }
+
+        // Filter parameters for Grok 4
+        let temperature = request.settings.temperature
+        var frequencyPenalty = request.settings.frequencyPenalty
+        var presencePenalty = request.settings.presencePenalty
+        var stop = request.settings.stopSequences
+
+        if self.modelName.contains("grok-4") || self.modelName.contains("grok-3") {
+            // Grok 3 and 4 models don't support these parameters
+            frequencyPenalty = nil
+            presencePenalty = nil
+            stop = nil
+        }
+
+        return GrokChatCompletionRequest(
+            model: self.modelName,
+            messages: messages,
+            tools: tools,
+            toolChoice: self.convertToolChoice(request.settings.toolChoice),
+            temperature: temperature,
+            maxTokens: request.settings.maxTokens,
+            stream: stream,
+            frequencyPenalty: frequencyPenalty,
+            presencePenalty: presencePenalty,
+            stop: stop)
+    }
+
+    private func convertUserMessageContent(_ content: MessageContent) throws -> GrokMessage {
+        switch content {
+        case let .text(text):
+            return GrokMessage(role: "user", content: .string(text), toolCalls: nil, toolCallId: nil)
+
+        case let .image(imageContent):
+            var content: [GrokMessageContentPart] = []
+
+            if let url = imageContent.url {
+                content.append(GrokMessageContentPart(
+                    type: "image_url",
+                    text: nil,
+                    imageUrl: GrokImageUrl(
+                        url: url,
+                        detail: imageContent.detail?.rawValue)))
+            } else if let base64 = imageContent.base64 {
+                content.append(GrokMessageContentPart(
+                    type: "image_url",
+                    text: nil,
+                    imageUrl: GrokImageUrl(
+                        url: "data:image/jpeg;base64,\(base64)",
+                        detail: imageContent.detail?.rawValue)))
+            }
+
+            return GrokMessage(role: "user", content: .array(content), toolCalls: nil, toolCallId: nil)
+
+        case let .multimodal(parts):
+            let content = parts.compactMap { part -> GrokMessageContentPart? in
+                if let text = part.text {
+                    return GrokMessageContentPart(
+                        type: "text",
+                        text: text,
+                        imageUrl: nil)
+                } else if let image = part.imageUrl {
+                    if let url = image.url {
+                        return GrokMessageContentPart(
+                            type: "image_url",
+                            text: nil,
+                            imageUrl: GrokImageUrl(url: url, detail: image.detail?.rawValue))
+                    } else if let base64 = image.base64 {
+                        return GrokMessageContentPart(
+                            type: "image_url",
+                            text: nil,
+                            imageUrl: GrokImageUrl(
+                                url: "data:image/jpeg;base64,\(base64)",
+                                detail: image.detail?.rawValue))
+                    }
+                }
+                return nil
+            }
+            return GrokMessage(role: "user", content: .array(content), toolCalls: nil, toolCallId: nil)
+
+        case .file:
+            throw TachikomaError.invalidRequest("File content not supported in Grok chat completions")
+
+        case let .audio(audioContent):
+            // Grok doesn't support native audio, so we need to use the transcript
+            if let transcript = audioContent.transcript {
+                // Include metadata about the audio source
+                var text = transcript
+                if let duration = audioContent.duration {
+                    text = "[Audio transcript, duration: \(Int(duration))s] \(transcript)"
+                } else {
+                    text = "[Audio transcript] \(transcript)"
+                }
+                return GrokMessage(role: "user", content: .string(text), toolCalls: nil, toolCallId: nil)
+            } else {
+                throw TachikomaError.invalidRequest("Audio content must be transcribed before sending to Grok. Please ensure transcript is provided.")
+            }
+        }
+    }
+
+    private func convertAssistantMessageContent(_ contentArray: [AssistantContent]) throws -> GrokMessage {
+        var textContent = ""
+        var toolCalls: [GrokToolCall] = []
+
+        for content in contentArray {
+            switch content {
+            case let .outputText(text):
+                textContent += text
+
+            case let .refusal(refusal):
+                return GrokMessage(role: "assistant", content: .string(refusal), toolCalls: nil, toolCallId: nil)
+
+            case let .toolCall(toolCall):
+                toolCalls.append(GrokToolCall(
+                    id: toolCall.id,
+                    type: toolCall.type.rawValue,
+                    function: GrokFunctionCall(
+                        name: toolCall.function.name,
+                        arguments: toolCall.function.arguments)))
+            }
+        }
+
+        // Include tool calls if present
+        if !toolCalls.isEmpty {
+            return GrokMessage(
+                role: "assistant",
+                content: textContent.isEmpty ? nil : .string(textContent),
+                toolCalls: toolCalls,
+                toolCallId: nil)
+        }
+
+        return GrokMessage(role: "assistant", content: .string(textContent), toolCalls: nil, toolCallId: nil)
+    }
+
+    private func convertToolParameters(_ params: ToolParameters) -> GrokTool.Parameters {
+        let (type, properties, required) = params.toGrokParameters()
+        return GrokTool.Parameters(
+            type: type,
+            properties: properties,
+            required: required)
+    }
+
+    private func convertToolChoice(_ toolChoice: ToolChoice?) -> GrokToolChoice? {
+        guard let toolChoice else { return nil }
+
+        switch toolChoice {
+        case .auto:
+            return .string("auto")
+        case .none:
+            return .string("none")
+        case .required:
+            return .string("required")
+        case let .specific(toolName):
+            return .object(GrokToolChoiceObject(
+                type: "function",
+                function: GrokToolChoiceFunction(name: toolName)))
+        }
+    }
+
+    private func convertFromGrokResponse(_ response: GrokChatCompletionResponse) throws -> ModelResponse {
+        guard let choice = response.choices.first else {
+            throw TachikomaError.apiError(message: "No choices in response")
+        }
+
+        var content: [AssistantContent] = []
+
+        // Add text content if present
+        if let textContent = choice.message.content {
+            content.append(.outputText(textContent))
+        }
+
+        // Add tool calls if present
+        if let toolCalls = choice.message.toolCalls {
+            for toolCall in toolCalls {
+                content.append(.toolCall(ToolCallItem(
+                    id: toolCall.id,
+                    type: .function,
+                    function: FunctionCall(
+                        name: toolCall.function.name,
+                        arguments: toolCall.function.arguments))))
+            }
+        }
+
+        let usage = response.usage.map { usage in
+            Usage(
+                promptTokens: usage.promptTokens,
+                completionTokens: usage.completionTokens,
+                totalTokens: usage.totalTokens,
+                promptTokensDetails: nil,
+                completionTokensDetails: nil)
+        }
+
+        return ModelResponse(
+            id: response.id,
+            model: response.model,
+            content: content,
+            usage: usage,
+            flagged: false,
+            finishReason: self.convertFinishReason(choice.finishReason))
+    }
+
+    private func convertFinishReason(_ reason: String?) -> FinishReason? {
+        guard let reason else { return nil }
+        return FinishReason(rawValue: reason)
+    }
+
+    private func processGrokChunk(
+        _ chunk: GrokChatCompletionChunk,
+        toolCalls: inout [String: GrokPartialToolCall]) -> [StreamEvent]?
+    {
+        var events: [StreamEvent] = []
+
+        // First chunk often contains metadata
+        if !chunk.id.isEmpty, chunk.model.isEmpty == false {
+            events.append(.responseStarted(StreamResponseStarted(
+                id: chunk.id,
+                model: chunk.model,
+                systemFingerprint: chunk.systemFingerprint)))
+        }
+
+        for choice in chunk.choices {
+            let delta = choice.delta
+
+            // Handle text content
+            if let content = delta.content, !content.isEmpty {
+                events.append(.textDelta(StreamTextDelta(delta: content, index: choice.index)))
+            }
+
+            // Handle tool calls
+            if let deltaToolCalls = delta.toolCalls {
+                for toolCallDelta in deltaToolCalls {
+                    let toolCallId = toolCallDelta.id ?? ""
+
+                    if toolCalls[toolCallId] == nil {
+                        let partialCall = GrokPartialToolCall(from: toolCallDelta)
+                        toolCalls[toolCallId] = partialCall
+                    } else {
+                        toolCalls[toolCallId]?.update(with: toolCallDelta)
+                    }
+
+                    // Emit delta event
+                    if let functionDelta = toolCallDelta.function {
+                        events.append(.toolCallDelta(StreamToolCallDelta(
+                            id: toolCallId,
+                            index: toolCallDelta.index,
+                            function: FunctionCallDelta(
+                                name: functionDelta.name,
+                                arguments: functionDelta.arguments))))
+                    }
+                }
+            }
+
+            // Handle finish reason
+            if let finishReason = choice.finishReason {
+                // If this is a tool call finish, emit completed events
+                if finishReason == "tool_calls" {
+                    for (id, toolCall) in toolCalls {
+                        if let completed = toolCall.toCompleted() {
+                            events.append(.toolCallCompleted(
+                                StreamToolCallCompleted(id: id, function: completed)))
+                        }
+                    }
+                }
+
+                events.append(.responseCompleted(StreamResponseCompleted(
+                    id: chunk.id,
+                    usage: nil,
+                    finishReason: FinishReason(rawValue: finishReason))))
+            }
+        }
+
+        return events.isEmpty ? nil : events
+    }
+
+    private func handleErrorResponse(data: Data, response: HTTPURLResponse) throws {
+        if let errorResponse = try? JSONDecoder().decode(GrokErrorResponse.self, from: data) {
+            let message = errorResponse.error.message
+            
+            switch response.statusCode {
+            case 401:
+                throw TachikomaError.authenticationFailed
+            case 429:
+                throw TachikomaError.rateLimited
+            case 400:
+                if message.contains("credit") || message.contains("usage") {
+                    throw TachikomaError.insufficientQuota
+                } else {
+                    throw TachikomaError.invalidRequest(message)
+                }
+            case 500...599:
+                throw TachikomaError.modelOverloaded
+            default:
+                throw TachikomaError.apiError(message: message, code: errorResponse.error.code)
+            }
+        } else {
+            throw TachikomaError.apiError(message: "HTTP \(response.statusCode)")
+        }
+    }
+}
+
diff --git a/Sources/Providers/Grok/GrokTypes.swift b/Sources/Providers/Grok/GrokTypes.swift
new file mode 100644
index 0000000..cbee943
--- /dev/null
+++ b/Sources/Providers/Grok/GrokTypes.swift
@@ -0,0 +1,346 @@
+import Foundation
+
+// MARK: - Helper Types
+
+internal class GrokPartialToolCall {
+    var id: String = ""
+    var type: String = "function"
+    var index: Int = 0
+    var name: String?
+    var arguments: String = ""
+
+    init() {
+        // Default initializer
+    }
+
+    init(from delta: GrokToolCallDelta) {
+        self.id = delta.id ?? ""
+        self.index = delta.index
+        self.name = delta.function?.name
+        self.arguments = delta.function?.arguments ?? ""
+    }
+
+    func update(with delta: GrokToolCallDelta) {
+        if let funcName = delta.function?.name {
+            self.name = funcName
+        }
+        if let args = delta.function?.arguments {
+            self.arguments += args
+        }
+    }
+
+    func toCompleted() -> FunctionCall? {
+        guard let name else { return nil }
+        return FunctionCall(name: name, arguments: self.arguments)
+    }
+}
+
+// MARK: - Grok Request Types
+
+internal struct GrokChatCompletionRequest: Encodable {
+    let model: String
+    let messages: [GrokMessage]
+    let tools: [GrokTool]?
+    let toolChoice: GrokToolChoice?
+    let temperature: Double?
+    let maxTokens: Int?
+    let stream: Bool
+    let frequencyPenalty: Double?
+    let presencePenalty: Double?
+    let stop: [String]?
+
+    enum CodingKeys: String, CodingKey {
+        case model, messages, tools, temperature, stream
+        case toolChoice = "tool_choice"
+        case maxTokens = "max_tokens"
+        case frequencyPenalty = "frequency_penalty"
+        case presencePenalty = "presence_penalty"
+        case stop
+    }
+}
+
+internal struct GrokMessage: Encodable {
+    let role: String
+    let content: GrokMessageContent?
+    let toolCalls: [GrokToolCall]?
+    let toolCallId: String?
+
+    enum CodingKeys: String, CodingKey {
+        case role, content
+        case toolCalls = "tool_calls"
+        case toolCallId = "tool_call_id"
+    }
+}
+
+internal enum GrokMessageContent: Encodable {
+    case string(String)
+    case array([GrokMessageContentPart])
+
+    func encode(to encoder: any Encoder) throws {
+        var container = encoder.singleValueContainer()
+        switch self {
+        case let .string(text):
+            try container.encode(text)
+        case let .array(parts):
+            try container.encode(parts)
+        }
+    }
+}
+
+internal struct GrokMessageContentPart: Encodable {
+    let type: String
+    let text: String?
+    let imageUrl: GrokImageUrl?
+
+    enum CodingKeys: String, CodingKey {
+        case type, text
+        case imageUrl = "image_url"
+    }
+}
+
+internal struct GrokImageUrl: Encodable {
+    let url: String
+    let detail: String?
+}
+
+internal struct GrokToolCall: Encodable {
+    let id: String
+    let type: String
+    let function: GrokFunctionCall
+}
+
+internal struct GrokFunctionCall: Encodable {
+    let name: String
+    let arguments: String
+}
+
+internal struct GrokTool: Encodable {
+    let type: String
+    let function: Function
+
+    struct Function: Encodable {
+        let name: String
+        let description: String?
+        let parameters: Parameters
+    }
+
+    struct Parameters: Encodable {
+        let type: String
+        let properties: [String: GrokPropertySchema]
+        let required: [String]
+    }
+}
+
+internal enum GrokToolChoice: Encodable {
+    case string(String)
+    case object(GrokToolChoiceObject)
+
+    func encode(to encoder: any Encoder) throws {
+        var container = encoder.singleValueContainer()
+        switch self {
+        case let .string(value):
+            try container.encode(value)
+        case let .object(obj):
+            try container.encode(obj)
+        }
+    }
+}
+
+internal struct GrokToolChoiceObject: Encodable {
+    let type: String
+    let function: GrokToolChoiceFunction
+}
+
+internal struct GrokToolChoiceFunction: Encodable {
+    let name: String
+}
+
+// MARK: - Response Types
+
+internal struct GrokChatCompletionResponse: Decodable {
+    let id: String
+    let model: String
+    let choices: [Choice]
+    let usage: Usage?
+
+    struct Choice: Decodable {
+        let message: Message
+        let finishReason: String?
+
+        enum CodingKeys: String, CodingKey {
+            case message
+            case finishReason = "finish_reason"
+        }
+    }
+
+    struct Message: Decodable {
+        let role: String
+        let content: String?
+        let toolCalls: [ToolCall]?
+
+        enum CodingKeys: String, CodingKey {
+            case role, content
+            case toolCalls = "tool_calls"
+        }
+
+        struct ToolCall: Decodable {
+            let id: String
+            let type: String
+            let function: Function
+
+            struct Function: Decodable {
+                let name: String
+                let arguments: String
+            }
+        }
+    }
+
+    struct Usage: Decodable {
+        let promptTokens: Int
+        let completionTokens: Int
+        let totalTokens: Int
+
+        enum CodingKeys: String, CodingKey {
+            case promptTokens = "prompt_tokens"
+            case completionTokens = "completion_tokens"
+            case totalTokens = "total_tokens"
+        }
+    }
+}
+
+// MARK: - Streaming Types
+
+internal struct GrokChatCompletionChunk: Decodable {
+    let id: String
+    let model: String
+    let choices: [StreamChoice]
+    let systemFingerprint: String?
+
+    enum CodingKeys: String, CodingKey {
+        case id, model, choices
+        case systemFingerprint = "system_fingerprint"
+    }
+
+    struct StreamChoice: Decodable {
+        let index: Int
+        let delta: Delta
+        let finishReason: String?
+
+        enum CodingKeys: String, CodingKey {
+            case index, delta
+            case finishReason = "finish_reason"
+        }
+
+        struct Delta: Decodable {
+            let role: String?
+            let content: String?
+            let toolCalls: [GrokToolCallDelta]?
+
+            enum CodingKeys: String, CodingKey {
+                case role, content
+                case toolCalls = "tool_calls"
+            }
+        }
+    }
+}
+
+internal struct GrokToolCallDelta: Decodable {
+    let index: Int
+    let id: String?
+    let type: String?
+    let function: StreamFunction?
+
+    struct StreamFunction: Decodable {
+        let name: String?
+        let arguments: String?
+    }
+}
+
+// MARK: - Error Types
+
+internal struct GrokErrorResponse: Decodable {
+    let error: GrokError
+
+    var message: String {
+        self.error.message
+    }
+
+    var code: String? {
+        self.error.code
+    }
+
+    var type: String? {
+        self.error.type
+    }
+}
+
+internal struct GrokError: Decodable {
+    let message: String
+    let type: String
+    let code: String?
+}
+
+// MARK: - Property Schema
+
+/// Type-safe property schema for Grok tool parameters
+internal struct GrokPropertySchema: Codable, Sendable {
+    let type: String
+    let description: String?
+    let `enum`: [String]?
+    let items: Box<GrokPropertySchema>?
+    let properties: [String: GrokPropertySchema]?
+    let minimum: Double?
+    let maximum: Double?
+    let pattern: String?
+    let required: [String]?
+
+    init(
+        type: String,
+        description: String? = nil,
+        enum enumValues: [String]? = nil,
+        items: GrokPropertySchema? = nil,
+        properties: [String: GrokPropertySchema]? = nil,
+        minimum: Double? = nil,
+        maximum: Double? = nil,
+        pattern: String? = nil,
+        required: [String]? = nil)
+    {
+        self.type = type
+        self.description = description
+        self.enum = enumValues
+        self.items = items.map(Box.init)
+        self.properties = properties
+        self.minimum = minimum
+        self.maximum = maximum
+        self.pattern = pattern
+        self.required = required
+    }
+
+    /// Create from a ParameterSchema
+    init(from schema: ParameterSchema) {
+        self.type = schema.type.rawValue
+        self.description = schema.description
+        self.enum = schema.enumValues
+        self.items = schema.items.map { Box(GrokPropertySchema(from: $0.value)) }
+        self.properties = schema.properties?.mapValues { GrokPropertySchema(from: $0) }
+        self.minimum = schema.minimum
+        self.maximum = schema.maximum
+        self.pattern = schema.pattern
+        self.required = nil
+    }
+}
+
+// MARK: - Extensions
+
+/// Helper to convert ToolParameters to Grok-compatible structure
+internal extension ToolParameters {
+    func toGrokParameters() -> (type: String, properties: [String: GrokPropertySchema], required: [String]) {
+        var grokProperties: [String: GrokPropertySchema] = [:]
+
+        for (key, schema) in properties {
+            grokProperties[key] = GrokPropertySchema(from: schema)
+        }
+
+        return (type: type, properties: grokProperties, required: required)
+    }
+}
\ No newline at end of file
diff --git a/Sources/Providers/Ollama/OllamaModel.swift b/Sources/Providers/Ollama/OllamaModel.swift
new file mode 100644
index 0000000..e58ffd2
--- /dev/null
+++ b/Sources/Providers/Ollama/OllamaModel.swift
@@ -0,0 +1,336 @@
+import Foundation
+
+/// Ollama model implementation conforming to ModelInterface
+@available(macOS 14.0, iOS 17.0, watchOS 10.0, tvOS 17.0, *)
+public final class OllamaModel: ModelInterface, Sendable {
+    private let modelName: String
+    private let baseURL: URL
+    private let session: URLSession
+
+    public init(
+        modelName: String,
+        baseURL: URL = URL(string: "http://localhost:11434")!,
+        session: URLSession? = nil)
+    {
+        self.modelName = modelName
+        self.baseURL = baseURL
+        
+        if let session {
+            self.session = session
+        } else {
+            let config = URLSessionConfiguration.default
+            config.timeoutIntervalForRequest = 300 // 5 minutes for local models
+            config.timeoutIntervalForResource = 300
+            self.session = URLSession(configuration: config)
+        }
+    }
+
+    // MARK: - ModelInterface Implementation
+
+    public var maskedApiKey: String {
+        "local-ollama"
+    }
+
+    public func getResponse(request: ModelRequest) async throws -> ModelResponse {
+        let ollamaRequest = try convertToOllamaRequest(request, stream: false)
+        let urlRequest = try createURLRequest(endpoint: "api/chat", body: ollamaRequest)
+
+        let (data, response) = try await session.data(for: urlRequest)
+
+        guard let httpResponse = response as? HTTPURLResponse else {
+            throw TachikomaError.networkError(underlying: URLError(.badServerResponse))
+        }
+
+        if httpResponse.statusCode != 200 {
+            try handleErrorResponse(data: data, response: httpResponse)
+        }
+
+        let ollamaResponse = try JSONDecoder().decode(OllamaChatResponse.self, from: data)
+        return try self.convertFromOllamaResponse(ollamaResponse)
+    }
+
+    public func getStreamedResponse(request: ModelRequest) async throws -> AsyncThrowingStream<StreamEvent, any Error> {
+        let ollamaRequest = try convertToOllamaRequest(request, stream: true)
+        let urlRequest = try createURLRequest(endpoint: "api/chat", body: ollamaRequest)
+
+        return AsyncThrowingStream { continuation in
+            Task {
+                do {
+                    let (bytes, response) = try await session.bytes(for: urlRequest)
+
+                    guard let httpResponse = response as? HTTPURLResponse else {
+                        continuation.finish(throwing: TachikomaError.networkError(underlying: URLError(.badServerResponse)))
+                        return
+                    }
+
+                    if httpResponse.statusCode != 200 {
+                        var errorData = Data()
+                        for try await byte in bytes.prefix(1024) {
+                            errorData.append(byte)
+                        }
+                        try self.handleErrorResponse(data: errorData, response: httpResponse)
+                    }
+
+                    // Process JSON stream (one JSON object per line)
+                    for try await line in bytes.lines {
+                        if line.isEmpty { continue }
+                        
+                        if let data = line.data(using: .utf8),
+                           let chunk = try? JSONDecoder().decode(OllamaChatChunk.self, from: data) {
+                            
+                            if let events = self.processOllamaChunk(chunk) {
+                                for event in events {
+                                    continuation.yield(event)
+                                }
+                            }
+                            
+                            // Check if done
+                            if chunk.done {
+                                continuation.finish()
+                                return
+                            }
+                        }
+                    }
+
+                    continuation.finish()
+                } catch {
+                    continuation.finish(throwing: TachikomaError.streamingError(error.localizedDescription))
+                }
+            }
+        }
+    }
+
+    // MARK: - Private Methods
+
+    private func createURLRequest(endpoint: String, body: any Encodable) throws -> URLRequest {
+        let url = self.baseURL.appendingPathComponent(endpoint)
+        var request = URLRequest(url: url)
+        request.httpMethod = "POST"
+        request.setValue("application/json", forHTTPHeaderField: "Content-Type")
+
+        let encoder = JSONEncoder()
+        encoder.outputFormatting = .sortedKeys
+
+        do {
+            request.httpBody = try encoder.encode(body)
+        } catch {
+            throw TachikomaError.configurationError("Failed to encode Ollama request: \(error.localizedDescription)")
+        }
+
+        request.timeoutInterval = 300 // 5 minutes for local models
+
+        return request
+    }
+
+    private func convertToOllamaRequest(_ request: ModelRequest, stream: Bool) throws -> OllamaChatRequest {
+        // Convert messages
+        let messages = try request.messages.compactMap { message -> OllamaMessage? in
+            switch message {
+            case let .system(_, content):
+                return OllamaMessage(role: "system", content: content, images: nil)
+
+            case let .user(_, content):
+                return try convertUserMessage(content)
+
+            case let .assistant(_, content, _):
+                return convertAssistantMessage(content)
+
+            case let .tool(_, _, content):
+                // Ollama handles tool results differently - might need adaptation
+                return OllamaMessage(role: "user", content: "Tool result: \(content)", images: nil)
+
+            case .reasoning:
+                // Skip reasoning messages for Ollama
+                return nil
+            }
+        }
+
+        // Convert tools (if supported by the model)
+        let tools = request.tools?.map { toolDef -> OllamaTool in
+            OllamaTool(
+                type: "function",
+                function: OllamaFunction(
+                    name: toolDef.function.name,
+                    description: toolDef.function.description,
+                    parameters: convertToolParameters(toolDef.function.parameters)))
+        }
+
+        return OllamaChatRequest(
+            model: self.modelName,
+            messages: messages,
+            tools: tools,
+            stream: stream,
+            options: OllamaOptions(
+                temperature: request.settings.temperature,
+                topP: request.settings.topP,
+                stop: request.settings.stopSequences))
+    }
+
+    private func convertUserMessage(_ content: MessageContent) throws -> OllamaMessage {
+        switch content {
+        case let .text(text):
+            return OllamaMessage(role: "user", content: text, images: nil)
+
+        case let .image(imageContent):
+            // Ollama supports base64 images
+            if let base64 = imageContent.base64 {
+                return OllamaMessage(role: "user", content: "", images: [base64])
+            } else if imageContent.url != nil {
+                throw TachikomaError.invalidRequest("Image URLs not supported in Ollama - please provide base64 data")
+            } else {
+                throw TachikomaError.invalidRequest("No image data provided")
+            }
+
+        case let .multimodal(parts):
+            var text = ""
+            var images: [String] = []
+            
+            for part in parts {
+                if let partText = part.text {
+                    text += partText
+                } else if let image = part.imageUrl {
+                    if let base64 = image.base64 {
+                        images.append(base64)
+                    } else if image.url != nil {
+                        throw TachikomaError.invalidRequest("Image URLs not supported in Ollama - please provide base64 data")
+                    }
+                }
+            }
+            
+            return OllamaMessage(role: "user", content: text, images: images.isEmpty ? nil : images)
+
+        case .file:
+            throw TachikomaError.invalidRequest("File content not supported in Ollama API")
+
+        case let .audio(audioContent):
+            // Ollama doesn't support native audio, use transcript if available
+            if let transcript = audioContent.transcript {
+                var text = transcript
+                if let duration = audioContent.duration {
+                    text = "[Audio transcript, duration: \(Int(duration))s] \(transcript)"
+                } else {
+                    text = "[Audio transcript] \(transcript)"
+                }
+                return OllamaMessage(role: "user", content: text, images: nil)
+            } else {
+                throw TachikomaError.invalidRequest("Audio content must be transcribed before sending to Ollama")
+            }
+        }
+    }
+
+    private func convertAssistantMessage(_ content: [AssistantContent]) -> OllamaMessage {
+        var text = ""
+        
+        for item in content {
+            switch item {
+            case let .outputText(outputText):
+                text += outputText
+            case let .refusal(refusal):
+                text += refusal
+            case let .toolCall(toolCall):
+                // Convert tool call to text representation for now
+                text += "\n[Tool Call: \(toolCall.function.name)(\(toolCall.function.arguments))]"
+            }
+        }
+        
+        return OllamaMessage(role: "assistant", content: text, images: nil)
+    }
+
+    private func convertToolParameters(_ params: ToolParameters) -> [String: Any] {
+        var properties: [String: Any] = [:]
+        
+        for (key, schema) in params.properties {
+            properties[key] = convertParameterSchema(schema)
+        }
+        
+        return [
+            "type": params.type,
+            "properties": properties,
+            "required": params.required
+        ]
+    }
+
+    private func convertParameterSchema(_ schema: ParameterSchema) -> [String: Any] {
+        var result: [String: Any] = [
+            "type": schema.type.rawValue
+        ]
+        
+        if let description = schema.description {
+            result["description"] = description
+        }
+        
+        if let enumValues = schema.enumValues {
+            result["enum"] = enumValues
+        }
+        
+        return result
+    }
+
+    private func convertFromOllamaResponse(_ response: OllamaChatResponse) throws -> ModelResponse {
+        let content: [AssistantContent] = [.outputText(response.message.content)]
+        
+        // Ollama doesn't provide detailed usage info in the same format
+        let usage = Usage(
+            promptTokens: 0, // Not provided by Ollama
+            completionTokens: 0, // Not provided by Ollama
+            totalTokens: 0, // Not provided by Ollama
+            promptTokensDetails: nil,
+            completionTokensDetails: nil)
+
+        return ModelResponse(
+            id: UUID().uuidString, // Ollama doesn't provide response IDs
+            model: response.model,
+            content: content,
+            usage: usage,
+            flagged: false,
+            finishReason: response.done ? .stop : nil)
+    }
+
+    private func processOllamaChunk(_ chunk: OllamaChatChunk) -> [StreamEvent]? {
+        var events: [StreamEvent] = []
+
+        // First chunk with model info
+        if !chunk.model.isEmpty && events.isEmpty {
+            events.append(.responseStarted(StreamResponseStarted(
+                id: UUID().uuidString,
+                model: chunk.model,
+                systemFingerprint: nil)))
+        }
+
+        // Text content
+        if let content = chunk.message?.content, !content.isEmpty {
+            events.append(.textDelta(StreamTextDelta(delta: content, index: 0)))
+        }
+
+        // Done
+        if chunk.done {
+            events.append(.responseCompleted(StreamResponseCompleted(
+                id: UUID().uuidString,
+                usage: nil,
+                finishReason: .stop)))
+        }
+
+        return events.isEmpty ? nil : events
+    }
+
+    private func handleErrorResponse(data: Data, response: HTTPURLResponse) throws {
+        // Try to decode Ollama error format
+        if let errorText = String(data: data, encoding: .utf8) {
+            let message = errorText.isEmpty ? "HTTP \(response.statusCode)" : errorText
+            
+            switch response.statusCode {
+            case 400:
+                throw TachikomaError.invalidRequest(message)
+            case 404:
+                throw TachikomaError.modelNotFound(self.modelName)
+            case 500...599:
+                throw TachikomaError.modelOverloaded
+            default:
+                throw TachikomaError.apiError(message: message)
+            }
+        } else {
+            throw TachikomaError.apiError(message: "HTTP \(response.statusCode)")
+        }
+    }
+}
+
diff --git a/Sources/Providers/Ollama/OllamaTypes.swift b/Sources/Providers/Ollama/OllamaTypes.swift
new file mode 100644
index 0000000..c64799f
--- /dev/null
+++ b/Sources/Providers/Ollama/OllamaTypes.swift
@@ -0,0 +1,69 @@
+import Foundation
+
+// MARK: - Ollama Request Types
+
+internal struct OllamaChatRequest: Encodable {
+    let model: String
+    let messages: [OllamaMessage]
+    let tools: [OllamaTool]?
+    let stream: Bool
+    let options: OllamaOptions?
+}
+
+internal struct OllamaMessage: Codable {
+    let role: String
+    let content: String
+    let images: [String]?
+}
+
+internal struct OllamaTool: Encodable {
+    let type: String
+    let function: OllamaFunction
+}
+
+internal struct OllamaFunction: Encodable {
+    let name: String
+    let description: String
+    let parameters: [String: Any]
+    
+    enum CodingKeys: String, CodingKey {
+        case name, description, parameters
+    }
+    
+    func encode(to encoder: any Encoder) throws {
+        var container = encoder.container(keyedBy: CodingKeys.self)
+        try container.encode(name, forKey: .name)
+        try container.encode(description, forKey: .description)
+        
+        // Encode parameters as JSON
+        let data = try JSONSerialization.data(withJSONObject: parameters)
+        let jsonString = String(data: data, encoding: .utf8) ?? "{}"
+        try container.encode(jsonString, forKey: .parameters)
+    }
+}
+
+internal struct OllamaOptions: Encodable {
+    let temperature: Double?
+    let topP: Double?
+    let stop: [String]?
+    
+    enum CodingKeys: String, CodingKey {
+        case temperature
+        case topP = "top_p"
+        case stop
+    }
+}
+
+// MARK: - Ollama Response Types
+
+internal struct OllamaChatResponse: Decodable {
+    let model: String
+    let message: OllamaMessage
+    let done: Bool
+}
+
+internal struct OllamaChatChunk: Decodable {
+    let model: String
+    let message: OllamaMessage?
+    let done: Bool
+}
\ No newline at end of file
diff --git a/Sources/Providers/OpenAI/OpenAIModel.swift b/Sources/Providers/OpenAI/OpenAIModel.swift
new file mode 100644
index 0000000..8abd840
--- /dev/null
+++ b/Sources/Providers/OpenAI/OpenAIModel.swift
@@ -0,0 +1,516 @@
+import Foundation
+
+/// OpenAI model implementation conforming to ModelInterface
+@available(macOS 14.0, iOS 17.0, watchOS 10.0, tvOS 17.0, *)
+public final class OpenAIModel: ModelInterface, Sendable {
+    private let apiKey: String
+    private let baseURL: URL
+    private let session: URLSession
+    private let organizationId: String?
+    private let customHeaders: [String: String]?
+    private let customModelName: String?
+
+    public init(
+        apiKey: String,
+        baseURL: URL = URL(string: "https://api.openai.com/v1")!,
+        organizationId: String? = nil,
+        modelName: String? = nil,
+        headers: [String: String]? = nil,
+        session: URLSession? = nil)
+    {
+        self.apiKey = apiKey
+        self.baseURL = baseURL
+        self.organizationId = organizationId
+        self.customHeaders = headers
+        self.customModelName = modelName
+        
+        if let session {
+            self.session = session
+        } else {
+            let config = URLSessionConfiguration.default
+            config.timeoutIntervalForRequest = 600 // 10 minutes for o3 models
+            config.timeoutIntervalForResource = 600
+            self.session = URLSession(configuration: config)
+        }
+    }
+
+    // MARK: - ModelInterface Implementation
+
+    public var maskedApiKey: String {
+        guard self.apiKey.count > 8 else { return "***" }
+        let start = self.apiKey.prefix(6)
+        let end = self.apiKey.suffix(2)
+        return "\(start)...\(end)"
+    }
+
+    public func getResponse(request: ModelRequest) async throws -> ModelResponse {
+        let openAIRequest = try convertToOpenAIRequest(request, stream: false)
+        let endpoint = getEndpointForModel(request.settings.modelName)
+        let urlRequest = try createURLRequest(endpoint: endpoint, body: openAIRequest)
+
+        let (data, response) = try await session.data(for: urlRequest)
+
+        guard let httpResponse = response as? HTTPURLResponse else {
+            throw TachikomaError.networkError(underlying: URLError(.badServerResponse))
+        }
+
+        if httpResponse.statusCode != 200 {
+            try handleErrorResponse(data: data, response: httpResponse)
+        }
+
+        do {
+            let openAIResponse = try JSONDecoder().decode(OpenAIResponse.self, from: data)
+            return try convertFromOpenAIResponse(openAIResponse)
+        } catch {
+            throw TachikomaError.decodingError(underlying: error)
+        }
+    }
+
+    public func getStreamedResponse(request: ModelRequest) async throws -> AsyncThrowingStream<StreamEvent, any Error> {
+        let openAIRequest = try convertToOpenAIRequest(request, stream: true)
+        let endpoint = getEndpointForModel(request.settings.modelName)
+        let urlRequest = try createURLRequest(endpoint: endpoint, body: openAIRequest)
+
+        return AsyncThrowingStream { continuation in
+            Task {
+                do {
+                    let (bytes, response) = try await session.bytes(for: urlRequest)
+
+                    guard let httpResponse = response as? HTTPURLResponse else {
+                        continuation.finish(throwing: TachikomaError.networkError(underlying: URLError(.badServerResponse)))
+                        return
+                    }
+
+                    if httpResponse.statusCode != 200 {
+                        var errorData = Data()
+                        for try await byte in bytes.prefix(1024) {
+                            errorData.append(byte)
+                        }
+                        try self.handleErrorResponse(data: errorData, response: httpResponse)
+                    }
+
+                    // Process SSE stream
+                    for try await line in bytes.lines {
+                        if line.hasPrefix("data: ") {
+                            let data = String(line.dropFirst(6))
+
+                            if data == "[DONE]" {
+                                continuation.finish()
+                                return
+                            }
+
+                            if let chunkData = data.data(using: .utf8),
+                               let chunk = try? JSONDecoder().decode(OpenAIStreamChunk.self, from: chunkData) {
+                                if let events = processStreamChunk(chunk) {
+                                    for event in events {
+                                        continuation.yield(event)
+                                    }
+                                }
+                            }
+                        }
+                    }
+
+                    continuation.finish()
+                } catch {
+                    continuation.finish(throwing: TachikomaError.streamingError(error.localizedDescription))
+                }
+            }
+        }
+    }
+
+    // MARK: - Private Methods
+
+    private func getEndpointForModel(_ modelName: String) -> String {
+        // Use Responses API for o3/o4 models, Chat Completions for others
+        if modelName.hasPrefix("o3") || modelName.hasPrefix("o4") {
+            return "responses"
+        } else {
+            return "chat/completions"
+        }
+    }
+
+    private func createURLRequest(endpoint: String, body: any Encodable) throws -> URLRequest {
+        let url = self.baseURL.appendingPathComponent(endpoint)
+        var request = URLRequest(url: url)
+        request.httpMethod = "POST"
+        request.setValue("Bearer \(self.apiKey)", forHTTPHeaderField: "Authorization")
+        request.setValue("application/json", forHTTPHeaderField: "Content-Type")
+
+        if let orgId = organizationId {
+            request.setValue(orgId, forHTTPHeaderField: "OpenAI-Organization")
+        }
+        
+        customHeaders?.forEach { key, value in
+            request.setValue(value, forHTTPHeaderField: key)
+        }
+
+        let encoder = JSONEncoder()
+        encoder.outputFormatting = .sortedKeys
+
+        do {
+            request.httpBody = try encoder.encode(body)
+        } catch {
+            throw TachikomaError.configurationError("Failed to encode OpenAI request: \(error.localizedDescription)")
+        }
+
+        // Set timeout for different API types
+        if endpoint == "responses" {
+            request.timeoutInterval = 600 // 10 minutes for o3 models
+        } else {
+            request.timeoutInterval = 120 // 2 minutes for other models
+        }
+
+        return request
+    }
+
+    private func convertToOpenAIRequest(_ request: ModelRequest, stream: Bool) throws -> any Encodable {
+        let modelName = customModelName ?? request.settings.modelName
+        
+        if modelName.hasPrefix("o3") || modelName.hasPrefix("o4") {
+            return try convertToResponsesRequest(request, stream: stream)
+        } else {
+            return try convertToChatRequest(request, stream: stream)
+        }
+    }
+
+    private func convertToChatRequest(_ request: ModelRequest, stream: Bool) throws -> OpenAIChatRequest {
+        let messages = try request.messages.map { message -> OpenAIMessage in
+            switch message {
+            case let .system(_, content):
+                return OpenAIMessage(role: "system", content: .string(content))
+            case let .user(_, content):
+                return try convertUserMessage(content)
+            case let .assistant(_, content, _):
+                return try convertAssistantMessage(content)
+            case let .tool(_, toolCallId, content):
+                return OpenAIMessage(role: "tool", content: .string(content), toolCallId: toolCallId)
+            case .reasoning:
+                throw TachikomaError.invalidRequest("Reasoning messages not supported in Chat Completions API")
+            }
+        }
+
+        let tools = request.tools?.map { tool in
+            OpenAITool(
+                type: "function",
+                function: OpenAIFunction(
+                    name: tool.function.name,
+                    description: tool.function.description,
+                    parameters: convertToolParameters(tool.function.parameters)))
+        }
+
+        return OpenAIChatRequest(
+            model: customModelName ?? request.settings.modelName,
+            messages: messages,
+            tools: tools,
+            toolChoice: convertToolChoice(request.settings.toolChoice),
+            temperature: request.settings.temperature,
+            topP: request.settings.topP,
+            stream: stream,
+            maxTokens: request.settings.maxTokens)
+    }
+
+    private func convertToResponsesRequest(_ request: ModelRequest, stream: Bool) throws -> OpenAIResponsesRequest {
+        let messages = try request.messages.compactMap { message -> OpenAIMessage? in
+            switch message {
+            case let .system(_, content):
+                return OpenAIMessage(role: "system", content: .string(content))
+            case let .user(_, content):
+                return try convertUserMessage(content)
+            case let .assistant(_, content, _):
+                return try convertAssistantMessage(content)
+            case let .tool(_, _, content):
+                return OpenAIMessage(role: "user", content: .string(content))
+            case .reasoning:
+                return nil // Skip reasoning messages
+            }
+        }
+
+        let tools = request.tools?.map { tool in
+            OpenAIResponsesTool(
+                type: "function",
+                name: tool.function.name,
+                description: tool.function.description,
+                parameters: convertToolParameters(tool.function.parameters))
+        }
+
+        let modelName = customModelName ?? request.settings.modelName
+        
+        return OpenAIResponsesRequest(
+            model: modelName,
+            input: messages,
+            tools: tools,
+            toolChoice: convertToolChoice(request.settings.toolChoice),
+            temperature: nil, // o3/o4 models don't support temperature
+            topP: request.settings.topP,
+            stream: stream,
+            maxOutputTokens: request.settings.maxTokens ?? 65536,
+            reasoning: (modelName.hasPrefix("o3") || modelName.hasPrefix("o4")) ? 
+                OpenAIReasoning(
+                    effort: request.settings.additionalParameters?.string("reasoning_effort") ?? "medium",
+                    summary: "detailed") : nil)
+    }
+
+    private func convertUserMessage(_ content: MessageContent) throws -> OpenAIMessage {
+        switch content {
+        case let .text(text):
+            return OpenAIMessage(role: "user", content: .string(text))
+        case let .image(imageContent):
+            var parts: [OpenAIMessageContentPart] = []
+            
+            if let url = imageContent.url {
+                parts.append(OpenAIMessageContentPart(
+                    type: "image_url",
+                    text: nil,
+                    imageUrl: OpenAIImageUrl(url: url, detail: imageContent.detail?.rawValue)))
+            } else if let base64 = imageContent.base64 {
+                parts.append(OpenAIMessageContentPart(
+                    type: "image_url", 
+                    text: nil,
+                    imageUrl: OpenAIImageUrl(url: "data:image/jpeg;base64,\(base64)", detail: imageContent.detail?.rawValue)))
+            }
+            
+            return OpenAIMessage(role: "user", content: .array(parts))
+        case let .multimodal(parts):
+            let contentParts = parts.compactMap { part -> OpenAIMessageContentPart? in
+                if let text = part.text {
+                    return OpenAIMessageContentPart(type: "text", text: text, imageUrl: nil)
+                } else if let image = part.imageUrl {
+                    if let url = image.url {
+                        return OpenAIMessageContentPart(
+                            type: "image_url",
+                            text: nil,
+                            imageUrl: OpenAIImageUrl(url: url, detail: image.detail?.rawValue))
+                    } else if let base64 = image.base64 {
+                        return OpenAIMessageContentPart(
+                            type: "image_url",
+                            text: nil,
+                            imageUrl: OpenAIImageUrl(url: "data:image/jpeg;base64,\(base64)", detail: image.detail?.rawValue))
+                    }
+                }
+                return nil
+            }
+            return OpenAIMessage(role: "user", content: .array(contentParts))
+        case .file:
+            throw TachikomaError.invalidRequest("File content not supported in OpenAI API")
+        case let .audio(audioContent):
+            if let transcript = audioContent.transcript {
+                var text = transcript
+                if let duration = audioContent.duration {
+                    text = "[Audio transcript, duration: \(Int(duration))s] \(transcript)"
+                } else {
+                    text = "[Audio transcript] \(transcript)"
+                }
+                return OpenAIMessage(role: "user", content: .string(text))
+            } else {
+                throw TachikomaError.invalidRequest("Audio content must be transcribed before sending to OpenAI")
+            }
+        }
+    }
+
+    private func convertAssistantMessage(_ content: [AssistantContent]) throws -> OpenAIMessage {
+        var textContent = ""
+        var toolCalls: [OpenAIToolCall] = []
+
+        for item in content {
+            switch item {
+            case let .outputText(text):
+                textContent += text
+            case let .refusal(refusal):
+                return OpenAIMessage(role: "assistant", content: .string(refusal))
+            case let .toolCall(toolCall):
+                toolCalls.append(OpenAIToolCall(
+                    id: toolCall.id,
+                    type: "function",
+                    function: OpenAIFunction(
+                        name: toolCall.function.name,
+                        description: nil,
+                        parameters: nil,
+                        arguments: toolCall.function.arguments)))
+            }
+        }
+
+        if !toolCalls.isEmpty {
+            return OpenAIMessage(role: "assistant", content: .string(textContent), toolCalls: toolCalls)
+        } else {
+            return OpenAIMessage(role: "assistant", content: .string(textContent))
+        }
+    }
+
+    private func convertToolParameters(_ params: ToolParameters) -> [String: Any] {
+        var properties: [String: Any] = [:]
+        
+        for (key, schema) in params.properties {
+            properties[key] = convertParameterSchema(schema)
+        }
+        
+        return [
+            "type": params.type,
+            "properties": properties,
+            "required": params.required,
+            "additionalProperties": params.additionalProperties
+        ]
+    }
+
+    private func convertParameterSchema(_ schema: ParameterSchema) -> [String: Any] {
+        var result: [String: Any] = [
+            "type": schema.type.rawValue
+        ]
+        
+        if let description = schema.description {
+            result["description"] = description
+        }
+        
+        if let enumValues = schema.enumValues {
+            result["enum"] = enumValues
+        }
+        
+        if let minimum = schema.minimum {
+            result["minimum"] = minimum
+        }
+        
+        if let maximum = schema.maximum {
+            result["maximum"] = maximum
+        }
+        
+        if let pattern = schema.pattern {
+            result["pattern"] = pattern
+        }
+        
+        if let items = schema.items {
+            result["items"] = convertParameterSchema(items.value)
+        }
+        
+        if let properties = schema.properties {
+            result["properties"] = properties.mapValues { convertParameterSchema($0) }
+        }
+        
+        return result
+    }
+
+    private func convertToolChoice(_ toolChoice: ToolChoice?) -> String? {
+        guard let toolChoice else { return nil }
+
+        switch toolChoice {
+        case .auto:
+            return "auto"
+        case .none:
+            return "none"
+        case .required:
+            return "required"
+        case let .specific(toolName):
+            return toolName
+        }
+    }
+
+    private func convertFromOpenAIResponse(_ response: OpenAIResponse) throws -> ModelResponse {
+        guard let choice = response.choices.first else {
+            throw TachikomaError.apiError(message: "No choices in OpenAI response")
+        }
+
+        var content: [AssistantContent] = []
+
+        if let messageContent = choice.message.content {
+            switch messageContent {
+            case let .string(text):
+                content.append(.outputText(text))
+            case let .array(parts):
+                // Extract text from content parts
+                let text = parts.compactMap { $0.text }.joined()
+                if !text.isEmpty {
+                    content.append(.outputText(text))
+                }
+            }
+        }
+
+        if let toolCalls = choice.message.toolCalls {
+            for toolCall in toolCalls {
+                content.append(.toolCall(ToolCallItem(
+                    id: toolCall.id,
+                    type: .function,
+                    function: FunctionCall(
+                        name: toolCall.function.name,
+                        arguments: toolCall.function.arguments ?? ""))))
+            }
+        }
+
+        let usage = response.usage.map { usage in
+            Usage(
+                promptTokens: usage.promptTokens,
+                completionTokens: usage.completionTokens,
+                totalTokens: usage.totalTokens,
+                promptTokensDetails: nil,
+                completionTokensDetails: nil)
+        }
+
+        return ModelResponse(
+            id: response.id,
+            model: response.model,
+            content: content,
+            usage: usage,
+            flagged: false,
+            finishReason: convertFinishReason(choice.finishReason))
+    }
+
+    private func convertFinishReason(_ reason: String?) -> FinishReason? {
+        guard let reason else { return nil }
+        return FinishReason(rawValue: reason)
+    }
+
+    private func processStreamChunk(_ chunk: OpenAIStreamChunk) -> [StreamEvent]? {
+        var events: [StreamEvent] = []
+
+        if let delta = chunk.choices?.first?.delta {
+            if let content = delta.content {
+                events.append(.textDelta(StreamTextDelta(delta: content, index: 0)))
+            }
+
+            if let toolCalls = delta.toolCalls {
+                for toolCall in toolCalls {
+                    if let id = toolCall.id, let function = toolCall.function {
+                        events.append(.toolCallDelta(StreamToolCallDelta(
+                            id: id,
+                            index: toolCall.index ?? 0,
+                            function: FunctionCallDelta(
+                                name: function.name,
+                                arguments: function.arguments))))
+                    }
+                }
+            }
+        }
+
+        if let finishReason = chunk.choices?.first?.finishReason {
+            events.append(.responseCompleted(StreamResponseCompleted(
+                id: chunk.id ?? "",
+                usage: nil,
+                finishReason: convertFinishReason(finishReason))))
+        }
+
+        return events.isEmpty ? nil : events
+    }
+
+    private func handleErrorResponse(data: Data, response: HTTPURLResponse) throws {
+        if let errorResponse = try? JSONDecoder().decode(OpenAIErrorResponse.self, from: data) {
+            let message = errorResponse.error.message
+            let code = errorResponse.error.code
+            
+            switch response.statusCode {
+            case 401:
+                throw TachikomaError.authenticationFailed
+            case 429:
+                throw TachikomaError.rateLimited
+            case 400:
+                if message.contains("context_length_exceeded") {
+                    throw TachikomaError.contextLengthExceeded
+                } else {
+                    throw TachikomaError.invalidRequest(message)
+                }
+            case 500...599:
+                throw TachikomaError.modelOverloaded
+            default:
+                throw TachikomaError.apiError(message: message, code: code)
+            }
+        } else {
+            throw TachikomaError.apiError(message: "HTTP \(response.statusCode)", code: "\(response.statusCode)")
+        }
+    }
+}
\ No newline at end of file
diff --git a/Sources/Providers/OpenAI/OpenAITypes.swift b/Sources/Providers/OpenAI/OpenAITypes.swift
new file mode 100644
index 0000000..d44ecf6
--- /dev/null
+++ b/Sources/Providers/OpenAI/OpenAITypes.swift
@@ -0,0 +1,481 @@
+import Foundation
+
+// MARK: - Helper Types
+
+/// Sendable wrapper for Any values
+@available(macOS 14.0, iOS 17.0, watchOS 10.0, tvOS 17.0, *)
+public struct AnySendable: Codable, @unchecked Sendable {
+    public let value: Any
+    
+    public init(_ value: Any) {
+        self.value = value
+    }
+    
+    public init(from decoder: any Decoder) throws {
+        let container = try decoder.singleValueContainer()
+        
+        if let intValue = try? container.decode(Int.self) {
+            self.value = intValue
+        } else if let doubleValue = try? container.decode(Double.self) {
+            self.value = doubleValue
+        } else if let boolValue = try? container.decode(Bool.self) {
+            self.value = boolValue
+        } else if let stringValue = try? container.decode(String.self) {
+            self.value = stringValue
+        } else if let arrayValue = try? container.decode([AnySendable].self) {
+            self.value = arrayValue.map(\.value)
+        } else if let dictValue = try? container.decode([String: AnySendable].self) {
+            self.value = dictValue.mapValues(\.value)
+        } else {
+            self.value = NSNull()
+        }
+    }
+    
+    public func encode(to encoder: any Encoder) throws {
+        var container = encoder.singleValueContainer()
+        
+        switch value {
+        case let intValue as Int:
+            try container.encode(intValue)
+        case let doubleValue as Double:
+            try container.encode(doubleValue)
+        case let boolValue as Bool:
+            try container.encode(boolValue)
+        case let stringValue as String:
+            try container.encode(stringValue)
+        case let arrayValue as [Any]:
+            try container.encode(arrayValue.map { AnySendable($0) })
+        case let dictValue as [String: Any]:
+            try container.encode(dictValue.mapValues { AnySendable($0) })
+        default:
+            try container.encodeNil()
+        }
+    }
+}
+
+// MARK: - OpenAI API Request Types
+
+/// Chat Completions API request format
+@available(macOS 14.0, iOS 17.0, watchOS 10.0, tvOS 17.0, *)
+public struct OpenAIChatRequest: Codable, Sendable {
+    public let model: String
+    public let messages: [OpenAIMessage]
+    public let tools: [OpenAITool]?
+    public let toolChoice: String?
+    public let temperature: Double?
+    public let topP: Double?
+    public let stream: Bool?
+    public let maxTokens: Int?
+
+    enum CodingKeys: String, CodingKey {
+        case model, messages, tools, temperature, stream
+        case toolChoice = "tool_choice"
+        case topP = "top_p"
+        case maxTokens = "max_tokens"
+    }
+}
+
+/// Responses API request format (for o3/o4 models)
+@available(macOS 14.0, iOS 17.0, watchOS 10.0, tvOS 17.0, *)
+public struct OpenAIResponsesRequest: Codable, Sendable {
+    public let model: String
+    public let input: [OpenAIMessage]
+    public let tools: [OpenAIResponsesTool]?
+    public let toolChoice: String?
+    public let temperature: Double?
+    public let topP: Double?
+    public let stream: Bool?
+    public let maxOutputTokens: Int?
+    public let reasoning: OpenAIReasoning?
+
+    enum CodingKeys: String, CodingKey {
+        case model, input, tools, temperature, stream, reasoning
+        case toolChoice = "tool_choice"
+        case topP = "top_p"
+        case maxOutputTokens = "max_output_tokens"
+    }
+}
+
+/// OpenAI message format
+@available(macOS 14.0, iOS 17.0, watchOS 10.0, tvOS 17.0, *)
+public struct OpenAIMessage: Codable, Sendable {
+    public let role: String
+    public let content: MessageContent?
+    public let toolCalls: [OpenAIToolCall]?
+    public let toolCallId: String?
+
+    public enum MessageContent: Codable, Sendable {
+        case string(String)
+        case array([OpenAIMessageContentPart])
+
+        public init(from decoder: any Decoder) throws {
+            let container = try decoder.singleValueContainer()
+            if let stringValue = try? container.decode(String.self) {
+                self = .string(stringValue)
+            } else if let arrayValue = try? container.decode([OpenAIMessageContentPart].self) {
+                self = .array(arrayValue)
+            } else {
+                throw DecodingError.dataCorruptedError(in: container, debugDescription: "Unable to decode message content")
+            }
+        }
+
+        public func encode(to encoder: any Encoder) throws {
+            var container = encoder.singleValueContainer()
+            switch self {
+            case let .string(value):
+                try container.encode(value)
+            case let .array(value):
+                try container.encode(value)
+            }
+        }
+    }
+
+    enum CodingKeys: String, CodingKey {
+        case role, content
+        case toolCalls = "tool_calls"
+        case toolCallId = "tool_call_id"
+    }
+
+    public init(role: String, content: MessageContent? = nil, toolCalls: [OpenAIToolCall]? = nil, toolCallId: String? = nil) {
+        self.role = role
+        self.content = content
+        self.toolCalls = toolCalls
+        self.toolCallId = toolCallId
+    }
+}
+
+/// OpenAI message content part for multimodal messages
+@available(macOS 14.0, iOS 17.0, watchOS 10.0, tvOS 17.0, *)
+public struct OpenAIMessageContentPart: Codable, Sendable {
+    public let type: String
+    public let text: String?
+    public let imageUrl: OpenAIImageUrl?
+
+    enum CodingKeys: String, CodingKey {
+        case type, text
+        case imageUrl = "image_url"
+    }
+
+    public init(type: String, text: String? = nil, imageUrl: OpenAIImageUrl? = nil) {
+        self.type = type
+        self.text = text
+        self.imageUrl = imageUrl
+    }
+}
+
+/// OpenAI image URL format
+@available(macOS 14.0, iOS 17.0, watchOS 10.0, tvOS 17.0, *)
+public struct OpenAIImageUrl: Codable, Sendable {
+    public let url: String
+    public let detail: String?
+
+    public init(url: String, detail: String? = nil) {
+        self.url = url
+        self.detail = detail
+    }
+}
+
+/// OpenAI tool definition for Chat Completions API
+@available(macOS 14.0, iOS 17.0, watchOS 10.0, tvOS 17.0, *)
+public struct OpenAITool: Codable, Sendable {
+    public let type: String
+    public let function: OpenAIFunction
+
+    public init(type: String, function: OpenAIFunction) {
+        self.type = type
+        self.function = function
+    }
+}
+
+/// OpenAI tool definition for Responses API
+@available(macOS 14.0, iOS 17.0, watchOS 10.0, tvOS 17.0, *)
+public struct OpenAIResponsesTool: Codable, Sendable {
+    public let type: String
+    public let name: String
+    public let description: String
+    public let parameters: [String: AnySendable]
+
+    enum CodingKeys: String, CodingKey {
+        case type, name, description, parameters
+    }
+
+    public init(type: String, name: String, description: String, parameters: [String: Any]) {
+        self.type = type
+        self.name = name
+        self.description = description
+        self.parameters = parameters.mapValues { AnySendable($0) }
+    }
+
+    public init(from decoder: any Decoder) throws {
+        let container = try decoder.container(keyedBy: CodingKeys.self)
+        self.type = try container.decode(String.self, forKey: .type)
+        self.name = try container.decode(String.self, forKey: .name)
+        self.description = try container.decode(String.self, forKey: .description)
+        
+        // Decode parameters as generic JSON
+        let parametersContainer = try container.nestedContainer(keyedBy: AnyCodingKey.self, forKey: .parameters)
+        var parameters: [String: AnySendable] = [:]
+        for key in parametersContainer.allKeys {
+            parameters[key.stringValue] = try parametersContainer.decode(AnySendable.self, forKey: key)
+        }
+        self.parameters = parameters
+    }
+
+    public func encode(to encoder: any Encoder) throws {
+        var container = encoder.container(keyedBy: CodingKeys.self)
+        try container.encode(type, forKey: .type)
+        try container.encode(name, forKey: .name)
+        try container.encode(description, forKey: .description)
+        
+        // Skip encoding parameters for now - this needs to be handled at runtime
+        try container.encodeIfPresent(nil as String?, forKey: .parameters)
+    }
+}
+
+/// OpenAI function definition
+@available(macOS 14.0, iOS 17.0, watchOS 10.0, tvOS 17.0, *)
+public struct OpenAIFunction: Codable, Sendable {
+    public let name: String
+    public let description: String?
+    public let parameters: [String: AnySendable]?
+    public let arguments: String?
+
+    enum CodingKeys: String, CodingKey {
+        case name, description, parameters, arguments
+    }
+
+    public init(name: String, description: String? = nil, parameters: [String: Any]? = nil, arguments: String? = nil) {
+        self.name = name
+        self.description = description
+        self.parameters = parameters?.mapValues { AnySendable($0) }
+        self.arguments = arguments
+    }
+
+    public init(from decoder: any Decoder) throws {
+        let container = try decoder.container(keyedBy: CodingKeys.self)
+        self.name = try container.decode(String.self, forKey: .name)
+        self.description = try container.decodeIfPresent(String.self, forKey: .description)
+        self.arguments = try container.decodeIfPresent(String.self, forKey: .arguments)
+        
+        if container.contains(.parameters) {
+            let parametersContainer = try container.nestedContainer(keyedBy: AnyCodingKey.self, forKey: .parameters)
+            var parameters: [String: AnySendable] = [:]
+            for key in parametersContainer.allKeys {
+                parameters[key.stringValue] = try parametersContainer.decode(AnySendable.self, forKey: key)
+            }
+            self.parameters = parameters
+        } else {
+            self.parameters = nil
+        }
+    }
+
+    public func encode(to encoder: any Encoder) throws {
+        var container = encoder.container(keyedBy: CodingKeys.self)
+        try container.encode(name, forKey: .name)
+        try container.encodeIfPresent(description, forKey: .description)
+        try container.encodeIfPresent(arguments, forKey: .arguments)
+        
+        if let parameters = parameters {
+            // Convert AnySendable parameters to AnyCodable for encoding
+            let codableParams = parameters.mapValues { AnyCodable($0.value) }
+            try container.encode(codableParams, forKey: .parameters)
+        }
+    }
+}
+
+/// OpenAI tool call
+@available(macOS 14.0, iOS 17.0, watchOS 10.0, tvOS 17.0, *)
+public struct OpenAIToolCall: Codable, Sendable {
+    public let id: String
+    public let type: String
+    public let function: OpenAIFunction
+
+    public init(id: String, type: String, function: OpenAIFunction) {
+        self.id = id
+        self.type = type
+        self.function = function
+    }
+}
+
+/// OpenAI reasoning configuration for o3/o4 models
+@available(macOS 14.0, iOS 17.0, watchOS 10.0, tvOS 17.0, *)
+public struct OpenAIReasoning: Codable, Sendable {
+    public let effort: String
+    public let summary: String
+
+    public init(effort: String, summary: String) {
+        self.effort = effort
+        self.summary = summary
+    }
+}
+
+// MARK: - OpenAI Response Types
+
+/// OpenAI Chat Completions response
+@available(macOS 14.0, iOS 17.0, watchOS 10.0, tvOS 17.0, *)
+public struct OpenAIResponse: Codable, Sendable {
+    public let id: String
+    public let model: String
+    public let choices: [OpenAIChoice]
+    public let usage: OpenAIUsage?
+}
+
+/// OpenAI response choice
+@available(macOS 14.0, iOS 17.0, watchOS 10.0, tvOS 17.0, *)
+public struct OpenAIChoice: Codable, Sendable {
+    public let message: OpenAIMessage
+    public let finishReason: String?
+
+    enum CodingKeys: String, CodingKey {
+        case message
+        case finishReason = "finish_reason"
+    }
+}
+
+/// OpenAI usage information
+@available(macOS 14.0, iOS 17.0, watchOS 10.0, tvOS 17.0, *)
+public struct OpenAIUsage: Codable, Sendable {
+    public let promptTokens: Int
+    public let completionTokens: Int
+    public let totalTokens: Int
+
+    enum CodingKeys: String, CodingKey {
+        case promptTokens = "prompt_tokens"
+        case completionTokens = "completion_tokens"
+        case totalTokens = "total_tokens"
+    }
+}
+
+// MARK: - OpenAI Streaming Types
+
+/// OpenAI streaming chunk
+@available(macOS 14.0, iOS 17.0, watchOS 10.0, tvOS 17.0, *)
+public struct OpenAIStreamChunk: Codable, Sendable {
+    public let id: String?
+    public let model: String?
+    public let choices: [OpenAIStreamChoice]?
+}
+
+/// OpenAI streaming choice
+@available(macOS 14.0, iOS 17.0, watchOS 10.0, tvOS 17.0, *)
+public struct OpenAIStreamChoice: Codable, Sendable {
+    public let delta: OpenAIStreamDelta?
+    public let finishReason: String?
+
+    enum CodingKeys: String, CodingKey {
+        case delta
+        case finishReason = "finish_reason"
+    }
+}
+
+/// OpenAI streaming delta
+@available(macOS 14.0, iOS 17.0, watchOS 10.0, tvOS 17.0, *)
+public struct OpenAIStreamDelta: Codable, Sendable {
+    public let content: String?
+    public let toolCalls: [OpenAIStreamToolCall]?
+
+    enum CodingKeys: String, CodingKey {
+        case content
+        case toolCalls = "tool_calls"
+    }
+}
+
+/// OpenAI streaming tool call
+@available(macOS 14.0, iOS 17.0, watchOS 10.0, tvOS 17.0, *)
+public struct OpenAIStreamToolCall: Codable, Sendable {
+    public let id: String?
+    public let type: String?
+    public let index: Int?
+    public let function: OpenAIStreamFunction?
+}
+
+/// OpenAI streaming function
+@available(macOS 14.0, iOS 17.0, watchOS 10.0, tvOS 17.0, *)
+public struct OpenAIStreamFunction: Codable, Sendable {
+    public let name: String?
+    public let arguments: String?
+}
+
+// MARK: - Error Types
+
+/// OpenAI error response
+@available(macOS 14.0, iOS 17.0, watchOS 10.0, tvOS 17.0, *)
+public struct OpenAIErrorResponse: Codable, Sendable {
+    public let error: OpenAIError
+}
+
+/// OpenAI error details
+@available(macOS 14.0, iOS 17.0, watchOS 10.0, tvOS 17.0, *)
+public struct OpenAIError: Codable, Sendable {
+    public let message: String
+    public let type: String?
+    public let code: String?
+}
+
+// MARK: - Helper Types
+
+/// Dynamic coding key for JSON encoding/decoding
+@available(macOS 14.0, iOS 17.0, watchOS 10.0, tvOS 17.0, *)
+struct AnyCodingKey: CodingKey {
+    var stringValue: String
+    var intValue: Int?
+
+    init?(stringValue: String) {
+        self.stringValue = stringValue
+        self.intValue = nil
+    }
+
+    init?(intValue: Int) {
+        self.stringValue = "\(intValue)"
+        self.intValue = intValue
+    }
+}
+
+/// Wrapper for any codable value
+@available(macOS 14.0, iOS 17.0, watchOS 10.0, tvOS 17.0, *)
+public struct AnyCodable: Codable, @unchecked Sendable {
+    public let value: Any
+    
+    public init(_ value: Any) {
+        self.value = value
+    }
+    
+    public func encode(to encoder: any Encoder) throws {
+        var container = encoder.singleValueContainer()
+        
+        if let intValue = value as? Int {
+            try container.encode(intValue)
+        } else if let doubleValue = value as? Double {
+            try container.encode(doubleValue)
+        } else if let stringValue = value as? String {
+            try container.encode(stringValue)
+        } else if let boolValue = value as? Bool {
+            try container.encode(boolValue)
+        } else {
+            let data = try JSONSerialization.data(withJSONObject: value)
+            let str = String(data: data, encoding: .utf8) ?? "{}"
+            try container.encode(str)
+        }
+    }
+    
+    public init(from decoder: any Decoder) throws {
+        let container = try decoder.singleValueContainer()
+        
+        if let intValue = try? container.decode(Int.self) {
+            value = intValue
+        } else if let doubleValue = try? container.decode(Double.self) {
+            value = doubleValue
+        } else if let stringValue = try? container.decode(String.self) {
+            value = stringValue
+        } else if let boolValue = try? container.decode(Bool.self) {
+            value = boolValue
+        } else {
+            value = NSNull()
+        }
+    }
+}
+
+// MARK: - Container Extensions
+
+// Note: Complex Any encoding/decoding extensions removed
+// We use AnySendable for type-safe handling of dynamic JSON data
\ No newline at end of file
diff --git a/Sources/Tachikoma.swift b/Sources/Tachikoma.swift
new file mode 100644
index 0000000..5d00166
--- /dev/null
+++ b/Sources/Tachikoma.swift
@@ -0,0 +1,87 @@
+import Foundation
+@_exported import Logging
+
+/// Tachikoma - A comprehensive Swift package for AI model integration
+///
+/// Tachikoma provides a unified interface for connecting to various AI providers
+/// including OpenAI, Anthropic, Grok (xAI), Ollama, and custom endpoints.
+/// It supports both streaming and non-streaming responses, tool calling,
+/// multimodal inputs, and configuration management.
+///
+/// Named after the AI entity from Ghost in the Shell, Tachikoma embodies
+/// the cyberpunk aesthetic of autonomous AI systems.
+@available(macOS 14.0, iOS 17.0, watchOS 10.0, tvOS 17.0, *)
+public final class Tachikoma: @unchecked Sendable {
+    public static let shared = Tachikoma()
+    
+    private let logger: Logger
+    
+    private init() {
+        self.logger = Logger(label: "build.tachikoma")
+    }
+    
+    /// Get the shared logger instance
+    public var log: Logger {
+        logger
+    }
+    
+    /// Get a model instance for the specified model name
+    /// - Parameter modelName: The model identifier (e.g., "gpt-4.1", "claude-opus-4", "provider-id/model-name")
+    /// - Returns: A model instance conforming to ModelInterface
+    /// - Throws: TachikomaError if the model is not available or configuration is invalid
+    public func getModel(_ modelName: String) async throws -> any ModelInterface {
+        return try await ModelProvider.shared.getModel(modelName: modelName)
+    }
+    
+    /// Configure OpenAI provider with specific settings
+    /// - Parameter configuration: OpenAI configuration
+    public func configureOpenAI(_ configuration: ProviderConfiguration.OpenAI) async {
+        await ModelProvider.shared.configureOpenAI(configuration)
+    }
+    
+    /// Configure Anthropic provider with specific settings
+    /// - Parameter configuration: Anthropic configuration
+    public func configureAnthropic(_ configuration: ProviderConfiguration.Anthropic) async {
+        await ModelProvider.shared.configureAnthropic(configuration)
+    }
+    
+    /// Configure Ollama provider with specific settings
+    /// - Parameter configuration: Ollama configuration
+    public func configureOllama(_ configuration: ProviderConfiguration.Ollama) async {
+        await ModelProvider.shared.configureOllama(configuration)
+    }
+    
+    /// Configure Grok provider with specific settings
+    /// - Parameter configuration: Grok configuration
+    public func configureGrok(_ configuration: ProviderConfiguration.Grok) async {
+        await ModelProvider.shared.configureGrok(configuration)
+    }
+    
+    /// Set up all providers from environment variables
+    /// - Throws: TachikomaError if setup fails
+    public func setupFromEnvironment() async throws {
+        try await ModelProvider.shared.setupFromEnvironment()
+    }
+    
+    /// List all available models from configured providers
+    /// - Returns: Array of available model identifiers
+    public func availableModels() async -> [String] {
+        return await ModelProvider.shared.listModels()
+    }
+    
+    /// Clear all cached model instances
+    public func clearModelCache() async {
+        await ModelProvider.shared.clearCache()
+    }
+    
+    /// Register a custom model factory
+    /// - Parameters:
+    ///   - modelName: The model name to register
+    ///   - factory: Factory closure that creates the model instance
+    public func registerModel(
+        name modelName: String,
+        factory: @escaping @Sendable () throws -> any ModelInterface) async
+    {
+        await ModelProvider.shared.register(modelName: modelName, factory: factory)
+    }
+}
\ No newline at end of file
diff --git a/Tests/TachikomaTests/AnthropicModelTests.swift b/Tests/TachikomaTests/AnthropicModelTests.swift
new file mode 100644
index 0000000..8c34cd7
--- /dev/null
+++ b/Tests/TachikomaTests/AnthropicModelTests.swift
@@ -0,0 +1,373 @@
+import Foundation
+import Testing
+@testable import Tachikoma
+
+@Suite("Anthropic Model Tests")
+struct AnthropicModelTests {
+    @Test("Model initialization")
+    func modelInitialization() async throws {
+        let model = AnthropicModel(
+            apiKey: "sk-ant-test-key-123456789",
+            modelName: "claude-opus-4-20250514")
+
+        #expect(model.maskedApiKey == "sk-ant...789")
+    }
+
+    @Test("API key masking")
+    func apiKeyMasking() async throws {
+        // Test short key
+        let shortModel = AnthropicModel(apiKey: "short")
+        #expect(shortModel.maskedApiKey == "***")
+
+        // Test normal key
+        let normalModel = AnthropicModel(apiKey: "sk-ant-api-key-1234567890abcdefghijklmnopqrstuvwxyz")
+        #expect(normalModel.maskedApiKey == "sk-ant...xyz")
+    }
+
+    @Test("System message extraction")
+    func systemMessageExtraction() async throws {
+        let model = AnthropicModel(apiKey: "test-key")
+
+        let request = ModelRequest(
+            messages: [
+                Message.system(content: "You are a helpful assistant."),
+                Message.user(content: .text("Hello!")),
+            ],
+            tools: nil,
+            settings: ModelSettings(modelName: "claude-opus-4-20250514"))
+
+        // System messages should be properly handled
+        #expect(request.messages.first?.type == .system)
+    }
+
+    @Test("Tool conversion")
+    func toolConversion() async throws {
+        let model = AnthropicModel(apiKey: "test-key")
+
+        let toolDef = ToolDefinition(
+            function: FunctionDefinition(
+                name: "get_weather",
+                description: "Get the current weather",
+                parameters: ToolParameters(
+                    properties: ["location": ParameterSchema(type: .string, description: "The location")],
+                    required: ["location"])))
+
+        let request = ModelRequest(
+            messages: [
+                Message.user(content: .text("What's the weather?")),
+            ],
+            tools: [toolDef],
+            settings: ModelSettings(modelName: "claude-opus-4-20250514"))
+
+        #expect(request.tools?.count == 1)
+        #expect(request.tools?.first?.function.name == "get_weather")
+
+        // Test that the model can process the request (will fail at network level)
+        do {
+            _ = try await model.getResponse(request: request)
+            Issue.record("Expected network error but got success")
+        } catch {
+            #expect(error is TachikomaError)
+        }
+    }
+
+    @Test("Image content handling")
+    func imageContentHandling() async throws {
+        let model = AnthropicModel(apiKey: "test-key", modelName: "claude-opus-4-20250514")
+
+        let imageData = "iVBORw0KGgoAAAANSUhEUgAAAAEAAAABCAYAAAAfFcSJAAAADUlEQVR42mNkYPhfDwAChwGA60e6kgAAAABJRU5ErkJggg=="
+
+        let request = ModelRequest(
+            messages: [
+                Message.user(content: .multimodal([
+                    MessageContentPart(type: "text", text: "What's in this image?"),
+                    MessageContentPart(type: "image", imageUrl: ImageContent(base64: imageData)),
+                ])),
+            ],
+            tools: nil,
+            settings: ModelSettings(modelName: "claude-opus-4-20250514"))
+
+        if case let .user(_, content) = request.messages.first,
+           case let .multimodal(parts) = content
+        {
+            #expect(parts.count == 2)
+        } else {
+            Issue.record("Expected multimodal content")
+        }
+
+        // Test that URL images are supported
+        let urlRequest = ModelRequest(
+            messages: [
+                Message.user(content: .image(ImageContent(url: "https://example.com/image.jpg"))),
+            ],
+            tools: nil,
+            settings: ModelSettings(modelName: "claude-opus-4-20250514"))
+
+        if case let .user(_, content) = urlRequest.messages.first,
+           case .image = content
+        {
+            // Expected image content
+        } else {
+            Issue.record("Expected image content")
+        }
+
+        // Test processing (will fail at network level)
+        do {
+            _ = try await model.getResponse(request: request)
+            Issue.record("Expected network error")
+        } catch {
+            #expect(error is TachikomaError)
+        }
+    }
+
+    @Test("Message type conversion")
+    func messageTypeConversion() async throws {
+        let model = AnthropicModel(apiKey: "test-key")
+
+        // Test various message types
+        let messages: [Message] = [
+            Message.system(content: "You are Claude."),
+            Message.user(content: .text("Hello Claude!")),
+            Message.assistant(content: [.outputText("Hello! How can I help you?")]),
+            Message.user(content: .text("What's 2+2?")),
+            Message.assistant(content: [.outputText("2 + 2 = 4")]),
+        ]
+
+        let request = ModelRequest(
+            messages: messages,
+            tools: nil,
+            settings: ModelSettings(modelName: "claude-opus-4-20250514"))
+
+        // Verify message structure
+        #expect(request.messages.count == 5)
+        #expect(request.messages[0].type == .system)
+        #expect(request.messages[1].type == .user)
+        #expect(request.messages[2].type == .assistant)
+
+        // Test processing (will fail at network level)
+        do {
+            _ = try await model.getResponse(request: request)
+            Issue.record("Expected network error")
+        } catch {
+            #expect(error is TachikomaError)
+        }
+    }
+
+    @Test("Streaming response handling")
+    func streamingResponseHandling() async throws {
+        let model = AnthropicModel(apiKey: "test-key")
+
+        let request = ModelRequest(
+            messages: [
+                Message.user(content: .text("Write a short poem")),
+            ],
+            tools: nil,
+            settings: ModelSettings(modelName: "claude-opus-4-20250514"))
+
+        // Test streaming (will fail at network level)
+        do {
+            let stream = try await model.getStreamedResponse(request: request)
+            var eventCount = 0
+
+            for try await event in stream {
+                eventCount += 1
+                _ = event
+            }
+
+            Issue.record("Expected network error but got \(eventCount) events")
+        } catch {
+            #expect(error is TachikomaError)
+        }
+    }
+
+    @Test("Tool call handling")
+    func toolCallHandling() async throws {
+        let model = AnthropicModel(apiKey: "test-key")
+
+        // Create a tool call message
+        let toolCall = ToolCallItem(
+            id: "call_123",
+            type: .function,
+            function: FunctionCall(
+                name: "get_weather",
+                arguments: "{\"location\": \"Paris\"}"
+            )
+        )
+
+        let messages: [Message] = [
+            Message.user(content: .text("What's the weather in Paris?")),
+            Message.assistant(content: [.toolCall(toolCall)]),
+            Message.tool(toolCallId: "call_123", content: "It's sunny, 22°C"),
+        ]
+
+        let request = ModelRequest(
+            messages: messages,
+            tools: nil,
+            settings: ModelSettings(modelName: "claude-opus-4-20250514"))
+
+        // Test tool call processing (will fail at network level)
+        do {
+            _ = try await model.getResponse(request: request)
+            Issue.record("Expected network error")
+        } catch {
+            #expect(error is TachikomaError)
+        }
+    }
+
+    @Test("Model variants")
+    func modelVariants() async throws {
+        let modelNames = [
+            "claude-opus-4-20250514",
+            "claude-sonnet-4-20250514",
+            "claude-opus-4-20250514-thinking",
+            "claude-sonnet-4-20250514-thinking",
+            "claude-3-7-sonnet",
+            "claude-3-5-sonnet",
+            "claude-3-5-haiku",
+        ]
+
+        for modelName in modelNames {
+            let model = AnthropicModel(apiKey: "test-key", modelName: modelName)
+            #expect(model.maskedApiKey == "***")
+
+            // Test that each model variant can be created and handles requests
+            let request = ModelRequest(
+                messages: [Message.user(content: .text("Test"))],
+                settings: ModelSettings(modelName: "claude-opus-4-20250514"))
+
+            do {
+                _ = try await model.getResponse(request: request)
+                Issue.record("Expected network error for \(modelName)")
+            } catch {
+                #expect(error is TachikomaError)
+            }
+        }
+    }
+
+    @Test("Error handling")
+    func errorHandling() async throws {
+        let model = AnthropicModel(apiKey: "invalid-key")
+
+        let request = ModelRequest(
+            messages: [
+                Message.user(content: .text("Test")),
+            ],
+            tools: nil,
+            settings: ModelSettings(modelName: "claude-opus-4-20250514"))
+
+        do {
+            _ = try await model.getResponse(request: request)
+            Issue.record("Expected error but got success")
+        } catch let error as TachikomaError {
+            // Verify we get appropriate error types
+            switch error {
+            case .apiError, .authenticationFailed, .networkError:
+                // Expected error types for invalid API key
+                break
+            default:
+                Issue.record("Unexpected error type: \(error)")
+            }
+        } catch {
+            Issue.record("Unexpected error type: \(type(of: error))")
+        }
+    }
+
+    @Test("Audio content handling")
+    func audioContentHandling() async throws {
+        let model = AnthropicModel(apiKey: "test-key")
+
+        let audioContent = AudioContent(
+            transcript: "Hello, this is a test transcript.",
+            duration: 5.0
+        )
+
+        let request = ModelRequest(
+            messages: [
+                Message.user(content: .audio(audioContent)),
+            ],
+            settings: ModelSettings(modelName: "claude-opus-4-20250514"))
+
+        // Test audio content processing
+        do {
+            _ = try await model.getResponse(request: request)
+            Issue.record("Expected network error")
+        } catch {
+            #expect(error is TachikomaError)
+        }
+    }
+
+    @Test("File content rejection")
+    func fileContentRejection() async throws {
+        let model = AnthropicModel(apiKey: "test-key")
+
+        let fileContent = FileContent(
+            id: nil,
+            url: nil,
+            name: "test.txt"
+        )
+
+        let request = ModelRequest(
+            messages: [
+                Message.user(content: .file(fileContent)),
+            ],
+            settings: ModelSettings(modelName: "claude-opus-4-20250514"))
+
+        // File content should be rejected
+        do {
+            _ = try await model.getResponse(request: request)
+            Issue.record("Expected error for file content")
+        } catch let error as TachikomaError {
+            switch error {
+            case .invalidRequest:
+                // Expected - file content not supported
+                break
+            default:
+                Issue.record("Expected invalidRequest error, got: \(error)")
+            }
+        }
+    }
+}
+
+// MARK: - Provider Configuration Tests
+
+@Suite("Anthropic Provider Configuration Tests")
+struct AnthropicProviderConfigurationTests {
+    @Test("Provider configuration")
+    func providerConfiguration() async throws {
+        let tachikoma = Tachikoma.shared
+
+        // Test custom Anthropic configuration
+        let config = ProviderConfiguration.Anthropic(
+            apiKey: "test-key",
+            baseURL: URL(string: "https://api.anthropic.com/v1")!
+        )
+
+        await tachikoma.configureAnthropic(config)
+    }
+
+    @Test("Model registration")
+    func modelRegistration() async throws {
+        let tachikoma = Tachikoma.shared
+
+        // Register Claude models
+        let modelNames = [
+            "claude-opus-4",
+            "claude-sonnet-4",
+            "claude-3-5-sonnet",
+            "claude-3-5-haiku",
+        ]
+
+        for modelName in modelNames {
+            await tachikoma.registerModel(name: modelName, factory: {
+                AnthropicModel(apiKey: "test-key", modelName: modelName)
+            })
+
+            do {
+                let model = try await tachikoma.getModel(modelName)
+                #expect(model is AnthropicModel)
+            } catch {
+                Issue.record("Failed to get model \(modelName): \(error)")
+            }
+        }
+    }
+}
\ No newline at end of file
diff --git a/Tests/TachikomaTests/GrokModelTests.swift b/Tests/TachikomaTests/GrokModelTests.swift
new file mode 100644
index 0000000..47f2f96
--- /dev/null
+++ b/Tests/TachikomaTests/GrokModelTests.swift
@@ -0,0 +1,331 @@
+import Foundation
+import Testing
+@testable import Tachikoma
+
+@Suite("Grok Model Tests")
+struct GrokModelTests {
+    @Test("Model initialization")
+    func modelInitialization() async throws {
+        let model = GrokModel(
+            apiKey: "test-key-123456",
+            baseURL: URL(string: "https://api.x.ai/v1")!)
+
+        #expect(model.maskedApiKey == "test-k...56")
+    }
+
+    @Test("API key masking")
+    func apiKeyMasking() async throws {
+        // Test short key
+        let shortModel = GrokModel(apiKey: "short")
+        #expect(shortModel.maskedApiKey == "***")
+
+        // Test normal key
+        let normalModel = GrokModel(apiKey: "test-api-key-1234567890abcdefghijklmnopqrstuvwxyz")
+        #expect(normalModel.maskedApiKey == "test-a...yz")
+    }
+
+    @Test("Default base URL")
+    func defaultBaseURL() async throws {
+        let model = GrokModel(apiKey: "test-key-123456")
+
+        // Verify it uses the correct xAI API endpoint
+        // We can't directly access baseURL, but we can test the behavior
+        #expect(model.maskedApiKey == "test-k...56")
+    }
+
+    @Test("Parameter filtering for Grok 4")
+    func grok4ParameterFiltering() async throws {
+        let model = GrokModel(apiKey: "test-key")
+
+        // Create a request with parameters that should be filtered for Grok 4
+        let settings = ModelSettings(
+            modelName: "grok-4",
+            temperature: 0.7,
+            frequencyPenalty: 0.5, // Should be removed for grok-4
+            presencePenalty: 0.5, // Should be removed for grok-4
+            stopSequences: ["stop"] // Should be removed for grok-4
+        )
+
+        let request = ModelRequest(
+            messages: [
+                Message.system(content: "Test system message"),
+                Message.user(content: .text("Test user message")),
+            ],
+            tools: nil,
+            settings: settings)
+
+        // We can't directly test the filtering without mocking the network request
+        // But we can verify the model handles the request without crashing
+        do {
+            _ = try await model.getResponse(request: request)
+            Issue.record("Expected network error but got success")
+        } catch {
+            // Expected to fail due to no valid API key/network
+            #expect(error is TachikomaError)
+        }
+    }
+
+    @Test("Tool parameter conversion")
+    func toolParameterConversion() async throws {
+        let model = GrokModel(apiKey: "test-key")
+
+        // Create a tool definition
+        let tool = ToolDefinition(
+            function: FunctionDefinition(
+                name: "test_tool",
+                description: "A test tool",
+                parameters: ToolParameters(
+                    type: "object",
+                    properties: [
+                        "message": ParameterSchema(
+                            type: .string,
+                            description: "A test message"),
+                        "count": ParameterSchema(
+                            type: .integer,
+                            description: "A count",
+                            minimum: 0,
+                            maximum: 100),
+                    ],
+                    required: ["message"])))
+
+        let request = ModelRequest(
+            messages: [
+                Message.user(content: .text("Use the test tool")),
+            ],
+            tools: [tool],
+            settings: ModelSettings(modelName: "grok-4"))
+
+        // Verify the model can process tool definitions
+        do {
+            _ = try await model.getResponse(request: request)
+            Issue.record("Expected network error but got success")
+        } catch {
+            // Expected to fail due to no valid API key/network
+            #expect(error is TachikomaError)
+        }
+    }
+
+    @Test("Message type conversion")
+    func messageTypeConversion() async throws {
+        let model = GrokModel(apiKey: "test-key")
+
+        // Test various message types
+        let messages: [Message] = [
+            Message.system(content: "System prompt"),
+            Message.user(content: .text("User text")),
+            Message.assistant(content: [.outputText("Assistant response")]),
+            Message.tool(
+                toolCallId: "tool-123",
+                content: "Tool result"),
+        ]
+
+        let request = ModelRequest(
+            messages: messages,
+            tools: nil,
+            settings: ModelSettings(modelName: "grok-4"))
+
+        // Verify message conversion doesn't crash
+        do {
+            _ = try await model.getResponse(request: request)
+            Issue.record("Expected network error but got success")
+        } catch {
+            // Expected to fail due to no valid API key/network
+            #expect(error is TachikomaError)
+        }
+    }
+
+    @Test("Multimodal message support")
+    func multimodalMessageSupport() async throws {
+        let model = GrokModel(apiKey: "test-key", modelName: "grok-2-vision-1212")
+
+        // Create a multimodal message with text and image
+        let imageData = Data([0xFF, 0xD8, 0xFF]) // Minimal JPEG header
+
+        let request = ModelRequest(
+            messages: [
+                Message.user(content: .multimodal([
+                    MessageContentPart(type: "text", text: "What is in this image?"),
+                    MessageContentPart(type: "image", imageUrl: ImageContent(base64: imageData.base64EncodedString())),
+                ])),
+            ],
+            tools: nil,
+            settings: ModelSettings(modelName: "grok-2-vision-1212"))
+
+        // Verify multimodal content handling
+        do {
+            _ = try await model.getResponse(request: request)
+            Issue.record("Expected network error but got success")
+        } catch {
+            // Expected to fail due to no valid API key/network
+            #expect(error is TachikomaError)
+        }
+    }
+
+    @Test("Streaming response handling")
+    func streamingResponse() async throws {
+        let model = GrokModel(apiKey: "test-key")
+
+        let request = ModelRequest(
+            messages: [
+                Message.user(content: .text("Stream this response")),
+            ],
+            tools: nil,
+            settings: ModelSettings(modelName: "grok-4"))
+
+        // Test streaming
+        do {
+            let stream = try await model.getStreamedResponse(request: request)
+            var eventCount = 0
+
+            for try await event in stream {
+                eventCount += 1
+                // Would normally process events here
+                _ = event
+            }
+
+            Issue.record("Expected network error but got success with \(eventCount) events")
+        } catch {
+            // Expected to fail due to no valid API key/network
+            #expect(error is TachikomaError)
+        }
+    }
+
+    @Test("Error handling")
+    func errorHandling() async throws {
+        let model = GrokModel(apiKey: "invalid-key")
+
+        let request = ModelRequest(
+            messages: [
+                Message.user(content: .text("Test")),
+            ],
+            tools: nil,
+            settings: ModelSettings(modelName: "grok-4"))
+
+        do {
+            _ = try await model.getResponse(request: request)
+            Issue.record("Expected error but got success")
+        } catch let error as TachikomaError {
+            // Verify we get appropriate error types
+            switch error {
+            case .apiError, .authenticationFailed:
+                // Expected error types for invalid API key
+                break
+            default:
+                Issue.record("Unexpected error type: \(error)")
+            }
+        } catch {
+            Issue.record("Unexpected error type: \(type(of: error))")
+        }
+    }
+
+    @Test("Reasoning message rejection")
+    func reasoningMessageRejection() async throws {
+        let model = GrokModel(apiKey: "test-key")
+
+        let request = ModelRequest(
+            messages: [
+                Message.reasoning(content: "Some reasoning"),
+                Message.user(content: .text("Test")),
+            ],
+            tools: nil,
+            settings: ModelSettings(modelName: "grok-4"))
+
+        do {
+            _ = try await model.getResponse(request: request)
+            Issue.record("Expected error for reasoning messages")
+        } catch let error as TachikomaError {
+            switch error {
+            case .invalidRequest:
+                // Expected - reasoning messages not supported
+                break
+            default:
+                Issue.record("Expected invalidRequest error, got: \(error)")
+            }
+        }
+    }
+}
+
+// MARK: - Model Provider Tests
+
+@Suite("Grok Model Provider Tests")
+struct GrokModelProviderTests {
+    @Test("Grok model registration")
+    func grokModelRegistration() async throws {
+        let tachikoma = Tachikoma.shared
+
+        // Register a test Grok model
+        await tachikoma.registerModel(name: "test-grok", factory: {
+            GrokModel(apiKey: "test-key", modelName: "grok-4")
+        })
+
+        // Test that we can get the model
+        do {
+            let model = try await tachikoma.getModel("test-grok")
+            #expect(model is GrokModel)
+        } catch {
+            Issue.record("Failed to get registered model: \(error)")
+        }
+    }
+
+    @Test("Model name variants")
+    func modelNameVariants() async throws {
+        let tachikoma = Tachikoma.shared
+
+        // Register various Grok model names
+        let modelNames = [
+            "grok-4",
+            "grok-4-0709",
+            "grok-4-latest",
+            "grok-2-1212",
+            "grok-2-vision-1212",
+            "grok-beta",
+            "grok-vision-beta",
+        ]
+
+        for modelName in modelNames {
+            await tachikoma.registerModel(name: modelName, factory: {
+                GrokModel(apiKey: "test-key", modelName: modelName)
+            })
+
+            do {
+                let model = try await tachikoma.getModel(modelName)
+                #expect(model is GrokModel)
+            } catch {
+                Issue.record("Failed to get model \(modelName): \(error)")
+            }
+        }
+    }
+
+    @Test("Parameter filtering detection")
+    func parameterFilteringDetection() async throws {
+        // Test that Grok 3 and 4 models filter parameters correctly
+        let grok3Model = GrokModel(apiKey: "test-key", modelName: "grok-3")
+        let grok4Model = GrokModel(apiKey: "test-key", modelName: "grok-4")
+        let grokBetaModel = GrokModel(apiKey: "test-key", modelName: "grok-beta")
+
+        // All should handle the same request without errors (though network will fail)
+        let settings = ModelSettings(
+            modelName: "grok-4",
+            temperature: 0.7,
+            frequencyPenalty: 0.5,
+            presencePenalty: 0.5,
+            stopSequences: ["stop"]
+        )
+
+        let request = ModelRequest(
+            messages: [Message.user(content: .text("Test"))],
+            settings: settings
+        )
+
+        // Test each model handles parameter filtering
+        for (name, model) in [("grok-3", grok3Model), ("grok-4", grok4Model), ("grok-beta", grokBetaModel)] {
+            do {
+                _ = try await model.getResponse(request: request)
+                Issue.record("Expected network error for \(name)")
+            } catch {
+                // Expected to fail due to network/auth, but not due to parameter issues
+                #expect(error is TachikomaError)
+            }
+        }
+    }
+}
\ No newline at end of file
diff --git a/Tests/TachikomaTests/OllamaModelTests.swift b/Tests/TachikomaTests/OllamaModelTests.swift
new file mode 100644
index 0000000..f4cdbd0
--- /dev/null
+++ b/Tests/TachikomaTests/OllamaModelTests.swift
@@ -0,0 +1,611 @@
+import Foundation
+import Testing
+@testable import Tachikoma
+
+@Suite("Ollama Model Tests")
+struct OllamaModelTests {
+    @Test("Model initialization")
+    func modelInitialization() async throws {
+        let model = OllamaModel(
+            modelName: "llama3.3",
+            baseURL: URL(string: "http://localhost:11434")!)
+
+        // Ollama doesn't use API keys, so maskedApiKey should return a placeholder
+        #expect(model.maskedApiKey == "local-ollama")
+    }
+
+    @Test("Default base URL")
+    func defaultBaseURL() async throws {
+        let model = OllamaModel(modelName: "llama3.3")
+
+        // Should use default localhost URL
+        #expect(model.maskedApiKey == "local-ollama")
+    }
+
+    @Test("Custom base URL")
+    func customBaseURL() async throws {
+        let customURL = URL(string: "http://remote-server:11434")!
+        let model = OllamaModel(modelName: "llama3.3", baseURL: customURL)
+
+        #expect(model.maskedApiKey == "local-ollama")
+    }
+
+    @Test("Tool calling support detection")
+    func toolCallingSupportDetection() async throws {
+        // Models with tool calling support
+        let supportedModels = [
+            "llama3.3",
+            "llama3.2",
+            "llama3.1",
+            "mistral-nemo",
+            "firefunction-v2",
+            "command-r-plus",
+            "command-r",
+        ]
+
+        for modelName in supportedModels {
+            let model = OllamaModel(modelName: modelName)
+
+            let toolDef = ToolDefinition(
+                function: FunctionDefinition(
+                    name: "get_time",
+                    description: "Get current time",
+                    parameters: ToolParameters(
+                        properties: [:],
+                        required: [])))
+
+            let request = ModelRequest(
+                messages: [
+                    Message.user(content: .text("What time is it?")),
+                ],
+                tools: [toolDef],
+                settings: ModelSettings(modelName: "llama3.3"))
+
+            // Should handle tool calls (will fail at network level)
+            do {
+                _ = try await model.getResponse(request: request)
+                Issue.record("Expected network error for \(modelName)")
+            } catch {
+                #expect(error is TachikomaError)
+            }
+        }
+    }
+
+    @Test("Vision model tool rejection")
+    func visionModelToolRejection() async throws {
+        // Vision models that don't support tool calling
+        let visionModels = [
+            "llava",
+            "bakllava",
+            "llama3.2-vision:11b",
+            "qwen2.5vl:7b",
+        ]
+
+        for modelName in visionModels {
+            let model = OllamaModel(modelName: modelName)
+
+            let toolDef = ToolDefinition(
+                function: FunctionDefinition(
+                    name: "get_time",
+                    description: "Get current time",
+                    parameters: ToolParameters(
+                        properties: [:],
+                        required: [])))
+
+            let request = ModelRequest(
+                messages: [
+                    Message.user(content: .text("What time is it?")),
+                ],
+                tools: [toolDef],
+                settings: ModelSettings(modelName: "llama3.3"))
+
+            // Should reject tool calls for vision models
+            do {
+                _ = try await model.getResponse(request: request)
+                Issue.record("Expected error for vision model \(modelName) with tools")
+            } catch let error as TachikomaError {
+                switch error {
+                case .invalidRequest:
+                    // Expected - vision models don't support tool calling
+                    break
+                default:
+                    Issue.record("Expected invalidRequest error for \(modelName), got: \(error)")
+                }
+            }
+        }
+    }
+
+    @Test("Message type conversion")
+    func messageTypeConversion() async throws {
+        let model = OllamaModel(modelName: "llama3.3")
+
+        // Test various message types
+        let messages: [Message] = [
+            Message.system(content: "You are a helpful assistant."),
+            Message.user(content: .text("Hello!")),
+            Message.assistant(content: [.outputText("Hi there!")]),
+            Message.tool(
+                toolCallId: "call_123",
+                content: "Current time: 2:30 PM"),
+        ]
+
+        let request = ModelRequest(
+            messages: messages,
+            tools: nil,
+            settings: ModelSettings(modelName: "llama3.3"))
+
+        // Verify message conversion doesn't crash
+        do {
+            _ = try await model.getResponse(request: request)
+            Issue.record("Expected network error but got success")
+        } catch {
+            #expect(error is TachikomaError)
+        }
+    }
+
+    @Test("Multimodal message support for vision models")
+    func multimodalMessageSupport() async throws {
+        let model = OllamaModel(modelName: "llava")
+
+        // Create a multimodal message with text and image
+        let imageData = Data([0xFF, 0xD8, 0xFF]) // Minimal JPEG header
+
+        let request = ModelRequest(
+            messages: [
+                Message.user(content: .multimodal([
+                    MessageContentPart(type: "text", text: "What is in this image?"),
+                    MessageContentPart(type: "image", imageUrl: ImageContent(base64: imageData.base64EncodedString())),
+                ])),
+            ],
+            tools: nil,
+            settings: ModelSettings(modelName: "llava"))
+
+        // Verify multimodal content handling for vision models
+        do {
+            _ = try await model.getResponse(request: request)
+            Issue.record("Expected network error but got success")
+        } catch {
+            #expect(error is TachikomaError)
+        }
+    }
+
+    @Test("Text-only models image rejection")
+    func textOnlyModelsImageRejection() async throws {
+        let model = OllamaModel(modelName: "llama3.3") // Text-only model
+
+        let imageData = Data([0xFF, 0xD8, 0xFF])
+
+        let request = ModelRequest(
+            messages: [
+                Message.user(content: .image(ImageContent(base64: imageData.base64EncodedString()))),
+            ],
+            tools: nil,
+            settings: ModelSettings(modelName: "llama3.3"))
+
+        // Should reject image content for text-only models
+        do {
+            _ = try await model.getResponse(request: request)
+            Issue.record("Expected error for text-only model with image")
+        } catch let error as TachikomaError {
+            switch error {
+            case .invalidRequest:
+                // Expected - text-only models don't support images
+                break
+            default:
+                Issue.record("Expected invalidRequest error, got: \(error)")
+            }
+        }
+    }
+
+    @Test("Streaming response handling")
+    func streamingResponse() async throws {
+        let model = OllamaModel(modelName: "llama3.3")
+
+        let request = ModelRequest(
+            messages: [
+                Message.user(content: .text("Tell me a joke")),
+            ],
+            tools: nil,
+            settings: ModelSettings(modelName: "llama3.3"))
+
+        // Test streaming
+        do {
+            let stream = try await model.getStreamedResponse(request: request)
+            var eventCount = 0
+
+            for try await event in stream {
+                eventCount += 1
+                _ = event
+            }
+
+            Issue.record("Expected network error but got success with \(eventCount) events")
+        } catch {
+            #expect(error is TachikomaError)
+        }
+    }
+
+    @Test("Extended timeout handling")
+    func extendedTimeoutHandling() async throws {
+        let model = OllamaModel(modelName: "llama3.3")
+
+        let request = ModelRequest(
+            messages: [
+                Message.user(content: .text("Generate a long response")),
+            ],
+            tools: nil,
+            settings: ModelSettings(modelName: "llama3.3"))
+
+        // Ollama requests should have extended timeouts (5 minutes)
+        // We can't test the actual timeout without a real server,
+        // but we can verify the request structure
+        do {
+            _ = try await model.getResponse(request: request)
+            Issue.record("Expected network error but got success")
+        } catch {
+            #expect(error is TachikomaError)
+        }
+    }
+
+    @Test("Tool call JSON parsing")
+    func toolCallJSONParsing() async throws {
+        let model = OllamaModel(modelName: "llama3.3")
+
+        // Test models that output tool calls as JSON in content
+        let toolDef = ToolDefinition(
+            function: FunctionDefinition(
+                name: "calculate",
+                description: "Perform calculation",
+                parameters: ToolParameters(
+                    properties: [
+                        "expression": ParameterSchema(type: .string, description: "Math expression")
+                    ],
+                    required: ["expression"])))
+
+        let request = ModelRequest(
+            messages: [
+                Message.user(content: .text("What is 5 + 3?")),
+            ],
+            tools: [toolDef],
+            settings: ModelSettings(modelName: "llama3.3"))
+
+        // Should handle tool call parsing
+        do {
+            _ = try await model.getResponse(request: request)
+            Issue.record("Expected network error but got success")
+        } catch {
+            #expect(error is TachikomaError)
+        }
+    }
+
+    @Test("Error handling")
+    func errorHandling() async throws {
+        let model = OllamaModel(modelName: "nonexistent-model")
+
+        let request = ModelRequest(
+            messages: [
+                Message.user(content: .text("Test")),
+            ],
+            tools: nil,
+            settings: ModelSettings(modelName: "llama3.3"))
+
+        do {
+            _ = try await model.getResponse(request: request)
+            Issue.record("Expected error but got success")
+        } catch let error as TachikomaError {
+            // Verify we get appropriate error types
+            switch error {
+            case .apiError, .networkError:
+                // Expected error types for nonexistent model
+                break
+            default:
+                Issue.record("Unexpected error type: \(error)")
+            }
+        } catch {
+            Issue.record("Unexpected error type: \(type(of: error))")
+        }
+    }
+
+    @Test("Reasoning message rejection")
+    func reasoningMessageRejection() async throws {
+        let model = OllamaModel(modelName: "llama3.3")
+
+        let request = ModelRequest(
+            messages: [
+                Message.reasoning(content: "Let me think..."),
+                Message.user(content: .text("Test")),
+            ],
+            tools: nil,
+            settings: ModelSettings(modelName: "llama3.3"))
+
+        do {
+            _ = try await model.getResponse(request: request)
+            Issue.record("Expected error for reasoning messages")
+        } catch let error as TachikomaError {
+            switch error {
+            case .invalidRequest:
+                // Expected - reasoning messages not supported
+                break
+            default:
+                Issue.record("Expected invalidRequest error, got: \(error)")
+            }
+        }
+    }
+
+    @Test("File content rejection")
+    func fileContentRejection() async throws {
+        let model = OllamaModel(modelName: "llama3.3")
+
+        let fileContent = FileContent(
+            id: nil,
+            url: nil,
+            name: "test.txt"
+        )
+
+        let request = ModelRequest(
+            messages: [
+                Message.user(content: .file(fileContent)),
+            ],
+            settings: ModelSettings(modelName: "llama3.3"))
+
+        // File content should be rejected
+        do {
+            _ = try await model.getResponse(request: request)
+            Issue.record("Expected error for file content")
+        } catch let error as TachikomaError {
+            switch error {
+            case .invalidRequest:
+                // Expected - file content not supported
+                break
+            default:
+                Issue.record("Expected invalidRequest error, got: \(error)")
+            }
+        }
+    }
+
+    @Test("Audio content handling")
+    func audioContentHandling() async throws {
+        let model = OllamaModel(modelName: "llama3.3")
+
+        let audioContent = AudioContent(
+            transcript: "Hello, this is a test transcript.",
+            duration: 5.0
+        )
+
+        let request = ModelRequest(
+            messages: [
+                Message.user(content: .audio(audioContent)),
+            ],
+            settings: ModelSettings(modelName: "llama3.3"))
+
+        // Test audio content processing (converts to text)
+        do {
+            _ = try await model.getResponse(request: request)
+            Issue.record("Expected network error")
+        } catch {
+            #expect(error is TachikomaError)
+        }
+    }
+}
+
+// MARK: - Model Provider Tests
+
+@Suite("Ollama Model Provider Tests")
+struct OllamaModelProviderTests {
+    @Test("Ollama model registration")
+    func ollamaModelRegistration() async throws {
+        let tachikoma = Tachikoma.shared
+
+        // Register a test Ollama model
+        await tachikoma.registerModel(name: "test-llama", factory: {
+            OllamaModel(modelName: "llama3.3")
+        })
+
+        // Test that we can get the model
+        do {
+            let model = try await tachikoma.getModel("test-llama")
+            #expect(model is OllamaModel)
+        } catch {
+            Issue.record("Failed to get registered model: \(error)")
+        }
+    }
+
+    @Test("Model name variants")
+    func modelNameVariants() async throws {
+        let tachikoma = Tachikoma.shared
+
+        // Register various Ollama model names
+        let modelNames = [
+            "llama3.3",
+            "llama3.2",
+            "llama3.1",
+            "llava",
+            "mistral-nemo",
+            "firefunction-v2",
+            "command-r-plus",
+            "deepseek-r1:8b",
+        ]
+
+        for modelName in modelNames {
+            await tachikoma.registerModel(name: modelName, factory: {
+                OllamaModel(modelName: modelName)
+            })
+
+            do {
+                let model = try await tachikoma.getModel(modelName)
+                #expect(model is OllamaModel)
+            } catch {
+                Issue.record("Failed to get model \(modelName): \(error)")
+            }
+        }
+    }
+
+    @Test("Base URL configuration")
+    func baseURLConfiguration() async throws {
+        let tachikoma = Tachikoma.shared
+
+        // Test custom base URL
+        let customURL = URL(string: "http://remote-ollama:11434")!
+
+        await tachikoma.registerModel(name: "custom-ollama", factory: {
+            OllamaModel(modelName: "llama3.3", baseURL: customURL)
+        })
+
+        do {
+            let model = try await tachikoma.getModel("custom-ollama")
+            #expect(model is OllamaModel)
+        } catch {
+            Issue.record("Failed to get custom URL model: \(error)")
+        }
+    }
+
+    @Test("Tool support matrix")
+    func toolSupportMatrix() async throws {
+        let tachikoma = Tachikoma.shared
+
+        // Models with tool support
+        let toolSupportedModels = [
+            "llama3.3",
+            "llama3.2",
+            "mistral-nemo",
+            "firefunction-v2",
+        ]
+
+        // Models without tool support  
+        let nonToolModels = [
+            "llava",
+            "bakllava",
+            "devstral",
+        ]
+
+        let toolDef = ToolDefinition(
+            function: FunctionDefinition(
+                name: "test_tool",
+                description: "Test tool",
+                parameters: ToolParameters(properties: [:], required: [])))
+
+        // Test tool-supported models
+        for modelName in toolSupportedModels {
+            await tachikoma.registerModel(name: "tool-\(modelName)", factory: {
+                OllamaModel(modelName: modelName)
+            })
+
+            do {
+                let model = try await tachikoma.getModel("tool-\(modelName)")
+                #expect(model is OllamaModel)
+
+                // Should accept tool definitions
+                let request = ModelRequest(
+                    messages: [Message.user(content: .text("Use tool"))],
+                    tools: [toolDef],
+                    settings: ModelSettings(modelName: "llama3.3"))
+
+                do {
+                    _ = try await model.getResponse(request: request)
+                    Issue.record("Expected network error for \(modelName)")
+                } catch {
+                    #expect(error is TachikomaError)
+                }
+            } catch {
+                Issue.record("Failed to get tool model \(modelName): \(error)")
+            }
+        }
+
+        // Test non-tool models
+        for modelName in nonToolModels {
+            await tachikoma.registerModel(name: "no-tool-\(modelName)", factory: {
+                OllamaModel(modelName: modelName)
+            })
+
+            do {
+                let model = try await tachikoma.getModel("no-tool-\(modelName)")
+                #expect(model is OllamaModel)
+
+                // Should reject tool definitions
+                let request = ModelRequest(
+                    messages: [Message.user(content: .text("Use tool"))],
+                    tools: [toolDef],
+                    settings: ModelSettings(modelName: "llama3.3"))
+
+                do {
+                    _ = try await model.getResponse(request: request)
+                    Issue.record("Expected error for non-tool model \(modelName)")
+                } catch let error as TachikomaError {
+                    switch error {
+                    case .invalidRequest:
+                        // Expected for non-tool models
+                        break
+                    default:
+                        Issue.record("Expected invalidRequest for \(modelName), got: \(error)")
+                    }
+                }
+            } catch {
+                Issue.record("Failed to get non-tool model \(modelName): \(error)")
+            }
+        }
+    }
+
+    @Test("Vision capability detection")
+    func visionCapabilityDetection() async throws {
+        let tachikoma = Tachikoma.shared
+
+        // Vision models
+        let visionModels = ["llava", "bakllava", "llama3.2-vision:11b"]
+        
+        // Text-only models
+        let textModels = ["llama3.3", "mistral-nemo", "command-r"]
+
+        let imageData = Data([0xFF, 0xD8, 0xFF])
+
+        // Test vision models accept images
+        for modelName in visionModels {
+            await tachikoma.registerModel(name: "vision-\(modelName)", factory: {
+                OllamaModel(modelName: modelName)
+            })
+
+            do {
+                let model = try await tachikoma.getModel("vision-\(modelName)")
+                let request = ModelRequest(
+                    messages: [Message.user(content: .image(ImageContent(base64: imageData.base64EncodedString())))],
+                    settings: ModelSettings(modelName: "llama3.3"))
+
+                do {
+                    _ = try await model.getResponse(request: request)
+                    Issue.record("Expected network error for vision model \(modelName)")
+                } catch {
+                    #expect(error is TachikomaError)
+                }
+            } catch {
+                Issue.record("Failed vision model test for \(modelName): \(error)")
+            }
+        }
+
+        // Test text models reject images
+        for modelName in textModels {
+            await tachikoma.registerModel(name: "text-\(modelName)", factory: {
+                OllamaModel(modelName: modelName)
+            })
+
+            do {
+                let model = try await tachikoma.getModel("text-\(modelName)")
+                let request = ModelRequest(
+                    messages: [Message.user(content: .image(ImageContent(base64: imageData.base64EncodedString())))],
+                    settings: ModelSettings(modelName: "llama3.3"))
+
+                do {
+                    _ = try await model.getResponse(request: request)
+                    Issue.record("Expected error for text model \(modelName) with image")
+                } catch let error as TachikomaError {
+                    switch error {
+                    case .invalidRequest:
+                        // Expected for text-only models
+                        break
+                    default:
+                        Issue.record("Expected invalidRequest for \(modelName), got: \(error)")
+                    }
+                }
+            } catch {
+                Issue.record("Failed text model test for \(modelName): \(error)")
+            }
+        }
+    }
+}
\ No newline at end of file
diff --git a/Tests/TachikomaTests/OpenAIModelTests.swift b/Tests/TachikomaTests/OpenAIModelTests.swift
new file mode 100644
index 0000000..a1f1644
--- /dev/null
+++ b/Tests/TachikomaTests/OpenAIModelTests.swift
@@ -0,0 +1,475 @@
+import Foundation
+import Testing
+@testable import Tachikoma
+
+@Suite("OpenAI Model Tests")
+struct OpenAIModelTests {
+    @Test("Model initialization")
+    func modelInitialization() async throws {
+        let model = OpenAIModel(
+            apiKey: "sk-test-key-123456789",
+            modelName: "gpt-4.1")
+
+        #expect(model.maskedApiKey == "sk-...789")
+    }
+
+    @Test("API key masking")
+    func apiKeyMasking() async throws {
+        // Test short key
+        let shortModel = OpenAIModel(apiKey: "short")
+        #expect(shortModel.maskedApiKey == "***")
+
+        // Test normal key
+        let normalModel = OpenAIModel(apiKey: "sk-test-api-key-1234567890abcdefghijklmnopqrstuvwxyz")
+        #expect(normalModel.maskedApiKey == "sk-...xyz")
+    }
+
+    @Test("Default base URL")
+    func defaultBaseURL() async throws {
+        let model = OpenAIModel(apiKey: "test-key")
+
+        // Verify it uses the correct OpenAI API endpoint
+        // We can't directly access baseURL, but we can test the behavior
+        #expect(model.maskedApiKey == "***")
+    }
+
+    @Test("Dual API support")
+    func dualAPISupport() async throws {
+        let model = OpenAIModel(apiKey: "test-key")
+
+        // Test Chat Completions API request
+        let chatRequest = ModelRequest(
+            messages: [
+                Message.user(content: .text("Hello")),
+            ],
+            tools: nil,
+            settings: ModelSettings(apiType: "chat"))
+
+        // Test Responses API request (for reasoning models)
+        let responsesRequest = ModelRequest(
+            messages: [
+                Message.user(content: .text("Hello")),
+            ],
+            tools: nil,
+            settings: ModelSettings(apiType: "responses"))
+
+        // Both should be processable (will fail at network level)
+        do {
+            _ = try await model.getResponse(request: chatRequest)
+            Issue.record("Expected network error but got success")
+        } catch {
+            #expect(error is TachikomaError)
+        }
+
+        do {
+            _ = try await model.getResponse(request: responsesRequest)
+            Issue.record("Expected network error but got success")
+        } catch {
+            #expect(error is TachikomaError)
+        }
+    }
+
+    @Test("Reasoning models parameter handling")
+    func reasoningModelsParameterHandling() async throws {
+        let model = OpenAIModel(apiKey: "test-key", modelName: "o3")
+
+        // Create a request with reasoning parameters
+        let settings = ModelSettings(
+            reasoningEffort: "medium",
+            reasoning: ["summary": "detailed"],
+            temperature: nil // o3 models don't support temperature
+        )
+
+        let request = ModelRequest(
+            messages: [
+                Message.user(content: .text("Solve this complex problem")),
+            ],
+            tools: nil,
+            settings: settings)
+
+        // Should handle reasoning parameters correctly
+        do {
+            _ = try await model.getResponse(request: request)
+            Issue.record("Expected network error but got success")
+        } catch {
+            #expect(error is TachikomaError)
+        }
+    }
+
+    @Test("Tool parameter conversion")
+    func toolParameterConversion() async throws {
+        let model = OpenAIModel(apiKey: "test-key")
+
+        // Create a tool definition
+        let tool = ToolDefinition(
+            function: FunctionDefinition(
+                name: "get_weather",
+                description: "Get current weather",
+                parameters: ToolParameters(
+                    type: "object",
+                    properties: [
+                        "location": ParameterSchema(
+                            type: .string,
+                            description: "The location"),
+                        "units": ParameterSchema(
+                            type: .string,
+                            description: "Temperature units",
+                            enumValues: ["celsius", "fahrenheit"]),
+                    ],
+                    required: ["location"])))
+
+        let request = ModelRequest(
+            messages: [
+                Message.user(content: .text("What's the weather in Paris?")),
+            ],
+            tools: [tool],
+            settings: ModelSettings(modelName: "gpt-4.1"))
+
+        // Verify the model can process tool definitions
+        do {
+            _ = try await model.getResponse(request: request)
+            Issue.record("Expected network error but got success")
+        } catch {
+            #expect(error is TachikomaError)
+        }
+    }
+
+    @Test("Message type conversion")
+    func messageTypeConversion() async throws {
+        let model = OpenAIModel(apiKey: "test-key")
+
+        // Test various message types
+        let messages: [Message] = [
+            Message.system(content: "You are a helpful assistant."),
+            Message.user(content: .text("Hello!")),
+            Message.assistant(content: [.outputText("Hi there!")]),
+            Message.tool(
+                toolCallId: "call_123",
+                content: "Weather data"),
+        ]
+
+        let request = ModelRequest(
+            messages: messages,
+            tools: nil,
+            settings: ModelSettings(modelName: "gpt-4.1"))
+
+        // Verify message conversion doesn't crash
+        do {
+            _ = try await model.getResponse(request: request)
+            Issue.record("Expected network error but got success")
+        } catch {
+            #expect(error is TachikomaError)
+        }
+    }
+
+    @Test("Multimodal message support")
+    func multimodalMessageSupport() async throws {
+        let model = OpenAIModel(apiKey: "test-key", modelName: "gpt-4o")
+
+        // Create a multimodal message with text and image
+        let imageData = Data([0xFF, 0xD8, 0xFF]) // Minimal JPEG header
+
+        let request = ModelRequest(
+            messages: [
+                Message.user(content: .multimodal([
+                    MessageContentPart(type: "text", text: "What is in this image?"),
+                    MessageContentPart(type: "image", imageUrl: ImageContent(base64: imageData.base64EncodedString())),
+                ])),
+            ],
+            tools: nil,
+            settings: ModelSettings(modelName: "gpt-4.1"))
+
+        // Verify multimodal content handling
+        do {
+            _ = try await model.getResponse(request: request)
+            Issue.record("Expected network error but got success")
+        } catch {
+            #expect(error is TachikomaError)
+        }
+    }
+
+    @Test("Streaming response handling")
+    func streamingResponse() async throws {
+        let model = OpenAIModel(apiKey: "test-key")
+
+        let request = ModelRequest(
+            messages: [
+                Message.user(content: .text("Write a short story")),
+            ],
+            tools: nil,
+            settings: ModelSettings(modelName: "gpt-4.1"))
+
+        // Test streaming
+        do {
+            let stream = try await model.getStreamedResponse(request: request)
+            var eventCount = 0
+
+            for try await event in stream {
+                eventCount += 1
+                _ = event
+            }
+
+            Issue.record("Expected network error but got success with \(eventCount) events")
+        } catch {
+            #expect(error is TachikomaError)
+        }
+    }
+
+    @Test("Error handling")
+    func errorHandling() async throws {
+        let model = OpenAIModel(apiKey: "invalid-key")
+
+        let request = ModelRequest(
+            messages: [
+                Message.user(content: .text("Test")),
+            ],
+            tools: nil,
+            settings: ModelSettings(modelName: "gpt-4.1"))
+
+        do {
+            _ = try await model.getResponse(request: request)
+            Issue.record("Expected error but got success")
+        } catch let error as TachikomaError {
+            // Verify we get appropriate error types
+            switch error {
+            case .apiError, .authenticationFailed:
+                // Expected error types for invalid API key
+                break
+            default:
+                Issue.record("Unexpected error type: \(error)")
+            }
+        } catch {
+            Issue.record("Unexpected error type: \(type(of: error))")
+        }
+    }
+
+    @Test("Reasoning message handling")
+    func reasoningMessageHandling() async throws {
+        let model = OpenAIModel(apiKey: "test-key", modelName: "o3")
+
+        let request = ModelRequest(
+            messages: [
+                Message.reasoning(content: "Let me think about this step by step..."),
+                Message.user(content: .text("What is 2+2?")),
+            ],
+            tools: nil,
+            settings: ModelSettings(modelName: "gpt-4.1"))
+
+        // o3 models should handle reasoning messages
+        do {
+            _ = try await model.getResponse(request: request)
+            Issue.record("Expected network error but got success")
+        } catch {
+            #expect(error is TachikomaError)
+        }
+    }
+
+    @Test("Model variants")
+    func modelVariants() async throws {
+        let modelNames = [
+            "o3",
+            "o3-mini",
+            "o3-pro",
+            "o4-mini",
+            "gpt-4.1",
+            "gpt-4.1-mini",
+            "gpt-4o",
+            "gpt-4o-mini",
+        ]
+
+        for modelName in modelNames {
+            let model = OpenAIModel(apiKey: "test-key", modelName: modelName)
+            #expect(model.maskedApiKey == "***")
+
+            // Test that each model variant can be created and handles requests
+            let request = ModelRequest(
+                messages: [Message.user(content: .text("Test"))],
+                settings: ModelSettings(modelName: "gpt-4.1"))
+
+            do {
+                _ = try await model.getResponse(request: request)
+                Issue.record("Expected network error for \(modelName)")
+            } catch {
+                #expect(error is TachikomaError)
+            }
+        }
+    }
+
+    @Test("Temperature parameter filtering")
+    func temperatureParameterFiltering() async throws {
+        // o3 models should not support temperature
+        let o3Model = OpenAIModel(apiKey: "test-key", modelName: "o3")
+        let gptModel = OpenAIModel(apiKey: "test-key", modelName: "gpt-4.1")
+
+        let settings = ModelSettings(temperature: 0.7)
+
+        let request = ModelRequest(
+            messages: [Message.user(content: .text("Test"))],
+            settings: settings)
+
+        // Both should handle the request (temperature filtered for o3)
+        for (name, model) in [("o3", o3Model), ("gpt-4.1", gptModel)] {
+            do {
+                _ = try await model.getResponse(request: request)
+                Issue.record("Expected network error for \(name)")
+            } catch {
+                #expect(error is TachikomaError)
+            }
+        }
+    }
+
+    @Test("File content rejection")
+    func fileContentRejection() async throws {
+        let model = OpenAIModel(apiKey: "test-key")
+
+        let fileContent = FileContent(
+            filename: "test.txt",
+            content: "Test file content",
+            mimeType: "text/plain"
+        )
+
+        let request = ModelRequest(
+            messages: [
+                Message.user(content: .file(fileContent)),
+            ],
+            settings: ModelSettings(modelName: "gpt-4.1"))
+
+        // File content should be rejected
+        do {
+            _ = try await model.getResponse(request: request)
+            Issue.record("Expected error for file content")
+        } catch let error as TachikomaError {
+            switch error {
+            case .invalidRequest:
+                // Expected - file content not supported
+                break
+            default:
+                Issue.record("Expected invalidRequest error, got: \(error)")
+            }
+        }
+    }
+
+    @Test("Audio content handling")
+    func audioContentHandling() async throws {
+        let model = OpenAIModel(apiKey: "test-key")
+
+        let audioContent = AudioContent(
+            transcript: "Hello, this is a test transcript.",
+            duration: 5.0
+        )
+
+        let request = ModelRequest(
+            messages: [
+                Message.user(content: .audio(audioContent)),
+            ],
+            settings: ModelSettings(modelName: "gpt-4.1"))
+
+        // Test audio content processing
+        do {
+            _ = try await model.getResponse(request: request)
+            Issue.record("Expected network error")
+        } catch {
+            #expect(error is TachikomaError)
+        }
+    }
+}
+
+// MARK: - Provider Configuration Tests
+
+@Suite("OpenAI Provider Configuration Tests")
+struct OpenAIProviderConfigurationTests {
+    @Test("Provider configuration")
+    func providerConfiguration() async throws {
+        let tachikoma = Tachikoma.shared
+
+        // Test custom OpenAI configuration
+        let config = ProviderConfiguration.OpenAI(
+            apiKey: "test-key",
+            baseURL: URL(string: "https://api.openai.com/v1")!
+        )
+
+        await tachikoma.configureOpenAI(config)
+    }
+
+    @Test("Model registration")
+    func modelRegistration() async throws {
+        let tachikoma = Tachikoma.shared
+
+        // Register OpenAI models
+        let modelNames = [
+            "o3",
+            "o3-mini",
+            "gpt-4.1",
+            "gpt-4o",
+        ]
+
+        for modelName in modelNames {
+            await tachikoma.registerModel(name: modelName, factory: {
+                OpenAIModel(apiKey: "test-key", modelName: modelName)
+            })
+
+            do {
+                let model = try await tachikoma.getModel(modelName)
+                #expect(model is OpenAIModel)
+            } catch {
+                Issue.record("Failed to get model \(modelName): \(error)")
+            }
+        }
+    }
+
+    @Test("API type selection")
+    func apiTypeSelection() async throws {
+        let tachikoma = Tachikoma.shared
+
+        // Register models with different API preferences
+        await tachikoma.registerModel(name: "gpt-4.1-chat", factory: {
+            OpenAIModel(apiKey: "test-key", modelName: "gpt-4.1")
+        })
+
+        await tachikoma.registerModel(name: "o3-responses", factory: {
+            OpenAIModel(apiKey: "test-key", modelName: "o3")
+        })
+
+        // Test that both can be retrieved
+        do {
+            let chatModel = try await tachikoma.getModel("gpt-4.1-chat")
+            #expect(chatModel is OpenAIModel)
+
+            let responsesModel = try await tachikoma.getModel("o3-responses")
+            #expect(responsesModel is OpenAIModel)
+        } catch {
+            Issue.record("Failed to get models: \(error)")
+        }
+    }
+
+    @Test("Lenient model name resolution")
+    func lenientModelNameResolution() async throws {
+        let tachikoma = Tachikoma.shared
+
+        // Register base models
+        await tachikoma.registerModel(name: "gpt-4.1", factory: {
+            OpenAIModel(apiKey: "test-key", modelName: "gpt-4.1")
+        })
+
+        await tachikoma.registerModel(name: "o3", factory: {
+            OpenAIModel(apiKey: "test-key", modelName: "o3")
+        })
+
+        // Test lenient name matching
+        let nameMapping = [
+            "gpt": "gpt-4.1",
+            "gpt-4": "gpt-4.1",
+            "gpt4": "gpt-4.1",
+            "o3": "o3",
+        ]
+
+        for (input, _) in nameMapping {
+            do {
+                let model = try await tachikoma.getModel(input)
+                #expect(model is OpenAIModel)
+            } catch {
+                Issue.record("Failed to resolve \(input): \(error)")
+            }
+        }
+    }
+}
\ No newline at end of file
diff --git a/Tests/TachikomaTests/StreamingAndToolTests.swift b/Tests/TachikomaTests/StreamingAndToolTests.swift
new file mode 100644
index 0000000..b40458d
--- /dev/null
+++ b/Tests/TachikomaTests/StreamingAndToolTests.swift
@@ -0,0 +1,439 @@
+import Foundation
+import Testing
+@testable import Tachikoma
+
+@Suite("Streaming Types Tests")
+struct StreamingTypesTests {
+    @Test("StreamEvent creation and types")
+    func streamEventCreationAndTypes() {
+        let events: [StreamEvent] = [
+            .contentDelta("Hello"),
+            .contentComplete("Hello, world!"),
+            .toolCallDelta("tool_123", "get_", "{}"),
+            .toolCallComplete("tool_123", "get_weather", "{\"location\": \"SF\"}"),
+            .reasoningDelta("I need to think..."),
+            .reasoningComplete("I need to think about this carefully."),
+            .done,
+            .error("Network error"),
+            .metadata(["usage": ["tokens": 42]]),
+        ]
+        
+        #expect(events.count == 9)
+        
+        // Test specific event properties
+        if case let .contentDelta(text) = events[0] {
+            #expect(text == "Hello")
+        } else {
+            Issue.record("Expected contentDelta event")
+        }
+        
+        if case let .toolCallDelta(id, name, args) = events[2] {
+            #expect(id == "tool_123")
+            #expect(name == "get_")
+            #expect(args == "{}")
+        } else {
+            Issue.record("Expected toolCallDelta event")
+        }
+        
+        if case .done = events[6] {
+            // Expected
+        } else {
+            Issue.record("Expected done event")
+        }
+    }
+
+    @Test("StreamEvent Codable")
+    func streamEventCodable() throws {
+        let originalEvents: [StreamEvent] = [
+            .contentDelta("Hello"),
+            .toolCallComplete("tool_123", "get_weather", "{\"location\": \"SF\"}"),
+            .done,
+            .error("Network error"),
+            .metadata(["usage": ["tokens": 42]]),
+        ]
+        
+        let encoder = JSONEncoder()
+        let decoder = JSONDecoder()
+        
+        for originalEvent in originalEvents {
+            let data = try encoder.encode(originalEvent)
+            let decodedEvent = try decoder.decode(StreamEvent.self, from: data)
+            
+            // Compare events (simplified comparison)
+            switch (originalEvent, decodedEvent) {
+            case let (.contentDelta(orig), .contentDelta(decoded)):
+                #expect(orig == decoded)
+            case let (.toolCallComplete(origId, origName, origArgs), .toolCallComplete(decodedId, decodedName, decodedArgs)):
+                #expect(origId == decodedId)
+                #expect(origName == decodedName)
+                #expect(origArgs == decodedArgs)
+            case (.done, .done):
+                // Expected
+                break
+            case let (.error(orig), .error(decoded)):
+                #expect(orig == decoded)
+            case (.metadata, .metadata):
+                // Metadata comparison is complex, just verify it decodes
+                break
+            default:
+                Issue.record("Event types don't match")
+            }
+        }
+    }
+
+    @Test("StreamingResponseIterator behavior")
+    func streamingResponseIteratorBehavior() async throws {
+        // Create a mock stream of events
+        let events: [StreamEvent] = [
+            .contentDelta("Hello"),
+            .contentDelta(" world"),
+            .contentComplete("Hello world!"),
+            .done
+        ]
+        
+        // Create an AsyncStream to simulate streaming
+        let stream = AsyncThrowingStream<StreamEvent, Error> { continuation in
+            Task {
+                for event in events {
+                    continuation.yield(event)
+                    try await Task.sleep(nanoseconds: 1_000_000) // 1ms delay
+                }
+                continuation.finish()
+            }
+        }
+        
+        // Collect events from the stream
+        var collectedEvents: [StreamEvent] = []
+        
+        do {
+            for try await event in stream {
+                collectedEvents.append(event)
+            }
+        } catch {
+            Issue.record("Stream iteration failed: \(error)")
+        }
+        
+        #expect(collectedEvents.count == 4)
+        
+        // Verify event sequence
+        if case let .contentDelta(text1) = collectedEvents[0] {
+            #expect(text1 == "Hello")
+        } else {
+            Issue.record("Expected first contentDelta")
+        }
+        
+        if case let .contentDelta(text2) = collectedEvents[1] {
+            #expect(text2 == " world")
+        } else {
+            Issue.record("Expected second contentDelta")
+        }
+        
+        if case .done = collectedEvents[3] {
+            // Expected
+        } else {
+            Issue.record("Expected done event at end")
+        }
+    }
+
+    @Test("StreamEvent error handling")
+    func streamEventErrorHandling() async throws {
+        let stream = AsyncThrowingStream<StreamEvent, Error> { continuation in
+            continuation.yield(.contentDelta("Hello"))
+            continuation.finish(throwing: TachikomaError.networkError("Connection lost"))
+        }
+        
+        var collectedEvents: [StreamEvent] = []
+        var caughtError: Error?
+        
+        do {
+            for try await event in stream {
+                collectedEvents.append(event)
+            }
+        } catch {
+            caughtError = error
+        }
+        
+        #expect(collectedEvents.count == 1)
+        #expect(caughtError is TachikomaError)
+        
+        if let tachikomaError = caughtError as? TachikomaError,
+           case let .networkError(message) = tachikomaError {
+            #expect(message == "Connection lost")
+        } else {
+            Issue.record("Expected TachikomaError.networkError")
+        }
+    }
+}
+
+// MARK: - Tool Definition Tests
+
+@Suite("Tool Definition Tests")
+struct ToolDefinitionTests {
+    @Test("Simple tool definition")
+    func simpleToolDefinition() {
+        let tool = ToolDefinition(
+            function: FunctionDefinition(
+                name: "get_time",
+                description: "Get the current time",
+                parameters: ToolParameters(
+                    properties: [:],
+                    required: []
+                )
+            )
+        )
+        
+        #expect(tool.function.name == "get_time")
+        #expect(tool.function.description == "Get the current time")
+        #expect(tool.function.parameters.properties.isEmpty)
+        #expect(tool.function.parameters.required.isEmpty)
+    }
+
+    @Test("Tool definition with parameters")
+    func toolDefinitionWithParameters() {
+        let tool = ToolDefinition(
+            function: FunctionDefinition(
+                name: "get_weather",
+                description: "Get weather information",
+                parameters: ToolParameters(
+                    type: "object",
+                    properties: [
+                        "location": ParameterSchema(
+                            type: .string,
+                            description: "The location to get weather for"
+                        ),
+                        "units": ParameterSchema(
+                            type: .string,
+                            description: "Temperature units",
+                            enumValues: ["celsius", "fahrenheit"]
+                        ),
+                        "include_forecast": ParameterSchema(
+                            type: .boolean,
+                            description: "Include forecast data"
+                        )
+                    ],
+                    required: ["location"]
+                )
+            )
+        )
+        
+        #expect(tool.function.name == "get_weather")
+        #expect(tool.function.parameters.properties.count == 3)
+        #expect(tool.function.parameters.required == ["location"])
+        
+        // Check parameter schemas
+        let locationParam = tool.function.parameters.properties["location"]
+        #expect(locationParam?.type == .string)
+        #expect(locationParam?.description == "The location to get weather for")
+        
+        let unitsParam = tool.function.parameters.properties["units"]
+        #expect(unitsParam?.enumValues == ["celsius", "fahrenheit"])
+    }
+
+    @Test("ParameterSchema types")
+    func parameterSchemaTypes() {
+        let schemas: [ParameterSchema] = [
+            ParameterSchema(type: .string, description: "A string value"),
+            ParameterSchema(type: .integer, description: "An integer value", minimum: 0, maximum: 100),
+            ParameterSchema(type: .number, description: "A number value"),
+            ParameterSchema(type: .boolean, description: "A boolean value"),
+            ParameterSchema(type: .array, description: "An array value"),
+            ParameterSchema(type: .object, description: "An object value"),
+        ]
+        
+        #expect(schemas.count == 6)
+        
+        // Test specific properties
+        let intSchema = schemas[1]
+        #expect(intSchema.type == .integer)
+        #expect(intSchema.minimum == 0)
+        #expect(intSchema.maximum == 100)
+    }
+
+    @Test("Tool parameters codable")
+    func toolParametersCodable() throws {
+        let original = ToolParameters(
+            type: "object",
+            properties: [
+                "name": ParameterSchema(type: .string, description: "Name field"),
+                "age": ParameterSchema(type: .integer, description: "Age field", minimum: 0),
+            ],
+            required: ["name"]
+        )
+        
+        let encoder = JSONEncoder()
+        let data = try encoder.encode(original)
+        
+        let decoder = JSONDecoder()
+        let decoded = try decoder.decode(ToolParameters.self, from: data)
+        
+        #expect(decoded.type == original.type)
+        #expect(decoded.properties.count == original.properties.count)
+        #expect(decoded.required == original.required)
+        
+        let nameParam = decoded.properties["name"]
+        #expect(nameParam?.type == .string)
+        #expect(nameParam?.description == "Name field")
+    }
+
+    @Test("Generic Tool creation")
+    func genericToolCreation() async throws {
+        // Context type for the tool
+        struct WeatherContext {
+            let apiKey: String
+        }
+        
+        // Create a generic tool
+        let weatherTool = Tool<WeatherContext>(
+            name: "get_weather",
+            description: "Get weather for a location",
+            parameters: ToolParameters(
+                properties: [
+                    "location": ParameterSchema(type: .string, description: "Location name")
+                ],
+                required: ["location"]
+            )
+        ) { input, context in
+            // Simulate tool execution
+            var location = "Unknown"
+            if case let .dictionary(dict) = input {
+                location = dict["location"] as? String ?? "Unknown"
+            }
+            return .string("Weather in \(location): 72°F and sunny (API key: \(context.apiKey.prefix(3))...)")
+        }
+        
+        // Convert to tool definition
+        let toolDef = weatherTool.toToolDefinition()
+        
+        #expect(toolDef.function.name == "get_weather")
+        #expect(toolDef.function.description == "Get weather for a location")
+        
+        // Test tool execution
+        let context = WeatherContext(apiKey: "test-api-key-123")
+        let input = ToolInput.dictionary(["location": "San Francisco"])
+        
+        let output = try await weatherTool.execute(input, context)
+        
+        if case let .string(result) = output {
+            #expect(result.contains("San Francisco"))
+            #expect(result.contains("test..."))
+        } else {
+            Issue.record("Expected string output")
+        }
+    }
+
+    @Test("ToolCallItem creation")
+    func toolCallItemCreation() {
+        let toolCall = ToolCallItem(
+            id: "call_abc123",
+            type: .function,
+            function: FunctionCall(
+                name: "calculate",
+                arguments: "{\"expression\": \"2 + 2\"}"
+            )
+        )
+        
+        #expect(toolCall.id == "call_abc123")
+        #expect(toolCall.type == .function)
+        #expect(toolCall.function.name == "calculate")
+        #expect(toolCall.function.arguments == "{\"expression\": \"2 + 2\"}")
+    }
+
+    @Test("ToolInput and ToolOutput")
+    func toolInputAndOutput() {
+        let input = ToolInput.dictionary([
+            "location": "Paris",
+            "units": "celsius"
+        ])
+        
+        if case let .dictionary(args) = input {
+            #expect(args["location"] as? String == "Paris")
+            #expect(args["units"] as? String == "celsius")
+        } else {
+            Issue.record("Expected dictionary input")
+        }
+        
+        let output = ToolOutput.string("Weather in Paris: 18°C and cloudy")
+        
+        if case let .string(content) = output {
+            #expect(content == "Weather in Paris: 18°C and cloudy")
+        } else {
+            Issue.record("Expected string output")
+        }
+    }
+
+    @Test("FunctionCall argument parsing")
+    func functionCallArgumentParsing() throws {
+        let functionCall = FunctionCall(
+            name: "get_weather",
+            arguments: "{\"location\": \"Tokyo\", \"units\": \"celsius\"}"
+        )
+        
+        #expect(functionCall.name == "get_weather")
+        #expect(functionCall.arguments == "{\"location\": \"Tokyo\", \"units\": \"celsius\"}")
+        
+        // Test parsing arguments as JSON
+        let data = functionCall.arguments.data(using: .utf8)!
+        let parsed = try JSONSerialization.jsonObject(with: data) as? [String: Any]
+        
+        #expect(parsed?["location"] as? String == "Tokyo")
+        #expect(parsed?["units"] as? String == "celsius")
+    }
+
+    @Test("ParameterSchema with complex properties")
+    func parameterSchemaWithComplexProperties() {
+        let schema = ParameterSchema(
+            type: .object,
+            description: "A complex object",
+            properties: [
+                "nested_string": ParameterSchema(type: .string, description: "Nested string"),
+                "nested_array": ParameterSchema(type: .array, description: "Nested array"),
+            ]
+        )
+        
+        #expect(schema.type == .object)
+        #expect(schema.properties?.count == 2)
+        
+        let nestedString = schema.properties?["nested_string"] as? ParameterSchema
+        #expect(nestedString?.type == .string)
+        #expect(nestedString?.description == "Nested string")
+    }
+
+    @Test("Tool definition JSON serialization")
+    func toolDefinitionJSONSerialization() throws {
+        let tool = ToolDefinition(
+            function: FunctionDefinition(
+                name: "calculate",
+                description: "Perform a calculation",
+                parameters: ToolParameters(
+                    type: "object",
+                    properties: [
+                        "expression": ParameterSchema(
+                            type: .string,
+                            description: "Mathematical expression to evaluate"
+                        )
+                    ],
+                    required: ["expression"]
+                )
+            )
+        )
+        
+        let encoder = JSONEncoder()
+        encoder.outputFormatting = .prettyPrinted
+        
+        let jsonData = try encoder.encode(tool)
+        let jsonString = String(data: jsonData, encoding: .utf8)!
+        
+        #expect(jsonString.contains("calculate"))
+        #expect(jsonString.contains("Perform a calculation"))
+        #expect(jsonString.contains("expression"))
+        #expect(jsonString.contains("Mathematical expression"))
+        
+        // Test round-trip encoding/decoding
+        let decoder = JSONDecoder()
+        let decoded = try decoder.decode(ToolDefinition.self, from: jsonData)
+        
+        #expect(decoded.function.name == tool.function.name)
+        #expect(decoded.function.description == tool.function.description)
+        #expect(decoded.function.parameters.required == tool.function.parameters.required)
+    }
+}
\ No newline at end of file
diff --git a/Tests/TachikomaTests/TachikomaCoreTests.swift b/Tests/TachikomaTests/TachikomaCoreTests.swift
new file mode 100644
index 0000000..06cd39f
--- /dev/null
+++ b/Tests/TachikomaTests/TachikomaCoreTests.swift
@@ -0,0 +1,507 @@
+import Foundation
+import Testing
+@testable import Tachikoma
+
+@Suite("Tachikoma Core Tests")
+struct TachikomaCoreTests {
+    @Test("Tachikoma singleton initialization")
+    func singletonInitialization() async throws {
+        let tachikoma1 = Tachikoma.shared
+        let tachikoma2 = Tachikoma.shared
+        
+        // Should be the same instance
+        #expect(tachikoma1 === tachikoma2)
+    }
+
+    @Test("Model registration and retrieval")
+    func modelRegistrationAndRetrieval() async throws {
+        let tachikoma = Tachikoma.shared
+
+        // Register a test model
+        await tachikoma.registerModel(name: "test-model", factory: {
+            OpenAIModel(apiKey: "test-key", modelName: "gpt-4.1")
+        })
+
+        // Should be able to retrieve it
+        do {
+            let model = try await tachikoma.getModel("test-model")
+            #expect(model is OpenAIModel)
+        } catch {
+            Issue.record("Failed to retrieve registered model: \(error)")
+        }
+    }
+
+    @Test("Model not found error")
+    func modelNotFoundError() async throws {
+        let tachikoma = Tachikoma.shared
+
+        // Should throw error for non-existent model
+        do {
+            _ = try await tachikoma.getModel("nonexistent-model")
+            Issue.record("Expected error for nonexistent model")
+        } catch let error as TachikomaError {
+            switch error {
+            case .modelNotFound:
+                // Expected
+                break
+            default:
+                Issue.record("Expected modelNotFound error, got: \(error)")
+            }
+        }
+    }
+
+    @Test("Provider configuration")
+    func providerConfiguration() async throws {
+        let tachikoma = Tachikoma.shared
+
+        // Test OpenAI configuration
+        let openaiConfig = ProviderConfiguration.OpenAI(
+            apiKey: "test-key",
+            baseURL: URL(string: "https://api.openai.com/v1")!
+        )
+        await tachikoma.configureOpenAI(openaiConfig)
+
+        // Test Anthropic configuration
+        let anthropicConfig = ProviderConfiguration.Anthropic(
+            apiKey: "test-key",
+            baseURL: URL(string: "https://api.anthropic.com/v1")!
+        )
+        await tachikoma.configureAnthropic(anthropicConfig)
+
+        // Test Grok configuration
+        let grokConfig = ProviderConfiguration.Grok(
+            apiKey: "test-key",
+            baseURL: URL(string: "https://api.x.ai/v1")!
+        )
+        await tachikoma.configureGrok(grokConfig)
+
+        // Test Ollama configuration
+        let ollamaConfig = ProviderConfiguration.Ollama(
+            baseURL: URL(string: "http://localhost:11434")!
+        )
+        await tachikoma.configureOllama(ollamaConfig)
+    }
+
+    @Test("Model factory functions")
+    func modelFactoryFunctions() async throws {
+        let tachikoma = Tachikoma.shared
+
+        // Test that factory functions work correctly
+        await tachikoma.registerModel(name: "factory-openai", factory: {
+            OpenAIModel(apiKey: "test-key", modelName: "gpt-4.1")
+        })
+
+        await tachikoma.registerModel(name: "factory-anthropic", factory: {
+            AnthropicModel(apiKey: "test-key", modelName: "claude-opus-4-20250514")
+        })
+
+        await tachikoma.registerModel(name: "factory-grok", factory: {
+            GrokModel(apiKey: "test-key", modelName: "grok-4")
+        })
+
+        await tachikoma.registerModel(name: "factory-ollama", factory: {
+            OllamaModel(modelName: "llama3.3")
+        })
+
+        // Test retrieval
+        let modelNames = ["factory-openai", "factory-anthropic", "factory-grok", "factory-ollama"]
+        
+        for modelName in modelNames {
+            do {
+                let model = try await tachikoma.getModel(modelName)
+                #expect(model is any ModelInterface)
+            } catch {
+                Issue.record("Failed to get \(modelName): \(error)")
+            }
+        }
+    }
+
+    @Test("Concurrent model access")
+    func concurrentModelAccess() async throws {
+        let tachikoma = Tachikoma.shared
+
+        // Register a model
+        await tachikoma.registerModel(name: "concurrent-test", factory: {
+            OpenAIModel(apiKey: "test-key", modelName: "gpt-4.1")
+        })
+
+        // Access it concurrently
+        await withTaskGroup(of: Void.self) { group in
+            for i in 0..<10 {
+                group.addTask {
+                    do {
+                        let model = try await tachikoma.getModel("concurrent-test")
+                        #expect(model is OpenAIModel)
+                    } catch {
+                        Issue.record("Concurrent access failed for iteration \(i): \(error)")
+                    }
+                }
+            }
+        }
+    }
+}
+
+// MARK: - Message Type Tests
+
+@Suite("Message Type Tests")
+struct MessageTypeTests {
+    @Test("System message creation")
+    func systemMessageCreation() {
+        let message = Message.system(content: "You are a helpful assistant.")
+        
+        if case let .system(id, content) = message {
+            #expect(id == nil)
+            #expect(content == "You are a helpful assistant.")
+        } else {
+            Issue.record("Expected system message")
+        }
+    }
+
+    @Test("User message with text content")
+    func userMessageWithTextContent() {
+        let message = Message.user(content: .text("Hello, AI!"))
+        
+        if case let .user(id, content) = message {
+            #expect(id == nil)
+            if case let .text(text) = content {
+                #expect(text == "Hello, AI!")
+            } else {
+                Issue.record("Expected text content")
+            }
+        } else {
+            Issue.record("Expected user message")
+        }
+    }
+
+    @Test("User message with multimodal content")
+    func userMessageWithMultimodalContent() {
+        let imageData = Data([0xFF, 0xD8, 0xFF])
+        let message = Message.user(content: .multimodal([
+            .text("What's in this image?"),
+            .imageUrl(ImageUrl(base64: imageData.base64EncodedString()))
+        ]))
+        
+        if case let .user(_, content) = message {
+            if case let .multimodal(parts) = content {
+                #expect(parts.count == 2)
+                
+                if case let .text(text) = parts[0] {
+                    #expect(text == "What's in this image?")
+                } else {
+                    Issue.record("Expected text part at index 0")
+                }
+                
+                if case .imageUrl = parts[1] {
+                    // Expected image part
+                } else {
+                    Issue.record("Expected image part at index 1")
+                }
+            } else {
+                Issue.record("Expected multimodal content")
+            }
+        } else {
+            Issue.record("Expected user message")
+        }
+    }
+
+    @Test("Assistant message creation")
+    func assistantMessageCreation() {
+        let message = Message.assistant(content: [
+            .outputText("Hello! How can I help you?")
+        ])
+        
+        if case let .assistant(id, content, status) = message {
+            #expect(id == nil)
+            #expect(status == .completed)
+            #expect(content.count == 1)
+            
+            if case let .outputText(text) = content[0] {
+                #expect(text == "Hello! How can I help you?")
+            } else {
+                Issue.record("Expected output text content")
+            }
+        } else {
+            Issue.record("Expected assistant message")
+        }
+    }
+
+    @Test("Tool call message")
+    func toolCallMessage() {
+        let toolCall = ToolCallItem(
+            id: "call_123",
+            type: .function,
+            function: FunctionCall(
+                name: "get_weather",
+                arguments: "{\"location\": \"San Francisco\"}"
+            )
+        )
+        
+        let message = Message.assistant(content: [.toolCall(toolCall)])
+        
+        if case let .assistant(_, content, _) = message {
+            if case let .toolCall(call) = content[0] {
+                #expect(call.id == "call_123")
+                #expect(call.function.name == "get_weather")
+                #expect(call.function.arguments == "{\"location\": \"San Francisco\"}")
+            } else {
+                Issue.record("Expected tool call content")
+            }
+        } else {
+            Issue.record("Expected assistant message")
+        }
+    }
+
+    @Test("Tool result message")
+    func toolResultMessage() {
+        let message = Message.tool(
+            toolCallId: "call_123",
+            content: "The weather in San Francisco is 72°F and sunny."
+        )
+        
+        if case let .tool(id, toolCallId, content) = message {
+            #expect(id == nil)
+            #expect(toolCallId == "call_123")
+            #expect(content == "The weather in San Francisco is 72°F and sunny.")
+        } else {
+            Issue.record("Expected tool message")
+        }
+    }
+
+    @Test("Reasoning message")
+    func reasoningMessage() {
+        let message = Message.reasoning(content: "Let me think about this step by step...")
+        
+        if case let .reasoning(id, content) = message {
+            #expect(id == nil)
+            #expect(content == "Let me think about this step by step...")
+        } else {
+            Issue.record("Expected reasoning message")
+        }
+    }
+
+    @Test("Message with custom ID")
+    func messageWithCustomID() {
+        let message = Message.user(id: "custom-123", content: .text("Hello"))
+        
+        if case let .user(id, _) = message {
+            #expect(id == "custom-123")
+        } else {
+            Issue.record("Expected user message with custom ID")
+        }
+    }
+
+    @Test("Message type property")
+    func messageTypeProperty() {
+        let messages: [Message] = [
+            .system(content: "System"),
+            .user(content: .text("User")),
+            .assistant(content: [.outputText("Assistant")]),
+            .tool(toolCallId: "call", content: "Tool"),
+            .reasoning(content: "Reasoning")
+        ]
+        
+        let expectedTypes: [MessageType] = [.system, .user, .assistant, .tool, .reasoning]
+        
+        for (message, expectedType) in zip(messages, expectedTypes) {
+            #expect(message.type == expectedType)
+        }
+    }
+}
+
+// MARK: - MessageContent Tests
+
+@Suite("MessageContent Tests")
+struct MessageContentTests {
+    @Test("Text content")
+    func textContent() {
+        let content = MessageContent.text("Hello, world!")
+        
+        if case let .text(text) = content {
+            #expect(text == "Hello, world!")
+        } else {
+            Issue.record("Expected text content")
+        }
+    }
+
+    @Test("Image content with base64")
+    func imageContentWithBase64() {
+        let imageData = Data([0xFF, 0xD8, 0xFF])
+        let imageUrl = ImageUrl(base64: imageData.base64EncodedString())
+        let content = MessageContent.image(imageUrl)
+        
+        if case let .image(url) = content {
+            #expect(url.base64 == imageData.base64EncodedString())
+            #expect(url.url == nil)
+        } else {
+            Issue.record("Expected image content")
+        }
+    }
+
+    @Test("Image content with URL")
+    func imageContentWithURL() {
+        let imageUrl = ImageUrl(url: "https://example.com/image.jpg")
+        let content = MessageContent.image(imageUrl)
+        
+        if case let .image(url) = content {
+            #expect(url.url == "https://example.com/image.jpg")
+            #expect(url.base64 == nil)
+        } else {
+            Issue.record("Expected image content")
+        }
+    }
+
+    @Test("Audio content")
+    func audioContent() {
+        let audioData = AudioContent(
+            transcript: "Hello, this is a test.",
+            duration: 5.0
+        )
+        let content = MessageContent.audio(audioData)
+        
+        if case let .audio(audio) = content {
+            #expect(audio.transcript == "Hello, this is a test.")
+            #expect(audio.duration == 5.0)
+        } else {
+            Issue.record("Expected audio content")
+        }
+    }
+
+    @Test("File content")
+    func fileContent() {
+        let fileData = FileContent(
+            filename: "test.txt",
+            content: "File content here",
+            mimeType: "text/plain"
+        )
+        let content = MessageContent.file(fileData)
+        
+        if case let .file(file) = content {
+            #expect(file.filename == "test.txt")
+            #expect(file.content == "File content here")
+            #expect(file.mimeType == "text/plain")
+        } else {
+            Issue.record("Expected file content")
+        }
+    }
+
+    @Test("Multimodal content")
+    func multimodalContent() {
+        let parts: [MessageContentPart] = [
+            .text("Describe this image:"),
+            .imageUrl(ImageUrl(url: "https://example.com/image.jpg")),
+            .text("What do you see?")
+        ]
+        let content = MessageContent.multimodal(parts)
+        
+        if case let .multimodal(contentParts) = content {
+            #expect(contentParts.count == 3)
+            
+            #expect(contentParts[0].type == "text")
+            #expect(contentParts[0].text == "Describe this image:")
+            
+            #expect(contentParts[1].type == "image")
+            #expect(contentParts[1].imageUrl != nil)
+            
+            #expect(contentParts[2].type == "text")
+            #expect(contentParts[2].text == "What do you see?")
+        } else {
+            Issue.record("Expected multimodal content")
+        }
+    }
+}
+
+// MARK: - Error Handling Tests
+
+@Suite("Error Handling Tests")
+struct ErrorHandlingTests {
+    @Test("TachikomaError cases")
+    func tachikomaErrorCases() {
+        let errors: [TachikomaError] = [
+            .modelNotFound("test-model"),
+            .invalidRequest("Invalid parameters"),
+            .authenticationFailed,
+            .apiError(message: "Rate limit exceeded", code: "429"),
+            .networkError(underlying: URLError(.notConnectedToInternet)),
+            .configurationError("Missing configuration"),
+            .streamingError("Stream interrupted"),
+        ]
+        
+        // Verify all error cases can be created
+        #expect(errors.count == 9)
+        
+        // Test error descriptions
+        for error in errors {
+            let description = error.localizedDescription
+            #expect(!description.isEmpty)
+        }
+    }
+
+    @Test("Error equality")
+    func errorEquality() {
+        let error1 = TachikomaError.modelNotFound("test")
+        let error2 = TachikomaError.modelNotFound("test")
+        let error3 = TachikomaError.modelNotFound("different")
+        
+        #expect(error1.localizedDescription == error2.localizedDescription)
+        #expect(error1.localizedDescription != error3.localizedDescription)
+    }
+}
+
+// MARK: - Model Settings Tests
+
+@Suite("Model Settings Tests")
+struct ModelSettingsTests {
+    @Test("Default model settings")
+    func defaultModelSettings() {
+        let settings = ModelSettings(modelName: "test-model")
+        
+        #expect(settings.modelName == "test-model")
+        #expect(settings.temperature == nil)
+        #expect(settings.maxTokens == nil)
+        #expect(settings.topP == nil)
+        #expect(settings.frequencyPenalty == nil)
+        #expect(settings.presencePenalty == nil)
+        #expect(settings.stopSequences == nil)
+        #expect(settings.seed == nil)
+        #expect(settings.toolChoice == nil)
+        #expect(settings.parallelToolCalls == nil)
+        #expect(settings.additionalParameters == nil)
+    }
+
+    @Test("Custom model settings")
+    func customModelSettings() {
+        var additionalParams = ModelParameters()
+        additionalParams.set("apiType", value: "chat")
+        additionalParams.set("reasoningEffort", value: "medium")
+        additionalParams.set("reasoning", value: ["summary": "detailed"])
+        additionalParams.set("logprobs", value: true)
+        additionalParams.set("topLogprobs", value: 5)
+        
+        let settings = ModelSettings(
+            modelName: "test-model",
+            temperature: 0.7,
+            topP: 0.9,
+            maxTokens: 1000,
+            frequencyPenalty: 0.1,
+            presencePenalty: 0.2,
+            stopSequences: ["STOP"],
+            toolChoice: .auto,
+            parallelToolCalls: true,
+            seed: 42,
+            additionalParameters: additionalParams
+        )
+        
+        #expect(settings.modelName == "test-model")
+        #expect(settings.temperature == 0.7)
+        #expect(settings.maxTokens == 1000)
+        #expect(settings.topP == 0.9)
+        #expect(settings.frequencyPenalty == 0.1)
+        #expect(settings.presencePenalty == 0.2)
+        #expect(settings.stopSequences == ["STOP"])
+        #expect(settings.seed == 42)
+        #expect(settings.toolChoice == .auto)
+        #expect(settings.parallelToolCalls == true)
+        #expect(settings.additionalParameters?.get("apiType") as? String == "chat")
+        #expect(settings.additionalParameters?.get("reasoningEffort") as? String == "medium")
+    }
+}
\ No newline at end of file
diff --git a/assets/logo.png b/assets/logo.png
new file mode 100644
index 0000000000000000000000000000000000000000..6681c8edb46668adbb1a9ec803569f8a61c72fe8
GIT binary patch
literal 341825
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%0ANSBko?EEI-7lK==2Rf;9{Zre`n-yIge
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%0DwRwnC#9}DYbXDm<R&_(o`W)@`_1g
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%0D156S8M_-`|
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

literal 0
HcmV?d00001