pocketflow 1.0.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 490463d8d52e70e815ca1a168f6898f63635598a974345986fe56d7455b5de3c
+  data.tar.gz: 4a1a7e3f49c36db3d280cc3ceb7851f291b542fbb1118a9caf458ec071622a64
+SHA512:
+  metadata.gz: 6ad329a5dc7bac6d51ffc071823bc2f823d7627ba06bdb9d33bf2f87ad6740e03be97b5e957b0e2f23a886a27e7f569f39bfb97f619cfe0836fa0b4d90269963
+  data.tar.gz: 85df02a0643c70785e7f23943494ed6bd8905461206ed2c00ca910d3efae20cb93effd9bb91444a162c693c0d1cf3bf67471af8dd0a44740377f89f054e58d43

data/CODE_OF_CONDUCT.md

@@ -0,0 +1,132 @@
+# Contributor Covenant Code of Conduct
+
+## Our Pledge
+
+We as members, contributors, and leaders pledge to make participation in our
+community a harassment-free experience for everyone, regardless of age, body
+size, visible or invisible disability, ethnicity, sex characteristics, gender
+identity and expression, level of experience, education, socio-economic status,
+nationality, personal appearance, race, caste, color, religion, or sexual
+identity and orientation.
+
+We pledge to act and interact in ways that contribute to an open, welcoming,
+diverse, inclusive, and healthy community.
+
+## Our Standards
+
+Examples of behavior that contributes to a positive environment for our
+community include:
+
+* Demonstrating empathy and kindness toward other people
+* Being respectful of differing opinions, viewpoints, and experiences
+* Giving and gracefully accepting constructive feedback
+* Accepting responsibility and apologizing to those affected by our mistakes,
+  and learning from the experience
+* Focusing on what is best not just for us as individuals, but for the overall
+  community
+
+Examples of unacceptable behavior include:
+
+* The use of sexualized language or imagery, and sexual attention or advances of
+  any kind
+* Trolling, insulting or derogatory comments, and personal or political attacks
+* Public or private harassment
+* Publishing others' private information, such as a physical or email address,
+  without their explicit permission
+* Other conduct which could reasonably be considered inappropriate in a
+  professional setting
+
+## Enforcement Responsibilities
+
+Community leaders are responsible for clarifying and enforcing our standards of
+acceptable behavior and will take appropriate and fair corrective action in
+response to any behavior that they deem inappropriate, threatening, offensive,
+or harmful.
+
+Community leaders have the right and responsibility to remove, edit, or reject
+comments, commits, code, wiki edits, issues, and other contributions that are
+not aligned to this Code of Conduct, and will communicate reasons for moderation
+decisions when appropriate.
+
+## Scope
+
+This Code of Conduct applies within all community spaces, and also applies when
+an individual is officially representing the community in public spaces.
+Examples of representing our community include using an official email address,
+posting via an official social media account, or acting as an appointed
+representative at an online or offline event.
+
+## Enforcement
+
+Instances of abusive, harassing, or otherwise unacceptable behavior may be
+reported to the community leaders responsible for enforcement at
+[INSERT CONTACT METHOD].
+All complaints will be reviewed and investigated promptly and fairly.
+
+All community leaders are obligated to respect the privacy and security of the
+reporter of any incident.
+
+## Enforcement Guidelines
+
+Community leaders will follow these Community Impact Guidelines in determining
+the consequences for any action they deem in violation of this Code of Conduct:
+
+### 1. Correction
+
+**Community Impact**: Use of inappropriate language or other behavior deemed
+unprofessional or unwelcome in the community.
+
+**Consequence**: A private, written warning from community leaders, providing
+clarity around the nature of the violation and an explanation of why the
+behavior was inappropriate. A public apology may be requested.
+
+### 2. Warning
+
+**Community Impact**: A violation through a single incident or series of
+actions.
+
+**Consequence**: A warning with consequences for continued behavior. No
+interaction with the people involved, including unsolicited interaction with
+those enforcing the Code of Conduct, for a specified period of time. This
+includes avoiding interactions in community spaces as well as external channels
+like social media. Violating these terms may lead to a temporary or permanent
+ban.
+
+### 3. Temporary Ban
+
+**Community Impact**: A serious violation of community standards, including
+sustained inappropriate behavior.
+
+**Consequence**: A temporary ban from any sort of interaction or public
+communication with the community for a specified period of time. No public or
+private interaction with the people involved, including unsolicited interaction
+with those enforcing the Code of Conduct, is allowed during this period.
+Violating these terms may lead to a permanent ban.
+
+### 4. Permanent Ban
+
+**Community Impact**: Demonstrating a pattern of violation of community
+standards, including sustained inappropriate behavior, harassment of an
+individual, or aggression toward or disparagement of classes of individuals.
+
+**Consequence**: A permanent ban from any sort of public interaction within the
+community.
+
+## Attribution
+
+This Code of Conduct is adapted from the [Contributor Covenant][homepage],
+version 2.1, available at
+[https://www.contributor-covenant.org/version/2/1/code_of_conduct.html][v2.1].
+
+Community Impact Guidelines were inspired by
+[Mozilla's code of conduct enforcement ladder][Mozilla CoC].
+
+For answers to common questions about this code of conduct, see the FAQ at
+[https://www.contributor-covenant.org/faq][FAQ]. Translations are available at
+[https://www.contributor-covenant.org/translations][translations].
+
+[homepage]: https://www.contributor-covenant.org
+[v2.1]: https://www.contributor-covenant.org/version/2/1/code_of_conduct.html
+[Mozilla CoC]: https://github.com/mozilla/diversity
+[FAQ]: https://www.contributor-covenant.org/faq
+[translations]: https://www.contributor-covenant.org/translations

data/LICENSE.txt

@@ -0,0 +1,45 @@
+MIT License
+
+Copyright (c) 2025 Victor Duarte and Zachary Huang
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
+
+---
+
+The MIT License (MIT)
+
+Copyright (c) 2025 Jonathan Hoyt
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

data/README.md

@@ -0,0 +1,253 @@
+# PocketFlow Ruby
+
+PocketFlow Ruby is a minimal, synchronous workflow library for Ruby 3.4+, **ported from the excellent [PocketFlow project](https://github.com/The-Pocket/PocketFlow)** by [The Pocket](https://www.thepocket.io/). This version draws inspiration primarily from the TypeScript implementation and reimagines it using idiomatic Ruby and plain-old Ruby objects. It aims to maintain API consistency across languages while being lightweight and extensible.
+
+> [!NOTE]
+> This library is a community-maintained port and is not affiliated with or officially supported by the original PocketFlow maintainers.
+
+All "parallel" variants currently run sequentially, making it safe to adopt now and evolve toward concurrency later without breaking consumers.
+
+## Getting Started
+
+Add PocketFlow to your `Gemfile`:
+
+```ruby
+gem "pocketflow"
+```
+
+Then install via Bundler:
+
+```bash
+bundle install
+```
+
+## Core Abstractions
+
+PocketFlow is built around a handful of simple, composable concepts:
+
+- **BaseNode**: The fundamental unit of work, following a `prep → exec → post` lifecycle. Successor nodes are linked via actions.
+- **Node**: Extends `BaseNode` with configurable retry and wait behavior around `exec` (via `max_retries` and `wait`).
+- **BatchNode**: Processes an array of items sequentially, applying `exec` to each element.
+- **ParallelBatchNode**: API-compatible with `BatchNode`; runs sequentially for now.
+- **Flow**: Orchestrates a graph of linked nodes, starting from a root node and following action-based transitions.
+- **BatchFlow**: Executes a flow once per parameter set returned by `prep`, useful for batch processing.
+- **ParallelBatchFlow**: API-compatible with `BatchFlow`; runs sequentially for now.
+
+## Examples
+
+### Hello World
+
+```ruby
+require "pocketflow"
+
+class HelloNode < Pocketflow::Node
+  def exec(_)
+    puts "hello, world"
+  end
+end
+
+Pocketflow::Flow.new(HelloNode.new).run({})
+```
+
+```mermaid
+flowchart LR
+  HelloNode[HelloNode] --> Flow[Flow]
+```
+
+### Question-Answer (QA) Pattern
+
+```ruby
+require "pocketflow"
+
+# Define the nodes
+class GetQuestionNode < Pocketflow::Node
+  def initialize(question)
+    @question = question
+    super()
+  end
+  def exec(_)
+    @question
+  end
+  def post(shared, _prep, question)
+    shared[:question] = question
+    "default"
+  end
+end
+
+class AnswerNode < Pocketflow::Node
+  def prep(shared)
+    shared[:question] || ""
+  end
+  def exec(question)
+    # Simple QA logic / LLM call
+    if question.include?("PocketFlow")
+      "PocketFlow is a TypeScript library for building reliable AI pipelines."
+    else
+      "I don't know the answer to that question."
+    end
+  end
+  def post(shared, _prep, answer)
+    shared[:answer] = answer
+    nil
+  end
+end
+
+# Build and run the flow
+flow = Pocketflow::Flow.new(
+  GetQuestionNode.new("What is PocketFlow?")
+    .next(AnswerNode.new)
+)
+shared = {}
+flow.run(shared)
+puts shared[:answer]
+```
+
+```mermaid
+flowchart LR
+  GetQuestionNode[GetQuestionNode] --> AnswerNode[AnswerNode]
+```
+
+
+### Retrieval-Augmented Generation (RAG) Pattern
+
+```ruby
+require "pocketflow"
+
+# Offline indexing
+offline_flow = Pocketflow::Flow.new(
+  ChunkDocs.new
+    .next(EmbedDocs.new)
+    .next(StoreIndex.new)
+)
+shared = { files: %w[doc1.txt doc2.txt] }
+offline_flow.run(shared)
+
+# Online query and answer
+online_flow = Pocketflow::Flow.new(
+  EmbedQuery.new
+    .next(RetrieveDocs.new)
+    .next(GenerateAnswer.new)
+)
+shared[:question] = "What is the content about?"
+online_flow.run(shared)
+puts shared[:answer]
+
+# Combined RAG pipeline
+full_flow = Pocketflow::Flow.new(
+  ChunkDocs.new
+    .next(EmbedDocs.new)
+    .next(StoreIndex.new)
+    .next(EmbedQuery.new)
+    .next(RetrieveDocs.new)
+    .next(GenerateAnswer.new)
+)
+shared = { files: %w[doc1.txt doc2.txt], question: "What is the content about?" }
+full_flow.run(shared)
+puts shared[:answer]
+```
+
+#### Offline Flow
+
+```mermaid
+flowchart LR
+  ChunkDocs[ChunkDocs] --> EmbedDocs[EmbedDocs] --> StoreIndex[StoreIndex]
+```
+
+#### Online Flow
+
+```mermaid
+flowchart LR
+  EmbedQuery[EmbedQuery] --> RetrieveDocs[RetrieveDocs] --> GenerateAnswer[GenerateAnswer]
+```
+
+### MapReduce Pattern
+
+```ruby
+require "pocketflow"
+
+# Summarize multiple files
+flow = Pocketflow::Flow.new(
+  SummarizeAllFiles.new
+    .on("summarized", CombineSummaries.new)
+)
+shared = { files: { 'file1.txt' => '...', 'file2.txt' => '...', 'file3.txt' => '...' } }
+flow.run(shared)
+puts shared[:all_files_summary]
+```
+
+```mermaid
+flowchart LR
+  SummarizeAllFiles[SummarizeAllFiles] --> CombineSummaries[CombineSummaries]
+```
+
+```ruby
+# Map and reduce text transformation
+flow = Pocketflow::Flow.new(
+  MapChunks.new
+    .on("mapped", ReduceResults.new)
+)
+shared = { text_to_process: 'This is a sample text to process.' }
+flow.run(shared)
+puts shared[:final_result]
+```
+
+```mermaid
+flowchart LR
+  MapChunks[MapChunks] --> ReduceResults[ReduceResults]
+```
+
+### Multi-Agent Pattern
+
+```ruby
+require "pocketflow"
+
+# Simple message listener loop
+listener = ListenerAgent.new.on("continue", ListenerAgent.new)
+flow = Pocketflow::Flow.new(listener)
+shared = { messages: ["msg1", "msg2", "msg3"], processed_messages: [] }
+flow.run(shared)
+puts shared[:processed_messages]
+```
+
+```mermaid
+flowchart LR
+  ListenerAgent[ListenerAgent] --> ListenerAgent[ListenerAgent]
+```
+
+```ruby
+# Taboo-style hint and guess agents
+hinter = Hinter.new.on("continue_hinter", Hinter.new)
+guesser = Guesser.new.on("continue_guesser", Guesser.new)
+hinter_flow = Pocketflow::Flow.new(hinter)
+guesser_flow = Pocketflow::Flow.new(guesser)
+shared = {
+  target_word: "popsicle",
+  forbidden_words: %w[ice cream frozen stick summer],
+  past_guesses: [],
+  hinter_queue: ["start_game"],
+  guesser_queue: [],
+  game_over: false,
+  max_rounds: 3,
+  current_round: 0
+}
+until shared[:game_over]
+  hinter_flow.run(shared)
+  guesser_flow.run(shared)
+
+until shared[:game_over]
+puts shared[:past_guesses]
+```
+
+```mermaid
+flowchart LR
+  Hinter[Hinter] -->|continue_hinter| Hinter[Hinter]
+  Guesser[Guesser] -->|continue_guesser| Guesser[Guesser]
+```
+
+## Contributing
+
+Contributions and feedback are welcome — please fork the repository and open a pull request.
+
+## License
+
+This project is licensed under the MIT License - see the LICENSE.txt file for details.

data/Rakefile

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+
+require "bundler/gem_tasks"
+require "minitest/test_task"
+
+Minitest::TestTask.create
+
+task default: %i[test]

data/lib/pocketflow.rb

@@ -0,0 +1,293 @@
+# frozen_string_literal: true
+
+# Public: Pocketflow – A tiny, synchronous workflow library for Ruby 3.4+.
+#
+# The library mirrors sibling implementations in TypeScript, Python, Go and
+# Java while embracing plain‑old Ruby objects and language idioms. All "parallel"
+# variants share the same public surface as their concurrent cousins but run
+# sequentially for now so that real parallelism can be introduced later without
+# breaking consumers.
+#
+# Examples
+#
+#   require_relative "pocketflow"
+#
+#   class HelloNode < Pocketflow::Node
+#     def exec(*)
+#       puts "hello, world"
+#     end
+#   end
+#
+#   Pocketflow::Flow.new(HelloNode.new).run({})
+#
+# Returns nothing.
+module Pocketflow
+  VERSION = "1.0.0"
+
+  # Public: Default action name used when a node's +post+ does not specify one.
+  DEFAULT_ACTION = "default"
+
+  # Public: BaseNode is the minimal building block of a Pocketflow graph.
+  #
+  # A node's lifecycle is **prep → exec → post**. Override those hooks to
+  # perform work. Successor nodes are linked via {#next} or {#on}.
+  class BaseNode
+    # Public: Arbitrary parameters for the node.
+    attr_accessor :params
+
+    # Internal: Action → successor node mapping.
+    attr_reader :successors
+
+    # Public: Create a node.
+    #
+    # Returns the new BaseNode.
+    def initialize
+      @params     = {}
+      @successors = {}
+    end
+
+    # Public: Replace the parameter hash.
+    #
+    # params - The Hash of parameters (may be nil).
+    #
+    # Returns the node itself.
+    def set_params(params)
+      @params = params || {}
+      self
+    end
+
+    # Public: Connect this node to another node for a given action.
+    #
+    # node   - The BaseNode successor.
+    # action - The String action name (default: DEFAULT_ACTION).
+    #
+    # Returns the given node.
+    def next(node, action = DEFAULT_ACTION)
+      on(action, node)
+      node
+    end
+
+    alias >> next
+
+    # Public: Define (or overwrite) a successor for an action.
+    #
+    # action - The String action name.
+    # node   - The BaseNode successor.
+    #
+    # Returns the node itself.
+    def on(action, node)
+      warn "Overwriting successor for action '#{action}'" if @successors.key?(action)
+      @successors[action] = node
+      self
+    end
+
+    # Public: Prepare for execution. Override in subclasses.
+    #
+    # shared - The shared context passed through the entire flow.
+    #
+    # Returns an arbitrary prep object.
+    def prep(shared) = nil
+
+    # Public: Perform the primary work. Override in subclasses.
+    #
+    # prep_res - The value returned by +prep+.
+    #
+    # Returns an arbitrary execution result.
+    def exec(prep_res) = nil
+
+    # Public: Process results and decide the next action. Override in subclasses.
+    #
+    # shared    - The shared context.
+    # prep_res  - The object returned by +prep+.
+    # exec_res  - The object returned by +exec+.
+    #
+    # Returns the String action name or +nil+ / DEFAULT_ACTION.
+    def post(shared, prep_res, exec_res) = nil
+
+    # Internal: Wrapper around the node lifecycle.
+    #
+    # shared - The shared context.
+    #
+    # Returns the action String (or nil).
+    def run_internal(shared)
+      prep_res = prep(shared)
+      exec_res = exec_internal(prep_res)
+      post(shared, prep_res, exec_res)
+    end
+
+    # Internal: Wrapper around +exec+. Subclasses override to inject retry
+    # logic.
+    #
+    # prep_res - The object returned by +prep+.
+    #
+    # Returns whatever +exec+ returns.
+    def exec_internal(prep_res) = exec(prep_res)
+
+    # Public: Execute this node as a standalone unit.
+    #
+    # shared - The shared context.
+    #
+    # Returns the action String (or nil).
+    def run(shared)
+      warn "Node won't run successors. Use Flow." unless @successors.empty?
+      run_internal(shared)
+    end
+
+    # Internal: Retrieve the successor for an action.
+    #
+    # action - The String action name (default: DEFAULT_ACTION).
+    #
+    # Returns the BaseNode successor or nil.
+    def get_next_node(action = DEFAULT_ACTION)
+      action = DEFAULT_ACTION if action.nil? || action.empty?
+      next_node = @successors[action]
+      warn "Flow ends: '#{action}' not found in #{successors.keys}" if next_node.nil? && !@successors.empty?
+      next_node
+    end
+
+    # Internal: Shallow‑clone the node so that params/successors are isolated.
+    #
+    # Returns the cloned BaseNode.
+    def clone
+      # Use Object#clone to preserve singleton methods; shallow-copy params and successors
+      cloned = super
+      cloned.params = @params.dup
+      cloned.instance_variable_set(:@successors, @successors.dup)
+      cloned
+    end
+  end
+
+  # Public: Node adds retry/wait behaviour around BaseNode#exec.
+  class Node < BaseNode
+    attr_reader :max_retries, :wait, :current_retry
+
+    # Public: Build a Node.
+    #
+    # max_retries - The Integer attempts per execution (minimum 1).
+    # wait        - The Numeric seconds between retries.
+    #
+    # Returns the new Node.
+    def initialize(max_retries: 1, wait: 0)
+      super()
+      @max_retries  = [max_retries, 1].max
+      @wait         = [wait, 0].max
+      @current_retry = 0
+    end
+
+    # Public: Called after all retries fail. Override to customise behaviour.
+    #
+    # prep_res - The object returned by +prep+.
+    # error    - The Exception raised by the last attempt.
+    #
+    # Returns an execution result or raises.
+    def exec_fallback(prep_res, error)
+      raise error
+    end
+
+    # Internal: Retry wrapper around +exec+.
+    def exec_internal(prep_res)
+      @current_retry = 0
+      while @current_retry < @max_retries
+        begin
+          return exec(prep_res)
+        rescue StandardError => e
+          if @current_retry == @max_retries - 1
+            return exec_fallback(prep_res, e)
+          end
+          sleep @wait if @wait.positive?
+        ensure
+          @current_retry += 1
+        end
+      end
+    end
+  end
+
+  # Public: BatchNode executes Node#exec_internal once per item.
+  class BatchNode < Node
+    # Internal: Sequentially process an Array of items.
+    def exec_internal(items)
+      return [] unless items.is_a?(Array)
+      items.map { |item| super(item) }
+    end
+  end
+
+  # Public: ParallelBatchNode matches BatchNode's API; runs sequentially for now.
+  class ParallelBatchNode < Node
+    # Internal: Sequentially process an Array of items.
+    def exec_internal(items)
+      return [] unless items.is_a?(Array)
+      items.map { |item| super(item) }
+    end
+  end
+
+  # Public: Flow orchestrates the execution of a linked chain of nodes.
+  class Flow < BaseNode
+    attr_reader :start
+
+    # Public: Build a Flow.
+    #
+    # start - The BaseNode that begins the graph.
+    #
+    # Returns the new Flow.
+    def initialize(start)
+      super()
+      @start = start
+    end
+
+    # Internal: Execute the graph beginning at +@start+.
+    #
+    # shared - The shared context.
+    # params - A Hash of parameters to merge into each node (optional).
+    #
+    # Returns nothing.
+    def orchestrate_internal(shared, params = nil)
+      current          = @start.clone
+      effective_params = params || @params
+
+      while current
+        current.set_params(effective_params)
+        action  = current.run_internal(shared)
+        current = current.get_next_node(action)&.clone
+      end
+    end
+
+    # Internal: Flow's lifecycle wrapper.
+    def run_internal(shared)
+      prep_res = prep(shared)
+      orchestrate_internal(shared)
+      post(shared, prep_res, nil)
+    end
+
+    # Public: Flows cannot be executed via +exec+.
+    def exec(*)
+      raise "Flow can't exec directly."
+    end
+  end
+
+  # Public: BatchFlow runs its flow once for every parameter‑set yielded by +prep+.
+  class BatchFlow < Flow
+    # Internal: Run the batch flow.
+    def run_internal(shared)
+      batch_params = prep(shared) || []
+      batch_params.each do |bp|
+        orchestrate_internal(shared, @params.merge(bp.to_h))
+      end
+      post(shared, batch_params, nil)
+    end
+
+    # Public: Override to supply an Array of Hash‑like parameter sets.
+    def prep(shared) = []
+  end
+
+  # Public: ParallelBatchFlow mirrors BatchFlow; execution is sequential.
+  class ParallelBatchFlow < BatchFlow
+    # Internal: Run the batch flow sequentially.
+    def run_internal(shared)
+      batch_params = prep(shared) || []
+      batch_params.each do |bp|
+        orchestrate_internal(shared, @params.merge(bp.to_h))
+      end
+      post(shared, batch_params, nil)
+    end
+  end
+end

metadata

@@ -0,0 +1,49 @@
+--- !ruby/object:Gem::Specification
+name: pocketflow
+version: !ruby/object:Gem::Version
+  version: 1.0.0
+platform: ruby
+authors:
+- Jonathan Hoyt
+bindir: exe
+cert_chain: []
+date: 2025-05-05 00:00:00.000000000 Z
+dependencies: []
+description: 'Pocket Flow: A minimalist LLM framework. Let Agents build Agents!'
+email:
+- jonmagic@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- CODE_OF_CONDUCT.md
+- LICENSE.txt
+- README.md
+- Rakefile
+- lib/pocketflow.rb
+homepage: https://github.com/jonmagic/PocketFlow-Ruby
+licenses:
+- MIT
+metadata:
+  homepage_uri: https://github.com/jonmagic/PocketFlow-Ruby
+  source_code_uri: https://github.com/jonmagic/PocketFlow-Ruby
+  changelog_uri: https://github.com/jonmagic/PocketFlow-Ruby
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 3.1.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.6.6
+specification_version: 4
+summary: pocketflow.rb is a Ruby port of the original Python version - a minimalist
+  LLM framework.
+test_files: []