cadenya 0.22.0 → 0.23.0

data/lib/cadenya/resources/objectives.rb

@@ -222,7 +222,7 @@ module Cadenya
       #
       # @param request_options [Cadenya::RequestOptions, Hash{Symbol=>Object}, nil]
       #
-      # @return [Cadenya::Models::ObjectiveContinueResponse]
+      # @return [Cadenya::Models::ObjectiveEvent]
       #
       # @see Cadenya::Models::ObjectiveContinueParams
       def continue(objective_id, params)
@@ -235,7 +235,7 @@ module Cadenya
           method: :post,
           path: ["v1/workspaces/%1$s/objectives/%2$s:continue", workspace_id, objective_id],
           body: parsed,
-          model: Cadenya::Models::ObjectiveContinueResponse,
+          model: Cadenya::ObjectiveEvent,
           options: options
         )
       end
@@ -299,7 +299,7 @@ module Cadenya
       #
       # @param request_options [Cadenya::RequestOptions, Hash{Symbol=>Object}, nil]
       #
-      # @return [Cadenya::Internal::CursorPagination<Cadenya::Models::ObjectiveListEventsResponse>]
+      # @return [Cadenya::Internal::CursorPagination<Cadenya::Models::ObjectiveEvent>]
       #
       # @see Cadenya::Models::ObjectiveListEventsParams
       def list_events(objective_id, params)
@@ -319,7 +319,34 @@ module Cadenya
             window_id: "windowId"
           ),
           page: Cadenya::Internal::CursorPagination,
-          model: Cadenya::Models::ObjectiveListEventsResponse,
+          model: Cadenya::ObjectiveEvent,
+          options: options
+        )
+      end
+
+      # Streams events for an objective in real-time using server-sent events (SSE)
+      #
+      # @overload stream_events_streaming(objective_id, workspace_id:, request_options: {})
+      #
+      # @param objective_id [String]
+      # @param workspace_id [String]
+      # @param request_options [Cadenya::RequestOptions, Hash{Symbol=>Object}, nil]
+      #
+      # @return [Cadenya::Internal::Stream<Cadenya::Models::ObjectiveEvent>]
+      #
+      # @see Cadenya::Models::ObjectiveStreamEventsParams
+      def stream_events_streaming(objective_id, params)
+        parsed, options = Cadenya::ObjectiveStreamEventsParams.dump_request(params)
+        workspace_id =
+          parsed.delete(:workspace_id) do
+            raise ArgumentError.new("missing required path argument #{_1}")
+          end
+        @client.request(
+          method: :get,
+          path: ["v1/workspaces/%1$s/objectives/%2$s/events:stream", workspace_id, objective_id],
+          headers: {"accept" => "text/event-stream", "accept-encoding" => "identity"},
+          stream: Cadenya::Internal::Stream,
+          model: Cadenya::ObjectiveEvent,
           options: options
         )
       end

data/lib/cadenya/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Cadenya
-  VERSION = "0.22.0"
+  VERSION = "0.23.0"
 end

data/lib/cadenya.rb

@@ -45,6 +45,7 @@ require_relative "cadenya/internal/type/array_of"
 require_relative "cadenya/internal/type/hash_of"
 require_relative "cadenya/internal/type/base_model"
 require_relative "cadenya/internal/type/base_page"
+require_relative "cadenya/internal/type/base_stream"
 require_relative "cadenya/internal/type/request_parameters"
 require_relative "cadenya/internal"
 require_relative "cadenya/request_options"
@@ -53,6 +54,7 @@ require_relative "cadenya/errors"
 require_relative "cadenya/internal/transport/base_client"
 require_relative "cadenya/internal/transport/pooled_net_requester"
 require_relative "cadenya/client"
+require_relative "cadenya/internal/stream"
 require_relative "cadenya/internal/cursor_pagination"
 require_relative "cadenya/models/account"
 require_relative "cadenya/models/account_info"
@@ -177,16 +179,15 @@ require_relative "cadenya/models/objective_config_snapshot"
 require_relative "cadenya/models/objective_context_window"
 require_relative "cadenya/models/objective_context_window_data"
 require_relative "cadenya/models/objective_continue_params"
-require_relative "cadenya/models/objective_continue_response"
 require_relative "cadenya/models/objective_create_params"
 require_relative "cadenya/models/objective_error"
+require_relative "cadenya/models/objective_event"
 require_relative "cadenya/models/objective_event_data"
 require_relative "cadenya/models/objective_event_info"
 require_relative "cadenya/models/objective_event_webhook_data"
 require_relative "cadenya/models/objective_info"
 require_relative "cadenya/models/objective_list_context_windows_params"
 require_relative "cadenya/models/objective_list_events_params"
-require_relative "cadenya/models/objective_list_events_response"
 require_relative "cadenya/models/objective_list_params"
 require_relative "cadenya/models/objective_retrieve_params"
 require_relative "cadenya/models/objectives/feedback_create_params"
@@ -215,6 +216,7 @@ require_relative "cadenya/models/objectives/tool_call_list_params"
 require_relative "cadenya/models/objectives/tool_call_retrieve_params"
 require_relative "cadenya/models/objectives/tool_list_params"
 require_relative "cadenya/models/objective_secret"
+require_relative "cadenya/models/objective_stream_events_params"
 require_relative "cadenya/models/operation_metadata"
 require_relative "cadenya/models/page"
 require_relative "cadenya/models/profile"

data/rbi/cadenya/internal/stream.rbi

@@ -0,0 +1,18 @@
+# typed: strong
+
+module Cadenya
+  module Internal
+    class Stream
+      Message =
+        type_member(:in) { { fixed: Cadenya::Internal::Util::ServerSentEvent } }
+      Elem = type_member(:out)
+
+      include Cadenya::Internal::Type::BaseStream
+
+      # @api private
+      sig { override.returns(T::Enumerable[Elem]) }
+      private def iterator
+      end
+    end
+  end
+end

data/rbi/cadenya/internal/transport/base_client.rbi

@@ -49,7 +49,15 @@ module Cadenya
                     ]
                   ]
                 ),
-              stream: T.nilable(T::Class[T.anything]),
+              stream:
+                T.nilable(
+                  T::Class[
+                    Cadenya::Internal::Type::BaseStream[
+                      T.anything,
+                      Cadenya::Internal::Type::BaseModel
+                    ]
+                  ]
+                ),
               model: T.nilable(Cadenya::Internal::Type::Converter::Input),
               options: T.nilable(Cadenya::RequestOptions::OrHash)
             }
@@ -268,7 +276,15 @@ module Cadenya
                   ]
                 ]
               ),
-            stream: T.nilable(T::Class[T.anything]),
+            stream:
+              T.nilable(
+                T::Class[
+                  Cadenya::Internal::Type::BaseStream[
+                    T.anything,
+                    Cadenya::Internal::Type::BaseModel
+                  ]
+                ]
+              ),
             model: T.nilable(Cadenya::Internal::Type::Converter::Input),
             options: T.nilable(Cadenya::RequestOptions::OrHash)
           ).returns(T.anything)

data/rbi/cadenya/internal/type/base_stream.rbi

@@ -0,0 +1,75 @@
+# typed: strong
+
+module Cadenya
+  module Internal
+    module Type
+      # @api private
+      #
+      # This module provides a base implementation for streaming responses in the SDK.
+      module BaseStream
+        include Enumerable
+
+        Message = type_member(:in)
+        Elem = type_member(:out)
+
+        sig { returns(Integer) }
+        attr_reader :status
+
+        sig { returns(T::Hash[String, String]) }
+        attr_reader :headers
+
+        sig { void }
+        def close
+        end
+
+        # @api private
+        sig { overridable.returns(T::Enumerable[Elem]) }
+        private def iterator
+        end
+
+        sig { params(blk: T.proc.params(arg0: Elem).void).void }
+        def each(&blk)
+        end
+
+        sig { returns(T::Enumerator[Elem]) }
+        def to_enum
+        end
+
+        # @api private
+        sig do
+          params(
+            model:
+              T.any(T::Class[T.anything], Cadenya::Internal::Type::Converter),
+            url: URI::Generic,
+            status: Integer,
+            headers: T::Hash[String, String],
+            response: Net::HTTPResponse,
+            unwrap:
+              T.any(
+                Symbol,
+                Integer,
+                T::Array[T.any(Symbol, Integer)],
+                T.proc.params(arg0: T.anything).returns(T.anything)
+              ),
+            stream: T::Enumerable[Message]
+          ).void
+        end
+        def initialize(
+          model:,
+          url:,
+          status:,
+          headers:,
+          response:,
+          unwrap:,
+          stream:
+        )
+        end
+
+        # @api private
+        sig { returns(String) }
+        def inspect
+        end
+      end
+    end
+  end
+end

data/rbi/cadenya/models/ai_provider_key_spec.rbi

@@ -8,29 +8,22 @@ module Cadenya
           T.any(Cadenya::AIProviderKeySpec, Cadenya::Internal::AnyHash)
         end
 
-      # AIProviderConfig holds non-secret, provider-specific settings. The set case must
-      # correspond to AIProviderKeySpec.provider. Providers with no settings (Anthropic,
-      # Gemini) simply leave this unset. The endpoint of a named provider is fixed and
-      # intentionally not overridable here; use the OpenAI-compatible provider to target
-      # a custom endpoint.
-      sig { returns(T.nilable(Cadenya::AIProviderKeySpec::Config)) }
-      attr_reader :config
+      # The provider credential. Accepted on create/update; never populated in responses
+      # (the server returns an empty value to avoid leaking it).
+      sig { returns(T.nilable(String)) }
+      attr_reader :api_key
 
-      sig { params(config: Cadenya::AIProviderKeySpec::Config::OrHash).void }
-      attr_writer :config
+      sig { params(api_key: String).void }
+      attr_writer :api_key
 
-      # AIProviderCredential is the secret material used to authenticate with a
-      # provider. The set case must correspond to AIProviderKeySpec.provider. The server
-      # encrypts the serialized message at rest and never returns it on reads.
-      sig { returns(T.nilable(Cadenya::AIProviderKeySpec::Credentials)) }
-      attr_reader :credentials
+      # OpenRouterConfig holds OpenRouter-specific settings. Empty for now; it exists as
+      # the oneof seam so provider-specific options (region, base URL, etc.) can be
+      # added later without restructuring the spec.
+      sig { returns(T.nilable(T.anything)) }
+      attr_reader :openrouter
 
-      sig do
-        params(
-          credentials: Cadenya::AIProviderKeySpec::Credentials::OrHash
-        ).void
-      end
-      attr_writer :credentials
+      sig { params(openrouter: T.anything).void }
+      attr_writer :openrouter
 
       # The AI provider this key authenticates against.
       sig { returns(T.nilable(Cadenya::AIProviderKeySpec::Provider::OrSymbol)) }
@@ -43,22 +36,19 @@ module Cadenya
 
       sig do
         params(
-          config: Cadenya::AIProviderKeySpec::Config::OrHash,
-          credentials: Cadenya::AIProviderKeySpec::Credentials::OrHash,
+          api_key: String,
+          openrouter: T.anything,
           provider: Cadenya::AIProviderKeySpec::Provider::OrSymbol
         ).returns(T.attached_class)
       end
       def self.new(
-        # AIProviderConfig holds non-secret, provider-specific settings. The set case must
-        # correspond to AIProviderKeySpec.provider. Providers with no settings (Anthropic,
-        # Gemini) simply leave this unset. The endpoint of a named provider is fixed and
-        # intentionally not overridable here; use the OpenAI-compatible provider to target
-        # a custom endpoint.
-        config: nil,
-        # AIProviderCredential is the secret material used to authenticate with a
-        # provider. The set case must correspond to AIProviderKeySpec.provider. The server
-        # encrypts the serialized message at rest and never returns it on reads.
-        credentials: nil,
+        # The provider credential. Accepted on create/update; never populated in responses
+        # (the server returns an empty value to avoid leaking it).
+        api_key: nil,
+        # OpenRouterConfig holds OpenRouter-specific settings. Empty for now; it exists as
+        # the oneof seam so provider-specific options (region, base URL, etc.) can be
+        # added later without restructuring the spec.
+        openrouter: nil,
         # The AI provider this key authenticates against.
         provider: nil
       )
@@ -67,8 +57,8 @@ module Cadenya
       sig do
         override.returns(
           {
-            config: Cadenya::AIProviderKeySpec::Config,
-            credentials: Cadenya::AIProviderKeySpec::Credentials,
+            api_key: String,
+            openrouter: T.anything,
             provider: Cadenya::AIProviderKeySpec::Provider::OrSymbol
           }
         )
@@ -76,315 +66,6 @@ module Cadenya
       def to_hash
       end
 
-      class Config < Cadenya::Internal::Type::BaseModel
-        OrHash =
-          T.type_alias do
-            T.any(
-              Cadenya::AIProviderKeySpec::Config,
-              Cadenya::Internal::AnyHash
-            )
-          end
-
-        # OpenAIConfig holds OpenAI-specific settings.
-        sig { returns(T.nilable(Cadenya::AIProviderKeySpec::Config::OpenAI)) }
-        attr_reader :openai
-
-        sig do
-          params(
-            openai: Cadenya::AIProviderKeySpec::Config::OpenAI::OrHash
-          ).void
-        end
-        attr_writer :openai
-
-        # OpenAICompatibleConfig configures a generic endpoint that speaks the OpenAI Chat
-        # Completions API. The base URL is required and its model catalog is discovered
-        # live via GET {base_url}/models.
-        sig do
-          returns(
-            T.nilable(Cadenya::AIProviderKeySpec::Config::OpenAICompatible)
-          )
-        end
-        attr_reader :openai_compatible
-
-        sig do
-          params(
-            openai_compatible:
-              Cadenya::AIProviderKeySpec::Config::OpenAICompatible::OrHash
-          ).void
-        end
-        attr_writer :openai_compatible
-
-        # OpenRouterConfig holds OpenRouter-specific settings.
-        sig do
-          returns(T.nilable(Cadenya::AIProviderKeySpec::Config::Openrouter))
-        end
-        attr_reader :openrouter
-
-        sig do
-          params(
-            openrouter: Cadenya::AIProviderKeySpec::Config::Openrouter::OrHash
-          ).void
-        end
-        attr_writer :openrouter
-
-        # AIProviderConfig holds non-secret, provider-specific settings. The set case must
-        # correspond to AIProviderKeySpec.provider. Providers with no settings (Anthropic,
-        # Gemini) simply leave this unset. The endpoint of a named provider is fixed and
-        # intentionally not overridable here; use the OpenAI-compatible provider to target
-        # a custom endpoint.
-        sig do
-          params(
-            openai: Cadenya::AIProviderKeySpec::Config::OpenAI::OrHash,
-            openai_compatible:
-              Cadenya::AIProviderKeySpec::Config::OpenAICompatible::OrHash,
-            openrouter: Cadenya::AIProviderKeySpec::Config::Openrouter::OrHash
-          ).returns(T.attached_class)
-        end
-        def self.new(
-          # OpenAIConfig holds OpenAI-specific settings.
-          openai: nil,
-          # OpenAICompatibleConfig configures a generic endpoint that speaks the OpenAI Chat
-          # Completions API. The base URL is required and its model catalog is discovered
-          # live via GET {base_url}/models.
-          openai_compatible: nil,
-          # OpenRouterConfig holds OpenRouter-specific settings.
-          openrouter: nil
-        )
-        end
-
-        sig do
-          override.returns(
-            {
-              openai: Cadenya::AIProviderKeySpec::Config::OpenAI,
-              openai_compatible:
-                Cadenya::AIProviderKeySpec::Config::OpenAICompatible,
-              openrouter: Cadenya::AIProviderKeySpec::Config::Openrouter
-            }
-          )
-        end
-        def to_hash
-        end
-
-        class OpenAI < Cadenya::Internal::Type::BaseModel
-          OrHash =
-            T.type_alias do
-              T.any(
-                Cadenya::AIProviderKeySpec::Config::OpenAI,
-                Cadenya::Internal::AnyHash
-              )
-            end
-
-          # Sent as the OpenAI-Organization header when set.
-          sig { returns(T.nilable(String)) }
-          attr_reader :organization_id
-
-          sig { params(organization_id: String).void }
-          attr_writer :organization_id
-
-          # Sent as the OpenAI-Project header when set.
-          sig { returns(T.nilable(String)) }
-          attr_reader :project_id
-
-          sig { params(project_id: String).void }
-          attr_writer :project_id
-
-          # OpenAIConfig holds OpenAI-specific settings.
-          sig do
-            params(organization_id: String, project_id: String).returns(
-              T.attached_class
-            )
-          end
-          def self.new(
-            # Sent as the OpenAI-Organization header when set.
-            organization_id: nil,
-            # Sent as the OpenAI-Project header when set.
-            project_id: nil
-          )
-          end
-
-          sig do
-            override.returns({ organization_id: String, project_id: String })
-          end
-          def to_hash
-          end
-        end
-
-        class OpenAICompatible < Cadenya::Internal::Type::BaseModel
-          OrHash =
-            T.type_alias do
-              T.any(
-                Cadenya::AIProviderKeySpec::Config::OpenAICompatible,
-                Cadenya::Internal::AnyHash
-              )
-            end
-
-          sig { returns(T.nilable(String)) }
-          attr_reader :base_url
-
-          sig { params(base_url: String).void }
-          attr_writer :base_url
-
-          # OpenAICompatibleConfig configures a generic endpoint that speaks the OpenAI Chat
-          # Completions API. The base URL is required and its model catalog is discovered
-          # live via GET {base_url}/models.
-          sig { params(base_url: String).returns(T.attached_class) }
-          def self.new(base_url: nil)
-          end
-
-          sig { override.returns({ base_url: String }) }
-          def to_hash
-          end
-        end
-
-        class Openrouter < Cadenya::Internal::Type::BaseModel
-          OrHash =
-            T.type_alias do
-              T.any(
-                Cadenya::AIProviderKeySpec::Config::Openrouter,
-                Cadenya::Internal::AnyHash
-              )
-            end
-
-          # Data-residency region (e.g. "us", "eu"). Empty uses the provider default.
-          sig { returns(T.nilable(String)) }
-          attr_reader :region
-
-          sig { params(region: String).void }
-          attr_writer :region
-
-          # OpenRouterConfig holds OpenRouter-specific settings.
-          sig { params(region: String).returns(T.attached_class) }
-          def self.new(
-            # Data-residency region (e.g. "us", "eu"). Empty uses the provider default.
-            region: nil
-          )
-          end
-
-          sig { override.returns({ region: String }) }
-          def to_hash
-          end
-        end
-      end
-
-      class Credentials < Cadenya::Internal::Type::BaseModel
-        OrHash =
-          T.type_alias do
-            T.any(
-              Cadenya::AIProviderKeySpec::Credentials,
-              Cadenya::Internal::AnyHash
-            )
-          end
-
-        # CredentialAPIKey carries a single bearer/header API key.
-        sig do
-          returns(T.nilable(Cadenya::AIProviderKeySpec::Credentials::APIKey))
-        end
-        attr_reader :api_key
-
-        sig do
-          params(
-            api_key: Cadenya::AIProviderKeySpec::Credentials::APIKey::OrHash
-          ).void
-        end
-        attr_writer :api_key
-
-        # CredentialHeaders carries arbitrary HTTP headers sent with every request to the
-        # provider (e.g. {"Authorization": "Bearer ...", "X-Api-Key": "..."}).
-        sig do
-          returns(T.nilable(Cadenya::AIProviderKeySpec::Credentials::Headers))
-        end
-        attr_reader :headers
-
-        sig do
-          params(
-            headers: Cadenya::AIProviderKeySpec::Credentials::Headers::OrHash
-          ).void
-        end
-        attr_writer :headers
-
-        # AIProviderCredential is the secret material used to authenticate with a
-        # provider. The set case must correspond to AIProviderKeySpec.provider. The server
-        # encrypts the serialized message at rest and never returns it on reads.
-        sig do
-          params(
-            api_key: Cadenya::AIProviderKeySpec::Credentials::APIKey::OrHash,
-            headers: Cadenya::AIProviderKeySpec::Credentials::Headers::OrHash
-          ).returns(T.attached_class)
-        end
-        def self.new(
-          # CredentialAPIKey carries a single bearer/header API key.
-          api_key: nil,
-          # CredentialHeaders carries arbitrary HTTP headers sent with every request to the
-          # provider (e.g. {"Authorization": "Bearer ...", "X-Api-Key": "..."}).
-          headers: nil
-        )
-        end
-
-        sig do
-          override.returns(
-            {
-              api_key: Cadenya::AIProviderKeySpec::Credentials::APIKey,
-              headers: Cadenya::AIProviderKeySpec::Credentials::Headers
-            }
-          )
-        end
-        def to_hash
-        end
-
-        class APIKey < Cadenya::Internal::Type::BaseModel
-          OrHash =
-            T.type_alias do
-              T.any(
-                Cadenya::AIProviderKeySpec::Credentials::APIKey,
-                Cadenya::Internal::AnyHash
-              )
-            end
-
-          sig { returns(T.nilable(String)) }
-          attr_reader :api_key
-
-          sig { params(api_key: String).void }
-          attr_writer :api_key
-
-          # CredentialAPIKey carries a single bearer/header API key.
-          sig { params(api_key: String).returns(T.attached_class) }
-          def self.new(api_key: nil)
-          end
-
-          sig { override.returns({ api_key: String }) }
-          def to_hash
-          end
-        end
-
-        class Headers < Cadenya::Internal::Type::BaseModel
-          OrHash =
-            T.type_alias do
-              T.any(
-                Cadenya::AIProviderKeySpec::Credentials::Headers,
-                Cadenya::Internal::AnyHash
-              )
-            end
-
-          sig { returns(T.nilable(T::Hash[Symbol, String])) }
-          attr_reader :headers
-
-          sig { params(headers: T::Hash[Symbol, String]).void }
-          attr_writer :headers
-
-          # CredentialHeaders carries arbitrary HTTP headers sent with every request to the
-          # provider (e.g. {"Authorization": "Bearer ...", "X-Api-Key": "..."}).
-          sig do
-            params(headers: T::Hash[Symbol, String]).returns(T.attached_class)
-          end
-          def self.new(headers: nil)
-          end
-
-          sig { override.returns({ headers: T::Hash[Symbol, String] }) }
-          def to_hash
-          end
-        end
-      end
-
       # The AI provider this key authenticates against.
       module Provider
         extend Cadenya::Internal::Type::Enum
@@ -403,26 +84,6 @@ module Cadenya
             :AI_PROVIDER_OPENROUTER,
             Cadenya::AIProviderKeySpec::Provider::TaggedSymbol
           )
-        AI_PROVIDER_OPENAI =
-          T.let(
-            :AI_PROVIDER_OPENAI,
-            Cadenya::AIProviderKeySpec::Provider::TaggedSymbol
-          )
-        AI_PROVIDER_ANTHROPIC =
-          T.let(
-            :AI_PROVIDER_ANTHROPIC,
-            Cadenya::AIProviderKeySpec::Provider::TaggedSymbol
-          )
-        AI_PROVIDER_GEMINI =
-          T.let(
-            :AI_PROVIDER_GEMINI,
-            Cadenya::AIProviderKeySpec::Provider::TaggedSymbol
-          )
-        AI_PROVIDER_OPENAI_COMPATIBLE =
-          T.let(
-            :AI_PROVIDER_OPENAI_COMPATIBLE,
-            Cadenya::AIProviderKeySpec::Provider::TaggedSymbol
-          )
 
         sig do
           override.returns(

data/rbi/cadenya/models/{objective_continue_response.rbi → objective_event.rbi}

@@ -2,13 +2,10 @@
 
 module Cadenya
   module Models
-    class ObjectiveContinueResponse < Cadenya::Internal::Type::BaseModel
+    class ObjectiveEvent < Cadenya::Internal::Type::BaseModel
       OrHash =
         T.type_alias do
-          T.any(
-            Cadenya::Models::ObjectiveContinueResponse,
-            Cadenya::Internal::AnyHash
-          )
+          T.any(Cadenya::ObjectiveEvent, Cadenya::Internal::AnyHash)
         end
 
       sig { returns(Cadenya::ObjectiveEventData) }