Tool Errors and Troubleshooting

Connector tool calls return a structured JSON error envelope designed so the AI can understand what went wrong, relay it in plain language, and offer sensible next steps. Platform tools,…

Written By Christopher Scaminaci

Last updated 3 days ago

Connector tool calls return a structured JSON error envelope designed so the AI can understand what went wrong, relay it in plain language, and offer sensible next steps. Platform tools, parameter-binding or protocol failures, and transport authorization failures can return smaller JSON shapes or an HTTP/MCP-level error instead. This page documents the representative cross-cutting errors that can affect many tools; each generated tool description remains the source of truth for operation-specific validation and state errors.

The error envelope

The full connector-execution envelope is shaped like this (fields that do not apply are omitted):

{
  "error": true,
  "errorType": "forbidden",
  "retryable": false,
  "tool": "halo_create_ticket",
  "message": "Halo API returned 403 for /api/Tickets",
  "guidance": "Access denied. The connector account may lack required permissions for this operation.",
  "httpStatus": 403,
  "upstreamError": "…the vendor API's own error body…",
  "correlationId": "4bf92f3577b34da6a3ce929d0e0e4736",
  "supportTicketDraft": { "subject": "…", "description": "…" },
  "nextActions": [
    {
      "tool": "stackjack_create_support_ticket",
      "requiresUserAuthorization": true,
      "reason": "Ask the user before opening a StackJack support ticket with this draft."
    }
  ]
}

Gate errors raised inside the same connector-execution path (plan, billing, allowance) carry this envelope without the upstream fields — for example a monthly_limit_exceeded message includes usage, limit, and the billing-cycle window (start–end), but no httpStatus or upstreamError.

Field by field:

Field	Meaning
`errorType`	A stable machine-readable code for that path. The tables below are representative; individual platform and connector tools can define additional codes.
`retryable`	Whether simply trying again may succeed (true for rate limits and transient upstream failures).
`message` / `guidance`	Plain-language explanation and suggested action, written for the AI to relay to you.
`httpStatus`	The HTTP status the vendor API returned, when the failure came from upstream.
`upstreamError`	A credential-sanitized, 2,000-character excerpt of the vendor response. It is not a lossless body; truncation can remove useful tail content. It is the vendor's own text, so it can echo values you sent or details about your customers. Masking targets recognized credential shapes (tokens, keys, passwords, authorization headers) and is not a general removal of sensitive data — see What usage records contain.
`correlationId`	W3C `traceId-spanId` when both exist, the trace id when no span is available, or a request identifier when no usable activity exists. Quote it to StackJack support — it helps correlate the report with available telemetry.
`supportTicketDraft` / `nextActions`	Conditional fields for the support-worthy allowlist below. They prefill error context and tell the harness to ask before calling `stackjack_create_support_ticket`.

On the shared connector-execution path, calls StackJack records as failed do not count against your monthly allowance. Only successful live connector calls consume quota; a successful replay served from a recorded fixture does not consume live connector quota either.

When a support draft appears

The current 14 support-worthy codes are authentication_error, authorization_expired, capability_not_enabled, connector_api_error, connector_not_configured, forbidden, gateway_timeout, internal_error, network_error, refresh_in_progress, refresh_token_persistence_failed, service_unavailable, timeout, and upstream_server_error.

No automatic draft is attached to bad_request, not_found, rate_limited, write_unverified (a HaloPSA read-back verdict; the cause is the vendor's own configuration, not a StackJack fault), cipp_result_failed (CIPP reported the failure inside its own response; the cause is inside your M365 tenant), connector_disconnected (your own organization removed the connection; reconnect it on the Connectors page), request_shape_error (the vendor could not read a field of the request your AI sent, so the AI corrects that field and sends the request again), user_context_required (NinjaOne needs this action done by a signed-in technician, and your NinjaOne connection is Client Credentials; switch it to Authorization Code on the Connectors page), ordinary validation failures, or normal plan, permission-selection, subscription, billing, and allowance gates. If you elect to create a ticket from an eligible draft, the ticket is saved first and StackJack then attempts a system bundle and sanitized MCP-log upload independently. Those uploads are best-effort; the create response reports diagnosticsAttached, and the ticket remains open even if both uploads fail.

Retrying a failed or timed-out write

A write that failed or timed out may already have changed the upstream system. StackJack reports what it observed, and a connection that dropped after the vendor accepted the request looks the same from here as one that never arrived. Before you repeat a write, verify its outcome in the vendor — unless that operation's own documented idempotency contract makes a repeat safe.

This applies to every one of these:

What you saw	What may already have happened	Do this before retrying
`timeout`	StackJack stopped waiting. The vendor may still have completed the call.	Read the target record back, then retry only if the change is absent.
`gateway_timeout` (504)	The vendor's own gateway timed out over a request its backend may have processed.	Same: read back first.
`upstream_server_error` (500) / `service_unavailable` (503)	The vendor failed after receiving the request. A 500 on a create can still leave the record.	Search for the record by a field you supplied before creating a second one.
`network_error`	StackJack could not complete the exchange. It cannot tell whether the request left.	Read back first.
`tool_result_too_large`	The vendor call ran and StackJack refused the oversized response. On a write, the change can already be in place.	Verify in the vendor, then narrow the request rather than repeating the write.
`write_unverified`	The vendor accepted the write and StackJack's read-back could not confirm it held.	Read the guidance in the error — it says whether the write must not be re-sent.
`cipp_result_failed`	Often partial: part of the operation applied and part did not.	Read the `Results` list, then re-send only the step that failed.
`request_shape_error`	Nothing. The vendor could not read a field of the request, so it created and changed nothing.	Do not send the same request again. Correct the field the error names, then send the request once.
`user_context_required`	Nothing. NinjaOne refused the action before doing it.	Do not retry: it fails the same way until the NinjaOne connection is signed in as a technician (Authorization Code, or a personal NinjaOne sign-in).

Reads are different, but not free. Repeating a read does not change anything in the vendor, so the retry rule above does not apply. It does consume another call against the connector's monthly allowance, and it hands the returned records to your AI application again — which matters when the tool reads passwords, contacts, or other sensitive records.

A vendor error is not proof of a mistake on your side. bad_request and forbidden usually point at your request or your key's scope, but an unfamiliar vendor error can also come from a StackJack defect, a vendor incident, or a change in the vendor's API. Keep the correlationId and escalate rather than assuming the cause; see Troubleshooting recipes.

Error types: access and billing gates

These are raised by StackJack before the vendor API is ever contacted:

errorType	Meaning	What to do
`tool_not_allowed`	The tool isn't in this MCP client's (or team member's) tool selection.	An admin updates the client's tool selection on Endpoints (or the member's grants on Team).
`plan_upgrade_required`	The tool needs a higher plan tier than the connector subscription has.	Upgrade that connector's plan, or use a lower-tier alternative tool.
`subscription_past_due`	The connector subscription's renewal payment failed.	Update the payment method on the billing page.
`subscription_paused`	The connector subscription is paused.	Resume it on the billing page.
`subscription_canceled`	The connector subscription was canceled.	Resubscribe to restore access.
`subscription_inactive`	The connector subscription is in some other non-active billing state.	Check the subscription on the billing page.
`subscription_period_ended`	The billing period ended and no renewal has been recorded yet.	Usually resolves when the renewal processes; check the billing page if it persists.
`monthly_limit_exceeded`	The connector's call allowance for the current billing cycle is used up. The message shows usage, limit, and the billing-cycle window.	Wait for the cycle reset or upgrade the plan. Call `stackjack_get_quota_status` to see where every other connector stands before planning around it, and to catch the next one early.
`instance_version_unsupported`	The tool declares a minimum connected-product version and the instance reports an older one.	Upgrade the connected instance or use an equivalent tool.

Error types: upstream vendor API failures

When your connected product's API rejects or fails a call, StackJack classifies the HTTP status:

errorType	HTTP status	What it usually means
`bad_request`	400	The vendor rejected the request parameters. The guidance includes a snippet of the vendor's response so the AI can self-correct.
`authentication_error`	401	The connector credentials were rejected. Re-validate or reconfigure them on the Connectors page.
`forbidden`	403	Credentials are valid but lack permission for this operation in the vendor product. Grant the missing permission on the vendor side (open the connector's API Permissions planner from Connectors to see what each tool needs).
`not_found`	404	Usually a wrong, stale, or removed ID. Verify it with a list/search tool first. If known-valid IDs fail persistently, investigate the vendor endpoint, product entitlement, or permission boundary and contact support with a correlation id.
`rate_limited`	429	The vendor's own rate limit tripped. Retryable — the AI should honor the returned guidance, wait, and try again. StackJack applies connector-specific pacing or concurrency protection where configured, but the vendor remains authoritative and can still return 429.
`upstream_server_error`	500	The vendor API had an internal error. Usually transient — retry.
`service_unavailable`	503	The vendor API is down or in maintenance. Retry later.
`gateway_timeout`	504	The vendor API timed out. Retry later.
`connector_api_error`	other	Any other vendor API failure; see `upstreamError` for the vendor's detail.
`write_unverified`	200	The vendor accepted the write, but StackJack's read-back could not confirm it held — a HaloPSA workflow rule reverted a field, or the read-back could not be completed. The guidance says whether the write must NOT be re-sent (an action, its note and any email already exist). No support draft is attached: the cause is the vendor's own configuration, not a StackJack fault.
`cipp_result_failed`	502	CIPP answered 200 and reported an operation failure inside its own `Results` list — a licence that would not detach, a mailbox rule Exchange refused. Not retryable, and on a write that matters: those failures are often partial (the user was disabled, the session revoke failed), so re-sending re-applies whatever already worked, and the guidance says so. On the handful of CIPP tools that only read, the guidance says instead that nothing was necessarily applied — fix the cause and call the tool again. `upstreamError` carries the full `Results` list either way, including the lines that succeeded. No support draft is attached: the cause is inside your M365 tenant, not a StackJack fault.
`request_shape_error`	500	ConnectWise could not read a field of the request your AI sent: a name or a plain value where ConnectWise needs a reference such as `{"id": 12}`, or a value that is not one of the field's allowed values. ConnectWise reports this as a server error, but nothing was created or changed, and the same request fails the same way every time, so it is not retryable. The message names the field and the shape it needs, and `upstreamError` carries ConnectWise's own text. Ask your AI to correct that field and send the request again. No support draft is attached: the request needs correcting, and the cause is not a StackJack or ConnectWise fault.
`user_context_required`	403	NinjaOne refused the action because it must be done by a signed-in NinjaOne technician and your NinjaOne connection is Client Credentials, an app-only key with no user context. This applies to adding ticket comments, creating tickets, running scripts and ticket boards. Your credentials were not rejected: the connection stays enabled and your other NinjaOne tools keep working. Not retryable. An owner or administrator switches the NinjaOne connection to Authorization Code (User OAuth) on the Connectors page; team members can then add their own NinjaOne sign-in. No support draft is attached: the fix is a connection setting, not a StackJack or NinjaOne fault.

A note on 404 and 429 semantics: a single wrong ID or a busy vendor API is an expected environmental outcome, so either code is not automatically a StackJack incident. Persistent 404s for known-valid IDs or sustained 429s after backoff can still signal an endpoint, entitlement, permission, pacing, or vendor-service problem and are worth escalating with correlation ids. The other 4xx codes (401/403) usually point at credential or permission configuration and need action.

Error types: credentials and configuration

errorType	Meaning	What to do
`connector_not_configured`	The tenant has a subscription but no working credentials for this connector.	Add or fix credentials on the Connectors page.
`personal_sign_in_required`	You are signed in as a Member or Administrator, and the only credential your organization holds for this connector is a shared sign-in that carries the account owner's own identity (a connector authorized by signing in, rather than with an API key). StackJack never runs one member's calls as another person, so nothing ran. This is not a fault and not a missing configuration — the same connector works for the owner.	For HaloPSA, NinjaOne, Microsoft Azure and Microsoft Graph: add your own sign-in under Your personal sign-ins on the Connectors page. For a connector that is authorized once for the whole organization and has no per-member sign-in (Reddit Ads), an owner has to run its tools.
`connector_unavailable`	The subscription exists, but StackJack could not load that connector's credentials for this request. Unlike an unconfigured connector, this is transient.	Retry. If it persists, check platform status and contact support with the `correlationId`.
`connection_default_disabled`	The connector's default connection is disabled and the call named no other connection. StackJack refuses rather than run the call against a different connection's credentials. The message names the connection and why it is disabled.	Name another connection with the `connection` argument (`stackjack_list_connections` lists them), or re-enable or replace the default connection on the Connectors page.
`connection_not_found`	The call named a `connection` and no connection of that connector matches the name or key. The payload's `known_connections` lists the ones that exist.	Pass one of the listed names or keys, or omit the argument to use the default connection.
`connection_not_permitted`	The endpoint is pinned to one connection of this connector (or the automation is bound to one), and the call named a different one. The payload discloses only the pinned connection.	Omit the `connection` argument to use the pinned connection, or run the call from an endpoint that is not pinned.
`connection_disabled`	The named connection exists but is disabled. The message carries the reason.	Re-enable or fix the connection on the Connectors page, or name another connection.
`connection_not_configured`	The named connection exists, but there is no usable credential on it for the identity making the call — for example a member who has not signed in on that connection — or the automation's bound credential is unavailable.	An owner adds or repairs the credential on the Connectors page; a member signs in on that connection under Your personal sign-ins on the same page; an automation is re-enrolled on its page.
`connection_unavailable`	StackJack could not read the organization's connections on this request, so the named connection could not be verified. This is transient, and the payload carries `retryable: true`.	Retry. If it keeps failing, check the service status.
`connector_disconnected`	Someone in your organization disconnected this connector in StackJack while the call was in flight, so StackJack refused the call instead of sending it. Nothing reached the vendor and nothing changed. This is not a credential fault — the connection is simply gone.	An owner or admin reconnects the connector on the Connectors page; the same call then works again. No support ticket is needed, and no draft is attached.
`authorization_expired`	A stored authorization (for example an OAuth refresh chain) is definitively no longer valid.	Reconnect/re-authorize the connector in the portal.
`refresh_in_progress`	Another request is refreshing this connector's token right now.	Retry in a few seconds.
`refresh_token_persistence_failed`	A rotated token could not be saved — StackJack fails safe rather than risk breaking the credential chain.	Retry; contact support with the `correlationId` if it recurs.
`capability_not_enabled`	The vendor API key lacks an optional capability. Today this is IT Glue's Password Access: password tools return this until you regenerate the IT Glue key with password access enabled.	Follow the guidance in the error — it names the exact capability to enable.

Error types: everything else

errorType	Meaning
`timeout`	The call exceeded StackJack's time budget waiting on the vendor. Retryable.
`network_error`	StackJack couldn't reach the vendor API (DNS/connectivity). Retryable.
`connector_concurrency_limit`	StackJack briefly caps how many of your calls can hit the same vendor object endpoint at once (mirroring the vendor's own concurrent-request cap), and no slot opened up within the short wait window — so the call was never sent to the vendor. This is StackJack's own limiter, not a vendor rate limit (429). Retryable: retry in a moment, and avoid firing many calls at the same entity type in parallel (for example several get-all or aggregation tools at once). Currently only the Autotask connector applies this limiter (up to 3 concurrent calls per object endpoint, with a wait of about 10 seconds).
`validation_error`	An input problem: a tool parameter failed validation (the message names the parameter and valid values), a JSON parameter was malformed, or — less commonly — the vendor API returned a JSON shape the tool didn't expect.
`unknown_arguments`	The call named an argument the tool does not have. This gate exists only on the compact/minimal catalog dispatch path (running a tool through `stackjack_run_tool` or the folded platform router): there the argument names cannot be schema-checked by your AI client up front, so StackJack refuses unknown keys instead of silently dropping them into a defaults-shaped wrong answer. The error lists the offending argument(s) and the tool's real parameter names (`valid_parameters`) — re-send using only those, and don't nest parameters inside wrapper objects like `Pagination` or `Filters` unless a parameter is defined that way. A direct (full-catalog) call to the same tool never produces this code; unknown keys there are ignored by the schema layer. Sibling code from the same dispatcher: `unknown_tool`, when the tool name itself doesn't resolve — check the name against a catalog search.
`tool_result_too_large`	The tool returned more characters than the result cap — 5,000,000 characters on the platform, or the lower ceiling an Automation sets for itself (10,000–5,000,000) — and the result could not be saved to a link. The message reads "…exceeds the 5,000,000-character platform limit and was not returned" (or names the Automation's limit) (see Oversized results below). A write may already have completed upstream before StackJack refused its oversized response. Do not retry blindly: verify the target record or action in the vendor first, then retry only if it did not happen. The refused response does not consume the connector's monthly call allowance.
`internal_error`	An unexpected StackJack-side failure. Contact support with the `correlationId` if it persists.
`feature_disabled`	Two different features produce this code, and the message tells you which. Automations: every automation platform tool (`stackjack_run_agent`, `stackjack_list_agents`, `stackjack_get_run_transcript`, and the automation-builder tools) returns it when Agentic Orchestration isn't enabled for your organization — contact StackJack support to enable it. Catalog modes: on the standard endpoint, the catalog discovery, dispatch, and mode tools return it when catalog modes are not enabled for your organization — that one you fix yourself, on the Settings page ("Enable catalog modes for this organization"), and nothing was changed by the refused call. Those tools are always available on the compact endpoint. See Catalog modes.
`capacity_exceeded`	Queueing was not available for this attempt. Two things produce it: the platform-wide Automation run-slot pool being full, or your own organization's concurrent-run limit — read the message, which names the organization and its slot count when it is the latter, and is not a platform outage. A transcript fetch that was rate-limited upstream uses the same code. Retryable — try again shortly. Note that saturation normally queues instead of returning this: a harness launch usually comes back with a `runId` whose status is `Queued`, including when another run of the same automation is already in progress. A queued run that waits past its deadline ends as `Skipped`.
`insufficient_credits`	A run launch refused on billing grounds. Two causes: the organization is out of StackJack credits, or an Agent Runner plan that admitted a bring-your-own Anthropic key has lapsed — restore the subscription or remove the key. Not retryable until one of those changes. See Agent Runner plans.

Oversized results: the spilled-result envelope

Some calls succeed and return more data than can be sent back through the AI connection in one piece — a full ticket export, a year of device telemetry. A single tool result may carry at most 5,000,000 characters (about 5 MB of text), or the lower ceiling an Automation sets for itself. A result is never silently truncated: rather than throw that data away, StackJack saves the complete result and hands your AI a link to it:

{
  "spilled": true,
  "tool": "halo_list_tickets",
  "chars": 6115797,
  "url": "https://…",
  "expiresAt": "2026-09-07T03:04:05+00:00",
  "preview": "{\"tickets\":[{\"id\":48213,…",
  "guidance": "The full result is at url (valid until expiresAt). Fetch it with your file/URL tool; do not ask for it again through this tool."
}

What to know:

This is a success, not an error. There is no error or errorType field. The vendor call happened, the data is complete, and the call counts toward the connector's monthly allowance like any other successful call.
chars is the size of the full result, not of the preview. Use it to decide whether fetching is worth it or whether to narrow the request instead.
preview is the first 2,000 characters of the real result. It is there so the AI can see the shape of the data — never report it to a user as the whole answer.
url is a temporary read link, and expiresAt is the only authority on how long it lasts. Read the expiry out of the response rather than assuming a duration; it is set when the link is minted and varies with how StackJack's storage is configured. Fetch the link with a tool that can read a URL or download a file, and fetch it before expiresAt. Repeating the original tool call re-runs the vendor query and produces a new link, which is slower and consumes another call.
Only successful results are saved this way. Error responses are always returned in full as the normal error envelope.
Known secret-returning tools are excluded from this storage. StackJack keeps a reviewed list of the tools whose job is to return secrets — stored passwords, API keys, vault entries. Their responses are handed straight to your AI and are never written to storage, even temporarily. If one of them exceeds the cap it comes back as tool_result_too_large instead of a link. Narrow the request — a single record, a smaller page size, one folder at a time — and it returns inline as normal. The exclusion is by tool, not by inspecting the content, so a sensitive value that turns up in an ordinary tool's response is not detected and can be written to the temporary link. Treat the link as carrying whatever the vendor returned, and keep the tool selection narrow for connectors holding sensitive records.

If the result cannot be saved, an oversized result returns tool_result_too_large instead — narrow the request with filters, fewer fields, or a smaller page size and iterate over pages.

Automation governance and replay errors

Calls made by an Automation pass additional run-specific safety gates. These codes normally mean the Automation's configuration or current run state needs attention, not that the connector is down:

errorType	Meaning	What to do
`dry_run_blocked`	A dry-run Automation attempted a write or destructive tool. The attempted call is recorded in the transcript and nothing is sent to the vendor. Read-only tools are unaffected — they execute for real. One exception ships enabled: approving a paused supervised test call executes it for real against live customer systems. It is an authorization, not a rehearsal. The approval is short-lived and single-use — it authorizes one execution of that tool and then it is spent — and if it is not consumed in time, or an internal component is unavailable, the call stays blocked and simulated instead. Approving one call never turns dry-run off for the Automation or for later calls.	See Approving a supervised test call. Read the dry-run transcript, confirm the exact target record, and approve only if you want that change made now. The approval is matched by AI-connection identity and tool name, not by run or by arguments — so if two supervised runs are paused on the same tool under the same identity, do not assume the one you were looking at is the one that proceeds. Handle them one at a time. Afterwards, verify the change in the vendor. Approving a single call is not promotion: promote the Automation separately when you are ready for it to make changes unattended.
`destructive_consent_required`	The Automation has a destructive tool but its destructive-action acknowledgement is not current.	Open the Automation, review its destructive tools, and accept the acknowledgement before retrying.
`support_tickets_disabled_for_agent`	The Automation tried to create or reply to a StackJack support ticket while its Guardrails toggle is off.	Enable Allow this agent to raise a StackJack support ticket for errors only if you want that Automation to open or update tickets.
`chain_context_unavailable`	A governed destructive call could not prove the trusted run context needed to enforce its ordered chain.	Do not bypass it; retry after the run context is healthy, or contact support if it repeats.
`chain_step_out_of_order`	The Automation attempted a governed chain step before its required predecessor.	Let the Automation complete the required earlier step first.
`duplicate_destructive_call`	The same destructive step has already been claimed for this run.	Treat the first call as authoritative and verify its result instead of repeating it.
`fixture_missing`	A replay run expected a recorded fixture that is not available.	Restore the fixture or run against live read data; do not assume the replay exercised that call.
`confirmation_required`	A high-consequence Automation management tool needs its exact deterministic confirmation text. The caller can obtain or derive it; it is a request guard, not server-side proof of a named person's approval.	Read the returned explanation, confirm the intended target, then repeat the call with the exact string only if authorized.

See Automation guardrails and safety for the operator-facing controls behind these errors.

HTTP-layer authorization responses

Some authorization failures happen before the tool runs and return an HTTP response instead of a tool-result envelope. A missing tenant identity blocks the session. The subscription and credential responses are narrower: initialization, tool discovery, and credential-independent stackjack_* calls can still work, while a connector call (or an unrecognized request that cannot be proved safe) is refused at the HTTP layer.

One case passes this layer even though no credential loaded: a connector whose default connection is disabled, or whose default is waiting for your own sign-in, while another connection of the same connector is enabled. A call to that connector that names a usable connection with the connection argument runs; a call that names none gets the connection_default_disabled or personal_sign_in_required tool error described above, not one of the 403 responses below.

Response	Meaning	What to do
`401 {"error":"Tenant not resolved"}`	The MCP client credentials are wrong, rotated, or revoked.	Check the client's credentials on Endpoints; re-copy them into the harness.
`403 {"error":"No active connector subscriptions found"}`	A request that needs connector access arrived for a tenant with no active connector subscription.	Subscribe to at least one connector. Credential-independent StackJack platform tools still work in this state.
`403 {"error":"No connector credentials configured for your active subscriptions"}`	A request that needs connector access arrived, subscriptions exist, but no subscribed connector has a credential row.	Configure credentials on the Connectors page. Credential-independent platform tools still work.
`403 {"error":"...","errorType":"personal_sign_in_required","guidance":"..."}`	Same shape as the row above, but nothing is unconfigured: every connector your organization subscribes to is one whose only credential is a shared sign-in carrying the account owner's own identity, and you are not an owner. The `error` and `guidance` read exactly as the `personal_sign_in_required` tool error does. If more than one connector is in this state, a `connectors` array carries each one's own message and guidance, because the answer differs per connector.	Add your own sign-in on the Connectors page for the connectors that offer one; where a connector is authorized once for the whole organization, an owner has to run its tools.
`503 {"error":"Connector credentials temporarily unavailable","retryable":true}`	A request that needs connector access arrived while at least one subscribed connector's credentials failed to load and none materialized for the request.	Retry. Credential-independent platform status and health calls remain available; contact support if the failure persists.

Troubleshooting recipes

"It connects, but every tool call is refused." Ask the AI to run stackjack_session_info. If it returns pending_approval, an admin needs to approve the member on the Team page and assign tools. The connector list contains the active connectors whose credentials loaded for that request. Each connector that needs your own sign-in carries "status": "personal_sign_in_required" and says what to do; stackjack_list_connections reports the same status per connector. If an expected connector is absent or its calls are refused for some other reason, open Connectors, inspect its saved configuration, and use Re-test or stackjack_health_check; a transient load failure can also produce connector_unavailable.

"The Connectors page shows it connected, but my calls fail." Check whether you are the workspace owner. A connector authorized by signing in — HaloPSA, NinjaOne, Microsoft Azure, Microsoft Graph, Reddit Ads — stores the authorizing person's own identity, and StackJack will not run another member's calls under it. The tool error is personal_sign_in_required — and if that connector is the only one your organization subscribes to, the same refusal arrives as an HTTP 403 carrying "errorType": "personal_sign_in_required" instead of a tool result. The connector's card in Your personal sign-ins tells you the same thing: Authorization Required with a Connect button where you can sign in yourself, or Owner Sign-in Only where the connector has no per-member sign-in at all. Connectors configured with an API key are shared by design and work for everyone.

"A tool that worked yesterday is gone." Plan downgrade, connector cancellation, or a narrowed client tool selection. See Why tools appear and disappear. If you just restored access, stackjack_refresh_tool_list reports the current catalog version and the refresh instructions; have the harness re-list its tools, then disconnect and reconnect if its cached list remains stale.

"The AI keeps getting not_found." Tell it to call the connector's list/search tool first and use a returned ID. If a newly returned ID also fails repeatedly, preserve the correlation id and investigate the endpoint, permissions, and vendor product state rather than assuming another guess will help.

"Calls are failing with forbidden after I set up a least-privilege key." The vendor key is missing a permission one of the selected tools needs. Open Connectors, open that connector's API Permissions planner, select the failing tool, and compare the Required Permissions list against the key's actual grants.

"Is StackJack itself having a problem?" Ask the AI to run stackjack_get_service_status — it returns live platform status, component health, and any advisories targeted at your connectors.

When you contact support: include the correlationId from the error. For a support-worthy error, you can also elect to have the AI open the prefilled draft with stackjack_create_support_ticket. The draft carries the error context only; after creation, StackJack separately attempts the two best-effort diagnostic uploads described above and reports diagnosticsAttached.

Still need help? Ask the team