langgraph-platform 0.1.0

data/lib/langgraph_platform/errors.rb

@@ -0,0 +1,49 @@
+module LanggraphPlatform
+  module Errors
+    class APIError < StandardError
+      attr_reader :message, :status_code
+
+      def initialize(message, status_code = nil)
+        @message = message
+        @status_code = status_code
+        super(message)
+      end
+    end
+
+    class BadRequestError < APIError
+      def initialize(message)
+        super(message, 400)
+      end
+    end
+
+    class UnauthorizedError < APIError
+      def initialize(message)
+        super(message, 401)
+      end
+    end
+
+    class NotFoundError < APIError
+      def initialize(message)
+        super(message, 404)
+      end
+    end
+
+    class ConflictError < APIError
+      def initialize(message)
+        super(message, 409)
+      end
+    end
+
+    class ValidationError < APIError
+      def initialize(message)
+        super(message, 422)
+      end
+    end
+
+    class ServerError < APIError
+      def initialize(message)
+        super(message, 500)
+      end
+    end
+  end
+end

data/lib/langgraph_platform/models/assistant.rb

@@ -0,0 +1,48 @@
+module LanggraphPlatform
+  module Models
+    class Assistant
+      attr_reader :assistant_id, :graph_id, :config, :created_at, :updated_at,
+                  :metadata, :version, :name, :description
+
+      def initialize(attributes)
+        @assistant_id = attributes['assistant_id']
+        @graph_id = attributes['graph_id']
+        @config = attributes['config']
+        @created_at = parse_time(attributes['created_at'])
+        @updated_at = parse_time(attributes['updated_at'])
+        @metadata = attributes['metadata'] || {}
+        @version = attributes['version']
+        @name = attributes['name']
+        @description = attributes['description']
+      end
+
+      def to_h
+        {
+          assistant_id: @assistant_id,
+          graph_id: @graph_id,
+          config: @config,
+          created_at: @created_at,
+          updated_at: @updated_at,
+          metadata: @metadata,
+          version: @version,
+          name: @name,
+          description: @description
+        }
+      end
+
+      def to_json(*args)
+        to_h.to_json(*args)
+      end
+
+      private
+
+      def parse_time(time_string)
+        return nil if time_string.nil?
+
+        Time.parse(time_string)
+      rescue ArgumentError
+        nil
+      end
+    end
+  end
+end

data/lib/langgraph_platform/models/checkpoint.rb

@@ -0,0 +1,42 @@
+module LanggraphPlatform
+  module Models
+    class Checkpoint
+      attr_reader :checkpoint_id, :thread_id, :checkpoint_ns, :checkpoint_map,
+                  :parent_checkpoint_id, :created_at
+
+      def initialize(attributes)
+        @checkpoint_id = attributes['checkpoint_id']
+        @thread_id = attributes['thread_id']
+        @checkpoint_ns = attributes['checkpoint_ns']
+        @checkpoint_map = attributes['checkpoint_map']
+        @parent_checkpoint_id = attributes['parent_checkpoint_id']
+        @created_at = parse_time(attributes['created_at'])
+      end
+
+      def to_h
+        {
+          checkpoint_id: @checkpoint_id,
+          thread_id: @thread_id,
+          checkpoint_ns: @checkpoint_ns,
+          checkpoint_map: @checkpoint_map,
+          parent_checkpoint_id: @parent_checkpoint_id,
+          created_at: @created_at
+        }
+      end
+
+      def to_json(*args)
+        to_h.to_json(*args)
+      end
+
+      private
+
+      def parse_time(time_string)
+        return nil if time_string.nil?
+
+        Time.parse(time_string)
+      rescue ArgumentError
+        nil
+      end
+    end
+  end
+end

data/lib/langgraph_platform/models/cron.rb

@@ -0,0 +1,56 @@
+module LanggraphPlatform
+  module Models
+    class Cron
+      attr_reader :cron_id, :assistant_id, :thread_id, :schedule, :payload,
+                  :created_at, :updated_at, :next_run_time, :enabled
+
+      def initialize(attributes)
+        @cron_id = attributes['cron_id']
+        @assistant_id = attributes['assistant_id']
+        @thread_id = attributes['thread_id']
+        @schedule = attributes['schedule']
+        @payload = attributes['payload']
+        @created_at = parse_time(attributes['created_at'])
+        @updated_at = parse_time(attributes['updated_at'])
+        @next_run_time = parse_time(attributes['next_run_time'])
+        @enabled = attributes['enabled']
+      end
+
+      def enabled?
+        @enabled == true
+      end
+
+      def disabled?
+        !enabled?
+      end
+
+      def to_h
+        {
+          cron_id: @cron_id,
+          assistant_id: @assistant_id,
+          thread_id: @thread_id,
+          schedule: @schedule,
+          payload: @payload,
+          created_at: @created_at,
+          updated_at: @updated_at,
+          next_run_time: @next_run_time,
+          enabled: @enabled
+        }
+      end
+
+      def to_json(*args)
+        to_h.to_json(*args)
+      end
+
+      private
+
+      def parse_time(time_string)
+        return nil if time_string.nil?
+
+        Time.parse(time_string)
+      rescue ArgumentError
+        nil
+      end
+    end
+  end
+end

data/lib/langgraph_platform/models/run.rb

@@ -0,0 +1,72 @@
+module LanggraphPlatform
+  module Models
+    class Run
+      attr_reader :run_id, :thread_id, :assistant_id, :created_at, :updated_at,
+                  :status, :metadata, :kwargs, :multitask_strategy
+
+      def initialize(attributes)
+        @run_id = attributes['run_id']
+        @thread_id = attributes['thread_id']
+        @assistant_id = attributes['assistant_id']
+        @created_at = parse_time(attributes['created_at'])
+        @updated_at = parse_time(attributes['updated_at'])
+        @status = attributes['status']
+        @metadata = attributes['metadata'] || {}
+        @kwargs = attributes['kwargs']
+        @multitask_strategy = attributes['multitask_strategy']
+      end
+
+      def pending?
+        @status == 'pending'
+      end
+
+      def running?
+        @status == 'running'
+      end
+
+      def success?
+        @status == 'success'
+      end
+
+      def error?
+        @status == 'error'
+      end
+
+      def timeout?
+        @status == 'timeout'
+      end
+
+      def interrupted?
+        @status == 'interrupted'
+      end
+
+      def to_h
+        {
+          run_id: @run_id,
+          thread_id: @thread_id,
+          assistant_id: @assistant_id,
+          created_at: @created_at,
+          updated_at: @updated_at,
+          status: @status,
+          metadata: @metadata,
+          kwargs: @kwargs,
+          multitask_strategy: @multitask_strategy
+        }
+      end
+
+      def to_json(*args)
+        to_h.to_json(*args)
+      end
+
+      private
+
+      def parse_time(time_string)
+        return nil if time_string.nil?
+
+        Time.parse(time_string)
+      rescue ArgumentError
+        nil
+      end
+    end
+  end
+end

data/lib/langgraph_platform/models/store_item.rb

@@ -0,0 +1,39 @@
+module LanggraphPlatform
+  module Models
+    class StoreItem
+      attr_reader :namespace, :key, :value, :created_at, :updated_at
+
+      def initialize(attributes)
+        @namespace = attributes['namespace']
+        @key = attributes['key']
+        @value = attributes['value']
+        @created_at = parse_time(attributes['created_at'])
+        @updated_at = parse_time(attributes['updated_at'])
+      end
+
+      def to_h
+        {
+          namespace: @namespace,
+          key: @key,
+          value: @value,
+          created_at: @created_at,
+          updated_at: @updated_at
+        }
+      end
+
+      def to_json(*args)
+        to_h.to_json(*args)
+      end
+
+      private
+
+      def parse_time(time_string)
+        return nil if time_string.nil?
+
+        Time.parse(time_string)
+      rescue ArgumentError
+        nil
+      end
+    end
+  end
+end

data/lib/langgraph_platform/models/thread.rb

@@ -0,0 +1,57 @@
+module LanggraphPlatform
+  module Models
+    class Thread
+      attr_reader :thread_id, :created_at, :updated_at, :metadata, :status, :values
+
+      def initialize(attributes)
+        @thread_id = attributes['thread_id']
+        @created_at = parse_time(attributes['created_at'])
+        @updated_at = parse_time(attributes['updated_at'])
+        @metadata = attributes['metadata'] || {}
+        @status = attributes['status']
+        @values = attributes['values']
+      end
+
+      def idle?
+        @status == 'idle'
+      end
+
+      def busy?
+        @status == 'busy'
+      end
+
+      def interrupted?
+        @status == 'interrupted'
+      end
+
+      def error?
+        @status == 'error'
+      end
+
+      def to_h
+        {
+          thread_id: @thread_id,
+          created_at: @created_at,
+          updated_at: @updated_at,
+          metadata: @metadata,
+          status: @status,
+          values: @values
+        }
+      end
+
+      def to_json(*args)
+        to_h.to_json(*args)
+      end
+
+      private
+
+      def parse_time(time_string)
+        return nil if time_string.nil?
+
+        Time.parse(time_string)
+      rescue ArgumentError
+        nil
+      end
+    end
+  end
+end

data/lib/langgraph_platform/models/thread_state.rb

@@ -0,0 +1,41 @@
+module LanggraphPlatform
+  module Models
+    class ThreadState
+      attr_reader :values, :next, :checkpoint, :metadata, :created_at, :parent_checkpoint
+
+      def initialize(attributes)
+        @values = attributes['values']
+        @next = attributes['next']
+        @checkpoint = attributes['checkpoint']
+        @metadata = attributes['metadata'] || {}
+        @created_at = parse_time(attributes['created_at'])
+        @parent_checkpoint = attributes['parent_checkpoint']
+      end
+
+      def to_h
+        {
+          values: @values,
+          next: @next,
+          checkpoint: @checkpoint,
+          metadata: @metadata,
+          created_at: @created_at,
+          parent_checkpoint: @parent_checkpoint
+        }
+      end
+
+      def to_json(*args)
+        to_h.to_json(*args)
+      end
+
+      private
+
+      def parse_time(time_string)
+        return nil if time_string.nil?
+
+        Time.parse(time_string)
+      rescue ArgumentError
+        nil
+      end
+    end
+  end
+end

data/lib/langgraph_platform/resources/assistants.rb

@@ -0,0 +1,65 @@
+module LanggraphPlatform
+  module Resources
+    class Assistants < BaseResource
+      def create(**params)
+        params[:config] ||= {}
+        params[:metadata] ||= {}
+        body = compact_params(params)
+        response = @client.post('/assistants', body)
+        Models::Assistant.new(response)
+      end
+
+      def find(assistant_id)
+        response = @client.get("/assistants/#{assistant_id}")
+        Models::Assistant.new(response)
+      end
+
+      def update(assistant_id, **params)
+        body = compact_params(params)
+        response = @client.patch("/assistants/#{assistant_id}", body)
+        Models::Assistant.new(response)
+      end
+
+      def delete(assistant_id) # rubocop:disable Naming/PredicateMethod
+        @client.delete("/assistants/#{assistant_id}")
+        true
+      end
+
+      def search(**params)
+        params[:metadata] ||= {}
+        params[:limit] ||= 10
+        params[:offset] ||= 0
+        body = compact_params(params)
+        response = @client.post('/assistants/search', body)
+        response.map { |assistant_data| Models::Assistant.new(assistant_data) }
+      end
+
+      def graph(assistant_id, **params)
+        params[:xray] ||= false
+        query_params = compact_params(params)
+        @client.get("/assistants/#{assistant_id}/graph", query_params)
+      end
+
+      def subgraphs(assistant_id, **params)
+        params[:recurse] ||= false
+        query_params = compact_params(params)
+        @client.get("/assistants/#{assistant_id}/subgraphs", query_params)
+      end
+
+      def schemas(assistant_id)
+        @client.get("/assistants/#{assistant_id}/schemas")
+      end
+
+      def versions(assistant_id)
+        response = @client.post("/assistants/#{assistant_id}/versions")
+        response.map { |assistant_data| Models::Assistant.new(assistant_data) }
+      end
+
+      def set_latest_version(assistant_id, **params)
+        body = compact_params(params)
+        response = @client.post("/assistants/#{assistant_id}/latest", body)
+        Models::Assistant.new(response)
+      end
+    end
+  end
+end

data/lib/langgraph_platform/resources/base_resource.rb

@@ -0,0 +1,27 @@
+module LanggraphPlatform
+  module Resources
+    class BaseResource
+      def initialize(client)
+        @client = client
+      end
+
+      private
+
+      attr_reader :client
+
+      def handle_response(response, model_class = nil)
+        return response unless model_class
+
+        if response.is_a?(Array)
+          response.map { |item| model_class.new(item) }
+        else
+          model_class.new(response)
+        end
+      end
+
+      def compact_params(params)
+        params.compact
+      end
+    end
+  end
+end

data/lib/langgraph_platform/resources/crons.rb

@@ -0,0 +1,54 @@
+module LanggraphPlatform
+  module Resources
+    class Crons < BaseResource
+      def create(**params)
+        params[:payload] ||= {}
+        body = compact_params(params)
+        response = @client.post('/crons', body)
+        Models::Cron.new(response)
+      end
+
+      def find(cron_id)
+        response = @client.get("/crons/#{cron_id}")
+        Models::Cron.new(response)
+      end
+
+      def update(cron_id, **params)
+        body = compact_params(params)
+        response = @client.patch("/crons/#{cron_id}", body)
+        Models::Cron.new(response)
+      end
+
+      def delete(cron_id) # rubocop:disable Naming/PredicateMethod
+        @client.delete("/crons/#{cron_id}")
+        true
+      end
+
+      def list(**params)
+        params[:limit] ||= 10
+        params[:offset] ||= 0
+        query_params = compact_params(params)
+        response = @client.get('/crons', query_params)
+        response.map { |cron_data| Models::Cron.new(cron_data) }
+      end
+
+      def search(**params)
+        params[:limit] ||= 10
+        params[:offset] ||= 0
+        body = compact_params(params)
+        response = @client.post('/crons/search', body)
+        response.map { |cron_data| Models::Cron.new(cron_data) }
+      end
+
+      def enable(cron_id) # rubocop:disable Naming/PredicateMethod
+        @client.post("/crons/#{cron_id}/enable")
+        true
+      end
+
+      def disable(cron_id) # rubocop:disable Naming/PredicateMethod
+        @client.post("/crons/#{cron_id}/disable")
+        true
+      end
+    end
+  end
+end

data/lib/langgraph_platform/resources/mcp.rb

@@ -0,0 +1,54 @@
+module LanggraphPlatform
+  module Resources
+    class Mcp < BaseResource
+      def call_tool(**params)
+        params[:arguments] ||= {}
+        body = compact_params(params)
+        @client.post('/mcp/tools/call', body)
+      end
+
+      def list_tools
+        @client.get('/mcp/tools')
+      end
+
+      def get_tool(tool_name)
+        @client.get("/mcp/tools/#{tool_name}")
+      end
+
+      def list_resources
+        @client.get('/mcp/resources')
+      end
+
+      def get_resource(**params)
+        query_params = compact_params(params)
+        @client.get('/mcp/resources/get', query_params)
+      end
+
+      def read_resource(**params)
+        query_params = compact_params(params)
+        @client.get('/mcp/resources/read', query_params)
+      end
+
+      def list_prompts
+        @client.get('/mcp/prompts')
+      end
+
+      def get_prompt(**params)
+        params[:arguments] ||= {}
+        body = compact_params(params)
+        @client.post('/mcp/prompts/get', body)
+      end
+
+      def complete_prompt(**params)
+        params[:arguments] ||= {}
+        body = compact_params(params)
+        @client.post('/mcp/prompts/complete', body)
+      end
+
+      def send_log(**params)
+        body = compact_params(params)
+        @client.post('/mcp/logging/log', body)
+      end
+    end
+  end
+end

data/lib/langgraph_platform/resources/runs.rb

@@ -0,0 +1,84 @@
+module LanggraphPlatform
+  module Resources
+    class Runs < BaseResource
+      def create(thread_id, **params)
+        body = compact_params(params)
+        response = @client.post("/threads/#{thread_id}/runs", body)
+        Models::Run.new(response)
+      end
+
+      def stream(thread_id, **params, &block)
+        params[:stream_mode] = Array(params[:stream_mode] || ['values'])
+        body = compact_params(params)
+        @client.stream("/threads/#{thread_id}/runs/stream", body, &block)
+      end
+
+      def wait(thread_id, **params)
+        body = compact_params(params)
+        @client.post("/threads/#{thread_id}/runs/wait", body)
+      end
+
+      def find(thread_id, run_id)
+        response = @client.get("/threads/#{thread_id}/runs/#{run_id}")
+        Models::Run.new(response)
+      end
+
+      def list(thread_id, **params)
+        params[:limit] ||= 10
+        params[:offset] ||= 0
+        query_params = compact_params(params)
+        response = @client.get("/threads/#{thread_id}/runs", query_params)
+        response.map { |run_data| Models::Run.new(run_data) }
+      end
+
+      def cancel(thread_id, run_id, **params)
+        params[:wait] ||= false
+        params[:action] ||= 'interrupt'
+        body = compact_params(params)
+        @client.post("/threads/#{thread_id}/runs/#{run_id}/cancel", body)
+      end
+
+      def join(thread_id, run_id, **params)
+        params[:cancel_on_disconnect] ||= false
+        query_params = compact_params(params)
+        @client.get("/threads/#{thread_id}/runs/#{run_id}/join", query_params)
+      end
+
+      def join_stream(thread_id, run_id, &block)
+        @client.stream("/threads/#{thread_id}/runs/#{run_id}/stream", &block)
+      end
+
+      def delete(thread_id, run_id) # rubocop:disable Naming/PredicateMethod
+        @client.delete("/threads/#{thread_id}/runs/#{run_id}")
+        true
+      end
+
+      # Stateless runs
+      def create_stateless(**params)
+        body = compact_params(params)
+        @client.post('/runs', body)
+      end
+
+      def stream_stateless(**params, &block)
+        params[:stream_mode] = Array(params[:stream_mode] || ['values'])
+        body = compact_params(params)
+        @client.stream('/runs/stream', body, &block)
+      end
+
+      def wait_stateless(**params)
+        body = compact_params(params)
+        @client.post('/runs/wait', body)
+      end
+
+      def create_batch(runs)
+        @client.post('/runs/batch', runs)
+      end
+
+      def cancel_multiple(**params)
+        params[:action] ||= 'interrupt'
+        body = compact_params(params)
+        @client.post('/runs/cancel', body)
+      end
+    end
+  end
+end