# Create new module files in the Elixact library
touch lib/elixact/json_schema/resolver.ex
touch lib/elixact/wrapper.ex

# Copy implementations from artifacts
cp resolver_implementation.ex lib/elixact/json_schema/resolver.ex
cp wrapper_implementation.ex lib/elixact/wrapper.ex

# Add any new dependencies if needed
defp deps do
  [
    # Existing dependencies...
    {:jason, "~> 1.0", optional: true},  # For JSON error formatting
    # Add other dependencies as needed
  ]
end

# In files that use the new modules
alias Elixact.{Runtime, TypeAdapter, EnhancedValidator, Config, Wrapper}
alias Elixact.JsonSchema.Resolver

# Create test directories
mkdir -p test/elixact/json_schema
mkdir -p test/elixact/runtime
mkdir -p test/integration

# Create test files
touch test/elixact/runtime_test.exs
touch test/elixact/type_adapter_test.exs
touch test/elixact/json_schema/resolver_test.exs
touch test/elixact/wrapper_test.exs
touch test/elixact/config_test.exs
touch test/elixact/enhanced_validator_test.exs
touch test/integration/dspy_patterns_test.exs

defmodule Elixact.RuntimeTest do
  use ExUnit.Case, async: true
  
  alias Elixact.Runtime
  alias Elixact.Runtime.DynamicSchema
  
  describe "create_schema/2" do
    test "creates schema with basic field definitions" do
      fields = [
        {:name, :string, [required: true, min_length: 2]},
        {:age, :integer, [optional: true, gt: 0]}
      ]
      
      schema = Runtime.create_schema(fields, title: "User Schema")
      
      assert %DynamicSchema{} = schema
      assert schema.config[:title] == "User Schema"
      assert map_size(schema.fields) == 2
    end
    
    test "handles complex nested types" do
      fields = [
        {:data, {:array, :string}, [min_items: 1]},
        {:metadata, {:map, {:string, :any}}, []}
      ]
      
      schema = Runtime.create_schema(fields)
      assert %DynamicSchema{} = schema
    end
    
    # Add 12 more tests as specified in test list...
  end
  
  describe "validate/3" do
    test "validates against runtime schema successfully" do
      schema = Runtime.create_schema([{:name, :string, [required: true]}])
      data = %{name: "John"}
      
      assert {:ok, %{name: "John"}} = Runtime.validate(data, schema)
    end
    
    # Add more validation tests...
  end
  
  # Add to_json_schema tests...
end

defmodule Elixact.TypeAdapterTest do
  use ExUnit.Case, async: true
  
  alias Elixact.TypeAdapter
  
  describe "validate/3" do
    test "validates basic types" do
      assert {:ok, "hello"} = TypeAdapter.validate(:string, "hello")
      assert {:ok, 42} = TypeAdapter.validate(:integer, 42)
      assert {:ok, true} = TypeAdapter.validate(:boolean, true)
    end
    
    test "validates complex types" do
      assert {:ok, [1, 2, 3]} = TypeAdapter.validate({:array, :integer}, [1, 2, 3])
      assert {:ok, %{"a" => 1}} = TypeAdapter.validate({:map, {:string, :integer}}, %{"a" => 1})
    end
    
    test "handles type coercion" do
      assert {:ok, 123} = TypeAdapter.validate(:integer, "123", coerce: true)
      assert {:ok, "42"} = TypeAdapter.validate(:string, 42, coerce: true)
    end
    
    # Add 9 more tests...
  end
  
  # Add dump and json_schema tests...
end

defmodule Elixact.JsonSchema.ResolverTest do
 use ExUnit.Case, async: true
 
 alias Elixact.JsonSchema.Resolver
 
 describe "resolve_references/2" do
   test "handles simple $ref" do
     schema = %{
       "type" => "object",
       "properties" => %{
         "user" => %{"$ref" => "#/definitions/User"}
       },
       "definitions" => %{
         "User" => %{"type" => "object", "properties" => %{"name" => %{"type" => "string"}}}
       }
     }
     
     resolved = Resolver.resolve_references(schema)
     
     refute Map.has_key?(resolved, "definitions")
     assert get_in(resolved, ["properties", "user", "type"]) == "object"
     assert get_in(resolved, ["properties", "user", "properties", "name", "type"]) == "string"
   end
   
   test "handles nested references" do
     schema = %{
       "type" => "object",
       "properties" => %{
         "company" => %{"$ref" => "#/definitions/Company"}
       },
       "definitions" => %{
         "Company" => %{
           "type" => "object",
           "properties" => %{
             "owner" => %{"$ref" => "#/definitions/User"}
           }
         },
         "User" => %{"type" => "object", "properties" => %{"name" => %{"type" => "string"}}}
       }
     }
     
     resolved = Resolver.resolve_references(schema)
     
     refute Map.has_key?(resolved, "definitions")
     assert get_in(resolved, ["properties", "company", "properties", "owner", "type"]) == "object"
   end
   
   test "prevents circular references" do
     schema = %{
       "type" => "object",
       "properties" => %{
         "node" => %{"$ref" => "#/definitions/Node"}
       },
       "definitions" => %{
         "Node" => %{
           "type" => "object",
           "properties" => %{
             "child" => %{"$ref" => "#/definitions/Node"}
           }
         }
       }
     }
     
     # Should not crash with circular reference
     resolved = Resolver.resolve_references(schema, max_depth: 2)
     assert is_map(resolved)
   end
 end
 
 describe "enforce_structured_output/2" do
   test "enforces OpenAI requirements" do
     schema = %{"type" => "object", "additionalProperties" => true}
     
     openai_schema = Resolver.enforce_structured_output(schema, provider: :openai)
     
     assert openai_schema["additionalProperties"] == false
     assert Map.has_key?(openai_schema, "properties")
   end
   
   test "enforces Anthropic requirements" do
     schema = %{"type" => "object", "properties" => %{"name" => %{"type" => "string"}}}
     
     anthropic_schema = Resolver.enforce_structured_output(schema, provider: :anthropic)
     
     assert anthropic_schema["additionalProperties"] == false
     assert Map.has_key?(anthropic_schema, "required")
   end
   
   test "removes unsupported formats for OpenAI" do
     schema = %{
       "type" => "object",
       "properties" => %{
         "email" => %{"type" => "string", "format" => "email"}
       }
     }
     
     openai_schema = Resolver.enforce_structured_output(schema, provider: :openai)
     
     refute Map.has_key?(openai_schema["properties"]["email"], "format")
   end
 end
 
 describe "flatten_schema/2" do
   test "expands references inline" do
     schema = %{
       "type" => "object",
       "properties" => %{
         "user" => %{"$ref" => "#/definitions/User"}
       },
       "definitions" => %{
         "User" => %{"type" => "string"}
       }
     }
     
     flattened = Resolver.flatten_schema(schema)
     
     assert get_in(flattened, ["properties", "user", "type"]) == "string"
     refute Map.has_key?(flattened, "definitions")
   end
   
   test "handles array items" do
     schema = %{
       "type" => "array",
       "items" => %{"$ref" => "#/definitions/Item"},
       "definitions" => %{
         "Item" => %{"type" => "string", "minLength" => 1}
       }
     }
     
     flattened = Resolver.flatten_schema(schema)
     
     assert flattened["items"]["type"] == "string"
     assert flattened["items"]["minLength"] == 1
   end
 end
 
 describe "optimize_for_llm/2" do
   test "removes descriptions when requested" do
     schema = %{
       "type" => "object",
       "description" => "A user object",
       "properties" => %{
         "name" => %{"type" => "string", "description" => "User's name"}
       }
     }
     
     optimized = Resolver.optimize_for_llm(schema, remove_descriptions: true)
     
     refute Map.has_key?(optimized, "description")
     refute Map.has_key?(optimized["properties"]["name"], "description")
   end
   
   test "simplifies large unions" do
     schema = %{
       "oneOf" => [
         %{"type" => "string"},
         %{"type" => "integer"},
         %{"type" => "boolean"},
         %{"type" => "array"},
         %{"type" => "object"}
       ]
     }
     
     optimized = Resolver.optimize_for_llm(schema, simplify_unions: true)
     
     assert length(optimized["oneOf"]) == 3
   end
 end
end