使用密钥库进行身份验证

curl --fail-with-body -sS "http://localhost:38080/v1/vaults/$vault_id/credentials" \
  -H "x-api-key: $OMA_API_KEY" \
  -H "anthropic-version: 2023-06-01" \
  -H "anthropic-beta: managed-agents-2026-04-01" \
  -H "content-type: application/json" \
  --data @- <<'EOF'
{
  "display_name": "Linear API key",
  "auth": {
    "type": "static_bearer",
    "mcp_server_url": "https://mcp.linear.app/mcp",
    "token": "lin_api_your_linear_key"
  }
}
EOF

ant beta:vaults:credentials create --vault-id "$VAULT_ID" <<'YAML'
display_name: Linear API key
auth:
  type: static_bearer
  mcp_server_url: https://mcp.linear.app/mcp
  token: lin_api_your_linear_key
YAML

bearer_credential = client.beta.vaults.credentials.create(
    vault_id=vault.id,
    display_name="Linear API key",
    auth={
        "type": "static_bearer",
        "mcp_server_url": "https://mcp.linear.app/mcp",
        "token": "lin_api_your_linear_key",
    },
)

const bearerCredential = await client.beta.vaults.credentials.create(vault.id, {
  display_name: "Linear API key",
  auth: {
    type: "static_bearer",
    mcp_server_url: "https://mcp.linear.app/mcp",
    token: "lin_api_your_linear_key",
  },
});

var bearerCredential = await client.Beta.Vaults.Credentials.Create(vault.ID, new()
{
    DisplayName = "Linear API key",
    Auth = new BetaManagedAgentsStaticBearerCreateParams
    {
        Type = BetaManagedAgentsStaticBearerCreateParamsType.StaticBearer,
        McpServerUrl = "https://mcp.linear.app/mcp",
        Token = "lin_api_your_linear_key",
    },
});

bearerCredential, err := client.Beta.Vaults.Credentials.New(ctx, vault.ID, anthropic.BetaVaultCredentialNewParams{
    DisplayName: anthropic.String("Linear API key"),
    Auth: anthropic.BetaVaultCredentialNewParamsAuthUnion{
        OfStaticBearer: &anthropic.BetaManagedAgentsStaticBearerCreateParams{
            Type:         anthropic.BetaManagedAgentsStaticBearerCreateParamsTypeStaticBearer,
            MCPServerURL: "https://mcp.linear.app/mcp",
            Token:        "lin_api_your_linear_key",
        },
    },
})
if err != nil {
    panic(err)
}
_ = bearerCredential

var bearerCredential = client.beta().vaults().credentials().create(vault.id(),
    CredentialCreateParams.builder()
        .displayName("Linear API key")
        .auth(BetaManagedAgentsStaticBearerCreateParams.builder()
            .type(BetaManagedAgentsStaticBearerCreateParams.Type.STATIC_BEARER)
            .mcpServerUrl("https://mcp.linear.app/mcp")
            .token("lin_api_your_linear_key")
            .build())
        .build());

$bearerCredential = $client->beta->vaults->credentials->create(
    vaultID: $vault->id,
    displayName: 'Linear API key',
    auth: ManagedAgentsStaticBearerCreateParams::with(
        type: 'static_bearer',
        mcpServerURL: 'https://mcp.linear.app/mcp',
        token: 'lin_api_your_linear_key',
    ),
);

bearer_credential = client.beta.vaults.credentials.create(
  vault.id,
  display_name: "Linear API key",
  auth: {
    type: "static_bearer",
    mcp_server_url: "https://mcp.linear.app/mcp",
    token: "lin_api_your_linear_key"
  }
)

curl --fail-with-body -sS "http://localhost:38080/v1/vaults/$vault_id/credentials" \
  -H "x-api-key: $OMA_API_KEY" \
  -H "anthropic-version: 2023-06-01" \
  -H "anthropic-beta: managed-agents-2026-04-01" \
  -H "content-type: application/json" \
  --data @- <<'EOF' | jq '.auth.injection_location'
{
  "auth": {
    "type": "environment_variable",
    "secret_name": "NOTION_API_KEY",
    "secret_value": "ntn_your-secret-here",
    "networking": {
      "type": "limited",
      "allowed_hosts": ["api.notion.com"]
    },
    "injection_location": {"header": true}
  },
  "display_name": "Notion API key for sandbox"
}
EOF

ant beta:vaults:credentials create \
  --vault-id "$VAULT_ID" \
  --transform 'auth.injection_location' --format json <<'YAML'
display_name: Notion API key for sandbox
auth:
  type: environment_variable
  secret_name: NOTION_API_KEY
  secret_value: ntn_your-secret-here
  injection_location:
    header: true
  networking:
    type: limited
    allowed_hosts: [api.notion.com]
YAML

env_credential = client.beta.vaults.credentials.create(
    vault_id=vault.id,
    display_name="Notion API key for sandbox",
    auth={
        "type": "environment_variable",
        "secret_name": "NOTION_API_KEY",
        "secret_value": "ntn_your-secret-here",
        "networking": {
            "type": "limited",
            "allowed_hosts": ["api.notion.com"],
        },
        "injection_location": {"header": True},
    },
)
if env_credential.auth.type == "environment_variable":
    location = env_credential.auth.injection_location
    print(f"header: {location.header}, body: {location.body}")  # header: True, body: False

const envVarCredential = await client.beta.vaults.credentials.create(vault.id, {
  display_name: "Notion API key for sandbox",
  auth: {
    type: "environment_variable",
    secret_name: "NOTION_API_KEY",
    secret_value: "ntn_your-secret-here",
    networking: {
      type: "limited",
      allowed_hosts: ["api.notion.com"],
    },
    injection_location: { header: true },
  },
});
if (envVarCredential.auth.type === "environment_variable") {
  console.log(envVarCredential.auth.injection_location); // { header: true, body: false }
}

var envVarCredential = await client.Beta.Vaults.Credentials.Create(vault.ID, new()
{
    DisplayName = "Notion API key for sandbox",
    Auth = new BetaManagedAgentsEnvironmentVariableCreateParams
    {
        Type = BetaManagedAgentsEnvironmentVariableCreateParamsType.EnvironmentVariable,
        SecretName = "NOTION_API_KEY",
        SecretValue = "ntn_your-secret-here",
        Networking = new BetaManagedAgentsLimitedCredentialNetworkingParams
        {
            Type = BetaManagedAgentsLimitedCredentialNetworkingParamsType.Limited,
            AllowedHosts = ["api.notion.com"],
        },
        InjectionLocation = new() { Header = true },
    },
});
if (envVarCredential.Auth.TryPickBetaManagedAgentsEnvironmentVariableAuthResponse(out var envVarAuth))
{
    var injectionLocation = envVarAuth.InjectionLocation;
    Console.WriteLine($"Header: {injectionLocation.Header}, Body: {injectionLocation.Body}"); // "Header: True, Body: False"
}

envVarCredential, err := client.Beta.Vaults.Credentials.New(ctx, vault.ID, anthropic.BetaVaultCredentialNewParams{
    DisplayName: anthropic.String("Notion API key for sandbox"),
    Auth: anthropic.BetaVaultCredentialNewParamsAuthUnion{
        OfEnvironmentVariable: &anthropic.BetaManagedAgentsEnvironmentVariableCreateParams{
            Type:        anthropic.BetaManagedAgentsEnvironmentVariableCreateParamsTypeEnvironmentVariable,
            SecretName:  "NOTION_API_KEY",
            SecretValue: "ntn_your-secret-here",
            Networking: anthropic.BetaManagedAgentsCredentialNetworkingParamsUnion{
                OfLimited: &anthropic.BetaManagedAgentsLimitedCredentialNetworkingParams{
                    Type:         anthropic.BetaManagedAgentsLimitedCredentialNetworkingParamsTypeLimited,
                    AllowedHosts: []string{"api.notion.com"},
                },
            },
            InjectionLocation: anthropic.BetaManagedAgentsInjectionLocationParams{
                Header: anthropic.Bool(true),
            },
        },
    },
})
if err != nil {
    panic(err)
}
if envVarAuth, ok := envVarCredential.Auth.AsAny().(anthropic.BetaManagedAgentsEnvironmentVariableAuthResponse); ok {
    injectionLocation := envVarAuth.InjectionLocation
    fmt.Printf("Header:%t Body:%t\n", injectionLocation.Header, injectionLocation.Body) // "Header:true Body:false"
}

var envVarCredential = client.beta().vaults().credentials().create(vault.id(),
    CredentialCreateParams.builder()
        .displayName("Notion API key for sandbox")
        .auth(BetaManagedAgentsEnvironmentVariableCreateParams.builder()
            .type(BetaManagedAgentsEnvironmentVariableCreateParams.Type.ENVIRONMENT_VARIABLE)
            .secretName("NOTION_API_KEY")
            .secretValue("ntn_your-secret-here")
            .limitedNetworking(List.of("api.notion.com"))
            .injectionLocation(BetaManagedAgentsInjectionLocationParams.builder()
                .header(true)
                .build())
            .build())
        .build());
envVarCredential.auth().environmentVariable().ifPresent(envVarAuth -> {
    var injectionLocation = envVarAuth.injectionLocation();
    IO.println("header=" + injectionLocation.header() + " body=" + injectionLocation.body()); // header=true body=false
});

$envVarCredential = $client->beta->vaults->credentials->create(
    vaultID: $vault->id,
    displayName: 'Notion API key for sandbox',
    auth: ManagedAgentsEnvironmentVariableCreateParams::with(
        type: ManagedAgentsEnvironmentVariableCreateParams\Type::ENVIRONMENT_VARIABLE,
        secretName: 'NOTION_API_KEY',
        secretValue: 'ntn_your-secret-here',
        networking: ManagedAgentsLimitedCredentialNetworkingParams::with(
            type: ManagedAgentsLimitedCredentialNetworkingParams\Type::LIMITED,
            allowedHosts: ['api.notion.com'],
        ),
        injectionLocation: ManagedAgentsInjectionLocationParams::with(header: true),
    ),
);
if ($envVarCredential->auth instanceof ManagedAgentsEnvironmentVariableAuthResponse) {
    $injectionLocation = $envVarCredential->auth->injectionLocation;
    echo 'header: ' . json_encode($injectionLocation->header) . "\n"; // header: true
    echo 'body: ' . json_encode($injectionLocation->body) . "\n"; // body: false
}

env_credential = client.beta.vaults.credentials.create(
  vault.id,
  display_name: "Notion API key for sandbox",
  auth: {
    type: "environment_variable",
    secret_name: "NOTION_API_KEY",
    secret_value: "ntn_your-secret-here",
    networking: {
      type: "limited",
      allowed_hosts: ["api.notion.com"]
    },
    injection_location: {header: true}
  }
)
if env_credential.auth.type == :environment_variable
  env_credential.auth.injection_location => {header:, body:}
  puts "header: #{header}, body: #{body}" # header: true, body: false
end