Overview
Voiceflow integrates with Freshchat so AI agents can recognize customers, create and follow up on support conversations, answer from approved FAQs and connect customers with your support team.
Use API tools for Freshchat data, Knowledge for approved FAQ content and a Custom Handoff relay for two-way human support. Each has its own setup: authorizing a data tool does not import FAQs or start live handoff. Freshchat uses conversations and topics; these instructions use the Freshchat API, not the Freshdesk ticket API.
Examples of when to use Freshchat
- Recognize a customer — retrieve the customer your application has verified.
- Record a support request — open a conversation in the right topic and retain its ID.
- Follow up on a case — read messages, assign a team or resolve the request.
- Brief your team — add private context without sending it to the customer.
- Import help articles — use approved Freshchat FAQ content in Knowledge.
- Human agent hand-off — keep the customer in Voiceflow while a teammate replies from Freshchat.
Studio
Use an editable Voiceflow project and ask your Freshchat administrator for the account’s API URL and token. Your application developer supplies verified customer IDs and prepared write payloads; live handoff also needs a deployed relay.
Code
Use Voiceflow’s management API or CLI to create, test and attach tools. Your backend verifies customer/case access, prepares payloads and hosts the optional relay. Keep the account-wide Freshchat token on the server.
Connecting Freshchat
Authorize your account and test a customer lookup before enabling writes.
Have a Freshchat account administrator open Admin settings → APIs for chat → Generate Token. Obtain the account’s API URL from those settings; use its host throughout these examples instead of assuming a global or Freshdesk host. Freshsales Suite also exposes chat API details under its API settings. Requests use Authorization: Bearer TOKEN; store only TOKEN in the restricted Secret freshchat_token.
The token grants access to your account’s user and conversation data. Use a test account for initial writes. Freshchat permits one generated token at a time: deleting it to generate a replacement interrupts consumers of the previous token. Coordinate that replacement across your tools and relay. See Freshchat API tokens.
Prepare and test a customer lookup
Studio
Store the credential
Open the project in Agent studio. In the left sidebar, open More → Secrets and create freshchat_token with the Freshchat token. Creating the default also sets Main’s Published value, so use a test project. Set an override for your test Environment’s Draft when it uses a different credential.
Create the API tool
Open Agent → Global tools → + → API, then create Find Freshchat customer. Choose GET and set the URL to https://YOUR_ACCOUNT.freshchat.com/v2/users/{user_id}. Add the header Authorization with value Bearer {api_token} and Accept: application/json.
Bind trusted inputs and test
First create freshchat_user_id in More → Variables, leaving its default empty. Have your developer pass variables: {"freshchat_user_id":"VERIFIED_FRESHCHAT_ID"} with the authenticated backend’s initial launch action; creating a session alone does not populate it. Obtain a verified test user ID from them. Return to the tool, set the api_token input’s default to the Secret freshchat_token, and bind user_id to that identity variable rather than asking the model to choose a customer. Test that user ID, inspect the response and capture only the fields your support task needs.
Before publishing a tested tool, select the target Environment and open freshchat_token in More → Secrets. Set its Default value to the credential that Environment’s published agent should use; Draft value alone does not supply it. Follow Secret publication behavior, then publish the tested agent.
Code
Create a personal or service key with access to the project and set it as VF_TOKEN. Set PROJECT_ID to that project’s ID and ENVIRONMENT to the alias shown on its Environments page. Use a test Environment. Set FRESHCHAT_TOKEN to your Freshchat API token and FRESHCHAT_USER_ID to a Freshchat user ID verified by your application. Use a current Voiceflow CLI with API-tool and tool commands; it reads VF_TOKEN.
Save this definition as freshchat-tool.json, replacing YOUR_ACCOUNT.freshchat.com with the host from your account API URL. Braced names declare API-tool inputs, not project Secrets:
Create the Secret and identity variable
Creating this Secret sets its project default and Main’s Published value. Use a test project, then set the intended Draft override:
Save secret.id as SECRET_ID:
Send variables: {"freshchat_user_id":"VERIFIED_FRESHCHAT_ID"} from your backend with the initial launch action. The action applies these variables before the turn; session creation alone does not set them. Do not set a shared Freshchat user ID as the variable default.
Save the request and discover its input IDs
Save apiTool.id as API_TOOL_ID, then inspect the schema and input IDs:
Match each variables[].name to its id; keep those IDs for the attachment below.
Execute against a test customer
Create the Secret and identity variable
This writes the project default and Main’s Published value. Save secret.id as SECRET_ID, then set the test Draft override:
Send variables: {"freshchat_user_id":"VERIFIED_FRESHCHAT_ID"} from your backend with the initial launch action, which sets variables before processing the turn. Do not use a shared Freshchat user ID as the variable default.
Save the request and discover its input IDs
Save apiTool.id as API_TOOL_ID:
Match variables[].name to id for the attachment below.
Execute against a test customer
Check success, error, truncated, output.status and output.body. A successful lookup has HTTP 200 and the expected output.body.id, output.body.first_name and output.body.email. A Voiceflow HTTP 200 alone is not provider success.
Make the lookup available to the agent
Studio
Keep the lookup in Global tools, write a trigger for authenticated customer questions, and run a conversation with your application-provided Freshchat user ID. Confirm that the correct record was used. Publish the tested Environment after preparing its published Secret value.
Code
Save this as freshchat-attachment.json. Replace the tool ID and the input IDs using the returned variables[] values:
Inspect tool and resolve unresolvedReferences before testing. Creating the request does not attach it. Test agent routing in Draft, set the target Published Secret value with versionVariant: "published", then publish the tested agent. Management and standalone execution use Draft; a named Environment’s Draft override does not set its Published value.
Repair authorization or replace a token
- 401: check the account API host and token expiry. Ask the administrator for a valid token, update the Draft Secret, test a read, then update the target Environment’s Published value. Regeneration invalidates the previous account token; coordinate all consumers.
- 403: confirm the account and operation are permitted. Retrying does not add permission.
- 429: honor Freshchat’s rate-limit headers before retrying. After an uncertain write, inspect the case rather than creating it again blindly.
Finding customers
Use verified customer identity to retrieve the right Freshchat record.
The lookup configured above reads GET /v2/users/USER_ID. The returned user has a root id, first_name, last_name, email, phone and properties. Freshchat’s user ID differs from your application’s user ID and from a support agent’s ID.
Establish the customer mapping
Studio
- Ask your application developer to map the signed-in customer to a verified Freshchat user ID. Create
freshchat_user_idin More → Variables with an empty default; the developer supplies it in the initial action’svariablesbefore lookup. - In Find Freshchat customer, bind
user_idto{freshchat_user_id}andapi_tokento thefreshchat_tokenSecret. Use a known test customer and confirm the returned rootidand permitted profile fields. - Capture only the context needed for the support task. A customer entering another person’s email must not gain access to that person’s profile or conversations.
Code
Resolve the authenticated customer on your backend. If you need a search, GET /v2/users?email=URL_ENCODED_EMAIL or ?reference_id=URL_ENCODED_REFERENCE returns users[]. At least one supported search criterion is required. Follow the response’s links.next_page.href when present, restricting it to the same trusted account origin, and verify the match against your own identity record. Search results alone are not authentication.
For a missing customer, POST /v2/users with confirmed first_name, last_name, email or phone, then persist the root id from the 201 response. Do not create a new user for every turn. Send the verified provider ID in the next action’s variables before running the attached lookup. Use the earlier API/CLI workflow to test the lookup against that ID.
Update confirmed profile details
Change the customer's name or contact details, then read them back.
Freshchat’s PUT /v2/users/USER_ID updates only email, first_name, last_name and phone. An omitted or null field retains its current value. Do not promise updates to properties or reference_id through this operation even though those fields appear in the broader user schema.
Studio
Create a separate API tool using PUT https://YOUR_ACCOUNT.freshchat.com/v2/users/{user_id} with the token Secret and Content-Type: application/json. Set the raw JSON body to {payload}. Create freshchat_profile_payload in More → Variables with an empty default; your developer serializes only confirmed fields using literal-safe preparation and supplies the resulting string in the next action’s variables. Bind user_id to {freshchat_user_id} and payload to {freshchat_profile_payload}. Test the developer’s prepared input, then GET the user again to verify the change.
Code
Copy the lookup definition, change httpMethod to "put" and add body: {"type":"raw-input","contentType":"json","content":"{payload}"} plus Content-Type: application/json. Use the write-payload encoder and pass the string as standalone inputs.payload. Create an empty freshchat_profile_payload variable using the earlier API or CLI command, populate it with the next action, and attach this tool with its own input IDs and trusted defaults for token, user and payload (required: false). A 202 response means accepted: GET the user again and compare the changed fields before reporting completion.
Creating conversations
Open a support request in the right topic and keep its conversation ID.
Freshchat calls a conversation topic a channel in its API. Ask your administrator to select the intended topic using GET /v2/channels and provide its id; use GET /v2/groups for allowed support-group IDs. Keep those routing choices under application control.
Prepare write payloads
Your backend builds the request from the verified Freshchat user ID and the customer’s confirmed issue. This illustrative payload creates a text conversation; replace both IDs with approved values:
Use actor_type: "user" with that customer’s valid actor_id. A developer must JSON-serialize dynamic text, then escape braces inside JSON strings as \u007b and \u007d before Voiceflow interpolation. Object braces stay intact; Freshchat receives the original decoded strings. This prevents customer text such as {customer_name} from being treated as a variable or Secret reference. Studio authors should obtain the prepared string from their developer.
Code
Save the confirmed body above as freshchat-conversation-payload.json. This encoder can be reused for the profile and note payloads by changing the file name:
Create and test the conversation tool
Studio
Add the request
Open Agent → Global tools → + → API and create Create Freshchat conversation. Choose POST https://YOUR_ACCOUNT.freshchat.com/v2/conversations. Add Authorization: Bearer {api_token}, bind api_token to freshchat_token, and add Content-Type: application/json. Set the raw JSON body to {payload}.
Bind the confirmed request
Create freshchat_conversation_payload in More → Variables, leaving the default empty. Have your developer supply the prepared string in the next action’s variables before the tool runs. Bind payload to that variable. Test with their prepared sample; never interpolate free text into a quoted JSON string by hand.
Verify the created case
Run once in a test account. Check HTTP 202 and the returned conversation_id. GET /v2/conversations/CONVERSATION_ID, then open the conversation in Freshchat and confirm its topic and initial message. Have the backend retain the returned ID with the verified customer and your own support-request ID.
Code
Save freshchat-conversation-tool.json, replacing the account host:
Build standalone inputs from the encoded file:
Save apiTool.id as CONVERSATION_TOOL_ID, then execute:
Save apiTool.id as CONVERSATION_TOOL_ID, then execute:
Inspect success, error, output.status and output.body.conversation_id; HTTP 202 is acceptance. GET the case and verify it in Freshchat before reporting it ready. Store the provider ID with the authenticated customer and your own support-request ID; users is not returned by conversation GET, so that response alone cannot prove ownership.
Create an empty freshchat_conversation_payload variable with the earlier API/CLI pattern. Your backend supplies the encoded string with the next action. Discover this tool’s input IDs, then attach it using CONVERSATION_TOOL_ID with defaults api_token: {freshchat_token} and payload: {freshchat_conversation_payload}, both required: false. Keep the create trigger distinct from case lookup, require confirmation, test Draft, prepare the Published Secret and publish the tested agent.
Avoid opening duplicate support requests
Retain the provider ID and reconcile a lost response before retrying creation.
Store one Freshchat conversation ID per application support request. Do not assume POST is idempotent. If creation times out, use GET /v2/users/USER_ID/conversations to inspect that verified customer’s conversations before issuing another create. Compare the topic and initial issue; do not attach a customer to an arbitrary recent case.
Reading and routing conversations
Review a customer’s case and route it to the right support teammate.
Read GET /v2/conversations/CONVERSATION_ID for the stored case. The response includes conversation_id, status, channel_id, assigned_agent_id and assigned_group_id. It does not return the users association supplied at creation: your backend must authorize access against its saved customer-to-case mapping.
Supply a verified case ID
Studio
Create freshchat_conversation_id in More → Variables, leaving its default empty. Ask your developer to populate it in the next action’s variables after verifying the case belongs to this customer. Do not bind it to a number or ID chosen by the model. Add a GET API tool at https://YOUR_ACCOUNT.freshchat.com/v2/conversations/{conversation_id}, binding conversation_id to that variable and api_token to the token Secret. Test with the authorized case and check its status and topic.
Code
Retain conversation_id from creation with the verified Freshchat user and your own support-request ID. For existing cases, establish that association on your backend before returning any data. Create the empty freshchat_conversation_id variable with the earlier API/CLI workflow and populate it in the action before execution. Copy the lookup tool, change its URL to /v2/conversations/{conversation_id}, discover its new input IDs and attach it with defaults api_token: {freshchat_token} and conversation_id: {freshchat_conversation_id}, both required: false.
Read the conversation history
GET /v2/conversations/CONVERSATION_ID/messages?items_per_page=50&page=1 returns messages[]. Follow message pages before declaring a history complete; the maximum page size is 50. from_time=UTC_TIMESTAMP includes messages at that timestamp, so deduplicate by message id when reading incrementally. Keep the current interaction_id: reopening a resolved conversation starts a new interaction within the same conversation.
Studio
Create another GET tool using /v2/conversations/{conversation_id}/messages and those fixed pagination query parameters. Reuse the trusted token/case bindings, then capture only the customer-visible text needed for the task. Have your developer paginate/filter the history when the task needs more than the returned page; private notes must not become customer replies.
Code
Use the same API/CLI tool workflow for the message URL, binding this tool’s own token and case inputs. If your backend aggregates history, paginate it and retain message/interaction IDs. Remove private, system and unsupported content before returning a customer-visible history; do not expose the account-wide raw response directly to the client.
Assign or resolve the case
Use PUT /v2/conversations/CONVERSATION_ID with the change you intend:
- Assign a group:
{"status":"assigned","assigned_group_id":"APPROVED_GROUP_ID"}. Freshchat can return statusnewafter placing it in that group. - Assign a teammate:
{"status":"assigned","assigned_agent_id":"APPROVED_AGENT_ID"}. If the case has a group, the teammate must belong to it. Obtain allowed IDs from your administrator via/v2/groupsand/v2/agents. - Resolve:
{"status":"resolved"}. - Reopen:
{"status":"reopened"}. This unassigns the current teammate and starts a new interaction; do not treat later events as part of an ended Voiceflow handoff.
Studio
Configure the permitted change
Create a separate PUT API tool for each permitted change. Use {conversation_id} with the verified case variable, Authorization: Bearer {api_token} bound to the Secret and Content-Type: application/json. Put the fixed JSON above in the raw body after your administrator replaces the allowed routing ID.
Verify the changed case
Confirm with the customer before resolving an active request. Test the change in the test account, then GET the case again to verify its assignment or status.
Code
Copy the case tool definition, set httpMethod: "put", add Content-Type: application/json and a raw JSON body whose content is the selected fixed JSON above. Create, execute and attach with the API/CLI workflow, using this tool’s own input IDs. Fixed routing values do not require a payload variable; keep them server-controlled. Check the returned status/assignment and GET the case after the change.
Set priority for Freshsales Suite chat accounts
Use conversation properties only where Freshchat's contract supports them.
Freshchat’s API documents properties for chat accounts within Freshsales Suite. For those accounts, PUT the conversation with {"properties":{"priority":"High"}}; supported priority values are Low, Medium, High and Urgent. Custom conversation properties use a cf_ prefix. Read the configured fields through GET /v2/conversations/fields before setting them. Keep the same trusted case/token bindings and verify the returned properties. Do not assume these properties work on a standalone Freshchat account.
Adding internal notes
Give teammates private context without sending it to the customer.
Use POST /v2/conversations/CONVERSATION_ID/messages with message_type: "private" and a valid support agent’s actor_id. The default message type is normal, so omitting private can expose the text to the customer. Have your administrator supply an allowed agent ID; never substitute a customer ID.
Add and verify a private note
Studio
Prepare the private note
Have your developer authorize the case using the verified case mapping, build the note with the allowed agent ID and serialize it using literal-safe preparation. Create freshchat_note_payload in More → Variables with an empty default. The developer supplies its prepared string in the next action before the tool runs.
Configure and test the request
Create Add Freshchat note under Agent → Global tools → + → API. Use POST https://YOUR_ACCOUNT.freshchat.com/v2/conversations/{conversation_id}/messages, the token Secret, Content-Type: application/json and raw JSON {payload}. Bind conversation_id to {freshchat_conversation_id} and payload to {freshchat_note_payload}. Test the developer’s prepared note, check the root message id and message_type: "private", and confirm it appears privately in Freshchat.
Code
Reuse the conversation write-tool definition and encoder, changing the URL to /v2/conversations/{conversation_id}/messages. Add the authorized case ID to standalone inputs alongside api_token and encoded payload. Create the empty freshchat_note_payload variable with the earlier API/CLI pattern; populate it in the next action. Discover this tool’s own input IDs, then attach with defaults api_token: {freshchat_token}, conversation_id: {freshchat_conversation_id} and payload: {freshchat_note_payload}, each required: false.
Check the provider HTTP 200, root message id and message_type: "private". Read back the messages and confirm the note is private in Freshchat. Your live relay must exclude it from customer callbacks.
Import help articles
Answer from your team’s Freshchat FAQs through Voiceflow Knowledge.
Have your support content owner supply the approved FAQ text, including each question and its current answer. Freshchat’s widget/mobile FAQ display does not create a Voiceflow Knowledge connection. The workflow below imports that supplied text; it does not synchronize a Freshchat account or expose private articles publicly.
Import and verify the answers
Studio
Obtain approved content
Ask the Freshchat content owner to provide the current questions and answers as plain text. Remove customer-specific records and internal-only answers that this agent should not disclose. Keep the original source and revision with your content review process.
Import the text
In your Voiceflow project, open Knowledge base → Add data source → Plain text. Paste the approved FAQ content and click Import. Wait until processing finishes.
Test actual retrieval
Enable Knowledge base in the agent’s system tools. Ask a question answered by the imported FAQ, then inspect the agent’s retrieved source and answer. A document appearing in Knowledge does not prove the agent used it. Publish the tested Environment when ready.
Code
Save the owner-approved content as a UTF-8 file named freshchat-faq.txt. Use the Voiceflow management bearer token, project and target Environment from connection setup. This is a multipart API upload, not a Freshchat API call:
Save document.id as DOCUMENT_ID, then check processing in the same Environment:
Wait for document.status.type to reach SUCCESS; inspect ERROR before retrying. Enable the agent’s Knowledge tool and test a real question through the Chat agent API, checking the retrieved source and answer before publishing. The import response is not a retrieval test.
Keep FAQ answers current
Replace reviewed content and remove obsolete answers explicitly.
Studio
Keep an owner for FAQ updates. Edit the imported text in Knowledge when the approved source changes, wait for processing, then repeat the retrieval test. Delete obsolete documents from Knowledge; do not leave contradictory copies indexed.
Code
Re-upload the revised file with the same filename and overwrite=true in the text-creation URL to replace it; filenames are unique across the project’s Knowledge base, not just a folder. Poll processing again and test retrieval. To remove the document, use DELETE /v1/stable/document/DOCUMENT_ID?projectID=PROJECT_ID&environmentAlias=ENVIRONMENT with the same management token. There is no automatic Freshchat FAQ refresh in this text-import workflow. See Knowledge document management.
Human agent hand-off
Keep the customer in Voiceflow while your team replies from Freshchat.
A developer must build and host a Custom Handoff relay. The relay creates the Freshchat conversation, forwards customer messages, receives public human replies and sends signed events to Voiceflow. The learning server illustrates the Voiceflow contract; it does not include a Freshchat adapter.
Use this path for text chat. Freshchat file/rich-message APIs do not automatically add file handling to your relay. Disable file uploads until you implement and test them in both directions. A phone transfer uses the separate Voice call transfer workflow.
Prepare the relay and reply delivery
Studio
Obtain the deployed service
Ask your developer to implement the Custom Handoff contract and Freshchat text-message delivery. Give them the test account API URL, token, approved topic, support group and the application’s verified customer mapping. They must handle public human replies, resolution, duplicate deliveries and private-message exclusion. Connecting the settings form does not build this service.
Obtain the connection values
Have the developer supply the HTTPS Base URL, relay Authorization header value, a separate Webhook secret of at least 32 characters for Voiceflow callbacks, and an application customer identifier the relay can map to the Freshchat user. Share credentials through your team’s secure process. The Freshchat token stays on the relay, separate from these connection credentials.
Confirm readiness
The service must accept authenticated create/message/end requests and have a running, authenticated Freshchat reply worker before you connect it. Have the developer confirm the topic/customer mapping and allowed human-agent IDs. The complete two-way test happens after the Workflow and customer client are ready below.
Code
Implement the connection’s create, message and end routes. Persist the Voiceflow connection ID, authenticated application customer, Freshchat user/conversation/topic/current interaction IDs and processed message IDs. Map endUser.externalId against your own customer records; do not trust it without validating the Voiceflow project and application association.
Create and retain the Freshchat conversation
On POST /conversations, verify the allowed project and idempotency key. Resolve the customer to the Freshchat user and use the conversation payload to call Freshchat POST /v2/conversations. Save its returned conversation_id before returning your own { "conversationId":"YOUR_CONNECTION_ID" } to Voiceflow. Use the configured topic, not an arbitrary model-selected destination.
Create the initial customer-visible request as normal; post internal escalation context separately as an agent private note using the note contract. Never place private transcript content in the initial public message. Retain the interaction ID from the created/read messages for later delivery filtering.
Forward customer text
On POST /conversations/YOUR_CONNECTION_ID/messages, find the stored provider conversation and deduplicate Voiceflow’s message id. Call Freshchat POST /v2/conversations/FRESHCHAT_CONVERSATION_ID/messages with the mapped user ID:
Serialize the real text with a JSON library. Reject unsupported files explicitly; do not acknowledge a message that was dropped.
Run an authenticated reply worker
Poll GET /v2/conversations/FRESHCHAT_CONVERSATION_ID/messages with from_time and items_per_page=50, following every page. Start from the saved creation time, retain a durable watermark and deduplicate by message id because from_time is inclusive. Keep a small overlap when resuming so equal timestamps are not lost. Honor account rate-limit headers, back off on 429/transient failures and stop on terminal authorization errors until credentials are repaired.
Forward only actor_type: "agent", message_type: "normal", a non-empty text part and an actor_id in your administrator-approved human allowlist. Reject bot, system, user, private, unknown and missing actors/types; do not infer a person from an outgoing message. Look up the human display name from the approved agent record. Restrict messages to the saved current interaction.
Deliver signed callbacks and closure
Translate each approved reply to message.received using the Voiceflow connection ID, stable provider message ID, timestamp, text and human agent name:
Send to https://general-runtime.voiceflow.com/handoff/webhook/custom with the Voiceflow HMAC headers. Retry transient callback failures using the same event ID; retain undelivered events. The shared protocol module implements this signing/retry shape.
Also poll GET /v2/conversations/FRESHCHAT_CONVERSATION_ID. Serialize delivery per conversation. When the active interaction reaches resolved, finish fetching its message pages, persist every pending approved reply and await successful Voiceflow delivery of those replies before sending conversation.ended once. Do not let a separate status poll overtake the last human message; Voiceflow closes the active mapping on the end event. Stop the worker only after closure is accepted. On Voiceflow POST /conversations/YOUR_CONNECTION_ID/end, PUT the provider case with {"status":"resolved"} and mark it ended. Make reflected closure idempotent. A later reopen gets a new interaction; it must not revive an ended Voiceflow connection.
Connect the service and route the agent
Studio
Open the connection
Open your project in Agent studio, then Integrations → Custom Handoff → Connect. Enter the developer’s Base URL, Auth header name Authorization, Auth header value and Webhook secret. Select Connect.
Configure the support Workflow
Create a Workflow, add a Handoff step and choose Custom Handoff. Set End user ID to {freshchat_user_id} from customer setup. Your backend must populate this empty-default variable with the verified Freshchat user ID before the action that starts handoff; the relay validates its customer/project association. Select Full transcript for Handoff context only when that content may be shared with the team. The relay must place internal context in a private note. Keep file uploads disabled and enable Return and Fail paths.
Attach and test the Workflow
Add the Workflow to the agent and explain when to call it, such as the customer asking for a person. Publish the test Environment, connect the actual customer chat and complete the checks below with a support teammate. Setting Queue ID routes a Freshchat group only if your relay explicitly maps it.
Code
Once the service and reply worker are ready, save freshchat-handoff.json. These are your relay credentials, not the Freshchat token:
A 200 confirms stored project default-slot configuration, not delivery. Complete the headless Workflow creation, attachment and publication procedure with provider custom, trusted customer identity and Return/Fail paths. Preserve existing agent registrations. Implement the Chat handoff traces and human-message contract in your customer client and test that published Environment.
Verify the complete conversation
- Escalate once from the verified test customer. Confirm one Freshchat conversation in the intended topic, with the correct customer and private escalation note.
- Send customer text from Voiceflow and a public human reply from Freshchat. Confirm each reaches the other interface once.
- Add a private note, a bot message and an unknown actor. None may become a customer reply. Replay a message ID and confirm no duplicate.
- Send a final human reply and immediately resolve in Freshchat. Confirm the reply arrives before closure and check the Return path. Separately end from Voiceflow and confirm the provider case resolves once. Reopen the provider case and confirm its new interaction does not revive the ended connection.
- Stop the service and check the Fail path for a new handoff. Inspect the worker, stored IDs and signed callback response if a reply is missing.