Tool Pipeline (3-Step)

Tool Pipeline: Chain Multiple Transformations in a Single Workflow

Developer workflows frequently involve multi-step data transformations where the output of one operation feeds directly into the next. Decoding a Base64-encoded API response, formatting the resulting JSON, and then converting it to TypeScript interfaces — that sequence requires opening three separate tool pages and manually copying results between them. The Tool Pipeline eliminates this friction by letting you define an ordered sequence of transformation steps, paste your input once, and receive the final result after all steps execute in order. Every transformation runs entirely client-side, so your data never leaves the browser regardless of how many steps you chain.

This meta-tool connects the full catalog of StrateCode utilities into composable building blocks. Each step in the pipeline takes the previous step's output as its input, applies its transformation, and passes the result forward. If any step fails — due to invalid input format, parsing errors, or type mismatches — the pipeline halts at that point and reports exactly which step encountered the problem. This makes debugging multi-step transformations straightforward: you can see intermediate results at every stage and identify precisely where your data deviates from expectations.

How Pipeline Execution Works

The Tool Pipeline operates on a simple sequential execution model. You configure an ordered list of transformation steps, each referencing one of the available StrateCode tools. When you provide input data and trigger execution, the pipeline engine processes steps from first to last:

1. Step 1 receives your raw input text and applies its transformation (e.g., Base64 Decode).
2. Step 2 receives the output of Step 1 as its input and applies its own transformation (e.g., JSON Formatter).
3. Step N receives the output of Step N-1, and its output becomes the final pipeline result.

Each step validates its input before processing. If the JSON Formatter step receives text that is not valid JSON, it reports a clear error indicating which step failed and why. The pipeline preserves intermediate outputs so you can inspect the state of your data at any point in the chain. This transparency is critical for debugging — when a five-step pipeline produces unexpected output, you can trace back through each intermediate result to find where the transformation diverged from your intent.

Steps execute synchronously in sequence. There is no parallel execution or branching — the pipeline is a linear chain where data flows strictly from one step to the next. This predictable execution model means the order of steps matters: Base64 Decode → JSON Formatter produces formatted JSON, while JSON Formatter → Base64 Decode would fail because formatted JSON is not valid Base64 input.

Common Pipeline Patterns for Developer Workflows

Certain transformation sequences appear repeatedly in day-to-day development work. These common patterns demonstrate how the pipeline reduces multi-step manual processes to a single operation:

• API Response Debugging: Base64 Decode → JSON Formatter → JSON Validator. Useful when API responses arrive as Base64-encoded payloads in webhooks, message queues, or logging systems. The pipeline decodes, pretty-prints, and validates the JSON in one pass.
• Configuration Migration: JSON Formatter → JSON to YAML → YAML Validator. When migrating application configuration from JSON to YAML for Kubernetes or Docker Compose, this pipeline ensures the JSON is well-formed first, converts it to YAML, and validates the output against YAML syntax rules.
• Type Generation: Base64 Decode → JSON Formatter → JSON to TypeScript. Extracts TypeScript interfaces from Base64-encoded JSON payloads — common when working with JWT token payloads or encoded API schemas that need type definitions.
• Data Export: JSON Formatter → JSON to CSV. Transforms raw JSON API responses into CSV format suitable for spreadsheet analysis or data import workflows.
• Security Analysis: Base64 Decode → JWT Decoder. Quickly decodes and inspects JWT tokens that arrive as raw Base64 strings in logs or HTTP headers.

These patterns are starting points — you can combine any available tools into custom pipelines tailored to your specific workflow. A pipeline configuration can be saved and reused, making repetitive multi-step transformations as fast as a single button click.

Pipeline Configuration and Step Management

Each pipeline is defined as an ordered array of step objects. A step specifies which tool to use for that transformation stage. The pipeline UI provides controls to add steps, remove steps, and reorder them via drag-and-drop or move buttons. You can also duplicate an existing pipeline configuration to create variations without rebuilding from scratch.

When configuring a pipeline, consider the data format compatibility between consecutive steps. Each tool expects its input in a specific format — the JSON Formatter expects valid JSON, the YAML Validator expects valid YAML, and the Base64 Decode step expects valid Base64-encoded text. If Step N produces output that Step N+1 cannot parse, the pipeline will halt with a descriptive error at Step N+1.

The interface displays each step as a card in the pipeline sequence, showing the tool name and a brief description of what it does. Between each step, a connector arrow indicates the data flow direction. The final output area shows the result of the last successful step, and an execution summary indicates total processing time and the number of steps completed.

For complex workflows, consider breaking very long pipelines (more than five steps) into smaller logical groups. While the engine supports arbitrary pipeline lengths, shorter pipelines are easier to debug when intermediate transformations produce unexpected results. You can always chain the output of one pipeline run as the input to another.

Error Handling and Debugging Pipelines

Pipeline errors are reported with full context: which step number failed, what tool was configured at that step, and the specific error message from that tool's processing logic. The pipeline engine does not silently skip failed steps or attempt to recover — it halts immediately at the first failure and preserves the intermediate state up to that point.

Common debugging strategies for pipeline failures include:

• Inspect intermediate output: Check the output of the step immediately before the failing one. This reveals whether the previous step produced the format the failing step expects.
• Test steps individually: Open the specific tool that failed and paste the intermediate output directly. This isolates whether the problem is the data or the pipeline configuration.
• Verify step order: Format conversion steps are not commutative. Ensure encoding/decoding steps come before format-specific operations.
• Check for empty output: Some tools produce empty output for certain inputs (e.g., minifying already-minimal JSON). An empty string passed to the next step may trigger an "empty input" validation error.

The pipeline execution log shows timestamps for each step, making it easy to identify performance bottlenecks in long chains. Steps that process large payloads (like JSON formatting of multi-megabyte files) will show longer execution times, helping you understand the total pipeline latency.

Code Examples

Pipeline Configuration: Base64 Decode → JSON Formatter → JSON to YAML

{
  "name": "API Response to YAML Config",
  "steps": [
    {
      "toolId": "base64-decode",
      "label": "Decode Base64 payload"
    },
    {
      "toolId": "json-formatter",
      "label": "Format and validate JSON"
    },
    {
      "toolId": "json-to-yaml",
      "label": "Convert to YAML configuration"
    }
  ],
  "input": "eyJhcGlWZXJzaW9uIjoiYXBwcy92MSIsImtpbmQiOiJEZXBsb3ltZW50IiwibWV0YWRhdGEiOnsibmFtZSI6IndlYi1hcHAifSwic3BlYyI6eyJyZXBsaWNhcyI6M319"
}

Output:

apiVersion: apps/v1
kind: Deployment
metadata:
  name: web-app
spec:
  replicas: 3

Pipeline Configuration: JSON to TypeScript Type Generation

{
  "name": "JSON Schema to TypeScript",
  "steps": [
    {
      "toolId": "json-formatter",
      "label": "Validate and format input JSON"
    },
    {
      "toolId": "json-to-typescript",
      "label": "Generate TypeScript interfaces"
    }
  ],
  "input": "{"id":1,"name":"Alice","email":"alice@example.com","roles":["admin","editor"],"settings":{"theme":"dark","notifications":true}}"
}

Output:

interface Root {
  id: number;
  name: string;
  email: string;
  roles: string[];
  settings: Settings;
}

interface Settings {
  theme: string;
  notifications: boolean;
}