proxy

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

type EgressProxyAuthorizer interface {
	AuthorizeEgressProxy(ctx context.Context, claimedSandboxID, credential string) (sandboxID string, err error)
}

type EgressProxyOptions struct {
	Authorizer      EgressProxyAuthorizer
	Policies        EgressProxyPolicySource
	SessionPolicies EgressProxySessionPolicySource
	Recorder        EgressProxyRecorder
	Logger          *slog.Logger
	// LookupIP resolves the destination of a request. It defaults to the
	// process resolver; a test injects one so a decision never depends on real
	// name resolution.
	LookupIP func(ctx context.Context, host string) ([]net.IP, error)
	// DialTimeout bounds the connection this proxy opens on the sandbox's
	// behalf. Zero uses DefaultEgressDialTimeout.
	DialTimeout time.Duration
	// Dial opens the upstream connection. It is nil in production, where the
	// proxy uses its own dialer; a test injects one to exercise the decision
	// and forwarding paths without reaching a real network.
	Dial func(ctx context.Context, network, address string) (net.Conn, error)
	// TLSMITM enables L7 TLS termination for an HTTPS allowance that declares
	// methods or paths. It is opt-in: with it off, such an allowance fails
	// closed rather than being forwarded uninspected.
	TLSMITM bool
	// CACertificatePEM and CAKeyPEM are the CA the proxy signs leaves with. When
	// both are empty and TLSMITM is true, the proxy generates an ephemeral CA.
	CACertificatePEM []byte
	CAKeyPEM         []byte
	// UpstreamTLSConfig is the base TLS configuration for the connection the
	// proxy opens to the real upstream after intercepting. Nil uses the system
	// roots. A test supplies a pool that trusts its local upstream certificate.
	UpstreamTLSConfig *tls.Config
}

type EgressProxyPolicySource interface {
	EgressProxyPolicy(ctx context.Context, sandboxID string) (egress.Policy, error)
}

type EgressProxyRecorder interface {
	RecordEgressDecision(ctx context.Context, record egress.Record)
}

type EgressProxySessionPolicySource interface {
	EgressProxyPolicyForSession(ctx context.Context, sandboxID, sessionID, marker string) (egress.Policy, error)
}

type EnsureReadyFunc func(ctx context.Context, sessionID string) (domain.ProxyState, error)

type HTTPDoer interface {
	Do(*http.Request) (*http.Response, error)
}

type JupyterOptions struct {
	BasePath    string
	Store       Store
	EnsureReady EnsureReadyFunc
	// Logger receives the readiness and upstream failures that the handler does
	// not return to the client. It defaults to slog.Default.
	Logger *slog.Logger
}

type RuntimeLLMConnectionResolver func(ctx context.Context, connectionID, model string) (llms.ResolvedTarget, error)

type RuntimeLLMOptions struct {
	Tokens      RuntimeLLMTokenStore
	Sandboxes   RuntimeLLMSandboxStore
	Connections RuntimeLLMConnectionResolver
	Client      HTTPDoer
	// MaxOutputTokens, when > 0, is injected into every proxied upstream LLM
	// request using the field names supported by the upstream protocol. codex
	// does not send max_output_tokens itself, so without this API proxies that
	// default to a small limit silently truncate long outputs.
	MaxOutputTokens int
	// Logger records why a proxied call failed. The guest receives a fixed
	// message, so the log is the only place the cause survives. Defaults to
	// slog.Default.
	Logger *slog.Logger
}

type RuntimeLLMSandboxStore interface {
	GetSandbox(context.Context, string) (*domain.Sandbox, error)
}

type RuntimeLLMTokenStore interface {
	GetLLMFacadeToken(context.Context, string) (llms.FacadeToken, error)
}

type Store interface {
	GetProxyState(id string) (domain.ProxyState, error)
}

type WorkspaceFilesResponse struct {
	WorkspaceID string                 `json:"workspace_id"`
	Files       []workspaces.FileEntry `json:"files"`
}

type WorkspaceLoader func(ctx context.Context, workspaceID string) (domain.WorkspaceConfig, workspaces.FileWorkspaceContent, error)

type WorkspaceOptions struct {
	UploadLimitBytes int64
	Load             WorkspaceLoader
}