DSPEx + Jido.Action Integration Analysis

Recommendation: Selective Adoption

Rather than wholesale adoption, I recommend taking specific patterns and concepts from Jido.Action that align with DSPEx’s goals.

What to Adopt from Jido.Action

1. Parameter Validation Pattern

# Current DSPEx approach
defmodule QASignature do
  use DSPEx.Signature, "question -> answer"
end

# Enhanced with Jido-style validation
defmodule EnhancedPredict do
  use DSPEx.Program,
    schema: [
      signature: [type: :atom, required: true],
      client: [type: :atom, required: true],
      temperature: [type: :float, default: 0.7],
      max_tokens: [type: :integer, default: 150]
    ]
  
  def run(params, context) do
    # Validated params come in
    {:ok, result}
  end
end

2. Error Handling Infrastructure

# Adopt Jido's structured error system
defmodule DSPEx.Error do
  use TypedStruct
  
  typedstruct do
    field(:type, error_type(), enforce: true)
    field(:message, String.t(), enforce: true)
    field(:details, map(), default: %{})
  end
  
  # DSPEx-specific error types
  def prediction_error(message, details \\ %{})
  def signature_error(message, details \\ %{})
  def teleprompter_error(message, details \\ %{})
end

3. Execution Framework

# Enhanced DSPEx.Exec inspired by Jido.Exec
defmodule DSPEx.Exec do
  def run(program, inputs, opts \\ []) do
    with {:ok, normalized_inputs} <- normalize_inputs(inputs),
         {:ok, validated_inputs} <- validate_inputs(program, normalized_inputs),
         {:ok, result} <- execute_with_telemetry(program, validated_inputs, opts),
         {:ok, validated_output} <- validate_outputs(program, result) do
      {:ok, result}
    end
  end
  
  def run_async(program, inputs, opts \\ []) do
    # Async execution similar to Jido
  end
end

4. Tool Integration

# DSPEx programs as AI tools
defmodule DSPEx.Tool do
  def to_tool(program) do
    %{
      name: program_name(program),
      description: program_description(program),
      parameters: signature_to_schema(program.signature),
      function: &execute_program(program, &1, &2)
    }
  end
end

What NOT to Adopt

1. Agent System

DSPEx doesn’t need Jido’s agent/state management - LLM programs are more functional

2. Workflow Orchestration

DSPEx has its own composition patterns (chaining, teleprompters)

3. Compensation Patterns

LLM operations don’t typically need rollback/compensation

Proposed DSPEx Enhancement

# Enhanced DSPEx.Program with Jido-inspired features
defmodule DSPEx.Program do
  defmacro __using__(opts) do
    quote do
      @behaviour DSPEx.Program
      
      # Schema validation like Jido.Action
      @schema unquote(Keyword.get(opts, :schema, []))
      @output_schema unquote(Keyword.get(opts, :output_schema, []))
      
      # Metadata like Jido.Action
      def name, do: unquote(Keyword.get(opts, :name))
      def description, do: unquote(Keyword.get(opts, :description))
      def version, do: unquote(Keyword.get(opts, :version, "1.0.0"))
      
      # Tool conversion
      def to_tool, do: DSPEx.Tool.to_tool(__MODULE__)
      
      # Validation functions
      def validate_params(params), do: validate_against_schema(params, @schema)
      def validate_output(output), do: validate_against_schema(output, @output_schema)
    end
  end
end

# Usage
defmodule MyLLMProgram do
  use DSPEx.Program,
    name: "question_answerer",
    description: "Answers questions using LLM",
    schema: [
      question: [type: :string, required: true],
      context: [type: :string, required: false],
      temperature: [type: :float, default: 0.7]
    ],
    output_schema: [
      answer: [type: :string, required: true],
      confidence: [type: :float, required: false]
    ]
  
  def run(params, context) do
    # LLM program logic
    {:ok, %{answer: "...", confidence: 0.9}}
  end
end

Benefits of This Approach

Better Parameter Validation: NimbleOptions-based schemas
Improved Error Handling: Structured errors with context
Tool Integration: Easy conversion to AI tool format
Telemetry: Rich observability like Jido
Async Support: Non-blocking execution for long LLM calls

Keep DSPEx’s Core Identity

Signatures: Keep the signature system - it’s perfect for LLM I/O contracts
Teleprompters: This is DSPEx’s killer feature for LLM optimization
Client Management: LLM provider abstraction is crucial
Examples: Training data representation for few-shot learning

Implementation Strategy

Phase 1: Adopt error handling and validation patterns
Phase 2: Enhance execution framework with async support
Phase 3: Add tool integration capabilities
Phase 4: Improve telemetry and observability

This gives you the benefits of Jido’s execution patterns while preserving DSPEx’s unique LLM-focused capabilities.