chore: better local dev with stainless script

1 files changed, 1385 insertions, 0 deletions

diff --git a/packages/tui/sdk/session.go b/packages/tui/sdk/session.go
new file mode 100644
index 000000000..e8216a1fd
--- /dev/null
+++ b/packages/tui/sdk/session.go
@@ -0,0 +1,1385 @@
+// File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+package opencode
+
+import (
+	"context"
+	"errors"
+	"fmt"
+	"net/http"
+	"reflect"
+
+	"github.com/sst/opencode-sdk-go/internal/apijson"
+	"github.com/sst/opencode-sdk-go/internal/param"
+	"github.com/sst/opencode-sdk-go/internal/requestconfig"
+	"github.com/sst/opencode-sdk-go/option"
+	"github.com/sst/opencode-sdk-go/shared"
+	"github.com/tidwall/gjson"
+)
+
+// SessionService contains methods and other services that help with interacting
+// with the opencode API.
+//
+// Note, unlike clients, this service does not read variables from the environment
+// automatically. You should not instantiate this service directly, and instead use
+// the [NewSessionService] method instead.
+type SessionService struct {
+	Options []option.RequestOption
+}
+
+// NewSessionService generates a new service that applies the given options to each
+// request. These options are applied after the parent client's options (if there
+// is one), and before any request-specific options.
+func NewSessionService(opts ...option.RequestOption) (r *SessionService) {
+	r = &SessionService{}
+	r.Options = opts
+	return
+}
+
+// Create a new session
+func (r *SessionService) New(ctx context.Context, opts ...option.RequestOption) (res *Session, err error) {
+	opts = append(r.Options[:], opts...)
+	path := "session"
+	err = requestconfig.ExecuteNewRequest(ctx, http.MethodPost, path, nil, &res, opts...)
+	return
+}
+
+// List all sessions
+func (r *SessionService) List(ctx context.Context, opts ...option.RequestOption) (res *[]Session, err error) {
+	opts = append(r.Options[:], opts...)
+	path := "session"
+	err = requestconfig.ExecuteNewRequest(ctx, http.MethodGet, path, nil, &res, opts...)
+	return
+}
+
+// Delete a session and all its data
+func (r *SessionService) Delete(ctx context.Context, id string, opts ...option.RequestOption) (res *bool, err error) {
+	opts = append(r.Options[:], opts...)
+	if id == "" {
+		err = errors.New("missing required id parameter")
+		return
+	}
+	path := fmt.Sprintf("session/%s", id)
+	err = requestconfig.ExecuteNewRequest(ctx, http.MethodDelete, path, nil, &res, opts...)
+	return
+}
+
+// Abort a session
+func (r *SessionService) Abort(ctx context.Context, id string, opts ...option.RequestOption) (res *bool, err error) {
+	opts = append(r.Options[:], opts...)
+	if id == "" {
+		err = errors.New("missing required id parameter")
+		return
+	}
+	path := fmt.Sprintf("session/%s/abort", id)
+	err = requestconfig.ExecuteNewRequest(ctx, http.MethodPost, path, nil, &res, opts...)
+	return
+}
+
+// Create and send a new message to a session
+func (r *SessionService) Chat(ctx context.Context, id string, body SessionChatParams, opts ...option.RequestOption) (res *Message, err error) {
+	opts = append(r.Options[:], opts...)
+	if id == "" {
+		err = errors.New("missing required id parameter")
+		return
+	}
+	path := fmt.Sprintf("session/%s/message", id)
+	err = requestconfig.ExecuteNewRequest(ctx, http.MethodPost, path, body, &res, opts...)
+	return
+}
+
+// Analyze the app and create an AGENTS.md file
+func (r *SessionService) Init(ctx context.Context, id string, body SessionInitParams, opts ...option.RequestOption) (res *bool, err error) {
+	opts = append(r.Options[:], opts...)
+	if id == "" {
+		err = errors.New("missing required id parameter")
+		return
+	}
+	path := fmt.Sprintf("session/%s/init", id)
+	err = requestconfig.ExecuteNewRequest(ctx, http.MethodPost, path, body, &res, opts...)
+	return
+}
+
+// List messages for a session
+func (r *SessionService) Messages(ctx context.Context, id string, opts ...option.RequestOption) (res *[]Message, err error) {
+	opts = append(r.Options[:], opts...)
+	if id == "" {
+		err = errors.New("missing required id parameter")
+		return
+	}
+	path := fmt.Sprintf("session/%s/message", id)
+	err = requestconfig.ExecuteNewRequest(ctx, http.MethodGet, path, nil, &res, opts...)
+	return
+}
+
+// Share a session
+func (r *SessionService) Share(ctx context.Context, id string, opts ...option.RequestOption) (res *Session, err error) {
+	opts = append(r.Options[:], opts...)
+	if id == "" {
+		err = errors.New("missing required id parameter")
+		return
+	}
+	path := fmt.Sprintf("session/%s/share", id)
+	err = requestconfig.ExecuteNewRequest(ctx, http.MethodPost, path, nil, &res, opts...)
+	return
+}
+
+// Summarize the session
+func (r *SessionService) Summarize(ctx context.Context, id string, body SessionSummarizeParams, opts ...option.RequestOption) (res *bool, err error) {
+	opts = append(r.Options[:], opts...)
+	if id == "" {
+		err = errors.New("missing required id parameter")
+		return
+	}
+	path := fmt.Sprintf("session/%s/summarize", id)
+	err = requestconfig.ExecuteNewRequest(ctx, http.MethodPost, path, body, &res, opts...)
+	return
+}
+
+// Unshare the session
+func (r *SessionService) Unshare(ctx context.Context, id string, opts ...option.RequestOption) (res *Session, err error) {
+	opts = append(r.Options[:], opts...)
+	if id == "" {
+		err = errors.New("missing required id parameter")
+		return
+	}
+	path := fmt.Sprintf("session/%s/share", id)
+	err = requestconfig.ExecuteNewRequest(ctx, http.MethodDelete, path, nil, &res, opts...)
+	return
+}
+
+type FilePart struct {
+	MediaType string       `json:"mediaType,required"`
+	Type      FilePartType `json:"type,required"`
+	URL       string       `json:"url,required"`
+	Filename  string       `json:"filename"`
+	JSON      filePartJSON `json:"-"`
+}
+
+// filePartJSON contains the JSON metadata for the struct [FilePart]
+type filePartJSON struct {
+	MediaType   apijson.Field
+	Type        apijson.Field
+	URL         apijson.Field
+	Filename    apijson.Field
+	raw         string
+	ExtraFields map[string]apijson.Field
+}
+
+func (r *FilePart) UnmarshalJSON(data []byte) (err error) {
+	return apijson.UnmarshalRoot(data, r)
+}
+
+func (r filePartJSON) RawJSON() string {
+	return r.raw
+}
+
+func (r FilePart) implementsMessagePart() {}
+
+type FilePartType string
+
+const (
+	FilePartTypeFile FilePartType = "file"
+)
+
+func (r FilePartType) IsKnown() bool {
+	switch r {
+	case FilePartTypeFile:
+		return true
+	}
+	return false
+}
+
+type FilePartParam struct {
+	MediaType param.Field[string]       `json:"mediaType,required"`
+	Type      param.Field[FilePartType] `json:"type,required"`
+	URL       param.Field[string]       `json:"url,required"`
+	Filename  param.Field[string]       `json:"filename"`
+}
+
+func (r FilePartParam) MarshalJSON() (data []byte, err error) {
+	return apijson.MarshalRoot(r)
+}
+
+func (r FilePartParam) implementsMessagePartUnionParam() {}
+
+type Message struct {
+	ID       string          `json:"id,required"`
+	Metadata MessageMetadata `json:"metadata,required"`
+	Parts    []MessagePart   `json:"parts,required"`
+	Role     MessageRole     `json:"role,required"`
+	JSON     messageJSON     `json:"-"`
+}
+
+// messageJSON contains the JSON metadata for the struct [Message]
+type messageJSON struct {
+	ID          apijson.Field
+	Metadata    apijson.Field
+	Parts       apijson.Field
+	Role        apijson.Field
+	raw         string
+	ExtraFields map[string]apijson.Field
+}
+
+func (r *Message) UnmarshalJSON(data []byte) (err error) {
+	return apijson.UnmarshalRoot(data, r)
+}
+
+func (r messageJSON) RawJSON() string {
+	return r.raw
+}
+
+type MessageMetadata struct {
+	SessionID string                         `json:"sessionID,required"`
+	Time      MessageMetadataTime            `json:"time,required"`
+	Tool      map[string]MessageMetadataTool `json:"tool,required"`
+	Assistant MessageMetadataAssistant       `json:"assistant"`
+	Error     MessageMetadataError           `json:"error"`
+	Snapshot  string                         `json:"snapshot"`
+	JSON      messageMetadataJSON            `json:"-"`
+}
+
+// messageMetadataJSON contains the JSON metadata for the struct [MessageMetadata]
+type messageMetadataJSON struct {
+	SessionID   apijson.Field
+	Time        apijson.Field
+	Tool        apijson.Field
+	Assistant   apijson.Field
+	Error       apijson.Field
+	Snapshot    apijson.Field
+	raw         string
+	ExtraFields map[string]apijson.Field
+}
+
+func (r *MessageMetadata) UnmarshalJSON(data []byte) (err error) {
+	return apijson.UnmarshalRoot(data, r)
+}
+
+func (r messageMetadataJSON) RawJSON() string {
+	return r.raw
+}
+
+type MessageMetadataTime struct {
+	Created   float64                 `json:"created,required"`
+	Completed float64                 `json:"completed"`
+	JSON      messageMetadataTimeJSON `json:"-"`
+}
+
+// messageMetadataTimeJSON contains the JSON metadata for the struct
+// [MessageMetadataTime]
+type messageMetadataTimeJSON struct {
+	Created     apijson.Field
+	Completed   apijson.Field
+	raw         string
+	ExtraFields map[string]apijson.Field
+}
+
+func (r *MessageMetadataTime) UnmarshalJSON(data []byte) (err error) {
+	return apijson.UnmarshalRoot(data, r)
+}
+
+func (r messageMetadataTimeJSON) RawJSON() string {
+	return r.raw
+}
+
+type MessageMetadataTool struct {
+	Time        MessageMetadataToolTime `json:"time,required"`
+	Title       string                  `json:"title,required"`
+	Snapshot    string                  `json:"snapshot"`
+	ExtraFields map[string]interface{}  `json:"-,extras"`
+	JSON        messageMetadataToolJSON `json:"-"`
+}
+
+// messageMetadataToolJSON contains the JSON metadata for the struct
+// [MessageMetadataTool]
+type messageMetadataToolJSON struct {
+	Time        apijson.Field
+	Title       apijson.Field
+	Snapshot    apijson.Field
+	raw         string
+	ExtraFields map[string]apijson.Field
+}
+
+func (r *MessageMetadataTool) UnmarshalJSON(data []byte) (err error) {
+	return apijson.UnmarshalRoot(data, r)
+}
+
+func (r messageMetadataToolJSON) RawJSON() string {
+	return r.raw
+}
+
+type MessageMetadataToolTime struct {
+	End   float64                     `json:"end,required"`
+	Start float64                     `json:"start,required"`
+	JSON  messageMetadataToolTimeJSON `json:"-"`
+}
+
+// messageMetadataToolTimeJSON contains the JSON metadata for the struct
+// [MessageMetadataToolTime]
+type messageMetadataToolTimeJSON struct {
+	End         apijson.Field
+	Start       apijson.Field
+	raw         string
+	ExtraFields map[string]apijson.Field
+}
+
+func (r *MessageMetadataToolTime) UnmarshalJSON(data []byte) (err error) {
+	return apijson.UnmarshalRoot(data, r)
+}
+
+func (r messageMetadataToolTimeJSON) RawJSON() string {
+	return r.raw
+}
+
+type MessageMetadataAssistant struct {
+	Cost       float64                        `json:"cost,required"`
+	ModelID    string                         `json:"modelID,required"`
+	Path       MessageMetadataAssistantPath   `json:"path,required"`
+	ProviderID string                         `json:"providerID,required"`
+	System     []string                       `json:"system,required"`
+	Tokens     MessageMetadataAssistantTokens `json:"tokens,required"`
+	Summary    bool                           `json:"summary"`
+	JSON       messageMetadataAssistantJSON   `json:"-"`
+}
+
+// messageMetadataAssistantJSON contains the JSON metadata for the struct
+// [MessageMetadataAssistant]
+type messageMetadataAssistantJSON struct {
+	Cost        apijson.Field
+	ModelID     apijson.Field
+	Path        apijson.Field
+	ProviderID  apijson.Field
+	System      apijson.Field
+	Tokens      apijson.Field
+	Summary     apijson.Field
+	raw         string
+	ExtraFields map[string]apijson.Field
+}
+
+func (r *MessageMetadataAssistant) UnmarshalJSON(data []byte) (err error) {
+	return apijson.UnmarshalRoot(data, r)
+}
+
+func (r messageMetadataAssistantJSON) RawJSON() string {
+	return r.raw
+}
+
+type MessageMetadataAssistantPath struct {
+	Cwd  string                           `json:"cwd,required"`
+	Root string                           `json:"root,required"`
+	JSON messageMetadataAssistantPathJSON `json:"-"`
+}
+
+// messageMetadataAssistantPathJSON contains the JSON metadata for the struct
+// [MessageMetadataAssistantPath]
+type messageMetadataAssistantPathJSON struct {
+	Cwd         apijson.Field
+	Root        apijson.Field
+	raw         string
+	ExtraFields map[string]apijson.Field
+}
+
+func (r *MessageMetadataAssistantPath) UnmarshalJSON(data []byte) (err error) {
+	return apijson.UnmarshalRoot(data, r)
+}
+
+func (r messageMetadataAssistantPathJSON) RawJSON() string {
+	return r.raw
+}
+
+type MessageMetadataAssistantTokens struct {
+	Cache     MessageMetadataAssistantTokensCache `json:"cache,required"`
+	Input     float64                             `json:"input,required"`
+	Output    float64                             `json:"output,required"`
+	Reasoning float64                             `json:"reasoning,required"`
+	JSON      messageMetadataAssistantTokensJSON  `json:"-"`
+}
+
+// messageMetadataAssistantTokensJSON contains the JSON metadata for the struct
+// [MessageMetadataAssistantTokens]
+type messageMetadataAssistantTokensJSON struct {
+	Cache       apijson.Field
+	Input       apijson.Field
+	Output      apijson.Field
+	Reasoning   apijson.Field
+	raw         string
+	ExtraFields map[string]apijson.Field
+}
+
+func (r *MessageMetadataAssistantTokens) UnmarshalJSON(data []byte) (err error) {
+	return apijson.UnmarshalRoot(data, r)
+}
+
+func (r messageMetadataAssistantTokensJSON) RawJSON() string {
+	return r.raw
+}
+
+type MessageMetadataAssistantTokensCache struct {
+	Read  float64                                 `json:"read,required"`
+	Write float64                                 `json:"write,required"`
+	JSON  messageMetadataAssistantTokensCacheJSON `json:"-"`
+}
+
+// messageMetadataAssistantTokensCacheJSON contains the JSON metadata for the
+// struct [MessageMetadataAssistantTokensCache]
+type messageMetadataAssistantTokensCacheJSON struct {
+	Read        apijson.Field
+	Write       apijson.Field
+	raw         string
+	ExtraFields map[string]apijson.Field
+}
+
+func (r *MessageMetadataAssistantTokensCache) UnmarshalJSON(data []byte) (err error) {
+	return apijson.UnmarshalRoot(data, r)
+}
+
+func (r messageMetadataAssistantTokensCacheJSON) RawJSON() string {
+	return r.raw
+}
+
+type MessageMetadataError struct {
+	// This field can have the runtime type of [shared.ProviderAuthErrorData],
+	// [shared.UnknownErrorData], [interface{}].
+	Data  interface{}              `json:"data,required"`
+	Name  MessageMetadataErrorName `json:"name,required"`
+	JSON  messageMetadataErrorJSON `json:"-"`
+	union MessageMetadataErrorUnion
+}
+
+// messageMetadataErrorJSON contains the JSON metadata for the struct
+// [MessageMetadataError]
+type messageMetadataErrorJSON struct {
+	Data        apijson.Field
+	Name        apijson.Field
+	raw         string
+	ExtraFields map[string]apijson.Field
+}
+
+func (r messageMetadataErrorJSON) RawJSON() string {
+	return r.raw
+}
+
+func (r *MessageMetadataError) UnmarshalJSON(data []byte) (err error) {
+	*r = MessageMetadataError{}
+	err = apijson.UnmarshalRoot(data, &r.union)
+	if err != nil {
+		return err
+	}
+	return apijson.Port(r.union, &r)
+}
+
+// AsUnion returns a [MessageMetadataErrorUnion] interface which you can cast to
+// the specific types for more type safety.
+//
+// Possible runtime types of the union are [shared.ProviderAuthError],
+// [shared.UnknownError], [MessageMetadataErrorMessageOutputLengthError].
+func (r MessageMetadataError) AsUnion() MessageMetadataErrorUnion {
+	return r.union
+}
+
+// Union satisfied by [shared.ProviderAuthError], [shared.UnknownError] or
+// [MessageMetadataErrorMessageOutputLengthError].
+type MessageMetadataErrorUnion interface {
+	ImplementsMessageMetadataError()
+}
+
+func init() {
+	apijson.RegisterUnion(
+		reflect.TypeOf((*MessageMetadataErrorUnion)(nil)).Elem(),
+		"name",
+		apijson.UnionVariant{
+			TypeFilter:         gjson.JSON,
+			Type:               reflect.TypeOf(shared.ProviderAuthError{}),
+			DiscriminatorValue: "ProviderAuthError",
+		},
+		apijson.UnionVariant{
+			TypeFilter:         gjson.JSON,
+			Type:               reflect.TypeOf(shared.UnknownError{}),
+			DiscriminatorValue: "UnknownError",
+		},
+		apijson.UnionVariant{
+			TypeFilter:         gjson.JSON,
+			Type:               reflect.TypeOf(MessageMetadataErrorMessageOutputLengthError{}),
+			DiscriminatorValue: "MessageOutputLengthError",
+		},
+	)
+}
+
+type MessageMetadataErrorMessageOutputLengthError struct {
+	Data interface{}                                      `json:"data,required"`
+	Name MessageMetadataErrorMessageOutputLengthErrorName `json:"name,required"`
+	JSON messageMetadataErrorMessageOutputLengthErrorJSON `json:"-"`
+}
+
+// messageMetadataErrorMessageOutputLengthErrorJSON contains the JSON metadata for
+// the struct [MessageMetadataErrorMessageOutputLengthError]
+type messageMetadataErrorMessageOutputLengthErrorJSON struct {
+	Data        apijson.Field
+	Name        apijson.Field
+	raw         string
+	ExtraFields map[string]apijson.Field
+}
+
+func (r *MessageMetadataErrorMessageOutputLengthError) UnmarshalJSON(data []byte) (err error) {
+	return apijson.UnmarshalRoot(data, r)
+}
+
+func (r messageMetadataErrorMessageOutputLengthErrorJSON) RawJSON() string {
+	return r.raw
+}
+
+func (r MessageMetadataErrorMessageOutputLengthError) ImplementsMessageMetadataError() {}
+
+type MessageMetadataErrorMessageOutputLengthErrorName string
+
+const (
+	MessageMetadataErrorMessageOutputLengthErrorNameMessageOutputLengthError MessageMetadataErrorMessageOutputLengthErrorName = "MessageOutputLengthError"
+)
+
+func (r MessageMetadataErrorMessageOutputLengthErrorName) IsKnown() bool {
+	switch r {
+	case MessageMetadataErrorMessageOutputLengthErrorNameMessageOutputLengthError:
+		return true
+	}
+	return false
+}
+
+type MessageMetadataErrorName string
+
+const (
+	MessageMetadataErrorNameProviderAuthError        MessageMetadataErrorName = "ProviderAuthError"
+	MessageMetadataErrorNameUnknownError             MessageMetadataErrorName = "UnknownError"
+	MessageMetadataErrorNameMessageOutputLengthError MessageMetadataErrorName = "MessageOutputLengthError"
+)
+
+func (r MessageMetadataErrorName) IsKnown() bool {
+	switch r {
+	case MessageMetadataErrorNameProviderAuthError, MessageMetadataErrorNameUnknownError, MessageMetadataErrorNameMessageOutputLengthError:
+		return true
+	}
+	return false
+}
+
+type MessageRole string
+
+const (
+	MessageRoleUser      MessageRole = "user"
+	MessageRoleAssistant MessageRole = "assistant"
+)
+
+func (r MessageRole) IsKnown() bool {
+	switch r {
+	case MessageRoleUser, MessageRoleAssistant:
+		return true
+	}
+	return false
+}
+
+type MessagePart struct {
+	Type      MessagePartType `json:"type,required"`
+	Filename  string          `json:"filename"`
+	MediaType string          `json:"mediaType"`
+	// This field can have the runtime type of [map[string]interface{}].
+	ProviderMetadata interface{} `json:"providerMetadata"`
+	SourceID         string      `json:"sourceId"`
+	Text             string      `json:"text"`
+	Title            string      `json:"title"`
+	// This field can have the runtime type of [ToolInvocationPartToolInvocation].
+	ToolInvocation interface{}     `json:"toolInvocation"`
+	URL            string          `json:"url"`
+	JSON           messagePartJSON `json:"-"`
+	union          MessagePartUnion
+}
+
+// messagePartJSON contains the JSON metadata for the struct [MessagePart]
+type messagePartJSON struct {
+	Type             apijson.Field
+	Filename         apijson.Field
+	MediaType        apijson.Field
+	ProviderMetadata apijson.Field
+	SourceID         apijson.Field
+	Text             apijson.Field
+	Title            apijson.Field
+	ToolInvocation   apijson.Field
+	URL              apijson.Field
+	raw              string
+	ExtraFields      map[string]apijson.Field
+}
+
+func (r messagePartJSON) RawJSON() string {
+	return r.raw
+}
+
+func (r *MessagePart) UnmarshalJSON(data []byte) (err error) {
+	*r = MessagePart{}
+	err = apijson.UnmarshalRoot(data, &r.union)
+	if err != nil {
+		return err
+	}
+	return apijson.Port(r.union, &r)
+}
+
+// AsUnion returns a [MessagePartUnion] interface which you can cast to the
+// specific types for more type safety.
+//
+// Possible runtime types of the union are [TextPart], [ReasoningPart],
+// [ToolInvocationPart], [SourceURLPart], [FilePart], [StepStartPart].
+func (r MessagePart) AsUnion() MessagePartUnion {
+	return r.union
+}
+
+// Union satisfied by [TextPart], [ReasoningPart], [ToolInvocationPart],
+// [SourceURLPart], [FilePart] or [StepStartPart].
+type MessagePartUnion interface {
+	implementsMessagePart()
+}
+
+func init() {
+	apijson.RegisterUnion(
+		reflect.TypeOf((*MessagePartUnion)(nil)).Elem(),
+		"type",
+		apijson.UnionVariant{
+			TypeFilter:         gjson.JSON,
+			Type:               reflect.TypeOf(TextPart{}),
+			DiscriminatorValue: "text",
+		},
+		apijson.UnionVariant{
+			TypeFilter:         gjson.JSON,
+			Type:               reflect.TypeOf(ReasoningPart{}),
+			DiscriminatorValue: "reasoning",
+		},
+		apijson.UnionVariant{
+			TypeFilter:         gjson.JSON,
+			Type:               reflect.TypeOf(ToolInvocationPart{}),
+			DiscriminatorValue: "tool-invocation",
+		},
+		apijson.UnionVariant{
+			TypeFilter:         gjson.JSON,
+			Type:               reflect.TypeOf(SourceURLPart{}),
+			DiscriminatorValue: "source-url",
+		},
+		apijson.UnionVariant{
+			TypeFilter:         gjson.JSON,
+			Type:               reflect.TypeOf(FilePart{}),
+			DiscriminatorValue: "file",
+		},
+		apijson.UnionVariant{
+			TypeFilter:         gjson.JSON,
+			Type:               reflect.TypeOf(StepStartPart{}),
+			DiscriminatorValue: "step-start",
+		},
+	)
+}
+
+type MessagePartType string
+
+const (
+	MessagePartTypeText           MessagePartType = "text"
+	MessagePartTypeReasoning      MessagePartType = "reasoning"
+	MessagePartTypeToolInvocation MessagePartType = "tool-invocation"
+	MessagePartTypeSourceURL      MessagePartType = "source-url"
+	MessagePartTypeFile           MessagePartType = "file"
+	MessagePartTypeStepStart      MessagePartType = "step-start"
+)
+
+func (r MessagePartType) IsKnown() bool {
+	switch r {
+	case MessagePartTypeText, MessagePartTypeReasoning, MessagePartTypeToolInvocation, MessagePartTypeSourceURL, MessagePartTypeFile, MessagePartTypeStepStart:
+		return true
+	}
+	return false
+}
+
+type MessagePartParam struct {
+	Type             param.Field[MessagePartType] `json:"type,required"`
+	Filename         param.Field[string]          `json:"filename"`
+	MediaType        param.Field[string]          `json:"mediaType"`
+	ProviderMetadata param.Field[interface{}]     `json:"providerMetadata"`
+	SourceID         param.Field[string]          `json:"sourceId"`
+	Text             param.Field[string]          `json:"text"`
+	Title            param.Field[string]          `json:"title"`
+	ToolInvocation   param.Field[interface{}]     `json:"toolInvocation"`
+	URL              param.Field[string]          `json:"url"`
+}
+
+func (r MessagePartParam) MarshalJSON() (data []byte, err error) {
+	return apijson.MarshalRoot(r)
+}
+
+func (r MessagePartParam) implementsMessagePartUnionParam() {}
+
+// Satisfied by [TextPartParam], [ReasoningPartParam], [ToolInvocationPartParam],
+// [SourceURLPartParam], [FilePartParam], [StepStartPartParam], [MessagePartParam].
+type MessagePartUnionParam interface {
+	implementsMessagePartUnionParam()
+}
+
+type ReasoningPart struct {
+	Text             string                 `json:"text,required"`
+	Type             ReasoningPartType      `json:"type,required"`
+	ProviderMetadata map[string]interface{} `json:"providerMetadata"`
+	JSON             reasoningPartJSON      `json:"-"`
+}
+
+// reasoningPartJSON contains the JSON metadata for the struct [ReasoningPart]
+type reasoningPartJSON struct {
+	Text             apijson.Field
+	Type             apijson.Field
+	ProviderMetadata apijson.Field
+	raw              string
+	ExtraFields      map[string]apijson.Field
+}
+
+func (r *ReasoningPart) UnmarshalJSON(data []byte) (err error) {
+	return apijson.UnmarshalRoot(data, r)
+}
+
+func (r reasoningPartJSON) RawJSON() string {
+	return r.raw
+}
+
+func (r ReasoningPart) implementsMessagePart() {}
+
+type ReasoningPartType string
+
+const (
+	ReasoningPartTypeReasoning ReasoningPartType = "reasoning"
+)
+
+func (r ReasoningPartType) IsKnown() bool {
+	switch r {
+	case ReasoningPartTypeReasoning:
+		return true
+	}
+	return false
+}
+
+type ReasoningPartParam struct {
+	Text             param.Field[string]                 `json:"text,required"`
+	Type             param.Field[ReasoningPartType]      `json:"type,required"`
+	ProviderMetadata param.Field[map[string]interface{}] `json:"providerMetadata"`
+}
+
+func (r ReasoningPartParam) MarshalJSON() (data []byte, err error) {
+	return apijson.MarshalRoot(r)
+}
+
+func (r ReasoningPartParam) implementsMessagePartUnionParam() {}
+
+type Session struct {
+	ID       string        `json:"id,required"`
+	Time     SessionTime   `json:"time,required"`
+	Title    string        `json:"title,required"`
+	Version  string        `json:"version,required"`
+	ParentID string        `json:"parentID"`
+	Revert   SessionRevert `json:"revert"`
+	Share    SessionShare  `json:"share"`
+	JSON     sessionJSON   `json:"-"`
+}
+
+// sessionJSON contains the JSON metadata for the struct [Session]
+type sessionJSON struct {
+	ID          apijson.Field
+	Time        apijson.Field
+	Title       apijson.Field
+	Version     apijson.Field
+	ParentID    apijson.Field
+	Revert      apijson.Field
+	Share       apijson.Field
+	raw         string
+	ExtraFields map[string]apijson.Field
+}
+
+func (r *Session) UnmarshalJSON(data []byte) (err error) {
+	return apijson.UnmarshalRoot(data, r)
+}
+
+func (r sessionJSON) RawJSON() string {
+	return r.raw
+}
+
+type SessionTime struct {
+	Created float64         `json:"created,required"`
+	Updated float64         `json:"updated,required"`
+	JSON    sessionTimeJSON `json:"-"`
+}
+
+// sessionTimeJSON contains the JSON metadata for the struct [SessionTime]
+type sessionTimeJSON struct {
+	Created     apijson.Field
+	Updated     apijson.Field
+	raw         string
+	ExtraFields map[string]apijson.Field
+}
+
+func (r *SessionTime) UnmarshalJSON(data []byte) (err error) {
+	return apijson.UnmarshalRoot(data, r)
+}
+
+func (r sessionTimeJSON) RawJSON() string {
+	return r.raw
+}
+
+type SessionRevert struct {
+	MessageID string            `json:"messageID,required"`
+	Part      float64           `json:"part,required"`
+	Snapshot  string            `json:"snapshot"`
+	JSON      sessionRevertJSON `json:"-"`
+}
+
+// sessionRevertJSON contains the JSON metadata for the struct [SessionRevert]
+type sessionRevertJSON struct {
+	MessageID   apijson.Field
+	Part        apijson.Field
+	Snapshot    apijson.Field
+	raw         string
+	ExtraFields map[string]apijson.Field
+}
+
+func (r *SessionRevert) UnmarshalJSON(data []byte) (err error) {
+	return apijson.UnmarshalRoot(data, r)
+}
+
+func (r sessionRevertJSON) RawJSON() string {
+	return r.raw
+}
+
+type SessionShare struct {
+	URL  string           `json:"url,required"`
+	JSON sessionShareJSON `json:"-"`
+}
+
+// sessionShareJSON contains the JSON metadata for the struct [SessionShare]
+type sessionShareJSON struct {
+	URL         apijson.Field
+	raw         string
+	ExtraFields map[string]apijson.Field
+}
+
+func (r *SessionShare) UnmarshalJSON(data []byte) (err error) {
+	return apijson.UnmarshalRoot(data, r)
+}
+
+func (r sessionShareJSON) RawJSON() string {
+	return r.raw
+}
+
+type SourceURLPart struct {
+	SourceID         string                 `json:"sourceId,required"`
+	Type             SourceURLPartType      `json:"type,required"`
+	URL              string                 `json:"url,required"`
+	ProviderMetadata map[string]interface{} `json:"providerMetadata"`
+	Title            string                 `json:"title"`
+	JSON             sourceURLPartJSON      `json:"-"`
+}
+
+// sourceURLPartJSON contains the JSON metadata for the struct [SourceURLPart]
+type sourceURLPartJSON struct {
+	SourceID         apijson.Field
+	Type             apijson.Field
+	URL              apijson.Field
+	ProviderMetadata apijson.Field
+	Title            apijson.Field
+	raw              string
+	ExtraFields      map[string]apijson.Field
+}
+
+func (r *SourceURLPart) UnmarshalJSON(data []byte) (err error) {
+	return apijson.UnmarshalRoot(data, r)
+}
+
+func (r sourceURLPartJSON) RawJSON() string {
+	return r.raw
+}
+
+func (r SourceURLPart) implementsMessagePart() {}
+
+type SourceURLPartType string
+
+const (
+	SourceURLPartTypeSourceURL SourceURLPartType = "source-url"
+)
+
+func (r SourceURLPartType) IsKnown() bool {
+	switch r {
+	case SourceURLPartTypeSourceURL:
+		return true
+	}
+	return false
+}
+
+type SourceURLPartParam struct {
+	SourceID         param.Field[string]                 `json:"sourceId,required"`
+	Type             param.Field[SourceURLPartType]      `json:"type,required"`
+	URL              param.Field[string]                 `json:"url,required"`
+	ProviderMetadata param.Field[map[string]interface{}] `json:"providerMetadata"`
+	Title            param.Field[string]                 `json:"title"`
+}
+
+func (r SourceURLPartParam) MarshalJSON() (data []byte, err error) {
+	return apijson.MarshalRoot(r)
+}
+
+func (r SourceURLPartParam) implementsMessagePartUnionParam() {}
+
+type StepStartPart struct {
+	Type StepStartPartType `json:"type,required"`
+	JSON stepStartPartJSON `json:"-"`
+}
+
+// stepStartPartJSON contains the JSON metadata for the struct [StepStartPart]
+type stepStartPartJSON struct {
+	Type        apijson.Field
+	raw         string
+	ExtraFields map[string]apijson.Field
+}
+
+func (r *StepStartPart) UnmarshalJSON(data []byte) (err error) {
+	return apijson.UnmarshalRoot(data, r)
+}
+
+func (r stepStartPartJSON) RawJSON() string {
+	return r.raw
+}
+
+func (r StepStartPart) implementsMessagePart() {}
+
+type StepStartPartType string
+
+const (
+	StepStartPartTypeStepStart StepStartPartType = "step-start"
+)
+
+func (r StepStartPartType) IsKnown() bool {
+	switch r {
+	case StepStartPartTypeStepStart:
+		return true
+	}
+	return false
+}
+
+type StepStartPartParam struct {
+	Type param.Field[StepStartPartType] `json:"type,required"`
+}
+
+func (r StepStartPartParam) MarshalJSON() (data []byte, err error) {
+	return apijson.MarshalRoot(r)
+}
+
+func (r StepStartPartParam) implementsMessagePartUnionParam() {}
+
+type TextPart struct {
+	Text string       `json:"text,required"`
+	Type TextPartType `json:"type,required"`
+	JSON textPartJSON `json:"-"`
+}
+
+// textPartJSON contains the JSON metadata for the struct [TextPart]
+type textPartJSON struct {
+	Text        apijson.Field
+	Type        apijson.Field
+	raw         string
+	ExtraFields map[string]apijson.Field
+}
+
+func (r *TextPart) UnmarshalJSON(data []byte) (err error) {
+	return apijson.UnmarshalRoot(data, r)
+}
+
+func (r textPartJSON) RawJSON() string {
+	return r.raw
+}
+
+func (r TextPart) implementsMessagePart() {}
+
+type TextPartType string
+
+const (
+	TextPartTypeText TextPartType = "text"
+)
+
+func (r TextPartType) IsKnown() bool {
+	switch r {
+	case TextPartTypeText:
+		return true
+	}
+	return false
+}
+
+type TextPartParam struct {
+	Text param.Field[string]       `json:"text,required"`
+	Type param.Field[TextPartType] `json:"type,required"`
+}
+
+func (r TextPartParam) MarshalJSON() (data []byte, err error) {
+	return apijson.MarshalRoot(r)
+}
+
+func (r TextPartParam) implementsMessagePartUnionParam() {}
+
+type ToolCall struct {
+	State      ToolCallState `json:"state,required"`
+	ToolCallID string        `json:"toolCallId,required"`
+	ToolName   string        `json:"toolName,required"`
+	Args       interface{}   `json:"args"`
+	Step       float64       `json:"step"`
+	JSON       toolCallJSON  `json:"-"`
+}
+
+// toolCallJSON contains the JSON metadata for the struct [ToolCall]
+type toolCallJSON struct {
+	State       apijson.Field
+	ToolCallID  apijson.Field
+	ToolName    apijson.Field
+	Args        apijson.Field
+	Step        apijson.Field
+	raw         string
+	ExtraFields map[string]apijson.Field
+}
+
+func (r *ToolCall) UnmarshalJSON(data []byte) (err error) {
+	return apijson.UnmarshalRoot(data, r)
+}
+
+func (r toolCallJSON) RawJSON() string {
+	return r.raw
+}
+
+func (r ToolCall) implementsToolInvocationPartToolInvocation() {}
+
+type ToolCallState string
+
+const (
+	ToolCallStateCall ToolCallState = "call"
+)
+
+func (r ToolCallState) IsKnown() bool {
+	switch r {
+	case ToolCallStateCall:
+		return true
+	}
+	return false
+}
+
+type ToolCallParam struct {
+	State      param.Field[ToolCallState] `json:"state,required"`
+	ToolCallID param.Field[string]        `json:"toolCallId,required"`
+	ToolName   param.Field[string]        `json:"toolName,required"`
+	Args       param.Field[interface{}]   `json:"args"`
+	Step       param.Field[float64]       `json:"step"`
+}
+
+func (r ToolCallParam) MarshalJSON() (data []byte, err error) {
+	return apijson.MarshalRoot(r)
+}
+
+func (r ToolCallParam) implementsToolInvocationPartToolInvocationUnionParam() {}
+
+type ToolInvocationPart struct {
+	ToolInvocation ToolInvocationPartToolInvocation `json:"toolInvocation,required"`
+	Type           ToolInvocationPartType           `json:"type,required"`
+	JSON           toolInvocationPartJSON           `json:"-"`
+}
+
+// toolInvocationPartJSON contains the JSON metadata for the struct
+// [ToolInvocationPart]
+type toolInvocationPartJSON struct {
+	ToolInvocation apijson.Field
+	Type           apijson.Field
+	raw            string
+	ExtraFields    map[string]apijson.Field
+}
+
+func (r *ToolInvocationPart) UnmarshalJSON(data []byte) (err error) {
+	return apijson.UnmarshalRoot(data, r)
+}
+
+func (r toolInvocationPartJSON) RawJSON() string {
+	return r.raw
+}
+
+func (r ToolInvocationPart) implementsMessagePart() {}
+
+type ToolInvocationPartToolInvocation struct {
+	State      ToolInvocationPartToolInvocationState `json:"state,required"`
+	ToolCallID string                                `json:"toolCallId,required"`
+	ToolName   string                                `json:"toolName,required"`
+	// This field can have the runtime type of [interface{}].
+	Args   interface{}                          `json:"args"`
+	Result string                               `json:"result"`
+	Step   float64                              `json:"step"`
+	JSON   toolInvocationPartToolInvocationJSON `json:"-"`
+	union  ToolInvocationPartToolInvocationUnion
+}
+
+// toolInvocationPartToolInvocationJSON contains the JSON metadata for the struct
+// [ToolInvocationPartToolInvocation]
+type toolInvocationPartToolInvocationJSON struct {
+	State       apijson.Field
+	ToolCallID  apijson.Field
+	ToolName    apijson.Field
+	Args        apijson.Field
+	Result      apijson.Field
+	Step        apijson.Field
+	raw         string
+	ExtraFields map[string]apijson.Field
+}
+
+func (r toolInvocationPartToolInvocationJSON) RawJSON() string {
+	return r.raw
+}
+
+func (r *ToolInvocationPartToolInvocation) UnmarshalJSON(data []byte) (err error) {
+	*r = ToolInvocationPartToolInvocation{}
+	err = apijson.UnmarshalRoot(data, &r.union)
+	if err != nil {
+		return err
+	}
+	return apijson.Port(r.union, &r)
+}
+
+// AsUnion returns a [ToolInvocationPartToolInvocationUnion] interface which you
+// can cast to the specific types for more type safety.
+//
+// Possible runtime types of the union are [ToolCall], [ToolPartialCall],
+// [ToolResult].
+func (r ToolInvocationPartToolInvocation) AsUnion() ToolInvocationPartToolInvocationUnion {
+	return r.union
+}
+
+// Union satisfied by [ToolCall], [ToolPartialCall] or [ToolResult].
+type ToolInvocationPartToolInvocationUnion interface {
+	implementsToolInvocationPartToolInvocation()
+}
+
+func init() {
+	apijson.RegisterUnion(
+		reflect.TypeOf((*ToolInvocationPartToolInvocationUnion)(nil)).Elem(),
+		"state",
+		apijson.UnionVariant{
+			TypeFilter:         gjson.JSON,
+			Type:               reflect.TypeOf(ToolCall{}),
+			DiscriminatorValue: "call",
+		},
+		apijson.UnionVariant{
+			TypeFilter:         gjson.JSON,
+			Type:               reflect.TypeOf(ToolPartialCall{}),
+			DiscriminatorValue: "partial-call",
+		},
+		apijson.UnionVariant{
+			TypeFilter:         gjson.JSON,
+			Type:               reflect.TypeOf(ToolResult{}),
+			DiscriminatorValue: "result",
+		},
+	)
+}
+
+type ToolInvocationPartToolInvocationState string
+
+const (
+	ToolInvocationPartToolInvocationStateCall        ToolInvocationPartToolInvocationState = "call"
+	ToolInvocationPartToolInvocationStatePartialCall ToolInvocationPartToolInvocationState = "partial-call"
+	ToolInvocationPartToolInvocationStateResult      ToolInvocationPartToolInvocationState = "result"
+)
+
+func (r ToolInvocationPartToolInvocationState) IsKnown() bool {
+	switch r {
+	case ToolInvocationPartToolInvocationStateCall, ToolInvocationPartToolInvocationStatePartialCall, ToolInvocationPartToolInvocationStateResult:
+		return true
+	}
+	return false
+}
+
+type ToolInvocationPartType string
+
+const (
+	ToolInvocationPartTypeToolInvocation ToolInvocationPartType = "tool-invocation"
+)
+
+func (r ToolInvocationPartType) IsKnown() bool {
+	switch r {
+	case ToolInvocationPartTypeToolInvocation:
+		return true
+	}
+	return false
+}
+
+type ToolInvocationPartParam struct {
+	ToolInvocation param.Field[ToolInvocationPartToolInvocationUnionParam] `json:"toolInvocation,required"`
+	Type           param.Field[ToolInvocationPartType]                     `json:"type,required"`
+}
+
+func (r ToolInvocationPartParam) MarshalJSON() (data []byte, err error) {
+	return apijson.MarshalRoot(r)
+}
+
+func (r ToolInvocationPartParam) implementsMessagePartUnionParam() {}
+
+type ToolInvocationPartToolInvocationParam struct {
+	State      param.Field[ToolInvocationPartToolInvocationState] `json:"state,required"`
+	ToolCallID param.Field[string]                                `json:"toolCallId,required"`
+	ToolName   param.Field[string]                                `json:"toolName,required"`
+	Args       param.Field[interface{}]                           `json:"args"`
+	Result     param.Field[string]                                `json:"result"`
+	Step       param.Field[float64]                               `json:"step"`
+}
+
+func (r ToolInvocationPartToolInvocationParam) MarshalJSON() (data []byte, err error) {
+	return apijson.MarshalRoot(r)
+}
+
+func (r ToolInvocationPartToolInvocationParam) implementsToolInvocationPartToolInvocationUnionParam() {
+}
+
+// Satisfied by [ToolCallParam], [ToolPartialCallParam], [ToolResultParam],
+// [ToolInvocationPartToolInvocationParam].
+type ToolInvocationPartToolInvocationUnionParam interface {
+	implementsToolInvocationPartToolInvocationUnionParam()
+}
+
+type ToolPartialCall struct {
+	State      ToolPartialCallState `json:"state,required"`
+	ToolCallID string               `json:"toolCallId,required"`
+	ToolName   string               `json:"toolName,required"`
+	Args       interface{}          `json:"args"`
+	Step       float64              `json:"step"`
+	JSON       toolPartialCallJSON  `json:"-"`
+}
+
+// toolPartialCallJSON contains the JSON metadata for the struct [ToolPartialCall]
+type toolPartialCallJSON struct {
+	State       apijson.Field
+	ToolCallID  apijson.Field
+	ToolName    apijson.Field
+	Args        apijson.Field
+	Step        apijson.Field
+	raw         string
+	ExtraFields map[string]apijson.Field
+}
+
+func (r *ToolPartialCall) UnmarshalJSON(data []byte) (err error) {
+	return apijson.UnmarshalRoot(data, r)
+}
+
+func (r toolPartialCallJSON) RawJSON() string {
+	return r.raw
+}
+
+func (r ToolPartialCall) implementsToolInvocationPartToolInvocation() {}
+
+type ToolPartialCallState string
+
+const (
+	ToolPartialCallStatePartialCall ToolPartialCallState = "partial-call"
+)
+
+func (r ToolPartialCallState) IsKnown() bool {
+	switch r {
+	case ToolPartialCallStatePartialCall:
+		return true
+	}
+	return false
+}
+
+type ToolPartialCallParam struct {
+	State      param.Field[ToolPartialCallState] `json:"state,required"`
+	ToolCallID param.Field[string]               `json:"toolCallId,required"`
+	ToolName   param.Field[string]               `json:"toolName,required"`
+	Args       param.Field[interface{}]          `json:"args"`
+	Step       param.Field[float64]              `json:"step"`
+}
+
+func (r ToolPartialCallParam) MarshalJSON() (data []byte, err error) {
+	return apijson.MarshalRoot(r)
+}
+
+func (r ToolPartialCallParam) implementsToolInvocationPartToolInvocationUnionParam() {}
+
+type ToolResult struct {
+	Result     string          `json:"result,required"`
+	State      ToolResultState `json:"state,required"`
+	ToolCallID string          `json:"toolCallId,required"`
+	ToolName   string          `json:"toolName,required"`
+	Args       interface{}     `json:"args"`
+	Step       float64         `json:"step"`
+	JSON       toolResultJSON  `json:"-"`
+}
+
+// toolResultJSON contains the JSON metadata for the struct [ToolResult]
+type toolResultJSON struct {
+	Result      apijson.Field
+	State       apijson.Field
+	ToolCallID  apijson.Field
+	ToolName    apijson.Field
+	Args        apijson.Field
+	Step        apijson.Field
+	raw         string
+	ExtraFields map[string]apijson.Field
+}
+
+func (r *ToolResult) UnmarshalJSON(data []byte) (err error) {
+	return apijson.UnmarshalRoot(data, r)
+}
+
+func (r toolResultJSON) RawJSON() string {
+	return r.raw
+}
+
+func (r ToolResult) implementsToolInvocationPartToolInvocation() {}
+
+type ToolResultState string
+
+const (
+	ToolResultStateResult ToolResultState = "result"
+)
+
+func (r ToolResultState) IsKnown() bool {
+	switch r {
+	case ToolResultStateResult:
+		return true
+	}
+	return false
+}
+
+type ToolResultParam struct {
+	Result     param.Field[string]          `json:"result,required"`
+	State      param.Field[ToolResultState] `json:"state,required"`
+	ToolCallID param.Field[string]          `json:"toolCallId,required"`
+	ToolName   param.Field[string]          `json:"toolName,required"`
+	Args       param.Field[interface{}]     `json:"args"`
+	Step       param.Field[float64]         `json:"step"`
+}
+
+func (r ToolResultParam) MarshalJSON() (data []byte, err error) {
+	return apijson.MarshalRoot(r)
+}
+
+func (r ToolResultParam) implementsToolInvocationPartToolInvocationUnionParam() {}
+
+type SessionChatParams struct {
+	ModelID    param.Field[string]                  `json:"modelID,required"`
+	Parts      param.Field[[]MessagePartUnionParam] `json:"parts,required"`
+	ProviderID param.Field[string]                  `json:"providerID,required"`
+}
+
+func (r SessionChatParams) MarshalJSON() (data []byte, err error) {
+	return apijson.MarshalRoot(r)
+}
+
+type SessionInitParams struct {
+	ModelID    param.Field[string] `json:"modelID,required"`
+	ProviderID param.Field[string] `json:"providerID,required"`
+}
+
+func (r SessionInitParams) MarshalJSON() (data []byte, err error) {
+	return apijson.MarshalRoot(r)
+}
+
+type SessionSummarizeParams struct {
+	ModelID    param.Field[string] `json:"modelID,required"`
+	ProviderID param.Field[string] `json:"providerID,required"`
+}
+
+func (r SessionSummarizeParams) MarshalJSON() (data []byte, err error) {
+	return apijson.MarshalRoot(r)
+}