vsm 0.0.1 → 0.1.0

data/lib/vsm/drivers/anthropic/async_driver.rb

@@ -0,0 +1,210 @@
+# frozen_string_literal: true
+require "json"
+require "net/http"
+require "uri"
+require "securerandom"
+
+module VSM
+  module Drivers
+    module Anthropic
+      class AsyncDriver
+        def initialize(api_key:, model:, base_url: "https://api.anthropic.com/v1", version: "2023-06-01")
+          @api_key, @model, @base, @version = api_key, model, base_url, version
+        end
+
+        def run!(conversation:, tools:, policy: {}, &emit)
+          # Always use Net::HTTP with SSE
+          emitted_terminal = false
+
+          headers = {
+            "x-api-key" => @api_key,
+            "anthropic-version" => @version,
+            "content-type" => "application/json",
+            "accept" => "text/event-stream"
+          }
+
+          messages  = to_anthropic_messages(conversation, policy[:system_prompt])
+          tool_list = normalize_anthropic_tools(tools)
+          payload = {
+            model: @model,
+            system: policy[:system_prompt],
+            messages: messages,
+            max_tokens: 512,
+            stream: true
+          }
+          if tool_list.any?
+            payload[:tools] = tool_list
+            payload[:tool_choice] = { type: "auto" }
+          end
+          body = JSON.dump(payload)
+
+          url = URI.parse("#{@base}/messages")
+          http = Net::HTTP.new(url.host, url.port)
+          http.use_ssl = (url.scheme == "https")
+          http.read_timeout = 120
+
+          req = Net::HTTP::Post.new(url.request_uri)
+          headers.each { |k,v| req[k] = v }
+          req.body = body
+
+          res = http.request(req) do |response|
+            ct = response["content-type"]
+            if response.code.to_i != 200
+              err_body = +""
+              response.read_body { |chunk| err_body << chunk }
+              preview = err_body.to_s.byteslice(0, 400)
+              emit.call(:assistant_final, "Anthropic HTTP #{response.code}: #{preview}")
+              emitted_terminal = true
+              next
+            end
+
+            if ct && ct.include?("text/event-stream")
+              buffer = +""
+              textbuf = +""
+              toolbuf = {}
+              tool_calls = []
+
+              response.read_body do |chunk|
+                buffer << chunk
+                while (i = buffer.index("\n"))
+                  line = buffer.slice!(0..i)
+                  line.chomp!
+                  next unless line.start_with?("data:")
+                  data = line.sub("data:","").strip
+                  next if data.empty? || data == "[DONE]"
+                  obj = JSON.parse(data) rescue nil
+                  next unless obj
+                  ev = obj["type"].to_s
+                  if ENV["VSM_DEBUG_STREAM"] == "1"
+                    $stderr.puts "anthropic(nethttp) <= #{ev}: #{data.byteslice(0, 160)}"
+                  end
+
+                  case ev
+                  when "content_block_delta"
+                    idx = obj["index"]; delta = obj["delta"] || {}
+                    case delta["type"]
+                    when "text_delta"
+                      part = delta["text"].to_s
+                      textbuf << part
+                      emit.call(:assistant_delta, part)
+                    when "input_json_delta"
+                      toolbuf[idx] ||= { id: nil, name: nil, json: +"" }
+                      toolbuf[idx][:json] << (delta["partial_json"] || "")
+                    end
+                  when "content_block_start"
+                    # For anthropic, the key can be 'content' or 'content_block'
+                    c = obj["content"] || obj["content_block"] || {}
+                    if c["type"] == "tool_use"
+                      name = c["name"] || obj["name"]
+                      toolbuf[obj["index"]] = { id: c["id"], name: name, json: +"" }
+                    end
+                  when "content_block_stop"
+                    idx = obj["index"]
+                    if tb = toolbuf[idx]
+                      args = tb[:json].empty? ? {} : (JSON.parse(tb[:json]) rescue {"_raw"=>tb[:json]})
+                      # Only enqueue if name is present
+                      if tb[:name].to_s.strip != "" && tb[:id]
+                        tool_calls << { id: tb[:id], name: tb[:name], arguments: args }
+                      end
+                    end
+                  when "message_stop"
+                    if tool_calls.any?
+                      emit.call(:tool_calls, tool_calls)
+                    else
+                      emit.call(:assistant_final, textbuf.dup)
+                    end
+                    emitted_terminal = true
+                  end
+                end
+              end
+
+              unless emitted_terminal
+                # If the stream closed without a terminal, emit final text
+                emit.call(:assistant_final, textbuf)
+                emitted_terminal = true
+              end
+            else
+              # Non-streaming JSON
+              data = ""
+              response.read_body { |chunk| data << chunk }
+              obj = JSON.parse(data) rescue {}
+              parts = Array(obj.dig("content"))
+              calls = []
+              text  = +""
+              parts.each do |p|
+                case p["type"]
+                when "text" then text << p["text"].to_s
+                when "tool_use" then calls << { id: p["id"] || SecureRandom.uuid, name: p["name"], arguments: p["input"] || {} }
+                end
+              end
+              if calls.any?
+                emit.call(:tool_calls, calls)
+              else
+                emit.call(:assistant_final, text)
+              end
+              emitted_terminal = true
+            end
+          end
+
+          :done
+        end
+
+        private
+        # (no IPv6/IPv4 forcing; rely on default Internet)
+        def normalize_anthropic_tools(tools)
+          Array(tools).map { |t| normalize_anthropic_tool(t) }
+        end
+
+        def normalize_anthropic_tool(t)
+          return t.to_anthropic_tool if t.respond_to?(:to_anthropic_tool)
+
+          # Provider-shaped: {name:, description:, input_schema: {…}}
+          if t.is_a?(Hash) && (t[:input_schema] || t["input_schema"])
+            return t
+          end
+
+          # Neutral hash {name:, description:, schema:}
+          if t.is_a?(Hash) && (t[:name] || t["name"])
+            return {
+              name:        t[:name]        || t["name"],
+              description: t[:description] || t["description"] || "",
+              input_schema: t[:schema]     || t["schema"]      || {}
+            }
+          end
+
+          raise TypeError, "unsupported tool descriptor: #{t.inspect}"
+        end
+
+
+        def to_anthropic_messages(neutral, _system)
+          # Build content blocks per message; keep ordering
+          neutral.map do |m|
+            case m[:role]
+            when "user"
+              { role: "user", content: [{ type: "text", text: m[:content].to_s }] }
+            when "assistant"
+              { role: "assistant", content: [{ type: "text", text: m[:content].to_s }] }
+            when "assistant_tool_calls"
+              blocks = Array(m[:tool_calls]).map { |c|
+                { type: "tool_use", id: c[:id], name: c[:name], input: c[:arguments] || {} }
+              }
+              { role: "assistant", content: blocks }
+            when "tool_result"
+              { role: "user", content: [{ type: "tool_result", tool_use_id: m[:tool_call_id], content: m[:content].to_s }] }
+            end
+          end.compact
+        end
+
+        def extract_sse_line!(buffer)
+          if (i = buffer.index("\n"))
+            line = buffer.slice!(0..i)
+            line.chomp!
+            return line
+          end
+          nil
+        end
+      end
+    end
+  end
+end
+

data/lib/vsm/drivers/family.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+module VSM
+  module Drivers
+    module Family
+      def self.of(driver)
+        case driver
+        when VSM::Drivers::OpenAI::AsyncDriver    then :openai
+        when VSM::Drivers::Anthropic::AsyncDriver then :anthropic
+        when VSM::Drivers::Gemini::AsyncDriver    then :gemini
+        else :openai
+        end
+      end
+    end
+  end
+end
+

data/lib/vsm/drivers/gemini/async_driver.rb

@@ -0,0 +1,149 @@
+# frozen_string_literal: true
+require "async"
+require "net/http"
+require "uri"
+require "json"
+require "securerandom"
+
+module VSM
+  module Drivers
+    module Gemini
+      class AsyncDriver
+        def initialize(api_key:, model:, base_url: "https://generativelanguage.googleapis.com/v1beta", streaming: true)
+          @api_key, @model, @base, @streaming = api_key, model, base_url, streaming
+        end
+
+        def run!(conversation:, tools:, policy: {}, &emit)
+          contents = to_gemini_contents(conversation)
+          fndecls  = normalize_gemini_tools(tools)
+          if @streaming
+            uri = URI.parse("#{@base}/models/#{@model}:streamGenerateContent?alt=sse&key=#{@api_key}")
+            headers = { "content-type" => "application/json", "accept" => "text/event-stream" }
+            body = JSON.dump({ contents: contents, system_instruction: (policy[:system_prompt] && { parts: [{ text: policy[:system_prompt] }], role: "user" }), tools: [{ functionDeclarations: fndecls }] })
+            http = Net::HTTP.new(uri.host, uri.port)
+            http.use_ssl = (uri.scheme == "https")
+            req = Net::HTTP::Post.new(uri.request_uri)
+            headers.each { |k,v| req[k] = v }
+            req.body = body
+            http.request(req) do |res|
+              if res.code.to_i != 200
+                err = +""; res.read_body { |c| err << c }
+                emit.call(:assistant_final, "Gemini HTTP #{res.code}: #{err.to_s.byteslice(0, 400)}")
+                next
+              end
+              buffer = +""; text = +""; calls = []
+              res.read_body do |chunk|
+                buffer << chunk
+                while (i = buffer.index("\n"))
+                  line = buffer.slice!(0..i)
+                  line.chomp!
+                  next unless line.start_with?("data:")
+                  data = line.sub("data:","").strip
+                  next if data.empty? || data == "[DONE]"
+                  obj = JSON.parse(data) rescue nil
+                  next unless obj
+                  parts = (obj.dig("candidates",0,"content","parts") || [])
+                  parts.each do |p|
+                    if (t = p["text"]) && !t.empty?
+                      text << t
+                      emit.call(:assistant_delta, t)
+                    end
+                    if (fc = p["functionCall"]) && fc["name"]
+                      calls << { id: SecureRandom.uuid, name: fc["name"], arguments: (fc["args"] || {}) }
+                    end
+                  end
+                end
+              end
+              if calls.any?
+                emit.call(:tool_calls, calls)
+              else
+                emit.call(:assistant_final, text)
+              end
+            end
+          else
+            uri = URI.parse("#{@base}/models/#{@model}:generateContent?key=#{@api_key}")
+            headers = { "content-type" => "application/json" }
+            body = JSON.dump({ contents: contents, system_instruction: (policy[:system_prompt] && { parts: [{ text: policy[:system_prompt] }], role: "user" }), tools: [{ functionDeclarations: fndecls }] })
+            http = Net::HTTP.new(uri.host, uri.port)
+            http.use_ssl = (uri.scheme == "https")
+            req = Net::HTTP::Post.new(uri.request_uri)
+            headers.each { |k,v| req[k] = v }
+            req.body = body
+            res = http.request(req)
+            if res.code.to_i != 200
+              emit.call(:assistant_final, "Gemini HTTP #{res.code}")
+            else
+              data = JSON.parse(res.body) rescue {}
+              parts = (data.dig("candidates",0,"content","parts") || [])
+              calls = parts.filter_map { |p| fc = p["functionCall"]; fc && { id: SecureRandom.uuid, name: fc["name"], arguments: fc["args"] || {} } }
+              if calls.any?
+                emit.call(:tool_calls, calls)
+              else
+                text = parts.filter_map { |p| p["text"] }.join
+                emit.call(:assistant_final, text.to_s)
+              end
+            end
+          end
+          :done
+        end
+
+        private
+        # (no IPv6/IPv4 forcing; rely on default Internet)
+        def normalize_gemini_tools(tools)
+          Array(tools).map { |t| normalize_gemini_tool(t) }
+        end
+
+        def normalize_gemini_tool(t)
+          return t.to_gemini_tool if t.respond_to?(:to_gemini_tool)
+
+          # Provider-shaped: { name:, description:, parameters: {…} }
+          if t.is_a?(Hash) && (t[:parameters] || t["parameters"])
+            return t
+          end
+
+          # Neutral hash {name:, description:, schema:}
+          if t.is_a?(Hash) && (t[:name] || t["name"])
+            return {
+              name:        t[:name]        || t["name"],
+              description: t[:description] || t["description"] || "",
+              parameters:  t[:schema]      || t["schema"]      || {}
+            }
+          end
+
+          raise TypeError, "unsupported tool descriptor: #{t.inspect}"
+        end
+
+
+        def to_gemini_contents(neutral)
+          items = []
+          neutral.each do |m|
+            case m[:role]
+            when "user"
+              items << { role: "user", parts: [{ text: m[:content].to_s }] }
+            when "assistant"
+              items << { role: "model", parts: [{ text: m[:content].to_s }] }
+            when "assistant_tool_calls"
+              # Gemini doesn't need us to echo previous functionCall(s)
+              # Skip: model will remember its own functionCall
+            when "tool_result"
+              # Provide functionResponse so model can continue
+              name = m[:name] || "tool"
+              items << { role: "user", parts: [{ functionResponse: { name: name, response: { content: m[:content].to_s } } }] }
+            end
+          end
+          items
+        end
+
+        def extract_sse_line!(buffer)
+          if (i = buffer.index("\n"))
+            line = buffer.slice!(0..i)
+            line.chomp!
+            return line
+          end
+          nil
+        end
+      end
+    end
+  end
+end
+

data/lib/vsm/drivers/openai/async_driver.rb

@@ -0,0 +1,202 @@
+# frozen_string_literal: true
+require "async"
+require "async/http/internet"
+require "json"
+
+module VSM
+  module Drivers
+    module OpenAI
+      class AsyncDriver
+        def initialize(api_key:, model:, base_url: "https://api.openai.com/v1")
+          @api_key, @model, @base = api_key, model, base_url
+        end
+
+        MAX_TOOL_TURNS = 8
+
+        def run!(conversation:, tools:, policy: {}, &emit)
+          internet = Async::HTTP::Internet.new
+          begin
+              headers = {
+                "Authorization" => "Bearer #{@api_key}",
+                "Content-Type"  => "application/json",
+                "Accept"        => "text/event-stream"
+              }
+
+              messages = to_openai_messages(conversation, policy[:system_prompt])
+              tool_list = normalize_openai_tools(tools)
+
+              req_body = JSON.dump({
+                model: @model,
+                messages: messages,
+                tools: tool_list,
+                tool_choice: "auto",
+                stream: true
+              })
+              
+              # Debug logging
+              if ENV["VSM_DEBUG_STREAM"] == "1"
+                $stderr.puts "openai => messages: #{JSON.pretty_generate(messages)}"
+                $stderr.puts "openai => tools count: #{tool_list.size}"
+              end
+
+              response = internet.post("#{@base}/chat/completions", headers, req_body)
+
+              if response.status != 200
+                body = response.read
+                warn "openai HTTP #{response.status}: #{body}"
+                emit.call(:assistant_final, "")
+                return :done
+              end
+
+              buffer      = +""
+              text_buffer = +""
+              tc_partial  = Hash.new { |h,k| h[k] = { id: nil, name: nil, args_str: +"" } }
+
+              response.body.each do |chunk|
+                buffer << chunk
+                while (line = extract_sse_line!(buffer))
+                  next if line.empty? || line.start_with?(":")
+                  next unless line.start_with?("data:")
+                  data = line.sub("data:","").strip
+                  $stderr.puts("openai <= #{data}") if ENV["VSM_DEBUG_STREAM"] == "1"
+                  next if data == "[DONE]"
+
+                  obj = JSON.parse(data) rescue nil
+                  next unless obj
+                  choice = obj.dig("choices",0) || {}
+                  delta  = choice["delta"] || {}
+
+                  if (content = delta["content"])
+                    text_buffer << content
+                    emit.call(:assistant_delta, content)
+                  end
+
+                  if (tcs = delta["tool_calls"])
+                    tcs.each do |tc|
+                      idx  = tc["index"] || 0
+                      cell = tc_partial[idx]
+                      cell[:id]   ||= tc["id"]
+                      fn           = tc["function"] || {}
+                      cell[:name] ||= fn["name"] if fn["name"]
+                      cell[:args_str] << (fn["arguments"] || "")
+                    end
+                  end
+
+                  if (fr = choice["finish_reason"])
+                    case fr
+                    when "tool_calls"
+                      calls = tc_partial.keys.sort.map do |i|
+                        cell = tc_partial[i]
+                        {
+                          id:  cell[:id]   || "call_#{i}",
+                          name: cell[:name] || "unknown_tool",
+                          arguments: safe_json(cell[:args_str])
+                        }
+                      end
+                      tc_partial.clear
+                      emit.call(:tool_calls, calls)
+                    when "stop", "length", "content_filter"
+                      emit.call(:assistant_final, text_buffer.dup)
+                      text_buffer.clear
+                    end
+                  end
+                end
+              end
+          ensure
+            internet.close
+          end
+          :done
+        end
+
+        private
+        def normalize_openai_tools(tools)
+          Array(tools).map { |t| normalize_openai_tool(t) }
+        end
+
+        def normalize_openai_tool(t)
+          # Case 1: our Descriptor object
+          return t.to_openai_tool if t.respond_to?(:to_openai_tool)
+
+          # Case 2: provider-shaped already (OpenAI tools API)
+          if (t.is_a?(Hash) && (t[:type] || t["type"]))
+            return t
+          end
+
+          # Case 3: neutral hash {name:, description:, schema:}
+          if t.is_a?(Hash) && (t[:name] || t["name"])
+            return {
+              type: "function",
+              function: {
+                name:        t[:name]        || t["name"],
+                description: t[:description] || t["description"] || "",
+                parameters:  t[:schema]      || t["schema"]      || {}
+              }
+            }
+          end
+
+          raise TypeError, "unsupported tool descriptor: #{t.inspect}"
+        end
+
+
+        def to_openai_messages(neutral, system_prompt)
+          msgs = []
+          msgs << { role: "system", content: system_prompt } if system_prompt
+          neutral.each do |m|
+            case m[:role]
+            when "user"
+              msgs << { role: "user", content: m[:content].to_s }
+            when "assistant"
+              msgs << { role: "assistant", content: m[:content].to_s }
+            when "assistant_tool_calls"
+              msg = {
+                role: "assistant",
+                tool_calls: Array(m[:tool_calls]).map { |c|
+                  {
+                    id: c[:id],
+                    type: "function",
+                    function: {
+                      name: c[:name],
+                      arguments: JSON.dump(c[:arguments] || {})
+                    }
+                  }
+                }
+              }
+              msgs << msg
+              if ENV["VSM_DEBUG_STREAM"] == "1"
+                $stderr.puts "OpenAI: Converting assistant_tool_calls: #{msg[:tool_calls].map{|tc| "#{tc[:function][:name]}(#{tc[:id]})"}.join(', ')}"
+              end
+            when "tool_result"
+              msg = {
+                role: "tool",
+                tool_call_id: m[:tool_call_id],
+                content: m[:content].to_s
+              }
+              msgs << msg
+              if ENV["VSM_DEBUG_STREAM"] == "1"
+                $stderr.puts "OpenAI: Converting tool_result(#{m[:tool_call_id]}): #{m[:content].to_s.slice(0, 100)}"
+              end
+            end
+          end
+          msgs
+        end
+
+        def extract_sse_line!(buffer)
+          if (i = buffer.index("\n"))
+            line = buffer.slice!(0..i)
+            line.chomp!
+            return line
+          end
+          nil
+        end
+
+        def safe_json(s)
+          return {} if s.nil? || s.empty?
+          JSON.parse(s)
+        rescue JSON::ParserError
+          { "_raw" => s }
+        end
+      end
+    end
+  end
+end
+

data/lib/vsm/dsl.rb

@@ -0,0 +1,50 @@
+# frozen_string_literal: true
+module VSM
+  module DSL
+    class Builder
+      def initialize(name)
+        @name = name
+        @roles = {}
+        @children = {}
+      end
+
+      def identity(klass: VSM::Identity, args: {})     = (@roles[:identity]     = klass.new(**args))
+      def governance(klass: VSM::Governance, args: {}) = (@roles[:governance]   = klass.new(**args))
+      def coordination(klass: VSM::Coordination, args: {}) = (@roles[:coordination] = klass.new(**args))
+      def intelligence(klass: VSM::Intelligence, args: {}) = (@roles[:intelligence] = klass.new(**args))
+      def operations(klass: VSM::Operations, args: {}, &blk)
+        @roles[:operations] = klass.new(**args)
+        if blk
+          builder = ChildrenBuilder.new
+          builder.instance_eval(&blk)
+          @children.merge!(builder.result)
+        end
+      end
+
+      def monitoring(klass: VSM::Monitoring, args: {}) = (@roles[:monitoring] = klass.new(**args))
+
+      def build
+        # Inject governance into tool capsules if they accept it
+        @children.each_value do |child|
+          child.governance = @roles[:governance] if child.respond_to?(:governance=)
+        end
+        VSM::Capsule.new(name: @name, roles: @roles, children: @children)
+      end
+
+      class ChildrenBuilder
+        def initialize; @children = {}; end
+        def capsule(name, klass:, args: {})
+          @children[name.to_s] = klass.new(**args)
+        end
+        def result = @children
+        def method_missing(*) = result
+        def respond_to_missing?(*) = true
+      end
+    end
+
+    def self.define(name, &blk)
+      Builder.new(name).tap { |b| b.instance_eval(&blk) }.build
+    end
+  end
+end
+

data/lib/vsm/executors/fiber_executor.rb

@@ -0,0 +1,10 @@
+# frozen_string_literal: true
+module VSM
+  module Executors
+    module FiberExecutor
+      def self.call(tool, args)
+        tool.run(args) # runs in current Async task
+      end
+    end
+  end
+end

data/lib/vsm/executors/thread_executor.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+module VSM
+  module Executors
+    module ThreadExecutor
+      def self.call(tool, args)
+        q = Queue.new
+        Thread.new do
+          begin
+            q << [:ok, tool.run(args)]
+          rescue => e
+            q << [:err, e]
+          end
+        end
+        tag, val = q.pop
+        tag == :ok ? val : raise(val)
+      end
+    end
+  end
+end

data/lib/vsm/homeostat.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+module VSM
+  class Homeostat
+    attr_reader :limits
+
+    def initialize
+      @limits = { tokens: 8_000, time_ms: 15_000, bytes: 2_000_000 }
+      @usage  = Hash.new(0)
+    end
+
+    def usage_snapshot
+      @usage.dup
+    end
+
+    def alarm?(message)
+      message.meta&.dig(:severity) == :algedonic
+    end
+  end
+end