Skip to main content

History, limitations and troubleshooting

Where to see function events

Open History → the call card → the Transcript tab, and turn on Show system events. Only administrators and developers have the checkbox; managers and members see the dialogue only, without function events. More on the card — Call details. Next to the utterances the feed carries Pre-call function and Post-call function events. The event row shows the function name, the HTTP status code, the time in milliseconds, the error text and the status. Clicking the row expands the details as JSON:
  • variables — the names of the variables written;
  • batch — the number of the block row the function ran in;
  • stage — when it ran: pre_dial — before the number was dialed, pre_start — before the first reply, late — late delivery;
  • request — the request sent, with secrets masked;
  • status_code — the response code;
  • for post-call functions — analysis_status, the status of post-call analytics at launch.
Pre-call function events sit above the first utterance: they really did run earlier. Variable values are visible to every role: the Data tab → Variables passed to the agent. The Download log button in the call card (administrator, developer) exports the call as JSON — with every function event and the variables.

Statuses in History

The mark without analytics result on a post-call function means no finished post-call analytics existed at launch: it is turned off or skipped, it failed, it was interrupted, or it was not waited for. The exact status is analysis_status in the event details. Error texts:
  • http_<code> — a response with a code outside the successful ones;
  • network — the address could not be reached;
  • blocked — the address was refused by the platform’s outbound request policy;
  • invalid_json — the response is declared as JSON but does not parse;
  • timeout — it did not fit into its time;
  • for a code function — the exception text.

Testing before publishing

A function card can be run in the editor without calling anyone: Test and Test with mock for a custom function, Run Code for a code function. Pre-call functions also have Trial budget — “Before the first reply (inbound, web)” or “Before dialing (outbound)”. The test result has its own labels: Success, Error, Timeout, Skipped (budget exhausted), plus the time in milliseconds. Test the block runs the whole block: Whole block — N ms and a breakdown “Row 1:”, “Row 2:” with the status of each function. Late delivery is not modelled in tests: a function that misses the chosen budget gets Timeout or Skipped (budget exhausted), even though on an inbound call its result would arrive in the background. More — Pre-call functions.

The dial decision in History

The decision applies only to campaign dialing. Inbound calls, web calls and one-off outbound calls from the cabinet or the API do not act on it; the event says “the decision does not apply outside a campaign dial”.
  • cancel — the number is not dialed; History keeps a session with the status Cancelled by a pre-dial function.
  • retry — there is no session in History; the campaign contact shows Deferred by a pre-call function.
  • The decision value was not recognized — the dial goes on — call_decision carried a value outside proceed / cancel / retry.
  • The retry time was not readable — the campaign retry policy applies — call_retry_after is neither a number of seconds nor an ISO 8601 date.
If the last 20 decisions in a row are cancel, the campaign pauses itself: this protects your contact base from a failure of your system that cancels everything. Resume the campaign manually once you have checked the system. More — Dial decisions in a campaign.

Limitations

  • Functions are never called mid-conversation. Anything to be asked during the dialogue belongs to flow nodes on the canvas.
  • An utterance already spoken is not replayed. The agent uses late data in its next utterance rather than asking again after the fact. In realtime mode late data reaches the variables and the tools, but not the system prompt.
  • Time. The timeout of one function is at most 30 seconds. The pre-call block budget is 10 seconds before the first reply on inbound and web calls and 60 seconds before dialing on outbound calls.
  • The block runs once. The post-call block runs once per call; a repeated finalization does not run it again. A failed function does not break the call, but it will not run a second time on its own.
  • HTTP request retries are the Retries field of the function form, 0 by default. Only a timeout, a network error and a 5xx response are retried; a 4xx response and blocked are not. A code function has no retries. A retry can deliver the same request to you twice — make the handling idempotent.
  • The number of functions in a block is not limited, but no more than 16 run at the same time within one row; how many fit into the budget is decided by the longest chain.
  • Post-call functions wait for post-call analytics for up to 60 seconds, then run without it; their events appear in History after they run. They share the queue with conversation analysis — keep the timeout as small as it can be.
  • Where results go. Variables written by pre-call functions are dynamic variables: they are available to post-call analytics and are sent in dynamic_variables of the call_ended / call_analyzed webhooks. Post-call function results stay in their events only.
  • Post-analytics, knowledge bases, and webhooks are not edited from the pipeline — those blocks show settings and lead to their forms.

Troubleshooting

The boundary is simple: before the request is sent and after the response is received is our side; what happens inside your system and what it returns is yours.