Model and credential providers
Interceptor authenticates the target agent's model and embedding requests on the host. The application uses its native API through the sandbox's model proxy, with synthetic SDK credentials when required. Real provider credentials never enter the target container. Operator configures Attack Harness model access separately.
Choose a model provider
Select --model-provider to match the API used by your application. Interceptor
does not translate one model API into another. Point the application's SDK at the
local proxy and configure its upstream provider independently on the host.
--model-provider |
Application API | Host --provider-base-url |
|---|---|---|
openai-chat |
OpenAI Chat Completions | https://api.openai.com/v1 |
openai-responses |
OpenAI Responses | https://api.openai.com/v1 |
anthropic-messages |
Anthropic Messages | https://api.anthropic.com; also set --provider-api-version to the required API header value. |
gemini-api |
Gemini generateContent | https://generativelanguage.googleapis.com/v1beta |
vertex-gemini |
Gemini generateContent | https://YOUR_LOCATION-aiplatform.googleapis.com/v1/projects/YOUR_PROJECT/locations/YOUR_LOCATION, ending before publishers/google/models. |
azure-openai |
OpenAI Chat or Responses | https://YOUR_RESOURCE.openai.azure.com/openai/v1 |
litellm |
OpenAI Chat or Responses | Your gateway's base URL, such as https://YOUR_GATEWAY/v1. |
bedrock-converse |
Bedrock Converse | Omit HTTP endpoint/key options; use --aws-region and host AWS authentication. |
These are base URLs, unlike Operator's complete operation URLs. Repeat
--allow-model for each exact model identifier the agent may request. For Azure,
use deployment names; for Bedrock, use the applicable model or inference-profile
identifier. The application cannot choose the upstream server.
The proxy supports non-streaming native requests. Streaming, multimodal/file inputs, provider-hosted tools, and background operations are outside its supported subset. A Responses client must send explicit input rather than depend on provider-stored conversation state. Choose an API and model supported by the application; selecting a different provider alone does not adapt its SDK.
Configure generation
This command connects an OpenAI Chat application to a stored model key. Replace
the paths and YOUR_MODEL; prepare the credential file
first:
interceptor run --environment ./interceptor-environment \
--production \
--model-provider openai-chat \
--provider-base-url https://api.openai.com/v1 \
--provider-auth secret-store \
--credential-config /absolute/private/credentials.yaml \
--model-credential-id model-key \
--allow-model YOUR_MODEL
Configure the OpenAI application SDK with base URL
http://127.0.0.1:18080/v1. For Anthropic, use the proxy origin with the SDK's
normal /v1/messages route; for Gemini, use its corresponding local generateContent
route. For Bedrock, use http://127.0.0.1:18080 as the Bedrock Runtime endpoint.
Use application-specific configuration or an invocation adapter; there is no
universal SDK environment variable.
Declare any SDK-required synthetic key in the blueprint's launch environment and
its credentials entries with accepted_by: model-proxy. The
customer-support recipe
shows this for OpenAI-compatible generation and embeddings. Interceptor replaces
synthetic authentication with real authentication only on the host.
Select model authentication
Choose one route-appropriate --provider-auth mode. Store authentication is
configured independently in the credential file.
--provider-auth |
Model providers | Additional options or host configuration |
|---|---|---|
secret-store or api-key |
All HTTP providers above | --credential-config FILE --model-credential-id ID. |
api-key-env |
All HTTP providers above | --model-api-key-env NAME; omit stored-credential options. The host variable contains the key. |
workload-token |
Anthropic | Use --credential-config FILE --model-credential-id ID for a bearer token. The administrator handles renewal. |
workload-identity |
Bedrock, Azure OpenAI, Vertex | Configured cloud workload identity; omit stored-key and environment-key options. |
aws-profile |
Bedrock | --aws-profile NAME --aws-region REGION. |
aws-environment |
Bedrock | Host AWS access-key pair and optional session token; use --aws-region REGION. |
google-adc |
Vertex | Explicit Google Application Default Credentials. |
azure-cli |
Azure OpenAI | Existing Azure CLI login available to the process. |
azure-client-secret |
Azure OpenAI | Host Azure tenant, client, and client-secret variables. |
none |
LiteLLM | Intentionally unauthenticated gateway; omit all credential options. |
Explicit environment-key selection also works with --production; implicit
environment-key fallback does not. Choose a mode explicitly so local development
and automation use the same credential source. Do not combine identity modes with
stored-key options. For example, Bedrock with an existing named AWS profile uses:
interceptor run --environment ./interceptor-environment \
--production \
--model-provider bedrock-converse \
--provider-auth aws-profile \
--aws-profile YOUR_AWS_PROFILE \
--aws-region us-east-1 \
--allow-model YOUR_BEDROCK_MODEL_OR_INFERENCE_PROFILE
For Vertex or Azure identity access, use the matching base URL from the provider
table, select google-adc, azure-cli, or the applicable workload mode, and omit
the key options. See host identity setup.
Configure embeddings independently
Generation configuration does not enable embeddings or supply their credentials.
Add the relevant option group to your complete interceptor run command.
For OpenAI-compatible embeddings with a stored API key:
--embeddings-provider openai-compatible \
--embeddings-base-url https://api.openai.com/v1 \
--embeddings-auth secret-store \
--embeddings-credential-config /absolute/private/credentials.yaml \
--embeddings-credential-id model-key \
--allow-embedding-model text-embedding-3-large
This explicitly reuses model-key; use a separate credential ID or file when
appropriate. Alternatives are --embeddings-auth api-key-env with
--embeddings-api-key-env NAME, or --embeddings-auth none for an intentionally
unauthenticated gateway. Omit stored-credential options for those alternatives.
The application uses the proxy's /v1/embeddings route with a synthetic key.
For native Amazon Titan text embeddings:
--embeddings-provider bedrock-titan \
--embeddings-auth aws-profile \
--embeddings-aws-profile YOUR_AWS_PROFILE \
--embeddings-aws-region us-east-1 \
--allow-embedding-model amazon.titan-embed-text-v2:0
Titan also accepts workload-identity or aws-environment; omit the profile option
for those modes. Do not supply HTTP endpoint or API-key options. Its AWS region and
profile are independent of generation. Configure the application's native Bedrock
Runtime client to use the proxy origin and declared synthetic AWS SDK credentials.
Repeat --allow-embedding-model for exact permitted identifiers on the compatible
route; the Titan route accepts the model shown above. Match the corpus and query
embedding model, dimensions, and normalization. Re-embed the corpus when changing
incompatible settings; equal vector dimensions do not establish compatibility.
The Quick start's support-agent recipe uses OpenAI-compatible embeddings and needs
corresponding application changes before switching to another embedding API.
Configure credential providers
Interceptor supports AWS Secrets Manager, Azure Key Vault, Google Cloud Secret Manager,
HashiCorp Vault KV v2, and 1Password. A profile selects a store and its permitted
secret locations; a credential reference gives a stored value a stable ID used
by --model-credential-id or --embeddings-credential-id. The model provider and
secret store can be in different clouds.
Create /absolute/private/credentials.yaml with the following structure. This
example reads a plain-text API key from AWS Secrets Manager through an explicit
host AWS profile. Replace the region, profile name, and secret location:
profiles:
- api_version: interceptor.dev/secret-store-profile/v1alpha1
kind: SecretStoreProfile
id: model-secrets
backend_kind: aws-secrets-manager
authentication: aws-profile
aws_profile: YOUR_AWS_PROFILE
region: us-east-1
allowed_locator_prefixes: [aws://us-east-1/simulation/model-key]
timeout_seconds: 10
max_value_bytes: 65536
max_cache_ttl_seconds: 300
credentials:
- api_version: interceptor.dev/host-credential-ref/v1alpha1
kind: HostCredentialRef
credential_id: model-key
store_profile_id: model-secrets
locator:
backend_kind: aws-secrets-manager
region: us-east-1
secret_id: simulation/model-key
version_stage: AWSCURRENT
value: {format: utf8}
cache_ttl_seconds: 30
This file contains references, never the API key itself. Protect it with mode 0600;
use regular files owned by the execution account or root, without symlinks. Use YAML
or JSON with the same structure. Both products accept either the
operator.dev or interceptor.dev credential schema namespace, so a private file
can be shared when the host accounts have the required access.
Backend fields and secret locations
To select another backend, retain the common schema, kind, IDs, limits, and value
selection above. Replace backend_kind in both the profile and locator, remove
fields belonging to the previous backend, and supply these fields:
| Backend | Profile fields | locator fields |
Example allowed prefix |
|---|---|---|---|
aws-secrets-manager |
region; authentication: workload-identity, aws-profile, or aws-environment; aws_profile only for named-profile access. |
Matching region, secret_id; optional version_id or version_stage. |
aws://us-east-1/simulation/ |
azure-key-vault |
HTTPS vault_url; authentication: workload-identity, azure-cli, or azure-client-secret. |
Matching vault_url, secret_name; optional version. |
https://YOUR_VAULT.vault.azure.net/secrets/simulation- |
gcp-secret-manager |
authentication: workload-identity or google-adc. |
project, secret_name, version such as latest. |
gcp://projects/YOUR_PROJECT/secrets/simulation- |
hashicorp-vault |
HTTPS vault_url; exactly one of vault_token_file or vault_proxy: true; optional vault_namespace, vault_ca_certificate. |
mount, path; optional version as a positive integer encoded as a string. |
vault://secret/simulation/ |
onepassword |
authentication: onepassword-desktop with onepassword_account, or onepassword-service-account without the account field. |
secret_reference: op://vault/item/[section/]field. |
op://simulation/ |
Cloud-store authentication defaults to workload identity, except that an explicit
aws_profile selects that profile when authentication is omitted. The locator
must match the backend and the configured AWS region or Azure vault. Allowlist
prefixes restrict selection; they do not grant access at the remote store.
For example, these are the replacement profile fields and locator for Google Secret Manager, merged into the same two records above:
# Fields in profiles[0]; remove region and aws_profile.
backend_kind: gcp-secret-manager
authentication: google-adc
allowed_locator_prefixes: [gcp://projects/YOUR_PROJECT/secrets/simulation-]
# Replace credentials[0].locator.
backend_kind: gcp-secret-manager
project: YOUR_PROJECT
secret_name: simulation-model-key
version: latest
Values, caching, and store access
Use value: {format: utf8} when the selected secret is the key itself. For a JSON
secret, select one top-level string with
value: {format: json-string-field, field: api_key}. Vault KV v2 requires this
explicit field selection. Binary values, empty keys, NUL, and line breaks in the
selected credential are rejected. The resolver reads secrets; it does not create,
rotate, list, or delete them.
timeout_seconds defaults to 10 and permits 1–60. max_value_bytes defaults to
65536 and permits at most 1048576. max_cache_ttl_seconds defaults to 300 and permits
up to 3600. A reference's cache_ttl_seconds defaults to zero (no caching) and cannot
exceed its profile's ceiling. A failed refresh does not fall back to a stale value.
Grant the chosen host identity only the access it needs:
| Store | Access and setup |
|---|---|
| AWS Secrets Manager | secretsmanager:GetSecretValue on the secret; customer-managed encryption keys may also require kms:Decrypt and an allowing key policy. |
| Azure Key Vault | Key Vault Secrets User, or secret Get under legacy access policies. Key Vault Reader alone cannot read values. |
| Google Secret Manager | Secret Manager Secret Accessor on the selected secret, an enabled Secret Manager API, and an enabled secret version. |
| Vault KV v2 | Read access to MOUNT/data/PATH through an already authenticated Agent or Proxy. |
| 1Password | Read access to the selected vault/item for the desktop account or service account. |
For Vault, vault_token_file names an absolute private token-sink file; it is reread
on uncached resolution. Alternatively, use an authenticating Proxy with
vault_proxy: true. The product does not perform Vault login. Keep TLS verification
enabled; vault_ca_certificate supplies a trusted certificate file when needed.
For 1Password desktop access, run as the signed-in desktop user, enable
Settings → Developer → Integrate with 1Password SDKs, and set
onepassword_account to the account name or UUID. For automation, select
onepassword-service-account and supply OP_SERVICE_ACCOUNT_TOKEN only to the host
process. No op CLI is required. References select one field; names or IDs are
accepted, and allowed prefixes must end on a component boundary with /.
Configure host identities
Run authentication setup as the account that will execute Interceptor. Model access and permission to read a secret are separate grants.
| Selection | Host prerequisites |
|---|---|
AWS workload-identity |
Web-identity token file and role, container role, or instance role. Shared AWS files are excluded. |
AWS aws-profile |
Explicit profile name; for SSO, run aws sso login --profile YOUR_AWS_PROFILE. |
AWS aws-environment |
AWS_ACCESS_KEY_ID, AWS_SECRET_ACCESS_KEY, and optionally AWS_SESSION_TOKEN in the host process. Shared profiles are ignored. |
Azure workload-identity |
Federated token file with AZURE_CLIENT_ID and AZURE_TENANT_ID, or managed identity. |
Azure azure-cli |
Existing az login session and az available on the process PATH. |
Azure azure-client-secret |
Host AZURE_TENANT_ID, AZURE_CLIENT_ID, and AZURE_CLIENT_SECRET. |
Google workload-identity |
Attached identity or external-account federation, including a configured GOOGLE_APPLICATION_CREDENTIALS file. |
Google google-adc |
Explicit Application Default Credentials; local setup uses gcloud auth application-default login, separately from gcloud auth login. |
AWS workload and named-profile modes reject static AWS credential environment
variables; choose aws-environment when using an exported access-key session.
For direct model access, grant Bedrock InvokeModel, Azure Cognitive Services
OpenAI User, or Vertex AI User/inference permission for the selected resource.
Google quota-project use can also require Service Usage Consumer.
In CI, AWS credential actions that export temporary keys use aws-environment;
Azure CLI login uses azure-cli; Google's federated credential file uses
workload-identity or google-adc. Keep the authenticated environment and files
available for the process lifetime. A detached service needs its own configured
account and environment and does not automatically inherit a terminal login.
Check credential access and model routing
A credential read can be checked separately from starting a sandbox or making a model call. With the host identity configured, use a new output path:
interceptor credentials check --live \
--credential-config /absolute/private/credentials.yaml \
--credential-id model-key \
--probe-id model-key-read \
--output /absolute/private/model-key-read.jsonl \
--timeout-seconds 30
This performs a real read from the selected store. Output records the result without the secret value. It does not prove model access. To check model routing, start the prepared target, perform a legitimate application operation, and inspect its output and model/embedding evidence as described in sessions and evidence.
Check failures against the chosen account, credential ID, allowed locator prefixes, store permissions, and model permissions. A generation credential does not enable embedding access. Stored-credential resolution writes a private host audit record; configuration and values are not included in public exports or blueprints.
Upstream references provide more detail on model routing and credential stores; choose the source tag matching your installed release.