prompt_objects 0.3.1 → 0.5.0

data/frontend/tailwind.config.js

@@ -7,18 +7,37 @@ export default {
   theme: {
     extend: {
       colors: {
-        // Custom colors for PromptObjects
         po: {
-          bg: '#0f0f1a',
-          surface: '#1a1a2e',
-          border: '#2d2d44',
-          accent: '#7c3aed',
-          'accent-hover': '#9061f9',
-          success: '#22c55e',
-          warning: '#f59e0b',
-          error: '#ef4444',
+          bg: '#1a1918',
+          surface: '#222120',
+          'surface-2': '#2c2a28',
+          'surface-3': '#363432',
+          border: '#3d3a37',
+          'border-focus': '#5c5752',
+          accent: '#d4952a',
+          'accent-muted': '#9a6d20',
+          'accent-wash': 'rgba(212,149,42,0.08)',
+          'text-primary': '#e8e2da',
+          'text-secondary': '#a8a29a',
+          'text-tertiary': '#78726a',
+          'text-ghost': '#524e48',
+          'status-idle': '#78726a',
+          'status-active': '#d4952a',
+          'status-calling': '#3b9a6e',
+          'status-error': '#c45c4a',
+          'status-delegated': '#5a8fc2',
+          success: '#3b9a6e',
+          warning: '#d4952a',
+          error: '#c45c4a',
         },
       },
+      fontFamily: {
+        ui: ['Geist', 'system-ui', 'sans-serif'],
+        mono: ['"Geist Mono"', '"IBM Plex Mono"', 'monospace'],
+      },
+      fontSize: {
+        '2xs': ['11px', { lineHeight: '15px' }],
+      },
     },
   },
   plugins: [],

data/lib/prompt_objects/capability.rb

@@ -27,11 +27,33 @@ module PromptObjects
         function: {
           name: name,
           description: description,
-          parameters: parameters
+          parameters: sanitize_schema(parameters)
         }
       }
     end
 
+    private
+
+    # Ensure array-typed properties have an `items` field.
+    # LLM APIs (Gemini, OpenAI, Ollama) reject array schemas without items.
+    def sanitize_schema(schema)
+      return schema unless schema.is_a?(Hash)
+
+      schema = schema.dup
+
+      if schema[:type] == "array" && !schema.key?(:items) && !schema.key?("items")
+        schema[:items] = {}
+      end
+
+      if schema[:properties].is_a?(Hash)
+        schema[:properties] = schema[:properties].transform_values { |v| sanitize_schema(v) }
+      end
+
+      schema
+    end
+
+    public
+
     # Define the parameters this capability accepts.
     # Override in subclasses for specific parameter schemas.
     # @return [Hash] JSON Schema for parameters

data/lib/prompt_objects/connectors/mcp.rb

@@ -176,20 +176,14 @@ module PromptObjects
 
           input_schema(
             type: "object",
-            properties: {},
-            required: []
+            properties: {}
           )
 
           def self.call(server_context:)
             env = server_context[:env]
 
             pos = env.registry.prompt_objects.map do |po|
-              {
-                name: po.name,
-                description: po.description,
-                state: po.state.to_s,
-                capabilities: po.config["capabilities"] || []
-              }
+              po.to_summary_hash(registry: env.registry)
             end
 
             ::MCP::Tool::Response.new([{
@@ -367,8 +361,7 @@ module PromptObjects
                 type: "string",
                 description: "Filter by source: tui, mcp, api, web (optional)"
               }
-            },
-            required: []
+            }
           )
 
           def self.call(po_name: nil, source: nil, server_context:)
@@ -413,8 +406,7 @@ module PromptObjects
 
           input_schema(
             type: "object",
-            properties: {},
-            required: []
+            properties: {}
           )
 
           def self.call(server_context:)
@@ -502,16 +494,7 @@ module PromptObjects
               }])
             end
 
-            info = {
-              name: po.name,
-              description: po.description,
-              state: po.state.to_s,
-              prompt: po.body,
-              capabilities: po.config["capabilities"] || [],
-              config: po.config,
-              session_id: po.instance_variable_get(:@session_id),
-              history_length: po.history.length
-            }
+            info = po.to_inspect_hash(registry: env.registry)
 
             ::MCP::Tool::Response.new([{
               type: "text",

data/lib/prompt_objects/environment.rb

@@ -41,6 +41,7 @@ module PromptObjects
                 :current_provider, :current_model
     attr_accessor :on_po_registered  # Callback for when a PO is registered
     attr_accessor :on_po_modified    # Callback for when a PO is modified (capabilities changed, etc.)
+    attr_accessor :on_delegation_event  # Callback for PO-to-PO delegation start/complete
 
     # Initialize from an environment path (with manifest) or objects directory.
     # @param env_path [String, nil] Path to environment directory (preferred)
@@ -215,6 +216,13 @@ module PromptObjects
       @on_po_modified&.call(po)
     end
 
+    # Notify that a PO-to-PO delegation has started or completed.
+    # @param event_type [Symbol] :started or :completed
+    # @param payload [Hash] { target:, caller:, thread_id:, tool_call_id: }
+    def notify_delegation(event_type, payload)
+      @on_delegation_event&.call(event_type, payload)
+    end
+
     # Load a prompt object by name from the objects directory.
     # @param name [String] Name of the prompt object (without .md extension)
     # @return [PromptObject]

data/lib/prompt_objects/llm/openai_adapter.rb

@@ -37,7 +37,29 @@ module PromptObjects
         end
 
         raw_response = @client.chat(parameters: params)
+
+        # Check for error responses (Ollama and some providers return errors inline)
+        if raw_response.is_a?(Hash) && raw_response["error"]
+          error_msg = raw_response["error"]
+          error_msg = error_msg["message"] if error_msg.is_a?(Hash)
+          raise Error, "#{@provider_name} API error: #{error_msg}"
+        end
+
         parse_response(raw_response)
+      rescue Faraday::ClientError => e
+        # Extract error body from 4xx responses (ruby-openai wraps these)
+        body = e.response&.dig(:body) rescue nil
+        detail = if body.is_a?(String)
+                   begin
+                     parsed = JSON.parse(body)
+                     parsed.dig("error", "message") || parsed["error"] || body
+                   rescue JSON::ParserError
+                     body
+                   end
+                 elsif body.is_a?(Hash)
+                   body.dig("error", "message") || body["error"] || body.to_s
+                 end
+        raise Error, "#{@provider_name} API error (#{e.response&.dig(:status)}): #{detail || e.message}"
       end
 
       private

data/lib/prompt_objects/mcp/tools/get_pending_requests.rb

@@ -15,8 +15,7 @@ module PromptObjects
               type: "string",
               description: "Optional: filter to requests from a specific PO"
             }
-          },
-          required: []
+          }
         )
 
         def self.call(po_name: nil, server_context:)

data/lib/prompt_objects/mcp/tools/inspect_po.rb

@@ -30,37 +30,7 @@ module PromptObjects
             }])
           end
 
-          # Categorize capabilities
-          declared_caps = po.config["capabilities"] || []
-          universal_caps = PromptObjects::UNIVERSAL_CAPABILITIES
-
-          # Resolve which are POs vs primitives
-          delegates = []
-          primitives = []
-
-          declared_caps.each do |cap_name|
-            cap = env.registry.get(cap_name)
-            if cap.is_a?(PromptObjects::PromptObject)
-              delegates << cap_name
-            elsif cap.is_a?(PromptObjects::Primitive)
-              primitives << cap_name
-            end
-          end
-
-          info = {
-            name: po.name,
-            description: po.description,
-            state: po.state || :idle,
-            config: po.config,
-            capabilities: {
-              universal: universal_caps,
-              primitives: primitives,
-              delegates: delegates,
-              all_declared: declared_caps
-            },
-            prompt_body: po.body,
-            history_length: po.history.length
-          }
+          info = po.to_inspect_hash(registry: env.registry)
 
           ::MCP::Tool::Response.new([{
             type: "text",

data/lib/prompt_objects/mcp/tools/list_prompt_objects.rb

@@ -10,20 +10,14 @@ module PromptObjects
 
         input_schema(
           type: "object",
-          properties: {},
-          required: []
+          properties: {}
         )
 
         def self.call(server_context:, **_args)
           env = server_context[:env]
 
           pos = env.registry.prompt_objects.map do |po|
-            {
-              name: po.name,
-              description: po.description,
-              state: po.state || :idle,
-              capabilities: po.config["capabilities"] || []
-            }
+            po.to_summary_hash(registry: env.registry)
           end
 
           ::MCP::Tool::Response.new([{

data/lib/prompt_objects/primitives/list_files.rb

@@ -20,8 +20,7 @@ module PromptObjects
               type: "string",
               description: "The directory path to list (defaults to current directory)"
             }
-          },
-          required: []
+          }
         }
       end
 

data/lib/prompt_objects/prompt_object.rb

@@ -232,8 +232,134 @@ module PromptObjects
       @session_id
     end
 
+    # --- Serialization ---
+    # Canonical methods for converting PO state to hashes for broadcasting,
+    # REST API responses, and MCP tool output. All consumers should use these
+    # to ensure consistent capability format across WebSocket, REST, and MCP.
+
+    # Full state hash for WebSocket/broadcast consumers.
+    # Matches the frontend's PromptObject TypeScript type.
+    # @param registry [Registry, nil] Registry for resolving capability descriptions
+    # @return [Hash]
+    def to_state_hash(registry: nil)
+      {
+        status: (@state || :idle).to_s,
+        description: description,
+        capabilities: resolve_capabilities(registry: registry),
+        universal_capabilities: resolve_universal_capabilities(registry: registry),
+        current_session: serialize_current_session,
+        sessions: list_sessions.map { |s| self.class.serialize_session(s) },
+        prompt: body,
+        config: config
+      }
+    end
+
+    # Summary hash for list endpoints (REST API, MCP list tools).
+    # Lightweight: no prompt, no session messages, no universal capabilities.
+    # @param registry [Registry, nil] Registry for resolving capability descriptions
+    # @return [Hash]
+    def to_summary_hash(registry: nil)
+      {
+        name: name,
+        description: description,
+        status: (@state || :idle).to_s,
+        capabilities: resolve_capabilities(registry: registry),
+        session_count: list_sessions.size
+      }
+    end
+
+    # Detailed inspection hash for single-PO endpoints (REST GET, MCP inspect).
+    # Everything in summary plus prompt, config, sessions, and universals.
+    # @param registry [Registry, nil] Registry for resolving capability descriptions
+    # @return [Hash]
+    def to_inspect_hash(registry: nil)
+      {
+        name: name,
+        description: description,
+        status: (@state || :idle).to_s,
+        capabilities: resolve_capabilities(registry: registry),
+        universal_capabilities: resolve_universal_capabilities(registry: registry),
+        prompt: body,
+        config: config,
+        session_id: session_id,
+        sessions: list_sessions.map { |s| self.class.serialize_session(s) },
+        history_length: history.length
+      }
+    end
+
+    # Serialize a message (in-memory or from DB) to a JSON-ready hash.
+    # Handles both ToolCall objects and plain Hashes (from SQLite).
+    # @param msg [Hash] The message to serialize
+    # @return [Hash]
+    def self.serialize_message(msg)
+      case msg[:role]
+      when :user
+        from = msg[:from] || msg[:from_po]
+        { role: "user", content: msg[:content], from: from }
+      when :assistant
+        hash = { role: "assistant", content: msg[:content] }
+        if msg[:tool_calls]
+          hash[:tool_calls] = msg[:tool_calls].map do |tc|
+            if tc.respond_to?(:id)
+              { id: tc.id, name: tc.name, arguments: tc.arguments }
+            else
+              { id: tc[:id] || tc["id"], name: tc[:name] || tc["name"], arguments: tc[:arguments] || tc["arguments"] || {} }
+            end
+          end
+        end
+        hash
+      when :tool
+        results = msg[:results] || msg[:tool_results]
+        { role: "tool", results: results }
+      else
+        { role: msg[:role].to_s, content: msg[:content] }
+      end
+    end
+
+    # Serialize a session record to a JSON-ready hash with thread fields.
+    # @param session [Hash] Session record from session store
+    # @return [Hash]
+    def self.serialize_session(session)
+      {
+        id: session[:id],
+        name: session[:name],
+        message_count: session[:message_count] || 0,
+        updated_at: session[:updated_at]&.iso8601,
+        parent_session_id: session[:parent_session_id],
+        parent_po: session[:parent_po],
+        thread_type: session[:thread_type] || "root"
+      }
+    end
+
     private
 
+    # Build capability info objects for this PO's declared capabilities.
+    def resolve_capabilities(registry: nil)
+      declared = @config["capabilities"] || []
+      return declared.map { |n| { name: n, description: n } } unless registry
+
+      declared.map do |cap_name|
+        cap = registry.get(cap_name)
+        { name: cap_name, description: cap&.description || "Capability not found", parameters: cap&.parameters }
+      end
+    end
+
+    # Build capability info objects for universal capabilities.
+    def resolve_universal_capabilities(registry: nil)
+      return [] unless registry
+
+      UNIVERSAL_CAPABILITIES.map do |cap_name|
+        cap = registry.get(cap_name)
+        { name: cap_name, description: cap&.description || "Universal capability", parameters: cap&.parameters }
+      end
+    end
+
+    # Serialize current session with messages for real-time state.
+    def serialize_current_session
+      return nil unless session_id
+      { id: session_id, messages: history.map { |m| self.class.serialize_message(m) } }
+    end
+
     def normalize_message(message)
       case message
       when String
@@ -328,12 +454,30 @@ module PromptObjects
         parent_message_id: get_last_message_id
       )
 
-      if delegation_thread
-        # Execute in isolated thread
-        target_po.receive_in_thread(tool_call.arguments, context: context, thread_id: delegation_thread)
-      else
-        # Fallback: execute in target's current session (no session store)
-        target_po.receive(tool_call.arguments, context: context)
+      # Notify delegation start so WebSocket clients see the target PO activate
+      @env.notify_delegation(:started, {
+        target: target_po.name,
+        caller: name,
+        thread_id: delegation_thread,
+        tool_call_id: tool_call.id
+      })
+
+      begin
+        if delegation_thread
+          # Execute in isolated thread
+          target_po.receive_in_thread(tool_call.arguments, context: context, thread_id: delegation_thread)
+        else
+          # Fallback: execute in target's current session (no session store)
+          target_po.receive(tool_call.arguments, context: context)
+        end
+      ensure
+        # Notify delegation complete — target PO is done
+        @env.notify_delegation(:completed, {
+          target: target_po.name,
+          caller: name,
+          thread_id: delegation_thread,
+          tool_call_id: tool_call.id
+        })
       end
     end
 

data/lib/prompt_objects/server/api/routes.rb

@@ -192,13 +192,7 @@ module PromptObjects
           end
 
           sessions = po.list_sessions.map do |s|
-            {
-              id: s[:id],
-              name: s[:name],
-              message_count: s[:message_count] || 0,
-              created_at: s[:created_at]&.iso8601,
-              updated_at: s[:updated_at]&.iso8601
-            }
+            PromptObject.serialize_session(s)
           end
 
           { sessions: sessions }
@@ -372,31 +366,11 @@ module PromptObjects
         # === Helpers ===
 
         def po_summary(po)
-          {
-            name: po.name,
-            description: po.description,
-            capabilities: po.config["capabilities"] || [],
-            session_count: po.list_sessions.size
-          }
+          po.to_summary_hash(registry: @runtime.registry)
         end
 
         def po_full(po)
-          {
-            name: po.name,
-            description: po.description,
-            capabilities: po.config["capabilities"] || [],
-            body: po.body,
-            config: po.config,
-            sessions: po.list_sessions.map do |s|
-              {
-                id: s[:id],
-                name: s[:name],
-                message_count: s[:message_count] || 0
-              }
-            end,
-            current_session: po.session_id,
-            history: po.history.map { |m| format_history_message(m) }
-          }
+          po.to_inspect_hash(registry: @runtime.registry)
         end
 
         def format_message(msg)
@@ -410,25 +384,6 @@ module PromptObjects
           }.compact
         end
 
-        def format_history_message(msg)
-          case msg[:role]
-          when :user
-            { role: "user", content: msg[:content], from: msg[:from] }
-          when :assistant
-            h = { role: "assistant", content: msg[:content] }
-            if msg[:tool_calls]
-              h[:tool_calls] = msg[:tool_calls].map do |tc|
-                { id: tc.id, name: tc.name, arguments: tc.arguments }
-              end
-            end
-            h
-          when :tool
-            { role: "tool", results: msg[:results] }
-          else
-            { role: msg[:role].to_s, content: msg[:content] }
-          end
-        end
-
         def path_param(path, index)
           # Extract path parameter from regex match
           # /prompt_objects/foo -> foo (index 1)

data/lib/prompt_objects/server/app.rb

@@ -19,6 +19,15 @@ module PromptObjects
         @public_path = File.expand_path("public", __dir__)
         @connections = []
         @connections_mutex = Mutex.new
+
+        # Broadcast PO-to-PO delegation events to all connected clients.
+        # This makes delegated POs visible in the UI (canvas + chat).
+        @runtime.on_delegation_event = ->(event_type, payload) {
+          broadcast(
+            type: "po_delegation_#{event_type}",
+            payload: payload
+          )
+        }
       end
 
       def call(env)