claude-agent-sdk 1.4.2 → 1.4.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: e818247c70aeb869293f08c2ae18750d4fdc03ac3caa77c3f40be464df2ed8d6
-  data.tar.gz: 3e29b5ea072ad2514ec3949efd1fa5dd339085d5859ac597fd2b4e1c44548ac2
+  metadata.gz: bb80b64b04c7a08624103b5ebf09504a42f20bd42d8587e23a10761dffa54d7e
+  data.tar.gz: 80dbdc35d394a22bbe20f5db952044cf82668e5c12c3eb98de2cb454779f6741
 SHA512:
-  metadata.gz: 166b250491fc219607048dfe81a349002c2c206bb2f3838b566b6b7431215ffd2ad83f634baa94ea757c0b719559dd8c0d3f488b5152479f6c1ebec5013f6f0e
-  data.tar.gz: 69abc6fbb88df26a6d74a7f348a07f83fa7010df39f0f031d7d3ba39d5fdf083706b305f5561a072d84fbfe9e09eec6f2eb6e7e80b4f20b3600a6357707c8d1b
+  metadata.gz: 355f4fd5d1163e46b922be4c8320b6d3ede6a916d7dd2b732aa70dc955d924411e0cb19b87b86b76c1a2cd4cdd3fc0d4fc1599605b60b6b88b7cbb70518c3f1d
+  data.tar.gz: a9e98c5026f9b04ac4a50b39c665cebc6e6b29058a8db8050a6293fc3aa49044c20cb5a48bddf3b6ccd0636031a79a86377b95fca8f684b2af2bb909cd9c558b

data/CHANGELOG.md

@@ -7,6 +7,17 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## [Unreleased]
 
+## [1.4.3] - 2026-10-28
+
+Syncs with Python SDK 0.2.174 (previously 0.2.162). Python #1331 and #1332 were already in 1.2.0, and `SandboxSettings#ignore_violations` already took the command-pattern Hash that Python #1380 fixed its type to; every other release in the range only bumps the CLI Python bundles.
+
+### Fixed
+- **`get_session_messages` and `get_subagent_messages` (disk and `session_store:`) no longer drop the tool calls of a parallel batch** (Python SDK #1422). The conversation goes on from the tool result written last. When that result answers an earlier call of the batch than the last one, the `tool_use` entries written after that call were off the path the readers walk, so 1.2.0's fix (#157) never saw them: the readers returned neither those calls nor their results. Of the parallel batches in one developer's local transcripts, about 7% have this shape. The readers now put back every entry of an API message on the conversation, right after its last entry there (in timestamp order), then the results as before. A result that the CLI parented on a hook attachment instead of its call's entry (its `sourceToolAssistantUUID` still names the call) is put back as well, when the same agent wrote both. The guards from #157 hold: the chain's own result wins, at most one result comes back per call, and the result of a branch a rewind dropped stays out. That last guard was also too wide on real transcripts, and missed results #157 meant to return: going on from a result no longer counts as a dropped branch when what goes on is a later call of the same batch, another result of the batch (the CLI sometimes parents one under an earlier result's hook attachment), or a meta entry (the `[Image: ...]` note the CLI writes under a screenshot result). A branch that goes on through a meta entry or through another result of the batch is still recognized. Affected sessions return more messages than before, so `offset:`/`limit:` pages over them shift. Python fixes the main-session readers only; here both readers are fixed.
+
+### Changed
+- `docs/options.md`: `include_hook_events` does not turn off the `SessionStart` and `Setup` hook events, which the CLI sends whether or not it is set (Python SDK #1336).
+- `CLIInstaller::PINNED_CLI_VERSION` moves from 2.1.295 to **2.1.311**, following the CLI the Python SDK bundles. `CLIInstaller.install_pinned` installs it. See the [Claude Code changelog](https://github.com/anthropics/claude-code/blob/main/CHANGELOG.md).
+
 ## [1.4.2] - 2026-10-27
 
 ### Fixed

data/docs/options.md

@@ -158,7 +158,7 @@ Asks the CLI for partial message chunks while the model is still producing a mes
 
 ### `include_hook_events`
 
-Asks the CLI to put all hook lifecycle events into the message stream, as `HookStartedMessage`, `HookProgressMessage` and `HookResponseMessage` (see [System and progress messages](types.md#system-and-progress-messages)). It only adds messages: the callbacks you register with `hooks` are called whether or not it is set.
+Asks the CLI to put all hook lifecycle events into the message stream, as `HookStartedMessage`, `HookProgressMessage` and `HookResponseMessage` (see [System and progress messages](types.md#system-and-progress-messages)). It only adds messages: the callbacks you register with `hooks` are called whether or not it is set. It does not turn any off either: the CLI sends the events of `SessionStart` and `Setup` hooks whether or not it is set.
 
 ## The CLI process
 

data/lib/claude_agent_sdk/cli_installer.rb

@@ -53,7 +53,7 @@ module ClaudeAgentSDK
     # Single source of truth: bumped here (and only here) by
     # .github/workflows/cli-pin-bump.yml or a Python-sync release, so a
     # Dependabot bump of the gem carries the CLI forward with it.
-    PINNED_CLI_VERSION = '2.1.295'
+    PINNED_CLI_VERSION = '2.1.311'
     # @api private
     BINARY_NAME = 'claude'
     # @api private

data/lib/claude_agent_sdk/sessions.rb

@@ -2037,25 +2037,29 @@ module ClaudeAgentSDK
       %w[user assistant].include?(entry['type']) && !off_main_conversation?(entry)
     end
 
-    # Put the results of parallel tool calls back on a leaf-to-root chain.
+    # Put the tool calls and results of parallel tool calls back on a
+    # leaf-to-root chain.
     #
-    # The CLI writes one assistant entry per tool_use block (chained through
-    # parentUuid) and parents every tool_result on the entry that holds ITS
-    # tool_use. With two or more calls in one API message, only the result
-    # the conversation continued from is an ancestor of the leaf; the others
-    # are siblings of the next tool_use entry, and a single-path walk returns
-    # their tool_use without them.
+    # The CLI writes one assistant entry per content block (they share
+    # message.id) and parents every tool_result on the entry that holds ITS
+    # tool_use. With two or more calls in one API message the transcript
+    # forks: the conversation goes on from the result written last, and a
+    # single-path walk keeps only that branch. When that result answers an
+    # earlier call, the tool_use entries written after it are off the path
+    # too, results and all (Python #1422).
     #
-    # For each assistant entry on the chain, take its user children that are
-    # not on the chain and carry a tool_result for a tool_use on the chain,
-    # and insert them — in file order — before the next user entry of the
-    # chain (the batch's own on-chain result), or at the end when the chain
-    # has none. The anchor, not the raw file position, decides the place: a
-    # result that arrived after the conversation had already moved on to a
-    # further tool_use of the same message still lands with its batch, so
-    # every result follows the assistant turn that asked for it.
+    # So first the off-chain entries of every API message on the chain go
+    # back in, right after that message's last entry on the chain
+    # (insert_parallel_siblings). Then, for each assistant entry, the results
+    # off the chain that answer one of its calls are inserted — in file order
+    # — before the next user entry of the chain (the batch's own on-chain
+    # result), or at the end when the chain has none. The anchor, not the raw
+    # file position, decides the place: a result that arrived after the
+    # conversation had already moved on to a further tool_use of the same
+    # message still lands with its batch, so every result follows the
+    # assistant turn that asked for it.
     #
-    # The tool_use_id match is what keeps other user siblings out: a prompt
+    # The tool_use_id match is what keeps other user entries out: a prompt
     # abandoned by a rewind is a second child of a chain entry too, and
     # starts a branch that was dropped — and so is the old result of a call
     # the conversation was rewound to and answered again: the chain's own
@@ -2067,6 +2071,7 @@ module ClaudeAgentSDK
     # rejects sidechain / meta / team entries (main transcripts; a subagent
     # transcript is sidechain throughout).
     def reattach_parallel_tool_results(chain, entries, skip_flagged:)
+      chain = insert_parallel_siblings(chain, entries, skip_flagged)
       off_chain = off_chain_tool_results(chain, entries, skip_flagged)
       return chain if off_chain.empty?
 
@@ -2083,29 +2088,79 @@ module ClaudeAgentSDK
       placed.concat(pending.sort_by(&:first).map(&:last))
     end
 
-    # { uuid of an assistant entry on the chain => [[file position, entry], ...] }
-    # for the off-chain user children reattach_parallel_tool_results places.
-    def off_chain_tool_results(chain, entries, skip_flagged) # rubocop:disable Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity -- one filter per condition of the re-attachment rule
+    # The chain with the off-chain assistant entries of each API message on
+    # it inserted after that message's last entry on the chain, in timestamp
+    # order (file order on a tie, as Python's stable sort). Only a message
+    # the chain holds is completed: an earlier attempt at the same turn is a
+    # different API message and stays out.
+    def insert_parallel_siblings(chain, entries, skip_flagged)
+      recovered = off_chain_siblings(chain, entries, skip_flagged)
+      return chain if recovered.empty?
+
+      chain.flat_map do |entry|
+        siblings = recovered.fetch(entry['uuid'], {}).values
+        [entry, *siblings.sort_by { |timestamp, position, _| [timestamp, position] }.map(&:last)]
+      end
+    end
+
+    # { uuid of an API message's last entry on the chain => { uuid => [timestamp, file position, entry] } }
+    # for that message's entries off the chain.
+    def off_chain_siblings(chain, entries, skip_flagged)
+      anchors = {} # message.id => uuid of its last entry on the chain
+      chain.each do |entry|
+        message_id = assistant_message_id(entry)
+        anchors[message_id] = entry['uuid'] if message_id
+      end
+      return {} if anchors.empty?
+
+      on_chain = chain.to_set { |entry| entry['uuid'] }
+      recovered = {}
+      entries.each_with_index do |entry, position|
+        anchor = anchors[assistant_message_id(entry)]
+        next if anchor.nil? || on_chain.include?(entry['uuid']) || (skip_flagged && off_main_conversation?(entry))
+
+        # A store can hold a second copy of an entry (a retried mirror batch).
+        (recovered[anchor] ||= {})[entry['uuid']] ||= [entry['timestamp'].to_s, position, entry]
+      end
+      recovered
+    end
+
+    # { uuid of the assistant entry a result belongs to => [[file position, entry], ...] }
+    # for the off-chain results reattach_parallel_tool_results places. A
+    # result belongs to its parent when that is an assistant entry of the
+    # chain, else to the entry holding the call it answers, if the same agent
+    # wrote both: the CLI sometimes parents a result on a hook attachment
+    # (its sourceToolAssistantUUID still names the call).
+    def off_chain_tool_results(chain, entries, skip_flagged) # rubocop:disable Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/MethodLength, Metrics/PerceivedComplexity -- one filter per condition of the re-attachment rule
       on_chain = Set.new
       assistants = Set.new
-      tool_use_ids = Set.new
+      owners = {} # tool_use id => the chain's assistant entry holding it (nil when two API messages claim it)
       answered = Set.new # tool_use ids the chain's own results answer
       chain.each do |entry|
         on_chain << entry['uuid']
         case entry['type']
         when 'assistant'
           assistants << entry['uuid']
-          tool_use_ids.merge(content_block_values(entry, 'tool_use', 'id'))
+          content_block_values(entry, 'tool_use', 'id').each do |id|
+            owner = owners.fetch(id, entry)
+            owners[id] = owner && assistant_message_id(owner) == assistant_message_id(entry) ? entry : nil
+          end
         when 'user' then answered.merge(content_block_values(entry, 'tool_result', 'tool_use_id'))
         end
       end
-      return {} if (tool_use_ids - answered).empty?
+      return {} if (owners.keys - answered.to_a).empty?
 
-      continued = continued_from(entries)
+      # An entry of the chain going on from a result (the next tool_use of
+      # its batch) is not a branch that went on. Nor is another result for a
+      # call of the chain (the CLI sometimes parents one under an earlier
+      # result's hook attachment) — unless something went on from it in turn.
+      batch = entries.filter_map do |entry|
+        entry['uuid'] if entry['type'] == 'user' && answers_chain_call?(entry, owners)
+      end
+      continued = continued_from(entries, except: on_chain, relay: batch.to_set)
       found = {}
       entries.each_with_index do |entry, position|
-        next unless entry['type'] == 'user' && assistants.include?(entry['parentUuid'])
-        next if on_chain.include?(entry['uuid'])
+        next unless entry['type'] == 'user' && !on_chain.include?(entry['uuid'])
         next if skip_flagged && off_main_conversation?(entry)
         # A result something went on from started a branch that a rewind
         # dropped (the conversation was rewound to the call and went on
@@ -2114,13 +2169,17 @@ module ClaudeAgentSDK
         next if continued.include?(entry['uuid'])
 
         ids = content_block_values(entry, 'tool_result', 'tool_use_id')
-        next if ids.empty? || !ids.all? { |id| tool_use_ids.include?(id) && !answered.include?(id) }
+        next if !answers_chain_call?(entry, owners) || ids.any? { |id| answered.include?(id) }
+
+        anchor = entry['parentUuid'] if assistants.include?(entry['parentUuid'])
+        anchor ||= (owner = owners[ids.first]) && same_writer?(entry, owner) && owner['uuid']
+        next unless anchor
 
         # Claimed: a later result for the same call is not added — nor a
         # second copy of this entry, which a store can hold (a retried mirror
         # batch overlaps the write it retries).
         answered.merge(ids)
-        (found[entry['parentUuid']] ||= []) << [position, entry]
+        (found[anchor] ||= []) << [position, entry]
       end
       found
     end
@@ -2128,21 +2187,64 @@ module ClaudeAgentSDK
     # uuids of the entries a user or assistant entry continues from: its
     # nearest user / assistant ancestor, reached through entries that are
     # neither (hook attachments, system entries) — so a hook attachment
-    # written after an entry does not count as going on from it.
-    def continued_from(entries)
+    # written after an entry does not count as going on from it. Meta
+    # entries count as neither: the CLI writes one under a result itself
+    # (the "[Image: ...]" note of a screenshot), so it does not go on from
+    # the result, and a branch that goes on through one is still found.
+    # Entries whose uuid is in +except+ are not counted as going on; those in
+    # +relay+ only once something goes on from them.
+    def continued_from(entries, except: Set.new, relay: Set.new)
+      parents = goes_on_from(entries, except)
+      continued = Set.new
+      pending = parents.keys.reject { |uuid| relay.include?(uuid) }
+      while (uuid = pending.pop)
+        from = parents[uuid]
+        pending << from if from && continued.add?(from) && relay.include?(from)
+      end
+      continued
+    end
+
+    # { uuid => uuid of the entry it goes on from } for the user and
+    # assistant entries not in +except+ (see continued_from).
+    def goes_on_from(entries, except)
       by_uuid = {}
       entries.each { |entry| by_uuid[entry['uuid']] = entry if entry['uuid'] }
-      continued = Set.new
-      entries.each do |entry|
-        next unless %w[user assistant].include?(entry['type'])
+      entries.each_with_object({}) do |entry, found|
+        next if !goes_on?(entry) || except.include?(entry['uuid'])
 
         seen = Set.new
         parent = by_uuid[entry['parentUuid']]
-        parent = by_uuid[parent['parentUuid']] while parent && !%w[user assistant].include?(parent['type']) &&
-                                                     seen.add?(parent['uuid'])
-        continued << parent['uuid'] if parent && %w[user assistant].include?(parent['type'])
+        parent = by_uuid[parent['parentUuid']] while parent && !goes_on?(parent) && seen.add?(parent['uuid'])
+        found[entry['uuid']] = parent['uuid'] if parent && goes_on?(parent)
       end
-      continued
+    end
+
+    # A user or assistant entry that is not a meta injection: what
+    # continued_from counts as going on.
+    def goes_on?(entry)
+      %w[user assistant].include?(entry['type']) && !entry['isMeta']
+    end
+
+    # Whether an entry carries tool_results, every one for a call +owners+
+    # (tool_use id => the chain's entry holding it) places.
+    def answers_chain_call?(entry, owners)
+      ids = content_block_values(entry, 'tool_result', 'tool_use_id')
+      !ids.empty? && ids.all? { |id| owners[id] }
+    end
+
+    # The API message.id of an assistant entry (nil for any other entry).
+    def assistant_message_id(entry)
+      return unless entry['type'] == 'assistant'
+
+      message = entry['message']
+      message_id = message['id'] if message.is_a?(Hash)
+      message_id if message_id.is_a?(String) && !message_id.empty?
+    end
+
+    # Whether two entries were written by the same agent (the main session,
+    # or one subagent).
+    def same_writer?(entry, other)
+      !entry['isSidechain'] == !other['isSidechain'] && entry['agentId'] == other['agentId']
     end
 
     # Values of +key+ over the +type+ content blocks of an entry's message
@@ -2208,7 +2310,10 @@ module ClaudeAgentSDK
                          :collect_agent_files, :parse_jsonl_entries, :utf8_transcript_text,
                          :build_conversation_chain, :walk_to_leaf, :walk_to_root,
                          :pick_leaf, :visible_ancestor?, :off_main_conversation?, :visible_message?,
-                         :reattach_parallel_tool_results, :off_chain_tool_results,
+                         :reattach_parallel_tool_results, :insert_parallel_siblings, :off_chain_siblings,
+                         :off_chain_tool_results,
+                         :continued_from, :goes_on_from, :goes_on?,
+                         :answers_chain_call?, :assistant_message_id, :same_writer?,
                          :content_block_values,
                          :filter_visible_messages, :build_session_info, :created_at_from_file, :user_entry_texts,
                          :each_line_past_head,

data/lib/claude_agent_sdk/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module ClaudeAgentSDK
-  VERSION = '1.4.2'
+  VERSION = '1.4.3'
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: claude-agent-sdk
 version: !ruby/object:Gem::Version
-  version: 1.4.2
+  version: 1.4.3
 platform: ruby
 authors:
 - ya-luotao
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2026-10-27 00:00:00.000000000 Z
+date: 2026-10-28 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: async