cadenya 0.3.0 → 0.5.0

data/lib/cadenya/resources/ai_provider_keys.rb

@@ -0,0 +1,173 @@
+# frozen_string_literal: true
+
+module Cadenya
+  module Resources
+    class AIProviderKeys
+      # Some parameter documentations has been truncated, see
+      # {Cadenya::Models::AIProviderKeyCreateParams} for more details.
+      #
+      # Creates a new customer-provided AI provider key in the workspace
+      #
+      # @overload create(workspace_id, metadata:, spec:, request_options: {})
+      #
+      # @param workspace_id [String] The workspace that will own this key.
+      #
+      # @param metadata [Cadenya::Models::CreateResourceMetadata] CreateResourceMetadata contains the user-provided fields for creating
+      #
+      # @param spec [Cadenya::Models::AIProviderKeySpec]
+      #
+      # @param request_options [Cadenya::RequestOptions, Hash{Symbol=>Object}, nil]
+      #
+      # @return [Cadenya::Models::AIProviderKey]
+      #
+      # @see Cadenya::Models::AIProviderKeyCreateParams
+      def create(workspace_id, params)
+        parsed, options = Cadenya::AIProviderKeyCreateParams.dump_request(params)
+        @client.request(
+          method: :post,
+          path: ["v1/workspaces/%1$s/ai_provider_keys", workspace_id],
+          body: parsed,
+          model: Cadenya::AIProviderKey,
+          options: options
+        )
+      end
+
+      # Retrieves an AI provider key by ID from the workspace
+      #
+      # @overload retrieve(id, workspace_id:, request_options: {})
+      #
+      # @param id [String] The key to retrieve.
+      #
+      # @param workspace_id [String] The workspace the key belongs to.
+      #
+      # @param request_options [Cadenya::RequestOptions, Hash{Symbol=>Object}, nil]
+      #
+      # @return [Cadenya::Models::AIProviderKey]
+      #
+      # @see Cadenya::Models::AIProviderKeyRetrieveParams
+      def retrieve(id, params)
+        parsed, options = Cadenya::AIProviderKeyRetrieveParams.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/ai_provider_keys/%2$s", workspace_id, id],
+          model: Cadenya::AIProviderKey,
+          options: options
+        )
+      end
+
+      # Some parameter documentations has been truncated, see
+      # {Cadenya::Models::AIProviderKeyUpdateParams} for more details.
+      #
+      # Updates an AI provider key's name or key value in the workspace
+      #
+      # @overload update(id, workspace_id:, metadata: nil, spec: nil, update_mask: nil, request_options: {})
+      #
+      # @param id [String] Path param: The key to update.
+      #
+      # @param workspace_id [String] Path param: The workspace the key belongs to.
+      #
+      # @param metadata [Cadenya::Models::UpdateResourceMetadata] Body param: UpdateResourceMetadata contains the user-provided fields for updatin
+      #
+      # @param spec [Cadenya::Models::AIProviderKeySpec] Body param
+      #
+      # @param update_mask [String] Body param: Fields to update.
+      #
+      # @param request_options [Cadenya::RequestOptions, Hash{Symbol=>Object}, nil]
+      #
+      # @return [Cadenya::Models::AIProviderKey]
+      #
+      # @see Cadenya::Models::AIProviderKeyUpdateParams
+      def update(id, params)
+        parsed, options = Cadenya::AIProviderKeyUpdateParams.dump_request(params)
+        workspace_id =
+          parsed.delete(:workspace_id) do
+            raise ArgumentError.new("missing required path argument #{_1}")
+          end
+        @client.request(
+          method: :patch,
+          path: ["v1/workspaces/%1$s/ai_provider_keys/%2$s", workspace_id, id],
+          body: parsed,
+          model: Cadenya::AIProviderKey,
+          options: options
+        )
+      end
+
+      # Some parameter documentations has been truncated, see
+      # {Cadenya::Models::AIProviderKeyListParams} for more details.
+      #
+      # Lists all customer-provided AI provider keys in the workspace
+      #
+      # @overload list(workspace_id, cursor: nil, include_info: nil, limit: nil, prefix: nil, query: nil, sort_order: nil, request_options: {})
+      #
+      # @param workspace_id [String] The workspace whose keys will be listed.
+      #
+      # @param cursor [String] Pagination cursor from previous response
+      #
+      # @param include_info [Boolean] When true, populate each item's info (model counts), at the cost of extra
+      #
+      # @param limit [Integer] Maximum number of results to return
+      #
+      # @param prefix [String] Filter expression (query param: prefix)
+      #
+      # @param query [String] Free-form search query
+      #
+      # @param sort_order [String] Sort order for results (asc or desc by creation time)
+      #
+      # @param request_options [Cadenya::RequestOptions, Hash{Symbol=>Object}, nil]
+      #
+      # @return [Cadenya::Internal::CursorPagination<Cadenya::Models::AIProviderKey>]
+      #
+      # @see Cadenya::Models::AIProviderKeyListParams
+      def list(workspace_id, params = {})
+        parsed, options = Cadenya::AIProviderKeyListParams.dump_request(params)
+        query = Cadenya::Internal::Util.encode_query_params(parsed)
+        @client.request(
+          method: :get,
+          path: ["v1/workspaces/%1$s/ai_provider_keys", workspace_id],
+          query: query.transform_keys(include_info: "includeInfo", sort_order: "sortOrder"),
+          page: Cadenya::Internal::CursorPagination,
+          model: Cadenya::AIProviderKey,
+          options: options
+        )
+      end
+
+      # Deletes an AI provider key from the workspace
+      #
+      # @overload delete(id, workspace_id:, request_options: {})
+      #
+      # @param id [String] The key to delete.
+      #
+      # @param workspace_id [String] The workspace the key belongs to.
+      #
+      # @param request_options [Cadenya::RequestOptions, Hash{Symbol=>Object}, nil]
+      #
+      # @return [nil]
+      #
+      # @see Cadenya::Models::AIProviderKeyDeleteParams
+      def delete(id, params)
+        parsed, options = Cadenya::AIProviderKeyDeleteParams.dump_request(params)
+        workspace_id =
+          parsed.delete(:workspace_id) do
+            raise ArgumentError.new("missing required path argument #{_1}")
+          end
+        @client.request(
+          method: :delete,
+          path: ["v1/workspaces/%1$s/ai_provider_keys/%2$s", workspace_id, id],
+          model: NilClass,
+          options: options
+        )
+      end
+
+      # @api private
+      #
+      # @param client [Cadenya::Client]
+      def initialize(client:)
+        @client = client
+      end
+    end
+  end
+end

data/lib/cadenya/resources/models.rb

@@ -33,16 +33,23 @@ module Cadenya
         )
       end
 
+      # Some parameter documentations has been truncated, see
+      # {Cadenya::Models::ModelListParams} for more details.
+      #
       # Lists all models in the workspace
       #
-      # @overload list(workspace_id, bundle_key: nil, cursor: nil, limit: nil, prefix: nil, query: nil, sort_order: nil, status: nil, request_options: {})
+      # @overload list(workspace_id, ai_provider_key_id: nil, bundle_key: nil, cursor: nil, include_info: nil, limit: nil, prefix: nil, query: nil, sort_order: nil, status: nil, request_options: {})
       #
       # @param workspace_id [String] Workspace ID.
       #
+      # @param ai_provider_key_id [String] Filter to models provisioned on a specific AI provider key. Accepts the
+      #
       # @param bundle_key [String] Filter by bundle_key — return only resources owned by this bundle.
       #
       # @param cursor [String] Pagination cursor from previous response
       #
+      # @param include_info [Boolean] When true, populate each item's info (e.g. the AI provider), at the cost of
+      #
       # @param limit [Integer] Maximum number of results to return
       #
       # @param prefix [String] Filter by name prefix
@@ -64,7 +71,12 @@ module Cadenya
         @client.request(
           method: :get,
           path: ["v1/workspaces/%1$s/models", workspace_id],
-          query: query.transform_keys(bundle_key: "bundleKey", sort_order: "sortOrder"),
+          query: query.transform_keys(
+            ai_provider_key_id: "aiProviderKeyId",
+            bundle_key: "bundleKey",
+            include_info: "includeInfo",
+            sort_order: "sortOrder"
+          ),
           page: Cadenya::Internal::CursorPagination,
           model: Cadenya::Model,
           options: options

data/lib/cadenya/version.rb

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

data/lib/cadenya.rb

@@ -108,6 +108,13 @@ require_relative "cadenya/models/agent_schedule_entry"
 require_relative "cadenya/models/agent_spec"
 require_relative "cadenya/models/agent_update_params"
 require_relative "cadenya/models/agent_variation_entry"
+require_relative "cadenya/models/ai_provider_key"
+require_relative "cadenya/models/ai_provider_key_create_params"
+require_relative "cadenya/models/ai_provider_key_delete_params"
+require_relative "cadenya/models/ai_provider_key_list_params"
+require_relative "cadenya/models/ai_provider_key_retrieve_params"
+require_relative "cadenya/models/ai_provider_key_spec"
+require_relative "cadenya/models/ai_provider_key_update_params"
 require_relative "cadenya/models/api_key"
 require_relative "cadenya/models/api_key_create_params"
 require_relative "cadenya/models/api_key_delete_params"
@@ -309,6 +316,7 @@ require_relative "cadenya/resources/agents/feedback"
 require_relative "cadenya/resources/agents/schedules"
 require_relative "cadenya/resources/agents/variations"
 require_relative "cadenya/resources/agents/webhook_deliveries"
+require_relative "cadenya/resources/ai_provider_keys"
 require_relative "cadenya/resources/api_keys"
 require_relative "cadenya/resources/api_keys/access"
 require_relative "cadenya/resources/bulk_workspace_resources"

data/rbi/cadenya/client.rbi

@@ -16,6 +16,9 @@ module Cadenya
     sig { returns(T.nilable(String)) }
     attr_reader :webhook_key
 
+    sig { returns(Cadenya::Resources::AIProviderKeys) }
+    attr_reader :ai_provider_keys
+
     # Manage the authenticated account. Accounts are the top-level organizational unit
     # and contain one or more workspaces.
     sig { returns(Cadenya::Resources::Account) }

data/rbi/cadenya/models/ai_provider_key.rbi

@@ -0,0 +1,109 @@
+# typed: strong
+
+module Cadenya
+  module Models
+    class AIProviderKey < Cadenya::Internal::Type::BaseModel
+      OrHash =
+        T.type_alias do
+          T.any(Cadenya::AIProviderKey, Cadenya::Internal::AnyHash)
+        end
+
+      # Standard metadata for persistent, named resources (e.g., agents, tools, prompts)
+      sig { returns(Cadenya::ResourceMetadata) }
+      attr_reader :metadata
+
+      sig { params(metadata: Cadenya::ResourceMetadata::OrHash).void }
+      attr_writer :metadata
+
+      sig { returns(Cadenya::AIProviderKeySpec) }
+      attr_reader :spec
+
+      sig { params(spec: Cadenya::AIProviderKeySpec::OrHash).void }
+      attr_writer :spec
+
+      # AIProviderKeyInfo carries server-derived, read-only details about a key, for AI
+      # provider management UIs.
+      sig { returns(T.nilable(Cadenya::AIProviderKey::Info)) }
+      attr_reader :info
+
+      sig { params(info: Cadenya::AIProviderKey::Info::OrHash).void }
+      attr_writer :info
+
+      # AIProviderKey is a customer-provided (BYOK) credential for an AI provider,
+      # scoped to a workspace. The secret value is never returned in responses.
+      sig do
+        params(
+          metadata: Cadenya::ResourceMetadata::OrHash,
+          spec: Cadenya::AIProviderKeySpec::OrHash,
+          info: Cadenya::AIProviderKey::Info::OrHash
+        ).returns(T.attached_class)
+      end
+      def self.new(
+        # Standard metadata for persistent, named resources (e.g., agents, tools, prompts)
+        metadata:,
+        spec:,
+        # AIProviderKeyInfo carries server-derived, read-only details about a key, for AI
+        # provider management UIs.
+        info: nil
+      )
+      end
+
+      sig do
+        override.returns(
+          {
+            metadata: Cadenya::ResourceMetadata,
+            spec: Cadenya::AIProviderKeySpec,
+            info: Cadenya::AIProviderKey::Info
+          }
+        )
+      end
+      def to_hash
+      end
+
+      class Info < Cadenya::Internal::Type::BaseModel
+        OrHash =
+          T.type_alias do
+            T.any(Cadenya::AIProviderKey::Info, Cadenya::Internal::AnyHash)
+          end
+
+        # Number of disabled models provisioned on this key.
+        sig { returns(T.nilable(Integer)) }
+        attr_reader :disabled_model_count
+
+        sig { params(disabled_model_count: Integer).void }
+        attr_writer :disabled_model_count
+
+        # Number of enabled models provisioned on this key.
+        sig { returns(T.nilable(Integer)) }
+        attr_reader :enabled_model_count
+
+        sig { params(enabled_model_count: Integer).void }
+        attr_writer :enabled_model_count
+
+        # AIProviderKeyInfo carries server-derived, read-only details about a key, for AI
+        # provider management UIs.
+        sig do
+          params(
+            disabled_model_count: Integer,
+            enabled_model_count: Integer
+          ).returns(T.attached_class)
+        end
+        def self.new(
+          # Number of disabled models provisioned on this key.
+          disabled_model_count: nil,
+          # Number of enabled models provisioned on this key.
+          enabled_model_count: nil
+        )
+        end
+
+        sig do
+          override.returns(
+            { disabled_model_count: Integer, enabled_model_count: Integer }
+          )
+        end
+        def to_hash
+        end
+      end
+    end
+  end
+end

data/rbi/cadenya/models/ai_provider_key_create_params.rbi

@@ -0,0 +1,65 @@
+# typed: strong
+
+module Cadenya
+  module Models
+    class AIProviderKeyCreateParams < Cadenya::Internal::Type::BaseModel
+      extend Cadenya::Internal::Type::RequestParameters::Converter
+      include Cadenya::Internal::Type::RequestParameters
+
+      OrHash =
+        T.type_alias do
+          T.any(Cadenya::AIProviderKeyCreateParams, Cadenya::Internal::AnyHash)
+        end
+
+      sig { returns(String) }
+      attr_accessor :workspace_id
+
+      # CreateResourceMetadata contains the user-provided fields for creating a
+      # workspace-scoped resource. Read-only fields (id, account_id, workspace_id,
+      # profile_id, created_at) are excluded since they are set by the server.
+      sig { returns(Cadenya::CreateResourceMetadata) }
+      attr_reader :metadata
+
+      sig { params(metadata: Cadenya::CreateResourceMetadata::OrHash).void }
+      attr_writer :metadata
+
+      sig { returns(Cadenya::AIProviderKeySpec) }
+      attr_reader :spec
+
+      sig { params(spec: Cadenya::AIProviderKeySpec::OrHash).void }
+      attr_writer :spec
+
+      sig do
+        params(
+          workspace_id: String,
+          metadata: Cadenya::CreateResourceMetadata::OrHash,
+          spec: Cadenya::AIProviderKeySpec::OrHash,
+          request_options: Cadenya::RequestOptions::OrHash
+        ).returns(T.attached_class)
+      end
+      def self.new(
+        workspace_id:,
+        # CreateResourceMetadata contains the user-provided fields for creating a
+        # workspace-scoped resource. Read-only fields (id, account_id, workspace_id,
+        # profile_id, created_at) are excluded since they are set by the server.
+        metadata:,
+        spec:,
+        request_options: {}
+      )
+      end
+
+      sig do
+        override.returns(
+          {
+            workspace_id: String,
+            metadata: Cadenya::CreateResourceMetadata,
+            spec: Cadenya::AIProviderKeySpec,
+            request_options: Cadenya::RequestOptions
+          }
+        )
+      end
+      def to_hash
+      end
+    end
+  end
+end

data/rbi/cadenya/models/ai_provider_key_delete_params.rbi

@@ -0,0 +1,43 @@
+# typed: strong
+
+module Cadenya
+  module Models
+    class AIProviderKeyDeleteParams < Cadenya::Internal::Type::BaseModel
+      extend Cadenya::Internal::Type::RequestParameters::Converter
+      include Cadenya::Internal::Type::RequestParameters
+
+      OrHash =
+        T.type_alias do
+          T.any(Cadenya::AIProviderKeyDeleteParams, Cadenya::Internal::AnyHash)
+        end
+
+      sig { returns(String) }
+      attr_accessor :workspace_id
+
+      sig { returns(String) }
+      attr_accessor :id
+
+      sig do
+        params(
+          workspace_id: String,
+          id: String,
+          request_options: Cadenya::RequestOptions::OrHash
+        ).returns(T.attached_class)
+      end
+      def self.new(workspace_id:, id:, request_options: {})
+      end
+
+      sig do
+        override.returns(
+          {
+            workspace_id: String,
+            id: String,
+            request_options: Cadenya::RequestOptions
+          }
+        )
+      end
+      def to_hash
+      end
+    end
+  end
+end

data/rbi/cadenya/models/ai_provider_key_list_params.rbi

@@ -0,0 +1,109 @@
+# typed: strong
+
+module Cadenya
+  module Models
+    class AIProviderKeyListParams < Cadenya::Internal::Type::BaseModel
+      extend Cadenya::Internal::Type::RequestParameters::Converter
+      include Cadenya::Internal::Type::RequestParameters
+
+      OrHash =
+        T.type_alias do
+          T.any(Cadenya::AIProviderKeyListParams, Cadenya::Internal::AnyHash)
+        end
+
+      sig { returns(String) }
+      attr_accessor :workspace_id
+
+      # Pagination cursor from previous response
+      sig { returns(T.nilable(String)) }
+      attr_reader :cursor
+
+      sig { params(cursor: String).void }
+      attr_writer :cursor
+
+      # When true, populate each item's info (model counts), at the cost of extra
+      # lookups.
+      sig { returns(T.nilable(T::Boolean)) }
+      attr_reader :include_info
+
+      sig { params(include_info: T::Boolean).void }
+      attr_writer :include_info
+
+      # Maximum number of results to return
+      sig { returns(T.nilable(Integer)) }
+      attr_reader :limit
+
+      sig { params(limit: Integer).void }
+      attr_writer :limit
+
+      # Filter expression (query param: prefix)
+      sig { returns(T.nilable(String)) }
+      attr_reader :prefix
+
+      sig { params(prefix: String).void }
+      attr_writer :prefix
+
+      # Free-form search query
+      sig { returns(T.nilable(String)) }
+      attr_reader :query
+
+      sig { params(query: String).void }
+      attr_writer :query
+
+      # Sort order for results (asc or desc by creation time)
+      sig { returns(T.nilable(String)) }
+      attr_reader :sort_order
+
+      sig { params(sort_order: String).void }
+      attr_writer :sort_order
+
+      sig do
+        params(
+          workspace_id: String,
+          cursor: String,
+          include_info: T::Boolean,
+          limit: Integer,
+          prefix: String,
+          query: String,
+          sort_order: String,
+          request_options: Cadenya::RequestOptions::OrHash
+        ).returns(T.attached_class)
+      end
+      def self.new(
+        workspace_id:,
+        # Pagination cursor from previous response
+        cursor: nil,
+        # When true, populate each item's info (model counts), at the cost of extra
+        # lookups.
+        include_info: nil,
+        # Maximum number of results to return
+        limit: nil,
+        # Filter expression (query param: prefix)
+        prefix: nil,
+        # Free-form search query
+        query: nil,
+        # Sort order for results (asc or desc by creation time)
+        sort_order: nil,
+        request_options: {}
+      )
+      end
+
+      sig do
+        override.returns(
+          {
+            workspace_id: String,
+            cursor: String,
+            include_info: T::Boolean,
+            limit: Integer,
+            prefix: String,
+            query: String,
+            sort_order: String,
+            request_options: Cadenya::RequestOptions
+          }
+        )
+      end
+      def to_hash
+      end
+    end
+  end
+end

data/rbi/cadenya/models/ai_provider_key_retrieve_params.rbi

@@ -0,0 +1,46 @@
+# typed: strong
+
+module Cadenya
+  module Models
+    class AIProviderKeyRetrieveParams < Cadenya::Internal::Type::BaseModel
+      extend Cadenya::Internal::Type::RequestParameters::Converter
+      include Cadenya::Internal::Type::RequestParameters
+
+      OrHash =
+        T.type_alias do
+          T.any(
+            Cadenya::AIProviderKeyRetrieveParams,
+            Cadenya::Internal::AnyHash
+          )
+        end
+
+      sig { returns(String) }
+      attr_accessor :workspace_id
+
+      sig { returns(String) }
+      attr_accessor :id
+
+      sig do
+        params(
+          workspace_id: String,
+          id: String,
+          request_options: Cadenya::RequestOptions::OrHash
+        ).returns(T.attached_class)
+      end
+      def self.new(workspace_id:, id:, request_options: {})
+      end
+
+      sig do
+        override.returns(
+          {
+            workspace_id: String,
+            id: String,
+            request_options: Cadenya::RequestOptions
+          }
+        )
+      end
+      def to_hash
+      end
+    end
+  end
+end