llm_logs 0.2.6 → 0.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 2d74b0f40702d1e844d16656a8c3e9c48f6f8f6fc6114097153b4d93389cd123
-  data.tar.gz: 20287a2481a84ed43c6967801b09c40ec4e533a78c87e10f315e9dbc37f866d1
+  metadata.gz: 042ed62e3a524de1a05ab6a8ce4184abe0634257c49d27da7f91e470d9810a66
+  data.tar.gz: 48b40cad0e67865812a1eca95cd6d2968309883ec66c55d8473ef274ec82b56c
 SHA512:
-  metadata.gz: 0f24855ed39f9e45b2c734ee66195045846bf6ba6b2834e83ff7f1b91a51af1d6f5042a31053a85ca662913743275d355f4e30616fa60cc6fc0255412c44afdd
-  data.tar.gz: 1ce3ee37439dfa90986394cf39e85bd67c6631d6d96a9c7138e0c2224af9a27a5d6d7c8661cb7c71950a8ed640f12f0396d7656bf073e4033d31632129cb87ea
+  metadata.gz: 74ff56b932ebe8b4f4fd4f810dfdb2f36be1b2011af5a0dc7fb1d0e43f1866a2e2bdb2ef450e2389d0a9e1660c3a93d6a9d6d98eb5f56ba20cde8bdde75793c6
+  data.tar.gz: 584ef268fb5947dcae78f95deb5a379337cbe6db5cede8b1eb6b4b2d89580a93d3cd5aa5b913c39e7fbd2a128881cf21c66fe7523d82137f27dc5215ca99eca7

data/README.md

@@ -182,9 +182,14 @@ Running the task creates missing prompts, updates metadata, and creates a new pr
 
 ## Batches
 
-Send requests through the [OpenAI Responses Batch API](https://platform.openai.com/docs/guides/batch) for roughly half the cost when latency doesn't matter. LlmLogs persists each request, groups pending requests into a provider batch, reconciles results, and records a trace per request — so batched work shows up in the dashboard alongside synchronous calls.
+Send latency-insensitive requests through a provider's Batch API for roughly half the cost. LlmLogs persists each request, groups pending requests into a provider batch, reconciles results, and records a trace per request — so batched work shows up in the dashboard alongside synchronous calls.
 
-Batch support uses the [`ruby_llm-responses_api`](https://rubygems.org/gems/ruby_llm-responses_api) provider. Add it to your app's Gemfile:
+Two batch backends are supported, selected **per model**:
+
+- **[OpenAI Responses Batch API](https://platform.openai.com/docs/guides/batch)** via [`ruby_llm-responses_api`](https://rubygems.org/gems/ruby_llm-responses_api) — the default for OpenAI models.
+- **[AWS Bedrock Batch API](#aws-bedrock-batches)** (`CreateModelInvocationJob`) for Anthropic Claude models.
+
+Add the OpenAI provider to your app's Gemfile:
 
 ```ruby
 gem "ruby_llm-responses_api"
@@ -246,6 +251,45 @@ LlmLogs::Batch::PollJob.perform_later
 
 `FlushJob` claims pending rows with `FOR UPDATE SKIP LOCKED`, so concurrent runs never double-submit. `PollJob` reconciles all unfinished batches and recovers requests stranded by an interrupted submission. Both are idempotent at the request level — already-resolved requests are skipped on re-run.
 
+### AWS Bedrock batches
+
+Anthropic Claude models can batch through the AWS Bedrock Batch API. Bedrock batching is file-based: LlmLogs writes a JSONL manifest to S3, starts a `CreateModelInvocationJob`, and reads the results back from S3. The enqueue/handler/flush/reconcile flow above is identical — only the backend differs.
+
+Add the AWS SDKs to your app's Gemfile:
+
+```ruby
+gem "aws-sdk-bedrock"
+gem "aws-sdk-s3"
+```
+
+Configure the Bedrock backend and register its adapter, pointing it at an S3 bucket and an IAM role Bedrock can assume:
+
+```ruby
+# config/initializers/llm_logs.rb
+LlmLogs.configuration.bedrock_batch = LlmLogs::Configuration::BedrockBatch.new(
+  role_arn:      "arn:aws:iam::<account>:role/<bedrock-batch-role>", # role Bedrock assumes to read/write S3
+  s3_bucket:     "my-bedrock-batch-bucket",                          # must be in the model's region
+  s3_prefix:     "llm-batch",
+  min_records:   100,                                                # Bedrock's minimum records per job
+  model_matcher: /\Aanthropic\./,                                    # model ids that route to Bedrock
+  region:        "us-east-1"
+)
+LlmLogs.register_batch_adapter(:bedrock, LlmLogs::Batch::Adapters::Bedrock.new)
+```
+
+Provider selection is per model: `LlmLogs::Batch.batch_provider_for(model)` returns `:bedrock` when the adapter is registered and `model_matcher` matches, otherwise the OpenAI backend when the model resolves there, otherwise `nil` (not batchable — run it synchronously). Bedrock enforces a **minimum records per job**, so check `LlmLogs::Batch.min_records_for(model)` and fall back to a synchronous call when a batch would be under the floor.
+
+The adapter builds its AWS clients from the ambient credential chain by default; inject your own to authenticate explicitly:
+
+```ruby
+LlmLogs::Batch::Adapters::Bedrock.new(
+  s3:      Aws::S3::Client.new(region: "us-east-1", credentials: creds),
+  bedrock: Aws::Bedrock::Client.new(region: "us-east-1", credentials: creds)
+)
+```
+
+**Prerequisites:** an S3 bucket in the model's region, and an IAM service role trusting `bedrock.amazonaws.com` with `s3:GetObject`/`s3:PutObject` on the bucket prefix. The principal that calls the API needs `bedrock:CreateModelInvocationJob`, `bedrock:GetModelInvocationJob`, and `iam:PassRole` on that role.
+
 ## Web UI
 
 Browse traces and manage prompts at `/llm_logs`.
@@ -266,7 +310,7 @@ LlmLogs.setup do |config|
   config.prompts_source_path = Rails.root.join("db/data/prompts")
   config.prompt_subfolders = %w[skills fragments templates]
   config.batch_enabled = true                                # enable the batch API integration
-  config.batch_provider = :openai_responses                  # batch backend
+  config.batch_provider = :openai_responses                  # default (OpenAI) backend; Bedrock is registered separately (see Batches)
   config.page_size = 50                                      # rows per page on all index pages
 end
 ```

data/app/jobs/llm_logs/batch/poll_job.rb

@@ -10,7 +10,7 @@ module LlmLogs
 
       def perform
         recover_stale_claims
-        LlmLogs::Batch.unreconciled.where.not(openai_batch_id: nil).find_each do |batch|
+        LlmLogs::Batch.unreconciled.where.not(provider_batch_id: nil).find_each do |batch|
           batch.reconcile!
         rescue StandardError => e
           Rails.logger.error("[llm_logs] batch #{batch.id} reconcile failed: #{e.class}: #{e.message}")
@@ -21,7 +21,7 @@ module LlmLogs
 
       def recover_stale_claims
         LlmLogs::Batch
-          .where(status: :pending, openai_batch_id: nil)
+          .where(status: :pending, provider_batch_id: nil)
           .where("created_at < ?", STALE_CLAIM_AFTER.ago)
           .find_each do |batch|
             batch.requests.update_all(batch_id: nil, status: :pending)

data/app/models/llm_logs/batch/adapters/bedrock.rb

@@ -0,0 +1,137 @@
+require "json"
+require "securerandom"
+
+module LlmLogs
+  class Batch
+    module Adapters
+      # AWS Bedrock Batch API (CreateModelInvocationJob). Writes a JSONL manifest to S3,
+      # starts an async job, polls it, and reads the output JSONL back from S3. Unlike the
+      # OpenAI adapter, submission/output is file-based (S3) rather than an upload endpoint.
+      class Bedrock
+        ANTHROPIC_VERSION = "bedrock-2023-05-31"
+        DEFAULT_MAX_TOKENS = 1024
+
+        Result = Struct.new(:content, :input_tokens, :output_tokens, :model_id, keyword_init: true)
+
+        def initialize(config: LlmLogs.bedrock_batch, s3: nil, bedrock: nil)
+          @config = config
+          @s3 = s3
+          @bedrock = bedrock
+        end
+
+        def submit(batch, requests)
+          key = "#{@config.s3_prefix}/#{batch.id}/input.jsonl"
+          manifest = requests.map { |r| JSON.generate(record_for(r)) }.join("\n") + "\n"
+          s3.put_object(bucket: @config.s3_bucket, key: key, body: manifest)
+
+          input_uri = "s3://#{@config.s3_bucket}/#{key}"
+          output_uri = "s3://#{@config.s3_bucket}/#{@config.s3_prefix}/#{batch.id}/out/"
+          job = bedrock.create_model_invocation_job(
+            job_name: job_name_for(batch),
+            role_arn: @config.role_arn,
+            model_id: batch.model,
+            input_data_config: {s3_input_data_config: {s3_uri: input_uri}},
+            output_data_config: {s3_output_data_config: {s3_uri: output_uri}}
+          )
+
+          {
+            provider_batch_id: job.job_arn,
+            openai_batch_id: nil,
+            provider_metadata: {
+              "s3_input_uri" => input_uri,
+              "s3_output_uri" => output_uri,
+              "job_id" => job.job_arn.split("/").last,
+              "input_basename" => "input.jsonl"
+            }
+          }
+        end
+
+        def terminal_status(batch)
+          job = bedrock.get_model_invocation_job(job_identifier: batch.provider_batch_id)
+          case job.status
+          when "Completed" then "completed"
+          when "Failed", "Stopped", "PartiallyCompleted" then "failed"
+          when "Expired" then "expired"
+          else "in_progress"
+          end
+        end
+
+        def results(batch)
+          parsed_output(batch).each_with_object({}) do |line, acc|
+            next if line["recordId"].nil? || line["error"]
+
+            output = line["modelOutput"] || {}
+            usage = output["usage"] || {}
+            acc[line["recordId"]] = Result.new(
+              content: extract_content(output),
+              input_tokens: usage["input_tokens"],
+              output_tokens: usage["output_tokens"],
+              model_id: output["model"] || batch.model
+            )
+          end
+        end
+
+        def error_ids(batch)
+          parsed_output(batch).filter_map { |line| line["recordId"] if line["error"] }
+        end
+
+        private
+
+        # Bedrock jobName allows only [A-Za-z0-9] plus '-', '+', '.'. Purposes such as
+        # "eval_judge" contain underscores, so map any disallowed character to a hyphen.
+        def job_name_for(batch)
+          "llmlogs-#{batch.purpose}-#{batch.id}-#{SecureRandom.hex(4)}".gsub(/[^a-zA-Z0-9+.-]/, "-")
+        end
+
+        # One JSONL record: {recordId, modelInput: <native Anthropic Messages body>}.
+        def record_for(request)
+          payload = request.payload
+          {recordId: request.custom_id, modelInput: model_input(payload)}
+        end
+
+        def model_input(payload)
+          body = {
+            "anthropic_version" => ANTHROPIC_VERSION,
+            "max_tokens" => DEFAULT_MAX_TOKENS,
+            "messages" => [{"role" => "user", "content" => payload["input"]}]
+          }
+          body["system"] = payload["instructions"] if payload["instructions"]
+          body.merge!(structured_output(payload["schema"])) if payload["schema"]
+          body
+        end
+
+        # Anthropic structured output via a single forced tool (verify encoding against QA).
+        def structured_output(schema)
+          spec = schema["schema"] || schema
+          {
+            "tools" => [{"name" => schema["name"] || "response", "description" => "Return the structured response.", "input_schema" => spec}],
+            "tool_choice" => {"type" => "tool", "name" => schema["name"] || "response"}
+          }
+        end
+
+        def extract_content(output)
+          blocks = output["content"] || []
+          tool = blocks.find { |b| b["type"] == "tool_use" }
+          return JSON.generate(tool["input"]) if tool
+
+          blocks.filter_map { |b| b["text"] if b["type"] == "text" }.join
+        end
+
+        def parsed_output(batch)
+          meta = batch.provider_metadata
+          key = "#{@config.s3_prefix}/#{batch.id}/out/#{meta["job_id"]}/#{meta["input_basename"]}.out"
+          body = s3.get_object(bucket: @config.s3_bucket, key: key).body.read
+          body.each_line.filter_map { |l| JSON.parse(l) unless l.strip.empty? }
+        end
+
+        def s3
+          @s3 ||= (require "aws-sdk-s3"; Aws::S3::Client.new(region: @config.region))
+        end
+
+        def bedrock
+          @bedrock ||= (require "aws-sdk-bedrock"; Aws::Bedrock::Client.new(region: @config.region))
+        end
+      end
+    end
+  end
+end

data/app/models/llm_logs/batch/adapters/openai_responses.rb

@@ -0,0 +1,54 @@
+module LlmLogs
+  class Batch
+    module Adapters
+      # Wraps ruby_llm-responses_api's OpenAI Batch API. Contains the remote-API logic
+      # previously inline in Submitter/Reconciler; the DB/claim lifecycle stays in those.
+      class OpenaiResponses
+        PROVIDER = :openai_responses
+
+        def submit(_batch, requests)
+          rubyllm_batch = RubyLLM.batch(model: requests.first.model, provider: PROVIDER)
+          requests.each do |request|
+            payload = request.payload
+            rubyllm_batch.add(
+              payload["input"],
+              id: request.custom_id,
+              instructions: payload["instructions"],
+              temperature: payload["temperature"],
+              **schema_extra(payload["schema"])
+            )
+          end
+          rubyllm_batch.create!
+          {provider_batch_id: rubyllm_batch.id, openai_batch_id: rubyllm_batch.id, provider_metadata: {}}
+        end
+
+        def terminal_status(batch)
+          resume(batch).status
+        end
+
+        def results(batch)
+          resume(batch).results
+        end
+
+        def error_ids(batch)
+          resume(batch).errors.filter_map { |e| e["custom_id"] }
+        end
+
+        private
+
+        # No memoization: LlmLogs.batch_adapters holds one shared instance of this adapter
+        # for the life of the process, so caching the resumed handle here would go stale
+        # for a long-running PollJob worker (in-progress batches would never re-fetch a
+        # later terminal status) and would grow unbounded. Build a fresh handle every call.
+        def resume(batch)
+          RubyLLM.batch(id: batch.provider_batch_id, provider: PROVIDER)
+        end
+
+        def schema_extra(schema)
+          format = SchemaFormat.call(schema)
+          format ? {text: format} : {}
+        end
+      end
+    end
+  end
+end

data/app/models/llm_logs/batch/reconciler.rb

@@ -9,12 +9,11 @@ module LlmLogs
       end
 
       def call
-        rubyllm_batch = RubyLLM.batch(id: @batch.openai_batch_id, provider: LlmLogs.batch_provider)
-        status = rubyllm_batch.status
-
+        adapter = LlmLogs::Batch.adapter_for(@batch.provider)
+        status = adapter.terminal_status(@batch)
         case status
         when "completed"
-          reconcile_completed(rubyllm_batch)
+          reconcile_completed(adapter)
         when "failed", "expired", "cancelled"
           fail_all(status)
         end
@@ -23,9 +22,9 @@ module LlmLogs
 
       private
 
-      def reconcile_completed(rubyllm_batch)
-        results = rubyllm_batch.results
-        error_ids = rubyllm_batch.errors.filter_map { |e| e["custom_id"] }
+      def reconcile_completed(adapter)
+        results = adapter.results(@batch)
+        error_ids = adapter.error_ids(@batch)
 
         @batch.update!(status: :completed, completed_at: Time.current)
 
@@ -42,7 +41,7 @@ module LlmLogs
       end
 
       def reconcile_success(request, message)
-        trace = TraceRecorder.record(request: request, message: message)
+        trace = TraceRecorder.record(request: request, message: message, provider: @batch.provider)
         request.assign_attributes(
           result_content: result_content_for(message.content),
           input_tokens: message.input_tokens,

data/app/models/llm_logs/batch/submitter.rb

@@ -34,7 +34,7 @@ module LlmLogs
 
           batch = LlmLogs::Batch.create!(
             purpose: @purpose,
-            provider: LlmLogs.batch_provider.to_s,
+            provider: LlmLogs::Batch.batch_provider_for(@model).to_s,
             model: @model,
             status: :pending,
             request_count: requests.size,
@@ -46,19 +46,14 @@ module LlmLogs
       end
 
       def submit(batch)
-        rubyllm_batch = RubyLLM.batch(model: @model, provider: LlmLogs.batch_provider)
-        batch.requests.each do |request|
-          payload = request.payload
-          rubyllm_batch.add(
-            payload["input"],
-            id: request.custom_id,
-            instructions: payload["instructions"],
-            temperature: payload["temperature"],
-            **schema_extra(payload["schema"])
-          )
-        end
-        rubyllm_batch.create!
-        batch.update!(openai_batch_id: rubyllm_batch.id, status: :submitted, submitted_at: Time.current)
+        result = LlmLogs::Batch.adapter_for(batch.provider).submit(batch, batch.requests.to_a)
+        batch.update!(
+          provider_batch_id: result[:provider_batch_id],
+          openai_batch_id: result[:openai_batch_id],
+          provider_metadata: result[:provider_metadata] || {},
+          status: :submitted,
+          submitted_at: Time.current
+        )
       rescue StandardError
         # Release the claim so the requests retry on the next flush, and drop the
         # placeholder batch so it isn't polled. Re-raise so the caller/job sees the error.
@@ -66,11 +61,6 @@ module LlmLogs
         batch.destroy
         raise
       end
-
-      def schema_extra(schema)
-        format = SchemaFormat.call(schema)
-        format ? { text: format } : {}
-      end
     end
   end
 end

data/app/models/llm_logs/batch/trace_recorder.rb

@@ -8,7 +8,7 @@ module LlmLogs
 
       module_function
 
-      def record(request:, message:)
+      def record(request:, message:, provider:)
         trace = nil
         metadata = request.routing.merge("execution_mode" => "batch")
         LlmLogs.trace(request.purpose, metadata: metadata) do |t|
@@ -20,7 +20,7 @@ module LlmLogs
             name: "batch.complete",
             span_type: "llm",
             model: message.model_id || request.model,
-            provider: LlmLogs.batch_provider.to_s,
+            provider: provider.to_s,
             input: request.payload["input"]
           )
           span.update!(

data/app/models/llm_logs/batch.rb

@@ -42,8 +42,43 @@ module LlmLogs
       Reconciler.new(self).call
     end
 
+    def self.adapter_for(provider)
+      LlmLogs.batch_adapters.fetch(provider.to_sym) do
+        raise ArgumentError, "no batch adapter registered for provider #{provider.inspect}"
+      end
+    end
+
     def self.batchable?(model)
       return false unless LlmLogs.batch_enabled?
+
+      !batch_provider_for(model).nil?
+    end
+
+    # Which batch provider (if any) serves this model. Bedrock wins for Claude models when
+    # the Bedrock adapter is configured; otherwise fall back to the OpenAI provider when the
+    # model resolves there; otherwise nil (run synchronously).
+    def self.batch_provider_for(model)
+      return :bedrock if bedrock_serves?(model)
+      return :openai_responses if openai_serves?(model)
+
+      nil
+    end
+
+    # The Bedrock minimum records-per-job floor for this model (0 when Bedrock does not serve it).
+    def self.min_records_for(model)
+      batch_provider_for(model) == :bedrock ? LlmLogs.bedrock_batch.min_records.to_i : 0
+    end
+
+    def self.bedrock_serves?(model)
+      config = LlmLogs.bedrock_batch
+      return false if config.nil?
+      return false unless LlmLogs.batch_adapters.key?(:bedrock)
+
+      matcher = config.model_matcher
+      matcher.respond_to?(:call) ? matcher.call(model.to_s) : matcher.match?(model.to_s)
+    end
+
+    def self.openai_serves?(model)
       return false unless defined?(RubyLLM::Providers::OpenAIResponses)
 
       servable_by_batch_provider?(model)

data/app/views/llm_logs/batches/index.html.erb

@@ -18,6 +18,7 @@
         <th class="px-4 py-3 text-left text-xs font-medium text-gray-500 uppercase">ID</th>
         <th class="px-4 py-3 text-left text-xs font-medium text-gray-500 uppercase">Purpose</th>
         <th class="px-4 py-3 text-left text-xs font-medium text-gray-500 uppercase">Model</th>
+        <th class="px-4 py-3 text-left text-xs font-medium text-gray-500 uppercase">Provider</th>
         <th class="px-4 py-3 text-left text-xs font-medium text-gray-500 uppercase">OpenAI Batch</th>
         <th class="px-4 py-3 text-right text-xs font-medium text-gray-500 uppercase">Requests</th>
         <th class="px-4 py-3 text-left text-xs font-medium text-gray-500 uppercase">Status</th>
@@ -31,6 +32,7 @@
           <td class="px-4 py-3 text-sm"><%= link_to "##{batch.id}", batch_path(batch), class: "text-indigo-600 hover:text-indigo-900 font-mono" %></td>
           <td class="px-4 py-3 text-sm"><%= link_to batch.purpose, batch_path(batch), class: "text-indigo-600 hover:text-indigo-900 font-medium" %></td>
           <td class="px-4 py-3 text-sm text-gray-500"><%= batch.model %></td>
+          <td class="px-4 py-3 text-sm text-gray-500"><%= batch.provider %></td>
           <td class="px-4 py-3 text-sm text-gray-500 font-mono"><%= batch.openai_batch_id %></td>
           <td class="px-4 py-3 text-sm text-gray-500 text-right"><%= batch.request_count %></td>
           <td class="px-4 py-3 text-sm">
@@ -40,7 +42,7 @@
         </tr>
       <% end %>
       <% if @batches.empty? %>
-        <tr><td colspan="7" class="px-4 py-8 text-center text-sm text-gray-500">No batches found.</td></tr>
+        <tr><td colspan="8" class="px-4 py-8 text-center text-sm text-gray-500">No batches found.</td></tr>
       <% end %>
     </tbody>
   </table>

data/app/views/llm_logs/batches/show.html.erb

@@ -2,9 +2,19 @@
   <%= link_to "← Batches", batches_path, class: "text-sm text-indigo-600 hover:text-indigo-900" %>
   <h1 class="text-2xl font-bold text-gray-900 mt-2"><%= @batch.purpose %> · <%= @batch.model %></h1>
   <p class="text-sm text-gray-500 mt-1">
+    Provider: <span class="font-mono"><%= @batch.provider %></span> ·
     OpenAI: <span class="font-mono"><%= @batch.openai_batch_id %></span> · status <%= @batch.status %> ·
     <%= @batch.request_count %> requests
   </p>
+  <p class="text-sm text-gray-500 mt-1">
+    Provider batch: <span class="font-mono"><%= @batch.provider_batch_id %></span>
+  </p>
+  <% if @batch.provider_metadata.present? %>
+    <p class="text-sm text-gray-500 mt-1">
+      S3 output: <span class="font-mono"><%= @batch.provider_metadata["s3_output_uri"] %></span> ·
+      Job ID: <span class="font-mono"><%= @batch.provider_metadata["job_id"] %></span>
+    </p>
+  <% end %>
 </div>
 
 <div class="bg-white shadow-sm ring-1 ring-gray-900/5 rounded-lg overflow-hidden">

data/db/migrate/009_add_provider_columns_to_llm_logs_batches.rb

@@ -0,0 +1,17 @@
+class AddProviderColumnsToLlmLogsBatches < ActiveRecord::Migration[8.0]
+  def change
+    add_column :llm_logs_batches, :provider_batch_id, :string
+    add_column :llm_logs_batches, :provider_metadata, :jsonb, null: false, default: {}
+    add_index  :llm_logs_batches, :provider_batch_id
+
+    # Backfill existing OpenAI rows so the reconciler/poll job can key off the
+    # generic column uniformly.
+    up_only do
+      execute <<~SQL.squish
+        UPDATE llm_logs_batches
+        SET provider_batch_id = openai_batch_id
+        WHERE openai_batch_id IS NOT NULL
+      SQL
+    end
+  end
+end

data/lib/llm_logs/configuration.rb

@@ -1,7 +1,9 @@
 module LlmLogs
   class Configuration
+    BedrockBatch = Struct.new(:role_arn, :s3_bucket, :s3_prefix, :min_records, :model_matcher, :region, keyword_init: true)
+
     attr_accessor :enabled, :auto_instrument, :retention_days, :prompts_source_path, :prompt_subfolders,
-                  :batch_enabled, :batch_provider, :page_size
+                  :batch_enabled, :batch_provider, :page_size, :bedrock_batch
 
     def initialize
       @enabled             = true
@@ -12,6 +14,7 @@ module LlmLogs
       @batch_enabled       = true
       @batch_provider      = :openai_responses
       @page_size           = 50
+      @bedrock_batch       = nil
     end
   end
 

data/lib/llm_logs/version.rb

@@ -1,3 +1,3 @@
 module LlmLogs
-  VERSION = "0.2.6"
+  VERSION = "0.3.0"
 end

data/lib/llm_logs.rb

@@ -54,6 +54,10 @@ module LlmLogs
     configuration.batch_provider
   end
 
+  def self.bedrock_batch
+    configuration.bedrock_batch
+  end
+
   def self.register_batch_handler(purpose, handler)
     LlmLogs::Batch::HandlerRegistry.register(purpose, handler)
   end
@@ -62,6 +66,14 @@ module LlmLogs
     LlmLogs::Batch::HandlerRegistry.resolve(purpose)
   end
 
+  def self.batch_adapters
+    @batch_adapters ||= {openai_responses: LlmLogs::Batch::Adapters::OpenaiResponses.new}
+  end
+
+  def self.register_batch_adapter(provider, adapter)
+    batch_adapters[provider.to_sym] = adapter
+  end
+
   def self.trace(name, **options, &block)
     LlmLogs::Tracer.start_trace(name, **options, &block)
   end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: llm_logs
 version: !ruby/object:Gem::Version
-  version: 0.2.6
+  version: 0.3.0
 platform: ruby
 authors:
 - Anton
@@ -135,6 +135,34 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '3.0'
+- !ruby/object:Gem::Dependency
+  name: aws-sdk-bedrock
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.0'
+- !ruby/object:Gem::Dependency
+  name: aws-sdk-s3
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.0'
 description: Mountable Rails engine that provides hierarchical LLM call tracing and
   versioned prompt management with Mustache templates.
 executables: []
@@ -157,6 +185,8 @@ files:
 - app/jobs/llm_logs/batch/poll_job.rb
 - app/models/llm_logs/application_record.rb
 - app/models/llm_logs/batch.rb
+- app/models/llm_logs/batch/adapters/bedrock.rb
+- app/models/llm_logs/batch/adapters/openai_responses.rb
 - app/models/llm_logs/batch/handler_registry.rb
 - app/models/llm_logs/batch/reconciler.rb
 - app/models/llm_logs/batch/schema_format.rb
@@ -199,6 +229,7 @@ files:
 - db/migrate/006_add_tags_to_prompts.rb
 - db/migrate/007_create_llm_logs_batches.rb
 - db/migrate/008_create_llm_logs_batch_requests.rb
+- db/migrate/009_add_provider_columns_to_llm_logs_batches.rb
 - lib/generators/llm_logs/install_generator.rb
 - lib/generators/llm_logs/templates/initializer.rb
 - lib/llm_logs.rb