mirror of
https://github.com/sst/opencode.git
synced 2025-07-07 16:14:59 +00:00
1385 lines
41 KiB
Go
1385 lines
41 KiB
Go
// 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)
|
|
}
|