turnkit 0.2.10 → 0.4.0

data/lib/turnkit/agent.rb

@@ -3,14 +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, :max_tool_executions_by_name
-    attr_reader :prompt_sections, :system_prompt, :prompt_mode, :thinking, :compaction, :output_schema, :on_event
-    attr_reader :output_audit, :output_audit_mode, :output_policy_model
+    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, max_tool_executions_by_name: nil, thinking: nil, compaction: nil,
-      output_schema: nil, output_audit: nil, output_audit_mode: nil, output_policy: nil, output_policy_mode: nil, output_policy_model: nil, output_policy_thinking: 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
@@ -26,16 +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_audit = normalize_output_policy_options(output_audit: output_audit, output_policy: output_policy, output_policy_model: output_policy_model, output_policy_thinking: output_policy_thinking)
-      @output_audit_mode = normalize_output_policy_mode(output_audit_mode: output_audit_mode, output_policy_mode: output_policy_mode)
+      @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!
@@ -70,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 })
@@ -99,16 +102,8 @@ module TurnKit
       thinking
     end
 
-    def effective_output_audit
-      Array(output_audit).compact
-    end
-
-    def output_policy
-      output_audit
-    end
-
-    def output_policy_mode
-      output_audit_mode
+    def effective_output_policy
+      Array(output_policy).compact
     end
 
     def effective_client
@@ -120,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
@@ -161,7 +158,7 @@ module TurnKit
         max_depth: max_depth || TurnKit.max_depth,
         max_tool_executions: max_tool_executions || TurnKit.max_tool_executions,
         max_tool_executions_by_name: max_tool_executions_by_name || TurnKit.max_tool_executions_by_name,
-        cost_limit: cost_limit || TurnKit.cost_limit,
+        max_spend: max_spend || TurnKit.max_spend,
         root_started_at: root_started_at
       )
     end
@@ -188,12 +185,6 @@ module TurnKit
         effective_tools.each(&:validate_definition!)
       end
 
-      def normalize_output_policy_options(output_audit:, output_policy:, output_policy_model:, output_policy_thinking:)
-        raise ArgumentError, "use output_policy: or output_audit:, not both" if output_audit && output_policy
-
-        output_policy.nil? ? output_audit : normalize_output_policy(output_policy, model: output_policy_model, thinking: output_policy_thinking)
-      end
-
       def normalize_output_policy(value, model: nil, thinking: nil)
         case value
         when nil
@@ -204,10 +195,12 @@ module TurnKit
           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 #call/#check object, or an array of those"
+          raise ArgumentError, "output_policy must be a policy file path, a skill, a #call/#check object, or an array of those"
         end
       end
 
@@ -223,12 +216,8 @@ module TurnKit
         )
       end
 
-      def normalize_output_policy_mode(output_audit_mode:, output_policy_mode:)
-        if output_audit_mode && output_policy_mode && output_audit_mode.to_sym != output_policy_mode.to_sym
-          raise ArgumentError, "use output_policy_mode: or output_audit_mode:, not both"
-        end
-
-        value = output_policy_mode || output_audit_mode || :report
+      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)
 

data/lib/turnkit/budget.rb

@@ -2,16 +2,24 @@
 
 module TurnKit
   class Budget
-    attr_reader :root_started_at, :max_iterations, :timeout, :max_depth, :max_tool_executions, :max_tool_executions_by_name, :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:, max_tool_executions_by_name: {}, 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
       @max_tool_executions_by_name = normalize_tool_limits(max_tool_executions_by_name)
-      @cost_limit = cost_limit
+      @max_spend = max_spend
       @iterations = 0
       @tool_executions = 0
       @tool_executions_by_name = Hash.new(0)
@@ -19,6 +27,17 @@ module TurnKit
       @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
@@ -44,11 +63,11 @@ 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 BudgetError, "cost limit reached" if @cost > cost_limit
+        raise BudgetError, "cost limit reached" if @cost > max_spend
       end
     end
 

data/lib/turnkit/client.rb

@@ -9,5 +9,9 @@ module TurnKit
     def chat(model:, messages:, tools:, instructions:, temperature: nil, thinking: nil, output_schema: nil, metadata: nil, on_event: nil)
       raise NotImplementedError
     end
+
+    def paint(prompt:, model:, provider: nil, size: nil, assume_model_exists: nil, input_images: nil, mask: nil, params: {}, metadata: nil, on_event: nil)
+      raise NotImplementedError
+    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.

data/lib/turnkit/error.rb

@@ -5,6 +5,7 @@ module TurnKit
   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/image_result.rb

@@ -0,0 +1,51 @@
+# frozen_string_literal: true
+
+require "base64"
+require "open-uri"
+
+module TurnKit
+  class ImageResult
+    attr_reader :url, :data, :mime_type, :revised_prompt, :model, :provider, :usage, :params, :metadata
+
+    def self.from_h(value)
+      new(**value.transform_keys(&:to_sym))
+    end
+
+    def initialize(url: nil, data: nil, mime_type: nil, revised_prompt: nil, model: nil, provider: nil, usage: Usage.new, params: {}, metadata: {}, **)
+      @url = url
+      @data = data
+      @mime_type = mime_type
+      @revised_prompt = revised_prompt
+      @model = model
+      @provider = provider
+      @usage = usage.is_a?(Usage) ? usage : Usage.from_h(usage || {})
+      @params = params || {}
+      @metadata = metadata || {}
+    end
+
+    def to_blob
+      raise Error, "image has no url or data" if url.to_s.empty? && data.to_s.empty?
+
+      data ? Base64.decode64(data) : URI.open(url, &:read)
+    end
+
+    def cost
+      Cost.from_usage(usage, model: model)
+    end
+
+    def to_h
+      {
+        "url" => url,
+        "data" => data,
+        "mime_type" => mime_type,
+        "revised_prompt" => revised_prompt,
+        "model" => model,
+        "provider" => provider,
+        "usage" => usage.to_h,
+        "cost" => cost.to_h,
+        "params" => params,
+        "metadata" => metadata
+      }.compact
+    end
+  end
+end

data/lib/turnkit/image_tool.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+module TurnKit
+  class ImageTool < Tool
+    class << self
+      %i[model provider size assume_model_exists params].each do |name|
+        define_method(name) do |value = nil|
+          instance_variable_set("@#{name}", value) unless value.nil?
+          instance_variable_get("@#{name}")
+        end
+      end
+    end
+
+    def call(turnkit_context:, **arguments)
+      turnkit_context.turn.paint(
+        prompt(**arguments),
+        model: self.class.model,
+        provider: self.class.provider,
+        size: self.class.size,
+        assume_model_exists: self.class.assume_model_exists,
+        params: self.class.params || {},
+        metadata: metadata(**arguments)
+      ).to_h
+    end
+
+    def metadata(**)
+      {}
+    end
+  end
+end

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

@@ -3,10 +3,10 @@
 module TurnKit
   class Message
     ROLES = %w[user assistant tool].freeze
-    KINDS = %w[text tool_call tool_result context_summary].freeze
+    KINDS = %w[text tool_call tool_result context_summary image].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,17 @@ module TurnKit
       kind == "context_summary"
     end
 
+    def image?
+      kind == "image"
+    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 +78,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,12 @@ 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) }
+      when "image"
+        { role: :assistant, content: projected_images }
       else
         { role: message.role.to_sym, content: message.text }
       end
@@ -50,5 +53,28 @@ 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
+
+      def projected_images
+        message.content.filter_map do |part|
+          next unless part.fetch("type") == "image"
+
+          attrs = part.slice("url", "mime_type", "model", "provider", "revised_prompt").compact
+          "Generated image: #{attrs.to_json}"
+        end.join("\n")
+      end
   end
 end

data/lib/turnkit/output_policy.rb

@@ -27,6 +27,19 @@ module TurnKit
       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 self.require_image
+      lambda do |output, output_data: nil, turn: nil, **|
+        data = output_data.is_a?(Hash) ? output_data : output
+        images = data.is_a?(Hash) ? data["images"] || data[:images] : nil
+        has_image = Array(images).any? || turn&.conversation&.messages_for_turn(turn)&.any?(&:image?)
+        { rule: "image_required", message: "output must include an image result" } unless has_image
+      end
+    end
+
     def initialize(content:, name: "output_policy", model: nil, thinking: nil, client: nil)
       @name = name.to_s
       @content = content.to_s
@@ -78,6 +91,8 @@ module TurnKit
 
           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

data/lib/turnkit/result.rb

@@ -2,19 +2,56 @@
 
 module TurnKit
   class Result
-    attr_reader :text, :tool_calls, :usage, :model, :finish_reason, :output_data
+    attr_reader :parts, :usage, :model, :finish_reason, :output_data
 
-    def initialize(text: "", tool_calls: [], usage: Usage.new, model: nil, finish_reason: nil, output_data: nil)
-      @text = text.to_s
-      @tool_calls = Array(tool_calls)
+    def initialize(text: "", tool_calls: [], parts: nil, usage: Usage.new, model: nil, finish_reason: nil, output_data: nil)
+      @parts = parts ? normalize_parts(parts) : synthesize_parts(text: text, tool_calls: tool_calls)
       @usage = usage || Usage.new
       @model = model
       @finish_reason = finish_reason
       @output_data = output_data
     end
 
+    def text
+      parts.filter_map { |part| part["text"] if part["type"] == "text" }.join("\n")
+    end
+
+    def tool_calls
+      parts.filter_map do |part|
+        next unless part["type"] == "tool_call"
+
+        ToolCall.new(id: part.fetch("id"), name: part.fetch("name"), arguments: part["arguments"] || {}, arguments_error: part["arguments_error"])
+      end
+    end
+
     def tool_calls?
       tool_calls.any?
     end
+
+    def images
+      parts.filter_map do |part|
+        next unless part["type"] == "image"
+
+        ImageResult.from_h(part)
+      end
+    end
+
+    def image?
+      images.any?
+    end
+
+    private
+      def synthesize_parts(text:, tool_calls:)
+        parts = []
+        parts << { "type" => "text", "text" => text.to_s } unless text.to_s.empty?
+        Array(tool_calls).each do |call|
+          parts << { "type" => "tool_call", "id" => call.id, "name" => call.name, "arguments" => call.arguments, "arguments_error" => call.arguments_error }.compact
+        end
+        parts
+      end
+
+      def normalize_parts(value)
+        Array(value).map { |part| part.to_h.transform_keys(&:to_s) }
+      end
   end
 end

data/lib/turnkit/run.rb

@@ -14,8 +14,8 @@ module TurnKit
     def output = output_text
     def output_text = turn.output_text
     def output_data = turn.output_data
-    def output_audit = turn.output_audit
-    def output_audit_clean? = output_audit.nil? || output_audit.fetch("clean", false)
+    def policy_audit = turn.policy_audit
+    def policy_clean? = policy_audit.nil? || policy_audit.fetch("clean", false)
     def usage = Usage.from_records(turn_records)
     def cost = Cost.from_records(turn_records)
     def steps = turn_records.length
@@ -27,9 +27,8 @@ module TurnKit
     end
 
     def messages
-      turn_records.flat_map do |record|
-        conversation = turn.store.load_conversation(record.fetch("conversation_id"))
-        turn.store.list_messages(conversation.fetch("id"))
+      turn_records.map { |record| record.fetch("conversation_id") }.uniq.flat_map do |conversation_id|
+        turn.store.list_messages(conversation_id).map { |attrs| Message.new(attrs) }
       end
     end
 

data/lib/turnkit/schema_check.rb

@@ -0,0 +1,68 @@
+# frozen_string_literal: true
+
+module TurnKit
+  module SchemaCheck
+    module_function
+
+    def validate!(value, schema, error_class: ToolValidationError, label: "input")
+      schema = stringify_schema(schema || {})
+      type = schema["type"] || "object"
+      validate_type!(value, type, schema, error_class: error_class, label: label)
+      validate_enum!(value, schema, error_class: error_class, label: label)
+
+      if type == "object" && schema["properties"]
+        attrs = value.respond_to?(:to_h) ? value.to_h.transform_keys(&:to_s) : {}
+        required = Array(schema["required"]).map(&:to_s)
+        missing = required.reject { |name| attrs.key?(name) }
+        raise error_class, "#{label} missing required field#{missing.length == 1 ? "" : "s"}: #{missing.join(", ")}" if missing.any?
+
+        schema.fetch("properties", {}).each do |name, child_schema|
+          next unless attrs.key?(name)
+
+          validate!(attrs[name], child_schema, error_class: error_class, label: "#{label}.#{name}")
+        end
+      elsif type == "array" && schema["items"] && value.is_a?(Array)
+        value.each_with_index do |item, index|
+          validate!(item, schema["items"], error_class: error_class, label: "#{label}[#{index}]")
+        end
+      end
+
+      true
+    end
+
+    def stringify_schema(value)
+      case value
+      when Hash
+        value.transform_keys(&:to_s).transform_values { |nested| stringify_schema(nested) }
+      when Array
+        value.map { |nested| stringify_schema(nested) }
+      when Symbol
+        value.to_s
+      else
+        value
+      end
+    end
+
+    def validate_type!(value, type, schema, error_class:, label:)
+      return if value.nil? && !Array(schema["required"]).include?(label.to_s)
+
+      valid = case type.to_s
+      when "string" then value.is_a?(String)
+      when "integer" then value.is_a?(Integer)
+      when "number" then value.is_a?(Numeric)
+      when "boolean" then value == true || value == false
+      when "array" then value.is_a?(Array)
+      when "object" then value.is_a?(Hash)
+      else true
+      end
+      raise error_class, "#{label} must be a #{type}" unless valid
+    end
+
+    def validate_enum!(value, schema, error_class:, label:)
+      enum = schema["enum"]
+      return unless enum && !Array(enum).include?(value)
+
+      raise error_class, "#{label} must be one of: #{Array(enum).join(", ")}"
+    end
+  end
+end