diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml index c6d8887..1e10b7a 100644 --- a/.github/workflows/ci.yml +++ b/.github/workflows/ci.yml @@ -26,14 +26,14 @@ jobs: github.repository == 'stainless-sdks/stagehand-go' && (github.event_name == 'push' || github.event.pull_request.head.repo.fork) && (github.event_name != 'push' || github.event.head_commit.message != 'codegen metadata') steps: - - uses: actions/checkout@v6 + - uses: actions/checkout@de0fac2e4500dabe0009e67214ff5f5447ce83dd # v6.0.2 - name: Get GitHub OIDC Token if: |- github.repository == 'stainless-sdks/stagehand-go' && !startsWith(github.ref, 'refs/heads/stl/') id: github-oidc - uses: actions/github-script@v8 + uses: actions/github-script@ed597411d8f924073f98dfc5c65a23a2325f34cd # v8.0.0 with: script: core.setOutput('github_token', await core.getIDToken()); @@ -53,10 +53,10 @@ jobs: if: github.event_name == 'push' || github.event.pull_request.head.repo.fork steps: - - uses: actions/checkout@v6 + - uses: actions/checkout@de0fac2e4500dabe0009e67214ff5f5447ce83dd # v6.0.2 - name: Setup go - uses: actions/setup-go@v5 + uses: actions/setup-go@40f1582b2485089dde7abd97c1529aa768e1baff # v5.6.0 with: go-version-file: ./go.mod @@ -68,10 +68,10 @@ jobs: runs-on: ${{ github.repository == 'stainless-sdks/stagehand-go' && 'depot-ubuntu-24.04' || 'ubuntu-latest' }} if: github.event_name == 'push' || github.event.pull_request.head.repo.fork steps: - - uses: actions/checkout@v6 + - uses: actions/checkout@de0fac2e4500dabe0009e67214ff5f5447ce83dd # v6.0.2 - name: Setup go - uses: actions/setup-go@v5 + uses: actions/setup-go@40f1582b2485089dde7abd97c1529aa768e1baff # v5.6.0 with: go-version-file: ./go.mod diff --git a/.release-please-manifest.json b/.release-please-manifest.json index d11c8fc..eba8a04 100644 --- a/.release-please-manifest.json +++ b/.release-please-manifest.json @@ -1,3 +1,3 @@ { - ".": "3.20.0" + ".": "3.21.0" } \ No newline at end of file diff --git a/.stats.yml b/.stats.yml index 391cde3..15099ca 100644 --- a/.stats.yml +++ b/.stats.yml @@ -1,4 +1,4 @@ configured_endpoints: 8 -openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/browserbase/stagehand-6f6bfb81d092f30a5e2005328c97d61b9ea36132bb19e9e79e55294b9534ce20.yml -openapi_spec_hash: f3fc1e3688a38dc2c28f7178f7d534e5 +openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/browserbase/stagehand-c7910965e66e73ad8b65b6cc391d431094b2a6c6577c3e9d82feaa8138e74cff.yml +openapi_spec_hash: 37748bb69c22a9ce721d9b5a5861f964 config_hash: 1fb12ae9b478488bc1e56bfbdc210b01 diff --git a/CHANGELOG.md b/CHANGELOG.md index f94f7eb..fe549e6 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -1,5 +1,27 @@ # Changelog +## 3.21.0 (2026-05-27) + +Full Changelog: [v3.20.0...v3.21.0](https://github.com/browserbase/stagehand-go/compare/v3.20.0...v3.21.0) + +### Features + +* [feat]: add `ignoreSelectors` to `observe()` ([501d30b](https://github.com/browserbase/stagehand-go/commit/501d30b5aa52a72eed5a25b064609b5c7c84d733)) +* [STG-1756] forward Vertex model config ([e707c1c](https://github.com/browserbase/stagehand-go/commit/e707c1ca0b01fa7babe4ee081789766695e7d48e)) +* Add `screenshot` option to Extract ([ba29e1e](https://github.com/browserbase/stagehand-go/commit/ba29e1e97d4744a504adf2990fa4cc1eeabf9bba)) +* **client:** optimize json encoder for internal types ([539a65e](https://github.com/browserbase/stagehand-go/commit/539a65e84dfdd9a1330c6142d229ea47b2575376)) +* STG-1756 add Vertex auth params to Stagehand spec ([b381980](https://github.com/browserbase/stagehand-go/commit/b381980c635b1d7968a2022709fa91921e77556e)) + + +### Bug Fixes + +* **go:** avoid panic when http.DefaultTransport is wrapped ([cea79d5](https://github.com/browserbase/stagehand-go/commit/cea79d5e25d6f072af7b2dde01d34be71106cb4b)) + + +### Chores + +* redact api-key headers in debug logs ([6378688](https://github.com/browserbase/stagehand-go/commit/637868870522a96e2e1d585949926a6116cb1e01)) + ## 3.20.0 (2026-05-06) Full Changelog: [v3.19.3...v3.20.0](https://github.com/browserbase/stagehand-go/compare/v3.19.3...v3.20.0) diff --git a/README.md b/README.md index 841a26a..a3282f4 100644 --- a/README.md +++ b/README.md @@ -90,7 +90,7 @@ Or to pin the version: ```sh -go get -u 'github.com/browserbase/stagehand-go@v3.20.0' +go get -u 'github.com/browserbase/stagehand-go@v3.21.0' ``` diff --git a/api.md b/api.md index 0955128..0723546 100644 --- a/api.md +++ b/api.md @@ -3,7 +3,6 @@ Params Types: - stagehand.ActionParam -- stagehand.ModelConfigParam Response Types: diff --git a/default_http_client.go b/default_http_client.go index 9338fb8..c362211 100644 --- a/default_http_client.go +++ b/default_http_client.go @@ -14,11 +14,17 @@ import ( const defaultResponseHeaderTimeout = 10 * time.Minute // defaultHTTPClient returns an [*http.Client] used when the caller does not -// supply one via [option.WithHTTPClient]. It clones [http.DefaultTransport] -// and adds a [http.Transport.ResponseHeaderTimeout] so stuck connections -// fail fast instead of compounding across retries. +// supply one via [option.WithHTTPClient]. When [http.DefaultTransport] is the +// stdlib [*http.Transport], it is cloned and a [http.Transport.ResponseHeaderTimeout] +// is set so stuck connections fail fast instead of compounding across retries. +// If [http.DefaultTransport] has been wrapped (for example by otelhttp for +// distributed tracing), the wrapping is preserved and the header timeout is +// skipped. func defaultHTTPClient() *http.Client { - transport := http.DefaultTransport.(*http.Transport).Clone() - transport.ResponseHeaderTimeout = defaultResponseHeaderTimeout - return &http.Client{Transport: transport} + if t, ok := http.DefaultTransport.(*http.Transport); ok { + t = t.Clone() + t.ResponseHeaderTimeout = defaultResponseHeaderTimeout + return &http.Client{Transport: t} + } + return &http.Client{Transport: http.DefaultTransport} } diff --git a/internal/encoding/json/encode.go b/internal/encoding/json/encode.go index 6603ba3..6b9c902 100644 --- a/internal/encoding/json/encode.go +++ b/internal/encoding/json/encode.go @@ -173,15 +173,21 @@ import ( // JSON cannot represent cyclic data structures and Marshal does not // handle them. Passing cyclic structures to Marshal will result in // an error. -func Marshal(v any) ([]byte, error) { +// EDIT(begin): add optimization options +func Marshal(v any, opts ...Option) ([]byte, error) { + // EDIT(end): add optimization options e := newEncodeState() defer encodeStatePool.Put(e) - // SHIM(begin): don't escape HTML by default - err := e.marshal(v, encOpts{escapeHTML: shims.EscapeHTMLByDefault}) + // EDIT(begin): don't escape HTML by default, and apply options + encOpts := encOpts{escapeHTML: shims.EscapeHTMLByDefault} + if opts != nil { + encOpts = encOpts.apply(opts...) + } + err := e.marshal(v, encOpts) // ORIGINAL: // err := e.marshal(v, encOpts{escapeHTML: true}) - // SHIM(end) + // EDIT(end) if err != nil { return nil, err } @@ -352,6 +358,9 @@ type encOpts struct { // EDIT(begin): save the timefmt timefmt string // EDIT(end) + // EDIT(begin): add optimization to skip compaction + skipCompaction bool + // EDIT(end) } type encoderFunc func(e *encodeState, v reflect.Value, opts encOpts) @@ -483,7 +492,7 @@ func marshalerEncoder(e *encodeState, v reflect.Value, opts encOpts) { if err == nil { e.Grow(len(b)) out := e.AvailableBuffer() - out, err = appendCompact(out, b, opts.escapeHTML) + out, err = appendCompact(out, b, opts) e.Buffer.Write(out) } if err != nil { @@ -509,7 +518,7 @@ func addrMarshalerEncoder(e *encodeState, v reflect.Value, opts encOpts) { if err == nil { e.Grow(len(b)) out := e.AvailableBuffer() - out, err = appendCompact(out, b, opts.escapeHTML) + out, err = appendCompact(out, b, opts) e.Buffer.Write(out) } if err != nil { diff --git a/internal/encoding/json/indent.go b/internal/encoding/json/indent.go index 01bfdf6..c9d6ca5 100644 --- a/internal/encoding/json/indent.go +++ b/internal/encoding/json/indent.go @@ -4,7 +4,9 @@ package json -import "bytes" +import ( + "bytes" +) // HTMLEscape appends to dst the JSON-encoded src with <, >, &, U+2028 and U+2029 // characters inside string literals changed to \u003c, \u003e, \u0026, \u2028, \u2029 @@ -41,12 +43,21 @@ func appendHTMLEscape(dst, src []byte) []byte { func Compact(dst *bytes.Buffer, src []byte) error { dst.Grow(len(src)) b := dst.AvailableBuffer() - b, err := appendCompact(b, src, false) + b, err := appendCompact(b, src, encOpts{}) dst.Write(b) return err } -func appendCompact(dst, src []byte, escape bool) ([]byte, error) { +func appendCompact(dst, src []byte, opts encOpts) ([]byte, error) { + // EDIT(begin): optimize for skipCompaction + if opts.skipCompaction { + dst = append(dst, src...) + return dst, nil + } + + escape := opts.escapeHTML + // EDIT(end) + origLen := len(dst) scan := newScanner() defer freeScanner(scan) diff --git a/internal/encoding/json/opt.go b/internal/encoding/json/opt.go new file mode 100644 index 0000000..fd6f8d2 --- /dev/null +++ b/internal/encoding/json/opt.go @@ -0,0 +1,24 @@ +// EDIT(begin): add custom options for JSON encoding +package json + +type Option func(*encOpts) + +// Every time a sub-type of [json.Marshaler] is encountered, +// skip a redundant and costly compaction step, trust it to self-compact. +// +// This is a divergence from the standard library behavior, and is only guaranteed +// safe with SDK types. +func WithSkipCompaction(b bool) Option { + return func(eos *encOpts) { + eos.skipCompaction = true + } +} + +func (eos encOpts) apply(opts ...Option) encOpts { + for _, opt := range opts { + opt(&eos) + } + return eos +} + +// EDIT(end) diff --git a/internal/encoding/json/stream.go b/internal/encoding/json/stream.go index e2d9470..652522c 100644 --- a/internal/encoding/json/stream.go +++ b/internal/encoding/json/stream.go @@ -6,7 +6,6 @@ package json import ( "bytes" - "errors" "io" ) @@ -253,30 +252,34 @@ func (enc *Encoder) SetEscapeHTML(on bool) { enc.escapeHTML = on } -// RawMessage is a raw encoded JSON value. -// It implements [Marshaler] and [Unmarshaler] and can -// be used to delay JSON decoding or precompute a JSON encoding. -type RawMessage []byte - -// MarshalJSON returns m as the JSON encoding of m. -func (m RawMessage) MarshalJSON() ([]byte, error) { - if m == nil { - return []byte("null"), nil - } - return m, nil -} - -// UnmarshalJSON sets *m to a copy of data. -func (m *RawMessage) UnmarshalJSON(data []byte) error { - if m == nil { - return errors.New("json.RawMessage: UnmarshalJSON on nil pointer") - } - *m = append((*m)[0:0], data...) - return nil -} - -var _ Marshaler = (*RawMessage)(nil) -var _ Unmarshaler = (*RawMessage)(nil) +// EDIT(begin): remove RawMessage +// +// // RawMessage is a raw encoded JSON value. +// // It implements [Marshaler] and [Unmarshaler] and can +// // be used to delay JSON decoding or precompute a JSON encoding. +// type RawMessage []byte +// +// // MarshalJSON returns m as the JSON encoding of m. +// func (m RawMessage) MarshalJSON() ([]byte, error) { +// if m == nil { +// return []byte("null"), nil +// } +// return m, nil +// } +// +// // UnmarshalJSON sets *m to a copy of data. +// func (m *RawMessage) UnmarshalJSON(data []byte) error { +// if m == nil { +// return errors.New("json.RawMessage: UnmarshalJSON on nil pointer") +// } +// *m = append((*m)[0:0], data...) +// return nil +// } +// +// var _ Marshaler = (*RawMessage)(nil) +// var _ Unmarshaler = (*RawMessage)(nil) +// +// EDIT(end) // A Token holds a value of one of these types: // diff --git a/internal/encoding/json/time.go b/internal/encoding/json/time.go index c70443d..9a4f70d 100644 --- a/internal/encoding/json/time.go +++ b/internal/encoding/json/time.go @@ -50,7 +50,7 @@ func timeMarshalEncoder(e *encodeState, v reflect.Value, opts encOpts) bool { if b != nil { e.Grow(len(b)) out := e.AvailableBuffer() - out, _ = appendCompact(out, b, opts.escapeHTML) + out, _ = appendCompact(out, b, opts) e.Buffer.Write(out) return true } diff --git a/internal/version.go b/internal/version.go index 2210a0d..f43b02b 100644 --- a/internal/version.go +++ b/internal/version.go @@ -2,4 +2,4 @@ package internal -const PackageVersion = "3.20.0" // x-release-please-version +const PackageVersion = "3.21.0" // x-release-please-version diff --git a/option/middleware.go b/option/middleware.go index 8ec9dd6..69f78f3 100644 --- a/option/middleware.go +++ b/option/middleware.go @@ -8,6 +8,10 @@ import ( "net/http/httputil" ) +// sensitiveLogHeaders are redacted before request and response content is +// written to the debug logger. +var sensitiveLogHeaders = []string{"authorization", "api-key", "x-api-key", "cookie", "set-cookie", "x-bb-api-key", "x-bb-project-id", "x-model-api-key"} + // WithDebugLog logs the HTTP request and response content. // If the logger parameter is nil, it uses the default logger. // @@ -20,7 +24,7 @@ func WithDebugLog(logger *log.Logger) RequestOption { logger = log.Default() } - if reqBytes, err := httputil.DumpRequest(req, true); err == nil { + if reqBytes, err := dumpRedactedRequest(req); err == nil { logger.Printf("Request Content:\n%s\n", reqBytes) } @@ -29,10 +33,48 @@ func WithDebugLog(logger *log.Logger) RequestOption { return resp, err } - if respBytes, err := httputil.DumpResponse(resp, true); err == nil { + if respBytes, err := dumpRedactedResponse(resp); err == nil { logger.Printf("Response Content:\n%s\n", respBytes) } return resp, err }) } + +// dumpRedactedRequest dumps req with sensitive headers replaced. The +// original headers are restored via defer so a panic in DumpRequest cannot +// leak the placeholder map into the live request sent downstream. +func dumpRedactedRequest(req *http.Request) ([]byte, error) { + origHeaders := req.Header + req.Header = redactDebugHeaders(origHeaders) + defer func() { req.Header = origHeaders }() + return httputil.DumpRequest(req, true) +} + +func dumpRedactedResponse(resp *http.Response) ([]byte, error) { + origHeaders := resp.Header + resp.Header = redactDebugHeaders(origHeaders) + defer func() { resp.Header = origHeaders }() + return httputil.DumpResponse(resp, true) +} + +func redactDebugHeaders(headers http.Header) http.Header { + var redacted http.Header + for _, name := range sensitiveLogHeaders { + values := headers.Values(name) + if len(values) == 0 { + continue + } + if redacted == nil { + redacted = headers.Clone() + } + redacted.Del(name) + for range values { + redacted.Add(name, "***") + } + } + if redacted == nil { + return headers + } + return redacted +} diff --git a/packages/param/encoder.go b/packages/param/encoder.go index 8faa2b4..33465f3 100644 --- a/packages/param/encoder.go +++ b/packages/param/encoder.go @@ -66,7 +66,7 @@ func MarshalWithExtras[T ParamStruct, R any](f T, underlying any, extras map[str } else if ovr, ok := f.Overrides(); ok { return shimjson.Marshal(ovr) } else { - return shimjson.Marshal(underlying) + return shimjson.Marshal(underlying, shimjson.WithSkipCompaction(true)) } } @@ -96,7 +96,7 @@ func MarshalUnion[T ParamStruct](metadata T, variants ...any) ([]byte, error) { Err: fmt.Errorf("expected union to have only one present variant, got %d", nPresent), } } - return shimjson.Marshal(variants[presentIdx]) + return shimjson.Marshal(variants[presentIdx], shimjson.WithSkipCompaction(true)) } // typeFor is shimmed from Go 1.23 "reflect" package diff --git a/packages/param/encoder_test.go b/packages/param/encoder_test.go index 90cee05..ff0bdc0 100644 --- a/packages/param/encoder_test.go +++ b/packages/param/encoder_test.go @@ -1,10 +1,13 @@ package param_test import ( + "bytes" "encoding/json" + "reflect" "testing" "time" + shimjson "github.com/browserbase/stagehand-go/v3/internal/encoding/json" "github.com/browserbase/stagehand-go/v3/packages/param" ) @@ -375,3 +378,176 @@ func TestNullStructUnion(t *testing.T) { t.Fatalf("expected null, received %s", string(b)) } } + +// +// Compaction optimization +// + +type NonCompactedDoubleParent struct { + Prop string `json:"prop"` + Parent NonCompactedParent `json:"parent"` + + param.APIObject +} + +type NonCompactedParent struct { + BadChild NonCompacted `json:"bad_child"` + + param.APIObject +} + +type NonCompacted struct { + Raw string + + param.APIObject +} + +func (a NonCompactedDoubleParent) MarshalJSON() ([]byte, error) { + type shadow NonCompactedDoubleParent + return param.MarshalObject(a, (*shadow)(&a)) +} + +func (a NonCompactedParent) MarshalJSON() ([]byte, error) { + type shadow NonCompactedParent + return param.MarshalObject(a, (*shadow)(&a)) +} + +func (a NonCompacted) MarshalJSON() ([]byte, error) { + if a.Raw == "" { + a.Raw = nonCompactedRaw + } + return []byte(a.Raw), nil +} + +var nonCompactedRaw string = ` { "foo": "bar" } ` + +func TestAppendCompactBroken(t *testing.T) { + tests := map[string]struct { + value json.Marshaler + }{ + "red/illegal-json": { + NonCompacted{Raw: `{ "broken": "json" `}, + }, + "red/nested-with-illegal-json": { + NonCompactedParent{BadChild: NonCompacted{ + Raw: `{ "broken": "json" `, + }}, + }, + } + + for name, test := range tests { + t.Run(name, func(t *testing.T) { + v, err := json.Marshal(test.value) + if err == nil { + t.Fatal("expected error got", v) + } + }) + } +} + +// TestAppendCompact validates an optimization for internal SDK types to +// avoid O(keys^2) iteration over each JSON object. +// +// It's possible to intentionally trigger this behavior as both a user and +// SDK developer. However, the edge case is quite pathological and requires +// calling [json.Marshaler.MarshalJSON] rather than [json.Marshal]. +func TestAppendCompact(t *testing.T) { + + tests := map[string]struct { + value json.Marshaler + expected string + }{ + // + // Non-compacted cases + // + // Note this is how to exploit the compacter to fail, you must call [json.Marshaler.MarshalJSON] rather than [json.Marshal]. + // The type must also embed [param.APIObject] and return non-compacted JSON. + // + + "no-compact/fails-compaction": { + NonCompacted{Raw: nonCompactedRaw}, + nonCompactedRaw, + }, + "no-compact/nested-with-bad-child": { + NonCompactedParent{BadChild: NonCompacted{ + Raw: nonCompactedRaw, + }}, + `{"bad_child":` + nonCompactedRaw + `}`, + }, + "no-compact/double-nested-with-bad-child": { + NonCompactedDoubleParent{Prop: "1", Parent: NonCompactedParent{BadChild: NonCompacted{ + Raw: nonCompactedRaw, + }}}, + `{"prop":"1","parent":{"bad_child":` + nonCompactedRaw + `}}`, + }, + + // + // Compacted cases + // + + "override/spaces-within": { + param.Override[NonCompactedDoubleParent](json.RawMessage(`{"com": "pact"}`)), + `{"com":"pact"}`, + }, + "override/spaces-after": { + param.Override[NonCompactedDoubleParent](json.RawMessage(`{"com":"pact"} `)), + `{"com":"pact"}`, + }, + "override/spaces-before": { + param.Override[NonCompactedDoubleParent](json.RawMessage(` {"com":"pact"}`)), + `{"com":"pact"}`, + }, + "override/spaces-around": { + param.Override[NonCompactedDoubleParent](json.RawMessage(` { "com": "pact" }`)), + `{"com":"pact"}`, + }, + "override/override-with-nested": { + param.Override[NonCompactedDoubleParent](NonCompactedParent{}), + `{"bad_child":{"foo":"bar"}}`, + }, + "override/override-with-non-compacted": { + param.Override[NonCompactedDoubleParent](NonCompacted{}), + `{"foo":"bar"}`, + }, + } + + for name, test := range tests { + t.Run(name+"/marshal-json", func(t *testing.T) { + b, err := test.value.MarshalJSON() + if err != nil { + t.Fatalf("didn't expect error %v, expected %s", err, test.expected) + } + if string(b) != test.expected { + t.Fatalf("expected %s (%s), received %s", test.expected, reflect.TypeOf(test.value), string(b)) + } + }) + + t.Run(name+"/json-marshal", func(t *testing.T) { + b, err := json.Marshal(test.value) + if err != nil { + t.Fatalf("didn't expect error %v, expected %s", err, test.expected) + } + + // expected output of JSON Marshal should always be compacted + var compactedExpected bytes.Buffer + err = json.Compact(&compactedExpected, []byte(test.expected)) + if err != nil { + t.Fatalf("didn't expect error %v, expected %s", err, test.expected) + } + + if string(b) != compactedExpected.String() { + t.Fatalf("expected %s (%s), received %s", test.expected, reflect.TypeOf(test.value), string(b)) + } + }) + + t.Run(name+"/shimjson-marshal", func(t *testing.T) { + b, err := shimjson.Marshal(test.value) + if err != nil { + t.Fatalf("didn't expect error %v, expected %s", err, test.expected) + } + if string(b) != test.expected { + t.Logf("expected %s (%s), received %s", test.expected, reflect.TypeOf(test.value), string(b)) + } + }) + } +} diff --git a/session.go b/session.go index f218fe0..a5c223c 100644 --- a/session.go +++ b/session.go @@ -264,42 +264,6 @@ func (r *ActionParam) UnmarshalJSON(data []byte) error { return apijson.UnmarshalRoot(data, r) } -// The property ModelName is required. -type ModelConfigParam struct { - // Model name string with provider prefix (e.g., 'openai/gpt-5-nano') - ModelName string `json:"modelName" api:"required"` - // API key for the model provider - APIKey param.Opt[string] `json:"apiKey,omitzero"` - // Base URL for the model provider - BaseURL param.Opt[string] `json:"baseURL,omitzero" format:"uri"` - // Custom headers sent with every request to the model provider - Headers map[string]string `json:"headers,omitzero"` - // AI provider for the model (or provide a baseURL endpoint instead) - // - // Any of "openai", "anthropic", "google", "microsoft", "bedrock". - Provider ModelConfigProvider `json:"provider,omitzero"` - paramObj -} - -func (r ModelConfigParam) MarshalJSON() (data []byte, err error) { - type shadow ModelConfigParam - return param.MarshalObject(r, (*shadow)(&r)) -} -func (r *ModelConfigParam) UnmarshalJSON(data []byte) error { - return apijson.UnmarshalRoot(data, r) -} - -// AI provider for the model (or provide a baseURL endpoint instead) -type ModelConfigProvider string - -const ( - ModelConfigProviderOpenAI ModelConfigProvider = "openai" - ModelConfigProviderAnthropic ModelConfigProvider = "anthropic" - ModelConfigProviderGoogle ModelConfigProvider = "google" - ModelConfigProviderMicrosoft ModelConfigProvider = "microsoft" - ModelConfigProviderBedrock ModelConfigProvider = "bedrock" -) - // Server-Sent Event emitted during streaming responses. Events are sent as // `event: \ndata: \n\n`, where the JSON payload has the shape // `{ data, type, id }`. @@ -1037,27 +1001,282 @@ func (r *SessionActParamsOptions) UnmarshalJSON(data []byte) error { // // Use [param.IsOmitted] to confirm if a field is set. type SessionActParamsOptionsModelUnion struct { - OfModelConfig *ModelConfigParam `json:",omitzero,inline"` - OfString param.Opt[string] `json:",omitzero,inline"` + OfSessionActsOptionsModelVertexModelConfigObject *SessionActParamsOptionsModelVertexModelConfigObject `json:",omitzero,inline"` + OfSessionActsOptionsModelGenericModelConfigObject *SessionActParamsOptionsModelGenericModelConfigObject `json:",omitzero,inline"` + OfString param.Opt[string] `json:",omitzero,inline"` paramUnion } func (u SessionActParamsOptionsModelUnion) MarshalJSON() ([]byte, error) { - return param.MarshalUnion(u, u.OfModelConfig, u.OfString) + return param.MarshalUnion(u, u.OfSessionActsOptionsModelVertexModelConfigObject, u.OfSessionActsOptionsModelGenericModelConfigObject, u.OfString) } func (u *SessionActParamsOptionsModelUnion) UnmarshalJSON(data []byte) error { return apijson.UnmarshalRoot(data, u) } func (u *SessionActParamsOptionsModelUnion) asAny() any { - if !param.IsOmitted(u.OfModelConfig) { - return u.OfModelConfig + if !param.IsOmitted(u.OfSessionActsOptionsModelVertexModelConfigObject) { + return u.OfSessionActsOptionsModelVertexModelConfigObject + } else if !param.IsOmitted(u.OfSessionActsOptionsModelGenericModelConfigObject) { + return u.OfSessionActsOptionsModelGenericModelConfigObject } else if !param.IsOmitted(u.OfString) { return &u.OfString.Value } return nil } +// Returns a pointer to the underlying variant's property, if present. +func (u SessionActParamsOptionsModelUnion) GetAuth() *SessionActParamsOptionsModelVertexModelConfigObjectAuth { + if vt := u.OfSessionActsOptionsModelVertexModelConfigObject; vt != nil { + return &vt.Auth + } + return nil +} + +// Returns a pointer to the underlying variant's property, if present. +func (u SessionActParamsOptionsModelUnion) GetProviderOptions() *SessionActParamsOptionsModelVertexModelConfigObjectProviderOptions { + if vt := u.OfSessionActsOptionsModelVertexModelConfigObject; vt != nil { + return &vt.ProviderOptions + } + return nil +} + +// Returns a pointer to the underlying variant's property, if present. +func (u SessionActParamsOptionsModelUnion) GetModelName() *string { + if vt := u.OfSessionActsOptionsModelVertexModelConfigObject; vt != nil { + return (*string)(&vt.ModelName) + } else if vt := u.OfSessionActsOptionsModelGenericModelConfigObject; vt != nil { + return (*string)(&vt.ModelName) + } + return nil +} + +// Returns a pointer to the underlying variant's property, if present. +func (u SessionActParamsOptionsModelUnion) GetProvider() *string { + if vt := u.OfSessionActsOptionsModelVertexModelConfigObject; vt != nil { + return (*string)(&vt.Provider) + } else if vt := u.OfSessionActsOptionsModelGenericModelConfigObject; vt != nil { + return (*string)(&vt.Provider) + } + return nil +} + +// Returns a pointer to the underlying variant's property, if present. +func (u SessionActParamsOptionsModelUnion) GetAPIKey() *string { + if vt := u.OfSessionActsOptionsModelVertexModelConfigObject; vt != nil && vt.APIKey.Valid() { + return &vt.APIKey.Value + } else if vt := u.OfSessionActsOptionsModelGenericModelConfigObject; vt != nil && vt.APIKey.Valid() { + return &vt.APIKey.Value + } + return nil +} + +// Returns a pointer to the underlying variant's property, if present. +func (u SessionActParamsOptionsModelUnion) GetBaseURL() *string { + if vt := u.OfSessionActsOptionsModelVertexModelConfigObject; vt != nil && vt.BaseURL.Valid() { + return &vt.BaseURL.Value + } else if vt := u.OfSessionActsOptionsModelGenericModelConfigObject; vt != nil && vt.BaseURL.Valid() { + return &vt.BaseURL.Value + } + return nil +} + +// Returns a pointer to the underlying variant's Headers property, if present. +func (u SessionActParamsOptionsModelUnion) GetHeaders() map[string]string { + if vt := u.OfSessionActsOptionsModelVertexModelConfigObject; vt != nil { + return vt.Headers + } else if vt := u.OfSessionActsOptionsModelGenericModelConfigObject; vt != nil { + return vt.Headers + } + return nil +} + +// The properties Auth, ModelName, Provider, ProviderOptions are required. +type SessionActParamsOptionsModelVertexModelConfigObject struct { + // Vertex provider authentication configuration + Auth SessionActParamsOptionsModelVertexModelConfigObjectAuth `json:"auth,omitzero" api:"required"` + // Model name string with provider prefix (e.g., 'openai/gpt-5-nano') + ModelName string `json:"modelName" api:"required"` + // Vertex provider-specific model configuration + ProviderOptions SessionActParamsOptionsModelVertexModelConfigObjectProviderOptions `json:"providerOptions,omitzero" api:"required"` + // API key for the model provider + APIKey param.Opt[string] `json:"apiKey,omitzero"` + // Base URL for the model provider + BaseURL param.Opt[string] `json:"baseURL,omitzero" format:"uri"` + // Custom headers sent with every request to the model provider + Headers map[string]string `json:"headers,omitzero"` + // Vertex AI model provider + // + // This field can be elided, and will marshal its zero value as "vertex". + Provider constant.Vertex `json:"provider" default:"vertex"` + paramObj +} + +func (r SessionActParamsOptionsModelVertexModelConfigObject) MarshalJSON() (data []byte, err error) { + type shadow SessionActParamsOptionsModelVertexModelConfigObject + return param.MarshalObject(r, (*shadow)(&r)) +} +func (r *SessionActParamsOptionsModelVertexModelConfigObject) UnmarshalJSON(data []byte) error { + return apijson.UnmarshalRoot(data, r) +} + +// Vertex provider authentication configuration +// +// The properties Credentials, Type are required. +type SessionActParamsOptionsModelVertexModelConfigObjectAuth struct { + // Google Cloud service account credentials + Credentials SessionActParamsOptionsModelVertexModelConfigObjectAuthCredentials `json:"credentials,omitzero" api:"required"` + // Google Cloud project ID used by google-auth-library + ProjectID param.Opt[string] `json:"projectId,omitzero"` + // Google Cloud universe domain + UniverseDomain param.Opt[string] `json:"universeDomain,omitzero"` + // Google auth scopes for the desired API request + Scopes SessionActParamsOptionsModelVertexModelConfigObjectAuthScopesUnion `json:"scopes,omitzero"` + // Use inline Google Cloud service account credentials for provider authentication + // + // This field can be elided, and will marshal its zero value as + // "googleServiceAccount". + Type constant.GoogleServiceAccount `json:"type" default:"googleServiceAccount"` + paramObj +} + +func (r SessionActParamsOptionsModelVertexModelConfigObjectAuth) MarshalJSON() (data []byte, err error) { + type shadow SessionActParamsOptionsModelVertexModelConfigObjectAuth + return param.MarshalObject(r, (*shadow)(&r)) +} +func (r *SessionActParamsOptionsModelVertexModelConfigObjectAuth) UnmarshalJSON(data []byte) error { + return apijson.UnmarshalRoot(data, r) +} + +// Google Cloud service account credentials +// +// The properties ClientEmail, PrivateKey are required. +type SessionActParamsOptionsModelVertexModelConfigObjectAuthCredentials struct { + ClientEmail string `json:"client_email" api:"required"` + PrivateKey string `json:"private_key" api:"required"` + AuthProviderX509CertURL param.Opt[string] `json:"auth_provider_x509_cert_url,omitzero" format:"uri"` + AuthUri param.Opt[string] `json:"auth_uri,omitzero" format:"uri"` + ClientID param.Opt[string] `json:"client_id,omitzero"` + ClientX509CertURL param.Opt[string] `json:"client_x509_cert_url,omitzero" format:"uri"` + PrivateKeyID param.Opt[string] `json:"private_key_id,omitzero"` + ProjectID param.Opt[string] `json:"project_id,omitzero"` + TokenUri param.Opt[string] `json:"token_uri,omitzero" format:"uri"` + UniverseDomain param.Opt[string] `json:"universe_domain,omitzero"` + // Any of "service_account". + Type string `json:"type,omitzero"` + paramObj +} + +func (r SessionActParamsOptionsModelVertexModelConfigObjectAuthCredentials) MarshalJSON() (data []byte, err error) { + type shadow SessionActParamsOptionsModelVertexModelConfigObjectAuthCredentials + return param.MarshalObject(r, (*shadow)(&r)) +} +func (r *SessionActParamsOptionsModelVertexModelConfigObjectAuthCredentials) UnmarshalJSON(data []byte) error { + return apijson.UnmarshalRoot(data, r) +} + +func init() { + apijson.RegisterFieldValidator[SessionActParamsOptionsModelVertexModelConfigObjectAuthCredentials]( + "type", "service_account", + ) +} + +// Only one field can be non-zero. +// +// Use [param.IsOmitted] to confirm if a field is set. +type SessionActParamsOptionsModelVertexModelConfigObjectAuthScopesUnion struct { + OfString param.Opt[string] `json:",omitzero,inline"` + OfStringArray []string `json:",omitzero,inline"` + paramUnion +} + +func (u SessionActParamsOptionsModelVertexModelConfigObjectAuthScopesUnion) MarshalJSON() ([]byte, error) { + return param.MarshalUnion(u, u.OfString, u.OfStringArray) +} +func (u *SessionActParamsOptionsModelVertexModelConfigObjectAuthScopesUnion) UnmarshalJSON(data []byte) error { + return apijson.UnmarshalRoot(data, u) +} + +func (u *SessionActParamsOptionsModelVertexModelConfigObjectAuthScopesUnion) asAny() any { + if !param.IsOmitted(u.OfString) { + return &u.OfString.Value + } else if !param.IsOmitted(u.OfStringArray) { + return &u.OfStringArray + } + return nil +} + +// Vertex provider-specific model configuration +// +// The property Vertex is required. +type SessionActParamsOptionsModelVertexModelConfigObjectProviderOptions struct { + // Vertex AI provider-specific settings + Vertex SessionActParamsOptionsModelVertexModelConfigObjectProviderOptionsVertex `json:"vertex,omitzero" api:"required"` + paramObj +} + +func (r SessionActParamsOptionsModelVertexModelConfigObjectProviderOptions) MarshalJSON() (data []byte, err error) { + type shadow SessionActParamsOptionsModelVertexModelConfigObjectProviderOptions + return param.MarshalObject(r, (*shadow)(&r)) +} +func (r *SessionActParamsOptionsModelVertexModelConfigObjectProviderOptions) UnmarshalJSON(data []byte) error { + return apijson.UnmarshalRoot(data, r) +} + +// Vertex AI provider-specific settings +// +// The properties Location, Project are required. +type SessionActParamsOptionsModelVertexModelConfigObjectProviderOptionsVertex struct { + // Google Cloud location for Vertex AI models + Location string `json:"location" api:"required"` + // Google Cloud project ID for Vertex AI models + Project string `json:"project" api:"required"` + // Base URL for the Vertex AI provider + BaseURL param.Opt[string] `json:"baseURL,omitzero" format:"uri"` + // Custom headers sent with every request to the Vertex AI provider + Headers map[string]string `json:"headers,omitzero"` + paramObj +} + +func (r SessionActParamsOptionsModelVertexModelConfigObjectProviderOptionsVertex) MarshalJSON() (data []byte, err error) { + type shadow SessionActParamsOptionsModelVertexModelConfigObjectProviderOptionsVertex + return param.MarshalObject(r, (*shadow)(&r)) +} +func (r *SessionActParamsOptionsModelVertexModelConfigObjectProviderOptionsVertex) UnmarshalJSON(data []byte) error { + return apijson.UnmarshalRoot(data, r) +} + +// The property ModelName is required. +type SessionActParamsOptionsModelGenericModelConfigObject struct { + // Model name string with provider prefix (e.g., 'openai/gpt-5-nano') + ModelName string `json:"modelName" api:"required"` + // API key for the model provider + APIKey param.Opt[string] `json:"apiKey,omitzero"` + // Base URL for the model provider + BaseURL param.Opt[string] `json:"baseURL,omitzero" format:"uri"` + // Custom headers sent with every request to the model provider + Headers map[string]string `json:"headers,omitzero"` + // AI provider for the model (or provide a baseURL endpoint instead) + // + // Any of "openai", "anthropic", "google", "microsoft", "bedrock". + Provider string `json:"provider,omitzero"` + paramObj +} + +func (r SessionActParamsOptionsModelGenericModelConfigObject) MarshalJSON() (data []byte, err error) { + type shadow SessionActParamsOptionsModelGenericModelConfigObject + return param.MarshalObject(r, (*shadow)(&r)) +} +func (r *SessionActParamsOptionsModelGenericModelConfigObject) UnmarshalJSON(data []byte) error { + return apijson.UnmarshalRoot(data, r) +} + +func init() { + apijson.RegisterFieldValidator[SessionActParamsOptionsModelGenericModelConfigObject]( + "provider", "openai", "anthropic", "google", "microsoft", "bedrock", + ) +} + // Only one field can be non-zero. // // Use [param.IsOmitted] to confirm if a field is set. @@ -1222,117 +1441,627 @@ func init() { // // Use [param.IsOmitted] to confirm if a field is set. type SessionExecuteParamsAgentConfigExecutionModelUnion struct { - OfModelConfig *ModelConfigParam `json:",omitzero,inline"` - OfString param.Opt[string] `json:",omitzero,inline"` + OfSessionExecutesAgentConfigExecutionModelVertexModelConfigObject *SessionExecuteParamsAgentConfigExecutionModelVertexModelConfigObject `json:",omitzero,inline"` + OfSessionExecutesAgentConfigExecutionModelGenericModelConfigObject *SessionExecuteParamsAgentConfigExecutionModelGenericModelConfigObject `json:",omitzero,inline"` + OfString param.Opt[string] `json:",omitzero,inline"` paramUnion } func (u SessionExecuteParamsAgentConfigExecutionModelUnion) MarshalJSON() ([]byte, error) { - return param.MarshalUnion(u, u.OfModelConfig, u.OfString) + return param.MarshalUnion(u, u.OfSessionExecutesAgentConfigExecutionModelVertexModelConfigObject, u.OfSessionExecutesAgentConfigExecutionModelGenericModelConfigObject, u.OfString) } func (u *SessionExecuteParamsAgentConfigExecutionModelUnion) UnmarshalJSON(data []byte) error { return apijson.UnmarshalRoot(data, u) } func (u *SessionExecuteParamsAgentConfigExecutionModelUnion) asAny() any { - if !param.IsOmitted(u.OfModelConfig) { - return u.OfModelConfig + if !param.IsOmitted(u.OfSessionExecutesAgentConfigExecutionModelVertexModelConfigObject) { + return u.OfSessionExecutesAgentConfigExecutionModelVertexModelConfigObject + } else if !param.IsOmitted(u.OfSessionExecutesAgentConfigExecutionModelGenericModelConfigObject) { + return u.OfSessionExecutesAgentConfigExecutionModelGenericModelConfigObject } else if !param.IsOmitted(u.OfString) { return &u.OfString.Value } return nil } -// Only one field can be non-zero. -// -// Use [param.IsOmitted] to confirm if a field is set. -type SessionExecuteParamsAgentConfigModelUnion struct { - OfModelConfig *ModelConfigParam `json:",omitzero,inline"` - OfString param.Opt[string] `json:",omitzero,inline"` - paramUnion -} - -func (u SessionExecuteParamsAgentConfigModelUnion) MarshalJSON() ([]byte, error) { - return param.MarshalUnion(u, u.OfModelConfig, u.OfString) -} -func (u *SessionExecuteParamsAgentConfigModelUnion) UnmarshalJSON(data []byte) error { - return apijson.UnmarshalRoot(data, u) +// Returns a pointer to the underlying variant's property, if present. +func (u SessionExecuteParamsAgentConfigExecutionModelUnion) GetAuth() *SessionExecuteParamsAgentConfigExecutionModelVertexModelConfigObjectAuth { + if vt := u.OfSessionExecutesAgentConfigExecutionModelVertexModelConfigObject; vt != nil { + return &vt.Auth + } + return nil } -func (u *SessionExecuteParamsAgentConfigModelUnion) asAny() any { - if !param.IsOmitted(u.OfModelConfig) { - return u.OfModelConfig - } else if !param.IsOmitted(u.OfString) { - return &u.OfString.Value +// Returns a pointer to the underlying variant's property, if present. +func (u SessionExecuteParamsAgentConfigExecutionModelUnion) GetProviderOptions() *SessionExecuteParamsAgentConfigExecutionModelVertexModelConfigObjectProviderOptions { + if vt := u.OfSessionExecutesAgentConfigExecutionModelVertexModelConfigObject; vt != nil { + return &vt.ProviderOptions } return nil } -// The property Instruction is required. -type SessionExecuteParamsExecuteOptions struct { - // Natural language instruction for the agent - Instruction string `json:"instruction" api:"required"` - // Whether to visually highlight the cursor during execution - HighlightCursor param.Opt[bool] `json:"highlightCursor,omitzero"` - // Maximum number of steps the agent can take - MaxSteps param.Opt[float64] `json:"maxSteps,omitzero"` - // Timeout in milliseconds for each agent tool call - ToolTimeout param.Opt[float64] `json:"toolTimeout,omitzero"` - // Whether to enable the web search tool powered by Browserbase Search API - UseSearch param.Opt[bool] `json:"useSearch,omitzero"` - // Variables available to the agent via %variableName% syntax in supported tools - Variables map[string]SessionExecuteParamsExecuteOptionsVariableUnion `json:"variables,omitzero"` - paramObj +// Returns a pointer to the underlying variant's property, if present. +func (u SessionExecuteParamsAgentConfigExecutionModelUnion) GetModelName() *string { + if vt := u.OfSessionExecutesAgentConfigExecutionModelVertexModelConfigObject; vt != nil { + return (*string)(&vt.ModelName) + } else if vt := u.OfSessionExecutesAgentConfigExecutionModelGenericModelConfigObject; vt != nil { + return (*string)(&vt.ModelName) + } + return nil } -func (r SessionExecuteParamsExecuteOptions) MarshalJSON() (data []byte, err error) { - type shadow SessionExecuteParamsExecuteOptions - return param.MarshalObject(r, (*shadow)(&r)) -} -func (r *SessionExecuteParamsExecuteOptions) UnmarshalJSON(data []byte) error { - return apijson.UnmarshalRoot(data, r) +// Returns a pointer to the underlying variant's property, if present. +func (u SessionExecuteParamsAgentConfigExecutionModelUnion) GetProvider() *string { + if vt := u.OfSessionExecutesAgentConfigExecutionModelVertexModelConfigObject; vt != nil { + return (*string)(&vt.Provider) + } else if vt := u.OfSessionExecutesAgentConfigExecutionModelGenericModelConfigObject; vt != nil { + return (*string)(&vt.Provider) + } + return nil } -// Only one field can be non-zero. -// -// Use [param.IsOmitted] to confirm if a field is set. -type SessionExecuteParamsExecuteOptionsVariableUnion struct { - OfString param.Opt[string] `json:",omitzero,inline"` - OfFloat param.Opt[float64] `json:",omitzero,inline"` - OfBool param.Opt[bool] `json:",omitzero,inline"` - OfSessionExecutesExecuteOptionsVariableObject *SessionExecuteParamsExecuteOptionsVariableObject `json:",omitzero,inline"` - paramUnion +// Returns a pointer to the underlying variant's property, if present. +func (u SessionExecuteParamsAgentConfigExecutionModelUnion) GetAPIKey() *string { + if vt := u.OfSessionExecutesAgentConfigExecutionModelVertexModelConfigObject; vt != nil && vt.APIKey.Valid() { + return &vt.APIKey.Value + } else if vt := u.OfSessionExecutesAgentConfigExecutionModelGenericModelConfigObject; vt != nil && vt.APIKey.Valid() { + return &vt.APIKey.Value + } + return nil } -func (u SessionExecuteParamsExecuteOptionsVariableUnion) MarshalJSON() ([]byte, error) { - return param.MarshalUnion(u, u.OfString, u.OfFloat, u.OfBool, u.OfSessionExecutesExecuteOptionsVariableObject) -} -func (u *SessionExecuteParamsExecuteOptionsVariableUnion) UnmarshalJSON(data []byte) error { - return apijson.UnmarshalRoot(data, u) +// Returns a pointer to the underlying variant's property, if present. +func (u SessionExecuteParamsAgentConfigExecutionModelUnion) GetBaseURL() *string { + if vt := u.OfSessionExecutesAgentConfigExecutionModelVertexModelConfigObject; vt != nil && vt.BaseURL.Valid() { + return &vt.BaseURL.Value + } else if vt := u.OfSessionExecutesAgentConfigExecutionModelGenericModelConfigObject; vt != nil && vt.BaseURL.Valid() { + return &vt.BaseURL.Value + } + return nil } -func (u *SessionExecuteParamsExecuteOptionsVariableUnion) asAny() any { - if !param.IsOmitted(u.OfString) { - return &u.OfString.Value - } else if !param.IsOmitted(u.OfFloat) { - return &u.OfFloat.Value - } else if !param.IsOmitted(u.OfBool) { - return &u.OfBool.Value - } else if !param.IsOmitted(u.OfSessionExecutesExecuteOptionsVariableObject) { - return u.OfSessionExecutesExecuteOptionsVariableObject +// Returns a pointer to the underlying variant's Headers property, if present. +func (u SessionExecuteParamsAgentConfigExecutionModelUnion) GetHeaders() map[string]string { + if vt := u.OfSessionExecutesAgentConfigExecutionModelVertexModelConfigObject; vt != nil { + return vt.Headers + } else if vt := u.OfSessionExecutesAgentConfigExecutionModelGenericModelConfigObject; vt != nil { + return vt.Headers } return nil } -// The property Value is required. -type SessionExecuteParamsExecuteOptionsVariableObject struct { - Value SessionExecuteParamsExecuteOptionsVariableObjectValueUnion `json:"value,omitzero" api:"required"` - Description param.Opt[string] `json:"description,omitzero"` +// The properties Auth, ModelName, Provider, ProviderOptions are required. +type SessionExecuteParamsAgentConfigExecutionModelVertexModelConfigObject struct { + // Vertex provider authentication configuration + Auth SessionExecuteParamsAgentConfigExecutionModelVertexModelConfigObjectAuth `json:"auth,omitzero" api:"required"` + // Model name string with provider prefix (e.g., 'openai/gpt-5-nano') + ModelName string `json:"modelName" api:"required"` + // Vertex provider-specific model configuration + ProviderOptions SessionExecuteParamsAgentConfigExecutionModelVertexModelConfigObjectProviderOptions `json:"providerOptions,omitzero" api:"required"` + // API key for the model provider + APIKey param.Opt[string] `json:"apiKey,omitzero"` + // Base URL for the model provider + BaseURL param.Opt[string] `json:"baseURL,omitzero" format:"uri"` + // Custom headers sent with every request to the model provider + Headers map[string]string `json:"headers,omitzero"` + // Vertex AI model provider + // + // This field can be elided, and will marshal its zero value as "vertex". + Provider constant.Vertex `json:"provider" default:"vertex"` paramObj } -func (r SessionExecuteParamsExecuteOptionsVariableObject) MarshalJSON() (data []byte, err error) { - type shadow SessionExecuteParamsExecuteOptionsVariableObject +func (r SessionExecuteParamsAgentConfigExecutionModelVertexModelConfigObject) MarshalJSON() (data []byte, err error) { + type shadow SessionExecuteParamsAgentConfigExecutionModelVertexModelConfigObject + return param.MarshalObject(r, (*shadow)(&r)) +} +func (r *SessionExecuteParamsAgentConfigExecutionModelVertexModelConfigObject) UnmarshalJSON(data []byte) error { + return apijson.UnmarshalRoot(data, r) +} + +// Vertex provider authentication configuration +// +// The properties Credentials, Type are required. +type SessionExecuteParamsAgentConfigExecutionModelVertexModelConfigObjectAuth struct { + // Google Cloud service account credentials + Credentials SessionExecuteParamsAgentConfigExecutionModelVertexModelConfigObjectAuthCredentials `json:"credentials,omitzero" api:"required"` + // Google Cloud project ID used by google-auth-library + ProjectID param.Opt[string] `json:"projectId,omitzero"` + // Google Cloud universe domain + UniverseDomain param.Opt[string] `json:"universeDomain,omitzero"` + // Google auth scopes for the desired API request + Scopes SessionExecuteParamsAgentConfigExecutionModelVertexModelConfigObjectAuthScopesUnion `json:"scopes,omitzero"` + // Use inline Google Cloud service account credentials for provider authentication + // + // This field can be elided, and will marshal its zero value as + // "googleServiceAccount". + Type constant.GoogleServiceAccount `json:"type" default:"googleServiceAccount"` + paramObj +} + +func (r SessionExecuteParamsAgentConfigExecutionModelVertexModelConfigObjectAuth) MarshalJSON() (data []byte, err error) { + type shadow SessionExecuteParamsAgentConfigExecutionModelVertexModelConfigObjectAuth + return param.MarshalObject(r, (*shadow)(&r)) +} +func (r *SessionExecuteParamsAgentConfigExecutionModelVertexModelConfigObjectAuth) UnmarshalJSON(data []byte) error { + return apijson.UnmarshalRoot(data, r) +} + +// Google Cloud service account credentials +// +// The properties ClientEmail, PrivateKey are required. +type SessionExecuteParamsAgentConfigExecutionModelVertexModelConfigObjectAuthCredentials struct { + ClientEmail string `json:"client_email" api:"required"` + PrivateKey string `json:"private_key" api:"required"` + AuthProviderX509CertURL param.Opt[string] `json:"auth_provider_x509_cert_url,omitzero" format:"uri"` + AuthUri param.Opt[string] `json:"auth_uri,omitzero" format:"uri"` + ClientID param.Opt[string] `json:"client_id,omitzero"` + ClientX509CertURL param.Opt[string] `json:"client_x509_cert_url,omitzero" format:"uri"` + PrivateKeyID param.Opt[string] `json:"private_key_id,omitzero"` + ProjectID param.Opt[string] `json:"project_id,omitzero"` + TokenUri param.Opt[string] `json:"token_uri,omitzero" format:"uri"` + UniverseDomain param.Opt[string] `json:"universe_domain,omitzero"` + // Any of "service_account". + Type string `json:"type,omitzero"` + paramObj +} + +func (r SessionExecuteParamsAgentConfigExecutionModelVertexModelConfigObjectAuthCredentials) MarshalJSON() (data []byte, err error) { + type shadow SessionExecuteParamsAgentConfigExecutionModelVertexModelConfigObjectAuthCredentials + return param.MarshalObject(r, (*shadow)(&r)) +} +func (r *SessionExecuteParamsAgentConfigExecutionModelVertexModelConfigObjectAuthCredentials) UnmarshalJSON(data []byte) error { + return apijson.UnmarshalRoot(data, r) +} + +func init() { + apijson.RegisterFieldValidator[SessionExecuteParamsAgentConfigExecutionModelVertexModelConfigObjectAuthCredentials]( + "type", "service_account", + ) +} + +// Only one field can be non-zero. +// +// Use [param.IsOmitted] to confirm if a field is set. +type SessionExecuteParamsAgentConfigExecutionModelVertexModelConfigObjectAuthScopesUnion struct { + OfString param.Opt[string] `json:",omitzero,inline"` + OfStringArray []string `json:",omitzero,inline"` + paramUnion +} + +func (u SessionExecuteParamsAgentConfigExecutionModelVertexModelConfigObjectAuthScopesUnion) MarshalJSON() ([]byte, error) { + return param.MarshalUnion(u, u.OfString, u.OfStringArray) +} +func (u *SessionExecuteParamsAgentConfigExecutionModelVertexModelConfigObjectAuthScopesUnion) UnmarshalJSON(data []byte) error { + return apijson.UnmarshalRoot(data, u) +} + +func (u *SessionExecuteParamsAgentConfigExecutionModelVertexModelConfigObjectAuthScopesUnion) asAny() any { + if !param.IsOmitted(u.OfString) { + return &u.OfString.Value + } else if !param.IsOmitted(u.OfStringArray) { + return &u.OfStringArray + } + return nil +} + +// Vertex provider-specific model configuration +// +// The property Vertex is required. +type SessionExecuteParamsAgentConfigExecutionModelVertexModelConfigObjectProviderOptions struct { + // Vertex AI provider-specific settings + Vertex SessionExecuteParamsAgentConfigExecutionModelVertexModelConfigObjectProviderOptionsVertex `json:"vertex,omitzero" api:"required"` + paramObj +} + +func (r SessionExecuteParamsAgentConfigExecutionModelVertexModelConfigObjectProviderOptions) MarshalJSON() (data []byte, err error) { + type shadow SessionExecuteParamsAgentConfigExecutionModelVertexModelConfigObjectProviderOptions + return param.MarshalObject(r, (*shadow)(&r)) +} +func (r *SessionExecuteParamsAgentConfigExecutionModelVertexModelConfigObjectProviderOptions) UnmarshalJSON(data []byte) error { + return apijson.UnmarshalRoot(data, r) +} + +// Vertex AI provider-specific settings +// +// The properties Location, Project are required. +type SessionExecuteParamsAgentConfigExecutionModelVertexModelConfigObjectProviderOptionsVertex struct { + // Google Cloud location for Vertex AI models + Location string `json:"location" api:"required"` + // Google Cloud project ID for Vertex AI models + Project string `json:"project" api:"required"` + // Base URL for the Vertex AI provider + BaseURL param.Opt[string] `json:"baseURL,omitzero" format:"uri"` + // Custom headers sent with every request to the Vertex AI provider + Headers map[string]string `json:"headers,omitzero"` + paramObj +} + +func (r SessionExecuteParamsAgentConfigExecutionModelVertexModelConfigObjectProviderOptionsVertex) MarshalJSON() (data []byte, err error) { + type shadow SessionExecuteParamsAgentConfigExecutionModelVertexModelConfigObjectProviderOptionsVertex + return param.MarshalObject(r, (*shadow)(&r)) +} +func (r *SessionExecuteParamsAgentConfigExecutionModelVertexModelConfigObjectProviderOptionsVertex) UnmarshalJSON(data []byte) error { + return apijson.UnmarshalRoot(data, r) +} + +// The property ModelName is required. +type SessionExecuteParamsAgentConfigExecutionModelGenericModelConfigObject struct { + // Model name string with provider prefix (e.g., 'openai/gpt-5-nano') + ModelName string `json:"modelName" api:"required"` + // API key for the model provider + APIKey param.Opt[string] `json:"apiKey,omitzero"` + // Base URL for the model provider + BaseURL param.Opt[string] `json:"baseURL,omitzero" format:"uri"` + // Custom headers sent with every request to the model provider + Headers map[string]string `json:"headers,omitzero"` + // AI provider for the model (or provide a baseURL endpoint instead) + // + // Any of "openai", "anthropic", "google", "microsoft", "bedrock". + Provider string `json:"provider,omitzero"` + paramObj +} + +func (r SessionExecuteParamsAgentConfigExecutionModelGenericModelConfigObject) MarshalJSON() (data []byte, err error) { + type shadow SessionExecuteParamsAgentConfigExecutionModelGenericModelConfigObject + return param.MarshalObject(r, (*shadow)(&r)) +} +func (r *SessionExecuteParamsAgentConfigExecutionModelGenericModelConfigObject) UnmarshalJSON(data []byte) error { + return apijson.UnmarshalRoot(data, r) +} + +func init() { + apijson.RegisterFieldValidator[SessionExecuteParamsAgentConfigExecutionModelGenericModelConfigObject]( + "provider", "openai", "anthropic", "google", "microsoft", "bedrock", + ) +} + +// Only one field can be non-zero. +// +// Use [param.IsOmitted] to confirm if a field is set. +type SessionExecuteParamsAgentConfigModelUnion struct { + OfSessionExecutesAgentConfigModelVertexModelConfigObject *SessionExecuteParamsAgentConfigModelVertexModelConfigObject `json:",omitzero,inline"` + OfSessionExecutesAgentConfigModelGenericModelConfigObject *SessionExecuteParamsAgentConfigModelGenericModelConfigObject `json:",omitzero,inline"` + OfString param.Opt[string] `json:",omitzero,inline"` + paramUnion +} + +func (u SessionExecuteParamsAgentConfigModelUnion) MarshalJSON() ([]byte, error) { + return param.MarshalUnion(u, u.OfSessionExecutesAgentConfigModelVertexModelConfigObject, u.OfSessionExecutesAgentConfigModelGenericModelConfigObject, u.OfString) +} +func (u *SessionExecuteParamsAgentConfigModelUnion) UnmarshalJSON(data []byte) error { + return apijson.UnmarshalRoot(data, u) +} + +func (u *SessionExecuteParamsAgentConfigModelUnion) asAny() any { + if !param.IsOmitted(u.OfSessionExecutesAgentConfigModelVertexModelConfigObject) { + return u.OfSessionExecutesAgentConfigModelVertexModelConfigObject + } else if !param.IsOmitted(u.OfSessionExecutesAgentConfigModelGenericModelConfigObject) { + return u.OfSessionExecutesAgentConfigModelGenericModelConfigObject + } else if !param.IsOmitted(u.OfString) { + return &u.OfString.Value + } + return nil +} + +// Returns a pointer to the underlying variant's property, if present. +func (u SessionExecuteParamsAgentConfigModelUnion) GetAuth() *SessionExecuteParamsAgentConfigModelVertexModelConfigObjectAuth { + if vt := u.OfSessionExecutesAgentConfigModelVertexModelConfigObject; vt != nil { + return &vt.Auth + } + return nil +} + +// Returns a pointer to the underlying variant's property, if present. +func (u SessionExecuteParamsAgentConfigModelUnion) GetProviderOptions() *SessionExecuteParamsAgentConfigModelVertexModelConfigObjectProviderOptions { + if vt := u.OfSessionExecutesAgentConfigModelVertexModelConfigObject; vt != nil { + return &vt.ProviderOptions + } + return nil +} + +// Returns a pointer to the underlying variant's property, if present. +func (u SessionExecuteParamsAgentConfigModelUnion) GetModelName() *string { + if vt := u.OfSessionExecutesAgentConfigModelVertexModelConfigObject; vt != nil { + return (*string)(&vt.ModelName) + } else if vt := u.OfSessionExecutesAgentConfigModelGenericModelConfigObject; vt != nil { + return (*string)(&vt.ModelName) + } + return nil +} + +// Returns a pointer to the underlying variant's property, if present. +func (u SessionExecuteParamsAgentConfigModelUnion) GetProvider() *string { + if vt := u.OfSessionExecutesAgentConfigModelVertexModelConfigObject; vt != nil { + return (*string)(&vt.Provider) + } else if vt := u.OfSessionExecutesAgentConfigModelGenericModelConfigObject; vt != nil { + return (*string)(&vt.Provider) + } + return nil +} + +// Returns a pointer to the underlying variant's property, if present. +func (u SessionExecuteParamsAgentConfigModelUnion) GetAPIKey() *string { + if vt := u.OfSessionExecutesAgentConfigModelVertexModelConfigObject; vt != nil && vt.APIKey.Valid() { + return &vt.APIKey.Value + } else if vt := u.OfSessionExecutesAgentConfigModelGenericModelConfigObject; vt != nil && vt.APIKey.Valid() { + return &vt.APIKey.Value + } + return nil +} + +// Returns a pointer to the underlying variant's property, if present. +func (u SessionExecuteParamsAgentConfigModelUnion) GetBaseURL() *string { + if vt := u.OfSessionExecutesAgentConfigModelVertexModelConfigObject; vt != nil && vt.BaseURL.Valid() { + return &vt.BaseURL.Value + } else if vt := u.OfSessionExecutesAgentConfigModelGenericModelConfigObject; vt != nil && vt.BaseURL.Valid() { + return &vt.BaseURL.Value + } + return nil +} + +// Returns a pointer to the underlying variant's Headers property, if present. +func (u SessionExecuteParamsAgentConfigModelUnion) GetHeaders() map[string]string { + if vt := u.OfSessionExecutesAgentConfigModelVertexModelConfigObject; vt != nil { + return vt.Headers + } else if vt := u.OfSessionExecutesAgentConfigModelGenericModelConfigObject; vt != nil { + return vt.Headers + } + return nil +} + +// The properties Auth, ModelName, Provider, ProviderOptions are required. +type SessionExecuteParamsAgentConfigModelVertexModelConfigObject struct { + // Vertex provider authentication configuration + Auth SessionExecuteParamsAgentConfigModelVertexModelConfigObjectAuth `json:"auth,omitzero" api:"required"` + // Model name string with provider prefix (e.g., 'openai/gpt-5-nano') + ModelName string `json:"modelName" api:"required"` + // Vertex provider-specific model configuration + ProviderOptions SessionExecuteParamsAgentConfigModelVertexModelConfigObjectProviderOptions `json:"providerOptions,omitzero" api:"required"` + // API key for the model provider + APIKey param.Opt[string] `json:"apiKey,omitzero"` + // Base URL for the model provider + BaseURL param.Opt[string] `json:"baseURL,omitzero" format:"uri"` + // Custom headers sent with every request to the model provider + Headers map[string]string `json:"headers,omitzero"` + // Vertex AI model provider + // + // This field can be elided, and will marshal its zero value as "vertex". + Provider constant.Vertex `json:"provider" default:"vertex"` + paramObj +} + +func (r SessionExecuteParamsAgentConfigModelVertexModelConfigObject) MarshalJSON() (data []byte, err error) { + type shadow SessionExecuteParamsAgentConfigModelVertexModelConfigObject + return param.MarshalObject(r, (*shadow)(&r)) +} +func (r *SessionExecuteParamsAgentConfigModelVertexModelConfigObject) UnmarshalJSON(data []byte) error { + return apijson.UnmarshalRoot(data, r) +} + +// Vertex provider authentication configuration +// +// The properties Credentials, Type are required. +type SessionExecuteParamsAgentConfigModelVertexModelConfigObjectAuth struct { + // Google Cloud service account credentials + Credentials SessionExecuteParamsAgentConfigModelVertexModelConfigObjectAuthCredentials `json:"credentials,omitzero" api:"required"` + // Google Cloud project ID used by google-auth-library + ProjectID param.Opt[string] `json:"projectId,omitzero"` + // Google Cloud universe domain + UniverseDomain param.Opt[string] `json:"universeDomain,omitzero"` + // Google auth scopes for the desired API request + Scopes SessionExecuteParamsAgentConfigModelVertexModelConfigObjectAuthScopesUnion `json:"scopes,omitzero"` + // Use inline Google Cloud service account credentials for provider authentication + // + // This field can be elided, and will marshal its zero value as + // "googleServiceAccount". + Type constant.GoogleServiceAccount `json:"type" default:"googleServiceAccount"` + paramObj +} + +func (r SessionExecuteParamsAgentConfigModelVertexModelConfigObjectAuth) MarshalJSON() (data []byte, err error) { + type shadow SessionExecuteParamsAgentConfigModelVertexModelConfigObjectAuth + return param.MarshalObject(r, (*shadow)(&r)) +} +func (r *SessionExecuteParamsAgentConfigModelVertexModelConfigObjectAuth) UnmarshalJSON(data []byte) error { + return apijson.UnmarshalRoot(data, r) +} + +// Google Cloud service account credentials +// +// The properties ClientEmail, PrivateKey are required. +type SessionExecuteParamsAgentConfigModelVertexModelConfigObjectAuthCredentials struct { + ClientEmail string `json:"client_email" api:"required"` + PrivateKey string `json:"private_key" api:"required"` + AuthProviderX509CertURL param.Opt[string] `json:"auth_provider_x509_cert_url,omitzero" format:"uri"` + AuthUri param.Opt[string] `json:"auth_uri,omitzero" format:"uri"` + ClientID param.Opt[string] `json:"client_id,omitzero"` + ClientX509CertURL param.Opt[string] `json:"client_x509_cert_url,omitzero" format:"uri"` + PrivateKeyID param.Opt[string] `json:"private_key_id,omitzero"` + ProjectID param.Opt[string] `json:"project_id,omitzero"` + TokenUri param.Opt[string] `json:"token_uri,omitzero" format:"uri"` + UniverseDomain param.Opt[string] `json:"universe_domain,omitzero"` + // Any of "service_account". + Type string `json:"type,omitzero"` + paramObj +} + +func (r SessionExecuteParamsAgentConfigModelVertexModelConfigObjectAuthCredentials) MarshalJSON() (data []byte, err error) { + type shadow SessionExecuteParamsAgentConfigModelVertexModelConfigObjectAuthCredentials + return param.MarshalObject(r, (*shadow)(&r)) +} +func (r *SessionExecuteParamsAgentConfigModelVertexModelConfigObjectAuthCredentials) UnmarshalJSON(data []byte) error { + return apijson.UnmarshalRoot(data, r) +} + +func init() { + apijson.RegisterFieldValidator[SessionExecuteParamsAgentConfigModelVertexModelConfigObjectAuthCredentials]( + "type", "service_account", + ) +} + +// Only one field can be non-zero. +// +// Use [param.IsOmitted] to confirm if a field is set. +type SessionExecuteParamsAgentConfigModelVertexModelConfigObjectAuthScopesUnion struct { + OfString param.Opt[string] `json:",omitzero,inline"` + OfStringArray []string `json:",omitzero,inline"` + paramUnion +} + +func (u SessionExecuteParamsAgentConfigModelVertexModelConfigObjectAuthScopesUnion) MarshalJSON() ([]byte, error) { + return param.MarshalUnion(u, u.OfString, u.OfStringArray) +} +func (u *SessionExecuteParamsAgentConfigModelVertexModelConfigObjectAuthScopesUnion) UnmarshalJSON(data []byte) error { + return apijson.UnmarshalRoot(data, u) +} + +func (u *SessionExecuteParamsAgentConfigModelVertexModelConfigObjectAuthScopesUnion) asAny() any { + if !param.IsOmitted(u.OfString) { + return &u.OfString.Value + } else if !param.IsOmitted(u.OfStringArray) { + return &u.OfStringArray + } + return nil +} + +// Vertex provider-specific model configuration +// +// The property Vertex is required. +type SessionExecuteParamsAgentConfigModelVertexModelConfigObjectProviderOptions struct { + // Vertex AI provider-specific settings + Vertex SessionExecuteParamsAgentConfigModelVertexModelConfigObjectProviderOptionsVertex `json:"vertex,omitzero" api:"required"` + paramObj +} + +func (r SessionExecuteParamsAgentConfigModelVertexModelConfigObjectProviderOptions) MarshalJSON() (data []byte, err error) { + type shadow SessionExecuteParamsAgentConfigModelVertexModelConfigObjectProviderOptions + return param.MarshalObject(r, (*shadow)(&r)) +} +func (r *SessionExecuteParamsAgentConfigModelVertexModelConfigObjectProviderOptions) UnmarshalJSON(data []byte) error { + return apijson.UnmarshalRoot(data, r) +} + +// Vertex AI provider-specific settings +// +// The properties Location, Project are required. +type SessionExecuteParamsAgentConfigModelVertexModelConfigObjectProviderOptionsVertex struct { + // Google Cloud location for Vertex AI models + Location string `json:"location" api:"required"` + // Google Cloud project ID for Vertex AI models + Project string `json:"project" api:"required"` + // Base URL for the Vertex AI provider + BaseURL param.Opt[string] `json:"baseURL,omitzero" format:"uri"` + // Custom headers sent with every request to the Vertex AI provider + Headers map[string]string `json:"headers,omitzero"` + paramObj +} + +func (r SessionExecuteParamsAgentConfigModelVertexModelConfigObjectProviderOptionsVertex) MarshalJSON() (data []byte, err error) { + type shadow SessionExecuteParamsAgentConfigModelVertexModelConfigObjectProviderOptionsVertex + return param.MarshalObject(r, (*shadow)(&r)) +} +func (r *SessionExecuteParamsAgentConfigModelVertexModelConfigObjectProviderOptionsVertex) UnmarshalJSON(data []byte) error { + return apijson.UnmarshalRoot(data, r) +} + +// The property ModelName is required. +type SessionExecuteParamsAgentConfigModelGenericModelConfigObject struct { + // Model name string with provider prefix (e.g., 'openai/gpt-5-nano') + ModelName string `json:"modelName" api:"required"` + // API key for the model provider + APIKey param.Opt[string] `json:"apiKey,omitzero"` + // Base URL for the model provider + BaseURL param.Opt[string] `json:"baseURL,omitzero" format:"uri"` + // Custom headers sent with every request to the model provider + Headers map[string]string `json:"headers,omitzero"` + // AI provider for the model (or provide a baseURL endpoint instead) + // + // Any of "openai", "anthropic", "google", "microsoft", "bedrock". + Provider string `json:"provider,omitzero"` + paramObj +} + +func (r SessionExecuteParamsAgentConfigModelGenericModelConfigObject) MarshalJSON() (data []byte, err error) { + type shadow SessionExecuteParamsAgentConfigModelGenericModelConfigObject + return param.MarshalObject(r, (*shadow)(&r)) +} +func (r *SessionExecuteParamsAgentConfigModelGenericModelConfigObject) UnmarshalJSON(data []byte) error { + return apijson.UnmarshalRoot(data, r) +} + +func init() { + apijson.RegisterFieldValidator[SessionExecuteParamsAgentConfigModelGenericModelConfigObject]( + "provider", "openai", "anthropic", "google", "microsoft", "bedrock", + ) +} + +// The property Instruction is required. +type SessionExecuteParamsExecuteOptions struct { + // Natural language instruction for the agent + Instruction string `json:"instruction" api:"required"` + // Whether to visually highlight the cursor during execution + HighlightCursor param.Opt[bool] `json:"highlightCursor,omitzero"` + // Maximum number of steps the agent can take + MaxSteps param.Opt[float64] `json:"maxSteps,omitzero"` + // Timeout in milliseconds for each agent tool call + ToolTimeout param.Opt[float64] `json:"toolTimeout,omitzero"` + // Whether to enable the web search tool powered by Browserbase Search API + UseSearch param.Opt[bool] `json:"useSearch,omitzero"` + // Variables available to the agent via %variableName% syntax in supported tools + Variables map[string]SessionExecuteParamsExecuteOptionsVariableUnion `json:"variables,omitzero"` + paramObj +} + +func (r SessionExecuteParamsExecuteOptions) MarshalJSON() (data []byte, err error) { + type shadow SessionExecuteParamsExecuteOptions + return param.MarshalObject(r, (*shadow)(&r)) +} +func (r *SessionExecuteParamsExecuteOptions) 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 SessionExecuteParamsExecuteOptionsVariableUnion struct { + OfString param.Opt[string] `json:",omitzero,inline"` + OfFloat param.Opt[float64] `json:",omitzero,inline"` + OfBool param.Opt[bool] `json:",omitzero,inline"` + OfSessionExecutesExecuteOptionsVariableObject *SessionExecuteParamsExecuteOptionsVariableObject `json:",omitzero,inline"` + paramUnion +} + +func (u SessionExecuteParamsExecuteOptionsVariableUnion) MarshalJSON() ([]byte, error) { + return param.MarshalUnion(u, u.OfString, u.OfFloat, u.OfBool, u.OfSessionExecutesExecuteOptionsVariableObject) +} +func (u *SessionExecuteParamsExecuteOptionsVariableUnion) UnmarshalJSON(data []byte) error { + return apijson.UnmarshalRoot(data, u) +} + +func (u *SessionExecuteParamsExecuteOptionsVariableUnion) asAny() any { + if !param.IsOmitted(u.OfString) { + return &u.OfString.Value + } else if !param.IsOmitted(u.OfFloat) { + return &u.OfFloat.Value + } else if !param.IsOmitted(u.OfBool) { + return &u.OfBool.Value + } else if !param.IsOmitted(u.OfSessionExecutesExecuteOptionsVariableObject) { + return u.OfSessionExecutesExecuteOptionsVariableObject + } + return nil +} + +// The property Value is required. +type SessionExecuteParamsExecuteOptionsVariableObject struct { + Value SessionExecuteParamsExecuteOptionsVariableObjectValueUnion `json:"value,omitzero" api:"required"` + Description param.Opt[string] `json:"description,omitzero"` + paramObj +} + +func (r SessionExecuteParamsExecuteOptionsVariableObject) MarshalJSON() (data []byte, err error) { + type shadow SessionExecuteParamsExecuteOptionsVariableObject return param.MarshalObject(r, (*shadow)(&r)) } func (r *SessionExecuteParamsExecuteOptionsVariableObject) UnmarshalJSON(data []byte) error { @@ -1342,105 +2071,363 @@ func (r *SessionExecuteParamsExecuteOptionsVariableObject) UnmarshalJSON(data [] // Only one field can be non-zero. // // Use [param.IsOmitted] to confirm if a field is set. -type SessionExecuteParamsExecuteOptionsVariableObjectValueUnion struct { - OfString param.Opt[string] `json:",omitzero,inline"` - OfFloat param.Opt[float64] `json:",omitzero,inline"` - OfBool param.Opt[bool] `json:",omitzero,inline"` +type SessionExecuteParamsExecuteOptionsVariableObjectValueUnion struct { + OfString param.Opt[string] `json:",omitzero,inline"` + OfFloat param.Opt[float64] `json:",omitzero,inline"` + OfBool param.Opt[bool] `json:",omitzero,inline"` + paramUnion +} + +func (u SessionExecuteParamsExecuteOptionsVariableObjectValueUnion) MarshalJSON() ([]byte, error) { + return param.MarshalUnion(u, u.OfString, u.OfFloat, u.OfBool) +} +func (u *SessionExecuteParamsExecuteOptionsVariableObjectValueUnion) UnmarshalJSON(data []byte) error { + return apijson.UnmarshalRoot(data, u) +} + +func (u *SessionExecuteParamsExecuteOptionsVariableObjectValueUnion) asAny() any { + if !param.IsOmitted(u.OfString) { + return &u.OfString.Value + } else if !param.IsOmitted(u.OfFloat) { + return &u.OfFloat.Value + } else if !param.IsOmitted(u.OfBool) { + return &u.OfBool.Value + } + return nil +} + +// Whether to stream the response via SSE +type SessionExecuteParamsXStreamResponse string + +const ( + SessionExecuteParamsXStreamResponseTrue SessionExecuteParamsXStreamResponse = "true" + SessionExecuteParamsXStreamResponseFalse SessionExecuteParamsXStreamResponse = "false" +) + +type SessionExtractParams struct { + // Target frame ID for the extraction + FrameID param.Opt[string] `json:"frameId,omitzero"` + // Natural language instruction for what to extract + Instruction param.Opt[string] `json:"instruction,omitzero"` + Options SessionExtractParamsOptions `json:"options,omitzero"` + // JSON Schema defining the structure of data to extract + Schema map[string]any `json:"schema,omitzero"` + // Whether to stream the response via SSE + // + // Any of "true", "false". + XStreamResponse SessionExtractParamsXStreamResponse `header:"x-stream-response,omitzero" json:"-"` + paramObj +} + +func (r SessionExtractParams) MarshalJSON() (data []byte, err error) { + type shadow SessionExtractParams + return param.MarshalObject(r, (*shadow)(&r)) +} +func (r *SessionExtractParams) UnmarshalJSON(data []byte) error { + return apijson.UnmarshalRoot(data, r) +} + +type SessionExtractParamsOptions struct { + // When true, include a screenshot of the current viewport in the extraction LLM + // call. Defaults to false. + Screenshot param.Opt[bool] `json:"screenshot,omitzero"` + // CSS selector to scope extraction to a specific element + Selector param.Opt[string] `json:"selector,omitzero"` + // Timeout in ms for the extraction + Timeout param.Opt[float64] `json:"timeout,omitzero"` + // Selectors for elements and subtrees that should be excluded from extraction + IgnoreSelectors []string `json:"ignoreSelectors,omitzero"` + // Model configuration object or model name string (e.g., 'openai/gpt-5-nano') + Model SessionExtractParamsOptionsModelUnion `json:"model,omitzero"` + paramObj +} + +func (r SessionExtractParamsOptions) MarshalJSON() (data []byte, err error) { + type shadow SessionExtractParamsOptions + return param.MarshalObject(r, (*shadow)(&r)) +} +func (r *SessionExtractParamsOptions) 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 SessionExtractParamsOptionsModelUnion struct { + OfSessionExtractsOptionsModelVertexModelConfigObject *SessionExtractParamsOptionsModelVertexModelConfigObject `json:",omitzero,inline"` + OfSessionExtractsOptionsModelGenericModelConfigObject *SessionExtractParamsOptionsModelGenericModelConfigObject `json:",omitzero,inline"` + OfString param.Opt[string] `json:",omitzero,inline"` + paramUnion +} + +func (u SessionExtractParamsOptionsModelUnion) MarshalJSON() ([]byte, error) { + return param.MarshalUnion(u, u.OfSessionExtractsOptionsModelVertexModelConfigObject, u.OfSessionExtractsOptionsModelGenericModelConfigObject, u.OfString) +} +func (u *SessionExtractParamsOptionsModelUnion) UnmarshalJSON(data []byte) error { + return apijson.UnmarshalRoot(data, u) +} + +func (u *SessionExtractParamsOptionsModelUnion) asAny() any { + if !param.IsOmitted(u.OfSessionExtractsOptionsModelVertexModelConfigObject) { + return u.OfSessionExtractsOptionsModelVertexModelConfigObject + } else if !param.IsOmitted(u.OfSessionExtractsOptionsModelGenericModelConfigObject) { + return u.OfSessionExtractsOptionsModelGenericModelConfigObject + } else if !param.IsOmitted(u.OfString) { + return &u.OfString.Value + } + return nil +} + +// Returns a pointer to the underlying variant's property, if present. +func (u SessionExtractParamsOptionsModelUnion) GetAuth() *SessionExtractParamsOptionsModelVertexModelConfigObjectAuth { + if vt := u.OfSessionExtractsOptionsModelVertexModelConfigObject; vt != nil { + return &vt.Auth + } + return nil +} + +// Returns a pointer to the underlying variant's property, if present. +func (u SessionExtractParamsOptionsModelUnion) GetProviderOptions() *SessionExtractParamsOptionsModelVertexModelConfigObjectProviderOptions { + if vt := u.OfSessionExtractsOptionsModelVertexModelConfigObject; vt != nil { + return &vt.ProviderOptions + } + return nil +} + +// Returns a pointer to the underlying variant's property, if present. +func (u SessionExtractParamsOptionsModelUnion) GetModelName() *string { + if vt := u.OfSessionExtractsOptionsModelVertexModelConfigObject; vt != nil { + return (*string)(&vt.ModelName) + } else if vt := u.OfSessionExtractsOptionsModelGenericModelConfigObject; vt != nil { + return (*string)(&vt.ModelName) + } + return nil +} + +// Returns a pointer to the underlying variant's property, if present. +func (u SessionExtractParamsOptionsModelUnion) GetProvider() *string { + if vt := u.OfSessionExtractsOptionsModelVertexModelConfigObject; vt != nil { + return (*string)(&vt.Provider) + } else if vt := u.OfSessionExtractsOptionsModelGenericModelConfigObject; vt != nil { + return (*string)(&vt.Provider) + } + return nil +} + +// Returns a pointer to the underlying variant's property, if present. +func (u SessionExtractParamsOptionsModelUnion) GetAPIKey() *string { + if vt := u.OfSessionExtractsOptionsModelVertexModelConfigObject; vt != nil && vt.APIKey.Valid() { + return &vt.APIKey.Value + } else if vt := u.OfSessionExtractsOptionsModelGenericModelConfigObject; vt != nil && vt.APIKey.Valid() { + return &vt.APIKey.Value + } + return nil +} + +// Returns a pointer to the underlying variant's property, if present. +func (u SessionExtractParamsOptionsModelUnion) GetBaseURL() *string { + if vt := u.OfSessionExtractsOptionsModelVertexModelConfigObject; vt != nil && vt.BaseURL.Valid() { + return &vt.BaseURL.Value + } else if vt := u.OfSessionExtractsOptionsModelGenericModelConfigObject; vt != nil && vt.BaseURL.Valid() { + return &vt.BaseURL.Value + } + return nil +} + +// Returns a pointer to the underlying variant's Headers property, if present. +func (u SessionExtractParamsOptionsModelUnion) GetHeaders() map[string]string { + if vt := u.OfSessionExtractsOptionsModelVertexModelConfigObject; vt != nil { + return vt.Headers + } else if vt := u.OfSessionExtractsOptionsModelGenericModelConfigObject; vt != nil { + return vt.Headers + } + return nil +} + +// The properties Auth, ModelName, Provider, ProviderOptions are required. +type SessionExtractParamsOptionsModelVertexModelConfigObject struct { + // Vertex provider authentication configuration + Auth SessionExtractParamsOptionsModelVertexModelConfigObjectAuth `json:"auth,omitzero" api:"required"` + // Model name string with provider prefix (e.g., 'openai/gpt-5-nano') + ModelName string `json:"modelName" api:"required"` + // Vertex provider-specific model configuration + ProviderOptions SessionExtractParamsOptionsModelVertexModelConfigObjectProviderOptions `json:"providerOptions,omitzero" api:"required"` + // API key for the model provider + APIKey param.Opt[string] `json:"apiKey,omitzero"` + // Base URL for the model provider + BaseURL param.Opt[string] `json:"baseURL,omitzero" format:"uri"` + // Custom headers sent with every request to the model provider + Headers map[string]string `json:"headers,omitzero"` + // Vertex AI model provider + // + // This field can be elided, and will marshal its zero value as "vertex". + Provider constant.Vertex `json:"provider" default:"vertex"` + paramObj +} + +func (r SessionExtractParamsOptionsModelVertexModelConfigObject) MarshalJSON() (data []byte, err error) { + type shadow SessionExtractParamsOptionsModelVertexModelConfigObject + return param.MarshalObject(r, (*shadow)(&r)) +} +func (r *SessionExtractParamsOptionsModelVertexModelConfigObject) UnmarshalJSON(data []byte) error { + return apijson.UnmarshalRoot(data, r) +} + +// Vertex provider authentication configuration +// +// The properties Credentials, Type are required. +type SessionExtractParamsOptionsModelVertexModelConfigObjectAuth struct { + // Google Cloud service account credentials + Credentials SessionExtractParamsOptionsModelVertexModelConfigObjectAuthCredentials `json:"credentials,omitzero" api:"required"` + // Google Cloud project ID used by google-auth-library + ProjectID param.Opt[string] `json:"projectId,omitzero"` + // Google Cloud universe domain + UniverseDomain param.Opt[string] `json:"universeDomain,omitzero"` + // Google auth scopes for the desired API request + Scopes SessionExtractParamsOptionsModelVertexModelConfigObjectAuthScopesUnion `json:"scopes,omitzero"` + // Use inline Google Cloud service account credentials for provider authentication + // + // This field can be elided, and will marshal its zero value as + // "googleServiceAccount". + Type constant.GoogleServiceAccount `json:"type" default:"googleServiceAccount"` + paramObj +} + +func (r SessionExtractParamsOptionsModelVertexModelConfigObjectAuth) MarshalJSON() (data []byte, err error) { + type shadow SessionExtractParamsOptionsModelVertexModelConfigObjectAuth + return param.MarshalObject(r, (*shadow)(&r)) +} +func (r *SessionExtractParamsOptionsModelVertexModelConfigObjectAuth) UnmarshalJSON(data []byte) error { + return apijson.UnmarshalRoot(data, r) +} + +// Google Cloud service account credentials +// +// The properties ClientEmail, PrivateKey are required. +type SessionExtractParamsOptionsModelVertexModelConfigObjectAuthCredentials struct { + ClientEmail string `json:"client_email" api:"required"` + PrivateKey string `json:"private_key" api:"required"` + AuthProviderX509CertURL param.Opt[string] `json:"auth_provider_x509_cert_url,omitzero" format:"uri"` + AuthUri param.Opt[string] `json:"auth_uri,omitzero" format:"uri"` + ClientID param.Opt[string] `json:"client_id,omitzero"` + ClientX509CertURL param.Opt[string] `json:"client_x509_cert_url,omitzero" format:"uri"` + PrivateKeyID param.Opt[string] `json:"private_key_id,omitzero"` + ProjectID param.Opt[string] `json:"project_id,omitzero"` + TokenUri param.Opt[string] `json:"token_uri,omitzero" format:"uri"` + UniverseDomain param.Opt[string] `json:"universe_domain,omitzero"` + // Any of "service_account". + Type string `json:"type,omitzero"` + paramObj +} + +func (r SessionExtractParamsOptionsModelVertexModelConfigObjectAuthCredentials) MarshalJSON() (data []byte, err error) { + type shadow SessionExtractParamsOptionsModelVertexModelConfigObjectAuthCredentials + return param.MarshalObject(r, (*shadow)(&r)) +} +func (r *SessionExtractParamsOptionsModelVertexModelConfigObjectAuthCredentials) UnmarshalJSON(data []byte) error { + return apijson.UnmarshalRoot(data, r) +} + +func init() { + apijson.RegisterFieldValidator[SessionExtractParamsOptionsModelVertexModelConfigObjectAuthCredentials]( + "type", "service_account", + ) +} + +// Only one field can be non-zero. +// +// Use [param.IsOmitted] to confirm if a field is set. +type SessionExtractParamsOptionsModelVertexModelConfigObjectAuthScopesUnion struct { + OfString param.Opt[string] `json:",omitzero,inline"` + OfStringArray []string `json:",omitzero,inline"` paramUnion } -func (u SessionExecuteParamsExecuteOptionsVariableObjectValueUnion) MarshalJSON() ([]byte, error) { - return param.MarshalUnion(u, u.OfString, u.OfFloat, u.OfBool) +func (u SessionExtractParamsOptionsModelVertexModelConfigObjectAuthScopesUnion) MarshalJSON() ([]byte, error) { + return param.MarshalUnion(u, u.OfString, u.OfStringArray) } -func (u *SessionExecuteParamsExecuteOptionsVariableObjectValueUnion) UnmarshalJSON(data []byte) error { +func (u *SessionExtractParamsOptionsModelVertexModelConfigObjectAuthScopesUnion) UnmarshalJSON(data []byte) error { return apijson.UnmarshalRoot(data, u) } -func (u *SessionExecuteParamsExecuteOptionsVariableObjectValueUnion) asAny() any { +func (u *SessionExtractParamsOptionsModelVertexModelConfigObjectAuthScopesUnion) asAny() any { if !param.IsOmitted(u.OfString) { return &u.OfString.Value - } else if !param.IsOmitted(u.OfFloat) { - return &u.OfFloat.Value - } else if !param.IsOmitted(u.OfBool) { - return &u.OfBool.Value + } else if !param.IsOmitted(u.OfStringArray) { + return &u.OfStringArray } return nil } -// Whether to stream the response via SSE -type SessionExecuteParamsXStreamResponse string - -const ( - SessionExecuteParamsXStreamResponseTrue SessionExecuteParamsXStreamResponse = "true" - SessionExecuteParamsXStreamResponseFalse SessionExecuteParamsXStreamResponse = "false" -) - -type SessionExtractParams struct { - // Target frame ID for the extraction - FrameID param.Opt[string] `json:"frameId,omitzero"` - // Natural language instruction for what to extract - Instruction param.Opt[string] `json:"instruction,omitzero"` - Options SessionExtractParamsOptions `json:"options,omitzero"` - // JSON Schema defining the structure of data to extract - Schema map[string]any `json:"schema,omitzero"` - // Whether to stream the response via SSE - // - // Any of "true", "false". - XStreamResponse SessionExtractParamsXStreamResponse `header:"x-stream-response,omitzero" json:"-"` +// Vertex provider-specific model configuration +// +// The property Vertex is required. +type SessionExtractParamsOptionsModelVertexModelConfigObjectProviderOptions struct { + // Vertex AI provider-specific settings + Vertex SessionExtractParamsOptionsModelVertexModelConfigObjectProviderOptionsVertex `json:"vertex,omitzero" api:"required"` paramObj } -func (r SessionExtractParams) MarshalJSON() (data []byte, err error) { - type shadow SessionExtractParams +func (r SessionExtractParamsOptionsModelVertexModelConfigObjectProviderOptions) MarshalJSON() (data []byte, err error) { + type shadow SessionExtractParamsOptionsModelVertexModelConfigObjectProviderOptions return param.MarshalObject(r, (*shadow)(&r)) } -func (r *SessionExtractParams) UnmarshalJSON(data []byte) error { +func (r *SessionExtractParamsOptionsModelVertexModelConfigObjectProviderOptions) UnmarshalJSON(data []byte) error { return apijson.UnmarshalRoot(data, r) } -type SessionExtractParamsOptions struct { - // CSS selector to scope extraction to a specific element - Selector param.Opt[string] `json:"selector,omitzero"` - // Timeout in ms for the extraction - Timeout param.Opt[float64] `json:"timeout,omitzero"` - // Selectors for elements and subtrees that should be excluded from extraction - IgnoreSelectors []string `json:"ignoreSelectors,omitzero"` - // Model configuration object or model name string (e.g., 'openai/gpt-5-nano') - Model SessionExtractParamsOptionsModelUnion `json:"model,omitzero"` +// Vertex AI provider-specific settings +// +// The properties Location, Project are required. +type SessionExtractParamsOptionsModelVertexModelConfigObjectProviderOptionsVertex struct { + // Google Cloud location for Vertex AI models + Location string `json:"location" api:"required"` + // Google Cloud project ID for Vertex AI models + Project string `json:"project" api:"required"` + // Base URL for the Vertex AI provider + BaseURL param.Opt[string] `json:"baseURL,omitzero" format:"uri"` + // Custom headers sent with every request to the Vertex AI provider + Headers map[string]string `json:"headers,omitzero"` paramObj } -func (r SessionExtractParamsOptions) MarshalJSON() (data []byte, err error) { - type shadow SessionExtractParamsOptions +func (r SessionExtractParamsOptionsModelVertexModelConfigObjectProviderOptionsVertex) MarshalJSON() (data []byte, err error) { + type shadow SessionExtractParamsOptionsModelVertexModelConfigObjectProviderOptionsVertex return param.MarshalObject(r, (*shadow)(&r)) } -func (r *SessionExtractParamsOptions) UnmarshalJSON(data []byte) error { +func (r *SessionExtractParamsOptionsModelVertexModelConfigObjectProviderOptionsVertex) 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 SessionExtractParamsOptionsModelUnion struct { - OfModelConfig *ModelConfigParam `json:",omitzero,inline"` - OfString param.Opt[string] `json:",omitzero,inline"` - paramUnion +// The property ModelName is required. +type SessionExtractParamsOptionsModelGenericModelConfigObject struct { + // Model name string with provider prefix (e.g., 'openai/gpt-5-nano') + ModelName string `json:"modelName" api:"required"` + // API key for the model provider + APIKey param.Opt[string] `json:"apiKey,omitzero"` + // Base URL for the model provider + BaseURL param.Opt[string] `json:"baseURL,omitzero" format:"uri"` + // Custom headers sent with every request to the model provider + Headers map[string]string `json:"headers,omitzero"` + // AI provider for the model (or provide a baseURL endpoint instead) + // + // Any of "openai", "anthropic", "google", "microsoft", "bedrock". + Provider string `json:"provider,omitzero"` + paramObj } -func (u SessionExtractParamsOptionsModelUnion) MarshalJSON() ([]byte, error) { - return param.MarshalUnion(u, u.OfModelConfig, u.OfString) +func (r SessionExtractParamsOptionsModelGenericModelConfigObject) MarshalJSON() (data []byte, err error) { + type shadow SessionExtractParamsOptionsModelGenericModelConfigObject + return param.MarshalObject(r, (*shadow)(&r)) } -func (u *SessionExtractParamsOptionsModelUnion) UnmarshalJSON(data []byte) error { - return apijson.UnmarshalRoot(data, u) +func (r *SessionExtractParamsOptionsModelGenericModelConfigObject) UnmarshalJSON(data []byte) error { + return apijson.UnmarshalRoot(data, r) } -func (u *SessionExtractParamsOptionsModelUnion) asAny() any { - if !param.IsOmitted(u.OfModelConfig) { - return u.OfModelConfig - } else if !param.IsOmitted(u.OfString) { - return &u.OfString.Value - } - return nil +func init() { + apijson.RegisterFieldValidator[SessionExtractParamsOptionsModelGenericModelConfigObject]( + "provider", "openai", "anthropic", "google", "microsoft", "bedrock", + ) } // Whether to stream the response via SSE @@ -1534,6 +2521,8 @@ type SessionObserveParamsOptions struct { Selector param.Opt[string] `json:"selector,omitzero"` // Timeout in ms for the observation Timeout param.Opt[float64] `json:"timeout,omitzero"` + // Selectors for elements and subtrees that should be excluded from observation + IgnoreSelectors []string `json:"ignoreSelectors,omitzero"` // Model configuration object or model name string (e.g., 'openai/gpt-5-nano') Model SessionObserveParamsOptionsModelUnion `json:"model,omitzero"` // Variables whose names are exposed to the model so observe() returns @@ -1555,27 +2544,282 @@ func (r *SessionObserveParamsOptions) UnmarshalJSON(data []byte) error { // // Use [param.IsOmitted] to confirm if a field is set. type SessionObserveParamsOptionsModelUnion struct { - OfModelConfig *ModelConfigParam `json:",omitzero,inline"` - OfString param.Opt[string] `json:",omitzero,inline"` + OfSessionObservesOptionsModelVertexModelConfigObject *SessionObserveParamsOptionsModelVertexModelConfigObject `json:",omitzero,inline"` + OfSessionObservesOptionsModelGenericModelConfigObject *SessionObserveParamsOptionsModelGenericModelConfigObject `json:",omitzero,inline"` + OfString param.Opt[string] `json:",omitzero,inline"` paramUnion } func (u SessionObserveParamsOptionsModelUnion) MarshalJSON() ([]byte, error) { - return param.MarshalUnion(u, u.OfModelConfig, u.OfString) + return param.MarshalUnion(u, u.OfSessionObservesOptionsModelVertexModelConfigObject, u.OfSessionObservesOptionsModelGenericModelConfigObject, u.OfString) } func (u *SessionObserveParamsOptionsModelUnion) UnmarshalJSON(data []byte) error { return apijson.UnmarshalRoot(data, u) } func (u *SessionObserveParamsOptionsModelUnion) asAny() any { - if !param.IsOmitted(u.OfModelConfig) { - return u.OfModelConfig + if !param.IsOmitted(u.OfSessionObservesOptionsModelVertexModelConfigObject) { + return u.OfSessionObservesOptionsModelVertexModelConfigObject + } else if !param.IsOmitted(u.OfSessionObservesOptionsModelGenericModelConfigObject) { + return u.OfSessionObservesOptionsModelGenericModelConfigObject } else if !param.IsOmitted(u.OfString) { return &u.OfString.Value } return nil } +// Returns a pointer to the underlying variant's property, if present. +func (u SessionObserveParamsOptionsModelUnion) GetAuth() *SessionObserveParamsOptionsModelVertexModelConfigObjectAuth { + if vt := u.OfSessionObservesOptionsModelVertexModelConfigObject; vt != nil { + return &vt.Auth + } + return nil +} + +// Returns a pointer to the underlying variant's property, if present. +func (u SessionObserveParamsOptionsModelUnion) GetProviderOptions() *SessionObserveParamsOptionsModelVertexModelConfigObjectProviderOptions { + if vt := u.OfSessionObservesOptionsModelVertexModelConfigObject; vt != nil { + return &vt.ProviderOptions + } + return nil +} + +// Returns a pointer to the underlying variant's property, if present. +func (u SessionObserveParamsOptionsModelUnion) GetModelName() *string { + if vt := u.OfSessionObservesOptionsModelVertexModelConfigObject; vt != nil { + return (*string)(&vt.ModelName) + } else if vt := u.OfSessionObservesOptionsModelGenericModelConfigObject; vt != nil { + return (*string)(&vt.ModelName) + } + return nil +} + +// Returns a pointer to the underlying variant's property, if present. +func (u SessionObserveParamsOptionsModelUnion) GetProvider() *string { + if vt := u.OfSessionObservesOptionsModelVertexModelConfigObject; vt != nil { + return (*string)(&vt.Provider) + } else if vt := u.OfSessionObservesOptionsModelGenericModelConfigObject; vt != nil { + return (*string)(&vt.Provider) + } + return nil +} + +// Returns a pointer to the underlying variant's property, if present. +func (u SessionObserveParamsOptionsModelUnion) GetAPIKey() *string { + if vt := u.OfSessionObservesOptionsModelVertexModelConfigObject; vt != nil && vt.APIKey.Valid() { + return &vt.APIKey.Value + } else if vt := u.OfSessionObservesOptionsModelGenericModelConfigObject; vt != nil && vt.APIKey.Valid() { + return &vt.APIKey.Value + } + return nil +} + +// Returns a pointer to the underlying variant's property, if present. +func (u SessionObserveParamsOptionsModelUnion) GetBaseURL() *string { + if vt := u.OfSessionObservesOptionsModelVertexModelConfigObject; vt != nil && vt.BaseURL.Valid() { + return &vt.BaseURL.Value + } else if vt := u.OfSessionObservesOptionsModelGenericModelConfigObject; vt != nil && vt.BaseURL.Valid() { + return &vt.BaseURL.Value + } + return nil +} + +// Returns a pointer to the underlying variant's Headers property, if present. +func (u SessionObserveParamsOptionsModelUnion) GetHeaders() map[string]string { + if vt := u.OfSessionObservesOptionsModelVertexModelConfigObject; vt != nil { + return vt.Headers + } else if vt := u.OfSessionObservesOptionsModelGenericModelConfigObject; vt != nil { + return vt.Headers + } + return nil +} + +// The properties Auth, ModelName, Provider, ProviderOptions are required. +type SessionObserveParamsOptionsModelVertexModelConfigObject struct { + // Vertex provider authentication configuration + Auth SessionObserveParamsOptionsModelVertexModelConfigObjectAuth `json:"auth,omitzero" api:"required"` + // Model name string with provider prefix (e.g., 'openai/gpt-5-nano') + ModelName string `json:"modelName" api:"required"` + // Vertex provider-specific model configuration + ProviderOptions SessionObserveParamsOptionsModelVertexModelConfigObjectProviderOptions `json:"providerOptions,omitzero" api:"required"` + // API key for the model provider + APIKey param.Opt[string] `json:"apiKey,omitzero"` + // Base URL for the model provider + BaseURL param.Opt[string] `json:"baseURL,omitzero" format:"uri"` + // Custom headers sent with every request to the model provider + Headers map[string]string `json:"headers,omitzero"` + // Vertex AI model provider + // + // This field can be elided, and will marshal its zero value as "vertex". + Provider constant.Vertex `json:"provider" default:"vertex"` + paramObj +} + +func (r SessionObserveParamsOptionsModelVertexModelConfigObject) MarshalJSON() (data []byte, err error) { + type shadow SessionObserveParamsOptionsModelVertexModelConfigObject + return param.MarshalObject(r, (*shadow)(&r)) +} +func (r *SessionObserveParamsOptionsModelVertexModelConfigObject) UnmarshalJSON(data []byte) error { + return apijson.UnmarshalRoot(data, r) +} + +// Vertex provider authentication configuration +// +// The properties Credentials, Type are required. +type SessionObserveParamsOptionsModelVertexModelConfigObjectAuth struct { + // Google Cloud service account credentials + Credentials SessionObserveParamsOptionsModelVertexModelConfigObjectAuthCredentials `json:"credentials,omitzero" api:"required"` + // Google Cloud project ID used by google-auth-library + ProjectID param.Opt[string] `json:"projectId,omitzero"` + // Google Cloud universe domain + UniverseDomain param.Opt[string] `json:"universeDomain,omitzero"` + // Google auth scopes for the desired API request + Scopes SessionObserveParamsOptionsModelVertexModelConfigObjectAuthScopesUnion `json:"scopes,omitzero"` + // Use inline Google Cloud service account credentials for provider authentication + // + // This field can be elided, and will marshal its zero value as + // "googleServiceAccount". + Type constant.GoogleServiceAccount `json:"type" default:"googleServiceAccount"` + paramObj +} + +func (r SessionObserveParamsOptionsModelVertexModelConfigObjectAuth) MarshalJSON() (data []byte, err error) { + type shadow SessionObserveParamsOptionsModelVertexModelConfigObjectAuth + return param.MarshalObject(r, (*shadow)(&r)) +} +func (r *SessionObserveParamsOptionsModelVertexModelConfigObjectAuth) UnmarshalJSON(data []byte) error { + return apijson.UnmarshalRoot(data, r) +} + +// Google Cloud service account credentials +// +// The properties ClientEmail, PrivateKey are required. +type SessionObserveParamsOptionsModelVertexModelConfigObjectAuthCredentials struct { + ClientEmail string `json:"client_email" api:"required"` + PrivateKey string `json:"private_key" api:"required"` + AuthProviderX509CertURL param.Opt[string] `json:"auth_provider_x509_cert_url,omitzero" format:"uri"` + AuthUri param.Opt[string] `json:"auth_uri,omitzero" format:"uri"` + ClientID param.Opt[string] `json:"client_id,omitzero"` + ClientX509CertURL param.Opt[string] `json:"client_x509_cert_url,omitzero" format:"uri"` + PrivateKeyID param.Opt[string] `json:"private_key_id,omitzero"` + ProjectID param.Opt[string] `json:"project_id,omitzero"` + TokenUri param.Opt[string] `json:"token_uri,omitzero" format:"uri"` + UniverseDomain param.Opt[string] `json:"universe_domain,omitzero"` + // Any of "service_account". + Type string `json:"type,omitzero"` + paramObj +} + +func (r SessionObserveParamsOptionsModelVertexModelConfigObjectAuthCredentials) MarshalJSON() (data []byte, err error) { + type shadow SessionObserveParamsOptionsModelVertexModelConfigObjectAuthCredentials + return param.MarshalObject(r, (*shadow)(&r)) +} +func (r *SessionObserveParamsOptionsModelVertexModelConfigObjectAuthCredentials) UnmarshalJSON(data []byte) error { + return apijson.UnmarshalRoot(data, r) +} + +func init() { + apijson.RegisterFieldValidator[SessionObserveParamsOptionsModelVertexModelConfigObjectAuthCredentials]( + "type", "service_account", + ) +} + +// Only one field can be non-zero. +// +// Use [param.IsOmitted] to confirm if a field is set. +type SessionObserveParamsOptionsModelVertexModelConfigObjectAuthScopesUnion struct { + OfString param.Opt[string] `json:",omitzero,inline"` + OfStringArray []string `json:",omitzero,inline"` + paramUnion +} + +func (u SessionObserveParamsOptionsModelVertexModelConfigObjectAuthScopesUnion) MarshalJSON() ([]byte, error) { + return param.MarshalUnion(u, u.OfString, u.OfStringArray) +} +func (u *SessionObserveParamsOptionsModelVertexModelConfigObjectAuthScopesUnion) UnmarshalJSON(data []byte) error { + return apijson.UnmarshalRoot(data, u) +} + +func (u *SessionObserveParamsOptionsModelVertexModelConfigObjectAuthScopesUnion) asAny() any { + if !param.IsOmitted(u.OfString) { + return &u.OfString.Value + } else if !param.IsOmitted(u.OfStringArray) { + return &u.OfStringArray + } + return nil +} + +// Vertex provider-specific model configuration +// +// The property Vertex is required. +type SessionObserveParamsOptionsModelVertexModelConfigObjectProviderOptions struct { + // Vertex AI provider-specific settings + Vertex SessionObserveParamsOptionsModelVertexModelConfigObjectProviderOptionsVertex `json:"vertex,omitzero" api:"required"` + paramObj +} + +func (r SessionObserveParamsOptionsModelVertexModelConfigObjectProviderOptions) MarshalJSON() (data []byte, err error) { + type shadow SessionObserveParamsOptionsModelVertexModelConfigObjectProviderOptions + return param.MarshalObject(r, (*shadow)(&r)) +} +func (r *SessionObserveParamsOptionsModelVertexModelConfigObjectProviderOptions) UnmarshalJSON(data []byte) error { + return apijson.UnmarshalRoot(data, r) +} + +// Vertex AI provider-specific settings +// +// The properties Location, Project are required. +type SessionObserveParamsOptionsModelVertexModelConfigObjectProviderOptionsVertex struct { + // Google Cloud location for Vertex AI models + Location string `json:"location" api:"required"` + // Google Cloud project ID for Vertex AI models + Project string `json:"project" api:"required"` + // Base URL for the Vertex AI provider + BaseURL param.Opt[string] `json:"baseURL,omitzero" format:"uri"` + // Custom headers sent with every request to the Vertex AI provider + Headers map[string]string `json:"headers,omitzero"` + paramObj +} + +func (r SessionObserveParamsOptionsModelVertexModelConfigObjectProviderOptionsVertex) MarshalJSON() (data []byte, err error) { + type shadow SessionObserveParamsOptionsModelVertexModelConfigObjectProviderOptionsVertex + return param.MarshalObject(r, (*shadow)(&r)) +} +func (r *SessionObserveParamsOptionsModelVertexModelConfigObjectProviderOptionsVertex) UnmarshalJSON(data []byte) error { + return apijson.UnmarshalRoot(data, r) +} + +// The property ModelName is required. +type SessionObserveParamsOptionsModelGenericModelConfigObject struct { + // Model name string with provider prefix (e.g., 'openai/gpt-5-nano') + ModelName string `json:"modelName" api:"required"` + // API key for the model provider + APIKey param.Opt[string] `json:"apiKey,omitzero"` + // Base URL for the model provider + BaseURL param.Opt[string] `json:"baseURL,omitzero" format:"uri"` + // Custom headers sent with every request to the model provider + Headers map[string]string `json:"headers,omitzero"` + // AI provider for the model (or provide a baseURL endpoint instead) + // + // Any of "openai", "anthropic", "google", "microsoft", "bedrock". + Provider string `json:"provider,omitzero"` + paramObj +} + +func (r SessionObserveParamsOptionsModelGenericModelConfigObject) MarshalJSON() (data []byte, err error) { + type shadow SessionObserveParamsOptionsModelGenericModelConfigObject + return param.MarshalObject(r, (*shadow)(&r)) +} +func (r *SessionObserveParamsOptionsModelGenericModelConfigObject) UnmarshalJSON(data []byte) error { + return apijson.UnmarshalRoot(data, r) +} + +func init() { + apijson.RegisterFieldValidator[SessionObserveParamsOptionsModelGenericModelConfigObject]( + "provider", "openai", "anthropic", "google", "microsoft", "bedrock", + ) +} + // Only one field can be non-zero. // // Use [param.IsOmitted] to confirm if a field is set. diff --git a/session_test.go b/session_test.go index 9c26e94..e60fa85 100644 --- a/session_test.go +++ b/session_test.go @@ -38,14 +38,43 @@ func TestSessionActWithOptionalParams(t *testing.T) { FrameID: stagehand.String("frameId"), Options: stagehand.SessionActParamsOptions{ Model: stagehand.SessionActParamsOptionsModelUnion{ - OfModelConfig: &stagehand.ModelConfigParam{ + OfSessionActsOptionsModelVertexModelConfigObject: &stagehand.SessionActParamsOptionsModelVertexModelConfigObject{ + Auth: stagehand.SessionActParamsOptionsModelVertexModelConfigObjectAuth{ + Credentials: stagehand.SessionActParamsOptionsModelVertexModelConfigObjectAuthCredentials{ + ClientEmail: "client_email", + PrivateKey: "private_key", + AuthProviderX509CertURL: stagehand.String("https://example.com"), + AuthUri: stagehand.String("https://example.com"), + ClientID: stagehand.String("client_id"), + ClientX509CertURL: stagehand.String("https://example.com"), + PrivateKeyID: stagehand.String("private_key_id"), + ProjectID: stagehand.String("project_id"), + TokenUri: stagehand.String("https://example.com"), + Type: "service_account", + UniverseDomain: stagehand.String("universe_domain"), + }, + ProjectID: stagehand.String("projectId"), + Scopes: stagehand.SessionActParamsOptionsModelVertexModelConfigObjectAuthScopesUnion{ + OfString: stagehand.String("string"), + }, + UniverseDomain: stagehand.String("universeDomain"), + }, ModelName: "openai/gpt-5.4-mini", - APIKey: stagehand.String("sk-some-openai-api-key"), - BaseURL: stagehand.String("https://api.openai.com/v1"), + ProviderOptions: stagehand.SessionActParamsOptionsModelVertexModelConfigObjectProviderOptions{ + Vertex: stagehand.SessionActParamsOptionsModelVertexModelConfigObjectProviderOptionsVertex{ + Location: "us-central1", + Project: "my-gcp-project", + BaseURL: stagehand.String("https://example.com"), + Headers: map[string]string{ + "foo": "string", + }, + }, + }, + APIKey: stagehand.String("sk-some-openai-api-key"), + BaseURL: stagehand.String("https://api.openai.com/v1"), Headers: map[string]string{ "foo": "string", }, - Provider: stagehand.ModelConfigProviderOpenAI, }, }, Timeout: stagehand.Float(30000), @@ -128,26 +157,84 @@ func TestSessionExecuteWithOptionalParams(t *testing.T) { AgentConfig: stagehand.SessionExecuteParamsAgentConfig{ Cua: stagehand.Bool(true), ExecutionModel: stagehand.SessionExecuteParamsAgentConfigExecutionModelUnion{ - OfModelConfig: &stagehand.ModelConfigParam{ + OfSessionExecutesAgentConfigExecutionModelVertexModelConfigObject: &stagehand.SessionExecuteParamsAgentConfigExecutionModelVertexModelConfigObject{ + Auth: stagehand.SessionExecuteParamsAgentConfigExecutionModelVertexModelConfigObjectAuth{ + Credentials: stagehand.SessionExecuteParamsAgentConfigExecutionModelVertexModelConfigObjectAuthCredentials{ + ClientEmail: "client_email", + PrivateKey: "private_key", + AuthProviderX509CertURL: stagehand.String("https://example.com"), + AuthUri: stagehand.String("https://example.com"), + ClientID: stagehand.String("client_id"), + ClientX509CertURL: stagehand.String("https://example.com"), + PrivateKeyID: stagehand.String("private_key_id"), + ProjectID: stagehand.String("project_id"), + TokenUri: stagehand.String("https://example.com"), + Type: "service_account", + UniverseDomain: stagehand.String("universe_domain"), + }, + ProjectID: stagehand.String("projectId"), + Scopes: stagehand.SessionExecuteParamsAgentConfigExecutionModelVertexModelConfigObjectAuthScopesUnion{ + OfString: stagehand.String("string"), + }, + UniverseDomain: stagehand.String("universeDomain"), + }, ModelName: "openai/gpt-5.4-mini", - APIKey: stagehand.String("sk-some-openai-api-key"), - BaseURL: stagehand.String("https://api.openai.com/v1"), + ProviderOptions: stagehand.SessionExecuteParamsAgentConfigExecutionModelVertexModelConfigObjectProviderOptions{ + Vertex: stagehand.SessionExecuteParamsAgentConfigExecutionModelVertexModelConfigObjectProviderOptionsVertex{ + Location: "us-central1", + Project: "my-gcp-project", + BaseURL: stagehand.String("https://example.com"), + Headers: map[string]string{ + "foo": "string", + }, + }, + }, + APIKey: stagehand.String("sk-some-openai-api-key"), + BaseURL: stagehand.String("https://api.openai.com/v1"), Headers: map[string]string{ "foo": "string", }, - Provider: stagehand.ModelConfigProviderOpenAI, }, }, Mode: "cua", Model: stagehand.SessionExecuteParamsAgentConfigModelUnion{ - OfModelConfig: &stagehand.ModelConfigParam{ + OfSessionExecutesAgentConfigModelVertexModelConfigObject: &stagehand.SessionExecuteParamsAgentConfigModelVertexModelConfigObject{ + Auth: stagehand.SessionExecuteParamsAgentConfigModelVertexModelConfigObjectAuth{ + Credentials: stagehand.SessionExecuteParamsAgentConfigModelVertexModelConfigObjectAuthCredentials{ + ClientEmail: "client_email", + PrivateKey: "private_key", + AuthProviderX509CertURL: stagehand.String("https://example.com"), + AuthUri: stagehand.String("https://example.com"), + ClientID: stagehand.String("client_id"), + ClientX509CertURL: stagehand.String("https://example.com"), + PrivateKeyID: stagehand.String("private_key_id"), + ProjectID: stagehand.String("project_id"), + TokenUri: stagehand.String("https://example.com"), + Type: "service_account", + UniverseDomain: stagehand.String("universe_domain"), + }, + ProjectID: stagehand.String("projectId"), + Scopes: stagehand.SessionExecuteParamsAgentConfigModelVertexModelConfigObjectAuthScopesUnion{ + OfString: stagehand.String("string"), + }, + UniverseDomain: stagehand.String("universeDomain"), + }, ModelName: "openai/gpt-5.4-mini", - APIKey: stagehand.String("sk-some-openai-api-key"), - BaseURL: stagehand.String("https://api.openai.com/v1"), + ProviderOptions: stagehand.SessionExecuteParamsAgentConfigModelVertexModelConfigObjectProviderOptions{ + Vertex: stagehand.SessionExecuteParamsAgentConfigModelVertexModelConfigObjectProviderOptionsVertex{ + Location: "us-central1", + Project: "my-gcp-project", + BaseURL: stagehand.String("https://example.com"), + Headers: map[string]string{ + "foo": "string", + }, + }, + }, + APIKey: stagehand.String("sk-some-openai-api-key"), + BaseURL: stagehand.String("https://api.openai.com/v1"), Headers: map[string]string{ "foo": "string", }, - Provider: stagehand.ModelConfigProviderOpenAI, }, }, Provider: "openai", @@ -203,18 +290,48 @@ func TestSessionExtractWithOptionalParams(t *testing.T) { Options: stagehand.SessionExtractParamsOptions{ IgnoreSelectors: []string{"nav", ".cookie-banner", "#sidebar-ads"}, Model: stagehand.SessionExtractParamsOptionsModelUnion{ - OfModelConfig: &stagehand.ModelConfigParam{ + OfSessionExtractsOptionsModelVertexModelConfigObject: &stagehand.SessionExtractParamsOptionsModelVertexModelConfigObject{ + Auth: stagehand.SessionExtractParamsOptionsModelVertexModelConfigObjectAuth{ + Credentials: stagehand.SessionExtractParamsOptionsModelVertexModelConfigObjectAuthCredentials{ + ClientEmail: "client_email", + PrivateKey: "private_key", + AuthProviderX509CertURL: stagehand.String("https://example.com"), + AuthUri: stagehand.String("https://example.com"), + ClientID: stagehand.String("client_id"), + ClientX509CertURL: stagehand.String("https://example.com"), + PrivateKeyID: stagehand.String("private_key_id"), + ProjectID: stagehand.String("project_id"), + TokenUri: stagehand.String("https://example.com"), + Type: "service_account", + UniverseDomain: stagehand.String("universe_domain"), + }, + ProjectID: stagehand.String("projectId"), + Scopes: stagehand.SessionExtractParamsOptionsModelVertexModelConfigObjectAuthScopesUnion{ + OfString: stagehand.String("string"), + }, + UniverseDomain: stagehand.String("universeDomain"), + }, ModelName: "openai/gpt-5.4-mini", - APIKey: stagehand.String("sk-some-openai-api-key"), - BaseURL: stagehand.String("https://api.openai.com/v1"), + ProviderOptions: stagehand.SessionExtractParamsOptionsModelVertexModelConfigObjectProviderOptions{ + Vertex: stagehand.SessionExtractParamsOptionsModelVertexModelConfigObjectProviderOptionsVertex{ + Location: "us-central1", + Project: "my-gcp-project", + BaseURL: stagehand.String("https://example.com"), + Headers: map[string]string{ + "foo": "string", + }, + }, + }, + APIKey: stagehand.String("sk-some-openai-api-key"), + BaseURL: stagehand.String("https://api.openai.com/v1"), Headers: map[string]string{ "foo": "string", }, - Provider: stagehand.ModelConfigProviderOpenAI, }, }, - Selector: stagehand.String("#main-content"), - Timeout: stagehand.Float(30000), + Screenshot: stagehand.Bool(false), + Selector: stagehand.String("#main-content"), + Timeout: stagehand.Float(30000), }, Schema: map[string]any{ "foo": "bar", @@ -292,15 +409,45 @@ func TestSessionObserveWithOptionalParams(t *testing.T) { FrameID: stagehand.String("frameId"), Instruction: stagehand.String("Find all clickable navigation links"), Options: stagehand.SessionObserveParamsOptions{ + IgnoreSelectors: []string{"nav", ".cookie-banner", "#sidebar-ads"}, Model: stagehand.SessionObserveParamsOptionsModelUnion{ - OfModelConfig: &stagehand.ModelConfigParam{ + OfSessionObservesOptionsModelVertexModelConfigObject: &stagehand.SessionObserveParamsOptionsModelVertexModelConfigObject{ + Auth: stagehand.SessionObserveParamsOptionsModelVertexModelConfigObjectAuth{ + Credentials: stagehand.SessionObserveParamsOptionsModelVertexModelConfigObjectAuthCredentials{ + ClientEmail: "client_email", + PrivateKey: "private_key", + AuthProviderX509CertURL: stagehand.String("https://example.com"), + AuthUri: stagehand.String("https://example.com"), + ClientID: stagehand.String("client_id"), + ClientX509CertURL: stagehand.String("https://example.com"), + PrivateKeyID: stagehand.String("private_key_id"), + ProjectID: stagehand.String("project_id"), + TokenUri: stagehand.String("https://example.com"), + Type: "service_account", + UniverseDomain: stagehand.String("universe_domain"), + }, + ProjectID: stagehand.String("projectId"), + Scopes: stagehand.SessionObserveParamsOptionsModelVertexModelConfigObjectAuthScopesUnion{ + OfString: stagehand.String("string"), + }, + UniverseDomain: stagehand.String("universeDomain"), + }, ModelName: "openai/gpt-5.4-mini", - APIKey: stagehand.String("sk-some-openai-api-key"), - BaseURL: stagehand.String("https://api.openai.com/v1"), + ProviderOptions: stagehand.SessionObserveParamsOptionsModelVertexModelConfigObjectProviderOptions{ + Vertex: stagehand.SessionObserveParamsOptionsModelVertexModelConfigObjectProviderOptionsVertex{ + Location: "us-central1", + Project: "my-gcp-project", + BaseURL: stagehand.String("https://example.com"), + Headers: map[string]string{ + "foo": "string", + }, + }, + }, + APIKey: stagehand.String("sk-some-openai-api-key"), + BaseURL: stagehand.String("https://api.openai.com/v1"), Headers: map[string]string{ "foo": "string", }, - Provider: stagehand.ModelConfigProviderOpenAI, }, }, Selector: stagehand.String("nav"), diff --git a/shared/constant/constants.go b/shared/constant/constants.go index 70a573e..65d2ba8 100644 --- a/shared/constant/constants.go +++ b/shared/constant/constants.go @@ -18,17 +18,23 @@ func ValueOf[T Constant[T]]() T { return t.Default() } -type Browserbase string // Always "browserbase" -type External string // Always "external" -type Running string // Always "running" - -func (c Browserbase) Default() Browserbase { return "browserbase" } -func (c External) Default() External { return "external" } -func (c Running) Default() Running { return "running" } - -func (c Browserbase) MarshalJSON() ([]byte, error) { return marshalString(c) } -func (c External) MarshalJSON() ([]byte, error) { return marshalString(c) } -func (c Running) MarshalJSON() ([]byte, error) { return marshalString(c) } +type Browserbase string // Always "browserbase" +type External string // Always "external" +type GoogleServiceAccount string // Always "googleServiceAccount" +type Running string // Always "running" +type Vertex string // Always "vertex" + +func (c Browserbase) Default() Browserbase { return "browserbase" } +func (c External) Default() External { return "external" } +func (c GoogleServiceAccount) Default() GoogleServiceAccount { return "googleServiceAccount" } +func (c Running) Default() Running { return "running" } +func (c Vertex) Default() Vertex { return "vertex" } + +func (c Browserbase) MarshalJSON() ([]byte, error) { return marshalString(c) } +func (c External) MarshalJSON() ([]byte, error) { return marshalString(c) } +func (c GoogleServiceAccount) MarshalJSON() ([]byte, error) { return marshalString(c) } +func (c Running) MarshalJSON() ([]byte, error) { return marshalString(c) } +func (c Vertex) MarshalJSON() ([]byte, error) { return marshalString(c) } type constant[T any] interface { Constant[T]