chore: import upstream snapshot with attribution

apps/sim/tools/dspy/chain_of_thought.ts

@@ -0,0 +1,109 @@
+import type { DSPyChainOfThoughtParams, DSPyChainOfThoughtResponse } from '@/tools/dspy/types'
+import type { ToolConfig } from '@/tools/types'
+
+export const chainOfThoughtTool: ToolConfig<DSPyChainOfThoughtParams, DSPyChainOfThoughtResponse> =
+  {
+    id: 'dspy_chain_of_thought',
+    name: 'DSPy Chain of Thought',
+    description:
+      'Run a Chain of Thought prediction using a self-hosted DSPy ChainOfThought program endpoint',
+    version: '1.0.0',
+
+    params: {
+      baseUrl: {
+        type: 'string',
+        required: true,
+        visibility: 'user-only',
+        description: 'Base URL of the DSPy server (e.g., https://your-dspy-server.com)',
+      },
+      apiKey: {
+        type: 'string',
+        required: false,
+        visibility: 'user-only',
+        description: 'API key for authentication (if required by your server)',
+      },
+      endpoint: {
+        type: 'string',
+        required: false,
+        visibility: 'user-only',
+        description: 'API endpoint path (defaults to /predict)',
+      },
+      question: {
+        type: 'string',
+        required: true,
+        visibility: 'user-or-llm',
+        description: 'The question to answer using chain of thought reasoning',
+      },
+      context: {
+        type: 'string',
+        required: false,
+        visibility: 'user-or-llm',
+        description: 'Additional context to provide for answering the question',
+      },
+    },
+
+    request: {
+      method: 'POST',
+      url: (params) => {
+        const baseUrl = params.baseUrl.replace(/\/$/, '')
+        const endpoint = params.endpoint || '/predict'
+        return `${baseUrl}${endpoint}`
+      },
+      headers: (params) => {
+        const headers: Record<string, string> = {
+          'Content-Type': 'application/json',
+        }
+        if (params.apiKey) {
+          headers.Authorization = `Bearer ${params.apiKey}`
+        }
+        return headers
+      },
+      body: (params) => {
+        const body: Record<string, unknown> = {
+          text: params.question,
+        }
+
+        if (params.context) {
+          body.context = params.context
+        }
+
+        return body
+      },
+    },
+
+    transformResponse: async (response: Response) => {
+      const data = await response.json()
+
+      const status = data.status ?? 'success'
+      const outputData = data.data ?? data
+
+      return {
+        success: true,
+        output: {
+          answer: outputData.answer ?? outputData.output ?? outputData.response ?? '',
+          reasoning: outputData.reasoning ?? outputData.rationale ?? outputData.thought ?? '',
+          status,
+          rawOutput: outputData,
+        },
+      }
+    },
+
+    outputs: {
+      answer: {
+        type: 'string',
+        description: 'The answer generated through chain of thought reasoning',
+      },
+      reasoning: {
+        type: 'string',
+        description: 'The step-by-step reasoning that led to the answer',
+      },
+      status: {
+        type: 'string',
+        description: 'Response status from the DSPy server (success or error)',
+      },
+      rawOutput: {
+        type: 'json',
+        description: 'The complete raw output from the DSPy program (result.toDict())',
+      },
+    },
+  }

apps/sim/tools/dspy/index.ts

@@ -0,0 +1,4 @@
+export { chainOfThoughtTool } from '@/tools/dspy/chain_of_thought'
+export { predictTool } from '@/tools/dspy/predict'
+export { reactTool } from '@/tools/dspy/react'
+export * from '@/tools/dspy/types'

apps/sim/tools/dspy/predict.ts

@@ -0,0 +1,125 @@
+import type { DSPyPredictParams, DSPyPredictResponse } from '@/tools/dspy/types'
+import type { ToolConfig } from '@/tools/types'
+
+export const predictTool: ToolConfig<DSPyPredictParams, DSPyPredictResponse> = {
+  id: 'dspy_predict',
+  name: 'DSPy Predict',
+  description: 'Run a prediction using a self-hosted DSPy program endpoint',
+  version: '1.0.0',
+
+  params: {
+    baseUrl: {
+      type: 'string',
+      required: true,
+      visibility: 'user-only',
+      description: 'Base URL of the DSPy server (e.g., https://your-dspy-server.com)',
+    },
+    apiKey: {
+      type: 'string',
+      required: false,
+      visibility: 'user-only',
+      description: 'API key for authentication (if required by your server)',
+    },
+    endpoint: {
+      type: 'string',
+      required: false,
+      visibility: 'user-only',
+      description: 'API endpoint path (defaults to /predict)',
+    },
+    input: {
+      type: 'string',
+      required: true,
+      visibility: 'user-or-llm',
+      description: 'The input text to send to the DSPy program',
+    },
+    inputField: {
+      type: 'string',
+      required: false,
+      visibility: 'user-only',
+      description: 'Name of the input field expected by the DSPy program (defaults to "text")',
+    },
+    context: {
+      type: 'string',
+      required: false,
+      visibility: 'user-or-llm',
+      description: 'Additional context to provide to the DSPy program',
+    },
+    additionalInputs: {
+      type: 'json',
+      required: false,
+      visibility: 'user-or-llm',
+      description: 'Additional key-value pairs to include in the request body',
+    },
+  },
+
+  request: {
+    method: 'POST',
+    url: (params) => {
+      const baseUrl = params.baseUrl.replace(/\/$/, '')
+      const endpoint = params.endpoint || '/predict'
+      return `${baseUrl}${endpoint}`
+    },
+    headers: (params) => {
+      const headers: Record<string, string> = {
+        'Content-Type': 'application/json',
+      }
+      if (params.apiKey) {
+        headers.Authorization = `Bearer ${params.apiKey}`
+      }
+      return headers
+    },
+    body: (params) => {
+      const inputField = params.inputField || 'text'
+      const body: Record<string, unknown> = {
+        [inputField]: params.input,
+      }
+
+      if (params.context) {
+        body.context = params.context
+      }
+
+      if (params.additionalInputs) {
+        Object.assign(body, params.additionalInputs)
+      }
+
+      return body
+    },
+  },
+
+  transformResponse: async (response: Response) => {
+    const data = await response.json()
+
+    const status = data.status ?? 'success'
+    const outputData = data.data ?? data
+
+    return {
+      success: true,
+      output: {
+        answer: outputData.answer ?? outputData.output ?? outputData.response ?? '',
+        reasoning: outputData.reasoning ?? outputData.rationale ?? null,
+        status,
+        rawOutput: outputData,
+      },
+    }
+  },
+
+  outputs: {
+    answer: {
+      type: 'string',
+      description: 'The main output/answer from the DSPy program',
+    },
+    reasoning: {
+      type: 'string',
+      description: 'The reasoning or rationale behind the answer (if available)',
+      optional: true,
+    },
+    status: {
+      type: 'string',
+      description: 'Response status from the DSPy server (success or error)',
+    },
+    rawOutput: {
+      type: 'json',
+      description: 'The complete raw output from the DSPy program (result.toDict())',
+    },
+  },
+}

apps/sim/tools/dspy/react.ts

@@ -0,0 +1,156 @@
+import type { DSPyReActParams, DSPyReActResponse } from '@/tools/dspy/types'
+import { parseTrajectory } from '@/tools/dspy/utils'
+import type { ToolConfig } from '@/tools/types'
+
+export const reactTool: ToolConfig<DSPyReActParams, DSPyReActResponse> = {
+  id: 'dspy_react',
+  name: 'DSPy ReAct',
+  description:
+    'Run a ReAct agent using a self-hosted DSPy ReAct program endpoint for multi-step reasoning and action',
+  version: '1.0.0',
+
+  params: {
+    baseUrl: {
+      type: 'string',
+      required: true,
+      visibility: 'user-only',
+      description: 'Base URL of the DSPy server (e.g., https://your-dspy-server.com)',
+    },
+    apiKey: {
+      type: 'string',
+      required: false,
+      visibility: 'user-only',
+      description: 'API key for authentication (if required by your server)',
+    },
+    endpoint: {
+      type: 'string',
+      required: false,
+      visibility: 'user-only',
+      description: 'API endpoint path (defaults to /predict)',
+    },
+    task: {
+      type: 'string',
+      required: true,
+      visibility: 'user-or-llm',
+      description: 'The task or question for the ReAct agent to work on',
+    },
+    context: {
+      type: 'string',
+      required: false,
+      visibility: 'user-or-llm',
+      description: 'Additional context to provide for the task',
+    },
+    maxIterations: {
+      type: 'number',
+      required: false,
+      visibility: 'user-only',
+      description: 'Maximum number of reasoning iterations (defaults to server setting)',
+    },
+  },
+
+  request: {
+    method: 'POST',
+    url: (params) => {
+      const baseUrl = params.baseUrl.replace(/\/$/, '')
+      const endpoint = params.endpoint || '/predict'
+      return `${baseUrl}${endpoint}`
+    },
+    headers: (params) => {
+      const headers: Record<string, string> = {
+        'Content-Type': 'application/json',
+      }
+      if (params.apiKey) {
+        headers.Authorization = `Bearer ${params.apiKey}`
+      }
+      return headers
+    },
+    body: (params) => {
+      const body: Record<string, unknown> = {
+        text: params.task,
+      }
+
+      if (params.context) {
+        body.context = params.context
+      }
+
+      if (params.maxIterations !== undefined) {
+        body.max_iters = params.maxIterations
+      }
+
+      return body
+    },
+  },
+
+  transformResponse: async (response: Response) => {
+    const data = await response.json()
+
+    const status = data.status ?? 'success'
+    const outputData = data.data ?? data
+
+    const rawTrajectory = outputData.trajectory ?? {}
+    const trajectory = Array.isArray(rawTrajectory)
+      ? rawTrajectory.map((step: Record<string, unknown>) => ({
+          thought: (step.thought as string) ?? (step.reasoning as string) ?? '',
+          toolName: (step.tool_name as string) ?? (step.selected_fn as string) ?? '',
+          toolArgs:
+            (step.tool_args as Record<string, unknown>) ??
+            (step.args as Record<string, unknown>) ??
+            {},
+          observation: step.observation !== undefined ? String(step.observation) : null,
+        }))
+      : parseTrajectory(rawTrajectory)
+
+    return {
+      success: true,
+      output: {
+        answer:
+          outputData.answer ??
+          outputData.process_result ??
+          outputData.output ??
+          outputData.response ??
+          '',
+        reasoning: outputData.reasoning ?? null,
+        trajectory,
+        status,
+        rawOutput: outputData,
+      },
+    }
+  },
+
+  outputs: {
+    answer: {
+      type: 'string',
+      description: 'The final answer or result from the ReAct agent',
+    },
+    reasoning: {
+      type: 'string',
+      description: 'The overall reasoning summary from the agent',
+      optional: true,
+    },
+    trajectory: {
+      type: 'array',
+      description: 'The step-by-step trajectory of thoughts, actions, and observations',
+      items: {
+        type: 'object',
+        properties: {
+          thought: { type: 'string', description: 'The reasoning thought at this step' },
+          toolName: { type: 'string', description: 'The name of the tool/action called' },
+          toolArgs: { type: 'json', description: 'Arguments passed to the tool' },
+          observation: {
+            type: 'string',
+            description: 'The observation/result from the tool execution',
+            optional: true,
+          },
+        },
+      },
+    },
+    status: {
+      type: 'string',
+      description: 'Response status from the DSPy server (success or error)',
+    },
+    rawOutput: {
+      type: 'json',
+      description: 'The complete raw output from the DSPy program (result.toDict())',
+    },
+  },
+}

apps/sim/tools/dspy/types.ts

@@ -0,0 +1,84 @@
+import type { ToolResponse } from '@/tools/types'
+
+/**
+ * Parameters for running a DSPy prediction
+ */
+export interface DSPyPredictParams {
+  baseUrl: string
+  apiKey?: string
+  endpoint?: string
+  input: string
+  inputField?: string
+  context?: string
+  additionalInputs?: Record<string, unknown>
+}
+
+/**
+ * Response from a DSPy prediction
+ */
+export interface DSPyPredictResponse extends ToolResponse {
+  output: {
+    answer: string
+    reasoning: string | null
+    status: string
+    rawOutput: Record<string, unknown>
+  }
+}
+
+/**
+ * Parameters for running a DSPy Chain of Thought prediction
+ */
+export interface DSPyChainOfThoughtParams {
+  baseUrl: string
+  apiKey?: string
+  endpoint?: string
+  question: string
+  context?: string
+}
+
+/**
+ * Response from a DSPy Chain of Thought prediction
+ */
+export interface DSPyChainOfThoughtResponse extends ToolResponse {
+  output: {
+    answer: string
+    reasoning: string
+    status: string
+    rawOutput: Record<string, unknown>
+  }
+}
+
+/**
+ * Parameters for running a DSPy ReAct agent
+ */
+export interface DSPyReActParams {
+  baseUrl: string
+  apiKey?: string
+  endpoint?: string
+  task: string
+  context?: string
+  maxIterations?: number
+}
+
+/**
+ * ReAct trajectory step structure (matches DSPy output format)
+ */
+export interface DSPyTrajectoryStep {
+  thought: string
+  toolName: string
+  toolArgs: Record<string, unknown>
+  observation: string | null
+}
+
+/**
+ * Response from a DSPy ReAct agent
+ */
+export interface DSPyReActResponse extends ToolResponse {
+  output: {
+    answer: string
+    reasoning: string | null
+    trajectory: DSPyTrajectoryStep[]
+    status: string
+    rawOutput: Record<string, unknown>
+  }
+}

apps/sim/tools/dspy/utils.ts

@@ -0,0 +1,28 @@
+import type { DSPyTrajectoryStep } from '@/tools/dspy/types'
+
+/**
+ * Parse DSPy ReAct trajectory format into structured steps
+ * DSPy trajectory format: { thought_0, tool_name_0, tool_args_0, observation_0, thought_1, ... }
+ */
+export function parseTrajectory(trajectory: Record<string, unknown>): DSPyTrajectoryStep[] {
+  const steps: DSPyTrajectoryStep[] = []
+  let idx = 0
+
+  while (
+    trajectory[`thought_${idx}`] !== undefined ||
+    trajectory[`tool_name_${idx}`] !== undefined
+  ) {
+    steps.push({
+      thought: (trajectory[`thought_${idx}`] as string) ?? '',
+      toolName: (trajectory[`tool_name_${idx}`] as string) ?? '',
+      toolArgs: (trajectory[`tool_args_${idx}`] as Record<string, unknown>) ?? {},
+      observation:
+        trajectory[`observation_${idx}`] !== undefined
+          ? String(trajectory[`observation_${idx}`])
+          : null,
+    })
+    idx++
+  }
+
+  return steps
+}