# Semantic Synthesis Engine (`automationnation/semantic-synthesis-engine`) Actor

RAG Pipeline, Agentic Infrastructure, Idempotent Ingestion — deterministic-first LLM synthesis over Delta-Sync Sentinel manifests, gated by a separated Critic/canary assertion step.

- **URL**: https://apify.com/automationnation/semantic-synthesis-engine.md
- **Developed by:** [Nathan Carter](https://apify.com/automationnation) (community)
- **Categories:** Developer tools
- **Stats:** 1 total users, 0 monthly users, 0.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $0.15 / actor start

This Actor is paid per event and usage. You are charged both the fixed price for specific events and for Apify platform usage.
Since this Actor supports Apify Store discounts, the price gets lower the higher subscription plan you have.

Learn more: https://docs.apify.com/platform/actors/running/actors-in-store#pay-per-event

## What's an Apify Actor?

Actors are a software tools running on the Apify platform, for all kinds of web data extraction and automation use cases.
In Batch mode, an Actor accepts a well-defined JSON input, performs an action which can take anything from a few seconds to a few hours,
and optionally produces a well-defined JSON output, datasets with results, or files in key-value store.
In Standby mode, an Actor provides a web server which can be used as a website, API, or an MCP server.
Actors are written with capital "A".

## How to integrate an Actor?

If asked about integration, you help developers integrate Actors into their projects.
You adapt to their stack and deliver integrations that are safe, well-documented, and production-ready.
The best way to integrate Actors is as follows.

In JavaScript/TypeScript projects, use official [JavaScript/TypeScript client](https://docs.apify.com/api/client/js.md):

```bash
npm install apify-client
```

In Python projects, use official [Python client library](https://docs.apify.com/api/client/python.md):

```bash
pip install apify-client
```

In shell scripts, use [Apify CLI](https://docs.apify.com/cli/docs.md):

````bash
# MacOS / Linux
curl -fsSL https://apify.com/install-cli.sh | bash
# Windows
irm https://apify.com/install-cli.ps1 | iex
```bash

In AI frameworks, you might use the [Apify MCP server](https://docs.apify.com/platform/integrations/mcp.md).

If your project is in a different language, use the [REST API](https://docs.apify.com/api/v2.md).

For usage examples, see the [API](#api) section below.

For more details, see Apify documentation as [Markdown index](https://docs.apify.com/llms.txt) and [Markdown full-text](https://docs.apify.com/llms-full.txt).


# README

## Semantic Synthesis Engine

**Actor 2 of 3.** Takes a committed manifest from [Delta-Sync Sentinel](../delta-sync-sentinel) and produces a synthesis result gated by a deterministic Critic — a "canary" step that decides `ok` vs `critic_rejected` before an agent ever sees the payload.

> **Status: implemented (Task 2).** `synthesize()` calls Claude (temperature 0) to produce `{summary, keyFacts, citedChunkIds}`. `runCritic()` runs four real deterministic checks. `main.ts` checks the KV idempotency cache before calling either. See "Task 2 implementation notes" below for where this deviates from the original brief, and why.

### Task 2 implementation notes

Three places where Task 2's instructions conflicted with what Task 1 already shipped. Resolved, not silently picked:

1. **Status vocabulary.** The brief said status is `'completed'` or `'needs_human_review'`. The already-published contract (types.ts, both output schemas) says `'ok'` / `'critic_rejected'` / `'error'`. Kept the original enum values — `completed` and `needs_human_review` are the human-readable *meaning* of `ok` and `critic_rejected`, not a field rename, so nothing that already reads this contract breaks.
2. **`determinism_self_test` redefined.** Originally specified (Task 1) as: re-run `synthesize()` and hash-compare, fail on any diff. Task 2 makes `synthesize()` a real LLM call — temperature 0 reduces but does not guarantee bit-exact output, so a strict re-run-and-diff would reject a large share of good runs and doubles LLM cost per verification. It now checks internal self-consistency of the single payload instead: no duplicate `citedChunkIds`, and zero citations despite available source chunks is treated as a failure (a vacuous-result guard), not a valid "nothing to say."
3. **Error shape.** Task 1's own infra rule banned prose errors. Task 2 rule 4 asks for `{ error: "CODE", message: "..." }`. `errorCode` stays the field to branch on (closed enum, matches the published schema); `message` was added as a supplementary string alongside it, not a replacement for the code.

**Verification gap, stated plainly:** this environment has no `ANTHROPIC_API_KEY` — only Claude Code's own OAuth session, not a usable API key for a direct SDK call. `synthesize()` is implemented against the real Anthropic SDK and typechecks, but the live LLM call itself has not been executed end-to-end. What *has* been verified for real:
- `npm run harness` — 8/8 passing, covering all four critic checks against fixture data (good payload, hallucinated citation, low coverage, duplicate citations, oversized output, vacuous zero-citation result).
- The cache-key fix (`analysis-<synthesisId>`, not `analysis-<manifestId>` as literally written in the brief) — confirmed the same manifestId produces different ids per mode, and the same id across repeats of the same mode, so a `narrative_summary` request can no longer incorrectly hit a `structured_extract` cache entry.
- `npx tsc --noEmit` — clean across the full implementation.

### Infrastructure-grade guarantees

**Idempotency.** `synthesisId = sha256(manifestId + synthesisMode + engineVersion)`. Same three inputs, same id — call this actor twice on the same manifest and you get the same identity back, so an agent can treat repeat calls as free.

**Versioning.** `engineVersion` is on every result, not just in a changelog. A cached `synthesisId` is only trustworthy alongside the `engineVersion` it was produced under — if the engine bumps, the id space is allowed to change, and callers are expected to check this rather than assume forever-stability.

**Canary verification.** Synthesis and verification are two separate modules (`synthesis.ts`, `critic.ts`) called from two separate steps in `main.ts`, on purpose — the Critic never trusts synthesis's own opinion of itself. Its checks are deterministic by design (set/schema operations, not model calls), so a `narrative_summary` synthesis can be non-deterministic while its verification stays reproducible. `status: "critic_rejected"` is a first-class outcome, not an error — the pipeline is expected to reject some fraction of runs, and that's the point of having it.

**Structured errors only.** Every failure path returns `{ status: "error", errorCode: <enum>, message?: <string> }`. `errorCode` — drawn from a closed enum (`MANIFEST_NOT_FOUND`, `SENTINEL_UNREACHABLE`, `COST_CEILING_EXCEEDED`, `VALIDATION_ERROR`, `SYNTHESIS_TIMEOUT`) — is the field to branch on, matching the Sentinel's own typed-error convention (`ValidationError`, `CostCeilingError`, etc. in `errors.ts`) one layer up the stack. `message` is a supplementary human-readable detail string; treat it as a log line, not a contract.

### Integration: how an agent triggers this from a Sentinel manifest

The Sentinel emits committed manifests with a `manifestId` (see its README, "Lifecycle example"). This actor's whole input surface exists to consume exactly that value:

```json
{
  "sentinelDatasetId": "<the Sentinel run's defaultDatasetId>",
  "manifestId": "9697071a4e2c...",
  "synthesisMode": "structured_extract",
  "maxCostUsd": "1.00"
}
````

Recommended agent loop:

1. Poll the Sentinel's health endpoint (or watch its dataset) for `last_cursor` to advance.
2. Read the new manifest's `manifestId` and the Sentinel run's `defaultDatasetId`.
3. Call this actor with both, plus a cost ceiling.
4. Branch only on `status`: `ok` → use `result`; `critic_rejected` → inspect `criticVerdict.checks` to see which assertion failed, do not use a partial `result` (there isn't one); `error` → branch on `errorCode`, never on message text.

### Agent-native schemas

- `.actor/input_schema.json` — every field's `description` is written to explain *intent*, not just type, so an agent building the call payload from the schema alone (function-calling style) has enough context to fill it in correctly.
- `output_schema.json` (project root) — the full function-calling **return** contract. Kept separate from `.actor/output_schema.json`, which is Apify's own link-template convention and isn't meant to carry field-level documentation.
- `.actor/dataset_schema.json` — same field descriptions as the root schema, in the shape Apify's Console actually renders as a table.

### Module boundaries

- `types.ts` — shared contract. No logic.
- `synthesis.ts` — candidate generation only. Must never decide acceptability.
- `critic.ts` — deterministic acceptance checks only. Must never generate content.
- `main.ts` — orchestration: fetch Sentinel chunks → synthesize → critic → structured outcome. Mirrors the Sentinel's `Actor.init()`/`log`/KV-first conventions.

### Local development

```bash
npm install
npm run typecheck
npm run harness      # critic.ts invariants against fixtures — no API key needed
ANTHROPIC_API_KEY=sk-... npm run start:dev   # real end-to-end run, requires a real key
```

# Actor input Schema

## `sentinelActorId` (type: `string`):

The Apify actor id or 'username/name' slug of the Delta-Sync Sentinel deployment to read committed manifests from. An agent should treat this as the upstream source-of-truth pointer, not a config detail to guess — always read it from the Sentinel's own actor metadata rather than hardcoding it.

## `sentinelDatasetId` (type: `string`):

The defaultDatasetId of the specific Sentinel run whose committed chunks should be read. Required because manifestId alone is only unique within one dataset — an agent must carry this value forward from the Sentinel run it is reacting to, not assume a single global dataset.

## `manifestId` (type: `string`):

The exact manifest\_id emitted by the Sentinel's commit step (see Sentinel README: 'Lifecycle example'). This is the trigger key: synthesis is always scoped to exactly one committed manifest, never to a raw cursor range or an unbounded dataset scan, so that a synthesis run is reproducible and cheap to verify.

## `synthesisMode` (type: `string`):

Which synthesis strategy to run. 'structured\_extract' is rule-based and fully deterministic (same chunks -> byte-identical output; prefer this by default). 'narrative\_summary' invokes model reasoning and is non-deterministic across model versions — use only when a human-readable narrative is explicitly required, and treat its output as advisory rather than as a fact source.

## `maxOutputTokens` (type: `integer`):

Upper bound on synthesis output size. Exists so an agent can budget downstream context-window usage before calling this actor, not just after receiving a response.

## `canaryMinCoverageRatio` (type: `integer`):

The Critic's deterministic acceptance threshold, expressed as a percentage (0-100): the minimum percentage of the manifest's chunk\_ids that the synthesis output must traceably reference for the run to pass. Below this, status is 'critic\_rejected' rather than 'ok' — this is a hallucination/omission guard, not a quality-of-writing check.

## `maxCostUsd` (type: `string`):

Hard spending ceiling, same contract as the Sentinel's identically-named field: checked before model-assisted synthesis is invoked, and the run self-terminates rather than exceed it. String type because the Apify input form has no float field.

## `anthropicApiKey` (type: `string`):

Your own Anthropic API key. This actor makes no LLM calls under any shared/platform key — every synthesize() call is billed directly to the key you provide here. Required; the run fails with a structured MISSING\_API\_KEY error if absent, before any Sentinel data is even fetched.

## Actor input object example

```json
{
  "sentinelActorId": "automationnation/delta-sync-sentinel",
  "synthesisMode": "structured_extract",
  "maxOutputTokens": 2000,
  "canaryMinCoverageRatio": 80,
  "maxCostUsd": "1.00"
}
```

# Actor output Schema

## `dataset` (type: `string`):

No description

# API

You can run this Actor programmatically using our API. Below are code examples in JavaScript, Python, and CLI, as well as the OpenAPI specification and MCP server setup.

## JavaScript example

```javascript
import { ApifyClient } from 'apify-client';

// Initialize the ApifyClient with your Apify API token
// Replace the '<YOUR_API_TOKEN>' with your token
const client = new ApifyClient({
    token: '<YOUR_API_TOKEN>',
});

// Prepare Actor input
const input = {
    "sentinelActorId": "automationnation/delta-sync-sentinel",
    "maxCostUsd": "1.00"
};

// Run the Actor and wait for it to finish
const run = await client.actor("automationnation/semantic-synthesis-engine").call(input);

// Fetch and print Actor results from the run's dataset (if any)
console.log('Results from dataset');
console.log(`💾 Check your data here: https://console.apify.com/storage/datasets/${run.defaultDatasetId}`);
const { items } = await client.dataset(run.defaultDatasetId).listItems();
items.forEach((item) => {
    console.dir(item);
});

// 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/js/docs

```

## Python example

```python
from apify_client import ApifyClient

# Initialize the ApifyClient with your Apify API token
# Replace '<YOUR_API_TOKEN>' with your token.
client = ApifyClient("<YOUR_API_TOKEN>")

# Prepare the Actor input
run_input = {
    "sentinelActorId": "automationnation/delta-sync-sentinel",
    "maxCostUsd": "1.00",
}

# Run the Actor and wait for it to finish
run = client.actor("automationnation/semantic-synthesis-engine").call(run_input=run_input)

# Fetch and print Actor results from the run's dataset (if there are any)
print("💾 Check your data here: https://console.apify.com/storage/datasets/" + run["defaultDatasetId"])
for item in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(item)

# 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/python/docs/quick-start

```

## CLI example

```bash
echo '{
  "sentinelActorId": "automationnation/delta-sync-sentinel",
  "maxCostUsd": "1.00"
}' |
apify call automationnation/semantic-synthesis-engine --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "command": "npx",
            "args": [
                "mcp-remote",
                "https://mcp.apify.com/?tools=automationnation/semantic-synthesis-engine",
                "--header",
                "Authorization: Bearer <YOUR_API_TOKEN>"
            ]
        }
    }
}

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Semantic Synthesis Engine",
        "description": "RAG Pipeline, Agentic Infrastructure, Idempotent Ingestion — deterministic-first LLM synthesis over Delta-Sync Sentinel manifests, gated by a separated Critic/canary assertion step.",
        "version": "0.1",
        "x-build-id": "4do9Q9piSYmUNJ62F"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/automationnation~semantic-synthesis-engine/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-automationnation-semantic-synthesis-engine",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for its completion, and returns Actor's dataset items in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        },
        "/acts/automationnation~semantic-synthesis-engine/runs": {
            "post": {
                "operationId": "runs-sync-automationnation-semantic-synthesis-engine",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor and returns information about the initiated run in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK",
                        "content": {
                            "application/json": {
                                "schema": {
                                    "$ref": "#/components/schemas/runsResponseSchema"
                                }
                            }
                        }
                    }
                }
            }
        },
        "/acts/automationnation~semantic-synthesis-engine/run-sync": {
            "post": {
                "operationId": "run-sync-automationnation-semantic-synthesis-engine",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for completion, and returns the OUTPUT from Key-value store in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        }
    },
    "components": {
        "schemas": {
            "inputSchema": {
                "type": "object",
                "required": [
                    "sentinelDatasetId",
                    "manifestId",
                    "maxCostUsd",
                    "anthropicApiKey"
                ],
                "properties": {
                    "sentinelActorId": {
                        "title": "Sentinel Actor ID",
                        "type": "string",
                        "description": "The Apify actor id or 'username/name' slug of the Delta-Sync Sentinel deployment to read committed manifests from. An agent should treat this as the upstream source-of-truth pointer, not a config detail to guess — always read it from the Sentinel's own actor metadata rather than hardcoding it."
                    },
                    "sentinelDatasetId": {
                        "title": "Sentinel Dataset ID",
                        "type": "string",
                        "description": "The defaultDatasetId of the specific Sentinel run whose committed chunks should be read. Required because manifestId alone is only unique within one dataset — an agent must carry this value forward from the Sentinel run it is reacting to, not assume a single global dataset."
                    },
                    "manifestId": {
                        "title": "Manifest ID",
                        "type": "string",
                        "description": "The exact manifest_id emitted by the Sentinel's commit step (see Sentinel README: 'Lifecycle example'). This is the trigger key: synthesis is always scoped to exactly one committed manifest, never to a raw cursor range or an unbounded dataset scan, so that a synthesis run is reproducible and cheap to verify."
                    },
                    "synthesisMode": {
                        "title": "Synthesis Mode",
                        "enum": [
                            "structured_extract",
                            "narrative_summary"
                        ],
                        "type": "string",
                        "description": "Which synthesis strategy to run. 'structured_extract' is rule-based and fully deterministic (same chunks -> byte-identical output; prefer this by default). 'narrative_summary' invokes model reasoning and is non-deterministic across model versions — use only when a human-readable narrative is explicitly required, and treat its output as advisory rather than as a fact source.",
                        "default": "structured_extract"
                    },
                    "maxOutputTokens": {
                        "title": "Max Output Tokens",
                        "minimum": 100,
                        "type": "integer",
                        "description": "Upper bound on synthesis output size. Exists so an agent can budget downstream context-window usage before calling this actor, not just after receiving a response.",
                        "default": 2000
                    },
                    "canaryMinCoverageRatio": {
                        "title": "Canary Min Coverage Ratio",
                        "minimum": 0,
                        "maximum": 100,
                        "type": "integer",
                        "description": "The Critic's deterministic acceptance threshold, expressed as a percentage (0-100): the minimum percentage of the manifest's chunk_ids that the synthesis output must traceably reference for the run to pass. Below this, status is 'critic_rejected' rather than 'ok' — this is a hallucination/omission guard, not a quality-of-writing check.",
                        "default": 80
                    },
                    "maxCostUsd": {
                        "title": "Max Cost (USD)",
                        "type": "string",
                        "description": "Hard spending ceiling, same contract as the Sentinel's identically-named field: checked before model-assisted synthesis is invoked, and the run self-terminates rather than exceed it. String type because the Apify input form has no float field."
                    },
                    "anthropicApiKey": {
                        "title": "Anthropic API Key (BYOK)",
                        "type": "string",
                        "description": "Your own Anthropic API key. This actor makes no LLM calls under any shared/platform key — every synthesize() call is billed directly to the key you provide here. Required; the run fails with a structured MISSING_API_KEY error if absent, before any Sentinel data is even fetched."
                    }
                }
            },
            "runsResponseSchema": {
                "type": "object",
                "properties": {
                    "data": {
                        "type": "object",
                        "properties": {
                            "id": {
                                "type": "string"
                            },
                            "actId": {
                                "type": "string"
                            },
                            "userId": {
                                "type": "string"
                            },
                            "startedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "finishedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "status": {
                                "type": "string",
                                "example": "READY"
                            },
                            "meta": {
                                "type": "object",
                                "properties": {
                                    "origin": {
                                        "type": "string",
                                        "example": "API"
                                    },
                                    "userAgent": {
                                        "type": "string"
                                    }
                                }
                            },
                            "stats": {
                                "type": "object",
                                "properties": {
                                    "inputBodyLen": {
                                        "type": "integer",
                                        "example": 2000
                                    },
                                    "rebootCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "restartCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "resurrectCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "computeUnits": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "options": {
                                "type": "object",
                                "properties": {
                                    "build": {
                                        "type": "string",
                                        "example": "latest"
                                    },
                                    "timeoutSecs": {
                                        "type": "integer",
                                        "example": 300
                                    },
                                    "memoryMbytes": {
                                        "type": "integer",
                                        "example": 1024
                                    },
                                    "diskMbytes": {
                                        "type": "integer",
                                        "example": 2048
                                    }
                                }
                            },
                            "buildId": {
                                "type": "string"
                            },
                            "defaultKeyValueStoreId": {
                                "type": "string"
                            },
                            "defaultDatasetId": {
                                "type": "string"
                            },
                            "defaultRequestQueueId": {
                                "type": "string"
                            },
                            "buildNumber": {
                                "type": "string",
                                "example": "1.0.0"
                            },
                            "containerUrl": {
                                "type": "string"
                            },
                            "usage": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "integer",
                                        "example": 1
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "usageTotalUsd": {
                                "type": "number",
                                "example": 0.00005
                            },
                            "usageUsd": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "number",
                                        "example": 0.00005
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```