activeagent 1.8.0 → 1.9.0

data/lib/active_agent/providers/deepseek/chat/_types.rb

@@ -0,0 +1,54 @@
+# frozen_string_literal: true
+
+require_relative "request"
+
+module ActiveAgent
+  module Providers
+    module DeepSeek
+      module Chat
+        # ActiveModel type for casting and serializing DeepSeek chat requests.
+        #
+        # @see ActiveAgent::Providers::Ollama::Chat::RequestType
+        class RequestType < ActiveModel::Type::Value
+          # @param value [Request, Hash, nil]
+          # @return [Request, nil]
+          # @raise [ArgumentError] if value cannot be cast
+          def cast(value)
+            case value
+            when Request
+              value
+            when Hash
+              Request.new(**value.deep_symbolize_keys)
+            when nil
+              nil
+            else
+              raise ArgumentError, "Cannot cast #{value.class} to Request"
+            end
+          end
+
+          # @param value [Request, Hash, nil]
+          # @return [Hash, nil]
+          # @raise [ArgumentError] if value cannot be serialized
+          def serialize(value)
+            case value
+            when Request
+              value.serialize
+            when Hash
+              value
+            when nil
+              nil
+            else
+              raise ArgumentError, "Cannot serialize #{value.class}"
+            end
+          end
+
+          # @param value [Object]
+          # @return [Request, nil]
+          def deserialize(value)
+            cast(value)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/active_agent/providers/deepseek/chat/request.rb

@@ -0,0 +1,121 @@
+# frozen_string_literal: true
+
+require_relative "../../open_ai/chat/request"
+
+module ActiveAgent
+  module Providers
+    module DeepSeek
+      module Chat
+        # Chat completion request for DeepSeek.
+        #
+        # Extends OpenAI::Chat::Request with DeepSeek's defaults for the two
+        # things OpenAI cannot supply: the model name and the message roles.
+        #
+        # Everything else is left to DeepSeek. Its API is the authority on how
+        # it wants to be called, and a library that second-guesses that gets
+        # stale as the provider tunes itself — thinking mode, for one, is on by
+        # default and is the provider's call to make.
+        #
+        # Thinking is worth knowing about either way, because it changes what
+        # the other parameters do: DeepSeek bills the reasoning whether or not
+        # the answer needed it, and it ignores temperature, presence_penalty and
+        # frequency_penalty while thinking. A one-line JSON extraction measured
+        # 83 output tokens at DeepSeek's default against 7 with thinking
+        # disabled, so a prompt that wants those sampling parameters to bite, or
+        # wants to skip paying for reasoning it discards, can opt out itself:
+        #
+        #   prompt "…", thinking: { type: "disabled" }
+        #
+        # @see OpenAI::Chat::Request
+        # @see https://api-docs.deepseek.com/guides/thinking_mode
+        class Request < OpenAI::Chat::Request
+          # Model used when a prompt does not name one. DeepSeek has no default
+          # of its own — the API requires `model` — so this is a convenience,
+          # not an override.
+          DEFAULT_MODEL = "deepseek-flash"
+
+          # @param params [Hash] request parameters
+          # @option params [String] :model (deepseek-flash)
+          # @option params [Hash] :thinking DeepSeek's own thinking toggle,
+          #   passed through untouched; `{ type: "disabled" }` opts out
+          def initialize(**params)
+            params[:model] ||= DEFAULT_MODEL
+
+            demote_developer_roles!(params)
+
+            super
+          end
+
+          private
+
+          # Rewrites `developer` messages to `system` before the OpenAI
+          # transforms run.
+          #
+          # DeepSeek accepts system, user, assistant, tool and latest_reminder,
+          # and nothing else. It rejects the rest rather than ignoring them:
+          #
+          #   messages[0].role: unknown variant `developer`, expected one of
+          #   `system`, `user`, `assistant`, `tool`, `latest_reminder`
+          #
+          # That is a 422 on the whole request, and `developer` is the role it
+          # bites on: OpenAI treats it as the successor to `system`, so the
+          # OpenAI transforms express `instructions` as a developer message and
+          # any agent using them fails outright here.
+          #
+          # @param params [Hash] request parameters, mutated in place
+          # @return [void]
+          def demote_developer_roles!(params)
+            if params.key?(:instructions)
+              # One message per instruction to start. The request cleanup then
+              # merges consecutive same-role messages into a single message
+              # with content parts, which DeepSeek accepts — unlike `developer`,
+              # the part that actually fails.
+              params[:messages] = wrap(params.delete(:instructions)).map { |text| { role: "system", content: text } } +
+                                  wrap(params[:messages])
+            end
+
+            messages = wrap(params[:messages])
+            return if messages.empty?
+
+            params[:messages] = messages.map do |message|
+              next message unless message.is_a?(Hash)
+
+              key = role_key(message)
+              next message unless key && message[key].to_s == "developer"
+
+              # A copy: the messages are the caller's own hashes — the provider
+              # keeps the very `context` the prompt was given — so rewriting one
+              # in place would rewrite it for every other provider that prompt
+              # reaches, and for every later reuse of the same context.
+              message.dup.tap { |copy| copy[key] = "system" }
+            end
+          end
+
+          # Wraps a value that may be a single item, a list, or absent.
+          #
+          # `Array(hash)` splits a lone Hash into pairs, which is not what a
+          # single message or instruction means.
+          #
+          # @param value [Object, Array, nil]
+          # @return [Array]
+          def wrap(value)
+            return [] if value.nil?
+            return [ value ] if value.is_a?(Hash)
+
+            Array(value)
+          end
+
+          # @param message [Hash]
+          # @return [Symbol, String, nil] whichever key the message spells its
+          #   role with, since a caller may use either
+          def role_key(message)
+            return :role if message.key?(:role)
+            return "role" if message.key?("role")
+
+            nil
+          end
+        end
+      end
+    end
+  end
+end

data/lib/active_agent/providers/deepseek/options.rb

@@ -0,0 +1,53 @@
+# frozen_string_literal: true
+
+require_relative "../open_ai/options"
+
+module ActiveAgent
+  module Providers
+    module DeepSeek
+      # Configuration options for the DeepSeek provider.
+      #
+      # Extends OpenAI::Options because DeepSeek serves an OpenAI-compatible
+      # API. Only the endpoint and the credential's environment variable differ;
+      # DeepSeek has no organization or project scoping.
+      #
+      # @example Configuration in active_agent.yml
+      #   deepseek:
+      #     service: "DeepSeek"
+      #     api_key: <%= ENV["DEEPSEEK_API_KEY"] %>
+      #
+      # @example Inline
+      #   generate_with :deepseek, model: "deepseek-flash"
+      #
+      # @see OpenAI::Options
+      # @see https://api-docs.deepseek.com
+      class Options < OpenAI::Options
+        # DeepSeek's OpenAI-compatible endpoint. The Anthropic-compatible one
+        # lives at /anthropic and is served by AnthropicProvider instead.
+        DEFAULT_BASE_URL = "https://api.deepseek.com"
+
+        # @param kwargs [Hash]
+        # @option kwargs [String] :api_key
+        # @option kwargs [String] :base_url (https://api.deepseek.com)
+        def initialize(kwargs = {})
+          kwargs = kwargs.deep_symbolize_keys if kwargs.respond_to?(:deep_symbolize_keys)
+
+          super(kwargs.merge(base_url: kwargs[:base_url].presence || DEFAULT_BASE_URL))
+        end
+
+        private
+
+        def resolve_api_key(kwargs)
+          kwargs[:api_key] ||
+            kwargs[:access_token] ||
+            ENV["DEEPSEEK_API_KEY"] ||
+            ENV["DEEPSEEK_ACCESS_TOKEN"]
+        end
+
+        # DeepSeek is not an OpenAI organization; scoping one would be a lie.
+        def resolve_organization_id(_kwargs) = nil
+        def resolve_project_id(_kwargs)      = nil
+      end
+    end
+  end
+end

data/lib/active_agent/providers/deepseek_provider.rb

@@ -0,0 +1,46 @@
+require_relative "_base_provider"
+
+require_gem!(:openai, __FILE__)
+
+require_relative "open_ai_provider"
+require_relative "deepseek/_types"
+
+module ActiveAgent
+  module Providers
+    # Provides access to DeepSeek's OpenAI-compatible API.
+    #
+    # Extends OpenAI's Chat provider, which DeepSeek follows for request shape,
+    # response shape and tool calling. Thinking mode is left to DeepSeek's own
+    # default — see {DeepSeek::Chat::Request} — because the provider's API is the
+    # authority on how it wants to be called.
+    #
+    # @example Configuration in active_agent.yml
+    #   deepseek:
+    #     service: "DeepSeek"
+    #     api_key: <%= ENV["DEEPSEEK_API_KEY"] %>
+    #
+    # @example Usage
+    #   class TicketAgent < ApplicationAgent
+    #     generate_with :deepseek, model: "deepseek-flash"
+    #   end
+    #
+    # @see OpenAI::ChatProvider
+    # @see https://api-docs.deepseek.com
+    class DeepSeekProvider < OpenAI::ChatProvider
+      # @return [String]
+      def self.service_name
+        "DeepSeek"
+      end
+
+      # @return [Class]
+      def self.options_klass
+        namespace::Options
+      end
+
+      # @return [ActiveModel::Type::Value]
+      def self.prompt_request_type
+        namespace::Chat::RequestType.new
+      end
+    end
+  end
+end

data/lib/active_agent/providers/log_subscriber.rb

@@ -122,6 +122,19 @@ module ActiveAgent
       end
       # event_log_level :tool_call, :debug # Rails 8.1
 
+      # @param event [ActiveSupport::Notifications::Event]
+      # @return [void]
+      def input_requested(event)
+        trace_id        = event.payload[:trace_id]
+        provider_module = event.payload[:provider_module]
+        tool_names      = Array(event.payload[:input_requests]).map(&:tool_name)
+
+        debug do
+          "[#{trace_id}] [ActiveAgent] [#{provider_module}] Awaiting input for: #{tool_names.join(", ")}"
+        end
+      end
+      # event_log_level :input_requested, :debug # Rails 8.1
+
       # @param event [ActiveSupport::Notifications::Event]
       # @return [void]
       def stream_chunk(event)