phronomy 0.26.0 → 0.28.0

data/sig/phronomy/persistence.rbs

@@ -1,189 +1,7 @@
 module Phronomy
-  interface _ContentRepository
-    def put: (String bytes, canonicalization_version: untyped) -> String
-    def fetch: (String content_id) -> String
-    def exist?: (String content_id) -> bool
-  end
-
-  # Runtime/domain-facing repository interfaces.
-  interface _AgentRepository
-    def create: (untyped root) -> untyped
-    def load: (String agent_id) -> untyped
-    def save: (String agent_id, expected_revision: Integer, root: untyped) -> untyped
-    def delete: (String agent_id) -> untyped
-  end
-
-  interface _JournalRepository
-    def append: (String agent_id, expected_position: Integer, records: Array[untyped]) -> Array[untyped]
-    def read: (String agent_id, ?after: Integer?, ?limit: Integer?) -> Array[untyped]
-    def head: (String agent_id) -> Integer
-    def delete: (String agent_id) -> untyped
-  end
-
-  interface _ExecutionRepository
-    def create_active: (untyped execution) -> untyped
-    def load: (String execution_id) -> untyped
-    def save: (String execution_id, expected_revision: Integer, execution: untyped) -> untyped
-    def list_active: (String agent_id) -> Array[untyped]
-    def list: (String agent_id, ?after: String?, ?limit: Integer) -> Array[untyped]
-    def delete: (String execution_id) -> untyped
-    def delete_for_agent: (String agent_id) -> untyped
-    def assert_idle!: (String agent_id) -> untyped
-  end
-
-  interface _WorkflowStateRepository
-    def load: (String workflow_instance_id) -> Hash[untyped, untyped]?
-    def save: (String workflow_instance_id, expected_revision: Integer?, snapshot: Hash[untyped, untyped]) -> Integer
-    def delete: (String workflow_instance_id, expected_revision: Integer) -> untyped
-  end
-
-  # Backend-side record repository interfaces. DurableRecord is the opaque data
-  # carrier. Identity/revision/index metadata is passed separately so backends do
-  # not need to interpret DurableRecord#payload.
-  interface _BackendAgentRecordRepository
-    def create: (agent_id: String, agent_revision: Integer, record: Persistence::DurableRecord) -> Persistence::DurableRecord
-    def load: (String agent_id) -> Persistence::DurableRecord
-    def save: (String agent_id, expected_revision: Integer, next_revision: Integer, record: Persistence::DurableRecord) -> Persistence::DurableRecord
-    def delete: (String agent_id) -> untyped
-  end
-
-  interface _BackendJournalRecordRepository
-    def append: (String agent_id, expected_position: Integer, records: Array[Persistence::DurableRecord], record_ids: Array[String]) -> Array[Persistence::DurableRecord]
-    def read: (String agent_id, ?after: Integer?, ?limit: Integer?) -> Array[Persistence::DurableRecord]
-    def head: (String agent_id) -> Integer
-    def delete: (String agent_id) -> untyped
-  end
-
-  interface _BackendExecutionRecordRepository
-    def create_active: (execution_id: String, agent_id: String, execution_revision: Integer, record: Persistence::DurableRecord) -> Persistence::DurableRecord
-    def load: (String execution_id) -> Persistence::DurableRecord
-    def save: (String execution_id, expected_revision: Integer, next_revision: Integer, agent_id: String, active: bool, record: Persistence::DurableRecord) -> Persistence::DurableRecord
-    def list_active: (String agent_id) -> Array[Persistence::DurableRecord]
-    def list: (String agent_id, ?after: String?, ?limit: Integer) -> Array[Persistence::DurableRecord]
-    def delete: (String execution_id) -> untyped
-    def delete_for_agent: (String agent_id) -> untyped
-    def assert_idle!: (String agent_id) -> untyped
-  end
-
-  interface _BackendWorkflowStateRecordRepository
-    def load: (String workflow_instance_id) -> Persistence::DurableRecord?
-    def save: (String workflow_instance_id, expected_revision: Integer?, next_revision: Integer, record: Persistence::DurableRecord) -> Persistence::DurableRecord
-    def delete: (String workflow_instance_id, expected_revision: Integer) -> untyped
-  end
-
-  interface _HandoffStateRepository
-    def load: (String main_agent_id) -> untyped
-    def save: (String main_agent_id, expected_revision: Integer?, state: untyped) -> untyped
-    def delete: (String main_agent_id, expected_revision: Integer) -> untyped
-  end
-
-  interface _TeamRepository
-    def create: (untyped root) -> untyped
-    def load: (String team_id) -> untyped
-    def save: (String team_id, expected_revision: Integer, root: untyped) -> untyped
-    def delete: (String team_id) -> untyped
-  end
-
-  interface _TeamExecutionRepository
-    def create_active: (untyped execution) -> untyped
-    def load: (String team_execution_id) -> untyped
-    def save: (String team_execution_id, expected_revision: Integer, execution: untyped) -> untyped
-    def list_active: (String team_id) -> Array[untyped]
-    def list: (String team_id, ?after: String?, ?limit: Integer) -> Array[untyped]
-    def delete: (String team_execution_id) -> untyped
-    def delete_for_team: (String team_id) -> untyped
-    def assert_idle!: (String team_id) -> untyped
-  end
-
-  interface _BackendHandoffStateRecordRepository
-    def load: (String main_agent_id) -> Persistence::DurableRecord?
-    def save: (String main_agent_id, expected_revision: Integer?, next_revision: Integer, active_agent_id: String, record: Persistence::DurableRecord) -> Persistence::DurableRecord
-    def delete: (String main_agent_id, expected_revision: Integer) -> untyped
-  end
-
-  interface _BackendTeamRecordRepository
-    def create: (team_id: String, team_revision: Integer, record: Persistence::DurableRecord) -> Persistence::DurableRecord
-    def load: (String team_id) -> Persistence::DurableRecord
-    def save: (String team_id, expected_revision: Integer, next_revision: Integer, record: Persistence::DurableRecord) -> Persistence::DurableRecord
-    def delete: (String team_id) -> untyped
-  end
-
-  interface _BackendTeamExecutionRecordRepository
-    def create_active: (team_execution_id: String, team_id: String, execution_revision: Integer, record: Persistence::DurableRecord) -> Persistence::DurableRecord
-    def load: (String team_execution_id) -> Persistence::DurableRecord
-    def save: (String team_execution_id, expected_revision: Integer, next_revision: Integer, team_id: String, active: bool, record: Persistence::DurableRecord) -> Persistence::DurableRecord
-    def list_active: (String team_id) -> Array[Persistence::DurableRecord]
-    def list: (String team_id, ?after: String?, ?limit: Integer) -> Array[Persistence::DurableRecord]
-    def delete: (String team_execution_id) -> untyped
-    def delete_for_team: (String team_id) -> untyped
-    def assert_idle!: (String team_id) -> untyped
-  end
-
-  interface _BackendWatermark
-    def assert_agent_watermark!: (agent_id: String, agent_revision: Integer, journal_position: Integer) -> true
-  end
-
-  interface _PersistenceTransactionView
-    def contents: () -> _ContentRepository
-    def agents: () -> _AgentRepository
-    def journals: () -> _JournalRepository
-    def executions: () -> _ExecutionRepository
-    def workflow_states: () -> _WorkflowStateRepository
-    def handoff_states: () -> _HandoffStateRepository
-    def teams: () -> _TeamRepository
-    def team_executions: () -> _TeamExecutionRepository
-    def assert_agent_watermark!: (agent_id: String, agent_revision: Integer, journal_position: Integer) -> true
-  end
-
   class Persistence
-    class ConflictError < Phronomy::Error
-    end
-    class NotFoundError < Phronomy::Error
-    end
-    class UnsupportedBackendError < Phronomy::Error
-    end
-    class SerializationError < Phronomy::Error
-    end
-
-    class DurableRecord
-      FORMAT_VERSION_PATTERN: Regexp
-      attr_reader record_type: String
-      attr_reader format_version: String
-      attr_reader payload: Hash[String, untyped]
-      def initialize: (record_type: String, format_version: String, payload: Hash[String, untyped]) -> void
-      def copy: () -> DurableRecord
-    end
-
-    module Migration
-      module InitialFormatMigration
-        def self.agent_root: (Hash[untyped, untyped] hash) -> DurableRecord
-        def self.agent_execution: (Hash[untyped, untyped] hash) -> DurableRecord
-        def self.journal_record: (Hash[untyped, untyped] hash) -> DurableRecord
-        def self.workflow_state: (workflow_instance_id: String, revision: Integer, snapshot: Hash[untyped, untyped]) -> DurableRecord
-        def self.llm_input_manifest: (Hash[untyped, untyped] hash) -> Hash[String, untyped]
-      end
-    end
-
-    REQUIRED_CAPABILITIES: Hash[Symbol, bool]
-
-    attr_reader contents: _ContentRepository
-    attr_reader agents: _AgentRepository
-    attr_reader journals: _JournalRepository
-    attr_reader executions: _ExecutionRepository
-    attr_reader workflow_states: _WorkflowStateRepository
-    attr_reader handoff_states: _HandoffStateRepository
-    attr_reader teams: _TeamRepository
-    attr_reader team_executions: _TeamExecutionRepository
-    def handoff_result: (String execution_id, ?main_agent_id: String?) -> Hash[Symbol, untyped]
-    def execution_result: (String execution_id) -> Hash[Symbol, untyped]
-    def list_executions: (String agent_id, ?after: String?, ?limit: Integer) -> Array[untyped]
-    def team_execution_result: (String team_execution_id) -> Hash[Symbol, untyped]
-    def list_team_executions: (String team_id, ?after: String?, ?limit: Integer) -> Array[untyped]
-
-    def initialize: (contents: _ContentRepository, agents: _BackendAgentRecordRepository, journals: _BackendJournalRecordRepository, executions: _BackendExecutionRecordRepository, workflow_states: _BackendWorkflowStateRecordRepository, handoff_states: _BackendHandoffStateRecordRepository, teams: _BackendTeamRecordRepository, team_executions: _BackendTeamExecutionRecordRepository) -> void
-    def capabilities: () -> Hash[Symbol, bool]
-    def transaction: () { (_PersistenceTransactionView) -> untyped } -> untyped
-    def build_transaction_view: (contents: _ContentRepository, agents: _BackendAgentRecordRepository, journals: _BackendJournalRecordRepository, executions: _BackendExecutionRecordRepository, workflow_states: _BackendWorkflowStateRecordRepository, handoff_states: _BackendHandoffStateRecordRepository, teams: _BackendTeamRecordRepository, team_executions: _BackendTeamExecutionRecordRepository, watermark: _BackendWatermark) -> _PersistenceTransactionView
-    def assert_agent_watermark!: (agent_id: String, agent_revision: Integer, journal_position: Integer) -> true
+    attr_reader backend: _StorageBackend
+    def initialize: (backend: _StorageBackend) -> void
+    def bind: [T] (_Participant[T] adapter) -> T
   end
 end

data/sig/phronomy/persistence_composition.rbs

@@ -0,0 +1,19 @@
+module Phronomy
+  module PersistenceComposition
+    class Stores < Data
+      attr_reader coordinator: ::Phronomy::Persistence
+      attr_reader agent: Agent::Store
+      attr_reader multi_agent: MultiAgent::Store
+      attr_reader workflow: _WorkflowStateRepository
+      def self.new: (coordinator: ::Phronomy::Persistence, agent: Agent::Store, multi_agent: MultiAgent::Store, workflow: _WorkflowStateRepository) -> instance
+    end
+
+    class Unit4Migration
+      def self.convert: (Hash[String, json_value] snapshot, quiescent: bool) -> Hash[String, json_value]
+    end
+
+    def self.agent: (?backend: _StorageBackend?) -> Agent::Store
+    def self.build: (backend: _StorageBackend) -> Stores
+    def self.in_memory: () -> Stores
+  end
+end

data/sig/phronomy/runtime_composition/configuration.rbs

@@ -0,0 +1,36 @@
+module Phronomy
+  class ConfigurationError < Error
+  end
+
+  class HandoffError < Error
+  end
+
+  class CancellationError < Error
+  end
+
+  class EventLoopReentrancyError < Error
+  end
+
+  class AgentAlreadyExistsError < Error
+  end
+
+  class AgentPurgedError < Error
+  end
+
+  class PoolShutdownError < Error
+  end
+
+  class BackpressureError < Error
+  end
+
+  class Configuration
+    attr_accessor agent_store: Agent::Store?
+    attr_accessor multi_agent_store: MultiAgent::Store?
+    attr_accessor workflow_store: _WorkflowStateRepository?
+    attr_accessor llm_adapter: LLMAdapter::Base
+    attr_accessor before_llm_input: Agent::_BeforeLLMInputHook?
+  end
+
+  def self.configuration: () -> Configuration
+  def self.configure: () { (Configuration) -> void } -> void
+end

data/sig/phronomy/storage/async/async_client.rbs

@@ -0,0 +1,8 @@
+module Phronomy
+  module Storage
+    class AsyncClient
+      def initialize: (backend: _StorageBackend, ?pool: untyped) -> void
+      def transaction_async: [T] (?cancellation_token: Concurrency::CancellationToken?, ?timeout: Numeric?) { (View) -> T } -> TaskResult[T]
+    end
+  end
+end

data/sig/phronomy/storage/backends/in_memory.rbs

@@ -0,0 +1,9 @@
+module Phronomy
+  module Storage
+    module Backends
+      class InMemory < Backend
+        def initialize: (?resources: Array[Resource]) -> void
+      end
+    end
+  end
+end

data/sig/phronomy/storage/contracts.rbs

@@ -0,0 +1,160 @@
+module Phronomy
+  interface _StorageBackend
+    def view: () -> Storage::View
+    def capabilities: () -> Hash[Symbol, bool | Integer]
+    def transaction_open?: () -> bool
+    def transaction: [T] () { (Storage::View) -> T } -> T
+  end
+
+  module Storage
+    type attributes = Hash[Symbol, String | Integer | bool | nil]
+    type resource_ref = Resource | String
+    type condition = Condition::RevisionIs | Condition::StreamHeadIs | Condition::NoRows
+
+    class ConflictError < Phronomy::Error
+    end
+    class UniqueConstraintError < ConflictError
+      attr_reader resource: String
+      attr_reader constraint: Symbol
+      def initialize: (resource: Resource, constraint: Symbol) -> void
+    end
+    class ConditionFailedError < ConflictError
+      attr_reader condition: condition
+      def initialize: (condition) -> void
+    end
+    class BlobConflictError < ConflictError
+    end
+    class TransactionError < Phronomy::Error
+    end
+    class NotFoundError < Phronomy::Error
+    end
+    class UnsupportedBackendError < Phronomy::Error
+    end
+    class SerializationError < Phronomy::Error
+    end
+
+    class DurableRecord
+      FORMAT_VERSION_PATTERN: Regexp
+      attr_reader record_type: String
+      attr_reader format_version: String
+      attr_reader payload: Hash[String, untyped]
+      def initialize: (record_type: String, format_version: String, payload: Hash[String, untyped]) -> void
+      def copy: () -> DurableRecord
+    end
+
+    class Resource
+      attr_reader id: String
+      attr_reader kind: Symbol
+      attr_reader attributes: Hash[Symbol, Symbol]
+      attr_reader immutable_attributes: Array[Symbol]
+      attr_reader indexes: Hash[Symbol, Array[Symbol]]
+      attr_reader unique: Array[Hash[Symbol, untyped]]
+      attr_reader guard: Hash[Symbol, untyped]?
+      def initialize: (id: String, kind: Symbol, ?attributes: Hash[Symbol, Symbol], ?immutable_attributes: Array[Symbol], ?indexes: Hash[Symbol, Array[Symbol]], ?unique: Array[Hash[Symbol, untyped]], ?guard: Hash[Symbol, untyped]?) -> void
+      def validate_attributes: (attributes, ?partial: bool) -> attributes
+      def index_values: (Symbol, attributes) -> attributes
+    end
+
+    module Entry
+      class Record
+        attr_reader key: String
+        attr_reader revision: Integer
+        attr_reader attributes: attributes
+        attr_reader record: DurableRecord
+        def initialize: (key: String, revision: Integer, attributes: attributes, record: DurableRecord) -> void
+        def to_h: () -> Hash[Symbol, untyped]
+      end
+      class Append
+        attr_reader id: String
+        attr_reader record: DurableRecord
+        def initialize: (id: String, record: DurableRecord) -> void
+        def to_h: () -> Hash[Symbol, untyped]
+      end
+      class Stream
+        attr_reader position: Integer
+        attr_reader id: String
+        attr_reader record: DurableRecord
+        def initialize: (position: Integer, id: String, record: DurableRecord) -> void
+        def to_h: () -> Hash[Symbol, untyped]
+      end
+      class Blob
+        attr_reader key: String
+        attr_reader bytes: String
+        attr_reader attributes: attributes
+        def initialize: (key: String, bytes: String, attributes: attributes) -> void
+        def to_h: () -> Hash[Symbol, untyped]
+      end
+    end
+
+    class GuardRef
+      attr_reader resource: resource_ref
+      attr_reader key: String
+      def initialize: (resource: resource_ref, key: String) -> void
+    end
+    module Condition
+      class RevisionIs
+        attr_reader resource: resource_ref
+        attr_reader key: String
+        attr_reader expected: Integer
+        def initialize: (resource: resource_ref, key: String, expected: Integer) -> void
+      end
+      class StreamHeadIs
+        attr_reader resource: resource_ref
+        attr_reader stream: String
+        attr_reader expected: Integer
+        def initialize: (resource: resource_ref, stream: String, expected: Integer) -> void
+      end
+      class NoRows
+        attr_reader resource: resource_ref
+        attr_reader index: Symbol
+        attr_reader equals: attributes
+        def initialize: (resource: resource_ref, index: Symbol, equals: attributes) -> void
+      end
+    end
+
+    class Records
+      UNCHECKED: Object
+      attr_reader resource: Resource
+      def initialize: (View, Resource) -> void
+      def insert: (key: String, revision: Integer, attributes: attributes, record: DurableRecord) -> Entry::Record
+      def read: (String) -> Entry::Record?
+      def fetch: (String) -> Entry::Record
+      def replace: (key: String, expected_revision: Integer, next_revision: Integer, attributes: attributes, record: DurableRecord, ?expected_attributes: attributes) -> Entry::Record
+      def delete: (key: String, ?expected_revision: Integer | Object) -> nil
+      def scan: (index: Symbol, equals: attributes, ?after: String?, ?limit: Integer?) -> Array[Entry::Record]
+      def delete_matching: (index: Symbol, equals: attributes) -> nil
+    end
+    class Streams
+      attr_reader resource: Resource
+      def initialize: (View, Resource) -> void
+      def append: (stream: String, expected_head: Integer, entries: Array[Entry::Append]) -> Array[Entry::Stream]
+      def read: (stream: String, ?after: Integer, ?limit: Integer?) -> Array[Entry::Stream]
+      def head: (stream: String) -> Integer
+      def delete: (stream: String) -> nil
+    end
+    class Blobs
+      attr_reader resource: Resource
+      def initialize: (View, Resource) -> void
+      def put_if_absent: (key: String, bytes: String, attributes: attributes) -> Entry::Blob
+      def fetch: (String) -> Entry::Blob
+      def exist?: (String) -> bool
+    end
+    class View
+      def records: (resource_ref) -> Records
+      def streams: (resource_ref) -> Streams
+      def blobs: (resource_ref) -> Blobs
+      def check!: (guards: Array[GuardRef], conditions: Array[condition]) -> true
+      def atomic: [T] () { (View) -> T } -> T
+    end
+    class Backend
+      REQUIRED_CAPABILITIES: Hash[Symbol, bool | Integer]
+      attr_reader resources: Hash[String, Resource]
+      attr_reader view: View
+      def initialize: (resources: Array[Resource]) -> void
+      def self.validate_capabilities!: (_StorageBackend backend) -> void
+      def capabilities: () -> Hash[Symbol, bool | Integer]
+      def transaction_open?: () -> bool
+      def transaction: [T] () { (View) -> T } -> T
+    end
+  end
+end

data/sig/phronomy/tool.rbs

@@ -1,10 +1,34 @@
 module Phronomy
   module Tool
+    module Operation
+      def self.call_async: (tool: Base, args: Hash[untyped, untyped], ?cancellation_token: Concurrency::CancellationToken?, ?config: Hash[untyped, untyped], ?submitter: _ExecutionSubmitter, ?on_full: Symbol) -> _CompletionHandle[untyped]
+      def self.with_result_transform: (singleton(Base) tool_class) { (untyped, String, Hash[untyped, untyped]) -> untyped } -> singleton(Base)
+    end
+    class Schema
+      def initialize: (?untyped schema) ?{ () -> untyped } -> void
+      def json_schema: () -> Hash[String, untyped]
+      def validate: (Hash[String | Symbol, untyped] arguments, ?coerce: bool) -> [Hash[Symbol, untyped]?, String?]
+    end
+    class CallRequest
+      attr_reader id: String
+      attr_reader name: String
+      attr_reader arguments: Hash[String, json_value]
+      attr_reader metadata: Hash[String, json_value]
+      def initialize: (id: String, name: String, arguments: Hash[String | Symbol, untyped], ?metadata: Hash[String | Symbol, untyped]) -> void
+      def self.from_h: (Hash[String | Symbol, untyped] value) -> CallRequest
+      def to_h: () -> Hash[String, untyped]
+    end
     class Base
+      def self.parameter: (String | Symbol name, ?type: String | Symbol, ?description: String?, ?required: bool) -> untyped
       def self.tool_name: (?untyped value) -> String?
       def self.description: (?String text) -> String?
       def self.desc: (?String text) -> String?
-      def self.parameters: () -> Hash[untyped, untyped]
+      def self.parameters: (?untyped schema) ?{ () -> untyped } -> untyped
+      def self.declared_parameters: () -> Hash[untyped, untyped]
+      def self.parameters_schema_definition: () -> untyped
+      def self.params: (?untyped schema) ?{ () -> untyped } -> untyped
+      def self.provider_options: (?untyped options) -> Hash[untyped, untyped]
+      def self.with_params: (**untyped options) -> untyped
       def self.params_schema_definition: () -> untyped
       def self.provider_params: () -> Hash[untyped, untyped]
       def self.param: (untyped name, ?enum: untyped, ?properties: untyped, **untyped options) -> untyped
@@ -18,22 +42,51 @@ module Phronomy
       def self.redact_params: (*untyped names) -> Array[Symbol]
       def self.max_result_size: (?untyped value) -> untyped
 
+      def description: () -> String?
       def name: () -> String
+      def parameters_schema: () -> untyped
+      def parameters: () -> Hash[untyped, untyped]
+      def provider_options: () -> Hash[untyped, untyped]
+      def provider_params: () -> Hash[untyped, untyped]
       def params_schema: () -> untyped
+      def validate_arguments: (Hash[String | Symbol, untyped]? args) -> [Hash[Symbol, untyped]?, String?]
       def call: (Hash[untyped, untyped] args, ?cancellation_token: Concurrency::CancellationToken?) -> untyped
       def call_async: (Hash[untyped, untyped] args, ?cancellation_token: Concurrency::CancellationToken?, ?config: Hash[untyped, untyped]) -> TaskResult[untyped]
       def requires_approval?: () -> untyped
       def tool_origin: () -> Symbol
       def approval_metadata: () -> Hash[untyped, untyped]
       def execute: (**untyped args) -> untyped
+
+      private
+
+      def call_async_operation: (Hash[untyped, untyped]? args, cancellation_token: Concurrency::CancellationToken?, operation_name: String) { (Hash[Symbol, untyped]) -> _CompletionHandle[untyped] } -> _CompletionHandle[untyped]
+      def async_error_value: (Exception error) -> untyped
     end
   end
 
-  module Agent
-    module Context
-      module Capability
-        class Base = ::Phronomy::Tool::Base
+end
+
+module Phronomy
+  module Tool
+    interface _AuthorizationRequest
+      def origin: () -> Symbol
+      def with: (?facts: Hash[untyped, untyped], ?default_decision: Symbol?) -> _AuthorizationRequest
+    end
+
+    module Authorization
+      class Decision
+        attr_reader decision: Symbol
+        attr_reader facts: Hash[untyped, untyped]
+        attr_reader reason: String?
       end
+      def self.call: (request: _AuthorizationRequest, arguments: Hash[untyped, untyped], context: Hash[untyped, untyped], ?facts: (^(Hash[untyped, untyped], Hash[untyped, untyped]) -> Hash[untyped, untyped]?)?, ?requirement: bool? | (^(_AuthorizationRequest) -> bool?), ?policy: (^(_AuthorizationRequest) -> Symbol)?) -> Decision
+    end
+
+    class DefinitionSet
+      attr_reader runtime_tools: Array[untyped]
+      attr_reader definitions: Array[Hash[String, untyped]]
+      def self.build: (tools: Array[untyped], ?runtime_tools: Array[untyped]) -> DefinitionSet
+      def select_definitions: (Array[Hash[String, untyped]] expected_definitions) -> DefinitionSet
     end
   end
 end

data/sig/phronomy/tracing/observation.rbs

@@ -0,0 +1,7 @@
+module Phronomy
+  module Tracing
+    module Observation
+      def self.trace: [A] (String name, ?input: untyped, **untyped meta) { (untyped span) -> [A, LLMAdapter::TokenUsage?] } -> A
+    end
+  end
+end

data/sig/phronomy/vector_store/async/async_client.rbs

@@ -0,0 +1,13 @@
+module Phronomy
+  module VectorStore
+    class AsyncClient
+      # pool is an optional internal execution-pool injection; ordinary callers omit it.
+      def initialize: (backend: Base, ?pool: untyped) -> void
+      def add_async: (id: String, embedding: Array[Float], ?metadata: Hash[untyped, untyped], ?cancellation_token: Concurrency::CancellationToken?, ?timeout: Numeric?) -> TaskResult[untyped]
+      def search_async: (query_embedding: Array[Float], ?k: Integer, ?cancellation_token: Concurrency::CancellationToken?, ?timeout: Numeric?) -> TaskResult[Array[Hash[Symbol, untyped]]]
+      def remove_async: (id: String, ?cancellation_token: Concurrency::CancellationToken?, ?timeout: Numeric?) -> TaskResult[untyped]
+      def clear_async: (?cancellation_token: Concurrency::CancellationToken?, ?timeout: Numeric?) -> TaskResult[untyped]
+    end
+
+  end
+end

data/sig/phronomy/vector_store/base.rbs

@@ -0,0 +1,23 @@
+module Phronomy
+  module VectorStore
+    class InvalidResultError < Phronomy::Error
+    end
+
+    class Base
+      def add: (id: String, embedding: Array[Numeric], ?metadata: Hash[untyped, untyped], ?cancellation_token: _CancellationSignal?) -> self
+      def search: (query_embedding: Array[Numeric], ?k: Integer | String, ?cancellation_token: _CancellationSignal?) -> Array[Hash[Symbol, untyped]]
+      def remove: (id: String) -> self
+      def clear: () -> self
+      def size: () -> Integer
+
+      # Protected extension SPI at runtime; RBS has no protected visibility.
+      private
+      def embedding_dimension: () -> Integer?
+      def perform_add: (id: String, embedding: Array[Float], metadata: Hash[untyped, untyped], cancellation_token: _CancellationSignal?) -> untyped
+      def perform_search: (query_embedding: Array[Float], k: Integer, cancellation_token: _CancellationSignal?) -> Array[Hash[Symbol, untyped]]
+      def perform_remove: (id: String) -> untyped
+      def perform_clear: () -> untyped
+      def perform_size: () -> Integer
+    end
+  end
+end

data/sig/phronomy/workflow/execution/workflow_execution_environment.rbs

@@ -0,0 +1,14 @@
+module Phronomy
+  # Private connection selected by composition, not a public application API.
+  class WorkflowExecutionEnvironment
+    def self.install_provider: (^() -> WorkflowExecutionEnvironment provider) -> untyped
+    def self.current: () -> WorkflowExecutionEnvironment
+    def registry: () -> untyped
+    def existing_registry: () -> untyped
+    def executing?: () -> bool
+    def submit: [V] (**untyped options) { () -> V } -> TaskResult[V]
+    def compile_transitions: (**untyped definition) -> untyped
+    def build_session: (**untyped options) -> untyped
+    def register_session: (untyped session, completion: TaskResult[untyped]) -> untyped
+  end
+end

data/sig/phronomy/workflow/runtime_binding/workflow_terminal_policy.rbs

@@ -0,0 +1,7 @@
+module Phronomy
+  class WorkflowTerminalPolicy
+    def start: (terminal_type: Symbol, context: untyped, event_sink: _FSMEventSink) -> untyped
+    def handles?: (Event event) -> bool
+    def decision_for: (Event event) -> TerminalDecision
+  end
+end

data/sig/phronomy/workflow/store.rbs

@@ -0,0 +1,8 @@
+module Phronomy
+  interface _WorkflowStateRepository
+    def load: (String workflow_instance_id) -> Hash[untyped, untyped]?
+    def save: (String workflow_instance_id, expected_revision: Integer?, snapshot: Hash[untyped, untyped]) -> Integer
+    def delete: (String workflow_instance_id, expected_revision: Integer) -> untyped
+  end
+
+end

data/sig/phronomy/workflow.rbs

@@ -8,7 +8,7 @@ module Phronomy
   end
 
   class Workflow
-    def self.define: (Class context_class, ?persistence: Persistence?) { () -> void } -> Workflow
+    def self.define: (Class context_class, ?persistence: _WorkflowStateRepository?) { () -> void } -> Workflow
 
     def invoke: (untyped input, ?config: Hash[untyped, untyped], ?invocation_context: untyped) -> untyped
     def invoke_async: (untyped input, ?config: Hash[untyped, untyped], ?invocation_context: untyped) -> TaskResult[untyped]

data/sig/phronomy.rbs

@@ -7,56 +7,7 @@ module Phronomy
   class ParseError < Error
   end
 
-  class RecursionLimitError < Error
-  end
-
   class ToolError < Error
   end
 
-  class TimeoutError < Error
-  end
-
-  class ConfigurationError < Error
-  end
-
-  class HandoffError < Error
-  end
-
-  class TransportError < Error
-  end
-
-  class RateLimitError < TransportError
-  end
-
-  class AuthenticationError < TransportError
-  end
-
-  class ContextLengthError < Error
-  end
-
-  class CancellationError < Error
-  end
-
-  class EventLoopReentrancyError < Error
-  end
-
-  class AgentAlreadyExistsError < Error
-  end
-
-  class AgentPurgedError < Error
-  end
-
-  class PoolShutdownError < Error
-  end
-
-  class BackpressureError < Error
-  end
-
-  class Configuration
-    attr_accessor llm_adapter: LLMAdapter::Base
-    attr_accessor before_llm_input: Agent::_BeforeLLMInputHook?
-  end
-
-  def self.configuration: () -> Configuration
-  def self.configure: () { (Configuration) -> void } -> void
 end