langgraph_rb 0.1.7 → 0.1.8

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: bd46b52a6c57bec611953702facad328eda63e0c5f66f85c403230d05548709b
-  data.tar.gz: 19e32e26b6c38044536b8498c7900bcb19386adf1853881cc3a9c3ca3861dae4
+  metadata.gz: 6882db2f57746e6a18576eefd6bd26749009361880d1cd858ee91d3d06385abe
+  data.tar.gz: fa195eb1ed6763a3e0b53803792e92e7dd1dd327c9dd9372d7acf7ab3ea49d8f
 SHA512:
-  metadata.gz: ed37faa9f9cc70f30a63ac31f96daafd2fa8f6362f78607ac3532ee396fdd04037265a428fc2e5492b4971100be836845e29228e59b5876abc8b50239c9b83a4
-  data.tar.gz: 33a4b49fa73f482c4a66299b0a58964be9a81f505e44d35c36b033334b73a24341fc3e78349ff0652f26ca0ae6884b5623fa07d8263570367a790b1324e278ec
+  metadata.gz: aa652301646c12a2d2ade30faf5d5f463a89190813b9dbccb8c1b8df675bc6e0e8911c3358166224617239f763578b95fe78f27850e11690fc3e7726b85edc4c
+  data.tar.gz: 1a7fa46cf43d02b0c356c58f5e5aaed84023c5c2cece84eaf49ff084627ac046f1dd170f4e9cf2477ed1981d1ca8b7321ad416c9e4610c854793bdcdbf6b990d

data/examples/chat_openai_tools_example.rb

@@ -38,7 +38,7 @@ end
 def run_chat_openai_tools
   tools = [MovieInfoTool.new(api_key: ENV['TMDB_API_KEY'] || 'demo')]
 
-  chat = LangGraphRB::ChatOpenAI.new(model: ENV.fetch('OPENAI_MODEL', 'gpt-4o-min3i'), temperature: 0)
+  chat = LangGraphRB::ChatOpenAI.new(model: ENV.fetch('OPENAI_MODEL', 'gpt-4o-mini'), temperature: 0)
   chat = chat.bind_tools(tools)
 
   observers = [LangGraphRB::Observers::LangfuseObserver.new(name: 'chat-openai-tools-example')]
@@ -50,11 +50,7 @@ def run_chat_openai_tools
       { messages: existing + [user_msg] }
     end
 
-    # Optional: callback to observe each assistant message as it's produced
-    add_message_callback = ->(message) { puts "New message: #{message}" }
-    sys_prompt = "You are a movie assistant. Use tools when helpful."
-
-    llm_node :chat, llm_client: chat, system_prompt: sys_prompt, add_message_callback: add_message_callback
+    llm_node :chat, llm_client: chat, system_prompt: "You are a movie assistant. Use tools when helpful."
 
     tool_node :tool, tools: tools
 

data/langgraph_rb.gemspec

@@ -33,7 +33,6 @@ Gem::Specification.new do |spec|
 
   # Runtime dependencies
   spec.add_dependency "json", "~> 2.0"
-  spec.add_dependency "openai", "~> 0.24.0"
 
   # Development dependencies
   spec.add_development_dependency "bundler", "~> 2.0"

data/lib/langgraph_rb/chat_openai.rb

@@ -1,12 +1,20 @@
-require 'openai'
+begin
+  require 'openai'
+rescue LoadError
+  raise "LangGraphRB::ChatOpenAI requires gem 'openai' (~> 0.24). Add it to your Gemfile."
+end
 require_relative 'llm_base'
 
 module LangGraphRB
   # ChatOpenAI wrapper compatible with LLMBase, supporting tool binding
   class ChatOpenAI < LLMBase
-    def initialize(model:, temperature: 0.0, api_key: ENV['OPENAI_API_KEY'])
+    def initialize(model:, temperature: 0.0, api_key: ENV['OPENAI_API_KEY'], client: nil)
       super(model: model, temperature: temperature)
-      @client = OpenAI::Client.new(api_key: api_key)
+      @client = client || OpenAI::Client.new(api_key: api_key)
+
+      unless @client.respond_to?(:chat) && @client.chat.respond_to?(:completions)
+        raise "LangGraphRB::ChatOpenAI expects 'openai' gem ~> 0.24 (client.chat.completions.create)"
+      end
     end
 
     # Returns a new instance with tools bound (non-destructive)

data/lib/langgraph_rb/chat_ruby_openai.rb

@@ -0,0 +1,171 @@
+begin
+  require 'openai'
+rescue LoadError
+  raise "LangGraphRB::ChatRubyOpenAI requires gem 'ruby-openai' (~> 8.1). Add it to your Gemfile."
+end
+
+require_relative 'llm_base'
+
+module LangGraphRB
+  class ChatRubyOpenAI < LLMBase
+    def initialize(model:, temperature: 0.0, api_key: ENV['OPENAI_API_KEY'], client: nil)
+      super(model: model, temperature: temperature)
+      @client = client || OpenAI::Client.new(access_token: api_key)
+    end
+
+    def bind_tools(tools)
+      dup_instance = self.class.new(model: @model, temperature: @temperature)
+      dup_instance.instance_variable_set(:@client, @client)
+      dup_instance.instance_variable_set(:@bound_tools, Array(tools))
+      dup_instance
+    end
+
+    def call(messages, tools: nil)
+      raise ArgumentError, 'messages must be an Array' unless messages.is_a?(Array)
+
+      tool_definitions = (tools || @bound_tools)
+      tool_schemas = Array(tool_definitions).flat_map do |tool|
+        if tool.respond_to?(:to_openai_tool_schema)
+          Array(tool.to_openai_tool_schema)
+        else
+          [tool]
+        end
+      end
+
+      request_payload = {
+        model: @model,
+        temperature: @temperature,
+        messages: normalize_messages(messages)
+      }
+
+      if tool_schemas && !tool_schemas.empty?
+        request_payload[:tools] = tool_schemas
+        request_payload[:tool_choice] = 'auto'
+      end
+
+      notify_llm_request({
+        name: 'OpenAI::ChatCompletion',
+        model: @model,
+        model_parameters: { temperature: @temperature },
+        input: request_payload[:messages]
+      })
+
+      # ruby-openai 8.1.x: client.chat(parameters: {...}) returns a Hash
+      response = @client.chat(parameters: request_payload)
+
+      message = extract_message_from_response(response)
+      tool_calls = message[:tool_calls]
+      text_content = message[:content]
+
+      usage = extract_usage_from_response(response)
+      notify_llm_response({
+        output: tool_calls ? { tool_calls: tool_calls } : text_content,
+        prompt_tokens: usage[:prompt_tokens],
+        completion_tokens: usage[:completion_tokens],
+        total_tokens: usage[:total_tokens]
+      })
+
+      if tool_calls && !tool_calls.empty?
+        normalized_calls = tool_calls.map do |tc|
+          {
+            id: tc[:id],
+            name: tc[:function][:name],
+            arguments: parse_tool_arguments(tc[:function][:arguments])
+          }
+        end
+        { tool_calls: normalized_calls }
+      else
+        text_content
+      end
+    rescue => e
+      notify_llm_error({ error: e.message })
+      raise e
+    end
+
+    private
+
+    def normalize_messages(messages)
+      messages.map do |m|
+        role = (m[:role] || m['role'])
+        content = m[:content] || m['content']
+
+        normalized = { role: role }
+
+        if content.is_a?(Array)
+          normalized[:content] = content
+        elsif content.nil?
+          normalized[:content] = nil
+        else
+          normalized[:content] = content.to_s
+        end
+
+        tool_calls = m[:tool_calls] || m['tool_calls']
+        if tool_calls && role.to_s == 'assistant'
+          normalized[:tool_calls] = Array(tool_calls).map do |tc|
+            if tc[:function] || tc['function']
+              fn = tc[:function] || tc['function']
+              raw_args = fn[:arguments] || fn['arguments']
+              args_str = raw_args.is_a?(String) ? raw_args : JSON.dump(raw_args || {})
+              {
+                id: (tc[:id] || tc['id']),
+                type: 'function',
+                function: {
+                  name: (fn[:name] || fn['name']).to_s,
+                  arguments: args_str
+                }
+              }
+            else
+              raw_args = tc[:arguments] || tc['arguments']
+              args_str = raw_args.is_a?(String) ? raw_args : JSON.dump(raw_args || {})
+              {
+                id: (tc[:id] || tc['id']),
+                type: 'function',
+                function: {
+                  name: (tc[:name] || tc['name']).to_s,
+                  arguments: args_str
+                }
+              }
+            end
+          end
+        end
+
+        if role.to_s == 'tool'
+          tool_call_id = m[:tool_call_id] || m['tool_call_id']
+          name = m[:name] || m['name']
+          normalized[:tool_call_id] = tool_call_id if tool_call_id
+          normalized[:name] = name if name
+        end
+
+        normalized
+      end
+    end
+
+    def parse_tool_arguments(raw)
+      return {} if raw.nil?
+      case raw
+      when String
+        JSON.parse(raw) rescue {}
+      when Hash
+        raw
+      else
+        {}
+      end
+    end
+
+    def extract_message_from_response(response)
+      (response['choices'] || []).dig(0, 'message') || {}
+    end
+
+    def extract_usage_from_response(response)
+      usage = response['usage']
+      return { prompt_tokens: nil, completion_tokens: nil, total_tokens: nil } unless usage
+      {
+        prompt_tokens: usage['prompt_tokens'],
+        completion_tokens: usage['completion_tokens'],
+        total_tokens: usage['total_tokens']
+      }
+    end
+  end
+end
+
+

data/lib/langgraph_rb/graph.rb

@@ -35,11 +35,11 @@ module LangGraphRB
       end
     end
 
-    def llm_node(name, llm_client:, system_prompt: nil, add_message_callback: nil, &block)
+    def llm_node(name, llm_client:, system_prompt: nil, &block)
       name = name.to_sym
       raise GraphError, "Node '#{name}' already exists" if @nodes.key?(name)
       
-      @nodes[name] = LLMNode.new(name, llm_client: llm_client, system_prompt: system_prompt, add_message_callback: add_message_callback, &block)
+      @nodes[name] = LLMNode.new(name, llm_client: llm_client, system_prompt: system_prompt, &block)
     end
 
     def tool_node(name, tools:, &block)

data/lib/langgraph_rb/node.rb

@@ -35,12 +35,11 @@ module LangGraphRB
 
   # Specialized node for LLM calls
   class LLMNode < Node
-    attr_reader :llm_client, :system_prompt, :add_message_callback
+    attr_reader :llm_client, :system_prompt
 
-    def initialize(name, llm_client:, system_prompt: nil, add_message_callback: nil, &block)
+    def initialize(name, llm_client:, system_prompt: nil, &block)
       @llm_client = llm_client
       @system_prompt = system_prompt
-      @add_message_callback = add_message_callback
 
       # Use default LLM behavior if no custom block provided
       super(name, &(block || method(:default_llm_call)))
@@ -50,8 +49,7 @@ module LangGraphRB
       # Auto-inject LLM config into the context for both default and custom blocks
       merged_context = (context || {}).merge(
         llm_client: @llm_client,
-        system_prompt: @system_prompt,
-        add_message_callback: @add_message_callback
+        system_prompt: @system_prompt
       )
 
       begin
@@ -89,14 +87,12 @@ module LangGraphRB
           content: nil,
           tool_calls: response[:tool_calls]
         }
-        @add_message_callback&.call(assistant_msg)
         {
           messages: (state[:messages] || []) + [assistant_msg],
           tool_call: response[:tool_calls].first
         }
       else
         assistant_msg = { role: 'assistant', content: response.to_s }
-        @add_message_callback&.call(assistant_msg)
         {
           messages: (state[:messages] || []) + [assistant_msg],
           last_response: response.to_s

data/lib/langgraph_rb/version.rb

@@ -1,3 +1,3 @@
 module LangGraphRB
-  VERSION = "0.1.7"
+  VERSION = "0.1.8"
 end 

data/lib/langgraph_rb.rb

@@ -11,7 +11,6 @@ require_relative 'langgraph_rb/observers/logger'
 require_relative 'langgraph_rb/observers/structured'
 require_relative 'langgraph_rb/observers/langfuse'
 require_relative 'langgraph_rb/llm_base'
-require_relative 'langgraph_rb/chat_openai'
 require_relative 'langgraph_rb/tool_definition'
 
 module LangGraphRB

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: langgraph_rb
 version: !ruby/object:Gem::Version
-  version: 0.1.7
+  version: 0.1.8
 platform: ruby
 authors:
 - Julian Toro
@@ -24,20 +24,6 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '2.0'
-- !ruby/object:Gem::Dependency
-  name: openai
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: 0.24.0
-  type: :runtime
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: 0.24.0
 - !ruby/object:Gem::Dependency
   name: bundler
   requirement: !ruby/object:Gem::Requirement
@@ -136,6 +122,7 @@ files:
 - langgraph_rb.gemspec
 - lib/langgraph_rb.rb
 - lib/langgraph_rb/chat_openai.rb
+- lib/langgraph_rb/chat_ruby_openai.rb
 - lib/langgraph_rb/command.rb
 - lib/langgraph_rb/edge.rb
 - lib/langgraph_rb/graph.rb