Caller Quick Start | CALL ANYTHING

What this page gets you to

From zero to one cross-process capability call

· Start the local supervisor
· Register a local Caller identity
· Mount the built-in example Hotline
· Use run-example to submit one local request
· Read the shared result_package shape

Official path: install the CLI and bootstrap

New users should start from the published @delexec/ops package. No superproject clone or monorepo context is required for the first local call.

bash

Any directory

npm install -g @delexec/ops
delexec-ops bootstrap --email [email protected] --text "Summarize this bootstrap request."
delexec-ops status
delexec-ops run-example --text "Summarize this follow-up request."

ExpectedThese four commands start the local runtime, prepare the example Hotline, and complete one local self-call. Seeing SUCCEEDED means the minimum Caller loop is working.

bash

Source contributor path

git clone --recursive https://github.com/hejiajiudeeyu/delegated-execution-dev.git
cd delegated-execution-dev
corepack pnpm install

bash

Client repo only

cd repos/client
npm install

NoteThe rest of this page is the source-level and HTTP debugging path. It assumes your working directory is repos/client.

Source breakdown: start the supervisor

If you are contributing code or debugging HTTP details, start the supervisor from source. First-time users can stay with delexec-ops bootstrap above.

bash

export DELEXEC_HOME="$HOME/.delexec-quickstart-en"
export OPS_PORT_SUPERVISOR=8179

DELEXEC_HOME="$DELEXEC_HOME" OPS_PORT_SUPERVISOR="$OPS_PORT_SUPERVISOR" npm run ops -- start

WarningThis runs in the foreground. Open a second terminal for the remaining steps. Once you see supervisor listening on 127.0.0.1:8179 the runtime is ready.

Initialize the first session

The first supervisor boot needs setup. After that, every admin request is scoped by the X-Ops-Session token.

bash

BASE="http://127.0.0.1:${OPS_PORT_SUPERVISOR:-8079}"
curl -s -X POST "$BASE/setup" -H 'content-type: application/json' -d '{}'
SESSION=$(curl -s -X POST "$BASE/auth/session/setup"   -H 'content-type: application/json'   -d '{"passphrase":"client-localtest-123"}' | jq -r '.token')
echo "$SESSION"
export OPS_SESSION="$SESSION"

TipIf you prefer the CLI path, the same runtime is also documented in repos/client/docs/current/guides/local-mode-onboarding.md.

Register a local Caller

Even in Local Mode the protocol keeps Caller identity explicit. This step writes a local account into your DELEXEC_HOME runtime state.

bash

CLI

npm run ops -- auth register --local --email [email protected]

bash

HTTP

curl -s -X POST "$BASE/auth/register-caller"   -H 'content-type: application/json'   -H "X-Ops-Session: $OPS_SESSION"   -d '{ "contact_email": "[email protected]" }'

Mount the built-in example Hotline

Local Mode lets the same machine act as both Caller and Responder. That keeps the first verification loop small before you integrate any real capability.

bash

curl -s -X POST "$BASE/responder/enable"   -H 'content-type: application/json'   -H "X-Ops-Session: $OPS_SESSION"   -d '{}'

curl -s -X POST "$BASE/responder/hotlines/example"   -H 'content-type: application/json'   -H "X-Ops-Session: $OPS_SESSION"   -d '{}'

List the local catalog

Catalog is the key Caller-side API. It defines which Hotlines are currently available to the agent runtime.

bash

curl -s "$BASE/catalog/hotlines"   -H "X-Ops-Session: $OPS_SESSION" | jq

ExpectedYou should see local.delegated-execution.workspace-summary.v1 in the list.

Submit one real request

At this point the runtime is live. The next request simulates the first external capability call an agent would make.

bash

HTTP

REQ=$(curl -s -X POST "$BASE/requests/example"   -H 'content-type: application/json'   -H "X-Ops-Session: $OPS_SESSION"   -d '{}')
echo "$REQ"
REQUEST_ID=$(echo "$REQ" | jq -r '.request_id')

bash

CLI

npm run ops -- run-example --text "summarize my workspace"

Fetch the result and inspect result_package

The protocol-level result envelope is the main thing to learn. Once your agent understands one result_package, it can reuse that outer shape across many Hotlines.

bash

curl -s "$BASE/requests/$REQUEST_ID/result"   -H "X-Ops-Session: $OPS_SESSION" | jq

json

Successful shape

{
  "request_id": "req_xxx",
  "status": "SUCCEEDED",
  "result_package": {
    "request_id": "req_xxx",
    "responder_id": "responder_xxx",
    "hotline_id": "local.delegated-execution.workspace-summary.v1",
    "status": "ok",
    "output": {
      "summary": "..."
    },
    "timing": {
      "elapsed_ms": 123
    }
  }
}

json

One common failure shape

{
  "request_id": "req_xxx",
  "status": "FAILED",
  "result_package": {
    "hotline_id": "local.delegated-execution.workspace-summary.v1",
    "status": "error",
    "error": {
      "code": "AUTH_TOKEN_INVALID",
      "message": "task token is missing or invalid"
    }
  }
}

Fields your agent should inspect first:

· status: request lifecycle status
· result_package.status: protocol-level success or error
· hotline_id: the exact capability version you called
· output: the capability-specific payload
· timing.elapsed_ms: runtime duration for observability and pricing

OPC #0 production rehearsal: make one paid call after recharge with one CLI command

This is not required for the local quick start. It is the public production rehearsal path: register a hosted Platform Caller, ask the operator to recharge that tenant, then let delexec-ops call-hotline handle billing consent, dispatch, result polling, and settlement evidence.

bash

PLATFORM="https://callanything.xyz/platform"
RELAY="https://callanything.xyz/relay"
CALLER_EMAIL="caller-opc0"@"example.com"
export DELEXEC_HOME="$HOME/.delexec-caller-public-en"
export OPS_PORT_SUPERVISOR=8279
export OPS_PORT_CALLER=8281
export TRANSPORT_TYPE="relay_http"
export TRANSPORT_BASE_URL="$RELAY"

# delexec-ops auth register calls $PLATFORM/v1/users/register and stores the API key locally.
CALLER_JSON=$(delexec-ops auth register   --platform "$PLATFORM"   --email "$CALLER_EMAIL")
echo "$CALLER_JSON" | jq

CALLER_API_KEY=$(echo "$CALLER_JSON" | jq -r '.api_key')
CALLER_TENANT_ID=$(echo "$CALLER_JSON" | jq -r '.user_id')
export CALLER_API_KEY CALLER_TENANT_ID

# Run this in a second terminal, or keep it alive with nohup. The Caller
# controller consumes the result and reports the billing-settlement event.
nohup env   DELEXEC_HOME="$DELEXEC_HOME"   OPS_PORT_SUPERVISOR="$OPS_PORT_SUPERVISOR"   OPS_PORT_CALLER="$OPS_PORT_CALLER"   TRANSPORT_TYPE="relay_http"   TRANSPORT_BASE_URL="$RELAY"   delexec-ops start   > "$DELEXEC_HOME/caller-public-relay.log" 2>&1 &

CALLER_BASE="http://127.0.0.1:$OPS_PORT_CALLER"

# Send CALLER_TENANT_ID to the operator. Continue after tenant creation and manual recharge.
curl -s "$PLATFORM/v1/tenants/me/balance"   -H "Authorization: Bearer $CALLER_API_KEY" | jq

bash

Select an approved Hotline and make the paid call with one CLI command

HOTLINE_ID="your.namespace.tool-name.v1"
RESPONDER_ID="responder_xxx"
REQUEST_ID="req_opc0_$(date +%s)"
MAX_CHARGE_CENTS=500

curl -s "$PLATFORM/v1/catalog/hotlines/$HOTLINE_ID" | jq

CALL_RESULT=$(delexec-ops call-hotline   --platform "$PLATFORM"   --caller-base-url "$CALLER_BASE"   --request-id "$REQUEST_ID"   --responder-id "$RESPONDER_ID"   --hotline-id "$HOTLINE_ID"   --text "Summarize this paid public relay request."   --max-charge-cents "$MAX_CHARGE_CENTS"   --poll-interval-ms 2000   --timeout-ms 60000)

echo "$CALL_RESULT" | tee /tmp/delexec-call-hotline.json | jq
echo "$CALL_RESULT" | jq '{request_id, task_token_present, task_token_claims, delivery_meta, dispatch, inbox, result, events, balance, ledger}'

bash

Drop down to the low-level shape only when debugging

# call-hotline already wraps these steps:
# /v1/tokens/task
# /v1/requests/$REQUEST_ID/delivery-meta
# /controller/requests
# /controller/requests/$REQUEST_ID/dispatch
# $RELAY/v1/messages/send
# /controller/inbox/pull
# /controller/requests/$REQUEST_ID/result
# /v1/tenants/me/balance
# /v1/tenants/me/ledger
# /v1/requests/$REQUEST_ID/events
echo "$CALL_RESULT" | jq '{task_token_claims, delivery_meta, dispatch, inbox, result, events, balance, ledger}'

AcceptanceA paid rehearsal is done when call-hotline exits 0 and returnstask_token_claims, delivery_meta,dispatch, result, events,balance, and ledger; and/v1/tenants/me/balance plus/v1/tenants/me/ledger reconcile againstmax_charge_cents and actual usage. The low-level APIs remain visible for diagnostics.

What to do next

You now have the minimum Caller-side loop. From here, either expand the set of Hotlines your agent can call or switch to the seller-side path and publish one yourself.

Expand the agent surface

Open the Console and Marketplace to see discovery, approvals, and runtime history from the team side.

Open Console Browse Marketplace

Publish a capability

The same supervisor can also host a Responder. Switch to the seller-side path to publish your own Hotline.

Responder Quick Start Docs overview

Caller FAQ

Caller Quick Start common questions

These are the three questions most likely to block the first caller-side integration, and they are also emitted as English FAQ schema for answer engines.

Who is Caller Quick Start for?

It is for agent teams that want to call an external capability through CALL ANYTHING without deploying the full platform first. The page uses Local Mode to prove the minimum caller loop with a real result package.

Why start with the example hotline?

Because it reduces debugging scope. You first prove that Caller, supervisor, and Responder can complete one stable loop before you spend time integrating a real business capability.

What should I inspect after the first call succeeds?

Inspect the result_package shape: request status, hotline_id, output, and timing. That is the shared contract your agent will parse across many Hotlines.

Connect onereal Hotline call

From zero to one cross-process capability call

Official path: install the CLI and bootstrap

Source breakdown: start the supervisor

Initialize the first session

Register a local Caller

Mount the built-in example Hotline

List the local catalog

Submit one real request

Fetch the result and inspect result_package

OPC #0 production rehearsal: make one paid call after recharge with one CLI command

What to do next

Caller Quick Start common questions

Who is Caller Quick Start for?

Why start with the example hotline?

What should I inspect after the first call succeeds?

Connect one
real Hotline call