diff --git a/.release-please-manifest.json b/.release-please-manifest.json
index f16e9b1ae..9a3ece4da 100644
--- a/.release-please-manifest.json
+++ b/.release-please-manifest.json
@@ -1,3 +1,3 @@
{
- ".": "1.32.0"
+ ".": "1.33.0"
}
diff --git a/.stats.yml b/.stats.yml
index f205c0359..2a72eef12 100644
--- a/.stats.yml
+++ b/.stats.yml
@@ -1,4 +1,4 @@
-configured_endpoints: 34
-openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/anthropic%2Fanthropic-04225437444990f383d0581df2f07022baab6ad510de0f3a8bd6b07c38d83cc9.yml
-openapi_spec_hash: cae9199aabfd7b87f0ff2dcc10760c92
-config_hash: fcc34074db6eaf64bc99b578c6c82c61
+configured_endpoints: 72
+openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/anthropic%2Fanthropic-69486316563eb49043ec1ef0b8e1d4164b6fadb58c7ae27477f9971448ede066.yml
+openapi_spec_hash: 24c3be07d605d11323afa51c7808fa00
+config_hash: 60af716d2229a28075dace69c52e5aa1
diff --git a/CHANGELOG.md b/CHANGELOG.md
index 2031df1d1..66a65e5a3 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -1,5 +1,13 @@
# Changelog
+## 1.33.0 (2026-04-08)
+
+Full Changelog: [v1.32.0...v1.33.0](https://github.com/anthropics/anthropic-sdk-go/compare/v1.32.0...v1.33.0)
+
+### Features
+
+* **api:** add support for Claude Managed Agents ([722b2ac](https://github.com/anthropics/anthropic-sdk-go/commit/722b2accb2ad73715639dd03339e14345304d5fc))
+
## 1.32.0 (2026-04-07)
Full Changelog: [v1.31.0...v1.32.0](https://github.com/anthropics/anthropic-sdk-go/compare/v1.31.0...v1.32.0)
diff --git a/README.md b/README.md
index ddd99e001..2b2afcfe8 100644
--- a/README.md
+++ b/README.md
@@ -29,7 +29,7 @@ Or explicitly add the dependency:
```sh
-go get -u 'github.com/anthropics/anthropic-sdk-go@v1.32.0'
+go get -u 'github.com/anthropics/anthropic-sdk-go@v1.33.0'
```
diff --git a/api.md b/api.md
index dda324941..5dea03d7c 100644
--- a/api.md
+++ b/api.md
@@ -518,10 +518,269 @@ Methods:
- client.Beta.Messages.Batches.Cancel(ctx context.Context, messageBatchID string, body anthropic.BetaMessageBatchCancelParams) (\*anthropic.BetaMessageBatch, error)
- client.Beta.Messages.Batches.Results(ctx context.Context, messageBatchID string, query anthropic.BetaMessageBatchResultsParams) (\*anthropic.BetaMessageBatchIndividualResponse, error)
+## Agents
+
+Params Types:
+
+- anthropic.BetaManagedAgentsAgentToolConfigParams
+- anthropic.BetaManagedAgentsAgentToolsetDefaultConfigParams
+- anthropic.BetaManagedAgentsAgentToolset20260401Params
+- anthropic.BetaManagedAgentsAlwaysAllowPolicyParam
+- anthropic.BetaManagedAgentsAlwaysAskPolicyParam
+- anthropic.BetaManagedAgentsAnthropicSkillParams
+- anthropic.BetaManagedAgentsCustomSkillParams
+- anthropic.BetaManagedAgentsCustomToolInputSchemaParam
+- anthropic.BetaManagedAgentsCustomToolParams
+- anthropic.BetaManagedAgentsMCPToolConfigParams
+- anthropic.BetaManagedAgentsMCPToolsetDefaultConfigParams
+- anthropic.BetaManagedAgentsMCPToolsetParams
+- anthropic.BetaManagedAgentsModel
+- anthropic.BetaManagedAgentsModelConfigParams
+- anthropic.BetaManagedAgentsSkillParamsUnion
+- anthropic.BetaManagedAgentsURLMCPServerParams
+
+Response Types:
+
+- anthropic.BetaManagedAgentsAgent
+- anthropic.BetaManagedAgentsAgentToolConfig
+- anthropic.BetaManagedAgentsAgentToolsetDefaultConfig
+- anthropic.BetaManagedAgentsAgentToolset20260401
+- anthropic.BetaManagedAgentsAlwaysAllowPolicy
+- anthropic.BetaManagedAgentsAlwaysAskPolicy
+- anthropic.BetaManagedAgentsAnthropicSkill
+- anthropic.BetaManagedAgentsCustomSkill
+- anthropic.BetaManagedAgentsCustomTool
+- anthropic.BetaManagedAgentsCustomToolInputSchema
+- anthropic.BetaManagedAgentsMCPServerURLDefinition
+- anthropic.BetaManagedAgentsMCPToolConfig
+- anthropic.BetaManagedAgentsMCPToolset
+- anthropic.BetaManagedAgentsMCPToolsetDefaultConfig
+- anthropic.BetaManagedAgentsModel
+- anthropic.BetaManagedAgentsModelConfig
+
+Methods:
+
+- client.Beta.Agents.New(ctx context.Context, params anthropic.BetaAgentNewParams) (\*anthropic.BetaManagedAgentsAgent, error)
+- client.Beta.Agents.Get(ctx context.Context, agentID string, params anthropic.BetaAgentGetParams) (\*anthropic.BetaManagedAgentsAgent, error)
+- client.Beta.Agents.Update(ctx context.Context, agentID string, params anthropic.BetaAgentUpdateParams) (\*anthropic.BetaManagedAgentsAgent, error)
+- client.Beta.Agents.List(ctx context.Context, params anthropic.BetaAgentListParams) (\*pagination.PageCursor[anthropic.BetaManagedAgentsAgent], error)
+- client.Beta.Agents.Archive(ctx context.Context, agentID string, body anthropic.BetaAgentArchiveParams) (\*anthropic.BetaManagedAgentsAgent, error)
+
+### Versions
+
+Methods:
+
+- client.Beta.Agents.Versions.List(ctx context.Context, agentID string, params anthropic.BetaAgentVersionListParams) (\*pagination.PageCursor[anthropic.BetaManagedAgentsAgent], error)
+
+## Environments
+
+Params Types:
+
+- anthropic.BetaCloudConfigParams
+- anthropic.BetaLimitedNetworkParams
+- anthropic.BetaPackagesParams
+- anthropic.BetaUnrestrictedNetworkParam
+
+Response Types:
+
+- anthropic.BetaCloudConfig
+- anthropic.BetaEnvironment
+- anthropic.BetaEnvironmentDeleteResponse
+- anthropic.BetaLimitedNetwork
+- anthropic.BetaPackages
+- anthropic.BetaUnrestrictedNetwork
+
+Methods:
+
+- client.Beta.Environments.New(ctx context.Context, params anthropic.BetaEnvironmentNewParams) (\*anthropic.BetaEnvironment, error)
+- client.Beta.Environments.Get(ctx context.Context, environmentID string, query anthropic.BetaEnvironmentGetParams) (\*anthropic.BetaEnvironment, error)
+- client.Beta.Environments.Update(ctx context.Context, environmentID string, params anthropic.BetaEnvironmentUpdateParams) (\*anthropic.BetaEnvironment, error)
+- client.Beta.Environments.List(ctx context.Context, params anthropic.BetaEnvironmentListParams) (\*pagination.PageCursor[anthropic.BetaEnvironment], error)
+- client.Beta.Environments.Delete(ctx context.Context, environmentID string, body anthropic.BetaEnvironmentDeleteParams) (\*anthropic.BetaEnvironmentDeleteResponse, error)
+- client.Beta.Environments.Archive(ctx context.Context, environmentID string, body anthropic.BetaEnvironmentArchiveParams) (\*anthropic.BetaEnvironment, error)
+
+## Sessions
+
+Params Types:
+
+- anthropic.BetaManagedAgentsAgentParams
+- anthropic.BetaManagedAgentsBranchCheckoutParam
+- anthropic.BetaManagedAgentsCommitCheckoutParam
+- anthropic.BetaManagedAgentsFileResourceParams
+- anthropic.BetaManagedAgentsGitHubRepositoryResourceParams
+
+Response Types:
+
+- anthropic.BetaManagedAgentsBranchCheckout
+- anthropic.BetaManagedAgentsCacheCreationUsage
+- anthropic.BetaManagedAgentsCommitCheckout
+- anthropic.BetaManagedAgentsDeletedSession
+- anthropic.BetaManagedAgentsSession
+- anthropic.BetaManagedAgentsSessionAgent
+- anthropic.BetaManagedAgentsSessionStats
+- anthropic.BetaManagedAgentsSessionUsage
+
+Methods:
+
+- client.Beta.Sessions.New(ctx context.Context, params anthropic.BetaSessionNewParams) (\*anthropic.BetaManagedAgentsSession, error)
+- client.Beta.Sessions.Get(ctx context.Context, sessionID string, query anthropic.BetaSessionGetParams) (\*anthropic.BetaManagedAgentsSession, error)
+- client.Beta.Sessions.Update(ctx context.Context, sessionID string, params anthropic.BetaSessionUpdateParams) (\*anthropic.BetaManagedAgentsSession, error)
+- client.Beta.Sessions.List(ctx context.Context, params anthropic.BetaSessionListParams) (\*pagination.PageCursor[anthropic.BetaManagedAgentsSession], error)
+- client.Beta.Sessions.Delete(ctx context.Context, sessionID string, body anthropic.BetaSessionDeleteParams) (\*anthropic.BetaManagedAgentsDeletedSession, error)
+- client.Beta.Sessions.Archive(ctx context.Context, sessionID string, body anthropic.BetaSessionArchiveParams) (\*anthropic.BetaManagedAgentsSession, error)
+
+### Events
+
+Params Types:
+
+- anthropic.BetaManagedAgentsBase64DocumentSourceParam
+- anthropic.BetaManagedAgentsBase64ImageSourceParam
+- anthropic.BetaManagedAgentsDocumentBlockParam
+- anthropic.BetaManagedAgentsEventParamsUnion
+- anthropic.BetaManagedAgentsFileDocumentSourceParam
+- anthropic.BetaManagedAgentsFileImageSourceParam
+- anthropic.BetaManagedAgentsImageBlockParam
+- anthropic.BetaManagedAgentsPlainTextDocumentSourceParam
+- anthropic.BetaManagedAgentsTextBlockParam
+- anthropic.BetaManagedAgentsURLDocumentSourceParam
+- anthropic.BetaManagedAgentsURLImageSourceParam
+- anthropic.BetaManagedAgentsUserCustomToolResultEventParams
+- anthropic.BetaManagedAgentsUserInterruptEventParams
+- anthropic.BetaManagedAgentsUserMessageEventParams
+- anthropic.BetaManagedAgentsUserToolConfirmationEventParams
+
+Response Types:
+
+- anthropic.BetaManagedAgentsAgentCustomToolUseEvent
+- anthropic.BetaManagedAgentsAgentMCPToolResultEvent
+- anthropic.BetaManagedAgentsAgentMCPToolUseEvent
+- anthropic.BetaManagedAgentsAgentMessageEvent
+- anthropic.BetaManagedAgentsAgentThinkingEvent
+- anthropic.BetaManagedAgentsAgentThreadContextCompactedEvent
+- anthropic.BetaManagedAgentsAgentToolResultEvent
+- anthropic.BetaManagedAgentsAgentToolUseEvent
+- anthropic.BetaManagedAgentsBase64DocumentSource
+- anthropic.BetaManagedAgentsBase64ImageSource
+- anthropic.BetaManagedAgentsBillingError
+- anthropic.BetaManagedAgentsDocumentBlock
+- anthropic.BetaManagedAgentsFileDocumentSource
+- anthropic.BetaManagedAgentsFileImageSource
+- anthropic.BetaManagedAgentsImageBlock
+- anthropic.BetaManagedAgentsMCPAuthenticationFailedError
+- anthropic.BetaManagedAgentsMCPConnectionFailedError
+- anthropic.BetaManagedAgentsModelOverloadedError
+- anthropic.BetaManagedAgentsModelRateLimitedError
+- anthropic.BetaManagedAgentsModelRequestFailedError
+- anthropic.BetaManagedAgentsPlainTextDocumentSource
+- anthropic.BetaManagedAgentsRetryStatusExhausted
+- anthropic.BetaManagedAgentsRetryStatusRetrying
+- anthropic.BetaManagedAgentsRetryStatusTerminal
+- anthropic.BetaManagedAgentsSendSessionEvents
+- anthropic.BetaManagedAgentsSessionDeletedEvent
+- anthropic.BetaManagedAgentsSessionEndTurn
+- anthropic.BetaManagedAgentsSessionErrorEvent
+- anthropic.BetaManagedAgentsSessionEventUnion
+- anthropic.BetaManagedAgentsSessionRequiresAction
+- anthropic.BetaManagedAgentsSessionRetriesExhausted
+- anthropic.BetaManagedAgentsSessionStatusIdleEvent
+- anthropic.BetaManagedAgentsSessionStatusRescheduledEvent
+- anthropic.BetaManagedAgentsSessionStatusRunningEvent
+- anthropic.BetaManagedAgentsSessionStatusTerminatedEvent
+- anthropic.BetaManagedAgentsSpanModelRequestEndEvent
+- anthropic.BetaManagedAgentsSpanModelRequestStartEvent
+- anthropic.BetaManagedAgentsSpanModelUsage
+- anthropic.BetaManagedAgentsStreamSessionEventsUnion
+- anthropic.BetaManagedAgentsTextBlock
+- anthropic.BetaManagedAgentsUnknownError
+- anthropic.BetaManagedAgentsURLDocumentSource
+- anthropic.BetaManagedAgentsURLImageSource
+- anthropic.BetaManagedAgentsUserCustomToolResultEvent
+- anthropic.BetaManagedAgentsUserInterruptEvent
+- anthropic.BetaManagedAgentsUserMessageEvent
+- anthropic.BetaManagedAgentsUserToolConfirmationEvent
+
+Methods:
+
+- client.Beta.Sessions.Events.List(ctx context.Context, sessionID string, params anthropic.BetaSessionEventListParams) (\*pagination.PageCursor[anthropic.BetaManagedAgentsSessionEventUnion], error)
+- client.Beta.Sessions.Events.Send(ctx context.Context, sessionID string, params anthropic.BetaSessionEventSendParams) (\*anthropic.BetaManagedAgentsSendSessionEvents, error)
+- client.Beta.Sessions.Events.Stream(ctx context.Context, sessionID string, query anthropic.BetaSessionEventStreamParams) (\*anthropic.BetaManagedAgentsStreamSessionEventsUnion, error)
+
+### Resources
+
+Response Types:
+
+- anthropic.BetaManagedAgentsDeleteSessionResource
+- anthropic.BetaManagedAgentsFileResource
+- anthropic.BetaManagedAgentsGitHubRepositoryResource
+- anthropic.BetaManagedAgentsSessionResourceUnion
+- anthropic.BetaSessionResourceGetResponseUnion
+- anthropic.BetaSessionResourceUpdateResponseUnion
+
+Methods:
+
+- client.Beta.Sessions.Resources.Get(ctx context.Context, resourceID string, params anthropic.BetaSessionResourceGetParams) (\*anthropic.BetaSessionResourceGetResponseUnion, error)
+- client.Beta.Sessions.Resources.Update(ctx context.Context, resourceID string, params anthropic.BetaSessionResourceUpdateParams) (\*anthropic.BetaSessionResourceUpdateResponseUnion, error)
+- client.Beta.Sessions.Resources.List(ctx context.Context, sessionID string, params anthropic.BetaSessionResourceListParams) (\*pagination.PageCursor[anthropic.BetaManagedAgentsSessionResourceUnion], error)
+- client.Beta.Sessions.Resources.Delete(ctx context.Context, resourceID string, params anthropic.BetaSessionResourceDeleteParams) (\*anthropic.BetaManagedAgentsDeleteSessionResource, error)
+- client.Beta.Sessions.Resources.Add(ctx context.Context, sessionID string, params anthropic.BetaSessionResourceAddParams) (\*anthropic.BetaManagedAgentsFileResource, error)
+
+## Vaults
+
+Response Types:
+
+- anthropic.BetaManagedAgentsDeletedVault
+- anthropic.BetaManagedAgentsVault
+
+Methods:
+
+- client.Beta.Vaults.New(ctx context.Context, params anthropic.BetaVaultNewParams) (\*anthropic.BetaManagedAgentsVault, error)
+- client.Beta.Vaults.Get(ctx context.Context, vaultID string, query anthropic.BetaVaultGetParams) (\*anthropic.BetaManagedAgentsVault, error)
+- client.Beta.Vaults.Update(ctx context.Context, vaultID string, params anthropic.BetaVaultUpdateParams) (\*anthropic.BetaManagedAgentsVault, error)
+- client.Beta.Vaults.List(ctx context.Context, params anthropic.BetaVaultListParams) (\*pagination.PageCursor[anthropic.BetaManagedAgentsVault], error)
+- client.Beta.Vaults.Delete(ctx context.Context, vaultID string, body anthropic.BetaVaultDeleteParams) (\*anthropic.BetaManagedAgentsDeletedVault, error)
+- client.Beta.Vaults.Archive(ctx context.Context, vaultID string, body anthropic.BetaVaultArchiveParams) (\*anthropic.BetaManagedAgentsVault, error)
+
+### Credentials
+
+Params Types:
+
+- anthropic.BetaManagedAgentsMCPOAuthCreateParams
+- anthropic.BetaManagedAgentsMCPOAuthRefreshParams
+- anthropic.BetaManagedAgentsMCPOAuthRefreshUpdateParams
+- anthropic.BetaManagedAgentsMCPOAuthUpdateParams
+- anthropic.BetaManagedAgentsStaticBearerCreateParams
+- anthropic.BetaManagedAgentsStaticBearerUpdateParams
+- anthropic.BetaManagedAgentsTokenEndpointAuthBasicParam
+- anthropic.BetaManagedAgentsTokenEndpointAuthBasicUpdateParam
+- anthropic.BetaManagedAgentsTokenEndpointAuthNoneParam
+- anthropic.BetaManagedAgentsTokenEndpointAuthPostParam
+- anthropic.BetaManagedAgentsTokenEndpointAuthPostUpdateParam
+
+Response Types:
+
+- anthropic.BetaManagedAgentsCredential
+- anthropic.BetaManagedAgentsDeletedCredential
+- anthropic.BetaManagedAgentsMCPOAuthAuthResponse
+- anthropic.BetaManagedAgentsMCPOAuthRefreshResponse
+- anthropic.BetaManagedAgentsStaticBearerAuthResponse
+- anthropic.BetaManagedAgentsTokenEndpointAuthBasicResponse
+- anthropic.BetaManagedAgentsTokenEndpointAuthNoneResponse
+- anthropic.BetaManagedAgentsTokenEndpointAuthPostResponse
+
+Methods:
+
+- client.Beta.Vaults.Credentials.New(ctx context.Context, vaultID string, params anthropic.BetaVaultCredentialNewParams) (\*anthropic.BetaManagedAgentsCredential, error)
+- client.Beta.Vaults.Credentials.Get(ctx context.Context, credentialID string, params anthropic.BetaVaultCredentialGetParams) (\*anthropic.BetaManagedAgentsCredential, error)
+- client.Beta.Vaults.Credentials.Update(ctx context.Context, credentialID string, params anthropic.BetaVaultCredentialUpdateParams) (\*anthropic.BetaManagedAgentsCredential, error)
+- client.Beta.Vaults.Credentials.List(ctx context.Context, vaultID string, params anthropic.BetaVaultCredentialListParams) (\*pagination.PageCursor[anthropic.BetaManagedAgentsCredential], error)
+- client.Beta.Vaults.Credentials.Delete(ctx context.Context, credentialID string, params anthropic.BetaVaultCredentialDeleteParams) (\*anthropic.BetaManagedAgentsDeletedCredential, error)
+- client.Beta.Vaults.Credentials.Archive(ctx context.Context, credentialID string, params anthropic.BetaVaultCredentialArchiveParams) (\*anthropic.BetaManagedAgentsCredential, error)
+
## Files
Response Types:
+- anthropic.BetaFileScope
- anthropic.DeletedFile
- anthropic.FileMetadata
diff --git a/beta.go b/beta.go
index d438ab704..7c91a88bd 100644
--- a/beta.go
+++ b/beta.go
@@ -18,11 +18,15 @@ import (
// automatically. You should not instantiate this service directly, and instead use
// the [NewBetaService] method instead.
type BetaService struct {
- Options []option.RequestOption
- Models BetaModelService
- Messages BetaMessageService
- Files BetaFileService
- Skills BetaSkillService
+ Options []option.RequestOption
+ Models BetaModelService
+ Messages BetaMessageService
+ Agents BetaAgentService
+ Environments BetaEnvironmentService
+ Sessions BetaSessionService
+ Vaults BetaVaultService
+ Files BetaFileService
+ Skills BetaSkillService
}
// NewBetaService generates a new service that applies the given options to each
@@ -33,6 +37,10 @@ func NewBetaService(opts ...option.RequestOption) (r BetaService) {
r.Options = opts
r.Models = NewBetaModelService(opts...)
r.Messages = NewBetaMessageService(opts...)
+ r.Agents = NewBetaAgentService(opts...)
+ r.Environments = NewBetaEnvironmentService(opts...)
+ r.Sessions = NewBetaSessionService(opts...)
+ r.Vaults = NewBetaVaultService(opts...)
r.Files = NewBetaFileService(opts...)
r.Skills = NewBetaSkillService(opts...)
return
diff --git a/betaagent.go b/betaagent.go
new file mode 100644
index 000000000..572c9ce26
--- /dev/null
+++ b/betaagent.go
@@ -0,0 +1,2209 @@
+// File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+package anthropic
+
+import (
+ "context"
+ "encoding/json"
+ "errors"
+ "fmt"
+ "net/http"
+ "net/url"
+ "slices"
+ "time"
+
+ "github.com/anthropics/anthropic-sdk-go/internal/apijson"
+ "github.com/anthropics/anthropic-sdk-go/internal/apiquery"
+ "github.com/anthropics/anthropic-sdk-go/internal/paramutil"
+ "github.com/anthropics/anthropic-sdk-go/internal/requestconfig"
+ "github.com/anthropics/anthropic-sdk-go/option"
+ "github.com/anthropics/anthropic-sdk-go/packages/pagination"
+ "github.com/anthropics/anthropic-sdk-go/packages/param"
+ "github.com/anthropics/anthropic-sdk-go/packages/respjson"
+)
+
+// BetaAgentService contains methods and other services that help with interacting
+// with the anthropic API.
+//
+// Note, unlike clients, this service does not read variables from the environment
+// automatically. You should not instantiate this service directly, and instead use
+// the [NewBetaAgentService] method instead.
+type BetaAgentService struct {
+ Options []option.RequestOption
+ Versions BetaAgentVersionService
+}
+
+// NewBetaAgentService generates a new service that applies the given options to
+// each request. These options are applied after the parent client's options (if
+// there is one), and before any request-specific options.
+func NewBetaAgentService(opts ...option.RequestOption) (r BetaAgentService) {
+ r = BetaAgentService{}
+ r.Options = opts
+ r.Versions = NewBetaAgentVersionService(opts...)
+ return
+}
+
+// Create Agent
+func (r *BetaAgentService) New(ctx context.Context, params BetaAgentNewParams, opts ...option.RequestOption) (res *BetaManagedAgentsAgent, err error) {
+ for _, v := range params.Betas {
+ opts = append(opts, option.WithHeaderAdd("anthropic-beta", fmt.Sprintf("%v", v)))
+ }
+ opts = slices.Concat(r.Options, opts)
+ opts = append([]option.RequestOption{option.WithHeader("anthropic-beta", "managed-agents-2026-04-01")}, opts...)
+ path := "v1/agents?beta=true"
+ err = requestconfig.ExecuteNewRequest(ctx, http.MethodPost, path, params, &res, opts...)
+ return res, err
+}
+
+// Get Agent
+func (r *BetaAgentService) Get(ctx context.Context, agentID string, params BetaAgentGetParams, opts ...option.RequestOption) (res *BetaManagedAgentsAgent, err error) {
+ for _, v := range params.Betas {
+ opts = append(opts, option.WithHeaderAdd("anthropic-beta", fmt.Sprintf("%v", v)))
+ }
+ opts = slices.Concat(r.Options, opts)
+ opts = append([]option.RequestOption{option.WithHeader("anthropic-beta", "managed-agents-2026-04-01")}, opts...)
+ if agentID == "" {
+ err = errors.New("missing required agent_id parameter")
+ return nil, err
+ }
+ path := fmt.Sprintf("v1/agents/%s?beta=true", agentID)
+ err = requestconfig.ExecuteNewRequest(ctx, http.MethodGet, path, params, &res, opts...)
+ return res, err
+}
+
+// Update Agent
+func (r *BetaAgentService) Update(ctx context.Context, agentID string, params BetaAgentUpdateParams, opts ...option.RequestOption) (res *BetaManagedAgentsAgent, err error) {
+ for _, v := range params.Betas {
+ opts = append(opts, option.WithHeaderAdd("anthropic-beta", fmt.Sprintf("%v", v)))
+ }
+ opts = slices.Concat(r.Options, opts)
+ opts = append([]option.RequestOption{option.WithHeader("anthropic-beta", "managed-agents-2026-04-01")}, opts...)
+ if agentID == "" {
+ err = errors.New("missing required agent_id parameter")
+ return nil, err
+ }
+ path := fmt.Sprintf("v1/agents/%s?beta=true", agentID)
+ err = requestconfig.ExecuteNewRequest(ctx, http.MethodPost, path, params, &res, opts...)
+ return res, err
+}
+
+// List Agents
+func (r *BetaAgentService) List(ctx context.Context, params BetaAgentListParams, opts ...option.RequestOption) (res *pagination.PageCursor[BetaManagedAgentsAgent], err error) {
+ var raw *http.Response
+ for _, v := range params.Betas {
+ opts = append(opts, option.WithHeaderAdd("anthropic-beta", fmt.Sprintf("%v", v)))
+ }
+ opts = slices.Concat(r.Options, opts)
+ opts = append([]option.RequestOption{option.WithHeader("anthropic-beta", "managed-agents-2026-04-01"), option.WithResponseInto(&raw)}, opts...)
+ path := "v1/agents?beta=true"
+ cfg, err := requestconfig.NewRequestConfig(ctx, http.MethodGet, path, params, &res, opts...)
+ if err != nil {
+ return nil, err
+ }
+ err = cfg.Execute()
+ if err != nil {
+ return nil, err
+ }
+ res.SetPageConfig(cfg, raw)
+ return res, nil
+}
+
+// List Agents
+func (r *BetaAgentService) ListAutoPaging(ctx context.Context, params BetaAgentListParams, opts ...option.RequestOption) *pagination.PageCursorAutoPager[BetaManagedAgentsAgent] {
+ return pagination.NewPageCursorAutoPager(r.List(ctx, params, opts...))
+}
+
+// Archive Agent
+func (r *BetaAgentService) Archive(ctx context.Context, agentID string, body BetaAgentArchiveParams, opts ...option.RequestOption) (res *BetaManagedAgentsAgent, err error) {
+ for _, v := range body.Betas {
+ opts = append(opts, option.WithHeaderAdd("anthropic-beta", fmt.Sprintf("%v", v)))
+ }
+ opts = slices.Concat(r.Options, opts)
+ opts = append([]option.RequestOption{option.WithHeader("anthropic-beta", "managed-agents-2026-04-01")}, opts...)
+ if agentID == "" {
+ err = errors.New("missing required agent_id parameter")
+ return nil, err
+ }
+ path := fmt.Sprintf("v1/agents/%s/archive?beta=true", agentID)
+ err = requestconfig.ExecuteNewRequest(ctx, http.MethodPost, path, nil, &res, opts...)
+ return res, err
+}
+
+// A Managed Agents `agent`.
+type BetaManagedAgentsAgent struct {
+ ID string `json:"id" api:"required"`
+ // A timestamp in RFC 3339 format
+ ArchivedAt time.Time `json:"archived_at" api:"required" format:"date-time"`
+ // A timestamp in RFC 3339 format
+ CreatedAt time.Time `json:"created_at" api:"required" format:"date-time"`
+ Description string `json:"description" api:"required"`
+ MCPServers []BetaManagedAgentsMCPServerURLDefinition `json:"mcp_servers" api:"required"`
+ Metadata map[string]string `json:"metadata" api:"required"`
+ // Model identifier and configuration.
+ Model BetaManagedAgentsModelConfig `json:"model" api:"required"`
+ Name string `json:"name" api:"required"`
+ Skills []BetaManagedAgentsAgentSkillUnion `json:"skills" api:"required"`
+ System string `json:"system" api:"required"`
+ Tools []BetaManagedAgentsAgentToolUnion `json:"tools" api:"required"`
+ // Any of "agent".
+ Type BetaManagedAgentsAgentType `json:"type" api:"required"`
+ // A timestamp in RFC 3339 format
+ UpdatedAt time.Time `json:"updated_at" api:"required" format:"date-time"`
+ // The agent's current version. Starts at 1 and increments when the agent is
+ // modified.
+ Version int64 `json:"version" api:"required"`
+ // JSON contains metadata for fields, check presence with [respjson.Field.Valid].
+ JSON struct {
+ ID respjson.Field
+ ArchivedAt respjson.Field
+ CreatedAt respjson.Field
+ Description respjson.Field
+ MCPServers respjson.Field
+ Metadata respjson.Field
+ Model respjson.Field
+ Name respjson.Field
+ Skills respjson.Field
+ System respjson.Field
+ Tools respjson.Field
+ Type respjson.Field
+ UpdatedAt respjson.Field
+ Version respjson.Field
+ ExtraFields map[string]respjson.Field
+ raw string
+ } `json:"-"`
+}
+
+// Returns the unmodified JSON received from the API
+func (r BetaManagedAgentsAgent) RawJSON() string { return r.JSON.raw }
+func (r *BetaManagedAgentsAgent) UnmarshalJSON(data []byte) error {
+ return apijson.UnmarshalRoot(data, r)
+}
+
+// BetaManagedAgentsAgentSkillUnion contains all possible properties and values
+// from [BetaManagedAgentsAnthropicSkill], [BetaManagedAgentsCustomSkill].
+//
+// Use the [BetaManagedAgentsAgentSkillUnion.AsAny] method to switch on the
+// variant.
+//
+// Use the methods beginning with 'As' to cast the union to one of its variants.
+type BetaManagedAgentsAgentSkillUnion struct {
+ SkillID string `json:"skill_id"`
+ // Any of "anthropic", "custom".
+ Type string `json:"type"`
+ Version string `json:"version"`
+ JSON struct {
+ SkillID respjson.Field
+ Type respjson.Field
+ Version respjson.Field
+ raw string
+ } `json:"-"`
+}
+
+// anyBetaManagedAgentsAgentSkill is implemented by each variant of
+// [BetaManagedAgentsAgentSkillUnion] to add type safety for the return type of
+// [BetaManagedAgentsAgentSkillUnion.AsAny]
+type anyBetaManagedAgentsAgentSkill interface {
+ implBetaManagedAgentsAgentSkillUnion()
+}
+
+func (BetaManagedAgentsAnthropicSkill) implBetaManagedAgentsAgentSkillUnion() {}
+func (BetaManagedAgentsCustomSkill) implBetaManagedAgentsAgentSkillUnion() {}
+
+// Use the following switch statement to find the correct variant
+//
+// switch variant := BetaManagedAgentsAgentSkillUnion.AsAny().(type) {
+// case anthropic.BetaManagedAgentsAnthropicSkill:
+// case anthropic.BetaManagedAgentsCustomSkill:
+// default:
+// fmt.Errorf("no variant present")
+// }
+func (u BetaManagedAgentsAgentSkillUnion) AsAny() anyBetaManagedAgentsAgentSkill {
+ switch u.Type {
+ case "anthropic":
+ return u.AsAnthropic()
+ case "custom":
+ return u.AsCustom()
+ }
+ return nil
+}
+
+func (u BetaManagedAgentsAgentSkillUnion) AsAnthropic() (v BetaManagedAgentsAnthropicSkill) {
+ apijson.UnmarshalRoot(json.RawMessage(u.JSON.raw), &v)
+ return
+}
+
+func (u BetaManagedAgentsAgentSkillUnion) AsCustom() (v BetaManagedAgentsCustomSkill) {
+ apijson.UnmarshalRoot(json.RawMessage(u.JSON.raw), &v)
+ return
+}
+
+// Returns the unmodified JSON received from the API
+func (u BetaManagedAgentsAgentSkillUnion) RawJSON() string { return u.JSON.raw }
+
+func (r *BetaManagedAgentsAgentSkillUnion) UnmarshalJSON(data []byte) error {
+ return apijson.UnmarshalRoot(data, r)
+}
+
+// BetaManagedAgentsAgentToolUnion contains all possible properties and values from
+// [BetaManagedAgentsAgentToolset20260401], [BetaManagedAgentsMCPToolset],
+// [BetaManagedAgentsCustomTool].
+//
+// Use the [BetaManagedAgentsAgentToolUnion.AsAny] method to switch on the variant.
+//
+// Use the methods beginning with 'As' to cast the union to one of its variants.
+type BetaManagedAgentsAgentToolUnion struct {
+ // This field is a union of [[]BetaManagedAgentsAgentToolConfig],
+ // [[]BetaManagedAgentsMCPToolConfig]
+ Configs BetaManagedAgentsAgentToolUnionConfigs `json:"configs"`
+ // This field is a union of [BetaManagedAgentsAgentToolsetDefaultConfig],
+ // [BetaManagedAgentsMCPToolsetDefaultConfig]
+ DefaultConfig BetaManagedAgentsAgentToolUnionDefaultConfig `json:"default_config"`
+ // Any of "agent_toolset_20260401", "mcp_toolset", "custom".
+ Type string `json:"type"`
+ // This field is from variant [BetaManagedAgentsMCPToolset].
+ MCPServerName string `json:"mcp_server_name"`
+ // This field is from variant [BetaManagedAgentsCustomTool].
+ Description string `json:"description"`
+ // This field is from variant [BetaManagedAgentsCustomTool].
+ InputSchema BetaManagedAgentsCustomToolInputSchema `json:"input_schema"`
+ // This field is from variant [BetaManagedAgentsCustomTool].
+ Name string `json:"name"`
+ JSON struct {
+ Configs respjson.Field
+ DefaultConfig respjson.Field
+ Type respjson.Field
+ MCPServerName respjson.Field
+ Description respjson.Field
+ InputSchema respjson.Field
+ Name respjson.Field
+ raw string
+ } `json:"-"`
+}
+
+// anyBetaManagedAgentsAgentTool is implemented by each variant of
+// [BetaManagedAgentsAgentToolUnion] to add type safety for the return type of
+// [BetaManagedAgentsAgentToolUnion.AsAny]
+type anyBetaManagedAgentsAgentTool interface {
+ implBetaManagedAgentsAgentToolUnion()
+}
+
+func (BetaManagedAgentsAgentToolset20260401) implBetaManagedAgentsAgentToolUnion() {}
+func (BetaManagedAgentsMCPToolset) implBetaManagedAgentsAgentToolUnion() {}
+func (BetaManagedAgentsCustomTool) implBetaManagedAgentsAgentToolUnion() {}
+
+// Use the following switch statement to find the correct variant
+//
+// switch variant := BetaManagedAgentsAgentToolUnion.AsAny().(type) {
+// case anthropic.BetaManagedAgentsAgentToolset20260401:
+// case anthropic.BetaManagedAgentsMCPToolset:
+// case anthropic.BetaManagedAgentsCustomTool:
+// default:
+// fmt.Errorf("no variant present")
+// }
+func (u BetaManagedAgentsAgentToolUnion) AsAny() anyBetaManagedAgentsAgentTool {
+ switch u.Type {
+ case "agent_toolset_20260401":
+ return u.AsAgentToolset20260401()
+ case "mcp_toolset":
+ return u.AsMCPToolset()
+ case "custom":
+ return u.AsCustom()
+ }
+ return nil
+}
+
+func (u BetaManagedAgentsAgentToolUnion) AsAgentToolset20260401() (v BetaManagedAgentsAgentToolset20260401) {
+ apijson.UnmarshalRoot(json.RawMessage(u.JSON.raw), &v)
+ return
+}
+
+func (u BetaManagedAgentsAgentToolUnion) AsMCPToolset() (v BetaManagedAgentsMCPToolset) {
+ apijson.UnmarshalRoot(json.RawMessage(u.JSON.raw), &v)
+ return
+}
+
+func (u BetaManagedAgentsAgentToolUnion) AsCustom() (v BetaManagedAgentsCustomTool) {
+ apijson.UnmarshalRoot(json.RawMessage(u.JSON.raw), &v)
+ return
+}
+
+// Returns the unmodified JSON received from the API
+func (u BetaManagedAgentsAgentToolUnion) RawJSON() string { return u.JSON.raw }
+
+func (r *BetaManagedAgentsAgentToolUnion) UnmarshalJSON(data []byte) error {
+ return apijson.UnmarshalRoot(data, r)
+}
+
+// BetaManagedAgentsAgentToolUnionConfigs is an implicit subunion of
+// [BetaManagedAgentsAgentToolUnion]. BetaManagedAgentsAgentToolUnionConfigs
+// provides convenient access to the sub-properties of the union.
+//
+// For type safety it is recommended to directly use a variant of the
+// [BetaManagedAgentsAgentToolUnion].
+//
+// If the underlying value is not a json object, one of the following properties
+// will be valid: OfBetaManagedAgentsAgentToolConfigArray
+// OfBetaManagedAgentsMCPToolConfigArray]
+type BetaManagedAgentsAgentToolUnionConfigs struct {
+ // This field will be present if the value is a
+ // [[]BetaManagedAgentsAgentToolConfig] instead of an object.
+ OfBetaManagedAgentsAgentToolConfigArray []BetaManagedAgentsAgentToolConfig `json:",inline"`
+ // This field will be present if the value is a [[]BetaManagedAgentsMCPToolConfig]
+ // instead of an object.
+ OfBetaManagedAgentsMCPToolConfigArray []BetaManagedAgentsMCPToolConfig `json:",inline"`
+ JSON struct {
+ OfBetaManagedAgentsAgentToolConfigArray respjson.Field
+ OfBetaManagedAgentsMCPToolConfigArray respjson.Field
+ raw string
+ } `json:"-"`
+}
+
+func (r *BetaManagedAgentsAgentToolUnionConfigs) UnmarshalJSON(data []byte) error {
+ return apijson.UnmarshalRoot(data, r)
+}
+
+// BetaManagedAgentsAgentToolUnionDefaultConfig is an implicit subunion of
+// [BetaManagedAgentsAgentToolUnion]. BetaManagedAgentsAgentToolUnionDefaultConfig
+// provides convenient access to the sub-properties of the union.
+//
+// For type safety it is recommended to directly use a variant of the
+// [BetaManagedAgentsAgentToolUnion].
+type BetaManagedAgentsAgentToolUnionDefaultConfig struct {
+ Enabled bool `json:"enabled"`
+ // This field is a union of
+ // [BetaManagedAgentsAgentToolsetDefaultConfigPermissionPolicyUnion],
+ // [BetaManagedAgentsMCPToolsetDefaultConfigPermissionPolicyUnion]
+ PermissionPolicy BetaManagedAgentsAgentToolUnionDefaultConfigPermissionPolicy `json:"permission_policy"`
+ JSON struct {
+ Enabled respjson.Field
+ PermissionPolicy respjson.Field
+ raw string
+ } `json:"-"`
+}
+
+func (r *BetaManagedAgentsAgentToolUnionDefaultConfig) UnmarshalJSON(data []byte) error {
+ return apijson.UnmarshalRoot(data, r)
+}
+
+// BetaManagedAgentsAgentToolUnionDefaultConfigPermissionPolicy is an implicit
+// subunion of [BetaManagedAgentsAgentToolUnion].
+// BetaManagedAgentsAgentToolUnionDefaultConfigPermissionPolicy provides convenient
+// access to the sub-properties of the union.
+//
+// For type safety it is recommended to directly use a variant of the
+// [BetaManagedAgentsAgentToolUnion].
+type BetaManagedAgentsAgentToolUnionDefaultConfigPermissionPolicy struct {
+ Type string `json:"type"`
+ JSON struct {
+ Type respjson.Field
+ raw string
+ } `json:"-"`
+}
+
+func (r *BetaManagedAgentsAgentToolUnionDefaultConfigPermissionPolicy) UnmarshalJSON(data []byte) error {
+ return apijson.UnmarshalRoot(data, r)
+}
+
+type BetaManagedAgentsAgentType string
+
+const (
+ BetaManagedAgentsAgentTypeAgent BetaManagedAgentsAgentType = "agent"
+)
+
+// Configuration for a specific agent tool.
+type BetaManagedAgentsAgentToolConfig struct {
+ Enabled bool `json:"enabled" api:"required"`
+ // Built-in agent tool identifier.
+ //
+ // Any of "bash", "edit", "read", "write", "glob", "grep", "web_fetch",
+ // "web_search".
+ Name BetaManagedAgentsAgentToolConfigName `json:"name" api:"required"`
+ // Permission policy for tool execution.
+ PermissionPolicy BetaManagedAgentsAgentToolConfigPermissionPolicyUnion `json:"permission_policy" api:"required"`
+ // JSON contains metadata for fields, check presence with [respjson.Field.Valid].
+ JSON struct {
+ Enabled respjson.Field
+ Name respjson.Field
+ PermissionPolicy respjson.Field
+ ExtraFields map[string]respjson.Field
+ raw string
+ } `json:"-"`
+}
+
+// Returns the unmodified JSON received from the API
+func (r BetaManagedAgentsAgentToolConfig) RawJSON() string { return r.JSON.raw }
+func (r *BetaManagedAgentsAgentToolConfig) UnmarshalJSON(data []byte) error {
+ return apijson.UnmarshalRoot(data, r)
+}
+
+// Built-in agent tool identifier.
+type BetaManagedAgentsAgentToolConfigName string
+
+const (
+ BetaManagedAgentsAgentToolConfigNameBash BetaManagedAgentsAgentToolConfigName = "bash"
+ BetaManagedAgentsAgentToolConfigNameEdit BetaManagedAgentsAgentToolConfigName = "edit"
+ BetaManagedAgentsAgentToolConfigNameRead BetaManagedAgentsAgentToolConfigName = "read"
+ BetaManagedAgentsAgentToolConfigNameWrite BetaManagedAgentsAgentToolConfigName = "write"
+ BetaManagedAgentsAgentToolConfigNameGlob BetaManagedAgentsAgentToolConfigName = "glob"
+ BetaManagedAgentsAgentToolConfigNameGrep BetaManagedAgentsAgentToolConfigName = "grep"
+ BetaManagedAgentsAgentToolConfigNameWebFetch BetaManagedAgentsAgentToolConfigName = "web_fetch"
+ BetaManagedAgentsAgentToolConfigNameWebSearch BetaManagedAgentsAgentToolConfigName = "web_search"
+)
+
+// BetaManagedAgentsAgentToolConfigPermissionPolicyUnion contains all possible
+// properties and values from [BetaManagedAgentsAlwaysAllowPolicy],
+// [BetaManagedAgentsAlwaysAskPolicy].
+//
+// Use the [BetaManagedAgentsAgentToolConfigPermissionPolicyUnion.AsAny] method to
+// switch on the variant.
+//
+// Use the methods beginning with 'As' to cast the union to one of its variants.
+type BetaManagedAgentsAgentToolConfigPermissionPolicyUnion struct {
+ // Any of "always_allow", "always_ask".
+ Type string `json:"type"`
+ JSON struct {
+ Type respjson.Field
+ raw string
+ } `json:"-"`
+}
+
+// anyBetaManagedAgentsAgentToolConfigPermissionPolicy is implemented by each
+// variant of [BetaManagedAgentsAgentToolConfigPermissionPolicyUnion] to add type
+// safety for the return type of
+// [BetaManagedAgentsAgentToolConfigPermissionPolicyUnion.AsAny]
+type anyBetaManagedAgentsAgentToolConfigPermissionPolicy interface {
+ implBetaManagedAgentsAgentToolConfigPermissionPolicyUnion()
+}
+
+func (BetaManagedAgentsAlwaysAllowPolicy) implBetaManagedAgentsAgentToolConfigPermissionPolicyUnion() {
+}
+func (BetaManagedAgentsAlwaysAskPolicy) implBetaManagedAgentsAgentToolConfigPermissionPolicyUnion() {}
+
+// Use the following switch statement to find the correct variant
+//
+// switch variant := BetaManagedAgentsAgentToolConfigPermissionPolicyUnion.AsAny().(type) {
+// case anthropic.BetaManagedAgentsAlwaysAllowPolicy:
+// case anthropic.BetaManagedAgentsAlwaysAskPolicy:
+// default:
+// fmt.Errorf("no variant present")
+// }
+func (u BetaManagedAgentsAgentToolConfigPermissionPolicyUnion) AsAny() anyBetaManagedAgentsAgentToolConfigPermissionPolicy {
+ switch u.Type {
+ case "always_allow":
+ return u.AsAlwaysAllow()
+ case "always_ask":
+ return u.AsAlwaysAsk()
+ }
+ return nil
+}
+
+func (u BetaManagedAgentsAgentToolConfigPermissionPolicyUnion) AsAlwaysAllow() (v BetaManagedAgentsAlwaysAllowPolicy) {
+ apijson.UnmarshalRoot(json.RawMessage(u.JSON.raw), &v)
+ return
+}
+
+func (u BetaManagedAgentsAgentToolConfigPermissionPolicyUnion) AsAlwaysAsk() (v BetaManagedAgentsAlwaysAskPolicy) {
+ apijson.UnmarshalRoot(json.RawMessage(u.JSON.raw), &v)
+ return
+}
+
+// Returns the unmodified JSON received from the API
+func (u BetaManagedAgentsAgentToolConfigPermissionPolicyUnion) RawJSON() string { return u.JSON.raw }
+
+func (r *BetaManagedAgentsAgentToolConfigPermissionPolicyUnion) UnmarshalJSON(data []byte) error {
+ return apijson.UnmarshalRoot(data, r)
+}
+
+// Configuration override for a specific tool within a toolset.
+//
+// The property Name is required.
+type BetaManagedAgentsAgentToolConfigParams struct {
+ // Built-in agent tool identifier.
+ //
+ // Any of "bash", "edit", "read", "write", "glob", "grep", "web_fetch",
+ // "web_search".
+ Name BetaManagedAgentsAgentToolConfigParamsName `json:"name,omitzero" api:"required"`
+ // Whether this tool is enabled and available to Claude. Overrides the
+ // default_config setting.
+ Enabled param.Opt[bool] `json:"enabled,omitzero"`
+ // Permission policy for tool execution.
+ PermissionPolicy BetaManagedAgentsAgentToolConfigParamsPermissionPolicyUnion `json:"permission_policy,omitzero"`
+ paramObj
+}
+
+func (r BetaManagedAgentsAgentToolConfigParams) MarshalJSON() (data []byte, err error) {
+ type shadow BetaManagedAgentsAgentToolConfigParams
+ return param.MarshalObject(r, (*shadow)(&r))
+}
+func (r *BetaManagedAgentsAgentToolConfigParams) UnmarshalJSON(data []byte) error {
+ return apijson.UnmarshalRoot(data, r)
+}
+
+// Built-in agent tool identifier.
+type BetaManagedAgentsAgentToolConfigParamsName string
+
+const (
+ BetaManagedAgentsAgentToolConfigParamsNameBash BetaManagedAgentsAgentToolConfigParamsName = "bash"
+ BetaManagedAgentsAgentToolConfigParamsNameEdit BetaManagedAgentsAgentToolConfigParamsName = "edit"
+ BetaManagedAgentsAgentToolConfigParamsNameRead BetaManagedAgentsAgentToolConfigParamsName = "read"
+ BetaManagedAgentsAgentToolConfigParamsNameWrite BetaManagedAgentsAgentToolConfigParamsName = "write"
+ BetaManagedAgentsAgentToolConfigParamsNameGlob BetaManagedAgentsAgentToolConfigParamsName = "glob"
+ BetaManagedAgentsAgentToolConfigParamsNameGrep BetaManagedAgentsAgentToolConfigParamsName = "grep"
+ BetaManagedAgentsAgentToolConfigParamsNameWebFetch BetaManagedAgentsAgentToolConfigParamsName = "web_fetch"
+ BetaManagedAgentsAgentToolConfigParamsNameWebSearch BetaManagedAgentsAgentToolConfigParamsName = "web_search"
+)
+
+// Only one field can be non-zero.
+//
+// Use [param.IsOmitted] to confirm if a field is set.
+type BetaManagedAgentsAgentToolConfigParamsPermissionPolicyUnion struct {
+ OfAlwaysAllow *BetaManagedAgentsAlwaysAllowPolicyParam `json:",omitzero,inline"`
+ OfAlwaysAsk *BetaManagedAgentsAlwaysAskPolicyParam `json:",omitzero,inline"`
+ paramUnion
+}
+
+func (u BetaManagedAgentsAgentToolConfigParamsPermissionPolicyUnion) MarshalJSON() ([]byte, error) {
+ return param.MarshalUnion(u, u.OfAlwaysAllow, u.OfAlwaysAsk)
+}
+func (u *BetaManagedAgentsAgentToolConfigParamsPermissionPolicyUnion) UnmarshalJSON(data []byte) error {
+ return apijson.UnmarshalRoot(data, u)
+}
+
+func (u *BetaManagedAgentsAgentToolConfigParamsPermissionPolicyUnion) asAny() any {
+ if !param.IsOmitted(u.OfAlwaysAllow) {
+ return u.OfAlwaysAllow
+ } else if !param.IsOmitted(u.OfAlwaysAsk) {
+ return u.OfAlwaysAsk
+ }
+ return nil
+}
+
+// Returns a pointer to the underlying variant's property, if present.
+func (u BetaManagedAgentsAgentToolConfigParamsPermissionPolicyUnion) GetType() *string {
+ if vt := u.OfAlwaysAllow; vt != nil {
+ return (*string)(&vt.Type)
+ } else if vt := u.OfAlwaysAsk; vt != nil {
+ return (*string)(&vt.Type)
+ }
+ return nil
+}
+
+func init() {
+ apijson.RegisterUnion[BetaManagedAgentsAgentToolConfigParamsPermissionPolicyUnion](
+ "type",
+ apijson.Discriminator[BetaManagedAgentsAlwaysAllowPolicyParam]("always_allow"),
+ apijson.Discriminator[BetaManagedAgentsAlwaysAskPolicyParam]("always_ask"),
+ )
+}
+
+// Resolved default configuration for agent tools.
+type BetaManagedAgentsAgentToolsetDefaultConfig struct {
+ Enabled bool `json:"enabled" api:"required"`
+ // Permission policy for tool execution.
+ PermissionPolicy BetaManagedAgentsAgentToolsetDefaultConfigPermissionPolicyUnion `json:"permission_policy" api:"required"`
+ // JSON contains metadata for fields, check presence with [respjson.Field.Valid].
+ JSON struct {
+ Enabled respjson.Field
+ PermissionPolicy respjson.Field
+ ExtraFields map[string]respjson.Field
+ raw string
+ } `json:"-"`
+}
+
+// Returns the unmodified JSON received from the API
+func (r BetaManagedAgentsAgentToolsetDefaultConfig) RawJSON() string { return r.JSON.raw }
+func (r *BetaManagedAgentsAgentToolsetDefaultConfig) UnmarshalJSON(data []byte) error {
+ return apijson.UnmarshalRoot(data, r)
+}
+
+// BetaManagedAgentsAgentToolsetDefaultConfigPermissionPolicyUnion contains all
+// possible properties and values from [BetaManagedAgentsAlwaysAllowPolicy],
+// [BetaManagedAgentsAlwaysAskPolicy].
+//
+// Use the [BetaManagedAgentsAgentToolsetDefaultConfigPermissionPolicyUnion.AsAny]
+// method to switch on the variant.
+//
+// Use the methods beginning with 'As' to cast the union to one of its variants.
+type BetaManagedAgentsAgentToolsetDefaultConfigPermissionPolicyUnion struct {
+ // Any of "always_allow", "always_ask".
+ Type string `json:"type"`
+ JSON struct {
+ Type respjson.Field
+ raw string
+ } `json:"-"`
+}
+
+// anyBetaManagedAgentsAgentToolsetDefaultConfigPermissionPolicy is implemented by
+// each variant of
+// [BetaManagedAgentsAgentToolsetDefaultConfigPermissionPolicyUnion] to add type
+// safety for the return type of
+// [BetaManagedAgentsAgentToolsetDefaultConfigPermissionPolicyUnion.AsAny]
+type anyBetaManagedAgentsAgentToolsetDefaultConfigPermissionPolicy interface {
+ implBetaManagedAgentsAgentToolsetDefaultConfigPermissionPolicyUnion()
+}
+
+func (BetaManagedAgentsAlwaysAllowPolicy) implBetaManagedAgentsAgentToolsetDefaultConfigPermissionPolicyUnion() {
+}
+func (BetaManagedAgentsAlwaysAskPolicy) implBetaManagedAgentsAgentToolsetDefaultConfigPermissionPolicyUnion() {
+}
+
+// Use the following switch statement to find the correct variant
+//
+// switch variant := BetaManagedAgentsAgentToolsetDefaultConfigPermissionPolicyUnion.AsAny().(type) {
+// case anthropic.BetaManagedAgentsAlwaysAllowPolicy:
+// case anthropic.BetaManagedAgentsAlwaysAskPolicy:
+// default:
+// fmt.Errorf("no variant present")
+// }
+func (u BetaManagedAgentsAgentToolsetDefaultConfigPermissionPolicyUnion) AsAny() anyBetaManagedAgentsAgentToolsetDefaultConfigPermissionPolicy {
+ switch u.Type {
+ case "always_allow":
+ return u.AsAlwaysAllow()
+ case "always_ask":
+ return u.AsAlwaysAsk()
+ }
+ return nil
+}
+
+func (u BetaManagedAgentsAgentToolsetDefaultConfigPermissionPolicyUnion) AsAlwaysAllow() (v BetaManagedAgentsAlwaysAllowPolicy) {
+ apijson.UnmarshalRoot(json.RawMessage(u.JSON.raw), &v)
+ return
+}
+
+func (u BetaManagedAgentsAgentToolsetDefaultConfigPermissionPolicyUnion) AsAlwaysAsk() (v BetaManagedAgentsAlwaysAskPolicy) {
+ apijson.UnmarshalRoot(json.RawMessage(u.JSON.raw), &v)
+ return
+}
+
+// Returns the unmodified JSON received from the API
+func (u BetaManagedAgentsAgentToolsetDefaultConfigPermissionPolicyUnion) RawJSON() string {
+ return u.JSON.raw
+}
+
+func (r *BetaManagedAgentsAgentToolsetDefaultConfigPermissionPolicyUnion) UnmarshalJSON(data []byte) error {
+ return apijson.UnmarshalRoot(data, r)
+}
+
+// Default configuration for all tools in a toolset.
+type BetaManagedAgentsAgentToolsetDefaultConfigParams struct {
+ // Whether tools are enabled and available to Claude by default. Defaults to true
+ // if not specified.
+ Enabled param.Opt[bool] `json:"enabled,omitzero"`
+ // Permission policy for tool execution.
+ PermissionPolicy BetaManagedAgentsAgentToolsetDefaultConfigParamsPermissionPolicyUnion `json:"permission_policy,omitzero"`
+ paramObj
+}
+
+func (r BetaManagedAgentsAgentToolsetDefaultConfigParams) MarshalJSON() (data []byte, err error) {
+ type shadow BetaManagedAgentsAgentToolsetDefaultConfigParams
+ return param.MarshalObject(r, (*shadow)(&r))
+}
+func (r *BetaManagedAgentsAgentToolsetDefaultConfigParams) UnmarshalJSON(data []byte) error {
+ return apijson.UnmarshalRoot(data, r)
+}
+
+// Only one field can be non-zero.
+//
+// Use [param.IsOmitted] to confirm if a field is set.
+type BetaManagedAgentsAgentToolsetDefaultConfigParamsPermissionPolicyUnion struct {
+ OfAlwaysAllow *BetaManagedAgentsAlwaysAllowPolicyParam `json:",omitzero,inline"`
+ OfAlwaysAsk *BetaManagedAgentsAlwaysAskPolicyParam `json:",omitzero,inline"`
+ paramUnion
+}
+
+func (u BetaManagedAgentsAgentToolsetDefaultConfigParamsPermissionPolicyUnion) MarshalJSON() ([]byte, error) {
+ return param.MarshalUnion(u, u.OfAlwaysAllow, u.OfAlwaysAsk)
+}
+func (u *BetaManagedAgentsAgentToolsetDefaultConfigParamsPermissionPolicyUnion) UnmarshalJSON(data []byte) error {
+ return apijson.UnmarshalRoot(data, u)
+}
+
+func (u *BetaManagedAgentsAgentToolsetDefaultConfigParamsPermissionPolicyUnion) asAny() any {
+ if !param.IsOmitted(u.OfAlwaysAllow) {
+ return u.OfAlwaysAllow
+ } else if !param.IsOmitted(u.OfAlwaysAsk) {
+ return u.OfAlwaysAsk
+ }
+ return nil
+}
+
+// Returns a pointer to the underlying variant's property, if present.
+func (u BetaManagedAgentsAgentToolsetDefaultConfigParamsPermissionPolicyUnion) GetType() *string {
+ if vt := u.OfAlwaysAllow; vt != nil {
+ return (*string)(&vt.Type)
+ } else if vt := u.OfAlwaysAsk; vt != nil {
+ return (*string)(&vt.Type)
+ }
+ return nil
+}
+
+func init() {
+ apijson.RegisterUnion[BetaManagedAgentsAgentToolsetDefaultConfigParamsPermissionPolicyUnion](
+ "type",
+ apijson.Discriminator[BetaManagedAgentsAlwaysAllowPolicyParam]("always_allow"),
+ apijson.Discriminator[BetaManagedAgentsAlwaysAskPolicyParam]("always_ask"),
+ )
+}
+
+type BetaManagedAgentsAgentToolset20260401 struct {
+ Configs []BetaManagedAgentsAgentToolConfig `json:"configs" api:"required"`
+ // Resolved default configuration for agent tools.
+ DefaultConfig BetaManagedAgentsAgentToolsetDefaultConfig `json:"default_config" api:"required"`
+ // Any of "agent_toolset_20260401".
+ Type BetaManagedAgentsAgentToolset20260401Type `json:"type" api:"required"`
+ // JSON contains metadata for fields, check presence with [respjson.Field.Valid].
+ JSON struct {
+ Configs respjson.Field
+ DefaultConfig respjson.Field
+ Type respjson.Field
+ ExtraFields map[string]respjson.Field
+ raw string
+ } `json:"-"`
+}
+
+// Returns the unmodified JSON received from the API
+func (r BetaManagedAgentsAgentToolset20260401) RawJSON() string { return r.JSON.raw }
+func (r *BetaManagedAgentsAgentToolset20260401) UnmarshalJSON(data []byte) error {
+ return apijson.UnmarshalRoot(data, r)
+}
+
+type BetaManagedAgentsAgentToolset20260401Type string
+
+const (
+ BetaManagedAgentsAgentToolset20260401TypeAgentToolset20260401 BetaManagedAgentsAgentToolset20260401Type = "agent_toolset_20260401"
+)
+
+// Configuration for built-in agent tools. Use this to enable or disable groups of
+// tools available to the agent.
+//
+// The property Type is required.
+type BetaManagedAgentsAgentToolset20260401Params struct {
+ // Any of "agent_toolset_20260401".
+ Type BetaManagedAgentsAgentToolset20260401ParamsType `json:"type,omitzero" api:"required"`
+ // Per-tool configuration overrides.
+ Configs []BetaManagedAgentsAgentToolConfigParams `json:"configs,omitzero"`
+ // Default configuration for all tools in a toolset.
+ DefaultConfig BetaManagedAgentsAgentToolsetDefaultConfigParams `json:"default_config,omitzero"`
+ paramObj
+}
+
+func (r BetaManagedAgentsAgentToolset20260401Params) MarshalJSON() (data []byte, err error) {
+ type shadow BetaManagedAgentsAgentToolset20260401Params
+ return param.MarshalObject(r, (*shadow)(&r))
+}
+func (r *BetaManagedAgentsAgentToolset20260401Params) UnmarshalJSON(data []byte) error {
+ return apijson.UnmarshalRoot(data, r)
+}
+
+type BetaManagedAgentsAgentToolset20260401ParamsType string
+
+const (
+ BetaManagedAgentsAgentToolset20260401ParamsTypeAgentToolset20260401 BetaManagedAgentsAgentToolset20260401ParamsType = "agent_toolset_20260401"
+)
+
+// Tool calls are automatically approved without user confirmation.
+type BetaManagedAgentsAlwaysAllowPolicy struct {
+ // Any of "always_allow".
+ Type BetaManagedAgentsAlwaysAllowPolicyType `json:"type" api:"required"`
+ // JSON contains metadata for fields, check presence with [respjson.Field.Valid].
+ JSON struct {
+ Type respjson.Field
+ ExtraFields map[string]respjson.Field
+ raw string
+ } `json:"-"`
+}
+
+// Returns the unmodified JSON received from the API
+func (r BetaManagedAgentsAlwaysAllowPolicy) RawJSON() string { return r.JSON.raw }
+func (r *BetaManagedAgentsAlwaysAllowPolicy) UnmarshalJSON(data []byte) error {
+ return apijson.UnmarshalRoot(data, r)
+}
+
+// ToParam converts this BetaManagedAgentsAlwaysAllowPolicy to a
+// BetaManagedAgentsAlwaysAllowPolicyParam.
+//
+// Warning: the fields of the param type will not be present. ToParam should only
+// be used at the last possible moment before sending a request. Test for this with
+// BetaManagedAgentsAlwaysAllowPolicyParam.Overrides()
+func (r BetaManagedAgentsAlwaysAllowPolicy) ToParam() BetaManagedAgentsAlwaysAllowPolicyParam {
+ return param.Override[BetaManagedAgentsAlwaysAllowPolicyParam](json.RawMessage(r.RawJSON()))
+}
+
+type BetaManagedAgentsAlwaysAllowPolicyType string
+
+const (
+ BetaManagedAgentsAlwaysAllowPolicyTypeAlwaysAllow BetaManagedAgentsAlwaysAllowPolicyType = "always_allow"
+)
+
+// Tool calls are automatically approved without user confirmation.
+//
+// The property Type is required.
+type BetaManagedAgentsAlwaysAllowPolicyParam struct {
+ // Any of "always_allow".
+ Type BetaManagedAgentsAlwaysAllowPolicyType `json:"type,omitzero" api:"required"`
+ paramObj
+}
+
+func (r BetaManagedAgentsAlwaysAllowPolicyParam) MarshalJSON() (data []byte, err error) {
+ type shadow BetaManagedAgentsAlwaysAllowPolicyParam
+ return param.MarshalObject(r, (*shadow)(&r))
+}
+func (r *BetaManagedAgentsAlwaysAllowPolicyParam) UnmarshalJSON(data []byte) error {
+ return apijson.UnmarshalRoot(data, r)
+}
+
+// Tool calls require user confirmation before execution.
+type BetaManagedAgentsAlwaysAskPolicy struct {
+ // Any of "always_ask".
+ Type BetaManagedAgentsAlwaysAskPolicyType `json:"type" api:"required"`
+ // JSON contains metadata for fields, check presence with [respjson.Field.Valid].
+ JSON struct {
+ Type respjson.Field
+ ExtraFields map[string]respjson.Field
+ raw string
+ } `json:"-"`
+}
+
+// Returns the unmodified JSON received from the API
+func (r BetaManagedAgentsAlwaysAskPolicy) RawJSON() string { return r.JSON.raw }
+func (r *BetaManagedAgentsAlwaysAskPolicy) UnmarshalJSON(data []byte) error {
+ return apijson.UnmarshalRoot(data, r)
+}
+
+// ToParam converts this BetaManagedAgentsAlwaysAskPolicy to a
+// BetaManagedAgentsAlwaysAskPolicyParam.
+//
+// Warning: the fields of the param type will not be present. ToParam should only
+// be used at the last possible moment before sending a request. Test for this with
+// BetaManagedAgentsAlwaysAskPolicyParam.Overrides()
+func (r BetaManagedAgentsAlwaysAskPolicy) ToParam() BetaManagedAgentsAlwaysAskPolicyParam {
+ return param.Override[BetaManagedAgentsAlwaysAskPolicyParam](json.RawMessage(r.RawJSON()))
+}
+
+type BetaManagedAgentsAlwaysAskPolicyType string
+
+const (
+ BetaManagedAgentsAlwaysAskPolicyTypeAlwaysAsk BetaManagedAgentsAlwaysAskPolicyType = "always_ask"
+)
+
+// Tool calls require user confirmation before execution.
+//
+// The property Type is required.
+type BetaManagedAgentsAlwaysAskPolicyParam struct {
+ // Any of "always_ask".
+ Type BetaManagedAgentsAlwaysAskPolicyType `json:"type,omitzero" api:"required"`
+ paramObj
+}
+
+func (r BetaManagedAgentsAlwaysAskPolicyParam) MarshalJSON() (data []byte, err error) {
+ type shadow BetaManagedAgentsAlwaysAskPolicyParam
+ return param.MarshalObject(r, (*shadow)(&r))
+}
+func (r *BetaManagedAgentsAlwaysAskPolicyParam) UnmarshalJSON(data []byte) error {
+ return apijson.UnmarshalRoot(data, r)
+}
+
+// A resolved Anthropic-managed skill.
+type BetaManagedAgentsAnthropicSkill struct {
+ SkillID string `json:"skill_id" api:"required"`
+ // Any of "anthropic".
+ Type BetaManagedAgentsAnthropicSkillType `json:"type" api:"required"`
+ Version string `json:"version" api:"required"`
+ // JSON contains metadata for fields, check presence with [respjson.Field.Valid].
+ JSON struct {
+ SkillID respjson.Field
+ Type respjson.Field
+ Version respjson.Field
+ ExtraFields map[string]respjson.Field
+ raw string
+ } `json:"-"`
+}
+
+// Returns the unmodified JSON received from the API
+func (r BetaManagedAgentsAnthropicSkill) RawJSON() string { return r.JSON.raw }
+func (r *BetaManagedAgentsAnthropicSkill) UnmarshalJSON(data []byte) error {
+ return apijson.UnmarshalRoot(data, r)
+}
+
+type BetaManagedAgentsAnthropicSkillType string
+
+const (
+ BetaManagedAgentsAnthropicSkillTypeAnthropic BetaManagedAgentsAnthropicSkillType = "anthropic"
+)
+
+// An Anthropic-managed skill.
+//
+// The properties SkillID, Type are required.
+type BetaManagedAgentsAnthropicSkillParams struct {
+ // Identifier of the Anthropic skill (e.g., "xlsx").
+ SkillID string `json:"skill_id" api:"required"`
+ // Any of "anthropic".
+ Type BetaManagedAgentsAnthropicSkillParamsType `json:"type,omitzero" api:"required"`
+ // Version to pin. Defaults to latest if omitted.
+ Version param.Opt[string] `json:"version,omitzero"`
+ paramObj
+}
+
+func (r BetaManagedAgentsAnthropicSkillParams) MarshalJSON() (data []byte, err error) {
+ type shadow BetaManagedAgentsAnthropicSkillParams
+ return param.MarshalObject(r, (*shadow)(&r))
+}
+func (r *BetaManagedAgentsAnthropicSkillParams) UnmarshalJSON(data []byte) error {
+ return apijson.UnmarshalRoot(data, r)
+}
+
+type BetaManagedAgentsAnthropicSkillParamsType string
+
+const (
+ BetaManagedAgentsAnthropicSkillParamsTypeAnthropic BetaManagedAgentsAnthropicSkillParamsType = "anthropic"
+)
+
+// A resolved user-created custom skill.
+type BetaManagedAgentsCustomSkill struct {
+ SkillID string `json:"skill_id" api:"required"`
+ // Any of "custom".
+ Type BetaManagedAgentsCustomSkillType `json:"type" api:"required"`
+ Version string `json:"version" api:"required"`
+ // JSON contains metadata for fields, check presence with [respjson.Field.Valid].
+ JSON struct {
+ SkillID respjson.Field
+ Type respjson.Field
+ Version respjson.Field
+ ExtraFields map[string]respjson.Field
+ raw string
+ } `json:"-"`
+}
+
+// Returns the unmodified JSON received from the API
+func (r BetaManagedAgentsCustomSkill) RawJSON() string { return r.JSON.raw }
+func (r *BetaManagedAgentsCustomSkill) UnmarshalJSON(data []byte) error {
+ return apijson.UnmarshalRoot(data, r)
+}
+
+type BetaManagedAgentsCustomSkillType string
+
+const (
+ BetaManagedAgentsCustomSkillTypeCustom BetaManagedAgentsCustomSkillType = "custom"
+)
+
+// A user-created custom skill.
+//
+// The properties SkillID, Type are required.
+type BetaManagedAgentsCustomSkillParams struct {
+ // Tagged ID of the custom skill (e.g., "skill_01XJ5...").
+ SkillID string `json:"skill_id" api:"required"`
+ // Any of "custom".
+ Type BetaManagedAgentsCustomSkillParamsType `json:"type,omitzero" api:"required"`
+ // Version to pin. Defaults to latest if omitted.
+ Version param.Opt[string] `json:"version,omitzero"`
+ paramObj
+}
+
+func (r BetaManagedAgentsCustomSkillParams) MarshalJSON() (data []byte, err error) {
+ type shadow BetaManagedAgentsCustomSkillParams
+ return param.MarshalObject(r, (*shadow)(&r))
+}
+func (r *BetaManagedAgentsCustomSkillParams) UnmarshalJSON(data []byte) error {
+ return apijson.UnmarshalRoot(data, r)
+}
+
+type BetaManagedAgentsCustomSkillParamsType string
+
+const (
+ BetaManagedAgentsCustomSkillParamsTypeCustom BetaManagedAgentsCustomSkillParamsType = "custom"
+)
+
+// A custom tool as returned in API responses.
+type BetaManagedAgentsCustomTool struct {
+ Description string `json:"description" api:"required"`
+ // JSON Schema for custom tool input parameters.
+ InputSchema BetaManagedAgentsCustomToolInputSchema `json:"input_schema" api:"required"`
+ Name string `json:"name" api:"required"`
+ // Any of "custom".
+ Type BetaManagedAgentsCustomToolType `json:"type" api:"required"`
+ // JSON contains metadata for fields, check presence with [respjson.Field.Valid].
+ JSON struct {
+ Description respjson.Field
+ InputSchema respjson.Field
+ Name respjson.Field
+ Type respjson.Field
+ ExtraFields map[string]respjson.Field
+ raw string
+ } `json:"-"`
+}
+
+// Returns the unmodified JSON received from the API
+func (r BetaManagedAgentsCustomTool) RawJSON() string { return r.JSON.raw }
+func (r *BetaManagedAgentsCustomTool) UnmarshalJSON(data []byte) error {
+ return apijson.UnmarshalRoot(data, r)
+}
+
+type BetaManagedAgentsCustomToolType string
+
+const (
+ BetaManagedAgentsCustomToolTypeCustom BetaManagedAgentsCustomToolType = "custom"
+)
+
+// JSON Schema for custom tool input parameters.
+type BetaManagedAgentsCustomToolInputSchema struct {
+ // JSON Schema properties defining the tool's input parameters.
+ Properties map[string]any `json:"properties" api:"nullable"`
+ // List of required property names.
+ Required []string `json:"required"`
+ // Must be 'object' for tool input schemas.
+ //
+ // Any of "object".
+ Type BetaManagedAgentsCustomToolInputSchemaType `json:"type"`
+ // JSON contains metadata for fields, check presence with [respjson.Field.Valid].
+ JSON struct {
+ Properties respjson.Field
+ Required respjson.Field
+ Type respjson.Field
+ ExtraFields map[string]respjson.Field
+ raw string
+ } `json:"-"`
+}
+
+// Returns the unmodified JSON received from the API
+func (r BetaManagedAgentsCustomToolInputSchema) RawJSON() string { return r.JSON.raw }
+func (r *BetaManagedAgentsCustomToolInputSchema) UnmarshalJSON(data []byte) error {
+ return apijson.UnmarshalRoot(data, r)
+}
+
+// ToParam converts this BetaManagedAgentsCustomToolInputSchema to a
+// BetaManagedAgentsCustomToolInputSchemaParam.
+//
+// Warning: the fields of the param type will not be present. ToParam should only
+// be used at the last possible moment before sending a request. Test for this with
+// BetaManagedAgentsCustomToolInputSchemaParam.Overrides()
+func (r BetaManagedAgentsCustomToolInputSchema) ToParam() BetaManagedAgentsCustomToolInputSchemaParam {
+ return param.Override[BetaManagedAgentsCustomToolInputSchemaParam](json.RawMessage(r.RawJSON()))
+}
+
+// Must be 'object' for tool input schemas.
+type BetaManagedAgentsCustomToolInputSchemaType string
+
+const (
+ BetaManagedAgentsCustomToolInputSchemaTypeObject BetaManagedAgentsCustomToolInputSchemaType = "object"
+)
+
+// JSON Schema for custom tool input parameters.
+type BetaManagedAgentsCustomToolInputSchemaParam struct {
+ // JSON Schema properties defining the tool's input parameters.
+ Properties map[string]any `json:"properties,omitzero"`
+ // List of required property names.
+ Required []string `json:"required,omitzero"`
+ // Must be 'object' for tool input schemas.
+ //
+ // Any of "object".
+ Type BetaManagedAgentsCustomToolInputSchemaType `json:"type,omitzero"`
+ paramObj
+}
+
+func (r BetaManagedAgentsCustomToolInputSchemaParam) MarshalJSON() (data []byte, err error) {
+ type shadow BetaManagedAgentsCustomToolInputSchemaParam
+ return param.MarshalObject(r, (*shadow)(&r))
+}
+func (r *BetaManagedAgentsCustomToolInputSchemaParam) UnmarshalJSON(data []byte) error {
+ return apijson.UnmarshalRoot(data, r)
+}
+
+// A custom tool that is executed by the API client rather than the agent. When the
+// agent calls this tool, an `agent.custom_tool_use` event is emitted and the
+// session goes idle, waiting for the client to provide the result via a
+// `user.custom_tool_result` event.
+//
+// The properties Description, InputSchema, Name, Type are required.
+type BetaManagedAgentsCustomToolParams struct {
+ // Description of what the tool does, shown to the agent to help it decide when to
+ // use the tool. 1-1024 characters.
+ Description string `json:"description" api:"required"`
+ // JSON Schema for custom tool input parameters.
+ InputSchema BetaManagedAgentsCustomToolInputSchemaParam `json:"input_schema,omitzero" api:"required"`
+ // Unique name for the tool. 1-128 characters; letters, digits, underscores, and
+ // hyphens.
+ Name string `json:"name" api:"required"`
+ // Any of "custom".
+ Type BetaManagedAgentsCustomToolParamsType `json:"type,omitzero" api:"required"`
+ paramObj
+}
+
+func (r BetaManagedAgentsCustomToolParams) MarshalJSON() (data []byte, err error) {
+ type shadow BetaManagedAgentsCustomToolParams
+ return param.MarshalObject(r, (*shadow)(&r))
+}
+func (r *BetaManagedAgentsCustomToolParams) UnmarshalJSON(data []byte) error {
+ return apijson.UnmarshalRoot(data, r)
+}
+
+type BetaManagedAgentsCustomToolParamsType string
+
+const (
+ BetaManagedAgentsCustomToolParamsTypeCustom BetaManagedAgentsCustomToolParamsType = "custom"
+)
+
+// URL-based MCP server connection as returned in API responses.
+type BetaManagedAgentsMCPServerURLDefinition struct {
+ Name string `json:"name" api:"required"`
+ // Any of "url".
+ Type BetaManagedAgentsMCPServerURLDefinitionType `json:"type" api:"required"`
+ URL string `json:"url" api:"required"`
+ // JSON contains metadata for fields, check presence with [respjson.Field.Valid].
+ JSON struct {
+ Name respjson.Field
+ Type respjson.Field
+ URL respjson.Field
+ ExtraFields map[string]respjson.Field
+ raw string
+ } `json:"-"`
+}
+
+// Returns the unmodified JSON received from the API
+func (r BetaManagedAgentsMCPServerURLDefinition) RawJSON() string { return r.JSON.raw }
+func (r *BetaManagedAgentsMCPServerURLDefinition) UnmarshalJSON(data []byte) error {
+ return apijson.UnmarshalRoot(data, r)
+}
+
+type BetaManagedAgentsMCPServerURLDefinitionType string
+
+const (
+ BetaManagedAgentsMCPServerURLDefinitionTypeURL BetaManagedAgentsMCPServerURLDefinitionType = "url"
+)
+
+// Resolved configuration for a specific MCP tool.
+type BetaManagedAgentsMCPToolConfig struct {
+ Enabled bool `json:"enabled" api:"required"`
+ Name string `json:"name" api:"required"`
+ // Permission policy for tool execution.
+ PermissionPolicy BetaManagedAgentsMCPToolConfigPermissionPolicyUnion `json:"permission_policy" api:"required"`
+ // JSON contains metadata for fields, check presence with [respjson.Field.Valid].
+ JSON struct {
+ Enabled respjson.Field
+ Name respjson.Field
+ PermissionPolicy respjson.Field
+ ExtraFields map[string]respjson.Field
+ raw string
+ } `json:"-"`
+}
+
+// Returns the unmodified JSON received from the API
+func (r BetaManagedAgentsMCPToolConfig) RawJSON() string { return r.JSON.raw }
+func (r *BetaManagedAgentsMCPToolConfig) UnmarshalJSON(data []byte) error {
+ return apijson.UnmarshalRoot(data, r)
+}
+
+// BetaManagedAgentsMCPToolConfigPermissionPolicyUnion contains all possible
+// properties and values from [BetaManagedAgentsAlwaysAllowPolicy],
+// [BetaManagedAgentsAlwaysAskPolicy].
+//
+// Use the [BetaManagedAgentsMCPToolConfigPermissionPolicyUnion.AsAny] method to
+// switch on the variant.
+//
+// Use the methods beginning with 'As' to cast the union to one of its variants.
+type BetaManagedAgentsMCPToolConfigPermissionPolicyUnion struct {
+ // Any of "always_allow", "always_ask".
+ Type string `json:"type"`
+ JSON struct {
+ Type respjson.Field
+ raw string
+ } `json:"-"`
+}
+
+// anyBetaManagedAgentsMCPToolConfigPermissionPolicy is implemented by each variant
+// of [BetaManagedAgentsMCPToolConfigPermissionPolicyUnion] to add type safety for
+// the return type of [BetaManagedAgentsMCPToolConfigPermissionPolicyUnion.AsAny]
+type anyBetaManagedAgentsMCPToolConfigPermissionPolicy interface {
+ implBetaManagedAgentsMCPToolConfigPermissionPolicyUnion()
+}
+
+func (BetaManagedAgentsAlwaysAllowPolicy) implBetaManagedAgentsMCPToolConfigPermissionPolicyUnion() {}
+func (BetaManagedAgentsAlwaysAskPolicy) implBetaManagedAgentsMCPToolConfigPermissionPolicyUnion() {}
+
+// Use the following switch statement to find the correct variant
+//
+// switch variant := BetaManagedAgentsMCPToolConfigPermissionPolicyUnion.AsAny().(type) {
+// case anthropic.BetaManagedAgentsAlwaysAllowPolicy:
+// case anthropic.BetaManagedAgentsAlwaysAskPolicy:
+// default:
+// fmt.Errorf("no variant present")
+// }
+func (u BetaManagedAgentsMCPToolConfigPermissionPolicyUnion) AsAny() anyBetaManagedAgentsMCPToolConfigPermissionPolicy {
+ switch u.Type {
+ case "always_allow":
+ return u.AsAlwaysAllow()
+ case "always_ask":
+ return u.AsAlwaysAsk()
+ }
+ return nil
+}
+
+func (u BetaManagedAgentsMCPToolConfigPermissionPolicyUnion) AsAlwaysAllow() (v BetaManagedAgentsAlwaysAllowPolicy) {
+ apijson.UnmarshalRoot(json.RawMessage(u.JSON.raw), &v)
+ return
+}
+
+func (u BetaManagedAgentsMCPToolConfigPermissionPolicyUnion) AsAlwaysAsk() (v BetaManagedAgentsAlwaysAskPolicy) {
+ apijson.UnmarshalRoot(json.RawMessage(u.JSON.raw), &v)
+ return
+}
+
+// Returns the unmodified JSON received from the API
+func (u BetaManagedAgentsMCPToolConfigPermissionPolicyUnion) RawJSON() string { return u.JSON.raw }
+
+func (r *BetaManagedAgentsMCPToolConfigPermissionPolicyUnion) UnmarshalJSON(data []byte) error {
+ return apijson.UnmarshalRoot(data, r)
+}
+
+// Configuration override for a specific MCP tool.
+//
+// The property Name is required.
+type BetaManagedAgentsMCPToolConfigParams struct {
+ // Name of the MCP tool to configure. 1-128 characters.
+ Name string `json:"name" api:"required"`
+ // Whether this tool is enabled. Overrides the `default_config` setting.
+ Enabled param.Opt[bool] `json:"enabled,omitzero"`
+ // Permission policy for tool execution.
+ PermissionPolicy BetaManagedAgentsMCPToolConfigParamsPermissionPolicyUnion `json:"permission_policy,omitzero"`
+ paramObj
+}
+
+func (r BetaManagedAgentsMCPToolConfigParams) MarshalJSON() (data []byte, err error) {
+ type shadow BetaManagedAgentsMCPToolConfigParams
+ return param.MarshalObject(r, (*shadow)(&r))
+}
+func (r *BetaManagedAgentsMCPToolConfigParams) UnmarshalJSON(data []byte) error {
+ return apijson.UnmarshalRoot(data, r)
+}
+
+// Only one field can be non-zero.
+//
+// Use [param.IsOmitted] to confirm if a field is set.
+type BetaManagedAgentsMCPToolConfigParamsPermissionPolicyUnion struct {
+ OfAlwaysAllow *BetaManagedAgentsAlwaysAllowPolicyParam `json:",omitzero,inline"`
+ OfAlwaysAsk *BetaManagedAgentsAlwaysAskPolicyParam `json:",omitzero,inline"`
+ paramUnion
+}
+
+func (u BetaManagedAgentsMCPToolConfigParamsPermissionPolicyUnion) MarshalJSON() ([]byte, error) {
+ return param.MarshalUnion(u, u.OfAlwaysAllow, u.OfAlwaysAsk)
+}
+func (u *BetaManagedAgentsMCPToolConfigParamsPermissionPolicyUnion) UnmarshalJSON(data []byte) error {
+ return apijson.UnmarshalRoot(data, u)
+}
+
+func (u *BetaManagedAgentsMCPToolConfigParamsPermissionPolicyUnion) asAny() any {
+ if !param.IsOmitted(u.OfAlwaysAllow) {
+ return u.OfAlwaysAllow
+ } else if !param.IsOmitted(u.OfAlwaysAsk) {
+ return u.OfAlwaysAsk
+ }
+ return nil
+}
+
+// Returns a pointer to the underlying variant's property, if present.
+func (u BetaManagedAgentsMCPToolConfigParamsPermissionPolicyUnion) GetType() *string {
+ if vt := u.OfAlwaysAllow; vt != nil {
+ return (*string)(&vt.Type)
+ } else if vt := u.OfAlwaysAsk; vt != nil {
+ return (*string)(&vt.Type)
+ }
+ return nil
+}
+
+func init() {
+ apijson.RegisterUnion[BetaManagedAgentsMCPToolConfigParamsPermissionPolicyUnion](
+ "type",
+ apijson.Discriminator[BetaManagedAgentsAlwaysAllowPolicyParam]("always_allow"),
+ apijson.Discriminator[BetaManagedAgentsAlwaysAskPolicyParam]("always_ask"),
+ )
+}
+
+type BetaManagedAgentsMCPToolset struct {
+ Configs []BetaManagedAgentsMCPToolConfig `json:"configs" api:"required"`
+ // Resolved default configuration for all tools from an MCP server.
+ DefaultConfig BetaManagedAgentsMCPToolsetDefaultConfig `json:"default_config" api:"required"`
+ MCPServerName string `json:"mcp_server_name" api:"required"`
+ // Any of "mcp_toolset".
+ Type BetaManagedAgentsMCPToolsetType `json:"type" api:"required"`
+ // JSON contains metadata for fields, check presence with [respjson.Field.Valid].
+ JSON struct {
+ Configs respjson.Field
+ DefaultConfig respjson.Field
+ MCPServerName respjson.Field
+ Type respjson.Field
+ ExtraFields map[string]respjson.Field
+ raw string
+ } `json:"-"`
+}
+
+// Returns the unmodified JSON received from the API
+func (r BetaManagedAgentsMCPToolset) RawJSON() string { return r.JSON.raw }
+func (r *BetaManagedAgentsMCPToolset) UnmarshalJSON(data []byte) error {
+ return apijson.UnmarshalRoot(data, r)
+}
+
+type BetaManagedAgentsMCPToolsetType string
+
+const (
+ BetaManagedAgentsMCPToolsetTypeMCPToolset BetaManagedAgentsMCPToolsetType = "mcp_toolset"
+)
+
+// Resolved default configuration for all tools from an MCP server.
+type BetaManagedAgentsMCPToolsetDefaultConfig struct {
+ Enabled bool `json:"enabled" api:"required"`
+ // Permission policy for tool execution.
+ PermissionPolicy BetaManagedAgentsMCPToolsetDefaultConfigPermissionPolicyUnion `json:"permission_policy" api:"required"`
+ // JSON contains metadata for fields, check presence with [respjson.Field.Valid].
+ JSON struct {
+ Enabled respjson.Field
+ PermissionPolicy respjson.Field
+ ExtraFields map[string]respjson.Field
+ raw string
+ } `json:"-"`
+}
+
+// Returns the unmodified JSON received from the API
+func (r BetaManagedAgentsMCPToolsetDefaultConfig) RawJSON() string { return r.JSON.raw }
+func (r *BetaManagedAgentsMCPToolsetDefaultConfig) UnmarshalJSON(data []byte) error {
+ return apijson.UnmarshalRoot(data, r)
+}
+
+// BetaManagedAgentsMCPToolsetDefaultConfigPermissionPolicyUnion contains all
+// possible properties and values from [BetaManagedAgentsAlwaysAllowPolicy],
+// [BetaManagedAgentsAlwaysAskPolicy].
+//
+// Use the [BetaManagedAgentsMCPToolsetDefaultConfigPermissionPolicyUnion.AsAny]
+// method to switch on the variant.
+//
+// Use the methods beginning with 'As' to cast the union to one of its variants.
+type BetaManagedAgentsMCPToolsetDefaultConfigPermissionPolicyUnion struct {
+ // Any of "always_allow", "always_ask".
+ Type string `json:"type"`
+ JSON struct {
+ Type respjson.Field
+ raw string
+ } `json:"-"`
+}
+
+// anyBetaManagedAgentsMCPToolsetDefaultConfigPermissionPolicy is implemented by
+// each variant of [BetaManagedAgentsMCPToolsetDefaultConfigPermissionPolicyUnion]
+// to add type safety for the return type of
+// [BetaManagedAgentsMCPToolsetDefaultConfigPermissionPolicyUnion.AsAny]
+type anyBetaManagedAgentsMCPToolsetDefaultConfigPermissionPolicy interface {
+ implBetaManagedAgentsMCPToolsetDefaultConfigPermissionPolicyUnion()
+}
+
+func (BetaManagedAgentsAlwaysAllowPolicy) implBetaManagedAgentsMCPToolsetDefaultConfigPermissionPolicyUnion() {
+}
+func (BetaManagedAgentsAlwaysAskPolicy) implBetaManagedAgentsMCPToolsetDefaultConfigPermissionPolicyUnion() {
+}
+
+// Use the following switch statement to find the correct variant
+//
+// switch variant := BetaManagedAgentsMCPToolsetDefaultConfigPermissionPolicyUnion.AsAny().(type) {
+// case anthropic.BetaManagedAgentsAlwaysAllowPolicy:
+// case anthropic.BetaManagedAgentsAlwaysAskPolicy:
+// default:
+// fmt.Errorf("no variant present")
+// }
+func (u BetaManagedAgentsMCPToolsetDefaultConfigPermissionPolicyUnion) AsAny() anyBetaManagedAgentsMCPToolsetDefaultConfigPermissionPolicy {
+ switch u.Type {
+ case "always_allow":
+ return u.AsAlwaysAllow()
+ case "always_ask":
+ return u.AsAlwaysAsk()
+ }
+ return nil
+}
+
+func (u BetaManagedAgentsMCPToolsetDefaultConfigPermissionPolicyUnion) AsAlwaysAllow() (v BetaManagedAgentsAlwaysAllowPolicy) {
+ apijson.UnmarshalRoot(json.RawMessage(u.JSON.raw), &v)
+ return
+}
+
+func (u BetaManagedAgentsMCPToolsetDefaultConfigPermissionPolicyUnion) AsAlwaysAsk() (v BetaManagedAgentsAlwaysAskPolicy) {
+ apijson.UnmarshalRoot(json.RawMessage(u.JSON.raw), &v)
+ return
+}
+
+// Returns the unmodified JSON received from the API
+func (u BetaManagedAgentsMCPToolsetDefaultConfigPermissionPolicyUnion) RawJSON() string {
+ return u.JSON.raw
+}
+
+func (r *BetaManagedAgentsMCPToolsetDefaultConfigPermissionPolicyUnion) UnmarshalJSON(data []byte) error {
+ return apijson.UnmarshalRoot(data, r)
+}
+
+// Default configuration for all tools from an MCP server.
+type BetaManagedAgentsMCPToolsetDefaultConfigParams struct {
+ // Whether tools are enabled by default. Defaults to true if not specified.
+ Enabled param.Opt[bool] `json:"enabled,omitzero"`
+ // Permission policy for tool execution.
+ PermissionPolicy BetaManagedAgentsMCPToolsetDefaultConfigParamsPermissionPolicyUnion `json:"permission_policy,omitzero"`
+ paramObj
+}
+
+func (r BetaManagedAgentsMCPToolsetDefaultConfigParams) MarshalJSON() (data []byte, err error) {
+ type shadow BetaManagedAgentsMCPToolsetDefaultConfigParams
+ return param.MarshalObject(r, (*shadow)(&r))
+}
+func (r *BetaManagedAgentsMCPToolsetDefaultConfigParams) UnmarshalJSON(data []byte) error {
+ return apijson.UnmarshalRoot(data, r)
+}
+
+// Only one field can be non-zero.
+//
+// Use [param.IsOmitted] to confirm if a field is set.
+type BetaManagedAgentsMCPToolsetDefaultConfigParamsPermissionPolicyUnion struct {
+ OfAlwaysAllow *BetaManagedAgentsAlwaysAllowPolicyParam `json:",omitzero,inline"`
+ OfAlwaysAsk *BetaManagedAgentsAlwaysAskPolicyParam `json:",omitzero,inline"`
+ paramUnion
+}
+
+func (u BetaManagedAgentsMCPToolsetDefaultConfigParamsPermissionPolicyUnion) MarshalJSON() ([]byte, error) {
+ return param.MarshalUnion(u, u.OfAlwaysAllow, u.OfAlwaysAsk)
+}
+func (u *BetaManagedAgentsMCPToolsetDefaultConfigParamsPermissionPolicyUnion) UnmarshalJSON(data []byte) error {
+ return apijson.UnmarshalRoot(data, u)
+}
+
+func (u *BetaManagedAgentsMCPToolsetDefaultConfigParamsPermissionPolicyUnion) asAny() any {
+ if !param.IsOmitted(u.OfAlwaysAllow) {
+ return u.OfAlwaysAllow
+ } else if !param.IsOmitted(u.OfAlwaysAsk) {
+ return u.OfAlwaysAsk
+ }
+ return nil
+}
+
+// Returns a pointer to the underlying variant's property, if present.
+func (u BetaManagedAgentsMCPToolsetDefaultConfigParamsPermissionPolicyUnion) GetType() *string {
+ if vt := u.OfAlwaysAllow; vt != nil {
+ return (*string)(&vt.Type)
+ } else if vt := u.OfAlwaysAsk; vt != nil {
+ return (*string)(&vt.Type)
+ }
+ return nil
+}
+
+func init() {
+ apijson.RegisterUnion[BetaManagedAgentsMCPToolsetDefaultConfigParamsPermissionPolicyUnion](
+ "type",
+ apijson.Discriminator[BetaManagedAgentsAlwaysAllowPolicyParam]("always_allow"),
+ apijson.Discriminator[BetaManagedAgentsAlwaysAskPolicyParam]("always_ask"),
+ )
+}
+
+// Configuration for tools from an MCP server defined in `mcp_servers`.
+//
+// The properties MCPServerName, Type are required.
+type BetaManagedAgentsMCPToolsetParams struct {
+ // Name of the MCP server. Must match a server name from the mcp_servers array.
+ // 1-255 characters.
+ MCPServerName string `json:"mcp_server_name" api:"required"`
+ // Any of "mcp_toolset".
+ Type BetaManagedAgentsMCPToolsetParamsType `json:"type,omitzero" api:"required"`
+ // Per-tool configuration overrides.
+ Configs []BetaManagedAgentsMCPToolConfigParams `json:"configs,omitzero"`
+ // Default configuration for all tools from an MCP server.
+ DefaultConfig BetaManagedAgentsMCPToolsetDefaultConfigParams `json:"default_config,omitzero"`
+ paramObj
+}
+
+func (r BetaManagedAgentsMCPToolsetParams) MarshalJSON() (data []byte, err error) {
+ type shadow BetaManagedAgentsMCPToolsetParams
+ return param.MarshalObject(r, (*shadow)(&r))
+}
+func (r *BetaManagedAgentsMCPToolsetParams) UnmarshalJSON(data []byte) error {
+ return apijson.UnmarshalRoot(data, r)
+}
+
+type BetaManagedAgentsMCPToolsetParamsType string
+
+const (
+ BetaManagedAgentsMCPToolsetParamsTypeMCPToolset BetaManagedAgentsMCPToolsetParamsType = "mcp_toolset"
+)
+
+// The model that will power your agent.\n\nSee
+// [models](https://docs.anthropic.com/en/docs/models-overview) for additional
+// details and options.
+type BetaManagedAgentsModel = string
+
+const (
+ BetaManagedAgentsModelClaudeOpus4_6 BetaManagedAgentsModel = "claude-opus-4-6"
+ BetaManagedAgentsModelClaudeSonnet4_6 BetaManagedAgentsModel = "claude-sonnet-4-6"
+ BetaManagedAgentsModelClaudeHaiku4_5 BetaManagedAgentsModel = "claude-haiku-4-5"
+ BetaManagedAgentsModelClaudeHaiku4_5_20251001 BetaManagedAgentsModel = "claude-haiku-4-5-20251001"
+ BetaManagedAgentsModelClaudeOpus4_5 BetaManagedAgentsModel = "claude-opus-4-5"
+ BetaManagedAgentsModelClaudeOpus4_5_20251101 BetaManagedAgentsModel = "claude-opus-4-5-20251101"
+ BetaManagedAgentsModelClaudeSonnet4_5 BetaManagedAgentsModel = "claude-sonnet-4-5"
+ BetaManagedAgentsModelClaudeSonnet4_5_20250929 BetaManagedAgentsModel = "claude-sonnet-4-5-20250929"
+)
+
+// Model identifier and configuration.
+type BetaManagedAgentsModelConfig struct {
+ // The model that will power your agent.\n\nSee
+ // [models](https://docs.anthropic.com/en/docs/models-overview) for additional
+ // details and options.
+ ID BetaManagedAgentsModel `json:"id" api:"required"`
+ // Inference speed mode. `fast` provides significantly faster output token
+ // generation at premium pricing. Not all models support `fast`; invalid
+ // combinations are rejected at create time.
+ //
+ // Any of "standard", "fast".
+ Speed BetaManagedAgentsModelConfigSpeed `json:"speed"`
+ // JSON contains metadata for fields, check presence with [respjson.Field.Valid].
+ JSON struct {
+ ID respjson.Field
+ Speed respjson.Field
+ ExtraFields map[string]respjson.Field
+ raw string
+ } `json:"-"`
+}
+
+// Returns the unmodified JSON received from the API
+func (r BetaManagedAgentsModelConfig) RawJSON() string { return r.JSON.raw }
+func (r *BetaManagedAgentsModelConfig) UnmarshalJSON(data []byte) error {
+ return apijson.UnmarshalRoot(data, r)
+}
+
+// Inference speed mode. `fast` provides significantly faster output token
+// generation at premium pricing. Not all models support `fast`; invalid
+// combinations are rejected at create time.
+type BetaManagedAgentsModelConfigSpeed string
+
+const (
+ BetaManagedAgentsModelConfigSpeedStandard BetaManagedAgentsModelConfigSpeed = "standard"
+ BetaManagedAgentsModelConfigSpeedFast BetaManagedAgentsModelConfigSpeed = "fast"
+)
+
+// An object that defines additional configuration control over model use
+//
+// The property ID is required.
+type BetaManagedAgentsModelConfigParams struct {
+ // The model that will power your agent.\n\nSee
+ // [models](https://docs.anthropic.com/en/docs/models-overview) for additional
+ // details and options.
+ ID BetaManagedAgentsModel `json:"id,omitzero" api:"required"`
+ // Inference speed mode. `fast` provides significantly faster output token
+ // generation at premium pricing. Not all models support `fast`; invalid
+ // combinations are rejected at create time.
+ //
+ // Any of "standard", "fast".
+ Speed BetaManagedAgentsModelConfigParamsSpeed `json:"speed,omitzero"`
+ paramObj
+}
+
+func (r BetaManagedAgentsModelConfigParams) MarshalJSON() (data []byte, err error) {
+ type shadow BetaManagedAgentsModelConfigParams
+ return param.MarshalObject(r, (*shadow)(&r))
+}
+func (r *BetaManagedAgentsModelConfigParams) UnmarshalJSON(data []byte) error {
+ return apijson.UnmarshalRoot(data, r)
+}
+
+// Inference speed mode. `fast` provides significantly faster output token
+// generation at premium pricing. Not all models support `fast`; invalid
+// combinations are rejected at create time.
+type BetaManagedAgentsModelConfigParamsSpeed string
+
+const (
+ BetaManagedAgentsModelConfigParamsSpeedStandard BetaManagedAgentsModelConfigParamsSpeed = "standard"
+ BetaManagedAgentsModelConfigParamsSpeedFast BetaManagedAgentsModelConfigParamsSpeed = "fast"
+)
+
+func BetaManagedAgentsSkillParamsOfAnthropic(skillID string) BetaManagedAgentsSkillParamsUnion {
+ var anthropic BetaManagedAgentsAnthropicSkillParams
+ anthropic.SkillID = skillID
+ return BetaManagedAgentsSkillParamsUnion{OfAnthropic: &anthropic}
+}
+
+func BetaManagedAgentsSkillParamsOfCustom(skillID string) BetaManagedAgentsSkillParamsUnion {
+ var custom BetaManagedAgentsCustomSkillParams
+ custom.SkillID = skillID
+ return BetaManagedAgentsSkillParamsUnion{OfCustom: &custom}
+}
+
+// Only one field can be non-zero.
+//
+// Use [param.IsOmitted] to confirm if a field is set.
+type BetaManagedAgentsSkillParamsUnion struct {
+ OfAnthropic *BetaManagedAgentsAnthropicSkillParams `json:",omitzero,inline"`
+ OfCustom *BetaManagedAgentsCustomSkillParams `json:",omitzero,inline"`
+ paramUnion
+}
+
+func (u BetaManagedAgentsSkillParamsUnion) MarshalJSON() ([]byte, error) {
+ return param.MarshalUnion(u, u.OfAnthropic, u.OfCustom)
+}
+func (u *BetaManagedAgentsSkillParamsUnion) UnmarshalJSON(data []byte) error {
+ return apijson.UnmarshalRoot(data, u)
+}
+
+func (u *BetaManagedAgentsSkillParamsUnion) asAny() any {
+ if !param.IsOmitted(u.OfAnthropic) {
+ return u.OfAnthropic
+ } else if !param.IsOmitted(u.OfCustom) {
+ return u.OfCustom
+ }
+ return nil
+}
+
+// Returns a pointer to the underlying variant's property, if present.
+func (u BetaManagedAgentsSkillParamsUnion) GetSkillID() *string {
+ if vt := u.OfAnthropic; vt != nil {
+ return (*string)(&vt.SkillID)
+ } else if vt := u.OfCustom; vt != nil {
+ return (*string)(&vt.SkillID)
+ }
+ return nil
+}
+
+// Returns a pointer to the underlying variant's property, if present.
+func (u BetaManagedAgentsSkillParamsUnion) GetType() *string {
+ if vt := u.OfAnthropic; vt != nil {
+ return (*string)(&vt.Type)
+ } else if vt := u.OfCustom; vt != nil {
+ return (*string)(&vt.Type)
+ }
+ return nil
+}
+
+// Returns a pointer to the underlying variant's property, if present.
+func (u BetaManagedAgentsSkillParamsUnion) GetVersion() *string {
+ if vt := u.OfAnthropic; vt != nil && vt.Version.Valid() {
+ return &vt.Version.Value
+ } else if vt := u.OfCustom; vt != nil && vt.Version.Valid() {
+ return &vt.Version.Value
+ }
+ return nil
+}
+
+func init() {
+ apijson.RegisterUnion[BetaManagedAgentsSkillParamsUnion](
+ "type",
+ apijson.Discriminator[BetaManagedAgentsAnthropicSkillParams]("anthropic"),
+ apijson.Discriminator[BetaManagedAgentsCustomSkillParams]("custom"),
+ )
+}
+
+// URL-based MCP server connection.
+//
+// The properties Name, Type, URL are required.
+type BetaManagedAgentsURLMCPServerParams struct {
+ // Unique name for this server, referenced by mcp_toolset configurations. 1-255
+ // characters.
+ Name string `json:"name" api:"required"`
+ // Any of "url".
+ Type BetaManagedAgentsURLMCPServerParamsType `json:"type,omitzero" api:"required"`
+ // Endpoint URL for the MCP server.
+ URL string `json:"url" api:"required"`
+ paramObj
+}
+
+func (r BetaManagedAgentsURLMCPServerParams) MarshalJSON() (data []byte, err error) {
+ type shadow BetaManagedAgentsURLMCPServerParams
+ return param.MarshalObject(r, (*shadow)(&r))
+}
+func (r *BetaManagedAgentsURLMCPServerParams) UnmarshalJSON(data []byte) error {
+ return apijson.UnmarshalRoot(data, r)
+}
+
+type BetaManagedAgentsURLMCPServerParamsType string
+
+const (
+ BetaManagedAgentsURLMCPServerParamsTypeURL BetaManagedAgentsURLMCPServerParamsType = "url"
+)
+
+type BetaAgentNewParams struct {
+ // Model identifier. Accepts the
+ // [model string](https://platform.claude.com/docs/en/about-claude/models/overview#latest-models-comparison),
+ // e.g. `claude-opus-4-6`, or a `model_config` object for additional configuration
+ // control
+ Model BetaManagedAgentsModelConfigParams `json:"model,omitzero" api:"required"`
+ // Human-readable name for the agent. 1-256 characters.
+ Name string `json:"name" api:"required"`
+ // Description of what the agent does. Up to 2048 characters.
+ Description param.Opt[string] `json:"description,omitzero"`
+ // System prompt for the agent. Up to 100,000 characters.
+ System param.Opt[string] `json:"system,omitzero"`
+ // MCP servers this agent connects to. Maximum 20. Names must be unique within the
+ // array.
+ MCPServers []BetaManagedAgentsURLMCPServerParams `json:"mcp_servers,omitzero"`
+ // Arbitrary key-value metadata. Maximum 16 pairs, keys up to 64 chars, values up
+ // to 512 chars.
+ Metadata map[string]string `json:"metadata,omitzero"`
+ // Skills available to the agent. Maximum 20.
+ Skills []BetaManagedAgentsSkillParamsUnion `json:"skills,omitzero"`
+ // Tool configurations available to the agent. Maximum of 128 tools across all
+ // toolsets allowed.
+ Tools []BetaAgentNewParamsToolUnion `json:"tools,omitzero"`
+ // Optional header to specify the beta version(s) you want to use.
+ Betas []AnthropicBeta `header:"anthropic-beta,omitzero" json:"-"`
+ paramObj
+}
+
+func (r BetaAgentNewParams) MarshalJSON() (data []byte, err error) {
+ type shadow BetaAgentNewParams
+ return param.MarshalObject(r, (*shadow)(&r))
+}
+func (r *BetaAgentNewParams) UnmarshalJSON(data []byte) error {
+ return apijson.UnmarshalRoot(data, r)
+}
+
+// Only one field can be non-zero.
+//
+// Use [param.IsOmitted] to confirm if a field is set.
+type BetaAgentNewParamsToolUnion struct {
+ OfAgentToolset20260401 *BetaManagedAgentsAgentToolset20260401Params `json:",omitzero,inline"`
+ OfMCPToolset *BetaManagedAgentsMCPToolsetParams `json:",omitzero,inline"`
+ OfCustom *BetaManagedAgentsCustomToolParams `json:",omitzero,inline"`
+ paramUnion
+}
+
+func (u BetaAgentNewParamsToolUnion) MarshalJSON() ([]byte, error) {
+ return param.MarshalUnion(u, u.OfAgentToolset20260401, u.OfMCPToolset, u.OfCustom)
+}
+func (u *BetaAgentNewParamsToolUnion) UnmarshalJSON(data []byte) error {
+ return apijson.UnmarshalRoot(data, u)
+}
+
+func (u *BetaAgentNewParamsToolUnion) asAny() any {
+ if !param.IsOmitted(u.OfAgentToolset20260401) {
+ return u.OfAgentToolset20260401
+ } else if !param.IsOmitted(u.OfMCPToolset) {
+ return u.OfMCPToolset
+ } else if !param.IsOmitted(u.OfCustom) {
+ return u.OfCustom
+ }
+ return nil
+}
+
+// Returns a pointer to the underlying variant's property, if present.
+func (u BetaAgentNewParamsToolUnion) GetMCPServerName() *string {
+ if vt := u.OfMCPToolset; vt != nil {
+ return &vt.MCPServerName
+ }
+ return nil
+}
+
+// Returns a pointer to the underlying variant's property, if present.
+func (u BetaAgentNewParamsToolUnion) GetDescription() *string {
+ if vt := u.OfCustom; vt != nil {
+ return &vt.Description
+ }
+ return nil
+}
+
+// Returns a pointer to the underlying variant's property, if present.
+func (u BetaAgentNewParamsToolUnion) GetInputSchema() *BetaManagedAgentsCustomToolInputSchemaParam {
+ if vt := u.OfCustom; vt != nil {
+ return &vt.InputSchema
+ }
+ return nil
+}
+
+// Returns a pointer to the underlying variant's property, if present.
+func (u BetaAgentNewParamsToolUnion) GetName() *string {
+ if vt := u.OfCustom; vt != nil {
+ return &vt.Name
+ }
+ return nil
+}
+
+// Returns a pointer to the underlying variant's property, if present.
+func (u BetaAgentNewParamsToolUnion) GetType() *string {
+ if vt := u.OfAgentToolset20260401; vt != nil {
+ return (*string)(&vt.Type)
+ } else if vt := u.OfMCPToolset; vt != nil {
+ return (*string)(&vt.Type)
+ } else if vt := u.OfCustom; vt != nil {
+ return (*string)(&vt.Type)
+ }
+ return nil
+}
+
+// Returns a subunion which exports methods to access subproperties
+//
+// Or use AsAny() to get the underlying value
+func (u BetaAgentNewParamsToolUnion) GetConfigs() (res betaAgentNewParamsToolUnionConfigs) {
+ if vt := u.OfAgentToolset20260401; vt != nil {
+ res.any = &vt.Configs
+ } else if vt := u.OfMCPToolset; vt != nil {
+ res.any = &vt.Configs
+ }
+ return
+}
+
+// Can have the runtime types [_[]BetaManagedAgentsAgentToolConfigParams],
+// [_[]BetaManagedAgentsMCPToolConfigParams]
+type betaAgentNewParamsToolUnionConfigs struct{ any }
+
+// Use the following switch statement to get the type of the union:
+//
+// switch u.AsAny().(type) {
+// case *[]anthropic.BetaManagedAgentsAgentToolConfigParams:
+// case *[]anthropic.BetaManagedAgentsMCPToolConfigParams:
+// default:
+// fmt.Errorf("not present")
+// }
+func (u betaAgentNewParamsToolUnionConfigs) AsAny() any { return u.any }
+
+// Returns a subunion which exports methods to access subproperties
+//
+// Or use AsAny() to get the underlying value
+func (u BetaAgentNewParamsToolUnion) GetDefaultConfig() (res betaAgentNewParamsToolUnionDefaultConfig) {
+ if vt := u.OfAgentToolset20260401; vt != nil {
+ res.any = &vt.DefaultConfig
+ } else if vt := u.OfMCPToolset; vt != nil {
+ res.any = &vt.DefaultConfig
+ }
+ return
+}
+
+// Can have the runtime types [*BetaManagedAgentsAgentToolsetDefaultConfigParams],
+// [*BetaManagedAgentsMCPToolsetDefaultConfigParams]
+type betaAgentNewParamsToolUnionDefaultConfig struct{ any }
+
+// Use the following switch statement to get the type of the union:
+//
+// switch u.AsAny().(type) {
+// case *anthropic.BetaManagedAgentsAgentToolsetDefaultConfigParams:
+// case *anthropic.BetaManagedAgentsMCPToolsetDefaultConfigParams:
+// default:
+// fmt.Errorf("not present")
+// }
+func (u betaAgentNewParamsToolUnionDefaultConfig) AsAny() any { return u.any }
+
+// Returns a pointer to the underlying variant's property, if present.
+func (u betaAgentNewParamsToolUnionDefaultConfig) GetEnabled() *bool {
+ switch vt := u.any.(type) {
+ case *BetaManagedAgentsAgentToolsetDefaultConfigParams:
+ return paramutil.AddrIfPresent(vt.Enabled)
+ case *BetaManagedAgentsMCPToolsetDefaultConfigParams:
+ return paramutil.AddrIfPresent(vt.Enabled)
+ }
+ return nil
+}
+
+// Returns a subunion which exports methods to access subproperties
+//
+// Or use AsAny() to get the underlying value
+func (u betaAgentNewParamsToolUnionDefaultConfig) GetPermissionPolicy() (res betaAgentNewParamsToolUnionDefaultConfigPermissionPolicy) {
+ switch vt := u.any.(type) {
+ case *BetaManagedAgentsAgentToolsetDefaultConfigParams:
+ res.any = vt.PermissionPolicy
+ case *BetaManagedAgentsMCPToolsetDefaultConfigParams:
+ res.any = vt.PermissionPolicy
+ }
+ return res
+}
+
+// Can have the runtime types [*BetaManagedAgentsAlwaysAllowPolicyParam],
+// [*BetaManagedAgentsAlwaysAskPolicyParam]
+type betaAgentNewParamsToolUnionDefaultConfigPermissionPolicy struct{ any }
+
+// Use the following switch statement to get the type of the union:
+//
+// switch u.AsAny().(type) {
+// case *anthropic.BetaManagedAgentsAlwaysAllowPolicyParam:
+// case *anthropic.BetaManagedAgentsAlwaysAskPolicyParam:
+// default:
+// fmt.Errorf("not present")
+// }
+func (u betaAgentNewParamsToolUnionDefaultConfigPermissionPolicy) AsAny() any { return u.any }
+
+// Returns a pointer to the underlying variant's property, if present.
+func (u betaAgentNewParamsToolUnionDefaultConfigPermissionPolicy) GetType() *string {
+ switch vt := u.any.(type) {
+ case *BetaManagedAgentsAgentToolsetDefaultConfigParamsPermissionPolicyUnion:
+ return vt.GetType()
+ case *BetaManagedAgentsMCPToolsetDefaultConfigParamsPermissionPolicyUnion:
+ return vt.GetType()
+ }
+ return nil
+}
+
+func init() {
+ apijson.RegisterUnion[BetaAgentNewParamsToolUnion](
+ "type",
+ apijson.Discriminator[BetaManagedAgentsAgentToolset20260401Params]("agent_toolset_20260401"),
+ apijson.Discriminator[BetaManagedAgentsMCPToolsetParams]("mcp_toolset"),
+ apijson.Discriminator[BetaManagedAgentsCustomToolParams]("custom"),
+ )
+}
+
+type BetaAgentGetParams struct {
+ // Agent version. Omit for the most recent version. Must be at least 1 if
+ // specified.
+ Version param.Opt[int64] `query:"version,omitzero" json:"-"`
+ // Optional header to specify the beta version(s) you want to use.
+ Betas []AnthropicBeta `header:"anthropic-beta,omitzero" json:"-"`
+ paramObj
+}
+
+// URLQuery serializes [BetaAgentGetParams]'s query parameters as `url.Values`.
+func (r BetaAgentGetParams) URLQuery() (v url.Values, err error) {
+ return apiquery.MarshalWithSettings(r, apiquery.QuerySettings{
+ ArrayFormat: apiquery.ArrayQueryFormatComma,
+ NestedFormat: apiquery.NestedQueryFormatBrackets,
+ })
+}
+
+type BetaAgentUpdateParams struct {
+ // The agent's current version, used to prevent concurrent overwrites. Obtain this
+ // value from a create or retrieve response. The request fails if this does not
+ // match the server's current version.
+ Version int64 `json:"version" api:"required"`
+ // Description. Up to 2048 characters. Omit to preserve; send empty string or null
+ // to clear.
+ Description param.Opt[string] `json:"description,omitzero"`
+ // System prompt. Up to 100,000 characters. Omit to preserve; send empty string or
+ // null to clear.
+ System param.Opt[string] `json:"system,omitzero"`
+ // Human-readable name. 1-256 characters. Omit to preserve. Cannot be cleared.
+ Name param.Opt[string] `json:"name,omitzero"`
+ // MCP servers. Full replacement. Omit to preserve; send empty array or null to
+ // clear. Names must be unique. Maximum 20.
+ MCPServers []BetaManagedAgentsURLMCPServerParams `json:"mcp_servers,omitzero"`
+ // Metadata patch. Set a key to a string to upsert it, or to null to delete it.
+ // Omit the field to preserve. The stored bag is limited to 16 keys (up to 64 chars
+ // each) with values up to 512 chars.
+ Metadata map[string]string `json:"metadata,omitzero"`
+ // Skills. Full replacement. Omit to preserve; send empty array or null to clear.
+ // Maximum 20.
+ Skills []BetaManagedAgentsSkillParamsUnion `json:"skills,omitzero"`
+ // Tool configurations available to the agent. Full replacement. Omit to preserve;
+ // send empty array or null to clear. Maximum of 128 tools across all toolsets
+ // allowed.
+ Tools []BetaAgentUpdateParamsToolUnion `json:"tools,omitzero"`
+ // Model identifier. Accepts the
+ // [model string](https://platform.claude.com/docs/en/about-claude/models/overview#latest-models-comparison),
+ // e.g. `claude-opus-4-6`, or a `model_config` object for additional configuration
+ // control. Omit to preserve. Cannot be cleared.
+ Model BetaManagedAgentsModelConfigParams `json:"model,omitzero"`
+ // Optional header to specify the beta version(s) you want to use.
+ Betas []AnthropicBeta `header:"anthropic-beta,omitzero" json:"-"`
+ paramObj
+}
+
+func (r BetaAgentUpdateParams) MarshalJSON() (data []byte, err error) {
+ type shadow BetaAgentUpdateParams
+ return param.MarshalObject(r, (*shadow)(&r))
+}
+func (r *BetaAgentUpdateParams) UnmarshalJSON(data []byte) error {
+ return apijson.UnmarshalRoot(data, r)
+}
+
+// Only one field can be non-zero.
+//
+// Use [param.IsOmitted] to confirm if a field is set.
+type BetaAgentUpdateParamsToolUnion struct {
+ OfAgentToolset20260401 *BetaManagedAgentsAgentToolset20260401Params `json:",omitzero,inline"`
+ OfMCPToolset *BetaManagedAgentsMCPToolsetParams `json:",omitzero,inline"`
+ OfCustom *BetaManagedAgentsCustomToolParams `json:",omitzero,inline"`
+ paramUnion
+}
+
+func (u BetaAgentUpdateParamsToolUnion) MarshalJSON() ([]byte, error) {
+ return param.MarshalUnion(u, u.OfAgentToolset20260401, u.OfMCPToolset, u.OfCustom)
+}
+func (u *BetaAgentUpdateParamsToolUnion) UnmarshalJSON(data []byte) error {
+ return apijson.UnmarshalRoot(data, u)
+}
+
+func (u *BetaAgentUpdateParamsToolUnion) asAny() any {
+ if !param.IsOmitted(u.OfAgentToolset20260401) {
+ return u.OfAgentToolset20260401
+ } else if !param.IsOmitted(u.OfMCPToolset) {
+ return u.OfMCPToolset
+ } else if !param.IsOmitted(u.OfCustom) {
+ return u.OfCustom
+ }
+ return nil
+}
+
+// Returns a pointer to the underlying variant's property, if present.
+func (u BetaAgentUpdateParamsToolUnion) GetMCPServerName() *string {
+ if vt := u.OfMCPToolset; vt != nil {
+ return &vt.MCPServerName
+ }
+ return nil
+}
+
+// Returns a pointer to the underlying variant's property, if present.
+func (u BetaAgentUpdateParamsToolUnion) GetDescription() *string {
+ if vt := u.OfCustom; vt != nil {
+ return &vt.Description
+ }
+ return nil
+}
+
+// Returns a pointer to the underlying variant's property, if present.
+func (u BetaAgentUpdateParamsToolUnion) GetInputSchema() *BetaManagedAgentsCustomToolInputSchemaParam {
+ if vt := u.OfCustom; vt != nil {
+ return &vt.InputSchema
+ }
+ return nil
+}
+
+// Returns a pointer to the underlying variant's property, if present.
+func (u BetaAgentUpdateParamsToolUnion) GetName() *string {
+ if vt := u.OfCustom; vt != nil {
+ return &vt.Name
+ }
+ return nil
+}
+
+// Returns a pointer to the underlying variant's property, if present.
+func (u BetaAgentUpdateParamsToolUnion) GetType() *string {
+ if vt := u.OfAgentToolset20260401; vt != nil {
+ return (*string)(&vt.Type)
+ } else if vt := u.OfMCPToolset; vt != nil {
+ return (*string)(&vt.Type)
+ } else if vt := u.OfCustom; vt != nil {
+ return (*string)(&vt.Type)
+ }
+ return nil
+}
+
+// Returns a subunion which exports methods to access subproperties
+//
+// Or use AsAny() to get the underlying value
+func (u BetaAgentUpdateParamsToolUnion) GetConfigs() (res betaAgentUpdateParamsToolUnionConfigs) {
+ if vt := u.OfAgentToolset20260401; vt != nil {
+ res.any = &vt.Configs
+ } else if vt := u.OfMCPToolset; vt != nil {
+ res.any = &vt.Configs
+ }
+ return
+}
+
+// Can have the runtime types [_[]BetaManagedAgentsAgentToolConfigParams],
+// [_[]BetaManagedAgentsMCPToolConfigParams]
+type betaAgentUpdateParamsToolUnionConfigs struct{ any }
+
+// Use the following switch statement to get the type of the union:
+//
+// switch u.AsAny().(type) {
+// case *[]anthropic.BetaManagedAgentsAgentToolConfigParams:
+// case *[]anthropic.BetaManagedAgentsMCPToolConfigParams:
+// default:
+// fmt.Errorf("not present")
+// }
+func (u betaAgentUpdateParamsToolUnionConfigs) AsAny() any { return u.any }
+
+// Returns a subunion which exports methods to access subproperties
+//
+// Or use AsAny() to get the underlying value
+func (u BetaAgentUpdateParamsToolUnion) GetDefaultConfig() (res betaAgentUpdateParamsToolUnionDefaultConfig) {
+ if vt := u.OfAgentToolset20260401; vt != nil {
+ res.any = &vt.DefaultConfig
+ } else if vt := u.OfMCPToolset; vt != nil {
+ res.any = &vt.DefaultConfig
+ }
+ return
+}
+
+// Can have the runtime types [*BetaManagedAgentsAgentToolsetDefaultConfigParams],
+// [*BetaManagedAgentsMCPToolsetDefaultConfigParams]
+type betaAgentUpdateParamsToolUnionDefaultConfig struct{ any }
+
+// Use the following switch statement to get the type of the union:
+//
+// switch u.AsAny().(type) {
+// case *anthropic.BetaManagedAgentsAgentToolsetDefaultConfigParams:
+// case *anthropic.BetaManagedAgentsMCPToolsetDefaultConfigParams:
+// default:
+// fmt.Errorf("not present")
+// }
+func (u betaAgentUpdateParamsToolUnionDefaultConfig) AsAny() any { return u.any }
+
+// Returns a pointer to the underlying variant's property, if present.
+func (u betaAgentUpdateParamsToolUnionDefaultConfig) GetEnabled() *bool {
+ switch vt := u.any.(type) {
+ case *BetaManagedAgentsAgentToolsetDefaultConfigParams:
+ return paramutil.AddrIfPresent(vt.Enabled)
+ case *BetaManagedAgentsMCPToolsetDefaultConfigParams:
+ return paramutil.AddrIfPresent(vt.Enabled)
+ }
+ return nil
+}
+
+// Returns a subunion which exports methods to access subproperties
+//
+// Or use AsAny() to get the underlying value
+func (u betaAgentUpdateParamsToolUnionDefaultConfig) GetPermissionPolicy() (res betaAgentUpdateParamsToolUnionDefaultConfigPermissionPolicy) {
+ switch vt := u.any.(type) {
+ case *BetaManagedAgentsAgentToolsetDefaultConfigParams:
+ res.any = vt.PermissionPolicy
+ case *BetaManagedAgentsMCPToolsetDefaultConfigParams:
+ res.any = vt.PermissionPolicy
+ }
+ return res
+}
+
+// Can have the runtime types [*BetaManagedAgentsAlwaysAllowPolicyParam],
+// [*BetaManagedAgentsAlwaysAskPolicyParam]
+type betaAgentUpdateParamsToolUnionDefaultConfigPermissionPolicy struct{ any }
+
+// Use the following switch statement to get the type of the union:
+//
+// switch u.AsAny().(type) {
+// case *anthropic.BetaManagedAgentsAlwaysAllowPolicyParam:
+// case *anthropic.BetaManagedAgentsAlwaysAskPolicyParam:
+// default:
+// fmt.Errorf("not present")
+// }
+func (u betaAgentUpdateParamsToolUnionDefaultConfigPermissionPolicy) AsAny() any { return u.any }
+
+// Returns a pointer to the underlying variant's property, if present.
+func (u betaAgentUpdateParamsToolUnionDefaultConfigPermissionPolicy) GetType() *string {
+ switch vt := u.any.(type) {
+ case *BetaManagedAgentsAgentToolsetDefaultConfigParamsPermissionPolicyUnion:
+ return vt.GetType()
+ case *BetaManagedAgentsMCPToolsetDefaultConfigParamsPermissionPolicyUnion:
+ return vt.GetType()
+ }
+ return nil
+}
+
+func init() {
+ apijson.RegisterUnion[BetaAgentUpdateParamsToolUnion](
+ "type",
+ apijson.Discriminator[BetaManagedAgentsAgentToolset20260401Params]("agent_toolset_20260401"),
+ apijson.Discriminator[BetaManagedAgentsMCPToolsetParams]("mcp_toolset"),
+ apijson.Discriminator[BetaManagedAgentsCustomToolParams]("custom"),
+ )
+}
+
+type BetaAgentListParams struct {
+ // Return agents created at or after this time (inclusive).
+ CreatedAtGte param.Opt[time.Time] `query:"created_at[gte],omitzero" format:"date-time" json:"-"`
+ // Return agents created at or before this time (inclusive).
+ CreatedAtLte param.Opt[time.Time] `query:"created_at[lte],omitzero" format:"date-time" json:"-"`
+ // Include archived agents in results. Defaults to false.
+ IncludeArchived param.Opt[bool] `query:"include_archived,omitzero" json:"-"`
+ // Maximum results per page. Default 20, maximum 100.
+ Limit param.Opt[int64] `query:"limit,omitzero" json:"-"`
+ // Opaque pagination cursor from a previous response.
+ Page param.Opt[string] `query:"page,omitzero" json:"-"`
+ // Optional header to specify the beta version(s) you want to use.
+ Betas []AnthropicBeta `header:"anthropic-beta,omitzero" json:"-"`
+ paramObj
+}
+
+// URLQuery serializes [BetaAgentListParams]'s query parameters as `url.Values`.
+func (r BetaAgentListParams) URLQuery() (v url.Values, err error) {
+ return apiquery.MarshalWithSettings(r, apiquery.QuerySettings{
+ ArrayFormat: apiquery.ArrayQueryFormatComma,
+ NestedFormat: apiquery.NestedQueryFormatBrackets,
+ })
+}
+
+type BetaAgentArchiveParams struct {
+ // Optional header to specify the beta version(s) you want to use.
+ Betas []AnthropicBeta `header:"anthropic-beta,omitzero" json:"-"`
+ paramObj
+}
diff --git a/betaagent_test.go b/betaagent_test.go
new file mode 100644
index 000000000..01f9b5064
--- /dev/null
+++ b/betaagent_test.go
@@ -0,0 +1,244 @@
+// File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+package anthropic_test
+
+import (
+ "context"
+ "errors"
+ "os"
+ "testing"
+ "time"
+
+ "github.com/anthropics/anthropic-sdk-go"
+ "github.com/anthropics/anthropic-sdk-go/internal/testutil"
+ "github.com/anthropics/anthropic-sdk-go/option"
+)
+
+func TestBetaAgentNewWithOptionalParams(t *testing.T) {
+ baseURL := "http://localhost:4010"
+ if envURL, ok := os.LookupEnv("TEST_API_BASE_URL"); ok {
+ baseURL = envURL
+ }
+ if !testutil.CheckTestServer(t, baseURL) {
+ return
+ }
+ client := anthropic.NewClient(
+ option.WithBaseURL(baseURL),
+ option.WithAPIKey("my-anthropic-api-key"),
+ )
+ _, err := client.Beta.Agents.New(context.TODO(), anthropic.BetaAgentNewParams{
+ Model: anthropic.BetaManagedAgentsModelConfigParams{
+ ID: anthropic.BetaManagedAgentsModelClaudeOpus4_6,
+ Speed: anthropic.BetaManagedAgentsModelConfigParamsSpeedStandard,
+ },
+ Name: "My First Agent",
+ Description: anthropic.String("A general-purpose starter agent."),
+ MCPServers: []anthropic.BetaManagedAgentsURLMCPServerParams{{
+ Name: "example-mcp",
+ Type: anthropic.BetaManagedAgentsURLMCPServerParamsTypeURL,
+ URL: "https://example-server.modelcontextprotocol.io/sse",
+ }},
+ Metadata: map[string]string{
+ "foo": "bar",
+ },
+ Skills: []anthropic.BetaManagedAgentsSkillParamsUnion{{
+ OfAnthropic: &anthropic.BetaManagedAgentsAnthropicSkillParams{
+ SkillID: "xlsx",
+ Type: anthropic.BetaManagedAgentsAnthropicSkillParamsTypeAnthropic,
+ Version: anthropic.String("1"),
+ },
+ }},
+ System: anthropic.String("You are a general-purpose agent that can research, write code, run commands, and use connected tools to complete the user's task end to end."),
+ Tools: []anthropic.BetaAgentNewParamsToolUnion{{
+ OfAgentToolset20260401: &anthropic.BetaManagedAgentsAgentToolset20260401Params{
+ Type: anthropic.BetaManagedAgentsAgentToolset20260401ParamsTypeAgentToolset20260401,
+ Configs: []anthropic.BetaManagedAgentsAgentToolConfigParams{{
+ Name: anthropic.BetaManagedAgentsAgentToolConfigParamsNameBash,
+ Enabled: anthropic.Bool(true),
+ PermissionPolicy: anthropic.BetaManagedAgentsAgentToolConfigParamsPermissionPolicyUnion{
+ OfAlwaysAllow: &anthropic.BetaManagedAgentsAlwaysAllowPolicyParam{
+ Type: anthropic.BetaManagedAgentsAlwaysAllowPolicyTypeAlwaysAllow,
+ },
+ },
+ }},
+ DefaultConfig: anthropic.BetaManagedAgentsAgentToolsetDefaultConfigParams{
+ Enabled: anthropic.Bool(true),
+ PermissionPolicy: anthropic.BetaManagedAgentsAgentToolsetDefaultConfigParamsPermissionPolicyUnion{
+ OfAlwaysAllow: &anthropic.BetaManagedAgentsAlwaysAllowPolicyParam{
+ Type: anthropic.BetaManagedAgentsAlwaysAllowPolicyTypeAlwaysAllow,
+ },
+ },
+ },
+ },
+ }},
+ Betas: []anthropic.AnthropicBeta{anthropic.AnthropicBetaMessageBatches2024_09_24},
+ })
+ if err != nil {
+ var apierr *anthropic.Error
+ if errors.As(err, &apierr) {
+ t.Log(string(apierr.DumpRequest(true)))
+ }
+ t.Fatalf("err should be nil: %s", err.Error())
+ }
+}
+
+func TestBetaAgentGetWithOptionalParams(t *testing.T) {
+ t.Skip("buildURL drops path-level query params (SDK-4349)")
+ baseURL := "http://localhost:4010"
+ if envURL, ok := os.LookupEnv("TEST_API_BASE_URL"); ok {
+ baseURL = envURL
+ }
+ if !testutil.CheckTestServer(t, baseURL) {
+ return
+ }
+ client := anthropic.NewClient(
+ option.WithBaseURL(baseURL),
+ option.WithAPIKey("my-anthropic-api-key"),
+ )
+ _, err := client.Beta.Agents.Get(
+ context.TODO(),
+ "agent_011CZkYpogX7uDKUyvBTophP",
+ anthropic.BetaAgentGetParams{
+ Version: anthropic.Int(0),
+ Betas: []anthropic.AnthropicBeta{anthropic.AnthropicBetaMessageBatches2024_09_24},
+ },
+ )
+ if err != nil {
+ var apierr *anthropic.Error
+ if errors.As(err, &apierr) {
+ t.Log(string(apierr.DumpRequest(true)))
+ }
+ t.Fatalf("err should be nil: %s", err.Error())
+ }
+}
+
+func TestBetaAgentUpdateWithOptionalParams(t *testing.T) {
+ baseURL := "http://localhost:4010"
+ if envURL, ok := os.LookupEnv("TEST_API_BASE_URL"); ok {
+ baseURL = envURL
+ }
+ if !testutil.CheckTestServer(t, baseURL) {
+ return
+ }
+ client := anthropic.NewClient(
+ option.WithBaseURL(baseURL),
+ option.WithAPIKey("my-anthropic-api-key"),
+ )
+ _, err := client.Beta.Agents.Update(
+ context.TODO(),
+ "agent_011CZkYpogX7uDKUyvBTophP",
+ anthropic.BetaAgentUpdateParams{
+ Version: 1,
+ Description: anthropic.String("description"),
+ MCPServers: []anthropic.BetaManagedAgentsURLMCPServerParams{{
+ Name: "example-mcp",
+ Type: anthropic.BetaManagedAgentsURLMCPServerParamsTypeURL,
+ URL: "https://example-server.modelcontextprotocol.io/sse",
+ }},
+ Metadata: map[string]string{
+ "foo": "string",
+ },
+ Model: anthropic.BetaManagedAgentsModelConfigParams{
+ ID: anthropic.BetaManagedAgentsModelClaudeOpus4_6,
+ Speed: anthropic.BetaManagedAgentsModelConfigParamsSpeedStandard,
+ },
+ Name: anthropic.String("name"),
+ Skills: []anthropic.BetaManagedAgentsSkillParamsUnion{{
+ OfAnthropic: &anthropic.BetaManagedAgentsAnthropicSkillParams{
+ SkillID: "xlsx",
+ Type: anthropic.BetaManagedAgentsAnthropicSkillParamsTypeAnthropic,
+ Version: anthropic.String("1"),
+ },
+ }},
+ System: anthropic.String("You are a general-purpose agent that can research, write code, run commands, and use connected tools to complete the user's task end to end."),
+ Tools: []anthropic.BetaAgentUpdateParamsToolUnion{{
+ OfAgentToolset20260401: &anthropic.BetaManagedAgentsAgentToolset20260401Params{
+ Type: anthropic.BetaManagedAgentsAgentToolset20260401ParamsTypeAgentToolset20260401,
+ Configs: []anthropic.BetaManagedAgentsAgentToolConfigParams{{
+ Name: anthropic.BetaManagedAgentsAgentToolConfigParamsNameBash,
+ Enabled: anthropic.Bool(true),
+ PermissionPolicy: anthropic.BetaManagedAgentsAgentToolConfigParamsPermissionPolicyUnion{
+ OfAlwaysAllow: &anthropic.BetaManagedAgentsAlwaysAllowPolicyParam{
+ Type: anthropic.BetaManagedAgentsAlwaysAllowPolicyTypeAlwaysAllow,
+ },
+ },
+ }},
+ DefaultConfig: anthropic.BetaManagedAgentsAgentToolsetDefaultConfigParams{
+ Enabled: anthropic.Bool(true),
+ PermissionPolicy: anthropic.BetaManagedAgentsAgentToolsetDefaultConfigParamsPermissionPolicyUnion{
+ OfAlwaysAllow: &anthropic.BetaManagedAgentsAlwaysAllowPolicyParam{
+ Type: anthropic.BetaManagedAgentsAlwaysAllowPolicyTypeAlwaysAllow,
+ },
+ },
+ },
+ },
+ }},
+ Betas: []anthropic.AnthropicBeta{anthropic.AnthropicBetaMessageBatches2024_09_24},
+ },
+ )
+ if err != nil {
+ var apierr *anthropic.Error
+ if errors.As(err, &apierr) {
+ t.Log(string(apierr.DumpRequest(true)))
+ }
+ t.Fatalf("err should be nil: %s", err.Error())
+ }
+}
+
+func TestBetaAgentListWithOptionalParams(t *testing.T) {
+ t.Skip("buildURL drops path-level query params (SDK-4349)")
+ baseURL := "http://localhost:4010"
+ if envURL, ok := os.LookupEnv("TEST_API_BASE_URL"); ok {
+ baseURL = envURL
+ }
+ if !testutil.CheckTestServer(t, baseURL) {
+ return
+ }
+ client := anthropic.NewClient(
+ option.WithBaseURL(baseURL),
+ option.WithAPIKey("my-anthropic-api-key"),
+ )
+ _, err := client.Beta.Agents.List(context.TODO(), anthropic.BetaAgentListParams{
+ CreatedAtGte: anthropic.Time(time.Now()),
+ CreatedAtLte: anthropic.Time(time.Now()),
+ IncludeArchived: anthropic.Bool(true),
+ Limit: anthropic.Int(0),
+ Page: anthropic.String("page"),
+ Betas: []anthropic.AnthropicBeta{anthropic.AnthropicBetaMessageBatches2024_09_24},
+ })
+ if err != nil {
+ var apierr *anthropic.Error
+ if errors.As(err, &apierr) {
+ t.Log(string(apierr.DumpRequest(true)))
+ }
+ t.Fatalf("err should be nil: %s", err.Error())
+ }
+}
+
+func TestBetaAgentArchiveWithOptionalParams(t *testing.T) {
+ baseURL := "http://localhost:4010"
+ if envURL, ok := os.LookupEnv("TEST_API_BASE_URL"); ok {
+ baseURL = envURL
+ }
+ if !testutil.CheckTestServer(t, baseURL) {
+ return
+ }
+ client := anthropic.NewClient(
+ option.WithBaseURL(baseURL),
+ option.WithAPIKey("my-anthropic-api-key"),
+ )
+ _, err := client.Beta.Agents.Archive(
+ context.TODO(),
+ "agent_011CZkYpogX7uDKUyvBTophP",
+ anthropic.BetaAgentArchiveParams{
+ Betas: []anthropic.AnthropicBeta{anthropic.AnthropicBetaMessageBatches2024_09_24},
+ },
+ )
+ if err != nil {
+ var apierr *anthropic.Error
+ if errors.As(err, &apierr) {
+ t.Log(string(apierr.DumpRequest(true)))
+ }
+ t.Fatalf("err should be nil: %s", err.Error())
+ }
+}
diff --git a/betaagentversion.go b/betaagentversion.go
new file mode 100644
index 000000000..84f06e0a2
--- /dev/null
+++ b/betaagentversion.go
@@ -0,0 +1,86 @@
+// File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+package anthropic
+
+import (
+ "context"
+ "errors"
+ "fmt"
+ "net/http"
+ "net/url"
+ "slices"
+
+ "github.com/anthropics/anthropic-sdk-go/internal/apiquery"
+ "github.com/anthropics/anthropic-sdk-go/internal/requestconfig"
+ "github.com/anthropics/anthropic-sdk-go/option"
+ "github.com/anthropics/anthropic-sdk-go/packages/pagination"
+ "github.com/anthropics/anthropic-sdk-go/packages/param"
+)
+
+// BetaAgentVersionService contains methods and other services that help with
+// interacting with the anthropic API.
+//
+// Note, unlike clients, this service does not read variables from the environment
+// automatically. You should not instantiate this service directly, and instead use
+// the [NewBetaAgentVersionService] method instead.
+type BetaAgentVersionService struct {
+ Options []option.RequestOption
+}
+
+// NewBetaAgentVersionService generates a new service that applies the given
+// options to each request. These options are applied after the parent client's
+// options (if there is one), and before any request-specific options.
+func NewBetaAgentVersionService(opts ...option.RequestOption) (r BetaAgentVersionService) {
+ r = BetaAgentVersionService{}
+ r.Options = opts
+ return
+}
+
+// List Agent Versions
+func (r *BetaAgentVersionService) List(ctx context.Context, agentID string, params BetaAgentVersionListParams, opts ...option.RequestOption) (res *pagination.PageCursor[BetaManagedAgentsAgent], err error) {
+ var raw *http.Response
+ for _, v := range params.Betas {
+ opts = append(opts, option.WithHeaderAdd("anthropic-beta", fmt.Sprintf("%v", v)))
+ }
+ opts = slices.Concat(r.Options, opts)
+ opts = append([]option.RequestOption{option.WithHeader("anthropic-beta", "managed-agents-2026-04-01"), option.WithResponseInto(&raw)}, opts...)
+ if agentID == "" {
+ err = errors.New("missing required agent_id parameter")
+ return nil, err
+ }
+ path := fmt.Sprintf("v1/agents/%s/versions?beta=true", agentID)
+ cfg, err := requestconfig.NewRequestConfig(ctx, http.MethodGet, path, params, &res, opts...)
+ if err != nil {
+ return nil, err
+ }
+ err = cfg.Execute()
+ if err != nil {
+ return nil, err
+ }
+ res.SetPageConfig(cfg, raw)
+ return res, nil
+}
+
+// List Agent Versions
+func (r *BetaAgentVersionService) ListAutoPaging(ctx context.Context, agentID string, params BetaAgentVersionListParams, opts ...option.RequestOption) *pagination.PageCursorAutoPager[BetaManagedAgentsAgent] {
+ return pagination.NewPageCursorAutoPager(r.List(ctx, agentID, params, opts...))
+}
+
+type BetaAgentVersionListParams struct {
+ // Maximum results per page. Default 20, maximum 100.
+ Limit param.Opt[int64] `query:"limit,omitzero" json:"-"`
+ // Opaque pagination cursor.
+ Page param.Opt[string] `query:"page,omitzero" json:"-"`
+ // Optional header to specify the beta version(s) you want to use.
+ Betas []AnthropicBeta `header:"anthropic-beta,omitzero" json:"-"`
+ paramObj
+}
+
+// URLQuery serializes [BetaAgentVersionListParams]'s query parameters as
+// `url.Values`.
+func (r BetaAgentVersionListParams) URLQuery() (v url.Values, err error) {
+ return apiquery.MarshalWithSettings(r, apiquery.QuerySettings{
+ ArrayFormat: apiquery.ArrayQueryFormatComma,
+ NestedFormat: apiquery.NestedQueryFormatBrackets,
+ })
+}
diff --git a/betaagentversion_test.go b/betaagentversion_test.go
new file mode 100644
index 000000000..ba83aba75
--- /dev/null
+++ b/betaagentversion_test.go
@@ -0,0 +1,45 @@
+// File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+package anthropic_test
+
+import (
+ "context"
+ "errors"
+ "os"
+ "testing"
+
+ "github.com/anthropics/anthropic-sdk-go"
+ "github.com/anthropics/anthropic-sdk-go/internal/testutil"
+ "github.com/anthropics/anthropic-sdk-go/option"
+)
+
+func TestBetaAgentVersionListWithOptionalParams(t *testing.T) {
+ t.Skip("buildURL drops path-level query params (SDK-4349)")
+ baseURL := "http://localhost:4010"
+ if envURL, ok := os.LookupEnv("TEST_API_BASE_URL"); ok {
+ baseURL = envURL
+ }
+ if !testutil.CheckTestServer(t, baseURL) {
+ return
+ }
+ client := anthropic.NewClient(
+ option.WithBaseURL(baseURL),
+ option.WithAPIKey("my-anthropic-api-key"),
+ )
+ _, err := client.Beta.Agents.Versions.List(
+ context.TODO(),
+ "agent_011CZkYpogX7uDKUyvBTophP",
+ anthropic.BetaAgentVersionListParams{
+ Limit: anthropic.Int(0),
+ Page: anthropic.String("page"),
+ Betas: []anthropic.AnthropicBeta{anthropic.AnthropicBetaMessageBatches2024_09_24},
+ },
+ )
+ if err != nil {
+ var apierr *anthropic.Error
+ if errors.As(err, &apierr) {
+ t.Log(string(apierr.DumpRequest(true)))
+ }
+ t.Fatalf("err should be nil: %s", err.Error())
+ }
+}
diff --git a/betaenvironment.go b/betaenvironment.go
new file mode 100644
index 000000000..e64ff1cba
--- /dev/null
+++ b/betaenvironment.go
@@ -0,0 +1,679 @@
+// File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+package anthropic
+
+import (
+ "context"
+ "encoding/json"
+ "errors"
+ "fmt"
+ "net/http"
+ "net/url"
+ "slices"
+
+ "github.com/anthropics/anthropic-sdk-go/internal/apijson"
+ "github.com/anthropics/anthropic-sdk-go/internal/apiquery"
+ "github.com/anthropics/anthropic-sdk-go/internal/requestconfig"
+ "github.com/anthropics/anthropic-sdk-go/option"
+ "github.com/anthropics/anthropic-sdk-go/packages/pagination"
+ "github.com/anthropics/anthropic-sdk-go/packages/param"
+ "github.com/anthropics/anthropic-sdk-go/packages/respjson"
+ "github.com/anthropics/anthropic-sdk-go/shared/constant"
+)
+
+// BetaEnvironmentService contains methods and other services that help with
+// interacting with the anthropic API.
+//
+// Note, unlike clients, this service does not read variables from the environment
+// automatically. You should not instantiate this service directly, and instead use
+// the [NewBetaEnvironmentService] method instead.
+type BetaEnvironmentService struct {
+ Options []option.RequestOption
+}
+
+// NewBetaEnvironmentService generates a new service that applies the given options
+// to each request. These options are applied after the parent client's options (if
+// there is one), and before any request-specific options.
+func NewBetaEnvironmentService(opts ...option.RequestOption) (r BetaEnvironmentService) {
+ r = BetaEnvironmentService{}
+ r.Options = opts
+ return
+}
+
+// Create a new environment with the specified configuration.
+func (r *BetaEnvironmentService) New(ctx context.Context, params BetaEnvironmentNewParams, opts ...option.RequestOption) (res *BetaEnvironment, err error) {
+ for _, v := range params.Betas {
+ opts = append(opts, option.WithHeaderAdd("anthropic-beta", fmt.Sprintf("%v", v)))
+ }
+ opts = slices.Concat(r.Options, opts)
+ opts = append([]option.RequestOption{option.WithHeader("anthropic-beta", "managed-agents-2026-04-01")}, opts...)
+ path := "v1/environments?beta=true"
+ err = requestconfig.ExecuteNewRequest(ctx, http.MethodPost, path, params, &res, opts...)
+ return res, err
+}
+
+// Retrieve a specific environment by ID.
+func (r *BetaEnvironmentService) Get(ctx context.Context, environmentID string, query BetaEnvironmentGetParams, opts ...option.RequestOption) (res *BetaEnvironment, err error) {
+ for _, v := range query.Betas {
+ opts = append(opts, option.WithHeaderAdd("anthropic-beta", fmt.Sprintf("%v", v)))
+ }
+ opts = slices.Concat(r.Options, opts)
+ opts = append([]option.RequestOption{option.WithHeader("anthropic-beta", "managed-agents-2026-04-01")}, opts...)
+ if environmentID == "" {
+ err = errors.New("missing required environment_id parameter")
+ return nil, err
+ }
+ path := fmt.Sprintf("v1/environments/%s?beta=true", environmentID)
+ err = requestconfig.ExecuteNewRequest(ctx, http.MethodGet, path, nil, &res, opts...)
+ return res, err
+}
+
+// Update an existing environment's configuration.
+func (r *BetaEnvironmentService) Update(ctx context.Context, environmentID string, params BetaEnvironmentUpdateParams, opts ...option.RequestOption) (res *BetaEnvironment, err error) {
+ for _, v := range params.Betas {
+ opts = append(opts, option.WithHeaderAdd("anthropic-beta", fmt.Sprintf("%v", v)))
+ }
+ opts = slices.Concat(r.Options, opts)
+ opts = append([]option.RequestOption{option.WithHeader("anthropic-beta", "managed-agents-2026-04-01")}, opts...)
+ if environmentID == "" {
+ err = errors.New("missing required environment_id parameter")
+ return nil, err
+ }
+ path := fmt.Sprintf("v1/environments/%s?beta=true", environmentID)
+ err = requestconfig.ExecuteNewRequest(ctx, http.MethodPost, path, params, &res, opts...)
+ return res, err
+}
+
+// List environments with pagination support.
+func (r *BetaEnvironmentService) List(ctx context.Context, params BetaEnvironmentListParams, opts ...option.RequestOption) (res *pagination.PageCursor[BetaEnvironment], err error) {
+ var raw *http.Response
+ for _, v := range params.Betas {
+ opts = append(opts, option.WithHeaderAdd("anthropic-beta", fmt.Sprintf("%v", v)))
+ }
+ opts = slices.Concat(r.Options, opts)
+ opts = append([]option.RequestOption{option.WithHeader("anthropic-beta", "managed-agents-2026-04-01"), option.WithResponseInto(&raw)}, opts...)
+ path := "v1/environments?beta=true"
+ cfg, err := requestconfig.NewRequestConfig(ctx, http.MethodGet, path, params, &res, opts...)
+ if err != nil {
+ return nil, err
+ }
+ err = cfg.Execute()
+ if err != nil {
+ return nil, err
+ }
+ res.SetPageConfig(cfg, raw)
+ return res, nil
+}
+
+// List environments with pagination support.
+func (r *BetaEnvironmentService) ListAutoPaging(ctx context.Context, params BetaEnvironmentListParams, opts ...option.RequestOption) *pagination.PageCursorAutoPager[BetaEnvironment] {
+ return pagination.NewPageCursorAutoPager(r.List(ctx, params, opts...))
+}
+
+// Delete an environment by ID. Returns a confirmation of the deletion.
+func (r *BetaEnvironmentService) Delete(ctx context.Context, environmentID string, body BetaEnvironmentDeleteParams, opts ...option.RequestOption) (res *BetaEnvironmentDeleteResponse, err error) {
+ for _, v := range body.Betas {
+ opts = append(opts, option.WithHeaderAdd("anthropic-beta", fmt.Sprintf("%v", v)))
+ }
+ opts = slices.Concat(r.Options, opts)
+ opts = append([]option.RequestOption{option.WithHeader("anthropic-beta", "managed-agents-2026-04-01")}, opts...)
+ if environmentID == "" {
+ err = errors.New("missing required environment_id parameter")
+ return nil, err
+ }
+ path := fmt.Sprintf("v1/environments/%s?beta=true", environmentID)
+ err = requestconfig.ExecuteNewRequest(ctx, http.MethodDelete, path, nil, &res, opts...)
+ return res, err
+}
+
+// Archive an environment by ID. Archived environments cannot be used to create new
+// sessions.
+func (r *BetaEnvironmentService) Archive(ctx context.Context, environmentID string, body BetaEnvironmentArchiveParams, opts ...option.RequestOption) (res *BetaEnvironment, err error) {
+ for _, v := range body.Betas {
+ opts = append(opts, option.WithHeaderAdd("anthropic-beta", fmt.Sprintf("%v", v)))
+ }
+ opts = slices.Concat(r.Options, opts)
+ opts = append([]option.RequestOption{option.WithHeader("anthropic-beta", "managed-agents-2026-04-01")}, opts...)
+ if environmentID == "" {
+ err = errors.New("missing required environment_id parameter")
+ return nil, err
+ }
+ path := fmt.Sprintf("v1/environments/%s/archive?beta=true", environmentID)
+ err = requestconfig.ExecuteNewRequest(ctx, http.MethodPost, path, nil, &res, opts...)
+ return res, err
+}
+
+// `cloud` environment configuration.
+type BetaCloudConfig struct {
+ // Network configuration policy.
+ Networking BetaCloudConfigNetworkingUnion `json:"networking" api:"required"`
+ // Package manager configuration.
+ Packages BetaPackages `json:"packages" api:"required"`
+ // Environment type
+ Type constant.Cloud `json:"type" default:"cloud"`
+ // JSON contains metadata for fields, check presence with [respjson.Field.Valid].
+ JSON struct {
+ Networking respjson.Field
+ Packages respjson.Field
+ Type respjson.Field
+ ExtraFields map[string]respjson.Field
+ raw string
+ } `json:"-"`
+}
+
+// Returns the unmodified JSON received from the API
+func (r BetaCloudConfig) RawJSON() string { return r.JSON.raw }
+func (r *BetaCloudConfig) UnmarshalJSON(data []byte) error {
+ return apijson.UnmarshalRoot(data, r)
+}
+
+// BetaCloudConfigNetworkingUnion contains all possible properties and values from
+// [BetaUnrestrictedNetwork], [BetaLimitedNetwork].
+//
+// Use the [BetaCloudConfigNetworkingUnion.AsAny] method to switch on the variant.
+//
+// Use the methods beginning with 'As' to cast the union to one of its variants.
+type BetaCloudConfigNetworkingUnion struct {
+ // Any of "unrestricted", "limited".
+ Type string `json:"type"`
+ // This field is from variant [BetaLimitedNetwork].
+ AllowMCPServers bool `json:"allow_mcp_servers"`
+ // This field is from variant [BetaLimitedNetwork].
+ AllowPackageManagers bool `json:"allow_package_managers"`
+ // This field is from variant [BetaLimitedNetwork].
+ AllowedHosts []string `json:"allowed_hosts"`
+ JSON struct {
+ Type respjson.Field
+ AllowMCPServers respjson.Field
+ AllowPackageManagers respjson.Field
+ AllowedHosts respjson.Field
+ raw string
+ } `json:"-"`
+}
+
+// anyBetaCloudConfigNetworking is implemented by each variant of
+// [BetaCloudConfigNetworkingUnion] to add type safety for the return type of
+// [BetaCloudConfigNetworkingUnion.AsAny]
+type anyBetaCloudConfigNetworking interface {
+ implBetaCloudConfigNetworkingUnion()
+}
+
+func (BetaUnrestrictedNetwork) implBetaCloudConfigNetworkingUnion() {}
+func (BetaLimitedNetwork) implBetaCloudConfigNetworkingUnion() {}
+
+// Use the following switch statement to find the correct variant
+//
+// switch variant := BetaCloudConfigNetworkingUnion.AsAny().(type) {
+// case anthropic.BetaUnrestrictedNetwork:
+// case anthropic.BetaLimitedNetwork:
+// default:
+// fmt.Errorf("no variant present")
+// }
+func (u BetaCloudConfigNetworkingUnion) AsAny() anyBetaCloudConfigNetworking {
+ switch u.Type {
+ case "unrestricted":
+ return u.AsUnrestricted()
+ case "limited":
+ return u.AsLimited()
+ }
+ return nil
+}
+
+func (u BetaCloudConfigNetworkingUnion) AsUnrestricted() (v BetaUnrestrictedNetwork) {
+ apijson.UnmarshalRoot(json.RawMessage(u.JSON.raw), &v)
+ return
+}
+
+func (u BetaCloudConfigNetworkingUnion) AsLimited() (v BetaLimitedNetwork) {
+ apijson.UnmarshalRoot(json.RawMessage(u.JSON.raw), &v)
+ return
+}
+
+// Returns the unmodified JSON received from the API
+func (u BetaCloudConfigNetworkingUnion) RawJSON() string { return u.JSON.raw }
+
+func (r *BetaCloudConfigNetworkingUnion) UnmarshalJSON(data []byte) error {
+ return apijson.UnmarshalRoot(data, r)
+}
+
+// Request params for `cloud` environment configuration.
+//
+// Fields default to null; on update, omitted fields preserve the existing value.
+//
+// The property Type is required.
+type BetaCloudConfigParams struct {
+ // Network configuration policy. Omit on update to preserve the existing value.
+ Networking BetaCloudConfigParamsNetworkingUnion `json:"networking,omitzero"`
+ // Specify packages (and optionally their versions) available in this environment.
+ //
+ // When versioning, use the version semantics relevant for the package manager,
+ // e.g. for `pip` use `package==1.0.0`. You are responsible for validating the
+ // package and version exist. Unversioned installs the latest.
+ Packages BetaPackagesParams `json:"packages,omitzero"`
+ // Environment type
+ //
+ // This field can be elided, and will marshal its zero value as "cloud".
+ Type constant.Cloud `json:"type" default:"cloud"`
+ paramObj
+}
+
+func (r BetaCloudConfigParams) MarshalJSON() (data []byte, err error) {
+ type shadow BetaCloudConfigParams
+ return param.MarshalObject(r, (*shadow)(&r))
+}
+func (r *BetaCloudConfigParams) UnmarshalJSON(data []byte) error {
+ return apijson.UnmarshalRoot(data, r)
+}
+
+// Only one field can be non-zero.
+//
+// Use [param.IsOmitted] to confirm if a field is set.
+type BetaCloudConfigParamsNetworkingUnion struct {
+ OfUnrestricted *BetaUnrestrictedNetworkParam `json:",omitzero,inline"`
+ OfLimited *BetaLimitedNetworkParams `json:",omitzero,inline"`
+ paramUnion
+}
+
+func (u BetaCloudConfigParamsNetworkingUnion) MarshalJSON() ([]byte, error) {
+ return param.MarshalUnion(u, u.OfUnrestricted, u.OfLimited)
+}
+func (u *BetaCloudConfigParamsNetworkingUnion) UnmarshalJSON(data []byte) error {
+ return apijson.UnmarshalRoot(data, u)
+}
+
+func (u *BetaCloudConfigParamsNetworkingUnion) asAny() any {
+ if !param.IsOmitted(u.OfUnrestricted) {
+ return u.OfUnrestricted
+ } else if !param.IsOmitted(u.OfLimited) {
+ return u.OfLimited
+ }
+ return nil
+}
+
+// Returns a pointer to the underlying variant's property, if present.
+func (u BetaCloudConfigParamsNetworkingUnion) GetAllowMCPServers() *bool {
+ if vt := u.OfLimited; vt != nil && vt.AllowMCPServers.Valid() {
+ return &vt.AllowMCPServers.Value
+ }
+ return nil
+}
+
+// Returns a pointer to the underlying variant's property, if present.
+func (u BetaCloudConfigParamsNetworkingUnion) GetAllowPackageManagers() *bool {
+ if vt := u.OfLimited; vt != nil && vt.AllowPackageManagers.Valid() {
+ return &vt.AllowPackageManagers.Value
+ }
+ return nil
+}
+
+// Returns a pointer to the underlying variant's property, if present.
+func (u BetaCloudConfigParamsNetworkingUnion) GetAllowedHosts() []string {
+ if vt := u.OfLimited; vt != nil {
+ return vt.AllowedHosts
+ }
+ return nil
+}
+
+// Returns a pointer to the underlying variant's property, if present.
+func (u BetaCloudConfigParamsNetworkingUnion) GetType() *string {
+ if vt := u.OfUnrestricted; vt != nil {
+ return (*string)(&vt.Type)
+ } else if vt := u.OfLimited; vt != nil {
+ return (*string)(&vt.Type)
+ }
+ return nil
+}
+
+func init() {
+ apijson.RegisterUnion[BetaCloudConfigParamsNetworkingUnion](
+ "type",
+ apijson.Discriminator[BetaUnrestrictedNetworkParam]("unrestricted"),
+ apijson.Discriminator[BetaLimitedNetworkParams]("limited"),
+ )
+}
+
+// Unified Environment resource for both cloud and BYOC environments.
+type BetaEnvironment struct {
+ // Environment identifier (e.g., 'env\_...')
+ ID string `json:"id" api:"required"`
+ // RFC 3339 timestamp when environment was archived, or null if not archived
+ ArchivedAt string `json:"archived_at" api:"required"`
+ // `cloud` environment configuration.
+ Config BetaCloudConfig `json:"config" api:"required"`
+ // RFC 3339 timestamp when environment was created
+ CreatedAt string `json:"created_at" api:"required"`
+ // User-provided description for the environment
+ Description string `json:"description" api:"required"`
+ // User-provided metadata key-value pairs
+ Metadata map[string]string `json:"metadata" api:"required"`
+ // Human-readable name for the environment
+ Name string `json:"name" api:"required"`
+ // The type of object (always 'environment')
+ Type constant.Environment `json:"type" default:"environment"`
+ // RFC 3339 timestamp when environment was last updated
+ UpdatedAt string `json:"updated_at" api:"required"`
+ // JSON contains metadata for fields, check presence with [respjson.Field.Valid].
+ JSON struct {
+ ID respjson.Field
+ ArchivedAt respjson.Field
+ Config respjson.Field
+ CreatedAt respjson.Field
+ Description respjson.Field
+ Metadata respjson.Field
+ Name respjson.Field
+ Type respjson.Field
+ UpdatedAt respjson.Field
+ ExtraFields map[string]respjson.Field
+ raw string
+ } `json:"-"`
+}
+
+// Returns the unmodified JSON received from the API
+func (r BetaEnvironment) RawJSON() string { return r.JSON.raw }
+func (r *BetaEnvironment) UnmarshalJSON(data []byte) error {
+ return apijson.UnmarshalRoot(data, r)
+}
+
+// Response after deleting an environment.
+type BetaEnvironmentDeleteResponse struct {
+ // Environment identifier
+ ID string `json:"id" api:"required"`
+ // The type of response
+ Type constant.EnvironmentDeleted `json:"type" default:"environment_deleted"`
+ // JSON contains metadata for fields, check presence with [respjson.Field.Valid].
+ JSON struct {
+ ID respjson.Field
+ Type respjson.Field
+ ExtraFields map[string]respjson.Field
+ raw string
+ } `json:"-"`
+}
+
+// Returns the unmodified JSON received from the API
+func (r BetaEnvironmentDeleteResponse) RawJSON() string { return r.JSON.raw }
+func (r *BetaEnvironmentDeleteResponse) UnmarshalJSON(data []byte) error {
+ return apijson.UnmarshalRoot(data, r)
+}
+
+// Limited network access.
+type BetaLimitedNetwork struct {
+ // Permits outbound access to MCP server endpoints configured on the agent, beyond
+ // those listed in the `allowed_hosts` array.
+ AllowMCPServers bool `json:"allow_mcp_servers" api:"required"`
+ // Permits outbound access to public package registries (PyPI, npm, etc.) beyond
+ // those listed in the `allowed_hosts` array.
+ AllowPackageManagers bool `json:"allow_package_managers" api:"required"`
+ // Specifies domains the container can reach.
+ AllowedHosts []string `json:"allowed_hosts" api:"required"`
+ // Network policy type
+ Type constant.Limited `json:"type" default:"limited"`
+ // JSON contains metadata for fields, check presence with [respjson.Field.Valid].
+ JSON struct {
+ AllowMCPServers respjson.Field
+ AllowPackageManagers respjson.Field
+ AllowedHosts respjson.Field
+ Type respjson.Field
+ ExtraFields map[string]respjson.Field
+ raw string
+ } `json:"-"`
+}
+
+// Returns the unmodified JSON received from the API
+func (r BetaLimitedNetwork) RawJSON() string { return r.JSON.raw }
+func (r *BetaLimitedNetwork) UnmarshalJSON(data []byte) error {
+ return apijson.UnmarshalRoot(data, r)
+}
+
+// Limited network request params.
+//
+// Fields default to null; on update, omitted fields preserve the existing value.
+//
+// The property Type is required.
+type BetaLimitedNetworkParams struct {
+ // Permits outbound access to MCP server endpoints configured on the agent, beyond
+ // those listed in the `allowed_hosts` array. Defaults to `false`.
+ AllowMCPServers param.Opt[bool] `json:"allow_mcp_servers,omitzero"`
+ // Permits outbound access to public package registries (PyPI, npm, etc.) beyond
+ // those listed in the `allowed_hosts` array. Defaults to `false`.
+ AllowPackageManagers param.Opt[bool] `json:"allow_package_managers,omitzero"`
+ // Specifies domains the container can reach.
+ AllowedHosts []string `json:"allowed_hosts,omitzero"`
+ // Network policy type
+ //
+ // This field can be elided, and will marshal its zero value as "limited".
+ Type constant.Limited `json:"type" default:"limited"`
+ paramObj
+}
+
+func (r BetaLimitedNetworkParams) MarshalJSON() (data []byte, err error) {
+ type shadow BetaLimitedNetworkParams
+ return param.MarshalObject(r, (*shadow)(&r))
+}
+func (r *BetaLimitedNetworkParams) UnmarshalJSON(data []byte) error {
+ return apijson.UnmarshalRoot(data, r)
+}
+
+// Packages (and their versions) available in this environment.
+type BetaPackages struct {
+ // Ubuntu/Debian packages to install
+ Apt []string `json:"apt" api:"required"`
+ // Rust packages to install
+ Cargo []string `json:"cargo" api:"required"`
+ // Ruby packages to install
+ Gem []string `json:"gem" api:"required"`
+ // Go packages to install
+ Go []string `json:"go" api:"required"`
+ // Node.js packages to install
+ Npm []string `json:"npm" api:"required"`
+ // Python packages to install
+ Pip []string `json:"pip" api:"required"`
+ // Package configuration type
+ //
+ // Any of "packages".
+ Type BetaPackagesType `json:"type"`
+ // JSON contains metadata for fields, check presence with [respjson.Field.Valid].
+ JSON struct {
+ Apt respjson.Field
+ Cargo respjson.Field
+ Gem respjson.Field
+ Go respjson.Field
+ Npm respjson.Field
+ Pip respjson.Field
+ Type respjson.Field
+ ExtraFields map[string]respjson.Field
+ raw string
+ } `json:"-"`
+}
+
+// Returns the unmodified JSON received from the API
+func (r BetaPackages) RawJSON() string { return r.JSON.raw }
+func (r *BetaPackages) UnmarshalJSON(data []byte) error {
+ return apijson.UnmarshalRoot(data, r)
+}
+
+// Package configuration type
+type BetaPackagesType string
+
+const (
+ BetaPackagesTypePackages BetaPackagesType = "packages"
+)
+
+// Specify packages (and optionally their versions) available in this environment.
+//
+// When versioning, use the version semantics relevant for the package manager,
+// e.g. for `pip` use `package==1.0.0`. You are responsible for validating the
+// package and version exist. Unversioned installs the latest.
+type BetaPackagesParams struct {
+ // Ubuntu/Debian packages to install
+ Apt []string `json:"apt,omitzero"`
+ // Rust packages to install
+ Cargo []string `json:"cargo,omitzero"`
+ // Ruby packages to install
+ Gem []string `json:"gem,omitzero"`
+ // Go packages to install
+ Go []string `json:"go,omitzero"`
+ // Node.js packages to install
+ Npm []string `json:"npm,omitzero"`
+ // Python packages to install
+ Pip []string `json:"pip,omitzero"`
+ // Package configuration type
+ //
+ // Any of "packages".
+ Type BetaPackagesParamsType `json:"type,omitzero"`
+ paramObj
+}
+
+func (r BetaPackagesParams) MarshalJSON() (data []byte, err error) {
+ type shadow BetaPackagesParams
+ return param.MarshalObject(r, (*shadow)(&r))
+}
+func (r *BetaPackagesParams) UnmarshalJSON(data []byte) error {
+ return apijson.UnmarshalRoot(data, r)
+}
+
+// Package configuration type
+type BetaPackagesParamsType string
+
+const (
+ BetaPackagesParamsTypePackages BetaPackagesParamsType = "packages"
+)
+
+// Unrestricted network access.
+type BetaUnrestrictedNetwork struct {
+ // Network policy type
+ Type constant.Unrestricted `json:"type" default:"unrestricted"`
+ // JSON contains metadata for fields, check presence with [respjson.Field.Valid].
+ JSON struct {
+ Type respjson.Field
+ ExtraFields map[string]respjson.Field
+ raw string
+ } `json:"-"`
+}
+
+// Returns the unmodified JSON received from the API
+func (r BetaUnrestrictedNetwork) RawJSON() string { return r.JSON.raw }
+func (r *BetaUnrestrictedNetwork) UnmarshalJSON(data []byte) error {
+ return apijson.UnmarshalRoot(data, r)
+}
+
+// ToParam converts this BetaUnrestrictedNetwork to a BetaUnrestrictedNetworkParam.
+//
+// Warning: the fields of the param type will not be present. ToParam should only
+// be used at the last possible moment before sending a request. Test for this with
+// BetaUnrestrictedNetworkParam.Overrides()
+func (r BetaUnrestrictedNetwork) ToParam() BetaUnrestrictedNetworkParam {
+ return param.Override[BetaUnrestrictedNetworkParam](json.RawMessage(r.RawJSON()))
+}
+
+func NewBetaUnrestrictedNetworkParam() BetaUnrestrictedNetworkParam {
+ return BetaUnrestrictedNetworkParam{
+ Type: "unrestricted",
+ }
+}
+
+// Unrestricted network access.
+//
+// This struct has a constant value, construct it with
+// [NewBetaUnrestrictedNetworkParam].
+type BetaUnrestrictedNetworkParam struct {
+ // Network policy type
+ Type constant.Unrestricted `json:"type" default:"unrestricted"`
+ paramObj
+}
+
+func (r BetaUnrestrictedNetworkParam) MarshalJSON() (data []byte, err error) {
+ type shadow BetaUnrestrictedNetworkParam
+ return param.MarshalObject(r, (*shadow)(&r))
+}
+func (r *BetaUnrestrictedNetworkParam) UnmarshalJSON(data []byte) error {
+ return apijson.UnmarshalRoot(data, r)
+}
+
+type BetaEnvironmentNewParams struct {
+ // Human-readable name for the environment
+ Name string `json:"name" api:"required"`
+ // Optional description of the environment
+ Description param.Opt[string] `json:"description,omitzero"`
+ // Request params for `cloud` environment configuration.
+ //
+ // Fields default to null; on update, omitted fields preserve the existing value.
+ Config BetaCloudConfigParams `json:"config,omitzero"`
+ // User-provided metadata key-value pairs
+ Metadata map[string]string `json:"metadata,omitzero"`
+ // Optional header to specify the beta version(s) you want to use.
+ Betas []AnthropicBeta `header:"anthropic-beta,omitzero" json:"-"`
+ paramObj
+}
+
+func (r BetaEnvironmentNewParams) MarshalJSON() (data []byte, err error) {
+ type shadow BetaEnvironmentNewParams
+ return param.MarshalObject(r, (*shadow)(&r))
+}
+func (r *BetaEnvironmentNewParams) UnmarshalJSON(data []byte) error {
+ return apijson.UnmarshalRoot(data, r)
+}
+
+type BetaEnvironmentGetParams struct {
+ // Optional header to specify the beta version(s) you want to use.
+ Betas []AnthropicBeta `header:"anthropic-beta,omitzero" json:"-"`
+ paramObj
+}
+
+type BetaEnvironmentUpdateParams struct {
+ // Updated description of the environment
+ Description param.Opt[string] `json:"description,omitzero"`
+ // Updated name for the environment
+ Name param.Opt[string] `json:"name,omitzero"`
+ // Request params for `cloud` environment configuration.
+ //
+ // Fields default to null; on update, omitted fields preserve the existing value.
+ Config BetaCloudConfigParams `json:"config,omitzero"`
+ // User-provided metadata key-value pairs. Set a value to null or empty string to
+ // delete the key.
+ Metadata map[string]string `json:"metadata,omitzero"`
+ // Optional header to specify the beta version(s) you want to use.
+ Betas []AnthropicBeta `header:"anthropic-beta,omitzero" json:"-"`
+ paramObj
+}
+
+func (r BetaEnvironmentUpdateParams) MarshalJSON() (data []byte, err error) {
+ type shadow BetaEnvironmentUpdateParams
+ return param.MarshalObject(r, (*shadow)(&r))
+}
+func (r *BetaEnvironmentUpdateParams) UnmarshalJSON(data []byte) error {
+ return apijson.UnmarshalRoot(data, r)
+}
+
+type BetaEnvironmentListParams struct {
+ // Opaque cursor from previous response for pagination. Pass the `next_page` value
+ // from the previous response.
+ Page param.Opt[string] `query:"page,omitzero" json:"-"`
+ // Include archived environments in the response
+ IncludeArchived param.Opt[bool] `query:"include_archived,omitzero" json:"-"`
+ // Maximum number of environments to return
+ Limit param.Opt[int64] `query:"limit,omitzero" json:"-"`
+ // Optional header to specify the beta version(s) you want to use.
+ Betas []AnthropicBeta `header:"anthropic-beta,omitzero" json:"-"`
+ paramObj
+}
+
+// URLQuery serializes [BetaEnvironmentListParams]'s query parameters as
+// `url.Values`.
+func (r BetaEnvironmentListParams) URLQuery() (v url.Values, err error) {
+ return apiquery.MarshalWithSettings(r, apiquery.QuerySettings{
+ ArrayFormat: apiquery.ArrayQueryFormatComma,
+ NestedFormat: apiquery.NestedQueryFormatBrackets,
+ })
+}
+
+type BetaEnvironmentDeleteParams struct {
+ // Optional header to specify the beta version(s) you want to use.
+ Betas []AnthropicBeta `header:"anthropic-beta,omitzero" json:"-"`
+ paramObj
+}
+
+type BetaEnvironmentArchiveParams struct {
+ // Optional header to specify the beta version(s) you want to use.
+ Betas []AnthropicBeta `header:"anthropic-beta,omitzero" json:"-"`
+ paramObj
+}
diff --git a/betaenvironment_test.go b/betaenvironment_test.go
new file mode 100644
index 000000000..16207e5ab
--- /dev/null
+++ b/betaenvironment_test.go
@@ -0,0 +1,223 @@
+// File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+package anthropic_test
+
+import (
+ "context"
+ "errors"
+ "os"
+ "testing"
+
+ "github.com/anthropics/anthropic-sdk-go"
+ "github.com/anthropics/anthropic-sdk-go/internal/testutil"
+ "github.com/anthropics/anthropic-sdk-go/option"
+)
+
+func TestBetaEnvironmentNewWithOptionalParams(t *testing.T) {
+ baseURL := "http://localhost:4010"
+ if envURL, ok := os.LookupEnv("TEST_API_BASE_URL"); ok {
+ baseURL = envURL
+ }
+ if !testutil.CheckTestServer(t, baseURL) {
+ return
+ }
+ client := anthropic.NewClient(
+ option.WithBaseURL(baseURL),
+ option.WithAPIKey("my-anthropic-api-key"),
+ )
+ _, err := client.Beta.Environments.New(context.TODO(), anthropic.BetaEnvironmentNewParams{
+ Name: "python-data-analysis",
+ Config: anthropic.BetaCloudConfigParams{
+ Networking: anthropic.BetaCloudConfigParamsNetworkingUnion{
+ OfLimited: &anthropic.BetaLimitedNetworkParams{
+ AllowMCPServers: anthropic.Bool(true),
+ AllowPackageManagers: anthropic.Bool(true),
+ AllowedHosts: []string{"api.example.com"},
+ },
+ },
+ Packages: anthropic.BetaPackagesParams{
+ Apt: []string{"string"},
+ Cargo: []string{"string"},
+ Gem: []string{"string"},
+ Go: []string{"string"},
+ Npm: []string{"string"},
+ Pip: []string{"pandas", "numpy"},
+ Type: anthropic.BetaPackagesParamsTypePackages,
+ },
+ },
+ Description: anthropic.String("Python environment with data-analysis packages."),
+ Metadata: map[string]string{
+ "foo": "string",
+ },
+ Betas: []anthropic.AnthropicBeta{anthropic.AnthropicBetaMessageBatches2024_09_24},
+ })
+ if err != nil {
+ var apierr *anthropic.Error
+ if errors.As(err, &apierr) {
+ t.Log(string(apierr.DumpRequest(true)))
+ }
+ t.Fatalf("err should be nil: %s", err.Error())
+ }
+}
+
+func TestBetaEnvironmentGetWithOptionalParams(t *testing.T) {
+ baseURL := "http://localhost:4010"
+ if envURL, ok := os.LookupEnv("TEST_API_BASE_URL"); ok {
+ baseURL = envURL
+ }
+ if !testutil.CheckTestServer(t, baseURL) {
+ return
+ }
+ client := anthropic.NewClient(
+ option.WithBaseURL(baseURL),
+ option.WithAPIKey("my-anthropic-api-key"),
+ )
+ _, err := client.Beta.Environments.Get(
+ context.TODO(),
+ "env_011CZkZ9X2dpNyB7HsEFoRfW",
+ anthropic.BetaEnvironmentGetParams{
+ Betas: []anthropic.AnthropicBeta{anthropic.AnthropicBetaMessageBatches2024_09_24},
+ },
+ )
+ if err != nil {
+ var apierr *anthropic.Error
+ if errors.As(err, &apierr) {
+ t.Log(string(apierr.DumpRequest(true)))
+ }
+ t.Fatalf("err should be nil: %s", err.Error())
+ }
+}
+
+func TestBetaEnvironmentUpdateWithOptionalParams(t *testing.T) {
+ baseURL := "http://localhost:4010"
+ if envURL, ok := os.LookupEnv("TEST_API_BASE_URL"); ok {
+ baseURL = envURL
+ }
+ if !testutil.CheckTestServer(t, baseURL) {
+ return
+ }
+ client := anthropic.NewClient(
+ option.WithBaseURL(baseURL),
+ option.WithAPIKey("my-anthropic-api-key"),
+ )
+ _, err := client.Beta.Environments.Update(
+ context.TODO(),
+ "env_011CZkZ9X2dpNyB7HsEFoRfW",
+ anthropic.BetaEnvironmentUpdateParams{
+ Config: anthropic.BetaCloudConfigParams{
+ Networking: anthropic.BetaCloudConfigParamsNetworkingUnion{
+ OfLimited: &anthropic.BetaLimitedNetworkParams{
+ AllowMCPServers: anthropic.Bool(true),
+ AllowPackageManagers: anthropic.Bool(true),
+ AllowedHosts: []string{"api.example.com"},
+ },
+ },
+ Packages: anthropic.BetaPackagesParams{
+ Apt: []string{"string"},
+ Cargo: []string{"string"},
+ Gem: []string{"string"},
+ Go: []string{"string"},
+ Npm: []string{"string"},
+ Pip: []string{"pandas", "numpy"},
+ Type: anthropic.BetaPackagesParamsTypePackages,
+ },
+ },
+ Description: anthropic.String("Python environment with data-analysis packages."),
+ Metadata: map[string]string{
+ "foo": "string",
+ },
+ Name: anthropic.String("x"),
+ Betas: []anthropic.AnthropicBeta{anthropic.AnthropicBetaMessageBatches2024_09_24},
+ },
+ )
+ if err != nil {
+ var apierr *anthropic.Error
+ if errors.As(err, &apierr) {
+ t.Log(string(apierr.DumpRequest(true)))
+ }
+ t.Fatalf("err should be nil: %s", err.Error())
+ }
+}
+
+func TestBetaEnvironmentListWithOptionalParams(t *testing.T) {
+ baseURL := "http://localhost:4010"
+ if envURL, ok := os.LookupEnv("TEST_API_BASE_URL"); ok {
+ baseURL = envURL
+ }
+ if !testutil.CheckTestServer(t, baseURL) {
+ return
+ }
+ client := anthropic.NewClient(
+ option.WithBaseURL(baseURL),
+ option.WithAPIKey("my-anthropic-api-key"),
+ )
+ _, err := client.Beta.Environments.List(context.TODO(), anthropic.BetaEnvironmentListParams{
+ IncludeArchived: anthropic.Bool(true),
+ Limit: anthropic.Int(1),
+ Page: anthropic.String("page"),
+ Betas: []anthropic.AnthropicBeta{anthropic.AnthropicBetaMessageBatches2024_09_24},
+ })
+ if err != nil {
+ var apierr *anthropic.Error
+ if errors.As(err, &apierr) {
+ t.Log(string(apierr.DumpRequest(true)))
+ }
+ t.Fatalf("err should be nil: %s", err.Error())
+ }
+}
+
+func TestBetaEnvironmentDeleteWithOptionalParams(t *testing.T) {
+ baseURL := "http://localhost:4010"
+ if envURL, ok := os.LookupEnv("TEST_API_BASE_URL"); ok {
+ baseURL = envURL
+ }
+ if !testutil.CheckTestServer(t, baseURL) {
+ return
+ }
+ client := anthropic.NewClient(
+ option.WithBaseURL(baseURL),
+ option.WithAPIKey("my-anthropic-api-key"),
+ )
+ _, err := client.Beta.Environments.Delete(
+ context.TODO(),
+ "env_011CZkZ9X2dpNyB7HsEFoRfW",
+ anthropic.BetaEnvironmentDeleteParams{
+ Betas: []anthropic.AnthropicBeta{anthropic.AnthropicBetaMessageBatches2024_09_24},
+ },
+ )
+ if err != nil {
+ var apierr *anthropic.Error
+ if errors.As(err, &apierr) {
+ t.Log(string(apierr.DumpRequest(true)))
+ }
+ t.Fatalf("err should be nil: %s", err.Error())
+ }
+}
+
+func TestBetaEnvironmentArchiveWithOptionalParams(t *testing.T) {
+ baseURL := "http://localhost:4010"
+ if envURL, ok := os.LookupEnv("TEST_API_BASE_URL"); ok {
+ baseURL = envURL
+ }
+ if !testutil.CheckTestServer(t, baseURL) {
+ return
+ }
+ client := anthropic.NewClient(
+ option.WithBaseURL(baseURL),
+ option.WithAPIKey("my-anthropic-api-key"),
+ )
+ _, err := client.Beta.Environments.Archive(
+ context.TODO(),
+ "env_011CZkZ9X2dpNyB7HsEFoRfW",
+ anthropic.BetaEnvironmentArchiveParams{
+ Betas: []anthropic.AnthropicBeta{anthropic.AnthropicBetaMessageBatches2024_09_24},
+ },
+ )
+ if err != nil {
+ var apierr *anthropic.Error
+ if errors.As(err, &apierr) {
+ t.Log(string(apierr.DumpRequest(true)))
+ }
+ t.Fatalf("err should be nil: %s", err.Error())
+ }
+}
diff --git a/betafile.go b/betafile.go
index 758caeb40..c8ac03227 100644
--- a/betafile.go
+++ b/betafile.go
@@ -130,6 +130,26 @@ func (r *BetaFileService) Upload(ctx context.Context, params BetaFileUploadParam
return res, err
}
+type BetaFileScope struct {
+ // The ID of the scoping resource (e.g., the session ID).
+ ID string `json:"id" api:"required"`
+ // The type of scope (e.g., `"session"`).
+ Type constant.Session `json:"type" default:"session"`
+ // JSON contains metadata for fields, check presence with [respjson.Field.Valid].
+ JSON struct {
+ ID respjson.Field
+ Type respjson.Field
+ ExtraFields map[string]respjson.Field
+ raw string
+ } `json:"-"`
+}
+
+// Returns the unmodified JSON received from the API
+func (r BetaFileScope) RawJSON() string { return r.JSON.raw }
+func (r *BetaFileScope) UnmarshalJSON(data []byte) error {
+ return apijson.UnmarshalRoot(data, r)
+}
+
type DeletedFile struct {
// ID of the deleted file.
ID string `json:"id" api:"required"`
@@ -182,6 +202,9 @@ type FileMetadata struct {
Type constant.File `json:"type" default:"file"`
// Whether the file can be downloaded.
Downloadable bool `json:"downloadable"`
+ // The scope of this file, indicating the context in which it was created (e.g., a
+ // session).
+ Scope BetaFileScope `json:"scope" api:"nullable"`
// JSON contains metadata for fields, check presence with [respjson.Field.Valid].
JSON struct {
ID respjson.Field
@@ -191,6 +214,7 @@ type FileMetadata struct {
SizeBytes respjson.Field
Type respjson.Field
Downloadable respjson.Field
+ Scope respjson.Field
ExtraFields map[string]respjson.Field
raw string
} `json:"-"`
@@ -213,6 +237,9 @@ type BetaFileListParams struct {
//
// Defaults to `20`. Ranges from `1` to `1000`.
Limit param.Opt[int64] `query:"limit,omitzero" json:"-"`
+ // Filter by scope ID. Only returns files associated with the specified scope
+ // (e.g., a session ID).
+ ScopeID param.Opt[string] `query:"scope_id,omitzero" json:"-"`
// Optional header to specify the beta version(s) you want to use.
Betas []AnthropicBeta `header:"anthropic-beta,omitzero" json:"-"`
paramObj
diff --git a/betafile_test.go b/betafile_test.go
index 42cd75c29..d222ef361 100644
--- a/betafile_test.go
+++ b/betafile_test.go
@@ -33,6 +33,7 @@ func TestBetaFileListWithOptionalParams(t *testing.T) {
AfterID: anthropic.String("after_id"),
BeforeID: anthropic.String("before_id"),
Limit: anthropic.Int(1),
+ ScopeID: anthropic.String("scope_id"),
Betas: []anthropic.AnthropicBeta{anthropic.AnthropicBetaMessageBatches2024_09_24},
})
if err != nil {
diff --git a/betasession.go b/betasession.go
new file mode 100644
index 000000000..374ea2919
--- /dev/null
+++ b/betasession.go
@@ -0,0 +1,1064 @@
+// File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+package anthropic
+
+import (
+ "context"
+ "encoding/json"
+ "errors"
+ "fmt"
+ "net/http"
+ "net/url"
+ "slices"
+ "time"
+
+ "github.com/anthropics/anthropic-sdk-go/internal/apijson"
+ "github.com/anthropics/anthropic-sdk-go/internal/apiquery"
+ "github.com/anthropics/anthropic-sdk-go/internal/requestconfig"
+ "github.com/anthropics/anthropic-sdk-go/option"
+ "github.com/anthropics/anthropic-sdk-go/packages/pagination"
+ "github.com/anthropics/anthropic-sdk-go/packages/param"
+ "github.com/anthropics/anthropic-sdk-go/packages/respjson"
+)
+
+// BetaSessionService contains methods and other services that help with
+// interacting with the anthropic API.
+//
+// Note, unlike clients, this service does not read variables from the environment
+// automatically. You should not instantiate this service directly, and instead use
+// the [NewBetaSessionService] method instead.
+type BetaSessionService struct {
+ Options []option.RequestOption
+ Events BetaSessionEventService
+ Resources BetaSessionResourceService
+}
+
+// NewBetaSessionService generates a new service that applies the given options to
+// each request. These options are applied after the parent client's options (if
+// there is one), and before any request-specific options.
+func NewBetaSessionService(opts ...option.RequestOption) (r BetaSessionService) {
+ r = BetaSessionService{}
+ r.Options = opts
+ r.Events = NewBetaSessionEventService(opts...)
+ r.Resources = NewBetaSessionResourceService(opts...)
+ return
+}
+
+// Create Session
+func (r *BetaSessionService) New(ctx context.Context, params BetaSessionNewParams, opts ...option.RequestOption) (res *BetaManagedAgentsSession, err error) {
+ for _, v := range params.Betas {
+ opts = append(opts, option.WithHeaderAdd("anthropic-beta", fmt.Sprintf("%v", v)))
+ }
+ opts = slices.Concat(r.Options, opts)
+ opts = append([]option.RequestOption{option.WithHeader("anthropic-beta", "managed-agents-2026-04-01")}, opts...)
+ path := "v1/sessions?beta=true"
+ err = requestconfig.ExecuteNewRequest(ctx, http.MethodPost, path, params, &res, opts...)
+ return res, err
+}
+
+// Get Session
+func (r *BetaSessionService) Get(ctx context.Context, sessionID string, query BetaSessionGetParams, opts ...option.RequestOption) (res *BetaManagedAgentsSession, err error) {
+ for _, v := range query.Betas {
+ opts = append(opts, option.WithHeaderAdd("anthropic-beta", fmt.Sprintf("%v", v)))
+ }
+ opts = slices.Concat(r.Options, opts)
+ opts = append([]option.RequestOption{option.WithHeader("anthropic-beta", "managed-agents-2026-04-01")}, opts...)
+ if sessionID == "" {
+ err = errors.New("missing required session_id parameter")
+ return nil, err
+ }
+ path := fmt.Sprintf("v1/sessions/%s?beta=true", sessionID)
+ err = requestconfig.ExecuteNewRequest(ctx, http.MethodGet, path, nil, &res, opts...)
+ return res, err
+}
+
+// Update Session
+func (r *BetaSessionService) Update(ctx context.Context, sessionID string, params BetaSessionUpdateParams, opts ...option.RequestOption) (res *BetaManagedAgentsSession, err error) {
+ for _, v := range params.Betas {
+ opts = append(opts, option.WithHeaderAdd("anthropic-beta", fmt.Sprintf("%v", v)))
+ }
+ opts = slices.Concat(r.Options, opts)
+ opts = append([]option.RequestOption{option.WithHeader("anthropic-beta", "managed-agents-2026-04-01")}, opts...)
+ if sessionID == "" {
+ err = errors.New("missing required session_id parameter")
+ return nil, err
+ }
+ path := fmt.Sprintf("v1/sessions/%s?beta=true", sessionID)
+ err = requestconfig.ExecuteNewRequest(ctx, http.MethodPost, path, params, &res, opts...)
+ return res, err
+}
+
+// List Sessions
+func (r *BetaSessionService) List(ctx context.Context, params BetaSessionListParams, opts ...option.RequestOption) (res *pagination.PageCursor[BetaManagedAgentsSession], err error) {
+ var raw *http.Response
+ for _, v := range params.Betas {
+ opts = append(opts, option.WithHeaderAdd("anthropic-beta", fmt.Sprintf("%v", v)))
+ }
+ opts = slices.Concat(r.Options, opts)
+ opts = append([]option.RequestOption{option.WithHeader("anthropic-beta", "managed-agents-2026-04-01"), option.WithResponseInto(&raw)}, opts...)
+ path := "v1/sessions?beta=true"
+ cfg, err := requestconfig.NewRequestConfig(ctx, http.MethodGet, path, params, &res, opts...)
+ if err != nil {
+ return nil, err
+ }
+ err = cfg.Execute()
+ if err != nil {
+ return nil, err
+ }
+ res.SetPageConfig(cfg, raw)
+ return res, nil
+}
+
+// List Sessions
+func (r *BetaSessionService) ListAutoPaging(ctx context.Context, params BetaSessionListParams, opts ...option.RequestOption) *pagination.PageCursorAutoPager[BetaManagedAgentsSession] {
+ return pagination.NewPageCursorAutoPager(r.List(ctx, params, opts...))
+}
+
+// Delete Session
+func (r *BetaSessionService) Delete(ctx context.Context, sessionID string, body BetaSessionDeleteParams, opts ...option.RequestOption) (res *BetaManagedAgentsDeletedSession, err error) {
+ for _, v := range body.Betas {
+ opts = append(opts, option.WithHeaderAdd("anthropic-beta", fmt.Sprintf("%v", v)))
+ }
+ opts = slices.Concat(r.Options, opts)
+ opts = append([]option.RequestOption{option.WithHeader("anthropic-beta", "managed-agents-2026-04-01")}, opts...)
+ if sessionID == "" {
+ err = errors.New("missing required session_id parameter")
+ return nil, err
+ }
+ path := fmt.Sprintf("v1/sessions/%s?beta=true", sessionID)
+ err = requestconfig.ExecuteNewRequest(ctx, http.MethodDelete, path, nil, &res, opts...)
+ return res, err
+}
+
+// Archive Session
+func (r *BetaSessionService) Archive(ctx context.Context, sessionID string, body BetaSessionArchiveParams, opts ...option.RequestOption) (res *BetaManagedAgentsSession, err error) {
+ for _, v := range body.Betas {
+ opts = append(opts, option.WithHeaderAdd("anthropic-beta", fmt.Sprintf("%v", v)))
+ }
+ opts = slices.Concat(r.Options, opts)
+ opts = append([]option.RequestOption{option.WithHeader("anthropic-beta", "managed-agents-2026-04-01")}, opts...)
+ if sessionID == "" {
+ err = errors.New("missing required session_id parameter")
+ return nil, err
+ }
+ path := fmt.Sprintf("v1/sessions/%s/archive?beta=true", sessionID)
+ err = requestconfig.ExecuteNewRequest(ctx, http.MethodPost, path, nil, &res, opts...)
+ return res, err
+}
+
+// Specification for an Agent. Provide a specific `version` or use the short-form
+// `agent="agent_id"` for the most recent version
+//
+// The properties ID, Type are required.
+type BetaManagedAgentsAgentParams struct {
+ // The `agent` ID.
+ ID string `json:"id" api:"required"`
+ // Any of "agent".
+ Type BetaManagedAgentsAgentParamsType `json:"type,omitzero" api:"required"`
+ // The specific `agent` version to use. Omit to use the latest version. Must be at
+ // least 1 if specified.
+ Version param.Opt[int64] `json:"version,omitzero"`
+ paramObj
+}
+
+func (r BetaManagedAgentsAgentParams) MarshalJSON() (data []byte, err error) {
+ type shadow BetaManagedAgentsAgentParams
+ return param.MarshalObject(r, (*shadow)(&r))
+}
+func (r *BetaManagedAgentsAgentParams) UnmarshalJSON(data []byte) error {
+ return apijson.UnmarshalRoot(data, r)
+}
+
+type BetaManagedAgentsAgentParamsType string
+
+const (
+ BetaManagedAgentsAgentParamsTypeAgent BetaManagedAgentsAgentParamsType = "agent"
+)
+
+type BetaManagedAgentsBranchCheckout struct {
+ // Branch name to check out.
+ Name string `json:"name" api:"required"`
+ // Any of "branch".
+ Type BetaManagedAgentsBranchCheckoutType `json:"type" api:"required"`
+ // JSON contains metadata for fields, check presence with [respjson.Field.Valid].
+ JSON struct {
+ Name respjson.Field
+ Type respjson.Field
+ ExtraFields map[string]respjson.Field
+ raw string
+ } `json:"-"`
+}
+
+// Returns the unmodified JSON received from the API
+func (r BetaManagedAgentsBranchCheckout) RawJSON() string { return r.JSON.raw }
+func (r *BetaManagedAgentsBranchCheckout) UnmarshalJSON(data []byte) error {
+ return apijson.UnmarshalRoot(data, r)
+}
+
+// ToParam converts this BetaManagedAgentsBranchCheckout to a
+// BetaManagedAgentsBranchCheckoutParam.
+//
+// Warning: the fields of the param type will not be present. ToParam should only
+// be used at the last possible moment before sending a request. Test for this with
+// BetaManagedAgentsBranchCheckoutParam.Overrides()
+func (r BetaManagedAgentsBranchCheckout) ToParam() BetaManagedAgentsBranchCheckoutParam {
+ return param.Override[BetaManagedAgentsBranchCheckoutParam](json.RawMessage(r.RawJSON()))
+}
+
+type BetaManagedAgentsBranchCheckoutType string
+
+const (
+ BetaManagedAgentsBranchCheckoutTypeBranch BetaManagedAgentsBranchCheckoutType = "branch"
+)
+
+// The properties Name, Type are required.
+type BetaManagedAgentsBranchCheckoutParam struct {
+ // Branch name to check out.
+ Name string `json:"name" api:"required"`
+ // Any of "branch".
+ Type BetaManagedAgentsBranchCheckoutType `json:"type,omitzero" api:"required"`
+ paramObj
+}
+
+func (r BetaManagedAgentsBranchCheckoutParam) MarshalJSON() (data []byte, err error) {
+ type shadow BetaManagedAgentsBranchCheckoutParam
+ return param.MarshalObject(r, (*shadow)(&r))
+}
+func (r *BetaManagedAgentsBranchCheckoutParam) UnmarshalJSON(data []byte) error {
+ return apijson.UnmarshalRoot(data, r)
+}
+
+// Prompt-cache creation token usage broken down by cache lifetime.
+type BetaManagedAgentsCacheCreationUsage struct {
+ // Tokens used to create 1-hour ephemeral cache entries.
+ Ephemeral1hInputTokens int64 `json:"ephemeral_1h_input_tokens"`
+ // Tokens used to create 5-minute ephemeral cache entries.
+ Ephemeral5mInputTokens int64 `json:"ephemeral_5m_input_tokens"`
+ // JSON contains metadata for fields, check presence with [respjson.Field.Valid].
+ JSON struct {
+ Ephemeral1hInputTokens respjson.Field
+ Ephemeral5mInputTokens respjson.Field
+ ExtraFields map[string]respjson.Field
+ raw string
+ } `json:"-"`
+}
+
+// Returns the unmodified JSON received from the API
+func (r BetaManagedAgentsCacheCreationUsage) RawJSON() string { return r.JSON.raw }
+func (r *BetaManagedAgentsCacheCreationUsage) UnmarshalJSON(data []byte) error {
+ return apijson.UnmarshalRoot(data, r)
+}
+
+type BetaManagedAgentsCommitCheckout struct {
+ // Full commit SHA to check out.
+ Sha string `json:"sha" api:"required"`
+ // Any of "commit".
+ Type BetaManagedAgentsCommitCheckoutType `json:"type" api:"required"`
+ // JSON contains metadata for fields, check presence with [respjson.Field.Valid].
+ JSON struct {
+ Sha respjson.Field
+ Type respjson.Field
+ ExtraFields map[string]respjson.Field
+ raw string
+ } `json:"-"`
+}
+
+// Returns the unmodified JSON received from the API
+func (r BetaManagedAgentsCommitCheckout) RawJSON() string { return r.JSON.raw }
+func (r *BetaManagedAgentsCommitCheckout) UnmarshalJSON(data []byte) error {
+ return apijson.UnmarshalRoot(data, r)
+}
+
+// ToParam converts this BetaManagedAgentsCommitCheckout to a
+// BetaManagedAgentsCommitCheckoutParam.
+//
+// Warning: the fields of the param type will not be present. ToParam should only
+// be used at the last possible moment before sending a request. Test for this with
+// BetaManagedAgentsCommitCheckoutParam.Overrides()
+func (r BetaManagedAgentsCommitCheckout) ToParam() BetaManagedAgentsCommitCheckoutParam {
+ return param.Override[BetaManagedAgentsCommitCheckoutParam](json.RawMessage(r.RawJSON()))
+}
+
+type BetaManagedAgentsCommitCheckoutType string
+
+const (
+ BetaManagedAgentsCommitCheckoutTypeCommit BetaManagedAgentsCommitCheckoutType = "commit"
+)
+
+// The properties Sha, Type are required.
+type BetaManagedAgentsCommitCheckoutParam struct {
+ // Full commit SHA to check out.
+ Sha string `json:"sha" api:"required"`
+ // Any of "commit".
+ Type BetaManagedAgentsCommitCheckoutType `json:"type,omitzero" api:"required"`
+ paramObj
+}
+
+func (r BetaManagedAgentsCommitCheckoutParam) MarshalJSON() (data []byte, err error) {
+ type shadow BetaManagedAgentsCommitCheckoutParam
+ return param.MarshalObject(r, (*shadow)(&r))
+}
+func (r *BetaManagedAgentsCommitCheckoutParam) UnmarshalJSON(data []byte) error {
+ return apijson.UnmarshalRoot(data, r)
+}
+
+// Confirmation that a `session` has been permanently deleted.
+type BetaManagedAgentsDeletedSession struct {
+ ID string `json:"id" api:"required"`
+ // Any of "session_deleted".
+ Type BetaManagedAgentsDeletedSessionType `json:"type" api:"required"`
+ // JSON contains metadata for fields, check presence with [respjson.Field.Valid].
+ JSON struct {
+ ID respjson.Field
+ Type respjson.Field
+ ExtraFields map[string]respjson.Field
+ raw string
+ } `json:"-"`
+}
+
+// Returns the unmodified JSON received from the API
+func (r BetaManagedAgentsDeletedSession) RawJSON() string { return r.JSON.raw }
+func (r *BetaManagedAgentsDeletedSession) UnmarshalJSON(data []byte) error {
+ return apijson.UnmarshalRoot(data, r)
+}
+
+type BetaManagedAgentsDeletedSessionType string
+
+const (
+ BetaManagedAgentsDeletedSessionTypeSessionDeleted BetaManagedAgentsDeletedSessionType = "session_deleted"
+)
+
+// Mount a file uploaded via the Files API into the session.
+//
+// The properties FileID, Type are required.
+type BetaManagedAgentsFileResourceParams struct {
+ // ID of a previously uploaded file.
+ FileID string `json:"file_id" api:"required"`
+ // Any of "file".
+ Type BetaManagedAgentsFileResourceParamsType `json:"type,omitzero" api:"required"`
+ // Mount path in the container. Defaults to `/mnt/session/uploads/`.
+ MountPath param.Opt[string] `json:"mount_path,omitzero"`
+ paramObj
+}
+
+func (r BetaManagedAgentsFileResourceParams) MarshalJSON() (data []byte, err error) {
+ type shadow BetaManagedAgentsFileResourceParams
+ return param.MarshalObject(r, (*shadow)(&r))
+}
+func (r *BetaManagedAgentsFileResourceParams) UnmarshalJSON(data []byte) error {
+ return apijson.UnmarshalRoot(data, r)
+}
+
+type BetaManagedAgentsFileResourceParamsType string
+
+const (
+ BetaManagedAgentsFileResourceParamsTypeFile BetaManagedAgentsFileResourceParamsType = "file"
+)
+
+// Mount a GitHub repository into the session's container.
+//
+// The properties AuthorizationToken, Type, URL are required.
+type BetaManagedAgentsGitHubRepositoryResourceParams struct {
+ // GitHub authorization token used to clone the repository.
+ AuthorizationToken string `json:"authorization_token" api:"required"`
+ // Any of "github_repository".
+ Type BetaManagedAgentsGitHubRepositoryResourceParamsType `json:"type,omitzero" api:"required"`
+ // Github URL of the repository
+ URL string `json:"url" api:"required"`
+ // Mount path in the container. Defaults to `/workspace/`.
+ MountPath param.Opt[string] `json:"mount_path,omitzero"`
+ // Branch or commit to check out. Defaults to the repository's default branch.
+ Checkout BetaManagedAgentsGitHubRepositoryResourceParamsCheckoutUnion `json:"checkout,omitzero"`
+ paramObj
+}
+
+func (r BetaManagedAgentsGitHubRepositoryResourceParams) MarshalJSON() (data []byte, err error) {
+ type shadow BetaManagedAgentsGitHubRepositoryResourceParams
+ return param.MarshalObject(r, (*shadow)(&r))
+}
+func (r *BetaManagedAgentsGitHubRepositoryResourceParams) UnmarshalJSON(data []byte) error {
+ return apijson.UnmarshalRoot(data, r)
+}
+
+type BetaManagedAgentsGitHubRepositoryResourceParamsType string
+
+const (
+ BetaManagedAgentsGitHubRepositoryResourceParamsTypeGitHubRepository BetaManagedAgentsGitHubRepositoryResourceParamsType = "github_repository"
+)
+
+// Only one field can be non-zero.
+//
+// Use [param.IsOmitted] to confirm if a field is set.
+type BetaManagedAgentsGitHubRepositoryResourceParamsCheckoutUnion struct {
+ OfBranch *BetaManagedAgentsBranchCheckoutParam `json:",omitzero,inline"`
+ OfCommit *BetaManagedAgentsCommitCheckoutParam `json:",omitzero,inline"`
+ paramUnion
+}
+
+func (u BetaManagedAgentsGitHubRepositoryResourceParamsCheckoutUnion) MarshalJSON() ([]byte, error) {
+ return param.MarshalUnion(u, u.OfBranch, u.OfCommit)
+}
+func (u *BetaManagedAgentsGitHubRepositoryResourceParamsCheckoutUnion) UnmarshalJSON(data []byte) error {
+ return apijson.UnmarshalRoot(data, u)
+}
+
+func (u *BetaManagedAgentsGitHubRepositoryResourceParamsCheckoutUnion) asAny() any {
+ if !param.IsOmitted(u.OfBranch) {
+ return u.OfBranch
+ } else if !param.IsOmitted(u.OfCommit) {
+ return u.OfCommit
+ }
+ return nil
+}
+
+// Returns a pointer to the underlying variant's property, if present.
+func (u BetaManagedAgentsGitHubRepositoryResourceParamsCheckoutUnion) GetName() *string {
+ if vt := u.OfBranch; vt != nil {
+ return &vt.Name
+ }
+ return nil
+}
+
+// Returns a pointer to the underlying variant's property, if present.
+func (u BetaManagedAgentsGitHubRepositoryResourceParamsCheckoutUnion) GetSha() *string {
+ if vt := u.OfCommit; vt != nil {
+ return &vt.Sha
+ }
+ return nil
+}
+
+// Returns a pointer to the underlying variant's property, if present.
+func (u BetaManagedAgentsGitHubRepositoryResourceParamsCheckoutUnion) GetType() *string {
+ if vt := u.OfBranch; vt != nil {
+ return (*string)(&vt.Type)
+ } else if vt := u.OfCommit; vt != nil {
+ return (*string)(&vt.Type)
+ }
+ return nil
+}
+
+func init() {
+ apijson.RegisterUnion[BetaManagedAgentsGitHubRepositoryResourceParamsCheckoutUnion](
+ "type",
+ apijson.Discriminator[BetaManagedAgentsBranchCheckoutParam]("branch"),
+ apijson.Discriminator[BetaManagedAgentsCommitCheckoutParam]("commit"),
+ )
+}
+
+// A Managed Agents `session`.
+type BetaManagedAgentsSession struct {
+ ID string `json:"id" api:"required"`
+ // Resolved `agent` definition for a `session`. Snapshot of the `agent` at
+ // `session` creation time.
+ Agent BetaManagedAgentsSessionAgent `json:"agent" api:"required"`
+ // A timestamp in RFC 3339 format
+ ArchivedAt time.Time `json:"archived_at" api:"required" format:"date-time"`
+ // A timestamp in RFC 3339 format
+ CreatedAt time.Time `json:"created_at" api:"required" format:"date-time"`
+ EnvironmentID string `json:"environment_id" api:"required"`
+ Metadata map[string]string `json:"metadata" api:"required"`
+ Resources []BetaManagedAgentsSessionResourceUnion `json:"resources" api:"required"`
+ // Timing statistics for a session.
+ Stats BetaManagedAgentsSessionStats `json:"stats" api:"required"`
+ // SessionStatus enum
+ //
+ // Any of "rescheduling", "running", "idle", "terminated".
+ Status BetaManagedAgentsSessionStatus `json:"status" api:"required"`
+ Title string `json:"title" api:"required"`
+ // Any of "session".
+ Type BetaManagedAgentsSessionType `json:"type" api:"required"`
+ // A timestamp in RFC 3339 format
+ UpdatedAt time.Time `json:"updated_at" api:"required" format:"date-time"`
+ // Cumulative token usage for a session across all turns.
+ Usage BetaManagedAgentsSessionUsage `json:"usage" api:"required"`
+ // Vault IDs attached to the session at creation. Empty when no vaults were
+ // supplied.
+ VaultIDs []string `json:"vault_ids" api:"required"`
+ // JSON contains metadata for fields, check presence with [respjson.Field.Valid].
+ JSON struct {
+ ID respjson.Field
+ Agent respjson.Field
+ ArchivedAt respjson.Field
+ CreatedAt respjson.Field
+ EnvironmentID respjson.Field
+ Metadata respjson.Field
+ Resources respjson.Field
+ Stats respjson.Field
+ Status respjson.Field
+ Title respjson.Field
+ Type respjson.Field
+ UpdatedAt respjson.Field
+ Usage respjson.Field
+ VaultIDs respjson.Field
+ ExtraFields map[string]respjson.Field
+ raw string
+ } `json:"-"`
+}
+
+// Returns the unmodified JSON received from the API
+func (r BetaManagedAgentsSession) RawJSON() string { return r.JSON.raw }
+func (r *BetaManagedAgentsSession) UnmarshalJSON(data []byte) error {
+ return apijson.UnmarshalRoot(data, r)
+}
+
+// SessionStatus enum
+type BetaManagedAgentsSessionStatus string
+
+const (
+ BetaManagedAgentsSessionStatusRescheduling BetaManagedAgentsSessionStatus = "rescheduling"
+ BetaManagedAgentsSessionStatusRunning BetaManagedAgentsSessionStatus = "running"
+ BetaManagedAgentsSessionStatusIdle BetaManagedAgentsSessionStatus = "idle"
+ BetaManagedAgentsSessionStatusTerminated BetaManagedAgentsSessionStatus = "terminated"
+)
+
+type BetaManagedAgentsSessionType string
+
+const (
+ BetaManagedAgentsSessionTypeSession BetaManagedAgentsSessionType = "session"
+)
+
+// Resolved `agent` definition for a `session`. Snapshot of the `agent` at
+// `session` creation time.
+type BetaManagedAgentsSessionAgent struct {
+ ID string `json:"id" api:"required"`
+ Description string `json:"description" api:"required"`
+ MCPServers []BetaManagedAgentsMCPServerURLDefinition `json:"mcp_servers" api:"required"`
+ // Model identifier and configuration.
+ Model BetaManagedAgentsModelConfig `json:"model" api:"required"`
+ Name string `json:"name" api:"required"`
+ Skills []BetaManagedAgentsSessionAgentSkillUnion `json:"skills" api:"required"`
+ System string `json:"system" api:"required"`
+ Tools []BetaManagedAgentsSessionAgentToolUnion `json:"tools" api:"required"`
+ // Any of "agent".
+ Type BetaManagedAgentsSessionAgentType `json:"type" api:"required"`
+ Version int64 `json:"version" api:"required"`
+ // JSON contains metadata for fields, check presence with [respjson.Field.Valid].
+ JSON struct {
+ ID respjson.Field
+ Description respjson.Field
+ MCPServers respjson.Field
+ Model respjson.Field
+ Name respjson.Field
+ Skills respjson.Field
+ System respjson.Field
+ Tools respjson.Field
+ Type respjson.Field
+ Version respjson.Field
+ ExtraFields map[string]respjson.Field
+ raw string
+ } `json:"-"`
+}
+
+// Returns the unmodified JSON received from the API
+func (r BetaManagedAgentsSessionAgent) RawJSON() string { return r.JSON.raw }
+func (r *BetaManagedAgentsSessionAgent) UnmarshalJSON(data []byte) error {
+ return apijson.UnmarshalRoot(data, r)
+}
+
+// BetaManagedAgentsSessionAgentSkillUnion contains all possible properties and
+// values from [BetaManagedAgentsAnthropicSkill], [BetaManagedAgentsCustomSkill].
+//
+// Use the [BetaManagedAgentsSessionAgentSkillUnion.AsAny] method to switch on the
+// variant.
+//
+// Use the methods beginning with 'As' to cast the union to one of its variants.
+type BetaManagedAgentsSessionAgentSkillUnion struct {
+ SkillID string `json:"skill_id"`
+ // Any of "anthropic", "custom".
+ Type string `json:"type"`
+ Version string `json:"version"`
+ JSON struct {
+ SkillID respjson.Field
+ Type respjson.Field
+ Version respjson.Field
+ raw string
+ } `json:"-"`
+}
+
+// anyBetaManagedAgentsSessionAgentSkill is implemented by each variant of
+// [BetaManagedAgentsSessionAgentSkillUnion] to add type safety for the return type
+// of [BetaManagedAgentsSessionAgentSkillUnion.AsAny]
+type anyBetaManagedAgentsSessionAgentSkill interface {
+ implBetaManagedAgentsSessionAgentSkillUnion()
+}
+
+func (BetaManagedAgentsAnthropicSkill) implBetaManagedAgentsSessionAgentSkillUnion() {}
+func (BetaManagedAgentsCustomSkill) implBetaManagedAgentsSessionAgentSkillUnion() {}
+
+// Use the following switch statement to find the correct variant
+//
+// switch variant := BetaManagedAgentsSessionAgentSkillUnion.AsAny().(type) {
+// case anthropic.BetaManagedAgentsAnthropicSkill:
+// case anthropic.BetaManagedAgentsCustomSkill:
+// default:
+// fmt.Errorf("no variant present")
+// }
+func (u BetaManagedAgentsSessionAgentSkillUnion) AsAny() anyBetaManagedAgentsSessionAgentSkill {
+ switch u.Type {
+ case "anthropic":
+ return u.AsAnthropic()
+ case "custom":
+ return u.AsCustom()
+ }
+ return nil
+}
+
+func (u BetaManagedAgentsSessionAgentSkillUnion) AsAnthropic() (v BetaManagedAgentsAnthropicSkill) {
+ apijson.UnmarshalRoot(json.RawMessage(u.JSON.raw), &v)
+ return
+}
+
+func (u BetaManagedAgentsSessionAgentSkillUnion) AsCustom() (v BetaManagedAgentsCustomSkill) {
+ apijson.UnmarshalRoot(json.RawMessage(u.JSON.raw), &v)
+ return
+}
+
+// Returns the unmodified JSON received from the API
+func (u BetaManagedAgentsSessionAgentSkillUnion) RawJSON() string { return u.JSON.raw }
+
+func (r *BetaManagedAgentsSessionAgentSkillUnion) UnmarshalJSON(data []byte) error {
+ return apijson.UnmarshalRoot(data, r)
+}
+
+// BetaManagedAgentsSessionAgentToolUnion contains all possible properties and
+// values from [BetaManagedAgentsAgentToolset20260401],
+// [BetaManagedAgentsMCPToolset], [BetaManagedAgentsCustomTool].
+//
+// Use the [BetaManagedAgentsSessionAgentToolUnion.AsAny] method to switch on the
+// variant.
+//
+// Use the methods beginning with 'As' to cast the union to one of its variants.
+type BetaManagedAgentsSessionAgentToolUnion struct {
+ // This field is a union of [[]BetaManagedAgentsAgentToolConfig],
+ // [[]BetaManagedAgentsMCPToolConfig]
+ Configs BetaManagedAgentsSessionAgentToolUnionConfigs `json:"configs"`
+ // This field is a union of [BetaManagedAgentsAgentToolsetDefaultConfig],
+ // [BetaManagedAgentsMCPToolsetDefaultConfig]
+ DefaultConfig BetaManagedAgentsSessionAgentToolUnionDefaultConfig `json:"default_config"`
+ // Any of "agent_toolset_20260401", "mcp_toolset", "custom".
+ Type string `json:"type"`
+ // This field is from variant [BetaManagedAgentsMCPToolset].
+ MCPServerName string `json:"mcp_server_name"`
+ // This field is from variant [BetaManagedAgentsCustomTool].
+ Description string `json:"description"`
+ // This field is from variant [BetaManagedAgentsCustomTool].
+ InputSchema BetaManagedAgentsCustomToolInputSchema `json:"input_schema"`
+ // This field is from variant [BetaManagedAgentsCustomTool].
+ Name string `json:"name"`
+ JSON struct {
+ Configs respjson.Field
+ DefaultConfig respjson.Field
+ Type respjson.Field
+ MCPServerName respjson.Field
+ Description respjson.Field
+ InputSchema respjson.Field
+ Name respjson.Field
+ raw string
+ } `json:"-"`
+}
+
+// anyBetaManagedAgentsSessionAgentTool is implemented by each variant of
+// [BetaManagedAgentsSessionAgentToolUnion] to add type safety for the return type
+// of [BetaManagedAgentsSessionAgentToolUnion.AsAny]
+type anyBetaManagedAgentsSessionAgentTool interface {
+ implBetaManagedAgentsSessionAgentToolUnion()
+}
+
+func (BetaManagedAgentsAgentToolset20260401) implBetaManagedAgentsSessionAgentToolUnion() {}
+func (BetaManagedAgentsMCPToolset) implBetaManagedAgentsSessionAgentToolUnion() {}
+func (BetaManagedAgentsCustomTool) implBetaManagedAgentsSessionAgentToolUnion() {}
+
+// Use the following switch statement to find the correct variant
+//
+// switch variant := BetaManagedAgentsSessionAgentToolUnion.AsAny().(type) {
+// case anthropic.BetaManagedAgentsAgentToolset20260401:
+// case anthropic.BetaManagedAgentsMCPToolset:
+// case anthropic.BetaManagedAgentsCustomTool:
+// default:
+// fmt.Errorf("no variant present")
+// }
+func (u BetaManagedAgentsSessionAgentToolUnion) AsAny() anyBetaManagedAgentsSessionAgentTool {
+ switch u.Type {
+ case "agent_toolset_20260401":
+ return u.AsAgentToolset20260401()
+ case "mcp_toolset":
+ return u.AsMCPToolset()
+ case "custom":
+ return u.AsCustom()
+ }
+ return nil
+}
+
+func (u BetaManagedAgentsSessionAgentToolUnion) AsAgentToolset20260401() (v BetaManagedAgentsAgentToolset20260401) {
+ apijson.UnmarshalRoot(json.RawMessage(u.JSON.raw), &v)
+ return
+}
+
+func (u BetaManagedAgentsSessionAgentToolUnion) AsMCPToolset() (v BetaManagedAgentsMCPToolset) {
+ apijson.UnmarshalRoot(json.RawMessage(u.JSON.raw), &v)
+ return
+}
+
+func (u BetaManagedAgentsSessionAgentToolUnion) AsCustom() (v BetaManagedAgentsCustomTool) {
+ apijson.UnmarshalRoot(json.RawMessage(u.JSON.raw), &v)
+ return
+}
+
+// Returns the unmodified JSON received from the API
+func (u BetaManagedAgentsSessionAgentToolUnion) RawJSON() string { return u.JSON.raw }
+
+func (r *BetaManagedAgentsSessionAgentToolUnion) UnmarshalJSON(data []byte) error {
+ return apijson.UnmarshalRoot(data, r)
+}
+
+// BetaManagedAgentsSessionAgentToolUnionConfigs is an implicit subunion of
+// [BetaManagedAgentsSessionAgentToolUnion].
+// BetaManagedAgentsSessionAgentToolUnionConfigs provides convenient access to the
+// sub-properties of the union.
+//
+// For type safety it is recommended to directly use a variant of the
+// [BetaManagedAgentsSessionAgentToolUnion].
+//
+// If the underlying value is not a json object, one of the following properties
+// will be valid: OfBetaManagedAgentsAgentToolConfigArray
+// OfBetaManagedAgentsMCPToolConfigArray]
+type BetaManagedAgentsSessionAgentToolUnionConfigs struct {
+ // This field will be present if the value is a
+ // [[]BetaManagedAgentsAgentToolConfig] instead of an object.
+ OfBetaManagedAgentsAgentToolConfigArray []BetaManagedAgentsAgentToolConfig `json:",inline"`
+ // This field will be present if the value is a [[]BetaManagedAgentsMCPToolConfig]
+ // instead of an object.
+ OfBetaManagedAgentsMCPToolConfigArray []BetaManagedAgentsMCPToolConfig `json:",inline"`
+ JSON struct {
+ OfBetaManagedAgentsAgentToolConfigArray respjson.Field
+ OfBetaManagedAgentsMCPToolConfigArray respjson.Field
+ raw string
+ } `json:"-"`
+}
+
+func (r *BetaManagedAgentsSessionAgentToolUnionConfigs) UnmarshalJSON(data []byte) error {
+ return apijson.UnmarshalRoot(data, r)
+}
+
+// BetaManagedAgentsSessionAgentToolUnionDefaultConfig is an implicit subunion of
+// [BetaManagedAgentsSessionAgentToolUnion].
+// BetaManagedAgentsSessionAgentToolUnionDefaultConfig provides convenient access
+// to the sub-properties of the union.
+//
+// For type safety it is recommended to directly use a variant of the
+// [BetaManagedAgentsSessionAgentToolUnion].
+type BetaManagedAgentsSessionAgentToolUnionDefaultConfig struct {
+ Enabled bool `json:"enabled"`
+ // This field is a union of
+ // [BetaManagedAgentsAgentToolsetDefaultConfigPermissionPolicyUnion],
+ // [BetaManagedAgentsMCPToolsetDefaultConfigPermissionPolicyUnion]
+ PermissionPolicy BetaManagedAgentsSessionAgentToolUnionDefaultConfigPermissionPolicy `json:"permission_policy"`
+ JSON struct {
+ Enabled respjson.Field
+ PermissionPolicy respjson.Field
+ raw string
+ } `json:"-"`
+}
+
+func (r *BetaManagedAgentsSessionAgentToolUnionDefaultConfig) UnmarshalJSON(data []byte) error {
+ return apijson.UnmarshalRoot(data, r)
+}
+
+// BetaManagedAgentsSessionAgentToolUnionDefaultConfigPermissionPolicy is an
+// implicit subunion of [BetaManagedAgentsSessionAgentToolUnion].
+// BetaManagedAgentsSessionAgentToolUnionDefaultConfigPermissionPolicy provides
+// convenient access to the sub-properties of the union.
+//
+// For type safety it is recommended to directly use a variant of the
+// [BetaManagedAgentsSessionAgentToolUnion].
+type BetaManagedAgentsSessionAgentToolUnionDefaultConfigPermissionPolicy struct {
+ Type string `json:"type"`
+ JSON struct {
+ Type respjson.Field
+ raw string
+ } `json:"-"`
+}
+
+func (r *BetaManagedAgentsSessionAgentToolUnionDefaultConfigPermissionPolicy) UnmarshalJSON(data []byte) error {
+ return apijson.UnmarshalRoot(data, r)
+}
+
+type BetaManagedAgentsSessionAgentType string
+
+const (
+ BetaManagedAgentsSessionAgentTypeAgent BetaManagedAgentsSessionAgentType = "agent"
+)
+
+// Timing statistics for a session.
+type BetaManagedAgentsSessionStats struct {
+ // Cumulative time in seconds the session spent in running status. Excludes idle
+ // time.
+ ActiveSeconds float64 `json:"active_seconds"`
+ // Elapsed time since session creation in seconds. For terminated sessions, frozen
+ // at the final update.
+ DurationSeconds float64 `json:"duration_seconds"`
+ // JSON contains metadata for fields, check presence with [respjson.Field.Valid].
+ JSON struct {
+ ActiveSeconds respjson.Field
+ DurationSeconds respjson.Field
+ ExtraFields map[string]respjson.Field
+ raw string
+ } `json:"-"`
+}
+
+// Returns the unmodified JSON received from the API
+func (r BetaManagedAgentsSessionStats) RawJSON() string { return r.JSON.raw }
+func (r *BetaManagedAgentsSessionStats) UnmarshalJSON(data []byte) error {
+ return apijson.UnmarshalRoot(data, r)
+}
+
+// Cumulative token usage for a session across all turns.
+type BetaManagedAgentsSessionUsage struct {
+ // Prompt-cache creation token usage broken down by cache lifetime.
+ CacheCreation BetaManagedAgentsCacheCreationUsage `json:"cache_creation"`
+ // Total tokens read from prompt cache.
+ CacheReadInputTokens int64 `json:"cache_read_input_tokens"`
+ // Total input tokens consumed across all turns.
+ InputTokens int64 `json:"input_tokens"`
+ // Total output tokens generated across all turns.
+ OutputTokens int64 `json:"output_tokens"`
+ // JSON contains metadata for fields, check presence with [respjson.Field.Valid].
+ JSON struct {
+ CacheCreation respjson.Field
+ CacheReadInputTokens respjson.Field
+ InputTokens respjson.Field
+ OutputTokens respjson.Field
+ ExtraFields map[string]respjson.Field
+ raw string
+ } `json:"-"`
+}
+
+// Returns the unmodified JSON received from the API
+func (r BetaManagedAgentsSessionUsage) RawJSON() string { return r.JSON.raw }
+func (r *BetaManagedAgentsSessionUsage) UnmarshalJSON(data []byte) error {
+ return apijson.UnmarshalRoot(data, r)
+}
+
+type BetaSessionNewParams struct {
+ // Agent identifier. Accepts the `agent` ID string, which pins the latest version
+ // for the session, or an `agent` object with both id and version specified.
+ Agent BetaSessionNewParamsAgentUnion `json:"agent,omitzero" api:"required"`
+ // ID of the `environment` defining the container configuration for this session.
+ EnvironmentID string `json:"environment_id" api:"required"`
+ // Human-readable session title.
+ Title param.Opt[string] `json:"title,omitzero"`
+ // Arbitrary key-value metadata attached to the session. Maximum 16 pairs, keys up
+ // to 64 chars, values up to 512 chars.
+ Metadata map[string]string `json:"metadata,omitzero"`
+ // Resources (e.g. repositories, files) to mount into the session's container.
+ Resources []BetaSessionNewParamsResourceUnion `json:"resources,omitzero"`
+ // Vault IDs for stored credentials the agent can use during the session.
+ VaultIDs []string `json:"vault_ids,omitzero"`
+ // Optional header to specify the beta version(s) you want to use.
+ Betas []AnthropicBeta `header:"anthropic-beta,omitzero" json:"-"`
+ paramObj
+}
+
+func (r BetaSessionNewParams) MarshalJSON() (data []byte, err error) {
+ type shadow BetaSessionNewParams
+ return param.MarshalObject(r, (*shadow)(&r))
+}
+func (r *BetaSessionNewParams) UnmarshalJSON(data []byte) error {
+ return apijson.UnmarshalRoot(data, r)
+}
+
+// Only one field can be non-zero.
+//
+// Use [param.IsOmitted] to confirm if a field is set.
+type BetaSessionNewParamsAgentUnion struct {
+ OfString param.Opt[string] `json:",omitzero,inline"`
+ OfBetaManagedAgentsAgents *BetaManagedAgentsAgentParams `json:",omitzero,inline"`
+ paramUnion
+}
+
+func (u BetaSessionNewParamsAgentUnion) MarshalJSON() ([]byte, error) {
+ return param.MarshalUnion(u, u.OfString, u.OfBetaManagedAgentsAgents)
+}
+func (u *BetaSessionNewParamsAgentUnion) UnmarshalJSON(data []byte) error {
+ return apijson.UnmarshalRoot(data, u)
+}
+
+func (u *BetaSessionNewParamsAgentUnion) asAny() any {
+ if !param.IsOmitted(u.OfString) {
+ return &u.OfString.Value
+ } else if !param.IsOmitted(u.OfBetaManagedAgentsAgents) {
+ return u.OfBetaManagedAgentsAgents
+ }
+ return nil
+}
+
+// Only one field can be non-zero.
+//
+// Use [param.IsOmitted] to confirm if a field is set.
+type BetaSessionNewParamsResourceUnion struct {
+ OfGitHubRepository *BetaManagedAgentsGitHubRepositoryResourceParams `json:",omitzero,inline"`
+ OfFile *BetaManagedAgentsFileResourceParams `json:",omitzero,inline"`
+ paramUnion
+}
+
+func (u BetaSessionNewParamsResourceUnion) MarshalJSON() ([]byte, error) {
+ return param.MarshalUnion(u, u.OfGitHubRepository, u.OfFile)
+}
+func (u *BetaSessionNewParamsResourceUnion) UnmarshalJSON(data []byte) error {
+ return apijson.UnmarshalRoot(data, u)
+}
+
+func (u *BetaSessionNewParamsResourceUnion) asAny() any {
+ if !param.IsOmitted(u.OfGitHubRepository) {
+ return u.OfGitHubRepository
+ } else if !param.IsOmitted(u.OfFile) {
+ return u.OfFile
+ }
+ return nil
+}
+
+// Returns a pointer to the underlying variant's property, if present.
+func (u BetaSessionNewParamsResourceUnion) GetAuthorizationToken() *string {
+ if vt := u.OfGitHubRepository; vt != nil {
+ return &vt.AuthorizationToken
+ }
+ return nil
+}
+
+// Returns a pointer to the underlying variant's property, if present.
+func (u BetaSessionNewParamsResourceUnion) GetURL() *string {
+ if vt := u.OfGitHubRepository; vt != nil {
+ return &vt.URL
+ }
+ return nil
+}
+
+// Returns a pointer to the underlying variant's property, if present.
+func (u BetaSessionNewParamsResourceUnion) GetCheckout() *BetaManagedAgentsGitHubRepositoryResourceParamsCheckoutUnion {
+ if vt := u.OfGitHubRepository; vt != nil {
+ return &vt.Checkout
+ }
+ return nil
+}
+
+// Returns a pointer to the underlying variant's property, if present.
+func (u BetaSessionNewParamsResourceUnion) GetFileID() *string {
+ if vt := u.OfFile; vt != nil {
+ return &vt.FileID
+ }
+ return nil
+}
+
+// Returns a pointer to the underlying variant's property, if present.
+func (u BetaSessionNewParamsResourceUnion) GetType() *string {
+ if vt := u.OfGitHubRepository; vt != nil {
+ return (*string)(&vt.Type)
+ } else if vt := u.OfFile; vt != nil {
+ return (*string)(&vt.Type)
+ }
+ return nil
+}
+
+// Returns a pointer to the underlying variant's property, if present.
+func (u BetaSessionNewParamsResourceUnion) GetMountPath() *string {
+ if vt := u.OfGitHubRepository; vt != nil && vt.MountPath.Valid() {
+ return &vt.MountPath.Value
+ } else if vt := u.OfFile; vt != nil && vt.MountPath.Valid() {
+ return &vt.MountPath.Value
+ }
+ return nil
+}
+
+func init() {
+ apijson.RegisterUnion[BetaSessionNewParamsResourceUnion](
+ "type",
+ apijson.Discriminator[BetaManagedAgentsGitHubRepositoryResourceParams]("github_repository"),
+ apijson.Discriminator[BetaManagedAgentsFileResourceParams]("file"),
+ )
+}
+
+type BetaSessionGetParams struct {
+ // Optional header to specify the beta version(s) you want to use.
+ Betas []AnthropicBeta `header:"anthropic-beta,omitzero" json:"-"`
+ paramObj
+}
+
+type BetaSessionUpdateParams struct {
+ // Human-readable session title.
+ Title param.Opt[string] `json:"title,omitzero"`
+ // Metadata patch. Set a key to a string to upsert it, or to null to delete it.
+ // Omit the field to preserve.
+ Metadata map[string]string `json:"metadata,omitzero"`
+ // Vault IDs (`vlt_*`) to attach to the session. Not yet supported; requests
+ // setting this field are rejected. Reserved for future use.
+ VaultIDs []string `json:"vault_ids,omitzero"`
+ // Optional header to specify the beta version(s) you want to use.
+ Betas []AnthropicBeta `header:"anthropic-beta,omitzero" json:"-"`
+ paramObj
+}
+
+func (r BetaSessionUpdateParams) MarshalJSON() (data []byte, err error) {
+ type shadow BetaSessionUpdateParams
+ return param.MarshalObject(r, (*shadow)(&r))
+}
+func (r *BetaSessionUpdateParams) UnmarshalJSON(data []byte) error {
+ return apijson.UnmarshalRoot(data, r)
+}
+
+type BetaSessionListParams struct {
+ // Filter sessions created with this agent ID.
+ AgentID param.Opt[string] `query:"agent_id,omitzero" json:"-"`
+ // Filter by agent version. Only applies when agent_id is also set.
+ AgentVersion param.Opt[int64] `query:"agent_version,omitzero" json:"-"`
+ // Return sessions created after this time (exclusive).
+ CreatedAtGt param.Opt[time.Time] `query:"created_at[gt],omitzero" format:"date-time" json:"-"`
+ // Return sessions created at or after this time (inclusive).
+ CreatedAtGte param.Opt[time.Time] `query:"created_at[gte],omitzero" format:"date-time" json:"-"`
+ // Return sessions created before this time (exclusive).
+ CreatedAtLt param.Opt[time.Time] `query:"created_at[lt],omitzero" format:"date-time" json:"-"`
+ // Return sessions created at or before this time (inclusive).
+ CreatedAtLte param.Opt[time.Time] `query:"created_at[lte],omitzero" format:"date-time" json:"-"`
+ // When true, includes archived sessions. Default: false (exclude archived).
+ IncludeArchived param.Opt[bool] `query:"include_archived,omitzero" json:"-"`
+ // Maximum number of results to return.
+ Limit param.Opt[int64] `query:"limit,omitzero" json:"-"`
+ // Opaque pagination cursor from a previous response's next_page.
+ Page param.Opt[string] `query:"page,omitzero" json:"-"`
+ // Sort direction for results, ordered by created_at. Defaults to desc (newest
+ // first).
+ //
+ // Any of "asc", "desc".
+ Order BetaSessionListParamsOrder `query:"order,omitzero" json:"-"`
+ // Optional header to specify the beta version(s) you want to use.
+ Betas []AnthropicBeta `header:"anthropic-beta,omitzero" json:"-"`
+ paramObj
+}
+
+// URLQuery serializes [BetaSessionListParams]'s query parameters as `url.Values`.
+func (r BetaSessionListParams) URLQuery() (v url.Values, err error) {
+ return apiquery.MarshalWithSettings(r, apiquery.QuerySettings{
+ ArrayFormat: apiquery.ArrayQueryFormatComma,
+ NestedFormat: apiquery.NestedQueryFormatBrackets,
+ })
+}
+
+// Sort direction for results, ordered by created_at. Defaults to desc (newest
+// first).
+type BetaSessionListParamsOrder string
+
+const (
+ BetaSessionListParamsOrderAsc BetaSessionListParamsOrder = "asc"
+ BetaSessionListParamsOrderDesc BetaSessionListParamsOrder = "desc"
+)
+
+type BetaSessionDeleteParams struct {
+ // Optional header to specify the beta version(s) you want to use.
+ Betas []AnthropicBeta `header:"anthropic-beta,omitzero" json:"-"`
+ paramObj
+}
+
+type BetaSessionArchiveParams struct {
+ // Optional header to specify the beta version(s) you want to use.
+ Betas []AnthropicBeta `header:"anthropic-beta,omitzero" json:"-"`
+ paramObj
+}
diff --git a/betasession_test.go b/betasession_test.go
new file mode 100644
index 000000000..b636a52d0
--- /dev/null
+++ b/betasession_test.go
@@ -0,0 +1,207 @@
+// File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+package anthropic_test
+
+import (
+ "context"
+ "errors"
+ "os"
+ "testing"
+ "time"
+
+ "github.com/anthropics/anthropic-sdk-go"
+ "github.com/anthropics/anthropic-sdk-go/internal/testutil"
+ "github.com/anthropics/anthropic-sdk-go/option"
+)
+
+func TestBetaSessionNewWithOptionalParams(t *testing.T) {
+ baseURL := "http://localhost:4010"
+ if envURL, ok := os.LookupEnv("TEST_API_BASE_URL"); ok {
+ baseURL = envURL
+ }
+ if !testutil.CheckTestServer(t, baseURL) {
+ return
+ }
+ client := anthropic.NewClient(
+ option.WithBaseURL(baseURL),
+ option.WithAPIKey("my-anthropic-api-key"),
+ )
+ _, err := client.Beta.Sessions.New(context.TODO(), anthropic.BetaSessionNewParams{
+ Agent: anthropic.BetaSessionNewParamsAgentUnion{
+ OfString: anthropic.String("agent_011CZkYpogX7uDKUyvBTophP"),
+ },
+ EnvironmentID: "env_011CZkZ9X2dpNyB7HsEFoRfW",
+ Metadata: map[string]string{
+ "foo": "string",
+ },
+ Resources: []anthropic.BetaSessionNewParamsResourceUnion{{
+ OfFile: &anthropic.BetaManagedAgentsFileResourceParams{
+ FileID: "file_011CNha8iCJcU1wXNR6q4V8w",
+ Type: anthropic.BetaManagedAgentsFileResourceParamsTypeFile,
+ MountPath: anthropic.String("/uploads/receipt.pdf"),
+ },
+ }},
+ Title: anthropic.String("Order #1234 inquiry"),
+ VaultIDs: []string{"string"},
+ Betas: []anthropic.AnthropicBeta{anthropic.AnthropicBetaMessageBatches2024_09_24},
+ })
+ if err != nil {
+ var apierr *anthropic.Error
+ if errors.As(err, &apierr) {
+ t.Log(string(apierr.DumpRequest(true)))
+ }
+ t.Fatalf("err should be nil: %s", err.Error())
+ }
+}
+
+func TestBetaSessionGetWithOptionalParams(t *testing.T) {
+ baseURL := "http://localhost:4010"
+ if envURL, ok := os.LookupEnv("TEST_API_BASE_URL"); ok {
+ baseURL = envURL
+ }
+ if !testutil.CheckTestServer(t, baseURL) {
+ return
+ }
+ client := anthropic.NewClient(
+ option.WithBaseURL(baseURL),
+ option.WithAPIKey("my-anthropic-api-key"),
+ )
+ _, err := client.Beta.Sessions.Get(
+ context.TODO(),
+ "sesn_011CZkZAtmR3yMPDzynEDxu7",
+ anthropic.BetaSessionGetParams{
+ Betas: []anthropic.AnthropicBeta{anthropic.AnthropicBetaMessageBatches2024_09_24},
+ },
+ )
+ if err != nil {
+ var apierr *anthropic.Error
+ if errors.As(err, &apierr) {
+ t.Log(string(apierr.DumpRequest(true)))
+ }
+ t.Fatalf("err should be nil: %s", err.Error())
+ }
+}
+
+func TestBetaSessionUpdateWithOptionalParams(t *testing.T) {
+ baseURL := "http://localhost:4010"
+ if envURL, ok := os.LookupEnv("TEST_API_BASE_URL"); ok {
+ baseURL = envURL
+ }
+ if !testutil.CheckTestServer(t, baseURL) {
+ return
+ }
+ client := anthropic.NewClient(
+ option.WithBaseURL(baseURL),
+ option.WithAPIKey("my-anthropic-api-key"),
+ )
+ _, err := client.Beta.Sessions.Update(
+ context.TODO(),
+ "sesn_011CZkZAtmR3yMPDzynEDxu7",
+ anthropic.BetaSessionUpdateParams{
+ Metadata: map[string]string{
+ "foo": "string",
+ },
+ Title: anthropic.String("Order #1234 inquiry"),
+ VaultIDs: []string{"string"},
+ Betas: []anthropic.AnthropicBeta{anthropic.AnthropicBetaMessageBatches2024_09_24},
+ },
+ )
+ if err != nil {
+ var apierr *anthropic.Error
+ if errors.As(err, &apierr) {
+ t.Log(string(apierr.DumpRequest(true)))
+ }
+ t.Fatalf("err should be nil: %s", err.Error())
+ }
+}
+
+func TestBetaSessionListWithOptionalParams(t *testing.T) {
+ t.Skip("buildURL drops path-level query params (SDK-4349)")
+ baseURL := "http://localhost:4010"
+ if envURL, ok := os.LookupEnv("TEST_API_BASE_URL"); ok {
+ baseURL = envURL
+ }
+ if !testutil.CheckTestServer(t, baseURL) {
+ return
+ }
+ client := anthropic.NewClient(
+ option.WithBaseURL(baseURL),
+ option.WithAPIKey("my-anthropic-api-key"),
+ )
+ _, err := client.Beta.Sessions.List(context.TODO(), anthropic.BetaSessionListParams{
+ AgentID: anthropic.String("agent_id"),
+ AgentVersion: anthropic.Int(0),
+ CreatedAtGt: anthropic.Time(time.Now()),
+ CreatedAtGte: anthropic.Time(time.Now()),
+ CreatedAtLt: anthropic.Time(time.Now()),
+ CreatedAtLte: anthropic.Time(time.Now()),
+ IncludeArchived: anthropic.Bool(true),
+ Limit: anthropic.Int(0),
+ Order: anthropic.BetaSessionListParamsOrderAsc,
+ Page: anthropic.String("page"),
+ Betas: []anthropic.AnthropicBeta{anthropic.AnthropicBetaMessageBatches2024_09_24},
+ })
+ if err != nil {
+ var apierr *anthropic.Error
+ if errors.As(err, &apierr) {
+ t.Log(string(apierr.DumpRequest(true)))
+ }
+ t.Fatalf("err should be nil: %s", err.Error())
+ }
+}
+
+func TestBetaSessionDeleteWithOptionalParams(t *testing.T) {
+ baseURL := "http://localhost:4010"
+ if envURL, ok := os.LookupEnv("TEST_API_BASE_URL"); ok {
+ baseURL = envURL
+ }
+ if !testutil.CheckTestServer(t, baseURL) {
+ return
+ }
+ client := anthropic.NewClient(
+ option.WithBaseURL(baseURL),
+ option.WithAPIKey("my-anthropic-api-key"),
+ )
+ _, err := client.Beta.Sessions.Delete(
+ context.TODO(),
+ "sesn_011CZkZAtmR3yMPDzynEDxu7",
+ anthropic.BetaSessionDeleteParams{
+ Betas: []anthropic.AnthropicBeta{anthropic.AnthropicBetaMessageBatches2024_09_24},
+ },
+ )
+ if err != nil {
+ var apierr *anthropic.Error
+ if errors.As(err, &apierr) {
+ t.Log(string(apierr.DumpRequest(true)))
+ }
+ t.Fatalf("err should be nil: %s", err.Error())
+ }
+}
+
+func TestBetaSessionArchiveWithOptionalParams(t *testing.T) {
+ baseURL := "http://localhost:4010"
+ if envURL, ok := os.LookupEnv("TEST_API_BASE_URL"); ok {
+ baseURL = envURL
+ }
+ if !testutil.CheckTestServer(t, baseURL) {
+ return
+ }
+ client := anthropic.NewClient(
+ option.WithBaseURL(baseURL),
+ option.WithAPIKey("my-anthropic-api-key"),
+ )
+ _, err := client.Beta.Sessions.Archive(
+ context.TODO(),
+ "sesn_011CZkZAtmR3yMPDzynEDxu7",
+ anthropic.BetaSessionArchiveParams{
+ Betas: []anthropic.AnthropicBeta{anthropic.AnthropicBetaMessageBatches2024_09_24},
+ },
+ )
+ if err != nil {
+ var apierr *anthropic.Error
+ if errors.As(err, &apierr) {
+ t.Log(string(apierr.DumpRequest(true)))
+ }
+ t.Fatalf("err should be nil: %s", err.Error())
+ }
+}
diff --git a/betasessionevent.go b/betasessionevent.go
new file mode 100644
index 000000000..9e9e38aa1
--- /dev/null
+++ b/betasessionevent.go
@@ -0,0 +1,4879 @@
+// File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+package anthropic
+
+import (
+ "context"
+ "encoding/json"
+ "errors"
+ "fmt"
+ "net/http"
+ "net/url"
+ "slices"
+ "time"
+
+ "github.com/anthropics/anthropic-sdk-go/internal/apijson"
+ "github.com/anthropics/anthropic-sdk-go/internal/apiquery"
+ "github.com/anthropics/anthropic-sdk-go/internal/requestconfig"
+ "github.com/anthropics/anthropic-sdk-go/option"
+ "github.com/anthropics/anthropic-sdk-go/packages/pagination"
+ "github.com/anthropics/anthropic-sdk-go/packages/param"
+ "github.com/anthropics/anthropic-sdk-go/packages/respjson"
+ "github.com/anthropics/anthropic-sdk-go/packages/ssestream"
+)
+
+// BetaSessionEventService contains methods and other services that help with
+// interacting with the anthropic API.
+//
+// Note, unlike clients, this service does not read variables from the environment
+// automatically. You should not instantiate this service directly, and instead use
+// the [NewBetaSessionEventService] method instead.
+type BetaSessionEventService struct {
+ Options []option.RequestOption
+}
+
+// NewBetaSessionEventService generates a new service that applies the given
+// options to each request. These options are applied after the parent client's
+// options (if there is one), and before any request-specific options.
+func NewBetaSessionEventService(opts ...option.RequestOption) (r BetaSessionEventService) {
+ r = BetaSessionEventService{}
+ r.Options = opts
+ return
+}
+
+// List Events
+func (r *BetaSessionEventService) List(ctx context.Context, sessionID string, params BetaSessionEventListParams, opts ...option.RequestOption) (res *pagination.PageCursor[BetaManagedAgentsSessionEventUnion], err error) {
+ var raw *http.Response
+ for _, v := range params.Betas {
+ opts = append(opts, option.WithHeaderAdd("anthropic-beta", fmt.Sprintf("%v", v)))
+ }
+ opts = slices.Concat(r.Options, opts)
+ opts = append([]option.RequestOption{option.WithHeader("anthropic-beta", "managed-agents-2026-04-01"), option.WithResponseInto(&raw)}, opts...)
+ if sessionID == "" {
+ err = errors.New("missing required session_id parameter")
+ return nil, err
+ }
+ path := fmt.Sprintf("v1/sessions/%s/events?beta=true", sessionID)
+ cfg, err := requestconfig.NewRequestConfig(ctx, http.MethodGet, path, params, &res, opts...)
+ if err != nil {
+ return nil, err
+ }
+ err = cfg.Execute()
+ if err != nil {
+ return nil, err
+ }
+ res.SetPageConfig(cfg, raw)
+ return res, nil
+}
+
+// List Events
+func (r *BetaSessionEventService) ListAutoPaging(ctx context.Context, sessionID string, params BetaSessionEventListParams, opts ...option.RequestOption) *pagination.PageCursorAutoPager[BetaManagedAgentsSessionEventUnion] {
+ return pagination.NewPageCursorAutoPager(r.List(ctx, sessionID, params, opts...))
+}
+
+// Send Events
+func (r *BetaSessionEventService) Send(ctx context.Context, sessionID string, params BetaSessionEventSendParams, opts ...option.RequestOption) (res *BetaManagedAgentsSendSessionEvents, err error) {
+ for _, v := range params.Betas {
+ opts = append(opts, option.WithHeaderAdd("anthropic-beta", fmt.Sprintf("%v", v)))
+ }
+ opts = slices.Concat(r.Options, opts)
+ opts = append([]option.RequestOption{option.WithHeader("anthropic-beta", "managed-agents-2026-04-01")}, opts...)
+ if sessionID == "" {
+ err = errors.New("missing required session_id parameter")
+ return nil, err
+ }
+ path := fmt.Sprintf("v1/sessions/%s/events?beta=true", sessionID)
+ err = requestconfig.ExecuteNewRequest(ctx, http.MethodPost, path, params, &res, opts...)
+ return res, err
+}
+
+// Stream Events
+func (r *BetaSessionEventService) StreamEvents(ctx context.Context, sessionID string, query BetaSessionEventStreamParams, opts ...option.RequestOption) (stream *ssestream.Stream[BetaManagedAgentsStreamSessionEventsUnion]) {
+ var (
+ raw *http.Response
+ err error
+ )
+ for _, v := range query.Betas {
+ opts = append(opts, option.WithHeaderAdd("anthropic-beta", fmt.Sprintf("%v", v)))
+ }
+ opts = slices.Concat(r.Options, opts)
+ opts = append([]option.RequestOption{option.WithHeader("anthropic-beta", "managed-agents-2026-04-01")}, opts...)
+ if sessionID == "" {
+ err = errors.New("missing required session_id parameter")
+ return ssestream.NewStream[BetaManagedAgentsStreamSessionEventsUnion](nil, err)
+ }
+ path := fmt.Sprintf("v1/sessions/%s/events/stream?beta=true", sessionID)
+ err = requestconfig.ExecuteNewRequest(ctx, http.MethodGet, path, nil, &raw, opts...)
+ return ssestream.NewStream[BetaManagedAgentsStreamSessionEventsUnion](ssestream.NewDecoder(raw), err)
+}
+
+// Event emitted when the agent calls a custom tool. The session goes idle until
+// the client sends a `user.custom_tool_result` event with the result.
+type BetaManagedAgentsAgentCustomToolUseEvent struct {
+ // Unique identifier for this event.
+ ID string `json:"id" api:"required"`
+ // Input parameters for the tool call.
+ Input map[string]any `json:"input" api:"required"`
+ // Name of the custom tool being called.
+ Name string `json:"name" api:"required"`
+ // A timestamp in RFC 3339 format
+ ProcessedAt time.Time `json:"processed_at" api:"required" format:"date-time"`
+ // Any of "agent.custom_tool_use".
+ Type BetaManagedAgentsAgentCustomToolUseEventType `json:"type" api:"required"`
+ // JSON contains metadata for fields, check presence with [respjson.Field.Valid].
+ JSON struct {
+ ID respjson.Field
+ Input respjson.Field
+ Name respjson.Field
+ ProcessedAt respjson.Field
+ Type respjson.Field
+ ExtraFields map[string]respjson.Field
+ raw string
+ } `json:"-"`
+}
+
+// Returns the unmodified JSON received from the API
+func (r BetaManagedAgentsAgentCustomToolUseEvent) RawJSON() string { return r.JSON.raw }
+func (r *BetaManagedAgentsAgentCustomToolUseEvent) UnmarshalJSON(data []byte) error {
+ return apijson.UnmarshalRoot(data, r)
+}
+
+type BetaManagedAgentsAgentCustomToolUseEventType string
+
+const (
+ BetaManagedAgentsAgentCustomToolUseEventTypeAgentCustomToolUse BetaManagedAgentsAgentCustomToolUseEventType = "agent.custom_tool_use"
+)
+
+// Event representing the result of an MCP tool execution.
+type BetaManagedAgentsAgentMCPToolResultEvent struct {
+ // Unique identifier for this event.
+ ID string `json:"id" api:"required"`
+ // The id of the `agent.mcp_tool_use` event this result corresponds to.
+ MCPToolUseID string `json:"mcp_tool_use_id" api:"required"`
+ // A timestamp in RFC 3339 format
+ ProcessedAt time.Time `json:"processed_at" api:"required" format:"date-time"`
+ // Any of "agent.mcp_tool_result".
+ Type BetaManagedAgentsAgentMCPToolResultEventType `json:"type" api:"required"`
+ // The result content returned by the tool.
+ Content []BetaManagedAgentsAgentMCPToolResultEventContentUnion `json:"content"`
+ // Whether the tool execution resulted in an error.
+ IsError bool `json:"is_error" api:"nullable"`
+ // JSON contains metadata for fields, check presence with [respjson.Field.Valid].
+ JSON struct {
+ ID respjson.Field
+ MCPToolUseID respjson.Field
+ ProcessedAt respjson.Field
+ Type respjson.Field
+ Content respjson.Field
+ IsError respjson.Field
+ ExtraFields map[string]respjson.Field
+ raw string
+ } `json:"-"`
+}
+
+// Returns the unmodified JSON received from the API
+func (r BetaManagedAgentsAgentMCPToolResultEvent) RawJSON() string { return r.JSON.raw }
+func (r *BetaManagedAgentsAgentMCPToolResultEvent) UnmarshalJSON(data []byte) error {
+ return apijson.UnmarshalRoot(data, r)
+}
+
+type BetaManagedAgentsAgentMCPToolResultEventType string
+
+const (
+ BetaManagedAgentsAgentMCPToolResultEventTypeAgentMCPToolResult BetaManagedAgentsAgentMCPToolResultEventType = "agent.mcp_tool_result"
+)
+
+// BetaManagedAgentsAgentMCPToolResultEventContentUnion contains all possible
+// properties and values from [BetaManagedAgentsTextBlock],
+// [BetaManagedAgentsImageBlock], [BetaManagedAgentsDocumentBlock].
+//
+// Use the [BetaManagedAgentsAgentMCPToolResultEventContentUnion.AsAny] method to
+// switch on the variant.
+//
+// Use the methods beginning with 'As' to cast the union to one of its variants.
+type BetaManagedAgentsAgentMCPToolResultEventContentUnion struct {
+ // This field is from variant [BetaManagedAgentsTextBlock].
+ Text string `json:"text"`
+ // Any of "text", "image", "document".
+ Type string `json:"type"`
+ // This field is a union of [BetaManagedAgentsImageBlockSourceUnion],
+ // [BetaManagedAgentsDocumentBlockSourceUnion]
+ Source BetaManagedAgentsAgentMCPToolResultEventContentUnionSource `json:"source"`
+ // This field is from variant [BetaManagedAgentsDocumentBlock].
+ Context string `json:"context"`
+ // This field is from variant [BetaManagedAgentsDocumentBlock].
+ Title string `json:"title"`
+ JSON struct {
+ Text respjson.Field
+ Type respjson.Field
+ Source respjson.Field
+ Context respjson.Field
+ Title respjson.Field
+ raw string
+ } `json:"-"`
+}
+
+// anyBetaManagedAgentsAgentMCPToolResultEventContent is implemented by each
+// variant of [BetaManagedAgentsAgentMCPToolResultEventContentUnion] to add type
+// safety for the return type of
+// [BetaManagedAgentsAgentMCPToolResultEventContentUnion.AsAny]
+type anyBetaManagedAgentsAgentMCPToolResultEventContent interface {
+ implBetaManagedAgentsAgentMCPToolResultEventContentUnion()
+}
+
+func (BetaManagedAgentsTextBlock) implBetaManagedAgentsAgentMCPToolResultEventContentUnion() {}
+func (BetaManagedAgentsImageBlock) implBetaManagedAgentsAgentMCPToolResultEventContentUnion() {}
+func (BetaManagedAgentsDocumentBlock) implBetaManagedAgentsAgentMCPToolResultEventContentUnion() {}
+
+// Use the following switch statement to find the correct variant
+//
+// switch variant := BetaManagedAgentsAgentMCPToolResultEventContentUnion.AsAny().(type) {
+// case anthropic.BetaManagedAgentsTextBlock:
+// case anthropic.BetaManagedAgentsImageBlock:
+// case anthropic.BetaManagedAgentsDocumentBlock:
+// default:
+// fmt.Errorf("no variant present")
+// }
+func (u BetaManagedAgentsAgentMCPToolResultEventContentUnion) AsAny() anyBetaManagedAgentsAgentMCPToolResultEventContent {
+ switch u.Type {
+ case "text":
+ return u.AsText()
+ case "image":
+ return u.AsImage()
+ case "document":
+ return u.AsDocument()
+ }
+ return nil
+}
+
+func (u BetaManagedAgentsAgentMCPToolResultEventContentUnion) AsText() (v BetaManagedAgentsTextBlock) {
+ apijson.UnmarshalRoot(json.RawMessage(u.JSON.raw), &v)
+ return
+}
+
+func (u BetaManagedAgentsAgentMCPToolResultEventContentUnion) AsImage() (v BetaManagedAgentsImageBlock) {
+ apijson.UnmarshalRoot(json.RawMessage(u.JSON.raw), &v)
+ return
+}
+
+func (u BetaManagedAgentsAgentMCPToolResultEventContentUnion) AsDocument() (v BetaManagedAgentsDocumentBlock) {
+ apijson.UnmarshalRoot(json.RawMessage(u.JSON.raw), &v)
+ return
+}
+
+// Returns the unmodified JSON received from the API
+func (u BetaManagedAgentsAgentMCPToolResultEventContentUnion) RawJSON() string { return u.JSON.raw }
+
+func (r *BetaManagedAgentsAgentMCPToolResultEventContentUnion) UnmarshalJSON(data []byte) error {
+ return apijson.UnmarshalRoot(data, r)
+}
+
+// BetaManagedAgentsAgentMCPToolResultEventContentUnionSource is an implicit
+// subunion of [BetaManagedAgentsAgentMCPToolResultEventContentUnion].
+// BetaManagedAgentsAgentMCPToolResultEventContentUnionSource provides convenient
+// access to the sub-properties of the union.
+//
+// For type safety it is recommended to directly use a variant of the
+// [BetaManagedAgentsAgentMCPToolResultEventContentUnion].
+type BetaManagedAgentsAgentMCPToolResultEventContentUnionSource struct {
+ Data string `json:"data"`
+ MediaType string `json:"media_type"`
+ Type string `json:"type"`
+ URL string `json:"url"`
+ FileID string `json:"file_id"`
+ JSON struct {
+ Data respjson.Field
+ MediaType respjson.Field
+ Type respjson.Field
+ URL respjson.Field
+ FileID respjson.Field
+ raw string
+ } `json:"-"`
+}
+
+func (r *BetaManagedAgentsAgentMCPToolResultEventContentUnionSource) UnmarshalJSON(data []byte) error {
+ return apijson.UnmarshalRoot(data, r)
+}
+
+// Event emitted when the agent invokes a tool provided by an MCP server.
+type BetaManagedAgentsAgentMCPToolUseEvent struct {
+ // Unique identifier for this event.
+ ID string `json:"id" api:"required"`
+ // Input parameters for the tool call.
+ Input map[string]any `json:"input" api:"required"`
+ // Name of the MCP server providing the tool.
+ MCPServerName string `json:"mcp_server_name" api:"required"`
+ // Name of the MCP tool being used.
+ Name string `json:"name" api:"required"`
+ // A timestamp in RFC 3339 format
+ ProcessedAt time.Time `json:"processed_at" api:"required" format:"date-time"`
+ // Any of "agent.mcp_tool_use".
+ Type BetaManagedAgentsAgentMCPToolUseEventType `json:"type" api:"required"`
+ // AgentEvaluatedPermission enum
+ //
+ // Any of "allow", "ask", "deny".
+ EvaluatedPermission BetaManagedAgentsAgentMCPToolUseEventEvaluatedPermission `json:"evaluated_permission"`
+ // JSON contains metadata for fields, check presence with [respjson.Field.Valid].
+ JSON struct {
+ ID respjson.Field
+ Input respjson.Field
+ MCPServerName respjson.Field
+ Name respjson.Field
+ ProcessedAt respjson.Field
+ Type respjson.Field
+ EvaluatedPermission respjson.Field
+ ExtraFields map[string]respjson.Field
+ raw string
+ } `json:"-"`
+}
+
+// Returns the unmodified JSON received from the API
+func (r BetaManagedAgentsAgentMCPToolUseEvent) RawJSON() string { return r.JSON.raw }
+func (r *BetaManagedAgentsAgentMCPToolUseEvent) UnmarshalJSON(data []byte) error {
+ return apijson.UnmarshalRoot(data, r)
+}
+
+type BetaManagedAgentsAgentMCPToolUseEventType string
+
+const (
+ BetaManagedAgentsAgentMCPToolUseEventTypeAgentMCPToolUse BetaManagedAgentsAgentMCPToolUseEventType = "agent.mcp_tool_use"
+)
+
+// AgentEvaluatedPermission enum
+type BetaManagedAgentsAgentMCPToolUseEventEvaluatedPermission string
+
+const (
+ BetaManagedAgentsAgentMCPToolUseEventEvaluatedPermissionAllow BetaManagedAgentsAgentMCPToolUseEventEvaluatedPermission = "allow"
+ BetaManagedAgentsAgentMCPToolUseEventEvaluatedPermissionAsk BetaManagedAgentsAgentMCPToolUseEventEvaluatedPermission = "ask"
+ BetaManagedAgentsAgentMCPToolUseEventEvaluatedPermissionDeny BetaManagedAgentsAgentMCPToolUseEventEvaluatedPermission = "deny"
+)
+
+// An agent response event in the session conversation.
+type BetaManagedAgentsAgentMessageEvent struct {
+ // Unique identifier for this event.
+ ID string `json:"id" api:"required"`
+ // Array of text blocks comprising the agent response.
+ Content []BetaManagedAgentsTextBlock `json:"content" api:"required"`
+ // A timestamp in RFC 3339 format
+ ProcessedAt time.Time `json:"processed_at" api:"required" format:"date-time"`
+ // Any of "agent.message".
+ Type BetaManagedAgentsAgentMessageEventType `json:"type" api:"required"`
+ // JSON contains metadata for fields, check presence with [respjson.Field.Valid].
+ JSON struct {
+ ID respjson.Field
+ Content respjson.Field
+ ProcessedAt respjson.Field
+ Type respjson.Field
+ ExtraFields map[string]respjson.Field
+ raw string
+ } `json:"-"`
+}
+
+// Returns the unmodified JSON received from the API
+func (r BetaManagedAgentsAgentMessageEvent) RawJSON() string { return r.JSON.raw }
+func (r *BetaManagedAgentsAgentMessageEvent) UnmarshalJSON(data []byte) error {
+ return apijson.UnmarshalRoot(data, r)
+}
+
+type BetaManagedAgentsAgentMessageEventType string
+
+const (
+ BetaManagedAgentsAgentMessageEventTypeAgentMessage BetaManagedAgentsAgentMessageEventType = "agent.message"
+)
+
+// Indicates the agent is making forward progress via extended thinking. A progress
+// signal, not a content carrier.
+type BetaManagedAgentsAgentThinkingEvent struct {
+ // Unique identifier for this event.
+ ID string `json:"id" api:"required"`
+ // A timestamp in RFC 3339 format
+ ProcessedAt time.Time `json:"processed_at" api:"required" format:"date-time"`
+ // Any of "agent.thinking".
+ Type BetaManagedAgentsAgentThinkingEventType `json:"type" api:"required"`
+ // JSON contains metadata for fields, check presence with [respjson.Field.Valid].
+ JSON struct {
+ ID respjson.Field
+ ProcessedAt respjson.Field
+ Type respjson.Field
+ ExtraFields map[string]respjson.Field
+ raw string
+ } `json:"-"`
+}
+
+// Returns the unmodified JSON received from the API
+func (r BetaManagedAgentsAgentThinkingEvent) RawJSON() string { return r.JSON.raw }
+func (r *BetaManagedAgentsAgentThinkingEvent) UnmarshalJSON(data []byte) error {
+ return apijson.UnmarshalRoot(data, r)
+}
+
+type BetaManagedAgentsAgentThinkingEventType string
+
+const (
+ BetaManagedAgentsAgentThinkingEventTypeAgentThinking BetaManagedAgentsAgentThinkingEventType = "agent.thinking"
+)
+
+// Indicates that context compaction (summarization) occurred during the session.
+type BetaManagedAgentsAgentThreadContextCompactedEvent struct {
+ // Unique identifier for this event.
+ ID string `json:"id" api:"required"`
+ // A timestamp in RFC 3339 format
+ ProcessedAt time.Time `json:"processed_at" api:"required" format:"date-time"`
+ // Any of "agent.thread_context_compacted".
+ Type BetaManagedAgentsAgentThreadContextCompactedEventType `json:"type" api:"required"`
+ // JSON contains metadata for fields, check presence with [respjson.Field.Valid].
+ JSON struct {
+ ID respjson.Field
+ ProcessedAt respjson.Field
+ Type respjson.Field
+ ExtraFields map[string]respjson.Field
+ raw string
+ } `json:"-"`
+}
+
+// Returns the unmodified JSON received from the API
+func (r BetaManagedAgentsAgentThreadContextCompactedEvent) RawJSON() string { return r.JSON.raw }
+func (r *BetaManagedAgentsAgentThreadContextCompactedEvent) UnmarshalJSON(data []byte) error {
+ return apijson.UnmarshalRoot(data, r)
+}
+
+type BetaManagedAgentsAgentThreadContextCompactedEventType string
+
+const (
+ BetaManagedAgentsAgentThreadContextCompactedEventTypeAgentThreadContextCompacted BetaManagedAgentsAgentThreadContextCompactedEventType = "agent.thread_context_compacted"
+)
+
+// Event representing the result of an agent tool execution.
+type BetaManagedAgentsAgentToolResultEvent struct {
+ // Unique identifier for this event.
+ ID string `json:"id" api:"required"`
+ // A timestamp in RFC 3339 format
+ ProcessedAt time.Time `json:"processed_at" api:"required" format:"date-time"`
+ // The id of the `agent.tool_use` event this result corresponds to.
+ ToolUseID string `json:"tool_use_id" api:"required"`
+ // Any of "agent.tool_result".
+ Type BetaManagedAgentsAgentToolResultEventType `json:"type" api:"required"`
+ // The result content returned by the tool.
+ Content []BetaManagedAgentsAgentToolResultEventContentUnion `json:"content"`
+ // Whether the tool execution resulted in an error.
+ IsError bool `json:"is_error" api:"nullable"`
+ // JSON contains metadata for fields, check presence with [respjson.Field.Valid].
+ JSON struct {
+ ID respjson.Field
+ ProcessedAt respjson.Field
+ ToolUseID respjson.Field
+ Type respjson.Field
+ Content respjson.Field
+ IsError respjson.Field
+ ExtraFields map[string]respjson.Field
+ raw string
+ } `json:"-"`
+}
+
+// Returns the unmodified JSON received from the API
+func (r BetaManagedAgentsAgentToolResultEvent) RawJSON() string { return r.JSON.raw }
+func (r *BetaManagedAgentsAgentToolResultEvent) UnmarshalJSON(data []byte) error {
+ return apijson.UnmarshalRoot(data, r)
+}
+
+type BetaManagedAgentsAgentToolResultEventType string
+
+const (
+ BetaManagedAgentsAgentToolResultEventTypeAgentToolResult BetaManagedAgentsAgentToolResultEventType = "agent.tool_result"
+)
+
+// BetaManagedAgentsAgentToolResultEventContentUnion contains all possible
+// properties and values from [BetaManagedAgentsTextBlock],
+// [BetaManagedAgentsImageBlock], [BetaManagedAgentsDocumentBlock].
+//
+// Use the [BetaManagedAgentsAgentToolResultEventContentUnion.AsAny] method to
+// switch on the variant.
+//
+// Use the methods beginning with 'As' to cast the union to one of its variants.
+type BetaManagedAgentsAgentToolResultEventContentUnion struct {
+ // This field is from variant [BetaManagedAgentsTextBlock].
+ Text string `json:"text"`
+ // Any of "text", "image", "document".
+ Type string `json:"type"`
+ // This field is a union of [BetaManagedAgentsImageBlockSourceUnion],
+ // [BetaManagedAgentsDocumentBlockSourceUnion]
+ Source BetaManagedAgentsAgentToolResultEventContentUnionSource `json:"source"`
+ // This field is from variant [BetaManagedAgentsDocumentBlock].
+ Context string `json:"context"`
+ // This field is from variant [BetaManagedAgentsDocumentBlock].
+ Title string `json:"title"`
+ JSON struct {
+ Text respjson.Field
+ Type respjson.Field
+ Source respjson.Field
+ Context respjson.Field
+ Title respjson.Field
+ raw string
+ } `json:"-"`
+}
+
+// anyBetaManagedAgentsAgentToolResultEventContent is implemented by each variant
+// of [BetaManagedAgentsAgentToolResultEventContentUnion] to add type safety for
+// the return type of [BetaManagedAgentsAgentToolResultEventContentUnion.AsAny]
+type anyBetaManagedAgentsAgentToolResultEventContent interface {
+ implBetaManagedAgentsAgentToolResultEventContentUnion()
+}
+
+func (BetaManagedAgentsTextBlock) implBetaManagedAgentsAgentToolResultEventContentUnion() {}
+func (BetaManagedAgentsImageBlock) implBetaManagedAgentsAgentToolResultEventContentUnion() {}
+func (BetaManagedAgentsDocumentBlock) implBetaManagedAgentsAgentToolResultEventContentUnion() {}
+
+// Use the following switch statement to find the correct variant
+//
+// switch variant := BetaManagedAgentsAgentToolResultEventContentUnion.AsAny().(type) {
+// case anthropic.BetaManagedAgentsTextBlock:
+// case anthropic.BetaManagedAgentsImageBlock:
+// case anthropic.BetaManagedAgentsDocumentBlock:
+// default:
+// fmt.Errorf("no variant present")
+// }
+func (u BetaManagedAgentsAgentToolResultEventContentUnion) AsAny() anyBetaManagedAgentsAgentToolResultEventContent {
+ switch u.Type {
+ case "text":
+ return u.AsText()
+ case "image":
+ return u.AsImage()
+ case "document":
+ return u.AsDocument()
+ }
+ return nil
+}
+
+func (u BetaManagedAgentsAgentToolResultEventContentUnion) AsText() (v BetaManagedAgentsTextBlock) {
+ apijson.UnmarshalRoot(json.RawMessage(u.JSON.raw), &v)
+ return
+}
+
+func (u BetaManagedAgentsAgentToolResultEventContentUnion) AsImage() (v BetaManagedAgentsImageBlock) {
+ apijson.UnmarshalRoot(json.RawMessage(u.JSON.raw), &v)
+ return
+}
+
+func (u BetaManagedAgentsAgentToolResultEventContentUnion) AsDocument() (v BetaManagedAgentsDocumentBlock) {
+ apijson.UnmarshalRoot(json.RawMessage(u.JSON.raw), &v)
+ return
+}
+
+// Returns the unmodified JSON received from the API
+func (u BetaManagedAgentsAgentToolResultEventContentUnion) RawJSON() string { return u.JSON.raw }
+
+func (r *BetaManagedAgentsAgentToolResultEventContentUnion) UnmarshalJSON(data []byte) error {
+ return apijson.UnmarshalRoot(data, r)
+}
+
+// BetaManagedAgentsAgentToolResultEventContentUnionSource is an implicit subunion
+// of [BetaManagedAgentsAgentToolResultEventContentUnion].
+// BetaManagedAgentsAgentToolResultEventContentUnionSource provides convenient
+// access to the sub-properties of the union.
+//
+// For type safety it is recommended to directly use a variant of the
+// [BetaManagedAgentsAgentToolResultEventContentUnion].
+type BetaManagedAgentsAgentToolResultEventContentUnionSource struct {
+ Data string `json:"data"`
+ MediaType string `json:"media_type"`
+ Type string `json:"type"`
+ URL string `json:"url"`
+ FileID string `json:"file_id"`
+ JSON struct {
+ Data respjson.Field
+ MediaType respjson.Field
+ Type respjson.Field
+ URL respjson.Field
+ FileID respjson.Field
+ raw string
+ } `json:"-"`
+}
+
+func (r *BetaManagedAgentsAgentToolResultEventContentUnionSource) UnmarshalJSON(data []byte) error {
+ return apijson.UnmarshalRoot(data, r)
+}
+
+// Event emitted when the agent invokes a built-in agent tool.
+type BetaManagedAgentsAgentToolUseEvent struct {
+ // Unique identifier for this event.
+ ID string `json:"id" api:"required"`
+ // Input parameters for the tool call.
+ Input map[string]any `json:"input" api:"required"`
+ // Name of the agent tool being used.
+ Name string `json:"name" api:"required"`
+ // A timestamp in RFC 3339 format
+ ProcessedAt time.Time `json:"processed_at" api:"required" format:"date-time"`
+ // Any of "agent.tool_use".
+ Type BetaManagedAgentsAgentToolUseEventType `json:"type" api:"required"`
+ // AgentEvaluatedPermission enum
+ //
+ // Any of "allow", "ask", "deny".
+ EvaluatedPermission BetaManagedAgentsAgentToolUseEventEvaluatedPermission `json:"evaluated_permission"`
+ // JSON contains metadata for fields, check presence with [respjson.Field.Valid].
+ JSON struct {
+ ID respjson.Field
+ Input respjson.Field
+ Name respjson.Field
+ ProcessedAt respjson.Field
+ Type respjson.Field
+ EvaluatedPermission respjson.Field
+ ExtraFields map[string]respjson.Field
+ raw string
+ } `json:"-"`
+}
+
+// Returns the unmodified JSON received from the API
+func (r BetaManagedAgentsAgentToolUseEvent) RawJSON() string { return r.JSON.raw }
+func (r *BetaManagedAgentsAgentToolUseEvent) UnmarshalJSON(data []byte) error {
+ return apijson.UnmarshalRoot(data, r)
+}
+
+type BetaManagedAgentsAgentToolUseEventType string
+
+const (
+ BetaManagedAgentsAgentToolUseEventTypeAgentToolUse BetaManagedAgentsAgentToolUseEventType = "agent.tool_use"
+)
+
+// AgentEvaluatedPermission enum
+type BetaManagedAgentsAgentToolUseEventEvaluatedPermission string
+
+const (
+ BetaManagedAgentsAgentToolUseEventEvaluatedPermissionAllow BetaManagedAgentsAgentToolUseEventEvaluatedPermission = "allow"
+ BetaManagedAgentsAgentToolUseEventEvaluatedPermissionAsk BetaManagedAgentsAgentToolUseEventEvaluatedPermission = "ask"
+ BetaManagedAgentsAgentToolUseEventEvaluatedPermissionDeny BetaManagedAgentsAgentToolUseEventEvaluatedPermission = "deny"
+)
+
+// Base64-encoded document data.
+type BetaManagedAgentsBase64DocumentSource struct {
+ // Base64-encoded document data.
+ Data string `json:"data" api:"required"`
+ // MIME type of the document (e.g., "application/pdf").
+ MediaType string `json:"media_type" api:"required"`
+ // Any of "base64".
+ Type BetaManagedAgentsBase64DocumentSourceType `json:"type" api:"required"`
+ // JSON contains metadata for fields, check presence with [respjson.Field.Valid].
+ JSON struct {
+ Data respjson.Field
+ MediaType respjson.Field
+ Type respjson.Field
+ ExtraFields map[string]respjson.Field
+ raw string
+ } `json:"-"`
+}
+
+// Returns the unmodified JSON received from the API
+func (r BetaManagedAgentsBase64DocumentSource) RawJSON() string { return r.JSON.raw }
+func (r *BetaManagedAgentsBase64DocumentSource) UnmarshalJSON(data []byte) error {
+ return apijson.UnmarshalRoot(data, r)
+}
+
+// ToParam converts this BetaManagedAgentsBase64DocumentSource to a
+// BetaManagedAgentsBase64DocumentSourceParam.
+//
+// Warning: the fields of the param type will not be present. ToParam should only
+// be used at the last possible moment before sending a request. Test for this with
+// BetaManagedAgentsBase64DocumentSourceParam.Overrides()
+func (r BetaManagedAgentsBase64DocumentSource) ToParam() BetaManagedAgentsBase64DocumentSourceParam {
+ return param.Override[BetaManagedAgentsBase64DocumentSourceParam](json.RawMessage(r.RawJSON()))
+}
+
+type BetaManagedAgentsBase64DocumentSourceType string
+
+const (
+ BetaManagedAgentsBase64DocumentSourceTypeBase64 BetaManagedAgentsBase64DocumentSourceType = "base64"
+)
+
+// Base64-encoded document data.
+//
+// The properties Data, MediaType, Type are required.
+type BetaManagedAgentsBase64DocumentSourceParam struct {
+ // Base64-encoded document data.
+ Data string `json:"data" api:"required"`
+ // MIME type of the document (e.g., "application/pdf").
+ MediaType string `json:"media_type" api:"required"`
+ // Any of "base64".
+ Type BetaManagedAgentsBase64DocumentSourceType `json:"type,omitzero" api:"required"`
+ paramObj
+}
+
+func (r BetaManagedAgentsBase64DocumentSourceParam) MarshalJSON() (data []byte, err error) {
+ type shadow BetaManagedAgentsBase64DocumentSourceParam
+ return param.MarshalObject(r, (*shadow)(&r))
+}
+func (r *BetaManagedAgentsBase64DocumentSourceParam) UnmarshalJSON(data []byte) error {
+ return apijson.UnmarshalRoot(data, r)
+}
+
+// Base64-encoded image data.
+type BetaManagedAgentsBase64ImageSource struct {
+ // Base64-encoded image data.
+ Data string `json:"data" api:"required"`
+ // MIME type of the image (e.g., "image/png", "image/jpeg", "image/gif",
+ // "image/webp").
+ MediaType string `json:"media_type" api:"required"`
+ // Any of "base64".
+ Type BetaManagedAgentsBase64ImageSourceType `json:"type" api:"required"`
+ // JSON contains metadata for fields, check presence with [respjson.Field.Valid].
+ JSON struct {
+ Data respjson.Field
+ MediaType respjson.Field
+ Type respjson.Field
+ ExtraFields map[string]respjson.Field
+ raw string
+ } `json:"-"`
+}
+
+// Returns the unmodified JSON received from the API
+func (r BetaManagedAgentsBase64ImageSource) RawJSON() string { return r.JSON.raw }
+func (r *BetaManagedAgentsBase64ImageSource) UnmarshalJSON(data []byte) error {
+ return apijson.UnmarshalRoot(data, r)
+}
+
+// ToParam converts this BetaManagedAgentsBase64ImageSource to a
+// BetaManagedAgentsBase64ImageSourceParam.
+//
+// Warning: the fields of the param type will not be present. ToParam should only
+// be used at the last possible moment before sending a request. Test for this with
+// BetaManagedAgentsBase64ImageSourceParam.Overrides()
+func (r BetaManagedAgentsBase64ImageSource) ToParam() BetaManagedAgentsBase64ImageSourceParam {
+ return param.Override[BetaManagedAgentsBase64ImageSourceParam](json.RawMessage(r.RawJSON()))
+}
+
+type BetaManagedAgentsBase64ImageSourceType string
+
+const (
+ BetaManagedAgentsBase64ImageSourceTypeBase64 BetaManagedAgentsBase64ImageSourceType = "base64"
+)
+
+// Base64-encoded image data.
+//
+// The properties Data, MediaType, Type are required.
+type BetaManagedAgentsBase64ImageSourceParam struct {
+ // Base64-encoded image data.
+ Data string `json:"data" api:"required"`
+ // MIME type of the image (e.g., "image/png", "image/jpeg", "image/gif",
+ // "image/webp").
+ MediaType string `json:"media_type" api:"required"`
+ // Any of "base64".
+ Type BetaManagedAgentsBase64ImageSourceType `json:"type,omitzero" api:"required"`
+ paramObj
+}
+
+func (r BetaManagedAgentsBase64ImageSourceParam) MarshalJSON() (data []byte, err error) {
+ type shadow BetaManagedAgentsBase64ImageSourceParam
+ return param.MarshalObject(r, (*shadow)(&r))
+}
+func (r *BetaManagedAgentsBase64ImageSourceParam) UnmarshalJSON(data []byte) error {
+ return apijson.UnmarshalRoot(data, r)
+}
+
+// The caller's organization or workspace cannot make model requests — out of
+// credits or spend limit reached. Retrying with the same credentials will not
+// succeed; the caller must resolve the billing state.
+type BetaManagedAgentsBillingError struct {
+ // Human-readable error description.
+ Message string `json:"message" api:"required"`
+ // What the client should do next in response to this error.
+ RetryStatus BetaManagedAgentsBillingErrorRetryStatusUnion `json:"retry_status" api:"required"`
+ // Any of "billing_error".
+ Type BetaManagedAgentsBillingErrorType `json:"type" api:"required"`
+ // JSON contains metadata for fields, check presence with [respjson.Field.Valid].
+ JSON struct {
+ Message respjson.Field
+ RetryStatus respjson.Field
+ Type respjson.Field
+ ExtraFields map[string]respjson.Field
+ raw string
+ } `json:"-"`
+}
+
+// Returns the unmodified JSON received from the API
+func (r BetaManagedAgentsBillingError) RawJSON() string { return r.JSON.raw }
+func (r *BetaManagedAgentsBillingError) UnmarshalJSON(data []byte) error {
+ return apijson.UnmarshalRoot(data, r)
+}
+
+// BetaManagedAgentsBillingErrorRetryStatusUnion contains all possible properties
+// and values from [BetaManagedAgentsRetryStatusRetrying],
+// [BetaManagedAgentsRetryStatusExhausted], [BetaManagedAgentsRetryStatusTerminal].
+//
+// Use the [BetaManagedAgentsBillingErrorRetryStatusUnion.AsAny] method to switch
+// on the variant.
+//
+// Use the methods beginning with 'As' to cast the union to one of its variants.
+type BetaManagedAgentsBillingErrorRetryStatusUnion struct {
+ // Any of "retrying", "exhausted", "terminal".
+ Type string `json:"type"`
+ JSON struct {
+ Type respjson.Field
+ raw string
+ } `json:"-"`
+}
+
+// anyBetaManagedAgentsBillingErrorRetryStatus is implemented by each variant of
+// [BetaManagedAgentsBillingErrorRetryStatusUnion] to add type safety for the
+// return type of [BetaManagedAgentsBillingErrorRetryStatusUnion.AsAny]
+type anyBetaManagedAgentsBillingErrorRetryStatus interface {
+ implBetaManagedAgentsBillingErrorRetryStatusUnion()
+}
+
+func (BetaManagedAgentsRetryStatusRetrying) implBetaManagedAgentsBillingErrorRetryStatusUnion() {}
+func (BetaManagedAgentsRetryStatusExhausted) implBetaManagedAgentsBillingErrorRetryStatusUnion() {}
+func (BetaManagedAgentsRetryStatusTerminal) implBetaManagedAgentsBillingErrorRetryStatusUnion() {}
+
+// Use the following switch statement to find the correct variant
+//
+// switch variant := BetaManagedAgentsBillingErrorRetryStatusUnion.AsAny().(type) {
+// case anthropic.BetaManagedAgentsRetryStatusRetrying:
+// case anthropic.BetaManagedAgentsRetryStatusExhausted:
+// case anthropic.BetaManagedAgentsRetryStatusTerminal:
+// default:
+// fmt.Errorf("no variant present")
+// }
+func (u BetaManagedAgentsBillingErrorRetryStatusUnion) AsAny() anyBetaManagedAgentsBillingErrorRetryStatus {
+ switch u.Type {
+ case "retrying":
+ return u.AsRetrying()
+ case "exhausted":
+ return u.AsExhausted()
+ case "terminal":
+ return u.AsTerminal()
+ }
+ return nil
+}
+
+func (u BetaManagedAgentsBillingErrorRetryStatusUnion) AsRetrying() (v BetaManagedAgentsRetryStatusRetrying) {
+ apijson.UnmarshalRoot(json.RawMessage(u.JSON.raw), &v)
+ return
+}
+
+func (u BetaManagedAgentsBillingErrorRetryStatusUnion) AsExhausted() (v BetaManagedAgentsRetryStatusExhausted) {
+ apijson.UnmarshalRoot(json.RawMessage(u.JSON.raw), &v)
+ return
+}
+
+func (u BetaManagedAgentsBillingErrorRetryStatusUnion) AsTerminal() (v BetaManagedAgentsRetryStatusTerminal) {
+ apijson.UnmarshalRoot(json.RawMessage(u.JSON.raw), &v)
+ return
+}
+
+// Returns the unmodified JSON received from the API
+func (u BetaManagedAgentsBillingErrorRetryStatusUnion) RawJSON() string { return u.JSON.raw }
+
+func (r *BetaManagedAgentsBillingErrorRetryStatusUnion) UnmarshalJSON(data []byte) error {
+ return apijson.UnmarshalRoot(data, r)
+}
+
+type BetaManagedAgentsBillingErrorType string
+
+const (
+ BetaManagedAgentsBillingErrorTypeBillingError BetaManagedAgentsBillingErrorType = "billing_error"
+)
+
+// Document content, either specified directly as base64 data, as text, or as a
+// reference via a URL.
+type BetaManagedAgentsDocumentBlock struct {
+ // Union type for document source variants.
+ Source BetaManagedAgentsDocumentBlockSourceUnion `json:"source" api:"required"`
+ // Any of "document".
+ Type BetaManagedAgentsDocumentBlockType `json:"type" api:"required"`
+ // Additional context about the document for the model.
+ Context string `json:"context" api:"nullable"`
+ // The title of the document.
+ Title string `json:"title" api:"nullable"`
+ // JSON contains metadata for fields, check presence with [respjson.Field.Valid].
+ JSON struct {
+ Source respjson.Field
+ Type respjson.Field
+ Context respjson.Field
+ Title respjson.Field
+ ExtraFields map[string]respjson.Field
+ raw string
+ } `json:"-"`
+}
+
+// Returns the unmodified JSON received from the API
+func (r BetaManagedAgentsDocumentBlock) RawJSON() string { return r.JSON.raw }
+func (r *BetaManagedAgentsDocumentBlock) UnmarshalJSON(data []byte) error {
+ return apijson.UnmarshalRoot(data, r)
+}
+
+// ToParam converts this BetaManagedAgentsDocumentBlock to a
+// BetaManagedAgentsDocumentBlockParam.
+//
+// Warning: the fields of the param type will not be present. ToParam should only
+// be used at the last possible moment before sending a request. Test for this with
+// BetaManagedAgentsDocumentBlockParam.Overrides()
+func (r BetaManagedAgentsDocumentBlock) ToParam() BetaManagedAgentsDocumentBlockParam {
+ return param.Override[BetaManagedAgentsDocumentBlockParam](json.RawMessage(r.RawJSON()))
+}
+
+// BetaManagedAgentsDocumentBlockSourceUnion contains all possible properties and
+// values from [BetaManagedAgentsBase64DocumentSource],
+// [BetaManagedAgentsPlainTextDocumentSource],
+// [BetaManagedAgentsURLDocumentSource], [BetaManagedAgentsFileDocumentSource].
+//
+// Use the [BetaManagedAgentsDocumentBlockSourceUnion.AsAny] method to switch on
+// the variant.
+//
+// Use the methods beginning with 'As' to cast the union to one of its variants.
+type BetaManagedAgentsDocumentBlockSourceUnion struct {
+ Data string `json:"data"`
+ MediaType string `json:"media_type"`
+ // Any of "base64", "text", "url", "file".
+ Type string `json:"type"`
+ // This field is from variant [BetaManagedAgentsURLDocumentSource].
+ URL string `json:"url"`
+ // This field is from variant [BetaManagedAgentsFileDocumentSource].
+ FileID string `json:"file_id"`
+ JSON struct {
+ Data respjson.Field
+ MediaType respjson.Field
+ Type respjson.Field
+ URL respjson.Field
+ FileID respjson.Field
+ raw string
+ } `json:"-"`
+}
+
+// anyBetaManagedAgentsDocumentBlockSource is implemented by each variant of
+// [BetaManagedAgentsDocumentBlockSourceUnion] to add type safety for the return
+// type of [BetaManagedAgentsDocumentBlockSourceUnion.AsAny]
+type anyBetaManagedAgentsDocumentBlockSource interface {
+ implBetaManagedAgentsDocumentBlockSourceUnion()
+}
+
+func (BetaManagedAgentsBase64DocumentSource) implBetaManagedAgentsDocumentBlockSourceUnion() {}
+func (BetaManagedAgentsPlainTextDocumentSource) implBetaManagedAgentsDocumentBlockSourceUnion() {}
+func (BetaManagedAgentsURLDocumentSource) implBetaManagedAgentsDocumentBlockSourceUnion() {}
+func (BetaManagedAgentsFileDocumentSource) implBetaManagedAgentsDocumentBlockSourceUnion() {}
+
+// Use the following switch statement to find the correct variant
+//
+// switch variant := BetaManagedAgentsDocumentBlockSourceUnion.AsAny().(type) {
+// case anthropic.BetaManagedAgentsBase64DocumentSource:
+// case anthropic.BetaManagedAgentsPlainTextDocumentSource:
+// case anthropic.BetaManagedAgentsURLDocumentSource:
+// case anthropic.BetaManagedAgentsFileDocumentSource:
+// default:
+// fmt.Errorf("no variant present")
+// }
+func (u BetaManagedAgentsDocumentBlockSourceUnion) AsAny() anyBetaManagedAgentsDocumentBlockSource {
+ switch u.Type {
+ case "base64":
+ return u.AsBase64()
+ case "text":
+ return u.AsText()
+ case "url":
+ return u.AsURL()
+ case "file":
+ return u.AsFile()
+ }
+ return nil
+}
+
+func (u BetaManagedAgentsDocumentBlockSourceUnion) AsBase64() (v BetaManagedAgentsBase64DocumentSource) {
+ apijson.UnmarshalRoot(json.RawMessage(u.JSON.raw), &v)
+ return
+}
+
+func (u BetaManagedAgentsDocumentBlockSourceUnion) AsText() (v BetaManagedAgentsPlainTextDocumentSource) {
+ apijson.UnmarshalRoot(json.RawMessage(u.JSON.raw), &v)
+ return
+}
+
+func (u BetaManagedAgentsDocumentBlockSourceUnion) AsURL() (v BetaManagedAgentsURLDocumentSource) {
+ apijson.UnmarshalRoot(json.RawMessage(u.JSON.raw), &v)
+ return
+}
+
+func (u BetaManagedAgentsDocumentBlockSourceUnion) AsFile() (v BetaManagedAgentsFileDocumentSource) {
+ apijson.UnmarshalRoot(json.RawMessage(u.JSON.raw), &v)
+ return
+}
+
+// Returns the unmodified JSON received from the API
+func (u BetaManagedAgentsDocumentBlockSourceUnion) RawJSON() string { return u.JSON.raw }
+
+func (r *BetaManagedAgentsDocumentBlockSourceUnion) UnmarshalJSON(data []byte) error {
+ return apijson.UnmarshalRoot(data, r)
+}
+
+type BetaManagedAgentsDocumentBlockType string
+
+const (
+ BetaManagedAgentsDocumentBlockTypeDocument BetaManagedAgentsDocumentBlockType = "document"
+)
+
+// Document content, either specified directly as base64 data, as text, or as a
+// reference via a URL.
+//
+// The properties Source, Type are required.
+type BetaManagedAgentsDocumentBlockParam struct {
+ // Union type for document source variants.
+ Source BetaManagedAgentsDocumentBlockSourceUnionParam `json:"source,omitzero" api:"required"`
+ // Any of "document".
+ Type BetaManagedAgentsDocumentBlockType `json:"type,omitzero" api:"required"`
+ // Additional context about the document for the model.
+ Context param.Opt[string] `json:"context,omitzero"`
+ // The title of the document.
+ Title param.Opt[string] `json:"title,omitzero"`
+ paramObj
+}
+
+func (r BetaManagedAgentsDocumentBlockParam) MarshalJSON() (data []byte, err error) {
+ type shadow BetaManagedAgentsDocumentBlockParam
+ return param.MarshalObject(r, (*shadow)(&r))
+}
+func (r *BetaManagedAgentsDocumentBlockParam) UnmarshalJSON(data []byte) error {
+ return apijson.UnmarshalRoot(data, r)
+}
+
+// Only one field can be non-zero.
+//
+// Use [param.IsOmitted] to confirm if a field is set.
+type BetaManagedAgentsDocumentBlockSourceUnionParam struct {
+ OfBase64 *BetaManagedAgentsBase64DocumentSourceParam `json:",omitzero,inline"`
+ OfText *BetaManagedAgentsPlainTextDocumentSourceParam `json:",omitzero,inline"`
+ OfURL *BetaManagedAgentsURLDocumentSourceParam `json:",omitzero,inline"`
+ OfFile *BetaManagedAgentsFileDocumentSourceParam `json:",omitzero,inline"`
+ paramUnion
+}
+
+func (u BetaManagedAgentsDocumentBlockSourceUnionParam) MarshalJSON() ([]byte, error) {
+ return param.MarshalUnion(u, u.OfBase64, u.OfText, u.OfURL, u.OfFile)
+}
+func (u *BetaManagedAgentsDocumentBlockSourceUnionParam) UnmarshalJSON(data []byte) error {
+ return apijson.UnmarshalRoot(data, u)
+}
+
+func (u *BetaManagedAgentsDocumentBlockSourceUnionParam) asAny() any {
+ if !param.IsOmitted(u.OfBase64) {
+ return u.OfBase64
+ } else if !param.IsOmitted(u.OfText) {
+ return u.OfText
+ } else if !param.IsOmitted(u.OfURL) {
+ return u.OfURL
+ } else if !param.IsOmitted(u.OfFile) {
+ return u.OfFile
+ }
+ return nil
+}
+
+// Returns a pointer to the underlying variant's property, if present.
+func (u BetaManagedAgentsDocumentBlockSourceUnionParam) GetURL() *string {
+ if vt := u.OfURL; vt != nil {
+ return &vt.URL
+ }
+ return nil
+}
+
+// Returns a pointer to the underlying variant's property, if present.
+func (u BetaManagedAgentsDocumentBlockSourceUnionParam) GetFileID() *string {
+ if vt := u.OfFile; vt != nil {
+ return &vt.FileID
+ }
+ return nil
+}
+
+// Returns a pointer to the underlying variant's property, if present.
+func (u BetaManagedAgentsDocumentBlockSourceUnionParam) GetData() *string {
+ if vt := u.OfBase64; vt != nil {
+ return (*string)(&vt.Data)
+ } else if vt := u.OfText; vt != nil {
+ return (*string)(&vt.Data)
+ }
+ return nil
+}
+
+// Returns a pointer to the underlying variant's property, if present.
+func (u BetaManagedAgentsDocumentBlockSourceUnionParam) GetMediaType() *string {
+ if vt := u.OfBase64; vt != nil {
+ return (*string)(&vt.MediaType)
+ } else if vt := u.OfText; vt != nil {
+ return (*string)(&vt.MediaType)
+ }
+ return nil
+}
+
+// Returns a pointer to the underlying variant's property, if present.
+func (u BetaManagedAgentsDocumentBlockSourceUnionParam) GetType() *string {
+ if vt := u.OfBase64; vt != nil {
+ return (*string)(&vt.Type)
+ } else if vt := u.OfText; vt != nil {
+ return (*string)(&vt.Type)
+ } else if vt := u.OfURL; vt != nil {
+ return (*string)(&vt.Type)
+ } else if vt := u.OfFile; vt != nil {
+ return (*string)(&vt.Type)
+ }
+ return nil
+}
+
+func init() {
+ apijson.RegisterUnion[BetaManagedAgentsDocumentBlockSourceUnionParam](
+ "type",
+ apijson.Discriminator[BetaManagedAgentsBase64DocumentSourceParam]("base64"),
+ apijson.Discriminator[BetaManagedAgentsPlainTextDocumentSourceParam]("text"),
+ apijson.Discriminator[BetaManagedAgentsURLDocumentSourceParam]("url"),
+ apijson.Discriminator[BetaManagedAgentsFileDocumentSourceParam]("file"),
+ )
+}
+
+func BetaManagedAgentsEventParamsOfUserMessage(content []BetaManagedAgentsUserMessageEventParamsContentUnion) BetaManagedAgentsEventParamsUnion {
+ var userMessage BetaManagedAgentsUserMessageEventParams
+ userMessage.Content = content
+ return BetaManagedAgentsEventParamsUnion{OfUserMessage: &userMessage}
+}
+
+func BetaManagedAgentsEventParamsOfUserInterrupt(type_ BetaManagedAgentsUserInterruptEventParamsType) BetaManagedAgentsEventParamsUnion {
+ var userInterrupt BetaManagedAgentsUserInterruptEventParams
+ userInterrupt.Type = type_
+ return BetaManagedAgentsEventParamsUnion{OfUserInterrupt: &userInterrupt}
+}
+
+func BetaManagedAgentsEventParamsOfUserToolConfirmation(result BetaManagedAgentsUserToolConfirmationEventParamsResult, toolUseID string, type_ BetaManagedAgentsUserToolConfirmationEventParamsType) BetaManagedAgentsEventParamsUnion {
+ var userToolConfirmation BetaManagedAgentsUserToolConfirmationEventParams
+ userToolConfirmation.Result = result
+ userToolConfirmation.ToolUseID = toolUseID
+ userToolConfirmation.Type = type_
+ return BetaManagedAgentsEventParamsUnion{OfUserToolConfirmation: &userToolConfirmation}
+}
+
+func BetaManagedAgentsEventParamsOfUserCustomToolResult(customToolUseID string) BetaManagedAgentsEventParamsUnion {
+ var userCustomToolResult BetaManagedAgentsUserCustomToolResultEventParams
+ userCustomToolResult.CustomToolUseID = customToolUseID
+ return BetaManagedAgentsEventParamsUnion{OfUserCustomToolResult: &userCustomToolResult}
+}
+
+// Only one field can be non-zero.
+//
+// Use [param.IsOmitted] to confirm if a field is set.
+type BetaManagedAgentsEventParamsUnion struct {
+ OfUserMessage *BetaManagedAgentsUserMessageEventParams `json:",omitzero,inline"`
+ OfUserInterrupt *BetaManagedAgentsUserInterruptEventParams `json:",omitzero,inline"`
+ OfUserToolConfirmation *BetaManagedAgentsUserToolConfirmationEventParams `json:",omitzero,inline"`
+ OfUserCustomToolResult *BetaManagedAgentsUserCustomToolResultEventParams `json:",omitzero,inline"`
+ paramUnion
+}
+
+func (u BetaManagedAgentsEventParamsUnion) MarshalJSON() ([]byte, error) {
+ return param.MarshalUnion(u, u.OfUserMessage, u.OfUserInterrupt, u.OfUserToolConfirmation, u.OfUserCustomToolResult)
+}
+func (u *BetaManagedAgentsEventParamsUnion) UnmarshalJSON(data []byte) error {
+ return apijson.UnmarshalRoot(data, u)
+}
+
+func (u *BetaManagedAgentsEventParamsUnion) asAny() any {
+ if !param.IsOmitted(u.OfUserMessage) {
+ return u.OfUserMessage
+ } else if !param.IsOmitted(u.OfUserInterrupt) {
+ return u.OfUserInterrupt
+ } else if !param.IsOmitted(u.OfUserToolConfirmation) {
+ return u.OfUserToolConfirmation
+ } else if !param.IsOmitted(u.OfUserCustomToolResult) {
+ return u.OfUserCustomToolResult
+ }
+ return nil
+}
+
+// Returns a pointer to the underlying variant's property, if present.
+func (u BetaManagedAgentsEventParamsUnion) GetResult() *string {
+ if vt := u.OfUserToolConfirmation; vt != nil {
+ return (*string)(&vt.Result)
+ }
+ return nil
+}
+
+// Returns a pointer to the underlying variant's property, if present.
+func (u BetaManagedAgentsEventParamsUnion) GetToolUseID() *string {
+ if vt := u.OfUserToolConfirmation; vt != nil {
+ return &vt.ToolUseID
+ }
+ return nil
+}
+
+// Returns a pointer to the underlying variant's property, if present.
+func (u BetaManagedAgentsEventParamsUnion) GetDenyMessage() *string {
+ if vt := u.OfUserToolConfirmation; vt != nil && vt.DenyMessage.Valid() {
+ return &vt.DenyMessage.Value
+ }
+ return nil
+}
+
+// Returns a pointer to the underlying variant's property, if present.
+func (u BetaManagedAgentsEventParamsUnion) GetCustomToolUseID() *string {
+ if vt := u.OfUserCustomToolResult; vt != nil {
+ return &vt.CustomToolUseID
+ }
+ return nil
+}
+
+// Returns a pointer to the underlying variant's property, if present.
+func (u BetaManagedAgentsEventParamsUnion) GetIsError() *bool {
+ if vt := u.OfUserCustomToolResult; vt != nil && vt.IsError.Valid() {
+ return &vt.IsError.Value
+ }
+ return nil
+}
+
+// Returns a pointer to the underlying variant's property, if present.
+func (u BetaManagedAgentsEventParamsUnion) GetType() *string {
+ if vt := u.OfUserMessage; vt != nil {
+ return (*string)(&vt.Type)
+ } else if vt := u.OfUserInterrupt; vt != nil {
+ return (*string)(&vt.Type)
+ } else if vt := u.OfUserToolConfirmation; vt != nil {
+ return (*string)(&vt.Type)
+ } else if vt := u.OfUserCustomToolResult; vt != nil {
+ return (*string)(&vt.Type)
+ }
+ return nil
+}
+
+// Returns a subunion which exports methods to access subproperties
+//
+// Or use AsAny() to get the underlying value
+func (u BetaManagedAgentsEventParamsUnion) GetContent() (res betaManagedAgentsEventParamsUnionContent) {
+ if vt := u.OfUserMessage; vt != nil {
+ res.any = &vt.Content
+ } else if vt := u.OfUserCustomToolResult; vt != nil {
+ res.any = &vt.Content
+ }
+ return
+}
+
+// Can have the runtime types
+// [_[]BetaManagedAgentsUserMessageEventParamsContentUnion],
+// [_[]BetaManagedAgentsUserCustomToolResultEventParamsContentUnion]
+type betaManagedAgentsEventParamsUnionContent struct{ any }
+
+// Use the following switch statement to get the type of the union:
+//
+// switch u.AsAny().(type) {
+// case *[]anthropic.BetaManagedAgentsUserMessageEventParamsContentUnion:
+// case *[]anthropic.BetaManagedAgentsUserCustomToolResultEventParamsContentUnion:
+// default:
+// fmt.Errorf("not present")
+// }
+func (u betaManagedAgentsEventParamsUnionContent) AsAny() any { return u.any }
+
+func init() {
+ apijson.RegisterUnion[BetaManagedAgentsEventParamsUnion](
+ "type",
+ apijson.Discriminator[BetaManagedAgentsUserMessageEventParams]("user.message"),
+ apijson.Discriminator[BetaManagedAgentsUserInterruptEventParams]("user.interrupt"),
+ apijson.Discriminator[BetaManagedAgentsUserToolConfirmationEventParams]("user.tool_confirmation"),
+ apijson.Discriminator[BetaManagedAgentsUserCustomToolResultEventParams]("user.custom_tool_result"),
+ )
+}
+
+// Document referenced by file ID.
+type BetaManagedAgentsFileDocumentSource struct {
+ // ID of a previously uploaded file.
+ FileID string `json:"file_id" api:"required"`
+ // Any of "file".
+ Type BetaManagedAgentsFileDocumentSourceType `json:"type" api:"required"`
+ // JSON contains metadata for fields, check presence with [respjson.Field.Valid].
+ JSON struct {
+ FileID respjson.Field
+ Type respjson.Field
+ ExtraFields map[string]respjson.Field
+ raw string
+ } `json:"-"`
+}
+
+// Returns the unmodified JSON received from the API
+func (r BetaManagedAgentsFileDocumentSource) RawJSON() string { return r.JSON.raw }
+func (r *BetaManagedAgentsFileDocumentSource) UnmarshalJSON(data []byte) error {
+ return apijson.UnmarshalRoot(data, r)
+}
+
+// ToParam converts this BetaManagedAgentsFileDocumentSource to a
+// BetaManagedAgentsFileDocumentSourceParam.
+//
+// Warning: the fields of the param type will not be present. ToParam should only
+// be used at the last possible moment before sending a request. Test for this with
+// BetaManagedAgentsFileDocumentSourceParam.Overrides()
+func (r BetaManagedAgentsFileDocumentSource) ToParam() BetaManagedAgentsFileDocumentSourceParam {
+ return param.Override[BetaManagedAgentsFileDocumentSourceParam](json.RawMessage(r.RawJSON()))
+}
+
+type BetaManagedAgentsFileDocumentSourceType string
+
+const (
+ BetaManagedAgentsFileDocumentSourceTypeFile BetaManagedAgentsFileDocumentSourceType = "file"
+)
+
+// Document referenced by file ID.
+//
+// The properties FileID, Type are required.
+type BetaManagedAgentsFileDocumentSourceParam struct {
+ // ID of a previously uploaded file.
+ FileID string `json:"file_id" api:"required"`
+ // Any of "file".
+ Type BetaManagedAgentsFileDocumentSourceType `json:"type,omitzero" api:"required"`
+ paramObj
+}
+
+func (r BetaManagedAgentsFileDocumentSourceParam) MarshalJSON() (data []byte, err error) {
+ type shadow BetaManagedAgentsFileDocumentSourceParam
+ return param.MarshalObject(r, (*shadow)(&r))
+}
+func (r *BetaManagedAgentsFileDocumentSourceParam) UnmarshalJSON(data []byte) error {
+ return apijson.UnmarshalRoot(data, r)
+}
+
+// Image referenced by file ID.
+type BetaManagedAgentsFileImageSource struct {
+ // ID of a previously uploaded file.
+ FileID string `json:"file_id" api:"required"`
+ // Any of "file".
+ Type BetaManagedAgentsFileImageSourceType `json:"type" api:"required"`
+ // JSON contains metadata for fields, check presence with [respjson.Field.Valid].
+ JSON struct {
+ FileID respjson.Field
+ Type respjson.Field
+ ExtraFields map[string]respjson.Field
+ raw string
+ } `json:"-"`
+}
+
+// Returns the unmodified JSON received from the API
+func (r BetaManagedAgentsFileImageSource) RawJSON() string { return r.JSON.raw }
+func (r *BetaManagedAgentsFileImageSource) UnmarshalJSON(data []byte) error {
+ return apijson.UnmarshalRoot(data, r)
+}
+
+// ToParam converts this BetaManagedAgentsFileImageSource to a
+// BetaManagedAgentsFileImageSourceParam.
+//
+// Warning: the fields of the param type will not be present. ToParam should only
+// be used at the last possible moment before sending a request. Test for this with
+// BetaManagedAgentsFileImageSourceParam.Overrides()
+func (r BetaManagedAgentsFileImageSource) ToParam() BetaManagedAgentsFileImageSourceParam {
+ return param.Override[BetaManagedAgentsFileImageSourceParam](json.RawMessage(r.RawJSON()))
+}
+
+type BetaManagedAgentsFileImageSourceType string
+
+const (
+ BetaManagedAgentsFileImageSourceTypeFile BetaManagedAgentsFileImageSourceType = "file"
+)
+
+// Image referenced by file ID.
+//
+// The properties FileID, Type are required.
+type BetaManagedAgentsFileImageSourceParam struct {
+ // ID of a previously uploaded file.
+ FileID string `json:"file_id" api:"required"`
+ // Any of "file".
+ Type BetaManagedAgentsFileImageSourceType `json:"type,omitzero" api:"required"`
+ paramObj
+}
+
+func (r BetaManagedAgentsFileImageSourceParam) MarshalJSON() (data []byte, err error) {
+ type shadow BetaManagedAgentsFileImageSourceParam
+ return param.MarshalObject(r, (*shadow)(&r))
+}
+func (r *BetaManagedAgentsFileImageSourceParam) UnmarshalJSON(data []byte) error {
+ return apijson.UnmarshalRoot(data, r)
+}
+
+// Image content specified directly as base64 data or as a reference via a URL.
+type BetaManagedAgentsImageBlock struct {
+ // Union type for image source variants.
+ Source BetaManagedAgentsImageBlockSourceUnion `json:"source" api:"required"`
+ // Any of "image".
+ Type BetaManagedAgentsImageBlockType `json:"type" api:"required"`
+ // JSON contains metadata for fields, check presence with [respjson.Field.Valid].
+ JSON struct {
+ Source respjson.Field
+ Type respjson.Field
+ ExtraFields map[string]respjson.Field
+ raw string
+ } `json:"-"`
+}
+
+// Returns the unmodified JSON received from the API
+func (r BetaManagedAgentsImageBlock) RawJSON() string { return r.JSON.raw }
+func (r *BetaManagedAgentsImageBlock) UnmarshalJSON(data []byte) error {
+ return apijson.UnmarshalRoot(data, r)
+}
+
+// ToParam converts this BetaManagedAgentsImageBlock to a
+// BetaManagedAgentsImageBlockParam.
+//
+// Warning: the fields of the param type will not be present. ToParam should only
+// be used at the last possible moment before sending a request. Test for this with
+// BetaManagedAgentsImageBlockParam.Overrides()
+func (r BetaManagedAgentsImageBlock) ToParam() BetaManagedAgentsImageBlockParam {
+ return param.Override[BetaManagedAgentsImageBlockParam](json.RawMessage(r.RawJSON()))
+}
+
+// BetaManagedAgentsImageBlockSourceUnion contains all possible properties and
+// values from [BetaManagedAgentsBase64ImageSource],
+// [BetaManagedAgentsURLImageSource], [BetaManagedAgentsFileImageSource].
+//
+// Use the [BetaManagedAgentsImageBlockSourceUnion.AsAny] method to switch on the
+// variant.
+//
+// Use the methods beginning with 'As' to cast the union to one of its variants.
+type BetaManagedAgentsImageBlockSourceUnion struct {
+ // This field is from variant [BetaManagedAgentsBase64ImageSource].
+ Data string `json:"data"`
+ // This field is from variant [BetaManagedAgentsBase64ImageSource].
+ MediaType string `json:"media_type"`
+ // Any of "base64", "url", "file".
+ Type string `json:"type"`
+ // This field is from variant [BetaManagedAgentsURLImageSource].
+ URL string `json:"url"`
+ // This field is from variant [BetaManagedAgentsFileImageSource].
+ FileID string `json:"file_id"`
+ JSON struct {
+ Data respjson.Field
+ MediaType respjson.Field
+ Type respjson.Field
+ URL respjson.Field
+ FileID respjson.Field
+ raw string
+ } `json:"-"`
+}
+
+// anyBetaManagedAgentsImageBlockSource is implemented by each variant of
+// [BetaManagedAgentsImageBlockSourceUnion] to add type safety for the return type
+// of [BetaManagedAgentsImageBlockSourceUnion.AsAny]
+type anyBetaManagedAgentsImageBlockSource interface {
+ implBetaManagedAgentsImageBlockSourceUnion()
+}
+
+func (BetaManagedAgentsBase64ImageSource) implBetaManagedAgentsImageBlockSourceUnion() {}
+func (BetaManagedAgentsURLImageSource) implBetaManagedAgentsImageBlockSourceUnion() {}
+func (BetaManagedAgentsFileImageSource) implBetaManagedAgentsImageBlockSourceUnion() {}
+
+// Use the following switch statement to find the correct variant
+//
+// switch variant := BetaManagedAgentsImageBlockSourceUnion.AsAny().(type) {
+// case anthropic.BetaManagedAgentsBase64ImageSource:
+// case anthropic.BetaManagedAgentsURLImageSource:
+// case anthropic.BetaManagedAgentsFileImageSource:
+// default:
+// fmt.Errorf("no variant present")
+// }
+func (u BetaManagedAgentsImageBlockSourceUnion) AsAny() anyBetaManagedAgentsImageBlockSource {
+ switch u.Type {
+ case "base64":
+ return u.AsBase64()
+ case "url":
+ return u.AsURL()
+ case "file":
+ return u.AsFile()
+ }
+ return nil
+}
+
+func (u BetaManagedAgentsImageBlockSourceUnion) AsBase64() (v BetaManagedAgentsBase64ImageSource) {
+ apijson.UnmarshalRoot(json.RawMessage(u.JSON.raw), &v)
+ return
+}
+
+func (u BetaManagedAgentsImageBlockSourceUnion) AsURL() (v BetaManagedAgentsURLImageSource) {
+ apijson.UnmarshalRoot(json.RawMessage(u.JSON.raw), &v)
+ return
+}
+
+func (u BetaManagedAgentsImageBlockSourceUnion) AsFile() (v BetaManagedAgentsFileImageSource) {
+ apijson.UnmarshalRoot(json.RawMessage(u.JSON.raw), &v)
+ return
+}
+
+// Returns the unmodified JSON received from the API
+func (u BetaManagedAgentsImageBlockSourceUnion) RawJSON() string { return u.JSON.raw }
+
+func (r *BetaManagedAgentsImageBlockSourceUnion) UnmarshalJSON(data []byte) error {
+ return apijson.UnmarshalRoot(data, r)
+}
+
+type BetaManagedAgentsImageBlockType string
+
+const (
+ BetaManagedAgentsImageBlockTypeImage BetaManagedAgentsImageBlockType = "image"
+)
+
+// Image content specified directly as base64 data or as a reference via a URL.
+//
+// The properties Source, Type are required.
+type BetaManagedAgentsImageBlockParam struct {
+ // Union type for image source variants.
+ Source BetaManagedAgentsImageBlockSourceUnionParam `json:"source,omitzero" api:"required"`
+ // Any of "image".
+ Type BetaManagedAgentsImageBlockType `json:"type,omitzero" api:"required"`
+ paramObj
+}
+
+func (r BetaManagedAgentsImageBlockParam) MarshalJSON() (data []byte, err error) {
+ type shadow BetaManagedAgentsImageBlockParam
+ return param.MarshalObject(r, (*shadow)(&r))
+}
+func (r *BetaManagedAgentsImageBlockParam) UnmarshalJSON(data []byte) error {
+ return apijson.UnmarshalRoot(data, r)
+}
+
+// Only one field can be non-zero.
+//
+// Use [param.IsOmitted] to confirm if a field is set.
+type BetaManagedAgentsImageBlockSourceUnionParam struct {
+ OfBase64 *BetaManagedAgentsBase64ImageSourceParam `json:",omitzero,inline"`
+ OfURL *BetaManagedAgentsURLImageSourceParam `json:",omitzero,inline"`
+ OfFile *BetaManagedAgentsFileImageSourceParam `json:",omitzero,inline"`
+ paramUnion
+}
+
+func (u BetaManagedAgentsImageBlockSourceUnionParam) MarshalJSON() ([]byte, error) {
+ return param.MarshalUnion(u, u.OfBase64, u.OfURL, u.OfFile)
+}
+func (u *BetaManagedAgentsImageBlockSourceUnionParam) UnmarshalJSON(data []byte) error {
+ return apijson.UnmarshalRoot(data, u)
+}
+
+func (u *BetaManagedAgentsImageBlockSourceUnionParam) asAny() any {
+ if !param.IsOmitted(u.OfBase64) {
+ return u.OfBase64
+ } else if !param.IsOmitted(u.OfURL) {
+ return u.OfURL
+ } else if !param.IsOmitted(u.OfFile) {
+ return u.OfFile
+ }
+ return nil
+}
+
+// Returns a pointer to the underlying variant's property, if present.
+func (u BetaManagedAgentsImageBlockSourceUnionParam) GetData() *string {
+ if vt := u.OfBase64; vt != nil {
+ return &vt.Data
+ }
+ return nil
+}
+
+// Returns a pointer to the underlying variant's property, if present.
+func (u BetaManagedAgentsImageBlockSourceUnionParam) GetMediaType() *string {
+ if vt := u.OfBase64; vt != nil {
+ return &vt.MediaType
+ }
+ return nil
+}
+
+// Returns a pointer to the underlying variant's property, if present.
+func (u BetaManagedAgentsImageBlockSourceUnionParam) GetURL() *string {
+ if vt := u.OfURL; vt != nil {
+ return &vt.URL
+ }
+ return nil
+}
+
+// Returns a pointer to the underlying variant's property, if present.
+func (u BetaManagedAgentsImageBlockSourceUnionParam) GetFileID() *string {
+ if vt := u.OfFile; vt != nil {
+ return &vt.FileID
+ }
+ return nil
+}
+
+// Returns a pointer to the underlying variant's property, if present.
+func (u BetaManagedAgentsImageBlockSourceUnionParam) GetType() *string {
+ if vt := u.OfBase64; vt != nil {
+ return (*string)(&vt.Type)
+ } else if vt := u.OfURL; vt != nil {
+ return (*string)(&vt.Type)
+ } else if vt := u.OfFile; vt != nil {
+ return (*string)(&vt.Type)
+ }
+ return nil
+}
+
+func init() {
+ apijson.RegisterUnion[BetaManagedAgentsImageBlockSourceUnionParam](
+ "type",
+ apijson.Discriminator[BetaManagedAgentsBase64ImageSourceParam]("base64"),
+ apijson.Discriminator[BetaManagedAgentsURLImageSourceParam]("url"),
+ apijson.Discriminator[BetaManagedAgentsFileImageSourceParam]("file"),
+ )
+}
+
+// Authentication to an MCP server failed.
+type BetaManagedAgentsMCPAuthenticationFailedError struct {
+ // Name of the MCP server that failed authentication.
+ MCPServerName string `json:"mcp_server_name" api:"required"`
+ // Human-readable error description.
+ Message string `json:"message" api:"required"`
+ // What the client should do next in response to this error.
+ RetryStatus BetaManagedAgentsMCPAuthenticationFailedErrorRetryStatusUnion `json:"retry_status" api:"required"`
+ // Any of "mcp_authentication_failed_error".
+ Type BetaManagedAgentsMCPAuthenticationFailedErrorType `json:"type" api:"required"`
+ // JSON contains metadata for fields, check presence with [respjson.Field.Valid].
+ JSON struct {
+ MCPServerName respjson.Field
+ Message respjson.Field
+ RetryStatus respjson.Field
+ Type respjson.Field
+ ExtraFields map[string]respjson.Field
+ raw string
+ } `json:"-"`
+}
+
+// Returns the unmodified JSON received from the API
+func (r BetaManagedAgentsMCPAuthenticationFailedError) RawJSON() string { return r.JSON.raw }
+func (r *BetaManagedAgentsMCPAuthenticationFailedError) UnmarshalJSON(data []byte) error {
+ return apijson.UnmarshalRoot(data, r)
+}
+
+// BetaManagedAgentsMCPAuthenticationFailedErrorRetryStatusUnion contains all
+// possible properties and values from [BetaManagedAgentsRetryStatusRetrying],
+// [BetaManagedAgentsRetryStatusExhausted], [BetaManagedAgentsRetryStatusTerminal].
+//
+// Use the [BetaManagedAgentsMCPAuthenticationFailedErrorRetryStatusUnion.AsAny]
+// method to switch on the variant.
+//
+// Use the methods beginning with 'As' to cast the union to one of its variants.
+type BetaManagedAgentsMCPAuthenticationFailedErrorRetryStatusUnion struct {
+ // Any of "retrying", "exhausted", "terminal".
+ Type string `json:"type"`
+ JSON struct {
+ Type respjson.Field
+ raw string
+ } `json:"-"`
+}
+
+// anyBetaManagedAgentsMCPAuthenticationFailedErrorRetryStatus is implemented by
+// each variant of [BetaManagedAgentsMCPAuthenticationFailedErrorRetryStatusUnion]
+// to add type safety for the return type of
+// [BetaManagedAgentsMCPAuthenticationFailedErrorRetryStatusUnion.AsAny]
+type anyBetaManagedAgentsMCPAuthenticationFailedErrorRetryStatus interface {
+ implBetaManagedAgentsMCPAuthenticationFailedErrorRetryStatusUnion()
+}
+
+func (BetaManagedAgentsRetryStatusRetrying) implBetaManagedAgentsMCPAuthenticationFailedErrorRetryStatusUnion() {
+}
+func (BetaManagedAgentsRetryStatusExhausted) implBetaManagedAgentsMCPAuthenticationFailedErrorRetryStatusUnion() {
+}
+func (BetaManagedAgentsRetryStatusTerminal) implBetaManagedAgentsMCPAuthenticationFailedErrorRetryStatusUnion() {
+}
+
+// Use the following switch statement to find the correct variant
+//
+// switch variant := BetaManagedAgentsMCPAuthenticationFailedErrorRetryStatusUnion.AsAny().(type) {
+// case anthropic.BetaManagedAgentsRetryStatusRetrying:
+// case anthropic.BetaManagedAgentsRetryStatusExhausted:
+// case anthropic.BetaManagedAgentsRetryStatusTerminal:
+// default:
+// fmt.Errorf("no variant present")
+// }
+func (u BetaManagedAgentsMCPAuthenticationFailedErrorRetryStatusUnion) AsAny() anyBetaManagedAgentsMCPAuthenticationFailedErrorRetryStatus {
+ switch u.Type {
+ case "retrying":
+ return u.AsRetrying()
+ case "exhausted":
+ return u.AsExhausted()
+ case "terminal":
+ return u.AsTerminal()
+ }
+ return nil
+}
+
+func (u BetaManagedAgentsMCPAuthenticationFailedErrorRetryStatusUnion) AsRetrying() (v BetaManagedAgentsRetryStatusRetrying) {
+ apijson.UnmarshalRoot(json.RawMessage(u.JSON.raw), &v)
+ return
+}
+
+func (u BetaManagedAgentsMCPAuthenticationFailedErrorRetryStatusUnion) AsExhausted() (v BetaManagedAgentsRetryStatusExhausted) {
+ apijson.UnmarshalRoot(json.RawMessage(u.JSON.raw), &v)
+ return
+}
+
+func (u BetaManagedAgentsMCPAuthenticationFailedErrorRetryStatusUnion) AsTerminal() (v BetaManagedAgentsRetryStatusTerminal) {
+ apijson.UnmarshalRoot(json.RawMessage(u.JSON.raw), &v)
+ return
+}
+
+// Returns the unmodified JSON received from the API
+func (u BetaManagedAgentsMCPAuthenticationFailedErrorRetryStatusUnion) RawJSON() string {
+ return u.JSON.raw
+}
+
+func (r *BetaManagedAgentsMCPAuthenticationFailedErrorRetryStatusUnion) UnmarshalJSON(data []byte) error {
+ return apijson.UnmarshalRoot(data, r)
+}
+
+type BetaManagedAgentsMCPAuthenticationFailedErrorType string
+
+const (
+ BetaManagedAgentsMCPAuthenticationFailedErrorTypeMCPAuthenticationFailedError BetaManagedAgentsMCPAuthenticationFailedErrorType = "mcp_authentication_failed_error"
+)
+
+// Failed to connect to an MCP server.
+type BetaManagedAgentsMCPConnectionFailedError struct {
+ // Name of the MCP server that failed to connect.
+ MCPServerName string `json:"mcp_server_name" api:"required"`
+ // Human-readable error description.
+ Message string `json:"message" api:"required"`
+ // What the client should do next in response to this error.
+ RetryStatus BetaManagedAgentsMCPConnectionFailedErrorRetryStatusUnion `json:"retry_status" api:"required"`
+ // Any of "mcp_connection_failed_error".
+ Type BetaManagedAgentsMCPConnectionFailedErrorType `json:"type" api:"required"`
+ // JSON contains metadata for fields, check presence with [respjson.Field.Valid].
+ JSON struct {
+ MCPServerName respjson.Field
+ Message respjson.Field
+ RetryStatus respjson.Field
+ Type respjson.Field
+ ExtraFields map[string]respjson.Field
+ raw string
+ } `json:"-"`
+}
+
+// Returns the unmodified JSON received from the API
+func (r BetaManagedAgentsMCPConnectionFailedError) RawJSON() string { return r.JSON.raw }
+func (r *BetaManagedAgentsMCPConnectionFailedError) UnmarshalJSON(data []byte) error {
+ return apijson.UnmarshalRoot(data, r)
+}
+
+// BetaManagedAgentsMCPConnectionFailedErrorRetryStatusUnion contains all possible
+// properties and values from [BetaManagedAgentsRetryStatusRetrying],
+// [BetaManagedAgentsRetryStatusExhausted], [BetaManagedAgentsRetryStatusTerminal].
+//
+// Use the [BetaManagedAgentsMCPConnectionFailedErrorRetryStatusUnion.AsAny] method
+// to switch on the variant.
+//
+// Use the methods beginning with 'As' to cast the union to one of its variants.
+type BetaManagedAgentsMCPConnectionFailedErrorRetryStatusUnion struct {
+ // Any of "retrying", "exhausted", "terminal".
+ Type string `json:"type"`
+ JSON struct {
+ Type respjson.Field
+ raw string
+ } `json:"-"`
+}
+
+// anyBetaManagedAgentsMCPConnectionFailedErrorRetryStatus is implemented by each
+// variant of [BetaManagedAgentsMCPConnectionFailedErrorRetryStatusUnion] to add
+// type safety for the return type of
+// [BetaManagedAgentsMCPConnectionFailedErrorRetryStatusUnion.AsAny]
+type anyBetaManagedAgentsMCPConnectionFailedErrorRetryStatus interface {
+ implBetaManagedAgentsMCPConnectionFailedErrorRetryStatusUnion()
+}
+
+func (BetaManagedAgentsRetryStatusRetrying) implBetaManagedAgentsMCPConnectionFailedErrorRetryStatusUnion() {
+}
+func (BetaManagedAgentsRetryStatusExhausted) implBetaManagedAgentsMCPConnectionFailedErrorRetryStatusUnion() {
+}
+func (BetaManagedAgentsRetryStatusTerminal) implBetaManagedAgentsMCPConnectionFailedErrorRetryStatusUnion() {
+}
+
+// Use the following switch statement to find the correct variant
+//
+// switch variant := BetaManagedAgentsMCPConnectionFailedErrorRetryStatusUnion.AsAny().(type) {
+// case anthropic.BetaManagedAgentsRetryStatusRetrying:
+// case anthropic.BetaManagedAgentsRetryStatusExhausted:
+// case anthropic.BetaManagedAgentsRetryStatusTerminal:
+// default:
+// fmt.Errorf("no variant present")
+// }
+func (u BetaManagedAgentsMCPConnectionFailedErrorRetryStatusUnion) AsAny() anyBetaManagedAgentsMCPConnectionFailedErrorRetryStatus {
+ switch u.Type {
+ case "retrying":
+ return u.AsRetrying()
+ case "exhausted":
+ return u.AsExhausted()
+ case "terminal":
+ return u.AsTerminal()
+ }
+ return nil
+}
+
+func (u BetaManagedAgentsMCPConnectionFailedErrorRetryStatusUnion) AsRetrying() (v BetaManagedAgentsRetryStatusRetrying) {
+ apijson.UnmarshalRoot(json.RawMessage(u.JSON.raw), &v)
+ return
+}
+
+func (u BetaManagedAgentsMCPConnectionFailedErrorRetryStatusUnion) AsExhausted() (v BetaManagedAgentsRetryStatusExhausted) {
+ apijson.UnmarshalRoot(json.RawMessage(u.JSON.raw), &v)
+ return
+}
+
+func (u BetaManagedAgentsMCPConnectionFailedErrorRetryStatusUnion) AsTerminal() (v BetaManagedAgentsRetryStatusTerminal) {
+ apijson.UnmarshalRoot(json.RawMessage(u.JSON.raw), &v)
+ return
+}
+
+// Returns the unmodified JSON received from the API
+func (u BetaManagedAgentsMCPConnectionFailedErrorRetryStatusUnion) RawJSON() string {
+ return u.JSON.raw
+}
+
+func (r *BetaManagedAgentsMCPConnectionFailedErrorRetryStatusUnion) UnmarshalJSON(data []byte) error {
+ return apijson.UnmarshalRoot(data, r)
+}
+
+type BetaManagedAgentsMCPConnectionFailedErrorType string
+
+const (
+ BetaManagedAgentsMCPConnectionFailedErrorTypeMCPConnectionFailedError BetaManagedAgentsMCPConnectionFailedErrorType = "mcp_connection_failed_error"
+)
+
+// The model is currently overloaded. Emitted after automatic retries are
+// exhausted.
+type BetaManagedAgentsModelOverloadedError struct {
+ // Human-readable error description.
+ Message string `json:"message" api:"required"`
+ // What the client should do next in response to this error.
+ RetryStatus BetaManagedAgentsModelOverloadedErrorRetryStatusUnion `json:"retry_status" api:"required"`
+ // Any of "model_overloaded_error".
+ Type BetaManagedAgentsModelOverloadedErrorType `json:"type" api:"required"`
+ // JSON contains metadata for fields, check presence with [respjson.Field.Valid].
+ JSON struct {
+ Message respjson.Field
+ RetryStatus respjson.Field
+ Type respjson.Field
+ ExtraFields map[string]respjson.Field
+ raw string
+ } `json:"-"`
+}
+
+// Returns the unmodified JSON received from the API
+func (r BetaManagedAgentsModelOverloadedError) RawJSON() string { return r.JSON.raw }
+func (r *BetaManagedAgentsModelOverloadedError) UnmarshalJSON(data []byte) error {
+ return apijson.UnmarshalRoot(data, r)
+}
+
+// BetaManagedAgentsModelOverloadedErrorRetryStatusUnion contains all possible
+// properties and values from [BetaManagedAgentsRetryStatusRetrying],
+// [BetaManagedAgentsRetryStatusExhausted], [BetaManagedAgentsRetryStatusTerminal].
+//
+// Use the [BetaManagedAgentsModelOverloadedErrorRetryStatusUnion.AsAny] method to
+// switch on the variant.
+//
+// Use the methods beginning with 'As' to cast the union to one of its variants.
+type BetaManagedAgentsModelOverloadedErrorRetryStatusUnion struct {
+ // Any of "retrying", "exhausted", "terminal".
+ Type string `json:"type"`
+ JSON struct {
+ Type respjson.Field
+ raw string
+ } `json:"-"`
+}
+
+// anyBetaManagedAgentsModelOverloadedErrorRetryStatus is implemented by each
+// variant of [BetaManagedAgentsModelOverloadedErrorRetryStatusUnion] to add type
+// safety for the return type of
+// [BetaManagedAgentsModelOverloadedErrorRetryStatusUnion.AsAny]
+type anyBetaManagedAgentsModelOverloadedErrorRetryStatus interface {
+ implBetaManagedAgentsModelOverloadedErrorRetryStatusUnion()
+}
+
+func (BetaManagedAgentsRetryStatusRetrying) implBetaManagedAgentsModelOverloadedErrorRetryStatusUnion() {
+}
+func (BetaManagedAgentsRetryStatusExhausted) implBetaManagedAgentsModelOverloadedErrorRetryStatusUnion() {
+}
+func (BetaManagedAgentsRetryStatusTerminal) implBetaManagedAgentsModelOverloadedErrorRetryStatusUnion() {
+}
+
+// Use the following switch statement to find the correct variant
+//
+// switch variant := BetaManagedAgentsModelOverloadedErrorRetryStatusUnion.AsAny().(type) {
+// case anthropic.BetaManagedAgentsRetryStatusRetrying:
+// case anthropic.BetaManagedAgentsRetryStatusExhausted:
+// case anthropic.BetaManagedAgentsRetryStatusTerminal:
+// default:
+// fmt.Errorf("no variant present")
+// }
+func (u BetaManagedAgentsModelOverloadedErrorRetryStatusUnion) AsAny() anyBetaManagedAgentsModelOverloadedErrorRetryStatus {
+ switch u.Type {
+ case "retrying":
+ return u.AsRetrying()
+ case "exhausted":
+ return u.AsExhausted()
+ case "terminal":
+ return u.AsTerminal()
+ }
+ return nil
+}
+
+func (u BetaManagedAgentsModelOverloadedErrorRetryStatusUnion) AsRetrying() (v BetaManagedAgentsRetryStatusRetrying) {
+ apijson.UnmarshalRoot(json.RawMessage(u.JSON.raw), &v)
+ return
+}
+
+func (u BetaManagedAgentsModelOverloadedErrorRetryStatusUnion) AsExhausted() (v BetaManagedAgentsRetryStatusExhausted) {
+ apijson.UnmarshalRoot(json.RawMessage(u.JSON.raw), &v)
+ return
+}
+
+func (u BetaManagedAgentsModelOverloadedErrorRetryStatusUnion) AsTerminal() (v BetaManagedAgentsRetryStatusTerminal) {
+ apijson.UnmarshalRoot(json.RawMessage(u.JSON.raw), &v)
+ return
+}
+
+// Returns the unmodified JSON received from the API
+func (u BetaManagedAgentsModelOverloadedErrorRetryStatusUnion) RawJSON() string { return u.JSON.raw }
+
+func (r *BetaManagedAgentsModelOverloadedErrorRetryStatusUnion) UnmarshalJSON(data []byte) error {
+ return apijson.UnmarshalRoot(data, r)
+}
+
+type BetaManagedAgentsModelOverloadedErrorType string
+
+const (
+ BetaManagedAgentsModelOverloadedErrorTypeModelOverloadedError BetaManagedAgentsModelOverloadedErrorType = "model_overloaded_error"
+)
+
+// The model request was rate-limited.
+type BetaManagedAgentsModelRateLimitedError struct {
+ // Human-readable error description.
+ Message string `json:"message" api:"required"`
+ // What the client should do next in response to this error.
+ RetryStatus BetaManagedAgentsModelRateLimitedErrorRetryStatusUnion `json:"retry_status" api:"required"`
+ // Any of "model_rate_limited_error".
+ Type BetaManagedAgentsModelRateLimitedErrorType `json:"type" api:"required"`
+ // JSON contains metadata for fields, check presence with [respjson.Field.Valid].
+ JSON struct {
+ Message respjson.Field
+ RetryStatus respjson.Field
+ Type respjson.Field
+ ExtraFields map[string]respjson.Field
+ raw string
+ } `json:"-"`
+}
+
+// Returns the unmodified JSON received from the API
+func (r BetaManagedAgentsModelRateLimitedError) RawJSON() string { return r.JSON.raw }
+func (r *BetaManagedAgentsModelRateLimitedError) UnmarshalJSON(data []byte) error {
+ return apijson.UnmarshalRoot(data, r)
+}
+
+// BetaManagedAgentsModelRateLimitedErrorRetryStatusUnion contains all possible
+// properties and values from [BetaManagedAgentsRetryStatusRetrying],
+// [BetaManagedAgentsRetryStatusExhausted], [BetaManagedAgentsRetryStatusTerminal].
+//
+// Use the [BetaManagedAgentsModelRateLimitedErrorRetryStatusUnion.AsAny] method to
+// switch on the variant.
+//
+// Use the methods beginning with 'As' to cast the union to one of its variants.
+type BetaManagedAgentsModelRateLimitedErrorRetryStatusUnion struct {
+ // Any of "retrying", "exhausted", "terminal".
+ Type string `json:"type"`
+ JSON struct {
+ Type respjson.Field
+ raw string
+ } `json:"-"`
+}
+
+// anyBetaManagedAgentsModelRateLimitedErrorRetryStatus is implemented by each
+// variant of [BetaManagedAgentsModelRateLimitedErrorRetryStatusUnion] to add type
+// safety for the return type of
+// [BetaManagedAgentsModelRateLimitedErrorRetryStatusUnion.AsAny]
+type anyBetaManagedAgentsModelRateLimitedErrorRetryStatus interface {
+ implBetaManagedAgentsModelRateLimitedErrorRetryStatusUnion()
+}
+
+func (BetaManagedAgentsRetryStatusRetrying) implBetaManagedAgentsModelRateLimitedErrorRetryStatusUnion() {
+}
+func (BetaManagedAgentsRetryStatusExhausted) implBetaManagedAgentsModelRateLimitedErrorRetryStatusUnion() {
+}
+func (BetaManagedAgentsRetryStatusTerminal) implBetaManagedAgentsModelRateLimitedErrorRetryStatusUnion() {
+}
+
+// Use the following switch statement to find the correct variant
+//
+// switch variant := BetaManagedAgentsModelRateLimitedErrorRetryStatusUnion.AsAny().(type) {
+// case anthropic.BetaManagedAgentsRetryStatusRetrying:
+// case anthropic.BetaManagedAgentsRetryStatusExhausted:
+// case anthropic.BetaManagedAgentsRetryStatusTerminal:
+// default:
+// fmt.Errorf("no variant present")
+// }
+func (u BetaManagedAgentsModelRateLimitedErrorRetryStatusUnion) AsAny() anyBetaManagedAgentsModelRateLimitedErrorRetryStatus {
+ switch u.Type {
+ case "retrying":
+ return u.AsRetrying()
+ case "exhausted":
+ return u.AsExhausted()
+ case "terminal":
+ return u.AsTerminal()
+ }
+ return nil
+}
+
+func (u BetaManagedAgentsModelRateLimitedErrorRetryStatusUnion) AsRetrying() (v BetaManagedAgentsRetryStatusRetrying) {
+ apijson.UnmarshalRoot(json.RawMessage(u.JSON.raw), &v)
+ return
+}
+
+func (u BetaManagedAgentsModelRateLimitedErrorRetryStatusUnion) AsExhausted() (v BetaManagedAgentsRetryStatusExhausted) {
+ apijson.UnmarshalRoot(json.RawMessage(u.JSON.raw), &v)
+ return
+}
+
+func (u BetaManagedAgentsModelRateLimitedErrorRetryStatusUnion) AsTerminal() (v BetaManagedAgentsRetryStatusTerminal) {
+ apijson.UnmarshalRoot(json.RawMessage(u.JSON.raw), &v)
+ return
+}
+
+// Returns the unmodified JSON received from the API
+func (u BetaManagedAgentsModelRateLimitedErrorRetryStatusUnion) RawJSON() string { return u.JSON.raw }
+
+func (r *BetaManagedAgentsModelRateLimitedErrorRetryStatusUnion) UnmarshalJSON(data []byte) error {
+ return apijson.UnmarshalRoot(data, r)
+}
+
+type BetaManagedAgentsModelRateLimitedErrorType string
+
+const (
+ BetaManagedAgentsModelRateLimitedErrorTypeModelRateLimitedError BetaManagedAgentsModelRateLimitedErrorType = "model_rate_limited_error"
+)
+
+// A model request failed for a reason other than overload or rate-limiting.
+type BetaManagedAgentsModelRequestFailedError struct {
+ // Human-readable error description.
+ Message string `json:"message" api:"required"`
+ // What the client should do next in response to this error.
+ RetryStatus BetaManagedAgentsModelRequestFailedErrorRetryStatusUnion `json:"retry_status" api:"required"`
+ // Any of "model_request_failed_error".
+ Type BetaManagedAgentsModelRequestFailedErrorType `json:"type" api:"required"`
+ // JSON contains metadata for fields, check presence with [respjson.Field.Valid].
+ JSON struct {
+ Message respjson.Field
+ RetryStatus respjson.Field
+ Type respjson.Field
+ ExtraFields map[string]respjson.Field
+ raw string
+ } `json:"-"`
+}
+
+// Returns the unmodified JSON received from the API
+func (r BetaManagedAgentsModelRequestFailedError) RawJSON() string { return r.JSON.raw }
+func (r *BetaManagedAgentsModelRequestFailedError) UnmarshalJSON(data []byte) error {
+ return apijson.UnmarshalRoot(data, r)
+}
+
+// BetaManagedAgentsModelRequestFailedErrorRetryStatusUnion contains all possible
+// properties and values from [BetaManagedAgentsRetryStatusRetrying],
+// [BetaManagedAgentsRetryStatusExhausted], [BetaManagedAgentsRetryStatusTerminal].
+//
+// Use the [BetaManagedAgentsModelRequestFailedErrorRetryStatusUnion.AsAny] method
+// to switch on the variant.
+//
+// Use the methods beginning with 'As' to cast the union to one of its variants.
+type BetaManagedAgentsModelRequestFailedErrorRetryStatusUnion struct {
+ // Any of "retrying", "exhausted", "terminal".
+ Type string `json:"type"`
+ JSON struct {
+ Type respjson.Field
+ raw string
+ } `json:"-"`
+}
+
+// anyBetaManagedAgentsModelRequestFailedErrorRetryStatus is implemented by each
+// variant of [BetaManagedAgentsModelRequestFailedErrorRetryStatusUnion] to add
+// type safety for the return type of
+// [BetaManagedAgentsModelRequestFailedErrorRetryStatusUnion.AsAny]
+type anyBetaManagedAgentsModelRequestFailedErrorRetryStatus interface {
+ implBetaManagedAgentsModelRequestFailedErrorRetryStatusUnion()
+}
+
+func (BetaManagedAgentsRetryStatusRetrying) implBetaManagedAgentsModelRequestFailedErrorRetryStatusUnion() {
+}
+func (BetaManagedAgentsRetryStatusExhausted) implBetaManagedAgentsModelRequestFailedErrorRetryStatusUnion() {
+}
+func (BetaManagedAgentsRetryStatusTerminal) implBetaManagedAgentsModelRequestFailedErrorRetryStatusUnion() {
+}
+
+// Use the following switch statement to find the correct variant
+//
+// switch variant := BetaManagedAgentsModelRequestFailedErrorRetryStatusUnion.AsAny().(type) {
+// case anthropic.BetaManagedAgentsRetryStatusRetrying:
+// case anthropic.BetaManagedAgentsRetryStatusExhausted:
+// case anthropic.BetaManagedAgentsRetryStatusTerminal:
+// default:
+// fmt.Errorf("no variant present")
+// }
+func (u BetaManagedAgentsModelRequestFailedErrorRetryStatusUnion) AsAny() anyBetaManagedAgentsModelRequestFailedErrorRetryStatus {
+ switch u.Type {
+ case "retrying":
+ return u.AsRetrying()
+ case "exhausted":
+ return u.AsExhausted()
+ case "terminal":
+ return u.AsTerminal()
+ }
+ return nil
+}
+
+func (u BetaManagedAgentsModelRequestFailedErrorRetryStatusUnion) AsRetrying() (v BetaManagedAgentsRetryStatusRetrying) {
+ apijson.UnmarshalRoot(json.RawMessage(u.JSON.raw), &v)
+ return
+}
+
+func (u BetaManagedAgentsModelRequestFailedErrorRetryStatusUnion) AsExhausted() (v BetaManagedAgentsRetryStatusExhausted) {
+ apijson.UnmarshalRoot(json.RawMessage(u.JSON.raw), &v)
+ return
+}
+
+func (u BetaManagedAgentsModelRequestFailedErrorRetryStatusUnion) AsTerminal() (v BetaManagedAgentsRetryStatusTerminal) {
+ apijson.UnmarshalRoot(json.RawMessage(u.JSON.raw), &v)
+ return
+}
+
+// Returns the unmodified JSON received from the API
+func (u BetaManagedAgentsModelRequestFailedErrorRetryStatusUnion) RawJSON() string { return u.JSON.raw }
+
+func (r *BetaManagedAgentsModelRequestFailedErrorRetryStatusUnion) UnmarshalJSON(data []byte) error {
+ return apijson.UnmarshalRoot(data, r)
+}
+
+type BetaManagedAgentsModelRequestFailedErrorType string
+
+const (
+ BetaManagedAgentsModelRequestFailedErrorTypeModelRequestFailedError BetaManagedAgentsModelRequestFailedErrorType = "model_request_failed_error"
+)
+
+// Plain text document content.
+type BetaManagedAgentsPlainTextDocumentSource struct {
+ // The plain text content.
+ Data string `json:"data" api:"required"`
+ // MIME type of the text content. Must be "text/plain".
+ //
+ // Any of "text/plain".
+ MediaType BetaManagedAgentsPlainTextDocumentSourceMediaType `json:"media_type" api:"required"`
+ // Any of "text".
+ Type BetaManagedAgentsPlainTextDocumentSourceType `json:"type" api:"required"`
+ // JSON contains metadata for fields, check presence with [respjson.Field.Valid].
+ JSON struct {
+ Data respjson.Field
+ MediaType respjson.Field
+ Type respjson.Field
+ ExtraFields map[string]respjson.Field
+ raw string
+ } `json:"-"`
+}
+
+// Returns the unmodified JSON received from the API
+func (r BetaManagedAgentsPlainTextDocumentSource) RawJSON() string { return r.JSON.raw }
+func (r *BetaManagedAgentsPlainTextDocumentSource) UnmarshalJSON(data []byte) error {
+ return apijson.UnmarshalRoot(data, r)
+}
+
+// ToParam converts this BetaManagedAgentsPlainTextDocumentSource to a
+// BetaManagedAgentsPlainTextDocumentSourceParam.
+//
+// Warning: the fields of the param type will not be present. ToParam should only
+// be used at the last possible moment before sending a request. Test for this with
+// BetaManagedAgentsPlainTextDocumentSourceParam.Overrides()
+func (r BetaManagedAgentsPlainTextDocumentSource) ToParam() BetaManagedAgentsPlainTextDocumentSourceParam {
+ return param.Override[BetaManagedAgentsPlainTextDocumentSourceParam](json.RawMessage(r.RawJSON()))
+}
+
+// MIME type of the text content. Must be "text/plain".
+type BetaManagedAgentsPlainTextDocumentSourceMediaType string
+
+const (
+ BetaManagedAgentsPlainTextDocumentSourceMediaTypeTextPlain BetaManagedAgentsPlainTextDocumentSourceMediaType = "text/plain"
+)
+
+type BetaManagedAgentsPlainTextDocumentSourceType string
+
+const (
+ BetaManagedAgentsPlainTextDocumentSourceTypeText BetaManagedAgentsPlainTextDocumentSourceType = "text"
+)
+
+// Plain text document content.
+//
+// The properties Data, MediaType, Type are required.
+type BetaManagedAgentsPlainTextDocumentSourceParam struct {
+ // The plain text content.
+ Data string `json:"data" api:"required"`
+ // MIME type of the text content. Must be "text/plain".
+ //
+ // Any of "text/plain".
+ MediaType BetaManagedAgentsPlainTextDocumentSourceMediaType `json:"media_type,omitzero" api:"required"`
+ // Any of "text".
+ Type BetaManagedAgentsPlainTextDocumentSourceType `json:"type,omitzero" api:"required"`
+ paramObj
+}
+
+func (r BetaManagedAgentsPlainTextDocumentSourceParam) MarshalJSON() (data []byte, err error) {
+ type shadow BetaManagedAgentsPlainTextDocumentSourceParam
+ return param.MarshalObject(r, (*shadow)(&r))
+}
+func (r *BetaManagedAgentsPlainTextDocumentSourceParam) UnmarshalJSON(data []byte) error {
+ return apijson.UnmarshalRoot(data, r)
+}
+
+// This turn is dead; queued inputs are flushed and the session returns to idle.
+// Client may send a new prompt.
+type BetaManagedAgentsRetryStatusExhausted struct {
+ // Any of "exhausted".
+ Type BetaManagedAgentsRetryStatusExhaustedType `json:"type" api:"required"`
+ // JSON contains metadata for fields, check presence with [respjson.Field.Valid].
+ JSON struct {
+ Type respjson.Field
+ ExtraFields map[string]respjson.Field
+ raw string
+ } `json:"-"`
+}
+
+// Returns the unmodified JSON received from the API
+func (r BetaManagedAgentsRetryStatusExhausted) RawJSON() string { return r.JSON.raw }
+func (r *BetaManagedAgentsRetryStatusExhausted) UnmarshalJSON(data []byte) error {
+ return apijson.UnmarshalRoot(data, r)
+}
+
+type BetaManagedAgentsRetryStatusExhaustedType string
+
+const (
+ BetaManagedAgentsRetryStatusExhaustedTypeExhausted BetaManagedAgentsRetryStatusExhaustedType = "exhausted"
+)
+
+// The server is retrying automatically. Client should wait; the same error type
+// may fire again as retrying, then once as exhausted when the retry budget runs
+// out.
+type BetaManagedAgentsRetryStatusRetrying struct {
+ // Any of "retrying".
+ Type BetaManagedAgentsRetryStatusRetryingType `json:"type" api:"required"`
+ // JSON contains metadata for fields, check presence with [respjson.Field.Valid].
+ JSON struct {
+ Type respjson.Field
+ ExtraFields map[string]respjson.Field
+ raw string
+ } `json:"-"`
+}
+
+// Returns the unmodified JSON received from the API
+func (r BetaManagedAgentsRetryStatusRetrying) RawJSON() string { return r.JSON.raw }
+func (r *BetaManagedAgentsRetryStatusRetrying) UnmarshalJSON(data []byte) error {
+ return apijson.UnmarshalRoot(data, r)
+}
+
+type BetaManagedAgentsRetryStatusRetryingType string
+
+const (
+ BetaManagedAgentsRetryStatusRetryingTypeRetrying BetaManagedAgentsRetryStatusRetryingType = "retrying"
+)
+
+// The session encountered a terminal error and will transition to `terminated`
+// state.
+type BetaManagedAgentsRetryStatusTerminal struct {
+ // Any of "terminal".
+ Type BetaManagedAgentsRetryStatusTerminalType `json:"type" api:"required"`
+ // JSON contains metadata for fields, check presence with [respjson.Field.Valid].
+ JSON struct {
+ Type respjson.Field
+ ExtraFields map[string]respjson.Field
+ raw string
+ } `json:"-"`
+}
+
+// Returns the unmodified JSON received from the API
+func (r BetaManagedAgentsRetryStatusTerminal) RawJSON() string { return r.JSON.raw }
+func (r *BetaManagedAgentsRetryStatusTerminal) UnmarshalJSON(data []byte) error {
+ return apijson.UnmarshalRoot(data, r)
+}
+
+type BetaManagedAgentsRetryStatusTerminalType string
+
+const (
+ BetaManagedAgentsRetryStatusTerminalTypeTerminal BetaManagedAgentsRetryStatusTerminalType = "terminal"
+)
+
+// Events that were successfully sent to the session.
+type BetaManagedAgentsSendSessionEvents struct {
+ // Sent events
+ Data []BetaManagedAgentsSendSessionEventsDataUnion `json:"data"`
+ // JSON contains metadata for fields, check presence with [respjson.Field.Valid].
+ JSON struct {
+ Data respjson.Field
+ ExtraFields map[string]respjson.Field
+ raw string
+ } `json:"-"`
+}
+
+// Returns the unmodified JSON received from the API
+func (r BetaManagedAgentsSendSessionEvents) RawJSON() string { return r.JSON.raw }
+func (r *BetaManagedAgentsSendSessionEvents) UnmarshalJSON(data []byte) error {
+ return apijson.UnmarshalRoot(data, r)
+}
+
+// BetaManagedAgentsSendSessionEventsDataUnion contains all possible properties and
+// values from [BetaManagedAgentsUserMessageEvent],
+// [BetaManagedAgentsUserInterruptEvent],
+// [BetaManagedAgentsUserToolConfirmationEvent],
+// [BetaManagedAgentsUserCustomToolResultEvent].
+//
+// Use the [BetaManagedAgentsSendSessionEventsDataUnion.AsAny] method to switch on
+// the variant.
+//
+// Use the methods beginning with 'As' to cast the union to one of its variants.
+type BetaManagedAgentsSendSessionEventsDataUnion struct {
+ ID string `json:"id"`
+ // This field is a union of [[]BetaManagedAgentsUserMessageEventContentUnion],
+ // [[]BetaManagedAgentsUserCustomToolResultEventContentUnion]
+ Content BetaManagedAgentsSendSessionEventsDataUnionContent `json:"content"`
+ // Any of "user.message", "user.interrupt", "user.tool_confirmation",
+ // "user.custom_tool_result".
+ Type string `json:"type"`
+ ProcessedAt time.Time `json:"processed_at"`
+ // This field is from variant [BetaManagedAgentsUserToolConfirmationEvent].
+ Result BetaManagedAgentsUserToolConfirmationEventResult `json:"result"`
+ // This field is from variant [BetaManagedAgentsUserToolConfirmationEvent].
+ ToolUseID string `json:"tool_use_id"`
+ // This field is from variant [BetaManagedAgentsUserToolConfirmationEvent].
+ DenyMessage string `json:"deny_message"`
+ // This field is from variant [BetaManagedAgentsUserCustomToolResultEvent].
+ CustomToolUseID string `json:"custom_tool_use_id"`
+ // This field is from variant [BetaManagedAgentsUserCustomToolResultEvent].
+ IsError bool `json:"is_error"`
+ JSON struct {
+ ID respjson.Field
+ Content respjson.Field
+ Type respjson.Field
+ ProcessedAt respjson.Field
+ Result respjson.Field
+ ToolUseID respjson.Field
+ DenyMessage respjson.Field
+ CustomToolUseID respjson.Field
+ IsError respjson.Field
+ raw string
+ } `json:"-"`
+}
+
+// anyBetaManagedAgentsSendSessionEventsData is implemented by each variant of
+// [BetaManagedAgentsSendSessionEventsDataUnion] to add type safety for the return
+// type of [BetaManagedAgentsSendSessionEventsDataUnion.AsAny]
+type anyBetaManagedAgentsSendSessionEventsData interface {
+ implBetaManagedAgentsSendSessionEventsDataUnion()
+}
+
+func (BetaManagedAgentsUserMessageEvent) implBetaManagedAgentsSendSessionEventsDataUnion() {}
+func (BetaManagedAgentsUserInterruptEvent) implBetaManagedAgentsSendSessionEventsDataUnion() {}
+func (BetaManagedAgentsUserToolConfirmationEvent) implBetaManagedAgentsSendSessionEventsDataUnion() {}
+func (BetaManagedAgentsUserCustomToolResultEvent) implBetaManagedAgentsSendSessionEventsDataUnion() {}
+
+// Use the following switch statement to find the correct variant
+//
+// switch variant := BetaManagedAgentsSendSessionEventsDataUnion.AsAny().(type) {
+// case anthropic.BetaManagedAgentsUserMessageEvent:
+// case anthropic.BetaManagedAgentsUserInterruptEvent:
+// case anthropic.BetaManagedAgentsUserToolConfirmationEvent:
+// case anthropic.BetaManagedAgentsUserCustomToolResultEvent:
+// default:
+// fmt.Errorf("no variant present")
+// }
+func (u BetaManagedAgentsSendSessionEventsDataUnion) AsAny() anyBetaManagedAgentsSendSessionEventsData {
+ switch u.Type {
+ case "user.message":
+ return u.AsUserMessage()
+ case "user.interrupt":
+ return u.AsUserInterrupt()
+ case "user.tool_confirmation":
+ return u.AsUserToolConfirmation()
+ case "user.custom_tool_result":
+ return u.AsUserCustomToolResult()
+ }
+ return nil
+}
+
+func (u BetaManagedAgentsSendSessionEventsDataUnion) AsUserMessage() (v BetaManagedAgentsUserMessageEvent) {
+ apijson.UnmarshalRoot(json.RawMessage(u.JSON.raw), &v)
+ return
+}
+
+func (u BetaManagedAgentsSendSessionEventsDataUnion) AsUserInterrupt() (v BetaManagedAgentsUserInterruptEvent) {
+ apijson.UnmarshalRoot(json.RawMessage(u.JSON.raw), &v)
+ return
+}
+
+func (u BetaManagedAgentsSendSessionEventsDataUnion) AsUserToolConfirmation() (v BetaManagedAgentsUserToolConfirmationEvent) {
+ apijson.UnmarshalRoot(json.RawMessage(u.JSON.raw), &v)
+ return
+}
+
+func (u BetaManagedAgentsSendSessionEventsDataUnion) AsUserCustomToolResult() (v BetaManagedAgentsUserCustomToolResultEvent) {
+ apijson.UnmarshalRoot(json.RawMessage(u.JSON.raw), &v)
+ return
+}
+
+// Returns the unmodified JSON received from the API
+func (u BetaManagedAgentsSendSessionEventsDataUnion) RawJSON() string { return u.JSON.raw }
+
+func (r *BetaManagedAgentsSendSessionEventsDataUnion) UnmarshalJSON(data []byte) error {
+ return apijson.UnmarshalRoot(data, r)
+}
+
+// BetaManagedAgentsSendSessionEventsDataUnionContent is an implicit subunion of
+// [BetaManagedAgentsSendSessionEventsDataUnion].
+// BetaManagedAgentsSendSessionEventsDataUnionContent provides convenient access to
+// the sub-properties of the union.
+//
+// For type safety it is recommended to directly use a variant of the
+// [BetaManagedAgentsSendSessionEventsDataUnion].
+//
+// If the underlying value is not a json object, one of the following properties
+// will be valid: OfBetaManagedAgentsUserMessageEventContentArray
+// OfBetaManagedAgentsUserCustomToolResultEventContentArray]
+type BetaManagedAgentsSendSessionEventsDataUnionContent struct {
+ // This field will be present if the value is a
+ // [[]BetaManagedAgentsUserMessageEventContentUnion] instead of an object.
+ OfBetaManagedAgentsUserMessageEventContentArray []BetaManagedAgentsUserMessageEventContentUnion `json:",inline"`
+ // This field will be present if the value is a
+ // [[]BetaManagedAgentsUserCustomToolResultEventContentUnion] instead of an object.
+ OfBetaManagedAgentsUserCustomToolResultEventContentArray []BetaManagedAgentsUserCustomToolResultEventContentUnion `json:",inline"`
+ JSON struct {
+ OfBetaManagedAgentsUserMessageEventContentArray respjson.Field
+ OfBetaManagedAgentsUserCustomToolResultEventContentArray respjson.Field
+ raw string
+ } `json:"-"`
+}
+
+func (r *BetaManagedAgentsSendSessionEventsDataUnionContent) UnmarshalJSON(data []byte) error {
+ return apijson.UnmarshalRoot(data, r)
+}
+
+// Emitted when a session has been deleted. Terminates any active event stream — no
+// further events will be emitted for this session.
+type BetaManagedAgentsSessionDeletedEvent struct {
+ // Unique identifier for this event.
+ ID string `json:"id" api:"required"`
+ // A timestamp in RFC 3339 format
+ ProcessedAt time.Time `json:"processed_at" api:"required" format:"date-time"`
+ // Any of "session.deleted".
+ Type BetaManagedAgentsSessionDeletedEventType `json:"type" api:"required"`
+ // JSON contains metadata for fields, check presence with [respjson.Field.Valid].
+ JSON struct {
+ ID respjson.Field
+ ProcessedAt respjson.Field
+ Type respjson.Field
+ ExtraFields map[string]respjson.Field
+ raw string
+ } `json:"-"`
+}
+
+// Returns the unmodified JSON received from the API
+func (r BetaManagedAgentsSessionDeletedEvent) RawJSON() string { return r.JSON.raw }
+func (r *BetaManagedAgentsSessionDeletedEvent) UnmarshalJSON(data []byte) error {
+ return apijson.UnmarshalRoot(data, r)
+}
+
+type BetaManagedAgentsSessionDeletedEventType string
+
+const (
+ BetaManagedAgentsSessionDeletedEventTypeSessionDeleted BetaManagedAgentsSessionDeletedEventType = "session.deleted"
+)
+
+// The agent completed its turn naturally and is ready for the next user message.
+type BetaManagedAgentsSessionEndTurn struct {
+ // Any of "end_turn".
+ Type BetaManagedAgentsSessionEndTurnType `json:"type" api:"required"`
+ // JSON contains metadata for fields, check presence with [respjson.Field.Valid].
+ JSON struct {
+ Type respjson.Field
+ ExtraFields map[string]respjson.Field
+ raw string
+ } `json:"-"`
+}
+
+// Returns the unmodified JSON received from the API
+func (r BetaManagedAgentsSessionEndTurn) RawJSON() string { return r.JSON.raw }
+func (r *BetaManagedAgentsSessionEndTurn) UnmarshalJSON(data []byte) error {
+ return apijson.UnmarshalRoot(data, r)
+}
+
+type BetaManagedAgentsSessionEndTurnType string
+
+const (
+ BetaManagedAgentsSessionEndTurnTypeEndTurn BetaManagedAgentsSessionEndTurnType = "end_turn"
+)
+
+// An error event indicating a problem occurred during session execution.
+type BetaManagedAgentsSessionErrorEvent struct {
+ // Unique identifier for this event.
+ ID string `json:"id" api:"required"`
+ // An unknown or unexpected error occurred during session execution. A fallback
+ // variant; clients that don't recognize a new error code can match on
+ // `retry_status` and `message` alone.
+ Error BetaManagedAgentsSessionErrorEventErrorUnion `json:"error" api:"required"`
+ // A timestamp in RFC 3339 format
+ ProcessedAt time.Time `json:"processed_at" api:"required" format:"date-time"`
+ // Any of "session.error".
+ Type BetaManagedAgentsSessionErrorEventType `json:"type" api:"required"`
+ // JSON contains metadata for fields, check presence with [respjson.Field.Valid].
+ JSON struct {
+ ID respjson.Field
+ Error respjson.Field
+ ProcessedAt respjson.Field
+ Type respjson.Field
+ ExtraFields map[string]respjson.Field
+ raw string
+ } `json:"-"`
+}
+
+// Returns the unmodified JSON received from the API
+func (r BetaManagedAgentsSessionErrorEvent) RawJSON() string { return r.JSON.raw }
+func (r *BetaManagedAgentsSessionErrorEvent) UnmarshalJSON(data []byte) error {
+ return apijson.UnmarshalRoot(data, r)
+}
+
+// BetaManagedAgentsSessionErrorEventErrorUnion contains all possible properties
+// and values from [BetaManagedAgentsUnknownError],
+// [BetaManagedAgentsModelOverloadedError],
+// [BetaManagedAgentsModelRateLimitedError],
+// [BetaManagedAgentsModelRequestFailedError],
+// [BetaManagedAgentsMCPConnectionFailedError],
+// [BetaManagedAgentsMCPAuthenticationFailedError],
+// [BetaManagedAgentsBillingError].
+//
+// Use the [BetaManagedAgentsSessionErrorEventErrorUnion.AsAny] method to switch on
+// the variant.
+//
+// Use the methods beginning with 'As' to cast the union to one of its variants.
+type BetaManagedAgentsSessionErrorEventErrorUnion struct {
+ Message string `json:"message"`
+ // This field is a union of [BetaManagedAgentsUnknownErrorRetryStatusUnion],
+ // [BetaManagedAgentsModelOverloadedErrorRetryStatusUnion],
+ // [BetaManagedAgentsModelRateLimitedErrorRetryStatusUnion],
+ // [BetaManagedAgentsModelRequestFailedErrorRetryStatusUnion],
+ // [BetaManagedAgentsMCPConnectionFailedErrorRetryStatusUnion],
+ // [BetaManagedAgentsMCPAuthenticationFailedErrorRetryStatusUnion],
+ // [BetaManagedAgentsBillingErrorRetryStatusUnion]
+ RetryStatus BetaManagedAgentsSessionErrorEventErrorUnionRetryStatus `json:"retry_status"`
+ // Any of "unknown_error", "model_overloaded_error", "model_rate_limited_error",
+ // "model_request_failed_error", "mcp_connection_failed_error",
+ // "mcp_authentication_failed_error", "billing_error".
+ Type string `json:"type"`
+ MCPServerName string `json:"mcp_server_name"`
+ JSON struct {
+ Message respjson.Field
+ RetryStatus respjson.Field
+ Type respjson.Field
+ MCPServerName respjson.Field
+ raw string
+ } `json:"-"`
+}
+
+// anyBetaManagedAgentsSessionErrorEventError is implemented by each variant of
+// [BetaManagedAgentsSessionErrorEventErrorUnion] to add type safety for the return
+// type of [BetaManagedAgentsSessionErrorEventErrorUnion.AsAny]
+type anyBetaManagedAgentsSessionErrorEventError interface {
+ implBetaManagedAgentsSessionErrorEventErrorUnion()
+}
+
+func (BetaManagedAgentsUnknownError) implBetaManagedAgentsSessionErrorEventErrorUnion() {}
+func (BetaManagedAgentsModelOverloadedError) implBetaManagedAgentsSessionErrorEventErrorUnion() {}
+func (BetaManagedAgentsModelRateLimitedError) implBetaManagedAgentsSessionErrorEventErrorUnion() {}
+func (BetaManagedAgentsModelRequestFailedError) implBetaManagedAgentsSessionErrorEventErrorUnion() {}
+func (BetaManagedAgentsMCPConnectionFailedError) implBetaManagedAgentsSessionErrorEventErrorUnion() {}
+func (BetaManagedAgentsMCPAuthenticationFailedError) implBetaManagedAgentsSessionErrorEventErrorUnion() {
+}
+func (BetaManagedAgentsBillingError) implBetaManagedAgentsSessionErrorEventErrorUnion() {}
+
+// Use the following switch statement to find the correct variant
+//
+// switch variant := BetaManagedAgentsSessionErrorEventErrorUnion.AsAny().(type) {
+// case anthropic.BetaManagedAgentsUnknownError:
+// case anthropic.BetaManagedAgentsModelOverloadedError:
+// case anthropic.BetaManagedAgentsModelRateLimitedError:
+// case anthropic.BetaManagedAgentsModelRequestFailedError:
+// case anthropic.BetaManagedAgentsMCPConnectionFailedError:
+// case anthropic.BetaManagedAgentsMCPAuthenticationFailedError:
+// case anthropic.BetaManagedAgentsBillingError:
+// default:
+// fmt.Errorf("no variant present")
+// }
+func (u BetaManagedAgentsSessionErrorEventErrorUnion) AsAny() anyBetaManagedAgentsSessionErrorEventError {
+ switch u.Type {
+ case "unknown_error":
+ return u.AsUnknownError()
+ case "model_overloaded_error":
+ return u.AsModelOverloadedError()
+ case "model_rate_limited_error":
+ return u.AsModelRateLimitedError()
+ case "model_request_failed_error":
+ return u.AsModelRequestFailedError()
+ case "mcp_connection_failed_error":
+ return u.AsMCPConnectionFailedError()
+ case "mcp_authentication_failed_error":
+ return u.AsMCPAuthenticationFailedError()
+ case "billing_error":
+ return u.AsBillingError()
+ }
+ return nil
+}
+
+func (u BetaManagedAgentsSessionErrorEventErrorUnion) AsUnknownError() (v BetaManagedAgentsUnknownError) {
+ apijson.UnmarshalRoot(json.RawMessage(u.JSON.raw), &v)
+ return
+}
+
+func (u BetaManagedAgentsSessionErrorEventErrorUnion) AsModelOverloadedError() (v BetaManagedAgentsModelOverloadedError) {
+ apijson.UnmarshalRoot(json.RawMessage(u.JSON.raw), &v)
+ return
+}
+
+func (u BetaManagedAgentsSessionErrorEventErrorUnion) AsModelRateLimitedError() (v BetaManagedAgentsModelRateLimitedError) {
+ apijson.UnmarshalRoot(json.RawMessage(u.JSON.raw), &v)
+ return
+}
+
+func (u BetaManagedAgentsSessionErrorEventErrorUnion) AsModelRequestFailedError() (v BetaManagedAgentsModelRequestFailedError) {
+ apijson.UnmarshalRoot(json.RawMessage(u.JSON.raw), &v)
+ return
+}
+
+func (u BetaManagedAgentsSessionErrorEventErrorUnion) AsMCPConnectionFailedError() (v BetaManagedAgentsMCPConnectionFailedError) {
+ apijson.UnmarshalRoot(json.RawMessage(u.JSON.raw), &v)
+ return
+}
+
+func (u BetaManagedAgentsSessionErrorEventErrorUnion) AsMCPAuthenticationFailedError() (v BetaManagedAgentsMCPAuthenticationFailedError) {
+ apijson.UnmarshalRoot(json.RawMessage(u.JSON.raw), &v)
+ return
+}
+
+func (u BetaManagedAgentsSessionErrorEventErrorUnion) AsBillingError() (v BetaManagedAgentsBillingError) {
+ apijson.UnmarshalRoot(json.RawMessage(u.JSON.raw), &v)
+ return
+}
+
+// Returns the unmodified JSON received from the API
+func (u BetaManagedAgentsSessionErrorEventErrorUnion) RawJSON() string { return u.JSON.raw }
+
+func (r *BetaManagedAgentsSessionErrorEventErrorUnion) UnmarshalJSON(data []byte) error {
+ return apijson.UnmarshalRoot(data, r)
+}
+
+// BetaManagedAgentsSessionErrorEventErrorUnionRetryStatus is an implicit subunion
+// of [BetaManagedAgentsSessionErrorEventErrorUnion].
+// BetaManagedAgentsSessionErrorEventErrorUnionRetryStatus provides convenient
+// access to the sub-properties of the union.
+//
+// For type safety it is recommended to directly use a variant of the
+// [BetaManagedAgentsSessionErrorEventErrorUnion].
+type BetaManagedAgentsSessionErrorEventErrorUnionRetryStatus struct {
+ Type string `json:"type"`
+ JSON struct {
+ Type respjson.Field
+ raw string
+ } `json:"-"`
+}
+
+func (r *BetaManagedAgentsSessionErrorEventErrorUnionRetryStatus) UnmarshalJSON(data []byte) error {
+ return apijson.UnmarshalRoot(data, r)
+}
+
+type BetaManagedAgentsSessionErrorEventType string
+
+const (
+ BetaManagedAgentsSessionErrorEventTypeSessionError BetaManagedAgentsSessionErrorEventType = "session.error"
+)
+
+// BetaManagedAgentsSessionEventUnion contains all possible properties and values
+// from [BetaManagedAgentsUserMessageEvent], [BetaManagedAgentsUserInterruptEvent],
+// [BetaManagedAgentsUserToolConfirmationEvent],
+// [BetaManagedAgentsUserCustomToolResultEvent],
+// [BetaManagedAgentsAgentCustomToolUseEvent],
+// [BetaManagedAgentsAgentMessageEvent], [BetaManagedAgentsAgentThinkingEvent],
+// [BetaManagedAgentsAgentMCPToolUseEvent],
+// [BetaManagedAgentsAgentMCPToolResultEvent],
+// [BetaManagedAgentsAgentToolUseEvent], [BetaManagedAgentsAgentToolResultEvent],
+// [BetaManagedAgentsAgentThreadContextCompactedEvent],
+// [BetaManagedAgentsSessionErrorEvent],
+// [BetaManagedAgentsSessionStatusRescheduledEvent],
+// [BetaManagedAgentsSessionStatusRunningEvent],
+// [BetaManagedAgentsSessionStatusIdleEvent],
+// [BetaManagedAgentsSessionStatusTerminatedEvent],
+// [BetaManagedAgentsSpanModelRequestStartEvent],
+// [BetaManagedAgentsSpanModelRequestEndEvent],
+// [BetaManagedAgentsSessionDeletedEvent].
+//
+// Use the [BetaManagedAgentsSessionEventUnion.AsAny] method to switch on the
+// variant.
+//
+// Use the methods beginning with 'As' to cast the union to one of its variants.
+type BetaManagedAgentsSessionEventUnion struct {
+ ID string `json:"id"`
+ // This field is a union of [[]BetaManagedAgentsUserMessageEventContentUnion],
+ // [[]BetaManagedAgentsUserCustomToolResultEventContentUnion],
+ // [[]BetaManagedAgentsTextBlock],
+ // [[]BetaManagedAgentsAgentMCPToolResultEventContentUnion],
+ // [[]BetaManagedAgentsAgentToolResultEventContentUnion]
+ Content BetaManagedAgentsSessionEventUnionContent `json:"content"`
+ // Any of "user.message", "user.interrupt", "user.tool_confirmation",
+ // "user.custom_tool_result", "agent.custom_tool_use", "agent.message",
+ // "agent.thinking", "agent.mcp_tool_use", "agent.mcp_tool_result",
+ // "agent.tool_use", "agent.tool_result", "agent.thread_context_compacted",
+ // "session.error", "session.status_rescheduled", "session.status_running",
+ // "session.status_idle", "session.status_terminated", "span.model_request_start",
+ // "span.model_request_end", "session.deleted".
+ Type string `json:"type"`
+ ProcessedAt time.Time `json:"processed_at"`
+ // This field is from variant [BetaManagedAgentsUserToolConfirmationEvent].
+ Result BetaManagedAgentsUserToolConfirmationEventResult `json:"result"`
+ ToolUseID string `json:"tool_use_id"`
+ // This field is from variant [BetaManagedAgentsUserToolConfirmationEvent].
+ DenyMessage string `json:"deny_message"`
+ // This field is from variant [BetaManagedAgentsUserCustomToolResultEvent].
+ CustomToolUseID string `json:"custom_tool_use_id"`
+ IsError bool `json:"is_error"`
+ Input any `json:"input"`
+ Name string `json:"name"`
+ // This field is from variant [BetaManagedAgentsAgentMCPToolUseEvent].
+ MCPServerName string `json:"mcp_server_name"`
+ EvaluatedPermission string `json:"evaluated_permission"`
+ // This field is from variant [BetaManagedAgentsAgentMCPToolResultEvent].
+ MCPToolUseID string `json:"mcp_tool_use_id"`
+ // This field is from variant [BetaManagedAgentsSessionErrorEvent].
+ Error BetaManagedAgentsSessionErrorEventErrorUnion `json:"error"`
+ // This field is from variant [BetaManagedAgentsSessionStatusIdleEvent].
+ StopReason BetaManagedAgentsSessionStatusIdleEventStopReasonUnion `json:"stop_reason"`
+ // This field is from variant [BetaManagedAgentsSpanModelRequestEndEvent].
+ ModelRequestStartID string `json:"model_request_start_id"`
+ // This field is from variant [BetaManagedAgentsSpanModelRequestEndEvent].
+ ModelUsage BetaManagedAgentsSpanModelUsage `json:"model_usage"`
+ JSON struct {
+ ID respjson.Field
+ Content respjson.Field
+ Type respjson.Field
+ ProcessedAt respjson.Field
+ Result respjson.Field
+ ToolUseID respjson.Field
+ DenyMessage respjson.Field
+ CustomToolUseID respjson.Field
+ IsError respjson.Field
+ Input respjson.Field
+ Name respjson.Field
+ MCPServerName respjson.Field
+ EvaluatedPermission respjson.Field
+ MCPToolUseID respjson.Field
+ Error respjson.Field
+ StopReason respjson.Field
+ ModelRequestStartID respjson.Field
+ ModelUsage respjson.Field
+ raw string
+ } `json:"-"`
+}
+
+// anyBetaManagedAgentsSessionEvent is implemented by each variant of
+// [BetaManagedAgentsSessionEventUnion] to add type safety for the return type of
+// [BetaManagedAgentsSessionEventUnion.AsAny]
+type anyBetaManagedAgentsSessionEvent interface {
+ implBetaManagedAgentsSessionEventUnion()
+}
+
+func (BetaManagedAgentsUserMessageEvent) implBetaManagedAgentsSessionEventUnion() {}
+func (BetaManagedAgentsUserInterruptEvent) implBetaManagedAgentsSessionEventUnion() {}
+func (BetaManagedAgentsUserToolConfirmationEvent) implBetaManagedAgentsSessionEventUnion() {}
+func (BetaManagedAgentsUserCustomToolResultEvent) implBetaManagedAgentsSessionEventUnion() {}
+func (BetaManagedAgentsAgentCustomToolUseEvent) implBetaManagedAgentsSessionEventUnion() {}
+func (BetaManagedAgentsAgentMessageEvent) implBetaManagedAgentsSessionEventUnion() {}
+func (BetaManagedAgentsAgentThinkingEvent) implBetaManagedAgentsSessionEventUnion() {}
+func (BetaManagedAgentsAgentMCPToolUseEvent) implBetaManagedAgentsSessionEventUnion() {}
+func (BetaManagedAgentsAgentMCPToolResultEvent) implBetaManagedAgentsSessionEventUnion() {}
+func (BetaManagedAgentsAgentToolUseEvent) implBetaManagedAgentsSessionEventUnion() {}
+func (BetaManagedAgentsAgentToolResultEvent) implBetaManagedAgentsSessionEventUnion() {}
+func (BetaManagedAgentsAgentThreadContextCompactedEvent) implBetaManagedAgentsSessionEventUnion() {}
+func (BetaManagedAgentsSessionErrorEvent) implBetaManagedAgentsSessionEventUnion() {}
+func (BetaManagedAgentsSessionStatusRescheduledEvent) implBetaManagedAgentsSessionEventUnion() {}
+func (BetaManagedAgentsSessionStatusRunningEvent) implBetaManagedAgentsSessionEventUnion() {}
+func (BetaManagedAgentsSessionStatusIdleEvent) implBetaManagedAgentsSessionEventUnion() {}
+func (BetaManagedAgentsSessionStatusTerminatedEvent) implBetaManagedAgentsSessionEventUnion() {}
+func (BetaManagedAgentsSpanModelRequestStartEvent) implBetaManagedAgentsSessionEventUnion() {}
+func (BetaManagedAgentsSpanModelRequestEndEvent) implBetaManagedAgentsSessionEventUnion() {}
+func (BetaManagedAgentsSessionDeletedEvent) implBetaManagedAgentsSessionEventUnion() {}
+
+// Use the following switch statement to find the correct variant
+//
+// switch variant := BetaManagedAgentsSessionEventUnion.AsAny().(type) {
+// case anthropic.BetaManagedAgentsUserMessageEvent:
+// case anthropic.BetaManagedAgentsUserInterruptEvent:
+// case anthropic.BetaManagedAgentsUserToolConfirmationEvent:
+// case anthropic.BetaManagedAgentsUserCustomToolResultEvent:
+// case anthropic.BetaManagedAgentsAgentCustomToolUseEvent:
+// case anthropic.BetaManagedAgentsAgentMessageEvent:
+// case anthropic.BetaManagedAgentsAgentThinkingEvent:
+// case anthropic.BetaManagedAgentsAgentMCPToolUseEvent:
+// case anthropic.BetaManagedAgentsAgentMCPToolResultEvent:
+// case anthropic.BetaManagedAgentsAgentToolUseEvent:
+// case anthropic.BetaManagedAgentsAgentToolResultEvent:
+// case anthropic.BetaManagedAgentsAgentThreadContextCompactedEvent:
+// case anthropic.BetaManagedAgentsSessionErrorEvent:
+// case anthropic.BetaManagedAgentsSessionStatusRescheduledEvent:
+// case anthropic.BetaManagedAgentsSessionStatusRunningEvent:
+// case anthropic.BetaManagedAgentsSessionStatusIdleEvent:
+// case anthropic.BetaManagedAgentsSessionStatusTerminatedEvent:
+// case anthropic.BetaManagedAgentsSpanModelRequestStartEvent:
+// case anthropic.BetaManagedAgentsSpanModelRequestEndEvent:
+// case anthropic.BetaManagedAgentsSessionDeletedEvent:
+// default:
+// fmt.Errorf("no variant present")
+// }
+func (u BetaManagedAgentsSessionEventUnion) AsAny() anyBetaManagedAgentsSessionEvent {
+ switch u.Type {
+ case "user.message":
+ return u.AsUserMessage()
+ case "user.interrupt":
+ return u.AsUserInterrupt()
+ case "user.tool_confirmation":
+ return u.AsUserToolConfirmation()
+ case "user.custom_tool_result":
+ return u.AsUserCustomToolResult()
+ case "agent.custom_tool_use":
+ return u.AsAgentCustomToolUse()
+ case "agent.message":
+ return u.AsAgentMessage()
+ case "agent.thinking":
+ return u.AsAgentThinking()
+ case "agent.mcp_tool_use":
+ return u.AsAgentMCPToolUse()
+ case "agent.mcp_tool_result":
+ return u.AsAgentMCPToolResult()
+ case "agent.tool_use":
+ return u.AsAgentToolUse()
+ case "agent.tool_result":
+ return u.AsAgentToolResult()
+ case "agent.thread_context_compacted":
+ return u.AsAgentThreadContextCompacted()
+ case "session.error":
+ return u.AsSessionError()
+ case "session.status_rescheduled":
+ return u.AsSessionStatusRescheduled()
+ case "session.status_running":
+ return u.AsSessionStatusRunning()
+ case "session.status_idle":
+ return u.AsSessionStatusIdle()
+ case "session.status_terminated":
+ return u.AsSessionStatusTerminated()
+ case "span.model_request_start":
+ return u.AsSpanModelRequestStart()
+ case "span.model_request_end":
+ return u.AsSpanModelRequestEnd()
+ case "session.deleted":
+ return u.AsSessionDeleted()
+ }
+ return nil
+}
+
+func (u BetaManagedAgentsSessionEventUnion) AsUserMessage() (v BetaManagedAgentsUserMessageEvent) {
+ apijson.UnmarshalRoot(json.RawMessage(u.JSON.raw), &v)
+ return
+}
+
+func (u BetaManagedAgentsSessionEventUnion) AsUserInterrupt() (v BetaManagedAgentsUserInterruptEvent) {
+ apijson.UnmarshalRoot(json.RawMessage(u.JSON.raw), &v)
+ return
+}
+
+func (u BetaManagedAgentsSessionEventUnion) AsUserToolConfirmation() (v BetaManagedAgentsUserToolConfirmationEvent) {
+ apijson.UnmarshalRoot(json.RawMessage(u.JSON.raw), &v)
+ return
+}
+
+func (u BetaManagedAgentsSessionEventUnion) AsUserCustomToolResult() (v BetaManagedAgentsUserCustomToolResultEvent) {
+ apijson.UnmarshalRoot(json.RawMessage(u.JSON.raw), &v)
+ return
+}
+
+func (u BetaManagedAgentsSessionEventUnion) AsAgentCustomToolUse() (v BetaManagedAgentsAgentCustomToolUseEvent) {
+ apijson.UnmarshalRoot(json.RawMessage(u.JSON.raw), &v)
+ return
+}
+
+func (u BetaManagedAgentsSessionEventUnion) AsAgentMessage() (v BetaManagedAgentsAgentMessageEvent) {
+ apijson.UnmarshalRoot(json.RawMessage(u.JSON.raw), &v)
+ return
+}
+
+func (u BetaManagedAgentsSessionEventUnion) AsAgentThinking() (v BetaManagedAgentsAgentThinkingEvent) {
+ apijson.UnmarshalRoot(json.RawMessage(u.JSON.raw), &v)
+ return
+}
+
+func (u BetaManagedAgentsSessionEventUnion) AsAgentMCPToolUse() (v BetaManagedAgentsAgentMCPToolUseEvent) {
+ apijson.UnmarshalRoot(json.RawMessage(u.JSON.raw), &v)
+ return
+}
+
+func (u BetaManagedAgentsSessionEventUnion) AsAgentMCPToolResult() (v BetaManagedAgentsAgentMCPToolResultEvent) {
+ apijson.UnmarshalRoot(json.RawMessage(u.JSON.raw), &v)
+ return
+}
+
+func (u BetaManagedAgentsSessionEventUnion) AsAgentToolUse() (v BetaManagedAgentsAgentToolUseEvent) {
+ apijson.UnmarshalRoot(json.RawMessage(u.JSON.raw), &v)
+ return
+}
+
+func (u BetaManagedAgentsSessionEventUnion) AsAgentToolResult() (v BetaManagedAgentsAgentToolResultEvent) {
+ apijson.UnmarshalRoot(json.RawMessage(u.JSON.raw), &v)
+ return
+}
+
+func (u BetaManagedAgentsSessionEventUnion) AsAgentThreadContextCompacted() (v BetaManagedAgentsAgentThreadContextCompactedEvent) {
+ apijson.UnmarshalRoot(json.RawMessage(u.JSON.raw), &v)
+ return
+}
+
+func (u BetaManagedAgentsSessionEventUnion) AsSessionError() (v BetaManagedAgentsSessionErrorEvent) {
+ apijson.UnmarshalRoot(json.RawMessage(u.JSON.raw), &v)
+ return
+}
+
+func (u BetaManagedAgentsSessionEventUnion) AsSessionStatusRescheduled() (v BetaManagedAgentsSessionStatusRescheduledEvent) {
+ apijson.UnmarshalRoot(json.RawMessage(u.JSON.raw), &v)
+ return
+}
+
+func (u BetaManagedAgentsSessionEventUnion) AsSessionStatusRunning() (v BetaManagedAgentsSessionStatusRunningEvent) {
+ apijson.UnmarshalRoot(json.RawMessage(u.JSON.raw), &v)
+ return
+}
+
+func (u BetaManagedAgentsSessionEventUnion) AsSessionStatusIdle() (v BetaManagedAgentsSessionStatusIdleEvent) {
+ apijson.UnmarshalRoot(json.RawMessage(u.JSON.raw), &v)
+ return
+}
+
+func (u BetaManagedAgentsSessionEventUnion) AsSessionStatusTerminated() (v BetaManagedAgentsSessionStatusTerminatedEvent) {
+ apijson.UnmarshalRoot(json.RawMessage(u.JSON.raw), &v)
+ return
+}
+
+func (u BetaManagedAgentsSessionEventUnion) AsSpanModelRequestStart() (v BetaManagedAgentsSpanModelRequestStartEvent) {
+ apijson.UnmarshalRoot(json.RawMessage(u.JSON.raw), &v)
+ return
+}
+
+func (u BetaManagedAgentsSessionEventUnion) AsSpanModelRequestEnd() (v BetaManagedAgentsSpanModelRequestEndEvent) {
+ apijson.UnmarshalRoot(json.RawMessage(u.JSON.raw), &v)
+ return
+}
+
+func (u BetaManagedAgentsSessionEventUnion) AsSessionDeleted() (v BetaManagedAgentsSessionDeletedEvent) {
+ apijson.UnmarshalRoot(json.RawMessage(u.JSON.raw), &v)
+ return
+}
+
+// Returns the unmodified JSON received from the API
+func (u BetaManagedAgentsSessionEventUnion) RawJSON() string { return u.JSON.raw }
+
+func (r *BetaManagedAgentsSessionEventUnion) UnmarshalJSON(data []byte) error {
+ return apijson.UnmarshalRoot(data, r)
+}
+
+// BetaManagedAgentsSessionEventUnionContent is an implicit subunion of
+// [BetaManagedAgentsSessionEventUnion]. BetaManagedAgentsSessionEventUnionContent
+// provides convenient access to the sub-properties of the union.
+//
+// For type safety it is recommended to directly use a variant of the
+// [BetaManagedAgentsSessionEventUnion].
+//
+// If the underlying value is not a json object, one of the following properties
+// will be valid: OfBetaManagedAgentsUserMessageEventContentArray
+// OfBetaManagedAgentsUserCustomToolResultEventContentArray
+// OfBetaManagedAgentsTextBlockArray
+// OfBetaManagedAgentsAgentMCPToolResultEventContentArray
+// OfBetaManagedAgentsAgentToolResultEventContentArray]
+type BetaManagedAgentsSessionEventUnionContent struct {
+ // This field will be present if the value is a
+ // [[]BetaManagedAgentsUserMessageEventContentUnion] instead of an object.
+ OfBetaManagedAgentsUserMessageEventContentArray []BetaManagedAgentsUserMessageEventContentUnion `json:",inline"`
+ // This field will be present if the value is a
+ // [[]BetaManagedAgentsUserCustomToolResultEventContentUnion] instead of an object.
+ OfBetaManagedAgentsUserCustomToolResultEventContentArray []BetaManagedAgentsUserCustomToolResultEventContentUnion `json:",inline"`
+ // This field will be present if the value is a [[]BetaManagedAgentsTextBlock]
+ // instead of an object.
+ OfBetaManagedAgentsTextBlockArray []BetaManagedAgentsTextBlock `json:",inline"`
+ // This field will be present if the value is a
+ // [[]BetaManagedAgentsAgentMCPToolResultEventContentUnion] instead of an object.
+ OfBetaManagedAgentsAgentMCPToolResultEventContentArray []BetaManagedAgentsAgentMCPToolResultEventContentUnion `json:",inline"`
+ // This field will be present if the value is a
+ // [[]BetaManagedAgentsAgentToolResultEventContentUnion] instead of an object.
+ OfBetaManagedAgentsAgentToolResultEventContentArray []BetaManagedAgentsAgentToolResultEventContentUnion `json:",inline"`
+ JSON struct {
+ OfBetaManagedAgentsUserMessageEventContentArray respjson.Field
+ OfBetaManagedAgentsUserCustomToolResultEventContentArray respjson.Field
+ OfBetaManagedAgentsTextBlockArray respjson.Field
+ OfBetaManagedAgentsAgentMCPToolResultEventContentArray respjson.Field
+ OfBetaManagedAgentsAgentToolResultEventContentArray respjson.Field
+ raw string
+ } `json:"-"`
+}
+
+func (r *BetaManagedAgentsSessionEventUnionContent) UnmarshalJSON(data []byte) error {
+ return apijson.UnmarshalRoot(data, r)
+}
+
+// The agent is idle waiting on one or more blocking user-input events (tool
+// confirmation, custom tool result, etc.). Resolving all of them transitions the
+// session back to running.
+type BetaManagedAgentsSessionRequiresAction struct {
+ // The ids of events the agent is blocked on. Resolving fewer than all re-emits
+ // `session.status_idle` with the remainder.
+ EventIDs []string `json:"event_ids" api:"required"`
+ // Any of "requires_action".
+ Type BetaManagedAgentsSessionRequiresActionType `json:"type" api:"required"`
+ // JSON contains metadata for fields, check presence with [respjson.Field.Valid].
+ JSON struct {
+ EventIDs respjson.Field
+ Type respjson.Field
+ ExtraFields map[string]respjson.Field
+ raw string
+ } `json:"-"`
+}
+
+// Returns the unmodified JSON received from the API
+func (r BetaManagedAgentsSessionRequiresAction) RawJSON() string { return r.JSON.raw }
+func (r *BetaManagedAgentsSessionRequiresAction) UnmarshalJSON(data []byte) error {
+ return apijson.UnmarshalRoot(data, r)
+}
+
+type BetaManagedAgentsSessionRequiresActionType string
+
+const (
+ BetaManagedAgentsSessionRequiresActionTypeRequiresAction BetaManagedAgentsSessionRequiresActionType = "requires_action"
+)
+
+// The turn ended because the retry budget was exhausted (`max_iterations` hit or
+// an error escalated to `retry_status: 'exhausted'`).
+type BetaManagedAgentsSessionRetriesExhausted struct {
+ // Any of "retries_exhausted".
+ Type BetaManagedAgentsSessionRetriesExhaustedType `json:"type" api:"required"`
+ // JSON contains metadata for fields, check presence with [respjson.Field.Valid].
+ JSON struct {
+ Type respjson.Field
+ ExtraFields map[string]respjson.Field
+ raw string
+ } `json:"-"`
+}
+
+// Returns the unmodified JSON received from the API
+func (r BetaManagedAgentsSessionRetriesExhausted) RawJSON() string { return r.JSON.raw }
+func (r *BetaManagedAgentsSessionRetriesExhausted) UnmarshalJSON(data []byte) error {
+ return apijson.UnmarshalRoot(data, r)
+}
+
+type BetaManagedAgentsSessionRetriesExhaustedType string
+
+const (
+ BetaManagedAgentsSessionRetriesExhaustedTypeRetriesExhausted BetaManagedAgentsSessionRetriesExhaustedType = "retries_exhausted"
+)
+
+// Indicates the agent has paused and is awaiting user input.
+type BetaManagedAgentsSessionStatusIdleEvent struct {
+ // Unique identifier for this event.
+ ID string `json:"id" api:"required"`
+ // A timestamp in RFC 3339 format
+ ProcessedAt time.Time `json:"processed_at" api:"required" format:"date-time"`
+ // The agent completed its turn naturally and is ready for the next user message.
+ StopReason BetaManagedAgentsSessionStatusIdleEventStopReasonUnion `json:"stop_reason" api:"required"`
+ // Any of "session.status_idle".
+ Type BetaManagedAgentsSessionStatusIdleEventType `json:"type" api:"required"`
+ // JSON contains metadata for fields, check presence with [respjson.Field.Valid].
+ JSON struct {
+ ID respjson.Field
+ ProcessedAt respjson.Field
+ StopReason respjson.Field
+ Type respjson.Field
+ ExtraFields map[string]respjson.Field
+ raw string
+ } `json:"-"`
+}
+
+// Returns the unmodified JSON received from the API
+func (r BetaManagedAgentsSessionStatusIdleEvent) RawJSON() string { return r.JSON.raw }
+func (r *BetaManagedAgentsSessionStatusIdleEvent) UnmarshalJSON(data []byte) error {
+ return apijson.UnmarshalRoot(data, r)
+}
+
+// BetaManagedAgentsSessionStatusIdleEventStopReasonUnion contains all possible
+// properties and values from [BetaManagedAgentsSessionEndTurn],
+// [BetaManagedAgentsSessionRequiresAction],
+// [BetaManagedAgentsSessionRetriesExhausted].
+//
+// Use the [BetaManagedAgentsSessionStatusIdleEventStopReasonUnion.AsAny] method to
+// switch on the variant.
+//
+// Use the methods beginning with 'As' to cast the union to one of its variants.
+type BetaManagedAgentsSessionStatusIdleEventStopReasonUnion struct {
+ // Any of "end_turn", "requires_action", "retries_exhausted".
+ Type string `json:"type"`
+ // This field is from variant [BetaManagedAgentsSessionRequiresAction].
+ EventIDs []string `json:"event_ids"`
+ JSON struct {
+ Type respjson.Field
+ EventIDs respjson.Field
+ raw string
+ } `json:"-"`
+}
+
+// anyBetaManagedAgentsSessionStatusIdleEventStopReason is implemented by each
+// variant of [BetaManagedAgentsSessionStatusIdleEventStopReasonUnion] to add type
+// safety for the return type of
+// [BetaManagedAgentsSessionStatusIdleEventStopReasonUnion.AsAny]
+type anyBetaManagedAgentsSessionStatusIdleEventStopReason interface {
+ implBetaManagedAgentsSessionStatusIdleEventStopReasonUnion()
+}
+
+func (BetaManagedAgentsSessionEndTurn) implBetaManagedAgentsSessionStatusIdleEventStopReasonUnion() {}
+func (BetaManagedAgentsSessionRequiresAction) implBetaManagedAgentsSessionStatusIdleEventStopReasonUnion() {
+}
+func (BetaManagedAgentsSessionRetriesExhausted) implBetaManagedAgentsSessionStatusIdleEventStopReasonUnion() {
+}
+
+// Use the following switch statement to find the correct variant
+//
+// switch variant := BetaManagedAgentsSessionStatusIdleEventStopReasonUnion.AsAny().(type) {
+// case anthropic.BetaManagedAgentsSessionEndTurn:
+// case anthropic.BetaManagedAgentsSessionRequiresAction:
+// case anthropic.BetaManagedAgentsSessionRetriesExhausted:
+// default:
+// fmt.Errorf("no variant present")
+// }
+func (u BetaManagedAgentsSessionStatusIdleEventStopReasonUnion) AsAny() anyBetaManagedAgentsSessionStatusIdleEventStopReason {
+ switch u.Type {
+ case "end_turn":
+ return u.AsEndTurn()
+ case "requires_action":
+ return u.AsRequiresAction()
+ case "retries_exhausted":
+ return u.AsRetriesExhausted()
+ }
+ return nil
+}
+
+func (u BetaManagedAgentsSessionStatusIdleEventStopReasonUnion) AsEndTurn() (v BetaManagedAgentsSessionEndTurn) {
+ apijson.UnmarshalRoot(json.RawMessage(u.JSON.raw), &v)
+ return
+}
+
+func (u BetaManagedAgentsSessionStatusIdleEventStopReasonUnion) AsRequiresAction() (v BetaManagedAgentsSessionRequiresAction) {
+ apijson.UnmarshalRoot(json.RawMessage(u.JSON.raw), &v)
+ return
+}
+
+func (u BetaManagedAgentsSessionStatusIdleEventStopReasonUnion) AsRetriesExhausted() (v BetaManagedAgentsSessionRetriesExhausted) {
+ apijson.UnmarshalRoot(json.RawMessage(u.JSON.raw), &v)
+ return
+}
+
+// Returns the unmodified JSON received from the API
+func (u BetaManagedAgentsSessionStatusIdleEventStopReasonUnion) RawJSON() string { return u.JSON.raw }
+
+func (r *BetaManagedAgentsSessionStatusIdleEventStopReasonUnion) UnmarshalJSON(data []byte) error {
+ return apijson.UnmarshalRoot(data, r)
+}
+
+type BetaManagedAgentsSessionStatusIdleEventType string
+
+const (
+ BetaManagedAgentsSessionStatusIdleEventTypeSessionStatusIdle BetaManagedAgentsSessionStatusIdleEventType = "session.status_idle"
+)
+
+// Indicates the session is recovering from an error state and is rescheduled for
+// execution.
+type BetaManagedAgentsSessionStatusRescheduledEvent struct {
+ // Unique identifier for this event.
+ ID string `json:"id" api:"required"`
+ // A timestamp in RFC 3339 format
+ ProcessedAt time.Time `json:"processed_at" api:"required" format:"date-time"`
+ // Any of "session.status_rescheduled".
+ Type BetaManagedAgentsSessionStatusRescheduledEventType `json:"type" api:"required"`
+ // JSON contains metadata for fields, check presence with [respjson.Field.Valid].
+ JSON struct {
+ ID respjson.Field
+ ProcessedAt respjson.Field
+ Type respjson.Field
+ ExtraFields map[string]respjson.Field
+ raw string
+ } `json:"-"`
+}
+
+// Returns the unmodified JSON received from the API
+func (r BetaManagedAgentsSessionStatusRescheduledEvent) RawJSON() string { return r.JSON.raw }
+func (r *BetaManagedAgentsSessionStatusRescheduledEvent) UnmarshalJSON(data []byte) error {
+ return apijson.UnmarshalRoot(data, r)
+}
+
+type BetaManagedAgentsSessionStatusRescheduledEventType string
+
+const (
+ BetaManagedAgentsSessionStatusRescheduledEventTypeSessionStatusRescheduled BetaManagedAgentsSessionStatusRescheduledEventType = "session.status_rescheduled"
+)
+
+// Indicates the session is actively running and the agent is working.
+type BetaManagedAgentsSessionStatusRunningEvent struct {
+ // Unique identifier for this event.
+ ID string `json:"id" api:"required"`
+ // A timestamp in RFC 3339 format
+ ProcessedAt time.Time `json:"processed_at" api:"required" format:"date-time"`
+ // Any of "session.status_running".
+ Type BetaManagedAgentsSessionStatusRunningEventType `json:"type" api:"required"`
+ // JSON contains metadata for fields, check presence with [respjson.Field.Valid].
+ JSON struct {
+ ID respjson.Field
+ ProcessedAt respjson.Field
+ Type respjson.Field
+ ExtraFields map[string]respjson.Field
+ raw string
+ } `json:"-"`
+}
+
+// Returns the unmodified JSON received from the API
+func (r BetaManagedAgentsSessionStatusRunningEvent) RawJSON() string { return r.JSON.raw }
+func (r *BetaManagedAgentsSessionStatusRunningEvent) UnmarshalJSON(data []byte) error {
+ return apijson.UnmarshalRoot(data, r)
+}
+
+type BetaManagedAgentsSessionStatusRunningEventType string
+
+const (
+ BetaManagedAgentsSessionStatusRunningEventTypeSessionStatusRunning BetaManagedAgentsSessionStatusRunningEventType = "session.status_running"
+)
+
+// Indicates the session has terminated, either due to an error or completion.
+type BetaManagedAgentsSessionStatusTerminatedEvent struct {
+ // Unique identifier for this event.
+ ID string `json:"id" api:"required"`
+ // A timestamp in RFC 3339 format
+ ProcessedAt time.Time `json:"processed_at" api:"required" format:"date-time"`
+ // Any of "session.status_terminated".
+ Type BetaManagedAgentsSessionStatusTerminatedEventType `json:"type" api:"required"`
+ // JSON contains metadata for fields, check presence with [respjson.Field.Valid].
+ JSON struct {
+ ID respjson.Field
+ ProcessedAt respjson.Field
+ Type respjson.Field
+ ExtraFields map[string]respjson.Field
+ raw string
+ } `json:"-"`
+}
+
+// Returns the unmodified JSON received from the API
+func (r BetaManagedAgentsSessionStatusTerminatedEvent) RawJSON() string { return r.JSON.raw }
+func (r *BetaManagedAgentsSessionStatusTerminatedEvent) UnmarshalJSON(data []byte) error {
+ return apijson.UnmarshalRoot(data, r)
+}
+
+type BetaManagedAgentsSessionStatusTerminatedEventType string
+
+const (
+ BetaManagedAgentsSessionStatusTerminatedEventTypeSessionStatusTerminated BetaManagedAgentsSessionStatusTerminatedEventType = "session.status_terminated"
+)
+
+// Emitted when a model request completes.
+type BetaManagedAgentsSpanModelRequestEndEvent struct {
+ // Unique identifier for this event.
+ ID string `json:"id" api:"required"`
+ // Whether the model request resulted in an error.
+ IsError bool `json:"is_error" api:"required"`
+ // The id of the corresponding `span.model_request_start` event.
+ ModelRequestStartID string `json:"model_request_start_id" api:"required"`
+ // Token usage for a single model request.
+ ModelUsage BetaManagedAgentsSpanModelUsage `json:"model_usage" api:"required"`
+ // A timestamp in RFC 3339 format
+ ProcessedAt time.Time `json:"processed_at" api:"required" format:"date-time"`
+ // Any of "span.model_request_end".
+ Type BetaManagedAgentsSpanModelRequestEndEventType `json:"type" api:"required"`
+ // JSON contains metadata for fields, check presence with [respjson.Field.Valid].
+ JSON struct {
+ ID respjson.Field
+ IsError respjson.Field
+ ModelRequestStartID respjson.Field
+ ModelUsage respjson.Field
+ ProcessedAt respjson.Field
+ Type respjson.Field
+ ExtraFields map[string]respjson.Field
+ raw string
+ } `json:"-"`
+}
+
+// Returns the unmodified JSON received from the API
+func (r BetaManagedAgentsSpanModelRequestEndEvent) RawJSON() string { return r.JSON.raw }
+func (r *BetaManagedAgentsSpanModelRequestEndEvent) UnmarshalJSON(data []byte) error {
+ return apijson.UnmarshalRoot(data, r)
+}
+
+type BetaManagedAgentsSpanModelRequestEndEventType string
+
+const (
+ BetaManagedAgentsSpanModelRequestEndEventTypeSpanModelRequestEnd BetaManagedAgentsSpanModelRequestEndEventType = "span.model_request_end"
+)
+
+// Emitted when a model request is initiated by the agent.
+type BetaManagedAgentsSpanModelRequestStartEvent struct {
+ // Unique identifier for this event.
+ ID string `json:"id" api:"required"`
+ // A timestamp in RFC 3339 format
+ ProcessedAt time.Time `json:"processed_at" api:"required" format:"date-time"`
+ // Any of "span.model_request_start".
+ Type BetaManagedAgentsSpanModelRequestStartEventType `json:"type" api:"required"`
+ // JSON contains metadata for fields, check presence with [respjson.Field.Valid].
+ JSON struct {
+ ID respjson.Field
+ ProcessedAt respjson.Field
+ Type respjson.Field
+ ExtraFields map[string]respjson.Field
+ raw string
+ } `json:"-"`
+}
+
+// Returns the unmodified JSON received from the API
+func (r BetaManagedAgentsSpanModelRequestStartEvent) RawJSON() string { return r.JSON.raw }
+func (r *BetaManagedAgentsSpanModelRequestStartEvent) UnmarshalJSON(data []byte) error {
+ return apijson.UnmarshalRoot(data, r)
+}
+
+type BetaManagedAgentsSpanModelRequestStartEventType string
+
+const (
+ BetaManagedAgentsSpanModelRequestStartEventTypeSpanModelRequestStart BetaManagedAgentsSpanModelRequestStartEventType = "span.model_request_start"
+)
+
+// Token usage for a single model request.
+type BetaManagedAgentsSpanModelUsage struct {
+ // Tokens used to create prompt cache in this request.
+ CacheCreationInputTokens int64 `json:"cache_creation_input_tokens" api:"required"`
+ // Tokens read from prompt cache in this request.
+ CacheReadInputTokens int64 `json:"cache_read_input_tokens" api:"required"`
+ // Input tokens consumed by this request.
+ InputTokens int64 `json:"input_tokens" api:"required"`
+ // Output tokens generated by this request.
+ OutputTokens int64 `json:"output_tokens" api:"required"`
+ // Inference speed mode. `fast` provides significantly faster output token
+ // generation at premium pricing. Not all models support `fast`; invalid
+ // combinations are rejected at create time.
+ //
+ // Any of "standard", "fast".
+ Speed BetaManagedAgentsSpanModelUsageSpeed `json:"speed" api:"nullable"`
+ // JSON contains metadata for fields, check presence with [respjson.Field.Valid].
+ JSON struct {
+ CacheCreationInputTokens respjson.Field
+ CacheReadInputTokens respjson.Field
+ InputTokens respjson.Field
+ OutputTokens respjson.Field
+ Speed respjson.Field
+ ExtraFields map[string]respjson.Field
+ raw string
+ } `json:"-"`
+}
+
+// Returns the unmodified JSON received from the API
+func (r BetaManagedAgentsSpanModelUsage) RawJSON() string { return r.JSON.raw }
+func (r *BetaManagedAgentsSpanModelUsage) UnmarshalJSON(data []byte) error {
+ return apijson.UnmarshalRoot(data, r)
+}
+
+// Inference speed mode. `fast` provides significantly faster output token
+// generation at premium pricing. Not all models support `fast`; invalid
+// combinations are rejected at create time.
+type BetaManagedAgentsSpanModelUsageSpeed string
+
+const (
+ BetaManagedAgentsSpanModelUsageSpeedStandard BetaManagedAgentsSpanModelUsageSpeed = "standard"
+ BetaManagedAgentsSpanModelUsageSpeedFast BetaManagedAgentsSpanModelUsageSpeed = "fast"
+)
+
+// BetaManagedAgentsStreamSessionEventsUnion contains all possible properties and
+// values from [BetaManagedAgentsUserMessageEvent],
+// [BetaManagedAgentsUserInterruptEvent],
+// [BetaManagedAgentsUserToolConfirmationEvent],
+// [BetaManagedAgentsUserCustomToolResultEvent],
+// [BetaManagedAgentsAgentCustomToolUseEvent],
+// [BetaManagedAgentsAgentMessageEvent], [BetaManagedAgentsAgentThinkingEvent],
+// [BetaManagedAgentsAgentMCPToolUseEvent],
+// [BetaManagedAgentsAgentMCPToolResultEvent],
+// [BetaManagedAgentsAgentToolUseEvent], [BetaManagedAgentsAgentToolResultEvent],
+// [BetaManagedAgentsAgentThreadContextCompactedEvent],
+// [BetaManagedAgentsSessionErrorEvent],
+// [BetaManagedAgentsSessionStatusRescheduledEvent],
+// [BetaManagedAgentsSessionStatusRunningEvent],
+// [BetaManagedAgentsSessionStatusIdleEvent],
+// [BetaManagedAgentsSessionStatusTerminatedEvent],
+// [BetaManagedAgentsSpanModelRequestStartEvent],
+// [BetaManagedAgentsSpanModelRequestEndEvent],
+// [BetaManagedAgentsSessionDeletedEvent].
+//
+// Use the [BetaManagedAgentsStreamSessionEventsUnion.AsAny] method to switch on
+// the variant.
+//
+// Use the methods beginning with 'As' to cast the union to one of its variants.
+type BetaManagedAgentsStreamSessionEventsUnion struct {
+ ID string `json:"id"`
+ // This field is a union of [[]BetaManagedAgentsUserMessageEventContentUnion],
+ // [[]BetaManagedAgentsUserCustomToolResultEventContentUnion],
+ // [[]BetaManagedAgentsTextBlock],
+ // [[]BetaManagedAgentsAgentMCPToolResultEventContentUnion],
+ // [[]BetaManagedAgentsAgentToolResultEventContentUnion]
+ Content BetaManagedAgentsStreamSessionEventsUnionContent `json:"content"`
+ // Any of "user.message", "user.interrupt", "user.tool_confirmation",
+ // "user.custom_tool_result", "agent.custom_tool_use", "agent.message",
+ // "agent.thinking", "agent.mcp_tool_use", "agent.mcp_tool_result",
+ // "agent.tool_use", "agent.tool_result", "agent.thread_context_compacted",
+ // "session.error", "session.status_rescheduled", "session.status_running",
+ // "session.status_idle", "session.status_terminated", "span.model_request_start",
+ // "span.model_request_end", "session.deleted".
+ Type string `json:"type"`
+ ProcessedAt time.Time `json:"processed_at"`
+ // This field is from variant [BetaManagedAgentsUserToolConfirmationEvent].
+ Result BetaManagedAgentsUserToolConfirmationEventResult `json:"result"`
+ ToolUseID string `json:"tool_use_id"`
+ // This field is from variant [BetaManagedAgentsUserToolConfirmationEvent].
+ DenyMessage string `json:"deny_message"`
+ // This field is from variant [BetaManagedAgentsUserCustomToolResultEvent].
+ CustomToolUseID string `json:"custom_tool_use_id"`
+ IsError bool `json:"is_error"`
+ Input any `json:"input"`
+ Name string `json:"name"`
+ // This field is from variant [BetaManagedAgentsAgentMCPToolUseEvent].
+ MCPServerName string `json:"mcp_server_name"`
+ EvaluatedPermission string `json:"evaluated_permission"`
+ // This field is from variant [BetaManagedAgentsAgentMCPToolResultEvent].
+ MCPToolUseID string `json:"mcp_tool_use_id"`
+ // This field is from variant [BetaManagedAgentsSessionErrorEvent].
+ Error BetaManagedAgentsSessionErrorEventErrorUnion `json:"error"`
+ // This field is from variant [BetaManagedAgentsSessionStatusIdleEvent].
+ StopReason BetaManagedAgentsSessionStatusIdleEventStopReasonUnion `json:"stop_reason"`
+ // This field is from variant [BetaManagedAgentsSpanModelRequestEndEvent].
+ ModelRequestStartID string `json:"model_request_start_id"`
+ // This field is from variant [BetaManagedAgentsSpanModelRequestEndEvent].
+ ModelUsage BetaManagedAgentsSpanModelUsage `json:"model_usage"`
+ JSON struct {
+ ID respjson.Field
+ Content respjson.Field
+ Type respjson.Field
+ ProcessedAt respjson.Field
+ Result respjson.Field
+ ToolUseID respjson.Field
+ DenyMessage respjson.Field
+ CustomToolUseID respjson.Field
+ IsError respjson.Field
+ Input respjson.Field
+ Name respjson.Field
+ MCPServerName respjson.Field
+ EvaluatedPermission respjson.Field
+ MCPToolUseID respjson.Field
+ Error respjson.Field
+ StopReason respjson.Field
+ ModelRequestStartID respjson.Field
+ ModelUsage respjson.Field
+ raw string
+ } `json:"-"`
+}
+
+// anyBetaManagedAgentsStreamSessionEvents is implemented by each variant of
+// [BetaManagedAgentsStreamSessionEventsUnion] to add type safety for the return
+// type of [BetaManagedAgentsStreamSessionEventsUnion.AsAny]
+type anyBetaManagedAgentsStreamSessionEvents interface {
+ implBetaManagedAgentsStreamSessionEventsUnion()
+}
+
+func (BetaManagedAgentsUserMessageEvent) implBetaManagedAgentsStreamSessionEventsUnion() {}
+func (BetaManagedAgentsUserInterruptEvent) implBetaManagedAgentsStreamSessionEventsUnion() {}
+func (BetaManagedAgentsUserToolConfirmationEvent) implBetaManagedAgentsStreamSessionEventsUnion() {}
+func (BetaManagedAgentsUserCustomToolResultEvent) implBetaManagedAgentsStreamSessionEventsUnion() {}
+func (BetaManagedAgentsAgentCustomToolUseEvent) implBetaManagedAgentsStreamSessionEventsUnion() {}
+func (BetaManagedAgentsAgentMessageEvent) implBetaManagedAgentsStreamSessionEventsUnion() {}
+func (BetaManagedAgentsAgentThinkingEvent) implBetaManagedAgentsStreamSessionEventsUnion() {}
+func (BetaManagedAgentsAgentMCPToolUseEvent) implBetaManagedAgentsStreamSessionEventsUnion() {}
+func (BetaManagedAgentsAgentMCPToolResultEvent) implBetaManagedAgentsStreamSessionEventsUnion() {}
+func (BetaManagedAgentsAgentToolUseEvent) implBetaManagedAgentsStreamSessionEventsUnion() {}
+func (BetaManagedAgentsAgentToolResultEvent) implBetaManagedAgentsStreamSessionEventsUnion() {}
+func (BetaManagedAgentsAgentThreadContextCompactedEvent) implBetaManagedAgentsStreamSessionEventsUnion() {
+}
+func (BetaManagedAgentsSessionErrorEvent) implBetaManagedAgentsStreamSessionEventsUnion() {}
+func (BetaManagedAgentsSessionStatusRescheduledEvent) implBetaManagedAgentsStreamSessionEventsUnion() {
+}
+func (BetaManagedAgentsSessionStatusRunningEvent) implBetaManagedAgentsStreamSessionEventsUnion() {}
+func (BetaManagedAgentsSessionStatusIdleEvent) implBetaManagedAgentsStreamSessionEventsUnion() {}
+func (BetaManagedAgentsSessionStatusTerminatedEvent) implBetaManagedAgentsStreamSessionEventsUnion() {
+}
+func (BetaManagedAgentsSpanModelRequestStartEvent) implBetaManagedAgentsStreamSessionEventsUnion() {}
+func (BetaManagedAgentsSpanModelRequestEndEvent) implBetaManagedAgentsStreamSessionEventsUnion() {}
+func (BetaManagedAgentsSessionDeletedEvent) implBetaManagedAgentsStreamSessionEventsUnion() {}
+
+// Use the following switch statement to find the correct variant
+//
+// switch variant := BetaManagedAgentsStreamSessionEventsUnion.AsAny().(type) {
+// case anthropic.BetaManagedAgentsUserMessageEvent:
+// case anthropic.BetaManagedAgentsUserInterruptEvent:
+// case anthropic.BetaManagedAgentsUserToolConfirmationEvent:
+// case anthropic.BetaManagedAgentsUserCustomToolResultEvent:
+// case anthropic.BetaManagedAgentsAgentCustomToolUseEvent:
+// case anthropic.BetaManagedAgentsAgentMessageEvent:
+// case anthropic.BetaManagedAgentsAgentThinkingEvent:
+// case anthropic.BetaManagedAgentsAgentMCPToolUseEvent:
+// case anthropic.BetaManagedAgentsAgentMCPToolResultEvent:
+// case anthropic.BetaManagedAgentsAgentToolUseEvent:
+// case anthropic.BetaManagedAgentsAgentToolResultEvent:
+// case anthropic.BetaManagedAgentsAgentThreadContextCompactedEvent:
+// case anthropic.BetaManagedAgentsSessionErrorEvent:
+// case anthropic.BetaManagedAgentsSessionStatusRescheduledEvent:
+// case anthropic.BetaManagedAgentsSessionStatusRunningEvent:
+// case anthropic.BetaManagedAgentsSessionStatusIdleEvent:
+// case anthropic.BetaManagedAgentsSessionStatusTerminatedEvent:
+// case anthropic.BetaManagedAgentsSpanModelRequestStartEvent:
+// case anthropic.BetaManagedAgentsSpanModelRequestEndEvent:
+// case anthropic.BetaManagedAgentsSessionDeletedEvent:
+// default:
+// fmt.Errorf("no variant present")
+// }
+func (u BetaManagedAgentsStreamSessionEventsUnion) AsAny() anyBetaManagedAgentsStreamSessionEvents {
+ switch u.Type {
+ case "user.message":
+ return u.AsUserMessage()
+ case "user.interrupt":
+ return u.AsUserInterrupt()
+ case "user.tool_confirmation":
+ return u.AsUserToolConfirmation()
+ case "user.custom_tool_result":
+ return u.AsUserCustomToolResult()
+ case "agent.custom_tool_use":
+ return u.AsAgentCustomToolUse()
+ case "agent.message":
+ return u.AsAgentMessage()
+ case "agent.thinking":
+ return u.AsAgentThinking()
+ case "agent.mcp_tool_use":
+ return u.AsAgentMCPToolUse()
+ case "agent.mcp_tool_result":
+ return u.AsAgentMCPToolResult()
+ case "agent.tool_use":
+ return u.AsAgentToolUse()
+ case "agent.tool_result":
+ return u.AsAgentToolResult()
+ case "agent.thread_context_compacted":
+ return u.AsAgentThreadContextCompacted()
+ case "session.error":
+ return u.AsSessionError()
+ case "session.status_rescheduled":
+ return u.AsSessionStatusRescheduled()
+ case "session.status_running":
+ return u.AsSessionStatusRunning()
+ case "session.status_idle":
+ return u.AsSessionStatusIdle()
+ case "session.status_terminated":
+ return u.AsSessionStatusTerminated()
+ case "span.model_request_start":
+ return u.AsSpanModelRequestStart()
+ case "span.model_request_end":
+ return u.AsSpanModelRequestEnd()
+ case "session.deleted":
+ return u.AsSessionDeleted()
+ }
+ return nil
+}
+
+func (u BetaManagedAgentsStreamSessionEventsUnion) AsUserMessage() (v BetaManagedAgentsUserMessageEvent) {
+ apijson.UnmarshalRoot(json.RawMessage(u.JSON.raw), &v)
+ return
+}
+
+func (u BetaManagedAgentsStreamSessionEventsUnion) AsUserInterrupt() (v BetaManagedAgentsUserInterruptEvent) {
+ apijson.UnmarshalRoot(json.RawMessage(u.JSON.raw), &v)
+ return
+}
+
+func (u BetaManagedAgentsStreamSessionEventsUnion) AsUserToolConfirmation() (v BetaManagedAgentsUserToolConfirmationEvent) {
+ apijson.UnmarshalRoot(json.RawMessage(u.JSON.raw), &v)
+ return
+}
+
+func (u BetaManagedAgentsStreamSessionEventsUnion) AsUserCustomToolResult() (v BetaManagedAgentsUserCustomToolResultEvent) {
+ apijson.UnmarshalRoot(json.RawMessage(u.JSON.raw), &v)
+ return
+}
+
+func (u BetaManagedAgentsStreamSessionEventsUnion) AsAgentCustomToolUse() (v BetaManagedAgentsAgentCustomToolUseEvent) {
+ apijson.UnmarshalRoot(json.RawMessage(u.JSON.raw), &v)
+ return
+}
+
+func (u BetaManagedAgentsStreamSessionEventsUnion) AsAgentMessage() (v BetaManagedAgentsAgentMessageEvent) {
+ apijson.UnmarshalRoot(json.RawMessage(u.JSON.raw), &v)
+ return
+}
+
+func (u BetaManagedAgentsStreamSessionEventsUnion) AsAgentThinking() (v BetaManagedAgentsAgentThinkingEvent) {
+ apijson.UnmarshalRoot(json.RawMessage(u.JSON.raw), &v)
+ return
+}
+
+func (u BetaManagedAgentsStreamSessionEventsUnion) AsAgentMCPToolUse() (v BetaManagedAgentsAgentMCPToolUseEvent) {
+ apijson.UnmarshalRoot(json.RawMessage(u.JSON.raw), &v)
+ return
+}
+
+func (u BetaManagedAgentsStreamSessionEventsUnion) AsAgentMCPToolResult() (v BetaManagedAgentsAgentMCPToolResultEvent) {
+ apijson.UnmarshalRoot(json.RawMessage(u.JSON.raw), &v)
+ return
+}
+
+func (u BetaManagedAgentsStreamSessionEventsUnion) AsAgentToolUse() (v BetaManagedAgentsAgentToolUseEvent) {
+ apijson.UnmarshalRoot(json.RawMessage(u.JSON.raw), &v)
+ return
+}
+
+func (u BetaManagedAgentsStreamSessionEventsUnion) AsAgentToolResult() (v BetaManagedAgentsAgentToolResultEvent) {
+ apijson.UnmarshalRoot(json.RawMessage(u.JSON.raw), &v)
+ return
+}
+
+func (u BetaManagedAgentsStreamSessionEventsUnion) AsAgentThreadContextCompacted() (v BetaManagedAgentsAgentThreadContextCompactedEvent) {
+ apijson.UnmarshalRoot(json.RawMessage(u.JSON.raw), &v)
+ return
+}
+
+func (u BetaManagedAgentsStreamSessionEventsUnion) AsSessionError() (v BetaManagedAgentsSessionErrorEvent) {
+ apijson.UnmarshalRoot(json.RawMessage(u.JSON.raw), &v)
+ return
+}
+
+func (u BetaManagedAgentsStreamSessionEventsUnion) AsSessionStatusRescheduled() (v BetaManagedAgentsSessionStatusRescheduledEvent) {
+ apijson.UnmarshalRoot(json.RawMessage(u.JSON.raw), &v)
+ return
+}
+
+func (u BetaManagedAgentsStreamSessionEventsUnion) AsSessionStatusRunning() (v BetaManagedAgentsSessionStatusRunningEvent) {
+ apijson.UnmarshalRoot(json.RawMessage(u.JSON.raw), &v)
+ return
+}
+
+func (u BetaManagedAgentsStreamSessionEventsUnion) AsSessionStatusIdle() (v BetaManagedAgentsSessionStatusIdleEvent) {
+ apijson.UnmarshalRoot(json.RawMessage(u.JSON.raw), &v)
+ return
+}
+
+func (u BetaManagedAgentsStreamSessionEventsUnion) AsSessionStatusTerminated() (v BetaManagedAgentsSessionStatusTerminatedEvent) {
+ apijson.UnmarshalRoot(json.RawMessage(u.JSON.raw), &v)
+ return
+}
+
+func (u BetaManagedAgentsStreamSessionEventsUnion) AsSpanModelRequestStart() (v BetaManagedAgentsSpanModelRequestStartEvent) {
+ apijson.UnmarshalRoot(json.RawMessage(u.JSON.raw), &v)
+ return
+}
+
+func (u BetaManagedAgentsStreamSessionEventsUnion) AsSpanModelRequestEnd() (v BetaManagedAgentsSpanModelRequestEndEvent) {
+ apijson.UnmarshalRoot(json.RawMessage(u.JSON.raw), &v)
+ return
+}
+
+func (u BetaManagedAgentsStreamSessionEventsUnion) AsSessionDeleted() (v BetaManagedAgentsSessionDeletedEvent) {
+ apijson.UnmarshalRoot(json.RawMessage(u.JSON.raw), &v)
+ return
+}
+
+// Returns the unmodified JSON received from the API
+func (u BetaManagedAgentsStreamSessionEventsUnion) RawJSON() string { return u.JSON.raw }
+
+func (r *BetaManagedAgentsStreamSessionEventsUnion) UnmarshalJSON(data []byte) error {
+ return apijson.UnmarshalRoot(data, r)
+}
+
+// BetaManagedAgentsStreamSessionEventsUnionContent is an implicit subunion of
+// [BetaManagedAgentsStreamSessionEventsUnion].
+// BetaManagedAgentsStreamSessionEventsUnionContent provides convenient access to
+// the sub-properties of the union.
+//
+// For type safety it is recommended to directly use a variant of the
+// [BetaManagedAgentsStreamSessionEventsUnion].
+//
+// If the underlying value is not a json object, one of the following properties
+// will be valid: OfBetaManagedAgentsUserMessageEventContentArray
+// OfBetaManagedAgentsUserCustomToolResultEventContentArray
+// OfBetaManagedAgentsTextBlockArray
+// OfBetaManagedAgentsAgentMCPToolResultEventContentArray
+// OfBetaManagedAgentsAgentToolResultEventContentArray]
+type BetaManagedAgentsStreamSessionEventsUnionContent struct {
+ // This field will be present if the value is a
+ // [[]BetaManagedAgentsUserMessageEventContentUnion] instead of an object.
+ OfBetaManagedAgentsUserMessageEventContentArray []BetaManagedAgentsUserMessageEventContentUnion `json:",inline"`
+ // This field will be present if the value is a
+ // [[]BetaManagedAgentsUserCustomToolResultEventContentUnion] instead of an object.
+ OfBetaManagedAgentsUserCustomToolResultEventContentArray []BetaManagedAgentsUserCustomToolResultEventContentUnion `json:",inline"`
+ // This field will be present if the value is a [[]BetaManagedAgentsTextBlock]
+ // instead of an object.
+ OfBetaManagedAgentsTextBlockArray []BetaManagedAgentsTextBlock `json:",inline"`
+ // This field will be present if the value is a
+ // [[]BetaManagedAgentsAgentMCPToolResultEventContentUnion] instead of an object.
+ OfBetaManagedAgentsAgentMCPToolResultEventContentArray []BetaManagedAgentsAgentMCPToolResultEventContentUnion `json:",inline"`
+ // This field will be present if the value is a
+ // [[]BetaManagedAgentsAgentToolResultEventContentUnion] instead of an object.
+ OfBetaManagedAgentsAgentToolResultEventContentArray []BetaManagedAgentsAgentToolResultEventContentUnion `json:",inline"`
+ JSON struct {
+ OfBetaManagedAgentsUserMessageEventContentArray respjson.Field
+ OfBetaManagedAgentsUserCustomToolResultEventContentArray respjson.Field
+ OfBetaManagedAgentsTextBlockArray respjson.Field
+ OfBetaManagedAgentsAgentMCPToolResultEventContentArray respjson.Field
+ OfBetaManagedAgentsAgentToolResultEventContentArray respjson.Field
+ raw string
+ } `json:"-"`
+}
+
+func (r *BetaManagedAgentsStreamSessionEventsUnionContent) UnmarshalJSON(data []byte) error {
+ return apijson.UnmarshalRoot(data, r)
+}
+
+// Regular text content.
+type BetaManagedAgentsTextBlock struct {
+ // The text content.
+ Text string `json:"text" api:"required"`
+ // Any of "text".
+ Type BetaManagedAgentsTextBlockType `json:"type" api:"required"`
+ // JSON contains metadata for fields, check presence with [respjson.Field.Valid].
+ JSON struct {
+ Text respjson.Field
+ Type respjson.Field
+ ExtraFields map[string]respjson.Field
+ raw string
+ } `json:"-"`
+}
+
+// Returns the unmodified JSON received from the API
+func (r BetaManagedAgentsTextBlock) RawJSON() string { return r.JSON.raw }
+func (r *BetaManagedAgentsTextBlock) UnmarshalJSON(data []byte) error {
+ return apijson.UnmarshalRoot(data, r)
+}
+
+// ToParam converts this BetaManagedAgentsTextBlock to a
+// BetaManagedAgentsTextBlockParam.
+//
+// Warning: the fields of the param type will not be present. ToParam should only
+// be used at the last possible moment before sending a request. Test for this with
+// BetaManagedAgentsTextBlockParam.Overrides()
+func (r BetaManagedAgentsTextBlock) ToParam() BetaManagedAgentsTextBlockParam {
+ return param.Override[BetaManagedAgentsTextBlockParam](json.RawMessage(r.RawJSON()))
+}
+
+type BetaManagedAgentsTextBlockType string
+
+const (
+ BetaManagedAgentsTextBlockTypeText BetaManagedAgentsTextBlockType = "text"
+)
+
+// Regular text content.
+//
+// The properties Text, Type are required.
+type BetaManagedAgentsTextBlockParam struct {
+ // The text content.
+ Text string `json:"text" api:"required"`
+ // Any of "text".
+ Type BetaManagedAgentsTextBlockType `json:"type,omitzero" api:"required"`
+ paramObj
+}
+
+func (r BetaManagedAgentsTextBlockParam) MarshalJSON() (data []byte, err error) {
+ type shadow BetaManagedAgentsTextBlockParam
+ return param.MarshalObject(r, (*shadow)(&r))
+}
+func (r *BetaManagedAgentsTextBlockParam) UnmarshalJSON(data []byte) error {
+ return apijson.UnmarshalRoot(data, r)
+}
+
+// An unknown or unexpected error occurred during session execution. A fallback
+// variant; clients that don't recognize a new error code can match on
+// `retry_status` and `message` alone.
+type BetaManagedAgentsUnknownError struct {
+ // Human-readable error description.
+ Message string `json:"message" api:"required"`
+ // What the client should do next in response to this error.
+ RetryStatus BetaManagedAgentsUnknownErrorRetryStatusUnion `json:"retry_status" api:"required"`
+ // Any of "unknown_error".
+ Type BetaManagedAgentsUnknownErrorType `json:"type" api:"required"`
+ // JSON contains metadata for fields, check presence with [respjson.Field.Valid].
+ JSON struct {
+ Message respjson.Field
+ RetryStatus respjson.Field
+ Type respjson.Field
+ ExtraFields map[string]respjson.Field
+ raw string
+ } `json:"-"`
+}
+
+// Returns the unmodified JSON received from the API
+func (r BetaManagedAgentsUnknownError) RawJSON() string { return r.JSON.raw }
+func (r *BetaManagedAgentsUnknownError) UnmarshalJSON(data []byte) error {
+ return apijson.UnmarshalRoot(data, r)
+}
+
+// BetaManagedAgentsUnknownErrorRetryStatusUnion contains all possible properties
+// and values from [BetaManagedAgentsRetryStatusRetrying],
+// [BetaManagedAgentsRetryStatusExhausted], [BetaManagedAgentsRetryStatusTerminal].
+//
+// Use the [BetaManagedAgentsUnknownErrorRetryStatusUnion.AsAny] method to switch
+// on the variant.
+//
+// Use the methods beginning with 'As' to cast the union to one of its variants.
+type BetaManagedAgentsUnknownErrorRetryStatusUnion struct {
+ // Any of "retrying", "exhausted", "terminal".
+ Type string `json:"type"`
+ JSON struct {
+ Type respjson.Field
+ raw string
+ } `json:"-"`
+}
+
+// anyBetaManagedAgentsUnknownErrorRetryStatus is implemented by each variant of
+// [BetaManagedAgentsUnknownErrorRetryStatusUnion] to add type safety for the
+// return type of [BetaManagedAgentsUnknownErrorRetryStatusUnion.AsAny]
+type anyBetaManagedAgentsUnknownErrorRetryStatus interface {
+ implBetaManagedAgentsUnknownErrorRetryStatusUnion()
+}
+
+func (BetaManagedAgentsRetryStatusRetrying) implBetaManagedAgentsUnknownErrorRetryStatusUnion() {}
+func (BetaManagedAgentsRetryStatusExhausted) implBetaManagedAgentsUnknownErrorRetryStatusUnion() {}
+func (BetaManagedAgentsRetryStatusTerminal) implBetaManagedAgentsUnknownErrorRetryStatusUnion() {}
+
+// Use the following switch statement to find the correct variant
+//
+// switch variant := BetaManagedAgentsUnknownErrorRetryStatusUnion.AsAny().(type) {
+// case anthropic.BetaManagedAgentsRetryStatusRetrying:
+// case anthropic.BetaManagedAgentsRetryStatusExhausted:
+// case anthropic.BetaManagedAgentsRetryStatusTerminal:
+// default:
+// fmt.Errorf("no variant present")
+// }
+func (u BetaManagedAgentsUnknownErrorRetryStatusUnion) AsAny() anyBetaManagedAgentsUnknownErrorRetryStatus {
+ switch u.Type {
+ case "retrying":
+ return u.AsRetrying()
+ case "exhausted":
+ return u.AsExhausted()
+ case "terminal":
+ return u.AsTerminal()
+ }
+ return nil
+}
+
+func (u BetaManagedAgentsUnknownErrorRetryStatusUnion) AsRetrying() (v BetaManagedAgentsRetryStatusRetrying) {
+ apijson.UnmarshalRoot(json.RawMessage(u.JSON.raw), &v)
+ return
+}
+
+func (u BetaManagedAgentsUnknownErrorRetryStatusUnion) AsExhausted() (v BetaManagedAgentsRetryStatusExhausted) {
+ apijson.UnmarshalRoot(json.RawMessage(u.JSON.raw), &v)
+ return
+}
+
+func (u BetaManagedAgentsUnknownErrorRetryStatusUnion) AsTerminal() (v BetaManagedAgentsRetryStatusTerminal) {
+ apijson.UnmarshalRoot(json.RawMessage(u.JSON.raw), &v)
+ return
+}
+
+// Returns the unmodified JSON received from the API
+func (u BetaManagedAgentsUnknownErrorRetryStatusUnion) RawJSON() string { return u.JSON.raw }
+
+func (r *BetaManagedAgentsUnknownErrorRetryStatusUnion) UnmarshalJSON(data []byte) error {
+ return apijson.UnmarshalRoot(data, r)
+}
+
+type BetaManagedAgentsUnknownErrorType string
+
+const (
+ BetaManagedAgentsUnknownErrorTypeUnknownError BetaManagedAgentsUnknownErrorType = "unknown_error"
+)
+
+// Document referenced by URL.
+type BetaManagedAgentsURLDocumentSource struct {
+ // Any of "url".
+ Type BetaManagedAgentsURLDocumentSourceType `json:"type" api:"required"`
+ // URL of the document to fetch.
+ URL string `json:"url" api:"required"`
+ // JSON contains metadata for fields, check presence with [respjson.Field.Valid].
+ JSON struct {
+ Type respjson.Field
+ URL respjson.Field
+ ExtraFields map[string]respjson.Field
+ raw string
+ } `json:"-"`
+}
+
+// Returns the unmodified JSON received from the API
+func (r BetaManagedAgentsURLDocumentSource) RawJSON() string { return r.JSON.raw }
+func (r *BetaManagedAgentsURLDocumentSource) UnmarshalJSON(data []byte) error {
+ return apijson.UnmarshalRoot(data, r)
+}
+
+// ToParam converts this BetaManagedAgentsURLDocumentSource to a
+// BetaManagedAgentsURLDocumentSourceParam.
+//
+// Warning: the fields of the param type will not be present. ToParam should only
+// be used at the last possible moment before sending a request. Test for this with
+// BetaManagedAgentsURLDocumentSourceParam.Overrides()
+func (r BetaManagedAgentsURLDocumentSource) ToParam() BetaManagedAgentsURLDocumentSourceParam {
+ return param.Override[BetaManagedAgentsURLDocumentSourceParam](json.RawMessage(r.RawJSON()))
+}
+
+type BetaManagedAgentsURLDocumentSourceType string
+
+const (
+ BetaManagedAgentsURLDocumentSourceTypeURL BetaManagedAgentsURLDocumentSourceType = "url"
+)
+
+// Document referenced by URL.
+//
+// The properties Type, URL are required.
+type BetaManagedAgentsURLDocumentSourceParam struct {
+ // Any of "url".
+ Type BetaManagedAgentsURLDocumentSourceType `json:"type,omitzero" api:"required"`
+ // URL of the document to fetch.
+ URL string `json:"url" api:"required"`
+ paramObj
+}
+
+func (r BetaManagedAgentsURLDocumentSourceParam) MarshalJSON() (data []byte, err error) {
+ type shadow BetaManagedAgentsURLDocumentSourceParam
+ return param.MarshalObject(r, (*shadow)(&r))
+}
+func (r *BetaManagedAgentsURLDocumentSourceParam) UnmarshalJSON(data []byte) error {
+ return apijson.UnmarshalRoot(data, r)
+}
+
+// Image referenced by URL.
+type BetaManagedAgentsURLImageSource struct {
+ // Any of "url".
+ Type BetaManagedAgentsURLImageSourceType `json:"type" api:"required"`
+ // URL of the image to fetch.
+ URL string `json:"url" api:"required"`
+ // JSON contains metadata for fields, check presence with [respjson.Field.Valid].
+ JSON struct {
+ Type respjson.Field
+ URL respjson.Field
+ ExtraFields map[string]respjson.Field
+ raw string
+ } `json:"-"`
+}
+
+// Returns the unmodified JSON received from the API
+func (r BetaManagedAgentsURLImageSource) RawJSON() string { return r.JSON.raw }
+func (r *BetaManagedAgentsURLImageSource) UnmarshalJSON(data []byte) error {
+ return apijson.UnmarshalRoot(data, r)
+}
+
+// ToParam converts this BetaManagedAgentsURLImageSource to a
+// BetaManagedAgentsURLImageSourceParam.
+//
+// Warning: the fields of the param type will not be present. ToParam should only
+// be used at the last possible moment before sending a request. Test for this with
+// BetaManagedAgentsURLImageSourceParam.Overrides()
+func (r BetaManagedAgentsURLImageSource) ToParam() BetaManagedAgentsURLImageSourceParam {
+ return param.Override[BetaManagedAgentsURLImageSourceParam](json.RawMessage(r.RawJSON()))
+}
+
+type BetaManagedAgentsURLImageSourceType string
+
+const (
+ BetaManagedAgentsURLImageSourceTypeURL BetaManagedAgentsURLImageSourceType = "url"
+)
+
+// Image referenced by URL.
+//
+// The properties Type, URL are required.
+type BetaManagedAgentsURLImageSourceParam struct {
+ // Any of "url".
+ Type BetaManagedAgentsURLImageSourceType `json:"type,omitzero" api:"required"`
+ // URL of the image to fetch.
+ URL string `json:"url" api:"required"`
+ paramObj
+}
+
+func (r BetaManagedAgentsURLImageSourceParam) MarshalJSON() (data []byte, err error) {
+ type shadow BetaManagedAgentsURLImageSourceParam
+ return param.MarshalObject(r, (*shadow)(&r))
+}
+func (r *BetaManagedAgentsURLImageSourceParam) UnmarshalJSON(data []byte) error {
+ return apijson.UnmarshalRoot(data, r)
+}
+
+// Event sent by the client providing the result of a custom tool execution.
+type BetaManagedAgentsUserCustomToolResultEvent struct {
+ // Unique identifier for this event.
+ ID string `json:"id" api:"required"`
+ // The id of the `agent.custom_tool_use` event this result corresponds to, which
+ // can be found in the last `session.status_idle`
+ // [event's](https://platform.claude.com/docs/en/api/beta/sessions/events/list#beta_managed_agents_session_requires_action.event_ids)
+ // `stop_reason.event_ids` field.
+ CustomToolUseID string `json:"custom_tool_use_id" api:"required"`
+ // Any of "user.custom_tool_result".
+ Type BetaManagedAgentsUserCustomToolResultEventType `json:"type" api:"required"`
+ // The result content returned by the tool.
+ Content []BetaManagedAgentsUserCustomToolResultEventContentUnion `json:"content"`
+ // Whether the tool execution resulted in an error.
+ IsError bool `json:"is_error" api:"nullable"`
+ // A timestamp in RFC 3339 format
+ ProcessedAt time.Time `json:"processed_at" api:"nullable" format:"date-time"`
+ // JSON contains metadata for fields, check presence with [respjson.Field.Valid].
+ JSON struct {
+ ID respjson.Field
+ CustomToolUseID respjson.Field
+ Type respjson.Field
+ Content respjson.Field
+ IsError respjson.Field
+ ProcessedAt respjson.Field
+ ExtraFields map[string]respjson.Field
+ raw string
+ } `json:"-"`
+}
+
+// Returns the unmodified JSON received from the API
+func (r BetaManagedAgentsUserCustomToolResultEvent) RawJSON() string { return r.JSON.raw }
+func (r *BetaManagedAgentsUserCustomToolResultEvent) UnmarshalJSON(data []byte) error {
+ return apijson.UnmarshalRoot(data, r)
+}
+
+type BetaManagedAgentsUserCustomToolResultEventType string
+
+const (
+ BetaManagedAgentsUserCustomToolResultEventTypeUserCustomToolResult BetaManagedAgentsUserCustomToolResultEventType = "user.custom_tool_result"
+)
+
+// BetaManagedAgentsUserCustomToolResultEventContentUnion contains all possible
+// properties and values from [BetaManagedAgentsTextBlock],
+// [BetaManagedAgentsImageBlock], [BetaManagedAgentsDocumentBlock].
+//
+// Use the [BetaManagedAgentsUserCustomToolResultEventContentUnion.AsAny] method to
+// switch on the variant.
+//
+// Use the methods beginning with 'As' to cast the union to one of its variants.
+type BetaManagedAgentsUserCustomToolResultEventContentUnion struct {
+ // This field is from variant [BetaManagedAgentsTextBlock].
+ Text string `json:"text"`
+ // Any of "text", "image", "document".
+ Type string `json:"type"`
+ // This field is a union of [BetaManagedAgentsImageBlockSourceUnion],
+ // [BetaManagedAgentsDocumentBlockSourceUnion]
+ Source BetaManagedAgentsUserCustomToolResultEventContentUnionSource `json:"source"`
+ // This field is from variant [BetaManagedAgentsDocumentBlock].
+ Context string `json:"context"`
+ // This field is from variant [BetaManagedAgentsDocumentBlock].
+ Title string `json:"title"`
+ JSON struct {
+ Text respjson.Field
+ Type respjson.Field
+ Source respjson.Field
+ Context respjson.Field
+ Title respjson.Field
+ raw string
+ } `json:"-"`
+}
+
+// anyBetaManagedAgentsUserCustomToolResultEventContent is implemented by each
+// variant of [BetaManagedAgentsUserCustomToolResultEventContentUnion] to add type
+// safety for the return type of
+// [BetaManagedAgentsUserCustomToolResultEventContentUnion.AsAny]
+type anyBetaManagedAgentsUserCustomToolResultEventContent interface {
+ implBetaManagedAgentsUserCustomToolResultEventContentUnion()
+}
+
+func (BetaManagedAgentsTextBlock) implBetaManagedAgentsUserCustomToolResultEventContentUnion() {}
+func (BetaManagedAgentsImageBlock) implBetaManagedAgentsUserCustomToolResultEventContentUnion() {}
+func (BetaManagedAgentsDocumentBlock) implBetaManagedAgentsUserCustomToolResultEventContentUnion() {}
+
+// Use the following switch statement to find the correct variant
+//
+// switch variant := BetaManagedAgentsUserCustomToolResultEventContentUnion.AsAny().(type) {
+// case anthropic.BetaManagedAgentsTextBlock:
+// case anthropic.BetaManagedAgentsImageBlock:
+// case anthropic.BetaManagedAgentsDocumentBlock:
+// default:
+// fmt.Errorf("no variant present")
+// }
+func (u BetaManagedAgentsUserCustomToolResultEventContentUnion) AsAny() anyBetaManagedAgentsUserCustomToolResultEventContent {
+ switch u.Type {
+ case "text":
+ return u.AsText()
+ case "image":
+ return u.AsImage()
+ case "document":
+ return u.AsDocument()
+ }
+ return nil
+}
+
+func (u BetaManagedAgentsUserCustomToolResultEventContentUnion) AsText() (v BetaManagedAgentsTextBlock) {
+ apijson.UnmarshalRoot(json.RawMessage(u.JSON.raw), &v)
+ return
+}
+
+func (u BetaManagedAgentsUserCustomToolResultEventContentUnion) AsImage() (v BetaManagedAgentsImageBlock) {
+ apijson.UnmarshalRoot(json.RawMessage(u.JSON.raw), &v)
+ return
+}
+
+func (u BetaManagedAgentsUserCustomToolResultEventContentUnion) AsDocument() (v BetaManagedAgentsDocumentBlock) {
+ apijson.UnmarshalRoot(json.RawMessage(u.JSON.raw), &v)
+ return
+}
+
+// Returns the unmodified JSON received from the API
+func (u BetaManagedAgentsUserCustomToolResultEventContentUnion) RawJSON() string { return u.JSON.raw }
+
+func (r *BetaManagedAgentsUserCustomToolResultEventContentUnion) UnmarshalJSON(data []byte) error {
+ return apijson.UnmarshalRoot(data, r)
+}
+
+// BetaManagedAgentsUserCustomToolResultEventContentUnionSource is an implicit
+// subunion of [BetaManagedAgentsUserCustomToolResultEventContentUnion].
+// BetaManagedAgentsUserCustomToolResultEventContentUnionSource provides convenient
+// access to the sub-properties of the union.
+//
+// For type safety it is recommended to directly use a variant of the
+// [BetaManagedAgentsUserCustomToolResultEventContentUnion].
+type BetaManagedAgentsUserCustomToolResultEventContentUnionSource struct {
+ Data string `json:"data"`
+ MediaType string `json:"media_type"`
+ Type string `json:"type"`
+ URL string `json:"url"`
+ FileID string `json:"file_id"`
+ JSON struct {
+ Data respjson.Field
+ MediaType respjson.Field
+ Type respjson.Field
+ URL respjson.Field
+ FileID respjson.Field
+ raw string
+ } `json:"-"`
+}
+
+func (r *BetaManagedAgentsUserCustomToolResultEventContentUnionSource) UnmarshalJSON(data []byte) error {
+ return apijson.UnmarshalRoot(data, r)
+}
+
+// Parameters for providing the result of a custom tool execution.
+//
+// The properties CustomToolUseID, Type are required.
+type BetaManagedAgentsUserCustomToolResultEventParams struct {
+ // The id of the `agent.custom_tool_use` event this result corresponds to, which
+ // can be found in the last `session.status_idle`
+ // [event's](https://platform.claude.com/docs/en/api/beta/sessions/events/list#beta_managed_agents_session_requires_action.event_ids)
+ // `stop_reason.event_ids` field.
+ CustomToolUseID string `json:"custom_tool_use_id" api:"required"`
+ // Any of "user.custom_tool_result".
+ Type BetaManagedAgentsUserCustomToolResultEventParamsType `json:"type,omitzero" api:"required"`
+ // Whether the tool execution resulted in an error.
+ IsError param.Opt[bool] `json:"is_error,omitzero"`
+ // The result content returned by the tool.
+ Content []BetaManagedAgentsUserCustomToolResultEventParamsContentUnion `json:"content,omitzero"`
+ paramObj
+}
+
+func (r BetaManagedAgentsUserCustomToolResultEventParams) MarshalJSON() (data []byte, err error) {
+ type shadow BetaManagedAgentsUserCustomToolResultEventParams
+ return param.MarshalObject(r, (*shadow)(&r))
+}
+func (r *BetaManagedAgentsUserCustomToolResultEventParams) UnmarshalJSON(data []byte) error {
+ return apijson.UnmarshalRoot(data, r)
+}
+
+type BetaManagedAgentsUserCustomToolResultEventParamsType string
+
+const (
+ BetaManagedAgentsUserCustomToolResultEventParamsTypeUserCustomToolResult BetaManagedAgentsUserCustomToolResultEventParamsType = "user.custom_tool_result"
+)
+
+// Only one field can be non-zero.
+//
+// Use [param.IsOmitted] to confirm if a field is set.
+type BetaManagedAgentsUserCustomToolResultEventParamsContentUnion struct {
+ OfText *BetaManagedAgentsTextBlockParam `json:",omitzero,inline"`
+ OfImage *BetaManagedAgentsImageBlockParam `json:",omitzero,inline"`
+ OfDocument *BetaManagedAgentsDocumentBlockParam `json:",omitzero,inline"`
+ paramUnion
+}
+
+func (u BetaManagedAgentsUserCustomToolResultEventParamsContentUnion) MarshalJSON() ([]byte, error) {
+ return param.MarshalUnion(u, u.OfText, u.OfImage, u.OfDocument)
+}
+func (u *BetaManagedAgentsUserCustomToolResultEventParamsContentUnion) UnmarshalJSON(data []byte) error {
+ return apijson.UnmarshalRoot(data, u)
+}
+
+func (u *BetaManagedAgentsUserCustomToolResultEventParamsContentUnion) asAny() any {
+ if !param.IsOmitted(u.OfText) {
+ return u.OfText
+ } else if !param.IsOmitted(u.OfImage) {
+ return u.OfImage
+ } else if !param.IsOmitted(u.OfDocument) {
+ return u.OfDocument
+ }
+ return nil
+}
+
+// Returns a pointer to the underlying variant's property, if present.
+func (u BetaManagedAgentsUserCustomToolResultEventParamsContentUnion) GetText() *string {
+ if vt := u.OfText; vt != nil {
+ return &vt.Text
+ }
+ return nil
+}
+
+// Returns a pointer to the underlying variant's property, if present.
+func (u BetaManagedAgentsUserCustomToolResultEventParamsContentUnion) GetContext() *string {
+ if vt := u.OfDocument; vt != nil && vt.Context.Valid() {
+ return &vt.Context.Value
+ }
+ return nil
+}
+
+// Returns a pointer to the underlying variant's property, if present.
+func (u BetaManagedAgentsUserCustomToolResultEventParamsContentUnion) GetTitle() *string {
+ if vt := u.OfDocument; vt != nil && vt.Title.Valid() {
+ return &vt.Title.Value
+ }
+ return nil
+}
+
+// Returns a pointer to the underlying variant's property, if present.
+func (u BetaManagedAgentsUserCustomToolResultEventParamsContentUnion) GetType() *string {
+ if vt := u.OfText; vt != nil {
+ return (*string)(&vt.Type)
+ } else if vt := u.OfImage; vt != nil {
+ return (*string)(&vt.Type)
+ } else if vt := u.OfDocument; vt != nil {
+ return (*string)(&vt.Type)
+ }
+ return nil
+}
+
+// Returns a subunion which exports methods to access subproperties
+//
+// Or use AsAny() to get the underlying value
+func (u BetaManagedAgentsUserCustomToolResultEventParamsContentUnion) GetSource() (res betaManagedAgentsUserCustomToolResultEventParamsContentUnionSource) {
+ if vt := u.OfImage; vt != nil {
+ res.any = vt.Source.asAny()
+ } else if vt := u.OfDocument; vt != nil {
+ res.any = vt.Source.asAny()
+ }
+ return
+}
+
+// Can have the runtime types [*BetaManagedAgentsBase64ImageSourceParam],
+// [*BetaManagedAgentsURLImageSourceParam],
+// [*BetaManagedAgentsFileImageSourceParam],
+// [*BetaManagedAgentsBase64DocumentSourceParam],
+// [*BetaManagedAgentsPlainTextDocumentSourceParam],
+// [*BetaManagedAgentsURLDocumentSourceParam],
+// [*BetaManagedAgentsFileDocumentSourceParam]
+type betaManagedAgentsUserCustomToolResultEventParamsContentUnionSource struct{ any }
+
+// Use the following switch statement to get the type of the union:
+//
+// switch u.AsAny().(type) {
+// case *anthropic.BetaManagedAgentsBase64ImageSourceParam:
+// case *anthropic.BetaManagedAgentsURLImageSourceParam:
+// case *anthropic.BetaManagedAgentsFileImageSourceParam:
+// case *anthropic.BetaManagedAgentsBase64DocumentSourceParam:
+// case *anthropic.BetaManagedAgentsPlainTextDocumentSourceParam:
+// case *anthropic.BetaManagedAgentsURLDocumentSourceParam:
+// case *anthropic.BetaManagedAgentsFileDocumentSourceParam:
+// default:
+// fmt.Errorf("not present")
+// }
+func (u betaManagedAgentsUserCustomToolResultEventParamsContentUnionSource) AsAny() any { return u.any }
+
+// Returns a pointer to the underlying variant's property, if present.
+func (u betaManagedAgentsUserCustomToolResultEventParamsContentUnionSource) GetData() *string {
+ switch vt := u.any.(type) {
+ case *BetaManagedAgentsImageBlockSourceUnionParam:
+ return vt.GetData()
+ case *BetaManagedAgentsDocumentBlockSourceUnionParam:
+ return vt.GetData()
+ }
+ return nil
+}
+
+// Returns a pointer to the underlying variant's property, if present.
+func (u betaManagedAgentsUserCustomToolResultEventParamsContentUnionSource) GetMediaType() *string {
+ switch vt := u.any.(type) {
+ case *BetaManagedAgentsImageBlockSourceUnionParam:
+ return vt.GetMediaType()
+ case *BetaManagedAgentsDocumentBlockSourceUnionParam:
+ return vt.GetMediaType()
+ }
+ return nil
+}
+
+// Returns a pointer to the underlying variant's property, if present.
+func (u betaManagedAgentsUserCustomToolResultEventParamsContentUnionSource) GetType() *string {
+ switch vt := u.any.(type) {
+ case *BetaManagedAgentsImageBlockSourceUnionParam:
+ return vt.GetType()
+ case *BetaManagedAgentsDocumentBlockSourceUnionParam:
+ return vt.GetType()
+ }
+ return nil
+}
+
+// Returns a pointer to the underlying variant's property, if present.
+func (u betaManagedAgentsUserCustomToolResultEventParamsContentUnionSource) GetURL() *string {
+ switch vt := u.any.(type) {
+ case *BetaManagedAgentsImageBlockSourceUnionParam:
+ return vt.GetURL()
+ case *BetaManagedAgentsDocumentBlockSourceUnionParam:
+ return vt.GetURL()
+ }
+ return nil
+}
+
+// Returns a pointer to the underlying variant's property, if present.
+func (u betaManagedAgentsUserCustomToolResultEventParamsContentUnionSource) GetFileID() *string {
+ switch vt := u.any.(type) {
+ case *BetaManagedAgentsImageBlockSourceUnionParam:
+ return vt.GetFileID()
+ case *BetaManagedAgentsDocumentBlockSourceUnionParam:
+ return vt.GetFileID()
+ }
+ return nil
+}
+
+func init() {
+ apijson.RegisterUnion[BetaManagedAgentsUserCustomToolResultEventParamsContentUnion](
+ "type",
+ apijson.Discriminator[BetaManagedAgentsTextBlockParam]("text"),
+ apijson.Discriminator[BetaManagedAgentsImageBlockParam]("image"),
+ apijson.Discriminator[BetaManagedAgentsDocumentBlockParam]("document"),
+ )
+}
+
+// An interrupt event that pauses agent execution and returns control to the user.
+type BetaManagedAgentsUserInterruptEvent struct {
+ // Unique identifier for this event.
+ ID string `json:"id" api:"required"`
+ // Any of "user.interrupt".
+ Type BetaManagedAgentsUserInterruptEventType `json:"type" api:"required"`
+ // A timestamp in RFC 3339 format
+ ProcessedAt time.Time `json:"processed_at" api:"nullable" format:"date-time"`
+ // JSON contains metadata for fields, check presence with [respjson.Field.Valid].
+ JSON struct {
+ ID respjson.Field
+ Type respjson.Field
+ ProcessedAt respjson.Field
+ ExtraFields map[string]respjson.Field
+ raw string
+ } `json:"-"`
+}
+
+// Returns the unmodified JSON received from the API
+func (r BetaManagedAgentsUserInterruptEvent) RawJSON() string { return r.JSON.raw }
+func (r *BetaManagedAgentsUserInterruptEvent) UnmarshalJSON(data []byte) error {
+ return apijson.UnmarshalRoot(data, r)
+}
+
+type BetaManagedAgentsUserInterruptEventType string
+
+const (
+ BetaManagedAgentsUserInterruptEventTypeUserInterrupt BetaManagedAgentsUserInterruptEventType = "user.interrupt"
+)
+
+// Parameters for sending an interrupt to pause the agent.
+//
+// The property Type is required.
+type BetaManagedAgentsUserInterruptEventParams struct {
+ // Any of "user.interrupt".
+ Type BetaManagedAgentsUserInterruptEventParamsType `json:"type,omitzero" api:"required"`
+ paramObj
+}
+
+func (r BetaManagedAgentsUserInterruptEventParams) MarshalJSON() (data []byte, err error) {
+ type shadow BetaManagedAgentsUserInterruptEventParams
+ return param.MarshalObject(r, (*shadow)(&r))
+}
+func (r *BetaManagedAgentsUserInterruptEventParams) UnmarshalJSON(data []byte) error {
+ return apijson.UnmarshalRoot(data, r)
+}
+
+type BetaManagedAgentsUserInterruptEventParamsType string
+
+const (
+ BetaManagedAgentsUserInterruptEventParamsTypeUserInterrupt BetaManagedAgentsUserInterruptEventParamsType = "user.interrupt"
+)
+
+// A user message event in the session conversation.
+type BetaManagedAgentsUserMessageEvent struct {
+ // Unique identifier for this event.
+ ID string `json:"id" api:"required"`
+ // Array of content blocks comprising the user message.
+ Content []BetaManagedAgentsUserMessageEventContentUnion `json:"content" api:"required"`
+ // Any of "user.message".
+ Type BetaManagedAgentsUserMessageEventType `json:"type" api:"required"`
+ // A timestamp in RFC 3339 format
+ ProcessedAt time.Time `json:"processed_at" api:"nullable" format:"date-time"`
+ // JSON contains metadata for fields, check presence with [respjson.Field.Valid].
+ JSON struct {
+ ID respjson.Field
+ Content respjson.Field
+ Type respjson.Field
+ ProcessedAt respjson.Field
+ ExtraFields map[string]respjson.Field
+ raw string
+ } `json:"-"`
+}
+
+// Returns the unmodified JSON received from the API
+func (r BetaManagedAgentsUserMessageEvent) RawJSON() string { return r.JSON.raw }
+func (r *BetaManagedAgentsUserMessageEvent) UnmarshalJSON(data []byte) error {
+ return apijson.UnmarshalRoot(data, r)
+}
+
+// BetaManagedAgentsUserMessageEventContentUnion contains all possible properties
+// and values from [BetaManagedAgentsTextBlock], [BetaManagedAgentsImageBlock],
+// [BetaManagedAgentsDocumentBlock].
+//
+// Use the [BetaManagedAgentsUserMessageEventContentUnion.AsAny] method to switch
+// on the variant.
+//
+// Use the methods beginning with 'As' to cast the union to one of its variants.
+type BetaManagedAgentsUserMessageEventContentUnion struct {
+ // This field is from variant [BetaManagedAgentsTextBlock].
+ Text string `json:"text"`
+ // Any of "text", "image", "document".
+ Type string `json:"type"`
+ // This field is a union of [BetaManagedAgentsImageBlockSourceUnion],
+ // [BetaManagedAgentsDocumentBlockSourceUnion]
+ Source BetaManagedAgentsUserMessageEventContentUnionSource `json:"source"`
+ // This field is from variant [BetaManagedAgentsDocumentBlock].
+ Context string `json:"context"`
+ // This field is from variant [BetaManagedAgentsDocumentBlock].
+ Title string `json:"title"`
+ JSON struct {
+ Text respjson.Field
+ Type respjson.Field
+ Source respjson.Field
+ Context respjson.Field
+ Title respjson.Field
+ raw string
+ } `json:"-"`
+}
+
+// anyBetaManagedAgentsUserMessageEventContent is implemented by each variant of
+// [BetaManagedAgentsUserMessageEventContentUnion] to add type safety for the
+// return type of [BetaManagedAgentsUserMessageEventContentUnion.AsAny]
+type anyBetaManagedAgentsUserMessageEventContent interface {
+ implBetaManagedAgentsUserMessageEventContentUnion()
+}
+
+func (BetaManagedAgentsTextBlock) implBetaManagedAgentsUserMessageEventContentUnion() {}
+func (BetaManagedAgentsImageBlock) implBetaManagedAgentsUserMessageEventContentUnion() {}
+func (BetaManagedAgentsDocumentBlock) implBetaManagedAgentsUserMessageEventContentUnion() {}
+
+// Use the following switch statement to find the correct variant
+//
+// switch variant := BetaManagedAgentsUserMessageEventContentUnion.AsAny().(type) {
+// case anthropic.BetaManagedAgentsTextBlock:
+// case anthropic.BetaManagedAgentsImageBlock:
+// case anthropic.BetaManagedAgentsDocumentBlock:
+// default:
+// fmt.Errorf("no variant present")
+// }
+func (u BetaManagedAgentsUserMessageEventContentUnion) AsAny() anyBetaManagedAgentsUserMessageEventContent {
+ switch u.Type {
+ case "text":
+ return u.AsText()
+ case "image":
+ return u.AsImage()
+ case "document":
+ return u.AsDocument()
+ }
+ return nil
+}
+
+func (u BetaManagedAgentsUserMessageEventContentUnion) AsText() (v BetaManagedAgentsTextBlock) {
+ apijson.UnmarshalRoot(json.RawMessage(u.JSON.raw), &v)
+ return
+}
+
+func (u BetaManagedAgentsUserMessageEventContentUnion) AsImage() (v BetaManagedAgentsImageBlock) {
+ apijson.UnmarshalRoot(json.RawMessage(u.JSON.raw), &v)
+ return
+}
+
+func (u BetaManagedAgentsUserMessageEventContentUnion) AsDocument() (v BetaManagedAgentsDocumentBlock) {
+ apijson.UnmarshalRoot(json.RawMessage(u.JSON.raw), &v)
+ return
+}
+
+// Returns the unmodified JSON received from the API
+func (u BetaManagedAgentsUserMessageEventContentUnion) RawJSON() string { return u.JSON.raw }
+
+func (r *BetaManagedAgentsUserMessageEventContentUnion) UnmarshalJSON(data []byte) error {
+ return apijson.UnmarshalRoot(data, r)
+}
+
+// BetaManagedAgentsUserMessageEventContentUnionSource is an implicit subunion of
+// [BetaManagedAgentsUserMessageEventContentUnion].
+// BetaManagedAgentsUserMessageEventContentUnionSource provides convenient access
+// to the sub-properties of the union.
+//
+// For type safety it is recommended to directly use a variant of the
+// [BetaManagedAgentsUserMessageEventContentUnion].
+type BetaManagedAgentsUserMessageEventContentUnionSource struct {
+ Data string `json:"data"`
+ MediaType string `json:"media_type"`
+ Type string `json:"type"`
+ URL string `json:"url"`
+ FileID string `json:"file_id"`
+ JSON struct {
+ Data respjson.Field
+ MediaType respjson.Field
+ Type respjson.Field
+ URL respjson.Field
+ FileID respjson.Field
+ raw string
+ } `json:"-"`
+}
+
+func (r *BetaManagedAgentsUserMessageEventContentUnionSource) UnmarshalJSON(data []byte) error {
+ return apijson.UnmarshalRoot(data, r)
+}
+
+type BetaManagedAgentsUserMessageEventType string
+
+const (
+ BetaManagedAgentsUserMessageEventTypeUserMessage BetaManagedAgentsUserMessageEventType = "user.message"
+)
+
+// Parameters for sending a user message to the session.
+//
+// The properties Content, Type are required.
+type BetaManagedAgentsUserMessageEventParams struct {
+ // Array of content blocks for the user message.
+ Content []BetaManagedAgentsUserMessageEventParamsContentUnion `json:"content,omitzero" api:"required"`
+ // Any of "user.message".
+ Type BetaManagedAgentsUserMessageEventParamsType `json:"type,omitzero" api:"required"`
+ paramObj
+}
+
+func (r BetaManagedAgentsUserMessageEventParams) MarshalJSON() (data []byte, err error) {
+ type shadow BetaManagedAgentsUserMessageEventParams
+ return param.MarshalObject(r, (*shadow)(&r))
+}
+func (r *BetaManagedAgentsUserMessageEventParams) UnmarshalJSON(data []byte) error {
+ return apijson.UnmarshalRoot(data, r)
+}
+
+// Only one field can be non-zero.
+//
+// Use [param.IsOmitted] to confirm if a field is set.
+type BetaManagedAgentsUserMessageEventParamsContentUnion struct {
+ OfText *BetaManagedAgentsTextBlockParam `json:",omitzero,inline"`
+ OfImage *BetaManagedAgentsImageBlockParam `json:",omitzero,inline"`
+ OfDocument *BetaManagedAgentsDocumentBlockParam `json:",omitzero,inline"`
+ paramUnion
+}
+
+func (u BetaManagedAgentsUserMessageEventParamsContentUnion) MarshalJSON() ([]byte, error) {
+ return param.MarshalUnion(u, u.OfText, u.OfImage, u.OfDocument)
+}
+func (u *BetaManagedAgentsUserMessageEventParamsContentUnion) UnmarshalJSON(data []byte) error {
+ return apijson.UnmarshalRoot(data, u)
+}
+
+func (u *BetaManagedAgentsUserMessageEventParamsContentUnion) asAny() any {
+ if !param.IsOmitted(u.OfText) {
+ return u.OfText
+ } else if !param.IsOmitted(u.OfImage) {
+ return u.OfImage
+ } else if !param.IsOmitted(u.OfDocument) {
+ return u.OfDocument
+ }
+ return nil
+}
+
+// Returns a pointer to the underlying variant's property, if present.
+func (u BetaManagedAgentsUserMessageEventParamsContentUnion) GetText() *string {
+ if vt := u.OfText; vt != nil {
+ return &vt.Text
+ }
+ return nil
+}
+
+// Returns a pointer to the underlying variant's property, if present.
+func (u BetaManagedAgentsUserMessageEventParamsContentUnion) GetContext() *string {
+ if vt := u.OfDocument; vt != nil && vt.Context.Valid() {
+ return &vt.Context.Value
+ }
+ return nil
+}
+
+// Returns a pointer to the underlying variant's property, if present.
+func (u BetaManagedAgentsUserMessageEventParamsContentUnion) GetTitle() *string {
+ if vt := u.OfDocument; vt != nil && vt.Title.Valid() {
+ return &vt.Title.Value
+ }
+ return nil
+}
+
+// Returns a pointer to the underlying variant's property, if present.
+func (u BetaManagedAgentsUserMessageEventParamsContentUnion) GetType() *string {
+ if vt := u.OfText; vt != nil {
+ return (*string)(&vt.Type)
+ } else if vt := u.OfImage; vt != nil {
+ return (*string)(&vt.Type)
+ } else if vt := u.OfDocument; vt != nil {
+ return (*string)(&vt.Type)
+ }
+ return nil
+}
+
+// Returns a subunion which exports methods to access subproperties
+//
+// Or use AsAny() to get the underlying value
+func (u BetaManagedAgentsUserMessageEventParamsContentUnion) GetSource() (res betaManagedAgentsUserMessageEventParamsContentUnionSource) {
+ if vt := u.OfImage; vt != nil {
+ res.any = vt.Source.asAny()
+ } else if vt := u.OfDocument; vt != nil {
+ res.any = vt.Source.asAny()
+ }
+ return
+}
+
+// Can have the runtime types [*BetaManagedAgentsBase64ImageSourceParam],
+// [*BetaManagedAgentsURLImageSourceParam],
+// [*BetaManagedAgentsFileImageSourceParam],
+// [*BetaManagedAgentsBase64DocumentSourceParam],
+// [*BetaManagedAgentsPlainTextDocumentSourceParam],
+// [*BetaManagedAgentsURLDocumentSourceParam],
+// [*BetaManagedAgentsFileDocumentSourceParam]
+type betaManagedAgentsUserMessageEventParamsContentUnionSource struct{ any }
+
+// Use the following switch statement to get the type of the union:
+//
+// switch u.AsAny().(type) {
+// case *anthropic.BetaManagedAgentsBase64ImageSourceParam:
+// case *anthropic.BetaManagedAgentsURLImageSourceParam:
+// case *anthropic.BetaManagedAgentsFileImageSourceParam:
+// case *anthropic.BetaManagedAgentsBase64DocumentSourceParam:
+// case *anthropic.BetaManagedAgentsPlainTextDocumentSourceParam:
+// case *anthropic.BetaManagedAgentsURLDocumentSourceParam:
+// case *anthropic.BetaManagedAgentsFileDocumentSourceParam:
+// default:
+// fmt.Errorf("not present")
+// }
+func (u betaManagedAgentsUserMessageEventParamsContentUnionSource) AsAny() any { return u.any }
+
+// Returns a pointer to the underlying variant's property, if present.
+func (u betaManagedAgentsUserMessageEventParamsContentUnionSource) GetData() *string {
+ switch vt := u.any.(type) {
+ case *BetaManagedAgentsImageBlockSourceUnionParam:
+ return vt.GetData()
+ case *BetaManagedAgentsDocumentBlockSourceUnionParam:
+ return vt.GetData()
+ }
+ return nil
+}
+
+// Returns a pointer to the underlying variant's property, if present.
+func (u betaManagedAgentsUserMessageEventParamsContentUnionSource) GetMediaType() *string {
+ switch vt := u.any.(type) {
+ case *BetaManagedAgentsImageBlockSourceUnionParam:
+ return vt.GetMediaType()
+ case *BetaManagedAgentsDocumentBlockSourceUnionParam:
+ return vt.GetMediaType()
+ }
+ return nil
+}
+
+// Returns a pointer to the underlying variant's property, if present.
+func (u betaManagedAgentsUserMessageEventParamsContentUnionSource) GetType() *string {
+ switch vt := u.any.(type) {
+ case *BetaManagedAgentsImageBlockSourceUnionParam:
+ return vt.GetType()
+ case *BetaManagedAgentsDocumentBlockSourceUnionParam:
+ return vt.GetType()
+ }
+ return nil
+}
+
+// Returns a pointer to the underlying variant's property, if present.
+func (u betaManagedAgentsUserMessageEventParamsContentUnionSource) GetURL() *string {
+ switch vt := u.any.(type) {
+ case *BetaManagedAgentsImageBlockSourceUnionParam:
+ return vt.GetURL()
+ case *BetaManagedAgentsDocumentBlockSourceUnionParam:
+ return vt.GetURL()
+ }
+ return nil
+}
+
+// Returns a pointer to the underlying variant's property, if present.
+func (u betaManagedAgentsUserMessageEventParamsContentUnionSource) GetFileID() *string {
+ switch vt := u.any.(type) {
+ case *BetaManagedAgentsImageBlockSourceUnionParam:
+ return vt.GetFileID()
+ case *BetaManagedAgentsDocumentBlockSourceUnionParam:
+ return vt.GetFileID()
+ }
+ return nil
+}
+
+func init() {
+ apijson.RegisterUnion[BetaManagedAgentsUserMessageEventParamsContentUnion](
+ "type",
+ apijson.Discriminator[BetaManagedAgentsTextBlockParam]("text"),
+ apijson.Discriminator[BetaManagedAgentsImageBlockParam]("image"),
+ apijson.Discriminator[BetaManagedAgentsDocumentBlockParam]("document"),
+ )
+}
+
+type BetaManagedAgentsUserMessageEventParamsType string
+
+const (
+ BetaManagedAgentsUserMessageEventParamsTypeUserMessage BetaManagedAgentsUserMessageEventParamsType = "user.message"
+)
+
+// A tool confirmation event that approves or denies a pending tool execution.
+type BetaManagedAgentsUserToolConfirmationEvent struct {
+ // Unique identifier for this event.
+ ID string `json:"id" api:"required"`
+ // UserToolConfirmationResult enum
+ //
+ // Any of "allow", "deny".
+ Result BetaManagedAgentsUserToolConfirmationEventResult `json:"result" api:"required"`
+ // The id of the `agent.tool_use` or `agent.mcp_tool_use` event this result
+ // corresponds to, which can be found in the last `session.status_idle`
+ // [event's](https://platform.claude.com/docs/en/api/beta/sessions/events/list#beta_managed_agents_session_requires_action.event_ids)
+ // `stop_reason.event_ids` field.
+ ToolUseID string `json:"tool_use_id" api:"required"`
+ // Any of "user.tool_confirmation".
+ Type BetaManagedAgentsUserToolConfirmationEventType `json:"type" api:"required"`
+ // Optional message providing context for a 'deny' decision. Only allowed when
+ // result is 'deny'.
+ DenyMessage string `json:"deny_message" api:"nullable"`
+ // A timestamp in RFC 3339 format
+ ProcessedAt time.Time `json:"processed_at" api:"nullable" format:"date-time"`
+ // JSON contains metadata for fields, check presence with [respjson.Field.Valid].
+ JSON struct {
+ ID respjson.Field
+ Result respjson.Field
+ ToolUseID respjson.Field
+ Type respjson.Field
+ DenyMessage respjson.Field
+ ProcessedAt respjson.Field
+ ExtraFields map[string]respjson.Field
+ raw string
+ } `json:"-"`
+}
+
+// Returns the unmodified JSON received from the API
+func (r BetaManagedAgentsUserToolConfirmationEvent) RawJSON() string { return r.JSON.raw }
+func (r *BetaManagedAgentsUserToolConfirmationEvent) UnmarshalJSON(data []byte) error {
+ return apijson.UnmarshalRoot(data, r)
+}
+
+// UserToolConfirmationResult enum
+type BetaManagedAgentsUserToolConfirmationEventResult string
+
+const (
+ BetaManagedAgentsUserToolConfirmationEventResultAllow BetaManagedAgentsUserToolConfirmationEventResult = "allow"
+ BetaManagedAgentsUserToolConfirmationEventResultDeny BetaManagedAgentsUserToolConfirmationEventResult = "deny"
+)
+
+type BetaManagedAgentsUserToolConfirmationEventType string
+
+const (
+ BetaManagedAgentsUserToolConfirmationEventTypeUserToolConfirmation BetaManagedAgentsUserToolConfirmationEventType = "user.tool_confirmation"
+)
+
+// Parameters for confirming or denying a tool execution request.
+//
+// The properties Result, ToolUseID, Type are required.
+type BetaManagedAgentsUserToolConfirmationEventParams struct {
+ // UserToolConfirmationResult enum
+ //
+ // Any of "allow", "deny".
+ Result BetaManagedAgentsUserToolConfirmationEventParamsResult `json:"result,omitzero" api:"required"`
+ // The id of the `agent.tool_use` or `agent.mcp_tool_use` event this result
+ // corresponds to, which can be found in the last `session.status_idle`
+ // [event's](https://platform.claude.com/docs/en/api/beta/sessions/events/list#beta_managed_agents_session_requires_action.event_ids)
+ // `stop_reason.event_ids` field.
+ ToolUseID string `json:"tool_use_id" api:"required"`
+ // Any of "user.tool_confirmation".
+ Type BetaManagedAgentsUserToolConfirmationEventParamsType `json:"type,omitzero" api:"required"`
+ // Optional message providing context for a 'deny' decision. Only allowed when
+ // result is 'deny'.
+ DenyMessage param.Opt[string] `json:"deny_message,omitzero"`
+ paramObj
+}
+
+func (r BetaManagedAgentsUserToolConfirmationEventParams) MarshalJSON() (data []byte, err error) {
+ type shadow BetaManagedAgentsUserToolConfirmationEventParams
+ return param.MarshalObject(r, (*shadow)(&r))
+}
+func (r *BetaManagedAgentsUserToolConfirmationEventParams) UnmarshalJSON(data []byte) error {
+ return apijson.UnmarshalRoot(data, r)
+}
+
+// UserToolConfirmationResult enum
+type BetaManagedAgentsUserToolConfirmationEventParamsResult string
+
+const (
+ BetaManagedAgentsUserToolConfirmationEventParamsResultAllow BetaManagedAgentsUserToolConfirmationEventParamsResult = "allow"
+ BetaManagedAgentsUserToolConfirmationEventParamsResultDeny BetaManagedAgentsUserToolConfirmationEventParamsResult = "deny"
+)
+
+type BetaManagedAgentsUserToolConfirmationEventParamsType string
+
+const (
+ BetaManagedAgentsUserToolConfirmationEventParamsTypeUserToolConfirmation BetaManagedAgentsUserToolConfirmationEventParamsType = "user.tool_confirmation"
+)
+
+type BetaSessionEventListParams struct {
+ // Query parameter for limit
+ Limit param.Opt[int64] `query:"limit,omitzero" json:"-"`
+ // Opaque pagination cursor from a previous response's next_page.
+ Page param.Opt[string] `query:"page,omitzero" json:"-"`
+ // Sort direction for results, ordered by created_at. Defaults to asc
+ // (chronological).
+ //
+ // Any of "asc", "desc".
+ Order BetaSessionEventListParamsOrder `query:"order,omitzero" json:"-"`
+ // Optional header to specify the beta version(s) you want to use.
+ Betas []AnthropicBeta `header:"anthropic-beta,omitzero" json:"-"`
+ paramObj
+}
+
+// URLQuery serializes [BetaSessionEventListParams]'s query parameters as
+// `url.Values`.
+func (r BetaSessionEventListParams) URLQuery() (v url.Values, err error) {
+ return apiquery.MarshalWithSettings(r, apiquery.QuerySettings{
+ ArrayFormat: apiquery.ArrayQueryFormatComma,
+ NestedFormat: apiquery.NestedQueryFormatBrackets,
+ })
+}
+
+// Sort direction for results, ordered by created_at. Defaults to asc
+// (chronological).
+type BetaSessionEventListParamsOrder string
+
+const (
+ BetaSessionEventListParamsOrderAsc BetaSessionEventListParamsOrder = "asc"
+ BetaSessionEventListParamsOrderDesc BetaSessionEventListParamsOrder = "desc"
+)
+
+type BetaSessionEventSendParams struct {
+ // Events to send to the `session`.
+ Events []BetaManagedAgentsEventParamsUnion `json:"events,omitzero" api:"required"`
+ // Optional header to specify the beta version(s) you want to use.
+ Betas []AnthropicBeta `header:"anthropic-beta,omitzero" json:"-"`
+ paramObj
+}
+
+func (r BetaSessionEventSendParams) MarshalJSON() (data []byte, err error) {
+ type shadow BetaSessionEventSendParams
+ return param.MarshalObject(r, (*shadow)(&r))
+}
+func (r *BetaSessionEventSendParams) UnmarshalJSON(data []byte) error {
+ return apijson.UnmarshalRoot(data, r)
+}
+
+type BetaSessionEventStreamParams struct {
+ // Optional header to specify the beta version(s) you want to use.
+ Betas []AnthropicBeta `header:"anthropic-beta,omitzero" json:"-"`
+ paramObj
+}
diff --git a/betasessionevent_test.go b/betasessionevent_test.go
new file mode 100644
index 000000000..9f7f307d1
--- /dev/null
+++ b/betasessionevent_test.go
@@ -0,0 +1,85 @@
+// File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+package anthropic_test
+
+import (
+ "context"
+ "errors"
+ "os"
+ "testing"
+
+ "github.com/anthropics/anthropic-sdk-go"
+ "github.com/anthropics/anthropic-sdk-go/internal/testutil"
+ "github.com/anthropics/anthropic-sdk-go/option"
+)
+
+func TestBetaSessionEventListWithOptionalParams(t *testing.T) {
+ t.Skip("buildURL drops path-level query params (SDK-4349)")
+ baseURL := "http://localhost:4010"
+ if envURL, ok := os.LookupEnv("TEST_API_BASE_URL"); ok {
+ baseURL = envURL
+ }
+ if !testutil.CheckTestServer(t, baseURL) {
+ return
+ }
+ client := anthropic.NewClient(
+ option.WithBaseURL(baseURL),
+ option.WithAPIKey("my-anthropic-api-key"),
+ )
+ _, err := client.Beta.Sessions.Events.List(
+ context.TODO(),
+ "sesn_011CZkZAtmR3yMPDzynEDxu7",
+ anthropic.BetaSessionEventListParams{
+ Limit: anthropic.Int(0),
+ Order: anthropic.BetaSessionEventListParamsOrderAsc,
+ Page: anthropic.String("page"),
+ Betas: []anthropic.AnthropicBeta{anthropic.AnthropicBetaMessageBatches2024_09_24},
+ },
+ )
+ if err != nil {
+ var apierr *anthropic.Error
+ if errors.As(err, &apierr) {
+ t.Log(string(apierr.DumpRequest(true)))
+ }
+ t.Fatalf("err should be nil: %s", err.Error())
+ }
+}
+
+func TestBetaSessionEventSendWithOptionalParams(t *testing.T) {
+ baseURL := "http://localhost:4010"
+ if envURL, ok := os.LookupEnv("TEST_API_BASE_URL"); ok {
+ baseURL = envURL
+ }
+ if !testutil.CheckTestServer(t, baseURL) {
+ return
+ }
+ client := anthropic.NewClient(
+ option.WithBaseURL(baseURL),
+ option.WithAPIKey("my-anthropic-api-key"),
+ )
+ _, err := client.Beta.Sessions.Events.Send(
+ context.TODO(),
+ "sesn_011CZkZAtmR3yMPDzynEDxu7",
+ anthropic.BetaSessionEventSendParams{
+ Events: []anthropic.BetaManagedAgentsEventParamsUnion{{
+ OfUserMessage: &anthropic.BetaManagedAgentsUserMessageEventParams{
+ Content: []anthropic.BetaManagedAgentsUserMessageEventParamsContentUnion{{
+ OfText: &anthropic.BetaManagedAgentsTextBlockParam{
+ Text: "Where is my order #1234?",
+ Type: anthropic.BetaManagedAgentsTextBlockTypeText,
+ },
+ }},
+ Type: anthropic.BetaManagedAgentsUserMessageEventParamsTypeUserMessage,
+ },
+ }},
+ Betas: []anthropic.AnthropicBeta{anthropic.AnthropicBetaMessageBatches2024_09_24},
+ },
+ )
+ if err != nil {
+ var apierr *anthropic.Error
+ if errors.As(err, &apierr) {
+ t.Log(string(apierr.DumpRequest(true)))
+ }
+ t.Fatalf("err should be nil: %s", err.Error())
+ }
+}
diff --git a/betasessionresource.go b/betasessionresource.go
new file mode 100644
index 000000000..f90920629
--- /dev/null
+++ b/betasessionresource.go
@@ -0,0 +1,619 @@
+// File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+package anthropic
+
+import (
+ "context"
+ "encoding/json"
+ "errors"
+ "fmt"
+ "net/http"
+ "net/url"
+ "slices"
+ "time"
+
+ "github.com/anthropics/anthropic-sdk-go/internal/apijson"
+ "github.com/anthropics/anthropic-sdk-go/internal/apiquery"
+ shimjson "github.com/anthropics/anthropic-sdk-go/internal/encoding/json"
+ "github.com/anthropics/anthropic-sdk-go/internal/requestconfig"
+ "github.com/anthropics/anthropic-sdk-go/option"
+ "github.com/anthropics/anthropic-sdk-go/packages/pagination"
+ "github.com/anthropics/anthropic-sdk-go/packages/param"
+ "github.com/anthropics/anthropic-sdk-go/packages/respjson"
+)
+
+// BetaSessionResourceService contains methods and other services that help with
+// interacting with the anthropic API.
+//
+// Note, unlike clients, this service does not read variables from the environment
+// automatically. You should not instantiate this service directly, and instead use
+// the [NewBetaSessionResourceService] method instead.
+type BetaSessionResourceService struct {
+ Options []option.RequestOption
+}
+
+// NewBetaSessionResourceService generates a new service that applies the given
+// options to each request. These options are applied after the parent client's
+// options (if there is one), and before any request-specific options.
+func NewBetaSessionResourceService(opts ...option.RequestOption) (r BetaSessionResourceService) {
+ r = BetaSessionResourceService{}
+ r.Options = opts
+ return
+}
+
+// Get Session Resource
+func (r *BetaSessionResourceService) Get(ctx context.Context, resourceID string, params BetaSessionResourceGetParams, opts ...option.RequestOption) (res *BetaSessionResourceGetResponseUnion, err error) {
+ for _, v := range params.Betas {
+ opts = append(opts, option.WithHeaderAdd("anthropic-beta", fmt.Sprintf("%v", v)))
+ }
+ opts = slices.Concat(r.Options, opts)
+ opts = append([]option.RequestOption{option.WithHeader("anthropic-beta", "managed-agents-2026-04-01")}, opts...)
+ if params.SessionID == "" {
+ err = errors.New("missing required session_id parameter")
+ return nil, err
+ }
+ if resourceID == "" {
+ err = errors.New("missing required resource_id parameter")
+ return nil, err
+ }
+ path := fmt.Sprintf("v1/sessions/%s/resources/%s?beta=true", params.SessionID, resourceID)
+ err = requestconfig.ExecuteNewRequest(ctx, http.MethodGet, path, nil, &res, opts...)
+ return res, err
+}
+
+// Update Session Resource
+func (r *BetaSessionResourceService) Update(ctx context.Context, resourceID string, params BetaSessionResourceUpdateParams, opts ...option.RequestOption) (res *BetaSessionResourceUpdateResponseUnion, err error) {
+ for _, v := range params.Betas {
+ opts = append(opts, option.WithHeaderAdd("anthropic-beta", fmt.Sprintf("%v", v)))
+ }
+ opts = slices.Concat(r.Options, opts)
+ opts = append([]option.RequestOption{option.WithHeader("anthropic-beta", "managed-agents-2026-04-01")}, opts...)
+ if params.SessionID == "" {
+ err = errors.New("missing required session_id parameter")
+ return nil, err
+ }
+ if resourceID == "" {
+ err = errors.New("missing required resource_id parameter")
+ return nil, err
+ }
+ path := fmt.Sprintf("v1/sessions/%s/resources/%s?beta=true", params.SessionID, resourceID)
+ err = requestconfig.ExecuteNewRequest(ctx, http.MethodPost, path, params, &res, opts...)
+ return res, err
+}
+
+// List Session Resources
+func (r *BetaSessionResourceService) List(ctx context.Context, sessionID string, params BetaSessionResourceListParams, opts ...option.RequestOption) (res *pagination.PageCursor[BetaManagedAgentsSessionResourceUnion], err error) {
+ var raw *http.Response
+ for _, v := range params.Betas {
+ opts = append(opts, option.WithHeaderAdd("anthropic-beta", fmt.Sprintf("%v", v)))
+ }
+ opts = slices.Concat(r.Options, opts)
+ opts = append([]option.RequestOption{option.WithHeader("anthropic-beta", "managed-agents-2026-04-01"), option.WithResponseInto(&raw)}, opts...)
+ if sessionID == "" {
+ err = errors.New("missing required session_id parameter")
+ return nil, err
+ }
+ path := fmt.Sprintf("v1/sessions/%s/resources?beta=true", sessionID)
+ cfg, err := requestconfig.NewRequestConfig(ctx, http.MethodGet, path, params, &res, opts...)
+ if err != nil {
+ return nil, err
+ }
+ err = cfg.Execute()
+ if err != nil {
+ return nil, err
+ }
+ res.SetPageConfig(cfg, raw)
+ return res, nil
+}
+
+// List Session Resources
+func (r *BetaSessionResourceService) ListAutoPaging(ctx context.Context, sessionID string, params BetaSessionResourceListParams, opts ...option.RequestOption) *pagination.PageCursorAutoPager[BetaManagedAgentsSessionResourceUnion] {
+ return pagination.NewPageCursorAutoPager(r.List(ctx, sessionID, params, opts...))
+}
+
+// Delete Session Resource
+func (r *BetaSessionResourceService) Delete(ctx context.Context, resourceID string, params BetaSessionResourceDeleteParams, opts ...option.RequestOption) (res *BetaManagedAgentsDeleteSessionResource, err error) {
+ for _, v := range params.Betas {
+ opts = append(opts, option.WithHeaderAdd("anthropic-beta", fmt.Sprintf("%v", v)))
+ }
+ opts = slices.Concat(r.Options, opts)
+ opts = append([]option.RequestOption{option.WithHeader("anthropic-beta", "managed-agents-2026-04-01")}, opts...)
+ if params.SessionID == "" {
+ err = errors.New("missing required session_id parameter")
+ return nil, err
+ }
+ if resourceID == "" {
+ err = errors.New("missing required resource_id parameter")
+ return nil, err
+ }
+ path := fmt.Sprintf("v1/sessions/%s/resources/%s?beta=true", params.SessionID, resourceID)
+ err = requestconfig.ExecuteNewRequest(ctx, http.MethodDelete, path, nil, &res, opts...)
+ return res, err
+}
+
+// Add Session Resource
+func (r *BetaSessionResourceService) Add(ctx context.Context, sessionID string, params BetaSessionResourceAddParams, opts ...option.RequestOption) (res *BetaManagedAgentsFileResource, err error) {
+ for _, v := range params.Betas {
+ opts = append(opts, option.WithHeaderAdd("anthropic-beta", fmt.Sprintf("%v", v)))
+ }
+ opts = slices.Concat(r.Options, opts)
+ opts = append([]option.RequestOption{option.WithHeader("anthropic-beta", "managed-agents-2026-04-01")}, opts...)
+ if sessionID == "" {
+ err = errors.New("missing required session_id parameter")
+ return nil, err
+ }
+ path := fmt.Sprintf("v1/sessions/%s/resources?beta=true", sessionID)
+ err = requestconfig.ExecuteNewRequest(ctx, http.MethodPost, path, params, &res, opts...)
+ return res, err
+}
+
+// Confirmation of resource deletion.
+type BetaManagedAgentsDeleteSessionResource struct {
+ ID string `json:"id" api:"required"`
+ // Any of "session_resource_deleted".
+ Type BetaManagedAgentsDeleteSessionResourceType `json:"type" api:"required"`
+ // JSON contains metadata for fields, check presence with [respjson.Field.Valid].
+ JSON struct {
+ ID respjson.Field
+ Type respjson.Field
+ ExtraFields map[string]respjson.Field
+ raw string
+ } `json:"-"`
+}
+
+// Returns the unmodified JSON received from the API
+func (r BetaManagedAgentsDeleteSessionResource) RawJSON() string { return r.JSON.raw }
+func (r *BetaManagedAgentsDeleteSessionResource) UnmarshalJSON(data []byte) error {
+ return apijson.UnmarshalRoot(data, r)
+}
+
+type BetaManagedAgentsDeleteSessionResourceType string
+
+const (
+ BetaManagedAgentsDeleteSessionResourceTypeSessionResourceDeleted BetaManagedAgentsDeleteSessionResourceType = "session_resource_deleted"
+)
+
+type BetaManagedAgentsFileResource struct {
+ ID string `json:"id" api:"required"`
+ // A timestamp in RFC 3339 format
+ CreatedAt time.Time `json:"created_at" api:"required" format:"date-time"`
+ FileID string `json:"file_id" api:"required"`
+ MountPath string `json:"mount_path" api:"required"`
+ // Any of "file".
+ Type BetaManagedAgentsFileResourceType `json:"type" api:"required"`
+ // A timestamp in RFC 3339 format
+ UpdatedAt time.Time `json:"updated_at" api:"required" format:"date-time"`
+ // JSON contains metadata for fields, check presence with [respjson.Field.Valid].
+ JSON struct {
+ ID respjson.Field
+ CreatedAt respjson.Field
+ FileID respjson.Field
+ MountPath respjson.Field
+ Type respjson.Field
+ UpdatedAt respjson.Field
+ ExtraFields map[string]respjson.Field
+ raw string
+ } `json:"-"`
+}
+
+// Returns the unmodified JSON received from the API
+func (r BetaManagedAgentsFileResource) RawJSON() string { return r.JSON.raw }
+func (r *BetaManagedAgentsFileResource) UnmarshalJSON(data []byte) error {
+ return apijson.UnmarshalRoot(data, r)
+}
+
+type BetaManagedAgentsFileResourceType string
+
+const (
+ BetaManagedAgentsFileResourceTypeFile BetaManagedAgentsFileResourceType = "file"
+)
+
+type BetaManagedAgentsGitHubRepositoryResource struct {
+ ID string `json:"id" api:"required"`
+ // A timestamp in RFC 3339 format
+ CreatedAt time.Time `json:"created_at" api:"required" format:"date-time"`
+ MountPath string `json:"mount_path" api:"required"`
+ // Any of "github_repository".
+ Type BetaManagedAgentsGitHubRepositoryResourceType `json:"type" api:"required"`
+ // A timestamp in RFC 3339 format
+ UpdatedAt time.Time `json:"updated_at" api:"required" format:"date-time"`
+ URL string `json:"url" api:"required"`
+ Checkout BetaManagedAgentsGitHubRepositoryResourceCheckoutUnion `json:"checkout" api:"nullable"`
+ // JSON contains metadata for fields, check presence with [respjson.Field.Valid].
+ JSON struct {
+ ID respjson.Field
+ CreatedAt respjson.Field
+ MountPath respjson.Field
+ Type respjson.Field
+ UpdatedAt respjson.Field
+ URL respjson.Field
+ Checkout respjson.Field
+ ExtraFields map[string]respjson.Field
+ raw string
+ } `json:"-"`
+}
+
+// Returns the unmodified JSON received from the API
+func (r BetaManagedAgentsGitHubRepositoryResource) RawJSON() string { return r.JSON.raw }
+func (r *BetaManagedAgentsGitHubRepositoryResource) UnmarshalJSON(data []byte) error {
+ return apijson.UnmarshalRoot(data, r)
+}
+
+type BetaManagedAgentsGitHubRepositoryResourceType string
+
+const (
+ BetaManagedAgentsGitHubRepositoryResourceTypeGitHubRepository BetaManagedAgentsGitHubRepositoryResourceType = "github_repository"
+)
+
+// BetaManagedAgentsGitHubRepositoryResourceCheckoutUnion contains all possible
+// properties and values from [BetaManagedAgentsBranchCheckout],
+// [BetaManagedAgentsCommitCheckout].
+//
+// Use the [BetaManagedAgentsGitHubRepositoryResourceCheckoutUnion.AsAny] method to
+// switch on the variant.
+//
+// Use the methods beginning with 'As' to cast the union to one of its variants.
+type BetaManagedAgentsGitHubRepositoryResourceCheckoutUnion struct {
+ // This field is from variant [BetaManagedAgentsBranchCheckout].
+ Name string `json:"name"`
+ // Any of "branch", "commit".
+ Type string `json:"type"`
+ // This field is from variant [BetaManagedAgentsCommitCheckout].
+ Sha string `json:"sha"`
+ JSON struct {
+ Name respjson.Field
+ Type respjson.Field
+ Sha respjson.Field
+ raw string
+ } `json:"-"`
+}
+
+// anyBetaManagedAgentsGitHubRepositoryResourceCheckout is implemented by each
+// variant of [BetaManagedAgentsGitHubRepositoryResourceCheckoutUnion] to add type
+// safety for the return type of
+// [BetaManagedAgentsGitHubRepositoryResourceCheckoutUnion.AsAny]
+type anyBetaManagedAgentsGitHubRepositoryResourceCheckout interface {
+ implBetaManagedAgentsGitHubRepositoryResourceCheckoutUnion()
+}
+
+func (BetaManagedAgentsBranchCheckout) implBetaManagedAgentsGitHubRepositoryResourceCheckoutUnion() {}
+func (BetaManagedAgentsCommitCheckout) implBetaManagedAgentsGitHubRepositoryResourceCheckoutUnion() {}
+
+// Use the following switch statement to find the correct variant
+//
+// switch variant := BetaManagedAgentsGitHubRepositoryResourceCheckoutUnion.AsAny().(type) {
+// case anthropic.BetaManagedAgentsBranchCheckout:
+// case anthropic.BetaManagedAgentsCommitCheckout:
+// default:
+// fmt.Errorf("no variant present")
+// }
+func (u BetaManagedAgentsGitHubRepositoryResourceCheckoutUnion) AsAny() anyBetaManagedAgentsGitHubRepositoryResourceCheckout {
+ switch u.Type {
+ case "branch":
+ return u.AsBranch()
+ case "commit":
+ return u.AsCommit()
+ }
+ return nil
+}
+
+func (u BetaManagedAgentsGitHubRepositoryResourceCheckoutUnion) AsBranch() (v BetaManagedAgentsBranchCheckout) {
+ apijson.UnmarshalRoot(json.RawMessage(u.JSON.raw), &v)
+ return
+}
+
+func (u BetaManagedAgentsGitHubRepositoryResourceCheckoutUnion) AsCommit() (v BetaManagedAgentsCommitCheckout) {
+ apijson.UnmarshalRoot(json.RawMessage(u.JSON.raw), &v)
+ return
+}
+
+// Returns the unmodified JSON received from the API
+func (u BetaManagedAgentsGitHubRepositoryResourceCheckoutUnion) RawJSON() string { return u.JSON.raw }
+
+func (r *BetaManagedAgentsGitHubRepositoryResourceCheckoutUnion) UnmarshalJSON(data []byte) error {
+ return apijson.UnmarshalRoot(data, r)
+}
+
+// BetaManagedAgentsSessionResourceUnion contains all possible properties and
+// values from [BetaManagedAgentsGitHubRepositoryResource],
+// [BetaManagedAgentsFileResource].
+//
+// Use the [BetaManagedAgentsSessionResourceUnion.AsAny] method to switch on the
+// variant.
+//
+// Use the methods beginning with 'As' to cast the union to one of its variants.
+type BetaManagedAgentsSessionResourceUnion struct {
+ ID string `json:"id"`
+ CreatedAt time.Time `json:"created_at"`
+ MountPath string `json:"mount_path"`
+ // Any of "github_repository", "file".
+ Type string `json:"type"`
+ UpdatedAt time.Time `json:"updated_at"`
+ // This field is from variant [BetaManagedAgentsGitHubRepositoryResource].
+ URL string `json:"url"`
+ // This field is from variant [BetaManagedAgentsGitHubRepositoryResource].
+ Checkout BetaManagedAgentsGitHubRepositoryResourceCheckoutUnion `json:"checkout"`
+ // This field is from variant [BetaManagedAgentsFileResource].
+ FileID string `json:"file_id"`
+ JSON struct {
+ ID respjson.Field
+ CreatedAt respjson.Field
+ MountPath respjson.Field
+ Type respjson.Field
+ UpdatedAt respjson.Field
+ URL respjson.Field
+ Checkout respjson.Field
+ FileID respjson.Field
+ raw string
+ } `json:"-"`
+}
+
+// anyBetaManagedAgentsSessionResource is implemented by each variant of
+// [BetaManagedAgentsSessionResourceUnion] to add type safety for the return type
+// of [BetaManagedAgentsSessionResourceUnion.AsAny]
+type anyBetaManagedAgentsSessionResource interface {
+ implBetaManagedAgentsSessionResourceUnion()
+}
+
+func (BetaManagedAgentsGitHubRepositoryResource) implBetaManagedAgentsSessionResourceUnion() {}
+func (BetaManagedAgentsFileResource) implBetaManagedAgentsSessionResourceUnion() {}
+
+// Use the following switch statement to find the correct variant
+//
+// switch variant := BetaManagedAgentsSessionResourceUnion.AsAny().(type) {
+// case anthropic.BetaManagedAgentsGitHubRepositoryResource:
+// case anthropic.BetaManagedAgentsFileResource:
+// default:
+// fmt.Errorf("no variant present")
+// }
+func (u BetaManagedAgentsSessionResourceUnion) AsAny() anyBetaManagedAgentsSessionResource {
+ switch u.Type {
+ case "github_repository":
+ return u.AsGitHubRepository()
+ case "file":
+ return u.AsFile()
+ }
+ return nil
+}
+
+func (u BetaManagedAgentsSessionResourceUnion) AsGitHubRepository() (v BetaManagedAgentsGitHubRepositoryResource) {
+ apijson.UnmarshalRoot(json.RawMessage(u.JSON.raw), &v)
+ return
+}
+
+func (u BetaManagedAgentsSessionResourceUnion) AsFile() (v BetaManagedAgentsFileResource) {
+ apijson.UnmarshalRoot(json.RawMessage(u.JSON.raw), &v)
+ return
+}
+
+// Returns the unmodified JSON received from the API
+func (u BetaManagedAgentsSessionResourceUnion) RawJSON() string { return u.JSON.raw }
+
+func (r *BetaManagedAgentsSessionResourceUnion) UnmarshalJSON(data []byte) error {
+ return apijson.UnmarshalRoot(data, r)
+}
+
+// BetaSessionResourceGetResponseUnion contains all possible properties and values
+// from [BetaManagedAgentsGitHubRepositoryResource],
+// [BetaManagedAgentsFileResource].
+//
+// Use the [BetaSessionResourceGetResponseUnion.AsAny] method to switch on the
+// variant.
+//
+// Use the methods beginning with 'As' to cast the union to one of its variants.
+type BetaSessionResourceGetResponseUnion struct {
+ ID string `json:"id"`
+ CreatedAt time.Time `json:"created_at"`
+ MountPath string `json:"mount_path"`
+ // Any of "github_repository", "file".
+ Type string `json:"type"`
+ UpdatedAt time.Time `json:"updated_at"`
+ // This field is from variant [BetaManagedAgentsGitHubRepositoryResource].
+ URL string `json:"url"`
+ // This field is from variant [BetaManagedAgentsGitHubRepositoryResource].
+ Checkout BetaManagedAgentsGitHubRepositoryResourceCheckoutUnion `json:"checkout"`
+ // This field is from variant [BetaManagedAgentsFileResource].
+ FileID string `json:"file_id"`
+ JSON struct {
+ ID respjson.Field
+ CreatedAt respjson.Field
+ MountPath respjson.Field
+ Type respjson.Field
+ UpdatedAt respjson.Field
+ URL respjson.Field
+ Checkout respjson.Field
+ FileID respjson.Field
+ raw string
+ } `json:"-"`
+}
+
+// anyBetaSessionResourceGetResponse is implemented by each variant of
+// [BetaSessionResourceGetResponseUnion] to add type safety for the return type of
+// [BetaSessionResourceGetResponseUnion.AsAny]
+type anyBetaSessionResourceGetResponse interface {
+ implBetaSessionResourceGetResponseUnion()
+}
+
+func (BetaManagedAgentsGitHubRepositoryResource) implBetaSessionResourceGetResponseUnion() {}
+func (BetaManagedAgentsFileResource) implBetaSessionResourceGetResponseUnion() {}
+
+// Use the following switch statement to find the correct variant
+//
+// switch variant := BetaSessionResourceGetResponseUnion.AsAny().(type) {
+// case anthropic.BetaManagedAgentsGitHubRepositoryResource:
+// case anthropic.BetaManagedAgentsFileResource:
+// default:
+// fmt.Errorf("no variant present")
+// }
+func (u BetaSessionResourceGetResponseUnion) AsAny() anyBetaSessionResourceGetResponse {
+ switch u.Type {
+ case "github_repository":
+ return u.AsGitHubRepository()
+ case "file":
+ return u.AsFile()
+ }
+ return nil
+}
+
+func (u BetaSessionResourceGetResponseUnion) AsGitHubRepository() (v BetaManagedAgentsGitHubRepositoryResource) {
+ apijson.UnmarshalRoot(json.RawMessage(u.JSON.raw), &v)
+ return
+}
+
+func (u BetaSessionResourceGetResponseUnion) AsFile() (v BetaManagedAgentsFileResource) {
+ apijson.UnmarshalRoot(json.RawMessage(u.JSON.raw), &v)
+ return
+}
+
+// Returns the unmodified JSON received from the API
+func (u BetaSessionResourceGetResponseUnion) RawJSON() string { return u.JSON.raw }
+
+func (r *BetaSessionResourceGetResponseUnion) UnmarshalJSON(data []byte) error {
+ return apijson.UnmarshalRoot(data, r)
+}
+
+// BetaSessionResourceUpdateResponseUnion contains all possible properties and
+// values from [BetaManagedAgentsGitHubRepositoryResource],
+// [BetaManagedAgentsFileResource].
+//
+// Use the [BetaSessionResourceUpdateResponseUnion.AsAny] method to switch on the
+// variant.
+//
+// Use the methods beginning with 'As' to cast the union to one of its variants.
+type BetaSessionResourceUpdateResponseUnion struct {
+ ID string `json:"id"`
+ CreatedAt time.Time `json:"created_at"`
+ MountPath string `json:"mount_path"`
+ // Any of "github_repository", "file".
+ Type string `json:"type"`
+ UpdatedAt time.Time `json:"updated_at"`
+ // This field is from variant [BetaManagedAgentsGitHubRepositoryResource].
+ URL string `json:"url"`
+ // This field is from variant [BetaManagedAgentsGitHubRepositoryResource].
+ Checkout BetaManagedAgentsGitHubRepositoryResourceCheckoutUnion `json:"checkout"`
+ // This field is from variant [BetaManagedAgentsFileResource].
+ FileID string `json:"file_id"`
+ JSON struct {
+ ID respjson.Field
+ CreatedAt respjson.Field
+ MountPath respjson.Field
+ Type respjson.Field
+ UpdatedAt respjson.Field
+ URL respjson.Field
+ Checkout respjson.Field
+ FileID respjson.Field
+ raw string
+ } `json:"-"`
+}
+
+// anyBetaSessionResourceUpdateResponse is implemented by each variant of
+// [BetaSessionResourceUpdateResponseUnion] to add type safety for the return type
+// of [BetaSessionResourceUpdateResponseUnion.AsAny]
+type anyBetaSessionResourceUpdateResponse interface {
+ implBetaSessionResourceUpdateResponseUnion()
+}
+
+func (BetaManagedAgentsGitHubRepositoryResource) implBetaSessionResourceUpdateResponseUnion() {}
+func (BetaManagedAgentsFileResource) implBetaSessionResourceUpdateResponseUnion() {}
+
+// Use the following switch statement to find the correct variant
+//
+// switch variant := BetaSessionResourceUpdateResponseUnion.AsAny().(type) {
+// case anthropic.BetaManagedAgentsGitHubRepositoryResource:
+// case anthropic.BetaManagedAgentsFileResource:
+// default:
+// fmt.Errorf("no variant present")
+// }
+func (u BetaSessionResourceUpdateResponseUnion) AsAny() anyBetaSessionResourceUpdateResponse {
+ switch u.Type {
+ case "github_repository":
+ return u.AsGitHubRepository()
+ case "file":
+ return u.AsFile()
+ }
+ return nil
+}
+
+func (u BetaSessionResourceUpdateResponseUnion) AsGitHubRepository() (v BetaManagedAgentsGitHubRepositoryResource) {
+ apijson.UnmarshalRoot(json.RawMessage(u.JSON.raw), &v)
+ return
+}
+
+func (u BetaSessionResourceUpdateResponseUnion) AsFile() (v BetaManagedAgentsFileResource) {
+ apijson.UnmarshalRoot(json.RawMessage(u.JSON.raw), &v)
+ return
+}
+
+// Returns the unmodified JSON received from the API
+func (u BetaSessionResourceUpdateResponseUnion) RawJSON() string { return u.JSON.raw }
+
+func (r *BetaSessionResourceUpdateResponseUnion) UnmarshalJSON(data []byte) error {
+ return apijson.UnmarshalRoot(data, r)
+}
+
+type BetaSessionResourceGetParams struct {
+ SessionID string `path:"session_id" api:"required" json:"-"`
+ // Optional header to specify the beta version(s) you want to use.
+ Betas []AnthropicBeta `header:"anthropic-beta,omitzero" json:"-"`
+ paramObj
+}
+
+type BetaSessionResourceUpdateParams struct {
+ SessionID string `path:"session_id" api:"required" json:"-"`
+ // New authorization token for the resource. Currently only `github_repository`
+ // resources support token rotation.
+ AuthorizationToken string `json:"authorization_token" api:"required"`
+ // Optional header to specify the beta version(s) you want to use.
+ Betas []AnthropicBeta `header:"anthropic-beta,omitzero" json:"-"`
+ paramObj
+}
+
+func (r BetaSessionResourceUpdateParams) MarshalJSON() (data []byte, err error) {
+ type shadow BetaSessionResourceUpdateParams
+ return param.MarshalObject(r, (*shadow)(&r))
+}
+func (r *BetaSessionResourceUpdateParams) UnmarshalJSON(data []byte) error {
+ return apijson.UnmarshalRoot(data, r)
+}
+
+type BetaSessionResourceListParams struct {
+ // Maximum number of resources to return per page (max 1000). If omitted, returns
+ // all resources.
+ Limit param.Opt[int64] `query:"limit,omitzero" json:"-"`
+ // Opaque cursor from a previous response's next_page field.
+ Page param.Opt[string] `query:"page,omitzero" json:"-"`
+ // Optional header to specify the beta version(s) you want to use.
+ Betas []AnthropicBeta `header:"anthropic-beta,omitzero" json:"-"`
+ paramObj
+}
+
+// URLQuery serializes [BetaSessionResourceListParams]'s query parameters as
+// `url.Values`.
+func (r BetaSessionResourceListParams) URLQuery() (v url.Values, err error) {
+ return apiquery.MarshalWithSettings(r, apiquery.QuerySettings{
+ ArrayFormat: apiquery.ArrayQueryFormatComma,
+ NestedFormat: apiquery.NestedQueryFormatBrackets,
+ })
+}
+
+type BetaSessionResourceDeleteParams struct {
+ SessionID string `path:"session_id" api:"required" json:"-"`
+ // Optional header to specify the beta version(s) you want to use.
+ Betas []AnthropicBeta `header:"anthropic-beta,omitzero" json:"-"`
+ paramObj
+}
+
+type BetaSessionResourceAddParams struct {
+ // Mount a file uploaded via the Files API into the session.
+ BetaManagedAgentsFileResourceParams BetaManagedAgentsFileResourceParams
+ // Optional header to specify the beta version(s) you want to use.
+ Betas []AnthropicBeta `header:"anthropic-beta,omitzero" json:"-"`
+ paramObj
+}
+
+func (r BetaSessionResourceAddParams) MarshalJSON() (data []byte, err error) {
+ return shimjson.Marshal(r.BetaManagedAgentsFileResourceParams)
+}
+func (r *BetaSessionResourceAddParams) UnmarshalJSON(data []byte) error {
+ return apijson.UnmarshalRoot(data, r)
+}
diff --git a/betasessionresource_test.go b/betasessionresource_test.go
new file mode 100644
index 000000000..a63ea3abf
--- /dev/null
+++ b/betasessionresource_test.go
@@ -0,0 +1,170 @@
+// File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+package anthropic_test
+
+import (
+ "context"
+ "errors"
+ "os"
+ "testing"
+
+ "github.com/anthropics/anthropic-sdk-go"
+ "github.com/anthropics/anthropic-sdk-go/internal/testutil"
+ "github.com/anthropics/anthropic-sdk-go/option"
+)
+
+func TestBetaSessionResourceGetWithOptionalParams(t *testing.T) {
+ t.Skip("prism can't find endpoint with beta only tag")
+ baseURL := "http://localhost:4010"
+ if envURL, ok := os.LookupEnv("TEST_API_BASE_URL"); ok {
+ baseURL = envURL
+ }
+ if !testutil.CheckTestServer(t, baseURL) {
+ return
+ }
+ client := anthropic.NewClient(
+ option.WithBaseURL(baseURL),
+ option.WithAPIKey("my-anthropic-api-key"),
+ )
+ _, err := client.Beta.Sessions.Resources.Get(
+ context.TODO(),
+ "sesrsc_011CZkZBJq5dWxk9fVLNcPht",
+ anthropic.BetaSessionResourceGetParams{
+ SessionID: "sesn_011CZkZAtmR3yMPDzynEDxu7",
+ Betas: []anthropic.AnthropicBeta{anthropic.AnthropicBetaMessageBatches2024_09_24},
+ },
+ )
+ if err != nil {
+ var apierr *anthropic.Error
+ if errors.As(err, &apierr) {
+ t.Log(string(apierr.DumpRequest(true)))
+ }
+ t.Fatalf("err should be nil: %s", err.Error())
+ }
+}
+
+func TestBetaSessionResourceUpdateWithOptionalParams(t *testing.T) {
+ t.Skip("prism can't find endpoint with beta only tag")
+ baseURL := "http://localhost:4010"
+ if envURL, ok := os.LookupEnv("TEST_API_BASE_URL"); ok {
+ baseURL = envURL
+ }
+ if !testutil.CheckTestServer(t, baseURL) {
+ return
+ }
+ client := anthropic.NewClient(
+ option.WithBaseURL(baseURL),
+ option.WithAPIKey("my-anthropic-api-key"),
+ )
+ _, err := client.Beta.Sessions.Resources.Update(
+ context.TODO(),
+ "sesrsc_011CZkZBJq5dWxk9fVLNcPht",
+ anthropic.BetaSessionResourceUpdateParams{
+ SessionID: "sesn_011CZkZAtmR3yMPDzynEDxu7",
+ AuthorizationToken: "ghp_exampletoken",
+ Betas: []anthropic.AnthropicBeta{anthropic.AnthropicBetaMessageBatches2024_09_24},
+ },
+ )
+ if err != nil {
+ var apierr *anthropic.Error
+ if errors.As(err, &apierr) {
+ t.Log(string(apierr.DumpRequest(true)))
+ }
+ t.Fatalf("err should be nil: %s", err.Error())
+ }
+}
+
+func TestBetaSessionResourceListWithOptionalParams(t *testing.T) {
+ t.Skip("prism can't find endpoint with beta only tag")
+ baseURL := "http://localhost:4010"
+ if envURL, ok := os.LookupEnv("TEST_API_BASE_URL"); ok {
+ baseURL = envURL
+ }
+ if !testutil.CheckTestServer(t, baseURL) {
+ return
+ }
+ client := anthropic.NewClient(
+ option.WithBaseURL(baseURL),
+ option.WithAPIKey("my-anthropic-api-key"),
+ )
+ _, err := client.Beta.Sessions.Resources.List(
+ context.TODO(),
+ "sesn_011CZkZAtmR3yMPDzynEDxu7",
+ anthropic.BetaSessionResourceListParams{
+ Limit: anthropic.Int(0),
+ Page: anthropic.String("page"),
+ Betas: []anthropic.AnthropicBeta{anthropic.AnthropicBetaMessageBatches2024_09_24},
+ },
+ )
+ if err != nil {
+ var apierr *anthropic.Error
+ if errors.As(err, &apierr) {
+ t.Log(string(apierr.DumpRequest(true)))
+ }
+ t.Fatalf("err should be nil: %s", err.Error())
+ }
+}
+
+func TestBetaSessionResourceDeleteWithOptionalParams(t *testing.T) {
+ t.Skip("prism can't find endpoint with beta only tag")
+ baseURL := "http://localhost:4010"
+ if envURL, ok := os.LookupEnv("TEST_API_BASE_URL"); ok {
+ baseURL = envURL
+ }
+ if !testutil.CheckTestServer(t, baseURL) {
+ return
+ }
+ client := anthropic.NewClient(
+ option.WithBaseURL(baseURL),
+ option.WithAPIKey("my-anthropic-api-key"),
+ )
+ _, err := client.Beta.Sessions.Resources.Delete(
+ context.TODO(),
+ "sesrsc_011CZkZBJq5dWxk9fVLNcPht",
+ anthropic.BetaSessionResourceDeleteParams{
+ SessionID: "sesn_011CZkZAtmR3yMPDzynEDxu7",
+ Betas: []anthropic.AnthropicBeta{anthropic.AnthropicBetaMessageBatches2024_09_24},
+ },
+ )
+ if err != nil {
+ var apierr *anthropic.Error
+ if errors.As(err, &apierr) {
+ t.Log(string(apierr.DumpRequest(true)))
+ }
+ t.Fatalf("err should be nil: %s", err.Error())
+ }
+}
+
+func TestBetaSessionResourceAddWithOptionalParams(t *testing.T) {
+ t.Skip("prism can't find endpoint with beta only tag")
+ baseURL := "http://localhost:4010"
+ if envURL, ok := os.LookupEnv("TEST_API_BASE_URL"); ok {
+ baseURL = envURL
+ }
+ if !testutil.CheckTestServer(t, baseURL) {
+ return
+ }
+ client := anthropic.NewClient(
+ option.WithBaseURL(baseURL),
+ option.WithAPIKey("my-anthropic-api-key"),
+ )
+ _, err := client.Beta.Sessions.Resources.Add(
+ context.TODO(),
+ "sesn_011CZkZAtmR3yMPDzynEDxu7",
+ anthropic.BetaSessionResourceAddParams{
+ BetaManagedAgentsFileResourceParams: anthropic.BetaManagedAgentsFileResourceParams{
+ FileID: "file_011CNha8iCJcU1wXNR6q4V8w",
+ Type: anthropic.BetaManagedAgentsFileResourceParamsTypeFile,
+ MountPath: anthropic.String("/uploads/receipt.pdf"),
+ },
+ Betas: []anthropic.AnthropicBeta{anthropic.AnthropicBetaMessageBatches2024_09_24},
+ },
+ )
+ if err != nil {
+ var apierr *anthropic.Error
+ if errors.As(err, &apierr) {
+ t.Log(string(apierr.DumpRequest(true)))
+ }
+ t.Fatalf("err should be nil: %s", err.Error())
+ }
+}
diff --git a/betavault.go b/betavault.go
new file mode 100644
index 000000000..f6f02d2e3
--- /dev/null
+++ b/betavault.go
@@ -0,0 +1,289 @@
+// File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+package anthropic
+
+import (
+ "context"
+ "errors"
+ "fmt"
+ "net/http"
+ "net/url"
+ "slices"
+ "time"
+
+ "github.com/anthropics/anthropic-sdk-go/internal/apijson"
+ "github.com/anthropics/anthropic-sdk-go/internal/apiquery"
+ "github.com/anthropics/anthropic-sdk-go/internal/requestconfig"
+ "github.com/anthropics/anthropic-sdk-go/option"
+ "github.com/anthropics/anthropic-sdk-go/packages/pagination"
+ "github.com/anthropics/anthropic-sdk-go/packages/param"
+ "github.com/anthropics/anthropic-sdk-go/packages/respjson"
+)
+
+// BetaVaultService contains methods and other services that help with interacting
+// with the anthropic API.
+//
+// Note, unlike clients, this service does not read variables from the environment
+// automatically. You should not instantiate this service directly, and instead use
+// the [NewBetaVaultService] method instead.
+type BetaVaultService struct {
+ Options []option.RequestOption
+ Credentials BetaVaultCredentialService
+}
+
+// NewBetaVaultService generates a new service that applies the given options to
+// each request. These options are applied after the parent client's options (if
+// there is one), and before any request-specific options.
+func NewBetaVaultService(opts ...option.RequestOption) (r BetaVaultService) {
+ r = BetaVaultService{}
+ r.Options = opts
+ r.Credentials = NewBetaVaultCredentialService(opts...)
+ return
+}
+
+// Create Vault
+func (r *BetaVaultService) New(ctx context.Context, params BetaVaultNewParams, opts ...option.RequestOption) (res *BetaManagedAgentsVault, err error) {
+ for _, v := range params.Betas {
+ opts = append(opts, option.WithHeaderAdd("anthropic-beta", fmt.Sprintf("%v", v)))
+ }
+ opts = slices.Concat(r.Options, opts)
+ opts = append([]option.RequestOption{option.WithHeader("anthropic-beta", "managed-agents-2026-04-01")}, opts...)
+ path := "v1/vaults?beta=true"
+ err = requestconfig.ExecuteNewRequest(ctx, http.MethodPost, path, params, &res, opts...)
+ return res, err
+}
+
+// Get Vault
+func (r *BetaVaultService) Get(ctx context.Context, vaultID string, query BetaVaultGetParams, opts ...option.RequestOption) (res *BetaManagedAgentsVault, err error) {
+ for _, v := range query.Betas {
+ opts = append(opts, option.WithHeaderAdd("anthropic-beta", fmt.Sprintf("%v", v)))
+ }
+ opts = slices.Concat(r.Options, opts)
+ opts = append([]option.RequestOption{option.WithHeader("anthropic-beta", "managed-agents-2026-04-01")}, opts...)
+ if vaultID == "" {
+ err = errors.New("missing required vault_id parameter")
+ return nil, err
+ }
+ path := fmt.Sprintf("v1/vaults/%s?beta=true", vaultID)
+ err = requestconfig.ExecuteNewRequest(ctx, http.MethodGet, path, nil, &res, opts...)
+ return res, err
+}
+
+// Update Vault
+func (r *BetaVaultService) Update(ctx context.Context, vaultID string, params BetaVaultUpdateParams, opts ...option.RequestOption) (res *BetaManagedAgentsVault, err error) {
+ for _, v := range params.Betas {
+ opts = append(opts, option.WithHeaderAdd("anthropic-beta", fmt.Sprintf("%v", v)))
+ }
+ opts = slices.Concat(r.Options, opts)
+ opts = append([]option.RequestOption{option.WithHeader("anthropic-beta", "managed-agents-2026-04-01")}, opts...)
+ if vaultID == "" {
+ err = errors.New("missing required vault_id parameter")
+ return nil, err
+ }
+ path := fmt.Sprintf("v1/vaults/%s?beta=true", vaultID)
+ err = requestconfig.ExecuteNewRequest(ctx, http.MethodPost, path, params, &res, opts...)
+ return res, err
+}
+
+// List Vaults
+func (r *BetaVaultService) List(ctx context.Context, params BetaVaultListParams, opts ...option.RequestOption) (res *pagination.PageCursor[BetaManagedAgentsVault], err error) {
+ var raw *http.Response
+ for _, v := range params.Betas {
+ opts = append(opts, option.WithHeaderAdd("anthropic-beta", fmt.Sprintf("%v", v)))
+ }
+ opts = slices.Concat(r.Options, opts)
+ opts = append([]option.RequestOption{option.WithHeader("anthropic-beta", "managed-agents-2026-04-01"), option.WithResponseInto(&raw)}, opts...)
+ path := "v1/vaults?beta=true"
+ cfg, err := requestconfig.NewRequestConfig(ctx, http.MethodGet, path, params, &res, opts...)
+ if err != nil {
+ return nil, err
+ }
+ err = cfg.Execute()
+ if err != nil {
+ return nil, err
+ }
+ res.SetPageConfig(cfg, raw)
+ return res, nil
+}
+
+// List Vaults
+func (r *BetaVaultService) ListAutoPaging(ctx context.Context, params BetaVaultListParams, opts ...option.RequestOption) *pagination.PageCursorAutoPager[BetaManagedAgentsVault] {
+ return pagination.NewPageCursorAutoPager(r.List(ctx, params, opts...))
+}
+
+// Delete Vault
+func (r *BetaVaultService) Delete(ctx context.Context, vaultID string, body BetaVaultDeleteParams, opts ...option.RequestOption) (res *BetaManagedAgentsDeletedVault, err error) {
+ for _, v := range body.Betas {
+ opts = append(opts, option.WithHeaderAdd("anthropic-beta", fmt.Sprintf("%v", v)))
+ }
+ opts = slices.Concat(r.Options, opts)
+ opts = append([]option.RequestOption{option.WithHeader("anthropic-beta", "managed-agents-2026-04-01")}, opts...)
+ if vaultID == "" {
+ err = errors.New("missing required vault_id parameter")
+ return nil, err
+ }
+ path := fmt.Sprintf("v1/vaults/%s?beta=true", vaultID)
+ err = requestconfig.ExecuteNewRequest(ctx, http.MethodDelete, path, nil, &res, opts...)
+ return res, err
+}
+
+// Archive Vault
+func (r *BetaVaultService) Archive(ctx context.Context, vaultID string, body BetaVaultArchiveParams, opts ...option.RequestOption) (res *BetaManagedAgentsVault, err error) {
+ for _, v := range body.Betas {
+ opts = append(opts, option.WithHeaderAdd("anthropic-beta", fmt.Sprintf("%v", v)))
+ }
+ opts = slices.Concat(r.Options, opts)
+ opts = append([]option.RequestOption{option.WithHeader("anthropic-beta", "managed-agents-2026-04-01")}, opts...)
+ if vaultID == "" {
+ err = errors.New("missing required vault_id parameter")
+ return nil, err
+ }
+ path := fmt.Sprintf("v1/vaults/%s/archive?beta=true", vaultID)
+ err = requestconfig.ExecuteNewRequest(ctx, http.MethodPost, path, nil, &res, opts...)
+ return res, err
+}
+
+// Confirmation of a deleted vault.
+type BetaManagedAgentsDeletedVault struct {
+ // Unique identifier of the deleted vault.
+ ID string `json:"id" api:"required"`
+ // Any of "vault_deleted".
+ Type BetaManagedAgentsDeletedVaultType `json:"type" api:"required"`
+ // JSON contains metadata for fields, check presence with [respjson.Field.Valid].
+ JSON struct {
+ ID respjson.Field
+ Type respjson.Field
+ ExtraFields map[string]respjson.Field
+ raw string
+ } `json:"-"`
+}
+
+// Returns the unmodified JSON received from the API
+func (r BetaManagedAgentsDeletedVault) RawJSON() string { return r.JSON.raw }
+func (r *BetaManagedAgentsDeletedVault) UnmarshalJSON(data []byte) error {
+ return apijson.UnmarshalRoot(data, r)
+}
+
+type BetaManagedAgentsDeletedVaultType string
+
+const (
+ BetaManagedAgentsDeletedVaultTypeVaultDeleted BetaManagedAgentsDeletedVaultType = "vault_deleted"
+)
+
+// A vault that stores credentials for use by agents during sessions.
+type BetaManagedAgentsVault struct {
+ // Unique identifier for the vault.
+ ID string `json:"id" api:"required"`
+ // A timestamp in RFC 3339 format
+ ArchivedAt time.Time `json:"archived_at" api:"required" format:"date-time"`
+ // A timestamp in RFC 3339 format
+ CreatedAt time.Time `json:"created_at" api:"required" format:"date-time"`
+ // Human-readable name for the vault.
+ DisplayName string `json:"display_name" api:"required"`
+ // Arbitrary key-value metadata attached to the vault.
+ Metadata map[string]string `json:"metadata" api:"required"`
+ // Any of "vault".
+ Type BetaManagedAgentsVaultType `json:"type" api:"required"`
+ // A timestamp in RFC 3339 format
+ UpdatedAt time.Time `json:"updated_at" api:"required" format:"date-time"`
+ // JSON contains metadata for fields, check presence with [respjson.Field.Valid].
+ JSON struct {
+ ID respjson.Field
+ ArchivedAt respjson.Field
+ CreatedAt respjson.Field
+ DisplayName respjson.Field
+ Metadata respjson.Field
+ Type respjson.Field
+ UpdatedAt respjson.Field
+ ExtraFields map[string]respjson.Field
+ raw string
+ } `json:"-"`
+}
+
+// Returns the unmodified JSON received from the API
+func (r BetaManagedAgentsVault) RawJSON() string { return r.JSON.raw }
+func (r *BetaManagedAgentsVault) UnmarshalJSON(data []byte) error {
+ return apijson.UnmarshalRoot(data, r)
+}
+
+type BetaManagedAgentsVaultType string
+
+const (
+ BetaManagedAgentsVaultTypeVault BetaManagedAgentsVaultType = "vault"
+)
+
+type BetaVaultNewParams struct {
+ // Human-readable name for the vault. 1-255 characters.
+ DisplayName string `json:"display_name" api:"required"`
+ // Arbitrary key-value metadata to attach to the vault. Maximum 16 pairs, keys up
+ // to 64 chars, values up to 512 chars.
+ Metadata map[string]string `json:"metadata,omitzero"`
+ // Optional header to specify the beta version(s) you want to use.
+ Betas []AnthropicBeta `header:"anthropic-beta,omitzero" json:"-"`
+ paramObj
+}
+
+func (r BetaVaultNewParams) MarshalJSON() (data []byte, err error) {
+ type shadow BetaVaultNewParams
+ return param.MarshalObject(r, (*shadow)(&r))
+}
+func (r *BetaVaultNewParams) UnmarshalJSON(data []byte) error {
+ return apijson.UnmarshalRoot(data, r)
+}
+
+type BetaVaultGetParams struct {
+ // Optional header to specify the beta version(s) you want to use.
+ Betas []AnthropicBeta `header:"anthropic-beta,omitzero" json:"-"`
+ paramObj
+}
+
+type BetaVaultUpdateParams struct {
+ // Updated human-readable name for the vault. 1-255 characters.
+ DisplayName param.Opt[string] `json:"display_name,omitzero"`
+ // Metadata patch. Set a key to a string to upsert it, or to null to delete it.
+ // Omitted keys are preserved.
+ Metadata map[string]string `json:"metadata,omitzero"`
+ // Optional header to specify the beta version(s) you want to use.
+ Betas []AnthropicBeta `header:"anthropic-beta,omitzero" json:"-"`
+ paramObj
+}
+
+func (r BetaVaultUpdateParams) MarshalJSON() (data []byte, err error) {
+ type shadow BetaVaultUpdateParams
+ return param.MarshalObject(r, (*shadow)(&r))
+}
+func (r *BetaVaultUpdateParams) UnmarshalJSON(data []byte) error {
+ return apijson.UnmarshalRoot(data, r)
+}
+
+type BetaVaultListParams struct {
+ // Whether to include archived vaults in the results.
+ IncludeArchived param.Opt[bool] `query:"include_archived,omitzero" json:"-"`
+ // Maximum number of vaults to return per page. Defaults to 20, maximum 100.
+ Limit param.Opt[int64] `query:"limit,omitzero" json:"-"`
+ // Opaque pagination token from a previous `list_vaults` response.
+ Page param.Opt[string] `query:"page,omitzero" json:"-"`
+ // Optional header to specify the beta version(s) you want to use.
+ Betas []AnthropicBeta `header:"anthropic-beta,omitzero" json:"-"`
+ paramObj
+}
+
+// URLQuery serializes [BetaVaultListParams]'s query parameters as `url.Values`.
+func (r BetaVaultListParams) URLQuery() (v url.Values, err error) {
+ return apiquery.MarshalWithSettings(r, apiquery.QuerySettings{
+ ArrayFormat: apiquery.ArrayQueryFormatComma,
+ NestedFormat: apiquery.NestedQueryFormatBrackets,
+ })
+}
+
+type BetaVaultDeleteParams struct {
+ // Optional header to specify the beta version(s) you want to use.
+ Betas []AnthropicBeta `header:"anthropic-beta,omitzero" json:"-"`
+ paramObj
+}
+
+type BetaVaultArchiveParams struct {
+ // Optional header to specify the beta version(s) you want to use.
+ Betas []AnthropicBeta `header:"anthropic-beta,omitzero" json:"-"`
+ paramObj
+}
diff --git a/betavault_test.go b/betavault_test.go
new file mode 100644
index 000000000..83e27f5cb
--- /dev/null
+++ b/betavault_test.go
@@ -0,0 +1,186 @@
+// File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+package anthropic_test
+
+import (
+ "context"
+ "errors"
+ "os"
+ "testing"
+
+ "github.com/anthropics/anthropic-sdk-go"
+ "github.com/anthropics/anthropic-sdk-go/internal/testutil"
+ "github.com/anthropics/anthropic-sdk-go/option"
+)
+
+func TestBetaVaultNewWithOptionalParams(t *testing.T) {
+ baseURL := "http://localhost:4010"
+ if envURL, ok := os.LookupEnv("TEST_API_BASE_URL"); ok {
+ baseURL = envURL
+ }
+ if !testutil.CheckTestServer(t, baseURL) {
+ return
+ }
+ client := anthropic.NewClient(
+ option.WithBaseURL(baseURL),
+ option.WithAPIKey("my-anthropic-api-key"),
+ )
+ _, err := client.Beta.Vaults.New(context.TODO(), anthropic.BetaVaultNewParams{
+ DisplayName: "Example vault",
+ Metadata: map[string]string{
+ "environment": "production",
+ },
+ Betas: []anthropic.AnthropicBeta{anthropic.AnthropicBetaMessageBatches2024_09_24},
+ })
+ if err != nil {
+ var apierr *anthropic.Error
+ if errors.As(err, &apierr) {
+ t.Log(string(apierr.DumpRequest(true)))
+ }
+ t.Fatalf("err should be nil: %s", err.Error())
+ }
+}
+
+func TestBetaVaultGetWithOptionalParams(t *testing.T) {
+ baseURL := "http://localhost:4010"
+ if envURL, ok := os.LookupEnv("TEST_API_BASE_URL"); ok {
+ baseURL = envURL
+ }
+ if !testutil.CheckTestServer(t, baseURL) {
+ return
+ }
+ client := anthropic.NewClient(
+ option.WithBaseURL(baseURL),
+ option.WithAPIKey("my-anthropic-api-key"),
+ )
+ _, err := client.Beta.Vaults.Get(
+ context.TODO(),
+ "vlt_011CZkZDLs7fYzm1hXNPeRjv",
+ anthropic.BetaVaultGetParams{
+ Betas: []anthropic.AnthropicBeta{anthropic.AnthropicBetaMessageBatches2024_09_24},
+ },
+ )
+ if err != nil {
+ var apierr *anthropic.Error
+ if errors.As(err, &apierr) {
+ t.Log(string(apierr.DumpRequest(true)))
+ }
+ t.Fatalf("err should be nil: %s", err.Error())
+ }
+}
+
+func TestBetaVaultUpdateWithOptionalParams(t *testing.T) {
+ baseURL := "http://localhost:4010"
+ if envURL, ok := os.LookupEnv("TEST_API_BASE_URL"); ok {
+ baseURL = envURL
+ }
+ if !testutil.CheckTestServer(t, baseURL) {
+ return
+ }
+ client := anthropic.NewClient(
+ option.WithBaseURL(baseURL),
+ option.WithAPIKey("my-anthropic-api-key"),
+ )
+ _, err := client.Beta.Vaults.Update(
+ context.TODO(),
+ "vlt_011CZkZDLs7fYzm1hXNPeRjv",
+ anthropic.BetaVaultUpdateParams{
+ DisplayName: anthropic.String("Example vault"),
+ Metadata: map[string]string{
+ "environment": "production",
+ },
+ Betas: []anthropic.AnthropicBeta{anthropic.AnthropicBetaMessageBatches2024_09_24},
+ },
+ )
+ if err != nil {
+ var apierr *anthropic.Error
+ if errors.As(err, &apierr) {
+ t.Log(string(apierr.DumpRequest(true)))
+ }
+ t.Fatalf("err should be nil: %s", err.Error())
+ }
+}
+
+func TestBetaVaultListWithOptionalParams(t *testing.T) {
+ t.Skip("buildURL drops path-level query params (SDK-4349)")
+ baseURL := "http://localhost:4010"
+ if envURL, ok := os.LookupEnv("TEST_API_BASE_URL"); ok {
+ baseURL = envURL
+ }
+ if !testutil.CheckTestServer(t, baseURL) {
+ return
+ }
+ client := anthropic.NewClient(
+ option.WithBaseURL(baseURL),
+ option.WithAPIKey("my-anthropic-api-key"),
+ )
+ _, err := client.Beta.Vaults.List(context.TODO(), anthropic.BetaVaultListParams{
+ IncludeArchived: anthropic.Bool(true),
+ Limit: anthropic.Int(0),
+ Page: anthropic.String("page"),
+ Betas: []anthropic.AnthropicBeta{anthropic.AnthropicBetaMessageBatches2024_09_24},
+ })
+ if err != nil {
+ var apierr *anthropic.Error
+ if errors.As(err, &apierr) {
+ t.Log(string(apierr.DumpRequest(true)))
+ }
+ t.Fatalf("err should be nil: %s", err.Error())
+ }
+}
+
+func TestBetaVaultDeleteWithOptionalParams(t *testing.T) {
+ baseURL := "http://localhost:4010"
+ if envURL, ok := os.LookupEnv("TEST_API_BASE_URL"); ok {
+ baseURL = envURL
+ }
+ if !testutil.CheckTestServer(t, baseURL) {
+ return
+ }
+ client := anthropic.NewClient(
+ option.WithBaseURL(baseURL),
+ option.WithAPIKey("my-anthropic-api-key"),
+ )
+ _, err := client.Beta.Vaults.Delete(
+ context.TODO(),
+ "vlt_011CZkZDLs7fYzm1hXNPeRjv",
+ anthropic.BetaVaultDeleteParams{
+ Betas: []anthropic.AnthropicBeta{anthropic.AnthropicBetaMessageBatches2024_09_24},
+ },
+ )
+ if err != nil {
+ var apierr *anthropic.Error
+ if errors.As(err, &apierr) {
+ t.Log(string(apierr.DumpRequest(true)))
+ }
+ t.Fatalf("err should be nil: %s", err.Error())
+ }
+}
+
+func TestBetaVaultArchiveWithOptionalParams(t *testing.T) {
+ baseURL := "http://localhost:4010"
+ if envURL, ok := os.LookupEnv("TEST_API_BASE_URL"); ok {
+ baseURL = envURL
+ }
+ if !testutil.CheckTestServer(t, baseURL) {
+ return
+ }
+ client := anthropic.NewClient(
+ option.WithBaseURL(baseURL),
+ option.WithAPIKey("my-anthropic-api-key"),
+ )
+ _, err := client.Beta.Vaults.Archive(
+ context.TODO(),
+ "vlt_011CZkZDLs7fYzm1hXNPeRjv",
+ anthropic.BetaVaultArchiveParams{
+ Betas: []anthropic.AnthropicBeta{anthropic.AnthropicBetaMessageBatches2024_09_24},
+ },
+ )
+ if err != nil {
+ var apierr *anthropic.Error
+ if errors.As(err, &apierr) {
+ t.Log(string(apierr.DumpRequest(true)))
+ }
+ t.Fatalf("err should be nil: %s", err.Error())
+ }
+}
diff --git a/betavaultcredential.go b/betavaultcredential.go
new file mode 100644
index 000000000..85685fa17
--- /dev/null
+++ b/betavaultcredential.go
@@ -0,0 +1,1195 @@
+// File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+package anthropic
+
+import (
+ "context"
+ "encoding/json"
+ "errors"
+ "fmt"
+ "net/http"
+ "net/url"
+ "slices"
+ "time"
+
+ "github.com/anthropics/anthropic-sdk-go/internal/apijson"
+ "github.com/anthropics/anthropic-sdk-go/internal/apiquery"
+ "github.com/anthropics/anthropic-sdk-go/internal/requestconfig"
+ "github.com/anthropics/anthropic-sdk-go/option"
+ "github.com/anthropics/anthropic-sdk-go/packages/pagination"
+ "github.com/anthropics/anthropic-sdk-go/packages/param"
+ "github.com/anthropics/anthropic-sdk-go/packages/respjson"
+)
+
+// BetaVaultCredentialService contains methods and other services that help with
+// interacting with the anthropic API.
+//
+// Note, unlike clients, this service does not read variables from the environment
+// automatically. You should not instantiate this service directly, and instead use
+// the [NewBetaVaultCredentialService] method instead.
+type BetaVaultCredentialService struct {
+ Options []option.RequestOption
+}
+
+// NewBetaVaultCredentialService generates a new service that applies the given
+// options to each request. These options are applied after the parent client's
+// options (if there is one), and before any request-specific options.
+func NewBetaVaultCredentialService(opts ...option.RequestOption) (r BetaVaultCredentialService) {
+ r = BetaVaultCredentialService{}
+ r.Options = opts
+ return
+}
+
+// Create Credential
+func (r *BetaVaultCredentialService) New(ctx context.Context, vaultID string, params BetaVaultCredentialNewParams, opts ...option.RequestOption) (res *BetaManagedAgentsCredential, err error) {
+ for _, v := range params.Betas {
+ opts = append(opts, option.WithHeaderAdd("anthropic-beta", fmt.Sprintf("%v", v)))
+ }
+ opts = slices.Concat(r.Options, opts)
+ opts = append([]option.RequestOption{option.WithHeader("anthropic-beta", "managed-agents-2026-04-01")}, opts...)
+ if vaultID == "" {
+ err = errors.New("missing required vault_id parameter")
+ return nil, err
+ }
+ path := fmt.Sprintf("v1/vaults/%s/credentials?beta=true", vaultID)
+ err = requestconfig.ExecuteNewRequest(ctx, http.MethodPost, path, params, &res, opts...)
+ return res, err
+}
+
+// Get Credential
+func (r *BetaVaultCredentialService) Get(ctx context.Context, credentialID string, params BetaVaultCredentialGetParams, opts ...option.RequestOption) (res *BetaManagedAgentsCredential, err error) {
+ for _, v := range params.Betas {
+ opts = append(opts, option.WithHeaderAdd("anthropic-beta", fmt.Sprintf("%v", v)))
+ }
+ opts = slices.Concat(r.Options, opts)
+ opts = append([]option.RequestOption{option.WithHeader("anthropic-beta", "managed-agents-2026-04-01")}, opts...)
+ if params.VaultID == "" {
+ err = errors.New("missing required vault_id parameter")
+ return nil, err
+ }
+ if credentialID == "" {
+ err = errors.New("missing required credential_id parameter")
+ return nil, err
+ }
+ path := fmt.Sprintf("v1/vaults/%s/credentials/%s?beta=true", params.VaultID, credentialID)
+ err = requestconfig.ExecuteNewRequest(ctx, http.MethodGet, path, nil, &res, opts...)
+ return res, err
+}
+
+// Update Credential
+func (r *BetaVaultCredentialService) Update(ctx context.Context, credentialID string, params BetaVaultCredentialUpdateParams, opts ...option.RequestOption) (res *BetaManagedAgentsCredential, err error) {
+ for _, v := range params.Betas {
+ opts = append(opts, option.WithHeaderAdd("anthropic-beta", fmt.Sprintf("%v", v)))
+ }
+ opts = slices.Concat(r.Options, opts)
+ opts = append([]option.RequestOption{option.WithHeader("anthropic-beta", "managed-agents-2026-04-01")}, opts...)
+ if params.VaultID == "" {
+ err = errors.New("missing required vault_id parameter")
+ return nil, err
+ }
+ if credentialID == "" {
+ err = errors.New("missing required credential_id parameter")
+ return nil, err
+ }
+ path := fmt.Sprintf("v1/vaults/%s/credentials/%s?beta=true", params.VaultID, credentialID)
+ err = requestconfig.ExecuteNewRequest(ctx, http.MethodPost, path, params, &res, opts...)
+ return res, err
+}
+
+// List Credentials
+func (r *BetaVaultCredentialService) List(ctx context.Context, vaultID string, params BetaVaultCredentialListParams, opts ...option.RequestOption) (res *pagination.PageCursor[BetaManagedAgentsCredential], err error) {
+ var raw *http.Response
+ for _, v := range params.Betas {
+ opts = append(opts, option.WithHeaderAdd("anthropic-beta", fmt.Sprintf("%v", v)))
+ }
+ opts = slices.Concat(r.Options, opts)
+ opts = append([]option.RequestOption{option.WithHeader("anthropic-beta", "managed-agents-2026-04-01"), option.WithResponseInto(&raw)}, opts...)
+ if vaultID == "" {
+ err = errors.New("missing required vault_id parameter")
+ return nil, err
+ }
+ path := fmt.Sprintf("v1/vaults/%s/credentials?beta=true", vaultID)
+ cfg, err := requestconfig.NewRequestConfig(ctx, http.MethodGet, path, params, &res, opts...)
+ if err != nil {
+ return nil, err
+ }
+ err = cfg.Execute()
+ if err != nil {
+ return nil, err
+ }
+ res.SetPageConfig(cfg, raw)
+ return res, nil
+}
+
+// List Credentials
+func (r *BetaVaultCredentialService) ListAutoPaging(ctx context.Context, vaultID string, params BetaVaultCredentialListParams, opts ...option.RequestOption) *pagination.PageCursorAutoPager[BetaManagedAgentsCredential] {
+ return pagination.NewPageCursorAutoPager(r.List(ctx, vaultID, params, opts...))
+}
+
+// Delete Credential
+func (r *BetaVaultCredentialService) Delete(ctx context.Context, credentialID string, params BetaVaultCredentialDeleteParams, opts ...option.RequestOption) (res *BetaManagedAgentsDeletedCredential, err error) {
+ for _, v := range params.Betas {
+ opts = append(opts, option.WithHeaderAdd("anthropic-beta", fmt.Sprintf("%v", v)))
+ }
+ opts = slices.Concat(r.Options, opts)
+ opts = append([]option.RequestOption{option.WithHeader("anthropic-beta", "managed-agents-2026-04-01")}, opts...)
+ if params.VaultID == "" {
+ err = errors.New("missing required vault_id parameter")
+ return nil, err
+ }
+ if credentialID == "" {
+ err = errors.New("missing required credential_id parameter")
+ return nil, err
+ }
+ path := fmt.Sprintf("v1/vaults/%s/credentials/%s?beta=true", params.VaultID, credentialID)
+ err = requestconfig.ExecuteNewRequest(ctx, http.MethodDelete, path, nil, &res, opts...)
+ return res, err
+}
+
+// Archive Credential
+func (r *BetaVaultCredentialService) Archive(ctx context.Context, credentialID string, params BetaVaultCredentialArchiveParams, opts ...option.RequestOption) (res *BetaManagedAgentsCredential, err error) {
+ for _, v := range params.Betas {
+ opts = append(opts, option.WithHeaderAdd("anthropic-beta", fmt.Sprintf("%v", v)))
+ }
+ opts = slices.Concat(r.Options, opts)
+ opts = append([]option.RequestOption{option.WithHeader("anthropic-beta", "managed-agents-2026-04-01")}, opts...)
+ if params.VaultID == "" {
+ err = errors.New("missing required vault_id parameter")
+ return nil, err
+ }
+ if credentialID == "" {
+ err = errors.New("missing required credential_id parameter")
+ return nil, err
+ }
+ path := fmt.Sprintf("v1/vaults/%s/credentials/%s/archive?beta=true", params.VaultID, credentialID)
+ err = requestconfig.ExecuteNewRequest(ctx, http.MethodPost, path, nil, &res, opts...)
+ return res, err
+}
+
+// A credential stored in a vault. Sensitive fields are never returned in
+// responses.
+type BetaManagedAgentsCredential struct {
+ // Unique identifier for the credential.
+ ID string `json:"id" api:"required"`
+ // A timestamp in RFC 3339 format
+ ArchivedAt time.Time `json:"archived_at" api:"required" format:"date-time"`
+ // Authentication details for a credential.
+ Auth BetaManagedAgentsCredentialAuthUnion `json:"auth" api:"required"`
+ // A timestamp in RFC 3339 format
+ CreatedAt time.Time `json:"created_at" api:"required" format:"date-time"`
+ // Arbitrary key-value metadata attached to the credential.
+ Metadata map[string]string `json:"metadata" api:"required"`
+ // Any of "vault_credential".
+ Type BetaManagedAgentsCredentialType `json:"type" api:"required"`
+ // A timestamp in RFC 3339 format
+ UpdatedAt time.Time `json:"updated_at" api:"required" format:"date-time"`
+ // Identifier of the vault this credential belongs to.
+ VaultID string `json:"vault_id" api:"required"`
+ // Human-readable name for the credential.
+ DisplayName string `json:"display_name" api:"nullable"`
+ // JSON contains metadata for fields, check presence with [respjson.Field.Valid].
+ JSON struct {
+ ID respjson.Field
+ ArchivedAt respjson.Field
+ Auth respjson.Field
+ CreatedAt respjson.Field
+ Metadata respjson.Field
+ Type respjson.Field
+ UpdatedAt respjson.Field
+ VaultID respjson.Field
+ DisplayName respjson.Field
+ ExtraFields map[string]respjson.Field
+ raw string
+ } `json:"-"`
+}
+
+// Returns the unmodified JSON received from the API
+func (r BetaManagedAgentsCredential) RawJSON() string { return r.JSON.raw }
+func (r *BetaManagedAgentsCredential) UnmarshalJSON(data []byte) error {
+ return apijson.UnmarshalRoot(data, r)
+}
+
+// BetaManagedAgentsCredentialAuthUnion contains all possible properties and values
+// from [BetaManagedAgentsMCPOAuthAuthResponse],
+// [BetaManagedAgentsStaticBearerAuthResponse].
+//
+// Use the [BetaManagedAgentsCredentialAuthUnion.AsAny] method to switch on the
+// variant.
+//
+// Use the methods beginning with 'As' to cast the union to one of its variants.
+type BetaManagedAgentsCredentialAuthUnion struct {
+ MCPServerURL string `json:"mcp_server_url"`
+ // Any of "mcp_oauth", "static_bearer".
+ Type string `json:"type"`
+ // This field is from variant [BetaManagedAgentsMCPOAuthAuthResponse].
+ ExpiresAt time.Time `json:"expires_at"`
+ // This field is from variant [BetaManagedAgentsMCPOAuthAuthResponse].
+ Refresh BetaManagedAgentsMCPOAuthRefreshResponse `json:"refresh"`
+ JSON struct {
+ MCPServerURL respjson.Field
+ Type respjson.Field
+ ExpiresAt respjson.Field
+ Refresh respjson.Field
+ raw string
+ } `json:"-"`
+}
+
+// anyBetaManagedAgentsCredentialAuth is implemented by each variant of
+// [BetaManagedAgentsCredentialAuthUnion] to add type safety for the return type of
+// [BetaManagedAgentsCredentialAuthUnion.AsAny]
+type anyBetaManagedAgentsCredentialAuth interface {
+ implBetaManagedAgentsCredentialAuthUnion()
+}
+
+func (BetaManagedAgentsMCPOAuthAuthResponse) implBetaManagedAgentsCredentialAuthUnion() {}
+func (BetaManagedAgentsStaticBearerAuthResponse) implBetaManagedAgentsCredentialAuthUnion() {}
+
+// Use the following switch statement to find the correct variant
+//
+// switch variant := BetaManagedAgentsCredentialAuthUnion.AsAny().(type) {
+// case anthropic.BetaManagedAgentsMCPOAuthAuthResponse:
+// case anthropic.BetaManagedAgentsStaticBearerAuthResponse:
+// default:
+// fmt.Errorf("no variant present")
+// }
+func (u BetaManagedAgentsCredentialAuthUnion) AsAny() anyBetaManagedAgentsCredentialAuth {
+ switch u.Type {
+ case "mcp_oauth":
+ return u.AsMCPOAuth()
+ case "static_bearer":
+ return u.AsStaticBearer()
+ }
+ return nil
+}
+
+func (u BetaManagedAgentsCredentialAuthUnion) AsMCPOAuth() (v BetaManagedAgentsMCPOAuthAuthResponse) {
+ apijson.UnmarshalRoot(json.RawMessage(u.JSON.raw), &v)
+ return
+}
+
+func (u BetaManagedAgentsCredentialAuthUnion) AsStaticBearer() (v BetaManagedAgentsStaticBearerAuthResponse) {
+ apijson.UnmarshalRoot(json.RawMessage(u.JSON.raw), &v)
+ return
+}
+
+// Returns the unmodified JSON received from the API
+func (u BetaManagedAgentsCredentialAuthUnion) RawJSON() string { return u.JSON.raw }
+
+func (r *BetaManagedAgentsCredentialAuthUnion) UnmarshalJSON(data []byte) error {
+ return apijson.UnmarshalRoot(data, r)
+}
+
+type BetaManagedAgentsCredentialType string
+
+const (
+ BetaManagedAgentsCredentialTypeVaultCredential BetaManagedAgentsCredentialType = "vault_credential"
+)
+
+// Confirmation of a deleted credential.
+type BetaManagedAgentsDeletedCredential struct {
+ // Unique identifier of the deleted credential.
+ ID string `json:"id" api:"required"`
+ // Any of "vault_credential_deleted".
+ Type BetaManagedAgentsDeletedCredentialType `json:"type" api:"required"`
+ // JSON contains metadata for fields, check presence with [respjson.Field.Valid].
+ JSON struct {
+ ID respjson.Field
+ Type respjson.Field
+ ExtraFields map[string]respjson.Field
+ raw string
+ } `json:"-"`
+}
+
+// Returns the unmodified JSON received from the API
+func (r BetaManagedAgentsDeletedCredential) RawJSON() string { return r.JSON.raw }
+func (r *BetaManagedAgentsDeletedCredential) UnmarshalJSON(data []byte) error {
+ return apijson.UnmarshalRoot(data, r)
+}
+
+type BetaManagedAgentsDeletedCredentialType string
+
+const (
+ BetaManagedAgentsDeletedCredentialTypeVaultCredentialDeleted BetaManagedAgentsDeletedCredentialType = "vault_credential_deleted"
+)
+
+// OAuth credential details for an MCP server.
+type BetaManagedAgentsMCPOAuthAuthResponse struct {
+ // URL of the MCP server this credential authenticates against.
+ MCPServerURL string `json:"mcp_server_url" api:"required"`
+ // Any of "mcp_oauth".
+ Type BetaManagedAgentsMCPOAuthAuthResponseType `json:"type" api:"required"`
+ // A timestamp in RFC 3339 format
+ ExpiresAt time.Time `json:"expires_at" api:"nullable" format:"date-time"`
+ // OAuth refresh token configuration returned in credential responses.
+ Refresh BetaManagedAgentsMCPOAuthRefreshResponse `json:"refresh" api:"nullable"`
+ // JSON contains metadata for fields, check presence with [respjson.Field.Valid].
+ JSON struct {
+ MCPServerURL respjson.Field
+ Type respjson.Field
+ ExpiresAt respjson.Field
+ Refresh respjson.Field
+ ExtraFields map[string]respjson.Field
+ raw string
+ } `json:"-"`
+}
+
+// Returns the unmodified JSON received from the API
+func (r BetaManagedAgentsMCPOAuthAuthResponse) RawJSON() string { return r.JSON.raw }
+func (r *BetaManagedAgentsMCPOAuthAuthResponse) UnmarshalJSON(data []byte) error {
+ return apijson.UnmarshalRoot(data, r)
+}
+
+type BetaManagedAgentsMCPOAuthAuthResponseType string
+
+const (
+ BetaManagedAgentsMCPOAuthAuthResponseTypeMCPOAuth BetaManagedAgentsMCPOAuthAuthResponseType = "mcp_oauth"
+)
+
+// Parameters for creating an MCP OAuth credential.
+//
+// The properties AccessToken, MCPServerURL, Type are required.
+type BetaManagedAgentsMCPOAuthCreateParams struct {
+ // OAuth access token.
+ AccessToken string `json:"access_token" api:"required"`
+ // URL of the MCP server this credential authenticates against.
+ MCPServerURL string `json:"mcp_server_url" api:"required"`
+ // Any of "mcp_oauth".
+ Type BetaManagedAgentsMCPOAuthCreateParamsType `json:"type,omitzero" api:"required"`
+ // A timestamp in RFC 3339 format
+ ExpiresAt param.Opt[time.Time] `json:"expires_at,omitzero" format:"date-time"`
+ // OAuth refresh token parameters for creating a credential with refresh support.
+ Refresh BetaManagedAgentsMCPOAuthRefreshParams `json:"refresh,omitzero"`
+ paramObj
+}
+
+func (r BetaManagedAgentsMCPOAuthCreateParams) MarshalJSON() (data []byte, err error) {
+ type shadow BetaManagedAgentsMCPOAuthCreateParams
+ return param.MarshalObject(r, (*shadow)(&r))
+}
+func (r *BetaManagedAgentsMCPOAuthCreateParams) UnmarshalJSON(data []byte) error {
+ return apijson.UnmarshalRoot(data, r)
+}
+
+type BetaManagedAgentsMCPOAuthCreateParamsType string
+
+const (
+ BetaManagedAgentsMCPOAuthCreateParamsTypeMCPOAuth BetaManagedAgentsMCPOAuthCreateParamsType = "mcp_oauth"
+)
+
+// OAuth refresh token parameters for creating a credential with refresh support.
+//
+// The properties ClientID, RefreshToken, TokenEndpoint, TokenEndpointAuth are
+// required.
+type BetaManagedAgentsMCPOAuthRefreshParams struct {
+ // OAuth client ID.
+ ClientID string `json:"client_id" api:"required"`
+ // OAuth refresh token.
+ RefreshToken string `json:"refresh_token" api:"required"`
+ // Token endpoint URL used to refresh the access token.
+ TokenEndpoint string `json:"token_endpoint" api:"required"`
+ // Token endpoint requires no client authentication.
+ TokenEndpointAuth BetaManagedAgentsMCPOAuthRefreshParamsTokenEndpointAuthUnion `json:"token_endpoint_auth,omitzero" api:"required"`
+ // OAuth resource indicator.
+ Resource param.Opt[string] `json:"resource,omitzero"`
+ // OAuth scope for the refresh request.
+ Scope param.Opt[string] `json:"scope,omitzero"`
+ paramObj
+}
+
+func (r BetaManagedAgentsMCPOAuthRefreshParams) MarshalJSON() (data []byte, err error) {
+ type shadow BetaManagedAgentsMCPOAuthRefreshParams
+ return param.MarshalObject(r, (*shadow)(&r))
+}
+func (r *BetaManagedAgentsMCPOAuthRefreshParams) UnmarshalJSON(data []byte) error {
+ return apijson.UnmarshalRoot(data, r)
+}
+
+// Only one field can be non-zero.
+//
+// Use [param.IsOmitted] to confirm if a field is set.
+type BetaManagedAgentsMCPOAuthRefreshParamsTokenEndpointAuthUnion struct {
+ OfNone *BetaManagedAgentsTokenEndpointAuthNoneParam `json:",omitzero,inline"`
+ OfClientSecretBasic *BetaManagedAgentsTokenEndpointAuthBasicParam `json:",omitzero,inline"`
+ OfClientSecretPost *BetaManagedAgentsTokenEndpointAuthPostParam `json:",omitzero,inline"`
+ paramUnion
+}
+
+func (u BetaManagedAgentsMCPOAuthRefreshParamsTokenEndpointAuthUnion) MarshalJSON() ([]byte, error) {
+ return param.MarshalUnion(u, u.OfNone, u.OfClientSecretBasic, u.OfClientSecretPost)
+}
+func (u *BetaManagedAgentsMCPOAuthRefreshParamsTokenEndpointAuthUnion) UnmarshalJSON(data []byte) error {
+ return apijson.UnmarshalRoot(data, u)
+}
+
+func (u *BetaManagedAgentsMCPOAuthRefreshParamsTokenEndpointAuthUnion) asAny() any {
+ if !param.IsOmitted(u.OfNone) {
+ return u.OfNone
+ } else if !param.IsOmitted(u.OfClientSecretBasic) {
+ return u.OfClientSecretBasic
+ } else if !param.IsOmitted(u.OfClientSecretPost) {
+ return u.OfClientSecretPost
+ }
+ return nil
+}
+
+// Returns a pointer to the underlying variant's property, if present.
+func (u BetaManagedAgentsMCPOAuthRefreshParamsTokenEndpointAuthUnion) GetType() *string {
+ if vt := u.OfNone; vt != nil {
+ return (*string)(&vt.Type)
+ } else if vt := u.OfClientSecretBasic; vt != nil {
+ return (*string)(&vt.Type)
+ } else if vt := u.OfClientSecretPost; vt != nil {
+ return (*string)(&vt.Type)
+ }
+ return nil
+}
+
+// Returns a pointer to the underlying variant's property, if present.
+func (u BetaManagedAgentsMCPOAuthRefreshParamsTokenEndpointAuthUnion) GetClientSecret() *string {
+ if vt := u.OfClientSecretBasic; vt != nil {
+ return (*string)(&vt.ClientSecret)
+ } else if vt := u.OfClientSecretPost; vt != nil {
+ return (*string)(&vt.ClientSecret)
+ }
+ return nil
+}
+
+func init() {
+ apijson.RegisterUnion[BetaManagedAgentsMCPOAuthRefreshParamsTokenEndpointAuthUnion](
+ "type",
+ apijson.Discriminator[BetaManagedAgentsTokenEndpointAuthNoneParam]("none"),
+ apijson.Discriminator[BetaManagedAgentsTokenEndpointAuthBasicParam]("client_secret_basic"),
+ apijson.Discriminator[BetaManagedAgentsTokenEndpointAuthPostParam]("client_secret_post"),
+ )
+}
+
+// OAuth refresh token configuration returned in credential responses.
+type BetaManagedAgentsMCPOAuthRefreshResponse struct {
+ // OAuth client ID.
+ ClientID string `json:"client_id" api:"required"`
+ // Token endpoint URL used to refresh the access token.
+ TokenEndpoint string `json:"token_endpoint" api:"required"`
+ // Token endpoint requires no client authentication.
+ TokenEndpointAuth BetaManagedAgentsMCPOAuthRefreshResponseTokenEndpointAuthUnion `json:"token_endpoint_auth" api:"required"`
+ // OAuth resource indicator.
+ Resource string `json:"resource" api:"nullable"`
+ // OAuth scope for the refresh request.
+ Scope string `json:"scope" api:"nullable"`
+ // JSON contains metadata for fields, check presence with [respjson.Field.Valid].
+ JSON struct {
+ ClientID respjson.Field
+ TokenEndpoint respjson.Field
+ TokenEndpointAuth respjson.Field
+ Resource respjson.Field
+ Scope respjson.Field
+ ExtraFields map[string]respjson.Field
+ raw string
+ } `json:"-"`
+}
+
+// Returns the unmodified JSON received from the API
+func (r BetaManagedAgentsMCPOAuthRefreshResponse) RawJSON() string { return r.JSON.raw }
+func (r *BetaManagedAgentsMCPOAuthRefreshResponse) UnmarshalJSON(data []byte) error {
+ return apijson.UnmarshalRoot(data, r)
+}
+
+// BetaManagedAgentsMCPOAuthRefreshResponseTokenEndpointAuthUnion contains all
+// possible properties and values from
+// [BetaManagedAgentsTokenEndpointAuthNoneResponse],
+// [BetaManagedAgentsTokenEndpointAuthBasicResponse],
+// [BetaManagedAgentsTokenEndpointAuthPostResponse].
+//
+// Use the [BetaManagedAgentsMCPOAuthRefreshResponseTokenEndpointAuthUnion.AsAny]
+// method to switch on the variant.
+//
+// Use the methods beginning with 'As' to cast the union to one of its variants.
+type BetaManagedAgentsMCPOAuthRefreshResponseTokenEndpointAuthUnion struct {
+ // Any of "none", "client_secret_basic", "client_secret_post".
+ Type string `json:"type"`
+ JSON struct {
+ Type respjson.Field
+ raw string
+ } `json:"-"`
+}
+
+// anyBetaManagedAgentsMCPOAuthRefreshResponseTokenEndpointAuth is implemented by
+// each variant of [BetaManagedAgentsMCPOAuthRefreshResponseTokenEndpointAuthUnion]
+// to add type safety for the return type of
+// [BetaManagedAgentsMCPOAuthRefreshResponseTokenEndpointAuthUnion.AsAny]
+type anyBetaManagedAgentsMCPOAuthRefreshResponseTokenEndpointAuth interface {
+ implBetaManagedAgentsMcpoAuthRefreshResponseTokenEndpointAuthUnion()
+}
+
+func (BetaManagedAgentsTokenEndpointAuthNoneResponse) implBetaManagedAgentsMcpoAuthRefreshResponseTokenEndpointAuthUnion() {
+}
+func (BetaManagedAgentsTokenEndpointAuthBasicResponse) implBetaManagedAgentsMcpoAuthRefreshResponseTokenEndpointAuthUnion() {
+}
+func (BetaManagedAgentsTokenEndpointAuthPostResponse) implBetaManagedAgentsMcpoAuthRefreshResponseTokenEndpointAuthUnion() {
+}
+
+// Use the following switch statement to find the correct variant
+//
+// switch variant := BetaManagedAgentsMCPOAuthRefreshResponseTokenEndpointAuthUnion.AsAny().(type) {
+// case anthropic.BetaManagedAgentsTokenEndpointAuthNoneResponse:
+// case anthropic.BetaManagedAgentsTokenEndpointAuthBasicResponse:
+// case anthropic.BetaManagedAgentsTokenEndpointAuthPostResponse:
+// default:
+// fmt.Errorf("no variant present")
+// }
+func (u BetaManagedAgentsMCPOAuthRefreshResponseTokenEndpointAuthUnion) AsAny() anyBetaManagedAgentsMCPOAuthRefreshResponseTokenEndpointAuth {
+ switch u.Type {
+ case "none":
+ return u.AsNone()
+ case "client_secret_basic":
+ return u.AsClientSecretBasic()
+ case "client_secret_post":
+ return u.AsClientSecretPost()
+ }
+ return nil
+}
+
+func (u BetaManagedAgentsMCPOAuthRefreshResponseTokenEndpointAuthUnion) AsNone() (v BetaManagedAgentsTokenEndpointAuthNoneResponse) {
+ apijson.UnmarshalRoot(json.RawMessage(u.JSON.raw), &v)
+ return
+}
+
+func (u BetaManagedAgentsMCPOAuthRefreshResponseTokenEndpointAuthUnion) AsClientSecretBasic() (v BetaManagedAgentsTokenEndpointAuthBasicResponse) {
+ apijson.UnmarshalRoot(json.RawMessage(u.JSON.raw), &v)
+ return
+}
+
+func (u BetaManagedAgentsMCPOAuthRefreshResponseTokenEndpointAuthUnion) AsClientSecretPost() (v BetaManagedAgentsTokenEndpointAuthPostResponse) {
+ apijson.UnmarshalRoot(json.RawMessage(u.JSON.raw), &v)
+ return
+}
+
+// Returns the unmodified JSON received from the API
+func (u BetaManagedAgentsMCPOAuthRefreshResponseTokenEndpointAuthUnion) RawJSON() string {
+ return u.JSON.raw
+}
+
+func (r *BetaManagedAgentsMCPOAuthRefreshResponseTokenEndpointAuthUnion) UnmarshalJSON(data []byte) error {
+ return apijson.UnmarshalRoot(data, r)
+}
+
+// Parameters for updating OAuth refresh token configuration.
+type BetaManagedAgentsMCPOAuthRefreshUpdateParams struct {
+ // Updated OAuth refresh token.
+ RefreshToken param.Opt[string] `json:"refresh_token,omitzero"`
+ // Updated OAuth scope for the refresh request.
+ Scope param.Opt[string] `json:"scope,omitzero"`
+ // Updated HTTP Basic authentication parameters for the token endpoint.
+ TokenEndpointAuth BetaManagedAgentsMCPOAuthRefreshUpdateParamsTokenEndpointAuthUnion `json:"token_endpoint_auth,omitzero"`
+ paramObj
+}
+
+func (r BetaManagedAgentsMCPOAuthRefreshUpdateParams) MarshalJSON() (data []byte, err error) {
+ type shadow BetaManagedAgentsMCPOAuthRefreshUpdateParams
+ return param.MarshalObject(r, (*shadow)(&r))
+}
+func (r *BetaManagedAgentsMCPOAuthRefreshUpdateParams) UnmarshalJSON(data []byte) error {
+ return apijson.UnmarshalRoot(data, r)
+}
+
+// Only one field can be non-zero.
+//
+// Use [param.IsOmitted] to confirm if a field is set.
+type BetaManagedAgentsMCPOAuthRefreshUpdateParamsTokenEndpointAuthUnion struct {
+ OfClientSecretBasic *BetaManagedAgentsTokenEndpointAuthBasicUpdateParam `json:",omitzero,inline"`
+ OfClientSecretPost *BetaManagedAgentsTokenEndpointAuthPostUpdateParam `json:",omitzero,inline"`
+ paramUnion
+}
+
+func (u BetaManagedAgentsMCPOAuthRefreshUpdateParamsTokenEndpointAuthUnion) MarshalJSON() ([]byte, error) {
+ return param.MarshalUnion(u, u.OfClientSecretBasic, u.OfClientSecretPost)
+}
+func (u *BetaManagedAgentsMCPOAuthRefreshUpdateParamsTokenEndpointAuthUnion) UnmarshalJSON(data []byte) error {
+ return apijson.UnmarshalRoot(data, u)
+}
+
+func (u *BetaManagedAgentsMCPOAuthRefreshUpdateParamsTokenEndpointAuthUnion) asAny() any {
+ if !param.IsOmitted(u.OfClientSecretBasic) {
+ return u.OfClientSecretBasic
+ } else if !param.IsOmitted(u.OfClientSecretPost) {
+ return u.OfClientSecretPost
+ }
+ return nil
+}
+
+// Returns a pointer to the underlying variant's property, if present.
+func (u BetaManagedAgentsMCPOAuthRefreshUpdateParamsTokenEndpointAuthUnion) GetType() *string {
+ if vt := u.OfClientSecretBasic; vt != nil {
+ return (*string)(&vt.Type)
+ } else if vt := u.OfClientSecretPost; vt != nil {
+ return (*string)(&vt.Type)
+ }
+ return nil
+}
+
+// Returns a pointer to the underlying variant's property, if present.
+func (u BetaManagedAgentsMCPOAuthRefreshUpdateParamsTokenEndpointAuthUnion) GetClientSecret() *string {
+ if vt := u.OfClientSecretBasic; vt != nil && vt.ClientSecret.Valid() {
+ return &vt.ClientSecret.Value
+ } else if vt := u.OfClientSecretPost; vt != nil && vt.ClientSecret.Valid() {
+ return &vt.ClientSecret.Value
+ }
+ return nil
+}
+
+func init() {
+ apijson.RegisterUnion[BetaManagedAgentsMCPOAuthRefreshUpdateParamsTokenEndpointAuthUnion](
+ "type",
+ apijson.Discriminator[BetaManagedAgentsTokenEndpointAuthBasicUpdateParam]("client_secret_basic"),
+ apijson.Discriminator[BetaManagedAgentsTokenEndpointAuthPostUpdateParam]("client_secret_post"),
+ )
+}
+
+// Parameters for updating an MCP OAuth credential. The `mcp_server_url` is
+// immutable.
+//
+// The property Type is required.
+type BetaManagedAgentsMCPOAuthUpdateParams struct {
+ // Any of "mcp_oauth".
+ Type BetaManagedAgentsMCPOAuthUpdateParamsType `json:"type,omitzero" api:"required"`
+ // Updated OAuth access token.
+ AccessToken param.Opt[string] `json:"access_token,omitzero"`
+ // A timestamp in RFC 3339 format
+ ExpiresAt param.Opt[time.Time] `json:"expires_at,omitzero" format:"date-time"`
+ // Parameters for updating OAuth refresh token configuration.
+ Refresh BetaManagedAgentsMCPOAuthRefreshUpdateParams `json:"refresh,omitzero"`
+ paramObj
+}
+
+func (r BetaManagedAgentsMCPOAuthUpdateParams) MarshalJSON() (data []byte, err error) {
+ type shadow BetaManagedAgentsMCPOAuthUpdateParams
+ return param.MarshalObject(r, (*shadow)(&r))
+}
+func (r *BetaManagedAgentsMCPOAuthUpdateParams) UnmarshalJSON(data []byte) error {
+ return apijson.UnmarshalRoot(data, r)
+}
+
+type BetaManagedAgentsMCPOAuthUpdateParamsType string
+
+const (
+ BetaManagedAgentsMCPOAuthUpdateParamsTypeMCPOAuth BetaManagedAgentsMCPOAuthUpdateParamsType = "mcp_oauth"
+)
+
+// Static bearer token credential details for an MCP server.
+type BetaManagedAgentsStaticBearerAuthResponse struct {
+ // URL of the MCP server this credential authenticates against.
+ MCPServerURL string `json:"mcp_server_url" api:"required"`
+ // Any of "static_bearer".
+ Type BetaManagedAgentsStaticBearerAuthResponseType `json:"type" api:"required"`
+ // JSON contains metadata for fields, check presence with [respjson.Field.Valid].
+ JSON struct {
+ MCPServerURL respjson.Field
+ Type respjson.Field
+ ExtraFields map[string]respjson.Field
+ raw string
+ } `json:"-"`
+}
+
+// Returns the unmodified JSON received from the API
+func (r BetaManagedAgentsStaticBearerAuthResponse) RawJSON() string { return r.JSON.raw }
+func (r *BetaManagedAgentsStaticBearerAuthResponse) UnmarshalJSON(data []byte) error {
+ return apijson.UnmarshalRoot(data, r)
+}
+
+type BetaManagedAgentsStaticBearerAuthResponseType string
+
+const (
+ BetaManagedAgentsStaticBearerAuthResponseTypeStaticBearer BetaManagedAgentsStaticBearerAuthResponseType = "static_bearer"
+)
+
+// Parameters for creating a static bearer token credential.
+//
+// The properties Token, MCPServerURL, Type are required.
+type BetaManagedAgentsStaticBearerCreateParams struct {
+ // Static bearer token value.
+ Token string `json:"token" api:"required"`
+ // URL of the MCP server this credential authenticates against.
+ MCPServerURL string `json:"mcp_server_url" api:"required"`
+ // Any of "static_bearer".
+ Type BetaManagedAgentsStaticBearerCreateParamsType `json:"type,omitzero" api:"required"`
+ paramObj
+}
+
+func (r BetaManagedAgentsStaticBearerCreateParams) MarshalJSON() (data []byte, err error) {
+ type shadow BetaManagedAgentsStaticBearerCreateParams
+ return param.MarshalObject(r, (*shadow)(&r))
+}
+func (r *BetaManagedAgentsStaticBearerCreateParams) UnmarshalJSON(data []byte) error {
+ return apijson.UnmarshalRoot(data, r)
+}
+
+type BetaManagedAgentsStaticBearerCreateParamsType string
+
+const (
+ BetaManagedAgentsStaticBearerCreateParamsTypeStaticBearer BetaManagedAgentsStaticBearerCreateParamsType = "static_bearer"
+)
+
+// Parameters for updating a static bearer token credential. The `mcp_server_url`
+// is immutable.
+//
+// The property Type is required.
+type BetaManagedAgentsStaticBearerUpdateParams struct {
+ // Any of "static_bearer".
+ Type BetaManagedAgentsStaticBearerUpdateParamsType `json:"type,omitzero" api:"required"`
+ // Updated static bearer token value.
+ Token param.Opt[string] `json:"token,omitzero"`
+ paramObj
+}
+
+func (r BetaManagedAgentsStaticBearerUpdateParams) MarshalJSON() (data []byte, err error) {
+ type shadow BetaManagedAgentsStaticBearerUpdateParams
+ return param.MarshalObject(r, (*shadow)(&r))
+}
+func (r *BetaManagedAgentsStaticBearerUpdateParams) UnmarshalJSON(data []byte) error {
+ return apijson.UnmarshalRoot(data, r)
+}
+
+type BetaManagedAgentsStaticBearerUpdateParamsType string
+
+const (
+ BetaManagedAgentsStaticBearerUpdateParamsTypeStaticBearer BetaManagedAgentsStaticBearerUpdateParamsType = "static_bearer"
+)
+
+// Token endpoint uses HTTP Basic authentication with client credentials.
+//
+// The properties ClientSecret, Type are required.
+type BetaManagedAgentsTokenEndpointAuthBasicParam struct {
+ // OAuth client secret.
+ ClientSecret string `json:"client_secret" api:"required"`
+ // Any of "client_secret_basic".
+ Type BetaManagedAgentsTokenEndpointAuthBasicParamType `json:"type,omitzero" api:"required"`
+ paramObj
+}
+
+func (r BetaManagedAgentsTokenEndpointAuthBasicParam) MarshalJSON() (data []byte, err error) {
+ type shadow BetaManagedAgentsTokenEndpointAuthBasicParam
+ return param.MarshalObject(r, (*shadow)(&r))
+}
+func (r *BetaManagedAgentsTokenEndpointAuthBasicParam) UnmarshalJSON(data []byte) error {
+ return apijson.UnmarshalRoot(data, r)
+}
+
+type BetaManagedAgentsTokenEndpointAuthBasicParamType string
+
+const (
+ BetaManagedAgentsTokenEndpointAuthBasicParamTypeClientSecretBasic BetaManagedAgentsTokenEndpointAuthBasicParamType = "client_secret_basic"
+)
+
+// Token endpoint uses HTTP Basic authentication with client credentials.
+type BetaManagedAgentsTokenEndpointAuthBasicResponse struct {
+ // Any of "client_secret_basic".
+ Type BetaManagedAgentsTokenEndpointAuthBasicResponseType `json:"type" api:"required"`
+ // JSON contains metadata for fields, check presence with [respjson.Field.Valid].
+ JSON struct {
+ Type respjson.Field
+ ExtraFields map[string]respjson.Field
+ raw string
+ } `json:"-"`
+}
+
+// Returns the unmodified JSON received from the API
+func (r BetaManagedAgentsTokenEndpointAuthBasicResponse) RawJSON() string { return r.JSON.raw }
+func (r *BetaManagedAgentsTokenEndpointAuthBasicResponse) UnmarshalJSON(data []byte) error {
+ return apijson.UnmarshalRoot(data, r)
+}
+
+type BetaManagedAgentsTokenEndpointAuthBasicResponseType string
+
+const (
+ BetaManagedAgentsTokenEndpointAuthBasicResponseTypeClientSecretBasic BetaManagedAgentsTokenEndpointAuthBasicResponseType = "client_secret_basic"
+)
+
+// Updated HTTP Basic authentication parameters for the token endpoint.
+//
+// The property Type is required.
+type BetaManagedAgentsTokenEndpointAuthBasicUpdateParam struct {
+ // Any of "client_secret_basic".
+ Type BetaManagedAgentsTokenEndpointAuthBasicUpdateParamType `json:"type,omitzero" api:"required"`
+ // Updated OAuth client secret.
+ ClientSecret param.Opt[string] `json:"client_secret,omitzero"`
+ paramObj
+}
+
+func (r BetaManagedAgentsTokenEndpointAuthBasicUpdateParam) MarshalJSON() (data []byte, err error) {
+ type shadow BetaManagedAgentsTokenEndpointAuthBasicUpdateParam
+ return param.MarshalObject(r, (*shadow)(&r))
+}
+func (r *BetaManagedAgentsTokenEndpointAuthBasicUpdateParam) UnmarshalJSON(data []byte) error {
+ return apijson.UnmarshalRoot(data, r)
+}
+
+type BetaManagedAgentsTokenEndpointAuthBasicUpdateParamType string
+
+const (
+ BetaManagedAgentsTokenEndpointAuthBasicUpdateParamTypeClientSecretBasic BetaManagedAgentsTokenEndpointAuthBasicUpdateParamType = "client_secret_basic"
+)
+
+// Token endpoint requires no client authentication.
+//
+// The property Type is required.
+type BetaManagedAgentsTokenEndpointAuthNoneParam struct {
+ // Any of "none".
+ Type BetaManagedAgentsTokenEndpointAuthNoneParamType `json:"type,omitzero" api:"required"`
+ paramObj
+}
+
+func (r BetaManagedAgentsTokenEndpointAuthNoneParam) MarshalJSON() (data []byte, err error) {
+ type shadow BetaManagedAgentsTokenEndpointAuthNoneParam
+ return param.MarshalObject(r, (*shadow)(&r))
+}
+func (r *BetaManagedAgentsTokenEndpointAuthNoneParam) UnmarshalJSON(data []byte) error {
+ return apijson.UnmarshalRoot(data, r)
+}
+
+type BetaManagedAgentsTokenEndpointAuthNoneParamType string
+
+const (
+ BetaManagedAgentsTokenEndpointAuthNoneParamTypeNone BetaManagedAgentsTokenEndpointAuthNoneParamType = "none"
+)
+
+// Token endpoint requires no client authentication.
+type BetaManagedAgentsTokenEndpointAuthNoneResponse struct {
+ // Any of "none".
+ Type BetaManagedAgentsTokenEndpointAuthNoneResponseType `json:"type" api:"required"`
+ // JSON contains metadata for fields, check presence with [respjson.Field.Valid].
+ JSON struct {
+ Type respjson.Field
+ ExtraFields map[string]respjson.Field
+ raw string
+ } `json:"-"`
+}
+
+// Returns the unmodified JSON received from the API
+func (r BetaManagedAgentsTokenEndpointAuthNoneResponse) RawJSON() string { return r.JSON.raw }
+func (r *BetaManagedAgentsTokenEndpointAuthNoneResponse) UnmarshalJSON(data []byte) error {
+ return apijson.UnmarshalRoot(data, r)
+}
+
+type BetaManagedAgentsTokenEndpointAuthNoneResponseType string
+
+const (
+ BetaManagedAgentsTokenEndpointAuthNoneResponseTypeNone BetaManagedAgentsTokenEndpointAuthNoneResponseType = "none"
+)
+
+// Token endpoint uses POST body authentication with client credentials.
+//
+// The properties ClientSecret, Type are required.
+type BetaManagedAgentsTokenEndpointAuthPostParam struct {
+ // OAuth client secret.
+ ClientSecret string `json:"client_secret" api:"required"`
+ // Any of "client_secret_post".
+ Type BetaManagedAgentsTokenEndpointAuthPostParamType `json:"type,omitzero" api:"required"`
+ paramObj
+}
+
+func (r BetaManagedAgentsTokenEndpointAuthPostParam) MarshalJSON() (data []byte, err error) {
+ type shadow BetaManagedAgentsTokenEndpointAuthPostParam
+ return param.MarshalObject(r, (*shadow)(&r))
+}
+func (r *BetaManagedAgentsTokenEndpointAuthPostParam) UnmarshalJSON(data []byte) error {
+ return apijson.UnmarshalRoot(data, r)
+}
+
+type BetaManagedAgentsTokenEndpointAuthPostParamType string
+
+const (
+ BetaManagedAgentsTokenEndpointAuthPostParamTypeClientSecretPost BetaManagedAgentsTokenEndpointAuthPostParamType = "client_secret_post"
+)
+
+// Token endpoint uses POST body authentication with client credentials.
+type BetaManagedAgentsTokenEndpointAuthPostResponse struct {
+ // Any of "client_secret_post".
+ Type BetaManagedAgentsTokenEndpointAuthPostResponseType `json:"type" api:"required"`
+ // JSON contains metadata for fields, check presence with [respjson.Field.Valid].
+ JSON struct {
+ Type respjson.Field
+ ExtraFields map[string]respjson.Field
+ raw string
+ } `json:"-"`
+}
+
+// Returns the unmodified JSON received from the API
+func (r BetaManagedAgentsTokenEndpointAuthPostResponse) RawJSON() string { return r.JSON.raw }
+func (r *BetaManagedAgentsTokenEndpointAuthPostResponse) UnmarshalJSON(data []byte) error {
+ return apijson.UnmarshalRoot(data, r)
+}
+
+type BetaManagedAgentsTokenEndpointAuthPostResponseType string
+
+const (
+ BetaManagedAgentsTokenEndpointAuthPostResponseTypeClientSecretPost BetaManagedAgentsTokenEndpointAuthPostResponseType = "client_secret_post"
+)
+
+// Updated POST body authentication parameters for the token endpoint.
+//
+// The property Type is required.
+type BetaManagedAgentsTokenEndpointAuthPostUpdateParam struct {
+ // Any of "client_secret_post".
+ Type BetaManagedAgentsTokenEndpointAuthPostUpdateParamType `json:"type,omitzero" api:"required"`
+ // Updated OAuth client secret.
+ ClientSecret param.Opt[string] `json:"client_secret,omitzero"`
+ paramObj
+}
+
+func (r BetaManagedAgentsTokenEndpointAuthPostUpdateParam) MarshalJSON() (data []byte, err error) {
+ type shadow BetaManagedAgentsTokenEndpointAuthPostUpdateParam
+ return param.MarshalObject(r, (*shadow)(&r))
+}
+func (r *BetaManagedAgentsTokenEndpointAuthPostUpdateParam) UnmarshalJSON(data []byte) error {
+ return apijson.UnmarshalRoot(data, r)
+}
+
+type BetaManagedAgentsTokenEndpointAuthPostUpdateParamType string
+
+const (
+ BetaManagedAgentsTokenEndpointAuthPostUpdateParamTypeClientSecretPost BetaManagedAgentsTokenEndpointAuthPostUpdateParamType = "client_secret_post"
+)
+
+type BetaVaultCredentialNewParams struct {
+ // Authentication details for creating a credential.
+ Auth BetaVaultCredentialNewParamsAuthUnion `json:"auth,omitzero" api:"required"`
+ // Human-readable name for the credential. Up to 255 characters.
+ DisplayName param.Opt[string] `json:"display_name,omitzero"`
+ // Arbitrary key-value metadata to attach to the credential. Maximum 16 pairs, keys
+ // up to 64 chars, values up to 512 chars.
+ Metadata map[string]string `json:"metadata,omitzero"`
+ // Optional header to specify the beta version(s) you want to use.
+ Betas []AnthropicBeta `header:"anthropic-beta,omitzero" json:"-"`
+ paramObj
+}
+
+func (r BetaVaultCredentialNewParams) MarshalJSON() (data []byte, err error) {
+ type shadow BetaVaultCredentialNewParams
+ return param.MarshalObject(r, (*shadow)(&r))
+}
+func (r *BetaVaultCredentialNewParams) UnmarshalJSON(data []byte) error {
+ return apijson.UnmarshalRoot(data, r)
+}
+
+// Only one field can be non-zero.
+//
+// Use [param.IsOmitted] to confirm if a field is set.
+type BetaVaultCredentialNewParamsAuthUnion struct {
+ OfMCPOAuth *BetaManagedAgentsMCPOAuthCreateParams `json:",omitzero,inline"`
+ OfStaticBearer *BetaManagedAgentsStaticBearerCreateParams `json:",omitzero,inline"`
+ paramUnion
+}
+
+func (u BetaVaultCredentialNewParamsAuthUnion) MarshalJSON() ([]byte, error) {
+ return param.MarshalUnion(u, u.OfMCPOAuth, u.OfStaticBearer)
+}
+func (u *BetaVaultCredentialNewParamsAuthUnion) UnmarshalJSON(data []byte) error {
+ return apijson.UnmarshalRoot(data, u)
+}
+
+func (u *BetaVaultCredentialNewParamsAuthUnion) asAny() any {
+ if !param.IsOmitted(u.OfMCPOAuth) {
+ return u.OfMCPOAuth
+ } else if !param.IsOmitted(u.OfStaticBearer) {
+ return u.OfStaticBearer
+ }
+ return nil
+}
+
+// Returns a pointer to the underlying variant's property, if present.
+func (u BetaVaultCredentialNewParamsAuthUnion) GetAccessToken() *string {
+ if vt := u.OfMCPOAuth; vt != nil {
+ return &vt.AccessToken
+ }
+ return nil
+}
+
+// Returns a pointer to the underlying variant's property, if present.
+func (u BetaVaultCredentialNewParamsAuthUnion) GetExpiresAt() *time.Time {
+ if vt := u.OfMCPOAuth; vt != nil && vt.ExpiresAt.Valid() {
+ return &vt.ExpiresAt.Value
+ }
+ return nil
+}
+
+// Returns a pointer to the underlying variant's property, if present.
+func (u BetaVaultCredentialNewParamsAuthUnion) GetRefresh() *BetaManagedAgentsMCPOAuthRefreshParams {
+ if vt := u.OfMCPOAuth; vt != nil {
+ return &vt.Refresh
+ }
+ return nil
+}
+
+// Returns a pointer to the underlying variant's property, if present.
+func (u BetaVaultCredentialNewParamsAuthUnion) GetToken() *string {
+ if vt := u.OfStaticBearer; vt != nil {
+ return &vt.Token
+ }
+ return nil
+}
+
+// Returns a pointer to the underlying variant's property, if present.
+func (u BetaVaultCredentialNewParamsAuthUnion) GetMCPServerURL() *string {
+ if vt := u.OfMCPOAuth; vt != nil {
+ return (*string)(&vt.MCPServerURL)
+ } else if vt := u.OfStaticBearer; vt != nil {
+ return (*string)(&vt.MCPServerURL)
+ }
+ return nil
+}
+
+// Returns a pointer to the underlying variant's property, if present.
+func (u BetaVaultCredentialNewParamsAuthUnion) GetType() *string {
+ if vt := u.OfMCPOAuth; vt != nil {
+ return (*string)(&vt.Type)
+ } else if vt := u.OfStaticBearer; vt != nil {
+ return (*string)(&vt.Type)
+ }
+ return nil
+}
+
+func init() {
+ apijson.RegisterUnion[BetaVaultCredentialNewParamsAuthUnion](
+ "type",
+ apijson.Discriminator[BetaManagedAgentsMCPOAuthCreateParams]("mcp_oauth"),
+ apijson.Discriminator[BetaManagedAgentsStaticBearerCreateParams]("static_bearer"),
+ )
+}
+
+type BetaVaultCredentialGetParams struct {
+ VaultID string `path:"vault_id" api:"required" json:"-"`
+ // Optional header to specify the beta version(s) you want to use.
+ Betas []AnthropicBeta `header:"anthropic-beta,omitzero" json:"-"`
+ paramObj
+}
+
+type BetaVaultCredentialUpdateParams struct {
+ VaultID string `path:"vault_id" api:"required" json:"-"`
+ // Updated human-readable name for the credential. 1-255 characters.
+ DisplayName param.Opt[string] `json:"display_name,omitzero"`
+ // Metadata patch. Set a key to a string to upsert it, or to null to delete it.
+ // Omitted keys are preserved.
+ Metadata map[string]string `json:"metadata,omitzero"`
+ // Updated authentication details for a credential.
+ Auth BetaVaultCredentialUpdateParamsAuthUnion `json:"auth,omitzero"`
+ // Optional header to specify the beta version(s) you want to use.
+ Betas []AnthropicBeta `header:"anthropic-beta,omitzero" json:"-"`
+ paramObj
+}
+
+func (r BetaVaultCredentialUpdateParams) MarshalJSON() (data []byte, err error) {
+ type shadow BetaVaultCredentialUpdateParams
+ return param.MarshalObject(r, (*shadow)(&r))
+}
+func (r *BetaVaultCredentialUpdateParams) UnmarshalJSON(data []byte) error {
+ return apijson.UnmarshalRoot(data, r)
+}
+
+// Only one field can be non-zero.
+//
+// Use [param.IsOmitted] to confirm if a field is set.
+type BetaVaultCredentialUpdateParamsAuthUnion struct {
+ OfMCPOAuth *BetaManagedAgentsMCPOAuthUpdateParams `json:",omitzero,inline"`
+ OfStaticBearer *BetaManagedAgentsStaticBearerUpdateParams `json:",omitzero,inline"`
+ paramUnion
+}
+
+func (u BetaVaultCredentialUpdateParamsAuthUnion) MarshalJSON() ([]byte, error) {
+ return param.MarshalUnion(u, u.OfMCPOAuth, u.OfStaticBearer)
+}
+func (u *BetaVaultCredentialUpdateParamsAuthUnion) UnmarshalJSON(data []byte) error {
+ return apijson.UnmarshalRoot(data, u)
+}
+
+func (u *BetaVaultCredentialUpdateParamsAuthUnion) asAny() any {
+ if !param.IsOmitted(u.OfMCPOAuth) {
+ return u.OfMCPOAuth
+ } else if !param.IsOmitted(u.OfStaticBearer) {
+ return u.OfStaticBearer
+ }
+ return nil
+}
+
+// Returns a pointer to the underlying variant's property, if present.
+func (u BetaVaultCredentialUpdateParamsAuthUnion) GetAccessToken() *string {
+ if vt := u.OfMCPOAuth; vt != nil && vt.AccessToken.Valid() {
+ return &vt.AccessToken.Value
+ }
+ return nil
+}
+
+// Returns a pointer to the underlying variant's property, if present.
+func (u BetaVaultCredentialUpdateParamsAuthUnion) GetExpiresAt() *time.Time {
+ if vt := u.OfMCPOAuth; vt != nil && vt.ExpiresAt.Valid() {
+ return &vt.ExpiresAt.Value
+ }
+ return nil
+}
+
+// Returns a pointer to the underlying variant's property, if present.
+func (u BetaVaultCredentialUpdateParamsAuthUnion) GetRefresh() *BetaManagedAgentsMCPOAuthRefreshUpdateParams {
+ if vt := u.OfMCPOAuth; vt != nil {
+ return &vt.Refresh
+ }
+ return nil
+}
+
+// Returns a pointer to the underlying variant's property, if present.
+func (u BetaVaultCredentialUpdateParamsAuthUnion) GetToken() *string {
+ if vt := u.OfStaticBearer; vt != nil && vt.Token.Valid() {
+ return &vt.Token.Value
+ }
+ return nil
+}
+
+// Returns a pointer to the underlying variant's property, if present.
+func (u BetaVaultCredentialUpdateParamsAuthUnion) GetType() *string {
+ if vt := u.OfMCPOAuth; vt != nil {
+ return (*string)(&vt.Type)
+ } else if vt := u.OfStaticBearer; vt != nil {
+ return (*string)(&vt.Type)
+ }
+ return nil
+}
+
+func init() {
+ apijson.RegisterUnion[BetaVaultCredentialUpdateParamsAuthUnion](
+ "type",
+ apijson.Discriminator[BetaManagedAgentsMCPOAuthUpdateParams]("mcp_oauth"),
+ apijson.Discriminator[BetaManagedAgentsStaticBearerUpdateParams]("static_bearer"),
+ )
+}
+
+type BetaVaultCredentialListParams struct {
+ // Whether to include archived credentials in the results.
+ IncludeArchived param.Opt[bool] `query:"include_archived,omitzero" json:"-"`
+ // Maximum number of credentials to return per page. Defaults to 20, maximum 100.
+ Limit param.Opt[int64] `query:"limit,omitzero" json:"-"`
+ // Opaque pagination token from a previous `list_credentials` response.
+ Page param.Opt[string] `query:"page,omitzero" json:"-"`
+ // Optional header to specify the beta version(s) you want to use.
+ Betas []AnthropicBeta `header:"anthropic-beta,omitzero" json:"-"`
+ paramObj
+}
+
+// URLQuery serializes [BetaVaultCredentialListParams]'s query parameters as
+// `url.Values`.
+func (r BetaVaultCredentialListParams) URLQuery() (v url.Values, err error) {
+ return apiquery.MarshalWithSettings(r, apiquery.QuerySettings{
+ ArrayFormat: apiquery.ArrayQueryFormatComma,
+ NestedFormat: apiquery.NestedQueryFormatBrackets,
+ })
+}
+
+type BetaVaultCredentialDeleteParams struct {
+ VaultID string `path:"vault_id" api:"required" json:"-"`
+ // Optional header to specify the beta version(s) you want to use.
+ Betas []AnthropicBeta `header:"anthropic-beta,omitzero" json:"-"`
+ paramObj
+}
+
+type BetaVaultCredentialArchiveParams struct {
+ VaultID string `path:"vault_id" api:"required" json:"-"`
+ // Optional header to specify the beta version(s) you want to use.
+ Betas []AnthropicBeta `header:"anthropic-beta,omitzero" json:"-"`
+ paramObj
+}
diff --git a/betavaultcredential_test.go b/betavaultcredential_test.go
new file mode 100644
index 000000000..6f5df74e8
--- /dev/null
+++ b/betavaultcredential_test.go
@@ -0,0 +1,223 @@
+// File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+package anthropic_test
+
+import (
+ "context"
+ "errors"
+ "os"
+ "testing"
+ "time"
+
+ "github.com/anthropics/anthropic-sdk-go"
+ "github.com/anthropics/anthropic-sdk-go/internal/testutil"
+ "github.com/anthropics/anthropic-sdk-go/option"
+)
+
+func TestBetaVaultCredentialNewWithOptionalParams(t *testing.T) {
+ baseURL := "http://localhost:4010"
+ if envURL, ok := os.LookupEnv("TEST_API_BASE_URL"); ok {
+ baseURL = envURL
+ }
+ if !testutil.CheckTestServer(t, baseURL) {
+ return
+ }
+ client := anthropic.NewClient(
+ option.WithBaseURL(baseURL),
+ option.WithAPIKey("my-anthropic-api-key"),
+ )
+ _, err := client.Beta.Vaults.Credentials.New(
+ context.TODO(),
+ "vlt_011CZkZDLs7fYzm1hXNPeRjv",
+ anthropic.BetaVaultCredentialNewParams{
+ Auth: anthropic.BetaVaultCredentialNewParamsAuthUnion{
+ OfStaticBearer: &anthropic.BetaManagedAgentsStaticBearerCreateParams{
+ Token: "bearer_exampletoken",
+ MCPServerURL: "https://example-server.modelcontextprotocol.io/sse",
+ Type: anthropic.BetaManagedAgentsStaticBearerCreateParamsTypeStaticBearer,
+ },
+ },
+ DisplayName: anthropic.String("Example credential"),
+ Metadata: map[string]string{
+ "environment": "production",
+ },
+ Betas: []anthropic.AnthropicBeta{anthropic.AnthropicBetaMessageBatches2024_09_24},
+ },
+ )
+ if err != nil {
+ var apierr *anthropic.Error
+ if errors.As(err, &apierr) {
+ t.Log(string(apierr.DumpRequest(true)))
+ }
+ t.Fatalf("err should be nil: %s", err.Error())
+ }
+}
+
+func TestBetaVaultCredentialGetWithOptionalParams(t *testing.T) {
+ baseURL := "http://localhost:4010"
+ if envURL, ok := os.LookupEnv("TEST_API_BASE_URL"); ok {
+ baseURL = envURL
+ }
+ if !testutil.CheckTestServer(t, baseURL) {
+ return
+ }
+ client := anthropic.NewClient(
+ option.WithBaseURL(baseURL),
+ option.WithAPIKey("my-anthropic-api-key"),
+ )
+ _, err := client.Beta.Vaults.Credentials.Get(
+ context.TODO(),
+ "vcrd_011CZkZEMt8gZan2iYOQfSkw",
+ anthropic.BetaVaultCredentialGetParams{
+ VaultID: "vlt_011CZkZDLs7fYzm1hXNPeRjv",
+ Betas: []anthropic.AnthropicBeta{anthropic.AnthropicBetaMessageBatches2024_09_24},
+ },
+ )
+ if err != nil {
+ var apierr *anthropic.Error
+ if errors.As(err, &apierr) {
+ t.Log(string(apierr.DumpRequest(true)))
+ }
+ t.Fatalf("err should be nil: %s", err.Error())
+ }
+}
+
+func TestBetaVaultCredentialUpdateWithOptionalParams(t *testing.T) {
+ baseURL := "http://localhost:4010"
+ if envURL, ok := os.LookupEnv("TEST_API_BASE_URL"); ok {
+ baseURL = envURL
+ }
+ if !testutil.CheckTestServer(t, baseURL) {
+ return
+ }
+ client := anthropic.NewClient(
+ option.WithBaseURL(baseURL),
+ option.WithAPIKey("my-anthropic-api-key"),
+ )
+ _, err := client.Beta.Vaults.Credentials.Update(
+ context.TODO(),
+ "vcrd_011CZkZEMt8gZan2iYOQfSkw",
+ anthropic.BetaVaultCredentialUpdateParams{
+ VaultID: "vlt_011CZkZDLs7fYzm1hXNPeRjv",
+ Auth: anthropic.BetaVaultCredentialUpdateParamsAuthUnion{
+ OfMCPOAuth: &anthropic.BetaManagedAgentsMCPOAuthUpdateParams{
+ Type: anthropic.BetaManagedAgentsMCPOAuthUpdateParamsTypeMCPOAuth,
+ AccessToken: anthropic.String("x"),
+ ExpiresAt: anthropic.Time(time.Now()),
+ Refresh: anthropic.BetaManagedAgentsMCPOAuthRefreshUpdateParams{
+ RefreshToken: anthropic.String("x"),
+ Scope: anthropic.String("scope"),
+ TokenEndpointAuth: anthropic.BetaManagedAgentsMCPOAuthRefreshUpdateParamsTokenEndpointAuthUnion{
+ OfClientSecretBasic: &anthropic.BetaManagedAgentsTokenEndpointAuthBasicUpdateParam{
+ Type: anthropic.BetaManagedAgentsTokenEndpointAuthBasicUpdateParamTypeClientSecretBasic,
+ ClientSecret: anthropic.String("x"),
+ },
+ },
+ },
+ },
+ },
+ DisplayName: anthropic.String("Example credential"),
+ Metadata: map[string]string{
+ "environment": "production",
+ },
+ Betas: []anthropic.AnthropicBeta{anthropic.AnthropicBetaMessageBatches2024_09_24},
+ },
+ )
+ if err != nil {
+ var apierr *anthropic.Error
+ if errors.As(err, &apierr) {
+ t.Log(string(apierr.DumpRequest(true)))
+ }
+ t.Fatalf("err should be nil: %s", err.Error())
+ }
+}
+
+func TestBetaVaultCredentialListWithOptionalParams(t *testing.T) {
+ t.Skip("buildURL drops path-level query params (SDK-4349)")
+ baseURL := "http://localhost:4010"
+ if envURL, ok := os.LookupEnv("TEST_API_BASE_URL"); ok {
+ baseURL = envURL
+ }
+ if !testutil.CheckTestServer(t, baseURL) {
+ return
+ }
+ client := anthropic.NewClient(
+ option.WithBaseURL(baseURL),
+ option.WithAPIKey("my-anthropic-api-key"),
+ )
+ _, err := client.Beta.Vaults.Credentials.List(
+ context.TODO(),
+ "vlt_011CZkZDLs7fYzm1hXNPeRjv",
+ anthropic.BetaVaultCredentialListParams{
+ IncludeArchived: anthropic.Bool(true),
+ Limit: anthropic.Int(0),
+ Page: anthropic.String("page"),
+ Betas: []anthropic.AnthropicBeta{anthropic.AnthropicBetaMessageBatches2024_09_24},
+ },
+ )
+ if err != nil {
+ var apierr *anthropic.Error
+ if errors.As(err, &apierr) {
+ t.Log(string(apierr.DumpRequest(true)))
+ }
+ t.Fatalf("err should be nil: %s", err.Error())
+ }
+}
+
+func TestBetaVaultCredentialDeleteWithOptionalParams(t *testing.T) {
+ baseURL := "http://localhost:4010"
+ if envURL, ok := os.LookupEnv("TEST_API_BASE_URL"); ok {
+ baseURL = envURL
+ }
+ if !testutil.CheckTestServer(t, baseURL) {
+ return
+ }
+ client := anthropic.NewClient(
+ option.WithBaseURL(baseURL),
+ option.WithAPIKey("my-anthropic-api-key"),
+ )
+ _, err := client.Beta.Vaults.Credentials.Delete(
+ context.TODO(),
+ "vcrd_011CZkZEMt8gZan2iYOQfSkw",
+ anthropic.BetaVaultCredentialDeleteParams{
+ VaultID: "vlt_011CZkZDLs7fYzm1hXNPeRjv",
+ Betas: []anthropic.AnthropicBeta{anthropic.AnthropicBetaMessageBatches2024_09_24},
+ },
+ )
+ if err != nil {
+ var apierr *anthropic.Error
+ if errors.As(err, &apierr) {
+ t.Log(string(apierr.DumpRequest(true)))
+ }
+ t.Fatalf("err should be nil: %s", err.Error())
+ }
+}
+
+func TestBetaVaultCredentialArchiveWithOptionalParams(t *testing.T) {
+ baseURL := "http://localhost:4010"
+ if envURL, ok := os.LookupEnv("TEST_API_BASE_URL"); ok {
+ baseURL = envURL
+ }
+ if !testutil.CheckTestServer(t, baseURL) {
+ return
+ }
+ client := anthropic.NewClient(
+ option.WithBaseURL(baseURL),
+ option.WithAPIKey("my-anthropic-api-key"),
+ )
+ _, err := client.Beta.Vaults.Credentials.Archive(
+ context.TODO(),
+ "vcrd_011CZkZEMt8gZan2iYOQfSkw",
+ anthropic.BetaVaultCredentialArchiveParams{
+ VaultID: "vlt_011CZkZDLs7fYzm1hXNPeRjv",
+ Betas: []anthropic.AnthropicBeta{anthropic.AnthropicBetaMessageBatches2024_09_24},
+ },
+ )
+ if err != nil {
+ var apierr *anthropic.Error
+ if errors.As(err, &apierr) {
+ t.Log(string(apierr.DumpRequest(true)))
+ }
+ t.Fatalf("err should be nil: %s", err.Error())
+ }
+}
diff --git a/examples/agents-comprehensive/greeting-SKILL.md b/examples/agents-comprehensive/greeting-SKILL.md
new file mode 100644
index 000000000..9fb9beebc
--- /dev/null
+++ b/examples/agents-comprehensive/greeting-SKILL.md
@@ -0,0 +1,6 @@
+---
+name: greeting
+description: Replaces ordinary greetings with nautical ones.
+---
+
+Whenever the user greets you, respond with "Ahoy!" instead of "Hello".
diff --git a/examples/agents-comprehensive/main.go b/examples/agents-comprehensive/main.go
new file mode 100644
index 000000000..d30d54ba5
--- /dev/null
+++ b/examples/agents-comprehensive/main.go
@@ -0,0 +1,244 @@
+package main
+
+import (
+ "context"
+ "encoding/json"
+ "fmt"
+ "io"
+ "os"
+ "time"
+
+ "github.com/anthropics/anthropic-sdk-go"
+ "github.com/anthropics/anthropic-sdk-go/packages/param"
+)
+
+const (
+ mcpServerName = "github"
+ mcpServerURL = "https://api.githubcopilot.com/mcp/"
+
+ prompt = "Hi! List every tool and skill you have access to, grouped by where they " +
+ "came from (built-in toolset, custom tool, MCP server, skills)."
+)
+
+func main() {
+ client := anthropic.NewClient()
+ ctx := context.TODO()
+
+ githubToken := os.Getenv("GITHUB_TOKEN")
+ if githubToken == "" {
+ panic("GITHUB_TOKEN is required (use a fine-grained PAT with public-repo read only)")
+ }
+
+ // Create an environment
+ environment, err := client.Beta.Environments.New(ctx, anthropic.BetaEnvironmentNewParams{
+ Name: "comprehensive-example-environment",
+ })
+ if err != nil {
+ panic(err)
+ }
+ fmt.Println("Created environment:", environment.ID)
+
+ // Create a vault and store the MCP server credential in it
+ vault, err := client.Beta.Vaults.New(ctx, anthropic.BetaVaultNewParams{
+ DisplayName: "comprehensive-example-vault",
+ })
+ if err != nil {
+ panic(err)
+ }
+ fmt.Println("Created vault:", vault.ID)
+
+ credential, err := client.Beta.Vaults.Credentials.New(ctx, vault.ID, anthropic.BetaVaultCredentialNewParams{
+ DisplayName: param.NewOpt("github-mcp"),
+ Auth: anthropic.BetaVaultCredentialNewParamsAuthUnion{
+ OfStaticBearer: &anthropic.BetaManagedAgentsStaticBearerCreateParams{
+ Type: anthropic.BetaManagedAgentsStaticBearerCreateParamsTypeStaticBearer,
+ MCPServerURL: mcpServerURL,
+ Token: githubToken,
+ },
+ },
+ })
+ if err != nil {
+ panic(err)
+ }
+ fmt.Println("Created credential:", credential.ID)
+
+ // Upload a custom skill
+ skillFile, err := os.Open("agents-comprehensive/greeting-SKILL.md")
+ if err != nil {
+ panic(err)
+ }
+ defer skillFile.Close()
+
+ skill, err := client.Beta.Skills.New(ctx, anthropic.BetaSkillNewParams{
+ DisplayTitle: param.NewOpt(fmt.Sprintf("comprehensive-greeting-%d", time.Now().UnixMilli())),
+ Files: []io.Reader{namedReader{skillFile, "greeting/SKILL.md"}},
+ })
+ if err != nil {
+ panic(err)
+ }
+ fmt.Println("Created skill:", skill.ID)
+
+ // Create v1 of the agent with the built-in toolset, an MCP server, and a custom tool
+ agentV1, err := client.Beta.Agents.New(ctx, anthropic.BetaAgentNewParams{
+ Name: "comprehensive-example-agent",
+ Model: anthropic.BetaManagedAgentsModelConfigParams{
+ ID: anthropic.BetaManagedAgentsModelClaudeSonnet4_6,
+ },
+ System: param.NewOpt("You are a helpful assistant."),
+ MCPServers: []anthropic.BetaManagedAgentsURLMCPServerParams{
+ {
+ Type: anthropic.BetaManagedAgentsURLMCPServerParamsTypeURL,
+ Name: mcpServerName,
+ URL: mcpServerURL,
+ },
+ },
+ Tools: []anthropic.BetaAgentNewParamsToolUnion{
+ {
+ OfAgentToolset20260401: &anthropic.BetaManagedAgentsAgentToolset20260401Params{
+ Type: anthropic.BetaManagedAgentsAgentToolset20260401ParamsTypeAgentToolset20260401,
+ },
+ },
+ {
+ OfMCPToolset: &anthropic.BetaManagedAgentsMCPToolsetParams{
+ Type: anthropic.BetaManagedAgentsMCPToolsetParamsTypeMCPToolset,
+ MCPServerName: mcpServerName,
+ },
+ },
+ {
+ OfCustom: &anthropic.BetaManagedAgentsCustomToolParams{
+ Type: anthropic.BetaManagedAgentsCustomToolParamsTypeCustom,
+ Name: "get_weather",
+ Description: "Look up the current weather for a city.",
+ InputSchema: anthropic.BetaManagedAgentsCustomToolInputSchemaParam{
+ Type: anthropic.BetaManagedAgentsCustomToolInputSchemaTypeObject,
+ Properties: map[string]any{"city": map[string]any{"type": "string"}},
+ Required: []string{"city"},
+ },
+ },
+ },
+ },
+ })
+ if err != nil {
+ panic(err)
+ }
+ fmt.Println("Created agent v1:", agentV1.ID)
+
+ // Patch the agent to v2 by adding skills; each update bumps the version
+ agent, err := client.Beta.Agents.Update(ctx, agentV1.ID, anthropic.BetaAgentUpdateParams{
+ Version: agentV1.Version,
+ Skills: []anthropic.BetaManagedAgentsSkillParamsUnion{
+ {
+ OfCustom: &anthropic.BetaManagedAgentsCustomSkillParams{
+ Type: anthropic.BetaManagedAgentsCustomSkillParamsTypeCustom,
+ SkillID: skill.ID,
+ },
+ },
+ {
+ OfAnthropic: &anthropic.BetaManagedAgentsAnthropicSkillParams{
+ Type: anthropic.BetaManagedAgentsAnthropicSkillParamsTypeAnthropic,
+ SkillID: "xlsx",
+ },
+ },
+ },
+ })
+ if err != nil {
+ panic(err)
+ }
+ fmt.Println("Patched agent to v2:", agent.ID)
+
+ // List agent versions
+ versions := client.Beta.Agents.Versions.ListAutoPaging(ctx, agent.ID, anthropic.BetaAgentVersionListParams{})
+ for versions.Next() {
+ v := versions.Current()
+ fmt.Printf(" version %d (created %s)\n", v.Version, v.CreatedAt)
+ }
+ if versions.Err() != nil {
+ panic(versions.Err())
+ }
+
+ // Create a session pinned to v2; the vault supplies the MCP credential
+ session, err := client.Beta.Sessions.New(ctx, anthropic.BetaSessionNewParams{
+ EnvironmentID: environment.ID,
+ Agent: anthropic.BetaSessionNewParamsAgentUnion{
+ OfBetaManagedAgentsAgents: &anthropic.BetaManagedAgentsAgentParams{
+ ID: agent.ID,
+ Type: anthropic.BetaManagedAgentsAgentParamsTypeAgent,
+ Version: param.NewOpt(agent.Version),
+ },
+ },
+ VaultIDs: []string{vault.ID},
+ })
+ if err != nil {
+ panic(err)
+ }
+ fmt.Println("Created session:", session.ID)
+
+ // Send a prompt and stream events, answering the custom tool if called
+ fmt.Println("Streaming events:")
+ _, err = client.Beta.Sessions.Events.Send(ctx, session.ID, anthropic.BetaSessionEventSendParams{
+ Events: []anthropic.BetaManagedAgentsEventParamsUnion{
+ {
+ OfUserMessage: &anthropic.BetaManagedAgentsUserMessageEventParams{
+ Type: anthropic.BetaManagedAgentsUserMessageEventParamsTypeUserMessage,
+ Content: []anthropic.BetaManagedAgentsUserMessageEventParamsContentUnion{
+ {
+ OfText: &anthropic.BetaManagedAgentsTextBlockParam{
+ Text: prompt,
+ Type: anthropic.BetaManagedAgentsTextBlockTypeText,
+ },
+ },
+ },
+ },
+ },
+ },
+ })
+ if err != nil {
+ panic(err)
+ }
+
+ stream := client.Beta.Sessions.Events.StreamEvents(ctx, session.ID, anthropic.BetaSessionEventStreamParams{})
+ for stream.Next() {
+ event := stream.Current()
+ data, _ := json.MarshalIndent(event, "", " ")
+ fmt.Println(string(data))
+
+ if event.Type == "agent.custom_tool_use" && event.Name == "get_weather" {
+ _, err = client.Beta.Sessions.Events.Send(ctx, session.ID, anthropic.BetaSessionEventSendParams{
+ Events: []anthropic.BetaManagedAgentsEventParamsUnion{
+ {
+ OfUserCustomToolResult: &anthropic.BetaManagedAgentsUserCustomToolResultEventParams{
+ Type: anthropic.BetaManagedAgentsUserCustomToolResultEventParamsTypeUserCustomToolResult,
+ CustomToolUseID: event.ID,
+ Content: []anthropic.BetaManagedAgentsUserCustomToolResultEventParamsContentUnion{
+ {
+ OfText: &anthropic.BetaManagedAgentsTextBlockParam{
+ Text: `{"temperature_c": 14}`,
+ Type: anthropic.BetaManagedAgentsTextBlockTypeText,
+ },
+ },
+ },
+ },
+ },
+ },
+ })
+ if err != nil {
+ panic(err)
+ }
+ }
+
+ if event.Type == "session.status_idle" && event.StopReason.Type == "end_turn" {
+ break
+ }
+ }
+ if stream.Err() != nil {
+ panic(stream.Err())
+ }
+}
+
+// namedReader wraps an io.Reader with a custom filename for multipart uploads.
+type namedReader struct {
+ io.Reader
+ name string
+}
+
+func (r namedReader) Filename() string { return r.name }
diff --git a/examples/agents-with-files/data.csv b/examples/agents-with-files/data.csv
new file mode 100644
index 000000000..a79407137
--- /dev/null
+++ b/examples/agents-with-files/data.csv
@@ -0,0 +1,3 @@
+alpha,bravo,charlie
+1,2,3
+4,5,6
diff --git a/examples/agents-with-files/main.go b/examples/agents-with-files/main.go
new file mode 100644
index 000000000..2a0c38b5b
--- /dev/null
+++ b/examples/agents-with-files/main.go
@@ -0,0 +1,129 @@
+package main
+
+import (
+ "context"
+ "encoding/json"
+ "fmt"
+ "os"
+
+ "github.com/anthropics/anthropic-sdk-go"
+ "github.com/anthropics/anthropic-sdk-go/packages/param"
+)
+
+func main() {
+ client := anthropic.NewClient()
+ ctx := context.TODO()
+
+ // Create an environment
+ environment, err := client.Beta.Environments.New(ctx, anthropic.BetaEnvironmentNewParams{
+ Name: "files-example-environment",
+ })
+ if err != nil {
+ panic(err)
+ }
+ fmt.Println("Created environment:", environment.ID)
+
+ // Create an agent with the built-in toolset and an always-allow permission policy
+ agent, err := client.Beta.Agents.New(ctx, anthropic.BetaAgentNewParams{
+ Name: "files-example-agent",
+ Model: anthropic.BetaManagedAgentsModelConfigParams{
+ ID: anthropic.BetaManagedAgentsModelClaudeSonnet4_6,
+ },
+ Tools: []anthropic.BetaAgentNewParamsToolUnion{
+ {
+ OfAgentToolset20260401: &anthropic.BetaManagedAgentsAgentToolset20260401Params{
+ Type: anthropic.BetaManagedAgentsAgentToolset20260401ParamsTypeAgentToolset20260401,
+ DefaultConfig: anthropic.BetaManagedAgentsAgentToolsetDefaultConfigParams{
+ Enabled: param.NewOpt(true),
+ PermissionPolicy: anthropic.BetaManagedAgentsAgentToolsetDefaultConfigParamsPermissionPolicyUnion{
+ OfAlwaysAllow: &anthropic.BetaManagedAgentsAlwaysAllowPolicyParam{
+ Type: anthropic.BetaManagedAgentsAlwaysAllowPolicyTypeAlwaysAllow,
+ },
+ },
+ },
+ },
+ },
+ },
+ })
+ if err != nil {
+ panic(err)
+ }
+ fmt.Println("Created agent:", agent.ID)
+
+ // Upload a file
+ csvFile, err := os.Open("agents-with-files/data.csv")
+ if err != nil {
+ panic(err)
+ }
+ defer csvFile.Close()
+
+ file, err := client.Beta.Files.Upload(ctx, anthropic.BetaFileUploadParams{
+ File: csvFile,
+ })
+ if err != nil {
+ panic(err)
+ }
+ fmt.Println("Uploaded file:", file.ID)
+
+ // Create a session with the file mounted as a resource
+ session, err := client.Beta.Sessions.New(ctx, anthropic.BetaSessionNewParams{
+ EnvironmentID: environment.ID,
+ Agent: anthropic.BetaSessionNewParamsAgentUnion{
+ OfBetaManagedAgentsAgents: &anthropic.BetaManagedAgentsAgentParams{
+ ID: agent.ID,
+ Type: anthropic.BetaManagedAgentsAgentParamsTypeAgent,
+ Version: param.NewOpt(agent.Version),
+ },
+ },
+ Resources: []anthropic.BetaSessionNewParamsResourceUnion{
+ {
+ OfFile: &anthropic.BetaManagedAgentsFileResourceParams{
+ Type: anthropic.BetaManagedAgentsFileResourceParamsTypeFile,
+ FileID: file.ID,
+ MountPath: param.NewOpt("data.csv"),
+ },
+ },
+ },
+ })
+ if err != nil {
+ panic(err)
+ }
+ fmt.Println("Created session:", session.ID)
+
+ // Send a prompt asking the agent to read the mounted file
+ fmt.Println("Streaming events:")
+ _, err = client.Beta.Sessions.Events.Send(ctx, session.ID, anthropic.BetaSessionEventSendParams{
+ Events: []anthropic.BetaManagedAgentsEventParamsUnion{
+ {
+ OfUserMessage: &anthropic.BetaManagedAgentsUserMessageEventParams{
+ Type: anthropic.BetaManagedAgentsUserMessageEventParamsTypeUserMessage,
+ Content: []anthropic.BetaManagedAgentsUserMessageEventParamsContentUnion{
+ {
+ OfText: &anthropic.BetaManagedAgentsTextBlockParam{
+ Text: "Read /uploads/data.csv and tell me the column names.",
+ Type: anthropic.BetaManagedAgentsTextBlockTypeText,
+ },
+ },
+ },
+ },
+ },
+ },
+ })
+ if err != nil {
+ panic(err)
+ }
+
+ // Stream events until the session goes idle
+ stream := client.Beta.Sessions.Events.StreamEvents(ctx, session.ID, anthropic.BetaSessionEventStreamParams{})
+ for stream.Next() {
+ event := stream.Current()
+ data, _ := json.MarshalIndent(event, "", " ")
+ fmt.Println(string(data))
+ if event.Type == "session.status_idle" {
+ break
+ }
+ }
+ if stream.Err() != nil {
+ panic(stream.Err())
+ }
+}
diff --git a/examples/agents/main.go b/examples/agents/main.go
new file mode 100644
index 000000000..c10ec40d6
--- /dev/null
+++ b/examples/agents/main.go
@@ -0,0 +1,87 @@
+package main
+
+import (
+ "context"
+ "encoding/json"
+ "fmt"
+
+ "github.com/anthropics/anthropic-sdk-go"
+)
+
+func main() {
+ client := anthropic.NewClient()
+ ctx := context.TODO()
+
+ // Create an environment
+ environment, err := client.Beta.Environments.New(ctx, anthropic.BetaEnvironmentNewParams{
+ Name: "simple-example-environment",
+ })
+ if err != nil {
+ panic(err)
+ }
+ fmt.Println("Created environment:", environment.ID)
+
+ // Create an agent
+ agent, err := client.Beta.Agents.New(ctx, anthropic.BetaAgentNewParams{
+ Name: "simple-example-agent",
+ Model: anthropic.BetaManagedAgentsModelConfigParams{
+ ID: anthropic.BetaManagedAgentsModelClaudeSonnet4_6,
+ },
+ })
+ if err != nil {
+ panic(err)
+ }
+ fmt.Println("Created agent:", agent.ID)
+
+ // Create a session
+ session, err := client.Beta.Sessions.New(ctx, anthropic.BetaSessionNewParams{
+ EnvironmentID: environment.ID,
+ Agent: anthropic.BetaSessionNewParamsAgentUnion{
+ OfBetaManagedAgentsAgents: &anthropic.BetaManagedAgentsAgentParams{
+ ID: agent.ID,
+ Type: anthropic.BetaManagedAgentsAgentParamsTypeAgent,
+ },
+ },
+ })
+ if err != nil {
+ panic(err)
+ }
+ fmt.Println("Created session:", session.ID)
+
+ // Send a user message
+ _, err = client.Beta.Sessions.Events.Send(ctx, session.ID, anthropic.BetaSessionEventSendParams{
+ Events: []anthropic.BetaManagedAgentsEventParamsUnion{
+ {
+ OfUserMessage: &anthropic.BetaManagedAgentsUserMessageEventParams{
+ Type: anthropic.BetaManagedAgentsUserMessageEventParamsTypeUserMessage,
+ Content: []anthropic.BetaManagedAgentsUserMessageEventParamsContentUnion{
+ {
+ OfText: &anthropic.BetaManagedAgentsTextBlockParam{
+ Text: "Hello Claude!",
+ Type: anthropic.BetaManagedAgentsTextBlockTypeText,
+ },
+ },
+ },
+ },
+ },
+ },
+ })
+ if err != nil {
+ panic(err)
+ }
+
+ // Stream events until the session goes idle
+ fmt.Println("Streaming events:")
+ stream := client.Beta.Sessions.Events.StreamEvents(ctx, session.ID, anthropic.BetaSessionEventStreamParams{})
+ for stream.Next() {
+ event := stream.Current()
+ data, _ := json.MarshalIndent(event, "", " ")
+ fmt.Println(string(data))
+ if event.Type == "session.status_idle" {
+ break
+ }
+ }
+ if stream.Err() != nil {
+ panic(stream.Err())
+ }
+}
diff --git a/internal/apiform/encoder.go b/internal/apiform/encoder.go
index d987608bc..2d8e3d08f 100644
--- a/internal/apiform/encoder.go
+++ b/internal/apiform/encoder.go
@@ -21,7 +21,7 @@ var encoders sync.Map // map[encoderEntry]encoderFunc
func Marshal(value any, writer *multipart.Writer) error {
e := &encoder{
dateFormat: time.RFC3339,
- arrayFmt: "comma",
+ arrayFmt: "brackets",
}
return e.marshal(value, writer)
}
@@ -30,7 +30,7 @@ func MarshalRoot(value any, writer *multipart.Writer) error {
e := &encoder{
root: true,
dateFormat: time.RFC3339,
- arrayFmt: "comma",
+ arrayFmt: "brackets",
}
return e.marshal(value, writer)
}
diff --git a/internal/version.go b/internal/version.go
index d10cb0080..6d1a6f936 100644
--- a/internal/version.go
+++ b/internal/version.go
@@ -2,4 +2,4 @@
package internal
-const PackageVersion = "1.32.0" // x-release-please-version
+const PackageVersion = "1.33.0" // x-release-please-version
diff --git a/packages/pagination/pagination.go b/packages/pagination/pagination.go
index 16a78035a..d0dd33a0b 100644
--- a/packages/pagination/pagination.go
+++ b/packages/pagination/pagination.go
@@ -245,12 +245,10 @@ func (r *TokenPageAutoPager[T]) Index() int {
type PageCursor[T any] struct {
Data []T `json:"data"`
- HasMore bool `json:"has_more"`
NextPage string `json:"next_page" api:"nullable"`
// JSON contains metadata for fields, check presence with [respjson.Field.Valid].
JSON struct {
Data respjson.Field
- HasMore respjson.Field
NextPage respjson.Field
ExtraFields map[string]respjson.Field
raw string
@@ -272,10 +270,6 @@ func (r *PageCursor[T]) GetNextPage() (res *PageCursor[T], err error) {
if len(r.Data) == 0 {
return nil, nil
}
-
- if r.JSON.HasMore.Valid() && r.HasMore == false {
- return nil, nil
- }
next := r.NextPage
if len(next) == 0 {
return nil, nil
diff --git a/packages/ssestream/ssestream.go b/packages/ssestream/ssestream.go
index 777e2197c..901ef808b 100644
--- a/packages/ssestream/ssestream.go
+++ b/packages/ssestream/ssestream.go
@@ -159,7 +159,7 @@ func (s *Stream[T]) Next() bool {
}
s.cur = nxt
return true
- case "message_start", "message_delta", "message_stop", "content_block_start", "content_block_delta", "content_block_stop":
+ case "message_start", "message_delta", "message_stop", "content_block_start", "content_block_delta", "content_block_stop", "message":
var nxt T
s.err = json.Unmarshal(s.decoder.Event().Data, &nxt)
if s.err != nil {
diff --git a/scripts/detect-breaking-changes b/scripts/detect-breaking-changes
index e0b2c7179..20ac0285d 100755
--- a/scripts/detect-breaking-changes
+++ b/scripts/detect-breaking-changes
@@ -15,6 +15,14 @@ TEST_PATHS=(
betamodel_test.go
betamessage_test.go
betamessagebatch_test.go
+ betaagent_test.go
+ betaagentversion_test.go
+ betaenvironment_test.go
+ betasession_test.go
+ betasessionevent_test.go
+ betasessionresource_test.go
+ betavault_test.go
+ betavaultcredential_test.go
betafile_test.go
betaskill_test.go
betaskillversion_test.go
diff --git a/scripts/mock b/scripts/mock
index 5cd7c157b..1f84b12f7 100755
--- a/scripts/mock
+++ b/scripts/mock
@@ -24,7 +24,7 @@ if [ "$1" == "--daemon" ]; then
# Pre-install the package so the download doesn't eat into the startup timeout
npm exec --package=@stdy/cli@0.20.2 -- steady --version
- npm exec --package=@stdy/cli@0.20.2 -- steady --host 127.0.0.1 -p 4010 --validator-query-array-format=comma --validator-form-array-format=comma --validator-query-object-format=brackets --validator-form-object-format=brackets "$URL" &> .stdy.log &
+ npm exec --package=@stdy/cli@0.20.2 -- steady --host 127.0.0.1 -p 4010 --validator-query-array-format=comma --validator-form-array-format=brackets --validator-query-object-format=brackets --validator-form-object-format=brackets "$URL" &> .stdy.log &
# Wait for server to come online via health endpoint (max 30s)
echo -n "Waiting for server"
@@ -48,5 +48,5 @@ if [ "$1" == "--daemon" ]; then
echo
else
- npm exec --package=@stdy/cli@0.20.2 -- steady --host 127.0.0.1 -p 4010 --validator-query-array-format=comma --validator-form-array-format=comma --validator-query-object-format=brackets --validator-form-object-format=brackets "$URL"
+ npm exec --package=@stdy/cli@0.20.2 -- steady --host 127.0.0.1 -p 4010 --validator-query-array-format=comma --validator-form-array-format=brackets --validator-query-object-format=brackets --validator-form-object-format=brackets "$URL"
fi
diff --git a/scripts/test b/scripts/test
index c3a0d2cc5..1bd9a5183 100755
--- a/scripts/test
+++ b/scripts/test
@@ -43,7 +43,7 @@ elif ! steady_is_running ; then
echo -e "To run the server, pass in the path or url of your OpenAPI"
echo -e "spec to the steady command:"
echo
- echo -e " \$ ${YELLOW}npm exec --package=@stdy/cli@0.20.2 -- steady path/to/your.openapi.yml --host 127.0.0.1 -p 4010 --validator-query-array-format=comma --validator-form-array-format=comma --validator-query-object-format=brackets --validator-form-object-format=brackets${NC}"
+ echo -e " \$ ${YELLOW}npm exec --package=@stdy/cli@0.20.2 -- steady path/to/your.openapi.yml --host 127.0.0.1 -p 4010 --validator-query-array-format=comma --validator-form-array-format=brackets --validator-query-object-format=brackets --validator-form-object-format=brackets${NC}"
echo
exit 1
diff --git a/shared/constant/constants.go b/shared/constant/constants.go
index b465e3c43..a91bf4b11 100644
--- a/shared/constant/constants.go
+++ b/shared/constant/constants.go
@@ -54,6 +54,7 @@ type CharLocation string // Always "char_location"
type CitationsDelta string // Always "citations_delta"
type ClearThinking20251015 string // Always "clear_thinking_20251015"
type ClearToolUses20250919 string // Always "clear_tool_uses_20250919"
+type Cloud string // Always "cloud"
type CodeExecution string // Always "code_execution"
type CodeExecution20250522 string // Always "code_execution_20250522"
type CodeExecution20250825 string // Always "code_execution_20250825"
@@ -83,6 +84,8 @@ type Disabled string // Always "disabled"
type Document string // Always "document"
type Enabled string // Always "enabled"
type EncryptedCodeExecutionResult string // Always "encrypted_code_execution_result"
+type Environment string // Always "environment"
+type EnvironmentDeleted string // Always "environment_deleted"
type Ephemeral string // Always "ephemeral"
type Error string // Always "error"
type Errored string // Always "errored"
@@ -94,6 +97,7 @@ type InputTokens string // Always "input_tokens"
type Insert string // Always "insert"
type InvalidRequestError string // Always "invalid_request_error"
type JSONSchema string // Always "json_schema"
+type Limited string // Always "limited"
type MCPToolResult string // Always "mcp_tool_result"
type MCPToolUse string // Always "mcp_tool_use"
type MCPToolset string // Always "mcp_toolset"
@@ -119,6 +123,7 @@ type Rename string // Always "rename"
type SearchResult string // Always "search_result"
type SearchResultLocation string // Always "search_result_location"
type ServerToolUse string // Always "server_tool_use"
+type Session string // Always "session"
type SignatureDelta string // Always "signature_delta"
type StrReplace string // Always "str_replace"
type StrReplaceBasedEditTool string // Always "str_replace_based_edit_tool"
@@ -150,6 +155,7 @@ type ToolSearchToolResultError string // Always "tool_search_tool_
type ToolSearchToolSearchResult string // Always "tool_search_tool_search_result"
type ToolUse string // Always "tool_use"
type ToolUses string // Always "tool_uses"
+type Unrestricted string // Always "unrestricted"
type URL string // Always "url"
type View string // Always "view"
type WebFetch string // Always "web_fetch"
@@ -198,6 +204,7 @@ func (c CharLocation) Default() CharLocation { return "char_lo
func (c CitationsDelta) Default() CitationsDelta { return "citations_delta" }
func (c ClearThinking20251015) Default() ClearThinking20251015 { return "clear_thinking_20251015" }
func (c ClearToolUses20250919) Default() ClearToolUses20250919 { return "clear_tool_uses_20250919" }
+func (c Cloud) Default() Cloud { return "cloud" }
func (c CodeExecution) Default() CodeExecution { return "code_execution" }
func (c CodeExecution20250522) Default() CodeExecution20250522 { return "code_execution_20250522" }
func (c CodeExecution20250825) Default() CodeExecution20250825 { return "code_execution_20250825" }
@@ -233,6 +240,8 @@ func (c Enabled) Default() Enabled { return "enabled"
func (c EncryptedCodeExecutionResult) Default() EncryptedCodeExecutionResult {
return "encrypted_code_execution_result"
}
+func (c Environment) Default() Environment { return "environment" }
+func (c EnvironmentDeleted) Default() EnvironmentDeleted { return "environment_deleted" }
func (c Ephemeral) Default() Ephemeral { return "ephemeral" }
func (c Error) Default() Error { return "error" }
func (c Errored) Default() Errored { return "errored" }
@@ -244,6 +253,7 @@ func (c InputTokens) Default() InputTokens { return "input_tok
func (c Insert) Default() Insert { return "insert" }
func (c InvalidRequestError) Default() InvalidRequestError { return "invalid_request_error" }
func (c JSONSchema) Default() JSONSchema { return "json_schema" }
+func (c Limited) Default() Limited { return "limited" }
func (c MCPToolResult) Default() MCPToolResult { return "mcp_tool_result" }
func (c MCPToolUse) Default() MCPToolUse { return "mcp_tool_use" }
func (c MCPToolset) Default() MCPToolset { return "mcp_toolset" }
@@ -269,6 +279,7 @@ func (c Rename) Default() Rename { return "rename" }
func (c SearchResult) Default() SearchResult { return "search_result" }
func (c SearchResultLocation) Default() SearchResultLocation { return "search_result_location" }
func (c ServerToolUse) Default() ServerToolUse { return "server_tool_use" }
+func (c Session) Default() Session { return "session" }
func (c SignatureDelta) Default() SignatureDelta { return "signature_delta" }
func (c StrReplace) Default() StrReplace { return "str_replace" }
func (c StrReplaceBasedEditTool) Default() StrReplaceBasedEditTool {
@@ -316,6 +327,7 @@ func (c ToolSearchToolSearchResult) Default() ToolSearchToolSearchResult {
}
func (c ToolUse) Default() ToolUse { return "tool_use" }
func (c ToolUses) Default() ToolUses { return "tool_uses" }
+func (c Unrestricted) Default() Unrestricted { return "unrestricted" }
func (c URL) Default() URL { return "url" }
func (c View) Default() View { return "view" }
func (c WebFetch) Default() WebFetch { return "web_fetch" }
@@ -362,6 +374,7 @@ func (c CharLocation) MarshalJSON() ([]byte, error) { ret
func (c CitationsDelta) MarshalJSON() ([]byte, error) { return marshalString(c) }
func (c ClearThinking20251015) MarshalJSON() ([]byte, error) { return marshalString(c) }
func (c ClearToolUses20250919) MarshalJSON() ([]byte, error) { return marshalString(c) }
+func (c Cloud) MarshalJSON() ([]byte, error) { return marshalString(c) }
func (c CodeExecution) MarshalJSON() ([]byte, error) { return marshalString(c) }
func (c CodeExecution20250522) MarshalJSON() ([]byte, error) { return marshalString(c) }
func (c CodeExecution20250825) MarshalJSON() ([]byte, error) { return marshalString(c) }
@@ -391,6 +404,8 @@ func (c Disabled) MarshalJSON() ([]byte, error) { ret
func (c Document) MarshalJSON() ([]byte, error) { return marshalString(c) }
func (c Enabled) MarshalJSON() ([]byte, error) { return marshalString(c) }
func (c EncryptedCodeExecutionResult) MarshalJSON() ([]byte, error) { return marshalString(c) }
+func (c Environment) MarshalJSON() ([]byte, error) { return marshalString(c) }
+func (c EnvironmentDeleted) MarshalJSON() ([]byte, error) { return marshalString(c) }
func (c Ephemeral) MarshalJSON() ([]byte, error) { return marshalString(c) }
func (c Error) MarshalJSON() ([]byte, error) { return marshalString(c) }
func (c Errored) MarshalJSON() ([]byte, error) { return marshalString(c) }
@@ -402,6 +417,7 @@ func (c InputTokens) MarshalJSON() ([]byte, error) { ret
func (c Insert) MarshalJSON() ([]byte, error) { return marshalString(c) }
func (c InvalidRequestError) MarshalJSON() ([]byte, error) { return marshalString(c) }
func (c JSONSchema) MarshalJSON() ([]byte, error) { return marshalString(c) }
+func (c Limited) MarshalJSON() ([]byte, error) { return marshalString(c) }
func (c MCPToolResult) MarshalJSON() ([]byte, error) { return marshalString(c) }
func (c MCPToolUse) MarshalJSON() ([]byte, error) { return marshalString(c) }
func (c MCPToolset) MarshalJSON() ([]byte, error) { return marshalString(c) }
@@ -427,6 +443,7 @@ func (c Rename) MarshalJSON() ([]byte, error) { ret
func (c SearchResult) MarshalJSON() ([]byte, error) { return marshalString(c) }
func (c SearchResultLocation) MarshalJSON() ([]byte, error) { return marshalString(c) }
func (c ServerToolUse) MarshalJSON() ([]byte, error) { return marshalString(c) }
+func (c Session) MarshalJSON() ([]byte, error) { return marshalString(c) }
func (c SignatureDelta) MarshalJSON() ([]byte, error) { return marshalString(c) }
func (c StrReplace) MarshalJSON() ([]byte, error) { return marshalString(c) }
func (c StrReplaceBasedEditTool) MarshalJSON() ([]byte, error) { return marshalString(c) }
@@ -462,6 +479,7 @@ func (c ToolSearchToolResultError) MarshalJSON() ([]byte, error) { retur
func (c ToolSearchToolSearchResult) MarshalJSON() ([]byte, error) { return marshalString(c) }
func (c ToolUse) MarshalJSON() ([]byte, error) { return marshalString(c) }
func (c ToolUses) MarshalJSON() ([]byte, error) { return marshalString(c) }
+func (c Unrestricted) MarshalJSON() ([]byte, error) { return marshalString(c) }
func (c URL) MarshalJSON() ([]byte, error) { return marshalString(c) }
func (c View) MarshalJSON() ([]byte, error) { return marshalString(c) }
func (c WebFetch) MarshalJSON() ([]byte, error) { return marshalString(c) }