experimental

type ActivateServerOptions ¶

type ActivateServerOptions struct {
	Directory         string
	RequestedServerId *string
	SessionDir        string
	Provider          *string
	Model             *string
}

ActivateServerOptions selects a logical server and startup-only worker model. Nil requested identity uses the directory's persisted default identity.

type ActivatedClientRuntimeServer ¶

type ActivatedClientRuntimeServer struct {
	*ClientRuntimeServer
	Directory  services.SessionDirectory
	Management services.SessionManagement
	Plugins    services.PresentationPlugins
	Models     services.Models
	Agent      services.AgentController
	Transcript services.Transcript
}

ActivatedClientRuntimeServer holds the built-in service views used by a non-interactive presentation.

func ActivateBuiltinClientServices(_ context.Context, server *ClientRuntimeServer) (*ActivatedClientRuntimeServer, error)

type ActivatedServer ¶

type ActivatedServer struct {
	Client *client.Client
	Route  client.UnixServerRoute
}

ActivatedServer owns a connected client and the stable logical server route it reached.

func ActivateServer(ctx context.Context, options ActivateServerOptions) (activated *ActivatedServer, err error)

type AuthInput ¶

type AuthInput struct {
	Type  string
	Token string
	Path  string
}

AuthInput selects an explicit token or a token file. Nil selects stored credentials.

type BundleFacetPackageOptions ¶

type BundleFacetPackageOptions struct {
	PackagePath   string
	Outdir        string
	DefaultFacets []FacetEntrySource
}

BundleFacetPackageOptions selects a directory or package.json and application-provided conventional entries. Nil defaults select no conventional entries.

type BundleFacetPackageResult ¶

type BundleFacetPackageResult struct {
	BundleFacetsResult
	PackageDirectory string
	PackageJsonPath  string
}

BundleFacetPackageResult includes the canonical package paths used to read metadata and resolve entries.

func BundleFacetPackage(ctx context.Context, options BundleFacetPackageOptions) (BundleFacetPackageResult, error)

type BundleFacetsOptions ¶

type BundleFacetsOptions struct {
	Plugin           FacetBundlePlugin
	Entries          []FacetEntrySource
	Outdir           string
	WorkingDirectory *string
	External         []string
	SourceMap        bool
}

BundleFacetsOptions selects independent entries and their output directory. A nil plugin version stays omitted; SourceMap defaults to false. WorkingDirectory defaults to the current directory.

type BundleFacetsResult ¶

type BundleFacetsResult struct {
	Manifest     FacetBundleManifest
	ManifestPath string
}

BundleFacetsResult owns the manifest data and the absolute path of its installed manifest file.

func BundleFacets(_ context.Context, options BundleFacetsOptions) (result BundleFacetsResult, err error)

type CliContext ¶

type CliContext struct {
	RunServer func(context.Context, ServerCommand) error
	RunClient func(context.Context, ClientCommand) error
}

CliContext supplies the two awaited experimental command actions. Each action owns its work until it returns.

type ClientAttachedResult ¶

type ClientAttachedResult struct {
	ServerId  string `json:"serverId"`
	SessionId string `json:"sessionId"`
}

func (ClientAttachedResult) Kind() string

func (result ClientAttachedResult) MarshalJSON() ([]byte, error)

type ClientCommand ¶

type ClientCommand struct {
	Command        string
	Connect        *TransportAddress
	SessionId      *string
	Continue       *bool
	Resume         *bool
	Provider       *string
	Model          *string
	PluginPackages []string
	Prompt         *string
}

ClientCommand preserves absent selections as nil, including absent versus explicitly empty PluginPackages.

type ClientListResult ¶

type ClientListResult struct {
	Sessions []services.SessionAddress `json:"sessions"`
}

func (ClientListResult) Kind() string

func (result ClientListResult) MarshalJSON() ([]byte, error)

type ClientPromptedResult ¶

type ClientPromptedResult struct {
	ServerId  string `json:"serverId"`
	SessionId string `json:"sessionId"`
	Text      string `json:"text"`
}

func (ClientPromptedResult) Kind() string

func (result ClientPromptedResult) MarshalJSON() ([]byte, error)

type ClientResult ¶

type ClientResult interface {
	Kind() string
	// contains filtered or unexported methods
}

ClientResult is the closed list/attached/prompted result union. Go names the upstream anonymous variants so callers cannot confuse absent fields with zero values.

func RunClient(ctx context.Context, command ClientCommand, options RunClientOptions) (result ClientResult, err error)

type ClientRuntime ¶

type ClientRuntime struct {
	Servers []*ClientRuntimeServer
	// contains filtered or unexported fields
}

ClientRuntime owns the live Unix client and service namespaces for one presentation. Dispose joins sources before transport lifetimes.

func OpenClientRuntime(ctx context.Context, command ClientCommand, options OpenClientRuntimeOptions) (_ *ClientRuntime, err error)

func (runtime *ClientRuntime) Dispose() error

type ClientRuntimeRoute ¶

type ClientRuntimeRoute struct {
	Transport string  `json:"transport"`
	ServerId  string  `json:"serverId"`
	Path      *string `json:"path,omitempty"`
}

ClientRuntimeRoute is a selected Unix route with its socket path and logical server ID.

type ClientRuntimeServer ¶

type ClientRuntimeServer struct {
	Route   ClientRuntimeRoute
	Client  *client.Client
	Server  ServerServiceSource
	Session SessionServiceSource
}

ClientRuntimeServer owns one connected client and its server/Session service namespaces.

type ClientServerServiceSource ¶

type ClientServerServiceSource struct {
	// contains filtered or unexported fields
}

ClientServerServiceSource adapts the real client to the structural source consumed by presentations and FacetHost.

func NewClientServerServiceSource(peer *client.Client, options ClientServiceSourceOptions) (result *ClientServerServiceSource, err error)

func (source *ClientServerServiceSource) AcceptsUnavailableServices() bool

func (source *ClientServerServiceSource) Catalogue(ctx context.Context) ([]chord.ServiceCatalogueEntry, error)

func (source *ClientServerServiceSource) Connection() chord.ReplicatedStateOf[*services.ServerConnectionState]

func (source *ClientServerServiceSource) Dispose(ctx context.Context) error

func (source *ClientServerServiceSource) Open(options chord.RemoteServiceSourceOpenOptions) (result chord.RemoteServices, err error)

type ClientServiceSourceOptions ¶

type ClientServiceSourceOptions struct {
	OnError         func(error)
	TransportClient client.ServiceTransportClient
}

ClientServiceSourceOptions selects an error sink and an optional request/subscription decorator. Lifecycle state always belongs to the original client.

type ClientSessionServiceSource ¶

type ClientSessionServiceSource struct {
	// contains filtered or unexported fields
}

ClientSessionServiceSource retains attachment generation fencing while adapting the real client to a structural Chord source.

func NewClientSessionServiceSource(peer *client.Client, options ClientServiceSourceOptions) (result *ClientSessionServiceSource, err error)

func (source *ClientSessionServiceSource) AcceptsUnavailableServices() bool

func (source *ClientSessionServiceSource) Attachment() chord.ReplicatedStateOf[*services.SessionAttachmentState]

func (source *ClientSessionServiceSource) Catalogue(ctx context.Context) ([]chord.ServiceCatalogueEntry, error)

func (source *ClientSessionServiceSource) Dispose(ctx context.Context) error

func (source *ClientSessionServiceSource) Open(options chord.RemoteServiceSourceOpenOptions) (result chord.RemoteServices, err error)

func (source *ClientSessionServiceSource) WhenAttached(ctx context.Context, id string) error

func (source *ClientSessionServiceSource) WhenDetached(ctx context.Context) error

type ClientTuiExecutor ¶

type ClientTuiExecutor struct {
	// contains filtered or unexported fields
}

ClientTuiExecutor serializes input, render and UI mutations for one experimental presentation. Operations admitted by RunOnMain finish before it returns. RPC and plugin operations run outside this executor. Close runs off-loop after the component has closed.

func NewClientTuiExecutor() *ClientTuiExecutor

func (executor *ClientTuiExecutor) Close()

func (executor *ClientTuiExecutor) QueueMicrotask(ctx context.Context, apply func()) error

func (executor *ClientTuiExecutor) RunOnMain(ctx context.Context, apply func()) error

type ClientTuiServer ¶

type ClientTuiServer struct {
	ServerId string
	Radius   bool
	Server   ServerServiceSource
	Session  SessionServiceSource
}

ClientTuiServer identifies a server and its independently scoped service sources. Radius enables connection recovery presentation.

type Command ¶

type Command struct {
	Name string
	// contains filtered or unexported fields
}

Command composes options, a builder, an awaited action, and subcommands. Configuration completes before concurrent parsing or execution.

func NewCommand(name string) *Command

func (c *Command) Action(action func(context.Context, NamedCommandInvocation, CliContext) error) *Command

func (c *Command) Build(builder func(ParsedCommandInput) CommandParseResult) *Command

func (c *Command) Command(command *Command) error

func (c *Command) Execute(ctx context.Context, argv []string, commandContext CliContext) (CommandExecutionResult, error)

func (c *Command) Option(option CommandOption) error

func (c *Command) Parse(argv []string) (CommandParseResult, error)

type CommandExecutionResult ¶

type CommandExecutionResult = CommandParseResult

CommandExecutionResult has the same shape as a parse result; Execute returns only after the selected action completes.

type CommandOption ¶

type CommandOption struct {
	Name       string
	Flag       bool
	Repeatable bool
	Parse      func(string) (any, error)
}

CommandOption describes a flag or a value option. Parse returns a CLI diagnostic on invalid input.

func FlagOption(name string) CommandOption

func StringOption(name string, repeatable bool) CommandOption

func ValueOption(name string, parse func(string) (any, error), repeatable bool) CommandOption

type CommandParseResult ¶

type CommandParseResult struct {
	Ok      bool
	Command NamedCommandInvocation
	Errors  []string
}

CommandParseResult distinguishes CLI diagnostics from successful invocations. Go errors carry upstream exceptions, not option diagnostics.

type ConfiguredServerPluginPackage ¶

type ConfiguredServerPluginPackage struct {
	ManifestPath string
	Build        func(context.Context) ([]FacetBundleArtifact, error)
}

ConfiguredServerPluginPackage is one serialized server-owned builder. Build waits for the complete compiler/filesystem operation, as upstream's context-free Promise does. It never evaluates plugin JavaScript.

func CreateServerPluginPackage(directory, serverId, packagePath string) (*ConfiguredServerPluginPackage, error)

type CoordinatorConnection ¶

type CoordinatorConnection struct {
	// contains filtered or unexported fields
}

CoordinatorConnection is the server-side endpoint of the coordinator's opaque message router. Event callbacks run in receive order, outside the state lock. They may send, close or unsubscribe.

func NewCoordinatorConnection(options CoordinatorConnectionOptions) *CoordinatorConnection

func (c *CoordinatorConnection) Broadcast(payload any) error

func (c *CoordinatorConnection) Close()

func (c *CoordinatorConnection) Connect(ctx context.Context) error

func (c *CoordinatorConnection) ControlPath() string

func (c *CoordinatorConnection) OnEvent(listener *CoordinatorConnectionListener) func()

func (c *CoordinatorConnection) PeerIDs() []string

func (c *CoordinatorConnection) Replaced() <-chan struct{}

func (c *CoordinatorConnection) Send(peerID string, payload any) error

func (c *CoordinatorConnection) ServerConnectionID() string

func (c *CoordinatorConnection) WasReplaced() bool

type CoordinatorConnectionEvent ¶

type CoordinatorConnectionEvent struct {
	Type    string
	PeerID  string
	From    string
	Payload json.RawMessage
}

CoordinatorConnectionEvent carries peer membership changes or an opaque routed payload. A nil Payload means absent; json.RawMessage("null") is an explicit JSON null.

type CoordinatorConnectionListener ¶

type CoordinatorConnectionListener struct {
	// contains filtered or unexported fields
}

CoordinatorConnectionListener is a callback with stable reference identity. Go functions cannot be compared; OnEvent identifies listeners by this pointer instead.

func NewCoordinatorConnectionListener(listener func(CoordinatorConnectionEvent)) *CoordinatorConnectionListener

type CoordinatorConnectionOptions ¶

type CoordinatorConnectionOptions struct {
	ControlPath        string
	Endpoint           string
	ServerConnectionID *string
}

CoordinatorConnectionOptions identifies this server generation and its private forwarding endpoint.

type CoordinatorStartupLease ¶

type CoordinatorStartupLease struct {
	// contains filtered or unexported fields
}

CoordinatorStartupLease keeps an unregistered control connection alive while a server starts.

func EnsureCoordinator(ctx context.Context, publicPath, controlPath string, options ...InternalProcessSpawnOptions) (*CoordinatorStartupLease, error)

func (lease *CoordinatorStartupLease) Close()

type CreateSessionOptions ¶

type CreateSessionOptions struct {
	ID  *string
	Cwd string
}

CreateSessionOptions selects the new Session's ID, which defaults to a random UUID, and its working directory.

type CreateSessionWorkerHarness ¶

type CreateSessionWorkerHarness func(ctx context.Context, databasePath string, options SessionWorkerOptions) (SessionWorkerRuntime, error)

CreateSessionWorkerHarness opens the Session's Harness over databasePath and returns it with its root conversation. It runs while the worker holds the Session lock; on failure it closes whatever it opened.

type ExperimentalChatView ¶

type ExperimentalChatView struct {
	Transcript      *tui.Container
	PendingMessages *tui.Container
	Status          *tui.Container
	// contains filtered or unexported fields
}

ExperimentalChatView renders the root conversation's durable view for the service-only experimental presentation. Apply and RefreshTheme run on the presentation owner loop. After detaching the view from that loop, Dispose cancels and joins its timers, image conversions and tool-renderer work.

func NewExperimentalChatView(ctx context.Context, cwd string, requestRender func(), runOnMain func(context.Context, func()) error) *ExperimentalChatView

func (view *ExperimentalChatView) Apply(conversation services.ConversationView) error

func (view *ExperimentalChatView) Dispose() error

func (view *ExperimentalChatView) RefreshTheme(conversation services.ConversationView) error

type ExperimentalClientTui ¶

type ExperimentalClientTui struct {
	// contains filtered or unexported fields
}

ExperimentalClientTui presents one attached Session through Chord services. UI methods run on the supplied owner executor; admitted transport operations and facet lifecycle operations are owned background work joined by Close, while a selected service call without an admission boundary keeps running on the background Context after Close, as in Pi.

func CreateExperimentalClientTui(ctx context.Context, options ExperimentalClientTuiOptions) (*ExperimentalClientTui, error)

func (component *ExperimentalClientTui) Close() error

func (component *ExperimentalClientTui) HandleInput(data string)

func (component *ExperimentalClientTui) Invalidate()

func (component *ExperimentalClientTui) LayoutRoot() tui.Component

func (component *ExperimentalClientTui) RefreshTheme()

func (component *ExperimentalClientTui) Render(width int) []string

func (component *ExperimentalClientTui) ShowError(message string)

type ExperimentalClientTuiOptions ¶

type ExperimentalClientTuiOptions struct {
	Command        ClientCommand
	UI             tui.Renderer
	Servers        []ClientTuiServer
	FacetLoader    chord.FacetLoader
	RequestRender  func()
	Finish         func()
	RunOnMain      func(context.Context, func()) error
	QueueMicrotask func(context.Context, func()) error
}

ExperimentalClientTuiOptions supplies presentation services and one UI owner executor. RunOnMain completes a top-level turn after its FIFO QueueMicrotask checkpoint; owner reentry executes inline without draining. Create and Close run off-loop; Render and HandleInput run on-loop. Keep the executor alive until Close completes.

type FacetBundleArtifact ¶

type FacetBundleArtifact struct {
	Format            string            `json:"format"`
	FormatVersion     int               `json:"formatVersion"`
	Plugin            FacetBundlePlugin `json:"plugin"`
	EntryName         string            `json:"entryName"`
	Entry             FacetBundleEntry  `json:"entry"`
	Source            string            `json:"source"`
	SourceMapContents *string           `json:"sourceMapContents,omitempty"`
}

FacetBundleArtifact is one self-contained entry transported to a Node host. Optional string pointers preserve omission separately from an explicit empty string.

func ReadFacetBundleArtifact(options FacetBundleArtifactReadOptions) (FacetBundleArtifact, error)

type FacetBundleArtifactLoaderOptions ¶

type FacetBundleArtifactLoaderOptions struct {
	Artifact           chord.JsonValue
	TemporaryDirectory string
	ResolveExternal    FacetBundleExternalResolver
}

FacetBundleArtifactLoaderOptions selects a transported entry and its optional materialization parent.

type FacetBundleArtifactReadOptions ¶

type FacetBundleArtifactReadOptions struct {
	ManifestPath string
	Entry        string
}

FacetBundleArtifactReadOptions selects one opaque entry from a manifest on disk.

type FacetBundleEntry ¶

type FacetBundleEntry struct {
	File            string   `json:"file"`
	Integrity       string   `json:"integrity"`
	ExternalImports []string `json:"externalImports"`
	SourceMap       *string  `json:"sourceMap,omitempty"`
}

FacetBundleEntry names one content-addressed CommonJS entry and its declared external imports.

type FacetBundleExternalResolver ¶

type FacetBundleExternalResolver func(string) (string, bool, error)

FacetBundleExternalResolver resolves one declared external import. A false result leaves resolution to the pinned Node loader; errors propagate before evaluation.

type FacetBundleLoaderOptions ¶

type FacetBundleLoaderOptions struct {
	ManifestPath    string
	Entry           string
	VerifyIntegrity *bool
	ResolveExternal FacetBundleExternalResolver
}

FacetBundleLoaderOptions selects an opaque bundle entry. ResolveExternal maps selected external imports to host module paths or file URLs. Nil VerifyIntegrity verifies the source.

type FacetBundleManifest ¶

type FacetBundleManifest struct {
	Format        string                      `json:"format"`
	FormatVersion int                         `json:"formatVersion"`
	Plugin        FacetBundlePlugin           `json:"plugin"`
	Entries       map[string]FacetBundleEntry `json:"entries"`
}

FacetBundleManifest describes the server-owned bundle entries. The builder owns entry ordering in the manifest file.

func ReadFacetBundleManifest(path string) (FacetBundleManifest, error)

type FacetBundlePlugin ¶

type FacetBundlePlugin struct {
	Id      string  `json:"id"`
	Version *string `json:"version,omitempty"`
}

FacetBundlePlugin identifies the selected plugin content.

func (plugin FacetBundlePlugin) MarshalJSON() ([]byte, error)

type FacetEntrySource ¶

type FacetEntrySource struct {
	Name   string
	Source string
}

FacetEntrySource retains the order of an upstream string-valued record. Repeated names overwrite their value without moving the first property; integer names enumerate before other names, as in Object.entries.

type InternalProcess ¶

type InternalProcess struct {
	// contains filtered or unexported fields
}

InternalProcess owns the child's exit observation and reaps it exactly once. A detached child may outlive its launcher. Done closes only after Wait has reaped it.

func SpawnInternalProcess(role InternalProcessRole, args []string, options InternalProcessSpawnOptions) (*InternalProcess, error)

func (p *InternalProcess) Done() <-chan struct{}

func (p *InternalProcess) PID() int

func (p *InternalProcess) ProcessState() *os.ProcessState

func (p *InternalProcess) Wait() error

type InternalProcessRole ¶

type InternalProcessRole string

InternalProcessRole selects an internal entrypoint, not a public CLI command.

func ConsumeInternalProcessRole() (InternalProcessRole, error)

func GetInternalProcessRole() (InternalProcessRole, error)

type InternalProcessSpawnOptions ¶

type InternalProcessSpawnOptions struct {
	EntryPath string
	Env       map[string]string
}

InternalProcessSpawnOptions supplies an optional native entry executable and environment overrides. EntryPath is the native counterpart of a source module URL; an empty path re-executes this executable.

type NamedCommandInvocation ¶

type NamedCommandInvocation interface {
	// contains filtered or unexported methods
}

NamedCommandInvocation is the closed union of experimental CLI invocations.

type OpenClientRuntimeOptions ¶

type OpenClientRuntimeOptions struct {
	Directory *string
}

OpenClientRuntimeOptions preserves an omitted search directory separately from an explicitly empty path.

type ParsedCommandInput ¶

type ParsedCommandInput struct {
	RemainingArgs []string
	// contains filtered or unexported fields
}

ParsedCommandInput retains the first unrecognized argument and every argument after it, including a -- separator.

func (p ParsedCommandInput) Value(option CommandOption) any

func (p ParsedCommandInput) Values(option CommandOption) []any

type RadiusClientAttachment ¶

type RadiusClientAttachment struct{ SessionID string }

RadiusClientAttachment identifies the currently selected Session.

type RadiusClientByteTransport ¶

type RadiusClientByteTransport struct {
	// contains filtered or unexported fields
}

RadiusClientByteTransport carries raw binary messages and reports one remote terminal event. Close initiates local shutdown; Done joins reads, writes, and cancellation cleanup.

func (t *RadiusClientByteTransport) Close()

func (t *RadiusClientByteTransport) Done() <-chan struct{}

func (t *RadiusClientByteTransport) Send(chunk []byte) error

type RadiusClientReconnect ¶

type RadiusClientReconnect struct {
	// contains filtered or unexported fields
}

RadiusClientReconnect reconnects an established client and restores its last selected Session. Dispose removes listeners, cancels, disconnects, and joins the retry loop.

func NewRadiusClientReconnect(ctx context.Context, client RadiusReconnectClient, reattach func(context.Context, string) error) *RadiusClientReconnect

func (r *RadiusClientReconnect) Dispose()

type RadiusClientTransportFactory ¶

type RadiusClientTransportFactory func(context.Context, RelayByteConnectionHandler) (*RadiusClientByteTransport, error)

RadiusClientTransportFactory resolves fresh credentials and connects one client byte stream. The context owns the resulting transport until Close.

func CreateRadiusClientTransportFactory(options RadiusClientTransportOptions) RadiusClientTransportFactory

type RadiusClientTransportOptions ¶

type RadiusClientTransportOptions struct {
	ServerID         string
	Auth             *RadiusRelayAuthResolver
	WebSocketFactory RadiusRelayWebSocketFactory
}

RadiusClientTransportOptions selects one authenticated raw client relay.

type RadiusReconnectClient ¶

type RadiusReconnectClient interface {
	Attachment() *RadiusClientAttachment
	Connected() bool
	ConnectionState() string
	Disconnect(reason string)
	OnAttachmentChange(func(*RadiusClientAttachment)) func()
	OnConnectionStateChange(func(string)) func()
	Reconnect(context.Context) error
}

RadiusReconnectClient is the established-client contract used by the reconnect owner. Listener removers must be safe during notification; methods and listeners may run concurrently.

type RadiusRelayAuth ¶

type RadiusRelayAuth struct {
	Gateway string
	Token   string
}

RadiusRelayAuth is one connection attempt's resolved credential.

type RadiusRelayAuthOptions ¶

type RadiusRelayAuthOptions struct {
	Input         *AuthInput
	Gateway       string
	CreateRuntime func() (*codingagent.RequestAuthRuntime, error)
}

RadiusRelayAuthOptions requires an explicit gateway. CreateRuntime supplies the stored-auth runtime without model-network refresh; it is called once, lazily, only without Input. Its owner must configure OAuth refresh for its selected gateway.

type RadiusRelayAuthResolver ¶

type RadiusRelayAuthResolver struct {
	// contains filtered or unexported fields
}

RadiusRelayAuthResolver rereads explicit or stored credentials for every connection attempt.

func NewRadiusRelayAuthResolver(options RadiusRelayAuthOptions) (*RadiusRelayAuthResolver, error)

func (r *RadiusRelayAuthResolver) Gateway() string

func (r *RadiusRelayAuthResolver) Resolve(ctx context.Context, required bool) (*RadiusRelayAuth, error)

type RadiusRelayHost ¶

type RadiusRelayHost struct {
	// contains filtered or unexported fields
}

RadiusRelayHost owns a reconnecting, multiplexed host connection. Incoming controls enqueue ordered replies without waiting for socket writes. Close cancels and joins every owned operation.

func NewRadiusRelayHost(options RadiusRelayHostOptions) (*RadiusRelayHost, error)

func (h *RadiusRelayHost) Close()

func (h *RadiusRelayHost) Start(ctx context.Context)

type RadiusRelayHostOptions ¶

type RadiusRelayHostOptions struct {
	ServerID         string
	Accept           func(*RelayServerByteConnection) RelayByteConnectionHandler
	Auth             *RadiusRelayAuthResolver
	WebSocketFactory RadiusRelayWebSocketFactory
	OnStatus         func(RadiusRelayHostStatus)
}

RadiusRelayHostOptions binds the relay to a server's accept operation. No command or default endpoint is activated by construction.

type RadiusRelayHostStatus ¶

type RadiusRelayHostStatus struct {
	Status string
	Error  string
}

RadiusRelayHostStatus reports authentication, connection, and retry transitions.

type RadiusRelayWebSocket ¶

type RadiusRelayWebSocket interface {
	Protocol() string
	Read() (binary bool, data []byte, err error)
	Send(binary bool, data []byte) error
	Close(code int, reason string) error
}

RadiusRelayWebSocket is a connected transport. Read has one owner; Send is serialized by the relay. Close must unblock both and may run concurrently with them.

type RadiusRelayWebSocketFactory ¶

type RadiusRelayWebSocketFactory func(context.Context, RadiusRelayWebSocketOptions) (RadiusRelayWebSocket, error)

RadiusRelayWebSocketFactory completes the opening handshake or returns its error. The context owns cancellation of the opening attempt.

type RadiusRelayWebSocketOptions ¶

type RadiusRelayWebSocketOptions struct {
	URL           string
	Protocol      string
	Authorization string
}

RadiusRelayWebSocketOptions carries the exact URL, subprotocol, and bearer header for an attempt.

type RelayByteConnectionHandler ¶

type RelayByteConnectionHandler struct {
	OnData  func([]byte)
	OnClose func()
	OnError func(error)
}

RelayByteConnectionHandler receives ordered data and exactly one terminal callback. Callbacks run on the host's reader, not the TUI loop; they must not wait for host shutdown.

type RelayDataFrame ¶

type RelayDataFrame struct {
	ConnectionID string
	Payload      []byte
}

RelayDataFrame contains a validated lowercase UUIDv4 and an independently owned payload.

func ParseRelayDataFrame(frame []byte) (RelayDataFrame, bool)

type RelayServerByteConnection ¶

type RelayServerByteConnection struct {
	// contains filtered or unexported fields
}

RelayServerByteConnection is one server-side virtual byte stream. Send and Close await ordered writes; a final chunk precedes its close control.

func (c *RelayServerByteConnection) Close(finalChunk []byte) error

func (c *RelayServerByteConnection) Closed() bool

func (c *RelayServerByteConnection) Send(chunk []byte) error

type RoutedSessionAttachment ¶

type RoutedSessionAttachment struct {
	// contains filtered or unexported fields
}

RoutedSessionAttachment fences all service invocations to one server generation and acknowledged client attachment.

func (a *RoutedSessionAttachment) InvokeService(ctx context.Context, call chord.ServiceCall, publish chord.ServiceUpdatePublisher) (json.RawMessage, error)

func (a *RoutedSessionAttachment) Release(ctx context.Context) error

type RoutedSessionHandle ¶

type RoutedSessionHandle struct {
	// contains filtered or unexported fields
}

RoutedSessionHandle retains the worker generation selected by OpenSession.

func (h *RoutedSessionHandle) AttachClient(ctx context.Context) (*RoutedSessionAttachment, error)

func (h *RoutedSessionHandle) Close(ctx context.Context) error

func (h *RoutedSessionHandle) TerminalError() error

func (h *RoutedSessionHandle) Terminated() <-chan struct{}

type RunClientOptions ¶

type RunClientOptions struct {
	Directory *string
}

RunClientOptions selects discovery. Directory defaults to PI_SERVER_DIR or ~/.pi/server.

type RunClientTuiOptions ¶

type RunClientTuiOptions struct {
	OpenClientRuntimeOptions
	FacetLoader chord.FacetLoader
	// ThemePaths are the resolved theme resources of a DefaultResourceLoader without extensions, skills, prompt templates or context files, in precedence order.
	ThemePaths []string
}

RunClientTuiOptions selects discovery and optional shared presentation facets.

type RunningServer ¶

type RunningServer struct {
	ServerId   string
	SocketPath string
	SessionDir string
	Server     *routing.Server
	// contains filtered or unexported fields
}

RunningServer owns one replaceable Unix server generation. Closed observes backend/catalog closure; Close also joins worker shutdown and coordinator cleanup.

func StartForegroundServer(ctx context.Context, options StartServerOptions) (runtime *RunningServer, err error)

func StartServer(ctx context.Context, options StartServerOptions) (runtime *RunningServer, err error)

func (server *RunningServer) Close() error

func (server *RunningServer) Closed() <-chan struct{}

func (server *RunningServer) ClosedError() error

func (server *RunningServer) WorkerPids() map[string]int

type ServerCommand ¶

type ServerCommand struct {
	Command        string
	Provider       *string
	Model          *string
	PluginPackages []string
	ServerId       *string
	SessionDir     *string
}

ServerCommand contains the server options before runtime defaults are applied.

type ServerLifetime ¶

type ServerLifetime struct {
	// contains filtered or unexported fields
}

ServerLifetime reconciles operator, startup, client, and worker holds for one server generation. The idle timer commits retirement (the lifetime stops) atomically with its eligibility check. The retire callback then runs outside the state lock and may stop the lifetime again.

func NewServerLifetime(keepAlive bool) *ServerLifetime

func (l *ServerLifetime) SetConnectionCount(count int)

func (l *ServerLifetime) SetWorkerCount(count int)

func (l *ServerLifetime) SetWorkerCountSource(source func() int)

func (l *ServerLifetime) Start(retire func())

func (l *ServerLifetime) Stop()

type ServerProfile ¶

type ServerProfile struct {
	ServerID string
	// contains filtered or unexported fields
}

ServerProfile owns the launcher lock for one persistent logical server identity.

func AcquireServerProfile(ctx context.Context, directory string, requestedServerID *string) (*ServerProfile, error)

func (p *ServerProfile) Release() error

type ServerServiceSource ¶

type ServerServiceSource interface {
	chord.RemoteServiceSource
	Connection() chord.ReplicatedStateOf[*services.ServerConnectionState]
	Dispose(context.Context) error
}

ServerServiceSource supplies server services and their replicated connection state. Both network and loopback presentations use this contract.

type SessionCatalogMetadata ¶

type SessionCatalogMetadata struct {
	ID        string  `json:"id"`
	CreatedAt float64 `json:"createdAt"`
	Cwd       string  `json:"cwd"`
	Path      string  `json:"path"`
}

SessionCatalogMetadata identifies one server-hosted Session: a directory holding meta.json and the worker-owned session.sqlite. It is also the StrictObject SessionWorkerMetadataSchema (session-worker.ts:69-74) that the manager sends in launch options and the worker echoes in worker_ready. CreatedAt is a JavaScript number, so any finite JSON number is valid. Cwd is the working directory the Session's agent runs in; Path is the Session directory, which workers lock and whose storage they own. upstream: packages/coding-agent/src/experimental/session-catalog.ts:SessionCatalogMetadata

func CreateSession(sessionDir string, options CreateSessionOptions) (SessionCatalogMetadata, error)

func ListSessions(sessionDir string) ([]SessionCatalogMetadata, error)

func ReadSession(sessionDir, id string) *SessionCatalogMetadata

func (metadata SessionCatalogMetadata) SessionID() string

type SessionPluginSelectionConflictError ¶

type SessionPluginSelectionConflictError struct{ Message string }

SessionPluginSelectionConflictError rejects changing the plugin selection of a running or starting Session.

func (e *SessionPluginSelectionConflictError) Error() string

type SessionServiceSource ¶

type SessionServiceSource interface {
	chord.RemoteServiceSource
	Attachment() chord.ReplicatedStateOf[*services.SessionAttachmentState]
	WhenAttached(context.Context, string) error
	WhenDetached(context.Context) error
	Dispose(context.Context) error
}

SessionServiceSource supplies the selected attachment's services. Readiness waits are fenced to the requested Session generation by the source implementation.

type SessionWorkerCoordinator ¶

type SessionWorkerCoordinator interface {
	ControlPath() string
	ServerConnectionID() string
	WasReplaced() bool
	OnEvent(*CoordinatorConnectionListener) func()
	Send(string, any) error
	Broadcast(any) error
}

SessionWorkerCoordinator is the coordinator boundary consumed by one replaceable server's worker manager.

type SessionWorkerHarness ¶

type SessionWorkerHarness interface {
	services.AgentHarness
	Close(context.Context) error
	// TaskGraph observes the Harness's live tasks.
	TaskGraph(context.Context) (services.TaskGraphActivity, error)
	// Resume continues work an interrupted turn left behind.
	Resume()
}

SessionWorkerHarness is the Session's durable Harness as the worker owns it: the submission and agent-document boundary of the services, its task activity, and recovery of interrupted work. Close releases the storage.

type SessionWorkerManager ¶

type SessionWorkerManager struct {
	// contains filtered or unexported fields
}

SessionWorkerManager owns process bookkeeping, generation-fenced requests, and attachment demand for one server generation. Blocking methods preserve awaited operations; Detach forgets workers without stopping their processes.

func NewSessionWorkerManager(coordinator SessionWorkerCoordinator, sessionDir string, model *SessionWorkerModel, onWorkerCountChanged func(int)) *SessionWorkerManager

func (m *SessionWorkerManager) AssertSessionPluginManifestPaths(metadata SessionCatalogMetadata, paths []string) error

func (m *SessionWorkerManager) CloseSession(ctx context.Context, metadata SessionCatalogMetadata) error

func (m *SessionWorkerManager) Detach()

func (m *SessionWorkerManager) Discover(peerIDs []string) error

func (m *SessionWorkerManager) OpenSession(ctx context.Context, metadata SessionCatalogMetadata, pluginManifestPaths []string) (*RoutedSessionHandle, error)

func (m *SessionWorkerManager) Shutdown() error

func (m *SessionWorkerManager) TrackedSessions() []SessionCatalogMetadata

func (m *SessionWorkerManager) WorkerCount() int

func (m *SessionWorkerManager) WorkerPids() map[string]int

type SessionWorkerModel ¶

type SessionWorkerModel struct {
	Provider *string `json:"provider,omitempty"`
	Model    string  `json:"model"`
}

SessionWorkerModel preserves a present model override even when empty. A nil Provider is omitted; a non-nil empty Provider reaches worker validation instead of selecting a default.

type SessionWorkerOptions ¶

type SessionWorkerOptions struct {
	SessionDir          string                 `json:"sessionDir"`
	Metadata            SessionCatalogMetadata `json:"metadata"`
	Provider            string                 `json:"provider,omitempty"`
	Model               string                 `json:"model,omitempty"`
	PluginManifestPaths []string               `json:"pluginManifestPaths"`
}

SessionWorkerOptions describes the durable Session and selected plugins of one worker process.

type SessionWorkerRuntime ¶

type SessionWorkerRuntime struct {
	Harness         SessionWorkerHarness
	Conversation    services.SessionWorkerConversation
	ModelRuntime    services.ModelsServiceModelRuntime
	SettingsManager services.ModelsServiceSettingsManager
	FacetLoader     chord.FacetLoader
	Cleanup         func(context.Context) error
}

SessionWorkerRuntime is a Session's opened Harness with its root conversation and the optional collaborators of the services. Cleanup releases resources the Harness does not own, such as execution environments, after it closed.

type StartServerOptions ¶

type StartServerOptions struct {
	Directory      *string
	ServerId       *string
	SessionDir     *string
	Provider       *string
	Model          *string
	KeepAlive      *bool
	PluginPackages []string
}

StartServerOptions preserves omitted paths, identity, model selection, lifetime policy, and plugin selection separately from explicit empty values.

type TransportAddress ¶

type TransportAddress struct {
	Transport string
	Path      string
}

TransportAddress is a parsed Unix address. Experimental Radius addresses are designed out (D64).

type WorkerLifecycle ¶

type WorkerLifecycle struct {
	// contains filtered or unexported fields
}

WorkerLifecycle reconciles generation-scoped attachment demand with Harness activity. OnRetire runs inside the critical section that commits retirement, as upstream's synchronous #reconcile does, so it must be brief and must not call back into the lifecycle.

func NewWorkerLifecycle(options WorkerLifecycleOptions) *WorkerLifecycle

func (l *WorkerLifecycle) BeginRequest(serverConnectionID, attachmentID string) (func(), error)

func (l *WorkerLifecycle) Close()

func (l *WorkerLifecycle) HoldRetirement() func()

func (l *WorkerLifecycle) ServerConnected(serverConnectionID string)

func (l *WorkerLifecycle) ServerDisconnected(serverConnectionID string)

func (l *WorkerLifecycle) SetDemand(serverConnectionID, attachmentID string, attached bool) error

func (l *WorkerLifecycle) SetHarnessActive(active bool)

type WorkerLifecycleOptions ¶

type WorkerLifecycleOptions struct {
	InitialServerConnectionID *string
	InitialDemandGraceMs      int
	OrphanDemandGraceMs       int
	// OnRetire runs once, under the lifecycle lock, when retirement commits.
	OnRetire func()
}

WorkerLifecycleOptions selects the initial generation and the initial/orphan demand grace periods in milliseconds.

type WorkerOperationRequest ¶

type WorkerOperationRequest struct {
	Type      string               `json:"type"`
	RequestID string               `json:"requestId"`
	Scope     WorkerOperationScope `json:"scope"`
	Call      chord.ServiceCall    `json:"call"`
}

type WorkerOperationScope ¶

type WorkerOperationScope struct {
	ServerConnectionID string `json:"serverConnectionId"`
	AttachmentID       string `json:"attachmentId"`
}