github.com/anthropics/anthropic-sdk-go@v1.70.1/beta.go

// File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.

package anthropic

import (
	"encoding/json"

	"github.com/anthropics/anthropic-sdk-go/internal/apijson"
	"github.com/anthropics/anthropic-sdk-go/option"
	"github.com/anthropics/anthropic-sdk-go/packages/param"
	"github.com/anthropics/anthropic-sdk-go/packages/respjson"
	"github.com/anthropics/anthropic-sdk-go/shared/constant"
)

// BetaService 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 [NewBetaService] method instead.
type BetaService struct {
	Options        []option.RequestOption
	Models         BetaModelService
	Messages       BetaMessageService
	Agents         BetaAgentService
	Environments   BetaEnvironmentService
	Sessions       BetaSessionService
	Deployments    BetaDeploymentService
	DeploymentRuns BetaDeploymentRunService
	Vaults         BetaVaultService
	MemoryStores   BetaMemoryStoreService
	Files          BetaFileService
	Skills         BetaSkillService
	Webhooks       BetaWebhookService
	UserProfiles   BetaUserProfileService
	Dreams         BetaDreamService
	Tunnels        BetaTunnelService
	Organization   BetaOrganizationService
}

// NewBetaService 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 NewBetaService(opts ...option.RequestOption) (r BetaService) {
	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.Deployments = NewBetaDeploymentService(opts...)
	r.DeploymentRuns = NewBetaDeploymentRunService(opts...)
	r.Vaults = NewBetaVaultService(opts...)
	r.MemoryStores = NewBetaMemoryStoreService(opts...)
	r.Files = NewBetaFileService(opts...)
	r.Skills = NewBetaSkillService(opts...)
	r.Webhooks = NewBetaWebhookService(opts...)
	r.UserProfiles = NewBetaUserProfileService(opts...)
	r.Dreams = NewBetaDreamService(opts...)
	r.Tunnels = NewBetaTunnelService(opts...)
	r.Organization = NewBetaOrganizationService(opts...)
	return
}

type AnthropicBeta = string

const (
	AnthropicBetaMessageBatches2024_09_24               AnthropicBeta = "message-batches-2024-09-24"
	AnthropicBetaPromptCaching2024_07_31                AnthropicBeta = "prompt-caching-2024-07-31"
	AnthropicBetaComputerUse2024_10_22                  AnthropicBeta = "computer-use-2024-10-22"
	AnthropicBetaComputerUse2025_01_24                  AnthropicBeta = "computer-use-2025-01-24"
	AnthropicBetaPDFs2024_09_25                         AnthropicBeta = "pdfs-2024-09-25"
	AnthropicBetaTokenCounting2024_11_01                AnthropicBeta = "token-counting-2024-11-01"
	AnthropicBetaTokenEfficientTools2025_02_19          AnthropicBeta = "token-efficient-tools-2025-02-19"
	AnthropicBetaOutput128k2025_02_19                   AnthropicBeta = "output-128k-2025-02-19"
	AnthropicBetaFilesAPI2025_04_14                     AnthropicBeta = "files-api-2025-04-14"
	AnthropicBetaMCPClient2025_04_04                    AnthropicBeta = "mcp-client-2025-04-04"
	AnthropicBetaMCPClient2025_11_20                    AnthropicBeta = "mcp-client-2025-11-20"
	AnthropicBetaDevFullThinking2025_05_14              AnthropicBeta = "dev-full-thinking-2025-05-14"
	AnthropicBetaInterleavedThinking2025_05_14          AnthropicBeta = "interleaved-thinking-2025-05-14"
	AnthropicBetaCodeExecution2025_05_22                AnthropicBeta = "code-execution-2025-05-22"
	AnthropicBetaExtendedCacheTTL2025_04_11             AnthropicBeta = "extended-cache-ttl-2025-04-11"
	AnthropicBetaContext1m2025_08_07                    AnthropicBeta = "context-1m-2025-08-07"
	AnthropicBetaContextManagement2025_06_27            AnthropicBeta = "context-management-2025-06-27"
	AnthropicBetaModelContextWindowExceeded2025_08_26   AnthropicBeta = "model-context-window-exceeded-2025-08-26"
	AnthropicBetaSkills2025_10_02                       AnthropicBeta = "skills-2025-10-02"
	AnthropicBetaFastMode2026_02_01                     AnthropicBeta = "fast-mode-2026-02-01"
	AnthropicBetaOutput300k2026_03_24                   AnthropicBeta = "output-300k-2026-03-24"
	AnthropicBetaUserProfiles2026_03_24                 AnthropicBeta = "user-profiles-2026-03-24"
	AnthropicBetaUserProfiles2026_08_18                 AnthropicBeta = "user-profiles-2026-08-18"
	AnthropicBetaAdvisorTool2026_03_01                  AnthropicBeta = "advisor-tool-2026-03-01"
	AnthropicBetaManagedAgents2026_04_01                AnthropicBeta = "managed-agents-2026-04-01"
	AnthropicBetaCacheDiagnosis2026_04_07               AnthropicBeta = "cache-diagnosis-2026-04-07"
	AnthropicBetaDreaming2026_04_21                     AnthropicBeta = "dreaming-2026-04-21"
	AnthropicBetaThinkingTokenCount2026_05_13           AnthropicBeta = "thinking-token-count-2026-05-13"
	AnthropicBetaServerSideFallback2026_06_01           AnthropicBeta = "server-side-fallback-2026-06-01"
	AnthropicBetaServerSideFallback2026_07_01           AnthropicBeta = "server-side-fallback-2026-07-01"
	AnthropicBetaFallbackCredit2026_06_01               AnthropicBeta = "fallback-credit-2026-06-01"
	AnthropicBetaFallbackCredit2026_07_01               AnthropicBeta = "fallback-credit-2026-07-01"
	AnthropicBetaAgentMemory2026_07_22                  AnthropicBeta = "agent-memory-2026-07-22"
	AnthropicBetaMidConversationToolChanges2026_07_01   AnthropicBeta = "mid-conversation-tool-changes-2026-07-01"
	AnthropicBetaCompact2026_01_12                      AnthropicBeta = "compact-2026-01-12"
	AnthropicBetaComputerUse2025_11_24                  AnthropicBeta = "computer-use-2025-11-24"
	AnthropicBetaMCPTunnels2026_06_22                   AnthropicBeta = "mcp-tunnels-2026-06-22"
	AnthropicBetaStructuredOutputs2025_11_13            AnthropicBeta = "structured-outputs-2025-11-13"
	AnthropicBetaTaskBudgets2026_03_13                  AnthropicBeta = "task-budgets-2026-03-13"
	AnthropicBetaThinkingDisplayUpdates2026_08_18       AnthropicBeta = "thinking-display-updates-2026-08-18"
	AnthropicBetaCEUserManagement2026_07_13             AnthropicBeta = "ce-user-management-2026-07-13"
	AnthropicBetaMidConversationOutputConfig2026_07_01  AnthropicBeta = "mid-conversation-output-config-2026-07-01"
	AnthropicBetaThinkingBindingControls2026_08_01      AnthropicBeta = "thinking-binding-controls-2026-08-01"
	AnthropicBetaMidConversationSystemClearAt2026_08_21 AnthropicBeta = "mid-conversation-system-clear-at-2026-08-21"
)

type BetaAPIError struct {
	Message string            `json:"message" api:"required"`
	Type    constant.APIError `json:"type" default:"api_error"`
	// JSON contains metadata for fields, check presence with [respjson.Field.Valid].
	JSON struct {
		Message     respjson.Field
		Type        respjson.Field
		ExtraFields map[string]respjson.Field
		raw         string
	} `json:"-"`
}

// Returns the unmodified JSON received from the API
func (r BetaAPIError) RawJSON() string { return r.JSON.raw }
func (r *BetaAPIError) UnmarshalJSON(data []byte) error {
	return apijson.UnmarshalRoot(data, r)
}

type BetaAuthenticationError struct {
	Message string                       `json:"message" api:"required"`
	Type    constant.AuthenticationError `json:"type" default:"authentication_error"`
	// JSON contains metadata for fields, check presence with [respjson.Field.Valid].
	JSON struct {
		Message     respjson.Field
		Type        respjson.Field
		ExtraFields map[string]respjson.Field
		raw         string
	} `json:"-"`
}

// Returns the unmodified JSON received from the API
func (r BetaAuthenticationError) RawJSON() string { return r.JSON.raw }
func (r *BetaAuthenticationError) UnmarshalJSON(data []byte) error {
	return apijson.UnmarshalRoot(data, r)
}

type BetaBillingError struct {
	Message string                `json:"message" api:"required"`
	Type    constant.BillingError `json:"type" default:"billing_error"`
	// JSON contains metadata for fields, check presence with [respjson.Field.Valid].
	JSON struct {
		Message     respjson.Field
		Type        respjson.Field
		ExtraFields map[string]respjson.Field
		raw         string
	} `json:"-"`
}

// Returns the unmodified JSON received from the API
func (r BetaBillingError) RawJSON() string { return r.JSON.raw }
func (r *BetaBillingError) UnmarshalJSON(data []byte) error {
	return apijson.UnmarshalRoot(data, r)
}

type BetaCurrency string

const (
	BetaCurrencyUSD BetaCurrency = "USD"
)

// BetaErrorUnion contains all possible properties and values from
// [BetaInvalidRequestError], [BetaAuthenticationError], [BetaBillingError],
// [BetaPermissionError], [BetaNotFoundError], [BetaRateLimitError],
// [BetaGatewayTimeoutError], [BetaAPIError], [BetaOverloadedError].
//
// Use the [BetaErrorUnion.AsAny] method to switch on the variant.
//
// Use the methods beginning with 'As' to cast the union to one of its variants.
type BetaErrorUnion struct {
	Message string `json:"message"`
	// Any of "invalid_request_error", "authentication_error", "billing_error",
	// "permission_error", "not_found_error", "rate_limit_error", "timeout_error",
	// "api_error", "overloaded_error".
	Type string `json:"type"`
	JSON struct {
		Message respjson.Field
		Type    respjson.Field
		raw     string
	} `json:"-"`
}

// anyBetaError is implemented by each variant of [BetaErrorUnion] to add type
// safety for the return type of [BetaErrorUnion.AsAny]
type anyBetaError interface {
	implBetaErrorUnion()
}

func (BetaInvalidRequestError) implBetaErrorUnion() {}
func (BetaAuthenticationError) implBetaErrorUnion() {}
func (BetaBillingError) implBetaErrorUnion()        {}
func (BetaPermissionError) implBetaErrorUnion()     {}
func (BetaNotFoundError) implBetaErrorUnion()       {}
func (BetaRateLimitError) implBetaErrorUnion()      {}
func (BetaGatewayTimeoutError) implBetaErrorUnion() {}
func (BetaAPIError) implBetaErrorUnion()            {}
func (BetaOverloadedError) implBetaErrorUnion()     {}

// Use the following switch statement to find the correct variant
//
//	switch variant := BetaErrorUnion.AsAny().(type) {
//	case anthropic.BetaInvalidRequestError:
//	case anthropic.BetaAuthenticationError:
//	case anthropic.BetaBillingError:
//	case anthropic.BetaPermissionError:
//	case anthropic.BetaNotFoundError:
//	case anthropic.BetaRateLimitError:
//	case anthropic.BetaGatewayTimeoutError:
//	case anthropic.BetaAPIError:
//	case anthropic.BetaOverloadedError:
//	default:
//	  fmt.Errorf("no variant present")
//	}
func (u BetaErrorUnion) AsAny() anyBetaError {
	switch u.Type {
	case "invalid_request_error":
		return u.AsInvalidRequestError()
	case "authentication_error":
		return u.AsAuthenticationError()
	case "billing_error":
		return u.AsBillingError()
	case "permission_error":
		return u.AsPermissionError()
	case "not_found_error":
		return u.AsNotFoundError()
	case "rate_limit_error":
		return u.AsRateLimitError()
	case "timeout_error":
		return u.AsTimeoutError()
	case "api_error":
		return u.AsAPIError()
	case "overloaded_error":
		return u.AsOverloadedError()
	}
	return nil
}

func (u BetaErrorUnion) AsInvalidRequestError() (v BetaInvalidRequestError) {
	apijson.UnmarshalRoot(json.RawMessage(u.JSON.raw), &v)
	return
}

func (u BetaErrorUnion) AsAuthenticationError() (v BetaAuthenticationError) {
	apijson.UnmarshalRoot(json.RawMessage(u.JSON.raw), &v)
	return
}

func (u BetaErrorUnion) AsBillingError() (v BetaBillingError) {
	apijson.UnmarshalRoot(json.RawMessage(u.JSON.raw), &v)
	return
}

func (u BetaErrorUnion) AsPermissionError() (v BetaPermissionError) {
	apijson.UnmarshalRoot(json.RawMessage(u.JSON.raw), &v)
	return
}

func (u BetaErrorUnion) AsNotFoundError() (v BetaNotFoundError) {
	apijson.UnmarshalRoot(json.RawMessage(u.JSON.raw), &v)
	return
}

func (u BetaErrorUnion) AsRateLimitError() (v BetaRateLimitError) {
	apijson.UnmarshalRoot(json.RawMessage(u.JSON.raw), &v)
	return
}

func (u BetaErrorUnion) AsTimeoutError() (v BetaGatewayTimeoutError) {
	apijson.UnmarshalRoot(json.RawMessage(u.JSON.raw), &v)
	return
}

func (u BetaErrorUnion) AsAPIError() (v BetaAPIError) {
	apijson.UnmarshalRoot(json.RawMessage(u.JSON.raw), &v)
	return
}

func (u BetaErrorUnion) AsOverloadedError() (v BetaOverloadedError) {
	apijson.UnmarshalRoot(json.RawMessage(u.JSON.raw), &v)
	return
}

// Returns the unmodified JSON received from the API
func (u BetaErrorUnion) RawJSON() string { return u.JSON.raw }

func (r *BetaErrorUnion) UnmarshalJSON(data []byte) error {
	return apijson.UnmarshalRoot(data, r)
}

type BetaErrorResponse struct {
	Error     BetaErrorUnion `json:"error" api:"required"`
	RequestID string         `json:"request_id" api:"required"`
	Type      constant.Error `json:"type" default:"error"`
	// JSON contains metadata for fields, check presence with [respjson.Field.Valid].
	JSON struct {
		Error       respjson.Field
		RequestID   respjson.Field
		Type        respjson.Field
		ExtraFields map[string]respjson.Field
		raw         string
	} `json:"-"`
}

// Returns the unmodified JSON received from the API
func (r BetaErrorResponse) RawJSON() string { return r.JSON.raw }
func (r *BetaErrorResponse) UnmarshalJSON(data []byte) error {
	return apijson.UnmarshalRoot(data, r)
}

type BetaGatewayTimeoutError struct {
	Message string                `json:"message" api:"required"`
	Type    constant.TimeoutError `json:"type" default:"timeout_error"`
	// JSON contains metadata for fields, check presence with [respjson.Field.Valid].
	JSON struct {
		Message     respjson.Field
		Type        respjson.Field
		ExtraFields map[string]respjson.Field
		raw         string
	} `json:"-"`
}

// Returns the unmodified JSON received from the API
func (r BetaGatewayTimeoutError) RawJSON() string { return r.JSON.raw }
func (r *BetaGatewayTimeoutError) UnmarshalJSON(data []byte) error {
	return apijson.UnmarshalRoot(data, r)
}

type BetaInvalidRequestError struct {
	Message string                       `json:"message" api:"required"`
	Type    constant.InvalidRequestError `json:"type" default:"invalid_request_error"`
	// JSON contains metadata for fields, check presence with [respjson.Field.Valid].
	JSON struct {
		Message     respjson.Field
		Type        respjson.Field
		ExtraFields map[string]respjson.Field
		raw         string
	} `json:"-"`
}

// Returns the unmodified JSON received from the API
func (r BetaInvalidRequestError) RawJSON() string { return r.JSON.raw }
func (r *BetaInvalidRequestError) UnmarshalJSON(data []byte) error {
	return apijson.UnmarshalRoot(data, r)
}

// A monetary amount in a specific currency.
type BetaMonetaryAmount struct {
	// Amount in minor units of the currency, as an integer decimal string with no
	// leading zeros: "2500" is $25.00 and "50" is fifty cents. A string rather than a
	// number so no float rounding is ever applied.
	Amount string `json:"amount" api:"required"`
	// Uppercase ISO-4217 currency code. `USD` is the only currency currently
	// supported; the accepted set is closed and grows only when a new currency is
	// priced.
	//
	// Any of "USD".
	Currency BetaCurrency `json:"currency" api:"required"`
	// JSON contains metadata for fields, check presence with [respjson.Field.Valid].
	JSON struct {
		Amount      respjson.Field
		Currency    respjson.Field
		ExtraFields map[string]respjson.Field
		raw         string
	} `json:"-"`
}

// Returns the unmodified JSON received from the API
func (r BetaMonetaryAmount) RawJSON() string { return r.JSON.raw }
func (r *BetaMonetaryAmount) UnmarshalJSON(data []byte) error {
	return apijson.UnmarshalRoot(data, r)
}

// ToParam converts this BetaMonetaryAmount to a BetaMonetaryAmountParam.
//
// 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
// BetaMonetaryAmountParam.Overrides()
func (r BetaMonetaryAmount) ToParam() BetaMonetaryAmountParam {
	return param.Override[BetaMonetaryAmountParam](json.RawMessage(r.RawJSON()))
}

// A monetary amount in a specific currency.
//
// The properties Amount, Currency are required.
type BetaMonetaryAmountParam struct {
	// Amount in minor units of the currency, as an integer decimal string with no
	// leading zeros: "2500" is $25.00 and "50" is fifty cents. A string rather than a
	// number so no float rounding is ever applied.
	Amount string `json:"amount" api:"required"`
	// Uppercase ISO-4217 currency code. `USD` is the only currency currently
	// supported; the accepted set is closed and grows only when a new currency is
	// priced.
	//
	// Any of "USD".
	Currency BetaCurrency `json:"currency,omitzero" api:"required"`
	paramObj
}

func (r BetaMonetaryAmountParam) MarshalJSON() (data []byte, err error) {
	type shadow BetaMonetaryAmountParam
	return param.MarshalObject(r, (*shadow)(&r))
}
func (r *BetaMonetaryAmountParam) UnmarshalJSON(data []byte) error {
	return apijson.UnmarshalRoot(data, r)
}

type BetaNotFoundError struct {
	Message string                 `json:"message" api:"required"`
	Type    constant.NotFoundError `json:"type" default:"not_found_error"`
	// JSON contains metadata for fields, check presence with [respjson.Field.Valid].
	JSON struct {
		Message     respjson.Field
		Type        respjson.Field
		ExtraFields map[string]respjson.Field
		raw         string
	} `json:"-"`
}

// Returns the unmodified JSON received from the API
func (r BetaNotFoundError) RawJSON() string { return r.JSON.raw }
func (r *BetaNotFoundError) UnmarshalJSON(data []byte) error {
	return apijson.UnmarshalRoot(data, r)
}

type BetaOverloadedError struct {
	Message string                   `json:"message" api:"required"`
	Type    constant.OverloadedError `json:"type" default:"overloaded_error"`
	// JSON contains metadata for fields, check presence with [respjson.Field.Valid].
	JSON struct {
		Message     respjson.Field
		Type        respjson.Field
		ExtraFields map[string]respjson.Field
		raw         string
	} `json:"-"`
}

// Returns the unmodified JSON received from the API
func (r BetaOverloadedError) RawJSON() string { return r.JSON.raw }
func (r *BetaOverloadedError) UnmarshalJSON(data []byte) error {
	return apijson.UnmarshalRoot(data, r)
}

type BetaPermissionError struct {
	Message string                   `json:"message" api:"required"`
	Type    constant.PermissionError `json:"type" default:"permission_error"`
	// JSON contains metadata for fields, check presence with [respjson.Field.Valid].
	JSON struct {
		Message     respjson.Field
		Type        respjson.Field
		ExtraFields map[string]respjson.Field
		raw         string
	} `json:"-"`
}

// Returns the unmodified JSON received from the API
func (r BetaPermissionError) RawJSON() string { return r.JSON.raw }
func (r *BetaPermissionError) UnmarshalJSON(data []byte) error {
	return apijson.UnmarshalRoot(data, r)
}

type BetaRateLimitError struct {
	Message string                  `json:"message" api:"required"`
	Type    constant.RateLimitError `json:"type" default:"rate_limit_error"`
	// JSON contains metadata for fields, check presence with [respjson.Field.Valid].
	JSON struct {
		Message     respjson.Field
		Type        respjson.Field
		ExtraFields map[string]respjson.Field
		raw         string
	} `json:"-"`
}

// Returns the unmodified JSON received from the API
func (r BetaRateLimitError) RawJSON() string { return r.JSON.raw }
func (r *BetaRateLimitError) UnmarshalJSON(data []byte) error {
	return apijson.UnmarshalRoot(data, r)
}