runtype 0.5.0 → 0.11.1

data/lib/runtype/detached_follow.rb

@@ -60,6 +60,18 @@ module Runtype
       seqs.max&.to_s
     end
 
+    # The agent-version keys a dispatch or resume body reports. The events
+    # alias never repeats them, so a followed envelope carries them forward.
+    RELEASE_KEYS = %w[agentVersionId alias agentTargetResolution].freeze
+
+    # @param response [Object]
+    # @return [Hash] the release keys `response` carries, or an empty Hash.
+    def release_fields(response)
+      return {} unless response.is_a?(Hash)
+
+      response.slice(*RELEASE_KEYS).compact
+    end
+
     # @param data [Hash]
     # @return [Boolean]
     def detached_await?(data)

data/lib/runtype/errors.rb

@@ -190,24 +190,58 @@ module Runtype
     end
   end
 
-  # Raised by `ensure_agent(definition, expect_no_changes: true)` when the
-  # platform's definition no longer matches the repo's.
+  # Raised by `ensure_agent(definition, expect_no_changes: true)`, and by the
+  # other `ensure_*` methods, when the platform's definition no longer matches
+  # the repo's.
   class DriftError < Error
     # @return [Hash] the dry-run plan: `"changes"`, `"changedKeys"`,
-    #   `"contentHash"`, `"remoteHash"`, `"agentId"`.
+    #   `"contentHash"`, `"remoteHash"`, and the entity's id.
     attr_reader :plan
 
     # @param plan [Hash]
     # @param name [String, nil]
-    def initialize(plan, name: nil)
+    # @param entity [String] what drifted, e.g. `"Agent"` or `"Flow"`.
+    # @param pull_hint [String] the call that absorbs the remote edit.
+    # @param ensure_hint [String] the method that converges it.
+    def initialize(plan, name: nil, entity: "Agent", pull_hint: "client.pull_agent(name)",
+                   ensure_hint: "ensure_agent")
       @plan = plan
-      changed = Array(plan["changedKeys"]).join(", ")
+      changed = (Array(plan["changedKeys"]) + self.class.skill_changes(plan) + self.class.deployment_changes(plan) +
+                 self.class.publish_changes(plan))
+                .join(", ")
       super(
-        "Agent #{(name || plan["agentId"] || "definition").inspect} drifted: plan is #{plan["changes"].inspect} " \
-        "(changed: #{changed.empty? ? "n/a" : changed}). Run client.pull_agent(name) to absorb the remote edit " \
-        "into your repo, or re-run ensure_agent to converge."
+        "#{entity} #{(name || plan["agentId"] || "definition").inspect} drifted: plan is #{plan["changes"].inspect} " \
+        "(changed: #{changed.empty? ? "n/a" : changed}). Run #{pull_hint} to absorb the remote edit " \
+        "into your repo, or re-run #{ensure_hint} to converge."
       )
     end
+
+    # @param plan [Hash]
+    # @return [Array<String>] `skill:<name> (<action>)` for each binding the plan would change.
+    def self.skill_changes(plan)
+      Array(plan["skillBindings"]).reject { |binding| binding["action"] == "unchanged" }
+                                  .map { |binding| "skill:#{binding["name"]} (#{binding["action"]})" }
+    end
+
+    # @param plan [Hash]
+    # @return [Array<String>] `publish (pending)` when a `release: "publish"` dry run would re-aim the pointer.
+    def self.publish_changes(plan)
+      plan["publishPending"] == true ? ["publish (pending)"] : []
+    end
+
+    # @param plan [Hash]
+    # @return [Array<String>] `deploy:<alias> (pointer)` and `deploy:<alias> (bindings)`
+    #   for an alias move or binding-name change the plan reports.
+    def self.deployment_changes(plan)
+      deployment = plan["deployment"]
+      return [] unless deployment.is_a?(Hash)
+
+      alias_name = deployment["alias"]
+      [
+        ("deploy:#{alias_name} (pointer)" if deployment["changed"] == true),
+        ("deploy:#{alias_name} (bindings)" if deployment["bindingsChanged"] == true)
+      ].compact
+    end
   end
 
   # A local tool could not be run during `run_with_local_tools`: the server

data/lib/runtype/local_tool_runner.rb

@@ -60,6 +60,7 @@ module Runtype
     # @return [Hash] the final JSON response body.
     def dispatch_with_local_tools(registry, params, max_rounds, request_options)
       response = dispatch(request_options: request_options, **params)
+      release = Runtype::DetachedFollow.release_fields(response)
       answered = AnsweredCalls.new
       replayed = false
       cursor = nil
@@ -80,6 +81,7 @@ module Runtype
             tool_outputs: registry.execute(batch),
             request_options: request_options
           )
+          release = release.merge(Runtype::DetachedFollow.release_fields(response))
           # A buffered continuation answers the leg in full; only a durable-lane
           # acknowledgement needs the run's events followed instead.
           next unless Runtype::DetachedFollow.detached_ack?(response)
@@ -90,7 +92,7 @@ module Runtype
         followed = Runtype::DetachedFollow.follow_buffered(
           self, collector.batch_execution_id, after: cursor, request_options: request_options
         )
-        response = followed.envelope
+        response = followed.envelope.merge(release)
         cursor = followed.cursor
         replayed = true
       end

data/lib/runtype/sdk_version.rb

@@ -9,7 +9,7 @@ module Runtype
   # collides today, but re-declaring it here would make the overlay's version
   # depend on generator require order.
   # Mirrored from ../../package.json by scripts/sync-sdk-versions.mjs; never hand-edit.
-  SDK_VERSION = "0.5.0"
+  SDK_VERSION = "0.11.1"
 
   # Outbound User-Agent identifying the SDK kind, version, and language, e.g.
   # "runtype-sdk/0.1.0 (ruby)". The `runtype-sdk/` prefix is what the API's

data/lib/runtype.rb

@@ -34,6 +34,8 @@ require_relative "runtype/streaming/event_stream"
 require_relative "runtype/canonical_json"
 require_relative "runtype/agent_definition"
 require_relative "runtype/agent_ensure"
+require_relative "runtype/content_hash"
+require_relative "runtype/config_ensure"
 require_relative "runtype/agent_release_aliases"
 require_relative "runtype/local_tools"
 require_relative "runtype/detached_follow"