collavre_completion_api 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: d657f80e16c1705fa79850aa8445aa53d90112de021c9640221f71b15d73f71e
+  data.tar.gz: 4cef77f5d3433dcb90d9c1a1c82c97a8b9c0d56ec727f61e73fab68a3fa68de1
+SHA512:
+  metadata.gz: 4a4d8cbd25e4f17e953085529b075b590e4dd390c1eb2d24cce0bd5a09d4c72ba25434a70b4a85e022a2e2ac8792a2c36adca9efdf657f6ec9565674836ef2a4
+  data.tar.gz: adc77be5cc324e467f24438d3677777259a4474fd44a151c4f7ea7642fe3b65cfaec60dbe41069104802b843ccfa521b1d48625a3c926f770ff0206f4bf2fabb

data/README.md

@@ -0,0 +1,41 @@
+# CollavreCompletionApi
+
+OpenAI-compatible chat completions API for Collavre.
+
+## Endpoints
+
+- `POST /api/v1/chat/completions` — Chat completion (streaming + non-streaming)
+- `GET /api/v1/models` — List accessible AI agents as models
+
+## Authentication
+
+Uses Doorkeeper OAuth Bearer tokens. Pass your OAuth access token as:
+
+```
+Authorization: Bearer <oauth_token>
+```
+
+Compatible with OpenAI SDK:
+
+```python
+from openai import OpenAI
+client = OpenAI(
+    base_url="https://your-collavre.com/api/v1",
+    api_key="<oauth_access_token>"
+)
+```
+
+## Context Injection
+
+Pass optional headers to inject Collavre context into AI prompts:
+
+- `X-Collavre-Creative: <creative_id>` — Include creative context
+- `X-Collavre-Topic: <topic_id>` — Filter context to specific topic
+
+## Installation
+
+Add to your host app's `Gemfile`:
+
+```ruby
+gem "collavre_completion_api", path: "engines/collavre_completion_api"
+```

data/Rakefile

@@ -0,0 +1,2 @@
+require "bundler/setup"
+require "bundler/gem_tasks"

data/app/controllers/collavre_completion_api/api/v1/base_controller.rb

@@ -0,0 +1,74 @@
+# frozen_string_literal: true
+
+module CollavreCompletionApi
+  module Api
+    module V1
+      class BaseController < ActionController::API
+        before_action :authenticate!
+
+        private
+
+        def authenticate!
+          token = extract_bearer_token
+          if token.blank?
+            render json: { error: { message: "Missing authentication token", type: "invalid_request_error",
+                                    code: "missing_token" } },
+                   status: :unauthorized
+            return
+          end
+
+          unless authenticate_oauth(token)
+            render json: { error: { message: "Invalid authentication token", type: "invalid_request_error",
+                                    code: "invalid_token" } },
+                   status: :unauthorized
+            nil
+          end
+        end
+
+        def authenticate_oauth(token)
+          access_token = Doorkeeper::AccessToken.by_token(token)
+          return false unless access_token&.accessible?
+
+          user = Collavre::User.find_by(id: access_token.resource_owner_id)
+          return false unless user
+
+          Collavre::Current.user = user
+          true
+        end
+
+        def extract_bearer_token
+          auth_header = request.headers["Authorization"]
+          return nil unless auth_header&.start_with?("Bearer ")
+
+          auth_header.sub("Bearer ", "")
+        end
+
+        def current_user
+          Collavre::Current.user
+        end
+
+        def collavre_creative
+          @collavre_creative ||= begin
+            creative_id = request.headers["X-Collavre-Creative"]
+            return nil if creative_id.blank?
+
+            creative = Collavre::Creative.find_by(id: creative_id)&.effective_origin
+            return nil unless creative&.has_permission?(current_user, :member)
+
+            creative
+          end
+        end
+
+        def collavre_topic
+          @collavre_topic ||= begin
+            topic_id = request.headers["X-Collavre-Topic"]
+            return nil if topic_id.blank?
+            return nil unless collavre_creative
+
+            collavre_creative.topics.find_by(id: topic_id)
+          end
+        end
+      end
+    end
+  end
+end

data/app/controllers/collavre_completion_api/api/v1/chat/completions_controller.rb

@@ -0,0 +1,214 @@
+# frozen_string_literal: true
+
+module CollavreCompletionApi
+  module Api
+    module V1
+      module Chat
+        class CompletionsController < BaseController
+          CREATIVE_CONTEXT_COMMENT_LIMIT = 20
+
+          def create
+            messages = params[:messages] || []
+            stream = params[:stream] == true || params[:stream] == "true"
+
+            if messages.empty?
+              render json: { error: { message: "messages is required", type: "invalid_request_error" } },
+                     status: :bad_request
+              return
+            end
+
+            agent = resolve_agent
+            unless agent
+              render json: { error: { message: "Invalid model", type: "invalid_request_error" } },
+                     status: :bad_request
+              return
+            end
+
+            system_prompt = build_system_prompt(messages, agent)
+            contents = build_contents(messages)
+
+            # Use agent owner's llm_api_key for external LLM calls
+            api_key = agent.respond_to?(:llm_api_key) ? agent.llm_api_key : nil
+            api_key ||= agent.respond_to?(:creator) ? agent.creator&.llm_api_key : nil
+
+            client = Collavre::AiClient.new(
+              vendor: agent.llm_vendor,
+              model: agent.llm_model,
+              system_prompt: system_prompt,
+              llm_api_key: api_key,
+              context: { creative: collavre_creative, user: current_user }
+            )
+
+            model_name = params[:model] || "collavre/#{agent.id}"
+
+            if stream
+              stream_response(client, contents, model_name)
+            else
+              non_stream_response(client, contents, model_name)
+            end
+          end
+
+          private
+
+          def resolve_agent
+            model_param = params[:model].to_s
+
+            return nil unless model_param.start_with?("collavre/")
+
+            ai_id = model_param.sub("collavre/", "")
+            agent = Collavre::User.find_by(id: ai_id)
+            return nil unless agent&.ai_user?
+            return nil unless agent_accessible?(agent)
+
+            agent
+          end
+
+          def agent_accessible?(agent)
+            agent.created_by_id == current_user.id || agent.searchable?
+          end
+
+          def build_system_prompt(messages, agent)
+            parts = []
+
+            parts << agent.system_prompt if agent.system_prompt.present?
+
+            system_messages = messages.select { |m| m[:role] == "system" || m["role"] == "system" }
+            system_messages.each do |msg|
+              parts << (msg[:content] || msg["content"])
+            end
+
+            parts << build_creative_context if collavre_creative
+
+            parts.compact.join("\n\n").presence || Collavre::AiClient::SYSTEM_INSTRUCTIONS
+          end
+
+          def build_creative_context
+            context_parts = []
+            context_parts << "## Collavre Context"
+            context_parts << "Creative: #{collavre_creative.title}" if collavre_creative.title.present?
+
+            if collavre_topic
+              context_parts << "Topic: #{collavre_topic.title}" if collavre_topic.title.present?
+            end
+
+            scope = collavre_creative.comments
+                                     .where(private: false)
+                                     .order(created_at: :desc)
+            scope = scope.where(topic_id: collavre_topic.id) if collavre_topic
+            recent_comments = scope.limit(CREATIVE_CONTEXT_COMMENT_LIMIT)
+                                   .includes(:user).to_a.reverse
+
+            if recent_comments.any?
+              context_parts << "\n### Recent Discussion"
+              recent_comments.each do |comment|
+                author = comment.user&.name || "Unknown"
+                context_parts << "- **#{author}**: #{comment.content.to_s.truncate(500)}"
+              end
+            end
+
+            context_parts.join("\n")
+          end
+
+          def build_contents(messages)
+            messages.reject { |m|
+              role = m[:role] || m["role"]
+              role == "system"
+            }.map { |m|
+              role = m[:role] || m["role"]
+              content = m[:content] || m["content"]
+              { role: role, text: content }
+            }
+          end
+
+          def non_stream_response(client, contents, model)
+            result = client.chat(contents)
+            completion_id = "chatcmpl-#{SecureRandom.hex(12)}"
+
+            prompt_tokens = client.last_input_tokens
+            completion_tokens = client.last_output_tokens
+
+            render json: {
+              id: completion_id,
+              object: "chat.completion",
+              created: Time.current.to_i,
+              model: model,
+              choices: [
+                {
+                  index: 0,
+                  message: { role: "assistant", content: result || "" },
+                  finish_reason: "stop"
+                }
+              ],
+              usage: {
+                prompt_tokens: prompt_tokens,
+                completion_tokens: completion_tokens,
+                total_tokens: prompt_tokens + completion_tokens
+              }
+            }
+          end
+
+          def stream_response(client, contents, model)
+            completion_id = "chatcmpl-#{SecureRandom.hex(12)}"
+
+            response.headers["Content-Type"] = "text/event-stream"
+            response.headers["Cache-Control"] = "no-cache"
+            response.headers["Connection"] = "keep-alive"
+
+            self.response_body = Enumerator.new do |yielder|
+              begin
+                client.chat(contents) do |chunk|
+                  data = {
+                    id: completion_id,
+                    object: "chat.completion.chunk",
+                    created: Time.current.to_i,
+                    model: model,
+                    choices: [
+                      {
+                        index: 0,
+                        delta: { content: chunk },
+                        finish_reason: nil
+                      }
+                    ]
+                  }
+                  yielder << "data: #{data.to_json}\n\n"
+                end
+
+                final = {
+                  id: completion_id,
+                  object: "chat.completion.chunk",
+                  created: Time.current.to_i,
+                  model: model,
+                  choices: [
+                    {
+                      index: 0,
+                      delta: {},
+                      finish_reason: "stop"
+                    }
+                  ]
+                }
+                yielder << "data: #{final.to_json}\n\n"
+              rescue StandardError => e
+                error_data = {
+                  id: completion_id,
+                  object: "chat.completion.chunk",
+                  created: Time.current.to_i,
+                  model: model,
+                  choices: [
+                    {
+                      index: 0,
+                      delta: { content: "\n\n⚠️ Error: #{e.message}" },
+                      finish_reason: "stop"
+                    }
+                  ]
+                }
+                yielder << "data: #{error_data.to_json}\n\n"
+              ensure
+                yielder << "data: [DONE]\n\n"
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/app/controllers/collavre_completion_api/api/v1/models_controller.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+module CollavreCompletionApi
+  module Api
+    module V1
+      class ModelsController < BaseController
+        def index
+          ai_agents = Collavre::User.accessible_ai_agents_for(current_user)
+
+          models = ai_agents.map do |agent|
+            {
+              id: "collavre/#{agent.id}",
+              object: "model",
+              created: agent.created_at.to_i,
+              owned_by: "collavre",
+              meta: {
+                name: agent.name,
+                llm_vendor: agent.llm_vendor,
+                llm_model: agent.llm_model
+              }
+            }
+          end
+
+          render json: { object: "list", data: models }
+        end
+      end
+    end
+  end
+end

data/config/routes.rb

@@ -0,0 +1,10 @@
+CollavreCompletionApi::Engine.routes.draw do
+  namespace :api do
+    namespace :v1 do
+      resources :models, only: [ :index ]
+      namespace :chat do
+        resources :completions, only: [ :create ]
+      end
+    end
+  end
+end

data/lib/collavre_completion_api/engine.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+module CollavreCompletionApi
+  class Engine < ::Rails::Engine
+    isolate_namespace CollavreCompletionApi
+
+    config.generators do |g|
+      g.test_framework :minitest
+    end
+
+    # Auto-mount engine routes under the Collavre engine
+    initializer "collavre_completion_api.routes", before: :add_routing_paths do |app|
+      app.routes.append do
+        mount CollavreCompletionApi::Engine => "/", as: :collavre_completion_api_engine
+      end
+    end
+  end
+end

data/lib/collavre_completion_api/version.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+module CollavreCompletionApi
+  VERSION = "0.1.0"
+end

data/lib/collavre_completion_api.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+require "collavre_completion_api/version"
+require "collavre_completion_api/engine"
+
+module CollavreCompletionApi
+end

metadata

@@ -0,0 +1,94 @@
+--- !ruby/object:Gem::Specification
+name: collavre_completion_api
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Collavre
+bindir: bin
+cert_chain: []
+date: 1980-01-02 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rails
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '8.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '8.0'
+- !ruby/object:Gem::Dependency
+  name: collavre
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: doorkeeper
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+description: Plugin engine providing OpenAI-compatible /v1/chat/completions and /v1/models
+  endpoints using Collavre AI agents with context injection.
+email:
+- support@collavre.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- README.md
+- Rakefile
+- app/controllers/collavre_completion_api/api/v1/base_controller.rb
+- app/controllers/collavre_completion_api/api/v1/chat/completions_controller.rb
+- app/controllers/collavre_completion_api/api/v1/models_controller.rb
+- config/routes.rb
+- lib/collavre_completion_api.rb
+- lib/collavre_completion_api/engine.rb
+- lib/collavre_completion_api/version.rb
+homepage: https://collavre.com
+licenses:
+- AGPL
+metadata:
+  homepage_uri: https://collavre.com
+  source_code_uri: https://github.com/sh1nj1/plan42
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.6.7
+specification_version: 4
+summary: OpenAI-compatible chat completions API for Collavre
+test_files: []