language-operator 0.1.56 → 0.1.57

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: ac246ba1f01262701f8e193f697a2df7753f23f376c71a8cbfc24ab87a59e088
-  data.tar.gz: b75afe1475935a9b9ccbe3cd717d46e5b180ba123818fc53ff954f228f5663c8
+  metadata.gz: 531bb19bab7e2aaac4dbc7e430147c722e42cad7802a662a13e7aab0c29fdf3a
+  data.tar.gz: a7f7ede687479319814e519c788a57906357e76bef99b45616282c1828b7959f
 SHA512:
-  metadata.gz: d66f44b6d599faaf6c0d93368ff03a50f50372c0924ad8b85f387c842c0302fa5e31c37472dbe484236fc917957ed33a2fa8b80502df0605a1d91909a5613b80
-  data.tar.gz: 727ac1463af4516edcc552582909f77351f913fbdad2ae260bcc62f1f0f058006cf56dbb71ccd4910ec0f63aeb41ec7c812ea2ab3ee8f413dab5e620443cd5a1
+  metadata.gz: a9782736dde3ec6caace204cd585de5a887c43086236325062f911e2d4271754b9a3d957c03b9ad2a8b795fcfadb6d6d5ad9f76016635182bf9ec45d7cbc1560
+  data.tar.gz: 3b1817c3d6c8ef8eff5cba64c47e7bf85edac523376a78170f16a702d82fc1a7ac0db21f7df547e99da94ad27adcd78774693faf980dceca75a957c44fd1900b

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    language-operator (0.1.56)
+    language-operator (0.1.57)
       faraday (~> 2.0)
       k8s-ruby (~> 0.17)
       mcp (~> 0.4)

data/lib/language_operator/agent/task_executor.rb

@@ -155,15 +155,19 @@ module LanguageOperator
 
         logger.info('Sending prompt to LLM',
                     task: task.name,
-                    prompt_length: prompt.length)
+                    prompt_length: prompt.length,
+                    available_tools: @agent.respond_to?(:tools) ? @agent.tools.map(&:name) : 'N/A')
 
         # Execute LLM call within traced span
         outputs = tracer.in_span('gen_ai.chat', attributes: neural_task_attributes(task, prompt, validated_inputs)) do |span|
           # Call LLM with full tool access
+          logger.debug('Calling LLM with prompt', task: task.name, prompt_preview: prompt[0..200])
           response = @agent.send_message(prompt)
 
           logger.info('LLM response received, extracting content',
-                      task: task.name)
+                      task: task.name,
+                      response_class: response.class.name,
+                      has_tool_calls: response.respond_to?(:tool_calls) && response.tool_calls&.any?)
 
           response_text = response.is_a?(String) ? response : response.content
 
@@ -367,8 +371,8 @@ module LanguageOperator
       def default_config
         {
           timeout_symbolic: 30.0,     # Default timeout for symbolic tasks (seconds)
-          timeout_neural: 240.0,      # Default timeout for neural tasks (seconds)
-          timeout_hybrid: 240.0,      # Default timeout for hybrid tasks (seconds)
+          timeout_neural: 360.0,      # Default timeout for neural tasks (seconds)
+          timeout_hybrid: 360.0,      # Default timeout for hybrid tasks (seconds)
           max_retries: 3,             # Default max retry attempts
           retry_delay_base: 1.0,      # Base delay for exponential backoff
           retry_delay_max: 10.0       # Maximum delay between retries

data/lib/language_operator/cli/commands/tool.rb

@@ -3,6 +3,7 @@
 require 'yaml'
 require 'erb'
 require 'net/http'
+require 'json'
 require_relative '../base_command'
 require_relative '../formatters/progress_formatter'
 require_relative '../formatters/table_formatter'
@@ -66,6 +67,140 @@ module LanguageOperator
           end
         end
 
+        desc 'inspect NAME', 'Show detailed tool information'
+        option :cluster, type: :string, desc: 'Override current cluster context'
+        def inspect(name)
+          handle_command_error('inspect tool') do
+            tool = get_resource_or_exit('LanguageTool', name)
+
+            puts "Tool: #{name}"
+            puts "  Cluster:   #{ctx.name}"
+            puts "  Namespace: #{ctx.namespace}"
+            puts
+
+            # Status
+            status = tool.dig('status', 'phase') || 'Unknown'
+            puts "Status: #{status}"
+            puts
+
+            # Spec details
+            puts 'Configuration:'
+            puts "  Type:            #{tool.dig('spec', 'type') || 'mcp'}"
+            puts "  Image:           #{tool.dig('spec', 'image')}"
+            puts "  Deployment Mode: #{tool.dig('spec', 'deploymentMode') || 'sidecar'}"
+            puts "  Port:            #{tool.dig('spec', 'port') || 8080}"
+            puts "  Replicas:        #{tool.dig('spec', 'replicas') || 1}"
+            puts
+
+            # Resources
+            resources = tool.dig('spec', 'resources')
+            if resources
+              puts 'Resources:'
+              if resources['requests']
+                puts '  Requests:'
+                puts "    CPU:    #{resources['requests']['cpu']}"
+                puts "    Memory: #{resources['requests']['memory']}"
+              end
+              if resources['limits']
+                puts '  Limits:'
+                puts "    CPU:    #{resources['limits']['cpu']}"
+                puts "    Memory: #{resources['limits']['memory']}"
+              end
+              puts
+            end
+
+            # RBAC
+            rbac = tool.dig('spec', 'rbac')
+            if rbac && rbac['clusterRole']
+              rules = rbac.dig('clusterRole', 'rules') || []
+              puts "RBAC Permissions (#{rules.length} rules):"
+              rules.each_with_index do |rule, idx|
+                puts "  Rule #{idx + 1}:"
+                puts "    API Groups: #{rule['apiGroups'].join(', ')}"
+                puts "    Resources:  #{rule['resources'].join(', ')}"
+                puts "    Verbs:      #{rule['verbs'].join(', ')}"
+              end
+              puts
+            end
+
+            # Egress rules
+            egress = tool.dig('spec', 'egress') || []
+            if egress.any?
+              puts "Network Egress (#{egress.length} rules):"
+              egress.each_with_index do |rule, idx|
+                puts "  Rule #{idx + 1}: #{rule['description']}"
+                puts "    DNS:   #{rule['dns'].join(', ')}" if rule['dns']
+                puts "    CIDR:  #{rule['cidr']}" if rule['cidr']
+                if rule['ports']
+                  ports_str = rule['ports'].map { |p| "#{p['port']}/#{p['protocol']}" }.join(', ')
+                  puts "    Ports: #{ports_str}"
+                end
+              end
+              puts
+            end
+
+            # Try to fetch MCP capabilities
+            capabilities = fetch_mcp_capabilities(name, tool, ctx.namespace)
+            if capabilities && capabilities['tools'] && capabilities['tools'].any?
+              puts "MCP Tools (#{capabilities['tools'].length}):"
+              capabilities['tools'].each_with_index do |mcp_tool, idx|
+                tool_name = mcp_tool['name']
+
+                # Generate a meaningful name if empty
+                if tool_name.nil? || tool_name.empty?
+                  # Try to derive from description (first few words)
+                  if mcp_tool['description']
+                    # Take first 3-4 words and convert to snake_case
+                    words = mcp_tool['description'].split(/\s+/).first(4)
+                    derived_name = words.join('_').downcase.gsub(/[^a-z0-9_]/, '')
+                    tool_name = "#{name}_#{derived_name}".gsub(/__+/, '_').sub(/_$/, '')
+                  else
+                    tool_name = "#{name}_tool_#{idx + 1}"
+                  end
+                end
+
+                puts "  #{tool_name}"
+                puts "    Description: #{mcp_tool['description']}" if mcp_tool['description']
+                next unless mcp_tool['inputSchema'] && mcp_tool['inputSchema']['properties']
+
+                params = mcp_tool['inputSchema']['properties'].keys
+                required = mcp_tool['inputSchema']['required'] || []
+                param_list = params.map { |p| required.include?(p) ? "#{p}*" : p }
+                puts "    Parameters:  #{param_list.join(', ')}"
+              end
+              puts '    (* = required)'
+              puts
+            end
+
+            # Get agents using this tool
+            agents = ctx.client.list_resources('LanguageAgent', namespace: ctx.namespace)
+            agents_using = agents.select do |agent|
+              tools = agent.dig('spec', 'tools') || []
+              tools.include?(name)
+            end
+
+            if agents_using.any?
+              puts "Agents using this tool (#{agents_using.count}):"
+              agents_using.each do |agent|
+                puts "  - #{agent.dig('metadata', 'name')}"
+              end
+            else
+              puts 'No agents using this tool'
+            end
+
+            puts
+            puts 'Labels:'
+            labels = tool.dig('metadata', 'labels') || {}
+            if labels.empty?
+              puts '  (none)'
+            else
+              labels.each do |key, value|
+                puts "  #{key}: #{value}"
+              end
+            end
+          end
+        end
+
         desc 'delete NAME', 'Delete a tool'
         option :cluster, type: :string, desc: 'Override current cluster context'
         option :force, type: :boolean, default: false, desc: 'Skip confirmation'
@@ -465,6 +600,54 @@ module LanguageOperator
             end
           end
         end
+
+        private
+
+        # Fetch MCP capabilities from a running tool server
+        #
+        # @param name [String] Tool name
+        # @param tool [Hash] Tool resource
+        # @param namespace [String] Kubernetes namespace
+        # @return [Hash, nil] MCP capabilities or nil if unavailable
+        def fetch_mcp_capabilities(name, tool, namespace)
+          return nil unless tool.dig('status', 'phase') == 'Running'
+
+          # Get the service endpoint
+          port = tool.dig('spec', 'port') || 80
+
+          # Try to query the MCP server using kubectl port-forward
+          # This is a fallback approach since we can't directly connect from CLI
+          begin
+            # Try to find a pod for this tool
+            label_selector = "app.kubernetes.io/name=#{name}"
+            pods = ctx.client.list_resources('Pod', namespace: namespace, label_selector: label_selector)
+
+            return nil if pods.empty?
+
+            pod_name = pods.first.dig('metadata', 'name')
+
+            # Query the MCP server using JSON-RPC protocol
+            # MCP uses the tools/list method to list available tools
+            json_rpc_request = {
+              jsonrpc: '2.0',
+              id: 1,
+              method: 'tools/list',
+              params: {}
+            }.to_json
+
+            result = `kubectl exec -n #{namespace} #{pod_name} -- curl -s -X POST \
+http://localhost:#{port}/mcp/tools/list -H "Content-Type: application/json" \
+-d '#{json_rpc_request}' 2>/dev/null`
+
+            return nil if result.empty?
+
+            response = JSON.parse(result)
+            response['result']
+          rescue StandardError
+            # Silently fail - capabilities are optional information
+            nil
+          end
+        end
       end
     end
   end

data/lib/language_operator/cli/templates/tools/generic.yaml

@@ -51,15 +51,15 @@ spec:
 <% rbac['clusterRole']['rules'].each do |rule| -%>
         - apiGroups:
 <% rule['apiGroups'].each do |group| -%>
-            - <%= group %>
+            - "<%= group %>"
 <% end -%>
           resources:
 <% rule['resources'].each do |resource| -%>
-            - <%= resource %>
+            - "<%= resource %>"
 <% end -%>
           verbs:
 <% rule['verbs'].each do |verb| -%>
-            - <%= verb %>
+            - "<%= verb %>"
 <% end -%>
 <% end -%>
 <% end -%>

data/lib/language_operator/client/mcp_connector.rb

@@ -27,6 +27,13 @@ module LanguageOperator
             tool_count = client.tools.length
             all_tools.concat(client.tools)
 
+            # Debug: inspect tool objects
+            if @debug
+              logger.debug('MCP tool objects inspection',
+                           server: server_config['name'],
+                           tools_inspect: client.tools.map { |t| { class: t.class.name, name: t.name, methods: t.methods.grep(/name/) } })
+            end
+
             logger.info('MCP server connected',
                         server: server_config['name'],
                         tool_count: tool_count,

data/lib/language_operator/dsl/adapter.rb

@@ -20,8 +20,8 @@ module LanguageOperator
 
         # Create a dynamic class that extends MCP::Tool
         Class.new(MCP::Tool) do
-          # Set the tool name
-          define_singleton_method(:name) { tool_def.name }
+          # Set the tool name using the MCP SDK's method
+          tool_name tool_def.name
 
           # Set the description
           description tool_def.description

data/lib/language_operator/templates/schema/agent_dsl_openapi.yaml

@@ -2,7 +2,7 @@
 :openapi: 3.0.3
 :info:
   :title: Language Operator Agent API
-  :version: 0.1.56
+  :version: 0.1.57
   :description: HTTP API endpoints exposed by Language Operator reactive agents
   :contact:
     :name: Language Operator

data/lib/language_operator/templates/schema/agent_dsl_schema.json

@@ -3,7 +3,7 @@
   "$id": "https://github.com/language-operator/language-operator-gem/schema/agent-dsl.json",
   "title": "Language Operator Agent DSL",
   "description": "Schema for defining autonomous AI agents using the Language Operator DSL",
-  "version": "0.1.56",
+  "version": "0.1.57",
   "type": "object",
   "properties": {
     "name": {

data/lib/language_operator/tool_loader.rb

@@ -181,6 +181,9 @@ module LanguageOperator
 
       # Create a dynamic MCP::Tool class
       Class.new(MCP::Tool) do
+        # Set tool name (required for MCP protocol)
+        tool_name tool_def.name
+
         description tool_def.description || "Tool: #{tool_def.name}"
 
         # Build input schema from parameters

data/lib/language_operator/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module LanguageOperator
-  VERSION = '0.1.56'
+  VERSION = '0.1.57'
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: language-operator
 version: !ruby/object:Gem::Version
-  version: 0.1.56
+  version: 0.1.57
 platform: ruby
 authors:
 - James Ryan