dspy-openai 1.0.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: e6c2209a6cdc9e1eba041246f0c8450fe569fcb0e7b7bf7be9988e24ac305f89
+  data.tar.gz: 43c0139cde022436be8b30ab36a5e42a68b1ee445161e8ba00c3571a51c0a962
+SHA512:
+  metadata.gz: 6e85f8eb04fc8bb782ff35221da6de10b52f3786d4065aded4ea1a61a484770925679cc2fdc9714482128c8bcf6e1d79c9600134d42258e60b6a2819b89e7e45
+  data.tar.gz: 90848415fb21d32cf14445abcca2049b136a61c7ffd98476ef6b7439fdd5c96c46819829d82a0a96f1df524f4c0e3ebdcf2f4593f1b5d195d1d65cd709d0ec14

data/LICENSE

@@ -0,0 +1,45 @@
+MIT License
+
+Copyright (c) 2025 Vicente Services SL
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
+
+This project is a Ruby port of the original Python [DSPy library](https://github.com/stanfordnlp/dspy), which is licensed under the MIT License:
+
+MIT License
+
+Copyright (c) 2023 Stanford Future Data Systems
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

data/README.md

@@ -0,0 +1,292 @@
+# DSPy.rb
+
+[![Gem Version](https://img.shields.io/gem/v/dspy)](https://rubygems.org/gems/dspy)
+[![Total Downloads](https://img.shields.io/gem/dt/dspy)](https://rubygems.org/gems/dspy)
+[![Build Status](https://img.shields.io/github/actions/workflow/status/vicentereig/dspy.rb/ruby.yml?branch=main&label=build)](https://github.com/vicentereig/dspy.rb/actions/workflows/ruby.yml)
+[![Documentation](https://img.shields.io/badge/docs-vicentereig.github.io%2Fdspy.rb-blue)](https://vicentereig.github.io/dspy.rb/)
+[![Discord](https://img.shields.io/discord/1161519468141355160?label=discord&logo=discord&logoColor=white)](https://discord.gg/zWBhrMqn)
+
+> [!NOTE]
+> The core Prompt Engineering Framework is production-ready with
+> comprehensive documentation. I am focusing now on educational content on systematic Prompt Optimization and Context Engineering.
+> Your feedback is invaluable. if you encounter issues, please open an [issue](https://github.com/vicentereig/dspy.rb/issues). If you have suggestions, open a [new thread](https://github.com/vicentereig/dspy.rb/discussions).  
+> 
+> If you want to contribute, feel free to reach out to me to coordinate efforts: hey at vicente.services
+>
+> And, yes, this is 100% a legit project. :) 
+
+
+**Build reliable LLM applications in idiomatic Ruby using composable, type-safe modules.**
+
+DSPy.rb is the Ruby-first surgical port of Stanford's [DSPy framework](https://github.com/stanfordnlp/dspy). It delivers structured LLM programming, prompt engineering, and context engineering in the language we love. Instead of wrestling with brittle prompt strings, you define typed signatures in idiomatic Ruby and compose workflows and agents that actually behave.
+
+**Prompts are just functions.** Traditional prompting is like writing code with string concatenation: it works until it doesn't. DSPy.rb brings you the programming approach pioneered by [dspy.ai](https://dspy.ai/): define modular signatures and let the framework deal with the messy bits.
+
+While we implement the same signatures, predictors, and optimization algorithms as the original library, DSPy.rb leans hard into Ruby conventions with Sorbet-based typing, ReAct loops, and production-ready integrations like non-blocking OpenTelemetry instrumentation.
+
+**What you get?** Ruby LLM applications that scale and don't break when you sneeze.
+
+Check the [examples](examples/) and take them for a spin!
+
+## Your First DSPy Program
+### Installation
+
+Add to your Gemfile:
+
+```ruby
+gem 'dspy'
+```
+
+and
+
+```bash
+bundle install
+```
+
+### Your First Reliable Predictor
+
+```ruby
+require 'dspy'
+
+# Configure DSPy globally to use your fave LLM (you can override per predictor).
+DSPy.configure do |c|
+  c.lm = DSPy::LM.new('openai/gpt-4o-mini',
+                      api_key: ENV['OPENAI_API_KEY'],
+                      structured_outputs: true)  # Enable OpenAI's native JSON mode
+end
+
+# Define a signature for sentiment classification - instead of writing a full prompt!
+class Classify < DSPy::Signature
+  description "Classify sentiment of a given sentence." # sets the goal of the underlying prompt
+
+  class Sentiment < T::Enum
+    enums do
+      Positive = new('positive')
+      Negative = new('negative')
+      Neutral = new('neutral')
+    end
+  end
+  
+  # Structured Inputs: makes sure you are sending only valid prompt inputs to your model
+  input do
+    const :sentence, String, description: 'The sentence to analyze'
+  end
+
+  # Structured Outputs: your predictor will validate the output of the model too.
+  output do
+    const :sentiment, Sentiment, description: 'The sentiment of the sentence'
+    const :confidence, Float, description: 'A number between 0.0 and 1.0'
+  end
+end
+
+# Wire it to the simplest prompting technique: a prediction loop.
+classify = DSPy::Predict.new(Classify)
+# it may raise an error if you mess the inputs or your LLM messes the outputs.
+result = classify.call(sentence: "This book was super fun to read!")
+
+puts result.sentiment    # => #<Sentiment::Positive>  
+puts result.confidence   # => 0.85
+```
+
+Save this as `examples/first_predictor.rb` and run it with:
+
+```bash
+bundle exec ruby examples/first_predictor.rb
+```
+
+### Sibling Gems
+
+DSPy.rb ships multiple gems from this monorepo so you can opt into features with heavier dependency trees (e.g., datasets pull in Polars/Arrow, MIPROv2 requires `numo-*` BLAS bindings) only when you need them. Add these alongside `dspy`:
+
+| Gem | Description | Status |
+| --- | --- | --- |
+| `dspy-schema` | Exposes `DSPy::TypeSystem::SorbetJsonSchema` for downstream reuse. (Still required by the core `dspy` gem; extraction lets other projects depend on it directly.) | **Stable** (v1.0.0) |
+| `dspy-code_act` | Think-Code-Observe agents that synthesize and execute Ruby safely. (Add the gem or set `DSPY_WITH_CODE_ACT=1` before requiring `dspy/code_act`.) | **Stable** (v1.0.0) |
+| `dspy-datasets` | Dataset helpers plus Parquet/Polars tooling for richer evaluation corpora. (Toggle via `DSPY_WITH_DATASETS`.) | **Stable** (v1.0.0) |
+| `dspy-evals` | High-throughput evaluation harness with metrics, callbacks, and regression fixtures. (Toggle via `DSPY_WITH_EVALS`.) | **Stable** (v1.0.0) |
+| `dspy-miprov2` | Bayesian optimization + Gaussian Process backend for the MIPROv2 teleprompter. (Install or export `DSPY_WITH_MIPROV2=1` before requiring the teleprompter.) | **Stable** (v1.0.0) |
+| `dspy-gepa` | `DSPy::Teleprompt::GEPA`, reflection loops, experiment tracking, telemetry adapters. (Install or set `DSPY_WITH_GEPA=1`.) | **Stable** (v1.0.0) |
+| `gepa` | GEPA optimizer core (Pareto engine, telemetry, reflective proposer). | **Stable** (v1.0.0) |
+| `dspy-o11y` | Core observability APIs: `DSPy::Observability`, async span processor, observation types. (Install or set `DSPY_WITH_O11Y=1`.) | **Stable** (v1.0.0) |
+| `dspy-o11y-langfuse` | Auto-configures DSPy observability to stream spans to Langfuse via OTLP. (Install or set `DSPY_WITH_O11Y_LANGFUSE=1`.) | **Stable** (v1.0.0) |
+| `dspy-deep_search` | Production DeepSearch loop with Exa-backed search/read, token budgeting, and instrumentation (Issue #163). | **Stable** (v1.0.0) |
+| `dspy-deep_research` | Planner/QA orchestration atop DeepSearch plus the memory supervisor used by the CLI example. | **Stable** (v1.0.0) |
+
+Set the matching `DSPY_WITH_*` environment variables (see `Gemfile`) to include or exclude each sibling gem when running Bundler locally (for example `DSPY_WITH_GEPA=1` or `DSPY_WITH_O11Y_LANGFUSE=1`). Refer to `adr/013-dependency-tree.md` for the full dependency map and roadmap.
+### Access to 200+ Models Across 5 Providers
+
+DSPy.rb provides unified access to major LLM providers with provider-specific optimizations:
+
+```ruby
+# OpenAI (GPT-4, GPT-4o, GPT-4o-mini, GPT-5, etc.)
+DSPy.configure do |c|
+  c.lm = DSPy::LM.new('openai/gpt-4o-mini',
+                      api_key: ENV['OPENAI_API_KEY'],
+                      structured_outputs: true)  # Native JSON mode
+end
+
+# Google Gemini (Gemini 1.5 Pro, Flash, Gemini 2.0, etc.)
+DSPy.configure do |c|
+  c.lm = DSPy::LM.new('gemini/gemini-2.5-flash',
+                      api_key: ENV['GEMINI_API_KEY'],
+                      structured_outputs: true)  # Native structured outputs
+end
+
+# Anthropic Claude (Claude 3.5, Claude 4, etc.)
+DSPy.configure do |c|
+  c.lm = DSPy::LM.new('anthropic/claude-sonnet-4-5-20250929',
+                      api_key: ENV['ANTHROPIC_API_KEY'],
+                      structured_outputs: true)  # Tool-based extraction (default)
+end
+
+# Ollama - Run any local model (Llama, Mistral, Gemma, etc.)
+DSPy.configure do |c|
+  c.lm = DSPy::LM.new('ollama/llama3.2')  # Free, runs locally, no API key needed
+end
+
+# OpenRouter - Access to 200+ models from multiple providers
+DSPy.configure do |c|
+  c.lm = DSPy::LM.new('openrouter/deepseek/deepseek-chat-v3.1:free',
+                      api_key: ENV['OPENROUTER_API_KEY'])
+end
+```
+
+## What You Get
+
+**Developer Experience:** Official clients, multimodal coverage, and observability baked in.
+<details>
+<summary>Expand for everything included</summary>
+
+- LLM provider support using official Ruby clients:
+  - [OpenAI Ruby](https://github.com/openai/openai-ruby) with vision model support
+  - [Anthropic Ruby SDK](https://github.com/anthropics/anthropic-sdk-ruby) with multimodal capabilities
+  - [Google Gemini API](https://ai.google.dev/) with native structured outputs
+  - [Ollama](https://ollama.com/) via OpenAI compatibility layer for local models
+- **Multimodal Support** - Complete image analysis with DSPy::Image, type-safe bounding boxes, vision-capable models
+- Runtime type checking with [Sorbet](https://sorbet.org/) including T::Enum and union types
+- Type-safe tool definitions for ReAct agents
+- Comprehensive instrumentation and observability
+</details>
+
+**Core Building Blocks:** Predictors, agents, and pipelines wired through type-safe signatures.
+<details>
+<summary>Expand for everything included</summary>
+
+- **Signatures** - Define input/output schemas using Sorbet types with T::Enum and union type support
+- **Predict** - LLM completion with structured data extraction and multimodal support
+- **Chain of Thought** - Step-by-step reasoning for complex problems with automatic prompt optimization
+- **ReAct** - Tool-using agents with type-safe tool definitions and error recovery
+- **Module Composition** - Combine multiple LLM calls into production-ready workflows
+</details>
+
+**Optimization & Evaluation:** Treat prompt optimization like a real ML workflow.
+<details>
+<summary>Expand for everything included</summary>
+
+- **Prompt Objects** - Manipulate prompts as first-class objects instead of strings
+- **Typed Examples** - Type-safe training data with automatic validation
+- **Evaluation Framework** - Advanced metrics beyond simple accuracy with error-resilient pipelines
+- **MIPROv2 Optimization** - Advanced Bayesian optimization with Gaussian Processes, multiple optimization strategies, auto-config presets, and storage persistence
+</details>
+
+**Production Features:** Hardened behaviors for teams shipping actual products.
+<details>
+<summary>Expand for everything included</summary>
+
+- **Reliable JSON Extraction** - Native structured outputs for OpenAI and Gemini, Anthropic tool-based extraction, and automatic strategy selection with fallback
+- **Type-Safe Configuration** - Strategy enums with automatic provider optimization (Strict/Compatible modes)
+- **Smart Retry Logic** - Progressive fallback with exponential backoff for handling transient failures
+- **Zero-Config Langfuse Integration** - Set env vars and get automatic OpenTelemetry traces in Langfuse
+- **Performance Caching** - Schema and capability caching for faster repeated operations
+- **File-based Storage** - Optimization result persistence with versioning
+- **Structured Logging** - JSON and key=value formats with span tracking
+</details>
+
+## Recent Achievements
+
+DSPy.rb has gone from experimental to production-ready in three fast releases.
+<details>
+<summary>Expand for the full changelog highlights</summary>
+
+### Foundation
+- ✅ **JSON Parsing Reliability** - Native OpenAI structured outputs with adaptive retry logic and schema-aware fallbacks
+- ✅ **Type-Safe Strategy Configuration** - Provider-optimized strategy selection and enum-backed optimizer presets
+- ✅ **Core Module System** - Predict, ChainOfThought, ReAct with type safety (add `dspy-code_act` for Think-Code-Observe agents)
+- ✅ **Production Observability** - OpenTelemetry, New Relic, and Langfuse integration
+- ✅ **Advanced Optimization** - MIPROv2 with Bayesian optimization, Gaussian Processes, and multi-mode search
+
+### Recent Advances
+- ✅ **MIPROv2 ADE Integrity (v0.29.1)** - Stratified train/val/test splits, honest precision accounting, and enum-driven `--auto` presets with integration coverage
+- ✅ **Instruction Deduplication (v0.29.1)** - Candidate generation now filters repeated programs so optimization logs highlight unique strategies
+- ✅ **GEPA Teleprompter (v0.29.0)** - Genetic-Pareto reflective prompt evolution with merge proposer scheduling, reflective mutation, and ADE demo parity
+- ✅ **Optimizer Utilities Parity (v0.29.0)** - Bootstrap strategies, dataset summaries, and Layer 3 utilities unlock multi-predictor programs on Ruby
+- ✅ **Observability Hardening (v0.29.0)** - OTLP exporter runs on a single-thread executor preventing frozen SSL contexts without blocking spans
+- ✅ **Documentation Refresh (v0.29.x)** - New GEPA guide plus ADE optimization docs covering presets, stratified splits, and error-handling defaults
+</details>
+
+**Current Focus Areas:** Closing the loop on production patterns and community adoption ahead of v1.0.
+<details>
+<summary>Expand for the roadmap</summary>
+
+### Production Readiness
+- 🚧 **Production Patterns** - Real-world usage validation and performance optimization
+- 🚧 **Ruby Ecosystem Integration** - Rails integration, Sidekiq compatibility, deployment patterns
+
+### Community & Adoption
+- 🚧 **Community Examples** - Real-world applications and case studies
+- 🚧 **Contributor Experience** - Making it easier to contribute and extend
+- 🚧 **Performance Benchmarks** - Comparative analysis vs other frameworks
+</details>
+
+**v1.0 Philosophy:** v1.0 lands after battle-testing, not checkbox bingo. The API is already stable; the milestone marks production confidence.
+
+
+## Documentation
+
+📖 **[Complete Documentation Website](https://vicentereig.github.io/dspy.rb/)**
+
+### LLM-Friendly Documentation
+
+For LLMs and AI assistants working with DSPy.rb:
+- **[llms.txt](https://vicentereig.github.io/dspy.rb/llms.txt)** - Concise reference optimized for LLMs
+- **[llms-full.txt](https://vicentereig.github.io/dspy.rb/llms-full.txt)** - Comprehensive API documentation
+
+### Getting Started
+- **[Installation & Setup](docs/src/getting-started/installation.md)** - Detailed installation and configuration
+- **[Quick Start Guide](docs/src/getting-started/quick-start.md)** - Your first DSPy programs
+- **[Core Concepts](docs/src/getting-started/core-concepts.md)** - Understanding signatures, predictors, and modules
+
+### Prompt Engineering
+- **[Signatures & Types](docs/src/core-concepts/signatures.md)** - Define typed interfaces for LLM operations
+- **[Predictors](docs/src/core-concepts/predictors.md)** - Predict, ChainOfThought, ReAct, and more
+- **[Modules & Pipelines](docs/src/core-concepts/modules.md)** - Compose complex multi-stage workflows
+- **[Multimodal Support](docs/src/core-concepts/multimodal.md)** - Image analysis with vision-capable models
+- **[Examples & Validation](docs/src/core-concepts/examples.md)** - Type-safe training data
+- **[Rich Types](docs/src/advanced/complex-types.md)** - Sorbet type integration with automatic coercion for structs, enums, and arrays
+- **[Composable Pipelines](docs/src/advanced/pipelines.md)** - Manual module composition patterns
+
+### Prompt Optimization
+- **[Evaluation Framework](docs/src/optimization/evaluation.md)** - Advanced metrics beyond simple accuracy
+- **[Prompt Optimization](docs/src/optimization/prompt-optimization.md)** - Manipulate prompts as objects
+- **[MIPROv2 Optimizer](docs/src/optimization/miprov2.md)** - Advanced Bayesian optimization with Gaussian Processes
+- **[GEPA Optimizer](docs/src/optimization/gepa.md)** *(beta)* - Reflective mutation with optional reflection LMs
+
+### Context Engineering
+- **[Tools](docs/src/core-concepts/toolsets.md)** - Tool wieldint agents.
+- **[Agentic Memory](docs/src/core-concepts/memory.md)** - Memory Tools & Agentic Loops
+- **[RAG Patterns](docs/src/advanced/rag.md)** - Manual RAG implementation with external services
+
+### Production Features
+- **[Observability](docs/src/production/observability.md)** - Zero-config Langfuse integration with a dedicated export worker that never blocks your LLMs
+- **[Storage System](docs/src/production/storage.md)** - Persistence and optimization result storage
+- **[Custom Metrics](docs/src/advanced/custom-metrics.md)** - Proc-based evaluation logic 
+
+
+
+
+
+
+
+
+## License
+This project is licensed under the MIT License.

data/lib/dspy/openai/README.md

@@ -0,0 +1,40 @@
+# DSPy OpenAI adapter gem
+
+`dspy-openai` packages the OpenAI-compatible adapters for DSPy.rb so we can keep the core `dspy` gem lean while still talking to GPT models (and any OpenAI-compatible endpoint). Install it whenever your project needs to invoke `openai/*`, `openrouter/*`, or `ollama/*` models through DSPy.
+
+## When you need it
+- You call `DSPy::LM.new` with a model id that starts with `openai/`, `openrouter/`, or `ollama/`.
+- You want to take advantage of structured outputs, streaming, or multimodal (vision) features exposed by OpenAI's API.
+
+If your project only uses non-OpenAI providers (e.g. Anthropic or Gemini) you can omit this gem entirely.
+
+## Installation
+Add the gem next to your `dspy` dependency and install Bundler dependencies:
+
+```ruby
+# Gemfile
+gem 'dspy'
+gem 'dspy-openai'
+```
+
+```sh
+bundle install
+```
+
+The gem depends on the official `openai` Ruby SDK (`~> 0.17`). The adapter checks this at load time and will raise if an incompatible version, or the older `ruby-openai` gem, is detected.
+
+## Basic usage
+
+```ruby
+require 'dspy'
+# No need to explicitly require 'dspy/openai'
+
+lm = DSPy::LM.new('openai/gpt-4o-mini', api_key: ENV.fetch('OPENAI_API_KEY'))
+
+```
+
+## Working with alternate providers
+- **OpenRouter**: instantiate with `DSPy::LM.new('openrouter/x-ai/grok-4-fast:free', api_key: ENV['OPENROUTER_API_KEY'])`. Any OpenAI-compatible model exposed by OpenRouter will work.
+- **Ollama**: use `DSPy::LM.new('ollama/llama3.2', api_key: nil)`.
+
+All three adapters share the same request handling, structured output support, and error reporting, so you can swap providers without changing higher-level DSPy code.

data/lib/dspy/openai/guardrails.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+require 'dspy/lm/errors'
+
+module DSPy
+  module OpenAI
+    class Guardrails
+      SUPPORTED_OPENAI_VERSIONS = "~> 0.17".freeze
+
+      def self.ensure_openai_installed!
+        require 'openai'
+
+        spec = Gem.loaded_specs["openai"] 
+        unless spec && Gem::Requirement.new(SUPPORTED_OPENAI_VERSIONS).satisfied_by?(spec.version)
+          msg = <<~MSG
+            DSPY requires the official `openai` gem #{SUPPORTED_OPENAI_VERSIONS}.
+            Please install or upgrade it with `bundle add openai --version "#{SUPPORTED_OPENAI_VERSIONS}"`.
+          MSG
+          raise DSPy::LM::UnsupportedVersionError, msg
+        end
+
+        if Gem.loaded_specs["ruby-openai"]
+          msg = <<~MSG
+            DSPy uses the official `openai` gem.
+            Please remove the `ruby-openai` gem to avoid namespace conflicts.
+          MSG
+          raise DSPy::LM::MissingOfficialSDKError, msg
+        end
+      end
+    end
+  end
+end

data/lib/dspy/openai/lm/adapters/ollama_adapter.rb

@@ -0,0 +1,78 @@
+# frozen_string_literal: true
+
+require 'openai'
+require 'dspy/openai/lm/adapters/openai_adapter'
+
+module DSPy
+  module OpenAI
+    module LM
+      module Adapters
+        class OllamaAdapter < OpenAIAdapter
+          DEFAULT_BASE_URL = 'http://localhost:11434/v1'
+
+          def initialize(model:, api_key: nil, base_url: nil, structured_outputs: true)
+            # Ollama doesn't require API key for local instances
+            # But may need it for remote/protected instances
+            api_key ||= 'ollama' # OpenAI client requires non-empty key
+            base_url ||= DEFAULT_BASE_URL
+
+            # Store base_url before calling super
+            @base_url = base_url
+
+            # Don't call parent's initialize, do it manually to control client creation
+            @model = model
+            @api_key = api_key
+            @structured_outputs_enabled = structured_outputs
+            validate_configuration!
+
+            # Create client with custom base URL
+            @client = ::OpenAI::Client.new(
+              api_key: @api_key,
+              base_url: @base_url
+            )
+          end
+
+          def chat(messages:, signature: nil, response_format: nil, &block)
+            # For Ollama, we need to be more lenient with structured outputs
+            # as it may not fully support OpenAI's response_format spec
+            begin
+              super
+            rescue => e
+              # If structured output fails, retry with enhanced prompting
+              if @structured_outputs_enabled && signature && e.message.include?('response_format')
+                DSPy.logger.debug("Ollama structured output failed, falling back to enhanced prompting")
+                @structured_outputs_enabled = false
+                retry
+              else
+                raise
+              end
+            end
+          end
+
+          private
+
+          def validate_configuration!
+            super
+            # Additional Ollama-specific validation could go here
+          end
+
+          def validate_api_key!(api_key, provider)
+            # For Ollama, API key is optional for local instances
+            # Only validate if it looks like a remote URL
+            if @base_url && !@base_url.include?('localhost') && !@base_url.include?('127.0.0.1')
+              super
+            end
+          end
+
+
+          # Ollama may have different model support for structured outputs
+          def supports_structured_outputs?
+            # For now, assume all Ollama models support basic JSON mode
+            # but may not support full OpenAI structured output spec
+            true
+          end
+        end
+      end
+    end
+  end
+end

data/lib/dspy/openai/lm/adapters/openai_adapter.rb

@@ -0,0 +1,196 @@
+# frozen_string_literal: true
+
+require 'openai'
+require_relative '../schema_converter'
+require 'dspy/lm/vision_models'
+require 'dspy/lm/adapter'
+
+require 'dspy/openai/guardrails'
+DSPy::OpenAI::Guardrails.ensure_openai_installed!
+
+module DSPy
+  module OpenAI
+    module LM
+      module Adapters
+        class OpenAIAdapter < DSPy::LM::Adapter
+          def initialize(model:, api_key:, structured_outputs: false)
+            super(model: model, api_key: api_key)
+            validate_api_key!(api_key, 'openai')
+            @client = ::OpenAI::Client.new(api_key: api_key)
+            @structured_outputs_enabled = structured_outputs
+          end
+
+          def chat(messages:, signature: nil, response_format: nil, &block)
+            normalized_messages = normalize_messages(messages)
+
+            # Validate vision support if images are present
+            if contains_images?(normalized_messages)
+              DSPy::LM::VisionModels.validate_vision_support!('openai', model)
+              # Convert messages to OpenAI format with proper image handling
+              normalized_messages = format_multimodal_messages(normalized_messages)
+            end
+
+            # Handle O1 model restrictions - convert system messages to user messages
+            if o1_model?(model)
+              normalized_messages = handle_o1_messages(normalized_messages)
+            end
+
+            request_params = default_request_params.merge(
+              messages: normalized_messages
+            )
+
+            # Add temperature based on model capabilities  
+            unless o1_model?(model)
+              temperature = case model
+                            when /^gpt-5/, /^gpt-4o/
+                              1.0 # GPT-5 and GPT-4o models only support default temperature of 1.0
+                            else
+                              0.0 # Near-deterministic for other models (0.0 no longer universally supported)
+                            end
+              request_params[:temperature] = temperature
+            end
+
+            # Add response format if provided by strategy
+            if response_format
+              request_params[:response_format] = response_format
+            elsif @structured_outputs_enabled && signature && supports_structured_outputs?
+              # Legacy behavior for backward compatibility
+              response_format = DSPy::OpenAI::LM::SchemaConverter.to_openai_format(signature)
+              request_params[:response_format] = response_format
+            end
+
+            # Add streaming if block provided
+            if block_given?
+              request_params[:stream] = proc do |chunk, _bytesize|
+                block.call(chunk) if chunk.dig("choices", 0, "delta", "content")
+              end
+            end
+
+            begin
+              response = @client.chat.completions.create(**request_params)
+
+              if response.respond_to?(:error) && response.error
+                raise DSPy::LM::AdapterError, "OpenAI API error: #{response.error}"
+              end
+
+              choice = response.choices.first
+              message = choice.message
+              content = message.content
+              usage = response.usage
+
+              # Handle structured output refusals
+              if message.respond_to?(:refusal) && message.refusal
+                raise DSPy::LM::AdapterError, "OpenAI refused to generate output: #{message.refusal}"
+              end
+
+              # Convert usage data to typed struct
+              usage_struct = DSPy::LM::UsageFactory.create('openai', usage)
+
+              # Create typed metadata
+              metadata = DSPy::LM::ResponseMetadataFactory.create('openai', {
+                model: model,
+                response_id: response.id,
+                created: response.created,
+                structured_output: @structured_outputs_enabled && signature && supports_structured_outputs?,
+                system_fingerprint: response.system_fingerprint,
+                finish_reason: choice.finish_reason
+              })
+
+              DSPy::LM::Response.new(
+                content: content,
+                usage: usage_struct,
+                metadata: metadata
+              )
+            rescue => e
+              # Check for specific error types and messages
+              error_msg = e.message.to_s
+
+              # Try to parse error body if it looks like JSON
+              error_body = if error_msg.start_with?('{')
+                             JSON.parse(error_msg) rescue nil
+                           elsif e.respond_to?(:response) && e.response
+                             e.response[:body] rescue nil
+                           end
+
+              # Check for specific image-related errors
+              if error_msg.include?('image_parse_error') || error_msg.include?('unsupported image')
+                raise DSPy::LM::AdapterError, "Image processing failed: #{error_msg}. Ensure your image is a valid PNG, JPEG, GIF, or WebP format and under 5MB."
+              elsif error_msg.include?('rate') && error_msg.include?('limit')
+                raise DSPy::LM::AdapterError, "OpenAI rate limit exceeded: #{error_msg}. Please wait and try again."
+              elsif error_msg.include?('authentication') || error_msg.include?('API key') || error_msg.include?('Unauthorized')
+                raise DSPy::LM::AdapterError, "OpenAI authentication failed: #{error_msg}. Check your API key."
+              elsif error_body && error_body.dig('error', 'message')
+                raise DSPy::LM::AdapterError, "OpenAI API error: #{error_body.dig('error', 'message')}"
+              else
+                # Generic error handling
+                raise DSPy::LM::AdapterError, "OpenAI adapter error: #{e.message}"
+              end
+            end
+          end
+
+          protected
+
+          # Allow subclasses to override request params (add headers, etc)
+          def default_request_params
+            {
+              model: model
+            }
+          end
+
+          private
+
+          def supports_structured_outputs?
+            DSPy::OpenAI::LM::SchemaConverter.supports_structured_outputs?(model)
+          end
+
+          def format_multimodal_messages(messages)
+            messages.map do |msg|
+              if msg[:content].is_a?(Array)
+                # Convert multimodal content to OpenAI format
+                formatted_content = msg[:content].map do |item|
+                  case item[:type]
+                  when 'text'
+                    { type: 'text', text: item[:text] }
+                  when 'image'
+                    # Validate image compatibility before formatting
+                    item[:image].validate_for_provider!('openai')
+                    item[:image].to_openai_format
+                  else
+                    item
+                  end
+                end
+
+                {
+                  role: msg[:role],
+                  content: formatted_content
+                }
+              else
+                msg
+              end
+            end
+          end
+
+          # Check if model is an O1 reasoning model (includes O1, O3, O4 series)
+          def o1_model?(model_name)
+            model_name.match?(/^o[134](-.*)?$/)
+          end
+
+          # Handle O1 model message restrictions
+          def handle_o1_messages(messages)
+            messages.map do |msg|
+              # Convert system messages to user messages for O1 models
+              if msg[:role] == 'system'
+                {
+                  role: 'user',
+                  content: "Instructions: #{msg[:content]}"
+                }
+              else
+                msg
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/dspy/openai/lm/adapters/openrouter_adapter.rb

@@ -0,0 +1,73 @@
+# frozen_string_literal: true
+
+require 'openai'
+require 'dspy/openai/lm/adapters/openai_adapter'
+
+module DSPy
+  module OpenAI
+    module LM
+      module Adapters
+        class OpenRouterAdapter < OpenAIAdapter
+          BASE_URL = 'https://openrouter.ai/api/v1'
+
+          def initialize(model:, api_key: nil, structured_outputs: true, http_referrer: nil, x_title: nil)
+            # Don't call parent's initialize, do it manually to control client creation
+            @model = model
+            @api_key = api_key
+            @structured_outputs_enabled = structured_outputs
+
+            @http_referrer = http_referrer
+            @x_title = x_title
+
+            validate_configuration!
+
+            # Create client with custom base URL
+            @client = ::OpenAI::Client.new(
+              api_key: @api_key,
+              base_url: BASE_URL
+            )
+          end
+
+          def chat(messages:, signature: nil, response_format: nil, &block)
+            # For OpenRouter, we need to be more lenient with structured outputs
+            # as the model behind it may not fully support OpenAI's response_format spec
+            begin
+              super
+            rescue => e
+              # If structured output fails, retry with enhanced prompting
+              if @structured_outputs_enabled && signature && e.message.include?('response_format')
+                DSPy.logger.debug("OpenRouter structured output failed, falling back to enhanced prompting")
+                @structured_outputs_enabled = false
+                retry
+              else
+                raise
+              end
+            end
+          end
+
+          protected
+
+          # Add any OpenRouter-specific headers to all requests
+          def default_request_params
+            headers = {
+              'X-Title' => @x_title,
+              'HTTP-Referer' => @http_referrer
+            }.compact
+
+            upstream_params = super
+            upstream_params.merge!(request_options: { extra_headers: headers }) if headers.any?
+            upstream_params
+          end
+
+          private
+
+          def supports_structured_outputs?
+            # Different models behind OpenRouter may have different capabilities
+            # For now, we rely on whatever was passed to the constructor
+            @structured_outputs_enabled
+          end
+        end
+      end
+    end
+  end
+end

data/lib/dspy/openai/lm/schema_converter.rb

@@ -0,0 +1,362 @@
+# frozen_string_literal: true
+
+require "sorbet-runtime"
+
+module DSPy
+  module OpenAI
+    module LM
+      # Converts DSPy signatures to OpenAI structured output format
+      class SchemaConverter
+        extend T::Sig
+
+        # Models that support structured outputs as of July 2025
+        STRUCTURED_OUTPUT_MODELS = T.let([
+          "gpt-4o-mini",
+          "gpt-4o-2024-08-06",
+          "gpt-4o",
+          "gpt-4-turbo",
+          "gpt-4-turbo-2024-04-09",
+          "gpt-5",
+          "gpt-5-pro",
+          "gpt-5-mini",
+          "gpt-5-nano",
+          "gpt-5-2025-08-07"
+        ].freeze, T::Array[String])
+
+        sig { params(signature_class: T.class_of(DSPy::Signature), name: T.nilable(String), strict: T::Boolean).returns(T::Hash[Symbol, T.untyped]) }
+        def self.to_openai_format(signature_class, name: nil, strict: true)
+          # Get the output JSON schema from the signature class
+          output_schema = signature_class.output_json_schema
+
+          # Convert oneOf to anyOf where safe, or raise error for unsupported cases
+          output_schema = convert_oneof_to_anyof_if_safe(output_schema)
+
+          # Build the complete schema with OpenAI-specific modifications
+          dspy_schema = {
+            "$schema": "http://json-schema.org/draft-06/schema#",
+            type: "object",
+            properties: output_schema[:properties] || {},
+            required: openai_required_fields(signature_class, output_schema)
+          }
+
+          # Generate a schema name if not provided
+          schema_name = name || generate_schema_name(signature_class)
+
+          # Remove the $schema field as OpenAI doesn't use it
+          openai_schema = dspy_schema.except(:$schema)
+
+          # Add additionalProperties: false for strict mode and fix nested struct schemas
+          if strict
+            openai_schema = add_additional_properties_recursively(openai_schema)
+            openai_schema = fix_nested_struct_required_fields(openai_schema)
+          end
+
+          # Wrap in OpenAI's required format
+          {
+            type: "json_schema",
+            json_schema: {
+              name: schema_name,
+              strict: strict,
+              schema: openai_schema
+            }
+          }
+        end
+
+        # Convert oneOf to anyOf if safe (discriminated unions), otherwise raise error
+        sig { params(schema: T.untyped).returns(T.untyped) }
+        def self.convert_oneof_to_anyof_if_safe(schema)
+          return schema unless schema.is_a?(Hash)
+
+          result = schema.dup
+
+          # Check if this schema has oneOf that we can safely convert
+          if result[:oneOf]
+            if all_have_discriminators?(result[:oneOf])
+              # Safe to convert - discriminators ensure mutual exclusivity
+              result[:anyOf] = result.delete(:oneOf).map { |s| convert_oneof_to_anyof_if_safe(s) }
+            else
+              # Unsafe conversion - raise error
+              raise DSPy::UnsupportedSchemaError.new(
+                "OpenAI structured outputs do not support oneOf schemas without discriminator fields. " \
+                "The schema contains union types that cannot be safely converted to anyOf. " \
+                "Please use enhanced_prompting strategy instead or add discriminator fields to union types."
+              )
+            end
+          end
+
+          # Recursively process nested schemas
+          if result[:properties].is_a?(Hash)
+            result[:properties] = result[:properties].transform_values { |v| convert_oneof_to_anyof_if_safe(v) }
+          end
+
+          if result[:items].is_a?(Hash)
+            result[:items] = convert_oneof_to_anyof_if_safe(result[:items])
+          end
+
+          # Process arrays of schema items
+          if result[:items].is_a?(Array)
+            result[:items] = result[:items].map { |item| 
+              item.is_a?(Hash) ? convert_oneof_to_anyof_if_safe(item) : item 
+            }
+          end
+
+          # Process anyOf arrays (in case there are nested oneOf within anyOf)
+          if result[:anyOf].is_a?(Array)
+            result[:anyOf] = result[:anyOf].map { |item| 
+              item.is_a?(Hash) ? convert_oneof_to_anyof_if_safe(item) : item 
+            }
+          end
+
+          result
+        end
+
+        # Check if all schemas in a oneOf array have discriminator fields (const properties)
+        sig { params(schemas: T::Array[T.untyped]).returns(T::Boolean) }
+        def self.all_have_discriminators?(schemas)
+          schemas.all? do |schema|
+            next false unless schema.is_a?(Hash)
+            next false unless schema[:properties].is_a?(Hash)
+
+            # Check if any property has a const value (our discriminator pattern)
+            schema[:properties].any? { |_, prop| prop.is_a?(Hash) && prop[:const] }
+          end
+        end
+
+        sig { params(model: String).returns(T::Boolean) }
+        def self.supports_structured_outputs?(model)
+          # Extract base model name without provider prefix
+          base_model = model.sub(/^openai\//, "")
+
+          # Check if it's a supported model or a newer version
+          STRUCTURED_OUTPUT_MODELS.any? { |supported| base_model.start_with?(supported) }
+        end
+
+        sig { params(schema: T::Hash[Symbol, T.untyped]).returns(T::Array[String]) }
+        def self.validate_compatibility(schema)
+          issues = []
+
+          # Check for deeply nested objects (OpenAI has depth limits)
+          depth = calculate_depth(schema)
+          if depth > 5
+            issues << "Schema depth (#{depth}) exceeds recommended limit of 5 levels"
+          end
+
+          # Check for unsupported JSON Schema features
+          if contains_pattern_properties?(schema)
+            issues << "Pattern properties are not supported in OpenAI structured outputs"
+          end
+
+          if contains_conditional_schemas?(schema)
+            issues << "Conditional schemas (if/then/else) are not supported"
+          end
+
+          issues
+        end
+
+        private
+
+        # OpenAI structured outputs requires ALL properties to be in the required array
+        # For T.nilable fields without defaults, we warn the user and mark as required
+        sig { params(signature_class: T.class_of(DSPy::Signature), output_schema: T::Hash[Symbol, T.untyped]).returns(T::Array[String]) }
+        def self.openai_required_fields(signature_class, output_schema)
+          all_properties = output_schema[:properties]&.keys || []
+          original_required = output_schema[:required] || []
+
+          # For OpenAI structured outputs, we need ALL properties to be required
+          # but warn about T.nilable fields without defaults
+          field_descriptors = signature_class.instance_variable_get(:@output_field_descriptors) || {}
+
+          all_properties.each do |property_name|
+            descriptor = field_descriptors[property_name.to_sym]
+
+            # If field is not originally required and doesn't have a default
+            if !original_required.include?(property_name.to_s) && descriptor && !descriptor.has_default
+              DSPy.logger.warn(
+                "OpenAI structured outputs: T.nilable field '#{property_name}' without default will be marked as required. " \
+                "Consider adding a default value or using a different provider for optional fields."
+              )
+            end
+          end
+
+          # Return all properties as required (OpenAI requirement)
+          all_properties.map(&:to_s)
+        end
+
+        # Fix nested struct schemas to include all properties in required array (OpenAI requirement)
+        sig { params(schema: T::Hash[Symbol, T.untyped]).returns(T::Hash[Symbol, T.untyped]) }
+        def self.fix_nested_struct_required_fields(schema)
+          return schema unless schema.is_a?(Hash)
+
+          result = schema.dup
+
+          # If this is an object with properties, make all properties required
+          if result[:type] == "object" && result[:properties].is_a?(Hash)
+            all_property_names = result[:properties].keys.map(&:to_s)
+            result[:required] = all_property_names unless result[:required] == all_property_names
+          end
+
+          # Process nested objects recursively
+          if result[:properties].is_a?(Hash)
+            result[:properties] = result[:properties].transform_values do |prop|
+              if prop.is_a?(Hash)
+                processed = fix_nested_struct_required_fields(prop)
+                # Handle arrays with object items
+                if processed[:type] == "array" && processed[:items].is_a?(Hash)
+                  processed[:items] = fix_nested_struct_required_fields(processed[:items])
+                end
+                processed
+              else
+                prop
+              end
+            end
+          end
+
+          result
+        end
+
+        sig { params(schema: T::Hash[Symbol, T.untyped]).returns(T::Hash[Symbol, T.untyped]) }
+        def self.add_additional_properties_recursively(schema)
+          return schema unless schema.is_a?(Hash)
+
+          result = schema.dup
+
+          # Add additionalProperties: false if this is an object
+          if result[:type] == "object"
+            result[:additionalProperties] = false
+          end
+
+          # Process properties recursively
+          if result[:properties].is_a?(Hash)
+            result[:properties] = result[:properties].transform_values do |prop|
+              if prop.is_a?(Hash)
+                processed = add_additional_properties_recursively(prop)
+                # Special handling for arrays - ensure their items have additionalProperties if they're objects
+                if processed[:type] == "array" && processed[:items].is_a?(Hash)
+                  processed[:items] = add_additional_properties_recursively(processed[:items])
+                end
+                processed
+              else
+                prop
+              end
+            end
+          end
+
+          # Process array items
+          if result[:items].is_a?(Hash)
+            processed_items = add_additional_properties_recursively(result[:items])
+            # OpenAI requires additionalProperties on all objects, even in array items
+            if processed_items.is_a?(Hash) && processed_items[:type] == "object" && !processed_items.key?(:additionalProperties)
+              processed_items[:additionalProperties] = false
+            end
+            result[:items] = processed_items
+          elsif result[:items].is_a?(Array)
+            # Handle tuple validation
+            result[:items] = result[:items].map do |item|
+              processed = item.is_a?(Hash) ? add_additional_properties_recursively(item) : item
+              if processed.is_a?(Hash) && processed[:type] == "object" && !processed.key?(:additionalProperties)
+                processed[:additionalProperties] = false
+              end
+              processed
+            end
+          end
+
+          # Process anyOf/allOf (oneOf should be converted to anyOf by this point)
+          [:anyOf, :allOf].each do |key|
+            if result[key].is_a?(Array)
+              result[key] = result[key].map do |sub_schema|
+                sub_schema.is_a?(Hash) ? add_additional_properties_recursively(sub_schema) : sub_schema
+              end
+            end
+          end
+
+          result
+        end
+
+        sig { params(signature_class: T.class_of(DSPy::Signature)).returns(String) }
+        def self.generate_schema_name(signature_class)
+          # Use the signature class name
+          class_name = signature_class.name&.split("::")&.last
+          if class_name
+            class_name.gsub(/[^a-zA-Z0-9_]/, "_").downcase
+          else
+            # Fallback to a generic name
+            "dspy_output_#{Time.now.to_i}"
+          end
+        end
+
+        sig { params(schema: T::Hash[Symbol, T.untyped], current_depth: Integer).returns(Integer) }
+        def self.calculate_depth(schema, current_depth = 0)
+          return current_depth unless schema.is_a?(Hash)
+
+          max_depth = current_depth
+
+          # Check properties
+          if schema[:properties].is_a?(Hash)
+            schema[:properties].each_value do |prop|
+              if prop.is_a?(Hash)
+                prop_depth = calculate_depth(prop, current_depth + 1)
+                max_depth = [max_depth, prop_depth].max
+              end
+            end
+          end
+
+          # Check array items
+          if schema[:items].is_a?(Hash)
+            items_depth = calculate_depth(schema[:items], current_depth + 1)
+            max_depth = [max_depth, items_depth].max
+          end
+
+          # Check anyOf/allOf (oneOf should be converted to anyOf by this point)
+          [:anyOf, :allOf].each do |key|
+            if schema[key].is_a?(Array)
+              schema[key].each do |sub_schema|
+                if sub_schema.is_a?(Hash)
+                  sub_depth = calculate_depth(sub_schema, current_depth + 1)
+                  max_depth = [max_depth, sub_depth].max
+                end
+              end
+            end
+          end
+
+          max_depth
+        end
+
+        sig { params(schema: T::Hash[Symbol, T.untyped]).returns(T::Boolean) }
+        def self.contains_pattern_properties?(schema)
+          return true if schema[:patternProperties]
+
+          # Recursively check nested schemas (oneOf should be converted to anyOf by this point)
+          [:properties, :items, :anyOf, :allOf].each do |key|
+            value = schema[key]
+            case value
+            when Hash
+              return true if contains_pattern_properties?(value)
+            when Array
+              return true if value.any? { |v| v.is_a?(Hash) && contains_pattern_properties?(v) }
+            end
+          end
+
+          false
+        end
+
+        sig { params(schema: T::Hash[Symbol, T.untyped]).returns(T::Boolean) }
+        def self.contains_conditional_schemas?(schema)
+          return true if schema[:if] || schema[:then] || schema[:else]
+
+          # Recursively check nested schemas (oneOf should be converted to anyOf by this point) 
+          [:properties, :items, :anyOf, :allOf].each do |key|
+            value = schema[key]
+            case value
+            when Hash
+              return true if contains_conditional_schemas?(value)
+            when Array
+              return true if value.any? { |v| v.is_a?(Hash) && contains_conditional_schemas?(v) }
+            end
+          end
+
+          false
+        end
+      end
+    end
+  end
+end

data/lib/dspy/openai/version.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+module DSPy
+  module OpenAI
+    VERSION = '1.0.0'
+  end
+end

data/lib/dspy/openai.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+require 'dspy/openai/version'
+
+require 'dspy/openai/guardrails'
+DSPy::OpenAI::Guardrails.ensure_openai_installed!
+
+require 'dspy/openai/lm/adapters/openai_adapter'
+require 'dspy/openai/lm/adapters/ollama_adapter'
+require 'dspy/openai/lm/adapters/openrouter_adapter'
+require 'dspy/openai/lm/schema_converter'

metadata

@@ -0,0 +1,80 @@
+--- !ruby/object:Gem::Specification
+name: dspy-openai
+version: !ruby/object:Gem::Version
+  version: 1.0.0
+platform: ruby
+authors:
+- Vicente Reig Rincón de Arellano
+bindir: bin
+cert_chain: []
+date: 1980-01-02 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: dspy
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 0.31.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 0.31.0
+- !ruby/object:Gem::Dependency
+  name: openai
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+description: Provides the OpenAI plus the Ollama and OpenRouter adapters so OpenAI-compatible
+  providers can be added to DSPy.rb projects independently of the core gem.
+email:
+- hey@vicente.services
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- LICENSE
+- README.md
+- lib/dspy/openai.rb
+- lib/dspy/openai/README.md
+- lib/dspy/openai/guardrails.rb
+- lib/dspy/openai/lm/adapters/ollama_adapter.rb
+- lib/dspy/openai/lm/adapters/openai_adapter.rb
+- lib/dspy/openai/lm/adapters/openrouter_adapter.rb
+- lib/dspy/openai/lm/schema_converter.rb
+- lib/dspy/openai/version.rb
+homepage: https://github.com/vicentereig/dspy.rb
+licenses:
+- MIT
+metadata:
+  github_repo: git@github.com:vicentereig/dspy.rb
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 3.3.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.6.9
+specification_version: 4
+summary: OpenAI and OpenRouter adapters for DSPy.rb.
+test_files: []