language-operator 0.1.56 → 0.1.58

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: ac246ba1f01262701f8e193f697a2df7753f23f376c71a8cbfc24ab87a59e088
-  data.tar.gz: b75afe1475935a9b9ccbe3cd717d46e5b180ba123818fc53ff954f228f5663c8
+  metadata.gz: afc74193530a3f556debc6b31b0a43769da67eaf9c956d0a7b4f17477792bf94
+  data.tar.gz: ffc401b931b0b3bd427c92a36847986442b738f2508acd1206547aa4d14c92eb
 SHA512:
-  metadata.gz: d66f44b6d599faaf6c0d93368ff03a50f50372c0924ad8b85f387c842c0302fa5e31c37472dbe484236fc917957ed33a2fa8b80502df0605a1d91909a5613b80
-  data.tar.gz: 727ac1463af4516edcc552582909f77351f913fbdad2ae260bcc62f1f0f058006cf56dbb71ccd4910ec0f63aeb41ec7c812ea2ab3ee8f413dab5e620443cd5a1
+  metadata.gz: 5079fbb3621d2e3d0f00a9381bc7b6fa09c3e28ae029d3e6cde4b7e0ac42643c7881953dd66549f0379414c0a74053dfed301e832812d82902d0de553f791158
+  data.tar.gz: f24aea2d8cb473e7e9633fe713e663f637391c258695eacdd091b94dc12b206606408162f1d3cf3ae60484aa8097177bd4a858d392b132e07f6aaafadf63f35a

data/Gemfile.lock

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

data/lib/language_operator/agent/executor.rb

@@ -107,6 +107,17 @@ module LanguageOperator
             )
           end
 
+          # Capture thinking blocks before stripping (for observability)
+          thinking_blocks = result_text.scan(%r{\[THINK\](.*?)\[/THINK\]}m).flatten
+          if thinking_blocks.any?
+            logger.info('LLM thinking captured',
+                        event: 'llm_thinking',
+                        iteration: @iteration_count,
+                        thinking_steps: thinking_blocks.length,
+                        thinking: thinking_blocks,
+                        thinking_preview: thinking_blocks.first&.[](0..500))
+          end
+
           # Log the actual LLM response content (strip [THINK] blocks)
           cleaned_response = result_text.gsub(%r{\[THINK\].*?\[/THINK\]}m, '').strip
           response_preview = cleaned_response.length > 500 ? "#{cleaned_response[0..500]}..." : cleaned_response

data/lib/language_operator/agent/task_executor.rb

@@ -155,15 +155,24 @@ 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)
 
+          # Check for tool calls and log details
+          has_tool_calls = response.respond_to?(:tool_calls) && response.tool_calls&.any?
+          tool_call_count = has_tool_calls ? response.tool_calls.length : 0
+
           logger.info('LLM response received, extracting content',
-                      task: task.name)
+                      task: task.name,
+                      response_class: response.class.name,
+                      has_tool_calls: has_tool_calls,
+                      tool_call_count: tool_call_count)
 
           response_text = response.is_a?(String) ? response : response.content
 
@@ -322,6 +331,17 @@ module LanguageOperator
       # @return [Hash] Parsed outputs
       # @raise [RuntimeError] If parsing fails
       def parse_neural_response(response_text, task)
+        # Capture thinking blocks before stripping (for observability)
+        thinking_blocks = response_text.scan(%r{\[THINK\](.*?)\[/THINK\]}m).flatten
+        if thinking_blocks.any?
+          logger.info('LLM thinking captured',
+                      event: 'llm_thinking',
+                      task: task.name,
+                      thinking_steps: thinking_blocks.length,
+                      thinking: thinking_blocks,
+                      thinking_preview: thinking_blocks.first&.[](0..500))
+        end
+
         # Strip thinking tags that some models add (e.g., [THINK]...[/THINK])
         cleaned_text = response_text.gsub(%r{\[THINK\].*?\[/THINK\]}m, '').strip
 
@@ -367,8 +387,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/agent.rb

@@ -44,6 +44,7 @@ module LanguageOperator
         option :persona, type: :string, desc: 'Persona to use for the agent'
         option :tools, type: :array, desc: 'Tools to make available to the agent'
         option :models, type: :array, desc: 'Models to make available to the agent'
+        option :workspace, type: :boolean, default: true, desc: 'Enable workspace for state persistence'
         option :dry_run, type: :boolean, default: false, desc: 'Preview what would be created without applying'
         option :wizard, type: :boolean, default: false, desc: 'Use interactive wizard mode'
         def create(description = nil)
@@ -98,7 +99,8 @@ module LanguageOperator
               cluster: ctx.namespace,
               persona: options[:persona],
               tools: options[:tools] || [],
-              models: models
+              models: models,
+              workspace: options[:workspace]
             )
 
             # Dry-run mode: preview without applying

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,
@@ -54,6 +61,9 @@ module LanguageOperator
 
         @chat.with_tools(*all_tools) unless all_tools.empty?
 
+        # Set up callbacks to log tool invocations
+        setup_tool_callbacks
+
         logger.info('Chat session initialized', with_tools: !all_tools.empty?)
       end
 
@@ -118,6 +128,27 @@ module LanguageOperator
 
         chat_params
       end
+
+      # Set up callbacks to log tool calls and results
+      #
+      # @return [void]
+      def setup_tool_callbacks
+        @chat.on_tool_call do |tool_call|
+          logger.info('Tool call initiated by LLM',
+                      event: 'tool_call_initiated',
+                      tool_name: tool_call.name,
+                      tool_id: tool_call.id,
+                      arguments: tool_call.arguments,
+                      arguments_json: tool_call.arguments.to_json)
+        end
+
+        @chat.on_tool_result do |result|
+          logger.info('Tool call result received',
+                      event: 'tool_result_received',
+                      result: result,
+                      result_preview: result.to_s[0..500])
+        end
+      end
     end
   end
 end

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/instrumentation/task_tracer.rb

@@ -26,6 +26,7 @@ module LanguageOperator
     #   Instrumentation adds <5% overhead with default settings
     #   Overhead may increase to ~10% with full data capture enabled
     #
+    # rubocop:disable Metrics/ModuleLength
     module TaskTracer
       # Maximum length for captured data before truncation
       MAX_CAPTURED_LENGTH = 1000
@@ -169,6 +170,11 @@ module LanguageOperator
         return unless response.respond_to?(:tool_calls)
         return unless response.tool_calls&.any?
 
+        logger&.info('Tool calls detected in LLM response',
+                     event: 'tool_calls_detected',
+                     tool_call_count: response.tool_calls.length,
+                     tool_names: response.tool_calls.map { |tc| extract_tool_name(tc) })
+
         response.tool_calls.each do |tool_call|
           record_single_tool_call(tool_call, parent_span)
         end
@@ -182,11 +188,26 @@ module LanguageOperator
       # @param parent_span [OpenTelemetry::Trace::Span] Parent span
       def record_single_tool_call(tool_call, _parent_span)
         tool_name = extract_tool_name(tool_call)
+        tool_id = tool_call.respond_to?(:id) ? tool_call.id : nil
+
+        # Extract and log tool arguments
+        arguments = extract_tool_arguments(tool_call)
 
+        logger&.info('Tool invoked by LLM',
+                     event: 'tool_call_invoked',
+                     tool_name: tool_name,
+                     tool_id: tool_id,
+                     arguments: arguments,
+                     arguments_json: (arguments.is_a?(Hash) ? JSON.generate(arguments) : arguments.to_s))
+
+        start_time = Time.now
         tracer.in_span("execute_tool #{tool_name}", attributes: build_tool_call_attributes(tool_call)) do |tool_span|
           # Tool execution already completed by ruby_llm
           # Just record the metadata
-          record_tool_result(tool_call.result, tool_span) if tool_call.respond_to?(:result) && tool_call.result
+          if tool_call.respond_to?(:result) && tool_call.result
+            duration_ms = ((Time.now - start_time) * 1000).round(2)
+            record_tool_result(tool_call.result, tool_span, tool_name, tool_id, duration_ms)
+          end
         end
       rescue StandardError => e
         logger&.warn('Failed to record tool call span', error: e.message, tool: tool_name)
@@ -206,6 +227,34 @@ module LanguageOperator
         end
       end
 
+      # Extract tool arguments from tool call object
+      #
+      # @param tool_call [Object] Tool call object
+      # @return [Hash, String] Tool arguments
+      def extract_tool_arguments(tool_call)
+        if tool_call.respond_to?(:arguments)
+          args = tool_call.arguments
+          parse_json_args(args)
+        elsif tool_call.respond_to?(:function) && tool_call.function.respond_to?(:arguments)
+          args = tool_call.function.arguments
+          parse_json_args(args)
+        else
+          {}
+        end
+      end
+
+      # Parse JSON arguments safely
+      #
+      # @param args [String, Object] Arguments to parse
+      # @return [Hash, String] Parsed arguments or original
+      def parse_json_args(args)
+        return args unless args.is_a?(String)
+
+        JSON.parse(args)
+      rescue JSON::ParserError
+        args
+      end
+
       # Build attributes for tool call span
       #
       # @param tool_call [Object] Tool call object
@@ -244,13 +293,25 @@ module LanguageOperator
       #
       # @param result [Object] Tool call result
       # @param span [OpenTelemetry::Trace::Span] The span to update
-      def record_tool_result(result, span)
+      # @param tool_name [String] Tool name (for logging)
+      # @param tool_id [String] Tool call ID (for logging)
+      # @param duration_ms [Float] Execution duration in milliseconds (for logging)
+      def record_tool_result(result, span, tool_name = nil, tool_id = nil, duration_ms = nil)
         result_str = result.is_a?(String) ? result : JSON.generate(result)
         span.set_attribute('gen_ai.tool.call.result.size', result_str.bytesize)
 
         if (sanitized_result = sanitize_data(result, :tool_results))
           span.set_attribute('gen_ai.tool.call.result', sanitized_result)
         end
+
+        # Log tool execution completion
+        logger&.info('Tool execution completed',
+                     event: 'tool_call_completed',
+                     tool_name: tool_name,
+                     tool_id: tool_id,
+                     result_size: result_str.bytesize,
+                     result: sanitize_data(result, :tool_results),
+                     duration_ms: duration_ms)
       rescue StandardError => e
         logger&.warn('Failed to record tool result', error: e.message)
       end
@@ -281,5 +342,6 @@ module LanguageOperator
         logger&.warn('Failed to record output metadata', error: e.message)
       end
     end
+    # rubocop:enable Metrics/ModuleLength
   end
 end

data/lib/language_operator/kubernetes/resource_builder.rb

@@ -25,7 +25,7 @@ module LanguageOperator
 
         # Build a LanguageAgent resource
         def language_agent(name, instructions:, cluster: nil, schedule: nil, persona: nil, tools: [], models: [],
-                           mode: nil, labels: {})
+                           mode: nil, workspace: true, labels: {})
           # Determine mode: reactive, scheduled, or autonomous
           spec_mode = mode || (schedule ? 'scheduled' : 'autonomous')
 
@@ -41,6 +41,8 @@ module LanguageOperator
           spec['toolRefs'] = tools.map { |t| { 'name' => t } } unless tools.empty?
           # Convert model names to modelRef objects
           spec['modelRefs'] = models.map { |m| { 'name' => m } } unless models.empty?
+          # Enable workspace by default for state persistence
+          spec['workspace'] = { 'enabled' => workspace } if workspace
 
           {
             'apiVersion' => 'langop.io/v1alpha1',

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.58
   :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.58",
   "type": "object",
   "properties": {
     "name": {

data/lib/language_operator/tool_loader.rb

@@ -173,7 +173,7 @@ module LanguageOperator
     #
     # @param tool_def [LanguageOperator::Dsl::ToolDefinition] Tool definition from DSL
     # @return [Class] MCP::Tool subclass
-    # rubocop:disable Metrics/MethodLength
+    # rubocop:disable Metrics/MethodLength, Metrics/AbcSize
     def self.create_mcp_tool(tool_def)
       # Capture tool name and tracer for use in the dynamic class
       tool_name = tool_def.name
@@ -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
@@ -210,7 +213,9 @@ module LanguageOperator
                            'tool.type' => 'custom'
                          }) do |span|
             # Execute the tool's block
-            result = @execute_block.call(params)
+            # Convert symbol keys to string keys for consistency with DSL expectations
+            string_params = params.transform_keys(&:to_s)
+            result = @execute_block.call(string_params)
 
             # Set success attribute
             span.set_attribute('tool.result', 'success')
@@ -232,6 +237,6 @@ module LanguageOperator
         end
       end
     end
-    # rubocop:enable Metrics/MethodLength
+    # rubocop:enable Metrics/MethodLength, Metrics/AbcSize
   end
 end

data/lib/language_operator/version.rb

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

data/synth/003/Makefile

@@ -7,6 +7,9 @@ TOOLS := workspace
 create:
 	cat agent.txt | $(AICTL) create --name $(AGENT) --tools "$(TOOLS)"
 
+run:
+	kubectl create job --from=cronjob/$(AGENT) $(AGENT)-manual
+
 code:
 	$(AICTL) code $(AGENT)
 

metadata

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