Refactor to support multiple instances inside single opencode process (#2360)

This release has a bunch of minor breaking changes if you are using opencode plugins or sdk 1. storage events have been removed (we might bring this back but had some issues) 2. concept of `app` is gone - there is a new concept called `project` and endpoints to list projects and get the current project 3. plugin receives `directory` which is cwd and `worktree` which is where the root of the project is if it's a git repo 4. the session.chat function has been renamed to session.prompt in sdk. it no longer requires model to be passed in (model is now an object) 5. every endpoint takes an optional `directory` parameter to operate as though opencode is running in that directory
2025-12-20 01:04:22 +01:00 · 2025-09-01 17:15:49 -04:00
parent e2df3eb44d
commit f993541e0b
112 changed files with 4303 additions and 3159 deletions
--- a/packages/sdk/go/session.go
+++ b/packages/sdk/go/session.go
@@ -7,9 +7,11 @@ import (
 	"errors"
 	"fmt"
 	"net/http"
+	"net/url"
 	"reflect"

 	"github.com/sst/opencode-sdk-go/internal/apijson"
+	"github.com/sst/opencode-sdk-go/internal/apiquery"
 	"github.com/sst/opencode-sdk-go/internal/param"
 	"github.com/sst/opencode-sdk-go/internal/requestconfig"
 	"github.com/sst/opencode-sdk-go/option"
@@ -39,119 +41,107 @@ func NewSessionService(opts ...option.RequestOption) (r *SessionService) {
 }

 // Create a new session
-func (r *SessionService) New(ctx context.Context, body SessionNewParams, opts ...option.RequestOption) (res *Session, err error) {
+func (r *SessionService) New(ctx context.Context, params SessionNewParams, opts ...option.RequestOption) (res *Session, err error) {
 	opts = append(r.Options[:], opts...)
 	path := "session"
-	err = requestconfig.ExecuteNewRequest(ctx, http.MethodPost, path, body, &res, opts...)
+	err = requestconfig.ExecuteNewRequest(ctx, http.MethodPost, path, params, &res, opts...)
 	return
 }

 // Update session properties
-func (r *SessionService) Update(ctx context.Context, id string, body SessionUpdateParams, opts ...option.RequestOption) (res *Session, err error) {
+func (r *SessionService) Update(ctx context.Context, id string, params SessionUpdateParams, 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", id)
-	err = requestconfig.ExecuteNewRequest(ctx, http.MethodPatch, path, body, &res, opts...)
+	err = requestconfig.ExecuteNewRequest(ctx, http.MethodPatch, path, params, &res, opts...)
 	return
 }

 // List all sessions
-func (r *SessionService) List(ctx context.Context, opts ...option.RequestOption) (res *[]Session, err error) {
+func (r *SessionService) List(ctx context.Context, query SessionListParams, opts ...option.RequestOption) (res *[]Session, err error) {
 	opts = append(r.Options[:], opts...)
 	path := "session"
-	err = requestconfig.ExecuteNewRequest(ctx, http.MethodGet, path, nil, &res, opts...)
+	err = requestconfig.ExecuteNewRequest(ctx, http.MethodGet, path, query, &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) {
+func (r *SessionService) Delete(ctx context.Context, id string, body SessionDeleteParams, 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...)
+	err = requestconfig.ExecuteNewRequest(ctx, http.MethodDelete, path, body, &res, opts...)
 	return
 }

 // Abort a session
-func (r *SessionService) Abort(ctx context.Context, id string, opts ...option.RequestOption) (res *bool, err error) {
+func (r *SessionService) Abort(ctx context.Context, id string, body SessionAbortParams, 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 *SessionChatResponse, 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
 }

 // Get a session's children
-func (r *SessionService) Children(ctx context.Context, id string, opts ...option.RequestOption) (res *[]Session, err error) {
+func (r *SessionService) Children(ctx context.Context, id string, query SessionChildrenParams, 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/children", id)
-	err = requestconfig.ExecuteNewRequest(ctx, http.MethodGet, path, nil, &res, opts...)
+	err = requestconfig.ExecuteNewRequest(ctx, http.MethodGet, path, query, &res, opts...)
 	return
 }

 // Send a new command to a session
-func (r *SessionService) Command(ctx context.Context, id string, body SessionCommandParams, opts ...option.RequestOption) (res *SessionCommandResponse, err error) {
+func (r *SessionService) Command(ctx context.Context, id string, params SessionCommandParams, opts ...option.RequestOption) (res *SessionCommandResponse, err error) {
 	opts = append(r.Options[:], opts...)
 	if id == "" {
 		err = errors.New("missing required id parameter")
 		return
 	}
 	path := fmt.Sprintf("session/%s/command", id)
-	err = requestconfig.ExecuteNewRequest(ctx, http.MethodPost, path, body, &res, opts...)
+	err = requestconfig.ExecuteNewRequest(ctx, http.MethodPost, path, params, &res, opts...)
 	return
 }

 // Get session
-func (r *SessionService) Get(ctx context.Context, id string, opts ...option.RequestOption) (res *Session, err error) {
+func (r *SessionService) Get(ctx context.Context, id string, query SessionGetParams, 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", id)
-	err = requestconfig.ExecuteNewRequest(ctx, http.MethodGet, path, nil, &res, opts...)
+	err = requestconfig.ExecuteNewRequest(ctx, http.MethodGet, path, query, &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) {
+func (r *SessionService) Init(ctx context.Context, id string, params 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...)
+	err = requestconfig.ExecuteNewRequest(ctx, http.MethodPost, path, params, &res, opts...)
 	return
 }

 // Get a message from a session
-func (r *SessionService) Message(ctx context.Context, id string, messageID string, opts ...option.RequestOption) (res *SessionMessageResponse, err error) {
+func (r *SessionService) Message(ctx context.Context, id string, messageID string, query SessionMessageParams, opts ...option.RequestOption) (res *SessionMessageResponse, err error) {
 	opts = append(r.Options[:], opts...)
 	if id == "" {
 		err = errors.New("missing required id parameter")
@@ -162,91 +152,103 @@ func (r *SessionService) Message(ctx context.Context, id string, messageID strin
 		return
 	}
 	path := fmt.Sprintf("session/%s/message/%s", id, messageID)
-	err = requestconfig.ExecuteNewRequest(ctx, http.MethodGet, path, nil, &res, opts...)
+	err = requestconfig.ExecuteNewRequest(ctx, http.MethodGet, path, query, &res, opts...)
 	return
 }

 // List messages for a session
-func (r *SessionService) Messages(ctx context.Context, id string, opts ...option.RequestOption) (res *[]SessionMessagesResponse, err error) {
+func (r *SessionService) Messages(ctx context.Context, id string, query SessionMessagesParams, opts ...option.RequestOption) (res *[]SessionMessagesResponse, 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...)
+	err = requestconfig.ExecuteNewRequest(ctx, http.MethodGet, path, query, &res, opts...)
+	return
+}
+
+// Create and send a new message to a session
+func (r *SessionService) Prompt(ctx context.Context, id string, params SessionPromptParams, opts ...option.RequestOption) (res *SessionPromptResponse, 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, params, &res, opts...)
 	return
 }

 // Revert a message
-func (r *SessionService) Revert(ctx context.Context, id string, body SessionRevertParams, opts ...option.RequestOption) (res *Session, err error) {
+func (r *SessionService) Revert(ctx context.Context, id string, params SessionRevertParams, 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/revert", id)
-	err = requestconfig.ExecuteNewRequest(ctx, http.MethodPost, path, body, &res, opts...)
+	err = requestconfig.ExecuteNewRequest(ctx, http.MethodPost, path, params, &res, opts...)
 	return
 }

 // Share a session
-func (r *SessionService) Share(ctx context.Context, id string, opts ...option.RequestOption) (res *Session, err error) {
+func (r *SessionService) Share(ctx context.Context, id string, body SessionShareParams, 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...)
+	err = requestconfig.ExecuteNewRequest(ctx, http.MethodPost, path, body, &res, opts...)
 	return
 }

 // Run a shell command
-func (r *SessionService) Shell(ctx context.Context, id string, body SessionShellParams, opts ...option.RequestOption) (res *AssistantMessage, err error) {
+func (r *SessionService) Shell(ctx context.Context, id string, params SessionShellParams, opts ...option.RequestOption) (res *AssistantMessage, err error) {
 	opts = append(r.Options[:], opts...)
 	if id == "" {
 		err = errors.New("missing required id parameter")
 		return
 	}
 	path := fmt.Sprintf("session/%s/shell", id)
-	err = requestconfig.ExecuteNewRequest(ctx, http.MethodPost, path, body, &res, opts...)
+	err = requestconfig.ExecuteNewRequest(ctx, http.MethodPost, path, params, &res, opts...)
 	return
 }

 // Summarize the session
-func (r *SessionService) Summarize(ctx context.Context, id string, body SessionSummarizeParams, opts ...option.RequestOption) (res *bool, err error) {
+func (r *SessionService) Summarize(ctx context.Context, id string, params 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...)
+	err = requestconfig.ExecuteNewRequest(ctx, http.MethodPost, path, params, &res, opts...)
 	return
 }

 // Restore all reverted messages
-func (r *SessionService) Unrevert(ctx context.Context, id string, opts ...option.RequestOption) (res *Session, err error) {
+func (r *SessionService) Unrevert(ctx context.Context, id string, body SessionUnrevertParams, 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/unrevert", id)
-	err = requestconfig.ExecuteNewRequest(ctx, http.MethodPost, path, nil, &res, opts...)
+	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) {
+func (r *SessionService) Unshare(ctx context.Context, id string, body SessionUnshareParams, 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...)
+	err = requestconfig.ExecuteNewRequest(ctx, http.MethodDelete, path, body, &res, opts...)
 	return
 }

@@ -331,7 +333,7 @@ func (r AgentPartInputParam) MarshalJSON() (data []byte, err error) {
 	return apijson.MarshalRoot(r)
 }

-func (r AgentPartInputParam) implementsSessionChatParamsPartUnion() {}
+func (r AgentPartInputParam) implementsSessionPromptParamsPartUnion() {}

 type AgentPartInputType string

@@ -707,7 +709,7 @@ func (r FilePartInputParam) MarshalJSON() (data []byte, err error) {
 	return apijson.MarshalRoot(r)
 }

-func (r FilePartInputParam) implementsSessionChatParamsPartUnion() {}
+func (r FilePartInputParam) implementsSessionPromptParamsPartUnion() {}

 type FilePartInputType string

@@ -1294,19 +1296,23 @@ func (r ReasoningPartType) IsKnown() bool {
 }

 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:"-"`
+	ID        string        `json:"id,required"`
+	Directory string        `json:"directory,required"`
+	ProjectID string        `json:"projectID,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
+	Directory   apijson.Field
+	ProjectID   apijson.Field
 	Time        apijson.Field
 	Title       apijson.Field
 	Version     apijson.Field
@@ -1814,7 +1820,7 @@ func (r TextPartInputParam) MarshalJSON() (data []byte, err error) {
 	return apijson.MarshalRoot(r)
 }

-func (r TextPartInputParam) implementsSessionChatParamsPartUnion() {}
+func (r TextPartInputParam) implementsSessionPromptParamsPartUnion() {}

 type TextPartInputType string

@@ -2290,29 +2296,6 @@ func (r userMessageTimeJSON) RawJSON() string {
 	return r.raw
 }

-type SessionChatResponse struct {
-	Info  AssistantMessage        `json:"info,required"`
-	Parts []Part                  `json:"parts,required"`
-	JSON  sessionChatResponseJSON `json:"-"`
-}
-
-// sessionChatResponseJSON contains the JSON metadata for the struct
-// [SessionChatResponse]
-type sessionChatResponseJSON struct {
-	Info        apijson.Field
-	Parts       apijson.Field
-	raw         string
-	ExtraFields map[string]apijson.Field
-}
-
-func (r *SessionChatResponse) UnmarshalJSON(data []byte) (err error) {
-	return apijson.UnmarshalRoot(data, r)
-}
-
-func (r sessionChatResponseJSON) RawJSON() string {
-	return r.raw
-}
-
 type SessionCommandResponse struct {
 	Info  AssistantMessage           `json:"info,required"`
 	Parts []Part                     `json:"parts,required"`
@@ -2382,81 +2365,116 @@ func (r sessionMessagesResponseJSON) RawJSON() string {
 	return r.raw
 }

+type SessionPromptResponse struct {
+	Info  AssistantMessage          `json:"info,required"`
+	Parts []Part                    `json:"parts,required"`
+	JSON  sessionPromptResponseJSON `json:"-"`
+}
+
+// sessionPromptResponseJSON contains the JSON metadata for the struct
+// [SessionPromptResponse]
+type sessionPromptResponseJSON struct {
+	Info        apijson.Field
+	Parts       apijson.Field
+	raw         string
+	ExtraFields map[string]apijson.Field
+}
+
+func (r *SessionPromptResponse) UnmarshalJSON(data []byte) (err error) {
+	return apijson.UnmarshalRoot(data, r)
+}
+
+func (r sessionPromptResponseJSON) RawJSON() string {
+	return r.raw
+}
+
 type SessionNewParams struct {
-	ParentID param.Field[string] `json:"parentID"`
-	Title    param.Field[string] `json:"title"`
+	Directory param.Field[string] `query:"directory"`
+	ParentID  param.Field[string] `json:"parentID"`
+	Title     param.Field[string] `json:"title"`
 }

 func (r SessionNewParams) MarshalJSON() (data []byte, err error) {
 	return apijson.MarshalRoot(r)
 }

+// URLQuery serializes [SessionNewParams]'s query parameters as `url.Values`.
+func (r SessionNewParams) URLQuery() (v url.Values) {
+	return apiquery.MarshalWithSettings(r, apiquery.QuerySettings{
+		ArrayFormat:  apiquery.ArrayQueryFormatComma,
+		NestedFormat: apiquery.NestedQueryFormatBrackets,
+	})
+}
+
 type SessionUpdateParams struct {
-	Title param.Field[string] `json:"title"`
+	Directory param.Field[string] `query:"directory"`
+	Title     param.Field[string] `json:"title"`
 }

 func (r SessionUpdateParams) MarshalJSON() (data []byte, err error) {
 	return apijson.MarshalRoot(r)
 }

-type SessionChatParams struct {
-	ModelID    param.Field[string]                       `json:"modelID,required"`
-	Parts      param.Field[[]SessionChatParamsPartUnion] `json:"parts,required"`
-	ProviderID param.Field[string]                       `json:"providerID,required"`
-	Agent      param.Field[string]                       `json:"agent"`
-	MessageID  param.Field[string]                       `json:"messageID"`
-	System     param.Field[string]                       `json:"system"`
-	Tools      param.Field[map[string]bool]              `json:"tools"`
+// URLQuery serializes [SessionUpdateParams]'s query parameters as `url.Values`.
+func (r SessionUpdateParams) URLQuery() (v url.Values) {
+	return apiquery.MarshalWithSettings(r, apiquery.QuerySettings{
+		ArrayFormat:  apiquery.ArrayQueryFormatComma,
+		NestedFormat: apiquery.NestedQueryFormatBrackets,
+	})
 }

-func (r SessionChatParams) MarshalJSON() (data []byte, err error) {
-	return apijson.MarshalRoot(r)
+type SessionListParams struct {
+	Directory param.Field[string] `query:"directory"`
 }

-type SessionChatParamsPart struct {
-	Type      param.Field[SessionChatParamsPartsType] `json:"type,required"`
-	ID        param.Field[string]                     `json:"id"`
-	Filename  param.Field[string]                     `json:"filename"`
-	Mime      param.Field[string]                     `json:"mime"`
-	Name      param.Field[string]                     `json:"name"`
-	Source    param.Field[interface{}]                `json:"source"`
-	Synthetic param.Field[bool]                       `json:"synthetic"`
-	Text      param.Field[string]                     `json:"text"`
-	Time      param.Field[interface{}]                `json:"time"`
-	URL       param.Field[string]                     `json:"url"`
+// URLQuery serializes [SessionListParams]'s query parameters as `url.Values`.
+func (r SessionListParams) URLQuery() (v url.Values) {
+	return apiquery.MarshalWithSettings(r, apiquery.QuerySettings{
+		ArrayFormat:  apiquery.ArrayQueryFormatComma,
+		NestedFormat: apiquery.NestedQueryFormatBrackets,
+	})
 }

-func (r SessionChatParamsPart) MarshalJSON() (data []byte, err error) {
-	return apijson.MarshalRoot(r)
+type SessionDeleteParams struct {
+	Directory param.Field[string] `query:"directory"`
 }

-func (r SessionChatParamsPart) implementsSessionChatParamsPartUnion() {}
-
-// Satisfied by [TextPartInputParam], [FilePartInputParam], [AgentPartInputParam],
-// [SessionChatParamsPart].
-type SessionChatParamsPartUnion interface {
-	implementsSessionChatParamsPartUnion()
+// URLQuery serializes [SessionDeleteParams]'s query parameters as `url.Values`.
+func (r SessionDeleteParams) URLQuery() (v url.Values) {
+	return apiquery.MarshalWithSettings(r, apiquery.QuerySettings{
+		ArrayFormat:  apiquery.ArrayQueryFormatComma,
+		NestedFormat: apiquery.NestedQueryFormatBrackets,
+	})
 }

-type SessionChatParamsPartsType string
+type SessionAbortParams struct {
+	Directory param.Field[string] `query:"directory"`
+}

-const (
-	SessionChatParamsPartsTypeText  SessionChatParamsPartsType = "text"
-	SessionChatParamsPartsTypeFile  SessionChatParamsPartsType = "file"
-	SessionChatParamsPartsTypeAgent SessionChatParamsPartsType = "agent"
-)
+// URLQuery serializes [SessionAbortParams]'s query parameters as `url.Values`.
+func (r SessionAbortParams) URLQuery() (v url.Values) {
+	return apiquery.MarshalWithSettings(r, apiquery.QuerySettings{
+		ArrayFormat:  apiquery.ArrayQueryFormatComma,
+		NestedFormat: apiquery.NestedQueryFormatBrackets,
+	})
+}

-func (r SessionChatParamsPartsType) IsKnown() bool {
-	switch r {
-	case SessionChatParamsPartsTypeText, SessionChatParamsPartsTypeFile, SessionChatParamsPartsTypeAgent:
-		return true
-	}
-	return false
+type SessionChildrenParams struct {
+	Directory param.Field[string] `query:"directory"`
+}
+
+// URLQuery serializes [SessionChildrenParams]'s query parameters as `url.Values`.
+func (r SessionChildrenParams) URLQuery() (v url.Values) {
+	return apiquery.MarshalWithSettings(r, apiquery.QuerySettings{
+		ArrayFormat:  apiquery.ArrayQueryFormatComma,
+		NestedFormat: apiquery.NestedQueryFormatBrackets,
+	})
 }

 type SessionCommandParams struct {
 	Arguments param.Field[string] `json:"arguments,required"`
 	Command   param.Field[string] `json:"command,required"`
+	Directory param.Field[string] `query:"directory"`
 	Agent     param.Field[string] `json:"agent"`
 	MessageID param.Field[string] `json:"messageID"`
 	Model     param.Field[string] `json:"model"`
@@ -2466,18 +2484,144 @@ func (r SessionCommandParams) MarshalJSON() (data []byte, err error) {
 	return apijson.MarshalRoot(r)
 }

+// URLQuery serializes [SessionCommandParams]'s query parameters as `url.Values`.
+func (r SessionCommandParams) URLQuery() (v url.Values) {
+	return apiquery.MarshalWithSettings(r, apiquery.QuerySettings{
+		ArrayFormat:  apiquery.ArrayQueryFormatComma,
+		NestedFormat: apiquery.NestedQueryFormatBrackets,
+	})
+}
+
+type SessionGetParams struct {
+	Directory param.Field[string] `query:"directory"`
+}
+
+// URLQuery serializes [SessionGetParams]'s query parameters as `url.Values`.
+func (r SessionGetParams) URLQuery() (v url.Values) {
+	return apiquery.MarshalWithSettings(r, apiquery.QuerySettings{
+		ArrayFormat:  apiquery.ArrayQueryFormatComma,
+		NestedFormat: apiquery.NestedQueryFormatBrackets,
+	})
+}
+
 type SessionInitParams struct {
 	MessageID  param.Field[string] `json:"messageID,required"`
 	ModelID    param.Field[string] `json:"modelID,required"`
 	ProviderID param.Field[string] `json:"providerID,required"`
+	Directory  param.Field[string] `query:"directory"`
 }

 func (r SessionInitParams) MarshalJSON() (data []byte, err error) {
 	return apijson.MarshalRoot(r)
 }

+// URLQuery serializes [SessionInitParams]'s query parameters as `url.Values`.
+func (r SessionInitParams) URLQuery() (v url.Values) {
+	return apiquery.MarshalWithSettings(r, apiquery.QuerySettings{
+		ArrayFormat:  apiquery.ArrayQueryFormatComma,
+		NestedFormat: apiquery.NestedQueryFormatBrackets,
+	})
+}
+
+type SessionMessageParams struct {
+	Directory param.Field[string] `query:"directory"`
+}
+
+// URLQuery serializes [SessionMessageParams]'s query parameters as `url.Values`.
+func (r SessionMessageParams) URLQuery() (v url.Values) {
+	return apiquery.MarshalWithSettings(r, apiquery.QuerySettings{
+		ArrayFormat:  apiquery.ArrayQueryFormatComma,
+		NestedFormat: apiquery.NestedQueryFormatBrackets,
+	})
+}
+
+type SessionMessagesParams struct {
+	Directory param.Field[string] `query:"directory"`
+}
+
+// URLQuery serializes [SessionMessagesParams]'s query parameters as `url.Values`.
+func (r SessionMessagesParams) URLQuery() (v url.Values) {
+	return apiquery.MarshalWithSettings(r, apiquery.QuerySettings{
+		ArrayFormat:  apiquery.ArrayQueryFormatComma,
+		NestedFormat: apiquery.NestedQueryFormatBrackets,
+	})
+}
+
+type SessionPromptParams struct {
+	Parts     param.Field[[]SessionPromptParamsPartUnion] `json:"parts,required"`
+	Directory param.Field[string]                         `query:"directory"`
+	Agent     param.Field[string]                         `json:"agent"`
+	MessageID param.Field[string]                         `json:"messageID"`
+	Model     param.Field[SessionPromptParamsModel]       `json:"model"`
+	System    param.Field[string]                         `json:"system"`
+	Tools     param.Field[map[string]bool]                `json:"tools"`
+}
+
+func (r SessionPromptParams) MarshalJSON() (data []byte, err error) {
+	return apijson.MarshalRoot(r)
+}
+
+// URLQuery serializes [SessionPromptParams]'s query parameters as `url.Values`.
+func (r SessionPromptParams) URLQuery() (v url.Values) {
+	return apiquery.MarshalWithSettings(r, apiquery.QuerySettings{
+		ArrayFormat:  apiquery.ArrayQueryFormatComma,
+		NestedFormat: apiquery.NestedQueryFormatBrackets,
+	})
+}
+
+type SessionPromptParamsPart struct {
+	Type      param.Field[SessionPromptParamsPartsType] `json:"type,required"`
+	ID        param.Field[string]                       `json:"id"`
+	Filename  param.Field[string]                       `json:"filename"`
+	Mime      param.Field[string]                       `json:"mime"`
+	Name      param.Field[string]                       `json:"name"`
+	Source    param.Field[interface{}]                  `json:"source"`
+	Synthetic param.Field[bool]                         `json:"synthetic"`
+	Text      param.Field[string]                       `json:"text"`
+	Time      param.Field[interface{}]                  `json:"time"`
+	URL       param.Field[string]                       `json:"url"`
+}
+
+func (r SessionPromptParamsPart) MarshalJSON() (data []byte, err error) {
+	return apijson.MarshalRoot(r)
+}
+
+func (r SessionPromptParamsPart) implementsSessionPromptParamsPartUnion() {}
+
+// Satisfied by [TextPartInputParam], [FilePartInputParam], [AgentPartInputParam],
+// [SessionPromptParamsPart].
+type SessionPromptParamsPartUnion interface {
+	implementsSessionPromptParamsPartUnion()
+}
+
+type SessionPromptParamsPartsType string
+
+const (
+	SessionPromptParamsPartsTypeText  SessionPromptParamsPartsType = "text"
+	SessionPromptParamsPartsTypeFile  SessionPromptParamsPartsType = "file"
+	SessionPromptParamsPartsTypeAgent SessionPromptParamsPartsType = "agent"
+)
+
+func (r SessionPromptParamsPartsType) IsKnown() bool {
+	switch r {
+	case SessionPromptParamsPartsTypeText, SessionPromptParamsPartsTypeFile, SessionPromptParamsPartsTypeAgent:
+		return true
+	}
+	return false
+}
+
+type SessionPromptParamsModel struct {
+	ModelID    param.Field[string] `json:"modelID,required"`
+	ProviderID param.Field[string] `json:"providerID,required"`
+}
+
+func (r SessionPromptParamsModel) MarshalJSON() (data []byte, err error) {
+	return apijson.MarshalRoot(r)
+}
+
 type SessionRevertParams struct {
 	MessageID param.Field[string] `json:"messageID,required"`
+	Directory param.Field[string] `query:"directory"`
 	PartID    param.Field[string] `json:"partID"`
 }

@@ -2485,20 +2629,82 @@ func (r SessionRevertParams) MarshalJSON() (data []byte, err error) {
 	return apijson.MarshalRoot(r)
 }

+// URLQuery serializes [SessionRevertParams]'s query parameters as `url.Values`.
+func (r SessionRevertParams) URLQuery() (v url.Values) {
+	return apiquery.MarshalWithSettings(r, apiquery.QuerySettings{
+		ArrayFormat:  apiquery.ArrayQueryFormatComma,
+		NestedFormat: apiquery.NestedQueryFormatBrackets,
+	})
+}
+
+type SessionShareParams struct {
+	Directory param.Field[string] `query:"directory"`
+}
+
+// URLQuery serializes [SessionShareParams]'s query parameters as `url.Values`.
+func (r SessionShareParams) URLQuery() (v url.Values) {
+	return apiquery.MarshalWithSettings(r, apiquery.QuerySettings{
+		ArrayFormat:  apiquery.ArrayQueryFormatComma,
+		NestedFormat: apiquery.NestedQueryFormatBrackets,
+	})
+}
+
 type SessionShellParams struct {
-	Agent   param.Field[string] `json:"agent,required"`
-	Command param.Field[string] `json:"command,required"`
+	Agent     param.Field[string] `json:"agent,required"`
+	Command   param.Field[string] `json:"command,required"`
+	Directory param.Field[string] `query:"directory"`
 }

 func (r SessionShellParams) MarshalJSON() (data []byte, err error) {
 	return apijson.MarshalRoot(r)
 }

+// URLQuery serializes [SessionShellParams]'s query parameters as `url.Values`.
+func (r SessionShellParams) URLQuery() (v url.Values) {
+	return apiquery.MarshalWithSettings(r, apiquery.QuerySettings{
+		ArrayFormat:  apiquery.ArrayQueryFormatComma,
+		NestedFormat: apiquery.NestedQueryFormatBrackets,
+	})
+}
+
 type SessionSummarizeParams struct {
 	ModelID    param.Field[string] `json:"modelID,required"`
 	ProviderID param.Field[string] `json:"providerID,required"`
+	Directory  param.Field[string] `query:"directory"`
 }

 func (r SessionSummarizeParams) MarshalJSON() (data []byte, err error) {
 	return apijson.MarshalRoot(r)
 }
+
+// URLQuery serializes [SessionSummarizeParams]'s query parameters as `url.Values`.
+func (r SessionSummarizeParams) URLQuery() (v url.Values) {
+	return apiquery.MarshalWithSettings(r, apiquery.QuerySettings{
+		ArrayFormat:  apiquery.ArrayQueryFormatComma,
+		NestedFormat: apiquery.NestedQueryFormatBrackets,
+	})
+}
+
+type SessionUnrevertParams struct {
+	Directory param.Field[string] `query:"directory"`
+}
+
+// URLQuery serializes [SessionUnrevertParams]'s query parameters as `url.Values`.
+func (r SessionUnrevertParams) URLQuery() (v url.Values) {
+	return apiquery.MarshalWithSettings(r, apiquery.QuerySettings{
+		ArrayFormat:  apiquery.ArrayQueryFormatComma,
+		NestedFormat: apiquery.NestedQueryFormatBrackets,
+	})
+}
+
+type SessionUnshareParams struct {
+	Directory param.Field[string] `query:"directory"`
+}
+
+// URLQuery serializes [SessionUnshareParams]'s query parameters as `url.Values`.
+func (r SessionUnshareParams) URLQuery() (v url.Values) {
+	return apiquery.MarshalWithSettings(r, apiquery.QuerySettings{
+		ArrayFormat:  apiquery.ArrayQueryFormatComma,
+		NestedFormat: apiquery.NestedQueryFormatBrackets,
+	})
+}