From 03b5aea699bfc300fc172617fa46a8a60913c989 Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Thu, 7 May 2026 17:46:10 +0000 Subject: [PATCH 01/11] codegen metadata --- .stats.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.stats.yml b/.stats.yml index 391cde3..57aa7a5 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-e629569417ad17cad5c73180109b4c3ae778f38063fc72146fa82f82de145911.yml +openapi_spec_hash: 42e4eedbc0fcc772bb271191a067bce1 config_hash: 1fb12ae9b478488bc1e56bfbdc210b01 From 13699f218c42404fd866e5d61f8100dea2cd8a6b Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Thu, 7 May 2026 18:23:01 +0000 Subject: [PATCH 02/11] codegen metadata --- .stats.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.stats.yml b/.stats.yml index 57aa7a5..094ac49 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-e629569417ad17cad5c73180109b4c3ae778f38063fc72146fa82f82de145911.yml -openapi_spec_hash: 42e4eedbc0fcc772bb271191a067bce1 +openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/browserbase/stagehand-49b40c7425adba9e67fc102838c5216c45ca1f7ef4c10823c5665fd413538504.yml +openapi_spec_hash: 6880dc029df2e88dfe8943c0dec5a3a5 config_hash: 1fb12ae9b478488bc1e56bfbdc210b01 From 501d30b5aa52a72eed5a25b064609b5c7c84d733 Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Thu, 7 May 2026 18:25:46 +0000 Subject: [PATCH 03/11] feat: [feat]: add `ignoreSelectors` to `observe()` --- .stats.yml | 4 ++-- session.go | 2 ++ session_test.go | 1 + 3 files changed, 5 insertions(+), 2 deletions(-) diff --git a/.stats.yml b/.stats.yml index 094ac49..0339c57 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-49b40c7425adba9e67fc102838c5216c45ca1f7ef4c10823c5665fd413538504.yml -openapi_spec_hash: 6880dc029df2e88dfe8943c0dec5a3a5 +openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/browserbase/stagehand-eae8400fade7b2c8329c4148f56de92e147c34c0feecb420c015aab6544a9acc.yml +openapi_spec_hash: 0a9eff1ac1d464e89cbd9db64709b08a config_hash: 1fb12ae9b478488bc1e56bfbdc210b01 diff --git a/session.go b/session.go index f218fe0..c3bf416 100644 --- a/session.go +++ b/session.go @@ -1534,6 +1534,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 diff --git a/session_test.go b/session_test.go index 9c26e94..26a8f1b 100644 --- a/session_test.go +++ b/session_test.go @@ -292,6 +292,7 @@ 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{ ModelName: "openai/gpt-5.4-mini", From 637868870522a96e2e1d585949926a6116cb1e01 Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Fri, 8 May 2026 02:01:20 +0000 Subject: [PATCH 04/11] chore: redact api-key headers in debug logs --- option/middleware.go | 46 ++++++++++++++++++++++++++++++++++++++++++-- 1 file changed, 44 insertions(+), 2 deletions(-) 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 +} From cea79d5e25d6f072af7b2dde01d34be71106cb4b Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Fri, 8 May 2026 02:01:58 +0000 Subject: [PATCH 05/11] fix(go): avoid panic when http.DefaultTransport is wrapped MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit defaultHTTPClient performed an unchecked type assertion on http.DefaultTransport, which panicked for any caller that had wrapped the global transport (e.g. otelhttp.NewTransport for distributed tracing). When the assertion fails, fall back to the wrapped RoundTripper as-is — preserving the caller's wrapping at the cost of ResponseHeaderTimeout, which is strictly better than panicking. --- default_http_client.go | 18 ++++++++++++------ 1 file changed, 12 insertions(+), 6 deletions(-) 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} } From 39ed37210e15594043fba9cc5c756aa038314c1c Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Wed, 13 May 2026 02:00:44 +0000 Subject: [PATCH 06/11] ci: pin GitHub Actions to commit SHAs Pin all GitHub Actions referenced in generated workflows (both first-party `actions/*` and third-party) to immutable commit SHAs. Updating pinned actions is now a deliberate codegen-side bump rather than implicit on every workflow run. --- .github/workflows/ci.yml | 12 ++++++------ 1 file changed, 6 insertions(+), 6 deletions(-) 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 From 539a65e84dfdd9a1330c6142d229ea47b2575376 Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Thu, 14 May 2026 02:02:04 +0000 Subject: [PATCH 07/11] feat(client): optimize json encoder for internal types --- internal/encoding/json/encode.go | 21 ++-- internal/encoding/json/indent.go | 17 ++- internal/encoding/json/opt.go | 24 +++++ internal/encoding/json/stream.go | 53 +++++----- internal/encoding/json/time.go | 2 +- packages/param/encoder.go | 4 +- packages/param/encoder_test.go | 176 +++++++++++++++++++++++++++++++ 7 files changed, 260 insertions(+), 37 deletions(-) create mode 100644 internal/encoding/json/opt.go 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/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)) + } + }) + } +} From b381980c635b1d7968a2022709fa91921e77556e Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Wed, 20 May 2026 19:16:18 +0000 Subject: [PATCH 08/11] feat: STG-1756 add Vertex auth params to Stagehand spec --- .stats.yml | 4 +- session.go | 88 +++++++++++++++++++++++++++++++++++++- session_test.go | 110 ++++++++++++++++++++++++++++++++++++++++++++++++ 3 files changed, 199 insertions(+), 3 deletions(-) diff --git a/.stats.yml b/.stats.yml index 0339c57..220445b 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-eae8400fade7b2c8329c4148f56de92e147c34c0feecb420c015aab6544a9acc.yml -openapi_spec_hash: 0a9eff1ac1d464e89cbd9db64709b08a +openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/browserbase/stagehand-e77d6b15f0a94b16a54ef87a84d2cabe49eb11cff5ceba76f00dd788ff483eab.yml +openapi_spec_hash: a1dab7fe72a772d188a15305124ebd73 config_hash: 1fb12ae9b478488bc1e56bfbdc210b01 diff --git a/session.go b/session.go index c3bf416..0de7570 100644 --- a/session.go +++ b/session.go @@ -272,11 +272,17 @@ type ModelConfigParam struct { APIKey param.Opt[string] `json:"apiKey,omitzero"` // Base URL for the model provider BaseURL param.Opt[string] `json:"baseURL,omitzero" format:"uri"` + // Google Cloud location for Vertex AI models + Location param.Opt[string] `json:"location,omitzero"` + // Google Cloud project ID for Vertex AI models + Project param.Opt[string] `json:"project,omitzero"` + // google-auth-library options used to authenticate Vertex AI models + GoogleAuthOptions ModelConfigGoogleAuthOptionsParam `json:"googleAuthOptions,omitzero"` // 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". + // Any of "openai", "anthropic", "google", "microsoft", "bedrock", "vertex". Provider ModelConfigProvider `json:"provider,omitzero"` paramObj } @@ -289,6 +295,85 @@ func (r *ModelConfigParam) UnmarshalJSON(data []byte) error { return apijson.UnmarshalRoot(data, r) } +// google-auth-library options used to authenticate Vertex AI models +type ModelConfigGoogleAuthOptionsParam struct { + // 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 Cloud service account credentials + Credentials ModelConfigGoogleAuthOptionsCredentialsParam `json:"credentials,omitzero"` + // Google auth scopes for the desired API request + Scopes ModelConfigGoogleAuthOptionsScopesUnionParam `json:"scopes,omitzero"` + paramObj +} + +func (r ModelConfigGoogleAuthOptionsParam) MarshalJSON() (data []byte, err error) { + type shadow ModelConfigGoogleAuthOptionsParam + return param.MarshalObject(r, (*shadow)(&r)) +} +func (r *ModelConfigGoogleAuthOptionsParam) UnmarshalJSON(data []byte) error { + return apijson.UnmarshalRoot(data, r) +} + +// Google Cloud service account credentials +// +// The properties ClientEmail, PrivateKey are required. +type ModelConfigGoogleAuthOptionsCredentialsParam 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 ModelConfigGoogleAuthOptionsCredentialsParam) MarshalJSON() (data []byte, err error) { + type shadow ModelConfigGoogleAuthOptionsCredentialsParam + return param.MarshalObject(r, (*shadow)(&r)) +} +func (r *ModelConfigGoogleAuthOptionsCredentialsParam) UnmarshalJSON(data []byte) error { + return apijson.UnmarshalRoot(data, r) +} + +func init() { + apijson.RegisterFieldValidator[ModelConfigGoogleAuthOptionsCredentialsParam]( + "type", "service_account", + ) +} + +// Only one field can be non-zero. +// +// Use [param.IsOmitted] to confirm if a field is set. +type ModelConfigGoogleAuthOptionsScopesUnionParam struct { + OfString param.Opt[string] `json:",omitzero,inline"` + OfStringArray []string `json:",omitzero,inline"` + paramUnion +} + +func (u ModelConfigGoogleAuthOptionsScopesUnionParam) MarshalJSON() ([]byte, error) { + return param.MarshalUnion(u, u.OfString, u.OfStringArray) +} +func (u *ModelConfigGoogleAuthOptionsScopesUnionParam) UnmarshalJSON(data []byte) error { + return apijson.UnmarshalRoot(data, u) +} + +func (u *ModelConfigGoogleAuthOptionsScopesUnionParam) asAny() any { + if !param.IsOmitted(u.OfString) { + return &u.OfString.Value + } else if !param.IsOmitted(u.OfStringArray) { + return &u.OfStringArray + } + return nil +} + // AI provider for the model (or provide a baseURL endpoint instead) type ModelConfigProvider string @@ -298,6 +383,7 @@ const ( ModelConfigProviderGoogle ModelConfigProvider = "google" ModelConfigProviderMicrosoft ModelConfigProvider = "microsoft" ModelConfigProviderBedrock ModelConfigProvider = "bedrock" + ModelConfigProviderVertex ModelConfigProvider = "vertex" ) // Server-Sent Event emitted during streaming responses. Events are sent as diff --git a/session_test.go b/session_test.go index 26a8f1b..1a643c8 100644 --- a/session_test.go +++ b/session_test.go @@ -42,9 +42,31 @@ func TestSessionActWithOptionalParams(t *testing.T) { ModelName: "openai/gpt-5.4-mini", APIKey: stagehand.String("sk-some-openai-api-key"), BaseURL: stagehand.String("https://api.openai.com/v1"), + GoogleAuthOptions: stagehand.ModelConfigGoogleAuthOptionsParam{ + Credentials: stagehand.ModelConfigGoogleAuthOptionsCredentialsParam{ + 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.ModelConfigGoogleAuthOptionsScopesUnionParam{ + OfString: stagehand.String("string"), + }, + UniverseDomain: stagehand.String("universeDomain"), + }, Headers: map[string]string{ "foo": "string", }, + Location: stagehand.String("us-central1"), + Project: stagehand.String("my-gcp-project"), Provider: stagehand.ModelConfigProviderOpenAI, }, }, @@ -132,9 +154,31 @@ func TestSessionExecuteWithOptionalParams(t *testing.T) { ModelName: "openai/gpt-5.4-mini", APIKey: stagehand.String("sk-some-openai-api-key"), BaseURL: stagehand.String("https://api.openai.com/v1"), + GoogleAuthOptions: stagehand.ModelConfigGoogleAuthOptionsParam{ + Credentials: stagehand.ModelConfigGoogleAuthOptionsCredentialsParam{ + 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.ModelConfigGoogleAuthOptionsScopesUnionParam{ + OfString: stagehand.String("string"), + }, + UniverseDomain: stagehand.String("universeDomain"), + }, Headers: map[string]string{ "foo": "string", }, + Location: stagehand.String("us-central1"), + Project: stagehand.String("my-gcp-project"), Provider: stagehand.ModelConfigProviderOpenAI, }, }, @@ -144,9 +188,31 @@ func TestSessionExecuteWithOptionalParams(t *testing.T) { ModelName: "openai/gpt-5.4-mini", APIKey: stagehand.String("sk-some-openai-api-key"), BaseURL: stagehand.String("https://api.openai.com/v1"), + GoogleAuthOptions: stagehand.ModelConfigGoogleAuthOptionsParam{ + Credentials: stagehand.ModelConfigGoogleAuthOptionsCredentialsParam{ + 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.ModelConfigGoogleAuthOptionsScopesUnionParam{ + OfString: stagehand.String("string"), + }, + UniverseDomain: stagehand.String("universeDomain"), + }, Headers: map[string]string{ "foo": "string", }, + Location: stagehand.String("us-central1"), + Project: stagehand.String("my-gcp-project"), Provider: stagehand.ModelConfigProviderOpenAI, }, }, @@ -207,9 +273,31 @@ func TestSessionExtractWithOptionalParams(t *testing.T) { ModelName: "openai/gpt-5.4-mini", APIKey: stagehand.String("sk-some-openai-api-key"), BaseURL: stagehand.String("https://api.openai.com/v1"), + GoogleAuthOptions: stagehand.ModelConfigGoogleAuthOptionsParam{ + Credentials: stagehand.ModelConfigGoogleAuthOptionsCredentialsParam{ + 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.ModelConfigGoogleAuthOptionsScopesUnionParam{ + OfString: stagehand.String("string"), + }, + UniverseDomain: stagehand.String("universeDomain"), + }, Headers: map[string]string{ "foo": "string", }, + Location: stagehand.String("us-central1"), + Project: stagehand.String("my-gcp-project"), Provider: stagehand.ModelConfigProviderOpenAI, }, }, @@ -298,9 +386,31 @@ func TestSessionObserveWithOptionalParams(t *testing.T) { ModelName: "openai/gpt-5.4-mini", APIKey: stagehand.String("sk-some-openai-api-key"), BaseURL: stagehand.String("https://api.openai.com/v1"), + GoogleAuthOptions: stagehand.ModelConfigGoogleAuthOptionsParam{ + Credentials: stagehand.ModelConfigGoogleAuthOptionsCredentialsParam{ + 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.ModelConfigGoogleAuthOptionsScopesUnionParam{ + OfString: stagehand.String("string"), + }, + UniverseDomain: stagehand.String("universeDomain"), + }, Headers: map[string]string{ "foo": "string", }, + Location: stagehand.String("us-central1"), + Project: stagehand.String("my-gcp-project"), Provider: stagehand.ModelConfigProviderOpenAI, }, }, From ba29e1e97d4744a504adf2990fa4cc1eeabf9bba Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Wed, 20 May 2026 21:00:23 +0000 Subject: [PATCH 09/11] feat: Add `screenshot` option to Extract --- .stats.yml | 4 ++-- session.go | 3 +++ session_test.go | 5 +++-- 3 files changed, 8 insertions(+), 4 deletions(-) diff --git a/.stats.yml b/.stats.yml index 220445b..9043f09 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-e77d6b15f0a94b16a54ef87a84d2cabe49eb11cff5ceba76f00dd788ff483eab.yml -openapi_spec_hash: a1dab7fe72a772d188a15305124ebd73 +openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/browserbase/stagehand-80502d74c1be605e77d45ff2b54297fe34ce85dbad1e8f2dfa30ba6d09601219.yml +openapi_spec_hash: fd62f768756a400c3ecd695bfcf3845a config_hash: 1fb12ae9b478488bc1e56bfbdc210b01 diff --git a/session.go b/session.go index 0de7570..b5d1a93 100644 --- a/session.go +++ b/session.go @@ -1485,6 +1485,9 @@ func (r *SessionExtractParams) UnmarshalJSON(data []byte) error { } 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 diff --git a/session_test.go b/session_test.go index 1a643c8..cb15772 100644 --- a/session_test.go +++ b/session_test.go @@ -301,8 +301,9 @@ func TestSessionExtractWithOptionalParams(t *testing.T) { 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", From e707c1ca0b01fa7babe4ee081789766695e7d48e Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Wed, 27 May 2026 19:42:41 +0000 Subject: [PATCH 10/11] feat: [STG-1756] forward Vertex model config --- .stats.yml | 4 +- api.md | 1 - session.go | 1577 +++++++++++++++++++++++++++++----- session_test.go | 135 +-- shared/constant/constants.go | 28 +- 5 files changed, 1469 insertions(+), 276 deletions(-) diff --git a/.stats.yml b/.stats.yml index 9043f09..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-80502d74c1be605e77d45ff2b54297fe34ce85dbad1e8f2dfa30ba6d09601219.yml -openapi_spec_hash: fd62f768756a400c3ecd695bfcf3845a +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/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/session.go b/session.go index b5d1a93..a5c223c 100644 --- a/session.go +++ b/session.go @@ -264,128 +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"` - // Google Cloud location for Vertex AI models - Location param.Opt[string] `json:"location,omitzero"` - // Google Cloud project ID for Vertex AI models - Project param.Opt[string] `json:"project,omitzero"` - // google-auth-library options used to authenticate Vertex AI models - GoogleAuthOptions ModelConfigGoogleAuthOptionsParam `json:"googleAuthOptions,omitzero"` - // 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", "vertex". - 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) -} - -// google-auth-library options used to authenticate Vertex AI models -type ModelConfigGoogleAuthOptionsParam struct { - // 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 Cloud service account credentials - Credentials ModelConfigGoogleAuthOptionsCredentialsParam `json:"credentials,omitzero"` - // Google auth scopes for the desired API request - Scopes ModelConfigGoogleAuthOptionsScopesUnionParam `json:"scopes,omitzero"` - paramObj -} - -func (r ModelConfigGoogleAuthOptionsParam) MarshalJSON() (data []byte, err error) { - type shadow ModelConfigGoogleAuthOptionsParam - return param.MarshalObject(r, (*shadow)(&r)) -} -func (r *ModelConfigGoogleAuthOptionsParam) UnmarshalJSON(data []byte) error { - return apijson.UnmarshalRoot(data, r) -} - -// Google Cloud service account credentials -// -// The properties ClientEmail, PrivateKey are required. -type ModelConfigGoogleAuthOptionsCredentialsParam 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 ModelConfigGoogleAuthOptionsCredentialsParam) MarshalJSON() (data []byte, err error) { - type shadow ModelConfigGoogleAuthOptionsCredentialsParam - return param.MarshalObject(r, (*shadow)(&r)) -} -func (r *ModelConfigGoogleAuthOptionsCredentialsParam) UnmarshalJSON(data []byte) error { - return apijson.UnmarshalRoot(data, r) -} - -func init() { - apijson.RegisterFieldValidator[ModelConfigGoogleAuthOptionsCredentialsParam]( - "type", "service_account", - ) -} - -// Only one field can be non-zero. -// -// Use [param.IsOmitted] to confirm if a field is set. -type ModelConfigGoogleAuthOptionsScopesUnionParam struct { - OfString param.Opt[string] `json:",omitzero,inline"` - OfStringArray []string `json:",omitzero,inline"` - paramUnion -} - -func (u ModelConfigGoogleAuthOptionsScopesUnionParam) MarshalJSON() ([]byte, error) { - return param.MarshalUnion(u, u.OfString, u.OfStringArray) -} -func (u *ModelConfigGoogleAuthOptionsScopesUnionParam) UnmarshalJSON(data []byte) error { - return apijson.UnmarshalRoot(data, u) -} - -func (u *ModelConfigGoogleAuthOptionsScopesUnionParam) asAny() any { - if !param.IsOmitted(u.OfString) { - return &u.OfString.Value - } else if !param.IsOmitted(u.OfStringArray) { - return &u.OfStringArray - } - return nil -} - -// 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" - ModelConfigProviderVertex ModelConfigProvider = "vertex" -) - // 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 }`. @@ -1123,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. @@ -1308,52 +1441,562 @@ 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. -// +// 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 +} + +// 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 +} + +// 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 +} + +// 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 +} + +// 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 +} + +// 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 +} + +// 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 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 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 SessionExecuteParamsAgentConfigModelUnion struct { - OfModelConfig *ModelConfigParam `json:",omitzero,inline"` +type SessionExecuteParamsAgentConfigModelVertexModelConfigObjectAuthScopesUnion struct { OfString param.Opt[string] `json:",omitzero,inline"` + OfStringArray []string `json:",omitzero,inline"` paramUnion } -func (u SessionExecuteParamsAgentConfigModelUnion) MarshalJSON() ([]byte, error) { - return param.MarshalUnion(u, u.OfModelConfig, u.OfString) +func (u SessionExecuteParamsAgentConfigModelVertexModelConfigObjectAuthScopesUnion) MarshalJSON() ([]byte, error) { + return param.MarshalUnion(u, u.OfString, u.OfStringArray) } -func (u *SessionExecuteParamsAgentConfigModelUnion) UnmarshalJSON(data []byte) error { +func (u *SessionExecuteParamsAgentConfigModelVertexModelConfigObjectAuthScopesUnion) UnmarshalJSON(data []byte) error { return apijson.UnmarshalRoot(data, u) } -func (u *SessionExecuteParamsAgentConfigModelUnion) asAny() any { - if !param.IsOmitted(u.OfModelConfig) { - return u.OfModelConfig - } else if !param.IsOmitted(u.OfString) { +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 @@ -1435,101 +2078,356 @@ type SessionExecuteParamsExecuteOptionsVariableObjectValueUnion struct { paramUnion } -func (u SessionExecuteParamsExecuteOptionsVariableObjectValueUnion) MarshalJSON() ([]byte, error) { - return param.MarshalUnion(u, u.OfString, u.OfFloat, u.OfBool) +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 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 { - // 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"` +// 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 @@ -1646,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 cb15772..e60fa85 100644 --- a/session_test.go +++ b/session_test.go @@ -38,12 +38,9 @@ func TestSessionActWithOptionalParams(t *testing.T) { FrameID: stagehand.String("frameId"), Options: stagehand.SessionActParamsOptions{ Model: stagehand.SessionActParamsOptionsModelUnion{ - OfModelConfig: &stagehand.ModelConfigParam{ - ModelName: "openai/gpt-5.4-mini", - APIKey: stagehand.String("sk-some-openai-api-key"), - BaseURL: stagehand.String("https://api.openai.com/v1"), - GoogleAuthOptions: stagehand.ModelConfigGoogleAuthOptionsParam{ - Credentials: stagehand.ModelConfigGoogleAuthOptionsCredentialsParam{ + OfSessionActsOptionsModelVertexModelConfigObject: &stagehand.SessionActParamsOptionsModelVertexModelConfigObject{ + Auth: stagehand.SessionActParamsOptionsModelVertexModelConfigObjectAuth{ + Credentials: stagehand.SessionActParamsOptionsModelVertexModelConfigObjectAuthCredentials{ ClientEmail: "client_email", PrivateKey: "private_key", AuthProviderX509CertURL: stagehand.String("https://example.com"), @@ -57,17 +54,27 @@ func TestSessionActWithOptionalParams(t *testing.T) { UniverseDomain: stagehand.String("universe_domain"), }, ProjectID: stagehand.String("projectId"), - Scopes: stagehand.ModelConfigGoogleAuthOptionsScopesUnionParam{ + Scopes: stagehand.SessionActParamsOptionsModelVertexModelConfigObjectAuthScopesUnion{ OfString: stagehand.String("string"), }, UniverseDomain: stagehand.String("universeDomain"), }, + ModelName: "openai/gpt-5.4-mini", + 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", }, - Location: stagehand.String("us-central1"), - Project: stagehand.String("my-gcp-project"), - Provider: stagehand.ModelConfigProviderOpenAI, }, }, Timeout: stagehand.Float(30000), @@ -150,12 +157,9 @@ func TestSessionExecuteWithOptionalParams(t *testing.T) { AgentConfig: stagehand.SessionExecuteParamsAgentConfig{ Cua: stagehand.Bool(true), ExecutionModel: stagehand.SessionExecuteParamsAgentConfigExecutionModelUnion{ - OfModelConfig: &stagehand.ModelConfigParam{ - ModelName: "openai/gpt-5.4-mini", - APIKey: stagehand.String("sk-some-openai-api-key"), - BaseURL: stagehand.String("https://api.openai.com/v1"), - GoogleAuthOptions: stagehand.ModelConfigGoogleAuthOptionsParam{ - Credentials: stagehand.ModelConfigGoogleAuthOptionsCredentialsParam{ + OfSessionExecutesAgentConfigExecutionModelVertexModelConfigObject: &stagehand.SessionExecuteParamsAgentConfigExecutionModelVertexModelConfigObject{ + Auth: stagehand.SessionExecuteParamsAgentConfigExecutionModelVertexModelConfigObjectAuth{ + Credentials: stagehand.SessionExecuteParamsAgentConfigExecutionModelVertexModelConfigObjectAuthCredentials{ ClientEmail: "client_email", PrivateKey: "private_key", AuthProviderX509CertURL: stagehand.String("https://example.com"), @@ -169,27 +173,34 @@ func TestSessionExecuteWithOptionalParams(t *testing.T) { UniverseDomain: stagehand.String("universe_domain"), }, ProjectID: stagehand.String("projectId"), - Scopes: stagehand.ModelConfigGoogleAuthOptionsScopesUnionParam{ + Scopes: stagehand.SessionExecuteParamsAgentConfigExecutionModelVertexModelConfigObjectAuthScopesUnion{ OfString: stagehand.String("string"), }, UniverseDomain: stagehand.String("universeDomain"), }, + ModelName: "openai/gpt-5.4-mini", + 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", }, - Location: stagehand.String("us-central1"), - Project: stagehand.String("my-gcp-project"), - Provider: stagehand.ModelConfigProviderOpenAI, }, }, Mode: "cua", Model: stagehand.SessionExecuteParamsAgentConfigModelUnion{ - OfModelConfig: &stagehand.ModelConfigParam{ - ModelName: "openai/gpt-5.4-mini", - APIKey: stagehand.String("sk-some-openai-api-key"), - BaseURL: stagehand.String("https://api.openai.com/v1"), - GoogleAuthOptions: stagehand.ModelConfigGoogleAuthOptionsParam{ - Credentials: stagehand.ModelConfigGoogleAuthOptionsCredentialsParam{ + OfSessionExecutesAgentConfigModelVertexModelConfigObject: &stagehand.SessionExecuteParamsAgentConfigModelVertexModelConfigObject{ + Auth: stagehand.SessionExecuteParamsAgentConfigModelVertexModelConfigObjectAuth{ + Credentials: stagehand.SessionExecuteParamsAgentConfigModelVertexModelConfigObjectAuthCredentials{ ClientEmail: "client_email", PrivateKey: "private_key", AuthProviderX509CertURL: stagehand.String("https://example.com"), @@ -203,17 +214,27 @@ func TestSessionExecuteWithOptionalParams(t *testing.T) { UniverseDomain: stagehand.String("universe_domain"), }, ProjectID: stagehand.String("projectId"), - Scopes: stagehand.ModelConfigGoogleAuthOptionsScopesUnionParam{ + Scopes: stagehand.SessionExecuteParamsAgentConfigModelVertexModelConfigObjectAuthScopesUnion{ OfString: stagehand.String("string"), }, UniverseDomain: stagehand.String("universeDomain"), }, + ModelName: "openai/gpt-5.4-mini", + 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", }, - Location: stagehand.String("us-central1"), - Project: stagehand.String("my-gcp-project"), - Provider: stagehand.ModelConfigProviderOpenAI, }, }, Provider: "openai", @@ -269,12 +290,9 @@ func TestSessionExtractWithOptionalParams(t *testing.T) { Options: stagehand.SessionExtractParamsOptions{ IgnoreSelectors: []string{"nav", ".cookie-banner", "#sidebar-ads"}, Model: stagehand.SessionExtractParamsOptionsModelUnion{ - OfModelConfig: &stagehand.ModelConfigParam{ - ModelName: "openai/gpt-5.4-mini", - APIKey: stagehand.String("sk-some-openai-api-key"), - BaseURL: stagehand.String("https://api.openai.com/v1"), - GoogleAuthOptions: stagehand.ModelConfigGoogleAuthOptionsParam{ - Credentials: stagehand.ModelConfigGoogleAuthOptionsCredentialsParam{ + OfSessionExtractsOptionsModelVertexModelConfigObject: &stagehand.SessionExtractParamsOptionsModelVertexModelConfigObject{ + Auth: stagehand.SessionExtractParamsOptionsModelVertexModelConfigObjectAuth{ + Credentials: stagehand.SessionExtractParamsOptionsModelVertexModelConfigObjectAuthCredentials{ ClientEmail: "client_email", PrivateKey: "private_key", AuthProviderX509CertURL: stagehand.String("https://example.com"), @@ -288,17 +306,27 @@ func TestSessionExtractWithOptionalParams(t *testing.T) { UniverseDomain: stagehand.String("universe_domain"), }, ProjectID: stagehand.String("projectId"), - Scopes: stagehand.ModelConfigGoogleAuthOptionsScopesUnionParam{ + Scopes: stagehand.SessionExtractParamsOptionsModelVertexModelConfigObjectAuthScopesUnion{ OfString: stagehand.String("string"), }, UniverseDomain: stagehand.String("universeDomain"), }, + ModelName: "openai/gpt-5.4-mini", + 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", }, - Location: stagehand.String("us-central1"), - Project: stagehand.String("my-gcp-project"), - Provider: stagehand.ModelConfigProviderOpenAI, }, }, Screenshot: stagehand.Bool(false), @@ -383,12 +411,9 @@ func TestSessionObserveWithOptionalParams(t *testing.T) { Options: stagehand.SessionObserveParamsOptions{ IgnoreSelectors: []string{"nav", ".cookie-banner", "#sidebar-ads"}, Model: stagehand.SessionObserveParamsOptionsModelUnion{ - OfModelConfig: &stagehand.ModelConfigParam{ - ModelName: "openai/gpt-5.4-mini", - APIKey: stagehand.String("sk-some-openai-api-key"), - BaseURL: stagehand.String("https://api.openai.com/v1"), - GoogleAuthOptions: stagehand.ModelConfigGoogleAuthOptionsParam{ - Credentials: stagehand.ModelConfigGoogleAuthOptionsCredentialsParam{ + OfSessionObservesOptionsModelVertexModelConfigObject: &stagehand.SessionObserveParamsOptionsModelVertexModelConfigObject{ + Auth: stagehand.SessionObserveParamsOptionsModelVertexModelConfigObjectAuth{ + Credentials: stagehand.SessionObserveParamsOptionsModelVertexModelConfigObjectAuthCredentials{ ClientEmail: "client_email", PrivateKey: "private_key", AuthProviderX509CertURL: stagehand.String("https://example.com"), @@ -402,17 +427,27 @@ func TestSessionObserveWithOptionalParams(t *testing.T) { UniverseDomain: stagehand.String("universe_domain"), }, ProjectID: stagehand.String("projectId"), - Scopes: stagehand.ModelConfigGoogleAuthOptionsScopesUnionParam{ + Scopes: stagehand.SessionObserveParamsOptionsModelVertexModelConfigObjectAuthScopesUnion{ OfString: stagehand.String("string"), }, UniverseDomain: stagehand.String("universeDomain"), }, + ModelName: "openai/gpt-5.4-mini", + 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", }, - Location: stagehand.String("us-central1"), - Project: stagehand.String("my-gcp-project"), - 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] From 5896a29c6c909e490928ecc19842a4170ab2b0e1 Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Wed, 27 May 2026 19:43:09 +0000 Subject: [PATCH 11/11] release: 3.21.0 --- .release-please-manifest.json | 2 +- CHANGELOG.md | 22 ++++++++++++++++++++++ README.md | 2 +- internal/version.go | 2 +- 4 files changed, 25 insertions(+), 3 deletions(-) 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/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/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