runtype 0.1.0 → 0.2.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 88d76ad46808e8a8a0c06eb80f6b2ff0c61065f12d9762884af36689151f7e37
-  data.tar.gz: ac201871d379ec67b60e7cb6d34b1df429c4723a26b2a5843225ed8d6bbe9ea5
+  metadata.gz: d383187521d3ec144df17ea5d0d8c64f349774acb0af763e75e457aa63d09252
+  data.tar.gz: 961b1325dfacd79d7a799f247a1a5f19bf93e8b129230e61a20d2c8f66f38861
 SHA512:
-  metadata.gz: 74823bde1a17d632a6a7cb59499e3233452401c157c736f5a5408bd45b37977d2962637841ce2cfa6cffcc8d4b1cc56568235d2db860c780130c9f8a9c9842b3
-  data.tar.gz: 02d0a9123404ebea9d4350e4ed019a96f37db67f9d741b63d7c4d53da6ffc92cc2b89c3247f700aa9a735985fd15a31d98a72e2bd1f37dfcf2e6d3ce36d4fbc7
+  metadata.gz: 6942ecf790ca77a26005334afb280abfb3b190ad5b797e6a65434cdfd29ef4dbe8fa178ebf76d503fdb233c9c5dd495b21b89549c39d512f2690d95009a0fd52
+  data.tar.gz: a1db354c934aced2d3055e770b20ae6d4a4878e9f9fbc5b71abd2c6fd8e7780e08853a031669146e4217f50b8b29b78f1fca3384ef3cc58eec6b8e8080783656

data/CHANGELOG.md

@@ -2,6 +2,47 @@
 
 All notable changes to the Runtype Ruby SDK are documented here.
 
+## 0.2.1
+
+- `Runtype::Client#run_with_local_tools` follows a run that detached from its
+  request. A saved-agent dispatch on the platform's durable lane answers a
+  buffered resume with `{ executionId, pauseKind, status: "running" }` and closes
+  a streamed resume on an `await` whose `awaitReason` is `detached`; the loop
+  used to return that acknowledgement as if it were the turn, with no result.
+  Both loops now read the rest of the turn through the execution events alias,
+  from the last event already consumed, and keep answering local-tool pauses
+  until the terminal frame (runtypelabs/core#8240 follow-up). The JSON loop
+  returns the buffered continuation envelope (`executionId`, `events[]`,
+  `status`, `error`) for a followed turn.
+- `Runtype::Client#execution_events_stream(execution_id, after:, conversation_id:)`:
+  the events alias (`GET /v1/executions/{executionId}/events`) as a
+  `Runtype::Streaming::EventStream`, the reattach handle for any execution.
+
+## 0.2.0
+
+- Agents as code: `Runtype.define_agent` builds a validated, immutable
+  `Runtype::AgentDefinition` (snake_case or wire camelCase top-level fields, nested
+  config passed through untouched, account-scoped `tool_…`/`agent_…`/`flow_…` refs
+  rejected). `Runtype::Client#ensure_agent` converges it via `POST /v1/agents/ensure`
+  with the hash-first probe, per-client memo of the server hash, `dry_run:`,
+  `expect_no_changes:` (raises `Runtype::DriftError`), `on_conflict:`, `release:` and
+  `expected_remote_hash:`; `#pull_agent` reads the platform's definition back.
+- `Runtype::AgentDefinition.content_hash_for` computes the platform's canonical
+  content hash: object keys ordered as `JSON.stringify` emits them and numbers
+  rendered as JavaScript renders them, so the hash matches byte for byte (asserted
+  against the shared parity corpus). `ensure_agent` also accepts the wire-shaped
+  definition `pull_agent` returns.
+- `Runtype::Client#run_with_local_tools`: the local-tool pause/resume loop. Executes
+  every paused tool in a batch concurrently and answers them in one resume keyed by
+  the server's per-call id, in JSON or streaming mode, and returns a pause this
+  process does not own (approval, elicitation, detached) untouched. `Runtype::LocalTool` pairs a handler with its schema; `scope: :turn`
+  ships those schemas as `clientTools[]`.
+- Curated errors: `Runtype::ConflictError` (409), `Runtype::EnsureConflictError`,
+  `Runtype::DriftError`, `Runtype::LocalToolError`.
+- The README's dispatch examples now show the wire shape, `agent: { agentId: }` with
+  real `agent_…` ids (the previous `agent: { id: "agt_…" }` examples never referenced
+  a saved agent), and the missing-target error names it.
+
 ## 0.1.0
 
 Initial release.

data/README.md

@@ -25,7 +25,7 @@ client = Runtype::Client.new(api_key: ENV["RUNTYPE_API_KEY"])
 
 # Stream an agent turn
 client.dispatch_stream(
-  agent: { id: "agt_abc123" },
+  agent: { agentId: "agent_abc123" },
   messages: [{ role: "user", content: "Summarize last quarter" }]
 ) do |event|
   print event["delta"] if event.type == "text_delta"
@@ -33,16 +33,71 @@ end
 
 # Or wait for the finished result
 result = client.dispatch(
-  agent: { id: "agt_abc123" },
+  agent: { agentId: "agent_abc123" },
   messages: [{ role: "user", content: "Summarize last quarter" }]
 )
 puts result["executionId"]
 
 # Every documented endpoint is a resource group on the client
 flows = client.flows.list_flows
-agent = client.agents.get_agent_details(id: "agt_abc123")
+agent = client.agents.get_agent_details(id: "agent_abc123")
 ```
 
+The dispatch `agent:` object is an agent definition. Reference a saved agent with
+`agentId:`, or run an inline one with `name:`, `model:`, `systemPrompt:` and the rest
+of the runtime config — nothing is persisted for inline agents.
+
+## Agents as code
+
+Keep the agent's definition in your repo and converge it onto the platform at boot or
+deploy time. `Runtype.define_agent` is pure and local; `ensure_agent` is idempotent
+and non-executing: it probes with a content hash, ships the full definition only when
+the platform reports a miss, appends an immutable version on every change, and never
+deletes. Identity is the agent's name within the API key's account scope.
+
+```ruby
+assistant = Runtype.define_agent(
+  name: "Pricing Assistant",
+  model: "claude-sonnet-4-6",
+  system_prompt: render_prompt(pricing_data),
+  loop_config: { maxTurns: 1 },
+  tools: {
+    toolIds: ["builtin:web_search", "tool:Price List"],   # portable refs only
+    runtimeTools: [
+      { name: "save_quote", toolType: "local", description: "Save a quote",
+        parametersSchema: { type: "object", properties: { total: { type: "number" } } } }
+    ]
+  }
+)
+
+result = client.ensure_agent(assistant, on_conflict: "overwrite", release: "publish")
+result["result"]    # "unchanged" | "created" | "updated"
+result["agentId"]   # dispatch with agent: { agentId: result["agentId"] }
+
+# CI drift gate: raises Runtype::DriftError unless the platform already matches
+client.ensure_agent(assistant, expect_no_changes: true)
+
+# Absorb a dashboard edit back into the repo
+pulled = client.pull_agent("Pricing Assistant")
+pulled["definition"]   # the canonical wire definition; ensure_agent accepts it as-is
+pulled["lastModifiedSource"]
+```
+
+Top-level fields take snake_case or the wire's camelCase; nested config (`tools`,
+`loop_config`, ...) is passed through in wire shape untouched, because its keys can be
+tool names. Definitions must be environment-portable: raw `tool_…`, `agent_…` and
+`flow_…` ids are rejected in favour of `builtin:`, `platform:`, `mcp:` and
+`tool:<name>` / `agent:<name>` / `flow:<name>` references, so the same definition
+converges staging and production.
+
+`ensure_agent` raises `Runtype::EnsureConflictError` (a 409) when the agent's last
+write came from the dashboard, the API or MCP (`#code == "external_modification"`;
+pass `on_conflict: "overwrite"` to converge over it) or when an
+`expected_remote_hash:` no longer matches (`#code == "remote_changed"`).
+`Runtype::AgentDefinition.content_hash_for(definition)` computes the same SHA-256 the
+platform does, over the canonical normalized form (keys ordered as `JSON.stringify`
+emits them, numbers rendered as JavaScript renders them).
+
 ## Authentication
 
 Pass `api_key:`, or leave it out and the client reads `RUNTYPE_API_KEY`. The base URL
@@ -67,7 +122,7 @@ events. Passing a block iterates it and closes the socket for you; the closed st
 comes back so the reconnect handle is still readable.
 
 ```ruby
-stream = client.dispatch_stream(agent: { id: "agt_abc123" }, messages: messages) do |event|
+stream = client.dispatch_stream(agent: { agentId: "agent_abc123" }, messages: messages) do |event|
   case event.type
   when "text_delta"      then print event["delta"]
   when "tool_start"      then puts "calling #{event["toolName"]}"
@@ -109,7 +164,7 @@ from where you left off.
 ```ruby
 detached = false
 
-stream = client.dispatch_stream(agent: { id: "agt_abc123" }, messages: messages) do |event|
+stream = client.dispatch_stream(agent: { agentId: "agent_abc123" }, messages: messages) do |event|
   detached ||= event.detached?
   handle(event)
 end
@@ -130,6 +185,33 @@ client.resume_stream(
 
 `resume` is the non-streaming equivalent. Neither counts against execution limits.
 
+`run_with_local_tools` runs that loop for you. Give it a map of tool name to handler;
+every time the execution pauses on one of them it executes the handler and resumes
+with the output, running all of a turn's parallel calls concurrently and answering
+them in one resume, until the execution ends or pauses on something this process does
+not own (an approval or an elicitation, say), which is returned as-is. Without a block it returns the final JSON body; with a block
+it streams every event of every leg and returns the last leg's stream.
+
+```ruby
+save_goals = Runtype::LocalTool.new(
+  description: "Save the patient's stated goals",
+  parameters_schema: { type: "object", properties: { goals: { type: "array", items: { type: "string" } } } }
+) { |args| Goals.save(args["goals"]); { ok: true } }
+
+result = client.run_with_local_tools(
+  { "save_goals" => save_goals, "lookup_order" => ->(args) { Orders.find(args["id"]) } },
+  agent: { agentId: "agent_abc123" },
+  messages: [{ role: "user", content: "I want to sleep better" }]
+)
+result["status"]   # "completed", or "paused" on a pause you do not own
+```
+
+A bare callable is enough when the saved agent already declares the tool as a
+`toolType: "local"` runtime tool. Pass `scope: :turn` to also ship every
+`Runtype::LocalTool`'s schema as `clientTools[]` for that one dispatch, for tools
+the saved agent does not declare. A missing handler, a handler that raises, or a
+loop that exceeds `max_rounds:` raises `Runtype::LocalToolError`.
+
 ## Errors
 
 Everything the client raises descends from `Runtype::Error`.
@@ -139,18 +221,22 @@ Everything the client raises descends from `Runtype::Error`.
 | `Runtype::AuthenticationError`      | 401, or no API key at construction |
 | `Runtype::PermissionDeniedError`    | 403                                |
 | `Runtype::NotFoundError`            | 404                                |
+| `Runtype::ConflictError`            | 409                                |
+| `Runtype::EnsureConflictError`      | 409 from `ensure_agent`, exposes `#code` |
 | `Runtype::UnprocessableEntityError` | 422                                |
 | `Runtype::RateLimitError`           | 429, exposes `#retry_after`        |
 | `Runtype::APIStatusError`           | any other non-2xx                  |
 | `Runtype::APITimeoutError`          | the request timed out              |
 | `Runtype::APIConnectionError`       | the request never reached the API  |
+| `Runtype::DriftError`               | `ensure_agent(..., expect_no_changes: true)` found drift, exposes `#plan` |
+| `Runtype::LocalToolError`           | `run_with_local_tools` could not run a tool, exposes `#tool_name` and `#cause` |
 
 Status errors carry `#status_code`, `#body` (parsed when the response was JSON), and
 `#headers`.
 
 ```ruby
 begin
-  client.dispatch(agent: { id: "agt_abc123" }, messages: messages)
+  client.dispatch(agent: { agentId: "agent_abc123" }, messages: messages)
 rescue Runtype::RateLimitError => e
   sleep(e.retry_after || 5)
   retry

data/generated/lib/runtype/agent_aliases/client.rb

@@ -0,0 +1,320 @@
+# frozen_string_literal: true
+
+module Runtype
+  module AgentAliases
+    class Client
+      # @param client [Runtype::Internal::Http::RawClient]
+      #
+      # @return [void]
+      def initialize(client:)
+        @client = client
+      end
+
+      # List the named pointers that select which immutable version of this agent runs. `live` sorts first, then the
+      # preview aliases by name. Archived aliases are omitted unless `includeArchived=true`. Omitting `limit` returns
+      # every pointer; supplying it pages through the same order with `cursor`.
+      #
+      # @param request_options [Hash]
+      # @param params [Hash]
+      # @option request_options [String] :base_url
+      # @option request_options [Hash{String => Object}] :additional_headers
+      # @option request_options [Hash{String => Object}] :additional_query_parameters
+      # @option request_options [Hash{String => Object}] :additional_body_parameters
+      # @option request_options [Integer] :timeout_in_seconds
+      # @option params [String] :id
+      # @option params [String, nil] :include_archived
+      # @option params [String, nil] :limit
+      # @option params [String, nil] :cursor
+      #
+      # @example
+      #   client.agent_aliases.list_release_aliases_for_an_agent(id: "id")
+      #
+      # @return [Runtype::AgentAliases::Types::GetV1AgentsIDAliasesResponse]
+      def list_release_aliases_for_an_agent(request_options: {}, **params)
+        params = Runtype::Internal::Types::Utils.normalize_keys(params)
+        query_params = {}
+        query_params["includeArchived"] = params[:include_archived] if params.key?(:include_archived)
+        query_params["limit"] = params[:limit] if params.key?(:limit)
+        query_params["cursor"] = params[:cursor] if params.key?(:cursor)
+
+        request = Runtype::Internal::JSON::Request.new(
+          base_url: request_options[:base_url],
+          method: "GET",
+          path: "v1/agents/#{URI.encode_uri_component(params[:id].to_s)}/aliases",
+          query: query_params,
+          request_options: request_options
+        )
+        begin
+          response = @client.send(request)
+        rescue Net::HTTPRequestTimeout
+          raise Runtype::Errors::TimeoutError
+        end
+        code = response.code.to_i
+        if code.between?(200, 299)
+          Runtype::AgentAliases::Types::GetV1AgentsIDAliasesResponse.load(response.body)
+        else
+          error_class = Runtype::Errors::ResponseError.subclass_for_code(code)
+          raise error_class.new(response.body, code: code)
+        end
+      end
+
+      # Read one pointer. A missing or archived alias answers a structured 404 naming the alias; it never falls back to
+      # live.
+      #
+      # @param request_options [Hash]
+      # @param params [Hash]
+      # @option request_options [String] :base_url
+      # @option request_options [Hash{String => Object}] :additional_headers
+      # @option request_options [Hash{String => Object}] :additional_query_parameters
+      # @option request_options [Hash{String => Object}] :additional_body_parameters
+      # @option request_options [Integer] :timeout_in_seconds
+      # @option params [String] :id
+      # @option params [String] :alias_
+      # @option params [String, nil] :include_archived
+      #
+      # @example
+      #   client.agent_aliases.get_one_release_alias(
+      #     id: "id",
+      #     alias_: "alias"
+      #   )
+      #
+      # @return [Runtype::AgentAliases::Types::GetV1AgentsIDAliasesAliasResponse]
+      def get_one_release_alias(request_options: {}, **params)
+        params = Runtype::Internal::Types::Utils.normalize_keys(params)
+        query_params = {}
+        query_params["includeArchived"] = params[:include_archived] if params.key?(:include_archived)
+
+        request = Runtype::Internal::JSON::Request.new(
+          base_url: request_options[:base_url],
+          method: "GET",
+          path: "v1/agents/#{URI.encode_uri_component(params[:id].to_s)}/aliases/#{URI.encode_uri_component(params[:alias_].to_s)}",
+          query: query_params,
+          request_options: request_options
+        )
+        begin
+          response = @client.send(request)
+        rescue Net::HTTPRequestTimeout
+          raise Runtype::Errors::TimeoutError
+        end
+        code = response.code.to_i
+        if code.between?(200, 299)
+          Runtype::AgentAliases::Types::GetV1AgentsIDAliasesAliasResponse.load(response.body)
+        else
+          error_class = Runtype::Errors::ResponseError.subclass_for_code(code)
+          raise error_class.new(response.body, code: code)
+        end
+      end
+
+      # Aim one alias at one immutable version of the same agent, appending a deployment receipt in the same
+      # transaction. Moving an existing `live` pointer requires the AGENTS:DEPLOY:LIVE scope and an `If-Match` revision;
+      # preview aliases require AGENTS:DEPLOY:PREVIEW. Dependency references the version names are fingerprinted first,
+      # and an unresolvable reference refuses the activation.
+      #
+      # @param request_options [Hash]
+      # @param params [Runtype::AgentAliases::Types::PutV1AgentsIDAliasesAliasRequest]
+      # @option request_options [String] :base_url
+      # @option request_options [Hash{String => Object}] :additional_headers
+      # @option request_options [Hash{String => Object}] :additional_query_parameters
+      # @option request_options [Hash{String => Object}] :additional_body_parameters
+      # @option request_options [Integer] :timeout_in_seconds
+      # @option params [String] :id
+      # @option params [String] :alias_
+      # @option params [String, nil] :if_match
+      # @option params [String, nil] :idempotency_key
+      #
+      # @example
+      #   client.agent_aliases.activate_a_version_at_a_release_alias(
+      #     id: "id",
+      #     alias_: "alias",
+      #     version_id: "versionId"
+      #   )
+      #
+      # @return [Runtype::AgentAliases::Types::PutV1AgentsIDAliasesAliasResponse]
+      def activate_a_version_at_a_release_alias(request_options: {}, **params)
+        params = Runtype::Internal::Types::Utils.normalize_keys(params)
+        request_data = Runtype::AgentAliases::Types::PutV1AgentsIDAliasesAliasRequest.new(params).to_h
+        non_body_param_names = %w[id alias if-match idempotency-key]
+        body = request_data.except(*non_body_param_names)
+
+        headers = {}
+        headers["if-match"] = params[:if_match] if params[:if_match]
+        headers["idempotency-key"] = params[:idempotency_key] if params[:idempotency_key]
+
+        request = Runtype::Internal::JSON::Request.new(
+          base_url: request_options[:base_url],
+          method: "PUT",
+          path: "v1/agents/#{URI.encode_uri_component(params[:id].to_s)}/aliases/#{URI.encode_uri_component(params[:alias_].to_s)}",
+          headers: headers,
+          body: body,
+          request_options: request_options
+        )
+        begin
+          response = @client.send(request)
+        rescue Net::HTTPRequestTimeout
+          raise Runtype::Errors::TimeoutError
+        end
+        code = response.code.to_i
+        if code.between?(200, 299)
+          Runtype::AgentAliases::Types::PutV1AgentsIDAliasesAliasResponse.load(response.body)
+        else
+          error_class = Runtype::Errors::ResponseError.subclass_for_code(code)
+          raise error_class.new(response.body, code: code)
+        end
+      end
+
+      # Archive a preview alias: it stops resolving for new executions, keeps its deployment history, and does not
+      # interrupt admitted runs. The row is never deleted, so a later activation revives the same pointer. `live` cannot
+      # be archived.
+      #
+      # @param request_options [Hash]
+      # @param params [Hash]
+      # @option request_options [String] :base_url
+      # @option request_options [Hash{String => Object}] :additional_headers
+      # @option request_options [Hash{String => Object}] :additional_query_parameters
+      # @option request_options [Hash{String => Object}] :additional_body_parameters
+      # @option request_options [Integer] :timeout_in_seconds
+      # @option params [String] :id
+      # @option params [String] :alias_
+      # @option params [String, nil] :if_match
+      # @option params [String, nil] :idempotency_key
+      #
+      # @example
+      #   client.agent_aliases.archive_a_release_alias(
+      #     id: "id",
+      #     alias_: "alias"
+      #   )
+      #
+      # @return [Runtype::AgentAliases::Types::DeleteV1AgentsIDAliasesAliasResponse]
+      def archive_a_release_alias(request_options: {}, **params)
+        params = Runtype::Internal::Types::Utils.normalize_keys(params)
+        headers = {}
+        headers["if-match"] = params[:if_match] if params[:if_match]
+        headers["idempotency-key"] = params[:idempotency_key] if params[:idempotency_key]
+
+        request = Runtype::Internal::JSON::Request.new(
+          base_url: request_options[:base_url],
+          method: "DELETE",
+          path: "v1/agents/#{URI.encode_uri_component(params[:id].to_s)}/aliases/#{URI.encode_uri_component(params[:alias_].to_s)}",
+          headers: headers,
+          request_options: request_options
+        )
+        begin
+          response = @client.send(request)
+        rescue Net::HTTPRequestTimeout
+          raise Runtype::Errors::TimeoutError
+        end
+        code = response.code.to_i
+        if code.between?(200, 299)
+          Runtype::AgentAliases::Types::DeleteV1AgentsIDAliasesAliasResponse.load(response.body)
+        else
+          error_class = Runtype::Errors::ResponseError.subclass_for_code(code)
+          raise error_class.new(response.body, code: code)
+        end
+      end
+
+      # Re-aim an alias at the version recorded as `previousVersionId` on its most recent pointer-moving receipt,
+      # walking `steps` receipts back. Writes a `rollback` receipt. Rolling back `live` follows the same scope and
+      # `If-Match` rules as activation, and restores configuration only: external data and side effects are not rolled
+      # back.
+      #
+      # @param request_options [Hash]
+      # @param params [Runtype::AgentAliases::Types::PostV1AgentsIDAliasesAliasRollbackRequest]
+      # @option request_options [String] :base_url
+      # @option request_options [Hash{String => Object}] :additional_headers
+      # @option request_options [Hash{String => Object}] :additional_query_parameters
+      # @option request_options [Hash{String => Object}] :additional_body_parameters
+      # @option request_options [Integer] :timeout_in_seconds
+      # @option params [String] :id
+      # @option params [String] :alias_
+      # @option params [String, nil] :if_match
+      # @option params [String, nil] :idempotency_key
+      #
+      # @example
+      #   client.agent_aliases.roll_a_release_alias_back_to_its_previous_version(
+      #     id: "id",
+      #     alias_: "alias"
+      #   )
+      #
+      # @return [Runtype::AgentAliases::Types::PostV1AgentsIDAliasesAliasRollbackResponse]
+      def roll_a_release_alias_back_to_its_previous_version(request_options: {}, **params)
+        params = Runtype::Internal::Types::Utils.normalize_keys(params)
+        request_data = Runtype::AgentAliases::Types::PostV1AgentsIDAliasesAliasRollbackRequest.new(params).to_h
+        non_body_param_names = %w[id alias if-match idempotency-key]
+        body = request_data.except(*non_body_param_names)
+
+        headers = {}
+        headers["if-match"] = params[:if_match] if params[:if_match]
+        headers["idempotency-key"] = params[:idempotency_key] if params[:idempotency_key]
+
+        request = Runtype::Internal::JSON::Request.new(
+          base_url: request_options[:base_url],
+          method: "POST",
+          path: "v1/agents/#{URI.encode_uri_component(params[:id].to_s)}/aliases/#{URI.encode_uri_component(params[:alias_].to_s)}/rollback",
+          headers: headers,
+          body: body,
+          request_options: request_options
+        )
+        begin
+          response = @client.send(request)
+        rescue Net::HTTPRequestTimeout
+          raise Runtype::Errors::TimeoutError
+        end
+        code = response.code.to_i
+        if code.between?(200, 299)
+          Runtype::AgentAliases::Types::PostV1AgentsIDAliasesAliasRollbackResponse.load(response.body)
+        else
+          error_class = Runtype::Errors::ResponseError.subclass_for_code(code)
+          raise error_class.new(response.body, code: code)
+        end
+      end
+
+      # The append-only deployment history of this agent, newest first, cursor-paginated. Each receipt records the
+      # pointer, the previous and new versions, the alias revision, the actor, provenance and the dependency
+      # fingerprints checked at activation.
+      #
+      # @param request_options [Hash]
+      # @param params [Hash]
+      # @option request_options [String] :base_url
+      # @option request_options [Hash{String => Object}] :additional_headers
+      # @option request_options [Hash{String => Object}] :additional_query_parameters
+      # @option request_options [Hash{String => Object}] :additional_body_parameters
+      # @option request_options [Integer] :timeout_in_seconds
+      # @option params [String] :id
+      # @option params [String, nil] :alias_
+      # @option params [String, nil] :limit
+      # @option params [String, nil] :cursor
+      #
+      # @example
+      #   client.agent_aliases.list_deployment_receipts_for_an_agent(id: "id")
+      #
+      # @return [Runtype::AgentAliases::Types::GetV1AgentsIDDeploymentsResponse]
+      def list_deployment_receipts_for_an_agent(request_options: {}, **params)
+        params = Runtype::Internal::Types::Utils.normalize_keys(params)
+        query_params = {}
+        query_params["alias"] = params[:alias_] if params.key?(:alias_)
+        query_params["limit"] = params[:limit] if params.key?(:limit)
+        query_params["cursor"] = params[:cursor] if params.key?(:cursor)
+
+        request = Runtype::Internal::JSON::Request.new(
+          base_url: request_options[:base_url],
+          method: "GET",
+          path: "v1/agents/#{URI.encode_uri_component(params[:id].to_s)}/deployments",
+          query: query_params,
+          request_options: request_options
+        )
+        begin
+          response = @client.send(request)
+        rescue Net::HTTPRequestTimeout
+          raise Runtype::Errors::TimeoutError
+        end
+        code = response.code.to_i
+        if code.between?(200, 299)
+          Runtype::AgentAliases::Types::GetV1AgentsIDDeploymentsResponse.load(response.body)
+        else
+          error_class = Runtype::Errors::ResponseError.subclass_for_code(code)
+          raise error_class.new(response.body, code: code)
+        end
+      end
+    end
+  end
+end

data/generated/lib/runtype/agent_aliases/types/delete_v1agents_id_aliases_alias_request.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+module Runtype
+  module AgentAliases
+    module Types
+      class DeleteV1AgentsIDAliasesAliasRequest < Internal::Types::Model
+        field :id, -> { String }, optional: false, nullable: false
+
+        field :alias_, -> { String }, optional: false, nullable: false, api_name: "alias"
+
+        field :if_match, -> { String }, optional: true, nullable: false, api_name: "if-match"
+
+        field :idempotency_key, -> { String }, optional: true, nullable: false, api_name: "idempotency-key"
+      end
+    end
+  end
+end

data/generated/lib/runtype/agent_aliases/types/delete_v1agents_id_aliases_alias_response.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+module Runtype
+  module AgentAliases
+    module Types
+      class DeleteV1AgentsIDAliasesAliasResponse < Internal::Types::Model
+        field :alias_, -> { String }, optional: false, nullable: false, api_name: "alias"
+
+        field :archived, -> { Internal::Types::Boolean }, optional: false, nullable: false
+
+        field :receipt_id, -> { String }, optional: false, nullable: false, api_name: "receiptId"
+
+        field :revision, -> { Integer }, optional: false, nullable: false
+      end
+    end
+  end
+end

data/generated/lib/runtype/agent_aliases/types/get_v1agents_id_aliases_alias_request.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+module Runtype
+  module AgentAliases
+    module Types
+      class GetV1AgentsIDAliasesAliasRequest < Internal::Types::Model
+        field :id, -> { String }, optional: false, nullable: false
+
+        field :alias_, -> { String }, optional: false, nullable: false, api_name: "alias"
+
+        field :include_archived, -> { String }, optional: true, nullable: false, api_name: "includeArchived"
+      end
+    end
+  end
+end

data/generated/lib/runtype/agent_aliases/types/get_v1agents_id_aliases_alias_response.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+module Runtype
+  module AgentAliases
+    module Types
+      class GetV1AgentsIDAliasesAliasResponse < Internal::Types::Model
+        field :alias_, -> { String }, optional: false, nullable: false, api_name: "alias"
+
+        field :archived_at, -> { String }, optional: false, nullable: true, api_name: "archivedAt"
+
+        field :content_hash, -> { String }, optional: false, nullable: true, api_name: "contentHash"
+
+        field :created_at, -> { String }, optional: false, nullable: false, api_name: "createdAt"
+
+        field :expires_at, -> { String }, optional: false, nullable: true, api_name: "expiresAt"
+
+        field :label, -> { String }, optional: false, nullable: true
+
+        field :revision, -> { Integer }, optional: false, nullable: false
+
+        field :updated_at, -> { String }, optional: false, nullable: false, api_name: "updatedAt"
+
+        field :version_id, -> { String }, optional: false, nullable: false, api_name: "versionId"
+
+        field :version_number, -> { Integer }, optional: false, nullable: true, api_name: "versionNumber"
+      end
+    end
+  end
+end

data/generated/lib/runtype/agent_aliases/types/get_v1agents_id_aliases_request.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+module Runtype
+  module AgentAliases
+    module Types
+      class GetV1AgentsIDAliasesRequest < Internal::Types::Model
+        field :id, -> { String }, optional: false, nullable: false
+
+        field :include_archived, -> { String }, optional: true, nullable: false, api_name: "includeArchived"
+
+        field :limit, -> { String }, optional: true, nullable: false
+
+        field :cursor, -> { String }, optional: true, nullable: false
+      end
+    end
+  end
+end

data/generated/lib/runtype/agent_aliases/types/get_v1agents_id_aliases_response.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+module Runtype
+  module AgentAliases
+    module Types
+      class GetV1AgentsIDAliasesResponse < Internal::Types::Model
+        field :data, -> { Internal::Types::Array[Runtype::AgentAliases::Types::GetV1AgentsIDAliasesResponseDataItem] }, optional: false, nullable: false
+
+        field :next_cursor, -> { String }, optional: false, nullable: true, api_name: "nextCursor"
+      end
+    end
+  end
+end