phronomy 0.26.0 → 0.28.0

data/lib/phronomy/agent/context/instruction/prompt_template.rb

@@ -1,102 +0,0 @@
-# frozen_string_literal: true
-
-module Phronomy
-  module Agent
-    module Context
-      module Instruction
-        # A prompt template that substitutes {{variable}} placeholders in a string.
-        #
-        # @example Simple human template
-        #   t = Phronomy::Agent::Context::Instruction::PromptTemplate.new(template: "Translate to {{lang}}: {{text}}")
-        #   t.format(lang: "French", text: "Hello")
-        #   # => "Translate to French: Hello"
-        #
-        # @example With a system template
-        #   t = Phronomy::Agent::Context::Instruction::PromptTemplate.new(
-        #     template: "{{question}}",
-        #     system_template: "You are a {{role}} assistant."
-        #   )
-        #   t.format_system(role: "helpful")
-        #   # => "You are a helpful assistant."
-        #
-        # As a Runnable, #invoke accepts a Hash of variables and returns a Hash
-        # with :prompt (and optionally :system) keys.
-        class PromptTemplate
-          include Phronomy::Runnable
-
-          PLACEHOLDER = /\{\{(\w+)\}\}/
-
-          attr_reader :template, :system_template
-
-          # @param template        [String] human message template with {{var}} placeholders
-          # @param system_template [String, nil] optional system message template
-          # @api public
-          def initialize(template:, system_template: nil)
-            @template = template
-            @system_template = system_template
-          end
-
-          # Substitute all {{var}} placeholders in the human template.
-          #
-          # @param variables [Hash{Symbol => String}]
-          # @return [String]
-          # @api public
-          def format(**variables)
-            substitute(@template, variables)
-          end
-
-          # Substitute all {{var}} placeholders in the system template.
-          # Returns nil when no system template was set.
-          #
-          # @param variables [Hash{Symbol => String}]
-          # @return [String, nil]
-          # @api public
-          def format_system(**variables)
-            @system_template && substitute(@system_template, variables)
-          end
-
-          # Runnable interface: accepts a Hash of variable values.
-          # Returns { prompt: String, system: String|nil }.
-          #
-          # @param input  [Hash{Symbol => String}]
-          # @return [Hash]
-          # @api public
-          def invoke(input, config: {})
-            vars = normalize_input(input)
-            result = {prompt: format(**vars)}
-            sys = format_system(**vars)
-            result[:system] = sys if sys
-            result
-          end
-
-          # Returns the list of placeholder names found in both templates.
-          #
-          # @return [Array<Symbol>]
-          # @api public
-          def variables
-            names = @template.scan(PLACEHOLDER).flatten
-            names += @system_template.scan(PLACEHOLDER).flatten if @system_template
-            names.map(&:to_sym).uniq
-          end
-
-          private
-
-          def substitute(text, variables)
-            text.gsub(PLACEHOLDER) do |match|
-              key = Regexp.last_match(1).to_sym
-              variables.fetch(key) { raise KeyError, "Missing variable: {{#{key}}}" }
-            end
-          end
-
-          def normalize_input(input)
-            case input
-            when Hash then input
-            when String then {input: input}
-            else raise ArgumentError, "PromptTemplate#invoke expects a Hash of variables, got #{input.class}"
-            end
-          end
-        end
-      end
-    end
-  end
-end

data/lib/phronomy/agent/context_parts/validators/final_budget_validator.rb

@@ -1,37 +0,0 @@
-# frozen_string_literal: true
-
-module Phronomy
-  module Agent
-    module ContextParts
-      module Validators
-        class FinalBudgetValidator
-          def initialize(content_loader:)
-            @content_loader = content_loader
-          end
-
-          def validate!(token_budget:, segments:, extra_values: [])
-            return 0 unless token_budget
-
-            estimated = Array(segments).sum do |segment|
-              Phronomy::LlmContextWindow::TokenEstimator.estimate(
-                @content_loader.call(segment.fetch(:content_ref))
-              )
-            end
-            estimated += Array(extra_values).sum do |value|
-              bytes = value.is_a?(String) ? value : Phronomy::CanonicalJSON.dump(value)
-              Phronomy::LlmContextWindow::TokenEstimator.estimate(bytes)
-            end
-
-            limit = token_budget.effective_input_limit
-            if estimated > limit
-              raise Phronomy::ContextBudgetExceededError,
-                "Canonical LLM input (estimated #{estimated} tokens) exceeds " \
-                "available input budget (#{limit} tokens)"
-            end
-            estimated
-          end
-        end
-      end
-    end
-  end
-end

data/lib/phronomy/agent/context_policies/default.rb

@@ -1,142 +0,0 @@
-# frozen_string_literal: true
-
-module Phronomy
-  module Agent
-    module ContextPolicies
-      class Default < ContextPolicy
-        CONVERSATION_SHARE = 0.60
-
-        def self.instance
-          @instance ||= new.freeze
-        end
-
-        def call(input)
-          unless input.is_a?(ContextPolicyInput)
-            raise ArgumentError, "Default ContextPolicy expected ContextPolicyInput"
-          end
-
-          return all_context(input) unless input.token_budget
-
-          limit = input.token_budget.effective_input_limit
-          required_knowledge = input.knowledge.select(&:required?)
-          optional_knowledge = input.knowledge.reject(&:required?)
-          required_conversation = input.conversation.select { |group| group.any?(&:required?) }
-          optional_conversation = input.conversation.reject { |group| group.any?(&:required?) }
-
-          fixed_cost = item_cost(input.instruction) + item_cost(input.tools) +
-            item_cost(required_knowledge) + group_cost(required_conversation)
-          if fixed_cost > limit
-            raise Phronomy::ContextBudgetExceededError,
-              "Required Context (estimated #{fixed_cost} tokens) exceeds " \
-              "available input budget (#{limit} tokens)"
-          end
-
-          remaining = limit - fixed_cost
-          conversation_budget = (remaining * CONVERSATION_SHARE).floor
-          knowledge_budget = remaining - conversation_budget
-
-          selected_conversation, older_conversation, conversation_used =
-            select_recent_suffix(optional_conversation, conversation_budget)
-          selected_knowledge, remaining_knowledge, knowledge_used =
-            select_stable_fit(optional_knowledge, knowledge_budget)
-
-          reusable = remaining - conversation_used - knowledge_used
-          if reusable.positive? && !older_conversation.empty?
-            more_conversation, _, used =
-              select_recent_suffix(older_conversation, reusable)
-            selected_conversation = more_conversation + selected_conversation
-            reusable -= used
-          end
-          if reusable.positive? && !remaining_knowledge.empty?
-            more_knowledge, _remaining_knowledge, used =
-              select_stable_fit(remaining_knowledge, reusable)
-            selected_knowledge += more_knowledge
-            reusable -= used
-          end
-
-          conversation = (required_conversation + selected_conversation)
-            .uniq
-            .sort_by { |group| group_sequence(group) }
-          knowledge_ids = (required_knowledge + selected_knowledge).to_h { |item| [item.id, true] }
-          knowledge = input.knowledge.select { |item| knowledge_ids[item.id] }
-
-          plan(
-            instruction: input.instruction,
-            knowledge: knowledge,
-            tools: input.tools,
-            conversation: conversation,
-            metadata: {
-              "default_policy" => true,
-              "estimated_fixed_tokens" => fixed_cost,
-              "estimated_unused_tokens" => reusable
-            }
-          )
-        end
-
-        private
-
-        def all_context(input)
-          plan(
-            instruction: input.instruction,
-            knowledge: input.knowledge,
-            tools: input.tools,
-            conversation: input.conversation,
-            metadata: {"default_policy" => true}
-          )
-        end
-
-        def item_cost(items)
-          Array(items).sum { |item| Integer(item.estimated_tokens || 0) }
-        end
-
-        def group_cost(groups)
-          Array(groups).sum { |group| item_cost(group) }
-        end
-
-        def group_sequence(group)
-          group.filter_map(&:sequence).min || 0
-        end
-
-        def select_recent_suffix(groups, budget)
-          ordered = Array(groups).sort_by { |group| group_sequence(group) }
-          selected = []
-          remaining = Integer(budget)
-          stop_index = -1
-
-          (ordered.length - 1).downto(0) do |index|
-            cost = item_cost(ordered[index])
-            if cost > remaining
-              stop_index = index
-              break
-            end
-            selected.unshift(ordered[index])
-            remaining -= cost
-          end
-
-          older = if stop_index >= 0
-            ordered[0..stop_index]
-          else
-            []
-          end
-          [selected.freeze, older.freeze, Integer(budget) - remaining]
-        end
-
-        def select_stable_fit(items, budget)
-          remaining = Integer(budget)
-          selected = []
-          unselected = []
-          Array(items).each do |item|
-            cost = Integer(item.estimated_tokens || 0)
-            if cost <= remaining
-              selected << item
-              remaining -= cost
-            else
-              unselected << item
-            end
-          end
-          [selected.freeze, unselected.freeze, Integer(budget) - remaining]
-        end
-      end
-    end
-  end
-end