- the composer shows a context ring and percentage from the last token-bearing assistant message, toned at 75% and 90%; tapping opens a sheet with the model, used tokens, limits, output reserve and turn cost - images a tool call names (read attachments as data URLs, input paths, and image paths in output text) get a link under the tool row; tapping previews it from the data URL or /api/fs/raw, allowing paths outside the workspace - directory-scoped requests now send x-opencode-directory-encoding: uri, which scoped routes such as /api/fs/raw need to decode the header - ocprobe gains a raw file command for checking previews Bump version to 0.2.2 (build 16).
317 lines
9.3 KiB
Go
317 lines
9.3 KiB
Go
package ocapi
|
|
|
|
import (
|
|
"context"
|
|
"encoding/json"
|
|
"net/http"
|
|
"net/url"
|
|
"strconv"
|
|
)
|
|
|
|
// ListSessionsOptions configures ListSessions.
|
|
type ListSessionsOptions struct {
|
|
// Directory scopes the list to one absolute path. Empty means all
|
|
// projects (each Session carries its own Location).
|
|
Directory string
|
|
Limit int
|
|
Cursor string
|
|
Order string // "asc" or "desc"
|
|
Search string
|
|
ParentID string
|
|
Archived *bool
|
|
}
|
|
|
|
// ListSessions lists sessions, newest first by default.
|
|
func (c *Client) ListSessions(ctx context.Context, o ListSessionsOptions) (SessionPage, error) {
|
|
q := url.Values{}
|
|
if o.Limit > 0 {
|
|
q.Set("limit", strconv.Itoa(o.Limit))
|
|
}
|
|
if o.Directory != "" {
|
|
q.Set("directory", o.Directory)
|
|
}
|
|
if o.Cursor != "" {
|
|
q.Set("cursor", o.Cursor)
|
|
}
|
|
if o.Order != "" {
|
|
q.Set("order", o.Order)
|
|
}
|
|
if o.Search != "" {
|
|
q.Set("search", o.Search)
|
|
}
|
|
if o.ParentID != "" {
|
|
q.Set("parentID", o.ParentID)
|
|
}
|
|
if o.Archived != nil {
|
|
q.Set("archived", strconv.FormatBool(*o.Archived))
|
|
}
|
|
var page SessionPage
|
|
err := c.do(ctx, http.MethodGet, "/api/session", requestOptions{directory: o.Directory, query: q}, nil, &page)
|
|
return page, err
|
|
}
|
|
|
|
// ActiveSessions returns the sessions running right now, keyed by id.
|
|
func (c *Client) ActiveSessions(ctx context.Context) (map[string]string, error) {
|
|
var payload struct {
|
|
Data map[string]struct {
|
|
Type string `json:"type"`
|
|
} `json:"data"`
|
|
}
|
|
if err := c.do(ctx, http.MethodGet, "/api/session/active", requestOptions{}, nil, &payload); err != nil {
|
|
return nil, err
|
|
}
|
|
out := make(map[string]string, len(payload.Data))
|
|
for id, v := range payload.Data {
|
|
out[id] = v.Type
|
|
}
|
|
return out, nil
|
|
}
|
|
|
|
// GetSession reads one session.
|
|
func (c *Client) GetSession(ctx context.Context, id, directory string) (Session, error) {
|
|
var payload struct {
|
|
Data Session `json:"data"`
|
|
}
|
|
err := c.do(ctx, http.MethodGet, "/api/session/"+url.PathEscape(id), requestOptions{directory: directory}, nil, &payload)
|
|
return payload.Data, err
|
|
}
|
|
|
|
// CreateSessionOptions configures CreateSession.
|
|
type CreateSessionOptions struct {
|
|
Directory string
|
|
Title string
|
|
Agent string
|
|
Model *ModelRef
|
|
}
|
|
|
|
// CreateSession makes a new session, optionally in a directory.
|
|
func (c *Client) CreateSession(ctx context.Context, o CreateSessionOptions) (Session, error) {
|
|
body := map[string]any{}
|
|
if o.Title != "" {
|
|
body["title"] = o.Title
|
|
}
|
|
if o.Agent != "" {
|
|
body["agent"] = o.Agent
|
|
}
|
|
if o.Model != nil {
|
|
body["model"] = o.Model
|
|
}
|
|
if o.Directory != "" {
|
|
body["location"] = map[string]string{"directory": o.Directory}
|
|
}
|
|
var payload struct {
|
|
Data Session `json:"data"`
|
|
}
|
|
err := c.do(ctx, http.MethodPost, "/api/session", requestOptions{directory: o.Directory}, body, &payload)
|
|
return payload.Data, err
|
|
}
|
|
|
|
// SessionPatch is PATCH /api/session/{id}: both fields are optional.
|
|
type SessionPatch struct {
|
|
Title *string `json:"title,omitempty"`
|
|
Archived *bool `json:"archived,omitempty"`
|
|
}
|
|
|
|
// UpdateSession renames or archives one session.
|
|
func (c *Client) UpdateSession(ctx context.Context, id, directory string, patch SessionPatch) error {
|
|
return c.do(ctx, http.MethodPatch, "/api/session/"+url.PathEscape(id), requestOptions{directory: directory}, patch, nil)
|
|
}
|
|
|
|
// DeleteSession removes a session and its children.
|
|
func (c *Client) DeleteSession(ctx context.Context, id, directory string) error {
|
|
return c.do(ctx, http.MethodDelete, "/api/session/"+url.PathEscape(id), requestOptions{directory: directory}, nil, nil)
|
|
}
|
|
|
|
// ListMessagesOptions configures ListMessages.
|
|
type ListMessagesOptions struct {
|
|
Directory string
|
|
Limit int
|
|
Cursor string
|
|
Order string // "asc" or "desc"
|
|
// PartShells asks OpenChamber to leave finished tool results out of the
|
|
// page, which is most of a long session's bytes. Fetch the message with
|
|
// GetMessage when a row expands.
|
|
PartShells bool
|
|
}
|
|
|
|
// ListMessages reads one page of a session's messages. Newest first by
|
|
// default, which is what a chat pages backwards with.
|
|
func (c *Client) ListMessages(ctx context.Context, id string, o ListMessagesOptions) (MessagePage, error) {
|
|
q := url.Values{}
|
|
if o.Limit > 0 {
|
|
q.Set("limit", strconv.Itoa(o.Limit))
|
|
}
|
|
if o.Cursor != "" {
|
|
q.Set("cursor", o.Cursor)
|
|
}
|
|
if o.Order != "" {
|
|
q.Set("order", o.Order)
|
|
}
|
|
req, err := c.newRequest(ctx, http.MethodGet, "/api/session/"+url.PathEscape(id)+"/message",
|
|
requestOptions{directory: o.Directory, query: q}, nil)
|
|
if err != nil {
|
|
return MessagePage{}, err
|
|
}
|
|
if o.PartShells {
|
|
req.Header.Set("x-openchamber-part-shells", "v1")
|
|
}
|
|
var page MessagePage
|
|
if err := c.send(req, &page); err != nil {
|
|
return MessagePage{}, err
|
|
}
|
|
return page, nil
|
|
}
|
|
|
|
// GetMessage reads one whole message, including tool results a shelled list
|
|
// page left out.
|
|
func (c *Client) GetMessage(ctx context.Context, sessionID, messageID, directory string) (Message, error) {
|
|
var msg Message
|
|
path := "/api/session/" + url.PathEscape(sessionID) + "/message/" + url.PathEscape(messageID)
|
|
err := c.do(ctx, http.MethodGet, path, requestOptions{directory: directory}, nil, &msg)
|
|
return msg, err
|
|
}
|
|
|
|
// ModelInfo is one model the server offers.
|
|
type ModelInfo struct {
|
|
ID string `json:"id"`
|
|
ProviderID string `json:"providerID"`
|
|
Name string `json:"name"`
|
|
Variant string `json:"variant"`
|
|
Limit struct {
|
|
Context int `json:"context"`
|
|
Output int `json:"output"`
|
|
} `json:"limit"`
|
|
}
|
|
|
|
// Models lists the models the server offers for a directory.
|
|
func (c *Client) Models(ctx context.Context, directory string) ([]ModelInfo, error) {
|
|
q := url.Values{}
|
|
if directory != "" {
|
|
q.Set("location[directory]", directory)
|
|
}
|
|
var payload struct {
|
|
Data []ModelInfo `json:"data"`
|
|
}
|
|
if err := c.do(ctx, http.MethodGet, "/api/model", requestOptions{query: q}, nil, &payload); err != nil {
|
|
return nil, err
|
|
}
|
|
return payload.Data, nil
|
|
}
|
|
|
|
// ProviderInfo is one provider the server offers, with its display name.
|
|
type ProviderInfo struct {
|
|
ID string `json:"id"`
|
|
Name string `json:"name"`
|
|
}
|
|
|
|
// Providers lists the providers available for a directory.
|
|
func (c *Client) Providers(ctx context.Context, directory string) ([]ProviderInfo, error) {
|
|
q := url.Values{}
|
|
if directory != "" {
|
|
q.Set("location[directory]", directory)
|
|
}
|
|
var payload struct {
|
|
Data []ProviderInfo `json:"data"`
|
|
}
|
|
if err := c.do(ctx, http.MethodGet, "/api/provider", requestOptions{query: q}, nil, &payload); err != nil {
|
|
return nil, err
|
|
}
|
|
return payload.Data, nil
|
|
}
|
|
|
|
// ServerLocation is the server's default working directory.
|
|
type ServerLocation struct {
|
|
Directory string `json:"directory"`
|
|
ProjectID string `json:"projectID"`
|
|
}
|
|
|
|
// Location reads the server's default location, which a new session uses
|
|
// when the user does not pick one.
|
|
func (c *Client) Location(ctx context.Context) (ServerLocation, error) {
|
|
var payload struct {
|
|
Directory string `json:"directory"`
|
|
Project struct {
|
|
ID string `json:"id"`
|
|
} `json:"project"`
|
|
}
|
|
if err := c.do(ctx, http.MethodGet, "/api/location", requestOptions{}, nil, &payload); err != nil {
|
|
return ServerLocation{}, err
|
|
}
|
|
return ServerLocation{Directory: payload.Directory, ProjectID: payload.Project.ID}, nil
|
|
}
|
|
|
|
// AgentInfo is one entry of GET /api/agent.
|
|
type AgentInfo struct {
|
|
ID string `json:"id"`
|
|
Name string `json:"name"`
|
|
Description string `json:"description"`
|
|
Mode string `json:"mode"`
|
|
Hidden bool `json:"hidden"`
|
|
}
|
|
|
|
// Agents lists the agents available for a directory.
|
|
func (c *Client) Agents(ctx context.Context, directory string) ([]AgentInfo, error) {
|
|
q := url.Values{}
|
|
if directory != "" {
|
|
q.Set("location[directory]", directory)
|
|
}
|
|
var payload struct {
|
|
Data []AgentInfo `json:"data"`
|
|
}
|
|
if err := c.do(ctx, http.MethodGet, "/api/agent", requestOptions{query: q}, nil, &payload); err != nil {
|
|
return nil, err
|
|
}
|
|
return payload.Data, nil
|
|
}
|
|
|
|
// PermissionRequest is a pending tool permission.
|
|
type PermissionRequest struct {
|
|
ID string `json:"id"`
|
|
SessionID string `json:"sessionID"`
|
|
Action string `json:"action"`
|
|
Resources []string `json:"resources"`
|
|
Message string `json:"message,omitempty"`
|
|
}
|
|
|
|
// PendingPermissions lists the pending permission requests for a directory.
|
|
func (c *Client) PendingPermissions(ctx context.Context, directory string) ([]PermissionRequest, error) {
|
|
q := url.Values{}
|
|
if directory != "" {
|
|
q.Set("location[directory]", directory)
|
|
}
|
|
var payload struct {
|
|
Data []PermissionRequest `json:"data"`
|
|
}
|
|
if err := c.do(ctx, http.MethodGet, "/api/permission/request", requestOptions{query: q}, nil, &payload); err != nil {
|
|
return nil, err
|
|
}
|
|
return payload.Data, nil
|
|
}
|
|
|
|
// PermissionDecision is how a permission request is answered.
|
|
type PermissionDecision string
|
|
|
|
const (
|
|
PermissionOnce PermissionDecision = "once"
|
|
PermissionAlways PermissionDecision = "always"
|
|
PermissionReject PermissionDecision = "reject"
|
|
)
|
|
|
|
// ReplyPermission answers a pending permission request.
|
|
func (c *Client) ReplyPermission(ctx context.Context, sessionID, requestID string, decision PermissionDecision, message string) error {
|
|
body := map[string]any{"decision": decision}
|
|
if message != "" {
|
|
body["message"] = message
|
|
}
|
|
path := "/api/session/" + url.PathEscape(sessionID) + "/permission/" + url.PathEscape(requestID) + "/reply"
|
|
return c.do(ctx, http.MethodPost, path, requestOptions{}, body, nil)
|
|
}
|
|
|
|
// EventData unmarshals an event's payload into v.
|
|
func (e Event) UnmarshalData(v any) error {
|
|
if len(e.Data) == 0 {
|
|
return nil
|
|
}
|
|
return json.Unmarshal(e.Data, v)
|
|
}
|