phronomy 0.26.0 → 0.27.0

data/sig/phronomy/persistence.rbs

@@ -1,10 +1,4 @@
 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
@@ -40,37 +34,6 @@ module Phronomy
   # 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
@@ -95,34 +58,6 @@ module Phronomy
     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
@@ -136,36 +71,16 @@ module Phronomy
   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.agent_root: (Hash[untyped, untyped] hash) -> Storage::DurableRecord
+        def self.agent_execution: (Hash[untyped, untyped] hash) -> Storage::DurableRecord
+        def self.journal_record: (Hash[untyped, untyped] hash) -> Storage::DurableRecord
+        def self.workflow_state: (workflow_instance_id: String, revision: Integer, snapshot: Hash[untyped, untyped]) -> Storage::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
@@ -180,10 +95,11 @@ module Phronomy
     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
+    attr_reader backend: _StorageBackend
+    def initialize: (backend: _StorageBackend) -> void
+    def self.in_memory: () -> Persistence
     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
   end
 end

data/sig/phronomy/storage.rbs

@@ -0,0 +1,174 @@
+module Phronomy
+  interface _ContentRepository
+    def put: (String bytes, canonicalization_version: untyped) -> String
+    def fetch: (String content_id) -> String
+    def exist?: (String content_id) -> bool
+    def put_text: (String text) -> String
+    def put_json: (untyped value) -> String
+    def fetch_text: (String content_id) -> String
+    def fetch_json: (String content_id) -> untyped
+    def fetch_many: (Array[String] content_ids) -> Hash[String, String]
+  end
+
+  interface _StorageBackend
+    def view: () -> Storage::View
+    def capabilities: () -> Hash[Symbol, bool | Integer]
+    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: [T] () { (View) -> T } -> T
+    end
+    module Backends
+      class InMemory < Backend
+        def initialize: (?resources: Array[Resource]) -> void
+      end
+    end
+  end
+end

data/sig/phronomy/tool.rbs

@@ -4,7 +4,12 @@ module Phronomy
       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
@@ -19,6 +24,10 @@ module Phronomy
       def self.max_result_size: (?untyped value) -> untyped
 
       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 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]