dtwo-add-intent-transition
ChatGPTAdd a transition row. Supply exactly one of peerUid or peerName (both is allowed if they resolve to the same intent). The declaring intent must be in RESTRICTED mode for the row to apply.
dtwo-add-policy
ChatGPTValidate Rego and create a new policy. Sets uiSettings.advancedMode = true. Pass writableKeySchema to declare the session-state keys this policy is authorized to write (e.g. a marker key); omit to leave the column NULL.
dtwo-apply-catalog-policy-update
ChatGPTPull the newer catalog version of an imported policy into its draft, resolving each part independently: applyPolicyCode and applyDescription control whether the Rego body and the description are replaced (both default to true; parts left out keep the local draft version). The recorded checksum is always updated so the draft reads as reconciled with the current catalog version. The draft keeps its name and tags, and no version is created unless publish is set. Returns a diff of the body change when the body is applied. Never applies updates automatically; call this only when the user has decided how to resolve the update.
dtwo-check-policy-updates
ChatGPTCompare imported tenant policies against the current catalog manifest to detect upstream changes. Reports a status per policy: upToDate, updateAvailable (the catalog body changed since import), or removedUpstream (the source no longer exists in the catalog). Each entry also includes skipped — true when the tenant previously skipped this exact upstream version. Use apply_catalog_policy_update to pull an available update into a draft, or skip_policy_update to dismiss it.
dtwo-create-gateway
ChatGPTCreate a new gateway as a draft from a name, tags and a deployment type. Use this first when setting up a gateway; afterwards add MCP servers (save_gateway_draft_config), publish (publish_gateway_config), and deploy (deploy_gateway). A localHttp or hostedAws gateway needs no auth setup step — Dtwo assigns its URL, so it is created with the Dtwo-managed Auth0 identity provider already bound to that audience, and set_gateway_auth is only for moving it to your own IdP. A standard gateway is created with neither a URL nor authentication, because its audience is a URL only you know: pass it to update_gateway, then call set_gateway_auth with mode dtwo_default. deploymentType defaults to hostedAws (a Dtwo-hosted instance); choose standard for a gateway you run yourself or localHttp for a locally-run one. For hostedAws, the AWS ProvisionAws task is queued automatically and returned. As a first-run guardrail against accidentally provisioning a second cloud instance, creating a hosted gateway when one already exists errors unless allowAdditionalHosted is set.
dtwo-create-gateway-activation
ChatGPTMint a new first-run activation bundle for a localHttp/standard gateway: a one-time SSM activation id/code and expiry, the docker compose file (name + text, with the local 443:443→80:80 swap for localHttp), and the activation command to run on the gateway host. EVERY call mints a fresh pair, which invalidates any activation issued earlier — activation codes are never stored, so there is no existing one to hand back. Because of that, do NOT call this again after activating a host: the second call invalidates the pair the host just used. Requires the server to be configured with the gateway compose URL (the compose file is fetched at call time). Hosted gateways are activated automatically during provisioning and return an error.
dtwo-create-intent
ChatGPTCreate a customer-tier intent. The full id is namespace:intentId. Transition modes default to ALL (no restriction) on both directions.
dtwo-create-intent-compatibility
ChatGPTDeclare that an intent is incompatible with a marker (intent is denied when the marker is active).
dtwo-create-marker
ChatGPTCreate a customer-tier marker. The full key form is marker:namespace:markerId. minimumTtlSeconds is the floor any writable-key schema can declare for this marker. clearable (default true) says whether the user may remove the marker through the human-gated clear flow; a non-clearable marker leaves the session only when its TTL expires. Shape validation on namespace / markerId (character class, forbidden chars, reserved prefixes) is enforced at the store layer — the tool boundary only requires non-empty strings.
dtwo-create-vault-entry
ChatGPTAdd a plain (unencrypted) entry to the Vault that gateway configs can reference by putting its name between << and >>, optionally followed by | and a fallback value before the closing >>. A plain value is stored as given and anyone who can see the Vault can read it, so never use this tool for a credential, API key, password, token, or other secret: call get_vault_secret_link instead, which lets the user enter the secret in the Hub. If you're not sure whether a value is secret, treat it as one and use get_vault_secret_link. If the user pastes a secret into the chat, don't put it in this or any other tool; give them that link instead. By default the entry is for all gateways, so the config and sidecars of any gateway can use it. Pass gatewayUid to keep it on one gateway instead: only the config and sidecars of that gateway can use it, and it is deleted with the gateway. Two gateways can each have their own entry with the same name, but an entry on a gateway cannot share a name with an entry for all gateways. Name, type, and gateway are fixed once created. The value is filled into a gateway config when the gateway deploys, and into its sidecars when the gateway is updated or restarted.
dtwo-delete-intent
ChatGPTDelete a customer-tier intent. Platform-managed entries cannot be deleted. The delete is refused, naming every blocking row, while any intent-compatibility or intent-transition row still references this intent on either end — delete those via delete_intent_compatibility / delete_intent_transition and retry.
dtwo-delete-intent-compatibility
ChatGPTDelete an intent/marker compatibility row.
dtwo-delete-intent-transition
ChatGPTDelete a transition row.
dtwo-delete-marker
ChatGPTDelete a customer-tier marker. Platform-managed entries cannot be deleted. The delete is refused, naming every blocking row, while anything still declares this marker: a draft policy's writableKeySchema (policy:{uid}), a published policy version a pipeline step currently selects (policy_version:{uid}@{n}), or an intent-compatibility row (compatibility:{intent}). Clear the reference and retry — via update_policy, by repinning or detaching the pipeline step, and delete_intent_compatibility respectively.
dtwo-delete-policy
ChatGPTDelete a policy by UID. Fails if the policy is still attached to one or more gateways — detach it from those gateways first.
dtwo-delete-vault-entry
ChatGPTDelete a Vault entry, including an encrypted entry's stored secret. A gateway config that still references it without a default fails validation and fails its next deploy, so check which configs use it first (validate_gateway_config reports each config's references).
dtwo-deploy-gateway
ChatGPTQueue the existing deploy task for a gateway and return task metadata.
dtwo-get-catalog-policy
ChatGPTFetch a single catalog policy by its source path, including its Rego body, metadata, and a suggested package name. The body checksum and schema version are verified server-side.
dtwo-get-catalog-policy-filters
ChatGPTList the available filter facets for the policy catalog: apps, industries, bundles, and tags. Use these values with list_catalog_policies.
dtwo-get-deployment
ChatGPTFetch a single deployment task with status, steps, and results.
dtwo-get-event-schema
ChatGPTDescribes the gateway event/log schema used by search_recent_events and search_events: every queryable field with its type, legal operators, description, and group (common, opa, discovery, auth, pulse, tool); known event_type values; query-syntax rules; and worked example queries. Call this FIRST, before your first event search, to construct a correct query on the first try. Key rules: one operator per field (range operators may combine into a bounded window); all matching is exact (no contains/like/full-text); timestamps are UTC ISO-8601.
dtwo-get-gateway
ChatGPTFetch a single gateway draft/current object by UID, along with the latest published version (null for never-published gateways).
dtwo-get-gateway-config
ChatGPTFetch the current draft YAML configuration for a gateway.
dtwo-get-gateway-connection-info
ChatGPTReturn the details an MCP client needs to connect to a gateway, on any deployment type. Reports the MCP URL plus authMode, which says how much else is filled in: dtwo (the default a gateway is created with) carries the audience, issuer, JWKS URI, Auth0 domain, and the tenant's own gateway client application id when one is registered — a tenant with none is reported by omitting clientId, not by failing, since a client carrying a Client ID Metadata Document needs only mcpUrl; custom carries the audience, issuer and JWKS URI the gateway is configured to verify against, and no client ID, because sign-in goes through the customer's own IdP; none means authentication is off, so the MCP URL is all there is. A custom gateway also returns callbackPort (33418), a loopback port to register as a redirect URI with that IdP for a client that signs in with its client id and lets you choose its callback port, such as claude mcp add --client-id … --callback-port 33418. A dtwo gateway returns no callbackPort on any deployment type, since CIMD clients bring their own redirect URIs. A gateway with no URL yet — a hosted one still provisioning — returns an error. Not every client needs clientId: Claude's hosted surfaces (claude.ai, Desktop, mobile, Cowork), Claude Code and Codex identify themselves with a Client ID Metadata Document, so on a dtwo gateway pointing them at mcpUrl is enough and they must not be given clientId (for Codex, never add --oauth-client-id). Clients without one (Cursor, MCP Inspector, …) are given clientId explicitly.
dtwo-get-gateway-deployments
ChatGPTList deployment tasks for a gateway.
dtwo-get-gateway-pipelines
ChatGPTFetch ingress and egress pipeline steps for a gateway, including policy details.
dtwo-get-gateway-versions
ChatGPTFetch published versions for a gateway, including latest version metadata.
dtwo-get-intent
ChatGPTFetch a single intent by UID.
dtwo-get-marker
ChatGPTFetch a single marker by UID.
dtwo-get-policy
ChatGPTFetch a single draft/current policy object by UID, along with the latest published version (null for draft-only policies).
dtwo-get-policy-versions
ChatGPTFetch published versions for a policy, including latest version metadata.
dtwo-get-setup-progress
ChatGPTRead the setup steps recorded for the current tenant. Returns completedSetupSteps (everything stored) and completedAssertedSteps (the closing steps that are done, in flow order). Only the closing steps are recorded: connectClient, testPolicies, and plugin. Every earlier step (creating the gateway, adding MCP servers, attaching policies, deploying) is derived from the tenant's own data, so it is never stored here and its absence says nothing. Use this when resuming an interrupted setup to see how far a previous run got.
dtwo-get-vault-entry
ChatGPTFetch one Vault entry by UID. An encrypted entry's value is always null.
dtwo-get-vault-secret-link
ChatGPTGet a link to the Vault page in the Hub where the user types a secret in themselves, such as an upstream API key, password, or token, so its value never passes through the chat or this server. To add a new encrypted entry, pass name, and optionally type, description, and gatewayUid: the link opens the add form with those filled in and encryption on. To give an existing encrypted entry a new value, pass only its uid: the link opens that entry's edit form. This call creates and changes nothing; the entry exists, or has its new value, only once the user saves the form. The link names this session's organization, and the Hub opens the form only while the user is signed in to that organization. Give the user the link, ask them to paste the secret there and save, and never ask for the value in the chat. Then confirm with list_vault_entries by name, or get_vault_entry. A config references the entry by putting its name between << and >>.
dtwo-import-catalog-policy
ChatGPTImport a catalog policy into the current tenant and create a first version of it. Fetches the checksum-verified body, validates Rego and the package name, and records catalog provenance (publishedPolicyChecksum and publishedPolicySource) on the created version. Never mutates the public catalog.
dtwo-list-catalog-policies
ChatGPTSearch the shared policy catalog. Returns a summary per policy — metadata only, with the Rego body and the policy tests omitted and the description truncated to 1500 characters; call get_catalog_policy with a policySource to fetch one in full, with its complete description. Filter by app, industry, bundle, tag, and direction. Use get_catalog_policy_filters to discover available filter values. Results are paged: when hasMore is true, call again with offset = nextOffset. No GitHub credentials are required.
dtwo-list-claims
ChatGPTReturn the union of JWT claim names discovered for the tenant, along with the issuers seen. Defaults to tenant-wide; pass gatewayUid to scope to a single gateway. Use these names when authoring policies that read JWT claims.
dtwo-list-gateways
ChatGPTList gateways in the current Dtwo account with optional exact-match filters.
dtwo-list-intent-compatibility
ChatGPTList intent/marker incompatibility rows. Each row says: when the marker is active in session state, the intent is denied.
dtwo-list-intent-transitions
ChatGPTList intent transitions. A transition row says the declaring intent permits direction with peer; only consulted when the corresponding mode is RESTRICTED.
dtwo-list-intents
ChatGPTList intents in the registry. Platform-managed entries (system=true) are read-only; customer-tier entries are tenant-scoped.
dtwo-list-markers
ChatGPTList markers in the registry. Markers are vocabulary items policies write to session state (e.g. marker:acme:privileged_data). Each entry carries clearable: false means the user cannot remove it through the human-gated clear flow, so a deny reason built on it should point at the TTL, not at a clear.
dtwo-list-policies
ChatGPTList policies in the current Dtwo account with optional exact-match filters. Returns a summary per policy — the Rego body, uiSettings and writableKeySchema are omitted and the description is truncated to 1500 characters; call get_policy with a uid to fetch one in full.
dtwo-list-vault-entries
ChatGPTList the entries in the account's Vault: named, typed values that gateway configs reference by putting the name between << and >> instead of embedding them. An entry is either for all gateways, so any gateway's config and sidecars can use it, or belongs to one gateway (its gatewayUid), so only that gateway's config and sidecars can use it. With no filters, every entry is listed. Pass gatewayUid for one gateway's own entries, or accountWideOnly: true for the entries for all gateways; a gateway can use both sets. Encrypted entries are listed with their name, type, and description, but their value is always null. Results come a page at a time: when nextOffset is set, call again with that offset for the rest. To check whether an entry already exists before creating one, pass its name.
dtwo-publish-gateway-config
ChatGPTCreate a new version from the current gateway draft configuration.
dtwo-publish-policy
ChatGPTCreate a new version from the current policy draft.
dtwo-record-setup-progress
ChatGPTRecord the closing setup steps for the current tenant, so the Dtwo Hub shows setup as finished instead of asking the user to tick off work already done with them. These three steps happen in the user's own tooling and nothing server-side can observe them, which is why they are asserted: connectClient (an MCP client registered against the gateway), testPolicies (a call made through the gateway and a policy seen to fire), and plugin (the Dtwo plugin installed). Record a step only once it has actually happened: after the user confirms the client is registered, after the policy test returns the gateway's own response. Steps merge with whatever is already recorded, so call it as each one completes. Do not send the earlier steps (gateway, mcpServers, policies, deploy): those are read from the tenant's data.
dtwo-refresh-gateway-activation
ChatGPTMint a fresh one-time SSM activation pair for a self-hosted (localHttp/standard) gateway, e.g. when its activation expired or was invalidated. Returns the same full bundle as create_gateway_activation — activation id/code/expiry plus the compose file and activationCommand — so the host can be re-registered from this one call. The returned command re-registers an ALREADY-RUNNING host: it takes the stack down, writes the new activation, and brings it back up without pulling, so the deployed image does not change. (For a host being set up for the first time use create_gateway_activation, whose command pulls the image.) Minting invalidates any previously issued activation. Requires the server to be configured with the gateway compose URL. Errors for hostedAws gateways: refreshing invalidates the activation the AWS provisioning flow baked into the launched instance.
dtwo-revert-gateway-config
ChatGPTRestore a published gateway version back into the current draft.
dtwo-revert-policy
ChatGPTRestore a published policy version back into the current draft.
dtwo-save-gateway-draft-config
ChatGPTSave YAML as the draft configuration for a gateway. This does not validate it, matching the Hub: ask the user whether they want it checked first, and if so call validate_gateway_config before saving. The config is stored with its Vault references intact; values are filled in when the gateway deploys, and a deploy fails on a reference to an entry that does not exist. Never put a credential, API key, password, or other secret directly in gateway YAML: reference a Vault entry instead, by putting its name between << and >>. To add the secret, call get_vault_secret_link and give the user the link, so they enter the value in the Hub themselves; never ask for it in the chat.
dtwo-search-events
ChatGPTSearch the FULL HISTORY of gateway events and logs (slow — a data-warehouse scan that can take tens of seconds per call). Do NOT use this for recent activity: search_recent_events covers the last ~30 days, is much faster, and takes identical arguments. Use this tool only when the time range you need extends beyond ~30 days ago, and ALWAYS bound the scan with since/until. Tenant scoping is automatic. Same query syntax as search_recent_events (exact matching, one operator per field — see get_event_schema). Returns at most 200 events per call (default 50); paginate with offset.
dtwo-search-recent-events
ChatGPTSearch gateway events and logs from approximately the LAST 30 DAYS (fast — served from the live log index). This is the default tool for investigating gateway behavior: errors, OPA policy decisions, MCP discovery runs, auth events, heartbeats. Only use search_events instead when you need data older than ~30 days. Tenant scoping is automatic. Matching is EXACT — do not try to filter message by keywords; narrow by event_type/levelname/gateway_id/ids and read messages from the results. Bound time with since/until (UTC ISO-8601). For any other queryable field use filters — call get_event_schema for the field list, operators, and known event types. Results are newest-first by default and omit empty fields. Returns at most 500 events per call (default 50); paginate with offset (limit + offset ≤ 8000).
dtwo-set-gateway-auth
ChatGPTChange the gateway's authentication block in its draft config, then save it. Like save_gateway_draft_config, this does not validate; offer validate_gateway_config if the user wants the result checked. A new localHttp or hostedAws gateway already carries the Dtwo-managed Auth0 IdP, so for those this is for moving off that default rather than first-time setup; a new standard gateway carries none, so it does need a first call here. custom writes your own IdP fields (requires customFields). disabled keeps the block but sets enabled: false. removed drops the block entirely. dtwo_default re-applies the Dtwo-managed defaults, binding the block to the gateway's own audience — no IdP details needed, but a gateway with no URL yet has no audience to bind to and errors, so give a self-hosted gateway its URL with update_gateway first (a hosted one gets its URL when provisioning finishes).
dtwo-set-gateway-pipelines
ChatGPTUpdate ingress and egress pipelines for a gateway using policy-version-aware steps.
dtwo-set-intent-transition-mode
ChatGPTSet an intent's transition mode for a direction. ALL allows any peer, NONE locks the direction, RESTRICTED defers to the transition rows.
dtwo-skip-policy-update
ChatGPTDismiss an available catalog update for a tenant policy by recording the skipped checksum. The update prompt stays hidden until a newer catalog version (different checksum) appears. Tenant-wide and reversible — apply_catalog_policy_update still works afterwards. Does not change the policy body.
dtwo-update-gateway
ChatGPTUpdate gateway metadata: name, tags, and — for a standard gateway — its MCP URL and OAuth callback URL. This is where a self-hosted gateway gets the URL it was created without; set it before set_gateway_auth, since the URL is the audience the IdP binds to. Changing the URL of a gateway already on the Dtwo-managed IdP re-registers its Auth0 API, so tokens minted for the old URL stop working. Use save_gateway_draft_config for the YAML config and set_gateway_pipelines for pipelines.
dtwo-update-intent
ChatGPTUpdate mutable fields on a customer-tier intent (description, tags, aliases). Use set_intent_transition_mode / add_intent_transition / delete_intent_transition to change transition rules.
dtwo-update-marker
ChatGPTUpdate mutable fields on a customer-tier marker (description, displayName, tags, minimumTtlSeconds, clearable). The change reaches gateways on their next deploy.
dtwo-update-policy
ChatGPTUpdate an existing policy. Any provided field is updated and omitted fields are left unchanged. Rego is validated when both policy and packageName are provided. Sets uiSettings.advancedMode = true. writableKeySchema is tri-state: omit to leave existing untouched, pass null to clear, pass [] for explicit-empty, pass a populated list to set.
dtwo-update-vault-entry
ChatGPTReplace a plain Vault entry's value, or any entry's description. An encrypted entry's value can't be set here: call get_vault_secret_link with its uid instead, so the user enters the new secret in the Hub. Name, type, and encryption can't be changed; delete the entry and add it again instead. Running gateways keep the old value in their config until they are next deployed. A gateway whose sidecars use the entry is marked as needing an update, which gives its sidecars the new value.
dtwo-validate-gateway-config
ChatGPTValidate a Dtwo gateway YAML configuration string without saving it. Saving does not validate, so offer this to the user before a save. This runs the same check as a deploy: Vault references (an entry name between << and >>, optionally followed by | and a fallback value) are resolved against the account's Vault, encrypted entries included, before the config is checked, so a malformed reference or one naming an entry that doesn't exist (and has no default) is an error. The result's parameters lists every Vault entry the config uses, whether it exists, and where it is referenced. The resolved config is never returned, and no error or warning contains an encrypted value. Pass gatewayUid when the YAML is for an existing gateway, so that gateway's own Vault entries count as well as the entries for all gateways, exactly as they do when it deploys. Never put a credential, API key, password, or other secret directly in gateway YAML: reference a Vault entry instead, by putting its name between << and >>. To add the secret, call get_vault_secret_link and give the user the link, so they enter the value in the Hub themselves; never ask for it in the chat.
dtwo-validate-policy-rego
ChatGPTValidate Rego policy code without saving it.
dtwo-add-intent-transition
Claudedtwo-add-policy
Claudedtwo-apply-catalog-policy-update
Claudedtwo-check-policy-updates
Claudedtwo-create-gateway
Claudedtwo-create-intent
Claudedtwo-create-intent-compatibility
Claudedtwo-create-marker
Claudedtwo-delete-intent
Claudedtwo-delete-intent-compatibility
Claudedtwo-delete-intent-transition
Claudedtwo-delete-marker
Claudedtwo-delete-policy
Claudedtwo-deploy-gateway
Claudedtwo-get-catalog-policy
Claudedtwo-get-catalog-policy-filters
Claudedtwo-get-deployment
Claudedtwo-get-event-schema
Claudedtwo-get-gateway
Claudedtwo-get-gateway-activation
Claudedtwo-get-gateway-config
Claudedtwo-get-gateway-connection-info
Claudedtwo-get-gateway-deployments
Claudedtwo-get-gateway-pipelines
Claudedtwo-get-gateway-versions
Claudedtwo-get-intent
Claudedtwo-get-marker
Claudedtwo-get-policy
Claudedtwo-get-policy-versions
Claudedtwo-import-catalog-policy
Claudedtwo-list-catalog-policies
Claudedtwo-list-claims
Claudedtwo-list-gateways
Claudedtwo-list-intent-compatibility
Claudedtwo-list-intent-transitions
Claudedtwo-list-intents
Claudedtwo-list-markers
Claudedtwo-list-policies
Claudedtwo-publish-gateway-config
Claudedtwo-publish-policy
Claudedtwo-refresh-gateway-activation
Claudedtwo-revert-gateway-config
Claudedtwo-revert-policy
Claudedtwo-save-gateway-draft-config
Claudedtwo-search-events
Claudedtwo-search-recent-events
Claudedtwo-set-gateway-auth
Claudedtwo-set-gateway-pipelines
Claudedtwo-set-intent-transition-mode
Claudedtwo-skip-policy-update
Claudedtwo-update-gateway
Claudedtwo-update-intent
Claudedtwo-update-marker
Claudedtwo-update-policy
Claudedtwo-validate-gateway-config
Claudedtwo-validate-policy-rego
Claude