scout-ai 1.2.5 → 2.0.0

data/test/scout/llm/agent/test_save.rb

@@ -0,0 +1,413 @@
+require File.expand_path(__FILE__).sub(%r(/test/.*), '/test/test_helper.rb')
+require 'scout/llm/agent'
+
+class TestLLMAgentSave < Test::Unit::TestCase
+  def setup
+    super
+    @dir = File.join(tmpdir, 'save_tests')
+    FileUtils.mkdir_p @dir
+  end
+
+  def simple_agent(content = 'you are a robot')
+    agent = LLM::Agent.new
+    agent.start_chat.system content
+    agent
+  end
+
+  def chat_files_under(dir)
+    Dir.glob(File.join(dir, '**', '*.chat')).sort
+  end
+
+  def test_society_dir_for
+    assert_equal 'a/b/c.society',
+                 LLM::Agent.society_dir_for('a/b/c.chat')
+    assert_equal 'a/b/worker.society',
+                 LLM::Agent.society_dir_for('a/b/worker.chat')
+    assert_equal './c.society',
+                 LLM::Agent.society_dir_for('c.chat')
+    agent = LLM::Agent.new
+    assert_equal 'a/b/c.society',
+                 agent.society_dir_for('a/b/c.chat')
+  end
+
+  def test_society_dir_by_location
+    agent = LLM::Agent.new
+
+    nested = 'a/society/Worker/w_1/agent.chat'
+    # A nested agent.chat nests its society as a SIBLING directory, never a
+    # second `.files` tree of its own, however the save was triggered.
+    assert_equal 'a/society/Worker/w_1/society', agent.society_dir(nested)
+    assert agent.nested_save?(nested)
+
+    assert_equal 'a/b/c.society', agent.society_dir('a/b/c.chat')
+    assert !agent.nested_save?('a/b/c.chat')
+  end
+
+  def test_save_explicit_path_writes_only_the_chat_file
+    TmpFile.with_dir do |dir|
+      agent = simple_agent
+      agent.user 'hello'
+
+      chat_file = File.join(dir, 'conversation.chat')
+      written = agent.save(chat_file)
+
+      assert_equal [File.expand_path(chat_file)], written
+      assert Open.exist?(chat_file)
+      assert_include Open.read(chat_file), 'hello'
+
+      # Lazy: no society, so no .files sidecar tree at all
+      assert !Open.exist?(chat_file + '.files')
+    end
+  end
+
+  def test_save_without_path_uses_save_file
+    TmpFile.with_dir do |dir|
+      agent = simple_agent
+      agent.user 'stored'
+
+      chat_file = File.join(dir, 'auto.chat')
+      agent.save_file = chat_file
+
+      assert_equal [File.expand_path(chat_file)], agent.save
+      assert_include Open.read(chat_file), 'stored'
+    end
+  end
+
+  def test_save_without_path_raises_when_unconfigured
+    agent = simple_agent
+    agent.user 'orphan'
+
+    assert_raise ScoutException do
+      agent.save
+    end
+  end
+
+  def test_save_nested_society
+    TmpFile.with_dir do |dir|
+      root = simple_agent('root')
+      root.user 'root question'
+
+      child = simple_agent('child')
+      child.user 'child question'
+      root.chats = { 'Worker/w_A' => child }
+
+      grandchild = simple_agent('grandchild')
+      grandchild.user 'grandchild question'
+      child.chats = { 'Critic/c_1' => grandchild }
+
+      chat_file = File.join(dir, 'root.chat')
+      written = root.save(chat_file)
+
+      expected_child = File.join(chat_file.sub(/\.chat\z/, '.society'), 'Worker', 'w_A', 'agent.chat')
+      expected_grandchild = File.join(chat_file.sub(/\.chat\z/, '.society'), 'Worker', 'w_A', 'society', 'Critic', 'c_1', 'agent.chat')
+
+      assert_equal [chat_file, expected_child, expected_grandchild].collect { |p| File.expand_path(p) }.sort, written
+
+      assert_include Open.read(expected_child), 'child question'
+      assert_include Open.read(expected_grandchild), 'grandchild question'
+
+      # child learned its own save_file for later independent auto-saves
+      assert_equal expected_child, child.save_file
+      assert_equal expected_grandchild, grandchild.save_file
+    end
+  end
+
+  def test_save_cyclic_society_terminates
+    TmpFile.with_dir do |dir|
+      a = simple_agent('a')
+      a.user 'a question'
+      b = simple_agent('b')
+      b.user 'b question'
+
+      a.chats = { 'Other/current' => b }
+      b.chats = { 'First/current' => a }
+
+      chat_file = File.join(dir, 'cycle.chat')
+      written = a.save(chat_file)
+
+      expected_b = File.join(chat_file.sub(/\.chat\z/, '.society'), 'Other', 'current', 'agent.chat')
+      assert_equal [chat_file, expected_b].collect { |p| File.expand_path(p) }.sort, written
+
+      # The tree is finite: b was saved once and going back to a was cut by
+      # the seen-agent check, so nothing was written twice.
+      assert_equal 1, chat_files_under(chat_file.sub(/\.chat\z/, '.society')).length
+    end
+  end
+
+  def test_save_skips_dead_entries
+    TmpFile.with_dir do |dir|
+      agent = simple_agent
+      agent.chats = { 'Worker/w_1' => nil, 'no-slash' => simple_agent, '/lead' => simple_agent }
+
+      chat_file = File.join(dir, 'dead.chat')
+      written = agent.save(chat_file)
+
+      assert_equal [File.expand_path(chat_file)], written
+    end
+  end
+
+  def test_save_sanitizes_weird_names
+    TmpFile.with_dir do |dir|
+      agent = simple_agent
+      bad = simple_agent('weird')
+      bad.user 'weird question'
+
+      agent.chats = { '../evil/name' => bad }
+
+      chat_file = File.join(dir, 'sanitized.chat')
+      written = agent.save(chat_file)
+
+      # '..' collapses to '_' and the '/' inside the conversation is
+      # replaced, so the file stays inside the society directory
+      weird_file = File.join(chat_file.sub(/\.chat\z/, '.society'), '__', 'evil_name', 'agent.chat')
+      assert_include written.collect { |p| File.expand_path(p) },
+                     File.expand_path(weird_file)
+      assert !Open.exist?(File.join(dir, 'name', 'agent.chat'))
+    end
+  end
+
+  def test_auto_save_after_ask
+    TmpFile.with_dir do |dir|
+      LLM::Mock.script('mock answer')
+
+      agent = simple_agent
+      chat_file = File.join(dir, 'auto_save.chat')
+      agent.save_file = chat_file
+
+      agent.user 'auto question'
+      res = agent.chat persist: false, endpoint: 'mock'
+
+      assert_equal 'mock answer', res
+      content = Open.read(chat_file)
+      assert_include content, 'auto question'
+      assert_include content, 'mock answer'
+    end
+  end
+
+  def test_child_auto_save_keeps_canonical_layout
+    TmpFile.with_dir do |dir|
+      LLM::Mock.script('mock answer')
+
+      root = simple_agent('root')
+      root.user 'root question'
+
+      child = simple_agent('child')
+      child.user 'child question'
+      root.chats = { 'Worker/w_A' => child }
+
+      chat_file = File.join(dir, 'root.chat')
+      root.save(chat_file)
+
+      child_file = File.join(chat_file.sub(/\.chat\z/, '.society'), 'Worker', 'w_A', 'agent.chat')
+      assert_equal child_file, child.save_file
+
+      # The child runs its own turn later (its own auto-save, no parent save):
+      # the answer must land in the child chat file and the grandchild must
+      # go to the SIBLING society dir, never to <child_file>.files/...
+      grandchild = simple_agent('grandchild')
+      grandchild.user 'grandchild question'
+      child.chats = { 'Critic/c_1' => grandchild }
+
+      child.chat persist: false, endpoint: 'mock'
+
+      assert_include Open.read(child_file), 'mock answer'
+
+      assert Open.exist?(File.join(File.dirname(child_file), 'society', 'Critic', 'c_1', 'agent.chat'))
+      assert !Open.exist?(child_file + '.files')
+      assert !Dir.glob(File.join(chat_file + '.files', '**', 'agent.chat.files')).any?
+    end
+  end
+
+  # A bare agent.ask round does not grow current_chat, so it must NOT
+  # auto-save: the auto-save hook fires on Agent#chat, not on ask.
+  def test_no_auto_save_after_bare_ask
+    TmpFile.with_dir do |dir|
+      # Plain-string script: no tool calls, so the round is a single
+      # assistant answer that never enters Agent#chat.
+      LLM::Mock.script('mock answer')
+
+      agent = simple_agent
+      chat_file = File.join(dir, 'ask_save.chat')
+      agent.save_file = chat_file
+      agent.user 'bare question'
+
+      assert_include agent.ask(agent.current_chat, persist: false, endpoint: :mock), 'mock answer'
+
+      # Bare ask: the chat was not grown by Agent#chat, so no file anywhere
+      assert !Open.exist?(chat_file)
+      assert_equal [], Dir.glob(File.join(dir, '**', '*.chat'))
+    end
+  end
+
+  # The chat path does persist growth: a round with a delegated tool call
+  # grows current_chat inside Agent#chat (function_call /
+  # function_call_output plus the answer), so the auto-save fires, and the
+  # delegated child conversation is saved with it into the society tree.
+  def test_auto_save_after_tool_round_via_chat
+    TmpFile.with_dir do |dir|
+      LLM::Mock.script([
+        {tool_calls: [{name: 'ask', arguments: {agent: 'Worker', prompt: 'hi'}}]},
+        'final answer'
+      ])
+
+      agent = simple_agent('root')
+      worker = simple_agent('worker')
+      agent.society = { 'Worker' => worker }
+      agent.socialize
+
+      chat_file = File.join(dir, 'tool_round.chat')
+      agent.save_file = chat_file
+      agent.user 'tool question'
+
+      assert_equal 'final answer', agent.chat(persist: false, endpoint: 'mock')
+
+      # The parent chat file holds the tool round and its answer
+      content = Open.read(chat_file)
+      assert_include content, 'tool question'
+      assert_include content, 'function_call'
+      assert_include content, 'final answer'
+
+      # The delegated child conversation was saved with it, lazily, under the
+      # canonical society layout
+      child_file = File.join(chat_file.sub(/\.chat\z/, '.society'), 'Worker', 'default', 'agent.chat')
+      assert Open.exist?(child_file)
+      assert_include Open.read(child_file), 'hi'
+    end
+  end
+
+  def test_no_auto_save_without_save_file
+    TmpFile.with_dir do |dir|
+      LLM::Mock.script('mock answer')
+
+      agent = simple_agent
+      agent.user 'volatile question'
+      agent.chat persist: false, endpoint: 'mock'
+
+      assert !Open.exist?(File.join(dir, 'never.chat'))
+      assert_equal [], Dir.glob(File.join(dir, '**', '*.chat'))
+    end
+  end
+
+  def test_restart_snapshot
+    TmpFile.with_dir do |dir|
+      agent = simple_agent
+      chat_file = File.join(dir, 'restarts.chat')
+      agent.save_file = chat_file
+
+      agent.user 'before restart'
+      agent.save
+
+      resets_dir = chat_file + '.files/resets'
+      assert !Open.exist?(resets_dir)
+
+      agent.start
+
+      assert Open.exist?(resets_dir)
+      snapshots = Dir.glob(File.join(resets_dir, '*.chat'))
+      assert_equal 1, snapshots.length
+      assert_include File.basename(snapshots.first), '.chat'
+      assert_include Open.read(snapshots.first), 'before restart'
+    end
+  end
+
+  def test_no_restart_snapshot_without_prior_chat
+    TmpFile.with_dir do |dir|
+      agent = simple_agent
+      chat_file = File.join(dir, 'fresh.chat')
+      agent.save_file = chat_file
+
+      agent.start
+
+      assert !Open.exist?(chat_file + '.files/resets')
+      assert !Open.exist?(chat_file + '.files')
+    end
+  end
+end
+
+# Step 3b: Agent#society_save_file (private, delegate.rb) must derive the
+# society directory with the CANONICAL rule (Agent.society_dir_for /
+# Agent#society_dir), never by unanchored string substitution on save_file.
+#
+# The bug: `"cli.chat.files/agent.chat".sub(/\.chat/, '.society')` replaces
+# the FIRST '.chat' and yields `cli.society.files/agent.chat/...`, growing a
+# second `.files` tree instead of `cli.chat.files/agent.society/...`.
+class TestLLMAgentSocietySaveFile < Test::Unit::TestCase
+  def simple_agent(content = 'you are a robot')
+    agent = LLM::Agent.new
+    agent.start_chat.system content
+    agent
+  end
+
+  # --- direct (private method, called through send) -----------------------
+
+  def test_society_save_file_is_nil_without_save_file
+    agent = LLM::Agent.new
+    # save.rb simply does not auto-save without a save_file; the delegation
+    # must mirror that instead of raising on nil (assigning nil to
+    # agent.save_file is harmless: it means "no auto-save").
+    assert_nil agent.send(:society_save_file, 'Direct', 'harness_test')
+  end
+
+  def test_society_save_file_cli_shaped_save_file
+    agent = LLM::Agent.new
+    agent.save_file = 'dir/cli.chat.files/agent.chat'
+    assert_equal 'dir/cli.chat.files/agent.society/Direct/harness_test/agent.chat',
+                 agent.send(:society_save_file, 'Direct', 'harness_test')
+  end
+
+  def test_society_save_file_cli_shaped_named_agent
+    agent = LLM::Agent.new
+    agent.save_file = 'dir/job.chat.files/worker.chat'
+    assert_equal 'dir/job.chat.files/worker.society/Direct/harness_test/agent.chat',
+                 agent.send(:society_save_file, 'Direct', 'harness_test')
+  end
+
+  def test_society_save_file_plain_root_chat
+    agent = LLM::Agent.new
+    agent.save_file = 'dir/root.chat'
+    assert_equal 'dir/root.society/Direct/harness_test/agent.chat',
+                 agent.send(:society_save_file, 'Direct', 'harness_test')
+  end
+
+  def test_society_save_file_nested_child_save_file
+    agent = LLM::Agent.new
+    # A child chat already living inside a society tree resolves through the
+    # location rule: the society of a nested chat is a SIBLING 'society' dir.
+    agent.save_file = 'dir/root.chat.files/root.society/Direct/harness_test/agent.chat'
+    assert_equal 'dir/root.chat.files/root.society/Direct/harness_test/society/Nested/default/agent.chat',
+                 agent.send(:society_save_file, 'Nested', 'default')
+  end
+
+  # --- public behavior ----------------------------------------------------
+
+  # load_chat hands the specialist its save_file derived from the PARENT's
+  # save_file: this is the path the CLI and chat_task jobs take.
+  def test_load_chat_assigns_canonical_child_save_file
+    TmpFile.with_dir do |dir|
+      root = simple_agent('root')
+      worker = simple_agent('worker')
+      root.society = {'Worker' => worker}
+      root.socialize
+
+      root.save_file = File.join(dir, 'cli.chat.files', 'agent.chat')
+      child = root.load_chat('Worker', {}, 'harness_test')
+
+      expected = File.join(dir, 'cli.chat.files', 'agent.society',
+                           'Worker', 'harness_test', 'agent.chat')
+      assert_equal expected, child.save_file
+
+      # Writing through the child must not grow any second `.files` tree and
+      # must not leave a stray `cli.society.files` directory behind.
+      LLM::Mock.script('mock answer')
+      child.user 'child question'
+      child.chat persist: false, endpoint: 'mock'
+
+      assert_include Open.read(expected), 'mock answer'
+      assert_empty Dir.glob(File.join(dir, '**', '*.society.files*'))
+      assert_empty Dir.glob(File.join(dir, '**', 'cli.society*'))
+      # The child auto-save is the only writer here (the root itself never
+      # ran a round), so the canonical child file is the ONLY chat file.
+      assert_equal [expected], Dir.glob(File.join(dir, '**', '*.chat')).sort
+    end
+  end
+end

data/test/scout/llm/agent/test_workflow.rb

@@ -0,0 +1,110 @@
+require File.expand_path(__FILE__).sub(%r(/test/.*), '/test/test_helper.rb')
+require File.expand_path(__FILE__).sub(%r(.*/test/), '').sub(/test_(.*)\.rb/,'\1')
+
+class TestWorkflowChatTaskSave < Test::Unit::TestCase
+  # NOTE on setup order: test_helper's `setup do` callback runs AFTER this
+  # `setup` method and does `Open.rm_rf tmpdir`, i.e. it deletes every
+  # directory under tmp/test_tmpdir — including any cwd we adopted here. So
+  # we must NOT Dir.chdir into a tmpdir-based directory, or every later
+  # FileUtils.pwd / Path.follow call raises Errno::ENOENT (getcwd) once the
+  # hook has removed it. The workflow does not depend on a particular cwd,
+  # so we only point the module's job directory at a fresh work dir (created
+  # with Open.mkdir so it exists regardless of Path semantics) and keep the
+  # process cwd untouched.
+  def setup
+    @tmp_work = Path.setup(File.join(TmpFile.tmpdir, 'workflow_chat_task_save'))
+    Open.mkdir @tmp_work
+    TestWorkflowChatTaskSaveWF.directory = @tmp_work
+  end
+
+  def teardown
+    FileUtils.rm_rf @tmp_work if File.exist?(@tmp_work)
+  end
+
+  def run_job(dir, task)
+    TestWorkflowChatTaskSaveWF.directory = Path.setup(dir)
+    job = TestWorkflowChatTaskSaveWF.job(task, chat: '')
+    job.produce
+    job
+  end
+
+  module TestWorkflowChatTaskSaveWF
+    extend Workflow
+    # `extend AgentWorkflow` alone does NOT copy the helper blocks into this
+    # module's helpers hash, so Workflow#job would extend the Step with an
+    # empty step_module and `log_agent` would be missing at run time.
+    # include_workflow merges the helpers (and tasks) properly.
+    include_workflow AgentWorkflow
+
+    self.name = 'TestWorkflowChatTaskSaveWF'
+
+    chat_task :plain do
+      LLM::Agent.new(start_chat: Chat.setup([{role: :system, content: 'You are a helper.'}, {role: :user, content: 'Say hi'}]))
+    end
+
+    chat_task :with_chat do
+      agent = LLM::Agent.new(start_chat: Chat.setup([{role: :system, content: 'You are a helper.'}]))
+      agent.user 'question one'
+      agent.current_chat.push({role: :assistant, content: 'answer one'})
+      agent
+    end
+  end
+
+  def test_no_files_without_society
+    job = run_job(TmpFile.tmpdir, :plain)
+    path = job.path
+    # The unified provenance save ALWAYS writes this job agent's own chat at
+    # `<path>.files/log/agent.chat` (that is the point of the mechanism);
+    # only the society subtree stays lazy and appears with a live society.
+    assert File.exist?("#{path}.files/agent.chat")
+    assert !File.exist?("#{path}.files/agent.society")
+  end
+
+  def test_canonical_layout_no_society
+    job = run_job(TmpFile.tmpdir, :with_chat)
+    path = job.path
+    # files_dir is the SUFFIXED sibling `<path>.files`, not a subdirectory
+    agent_chat = File.join("#{path}.files", 'agent.chat')
+    assert Open.exist?(agent_chat)
+    saved = LLM.chat(agent_chat)
+    assert_equal 'You are a helper.', saved.first[:content]
+    assert saved.any? { |m| m[:role] == 'assistant' && m[:content] == 'answer one' }
+    assert !File.exist?(File.join("#{path}.files", 'agent.society'))
+  end
+
+  def test_nested_society_layout
+    TmpFile.with_dir do |dir|
+      # ask_agent builds the specialist from this agent's society when the
+      # name is already there (LLM.load_agent would otherwise fail: there is
+      # no 'Worker' installed anywhere for these tests).
+      worker = LLM::Agent.new(start_chat: Chat.setup([{role: :system, content: 'child helper'}]))
+      LLM::Mock.script('child answer')
+
+      agent = LLM::Agent.new(start_chat: Chat.setup([{role: :system, content: 'parent'}]))
+      agent.society = { 'Worker' => worker }
+      agent.save_file = File.join(dir, 'agent.chat')
+      agent.user 'question'
+      child = agent.ask_agent('Worker', 'child prompt', options: {endpoint: 'mock'})
+      agent.current_chat.push({role: :assistant, content: 'final answer'})
+
+      written = agent.save
+      # ask_agent without a conversation argument lands in the 'default'
+      # conversation slot
+      nested = File.join(dir, 'agent.society', 'Worker', 'default', 'agent.chat')
+      assert_include written, File.expand_path(nested)
+      assert Open.exist?(nested)
+      assert !File.exist?(File.join(dir, 'nested.files'))
+    end
+  end
+
+  def test_chat_task_result_delta_preserved
+    job = run_job(TmpFile.tmpdir, :with_chat)
+    result = LLM.chat(job.path)
+    # The job result is a Chat projection: it legitimately starts with the
+    # provenance meta header (job=...). The delta assertions apply to the
+    # conversation messages themselves.
+    delta = result.reject { |m| m[:role].to_s == 'meta' }
+    assert_include delta.first[:content], 'question one'
+    assert_include delta.last[:content], 'answer one'
+  end
+end

data/test/scout/llm/backends/test_anthropic.rb

@@ -10,22 +10,105 @@ user: say hi
     ppp LLM::Anthropic.ask prompt
   end
 
-  def _test_ask
+  # ScoutCoder: Anthropic has no embeddings endpoint; the backend raises
+  # from embed_query, so the offline contract is the exception, not a vector.
+  def test_embeddings
+    assert_raise(RuntimeError) { LLM::Anthropic.embed 'Some text', log_errors: false, model: 'embedding-model' }
+  end
+
+  def test_ask
+    client = TestFixtures.anthropic_client('backends/anthropic')
+    res = LLM::Anthropic.ask 'user: write a script that sorts files in a directory',
+                             client: client, model: 'claude-sonnet-4-5', persist: false
+
+    assert_equal 'Mock answer from Anthropic messages', res
+    assert_equal 1, client.calls.length
+    assert_equal 'claude-sonnet-4-5', client.calls.first[:model]
+    assert client.calls.first[:messages].any? { |m| m[:role].to_s == 'user' }
+  end
+
+  def test_tool_call_output_weather
+    Log.severity = 0
     prompt =<<-EOF
-user: write a script that sorts files in a directory
+function_call:
+
+{"name":"get_current_temperature", "arguments":{"location":"London","unit":"Celsius"},"id":"tNTnsQq2s6jGh0npOh43AwDD"}
+
+function_call_output:
+
+{"id":"tNTnsQq2s6jGh0npOh43AwDD", "content":"It's 15 degrees and raining."}
+
+user:
+
+should i take an umbrella?
     EOF
-    sss 0
-    ppp LLM::Anthropic.ask prompt
+    client = TestFixtures.anthropic_client('backends/anthropic')
+    res = LLM::Anthropic.ask prompt, client: client, persist: false
+
+    assert_equal 'Mock answer from Anthropic messages', res
+    # ScoutCoder: the Anthropic backend rewrites the function_call /
+    # function_call_output pair into content array items (tool_use /
+    # tool_result) instead of separate messages.
+    sent = client.calls.first[:messages]
+    assert sent.any? { |m| m[:role].to_s == 'user' }
+    assert sent.inspect.include?('tool_result')
   end
 
-  def test_embeddings
-    Log.severity = 0
-    text =<<-EOF
-Some text
+  def test_tool
+    prompt =<<-EOF
+user:
+What is the weather in London. Should I take my umbrella?
     EOF
-    emb = LLM::Anthropic.embed text, log_errors: true, model: 'embedding-model'
 
-    assert(Float === emb.first)
+    tools = [
+      {
+        "type": "custom",
+        "name": "get_current_temperature",
+        "description": "Get the current temperature and raining conditions for a specific location",
+        "parameters": {
+          "type": "object",
+          "properties": {
+            "location": {
+              "type": "string",
+              "description": "The city and state, e.g., San Francisco, CA"
+            },
+            "unit": {
+              "type": "string",
+              "enum": ["Celsius", "Fahrenheit"],
+              "description": "The temperature unit to use. Infer this from the user's location."
+            }
+          },
+          "required": ["location", "unit"]
+        }
+      },
+    ]
+
+    client = TestFixtures.anthropic_client('backends/anthropic_tool_use', 'backends/anthropic')
+    respose = LLM::Anthropic.ask prompt, tools: tools,
+                                 client: client, log_errors: true, persist: false do |name,arguments|
+      "It's 15 degrees and raining."
+    end
+
+    assert_equal 'Mock answer from Anthropic messages', respose
+    assert_equal 2, client.calls.length
+
+    # ScoutCoder: LLM::Anthropic#format_tool_definitions renames
+    # `parameters` -> `input_schema` and forces type 'custom'.
+    sent_tools = client.calls.first[:tools]
+    assert sent_tools.any? { |t| (t[:name] || t['name']) == 'get_current_temperature' }
+    assert sent_tools.all? { |t| (t[:input_schema] || t['input_schema']) }
+    assert sent_tools.all? { |t| (t[:type] || t['type']).to_s == 'custom' }
+  end
+
+  def test_json_output
+    client = TestFixtures.anthropic_client('backends/anthropic')
+    res = LLM::Anthropic.ask 'user: What other movies have the protagonists of the original gost busters played on, just the top.',
+                             format: :json, client: client, persist: false
+
+    assert_equal 'Mock answer from Anthropic messages', res
+    # ScoutCoder: Anthropic takes a response_format hash, not the string key
+    # the OpenAI backends use.
+    assert client.calls.first.inspect.include?('json_object')
   end
 
   def _test_tool_call_output_2