turnkit 0.2.9 → 0.3.0

data/lib/turnkit/agent.rb

@@ -3,13 +3,14 @@
 module TurnKit
   class Agent
     attr_reader :name, :description, :model, :instructions, :tools, :skills, :available_skills, :sub_agents
-    attr_reader :client, :store, :max_iterations, :timeout, :cost_limit, :max_depth, :max_tool_executions
-    attr_reader :prompt_sections, :system_prompt, :prompt_mode, :thinking, :compaction, :output_schema, :on_event
+    attr_reader :client, :store, :max_iterations, :timeout, :max_spend, :max_depth, :max_tool_executions, :max_tool_executions_by_name
+    attr_reader :prompt_sections, :system_prompt, :prompt_mode, :thinking, :compaction, :output_schema, :input_schema, :on_event
+    attr_reader :output_policy, :output_policy_mode, :output_policy_model, :output_retries
 
     def initialize(name:, description: "", model: nil, instructions: "", tools: [], skills: [], available_skills: [], sub_agents: [],
       system_prompt: nil, prompt_sections: nil, prompt_mode: nil, client: nil, store: nil,
-      max_iterations: nil, timeout: nil, cost_limit: nil, max_depth: nil, max_tool_executions: nil, thinking: nil, compaction: nil,
-      output_schema: nil, on_event: nil)
+      max_iterations: nil, timeout: nil, max_spend: nil, max_depth: nil, max_tool_executions: nil, max_tool_executions_by_name: nil, thinking: nil, compaction: nil,
+      output_schema: nil, input_schema: nil, output_policy: nil, output_policy_mode: nil, output_policy_model: nil, output_policy_thinking: nil, output_retries: 0, on_event: nil)
       @name = name.to_s
       @description = description.to_s
       @model = model
@@ -25,12 +26,18 @@ module TurnKit
       @store = store
       @max_iterations = max_iterations
       @timeout = timeout
-      @cost_limit = cost_limit
+      @max_spend = max_spend
       @max_depth = max_depth
       @max_tool_executions = max_tool_executions
+      @max_tool_executions_by_name = max_tool_executions_by_name
       @thinking = self.class.normalize_thinking(thinking)
       @compaction = compaction
       @output_schema = output_schema
+      @input_schema = input_schema
+      @output_policy_model = output_policy_model
+      @output_policy = normalize_output_policy(output_policy, model: output_policy_model, thinking: output_policy_thinking)
+      @output_policy_mode = normalize_output_policy_mode(output_policy_mode)
+      @output_retries = Integer(output_retries || 0)
       @on_event = on_event
       raise ArgumentError, "name is required" if @name.empty?
       validate_tools!
@@ -65,6 +72,7 @@ module TurnKit
     def run(prompt = nil, task: nil, input: nil, async: false, subject: nil, metadata: {}, parent_run: nil, root_turn_id: nil, prompt_mode: :task, **options)
       task = task || prompt
       raise ArgumentError, "task is required" if task.to_s.empty?
+      SchemaCheck.validate!(input, input_schema, error_class: InputError, label: "input") if input_schema
 
       conversation = self.conversation(subject: subject, metadata: metadata)
       message = conversation.say(task_message(task, input), metadata: { "source" => "application", "task" => true })
@@ -94,6 +102,10 @@ module TurnKit
       thinking
     end
 
+    def effective_output_policy
+      Array(output_policy).compact
+    end
+
     def effective_client
       client || TurnKit.client
     end
@@ -103,7 +115,9 @@ module TurnKit
     end
 
     def effective_tools
-      tools + sub_agents.map { |agent| SubAgentTool.for(agent) }
+      configured = tools + sub_agents.map { |agent| SubAgentTool.for(agent) }
+      skills = effective_available_skills
+      skills.empty? ? configured : configured + [ LoadSkillTool.for(skills) ]
     end
 
     def effective_on_event
@@ -143,7 +157,8 @@ module TurnKit
         timeout: timeout || TurnKit.timeout,
         max_depth: max_depth || TurnKit.max_depth,
         max_tool_executions: max_tool_executions || TurnKit.max_tool_executions,
-        cost_limit: cost_limit || TurnKit.cost_limit,
+        max_tool_executions_by_name: max_tool_executions_by_name || TurnKit.max_tool_executions_by_name,
+        max_spend: max_spend || TurnKit.max_spend,
         root_started_at: root_started_at
       )
     end
@@ -170,6 +185,45 @@ module TurnKit
         effective_tools.each(&:validate_definition!)
       end
 
+      def normalize_output_policy(value, model: nil, thinking: nil)
+        case value
+        when nil
+          nil
+        when Array
+          value.map { |item| normalize_output_policy(item, model: model, thinking: thinking) }.compact
+        when String
+          output_policy_from_path(value, model: model, thinking: thinking)
+        when Pathname
+          output_policy_from_path(value.to_s, model: model, thinking: thinking)
+        when Skill
+          OutputPolicy.from_skill(value, model: model || TurnKit.output_policy_model, thinking: thinking || TurnKit.output_policy_thinking)
+        else
+          return value if value.respond_to?(:call) || value.respond_to?(:check)
+
+          raise ArgumentError, "output_policy must be a policy file path, a skill, a #call/#check object, or an array of those"
+        end
+      end
+
+      def output_policy_from_path(path, model: nil, thinking: nil)
+        unless path.match?(/\.(md|markdown|txt)\z/i)
+          raise ArgumentError, "output_policy string must be a .md, .markdown, or .txt file path"
+        end
+
+        TurnKit::OutputPolicy.from_file(
+          path,
+          model: model || TurnKit.output_policy_model,
+          thinking: thinking || TurnKit.output_policy_thinking
+        )
+      end
+
+      def normalize_output_policy_mode(value)
+        value ||= :fail
+        mode = value.to_sym
+        raise ArgumentError, "unknown output_policy_mode: #{value}" unless %i[report fail].include?(mode)
+
+        mode
+      end
+
       def task_message(task, input)
         text = task.to_s
         return text if input.nil?

data/lib/turnkit/budget.rb

@@ -2,32 +2,59 @@
 
 module TurnKit
   class Budget
-    attr_reader :root_started_at, :max_iterations, :timeout, :max_depth, :max_tool_executions, :cost_limit
+    attr_reader :root_started_at, :max_iterations, :timeout, :max_depth, :max_tool_executions, :max_tool_executions_by_name, :max_spend
 
-    def initialize(max_iterations:, timeout:, max_depth:, max_tool_executions:, cost_limit: nil, root_started_at: Clock.now)
+    def self.resume(store:, root_turn_id:, limits: {})
+      turns = store.list_turns(root_turn_id: root_turn_id)
+      root = turns.find { |turn| turn.fetch("id") == root_turn_id } || turns.first || {}
+      budget = new(**limits.merge(root_started_at: root["started_at"] || Clock.now))
+      budget.seed!(turns: turns, tool_executions: turns.flat_map { |turn| store.list_tool_executions(turn_id: turn.fetch("id")) })
+      budget
+    end
+
+    def initialize(max_iterations:, timeout:, max_depth:, max_tool_executions:, max_tool_executions_by_name: {}, max_spend: nil, root_started_at: Clock.now)
       @root_started_at = root_started_at
       @max_iterations = max_iterations
       @timeout = timeout
       @max_depth = max_depth
       @max_tool_executions = max_tool_executions
-      @cost_limit = cost_limit
+      @max_tool_executions_by_name = normalize_tool_limits(max_tool_executions_by_name)
+      @max_spend = max_spend
       @iterations = 0
       @tool_executions = 0
+      @tool_executions_by_name = Hash.new(0)
       @cost = 0
       @mutex = Mutex.new
     end
 
+    def seed!(turns:, tool_executions:)
+      @mutex.synchronize do
+        @iterations = Array(turns).sum { |turn| (turn["options"] || {})["iterations"].to_i }
+        completed = Array(tool_executions).select { |execution| %w[completed failed].include?(execution["status"]) && !execution.dig("error", "details", "budget_denied") }
+        @tool_executions = completed.length
+        completed.each { |execution| @tool_executions_by_name[execution.fetch("tool_name").to_s] += 1 }
+        @cost = Array(turns).sum { |turn| turn["cost"].to_f }
+      end
+      self
+    end
+
     def count_iteration!
       @mutex.synchronize do
+        raise BudgetError, "maximum iterations reached" if max_iterations && @iterations >= max_iterations
+
         @iterations += 1
-        raise Error, "maximum iterations reached" if max_iterations && @iterations > max_iterations
       end
     end
 
-    def count_tool_execution!
+    def count_tool_execution!(name = nil)
       @mutex.synchronize do
+        key = name.to_s if name
+        limit = max_tool_executions_by_name[key] if key
+        raise BudgetError, "maximum tool executions reached" if max_tool_executions && @tool_executions >= max_tool_executions
+        raise BudgetError, "maximum executions reached for tool #{key}" if limit && @tool_executions_by_name[key] >= limit
+
         @tool_executions += 1
-        raise Error, "maximum tool executions reached" if max_tool_executions && @tool_executions > max_tool_executions
+        @tool_executions_by_name[key] += 1 if key
       end
     end
 
@@ -36,17 +63,24 @@ module TurnKit
     end
 
     def add_cost!(cost)
-      return unless cost && cost_limit
+      return unless cost && max_spend
 
       @mutex.synchronize do
         @cost += cost.to_f
-        raise Error, "cost limit reached" if @cost > cost_limit
+        raise BudgetError, "cost limit reached" if @cost > max_spend
       end
     end
 
     def check!(depth:)
-      raise Error, "maximum sub-agent depth reached" if max_depth && depth > max_depth
-      raise Error, "turn timed out" if timeout && Clock.now >= root_started_at + timeout
+      raise BudgetError, "maximum sub-agent depth reached" if max_depth && depth > max_depth
+      raise BudgetError, "turn timed out" if timeout && Clock.now >= root_started_at + timeout
     end
+
+    private
+      def normalize_tool_limits(value)
+        value.to_h.transform_keys(&:to_s).transform_values do |limit|
+          limit.nil? ? nil : Integer(limit)
+        end
+      end
   end
 end

data/lib/turnkit/compaction.rb

@@ -83,6 +83,7 @@ module TurnKit
       - Keep every section.
       - Use terse bullets.
       - Preserve exact file paths, commands, error strings, IDs, and important values.
+      - In Tool Results To Remember, record which skill keys were loaded.
       - Do not invent facts.
       - Do not include secrets.
       - Do not include a greeting or preamble.
@@ -117,6 +118,8 @@ module TurnKit
       return unless force || over_threshold?(messages, policy)
 
       compact!(turn.conversation, agent: turn.agent, turn: turn, focus: focus, auto: true, overrides: policy, force: true)
+    rescue BudgetError
+      raise
     rescue StandardError => error
       TurnKit.logger&.warn("TurnKit compaction failed: #{error.class}: #{error.message}")
       nil
@@ -144,12 +147,15 @@ module TurnKit
         target_tokens: summary_budget(selected_tokens, policy),
         fallback_model: turn&.model || conversation.model || agent.effective_model,
         conversation_id: conversation.id,
-        turn_id: turn&.id
+        turn_id: turn&.id,
+        turn: turn
       )
 
       append_summary(conversation, turn: turn, summary: summary, selected: selected, policy: policy, focus: focus, auto: auto, input_tokens: selected_tokens)
     rescue CompactionError
       raise
+    rescue BudgetError
+      raise
     rescue StandardError => error
       raise CompactionError, "#{error.class}: #{error.message}"
     end
@@ -350,18 +356,24 @@ module TurnKit
       index
     end
 
-    def generate_summary(agent:, policy:, messages:, previous_summary:, focus:, target_tokens:, fallback_model:, conversation_id:, turn_id:)
+    def generate_summary(agent:, policy:, messages:, previous_summary:, focus:, target_tokens:, fallback_model:, conversation_id:, turn_id:, turn: nil)
       client = policy["client"] || agent.effective_client
       model = policy["model"] || fallback_model
       safe_messages = messages.map { |message| sanitize_message(message, policy) }
       prompt = build_prompt(previous_summary: previous_summary, focus: focus, target_tokens: target_tokens)
-      result = client.chat(
+      attrs = {
         model: model,
         messages: MessageProjection.for(safe_messages) + [ { role: :user, content: prompt } ],
         tools: [],
         instructions: COMPACTION_SYSTEM_PROMPT,
         metadata: { compaction: true, conversation_id: conversation_id, turn_id: turn_id }
-      )
+      }
+      result = if turn
+        turn.internal_model_call(**attrs, purpose: "compaction", client: policy["client"])
+      else
+        client.validate!(model: model)
+        client.chat(**attrs)
+      end
       text = result.text.to_s.strip
       raise CompactionError, "compaction model returned an empty summary" if text.empty?
 

data/lib/turnkit/error.rb

@@ -2,8 +2,10 @@
 
 module TurnKit
   class Error < StandardError; end
+  class BudgetError < Error; end
   class ConfigError < Error; end
   class CompactionError < Error; end
+  class InputError < Error; end
   class ModelAccessError < ConfigError; end
   class StoreError < Error; end
   class ToolError < Error; end

data/lib/turnkit/generators/turnkit/install/templates/create_turnkit_tables.rb

@@ -50,7 +50,6 @@ class CreateTurnkitTables < ActiveRecord::Migration[7.1]
       t.string :kind, null: false
       t.integer :sequence, null: false
       t.json :content, null: false, default: []
-      t.text :text
       t.string :tool_execution_uid
       t.string :provider_message_id
       t.json :metadata, null: false, default: {}

data/lib/turnkit/load_skill_tool.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+module TurnKit
+  class LoadSkillTool < Tool
+    tool_name "load_skill"
+    description "Load the full instructions for an available skill by key."
+    parameter :key, :string, required: true, description: "Skill key from <skills_available>."
+
+    def self.for(skills)
+      Class.new(self) do
+        tool_name "load_skill"
+        @skills = Array(skills).to_h { |skill| [ skill.key, skill ] }
+        class << self
+          attr_reader :skills
+        end
+      end
+    end
+
+    def call(key:, context:)
+      skill = self.class.skills[key]
+      unless skill
+        available = self.class.skills.keys.join(", ")
+        raise ToolError, "unknown skill: #{key}. Available: #{available}"
+      end
+
+      { "key" => skill.key, "name" => skill.name, "content" => skill.content }
+    end
+  end
+end

data/lib/turnkit/memory_store.rb

@@ -68,6 +68,17 @@ module TurnKit
       end
     end
 
+    def claim_turn(id, from: "pending", to: "running", **attributes)
+      attrs = Record.turn_update(attributes.merge(status: to))
+      @mutex.synchronize do
+        record = @turns.fetch(id)
+        return nil unless record["status"] == from
+
+        record.merge!(attrs.merge("updated_at" => Clock.now))
+        duplicate(record)
+      end
+    end
+
     def list_turns(root_turn_id: nil, conversation_id: nil, agent_name: nil)
       @mutex.synchronize do
         rows = @turns.values

data/lib/turnkit/message.rb

@@ -6,7 +6,7 @@ module TurnKit
     KINDS = %w[text tool_call tool_result context_summary].freeze
 
     attr_reader :id, :conversation_id, :turn_id, :role, :kind, :sequence
-    attr_reader :content, :text, :tool_execution_id, :provider_message_id, :metadata, :created_at
+    attr_reader :content, :tool_execution_id, :provider_message_id, :metadata, :created_at
 
     def initialize(attributes = {})
       attrs = stringify(attributes)
@@ -16,8 +16,7 @@ module TurnKit
       @role = attrs.fetch("role").to_s
       @kind = attrs.fetch("kind", "text").to_s
       @sequence = attrs.fetch("sequence").to_i
-      @content = normalize_content(attrs["content"] || attrs["text"])
-      @text = attrs["text"] || extract_text(@content)
+      @content = normalize_content(attrs["content"].nil? ? attrs["text"] : attrs["content"])
       @tool_execution_id = attrs["tool_execution_id"]
       @provider_message_id = attrs["provider_message_id"]
       @metadata = attrs["metadata"] || {}
@@ -35,7 +34,6 @@ module TurnKit
         "kind" => kind,
         "sequence" => sequence,
         "content" => content,
-        "text" => text,
         "tool_execution_id" => tool_execution_id,
         "provider_message_id" => provider_message_id,
         "metadata" => metadata,
@@ -59,6 +57,13 @@ module TurnKit
       kind == "context_summary"
     end
 
+    def text
+      content.filter_map do |part|
+        attrs = stringify(part)
+        attrs["text"] if attrs["type"] == "text"
+      end.join("\n")
+    end
+
     def compaction_metadata
       metadata.fetch("compaction", {})
     end
@@ -69,13 +74,15 @@ module TurnKit
       end
 
       def normalize_content(value)
-        return value if value.is_a?(Array)
+        return Array(value).map { |part| normalize_part(part) } if value.is_a?(Array)
 
         [ { "type" => "text", "text" => value.to_s } ]
       end
 
-      def extract_text(blocks)
-        Array(blocks).filter_map { |block| block.is_a?(Hash) ? block["text"] || block[:text] : nil }.join("\n")
+      def normalize_part(part)
+        attrs = part.respond_to?(:to_h) ? part.to_h.transform_keys(&:to_s) : { "type" => "text", "text" => part.to_s }
+        attrs["type"] ||= "text"
+        attrs
       end
 
       def validate!

data/lib/turnkit/message_projection.rb

@@ -40,9 +40,10 @@ module TurnKit
     def to_h
       case message.kind
       when "tool_call"
-        { role: :assistant, content: message.text, tool_calls: message.metadata.fetch("tool_calls", []) }
+        { role: :assistant, content: projected_content, tool_calls: tool_call_parts }
       when "tool_result"
-        { role: :tool, content: message.text, tool_call_id: message.metadata["tool_call_id"] }
+        part = message.content.find { |candidate| candidate.fetch("type") == "tool_result" }
+        { role: :tool, content: part&.fetch("text", message.text) || message.text, tool_call_id: part&.fetch("tool_call_id", nil) }
       else
         { role: message.role.to_sym, content: message.text }
       end
@@ -50,5 +51,19 @@ module TurnKit
 
     private
       attr_reader :message
+
+      def projected_content
+        parts = message.content.reject { |part| %w[tool_call provider].include?(part.fetch("type")) }
+        ordered = parts.select { |part| part.fetch("type") == "thinking" } + parts.select { |part| part.fetch("type") == "text" }
+        ordered.filter_map { |part| part.fetch("text", nil) }.join("\n")
+      end
+
+      def tool_call_parts
+        message.content.filter_map do |part|
+          next unless part.fetch("type") == "tool_call"
+
+          { "id" => part.fetch("id"), "name" => part.fetch("name"), "arguments" => part["arguments"] || {} }
+        end
+      end
   end
 end

data/lib/turnkit/output_audit.rb

@@ -0,0 +1,92 @@
+# frozen_string_literal: true
+
+module TurnKit
+  class OutputAudit
+    Violation = Struct.new(:rule, :message, :metadata, keyword_init: true) do
+      def to_h
+        { "rule" => rule.to_s, "message" => message.to_s, "metadata" => metadata || {} }
+      end
+    end
+
+    Result = Struct.new(:violations, keyword_init: true) do
+      def clean?
+        violations.empty?
+      end
+
+      def messages
+        violations.map(&:message)
+      end
+
+      def to_h
+        { "clean" => clean?, "violations" => violations.map(&:to_h) }
+      end
+    end
+
+    def self.check(output, constraints: [], context: {})
+      new(output, constraints: constraints, context: context).check
+    end
+
+    def initialize(output, constraints: [], context: {})
+      @output = output
+      @constraints = Array(constraints)
+      @context = context || {}
+    end
+
+    def check
+      Result.new(violations: constraints.flat_map { |constraint| normalize(check_constraint(constraint)) })
+    end
+
+    private
+      attr_reader :output, :constraints, :context
+
+      def check_constraint(constraint)
+        if constraint.respond_to?(:check)
+          call_with_optional_context(constraint.method(:check))
+        elsif constraint.respond_to?(:call)
+          callable = constraint.is_a?(Proc) ? constraint : constraint.method(:call)
+          call_with_optional_context(callable)
+        else
+          raise ArgumentError, "output constraints must respond to #call or #check"
+        end
+      end
+
+      def call_with_optional_context(method)
+        parameters = method.parameters
+        return method.call(output) unless parameters.any? { |kind, _| %i[key keyreq keyrest].include?(kind) }
+        return method.call(output, **context) if parameters.any? { |kind, _| kind == :keyrest }
+
+        accepted = parameters.filter_map { |kind, name| name if %i[key keyreq].include?(kind) }
+        method.call(output, **context.slice(*accepted))
+      end
+
+      def normalize(value)
+        case value
+        when nil, false, true
+          []
+        when Violation
+          [ value ]
+        when Result
+          value.violations
+        when String
+          [ Violation.new(rule: "output_constraint", message: value, metadata: {}) ]
+        when Hash
+          [ violation_from_hash(value) ]
+        else
+          if value.respond_to?(:to_ary)
+            value.to_ary.flat_map { |item| normalize(item) }
+          else
+            raise ArgumentError, "output constraint returned unsupported value: #{value.class}"
+          end
+        end
+      end
+
+      def violation_from_hash(value)
+        attrs = value.transform_keys(&:to_s)
+        Violation.new(
+          rule: attrs["rule"] || "output_constraint",
+          message: attrs["message"] || attrs["error"] || "output constraint failed",
+          metadata: attrs["metadata"] || attrs.reject { |key, _| %w[rule message error].include?(key) }
+        )
+      end
+  end
+end

data/lib/turnkit/output_policy.rb

@@ -0,0 +1,127 @@
+# frozen_string_literal: true
+
+module TurnKit
+  class OutputPolicy
+    DEFAULT_SCHEMA = {
+      type: "object",
+      properties: {
+        approved: { type: "boolean" },
+        violations: {
+          type: "array",
+          items: {
+            type: "object",
+            properties: {
+              rule: { type: "string" },
+              message: { type: "string" }
+            },
+            required: [ "rule", "message" ]
+          }
+        }
+      },
+      required: [ "approved", "violations" ]
+    }.freeze
+
+    attr_reader :name, :content, :model, :thinking, :client
+
+    def self.from_file(path, name: nil, **options)
+      new(name: name || File.basename(path, File.extname(path)), content: File.read(path), **options)
+    end
+
+    def self.from_skill(skill, **options)
+      new(name: skill.key, content: skill.content, **options)
+    end
+
+    def initialize(content:, name: "output_policy", model: nil, thinking: nil, client: nil)
+      @name = name.to_s
+      @content = content.to_s
+      @model = model
+      @thinking = Agent.normalize_thinking(thinking)
+      @client = client
+      raise ArgumentError, "content is required" if @content.empty?
+    end
+
+    def call(output, run: nil, turn: nil)
+      model_name = model || turn&.model || run&.turn&.model || TurnKit.default_model
+      result = if turn
+        turn.internal_model_call(
+          model: model_name,
+          messages: audit_messages(output),
+          tools: [],
+          instructions: audit_instructions,
+          thinking: thinking,
+          output_schema: DEFAULT_SCHEMA,
+          metadata: { output_policy: name },
+          purpose: "output_policy",
+          client: client
+        )
+      else
+        audit_client = client || TurnKit.client
+        audit_client.validate!(model: model_name)
+        chat(audit_client, model: model_name, messages: audit_messages(output), tools: [], instructions: audit_instructions, thinking: thinking, output_schema: DEFAULT_SCHEMA, metadata: { output_policy: name })
+      end
+      data = result.output_data || parse_json(result.text)
+      return if data.fetch("approved", false)
+
+      Array(data["violations"]).map do |violation|
+        attrs = violation.transform_keys(&:to_s)
+        OutputAudit::Violation.new(
+          rule: attrs["rule"] || name,
+          message: attrs["message"] || "output policy failed",
+          metadata: attrs.reject { |key, _| %w[rule message].include?(key) }
+        )
+      end
+    end
+
+    private
+      def audit_instructions
+        <<~TEXT
+          You audit model outputs against the policy below.
+
+          Return only a JSON object matching this shape:
+          {"approved":true,"violations":[]}
+
+          Set approved to true only when the output satisfies the policy. For each violation, include a concise rule and message. Do not repair the output. Do not wrap the JSON in Markdown. Do not include commentary before or after the JSON.
+
+          The policy may be a skill; treat its output-facing rules as normative and ignore process steps that are not observable in the output.
+
+          Policy:
+          #{content}
+        TEXT
+      end
+
+      def audit_messages(output)
+        [ { role: :user, content: JSON.generate(output: output) } ]
+      end
+
+      def chat(client, **kwargs)
+        accepted = chat_keyword_names(client)
+        kwargs = kwargs.slice(*accepted) unless accepted.include?(:keyrest)
+        client.chat(**kwargs)
+      end
+
+      def chat_keyword_names(client)
+        client.method(:chat).parameters.filter_map do |kind, name|
+          return [ :keyrest ] if kind == :keyrest
+
+          name if %i[key keyreq].include?(kind)
+        end
+      end
+
+      def parse_json(value)
+        JSON.parse(extract_json(value.to_s))
+      rescue JSON::ParserError
+        { "approved" => false, "violations" => [ { "rule" => name, "message" => "output policy returned invalid JSON" } ] }
+      end
+
+      def extract_json(value)
+        text = value.strip
+        return text if text.start_with?("{") && text.end_with?("}")
+
+        fenced = text[/```(?:json)?\s*(\{.*?\})\s*```/m, 1]
+        return fenced if fenced
+
+        object = text[/\{.*\}/m]
+        object || text
+      end
+  end
+end