solid_agent 0.0.0 → 0.2.0

data/lib/solid_agent/tool_cache.rb

@@ -0,0 +1,91 @@
+# frozen_string_literal: true
+
+require "digest"
+require "json"
+
+# Caches the results of tool / MCP / service interactions so repeated calls
+# with the same arguments reuse a persisted result instead of re-running the
+# side effect (HTTP fetch, search, remote MCP call, ...).
+#
+# Works out of the box in Rails apps (backed by Rails.cache); any object
+# responding to read/write can be substituted, so tests and non-Rails
+# runtimes can inject their own store.
+#
+# @example Caching a tool implementation
+#   def fetch_url(url:)
+#     SolidAgent::ToolCache.fetch(tool: "fetch_url", args: { url: url }) do
+#       Net::HTTP.get_response(URI(url)).body
+#     end
+#   end
+#
+# @example Disabling globally (e.g. in tests)
+#   SolidAgent::ToolCache.enabled = false
+module SolidAgent
+  module ToolCache
+    DEFAULT_TTL = 300 # seconds
+
+    class << self
+      attr_writer :enabled, :default_ttl, :store
+
+      def enabled
+        defined?(@enabled) ? @enabled : true
+      end
+
+      def default_ttl
+        @default_ttl || DEFAULT_TTL
+      end
+
+      def store
+        @store || (defined?(Rails) && Rails.respond_to?(:cache) ? Rails.cache : nil)
+      end
+
+      # Returns the cached result for (tool, args) or yields, caching the
+      # fresh result. Results that look like errors ({ error: ... }) are
+      # never cached, so transient failures don't stick.
+      #
+      # The returned hash is tagged with cached: true on cache hits so
+      # callers (and the model) can tell a replayed result from a fresh one.
+      def fetch(tool:, args: {}, ttl: nil, cache: store)
+        return yield unless enabled && cache
+
+        key = cache_key(tool, args)
+        cached = cache.read(key)
+        return tag_cached(cached) unless cached.nil?
+
+        result = yield
+        cache.write(key, result, expires_in: ttl || default_ttl) if cacheable?(result)
+        result
+      end
+
+      def cache_key(tool, args)
+        digest = Digest::SHA256.hexdigest(normalize_args(args).to_json)
+        "solid_agent:tool_cache:#{tool}:#{digest}"
+      end
+
+      private
+
+      def cacheable?(result)
+        return false if result.nil?
+        return !(result.key?(:error) || result.key?("error")) if result.respond_to?(:key?)
+
+        true
+      end
+
+      def tag_cached(result)
+        result.respond_to?(:merge) ? result.merge(cached: true) : result
+      end
+
+      # Stable key material regardless of hash ordering or string/symbol keys.
+      def normalize_args(args)
+        case args
+        when Hash
+          args.map { |k, v| [ k.to_s, normalize_args(v) ] }.sort_by(&:first)
+        when Array
+          args.map { |v| normalize_args(v) }
+        else
+          args
+        end
+      end
+    end
+  end
+end

data/lib/solid_agent/version.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+module SolidAgent
+  VERSION = "0.2.0"
+end

data/lib/solid_agent.rb

@@ -0,0 +1,95 @@
+# frozen_string_literal: true
+
+# The gem is written for a Rails host and used to assume one had already loaded
+# ActiveSupport and ActiveModel for it — `require "solid_agent"` on its own
+# raised NameError on ActiveSupport::Concern. Requiring the pieces we actually
+# use makes the gem loadable from a plain Ruby process (a rake task, an IRB
+# session, a non-Rails consumer of AgentManifest) and costs a Rails host
+# nothing, since these are already loaded there.
+#
+# The core extensions are named one by one rather than pulled in with
+# `active_support/all`: `safe_constantize` and `presence` are what the records
+# seam calls, and a gem should not decide for its host that every monkey patch
+# ActiveSupport ships is loaded.
+require "active_support"
+require "active_support/concern"
+require "active_support/notifications"
+require "active_support/core_ext/object/blank"
+require "active_support/core_ext/string/inflections"
+require "active_model"
+
+require_relative "solid_agent/version"
+require_relative "solid_agent/model_naming"
+require_relative "solid_agent/records"
+require_relative "solid_agent/tool_cache"
+require_relative "solid_agent/model_pricing"
+require_relative "solid_agent/run_fingerprint"
+
+module SolidAgent
+  class Error < StandardError; end
+  class LoadError < Error; end
+
+  class << self
+    attr_accessor :context_class, :message_class, :generation_class
+
+    def configure
+      yield self if block_given?
+    end
+
+    # Unified agent loading from any source
+    #
+    # @param source [String, Hash, URI] File path, URL, JSON, YAML, or Hash
+    # @param format [Symbol] Force format (:agent_md, :json, :yaml, :dotprompt, :crewai)
+    # @param base_class [Class] Parent class for generated agent
+    # @param as [String] Register as constant with this name
+    # @return [Class] Generated agent class
+    #
+    # @example Load from file
+    #   ResearchAgent = SolidAgent.agent("agents/research.agent.md")
+    #
+    # @example Load from URL
+    #   WeatherAgent = SolidAgent.agent("https://registry.example.com/weather.agent.md")
+    #
+    # @example Load from hash
+    #   QuickAgent = SolidAgent.agent({ name: "quick", model: "gpt-4o", instructions: "Be helpful" })
+    #
+    def agent(source, format: nil, base_class: nil, as: nil)
+      manifest = AgentManifest.load(source, format: format)
+      AgentManifest.build(manifest, base_class: base_class, class_name: as)
+    end
+
+    # Load multiple agents from a directory
+    #
+    # @param directory [String] Path to directory containing agent manifests
+    # @param pattern [String] Glob pattern for manifest files
+    # @param options [Hash] Options passed to agent()
+    # @return [Array<Class>] Array of generated agent classes
+    #
+    # @example Load all agents from config/agents
+    #   SolidAgent.agents_from("config/agents")
+    #
+    def agents_from(directory, pattern: "**/*.agent.md", **options)
+      Dir.glob(File.join(directory, pattern)).map do |path|
+        agent(path, **options)
+      end
+    end
+  end
+
+  # Default configuration
+  self.context_class = "AgentContext"
+  self.message_class = "AgentMessage"
+  self.generation_class = "AgentGeneration"
+end
+
+require_relative "solid_agent/has_context"
+require_relative "solid_agent/has_memory"
+require_relative "solid_agent/has_tools"
+require_relative "solid_agent/streams_tool_updates"
+require_relative "solid_agent/reasonable"
+require_relative "solid_agent/has_reasons"
+require_relative "solid_agent/agent_manifest"
+
+# Load Rails integration if Rails is present
+if defined?(Rails::Engine)
+  require_relative "solid_agent/engine"
+end

data/sig/solid_agent.rbs

@@ -0,0 +1,4 @@
+module SolidAgent
+  VERSION: String
+  # See the writing guide of rbs: https://github.com/ruby/rbs#guides
+end

metadata

@@ -1,27 +1,188 @@
 --- !ruby/object:Gem::Specification
 name: solid_agent
 version: !ruby/object:Gem::Version
-  version: 0.0.0
+  version: 0.2.0
 platform: ruby
 authors:
 - Justin Bowen
-autorequire:
-bindir: bin
+bindir: exe
 cert_chain: []
-date: 2024-05-29 00:00:00.000000000 Z
-dependencies: []
-description: A simple way to make Ruby AI Agents
-email: jusbowen@gmail.com
+date: 1980-01-02 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: activeagent
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 1.0.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 1.0.0
+- !ruby/object:Gem::Dependency
+  name: activesupport
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '7.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '7.0'
+- !ruby/object:Gem::Dependency
+  name: activerecord
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '7.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '7.0'
+- !ruby/object:Gem::Dependency
+  name: activemodel
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '7.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '7.0'
+description: SolidAgent extends ActiveAgent with database-backed prompt context management,
+  declarative tool schemas, and real-time streaming updates. Provides has_context,
+  has_tools, and streams_tool_updates concerns for building robust AI agents.
+email:
+- JusBowen@gmail.com
 executables: []
 extensions: []
 extra_rdoc_files: []
 files:
+- CHANGELOG.md
+- LICENSE
+- README.md
+- Rakefile
+- docs/agent-md-spec.md
+- docs/parser-design.md
+- docs/registry-api.md
+- examples/README.md
+- examples/manifests/changelog_writer.agent.md
+- examples/manifests/usage.rb
+- examples/memory_handoff/app/agents/researcher_agent.rb
+- examples/memory_handoff/app/agents/writer_agent.rb
+- examples/memory_handoff/usage.rb
+- examples/persistent_conversation/app/agents/support_agent.rb
+- examples/persistent_conversation/app/controllers/support_conversations_controller.rb
+- examples/persistent_conversation/app/views/agents/support/instructions.md.erb
+- examples/persistent_conversation/usage.rb
+- examples/reasoning/app/agents/analysis_agent.rb
+- examples/reasoning/usage.rb
+- examples/run_tracking/app/agents/report_agent.rb
+- examples/run_tracking/app/controllers/agent_runs_controller.rb
+- examples/run_tracking/app/jobs/document_analysis_job.rb
+- examples/run_tracking/app/services/document_analysis_run.rb
+- examples/run_tracking/usage.rb
+- examples/tool_streaming/app/agents/browser_agent.rb
+- examples/tool_streaming/app/channels/tool_status_channel.rb
+- examples/tool_streaming/app/views/browser_agent/tools/fetch_url.json.erb
+- examples/tool_streaming/usage.rb
+- lib/generators/solid_agent/agent/agent_generator.rb
+- lib/generators/solid_agent/agent/templates/action.text.erb
+- lib/generators/solid_agent/agent/templates/agent.rb.erb
+- lib/generators/solid_agent/context/context_generator.rb
+- lib/generators/solid_agent/context/templates/context_model.rb.erb
+- lib/generators/solid_agent/context/templates/create_context.rb.erb
+- lib/generators/solid_agent/context/templates/create_generations.rb.erb
+- lib/generators/solid_agent/context/templates/create_messages.rb.erb
+- lib/generators/solid_agent/context/templates/generation_model.rb.erb
+- lib/generators/solid_agent/context/templates/message_model.rb.erb
+- lib/generators/solid_agent/install/install_generator.rb
+- lib/generators/solid_agent/install/templates/agent_context.rb.erb
+- lib/generators/solid_agent/install/templates/agent_generation.rb.erb
+- lib/generators/solid_agent/install/templates/agent_memory.rb.erb
+- lib/generators/solid_agent/install/templates/agent_memory_entry.rb.erb
+- lib/generators/solid_agent/install/templates/agent_message.rb.erb
+- lib/generators/solid_agent/install/templates/agent_run.rb.erb
+- lib/generators/solid_agent/install/templates/create_agent_contexts.rb.erb
+- lib/generators/solid_agent/install/templates/create_agent_generations.rb.erb
+- lib/generators/solid_agent/install/templates/create_agent_memories.rb.erb
+- lib/generators/solid_agent/install/templates/create_agent_messages.rb.erb
+- lib/generators/solid_agent/install/templates/create_agent_runs.rb.erb
+- lib/generators/solid_agent/install/templates/initializer.rb.erb
+- lib/generators/solid_agent/manifest/manifest_generator.rb
+- lib/generators/solid_agent/manifest/templates/agent.md.erb
+- lib/generators/solid_agent/manifest/templates/prompt.erb
+- lib/generators/solid_agent/reasons/reasons_generator.rb
+- lib/generators/solid_agent/reasons/templates/add_reasoning_columns.rb.erb
+- lib/generators/solid_agent/tool/templates/tool.json.erb
+- lib/generators/solid_agent/tool/tool_generator.rb
 - lib/solid_agent.rb
-homepage: https://rubygems.org/gems/solid_eagent
+- lib/solid_agent/agent_manifest.rb
+- lib/solid_agent/agent_manifest/agent_builder.rb
+- lib/solid_agent/agent_manifest/errors.rb
+- lib/solid_agent/agent_manifest/exporter_registry.rb
+- lib/solid_agent/agent_manifest/exporters/agent_md_exporter.rb
+- lib/solid_agent/agent_manifest/exporters/base_exporter.rb
+- lib/solid_agent/agent_manifest/exporters/crewai_exporter.rb
+- lib/solid_agent/agent_manifest/exporters/dotprompt_exporter.rb
+- lib/solid_agent/agent_manifest/input_schema.rb
+- lib/solid_agent/agent_manifest/manifest.rb
+- lib/solid_agent/agent_manifest/parser_registry.rb
+- lib/solid_agent/agent_manifest/parsers/agent_md_parser.rb
+- lib/solid_agent/agent_manifest/parsers/base_parser.rb
+- lib/solid_agent/agent_manifest/parsers/crewai_parser.rb
+- lib/solid_agent/agent_manifest/parsers/dotprompt_parser.rb
+- lib/solid_agent/agent_manifest/parsers/github_prompt_parser.rb
+- lib/solid_agent/agent_manifest/picoschema.rb
+- lib/solid_agent/agent_manifest/registry/auth.rb
+- lib/solid_agent/agent_manifest/registry/client.rb
+- lib/solid_agent/agent_manifest/resource.rb
+- lib/solid_agent/agent_manifest/tool.rb
+- lib/solid_agent/agent_manifest/validator.rb
+- lib/solid_agent/engine.rb
+- lib/solid_agent/has_context.rb
+- lib/solid_agent/has_memory.rb
+- lib/solid_agent/has_reasons.rb
+- lib/solid_agent/has_tools.rb
+- lib/solid_agent/model_naming.rb
+- lib/solid_agent/model_pricing.rb
+- lib/solid_agent/reasonable.rb
+- lib/solid_agent/reasonable/reason.rb
+- lib/solid_agent/records.rb
+- lib/solid_agent/records/agent.rb
+- lib/solid_agent/records/agent_run.rb
+- lib/solid_agent/records/agent_template.rb
+- lib/solid_agent/records/agent_version.rb
+- lib/solid_agent/records/ownable.rb
+- lib/solid_agent/run_fingerprint.rb
+- lib/solid_agent/streams_tool_updates.rb
+- lib/solid_agent/tool_cache.rb
+- lib/solid_agent/version.rb
+- sig/solid_agent.rbs
+homepage: https://docs.activeagents.ai/solid_agent
 licenses:
 - MIT
-metadata: {}
-post_install_message:
+metadata:
+  homepage_uri: https://docs.activeagents.ai/solid_agent
+  source_code_uri: https://github.com/activeagents/solid_agent
+  changelog_uri: https://github.com/activeagents/solid_agent/blob/main/CHANGELOG.md
+  documentation_uri: https://docs.activeagents.ai/solid_agent
 rdoc_options: []
 require_paths:
 - lib
@@ -29,15 +190,14 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
-      version: '0'
+      version: 3.0.0
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.5.3
-signing_key:
+rubygems_version: 3.7.2
 specification_version: 4
-summary: A simple way to make Ruby AI Agents
+summary: Database-backed context, tools, and streaming for ActiveAgent
 test_files: []