prompt_objects 0.2.0 → 0.3.0

data/frontend/src/components/ThreadsSidebar.tsx

@@ -1,10 +1,13 @@
-import { useMemo } from 'react'
+import { useMemo, useState } from 'react'
+import { ContextMenu } from './ContextMenu'
 import type { PromptObject, Session, ThreadType } from '../types'
 
 interface ThreadsSidebarProps {
   po: PromptObject
   switchSession: (target: string, sessionId: string) => void
   createThread: (target: string) => void
+  requestUsage?: (sessionId: string, includeTree?: boolean) => void
+  exportThread?: (sessionId: string, format?: string) => void
 }
 
 // Build a flat list with depth info
@@ -59,12 +62,18 @@ function ThreadTypeIcon({ type }: { type: ThreadType }) {
   }
 }
 
-export function ThreadsSidebar({ po, switchSession, createThread }: ThreadsSidebarProps) {
+export function ThreadsSidebar({ po, switchSession, createThread, requestUsage, exportThread }: ThreadsSidebarProps) {
   const sessions = po.sessions || []
   const currentSessionId = po.current_session?.id
+  const [contextMenu, setContextMenu] = useState<{ x: number; y: number; sessionId: string } | null>(null)
 
   const threadList = useMemo(() => buildThreadList(sessions), [sessions])
 
+  const handleContextMenu = (e: React.MouseEvent, sessionId: string) => {
+    e.preventDefault()
+    setContextMenu({ x: e.clientX, y: e.clientY, sessionId })
+  }
+
   return (
     <div className="h-full flex flex-col">
       <div className="p-3 border-b border-po-border flex items-center justify-between">
@@ -88,6 +97,7 @@ export function ThreadsSidebar({ po, switchSession, createThread }: ThreadsSideb
             <button
               key={session.id}
               onClick={() => switchSession(po.name, session.id)}
+              onContextMenu={(e) => handleContextMenu(e, session.id)}
               className={`w-full text-left p-2 rounded text-xs transition-colors ${
                 session.id === currentSessionId
                   ? 'bg-po-accent/20 border border-po-accent'
@@ -114,6 +124,40 @@ export function ThreadsSidebar({ po, switchSession, createThread }: ThreadsSideb
           ))
         )}
       </div>
+
+      {contextMenu && (
+        <ContextMenu
+          x={contextMenu.x}
+          y={contextMenu.y}
+          onClose={() => setContextMenu(null)}
+          items={[
+            ...(requestUsage ? [
+              {
+                label: 'View Usage',
+                icon: '📊',
+                onClick: () => requestUsage(contextMenu.sessionId),
+              },
+              {
+                label: 'View Tree Usage',
+                icon: '🌳',
+                onClick: () => requestUsage(contextMenu.sessionId, true),
+              },
+            ] : []),
+            ...(exportThread ? [
+              {
+                label: 'Export as Markdown',
+                icon: '📄',
+                onClick: () => exportThread(contextMenu.sessionId, 'markdown'),
+              },
+              {
+                label: 'Export as JSON',
+                icon: '📋',
+                onClick: () => exportThread(contextMenu.sessionId, 'json'),
+              },
+            ] : []),
+          ]}
+        />
+      )}
     </div>
   )
 }

data/frontend/src/components/UsagePanel.tsx

@@ -0,0 +1,105 @@
+interface UsageData {
+  session_id: string
+  include_tree: boolean
+  input_tokens: number
+  output_tokens: number
+  total_tokens: number
+  estimated_cost_usd: number
+  calls: number
+  by_model: Record<string, {
+    input_tokens: number
+    output_tokens: number
+    estimated_cost_usd: number
+    calls: number
+  }>
+}
+
+interface UsagePanelProps {
+  usage: UsageData
+  onClose: () => void
+}
+
+function formatTokens(n: number): string {
+  if (n >= 1_000_000) return `${(n / 1_000_000).toFixed(1)}M`
+  if (n >= 1_000) return `${(n / 1_000).toFixed(1)}k`
+  return n.toString()
+}
+
+function formatCost(usd: number): string {
+  if (usd === 0) return '$0.00'
+  if (usd < 0.01) return `$${usd.toFixed(4)}`
+  return `$${usd.toFixed(2)}`
+}
+
+export function UsagePanel({ usage, onClose }: UsagePanelProps) {
+  const models = Object.entries(usage.by_model)
+
+  return (
+    <div className="fixed inset-0 z-50 flex items-center justify-center bg-black/50" onClick={onClose}>
+      <div
+        className="bg-po-surface border border-po-border rounded-lg shadow-2xl w-[420px] max-h-[80vh] overflow-auto"
+        onClick={(e) => e.stopPropagation()}
+      >
+        <div className="flex items-center justify-between p-4 border-b border-po-border">
+          <h3 className="font-medium text-white">
+            Token Usage {usage.include_tree && <span className="text-xs text-gray-400 ml-1">(full tree)</span>}
+          </h3>
+          <button onClick={onClose} className="text-gray-400 hover:text-white transition-colors">
+            &times;
+          </button>
+        </div>
+
+        <div className="p-4 space-y-4">
+          {/* Summary */}
+          <div className="grid grid-cols-3 gap-3">
+            <div className="bg-po-bg rounded-lg p-3 text-center">
+              <div className="text-lg font-mono text-po-accent">{formatTokens(usage.input_tokens)}</div>
+              <div className="text-[10px] text-gray-500 uppercase tracking-wider">Input</div>
+            </div>
+            <div className="bg-po-bg rounded-lg p-3 text-center">
+              <div className="text-lg font-mono text-po-warning">{formatTokens(usage.output_tokens)}</div>
+              <div className="text-[10px] text-gray-500 uppercase tracking-wider">Output</div>
+            </div>
+            <div className="bg-po-bg rounded-lg p-3 text-center">
+              <div className="text-lg font-mono text-white">{formatCost(usage.estimated_cost_usd)}</div>
+              <div className="text-[10px] text-gray-500 uppercase tracking-wider">Est. Cost</div>
+            </div>
+          </div>
+
+          <div className="flex justify-between text-xs text-gray-400 px-1">
+            <span>{usage.calls} LLM call{usage.calls !== 1 ? 's' : ''}</span>
+            <span>{formatTokens(usage.total_tokens)} total tokens</span>
+          </div>
+
+          {/* Per-model breakdown */}
+          {models.length > 0 && (
+            <div>
+              <h4 className="text-xs text-gray-500 uppercase tracking-wider mb-2">By Model</h4>
+              <div className="space-y-2">
+                {models.map(([model, data]) => (
+                  <div key={model} className="bg-po-bg rounded-lg p-3">
+                    <div className="flex items-center justify-between mb-1">
+                      <span className="text-xs font-mono text-white">{model}</span>
+                      <span className="text-xs text-gray-400">{data.calls} call{data.calls !== 1 ? 's' : ''}</span>
+                    </div>
+                    <div className="flex justify-between text-[10px] text-gray-500">
+                      <span>In: {formatTokens(data.input_tokens)}</span>
+                      <span>Out: {formatTokens(data.output_tokens)}</span>
+                      <span>{formatCost(data.estimated_cost_usd)}</span>
+                    </div>
+                  </div>
+                ))}
+              </div>
+            </div>
+          )}
+
+          {usage.calls === 0 && (
+            <div className="text-center text-gray-500 text-sm py-4">
+              No usage data recorded for this thread.
+            </div>
+          )}
+        </div>
+      </div>
+    </div>
+  )
+}

data/frontend/src/hooks/useWebSocket.ts

@@ -36,6 +36,7 @@ export function useWebSocket() {
     clearPendingResponse,
     setLLMConfig,
     updateCurrentLLM,
+    setUsageData,
   } = useStore()
 
   const connect = useCallback(() => {
@@ -213,6 +214,25 @@ export function useWebSocket() {
           break
         }
 
+        case 'session_usage': {
+          setUsageData(message.payload as Record<string, unknown>)
+          break
+        }
+
+        case 'thread_export': {
+          const { content, format, session_id } = message.payload as { content: string; format: string; session_id: string }
+          const mimeType = format === 'json' ? 'application/json' : 'text/markdown'
+          const ext = format === 'json' ? 'json' : 'md'
+          const blob = new Blob([content], { type: mimeType })
+          const url = URL.createObjectURL(blob)
+          const a = document.createElement('a')
+          a.href = url
+          a.download = `${session_id}.${ext}`
+          a.click()
+          URL.revokeObjectURL(url)
+          break
+        }
+
         case 'error': {
           const { message: errorMsg } = message.payload as { message: string }
           console.error('Server error:', errorMsg)
@@ -242,6 +262,7 @@ export function useWebSocket() {
       removeNotification,
       setLLMConfig,
       updateCurrentLLM,
+      setUsageData,
     ]
   )
 
@@ -352,6 +373,36 @@ export function useWebSocket() {
     )
   }, [])
 
+  // Request usage data for a session
+  const requestUsage = useCallback((sessionId: string, includeTree?: boolean) => {
+    if (!ws.current || ws.current.readyState !== WebSocket.OPEN) {
+      console.error('WebSocket not connected')
+      return
+    }
+
+    ws.current.send(
+      JSON.stringify({
+        type: 'get_session_usage',
+        payload: { session_id: sessionId, include_tree: includeTree || false },
+      })
+    )
+  }, [])
+
+  // Export a thread as markdown or JSON
+  const exportThread = useCallback((sessionId: string, format?: string) => {
+    if (!ws.current || ws.current.readyState !== WebSocket.OPEN) {
+      console.error('WebSocket not connected')
+      return
+    }
+
+    ws.current.send(
+      JSON.stringify({
+        type: 'export_thread',
+        payload: { session_id: sessionId, format: format || 'markdown' },
+      })
+    )
+  }, [])
+
   // Update a PO's prompt (markdown body)
   const updatePrompt = useCallback((target: string, prompt: string) => {
     if (!ws.current || ws.current.readyState !== WebSocket.OPEN) {
@@ -375,5 +426,7 @@ export function useWebSocket() {
     switchLLM,
     createThread,
     updatePrompt,
+    requestUsage,
+    exportThread,
   }
 }

data/frontend/src/store/index.ts

@@ -58,6 +58,11 @@ interface Store {
   llmConfig: LLMConfig | null
   setLLMConfig: (config: LLMConfig) => void
   updateCurrentLLM: (provider: string, model: string) => void
+
+  // Usage data (for modal display)
+  usageData: Record<string, unknown> | null
+  setUsageData: (data: Record<string, unknown>) => void
+  clearUsageData: () => void
 }
 
 export const useStore = create<Store>((set) => ({
@@ -230,6 +235,11 @@ export const useStore = create<Store>((set) => ({
         ? { ...s.llmConfig, current_provider: provider, current_model: model }
         : null,
     })),
+
+  // Usage data
+  usageData: null,
+  setUsageData: (data) => set({ usageData: data }),
+  clearUsageData: () => set({ usageData: null }),
 }))
 
 // Selectors - use useShallow to prevent infinite re-renders with derived arrays

data/frontend/src/types/index.ts

@@ -67,7 +67,8 @@ export interface PromptObject {
 export interface BusMessage {
   from: string
   to: string
-  content: string
+  content: string | Record<string, unknown>
+  summary?: string
   timestamp: string
 }
 
@@ -120,6 +121,8 @@ export type WSMessageType =
   | 'thread_tree'
   | 'llm_config'
   | 'llm_switched'
+  | 'session_usage'
+  | 'thread_export'
   | 'error'
   | 'pong'
 

data/lib/prompt_objects/cli.rb

@@ -365,6 +365,7 @@ module PromptObjects
             developer  - Code review, debugging, testing specialists
             writer     - Editor, researcher for content creation
             empty      - Bootstrap assistant only
+            arc-agi-1  - ARC-AGI-1 challenge solving with grid primitives
         HELP
       end
     end

data/lib/prompt_objects/connectors/mcp.rb

@@ -127,6 +127,7 @@ module PromptObjects
           {
             from: entry[:from],
             to: entry[:to],
+            summary: entry[:summary],
             message: entry[:message],
             timestamp: entry[:timestamp]&.iso8601
           }

data/lib/prompt_objects/environment.rb

@@ -86,7 +86,7 @@ module PromptObjects
       end
 
       @registry = Registry.new
-      @bus = MessageBus.new
+      @bus = MessageBus.new(session_store: @session_store)
       @human_queue = HumanQueue.new
 
       register_primitives
@@ -267,6 +267,29 @@ module PromptObjects
       @registry.register(Primitives::ListFiles.new)
       @registry.register(Primitives::WriteFile.new)
       @registry.register(Primitives::HttpGet.new)
+
+      # Load custom primitives from environment's primitives directory
+      load_custom_primitives
+    end
+
+    # Load custom primitives from the environment's primitives/ directory.
+    # Follows the same pattern as Universal::CreatePrimitive for class naming
+    # and loading. Warns on errors rather than crashing so a broken primitive
+    # file doesn't prevent the environment from starting (a PO can fix it).
+    def load_custom_primitives
+      return unless @primitives_dir && Dir.exist?(@primitives_dir)
+
+      Dir.glob(File.join(@primitives_dir, "*.rb")).sort.each do |path|
+        begin
+          filename = File.basename(path, ".rb")
+          class_name = filename.split("_").map(&:capitalize).join
+          load(path)
+          klass = PromptObjects::Primitives.const_get(class_name)
+          @registry.register(klass.new)
+        rescue SyntaxError, StandardError => e
+          warn "Warning: Failed to load custom primitive #{path}: #{e.message}"
+        end
+      end
     end
 
     # Register universal capabilities (available to all prompt objects).

data/lib/prompt_objects/llm/anthropic_adapter.rb

@@ -130,7 +130,21 @@ module PromptObjects
           end
         end
 
-        Response.new(content: content, tool_calls: tool_calls, raw: raw)
+        Response.new(content: content, tool_calls: tool_calls, raw: raw, usage: extract_usage(raw))
+      end
+
+      def extract_usage(raw)
+        return nil unless raw.respond_to?(:usage) && raw.usage
+
+        usage = raw.usage
+        {
+          input_tokens: usage.respond_to?(:input_tokens) ? usage.input_tokens : 0,
+          output_tokens: usage.respond_to?(:output_tokens) ? usage.output_tokens : 0,
+          cache_creation_tokens: usage.respond_to?(:cache_creation_input_tokens) ? (usage.cache_creation_input_tokens || 0) : 0,
+          cache_read_tokens: usage.respond_to?(:cache_read_input_tokens) ? (usage.cache_read_input_tokens || 0) : 0,
+          model: @model,
+          provider: "anthropic"
+        }
       end
     end
   end

data/lib/prompt_objects/llm/factory.rb

@@ -1,9 +1,12 @@
 # frozen_string_literal: true
 
+require "net/http"
+require "json"
+
 module PromptObjects
   module LLM
     # Factory for creating LLM adapters based on provider name.
-    # Provides a unified interface for switching between OpenAI, Anthropic, and Gemini.
+    # Provides a unified interface for switching between providers.
     class Factory
       PROVIDERS = {
         "openai" => {
@@ -23,6 +26,34 @@ module PromptObjects
           env_key: "GEMINI_API_KEY",
           default_model: "gemini-3-flash-preview",
           models: %w[gemini-3-flash-preview gemini-2.5-pro gemini-2.5-flash]
+        },
+        "ollama" => {
+          adapter: "OpenAIAdapter",
+          env_key: nil,
+          api_key_default: "ollama",
+          default_model: "llama3.2",
+          models: [],  # Dynamic — populated from Ollama API
+          base_url: "http://localhost:11434/v1",
+          local: true
+        },
+        "openrouter" => {
+          adapter: "OpenAIAdapter",
+          env_key: "OPENROUTER_API_KEY",
+          default_model: "meta-llama/llama-3.3-70b-instruct",
+          models: %w[
+            meta-llama/llama-3.3-70b-instruct
+            meta-llama/llama-4-scout
+            meta-llama/llama-4-maverick
+            mistralai/mistral-large-2411
+            google/gemma-3-27b-it
+            deepseek/deepseek-r1
+            qwen/qwen-2.5-72b-instruct
+          ],
+          base_url: "https://openrouter.ai/api/v1",
+          extra_headers: {
+            "HTTP-Referer" => "https://github.com/prompt-objects",
+            "X-Title" => "PromptObjects"
+          }
         }
       }.freeze
 
@@ -30,7 +61,7 @@ module PromptObjects
 
       class << self
         # Create an adapter for the given provider.
-        # @param provider [String] Provider name (openai, anthropic, gemini)
+        # @param provider [String] Provider name
         # @param model [String, nil] Optional model override
         # @param api_key [String, nil] Optional API key override
         # @return [OpenAIAdapter, AnthropicAdapter, GeminiAdapter]
@@ -40,8 +71,20 @@ module PromptObjects
 
           raise Error, "Unknown LLM provider: #{provider_name}" unless config
 
+          # Resolve API key: explicit > env var > default
+          resolved_key = api_key ||
+            (config[:env_key] && ENV[config[:env_key]]) ||
+            config[:api_key_default]
+
           adapter_class = LLM.const_get(config[:adapter])
-          adapter_class.new(api_key: api_key, model: model)
+
+          adapter_args = { api_key: resolved_key, model: model || config[:default_model] }
+          adapter_args[:base_url] = config[:base_url] if config[:base_url]
+          adapter_args[:extra_headers] = config[:extra_headers] if config[:extra_headers]
+          # Pass provider name for usage tracking (OpenAI adapter handles multiple providers)
+          adapter_args[:provider_name] = provider_name if config[:adapter] == "OpenAIAdapter"
+
+          adapter_class.new(**adapter_args)
         end
 
         # List available providers.
@@ -57,11 +100,17 @@ module PromptObjects
           PROVIDERS[provider.to_s.downcase]
         end
 
-        # Check which providers have API keys configured.
+        # Check which providers are available (have API keys or are local).
         # @return [Hash<String, Boolean>]
         def available_providers
           PROVIDERS.transform_values do |config|
-            ENV.key?(config[:env_key])
+            if config[:local]
+              check_local_provider(config[:base_url])
+            elsif config[:env_key]
+              ENV.key?(config[:env_key])
+            else
+              true
+            end
           end
         end
 
@@ -73,10 +122,48 @@ module PromptObjects
         end
 
         # Get available models for a provider.
+        # For Ollama, dynamically discovers installed models.
         # @param provider [String] Provider name
         # @return [Array<String>]
         def models_for(provider)
-          PROVIDERS.dig(provider.to_s.downcase, :models) || []
+          config = PROVIDERS[provider.to_s.downcase]
+          return [] unless config
+
+          # Dynamic model discovery for Ollama
+          if config[:local] && provider.to_s.downcase == "ollama"
+            models = discover_ollama_models(config[:base_url])
+            return models unless models.empty?
+          end
+
+          config[:models] || []
+        end
+
+        # Discover installed Ollama models.
+        # @param base_url [String] Ollama API base URL (with /v1 suffix)
+        # @return [Array<String>] Model names
+        def discover_ollama_models(base_url = "http://localhost:11434/v1")
+          # Ollama's model list endpoint is at /api/tags (not under /v1)
+          tags_url = base_url.sub(%r{/v1\z}, "") + "/api/tags"
+          uri = URI(tags_url)
+          response = Net::HTTP.get_response(uri)
+          return [] unless response.is_a?(Net::HTTPSuccess)
+
+          data = JSON.parse(response.body)
+          (data["models"] || []).map { |m| m["name"] }
+        rescue StandardError
+          []
+        end
+
+        private
+
+        def check_local_provider(base_url)
+          return false unless base_url
+          tags_url = base_url.sub(%r{/v1\z}, "") + "/api/tags"
+          uri = URI(tags_url)
+          response = Net::HTTP.get_response(uri)
+          response.is_a?(Net::HTTPSuccess)
+        rescue StandardError
+          false
         end
       end
     end

data/lib/prompt_objects/llm/gemini_adapter.rb

@@ -192,7 +192,19 @@ module PromptObjects
           end
         end
 
-        Response.new(content: text_content, tool_calls: tool_calls, raw: raw)
+        Response.new(content: text_content, tool_calls: tool_calls, raw: raw, usage: extract_usage(raw))
+      end
+
+      def extract_usage(raw)
+        meta = raw["usageMetadata"]
+        return nil unless meta
+
+        {
+          input_tokens: meta["promptTokenCount"] || 0,
+          output_tokens: meta["candidatesTokenCount"] || 0,
+          model: @model,
+          provider: "gemini"
+        }
       end
 
       def parse_function_call(fc)

data/lib/prompt_objects/llm/openai_adapter.rb

@@ -6,12 +6,17 @@ module PromptObjects
     class OpenAIAdapter
       DEFAULT_MODEL = "gpt-5.2"
 
-      def initialize(api_key: nil, model: nil)
+      def initialize(api_key: nil, model: nil, base_url: nil, extra_headers: nil, provider_name: nil)
         @api_key = api_key || ENV.fetch("OPENAI_API_KEY") do
           raise Error, "OPENAI_API_KEY environment variable not set"
         end
         @model = model || DEFAULT_MODEL
-        @client = OpenAI::Client.new(access_token: @api_key)
+        @provider_name = provider_name || "openai"
+
+        client_opts = { access_token: @api_key }
+        client_opts[:uri_base] = base_url if base_url
+        client_opts[:extra_headers] = extra_headers if extra_headers
+        @client = OpenAI::Client.new(**client_opts)
       end
 
       # Make a chat completion request.
@@ -80,12 +85,24 @@ module PromptObjects
         choice = raw.dig("choices", 0)
         message = choice&.dig("message")
 
-        return Response.new(content: "", raw: raw) unless message
+        return Response.new(content: "", raw: raw, usage: extract_usage(raw)) unless message
 
         content = message["content"] || ""
         tool_calls = parse_tool_calls(message["tool_calls"])
 
-        Response.new(content: content, tool_calls: tool_calls, raw: raw)
+        Response.new(content: content, tool_calls: tool_calls, raw: raw, usage: extract_usage(raw))
+      end
+
+      def extract_usage(raw)
+        usage = raw["usage"]
+        return nil unless usage
+
+        {
+          input_tokens: usage["prompt_tokens"] || 0,
+          output_tokens: usage["completion_tokens"] || 0,
+          model: @model,
+          provider: @provider_name
+        }
       end
 
       def parse_tool_calls(raw_tool_calls)

data/lib/prompt_objects/llm/pricing.rb

@@ -0,0 +1,49 @@
+# frozen_string_literal: true
+
+module PromptObjects
+  module LLM
+    # Static pricing table for cost estimation.
+    # Prices are per 1 million tokens in USD.
+    # Updated periodically — not guaranteed to be exact.
+    class Pricing
+      RATES = {
+        # OpenAI
+        "gpt-5.2" => { input: 2.00, output: 8.00 },
+        "gpt-4.1" => { input: 2.00, output: 8.00 },
+        "gpt-4.1-mini" => { input: 0.40, output: 1.60 },
+        "gpt-4.5-preview" => { input: 75.00, output: 150.00 },
+        "o3-mini" => { input: 1.10, output: 4.40 },
+        "o1" => { input: 15.00, output: 60.00 },
+        # Anthropic
+        "claude-opus-4" => { input: 15.00, output: 75.00 },
+        "claude-sonnet-4-5" => { input: 3.00, output: 15.00 },
+        "claude-haiku-4-5" => { input: 1.00, output: 5.00 },
+        # Gemini
+        "gemini-3-flash-preview" => { input: 0.15, output: 0.60 },
+        "gemini-2.5-pro" => { input: 1.25, output: 10.00 },
+        "gemini-2.5-flash" => { input: 0.15, output: 0.60 },
+      }.freeze
+
+      # Calculate cost in USD for a given usage.
+      # @param model [String] Model name
+      # @param input_tokens [Integer] Number of input tokens
+      # @param output_tokens [Integer] Number of output tokens
+      # @return [Float] Estimated cost in USD
+      def self.calculate(model:, input_tokens:, output_tokens:)
+        rates = RATES[model]
+        return 0.0 unless rates
+
+        input_cost = (input_tokens / 1_000_000.0) * rates[:input]
+        output_cost = (output_tokens / 1_000_000.0) * rates[:output]
+        input_cost + output_cost
+      end
+
+      # Check if we have pricing data for a model.
+      # @param model [String] Model name
+      # @return [Boolean]
+      def self.known_model?(model)
+        RATES.key?(model)
+      end
+    end
+  end
+end

data/lib/prompt_objects/llm/response.rb

@@ -5,12 +5,13 @@ module PromptObjects
     # Normalized response from an LLM API call.
     # Wraps provider-specific responses into a common interface.
     class Response
-      attr_reader :content, :tool_calls, :raw
+      attr_reader :content, :tool_calls, :raw, :usage
 
-      def initialize(content:, tool_calls: [], raw: nil)
+      def initialize(content:, tool_calls: [], raw: nil, usage: nil)
         @content = content
         @tool_calls = tool_calls
         @raw = raw
+        @usage = usage  # { input_tokens:, output_tokens:, model:, provider: }
       end
 
       # Check if the response includes tool calls.