spectre_ai 1.1.4 → 2.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: e92299b643fbf7d928b9c45de5ad9a504528cbb246202d56cb24d36a32030030
-  data.tar.gz: 8dc5d19040a9cac2cc929a1a91b55112d0e78fa21ca8de05bb6c3544838af9ed
+  metadata.gz: '03910c4dd38bf7a272fab91c0e9d1431d0f9bdc593abe62035271e9e07f22e89'
+  data.tar.gz: 0f1e927a42785d2f4735e4adf9140efad6815247fca6ce6270ac10ef286ae217
 SHA512:
-  metadata.gz: 8ea61b8b0a0e23d7a5c500fd99e147942fd33538e21d38be0030aff60dda20758a87651b9460d4b4de50f986ffe068da4dd29f172dc0a25a993595eadee34fe6
-  data.tar.gz: b4ef2e616f0143f677c635e6d999e155a1205a1ab90ac47fc2a8c322b95ee6f107522dc4c2d8a16e33a856f3387ffdb1e7ac85ca9f83b3a72960e9b8e6d52ca1
+  metadata.gz: 48e634fedb903de30ff0acba0b1de5b725fccb2ac0882bf8890740100312c92ae48c6c182612554cdd6968b34df5f6c7958a62caf19492ae29a42d8e084e1458
+  data.tar.gz: b7a382fb583431eff8715147df8f5251e30d528b0a77ecc6c2ecf68b324f57f76e9c6a2634da07f55159713d9cd58684e212b75fee7f5a7e20e56b437725dd55

data/CHANGELOG.md

@@ -138,4 +138,145 @@ Spectre::Openai::Completions.create(
 
 * Simplified Exception Handling for Timeouts
 * Removed explicit handling of Net::OpenTimeout and Net::ReadTimeout exceptions in both Completions and Embeddings classes.
-* Letting these exceptions propagate ensures clearer and more consistent error messages for timeout issues.
+* Letting these exceptions propagate ensures clearer and more consistent error messages for timeout issues.
+
+
+# Changelog for Version 1.2.0
+
+**Release Date:** [30th Jan 2025]
+
+### **New Features & Enhancements**
+
+1️⃣ **Unified Configuration for LLM Providers**
+
+🔧 Refactored the configuration system to provide a consistent interface for setting up OpenAI and Ollama within config/initializers/spectre.rb.\
+•	Now, developers can seamlessly switch between OpenAI and Ollama by defining a single provider configuration block.\
+•	Ensures better modularity and simplifies adding support for future providers (Claude, Cohere, etc.).
+
+🔑 **Example Configuration:**
+
+```ruby
+Spectre.setup do |config|
+  config.default_llm_provider = :openai
+
+  config.openai do |openai|
+    openai.api_key = ENV['OPENAI_API_KEY']
+  end
+
+  config.ollama do |ollama|
+    ollama.host = ENV['OLLAMA_HOST']
+    ollama.api_key = ENV['OLLAMA_API_KEY']
+  end
+end
+```
+
+Key Improvements:\
+✅ API key validation added: Now properly checks if api_key is missing and raises APIKeyNotConfiguredError.\
+✅ Host validation added: Now checks if host is missing for Ollama and raises HostNotConfiguredError.
+
+2️⃣ **Added Ollama Provider Support**
+
+🆕 Introduced full support for Ollama, allowing users to use local LLM models efficiently.\
+•	Supports Ollama-based completions for generating text using local models like llama3.\
+•	Supports Ollama-based embeddings for generating embeddings using local models like nomic-embed-text.\
+•	Automatic JSON Schema Conversion: OpenAI’s json_schema format is now automatically translated into Ollama’s format key.
+
+3️⃣ **Differences in OpenAI Interface: max_tokens Moved to `**args`**
+
+💡 Refactored the OpenAI completions request so that max_tokens is now passed as a dynamic argument inside `**args` instead of a separate parameter.\
+•	Why? To ensure a consistent interface across different providers, making it easier to switch between them seamlessly.\
+•	Before:
+```ruby
+Spectre.provider_module::Completions.create(messages: messages, max_tokens: 50)
+```
+•	After:
+```ruby
+Spectre.provider_module::Completions.create(messages: messages, openai: { max_tokens: 50 })
+```
+
+Key Benefits:\
+✅ Keeps the method signature cleaner and future-proof.\
+✅ Ensures optional parameters are handled dynamically without cluttering the main method signature.\
+✅ Improves consistency across OpenAI and Ollama providers.
+
+
+# Changelog for Version 2.0.0
+
+**Release Date:** [21st Sep 2025]
+
+### New Provider: Claude (Anthropic)
+
+- Added Spectre::Claude client for chat completions using Anthropic Messages API.
+- New configuration block: `Spectre.setup { |c| c.default_llm_provider = :claude; c.claude { |v| v.api_key = ENV['ANTHROPIC_API_KEY'] } }`.
+- Supports `claude: { max_tokens: ... }` in args to control max tokens.
+
+### Structured Outputs via Tools-based JSON Schema
+
+- Claude does not use `response_format`; instead, when `json_schema` is provided we now:
+  - Convert your schema into a single “virtual” tool (`tools[0]`) with `input_schema`.
+  - Force use of that tool by default with `tool_choice: { type: 'tool', name: <schema_name> }` (respects explicit `tool_choice` if you pass one).
+  - Merge your own `tools` alongside the schema tool without overriding them.
+- Messages content preserves structured blocks (hashes/arrays), enabling images and other block types to be sent as-is.
+
+### Output Normalization (Parity with OpenAI when using json_schema)
+
+- When a `json_schema` is provided and Claude returns a single `tool_use` with no text, we normalize the output to:
+  - `content: <parsed_object>` (Hash/Array), not a JSON string.
+  - This mirrors the behavior you get with OpenAI’s JSON schema mode, simplifying consumers.
+- When no `json_schema` is provided, we return `tool_calls` (raw `tool_use` blocks) plus any text content.
+
+### Error Handling & Stop Reasons
+
+- `stop_reason: 'max_tokens'` → raises `"Incomplete response: The completion was cut off due to token limit."`
+- `stop_reason: 'refusal'` → raises `Spectre::Claude::RefusalError`.
+- Unexpected stop reasons raise an error to make issues explicit.
+
+### Tools and tool_choice Support
+
+- Pass-through for user-defined tools.
+- Respect explicit `tool_choice`; only enforce schema tool when `json_schema` is present and no explicit choice is set.
+
+### Tests & DX
+
+- Added a comprehensive RSpec suite for `Spectre::Claude::Completions`.
+- Ensured spec loading works consistently across environments via `.rspec --require spec_helper` and consistent requires.
+- Full suite passes locally (69 examples).
+
+### Notes
+
+- Claude embeddings are not implemented (no native embeddings model).
+- Behavior change (Claude only): when `json_schema` is used, `:content` returns a parsed object (not a JSON string). If you relied on a string, wrap with `JSON.generate` on the caller side.
+
+
+
+# Changelog for Version 2.0.0
+
+**Release Date:** [21st Sep 2025]
+
+### New Provider: Gemini (Google)
+
+- Added Spectre::Gemini client for chat completions using Google’s OpenAI-compatible endpoint.
+- Added Spectre::Gemini embeddings using Google’s OpenAI-compatible endpoint.
+- New configuration block:
+  ```ruby
+  Spectre.setup do |c|
+    c.default_llm_provider = :gemini
+    c.gemini { |v| v.api_key = ENV['GEMINI_API_KEY'] }
+  end
+  ```
+- Supports `gemini: { max_tokens: ... }` in args to control max tokens for completions.
+- `json_schema` and `tools` are passed through in OpenAI-compatible format.
+
+### Core Wiring
+
+- Added `:gemini` to VALID_LLM_PROVIDERS and provider configuration accessors.
+- Updated Rails generator initializer template to include a gemini block.
+
+### Docs & Tests
+
+- Updated README to include Gemini in compatibility matrix and configuration example.
+- Added RSpec tests for Gemini completions and embeddings (mirroring OpenAI behavior and error handling).
+
+### Behavior Notes
+
+- Gemini OpenAI-compatible chat endpoint requires that the last message in `messages` has role 'user'. Spectre raises an ArgumentError if this requirement is not met to prevent 400 INVALID_ARGUMENT errors from the API.

data/README.md

@@ -6,14 +6,14 @@
 
 ## Compatibility
 
-| Feature                 | Compatibility |
-|-------------------------|---------------|
-| Foundation Models (LLM) | OpenAI        |
-| Embeddings              | OpenAI        |
-| Vector Searching        | MongoDB Atlas |
-| Prompt Templates        | OpenAI        |
+| Feature                 | Compatibility          |
+|-------------------------|------------------------|
+| Foundation Models (LLM) | OpenAI, Ollama, Claude, Gemini |
+| Embeddings              | OpenAI, Ollama, Gemini         |
+| Vector Searching        | MongoDB Atlas          |
+| Prompt Templates        | ✅                      |
 
-**💡 Note:** We will first prioritize adding support for additional foundation models (Claude, Cohere, LLaMA, etc.), then look to add support for more vector databases (Pgvector, Pinecone, etc.). If you're looking for something a bit more extensible, we highly recommend checking out [langchainrb](https://github.com/patterns-ai-core/langchainrb).
+**💡 Note:** We now support OpenAI, Ollama, Claude, and Gemini. Next, we'll add support for additional providers (e.g., Cohere) and more vector databases (Pgvector, Pinecone, etc.). If you're looking for something a bit more extensible, we highly recommend checking out [langchainrb](https://github.com/patterns-ai-core/langchainrb).
 
 ## Installation
 
@@ -37,24 +37,40 @@ gem install spectre_ai
 
 ## Usage
 
-### 1. Setup
+### 🔧 Configuration
 
-First, you’ll need to generate the initializer to configure your OpenAI API key. Run the following command to create the initializer:
+First, you’ll need to generate the initializer. Run the following command to create the initializer:
 
 ```bash
 rails generate spectre:install
 ```
 
-This will create a file at `config/initializers/spectre.rb`, where you can set your OpenAI API key:
+This will create a file at `config/initializers/spectre.rb`, where you can set your llm provider and configure the provider-specific settings.
 
 ```ruby
 Spectre.setup do |config|
-  config.api_key = 'your_openai_api_key'
-  config.llm_provider = :openai
+  config.default_llm_provider = :openai # or :claude, :ollama, :gemini
+
+  config.openai do |openai|
+    openai.api_key = ENV['OPENAI_API_KEY']
+  end
+
+  config.ollama do |ollama|
+    ollama.host = ENV['OLLAMA_HOST']
+    ollama.api_key = ENV['OLLAMA_API_KEY']
+  end
+
+  config.claude do |claude|
+    claude.api_key = ENV['ANTHROPIC_API_KEY']
+  end
+
+  config.gemini do |gemini|
+    gemini.api_key = ENV['GEMINI_API_KEY']
+  end
 end
 ```
 
-### 2. Enable Your Rails Model(s)
+### 📡 Embeddings & Vector Search
 
 #### For Embedding
 
@@ -146,6 +162,8 @@ This method sends the text to OpenAI’s API and returns the embedding vector. Y
 Spectre.provider_module::Embeddings.create("Your text here", model: "text-embedding-ada-002")
 ```
 
+**NOTE:** Different providers have different available args for the `create` method. Please refer to the provider-specific documentation for more details.
+
 ### 4. Performing Vector-Based Searches
 
 Once your model is configured as searchable, you can perform vector-based searches on the stored embeddings:
@@ -168,7 +186,7 @@ This method will:
 - **custom_result_fields:** Limit the fields returned in the search results.
 - **additional_scopes:** Apply additional MongoDB filters to the search results.
 
-### 5. Creating Completions
+### 💬 Chat Completions
 
 Spectre provides an interface to create chat completions using your configured LLM provider, allowing you to create dynamic responses, messages, or other forms of text.
 
@@ -182,17 +200,14 @@ messages = [
         { role: 'user', content: "Tell me a joke." }
 ]
 
-Spectre.provider_module::Completions.create(
-        messages: messages
-)
-
+Spectre.provider_module::Completions.create(messages: messages)
 ```
 
 This sends the request to the LLM provider’s API and returns the chat completion.
 
 **Customizing the Completion**
 
-You can customize the behavior by specifying additional parameters such as the model, maximum number of tokens, and any tools needed for function calls:
+You can customize the behavior by specifying additional parameters such as the model, any tools needed for function calls:
 
 ```ruby
 messages = [
@@ -204,7 +219,7 @@ messages = [
 Spectre.provider_module::Completions.create(
         messages: messages,
         model: "gpt-4",
-        max_tokens: 50
+        openai: { max_tokens: 50 }
 )
 
 ```
@@ -241,7 +256,78 @@ Spectre.provider_module::Completions.create(
 
 This structured format guarantees that the response adheres to the schema you’ve provided, ensuring more predictable and controlled results.
 
-**Using Tools for Function Calling**
+**NOTE:** Provider differences for structured output:
+- OpenAI: supports strict JSON Schema via `response_format.json_schema` (see JSON Schema docs: https://json-schema.org/overview/what-is-jsonschema.html).
+- Claude (Anthropic): does not use `response_format`. Spectre converts your `json_schema` into a single "virtual" tool with `input_schema` and, by default, forces its use via `tool_choice` (you can override `tool_choice` explicitly). When the reply consists only of that `tool_use`, Spectre returns the parsed object in `:content` (Hash/Array), not a JSON string.
+- Ollama: expects a plain JSON object in `format`. Spectre will convert OpenAI-style `{ name:, schema: }` automatically into the format Ollama expects.
+
+#### Claude (Anthropic) specifics
+
+- Configure:
+```ruby
+Spectre.setup do |config|
+  config.default_llm_provider = :claude
+  config.claude { |c| c.api_key = ENV['ANTHROPIC_API_KEY'] }
+end
+```
+
+- Structured output with a schema:
+```ruby
+json_schema = {
+  name: "completion_response",
+  schema: {
+    type: "object",
+    properties: { response: { type: "string" } },
+    required: ["response"],
+    additionalProperties: false
+  }
+}
+
+messages = [
+  { role: 'system', content: 'You are a helpful assistant.' },
+  { role: 'user', content: 'Say hello' }
+]
+
+result = Spectre.provider_module::Completions.create(
+  messages: messages,
+  json_schema: json_schema,
+  claude: { max_tokens: 256 }
+)
+
+# When only the schema tool is used, Spectre returns a parsed object:
+result[:content] # => { 'response' => 'Hello!' }
+```
+
+- Optional: override tool selection
+```ruby
+Spectre.provider_module::Completions.create(messages: messages, json_schema: json_schema, tool_choice: { type: 'auto' })
+```
+
+- Note: Claude embeddings are not implemented (no native embeddings model).
+
+#### Gemini (Google) specifics
+
+- Chat completions use Google's OpenAI-compatible endpoint. Important: the messages array must end with a user message. If the last message is assistant/system or missing, the API returns 400 INVALID_ARGUMENT (e.g., "Please ensure that single turn requests end with a user role or the role field is empty."). Spectre validates this and raises an ArgumentError earlier to help you fix the history before making an API call.
+- Example:
+
+```ruby
+# Incorrect (ends with assistant)
+messages = [
+  { role: 'system', content: 'You are a funny assistant.' },
+  { role: 'user', content: 'Tell me a joke.' },
+  { role: 'assistant', content: "Sure, here's a joke!" }
+]
+
+# Correct (ends with user)
+messages = [
+  { role: 'system', content: 'You are a funny assistant.' },
+  { role: 'user', content: 'Tell me a joke.' },
+  { role: 'assistant', content: "Sure, here's a joke!" },
+  { role: 'user', content: 'Tell me another one.' }
+]
+```
+
+⚙️ Function Calling (Tool Use)
 
 You can incorporate tools (function calls) in your completion to handle more complex interactions such as fetching external information via API or performing calculations. Define tools using the function call format and include them in the request:
 
@@ -321,7 +407,9 @@ else
 end
 ```
 
-### 6. Creating Dynamic Prompts
+**NOTE:** Completions class also supports different `**args` for different providers. Please refer to the provider-specific documentation for more details.
+
+### 🎭 Dynamic Prompt Rendering
 
 Spectre provides a system for creating dynamic prompts based on templates. You can define reusable prompt templates and render them with different parameters in your Rails app (think Ruby on Rails view partials).
 
@@ -424,7 +512,7 @@ Spectre.provider_module::Completions.create(
 
 ```
 
-## Contributing
+## 📜 Contributing
 
 Bug reports and pull requests are welcome on GitHub at [https://github.com/hiremav/spectre](https://github.com/hiremav/spectre). This project is intended to be a safe, welcoming space for collaboration, and your contributions are greatly appreciated!
 
@@ -434,6 +522,6 @@ Bug reports and pull requests are welcome on GitHub at [https://github.com/hirem
 4. **Push** the branch (`git push origin my-new-feature`).
 5. **Create** a pull request.
 
-## License
+## 📜 License
 
 This gem is available as open source under the terms of the MIT License.

data/lib/generators/spectre/templates/spectre_initializer.rb

@@ -3,8 +3,23 @@
 require 'spectre'
 
 Spectre.setup do |config|
-  # Chose your LLM (openai, cohere, ollama)
-  config.llm_provider = :openai
-  # Set the API key for your chosen LLM
-  config.api_key = ENV.fetch('CHATGPT_API_TOKEN')
+  # Chose your LLM (openai, ollama, claude, gemini)
+  config.default_llm_provider = :openai
+
+  config.openai do |openai|
+    openai.api_key = ENV['OPENAI_API_KEY']
+  end
+
+  config.ollama do |ollama|
+    ollama.host = ENV['OLLAMA_HOST']
+    ollama.api_key = ENV['OLLAMA_API_KEY']
+  end
+
+  config.claude do |claude|
+    claude.api_key = ENV['ANTHROPIC_API_KEY']
+  end
+
+  config.gemini do |gemini|
+    gemini.api_key = ENV['GEMINI_API_KEY']
+  end
 end

data/lib/spectre/claude/completions.rb

@@ -0,0 +1,207 @@
+# frozen_string_literal: true
+
+require 'net/http'
+require 'json'
+require 'uri'
+
+module Spectre
+  module Claude
+    class RefusalError < StandardError; end
+
+    class Completions
+      API_URL = 'https://api.anthropic.com/v1/messages'
+      DEFAULT_MODEL = 'claude-opus-4-1'
+      DEFAULT_TIMEOUT = 60
+      ANTHROPIC_VERSION = '2023-06-01'
+
+      # Class method to generate a completion based on user messages and optional tools
+      #
+      # @param messages [Array<Hash>] The conversation messages, each with a role and content
+      # @param model [String] The model to be used for generating completions, defaults to DEFAULT_MODEL
+      # @param json_schema [Hash, nil] Optional JSON Schema; when provided, it will be converted into a tool with input_schema and forced via tool_choice unless overridden
+      # @param tools [Array<Hash>, nil] An optional array of tool definitions for function calling
+      # @param tool_choice [Hash, nil] Optional tool_choice to force a specific tool use (e.g., { type: 'tool', name: 'record_summary' })
+      # @param args [Hash, nil] optional arguments like read_timeout and open_timeout. For Claude, max_tokens can be passed in the claude hash.
+      # @return [Hash] The parsed response including any tool calls or content
+      # @raise [APIKeyNotConfiguredError] If the API key is not set
+      # @raise [RuntimeError] For general API errors or unexpected issues
+      def self.create(messages:, model: DEFAULT_MODEL, json_schema: nil, tools: nil, tool_choice: nil, **args)
+        api_key = Spectre.claude_configuration&.api_key
+        raise APIKeyNotConfiguredError, "API key is not configured" unless api_key
+
+        validate_messages!(messages)
+
+        uri = URI(API_URL)
+        http = Net::HTTP.new(uri.host, uri.port)
+        http.use_ssl = true
+        http.read_timeout = args.fetch(:read_timeout, DEFAULT_TIMEOUT)
+        http.open_timeout = args.fetch(:open_timeout, DEFAULT_TIMEOUT)
+
+        request = Net::HTTP::Post.new(uri.path, {
+          'Content-Type' => 'application/json',
+          'x-api-key' => api_key,
+          'anthropic-version' => ANTHROPIC_VERSION
+        })
+
+        max_tokens = args.dig(:claude, :max_tokens) || 1024
+        request.body = generate_body(messages, model, json_schema, max_tokens, tools, tool_choice).to_json
+        response = http.request(request)
+
+        unless response.is_a?(Net::HTTPSuccess)
+          raise "Claude API Error: #{response.code} - #{response.message}: #{response.body}"
+        end
+
+        parsed_response = JSON.parse(response.body)
+
+        handle_response(parsed_response, schema_used: !!json_schema)
+      rescue JSON::ParserError => e
+        raise "JSON Parse Error: #{e.message}"
+      end
+
+      private
+
+      # Validate the structure and content of the messages array.
+      #
+      # @param messages [Array<Hash>] The array of message hashes to validate.
+      #
+      # @raise [ArgumentError] if the messages array is not in the expected format or contains invalid data.
+      def self.validate_messages!(messages)
+        unless messages.is_a?(Array) && messages.all? { |msg| msg.is_a?(Hash) }
+          raise ArgumentError, "Messages must be an array of message hashes."
+        end
+
+        if messages.empty?
+          raise ArgumentError, "Messages cannot be empty."
+        end
+      end
+
+      # Helper method to generate the request body for Anthropic Messages API
+      #
+      # @param messages [Array<Hash>] The conversation messages, each with a role and content
+      # @param model [String] The model to be used for generating completions
+      # @param json_schema [Hash, nil] An optional JSON schema to hint structured output
+      # @param max_tokens [Integer] The maximum number of tokens for the completion
+      # @param tools [Array<Hash>, nil] An optional array of tool definitions for function calling
+      # @return [Hash] The body for the API request
+      def self.generate_body(messages, model, json_schema, max_tokens, tools, tool_choice)
+        system_prompts, chat_messages = partition_system_and_chat(messages)
+
+        body = {
+          model: model,
+          max_tokens: max_tokens,
+          messages: chat_messages
+        }
+
+        # Join multiple system prompts into one. Anthropic supports a string here.
+        body[:system] = system_prompts.join("\n\n") unless system_prompts.empty?
+
+        # If a json_schema is provided, transform it into a "virtual" tool and force its use via tool_choice (unless already provided).
+        if json_schema
+          # Normalize schema input: accept anthropic-style { json_schema: { name:, schema:, strict: } },
+          # OpenAI-like { name:, schema:, strict: }, or a raw schema object.
+          if json_schema.is_a?(Hash) && (json_schema.key?(:json_schema) || json_schema.key?("json_schema"))
+            schema_payload = json_schema[:json_schema] || json_schema["json_schema"]
+            schema_name = (schema_payload[:name] || schema_payload["name"] || "structured_output").to_s
+            schema_object = schema_payload[:schema] || schema_payload["schema"] || schema_payload
+          else
+            schema_name = (json_schema.is_a?(Hash) && (json_schema[:name] || json_schema["name"])) || "structured_output"
+            schema_object = (json_schema.is_a?(Hash) && (json_schema[:schema] || json_schema["schema"])) || json_schema
+          end
+
+          schema_tool = {
+            name: schema_name,
+            description: "Return a JSON object that strictly follows the provided input_schema.",
+            input_schema: schema_object
+          }
+
+          # Merge with any user-provided tools. Prefer a single tool by default but don't drop existing tools.
+          existing_tools = tools || []
+          body[:tools] = [schema_tool] + existing_tools
+
+          # If the caller didn't specify tool_choice, force using the schema tool.
+          body[:tool_choice] = { type: 'tool', name: schema_name } unless tool_choice
+        end
+
+        body[:tools] = tools if tools && !body.key?(:tools)
+        body[:tool_choice] = tool_choice if tool_choice
+
+        body
+      end
+
+      # Normalize content for Anthropic: preserve arrays/hashes (structured blocks), stringify otherwise
+      def self.normalize_content(content)
+        case content
+        when Array
+          content
+        when Hash
+          content
+        else
+          content.to_s
+        end
+      end
+
+      # Partition system messages and convert remaining into Anthropic-compatible messages
+      def self.partition_system_and_chat(messages)
+        system_prompts = []
+        chat_messages = []
+
+        messages.each do |msg|
+          role = (msg[:role] || msg['role']).to_s
+          content = msg[:content] || msg['content']
+
+          case role
+          when 'system'
+            system_prompts << content.to_s
+          when 'user', 'assistant'
+            chat_messages << { role: role, content: normalize_content(content) }
+          else
+            # Unknown role, treat as user to avoid API errors
+            chat_messages << { role: 'user', content: normalize_content(content) }
+          end
+        end
+
+        [system_prompts, chat_messages]
+      end
+
+      # Handles the API response, raising errors for specific cases and returning structured content otherwise
+      #
+      # @param response [Hash] The parsed API response
+      # @param schema_used [Boolean] Whether the request used a JSON schema (tools-based) and needs normalization
+      # @return [Hash] The relevant data based on the stop_reason
+      def self.handle_response(response, schema_used: false)
+        content_blocks = response['content'] || []
+        stop_reason = response['stop_reason']
+
+        text_content = content_blocks.select { |b| b['type'] == 'text' }.map { |b| b['text'] }.join
+        tool_uses = content_blocks.select { |b| b['type'] == 'tool_use' }
+
+        if stop_reason == 'max_tokens'
+          raise "Incomplete response: The completion was cut off due to token limit."
+        end
+
+        if stop_reason == 'refusal'
+          raise RefusalError, "Content filtered: The model's output was blocked due to policy violations."
+        end
+
+        # If a json_schema was provided and Claude produced a single tool_use with no text,
+        # treat it as structured JSON output and return the parsed object in :content.
+        if schema_used && tool_uses.length == 1 && (text_content.nil? || text_content.strip.empty?)
+          input = tool_uses.first['input']
+          return({ content: input }) if input.is_a?(Hash) || input.is_a?(Array)
+        end
+
+        if !tool_uses.empty?
+          return { tool_calls: tool_uses, content: text_content }
+        end
+
+        # Normal end of turn
+        if stop_reason == 'end_turn' || stop_reason.nil?
+          return { content: text_content }
+        end
+
+        # Handle unexpected stop reasons
+        raise "Unexpected stop_reason: #{stop_reason}"
+      end
+    end
+  end
+end

data/lib/spectre/claude.rb

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+
+module Spectre
+  module Claude
+    # Require each specific client file here
+    require_relative 'claude/completions'
+  end
+end

data/lib/spectre/errors.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+module Spectre
+  # Define custom error classes here
+  class APIKeyNotConfiguredError < StandardError; end
+  class HostNotConfiguredError < StandardError; end
+end

data/lib/spectre/gemini/completions.rb

@@ -0,0 +1,120 @@
+# frozen_string_literal: true
+
+require 'net/http'
+require 'json'
+require 'uri'
+
+module Spectre
+  module Gemini
+    class Completions
+      # Using Google's OpenAI-compatible endpoint
+      API_URL = 'https://generativelanguage.googleapis.com/v1beta/openai/chat/completions'
+      DEFAULT_MODEL = 'gemini-2.5-flash'
+      DEFAULT_TIMEOUT = 60
+
+      # Class method to generate a completion based on user messages and optional tools
+      #
+      # @param messages [Array<Hash>] The conversation messages, each with a role and content
+      # @param model [String] The model to be used for generating completions, defaults to DEFAULT_MODEL
+      # @param json_schema [Hash, nil] An optional JSON schema to enforce structured output (OpenAI-compatible "response_format")
+      # @param tools [Array<Hash>, nil] An optional array of tool definitions for function calling
+      # @param args [Hash, nil] optional arguments like read_timeout and open_timeout. For Gemini, max_tokens can be passed in the gemini hash.
+      # @return [Hash] The parsed response including any function calls or content
+      # @raise [APIKeyNotConfiguredError] If the API key is not set
+      # @raise [RuntimeError] For general API errors or unexpected issues
+      def self.create(messages:, model: DEFAULT_MODEL, json_schema: nil, tools: nil, **args)
+        api_key = Spectre.gemini_configuration&.api_key
+        raise APIKeyNotConfiguredError, "API key is not configured" unless api_key
+
+        validate_messages!(messages)
+
+        uri = URI(API_URL)
+        http = Net::HTTP.new(uri.host, uri.port)
+        http.use_ssl = true
+        http.read_timeout = args.fetch(:read_timeout, DEFAULT_TIMEOUT)
+        http.open_timeout = args.fetch(:open_timeout, DEFAULT_TIMEOUT)
+
+        request = Net::HTTP::Post.new(uri.path, {
+          'Content-Type' => 'application/json',
+          'Authorization' => "Bearer #{api_key}"
+        })
+
+        max_tokens = args.dig(:gemini, :max_tokens)
+        request.body = generate_body(messages, model, json_schema, max_tokens, tools).to_json
+        response = http.request(request)
+
+        unless response.is_a?(Net::HTTPSuccess)
+          raise "Gemini API Error: #{response.code} - #{response.message}: #{response.body}"
+        end
+
+        parsed_response = JSON.parse(response.body)
+
+        handle_response(parsed_response)
+      rescue JSON::ParserError => e
+        raise "JSON Parse Error: #{e.message}"
+      end
+
+      private
+
+      # Validate the structure and content of the messages array.
+      def self.validate_messages!(messages)
+        unless messages.is_a?(Array) && messages.all? { |msg| msg.is_a?(Hash) }
+          raise ArgumentError, "Messages must be an array of message hashes."
+        end
+
+        if messages.empty?
+          raise ArgumentError, "Messages cannot be empty."
+        end
+
+        # Gemini's OpenAI-compatible chat endpoint requires that single-turn
+        # and general requests end with a user message. If not, return a clear error.
+        last_role = (messages.last[:role] || messages.last['role']).to_s
+        unless last_role == 'user'
+          raise ArgumentError, "Gemini: the last message must have role 'user'. Got '#{last_role}'."
+        end
+      end
+
+      # Helper method to generate the request body (OpenAI-compatible)
+      def self.generate_body(messages, model, json_schema, max_tokens, tools)
+        body = {
+          model: model,
+          messages: messages
+        }
+
+        body[:max_tokens] = max_tokens if max_tokens
+        body[:response_format] = { type: 'json_schema', json_schema: json_schema } if json_schema
+        body[:tools] = tools if tools
+
+        body
+      end
+
+      # Handles the API response, mirroring OpenAI semantics
+      def self.handle_response(response)
+        message = response.dig('choices', 0, 'message')
+        finish_reason = response.dig('choices', 0, 'finish_reason')
+
+        if message && message['refusal']
+          raise "Refusal: #{message['refusal']}"
+        end
+
+        if finish_reason == 'length'
+          raise "Incomplete response: The completion was cut off due to token limit."
+        end
+
+        if finish_reason == 'content_filter'
+          raise "Content filtered: The model's output was blocked due to policy violations."
+        end
+
+        if finish_reason == 'function_call' || finish_reason == 'tool_calls'
+          return { tool_calls: message['tool_calls'], content: message['content'] }
+        end
+
+        if finish_reason == 'stop'
+          return { content: message['content'] }
+        end
+
+        raise "Unexpected finish_reason: #{finish_reason}"
+      end
+    end
+  end
+end

data/lib/spectre/gemini/embeddings.rb

@@ -0,0 +1,44 @@
+# frozen_string_literal: true
+
+require 'net/http'
+require 'json'
+require 'uri'
+
+module Spectre
+  module Gemini
+    class Embeddings
+      # Using Google's OpenAI-compatible endpoint
+      API_URL = 'https://generativelanguage.googleapis.com/v1beta/openai/embeddings'
+      DEFAULT_MODEL = 'gemini-embedding-001'
+      DEFAULT_TIMEOUT = 60
+
+      # Generate embeddings for text
+      def self.create(text, model: DEFAULT_MODEL, **args)
+        api_key = Spectre.gemini_configuration&.api_key
+        raise APIKeyNotConfiguredError, "API key is not configured" unless api_key
+
+        uri = URI(API_URL)
+        http = Net::HTTP.new(uri.host, uri.port)
+        http.use_ssl = true
+        http.read_timeout = args.fetch(:read_timeout, DEFAULT_TIMEOUT)
+        http.open_timeout = args.fetch(:open_timeout, DEFAULT_TIMEOUT)
+
+        request = Net::HTTP::Post.new(uri.path, {
+          'Content-Type' => 'application/json',
+          'Authorization' => "Bearer #{api_key}"
+        })
+
+        request.body = { model: model, input: text }.to_json
+        response = http.request(request)
+
+        unless response.is_a?(Net::HTTPSuccess)
+          raise "Gemini API Error: #{response.code} - #{response.message}: #{response.body}"
+        end
+
+        JSON.parse(response.body).dig('data', 0, 'embedding')
+      rescue JSON::ParserError => e
+        raise "JSON Parse Error: #{e.message}"
+      end
+    end
+  end
+end

data/lib/spectre/gemini.rb

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+
+module Spectre
+  module Gemini
+    require_relative 'gemini/completions'
+    require_relative 'gemini/embeddings'
+  end
+end

data/lib/spectre/ollama/completions.rb

@@ -0,0 +1,135 @@
+# frozen_string_literal: true
+
+require 'net/http'
+require 'json'
+require 'uri'
+
+module Spectre
+  module Ollama
+    class Completions
+      API_PATH = 'api/chat'
+      DEFAULT_MODEL = 'llama3.1:8b'
+      DEFAULT_TIMEOUT = 60
+
+      # Class method to generate a completion based on user messages and optional tools
+      #
+      # @param messages [Array<Hash>] The conversation messages, each with a role and content
+      # @param model [String] The model to be used for generating completions, defaults to DEFAULT_MODEL
+      # @param json_schema [Hash, nil] An optional JSON schema to enforce structured output
+      # @param tools [Array<Hash>, nil] An optional array of tool definitions for function calling
+      # @param args [Hash, nil] optional arguments like read_timeout and open_timeout. You can pass in the ollama hash to specify the path and options.
+      # @param args.ollama.path [String, nil] The path to the Ollama API endpoint, defaults to API_PATH
+      # @param args.ollama.options [Hash, nil] Additional model parameters listed in the documentation for the https://github.com/ollama/ollama/blob/main/docs/modelfile.md#valid-parameters-and-values such as temperature
+      # @return [Hash] The parsed response including any function calls or content
+      # @raise [HostNotConfiguredError] If the API host is not set in the provider configuration.
+      # @raise [APIKeyNotConfiguredError] If the API key is not set
+      # @raise [RuntimeError] For general API errors or unexpected issues
+      def self.create(messages:, model: DEFAULT_MODEL, json_schema: nil, tools: nil, **args)
+        api_host = Spectre.ollama_configuration.host
+        api_key = Spectre.ollama_configuration.api_key
+        raise HostNotConfiguredError, "Host is not configured" unless api_host
+        raise APIKeyNotConfiguredError, "API key is not configured" unless api_key
+
+        validate_messages!(messages)
+
+        path = args.dig(:ollama, :path) || API_PATH
+        uri = URI.join(api_host, path)
+        http = Net::HTTP.new(uri.host, uri.port)
+        http.use_ssl = true if uri.scheme == 'https'
+        http.read_timeout = args.fetch(:read_timeout, DEFAULT_TIMEOUT)
+        http.open_timeout = args.fetch(:open_timeout, DEFAULT_TIMEOUT)
+
+        request = Net::HTTP::Post.new(uri.path, {
+          'Content-Type' => 'application/json',
+          'Authorization' => "Bearer #{api_key}"
+        })
+
+        options = args.dig(:ollama, :options)
+        request.body = generate_body(messages, model, json_schema, tools, options).to_json
+        response = http.request(request)
+
+        unless response.is_a?(Net::HTTPSuccess)
+          raise "Ollama API Error: #{response.code} - #{response.message}: #{response.body}"
+        end
+
+        parsed_response = JSON.parse(response.body)
+
+        handle_response(parsed_response)
+      rescue JSON::ParserError => e
+        raise "JSON Parse Error: #{e.message}"
+      end
+
+      private
+
+      # Validate the structure and content of the messages array.
+      #
+      # @param messages [Array<Hash>] The array of message hashes to validate.
+      #
+      # @raise [ArgumentError] if the messages array is not in the expected format or contains invalid data.
+      def self.validate_messages!(messages)
+        # Check if messages is an array of hashes.
+        # This ensures that the input is in the correct format for message processing.
+        unless messages.is_a?(Array) && messages.all? { |msg| msg.is_a?(Hash) }
+          raise ArgumentError, "Messages must be an array of message hashes."
+        end
+
+        # Check if the array is empty.
+        # This prevents requests with no messages, which would be invalid.
+        if messages.empty?
+          raise ArgumentError, "Messages cannot be empty."
+        end
+      end
+
+      # Helper method to generate the request body
+      #
+      # @param messages [Array<Hash>] The conversation messages, each with a role and content
+      # @param model [String] The model to be used for generating completions
+      # @param json_schema [Hash, nil] An optional JSON schema to enforce structured output
+      # @param tools [Array<Hash>, nil] An optional array of tool definitions for function calling
+      # @param options [Hash, nil] Additional model parameters listed in the documentation for the https://github.com/ollama/ollama/blob/main/docs/modelfile.md#valid-parameters-and-values such as temperature
+      # @return [Hash] The body for the API request
+      def self.generate_body(messages, model, json_schema, tools, options)
+        body = {
+          model: model,
+          stream: false,
+          messages: messages
+        }
+
+        # Extract schema if json_schema follows OpenAI's structure
+        if json_schema.is_a?(Hash) && json_schema.key?(:schema)
+          body[:format] = json_schema[:schema] # Use only the "schema" key
+        elsif json_schema.is_a?(Hash)
+          body[:format] = json_schema # Use the schema as-is if it doesn't follow OpenAI's structure
+        end
+
+        body[:tools] = tools if tools # Add the tools to the request body if provided
+        body[:options] = options if options
+
+        body
+      end
+
+      # Handles the API response, raising errors for specific cases and returning structured content otherwise
+      #
+      # @param response [Hash] The parsed API response
+      # @return [Hash] The relevant data based on the finish reason
+      def self.handle_response(response)
+        message = response.dig('message')
+        finish_reason = response.dig('done_reason')
+        done = response.dig('done')
+
+        # Check if the model made a function call
+        if message['tool_calls'] && !message['tool_calls'].empty?
+          return { tool_calls: message['tool_calls'], content: message['content'] }
+        end
+
+        # If the response finished normally, return the content
+        if done
+          return { content: message['content'] }
+        end
+
+        # Handle unexpected finish reasons
+        raise "Unexpected finish_reason: #{finish_reason}, done: #{done}, message: #{message}"
+      end
+    end
+  end
+end

data/lib/spectre/ollama/embeddings.rb

@@ -0,0 +1,59 @@
+# frozen_string_literal: true
+
+require 'net/http'
+require 'json'
+require 'uri'
+
+module Spectre
+  module Ollama
+    class Embeddings
+      API_PATH = 'api/embeddings'
+      DEFAULT_MODEL = 'nomic-embed-text'
+      PARAM_NAME = 'prompt'
+      DEFAULT_TIMEOUT = 60
+
+      # Class method to generate embeddings for a given text
+      #
+      # @param text [String] the text input for which embeddings are to be generated
+      # @param model [String] the model to be used for generating embeddings, defaults to DEFAULT_MODEL
+      # @param args [Hash, nil] optional arguments like read_timeout and open_timeout
+      # @param args.ollama.path [String, nil] the API path, defaults to API_PATH
+      # @param args.ollama.param_name [String, nil] the parameter key for the text input, defaults to PARAM_NAME
+      # @return [Array<Float>] the generated embedding vector
+      # @raise [HostNotConfiguredError] if the host is not set in the configuration
+      # @raise [APIKeyNotConfiguredError] if the API key is not set in the configuration
+      # @raise [RuntimeError] for API errors or invalid responses
+      # @raise [JSON::ParserError] if the response cannot be parsed as JSON
+      def self.create(text, model: DEFAULT_MODEL, **args)
+        api_host = Spectre.ollama_configuration.host
+        api_key = Spectre.ollama_configuration.api_key
+        raise HostNotConfiguredError, "Host is not configured" unless api_host
+        raise APIKeyNotConfiguredError, "API key is not configured" unless api_key
+
+        path = args.dig(:ollama, :path) || API_PATH
+        uri = URI.join(api_host, path)
+        http = Net::HTTP.new(uri.host, uri.port)
+        http.use_ssl = true if uri.scheme == 'https'
+        http.read_timeout = args.fetch(:read_timeout, DEFAULT_TIMEOUT)
+        http.open_timeout = args.fetch(:open_timeout, DEFAULT_TIMEOUT)
+
+        request = Net::HTTP::Post.new(uri.path, {
+          'Content-Type' => 'application/json',
+          'Authorization' => "Bearer #{api_key}"
+        })
+
+        param_name = args.dig(:ollama, :param_name) || PARAM_NAME
+        request.body = { model: model, param_name => text }.to_json
+        response = http.request(request)
+
+        unless response.is_a?(Net::HTTPSuccess)
+          raise "Ollama API Error: #{response.code} - #{response.message}: #{response.body}"
+        end
+
+        JSON.parse(response.body).dig('embedding')
+      rescue JSON::ParserError => e
+        raise "JSON Parse Error: #{e.message}"
+      end
+    end
+  end
+end

data/lib/spectre/ollama.rb

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+module Spectre
+  module Ollama
+    # Require each specific client file here
+    require_relative 'ollama/embeddings'
+    require_relative 'ollama/completions'
+  end
+end

data/lib/spectre/openai/completions.rb

@@ -16,14 +16,13 @@ module Spectre
       # @param messages [Array<Hash>] The conversation messages, each with a role and content
       # @param model [String] The model to be used for generating completions, defaults to DEFAULT_MODEL
       # @param json_schema [Hash, nil] An optional JSON schema to enforce structured output
-      # @param max_tokens [Integer] The maximum number of tokens for the completion (default: 50)
       # @param tools [Array<Hash>, nil] An optional array of tool definitions for function calling
-      # @param args [Hash] Optional arguments like timeouts
+      # @param args [Hash, nil] optional arguments like read_timeout and open_timeout. For OpenAI, max_tokens can be passed in the openai hash.
       # @return [Hash] The parsed response including any function calls or content
       # @raise [APIKeyNotConfiguredError] If the API key is not set
       # @raise [RuntimeError] For general API errors or unexpected issues
-      def self.create(messages:, model: DEFAULT_MODEL, json_schema: nil, max_tokens: nil, tools: nil, **args)
-        api_key = Spectre.api_key
+      def self.create(messages:, model: DEFAULT_MODEL, json_schema: nil, tools: nil, **args)
+        api_key = Spectre.openai_configuration.api_key
         raise APIKeyNotConfiguredError, "API key is not configured" unless api_key
 
         validate_messages!(messages)
@@ -39,6 +38,7 @@ module Spectre
           'Authorization' => "Bearer #{api_key}"
         })
 
+        max_tokens = args.dig(:openai, :max_tokens)
         request.body = generate_body(messages, model, json_schema, max_tokens, tools).to_json
         response = http.request(request)
 

data/lib/spectre/openai/embeddings.rb

@@ -15,12 +15,12 @@ module Spectre
       #
       # @param text [String] the text input for which embeddings are to be generated
       # @param model [String] the model to be used for generating embeddings, defaults to DEFAULT_MODEL
-      # # @param args [Hash] Optional arguments like timeouts
+      # @param args [Hash] optional arguments like read_timeout and open_timeout
       # @return [Array<Float>] the generated embedding vector
       # @raise [APIKeyNotConfiguredError] if the API key is not set
       # @raise [RuntimeError] for general API errors or unexpected issues
       def self.create(text, model: DEFAULT_MODEL, **args)
-        api_key = Spectre.api_key
+        api_key = Spectre.openai_configuration.api_key
         raise APIKeyNotConfiguredError, "API key is not configured" unless api_key
 
         uri = URI(API_URL)

data/lib/spectre/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Spectre # :nodoc:all
-  VERSION = "1.1.4"
+  VERSION = "2.0.0"
 end

data/lib/spectre.rb

@@ -4,16 +4,20 @@ require "spectre/version"
 require "spectre/embeddable"
 require 'spectre/searchable'
 require "spectre/openai"
+require "spectre/ollama"
+require "spectre/claude"
+require "spectre/gemini"
 require "spectre/logging"
 require 'spectre/prompt'
+require 'spectre/errors'
 
 module Spectre
-  class APIKeyNotConfiguredError < StandardError; end
-
   VALID_LLM_PROVIDERS = {
     openai: Spectre::Openai,
+    ollama: Spectre::Ollama,
+    claude: Spectre::Claude,
+    gemini: Spectre::Gemini
     # cohere: Spectre::Cohere,
-    # ollama: Spectre::Ollama
   }.freeze
 
   def self.included(base)
@@ -35,25 +39,93 @@ module Spectre
     end
   end
 
+  class Configuration
+    attr_accessor :default_llm_provider, :providers
+
+    def initialize
+      @providers = {}
+    end
+
+    def openai
+      @providers[:openai] ||= OpenaiConfiguration.new
+      yield @providers[:openai] if block_given?
+    end
+
+    def ollama
+      @providers[:ollama] ||= OllamaConfiguration.new
+      yield @providers[:ollama] if block_given?
+    end
+
+    def claude
+      @providers[:claude] ||= ClaudeConfiguration.new
+      yield @providers[:claude] if block_given?
+    end
+
+    def gemini
+      @providers[:gemini] ||= GeminiConfiguration.new
+      yield @providers[:gemini] if block_given?
+    end
+
+    def provider_configuration
+      providers[default_llm_provider] || raise("No configuration found for provider: #{default_llm_provider}")
+    end
+  end
+
+  class OpenaiConfiguration
+    attr_accessor :api_key
+  end
+
+  class OllamaConfiguration
+    attr_accessor :host, :api_key
+  end
+
+  class ClaudeConfiguration
+    attr_accessor :api_key
+  end
+
+  class GeminiConfiguration
+    attr_accessor :api_key
+  end
+
   class << self
-    attr_accessor :api_key, :llm_provider
+    attr_accessor :config
 
     def setup
-      yield self
+      self.config ||= Configuration.new
+      yield config
       validate_llm_provider!
     end
 
     def provider_module
-      VALID_LLM_PROVIDERS[llm_provider] || raise("LLM provider #{llm_provider} not supported")
+      VALID_LLM_PROVIDERS[config.default_llm_provider] || raise("LLM provider #{config.default_llm_provider} not supported")
+    end
+
+    def provider_configuration
+      config.provider_configuration
+    end
+
+    def openai_configuration
+      config.providers[:openai]
+    end
+
+    def ollama_configuration
+      config.providers[:ollama]
+    end
+
+    def claude_configuration
+      config.providers[:claude]
+    end
+
+    def gemini_configuration
+      config.providers[:gemini]
     end
 
     private
 
     def validate_llm_provider!
-      unless VALID_LLM_PROVIDERS.keys.include?(llm_provider)
-        raise ArgumentError, "Invalid llm_provider: #{llm_provider}. Must be one of: #{VALID_LLM_PROVIDERS.keys.join(', ')}"
+      unless VALID_LLM_PROVIDERS.keys.include?(config.default_llm_provider)
+        raise ArgumentError, "Invalid default_llm_provider: #{config.default_llm_provider}. Must be one of: #{VALID_LLM_PROVIDERS.keys.join(', ')}"
       end
     end
-
   end
 end

metadata

@@ -1,15 +1,15 @@
 --- !ruby/object:Gem::Specification
 name: spectre_ai
 version: !ruby/object:Gem::Version
-  version: 1.1.4
+  version: 2.0.0
 platform: ruby
 authors:
 - Ilya Klapatok
 - Matthew Black
-autorequire: 
+autorequire:
 bindir: bin
 cert_chain: []
-date: 2024-12-04 00:00:00.000000000 Z
+date: 2025-09-24 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rspec-rails
@@ -53,8 +53,17 @@ files:
 - lib/generators/spectre/templates/rag/user.yml.erb
 - lib/generators/spectre/templates/spectre_initializer.rb
 - lib/spectre.rb
+- lib/spectre/claude.rb
+- lib/spectre/claude/completions.rb
 - lib/spectre/embeddable.rb
+- lib/spectre/errors.rb
+- lib/spectre/gemini.rb
+- lib/spectre/gemini/completions.rb
+- lib/spectre/gemini/embeddings.rb
 - lib/spectre/logging.rb
+- lib/spectre/ollama.rb
+- lib/spectre/ollama/completions.rb
+- lib/spectre/ollama/embeddings.rb
 - lib/spectre/openai.rb
 - lib/spectre/openai/completions.rb
 - lib/spectre/openai/embeddings.rb
@@ -65,7 +74,7 @@ homepage: https://github.com/hiremav/spectre
 licenses:
 - MIT
 metadata: {}
-post_install_message: 
+post_install_message:
 rdoc_options: []
 require_paths:
 - lib
@@ -81,7 +90,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubygems_version: 3.5.11
-signing_key: 
+signing_key:
 specification_version: 4
 summary: Spectre
 test_files: []