prompt_objects 0.5.0 → 0.7.0

data/lib/prompt_objects/repositories/run_repository.rb

@@ -0,0 +1,254 @@
+# frozen_string_literal: true
+
+module PromptObjects
+  module Repositories
+    class RunRepository < BaseRepository
+      def enqueue(workspace_session_id:, thread_id:, po_name:, input_content:,
+                  definition_version:, source_type:, source_name: nil,
+                  client_request_id: nil, provider: nil, model: nil,
+                  capability_policy_version: nil, parent_run_id: nil,
+                  priority: 0, metadata: {}, id: SecureRandom.uuid)
+        enqueue_with_result(
+          workspace_session_id: workspace_session_id,
+          thread_id: thread_id,
+          po_name: po_name,
+          input_content: input_content,
+          definition_version: definition_version,
+          source_type: source_type,
+          source_name: source_name,
+          client_request_id: client_request_id,
+          provider: provider,
+          model: model,
+          capability_policy_version: capability_policy_version,
+          parent_run_id: parent_run_id,
+          priority: priority,
+          metadata: metadata,
+          id: id
+        ).first
+      end
+
+      def enqueue_with_result(workspace_session_id:, thread_id:, po_name:, input_content:,
+                              definition_version:, source_type:, source_name: nil,
+                              client_request_id: nil, provider: nil, model: nil,
+                              capability_policy_version: nil, parent_run_id: nil,
+                              priority: 0, metadata: {}, id: SecureRandom.uuid)
+        transaction do |db|
+          if client_request_id
+            existing = find_idempotent(db, workspace_session_id, source_type, client_request_id)
+            next [parse(existing), false] if existing
+          end
+
+          turn_ordinal = db.get_first_value(
+            "SELECT COALESCE(MAX(turn_ordinal), 0) + 1 FROM runs WHERE thread_id = ?",
+            [thread_id]
+          )
+          root_run_id = parent_run_id ? root_for(db, parent_run_id) : id
+          now = Time.now.utc.iso8601
+          params = [
+            id, client_request_id, workspace_session_id, thread_id, po_name,
+            turn_ordinal, input_content, definition_version, provider, model,
+            capability_policy_version, source_type, source_name, parent_run_id,
+            root_run_id, priority, now, JSON.generate(metadata)
+          ]
+          db.execute(<<~SQL, params)
+            INSERT INTO runs (
+              id, client_request_id, workspace_session_id, thread_id, po_name,
+              turn_ordinal, input_content, definition_version, provider, model,
+              capability_policy_version, source_type, source_name, parent_run_id,
+              root_run_id, status, priority, enqueued_at, metadata
+            ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, 'queued', ?, ?, ?)
+          SQL
+          [parse(db.get_first_row("SELECT * FROM runs WHERE id = ?", [id])), true]
+        end
+      rescue SQLite3::ConstraintException
+        existing = client_request_id && get_by_client_request(
+          workspace_session_id: workspace_session_id,
+          source_type: source_type,
+          client_request_id: client_request_id
+        )
+        return [existing, false] if existing
+
+        raise
+      end
+
+      def get(id)
+        row = read { |db| db.get_first_row("SELECT * FROM runs WHERE id = ?", [id]) }
+        row && parse(row)
+      end
+
+      def get_by_client_request(workspace_session_id:, source_type:, client_request_id:)
+        row = read do |db|
+          find_idempotent(db, workspace_session_id, source_type, client_request_id)
+        end
+        row && parse(row)
+      end
+
+      def list(workspace_session_id:, thread_id: nil, statuses: nil, limit: 100)
+        conditions = ["workspace_session_id = ?"]
+        params = [workspace_session_id]
+        if thread_id
+          conditions << "thread_id = ?"
+          params << thread_id
+        end
+        if statuses&.any?
+          unknown = statuses.map(&:to_s) - Execution::Contracts::RUN_STATUSES
+          raise ArgumentError, "unknown run status: #{unknown.first}" if unknown.any?
+
+          conditions << "status IN (#{Array.new(statuses.size, '?').join(', ')})"
+          params.concat(statuses.map(&:to_s))
+        end
+        params << limit
+        sql = "SELECT * FROM runs WHERE #{conditions.join(' AND ')} ORDER BY enqueued_at DESC LIMIT ?"
+        read { |db| db.execute(sql, params) }.map { |row| parse(row) }
+      end
+
+      def tree(root_run_id:)
+        read do |db|
+          db.execute(<<~SQL, [root_run_id, root_run_id, root_run_id]).map { |row| parse(row) }
+            SELECT * FROM runs
+            WHERE id = ? OR root_run_id = ?
+            ORDER BY CASE WHEN id = ? THEN 0 ELSE 1 END,
+              enqueued_at ASC, turn_ordinal ASC, id ASC
+          SQL
+        end
+      end
+
+      def active_for_source(workspace_session_id:, po_name:, source_type:, source_name:)
+        row = read do |db|
+          db.get_first_row(<<~SQL, [workspace_session_id, po_name, source_type, source_name])
+            SELECT * FROM runs
+            WHERE workspace_session_id = ? AND po_name = ? AND source_type = ?
+              AND source_name = ? AND status IN ('queued', 'running', 'waiting')
+            ORDER BY turn_ordinal ASC
+            LIMIT 1
+          SQL
+        end
+        row && parse(row)
+      end
+
+      def thread_head?(run)
+        read do |db|
+          count = db.get_first_value(<<~SQL, [run.thread_id, run.turn_ordinal, run.id])
+            SELECT COUNT(*) FROM runs
+            WHERE thread_id = ? AND turn_ordinal < ? AND id != ?
+              AND status IN ('queued', 'running', 'waiting')
+          SQL
+          count.to_i.zero?
+        end
+      end
+
+      def active_count(workspace_session_id:, po_name: nil)
+        conditions = ["workspace_session_id = ?", "status IN ('queued', 'running', 'waiting')"]
+        params = [workspace_session_id]
+        if po_name
+          conditions << "po_name = ?"
+          params << po_name
+        end
+        read do |db|
+          db.get_first_value(
+            "SELECT COUNT(*) FROM runs WHERE #{conditions.join(' AND ')}",
+            params
+          ).to_i
+        end
+      end
+
+      def active_children(parent_run_id:)
+        read do |db|
+          db.execute(<<~SQL, [parent_run_id]).map { |row| parse(row) }
+            SELECT * FROM runs
+            WHERE parent_run_id = ? AND status IN ('queued', 'running', 'waiting')
+            ORDER BY enqueued_at ASC
+          SQL
+        end
+      end
+
+      def descendant_count(root_run_id:)
+        read do |db|
+          db.get_first_value(
+            "SELECT COUNT(*) FROM runs WHERE root_run_id = ? AND id != ?",
+            [root_run_id, root_run_id]
+          ).to_i
+        end
+      end
+
+      def transition(id, status:, final_response: nil, cancellation_reason: nil,
+                     usage: nil, error: nil, history_cutoff_message_id: nil,
+                     input_message_id: nil)
+        validate_status!(status)
+        now = Time.now.utc.iso8601
+        transaction do |db|
+          current = db.get_first_row("SELECT * FROM runs WHERE id = ?", [id])
+          next nil unless current
+
+          started_at = status.to_s == "running" ? (current["started_at"] || now) : current["started_at"]
+          finished_at = terminal_status?(status) ? now : current["finished_at"]
+          params = [
+            status.to_s, started_at, finished_at, final_response,
+            cancellation_reason, usage && JSON.generate(usage),
+            error&.class&.name, error&.message, history_cutoff_message_id,
+            input_message_id, id
+          ]
+          db.execute(<<~SQL, params)
+            UPDATE runs SET
+              status = ?, started_at = ?, finished_at = ?, final_response = ?,
+              cancellation_reason = ?, usage = ?, error_class = ?, error_message = ?,
+              history_cutoff_message_id = COALESCE(?, history_cutoff_message_id),
+              input_message_id = COALESCE(?, input_message_id)
+            WHERE id = ?
+          SQL
+          db.execute(
+            "UPDATE sessions SET last_run_status = ?, last_activity_at = ?, updated_at = ? WHERE id = ?",
+            [status.to_s, now, now, current["thread_id"]]
+          )
+          parse(db.get_first_row("SELECT * FROM runs WHERE id = ?", [id]))
+        end
+      end
+
+      private
+
+      def find_idempotent(db, workspace_session_id, source_type, client_request_id)
+        db.get_first_row(<<~SQL, [workspace_session_id, source_type, client_request_id])
+          SELECT * FROM runs
+          WHERE workspace_session_id = ? AND source_type = ? AND client_request_id = ?
+          LIMIT 1
+        SQL
+      end
+
+      def root_for(db, parent_run_id)
+        parent = db.get_first_row("SELECT id, root_run_id FROM runs WHERE id = ?", [parent_run_id])
+        raise ArgumentError, "unknown parent run: #{parent_run_id}" unless parent
+
+        parent["root_run_id"] || parent["id"]
+      end
+
+      def validate_status!(status)
+        return if Execution::Contracts::RUN_STATUSES.include?(status.to_s)
+
+        raise ArgumentError, "unknown run status: #{status}"
+      end
+
+      def terminal_status?(status)
+        %w[completed failed cancelled skipped interrupted].include?(status.to_s)
+      end
+
+      def parse(row)
+        Domain::Run.new(
+          id: row["id"], client_request_id: row["client_request_id"],
+          workspace_session_id: row["workspace_session_id"], thread_id: row["thread_id"],
+          po_name: row["po_name"], turn_ordinal: row["turn_ordinal"],
+          input_content: row["input_content"], input_message_id: row["input_message_id"],
+          history_cutoff_message_id: row["history_cutoff_message_id"],
+          definition_version: row["definition_version"], provider: row["provider"], model: row["model"],
+          capability_policy_version: row["capability_policy_version"],
+          source_type: row["source_type"], source_name: row["source_name"],
+          parent_run_id: row["parent_run_id"], root_run_id: row["root_run_id"], status: row["status"],
+          priority: row["priority"], enqueued_at: timestamp(row["enqueued_at"]),
+          started_at: timestamp(row["started_at"]), finished_at: timestamp(row["finished_at"]),
+          cancellation_reason: row["cancellation_reason"], final_response: row["final_response"],
+          usage: json(row["usage"], default: nil), error_class: row["error_class"],
+          error_message: row["error_message"], metadata: json(row["metadata"])
+        )
+      end
+    end
+  end
+end

data/lib/prompt_objects/repositories/thread_repository.rb

@@ -0,0 +1,87 @@
+# frozen_string_literal: true
+
+module PromptObjects
+  module Repositories
+    class ThreadRepository < BaseRepository
+      def create(workspace_session_id:, po_name:, thread_type:, name: nil,
+                 parent_thread_id: nil, parent_run_id: nil, retention_policy: nil,
+                 source: "web", id: SecureRandom.uuid)
+        validate_thread_type!(thread_type)
+        now = Time.now.utc.iso8601
+        transaction do |db|
+          params = [
+            id, po_name, name, source, source, now, now, parent_thread_id,
+            po_name_for_parent(db, parent_thread_id), thread_type, workspace_session_id,
+            parent_run_id, retention_policy, now
+          ]
+          db.execute(<<~SQL, params)
+            INSERT INTO sessions (
+              id, po_name, name, source, last_message_source, created_at, updated_at,
+              parent_session_id, parent_po, thread_type, session_type, workspace_session_id,
+              parent_run_id, retention_policy, archived, last_activity_at
+            ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, 'thread', ?, ?, ?, 0, ?)
+          SQL
+        end
+        get(id)
+      end
+
+      def get(id)
+        row = read { |db| db.get_first_row("SELECT * FROM sessions WHERE id = ? AND po_name IS NOT NULL", [id]) }
+        row && parse(row)
+      end
+
+      def list(workspace_session_id:, po_name: nil, include_archived: false)
+        conditions = ["workspace_session_id = ?", "po_name IS NOT NULL"]
+        params = [workspace_session_id]
+        if po_name
+          conditions << "po_name = ?"
+          params << po_name
+        end
+        conditions << "archived = 0" unless include_archived
+        sql = "SELECT * FROM sessions WHERE #{conditions.join(' AND ')} ORDER BY updated_at DESC"
+        read { |db| db.execute(sql, params) }.map { |row| parse(row) }
+      end
+
+      def archive(id)
+        now = Time.now.utc.iso8601
+        transaction do |db|
+          db.execute("UPDATE sessions SET archived = 1, updated_at = ? WHERE id = ?", [now, id])
+        end
+        get(id)
+      end
+
+      def rename(id, name)
+        now = Time.now.utc.iso8601
+        transaction do |db|
+          db.execute("UPDATE sessions SET name = ?, updated_at = ? WHERE id = ?", [name, now, id])
+        end
+        get(id)
+      end
+
+      private
+
+      def validate_thread_type!(thread_type)
+        return if Execution::Contracts::THREAD_TYPES.include?(thread_type.to_s)
+
+        raise ArgumentError, "unknown thread type: #{thread_type}"
+      end
+
+      def po_name_for_parent(db, parent_thread_id)
+        return nil unless parent_thread_id
+
+        db.get_first_value("SELECT po_name FROM sessions WHERE id = ?", [parent_thread_id])
+      end
+
+      def parse(row)
+        Domain::Thread.new(
+          id: row["id"], workspace_session_id: row["workspace_session_id"],
+          po_name: row["po_name"], thread_type: row["thread_type"], name: row["name"],
+          parent_thread_id: row["parent_session_id"], parent_run_id: row["parent_run_id"],
+          retention_policy: row["retention_policy"], archived: row["archived"].to_i == 1,
+          created_at: timestamp(row["created_at"]), updated_at: timestamp(row["updated_at"]),
+          last_run_status: row["last_run_status"], last_activity_at: timestamp(row["last_activity_at"])
+        )
+      end
+    end
+  end
+end

data/lib/prompt_objects/repositories/tool_execution_repository.rb

@@ -0,0 +1,88 @@
+# frozen_string_literal: true
+
+module PromptObjects
+  module Repositories
+    class ToolExecutionRepository < BaseRepository
+      def create(run_id:, provider_tool_call_id:, batch_id:, batch_position:,
+                 capability_name:, arguments:, capability_policy_version: nil,
+                 resource_keys: [], id: SecureRandom.uuid)
+        transaction do |db|
+          params = [
+            id, provider_tool_call_id, run_id, batch_id, batch_position,
+            capability_name, capability_policy_version, JSON.generate(resource_keys),
+            JSON.generate(arguments)
+          ]
+          db.execute(<<~SQL, params)
+            INSERT INTO tool_executions (
+              id, provider_tool_call_id, run_id, batch_id, batch_position,
+              capability_name, capability_policy_version, status, resource_keys, arguments
+            ) VALUES (?, ?, ?, ?, ?, ?, ?, 'pending', ?, ?)
+          SQL
+        end
+        get(id)
+      end
+
+      def get(id)
+        row = read { |db| db.get_first_row("SELECT * FROM tool_executions WHERE id = ?", [id]) }
+        row && parse(row)
+      end
+
+      def list(run_id:)
+        read do |db|
+          db.execute(
+            "SELECT * FROM tool_executions WHERE run_id = ? ORDER BY batch_position ASC",
+            [run_id]
+          ).map { |row| parse(row) }
+        end
+      end
+
+      def transition(id, status:, result: nil, error: nil, cancellation_reason: nil)
+        validate_status!(status)
+        now = Time.now.utc.iso8601
+        transaction do |db|
+          current = db.get_first_row("SELECT * FROM tool_executions WHERE id = ?", [id])
+          next nil unless current
+
+          started_at = status.to_s == "running" ? (current["started_at"] || now) : current["started_at"]
+          finished_at = terminal_status?(status) ? now : current["finished_at"]
+          params = [
+            status.to_s, result.nil? ? nil : JSON.generate(result), error&.class&.name,
+            error&.message, cancellation_reason, started_at, finished_at, id
+          ]
+          db.execute(<<~SQL, params)
+            UPDATE tool_executions SET
+              status = ?, result = ?, error_class = ?, error_message = ?,
+              cancellation_reason = ?, started_at = ?, finished_at = ?
+            WHERE id = ?
+          SQL
+          parse(db.get_first_row("SELECT * FROM tool_executions WHERE id = ?", [id]))
+        end
+      end
+
+      private
+
+      def validate_status!(status)
+        return if Execution::Contracts::TOOL_EXECUTION_STATUSES.include?(status.to_s)
+
+        raise ArgumentError, "unknown tool execution status: #{status}"
+      end
+
+      def terminal_status?(status)
+        %w[completed failed cancelled timed_out].include?(status.to_s)
+      end
+
+      def parse(row)
+        Domain::ToolExecution.new(
+          id: row["id"], provider_tool_call_id: row["provider_tool_call_id"],
+          run_id: row["run_id"], batch_id: row["batch_id"], batch_position: row["batch_position"],
+          capability_name: row["capability_name"],
+          capability_policy_version: row["capability_policy_version"], status: row["status"],
+          resource_keys: json_array(row["resource_keys"]), arguments: json(row["arguments"]),
+          result: json(row["result"], default: nil), error_class: row["error_class"],
+          error_message: row["error_message"], cancellation_reason: row["cancellation_reason"],
+          started_at: timestamp(row["started_at"]), finished_at: timestamp(row["finished_at"])
+        )
+      end
+    end
+  end
+end

data/lib/prompt_objects/repositories/workspace_session_repository.rb

@@ -0,0 +1,61 @@
+# frozen_string_literal: true
+
+module PromptObjects
+  module Repositories
+    class WorkspaceSessionRepository < BaseRepository
+      def create(name: nil, status: "active", metadata: {}, id: SecureRandom.uuid)
+        now = Time.now.utc.iso8601
+        transaction do |db|
+          db.execute(<<~SQL, [id, name, status, now, now, JSON.generate(metadata)])
+            INSERT INTO workspace_sessions (id, name, status, created_at, updated_at, metadata)
+            VALUES (?, ?, ?, ?, ?, ?)
+          SQL
+        end
+        get(id)
+      end
+
+      def get(id)
+        row = read { |db| db.get_first_row("SELECT * FROM workspace_sessions WHERE id = ?", [id]) }
+        row && parse(row)
+      end
+
+      def list(status: nil)
+        rows = read do |db|
+          if status
+            db.execute("SELECT * FROM workspace_sessions WHERE status = ? ORDER BY updated_at DESC", [status])
+          else
+            db.execute("SELECT * FROM workspace_sessions ORDER BY updated_at DESC")
+          end
+        end
+        rows.map { |row| parse(row) }
+      end
+
+      def update(id, name: nil, status: nil, metadata: nil)
+        current = get(id)
+        return nil unless current
+
+        next_name = name.nil? ? current.name : name
+        next_status = status || current.status
+        next_metadata = metadata ? current.metadata.merge(metadata) : current.metadata
+        now = Time.now.utc.iso8601
+        transaction do |db|
+          db.execute(
+            "UPDATE workspace_sessions SET name = ?, status = ?, metadata = ?, updated_at = ? WHERE id = ?",
+            [next_name, next_status, JSON.generate(next_metadata), now, id]
+          )
+        end
+        get(id)
+      end
+
+      private
+
+      def parse(row)
+        Domain::WorkspaceSession.new(
+          id: row["id"], name: row["name"], status: row["status"],
+          created_at: timestamp(row["created_at"]), updated_at: timestamp(row["updated_at"]),
+          metadata: json(row["metadata"])
+        )
+      end
+    end
+  end
+end