diff --git a/.env.example b/.env.example index 05017bb5..78f5a8d0 100644 --- a/.env.example +++ b/.env.example @@ -59,6 +59,14 @@ JUPYTER_PROXY_BASE=/jupyter RUNTIME_DRIVER=docker DEFAULT_IMAGE=ghcr.io/chaitin/agent-compose-guest:latest +# Internal sandbox port-mapping addresses. Leave both unset for a daemon binary +# or a daemon container using host networking; agent-compose then uses the +# Docker default bridge gateway for both. A bridge-network daemon commonly uses +# the physical-host bridge gateway for Docker and its own container address for +# BoxLite/Microsandbox, for example: +# NETWORK_DOCKER_PUBLISH_ADDRESS=172.23.0.1 +# NETWORK_RUNTIME_PUBLISH_ADDRESS=172.23.0.2 + # --------------------------------------------------------------------------- # Runtime internals (advanced) # Change these only when your deployment environment requires custom runtime diff --git a/docs/README.md b/docs/README.md index 97e77c80..6b661aca 100644 --- a/docs/README.md +++ b/docs/README.md @@ -8,6 +8,7 @@ Chinese documentation is available at [zh-CN/README.md](zh-CN/README.md). - [Project overview and quick start](../README.md) - [Command line manual](command-line-manual.md) +- [Sandbox networks](sandbox-networks.md) - [Configuration example](../.env.example) - [Loader script API](../examples/scheduler-script/README.md) - [Security policy](../SECURITY.md) diff --git a/docs/sandbox-networks.md b/docs/sandbox-networks.md new file mode 100644 index 00000000..69ceb6d5 --- /dev/null +++ b/docs/sandbox-networks.md @@ -0,0 +1,98 @@ +# Sandbox networks + +Agent-compose connects sandboxes through TCP port mappings. Docker, BoxLite, +and Microsandbox consume the same normalized bindings, while each runtime uses +its own port-publishing implementation. + +## Project configuration + +Declare logical networks at the project level and attach agents by name: + +```yaml +name: network-demo + +networks: + frontend: {} + backend: + driver: port_mapping + +agents: + api: + networks: [frontend, backend] + expose: + - "8080" + - target: 9090 + host_port: 19090 + protocol: tcp + + worker: + networks: [backend] + + dashboard: + ports: + - "127.0.0.1:18080:8080" +``` + +`port_mapping` is currently the only supported network driver. When internal +networking is enabled, an agent without an explicit attachment joins the +implicit `default` network. + +## `expose` + +`expose` creates an internal listener that forwards to a service port inside +the target sandbox. + +- `"8080"` forwards to sandbox port 8080 and allocates the listener port + dynamically. +- The long form accepts `target`, optional `host_port`, and `protocol`. +- `host_port` fixes the listener port. A bind conflict fails sandbox startup; + agent-compose does not silently select another port. +- Only TCP is currently supported. + +The listener address is selected by the target runtime. It is not configured +per agent. + +## `ports` + +`ports` publishes a sandbox service with an explicit host address. Supported +short forms are: + +```yaml +ports: + - "8080" # dynamic host port -> sandbox 8080 + - "18080:8080" # 127.0.0.1:18080 -> sandbox 8080 + - "0.0.0.0:18080:8080" # all host interfaces -> sandbox 8080 +``` + +The default host IP is `127.0.0.1`. Host addresses must currently be IPv4, and +only TCP is supported. + +## Publish addresses + +Internal `expose` listeners use two optional daemon settings: + +```text +NETWORK_DOCKER_PUBLISH_ADDRESS +NETWORK_RUNTIME_PUBLISH_ADDRESS +``` + +Docker targets use the Docker address. BoxLite and Microsandbox targets use +the runtime address. If an address is omitted, agent-compose reads the IPv4 +gateway of Docker's default `bridge` network. + +A daemon running as a native process or in host network mode usually needs no +override. A daemon running in a regular Docker bridge network may need both +addresses configured so every source sandbox can route to the resulting +listener. + +## Current boundary + +Named networks record logical membership and annotate internal bindings. The +`port_mapping` driver does not create a Docker network, install firewall rules, +provide DNS names, or transparently rewrite `api:8080`. Sandboxes on different +logical networks may therefore still be able to reach the same underlying +listener. + +Applications use the actual `host_ip:host_port` recorded in sandbox network +state. Service discovery and access-policy enforcement are outside the current +network driver. diff --git a/docs/zh-CN/README.md b/docs/zh-CN/README.md index 586b5dfc..a0cda044 100644 --- a/docs/zh-CN/README.md +++ b/docs/zh-CN/README.md @@ -127,7 +127,8 @@ agents: prompt: "Review the current project state and summarize changes." ``` -完整字段说明见[命令行使用手册](command-line-manual.md)。 +完整字段说明见[命令行使用手册](command-line-manual.md)。Sandbox 互通配置见 +[Sandbox 网络](sandbox-networks.md)。 ## CLI 概览 diff --git a/docs/zh-CN/sandbox-networks.md b/docs/zh-CN/sandbox-networks.md new file mode 100644 index 00000000..e8b4b5a5 --- /dev/null +++ b/docs/zh-CN/sandbox-networks.md @@ -0,0 +1,88 @@ +# Sandbox 网络 + +Agent-compose 通过 TCP 端口映射连接 sandbox。Docker、BoxLite 和 +Microsandbox 消费相同的标准化 binding，再由各 runtime 使用自己的端口发布实现。 + +## Project 配置 + +在 project 顶层声明逻辑 network，并按名称把 agent 加入 network： + +```yaml +name: network-demo + +networks: + frontend: {} + backend: + driver: port_mapping + +agents: + api: + networks: [frontend, backend] + expose: + - "8080" + - target: 9090 + host_port: 19090 + protocol: tcp + + worker: + networks: [backend] + + dashboard: + ports: + - "127.0.0.1:18080:8080" +``` + +当前只支持 `port_mapping` network driver。启用内部网络后，没有显式声明 +network 的 agent 会加入隐式的 `default` network。 + +## `expose` + +`expose` 创建内部 listener，并把连接转发到目标 sandbox 内的服务端口。 + +- `"8080"` 转发到 sandbox 的 8080 端口，listener 端口由系统动态分配。 +- 长写法支持 `target`、可选的 `host_port` 和 `protocol`。 +- `host_port` 用来固定 listener 端口。发生端口冲突时 sandbox 启动失败， + agent-compose 不会悄悄改用其他端口。 +- 当前只支持 TCP。 + +Listener 地址由目标 runtime 选择，不需要在每个 agent 中重复配置。 + +## `ports` + +`ports` 使用明确的 host 地址发布 sandbox 服务。支持以下短写法： + +```yaml +ports: + - "8080" # 动态 host 端口 -> sandbox 8080 + - "18080:8080" # 127.0.0.1:18080 -> sandbox 8080 + - "0.0.0.0:18080:8080" # 所有 host 接口 -> sandbox 8080 +``` + +默认 host IP 是 `127.0.0.1`。当前 host 地址只支持 IPv4，协议只支持 TCP。 + +## 发布地址 + +内部 `expose` listener 使用两个可选的 daemon 配置： + +```text +NETWORK_DOCKER_PUBLISH_ADDRESS +NETWORK_RUNTIME_PUBLISH_ADDRESS +``` + +Docker target 使用 Docker 地址；BoxLite 和 Microsandbox target 使用 runtime +地址。没有配置某个地址时，agent-compose 会读取 Docker 默认 `bridge` network +的 IPv4 gateway。 + +Daemon 作为宿主机进程运行或使用 host network 时通常无需覆盖默认值。Daemon +运行在普通 Docker bridge network 中时，可能需要显式配置两个地址，确保所有 +source sandbox 都能路由到生成的 listener。 + +## 当前能力边界 + +命名 network 用于记录逻辑归属并标注内部 binding。`port_mapping` driver 不创建 +Docker network、不安装防火墙规则、不提供 DNS 名称，也不会透明改写 +`api:8080`。因此，属于不同逻辑 network 的 sandbox 在底层仍可能访问同一个 +listener。 + +应用通过 sandbox network state 中记录的实际 `host_ip:host_port` 访问服务。 +服务发现和访问策略强制执行不属于当前 network driver 的能力。 diff --git a/pkg/agentcompose/adapters/network_docker.go b/pkg/agentcompose/adapters/network_docker.go new file mode 100644 index 00000000..f1958231 --- /dev/null +++ b/pkg/agentcompose/adapters/network_docker.go @@ -0,0 +1,73 @@ +package adapters + +import ( + "context" + "fmt" + "net/netip" + "strings" + + networkapi "github.com/docker/docker/api/types/network" + "github.com/docker/docker/client" +) + +type dockerNetworkAPI interface { + NetworkInspect(context.Context, string, networkapi.InspectOptions) (networkapi.Inspect, error) + Close() error +} + +type dockerNetworkClientFactory func() (dockerNetworkAPI, error) + +type DockerPublishAddressProvider struct { + client dockerNetworkClientFactory +} + +func NewDockerPublishAddressProvider() *DockerPublishAddressProvider { + return &DockerPublishAddressProvider{client: newDockerNetworkAPI} +} + +func newDockerNetworkAPI() (dockerNetworkAPI, error) { + dockerClient, err := client.NewClientWithOpts(client.FromEnv, client.WithAPIVersionNegotiation()) + if err != nil { + return nil, fmt.Errorf("connect docker daemon: %w", err) + } + return dockerClient, nil +} + +func (p *DockerPublishAddressProvider) DefaultPublishAddress(ctx context.Context) (string, error) { + dockerClient, err := p.openClient() + if err != nil { + return "", err + } + defer func() { _ = dockerClient.Close() }() + network, err := dockerClient.NetworkInspect(ctx, "bridge", networkapi.InspectOptions{}) + if err != nil { + return "", fmt.Errorf("inspect Docker default bridge network: %w", err) + } + return ipv4Gateway(network, "Docker default bridge") +} + +func (p *DockerPublishAddressProvider) openClient() (dockerNetworkAPI, error) { + if p == nil || p.client == nil { + return nil, fmt.Errorf("docker network client is required") + } + return p.client() +} + +func ipv4Gateway(network networkapi.Inspect, description string) (string, error) { + var gateway string + for _, config := range network.IPAM.Config { + candidate := strings.TrimSpace(config.Gateway) + address, err := netip.ParseAddr(candidate) + if err != nil || !address.Is4() { + continue + } + if gateway != "" { + return "", fmt.Errorf("%s network has multiple IPv4 gateways", description) + } + gateway = address.String() + } + if gateway == "" { + return "", fmt.Errorf("%s network has no IPv4 gateway", description) + } + return gateway, nil +} diff --git a/pkg/agentcompose/adapters/network_docker_test.go b/pkg/agentcompose/adapters/network_docker_test.go new file mode 100644 index 00000000..911d54b2 --- /dev/null +++ b/pkg/agentcompose/adapters/network_docker_test.go @@ -0,0 +1,139 @@ +package adapters + +import ( + "context" + "fmt" + "io" + "os" + "strings" + "testing" + "time" + + containerapi "github.com/docker/docker/api/types/container" + networkapi "github.com/docker/docker/api/types/network" + "github.com/docker/docker/client" + "github.com/docker/go-connections/nat" +) + +func TestDockerPublishAddressProviderDefaultPublishAddress(t *testing.T) { + fake := &fakeDockerNetworkAPI{network: networkapi.Inspect{ + Name: "bridge", + IPAM: networkapi.IPAM{Config: []networkapi.IPAMConfig{ + {Subnet: "172.17.0.0/16", Gateway: "172.17.0.1"}, + {Subnet: "fd00::/64", Gateway: "fd00::1"}, + }}, + }} + provider := &DockerPublishAddressProvider{client: func() (dockerNetworkAPI, error) { return fake, nil }} + got, err := provider.DefaultPublishAddress(context.Background()) + if err != nil || got != "172.17.0.1" { + t.Fatalf("DefaultPublishAddress() = %q, %v", got, err) + } +} + +func TestDockerPublishAddressProviderRejectsMissingIPv4Gateway(t *testing.T) { + fake := &fakeDockerNetworkAPI{network: networkapi.Inspect{ + Name: "bridge", + IPAM: networkapi.IPAM{Config: []networkapi.IPAMConfig{{Subnet: "fd00::/64", Gateway: "fd00::1"}}}, + }} + provider := &DockerPublishAddressProvider{client: func() (dockerNetworkAPI, error) { return fake, nil }} + _, err := provider.DefaultPublishAddress(context.Background()) + if err == nil || !strings.Contains(err.Error(), "has no IPv4 gateway") { + t.Fatalf("DefaultPublishAddress() error = %v", err) + } +} + +func TestIntegrationDockerPublishAddressProviderDataPlane(t *testing.T) { + if os.Getenv("AGENT_COMPOSE_DOCKER_NETWORK_INTEGRATION") != "1" { + t.Skip("set AGENT_COMPOSE_DOCKER_NETWORK_INTEGRATION=1 to run the Docker network data-plane test") + } + ctx, cancel := context.WithTimeout(context.Background(), 90*time.Second) + defer cancel() + provider := NewDockerPublishAddressProvider() + publishAddress, err := provider.DefaultPublishAddress(ctx) + if err != nil { + t.Fatalf("DefaultPublishAddress() error = %v", err) + } + dockerClient, err := client.NewClientWithOpts(client.FromEnv, client.WithAPIVersionNegotiation()) + if err != nil { + t.Fatal(err) + } + defer func() { _ = dockerClient.Close() }() + + guestPort := nat.Port("80/tcp") + target, err := dockerClient.ContainerCreate(ctx, + &containerapi.Config{Image: "nginx:alpine", ExposedPorts: nat.PortSet{guestPort: struct{}{}}}, + &containerapi.HostConfig{ + NetworkMode: "bridge", + PortBindings: nat.PortMap{guestPort: []nat.PortBinding{{HostIP: publishAddress, HostPort: ""}}}, + }, nil, nil, "", + ) + if err != nil { + t.Fatalf("create target container: %v", err) + } + t.Cleanup(func() { + _ = dockerClient.ContainerRemove(context.Background(), target.ID, containerapi.RemoveOptions{Force: true}) + }) + if err := dockerClient.ContainerStart(ctx, target.ID, containerapi.StartOptions{}); err != nil { + t.Fatalf("start target container: %v", err) + } + inspected, err := dockerClient.ContainerInspect(ctx, target.ID) + if err != nil { + t.Fatal(err) + } + published := inspected.NetworkSettings.Ports[guestPort] + if len(published) == 0 || strings.TrimSpace(published[0].HostPort) == "" { + t.Fatalf("target published ports = %#v", published) + } + url := fmt.Sprintf("http://%s:%s", publishAddress, published[0].HostPort) + source, err := dockerClient.ContainerCreate(ctx, + &containerapi.Config{ + Image: "curlimages/curl:latest", Tty: true, + Cmd: []string{"-fsS", "--retry", "10", "--retry-connrefused", "--retry-delay", "1", url}, + }, + &containerapi.HostConfig{NetworkMode: "bridge"}, nil, nil, "", + ) + if err != nil { + t.Fatalf("create source container: %v", err) + } + t.Cleanup(func() { + _ = dockerClient.ContainerRemove(context.Background(), source.ID, containerapi.RemoveOptions{Force: true}) + }) + if err := dockerClient.ContainerStart(ctx, source.ID, containerapi.StartOptions{}); err != nil { + t.Fatalf("start source container: %v", err) + } + wait, waitErr := dockerClient.ContainerWait(ctx, source.ID, containerapi.WaitConditionNotRunning) + select { + case err := <-waitErr: + if err != nil { + t.Fatal(err) + } + case result := <-wait: + if result.StatusCode != 0 { + t.Fatalf("source exit code = %d", result.StatusCode) + } + case <-ctx.Done(): + t.Fatal(ctx.Err()) + } + logs, err := dockerClient.ContainerLogs(ctx, source.ID, containerapi.LogsOptions{ShowStdout: true, ShowStderr: true}) + if err != nil { + t.Fatal(err) + } + defer func() { _ = logs.Close() }() + output, err := io.ReadAll(logs) + if err != nil { + t.Fatal(err) + } + if !strings.Contains(string(output), "Welcome to nginx") { + t.Fatalf("source output does not contain nginx response: %q", output) + } +} + +type fakeDockerNetworkAPI struct { + network networkapi.Inspect +} + +func (f *fakeDockerNetworkAPI) NetworkInspect(context.Context, string, networkapi.InspectOptions) (networkapi.Inspect, error) { + return f.network, nil +} + +func (f *fakeDockerNetworkAPI) Close() error { return nil } diff --git a/pkg/agentcompose/adapters/network_ports.go b/pkg/agentcompose/adapters/network_ports.go new file mode 100644 index 00000000..be560613 --- /dev/null +++ b/pkg/agentcompose/adapters/network_ports.go @@ -0,0 +1,21 @@ +package adapters + +import ( + "context" + "fmt" +) + +type HostPortStore interface { + AllocateHostPortForSandbox(string) (int, error) +} + +type StorePortAllocator struct { + Store HostPortStore +} + +func (a StorePortAllocator) AllocateHostPort(_ context.Context, sandboxID string) (int, error) { + if a.Store == nil { + return 0, fmt.Errorf("host port store is required") + } + return a.Store.AllocateHostPortForSandbox(sandboxID) +} diff --git a/pkg/agentcompose/adapters/session_driver.go b/pkg/agentcompose/adapters/session_driver.go index 1fb8843f..22a4169e 100644 --- a/pkg/agentcompose/adapters/session_driver.go +++ b/pkg/agentcompose/adapters/session_driver.go @@ -2,6 +2,7 @@ package adapters import ( "context" + "fmt" "strings" "time" @@ -17,10 +18,15 @@ import ( ) type SandboxDriver struct { - Config *appconfig.Config - Store *sessionstore.Store - ConfigDB *configstore.ConfigStore - Runtimes RuntimeProvider + Config *appconfig.Config + Store *sessionstore.Store + ConfigDB *configstore.ConfigStore + Runtimes RuntimeProvider + NetworkPreparer SandboxNetworkPreparer +} + +type SandboxNetworkPreparer interface { + PrepareSandbox(context.Context, *domain.Sandbox) error } var ensureSandboxLLMFacadeConfig = runtimefacade.EnsureSessionLLMFacadeConfig @@ -63,6 +69,22 @@ func (d *SandboxDriver) StartSandboxVM(ctx context.Context, session *domain.Sand if err != nil { return err } + if sandboxHasNetworkIntent(session) { + if d.NetworkPreparer == nil { + err := fmt.Errorf("sandbox network preparer is required") + vmState.LastError = err.Error() + _ = d.Store.SaveVMState(session.Summary.ID, vmState) + return err + } + if err := d.NetworkPreparer.PrepareSandbox(ctx, session); err != nil { + vmState.LastError = err.Error() + _ = d.Store.SaveVMState(session.Summary.ID, vmState) + return err + } + if err := d.Store.UpdateSandbox(ctx, session); err != nil { + return fmt.Errorf("persist sandbox network plan: %w", err) + } + } vmState.Driver = driver vmState.Mode = driver vmState.BoxName = firstNonEmpty(vmState.BoxName, session.Summary.RuntimeRef) @@ -84,6 +106,14 @@ func (d *SandboxDriver) StartSandboxVM(ctx context.Context, session *domain.Sand return d.saveSandboxStartInfo(session, vmState, proxyState, info) } +func sandboxHasNetworkIntent(sandbox *domain.Sandbox) bool { + if sandbox == nil || sandbox.NetworkIntent == nil { + return false + } + intent := sandbox.NetworkIntent + return len(intent.Attachments) > 0 || len(intent.Expose) > 0 || len(intent.Ports) > 0 +} + func (d *SandboxDriver) saveSandboxStartInfo(session *domain.Sandbox, vmState domain.VMState, proxyState domain.ProxyState, info domain.SandboxVMInfo) error { vmState, proxyState = sessions.ApplySessionStartInfo(vmState, proxyState, info, time.Now()) if err := d.Store.SaveVMState(session.Summary.ID, vmState); err != nil { diff --git a/pkg/agentcompose/adapters/session_driver_test.go b/pkg/agentcompose/adapters/session_driver_test.go index e8537d0e..df205469 100644 --- a/pkg/agentcompose/adapters/session_driver_test.go +++ b/pkg/agentcompose/adapters/session_driver_test.go @@ -25,6 +25,28 @@ type fakeSessionRuntime struct { removeErr error } +type fakeSandboxNetworkPreparer struct { + err error + calls int +} + +func (p *fakeSandboxNetworkPreparer) PrepareSandbox(_ context.Context, sandbox *domain.Sandbox) error { + p.calls++ + if p.err != nil { + return p.err + } + sandbox.NetworkState = &domain.SandboxNetworkState{ + Attachments: []domain.SandboxNetworkEndpoint{{ + Name: "frontend", + }}, + Bindings: []domain.SandboxPortBinding{{ + Networks: []string{"frontend"}, HostIP: "10.254.1.1", HostPort: 32000, GuestPort: 8080, + Protocol: "tcp", Visibility: "internal", Publisher: "direct", + }}, + } + return nil +} + func (r fakeSessionRuntime) EnsureSandbox(_ context.Context, session *domain.Sandbox, _ domain.VMState, _ domain.ProxyState) (domain.SandboxVMInfo, error) { if r.ensureHook != nil { r.ensureHook(session) @@ -181,6 +203,76 @@ func TestSandboxDriverStartSandboxVMSavesRuntimeState(t *testing.T) { } } +func TestSandboxDriverPreparesAndPersistsNetworkBeforeRuntimeStart(t *testing.T) { + ctx := context.Background() + root := t.TempDir() + config := &appconfig.Config{ + DataRoot: root, SandboxRoot: filepath.Join(root, "sandboxes"), RuntimeDriver: driverpkg.RuntimeDriverBoxlite, + BoxliteHome: filepath.Join(root, "boxlite"), DefaultImage: "guest:latest", GuestWorkspacePath: "/workspace", + JupyterProxyBasePath: "/agent-compose/session", SandboxStartTimeout: 2 * time.Second, + } + store, err := sessionstore.NewWithConfig(config) + if err != nil { + t.Fatal(err) + } + sandbox, err := store.CreateSandboxWithOptions(ctx, "network", "", driverpkg.RuntimeDriverBoxlite, "guest:latest", "", domain.SandboxTypeManual, nil, nil, nil, sessionstore.CreateSandboxOptions{ + NetworkIntent: &domain.SandboxNetworkIntent{ + ProjectID: "project-1", Attachments: []domain.SandboxNetworkAttachment{{Name: "frontend", Driver: "port_mapping"}}, + Expose: []domain.SandboxNetworkPort{{Target: 8080, Protocol: "tcp"}}, + }, + }) + if err != nil { + t.Fatal(err) + } + preparer := &fakeSandboxNetworkPreparer{} + runtimeCalled := false + driver := NewSandboxDriver(config, store, nil, fakeRuntimeProvider{runtime: fakeSessionRuntime{ensureHook: func(started *domain.Sandbox) { + runtimeCalled = true + if started.NetworkState == nil || len(started.NetworkState.Bindings) != 1 { + t.Fatalf("runtime received network state %#v", started.NetworkState) + } + }}}) + driver.NetworkPreparer = preparer + if err := driver.StartSandboxVM(ctx, sandbox); err != nil { + t.Fatalf("StartSandboxVM() error = %v", err) + } + if preparer.calls != 1 || !runtimeCalled { + t.Fatalf("preparer calls = %d, runtime called = %v", preparer.calls, runtimeCalled) + } + loaded, err := store.GetSandbox(ctx, sandbox.Summary.ID) + if err != nil { + t.Fatal(err) + } + if loaded.NetworkState == nil || loaded.NetworkState.Bindings[0].HostPort != 32000 { + t.Fatalf("persisted network state = %#v", loaded.NetworkState) + } +} + +func TestSandboxDriverFailsClosedWithoutNetworkPreparer(t *testing.T) { + ctx := context.Background() + root := t.TempDir() + config := &appconfig.Config{ + DataRoot: root, SandboxRoot: filepath.Join(root, "sandboxes"), RuntimeDriver: driverpkg.RuntimeDriverDocker, + DefaultImage: "guest:latest", GuestWorkspacePath: "/workspace", JupyterProxyBasePath: "/jupyter", SandboxStartTimeout: time.Second, + } + store, err := sessionstore.NewWithConfig(config) + if err != nil { + t.Fatal(err) + } + sandbox, err := store.CreateSandboxWithOptions(ctx, "network", "", driverpkg.RuntimeDriverDocker, "guest:latest", "", domain.SandboxTypeManual, nil, nil, nil, sessionstore.CreateSandboxOptions{ + NetworkIntent: &domain.SandboxNetworkIntent{Ports: []domain.SandboxPublishedPort{{Published: 19000, Target: 8080, Protocol: "tcp"}}}, + }) + if err != nil { + t.Fatal(err) + } + runtimeCalled := false + driver := NewSandboxDriver(config, store, nil, fakeRuntimeProvider{runtime: fakeSessionRuntime{ensureHook: func(*domain.Sandbox) { runtimeCalled = true }}}) + err = driver.StartSandboxVM(ctx, sandbox) + if err == nil || err.Error() != "sandbox network preparer is required" || runtimeCalled { + t.Fatalf("StartSandboxVM() error = %v, runtime called = %v", err, runtimeCalled) + } +} + func TestSandboxDriverStopSandboxVMAddsDockerStopContextMargin(t *testing.T) { ctx := context.Background() root := t.TempDir() diff --git a/pkg/agentcompose/api/project.go b/pkg/agentcompose/api/project.go index ccccb729..43e5f726 100644 --- a/pkg/agentcompose/api/project.go +++ b/pkg/agentcompose/api/project.go @@ -6,6 +6,7 @@ import ( "fmt" "path/filepath" "slices" + "strconv" "strings" "agent-compose/pkg/capabilities" @@ -234,6 +235,7 @@ func ProjectSpecToProtoChecked(spec *compose.NormalizedProjectSpec) (*agentcompo Network: NetworkSpecToProto(spec.Network), Volumes: ProjectVolumeSpecsToProto(spec.Volumes), Mcps: MCPServerSpecsToProto(spec.MCPs), + Networks: ProjectNetworkSpecsToProto(spec.Networks), }, nil } @@ -275,6 +277,47 @@ func AgentSpecsToProto(agents []compose.NormalizedAgentSpec) []*agentcomposev2.A Volumes: VolumeMountSpecsToProto(agent.Volumes), Mcps: MCPServerSpecsToProto(agent.MCPs), Status: agentStatusToProto(agent.Status), + Networks: append([]string(nil), agent.Networks...), + Expose: ExposedPortSpecsToProto(agent.Expose), + Ports: PublishedPortSpecsToProto(agent.Ports), + }) + } + return items +} + +func ProjectNetworkSpecsToProto(networks map[string]compose.ProjectNetworkSpec) []*agentcomposev2.NamedNetworkSpec { + keys := make([]string, 0, len(networks)) + for key := range networks { + keys = append(keys, key) + } + slices.Sort(keys) + items := make([]*agentcomposev2.NamedNetworkSpec, 0, len(keys)) + for _, key := range keys { + items = append(items, &agentcomposev2.NamedNetworkSpec{Name: key, Driver: networks[key].Driver}) + } + return items +} + +func ExposedPortSpecsToProto(ports []compose.ExposedPortSpec) []*agentcomposev2.ExposedPortSpec { + items := make([]*agentcomposev2.ExposedPortSpec, 0, len(ports)) + for _, port := range ports { + items = append(items, &agentcomposev2.ExposedPortSpec{ + Target: uint32(port.Target), + Protocol: port.Protocol, + HostPort: uint32(port.HostPort), + }) + } + return items +} + +func PublishedPortSpecsToProto(ports []compose.PublishedPortSpec) []*agentcomposev2.PublishedPortSpec { + items := make([]*agentcomposev2.PublishedPortSpec, 0, len(ports)) + for _, port := range ports { + items = append(items, &agentcomposev2.PublishedPortSpec{ + HostIp: port.HostIP, + Published: uint32(port.Published), + Target: uint32(port.Target), + Protocol: port.Protocol, }) } return items @@ -526,9 +569,33 @@ func ProjectSpecYAMLShape(spec *agentcomposev2.ProjectSpec) (map[string]any, []* if network := NetworkYAMLShape(spec.GetNetwork()); len(network) > 0 { root["network"] = network } + if networks, issues := ProjectNetworkYAMLMap(spec.GetNetworks()); len(issues) > 0 { + return nil, issues + } else if len(networks) > 0 { + root["networks"] = networks + } return root, nil } +func ProjectNetworkYAMLMap(networks []*agentcomposev2.NamedNetworkSpec) (map[string]any, []*agentcomposev2.ProjectValidationIssue) { + values := make(map[string]any, len(networks)) + for index, network := range networks { + name := strings.TrimSpace(network.GetName()) + if name == "" { + return nil, []*agentcomposev2.ProjectValidationIssue{ProjectValidationIssue(fmt.Sprintf("networks[%d].name", index), "network name is required")} + } + if _, exists := values[name]; exists { + return nil, []*agentcomposev2.ProjectValidationIssue{ProjectValidationIssue(fmt.Sprintf("networks[%d].name", index), fmt.Sprintf("duplicate network %q", name))} + } + raw := map[string]any{} + if driver := strings.TrimSpace(network.GetDriver()); driver != "" { + raw["driver"] = driver + } + values[name] = raw + } + return values, nil +} + func ProjectVolumeYAMLMap(volumes []*agentcomposev2.ProjectVolumeSpec) (map[string]any, []*agentcomposev2.ProjectValidationIssue) { values := make(map[string]any, len(volumes)) for i, volume := range volumes { @@ -638,6 +705,19 @@ func AgentYAMLMap(agents []*agentcomposev2.AgentSpec) (map[string]any, []*agentc if jupyter := JupyterYAMLShape(agent.GetJupyter()); len(jupyter) > 0 { raw["jupyter"] = jupyter } + if len(agent.GetNetworks()) > 0 { + raw["networks"] = append([]string(nil), agent.GetNetworks()...) + } + if expose, issues := ExposedPortYAMLList(fmt.Sprintf("agents[%d].expose", i), agent.GetExpose()); len(issues) > 0 { + return nil, issues + } else if len(expose) > 0 { + raw["expose"] = expose + } + if ports, issues := PublishedPortYAMLList(fmt.Sprintf("agents[%d].ports", i), agent.GetPorts()); len(issues) > 0 { + return nil, issues + } else if len(ports) > 0 { + raw["ports"] = ports + } if volumes := VolumeMountYAMLList(agent.GetVolumes()); len(volumes) > 0 { raw["volumes"] = volumes } @@ -651,6 +731,55 @@ func AgentYAMLMap(agents []*agentcomposev2.AgentSpec) (map[string]any, []*agentc return values, nil } +func ExposedPortYAMLList(path string, ports []*agentcomposev2.ExposedPortSpec) ([]any, []*agentcomposev2.ProjectValidationIssue) { + result := make([]any, 0, len(ports)) + for index, port := range ports { + if port.GetTarget() == 0 || port.GetTarget() > 65535 || port.GetHostPort() > 65535 { + return nil, []*agentcomposev2.ProjectValidationIssue{ProjectValidationIssue(fmt.Sprintf("%s[%d]", path, index), "target and host_port must be valid TCP ports")} + } + protocol := strings.ToLower(strings.TrimSpace(port.GetProtocol())) + if protocol != "" && protocol != "tcp" { + return nil, []*agentcomposev2.ProjectValidationIssue{ProjectValidationIssue(fmt.Sprintf("%s[%d].protocol", path, index), "only TCP ports are supported")} + } + if port.GetHostPort() == 0 { + result = append(result, strconv.FormatUint(uint64(port.GetTarget()), 10)) + continue + } + result = append(result, map[string]any{ + "target": port.GetTarget(), + "host_port": port.GetHostPort(), + "protocol": "tcp", + }) + } + return result, nil +} + +func PublishedPortYAMLList(path string, ports []*agentcomposev2.PublishedPortSpec) ([]string, []*agentcomposev2.ProjectValidationIssue) { + result := make([]string, 0, len(ports)) + for index, port := range ports { + if port.GetTarget() == 0 || port.GetTarget() > 65535 || port.GetPublished() > 65535 { + return nil, []*agentcomposev2.ProjectValidationIssue{ProjectValidationIssue(fmt.Sprintf("%s[%d]", path, index), "published and target must be valid TCP ports")} + } + protocol := strings.ToLower(strings.TrimSpace(port.GetProtocol())) + if protocol != "" && protocol != "tcp" { + return nil, []*agentcomposev2.ProjectValidationIssue{ProjectValidationIssue(fmt.Sprintf("%s[%d].protocol", path, index), "only TCP ports are supported")} + } + hostIP := strings.TrimSpace(port.GetHostIp()) + target := strconv.FormatUint(uint64(port.GetTarget()), 10) + if port.GetPublished() == 0 { + result = append(result, target) + continue + } + published := strconv.FormatUint(uint64(port.GetPublished()), 10) + if hostIP == "" || hostIP == "127.0.0.1" { + result = append(result, published+":"+target) + continue + } + result = append(result, hostIP+":"+published+":"+target) + } + return result, nil +} + func MCPServerYAMLMap(path string, mcps []*agentcomposev2.MCPServerSpec) (map[string]any, []*agentcomposev2.ProjectValidationIssue) { values := make(map[string]any, len(mcps)) for i, mcp := range mcps { diff --git a/pkg/agentcompose/api/project_test.go b/pkg/agentcompose/api/project_test.go index 77f7fa23..4c8c2184 100644 --- a/pkg/agentcompose/api/project_test.go +++ b/pkg/agentcompose/api/project_test.go @@ -153,6 +153,34 @@ func TestProjectSpecToProtoIncludesJupyter(t *testing.T) { } } +func TestProjectSpecNetworkExposeFixedListenerRoundTrip(t *testing.T) { + spec := &compose.NormalizedProjectSpec{ + Name: "network", + Networks: map[string]compose.ProjectNetworkSpec{"default": {Driver: compose.NetworkDriverPortMapping}}, + Agents: []compose.NormalizedAgentSpec{{ + Name: "api", + Networks: []string{"default"}, + Expose: []compose.ExposedPortSpec{{Target: 8080, HostPort: 18080, Protocol: "tcp"}}, + }}, + } + + protoSpec := ProjectSpecToProto(spec) + port := protoSpec.GetAgents()[0].GetExpose()[0] + if port.GetTarget() != 8080 || port.GetHostPort() != 18080 || port.GetProtocol() != "tcp" { + t.Fatalf("proto expose = %#v", port) + } + raw, issues := ProjectSpecYAMLShape(protoSpec) + if len(issues) != 0 { + t.Fatalf("ProjectSpecYAMLShape() issues = %#v", issues) + } + agents := raw["agents"].(map[string]any) + expose := agents["api"].(map[string]any)["expose"].([]any) + listener := expose[0].(map[string]any) + if listener["target"] != uint32(8080) || listener["host_port"] != uint32(18080) { + t.Fatalf("YAML expose = %#v", expose) + } +} + func TestIntegrationProjectSpecToProtoIncludesWorkspaceRegistry(t *testing.T) { spec := &compose.NormalizedProjectSpec{ Name: "workspace-registry", diff --git a/pkg/agentcompose/api/sandbox.go b/pkg/agentcompose/api/sandbox.go index f8c26477..49bb78f4 100644 --- a/pkg/agentcompose/api/sandbox.go +++ b/pkg/agentcompose/api/sandbox.go @@ -379,6 +379,7 @@ func sandboxToV2WithTarget(sandbox *domain.Sandbox, target runs.SandboxRunTarget EventCount: uint32(sandbox.Summary.EventCount), ProjectId: target.ProjectID, AgentName: target.AgentName, + Network: SandboxNetworkStateToProto(sandbox.NetworkState), } for _, tag := range sandbox.Summary.Tags { result.Tags = append(result.Tags, &agentcomposev2.SandboxTag{Name: tag.Name, Value: tag.Value}) @@ -386,6 +387,30 @@ func sandboxToV2WithTarget(sandbox *domain.Sandbox, target runs.SandboxRunTarget return result } +func SandboxNetworkStateToProto(state *domain.SandboxNetworkState) *agentcomposev2.SandboxNetworkState { + if state == nil { + return nil + } + result := &agentcomposev2.SandboxNetworkState{} + for _, attachment := range state.Attachments { + result.Attachments = append(result.Attachments, &agentcomposev2.SandboxNetworkEndpoint{ + Name: attachment.Name, + }) + } + for _, binding := range state.Bindings { + result.Bindings = append(result.Bindings, &agentcomposev2.SandboxPortBinding{ + Networks: append([]string(nil), binding.Networks...), + HostIp: binding.HostIP, + HostPort: uint32(binding.HostPort), + GuestPort: uint32(binding.GuestPort), + Protocol: binding.Protocol, + Visibility: binding.Visibility, + Publisher: binding.Publisher, + }) + } + return result +} + func (h *SandboxHandler) sandboxToV2(ctx context.Context, sandbox *domain.Sandbox) *agentcomposev2.Sandbox { if h.runTargets == nil || sandbox == nil { return sandboxToV2(sandbox) diff --git a/pkg/agentcompose/api/sandbox_characterization_test.go b/pkg/agentcompose/api/sandbox_characterization_test.go index ee9a30c1..e6b384a0 100644 --- a/pkg/agentcompose/api/sandbox_characterization_test.go +++ b/pkg/agentcompose/api/sandbox_characterization_test.go @@ -78,6 +78,29 @@ func TestV2GetSandboxIncludesSavedExposedNotebookURL(t *testing.T) { } } +func TestV2GetSandboxIncludesNetworkEndpoints(t *testing.T) { + const sandboxID = "28fed243-4d9d-4e56-96cf-8b2baa8643c8" + store := &characterizationSandboxStore{session: &domain.Sandbox{ + Summary: domain.SandboxSummary{ID: sandboxID}, + NetworkState: &domain.SandboxNetworkState{ + Attachments: []domain.SandboxNetworkEndpoint{{Name: "frontend"}}, + Bindings: []domain.SandboxPortBinding{{Networks: []string{"frontend"}, HostIP: "10.254.1.1", HostPort: 32000, GuestPort: 8080, Protocol: "tcp", Visibility: "internal", Publisher: "docker"}}, + }, + }} + handler := NewSandboxHandler(&characterizationSessionDelegate{}, store, &characterizationSandboxRemover{}, nil) + response, err := handler.GetSandbox(context.Background(), connect.NewRequest(&agentcomposev2.GetSandboxRequest{SandboxId: sandboxID})) + if err != nil { + t.Fatalf("GetSandbox() error = %v", err) + } + network := response.Msg.GetSandbox().GetNetwork() + if network == nil || len(network.GetAttachments()) != 1 || len(network.GetBindings()) != 1 { + t.Fatalf("sandbox network = %#v", network) + } + if got := network.GetBindings()[0]; got.GetHostIp() != "10.254.1.1" || got.GetHostPort() != 32000 || got.GetGuestPort() != 8080 { + t.Fatalf("sandbox binding = %#v", got) + } +} + func TestGetSandboxDoesNotPrepareProxyForStoppedSandbox(t *testing.T) { const sandboxID = "28fed243-4d9d-4e56-96cf-8b2baa8643c8" delegate := &characterizationSessionDelegate{} diff --git a/pkg/agentcompose/app/app.go b/pkg/agentcompose/app/app.go index e8877efa..5d4f70a5 100644 --- a/pkg/agentcompose/app/app.go +++ b/pkg/agentcompose/app/app.go @@ -26,6 +26,7 @@ import ( "agent-compose/pkg/llms" "agent-compose/pkg/loaders" domain "agent-compose/pkg/model" + "agent-compose/pkg/networks" "agent-compose/pkg/projects" "agent-compose/pkg/resources" "agent-compose/pkg/runs" @@ -56,6 +57,7 @@ func RegisterDependencies(di do.Injector) { do.Provide(di, NewWorkspaceProvisioner) do.MustAs[*workspaces.Provisioner, workspaces.WorkspaceEnsurer](di) do.Provide(di, NewRuntimeProvider) + do.Provide(di, NewSandboxNetworkManager) do.Provide(di, NewLLMClient) do.Provide(di, NewCapabilityProvider) do.Provide(di, NewCapabilitySandboxResolver) @@ -244,12 +246,26 @@ func NewLLMClient(di do.Injector) (*adapters.LLMClient, error) { } func NewSandboxDriver(di do.Injector) (*adapters.SandboxDriver, error) { - return adapters.NewSandboxDriver( + driver := adapters.NewSandboxDriver( do.MustInvoke[*appconfig.Config](di), do.MustInvoke[*sessionstore.Store](di), do.MustInvoke[*configstore.ConfigStore](di), do.MustInvoke[adapters.RuntimeProvider](di), - ), nil + ) + driver.NetworkPreparer = do.MustInvoke[*networks.Manager](di) + return driver, nil +} + +func NewSandboxNetworkManager(di do.Injector) (*networks.Manager, error) { + config := do.MustInvoke[*appconfig.Config](di) + return &networks.Manager{ + PublishAddresses: adapters.NewDockerPublishAddressProvider(), + Ports: adapters.StorePortAllocator{ + Store: do.MustInvoke[*sessionstore.Store](di), + }, + DockerPublishAddress: config.NetworkDockerPublishAddress, + RuntimePublishAddress: config.NetworkRuntimePublishAddress, + }, nil } func NewCellExecutor(di do.Injector) (*adapters.CellExecutor, error) { diff --git a/pkg/compose/network.go b/pkg/compose/network.go new file mode 100644 index 00000000..32c6b42d --- /dev/null +++ b/pkg/compose/network.go @@ -0,0 +1,299 @@ +package compose + +import ( + "fmt" + "net/netip" + "slices" + "strconv" + "strings" + + "gopkg.in/yaml.v3" +) + +const NetworkDriverPortMapping = "port_mapping" + +type ExposedPortSpec struct { + Target int `yaml:"target" json:"target"` + HostPort int `yaml:"host_port,omitempty" json:"host_port,omitempty"` + Protocol string `yaml:"protocol" json:"protocol"` +} + +func (s *ExposedPortSpec) UnmarshalYAML(value *yaml.Node) error { + switch value.Kind { + case yaml.ScalarNode: + parsed, err := parseExposedPort(value.Value) + if err != nil { + return err + } + *s = parsed + return nil + case yaml.MappingNode: + type exposedPortSpec ExposedPortSpec + var decoded exposedPortSpec + if err := value.Decode(&decoded); err != nil { + return err + } + *s = ExposedPortSpec(decoded) + return nil + default: + return fmt.Errorf("expose entry must use short or long syntax") + } +} + +func (s ExposedPortSpec) MarshalYAML() (any, error) { + if s.HostPort == 0 && (s.Protocol == "" || s.Protocol == "tcp") { + return strconv.Itoa(s.Target), nil + } + if s.HostPort != 0 { + type exposedPortSpec ExposedPortSpec + return exposedPortSpec(s), nil + } + return fmt.Sprintf("%d/%s", s.Target, s.Protocol), nil +} + +type PublishedPortSpec struct { + HostIP string `yaml:"host_ip" json:"host_ip"` + Published int `yaml:"published" json:"published"` + Target int `yaml:"target" json:"target"` + Protocol string `yaml:"protocol" json:"protocol"` +} + +func (s *PublishedPortSpec) UnmarshalYAML(value *yaml.Node) error { + if value.Kind != yaml.ScalarNode { + return fmt.Errorf("ports entry must use short syntax") + } + parsed, err := parsePublishedPort(value.Value) + if err != nil { + return err + } + *s = parsed + return nil +} + +func (s PublishedPortSpec) MarshalYAML() (any, error) { + protocol := "" + if s.Protocol != "" && s.Protocol != "tcp" { + protocol = "/" + s.Protocol + } + if s.Published == 0 { + return strconv.Itoa(s.Target) + protocol, nil + } + if s.HostIP == "" || s.HostIP == "127.0.0.1" { + return fmt.Sprintf("%d:%d%s", s.Published, s.Target, protocol), nil + } + return fmt.Sprintf("%s:%d:%d%s", s.HostIP, s.Published, s.Target, protocol), nil +} + +func normalizeProjectNetworks(values map[string]ProjectNetworkSpec) (map[string]ProjectNetworkSpec, error) { + if len(values) == 0 { + return nil, nil + } + keys := make([]string, 0, len(values)) + for key := range values { + keys = append(keys, key) + } + slices.Sort(keys) + result := make(map[string]ProjectNetworkSpec, len(values)) + for _, rawName := range keys { + name := strings.TrimSpace(rawName) + if err := validateStableIdentifier(joinPath("networks", rawName), name, "network name"); err != nil { + return nil, err + } + if _, exists := result[name]; exists { + return nil, &ValidationError{Path: joinPath("networks", rawName), Message: fmt.Sprintf("duplicate network %q", name)} + } + driver := strings.ToLower(strings.TrimSpace(values[rawName].Driver)) + if driver == "" { + driver = NetworkDriverPortMapping + } + if driver != NetworkDriverPortMapping { + return nil, &ValidationError{Path: joinPath("networks", name) + ".driver", Message: fmt.Sprintf("unsupported network driver %q", driver)} + } + result[name] = ProjectNetworkSpec{Driver: driver} + } + return result, nil +} + +func normalizeAgentNetworkConfig(path string, agent AgentSpec, available map[string]ProjectNetworkSpec, enabled bool) ([]string, []ExposedPortSpec, []PublishedPortSpec, error) { + expose, err := normalizeExposedPorts(path+".expose", agent.Expose) + if err != nil { + return nil, nil, nil, err + } + ports, err := normalizePublishedPorts(path+".ports", agent.Ports) + if err != nil { + return nil, nil, nil, err + } + if !enabled { + return nil, expose, ports, nil + } + networks := normalizeStringList(agent.Networks) + if len(networks) == 0 { + networks = []string{"default"} + } + for _, name := range networks { + if _, ok := available[name]; !ok { + return nil, nil, nil, &ValidationError{Path: path + ".networks", Message: fmt.Sprintf("unknown network %q", name)} + } + } + return networks, expose, ports, nil +} + +func normalizeExposedPorts(path string, values []ExposedPortSpec) ([]ExposedPortSpec, error) { + result := make([]ExposedPortSpec, 0, len(values)) + seenTargets := make(map[int]struct{}, len(values)) + seenHostPorts := make(map[int]struct{}, len(values)) + for index, value := range values { + protocol, err := normalizeTCPProtocol(value.Protocol) + if err != nil { + return nil, &ValidationError{Path: fmt.Sprintf("%s[%d]", path, index), Message: err.Error()} + } + if err := validatePort(value.Target); err != nil { + return nil, &ValidationError{Path: fmt.Sprintf("%s[%d].target", path, index), Message: err.Error()} + } + if value.HostPort < 0 || value.HostPort > 65535 { + return nil, &ValidationError{Path: fmt.Sprintf("%s[%d].host_port", path, index), Message: "port must be between 1 and 65535 or omitted"} + } + if _, ok := seenTargets[value.Target]; ok { + return nil, &ValidationError{Path: fmt.Sprintf("%s[%d]", path, index), Message: fmt.Sprintf("duplicate exposed TCP port %d", value.Target)} + } + seenTargets[value.Target] = struct{}{} + if value.HostPort != 0 { + if _, ok := seenHostPorts[value.HostPort]; ok { + return nil, &ValidationError{Path: fmt.Sprintf("%s[%d].host_port", path, index), Message: fmt.Sprintf("duplicate listener TCP port %d", value.HostPort)} + } + seenHostPorts[value.HostPort] = struct{}{} + } + result = append(result, ExposedPortSpec{Target: value.Target, HostPort: value.HostPort, Protocol: protocol}) + } + slices.SortFunc(result, func(a, b ExposedPortSpec) int { return a.Target - b.Target }) + return result, nil +} + +func normalizePublishedPorts(path string, values []PublishedPortSpec) ([]PublishedPortSpec, error) { + result := make([]PublishedPortSpec, 0, len(values)) + seen := make(map[string]struct{}, len(values)) + for index, value := range values { + protocol, err := normalizeTCPProtocol(value.Protocol) + if err != nil { + return nil, &ValidationError{Path: fmt.Sprintf("%s[%d]", path, index), Message: err.Error()} + } + if err := validatePort(value.Target); err != nil { + return nil, &ValidationError{Path: fmt.Sprintf("%s[%d].target", path, index), Message: err.Error()} + } + if value.Published < 0 || value.Published > 65535 { + return nil, &ValidationError{Path: fmt.Sprintf("%s[%d].published", path, index), Message: "port must be between 1 and 65535 or omitted"} + } + hostIP := strings.TrimSpace(value.HostIP) + if hostIP == "" { + hostIP = "127.0.0.1" + } + addr, err := netip.ParseAddr(hostIP) + if err != nil || !addr.Is4() { + return nil, &ValidationError{Path: fmt.Sprintf("%s[%d].host_ip", path, index), Message: "host IP must be a valid IPv4 address"} + } + key := fmt.Sprintf("%s/%d/%d", hostIP, value.Published, value.Target) + if _, ok := seen[key]; ok { + return nil, &ValidationError{Path: fmt.Sprintf("%s[%d]", path, index), Message: "duplicate published TCP port"} + } + seen[key] = struct{}{} + result = append(result, PublishedPortSpec{HostIP: hostIP, Published: value.Published, Target: value.Target, Protocol: protocol}) + } + slices.SortFunc(result, func(a, b PublishedPortSpec) int { + if compare := strings.Compare(a.HostIP, b.HostIP); compare != 0 { + return compare + } + if a.Published != b.Published { + return a.Published - b.Published + } + return a.Target - b.Target + }) + return result, nil +} + +func parseExposedPort(raw string) (ExposedPortSpec, error) { + port, protocol, err := splitPortProtocol(raw) + if err != nil { + return ExposedPortSpec{}, err + } + target, err := parsePort(port) + if err != nil { + return ExposedPortSpec{}, err + } + return ExposedPortSpec{Target: target, Protocol: protocol}, nil +} + +func parsePublishedPort(raw string) (PublishedPortSpec, error) { + value, protocol, err := splitPortProtocol(raw) + if err != nil { + return PublishedPortSpec{}, err + } + parts := strings.Split(value, ":") + result := PublishedPortSpec{HostIP: "127.0.0.1", Protocol: protocol} + switch len(parts) { + case 1: + result.Target, err = parsePort(parts[0]) + case 2: + result.Published, err = parsePort(parts[0]) + if err == nil { + result.Target, err = parsePort(parts[1]) + } + case 3: + result.HostIP = strings.TrimSpace(parts[0]) + result.Published, err = parsePort(parts[1]) + if err == nil { + result.Target, err = parsePort(parts[2]) + } + default: + return PublishedPortSpec{}, fmt.Errorf("ports entry %q must use TARGET, PUBLISHED:TARGET, or HOST_IP:PUBLISHED:TARGET", raw) + } + if err != nil { + return PublishedPortSpec{}, err + } + return result, nil +} + +func splitPortProtocol(raw string) (string, string, error) { + value := strings.TrimSpace(raw) + if value == "" { + return "", "", fmt.Errorf("port entry is required") + } + protocol := "tcp" + if base, suffix, ok := strings.Cut(value, "/"); ok { + value = strings.TrimSpace(base) + protocol = strings.ToLower(strings.TrimSpace(suffix)) + } + protocol, err := normalizeTCPProtocol(protocol) + if err != nil { + return "", "", err + } + return value, protocol, nil +} + +func normalizeTCPProtocol(protocol string) (string, error) { + protocol = strings.ToLower(strings.TrimSpace(protocol)) + if protocol == "" { + protocol = "tcp" + } + if protocol != "tcp" { + return "", fmt.Errorf("only TCP ports are supported") + } + return protocol, nil +} + +func parsePort(value string) (int, error) { + port, err := strconv.Atoi(strings.TrimSpace(value)) + if err != nil { + return 0, fmt.Errorf("invalid port %q", value) + } + if err := validatePort(port); err != nil { + return 0, err + } + return port, nil +} + +func validatePort(port int) error { + if port < 1 || port > 65535 { + return fmt.Errorf("port must be between 1 and 65535") + } + return nil +} diff --git a/pkg/compose/network_test.go b/pkg/compose/network_test.go new file mode 100644 index 00000000..5f624261 --- /dev/null +++ b/pkg/compose/network_test.go @@ -0,0 +1,186 @@ +package compose + +import ( + "strings" + "testing" +) + +func TestNormalizeComposeNetworksAndTCPPorts(t *testing.T) { + spec := mustParseNetworkCompose(t, ` +name: network-demo +networks: + frontend: {} + backend: + driver: port_mapping +agents: + api: + networks: [frontend, backend] + expose: + - target: 9000 + host_port: 18000 + protocol: tcp + ports: + - "127.0.0.1:19000:9000" + - "9001" + worker: + networks: [backend] +`) + + normalized, err := Normalize(spec, NormalizeOptions{}) + if err != nil { + t.Fatalf("Normalize() error = %v", err) + } + if got := normalized.Networks["frontend"].Driver; got != NetworkDriverPortMapping { + t.Fatalf("frontend driver = %q, want %q", got, NetworkDriverPortMapping) + } + api := normalized.Agents[0] + if api.Name != "api" || strings.Join(api.Networks, ",") != "frontend,backend" { + t.Fatalf("api networks = %#v", api.Networks) + } + if len(api.Expose) != 1 || api.Expose[0] != (ExposedPortSpec{Target: 9000, HostPort: 18000, Protocol: "tcp"}) { + t.Fatalf("api expose = %#v", api.Expose) + } + if len(api.Ports) != 2 { + t.Fatalf("api ports = %#v", api.Ports) + } + if got := api.Ports[0]; got != (PublishedPortSpec{HostIP: "127.0.0.1", Published: 0, Target: 9001, Protocol: "tcp"}) { + t.Fatalf("dynamic port = %#v", got) + } + if got := api.Ports[1]; got != (PublishedPortSpec{HostIP: "127.0.0.1", Published: 19000, Target: 9000, Protocol: "tcp"}) { + t.Fatalf("fixed port = %#v", got) + } +} + +func TestNormalizeComposeNetworkAddsImplicitDefault(t *testing.T) { + spec := mustParseNetworkCompose(t, ` +name: network-default +agents: + api: + expose: ["8080"] + worker: {} +`) + normalized, err := Normalize(spec, NormalizeOptions{}) + if err != nil { + t.Fatalf("Normalize() error = %v", err) + } + if got := normalized.Networks["default"].Driver; got != NetworkDriverPortMapping { + t.Fatalf("default driver = %q", got) + } + for _, agent := range normalized.Agents { + if len(agent.Networks) != 1 || agent.Networks[0] != "default" { + t.Fatalf("%s networks = %#v", agent.Name, agent.Networks) + } + } +} + +func TestNormalizeComposePortsWithoutNetworksDoesNotEnableInternalNetworking(t *testing.T) { + spec := mustParseNetworkCompose(t, ` +name: external-only +agents: + api: + ports: ["19000:9000"] +`) + normalized, err := Normalize(spec, NormalizeOptions{}) + if err != nil { + t.Fatalf("Normalize() error = %v", err) + } + if len(normalized.Networks) != 0 || len(normalized.Agents[0].Networks) != 0 { + t.Fatalf("ports unexpectedly enabled internal networking: project=%#v agent=%#v", normalized.Networks, normalized.Agents[0].Networks) + } +} + +func TestNormalizeComposeNetworkValidation(t *testing.T) { + tests := []struct { + name string + raw string + want string + }{ + { + name: "unknown network", + raw: "name: demo\nnetworks:\n frontend: {}\nagents:\n api:\n networks: [missing]\n", + want: `unknown network "missing"`, + }, + { + name: "unsupported driver", + raw: "name: demo\nnetworks:\n frontend:\n driver: bridge\nagents:\n api: {}\n", + want: `unsupported network driver "bridge"`, + }, + { + name: "udp expose", + raw: "name: demo\nagents:\n api:\n expose: [\"53/udp\"]\n", + want: "only TCP ports are supported", + }, + { + name: "invalid expose host port", + raw: "name: demo\nagents:\n api:\n expose:\n - target: 8080\n host_port: 70000\n", + want: "port must be between 1 and 65535 or omitted", + }, + { + name: "duplicate expose listener port", + raw: "name: demo\nagents:\n api:\n expose:\n - target: 8080\n host_port: 18080\n - target: 9090\n host_port: 18080\n", + want: "duplicate listener TCP port 18080", + }, + { + name: "unknown expose field", + raw: "name: demo\nagents:\n api:\n expose:\n - target: 8080\n published: 18080\n", + want: "unknown field", + }, + { + name: "invalid host IP", + raw: "name: demo\nagents:\n api:\n ports: [\"localhost:19000:9000\"]\n", + want: "host IP must be a valid IPv4 address", + }, + } + for _, test := range tests { + t.Run(test.name, func(t *testing.T) { + spec, err := Parse([]byte(test.raw)) + if err == nil { + _, err = Normalize(spec, NormalizeOptions{}) + } + if err == nil || !strings.Contains(err.Error(), test.want) { + t.Fatalf("Normalize() error = %v, want containing %q", err, test.want) + } + }) + } +} + +func TestComposeNetworkCanonicalRoundTrip(t *testing.T) { + spec := mustParseNetworkCompose(t, ` +name: round-trip +networks: + backend: {} +agents: + api: + networks: [backend] + expose: + - target: 9000 + host_port: 18000 + ports: ["0.0.0.0:19000:9000"] +`) + normalized, err := Normalize(spec, NormalizeOptions{}) + if err != nil { + t.Fatalf("Normalize() error = %v", err) + } + data, err := normalized.MarshalCanonicalJSON(false) + if err != nil { + t.Fatalf("MarshalCanonicalJSON() error = %v", err) + } + if !strings.Contains(string(data), `"networks":[{"name":"backend","driver":"port_mapping"}]`) { + t.Fatalf("canonical JSON missing ordered networks: %s", data) + } + if !strings.Contains(string(data), `"expose":[{"target":9000,"host_port":18000,"protocol":"tcp"}]`) { + t.Fatalf("canonical JSON missing fixed expose listener: %s", data) + } + if !strings.Contains(string(data), `"ports":[{"host_ip":"0.0.0.0","published":19000,"target":9000,"protocol":"tcp"}]`) { + t.Fatalf("canonical JSON missing port mapping: %s", data) + } +} + +func mustParseNetworkCompose(t *testing.T, raw string) *ProjectSpec { + t.Helper() + spec, err := Parse([]byte(raw)) + if err != nil { + t.Fatalf("Parse() error = %v", err) + } + return spec +} diff --git a/pkg/compose/normalize.go b/pkg/compose/normalize.go index bf8f8857..2f7eb6e1 100644 --- a/pkg/compose/normalize.go +++ b/pkg/compose/normalize.go @@ -44,6 +44,7 @@ type NormalizedProjectSpec struct { Volumes map[string]NormalizedVolumeSpec `yaml:"volumes,omitempty" json:"volumes,omitempty"` Agents []NormalizedAgentSpec `yaml:"agents,omitempty" json:"agents,omitempty"` Network *NetworkSpec `yaml:"network,omitempty" json:"network,omitempty"` + Networks map[string]ProjectNetworkSpec `yaml:"networks,omitempty" json:"networks,omitempty"` } type NormalizedAgentSpec struct { @@ -63,6 +64,9 @@ type NormalizedAgentSpec struct { Workspace *WorkspaceSpec `yaml:"workspace,omitempty" json:"workspace,omitempty"` Scheduler *NormalizedSchedulerSpec `yaml:"scheduler,omitempty" json:"scheduler,omitempty"` Jupyter *JupyterSpec `yaml:"jupyter,omitempty" json:"jupyter,omitempty"` + Networks []string `yaml:"networks,omitempty" json:"networks,omitempty"` + Expose []ExposedPortSpec `yaml:"expose,omitempty" json:"expose,omitempty"` + Ports []PublishedPortSpec `yaml:"ports,omitempty" json:"ports,omitempty"` } type NormalizedMCPServerSpec struct { @@ -179,6 +183,35 @@ func Normalize(spec *ProjectSpec, options NormalizeOptions) (*NormalizedProjectS Variables: nil, Network: normalizeNetworkDefault(spec.Network), } + networkingEnabled := len(spec.Networks) > 0 + for _, agent := range spec.Agents { + if len(agent.Networks) > 0 || len(agent.Expose) > 0 { + networkingEnabled = true + break + } + } + networks, err := normalizeProjectNetworks(spec.Networks) + if err != nil { + return nil, err + } + if networkingEnabled { + needsDefault := len(networks) == 0 + for _, agent := range spec.Agents { + if len(agent.Networks) == 0 { + needsDefault = true + break + } + } + if networks == nil { + networks = make(map[string]ProjectNetworkSpec) + } + if needsDefault { + if _, ok := networks["default"]; !ok { + networks["default"] = ProjectNetworkSpec{Driver: NetworkDriverPortMapping} + } + } + } + normalized.Networks = networks variables, err := normalizeEnvVarMap("variables", spec.Variables, options) if err != nil { return nil, err @@ -214,7 +247,7 @@ func Normalize(spec *ProjectSpec, options NormalizeOptions) (*NormalizedProjectS return nil, err } agent := spec.Agents[agentName] - normalizedAgent, err := normalizeAgent(agentName, agent, options, normalized.Volumes, normalized.Workspaces, normalized.MCPs) + normalizedAgent, err := normalizeAgent(agentName, agent, options, normalized.Volumes, normalized.Workspaces, normalized.MCPs, normalized.Networks, networkingEnabled) if err != nil { return nil, err } @@ -236,7 +269,7 @@ func NormalizeFile(path string) (*NormalizedProjectSpec, error) { return normalized, nil } -func normalizeAgent(name string, agent AgentSpec, options NormalizeOptions, projectVolumes map[string]NormalizedVolumeSpec, projectWorkspaces map[string]WorkspaceSpec, projectMCPs map[string]NormalizedMCPServerSpec) (NormalizedAgentSpec, error) { +func normalizeAgent(name string, agent AgentSpec, options NormalizeOptions, projectVolumes map[string]NormalizedVolumeSpec, projectWorkspaces map[string]WorkspaceSpec, projectMCPs map[string]NormalizedMCPServerSpec, projectNetworks map[string]ProjectNetworkSpec, networkingEnabled bool) (NormalizedAgentSpec, error) { status := strings.ToLower(strings.TrimSpace(agent.Status)) if status != "" && status != "enabled" && status != "disabled" { return NormalizedAgentSpec{}, fmt.Errorf("%s.status must be enabled or disabled", joinPath("agents", name)) @@ -281,6 +314,10 @@ func normalizeAgent(name string, agent AgentSpec, options NormalizeOptions, proj if err != nil { return NormalizedAgentSpec{}, err } + networks, expose, ports, err := normalizeAgentNetworkConfig(joinPath("agents", name), agent, projectNetworks, networkingEnabled) + if err != nil { + return NormalizedAgentSpec{}, err + } return NormalizedAgentSpec{ Name: name, Status: status, @@ -298,6 +335,9 @@ func normalizeAgent(name string, agent AgentSpec, options NormalizeOptions, proj Workspace: workspace, Scheduler: scheduler, Jupyter: jupyter, + Networks: networks, + Expose: expose, + Ports: ports, }, nil } diff --git a/pkg/compose/output.go b/pkg/compose/output.go index 1279d7ba..ed9b3c41 100644 --- a/pkg/compose/output.go +++ b/pkg/compose/output.go @@ -25,6 +25,12 @@ type orderedProjectSpec struct { Volumes []orderedVolumeSpec `yaml:"volumes,omitempty" json:"volumes,omitempty"` Agents []orderedAgentSpec `yaml:"agents,omitempty" json:"agents,omitempty"` Network *NetworkSpec `yaml:"network,omitempty" json:"network,omitempty"` + Networks []orderedNetworkSpec `yaml:"networks,omitempty" json:"networks,omitempty"` +} + +type orderedNetworkSpec struct { + Name string `yaml:"name" json:"name"` + Driver string `yaml:"driver" json:"driver"` } type orderedNamedWorkspace struct { @@ -53,6 +59,9 @@ type orderedAgentSpec struct { Workspace *WorkspaceSpec `yaml:"workspace,omitempty" json:"workspace,omitempty"` Scheduler *NormalizedSchedulerSpec `yaml:"scheduler,omitempty" json:"scheduler,omitempty"` Jupyter *JupyterSpec `yaml:"jupyter,omitempty" json:"jupyter,omitempty"` + Networks []string `yaml:"networks,omitempty" json:"networks,omitempty"` + Expose []ExposedPortSpec `yaml:"expose,omitempty" json:"expose,omitempty"` + Ports []PublishedPortSpec `yaml:"ports,omitempty" json:"ports,omitempty"` } type orderedMCPServerSpec struct { @@ -146,6 +155,9 @@ func (s *NormalizedProjectSpec) ordered(redactSecrets bool) orderedProjectSpec { Workspace: cloneWorkspaceSpec(agent.Workspace), Scheduler: cloneNormalizedSchedulerSpec(agent.Scheduler), Jupyter: cloneJupyterSpec(agent.Jupyter), + Networks: slices.Clone(agent.Networks), + Expose: slices.Clone(agent.Expose), + Ports: slices.Clone(agent.Ports), }) } slices.SortFunc(agents, func(a, b orderedAgentSpec) int { @@ -159,6 +171,7 @@ func (s *NormalizedProjectSpec) ordered(redactSecrets bool) orderedProjectSpec { Volumes: orderedVolumes(s.Volumes), Agents: agents, Network: cloneNetworkSpecForOutput(s.Network), + Networks: orderedNetworks(s.Networks), } } @@ -171,6 +184,7 @@ func (s *NormalizedProjectSpec) clone(redactSecrets bool) *NormalizedProjectSpec MCPs: mcpMapFromOrdered(ordered.MCPs), Volumes: volumeMapFromOrdered(ordered.Volumes), Network: ordered.Network, + Networks: networkMapFromOrdered(ordered.Networks), } for _, agent := range ordered.Agents { cloned.Agents = append(cloned.Agents, NormalizedAgentSpec{ @@ -190,11 +204,41 @@ func (s *NormalizedProjectSpec) clone(redactSecrets bool) *NormalizedProjectSpec Workspace: agent.Workspace, Scheduler: agent.Scheduler, Jupyter: agent.Jupyter, + Networks: slices.Clone(agent.Networks), + Expose: slices.Clone(agent.Expose), + Ports: slices.Clone(agent.Ports), }) } return cloned } +func orderedNetworks(values map[string]ProjectNetworkSpec) []orderedNetworkSpec { + if len(values) == 0 { + return nil + } + keys := make([]string, 0, len(values)) + for key := range values { + keys = append(keys, key) + } + slices.Sort(keys) + result := make([]orderedNetworkSpec, 0, len(keys)) + for _, key := range keys { + result = append(result, orderedNetworkSpec{Name: key, Driver: values[key].Driver}) + } + return result +} + +func networkMapFromOrdered(values []orderedNetworkSpec) map[string]ProjectNetworkSpec { + if len(values) == 0 { + return nil + } + result := make(map[string]ProjectNetworkSpec, len(values)) + for _, value := range values { + result[value.Name] = ProjectNetworkSpec{Driver: value.Driver} + } + return result +} + func orderedWorkspaces(values map[string]WorkspaceSpec) []orderedNamedWorkspace { if len(values) == 0 { return nil diff --git a/pkg/compose/spec.go b/pkg/compose/spec.go index d7d3e06b..62eadaea 100644 --- a/pkg/compose/spec.go +++ b/pkg/compose/spec.go @@ -9,14 +9,15 @@ import ( ) type ProjectSpec struct { - Name string `yaml:"name,omitempty" json:"name,omitempty"` - EnvFiles EnvFileSpec `yaml:"env_file,omitempty" json:"env_file,omitempty"` - Variables map[string]EnvVarSpec `yaml:"variables,omitempty" json:"variables,omitempty"` - Workspaces map[string]WorkspaceSpec `yaml:"workspaces,omitempty" json:"workspaces,omitempty"` - MCPs map[string]MCPServerSpec `yaml:"mcps,omitempty" json:"mcps,omitempty"` - Volumes map[string]VolumeSpec `yaml:"volumes,omitempty" json:"volumes,omitempty"` - Agents map[string]AgentSpec `yaml:"agents,omitempty" json:"agents,omitempty"` - Network *NetworkSpec `yaml:"network,omitempty" json:"network,omitempty"` + Name string `yaml:"name,omitempty" json:"name,omitempty"` + EnvFiles EnvFileSpec `yaml:"env_file,omitempty" json:"env_file,omitempty"` + Variables map[string]EnvVarSpec `yaml:"variables,omitempty" json:"variables,omitempty"` + Workspaces map[string]WorkspaceSpec `yaml:"workspaces,omitempty" json:"workspaces,omitempty"` + MCPs map[string]MCPServerSpec `yaml:"mcps,omitempty" json:"mcps,omitempty"` + Volumes map[string]VolumeSpec `yaml:"volumes,omitempty" json:"volumes,omitempty"` + Agents map[string]AgentSpec `yaml:"agents,omitempty" json:"agents,omitempty"` + Network *NetworkSpec `yaml:"network,omitempty" json:"network,omitempty"` + Networks map[string]ProjectNetworkSpec `yaml:"networks,omitempty" json:"networks,omitempty"` } // EnvFileSpec lists dotenv files used while loading a project configuration. @@ -59,6 +60,9 @@ type AgentSpec struct { Workspace *WorkspaceSpec `yaml:"workspace,omitempty" json:"workspace,omitempty"` Scheduler *SchedulerSpec `yaml:"scheduler,omitempty" json:"scheduler,omitempty"` Jupyter *JupyterSpec `yaml:"jupyter,omitempty" json:"jupyter,omitempty"` + Networks []string `yaml:"networks,omitempty" json:"networks,omitempty"` + Expose []ExposedPortSpec `yaml:"expose,omitempty" json:"expose,omitempty"` + Ports []PublishedPortSpec `yaml:"ports,omitempty" json:"ports,omitempty"` } type AgentMCPEntriesSpec []AgentMCPEntrySpec @@ -208,6 +212,10 @@ type NetworkSpec struct { Mode string `yaml:"mode,omitempty" json:"mode,omitempty"` } +type ProjectNetworkSpec struct { + Driver string `yaml:"driver,omitempty" json:"driver,omitempty"` +} + type DriverSpec struct { Boxlite *BoxliteDriverSpec `yaml:"boxlite,omitempty" json:"boxlite,omitempty"` Docker *DockerDriverSpec `yaml:"docker,omitempty" json:"docker,omitempty"` @@ -473,6 +481,15 @@ func validateProjectNode(node *yaml.Node) error { "volumes": validateVolumeMap, "agents": validateAgentMap, "network": validateNetwork, + "networks": validateProjectNetworkMap, + }) +} + +func validateProjectNetworkMap(node *yaml.Node, path string) error { + return validateNamedMap(node, path, func(node *yaml.Node, path string) error { + return validateMapping(node, path, map[string]nodeValidator{ + "driver": validateScalar, + }) }) } @@ -508,9 +525,38 @@ func validateAgent(node *yaml.Node, path string) error { "workspace": validateWorkspace, "scheduler": validateScheduler, "jupyter": validateJupyter, + "networks": validateStringList, + "expose": validateExposedPortList, + "ports": validateStringList, }) } +func validateExposedPortList(node *yaml.Node, path string) error { + if err := requireKind(node, path, yaml.SequenceNode, "sequence"); err != nil { + return err + } + for index, item := range node.Content { + itemPath := fmt.Sprintf("%s[%d]", path, index) + switch item.Kind { + case yaml.ScalarNode: + if err := validateScalar(item, itemPath); err != nil { + return err + } + case yaml.MappingNode: + if err := validateMapping(item, itemPath, map[string]nodeValidator{ + "target": validateInt, + "host_port": validateInt, + "protocol": validateScalar, + }); err != nil { + return err + } + default: + return newParseError(item, itemPath, "expected scalar or mapping") + } + } + return nil +} + func validateMCPMap(node *yaml.Node, path string) error { return validateNamedMap(node, path, validateMCPServer) } diff --git a/pkg/config/config.go b/pkg/config/config.go index 06f3c283..01bdf77a 100644 --- a/pkg/config/config.go +++ b/pkg/config/config.go @@ -34,61 +34,63 @@ const ( var BuildVersion = "0" type Config struct { - DbAddr string - DbName string - DbTimeout time.Duration - DataRoot string - SandboxRoot string - SandboxRootExplicit bool - HttpListen string - AgentComposeSocket string - AgentComposeHost string - WebhookBodyLimitBytes int64 - WebhookQueueRulesJSON string - WebhookQueueDefaultWorkers int - WorkspaceUploadLimitBytes int64 - LLMAPIEndpoint string - LLMAPIProtocol string - LLMAPIKey string - LLMModel string - LLMTimeout time.Duration - RuntimeBaseURL string - AgentTimeout time.Duration - LoaderRunTimeout time.Duration - RuntimeDriver string - BoxliteHome string - BoxliteRuntimeDir string - DockerHome string - DockerHostSandboxRoot string - DockerDefaultImage string - MicrosandboxHome string - MicrosandboxMSBPath string - MicrosandboxLibPath string - MicrosandboxDefaultImage string - MicrosandboxInsecure []string - MicrosandboxBindQuotaGB int - DefaultImage string - BoxRootfsPath string - ImageRegistry string - ImageStoreMode string - ImageCacheRoot string - ImageInsecureRegistries []string - BoxDiskSizeGB int - BoxCacheTTL time.Duration - ImagePullTimeout time.Duration - GuestWorkspacePath string - GuestHomePath string - GuestStateRoot string - GuestRuntimeRoot string - GuestLogRoot string - JupyterGuestPort int - SandboxStartTimeout time.Duration - SandboxStopTimeout time.Duration - JupyterReadyTimeout time.Duration - JupyterProxyBasePath string - CapGRPCListen string - CapGRPCTarget string - Version string + DbAddr string + DbName string + DbTimeout time.Duration + DataRoot string + SandboxRoot string + SandboxRootExplicit bool + HttpListen string + AgentComposeSocket string + AgentComposeHost string + WebhookBodyLimitBytes int64 + WebhookQueueRulesJSON string + WebhookQueueDefaultWorkers int + WorkspaceUploadLimitBytes int64 + LLMAPIEndpoint string + LLMAPIProtocol string + LLMAPIKey string + LLMModel string + LLMTimeout time.Duration + RuntimeBaseURL string + AgentTimeout time.Duration + LoaderRunTimeout time.Duration + RuntimeDriver string + NetworkDockerPublishAddress string + NetworkRuntimePublishAddress string + BoxliteHome string + BoxliteRuntimeDir string + DockerHome string + DockerHostSandboxRoot string + DockerDefaultImage string + MicrosandboxHome string + MicrosandboxMSBPath string + MicrosandboxLibPath string + MicrosandboxDefaultImage string + MicrosandboxInsecure []string + MicrosandboxBindQuotaGB int + DefaultImage string + BoxRootfsPath string + ImageRegistry string + ImageStoreMode string + ImageCacheRoot string + ImageInsecureRegistries []string + BoxDiskSizeGB int + BoxCacheTTL time.Duration + ImagePullTimeout time.Duration + GuestWorkspacePath string + GuestHomePath string + GuestStateRoot string + GuestRuntimeRoot string + GuestLogRoot string + JupyterGuestPort int + SandboxStartTimeout time.Duration + SandboxStopTimeout time.Duration + JupyterReadyTimeout time.Duration + JupyterProxyBasePath string + CapGRPCListen string + CapGRPCTarget string + Version string } func NewConfig(di do.Injector) (*Config, error) { @@ -200,6 +202,14 @@ func NewConfig(di do.Injector) (*Config, error) { if err := validateRuntimeDriver(runtimeDriver); err != nil { return nil, err } + networkDockerPublishAddress, err := optionalIPv4Env("NETWORK_DOCKER_PUBLISH_ADDRESS") + if err != nil { + return nil, err + } + networkRuntimePublishAddress, err := optionalIPv4Env("NETWORK_RUNTIME_PUBLISH_ADDRESS") + if err != nil { + return nil, err + } boxliteHome := os.Getenv("BOXLITE_HOME") if boxliteHome == "" { @@ -422,61 +432,63 @@ func NewConfig(di do.Injector) (*Config, error) { } return &Config{ - DbAddr: dbPath, - DbName: dbName, - DbTimeout: dbTimeout, - DataRoot: dataRoot, - SandboxRoot: sandboxRoot, - SandboxRootExplicit: sandboxRootExplicit, - HttpListen: httpListen, - AgentComposeSocket: agentComposeSocket, - AgentComposeHost: agentComposeHost, - WebhookBodyLimitBytes: webhookBodyLimitBytes, - WebhookQueueRulesJSON: webhookQueueRulesJSON, - WebhookQueueDefaultWorkers: webhookQueueDefaultWorkers, - WorkspaceUploadLimitBytes: workspaceUploadLimitBytes, - LLMAPIEndpoint: llmAPIEndpoint, - LLMAPIProtocol: llmAPIProtocol, - LLMAPIKey: llmAPIKey, - LLMModel: llmModel, - LLMTimeout: llmTimeout, - RuntimeBaseURL: runtimeBaseURL, - AgentTimeout: agentTimeout, - LoaderRunTimeout: loaderRunTimeout, - RuntimeDriver: runtimeDriver, - BoxliteHome: boxliteHome, - BoxliteRuntimeDir: boxliteRuntimeDir, - DockerHome: dockerHome, - DockerHostSandboxRoot: dockerHostSandboxRoot, - DockerDefaultImage: dockerDefaultImage, - MicrosandboxHome: microsandboxHome, - MicrosandboxMSBPath: microsandboxMSBPath, - MicrosandboxLibPath: microsandboxLibPath, - MicrosandboxDefaultImage: microsandboxDefaultImage, - MicrosandboxInsecure: microsandboxInsecure, - MicrosandboxBindQuotaGB: microsandboxBindQuotaGB, - DefaultImage: defaultImage, - BoxRootfsPath: boxRootfsPath, - ImageRegistry: imageRegistry, - ImageStoreMode: imageStoreMode, - ImageCacheRoot: imageCacheRoot, - ImageInsecureRegistries: imageInsecureRegistries, - BoxDiskSizeGB: boxDiskSizeGB, - BoxCacheTTL: boxCacheTTL, - ImagePullTimeout: imagePullTimeout, - GuestWorkspacePath: guestPaths.GuestWorkspacePath, - GuestHomePath: guestPaths.GuestHomePath, - GuestStateRoot: guestPaths.GuestStateRoot, - GuestRuntimeRoot: guestPaths.GuestRuntimeRoot, - GuestLogRoot: guestPaths.GuestLogRoot, - JupyterGuestPort: jupyterGuestPort, - SandboxStartTimeout: startTimeout, - SandboxStopTimeout: stopTimeout, - JupyterReadyTimeout: jupyterReadyTimeout, - JupyterProxyBasePath: jupyterProxyBase, - CapGRPCListen: strings.TrimSpace(os.Getenv("CAP_GRPC_LISTEN")), - CapGRPCTarget: strings.TrimSpace(os.Getenv("CAP_GRPC_TARGET")), - Version: BuildVersion, + DbAddr: dbPath, + DbName: dbName, + DbTimeout: dbTimeout, + DataRoot: dataRoot, + SandboxRoot: sandboxRoot, + SandboxRootExplicit: sandboxRootExplicit, + HttpListen: httpListen, + AgentComposeSocket: agentComposeSocket, + AgentComposeHost: agentComposeHost, + WebhookBodyLimitBytes: webhookBodyLimitBytes, + WebhookQueueRulesJSON: webhookQueueRulesJSON, + WebhookQueueDefaultWorkers: webhookQueueDefaultWorkers, + WorkspaceUploadLimitBytes: workspaceUploadLimitBytes, + LLMAPIEndpoint: llmAPIEndpoint, + LLMAPIProtocol: llmAPIProtocol, + LLMAPIKey: llmAPIKey, + LLMModel: llmModel, + LLMTimeout: llmTimeout, + RuntimeBaseURL: runtimeBaseURL, + AgentTimeout: agentTimeout, + LoaderRunTimeout: loaderRunTimeout, + RuntimeDriver: runtimeDriver, + NetworkDockerPublishAddress: networkDockerPublishAddress, + NetworkRuntimePublishAddress: networkRuntimePublishAddress, + BoxliteHome: boxliteHome, + BoxliteRuntimeDir: boxliteRuntimeDir, + DockerHome: dockerHome, + DockerHostSandboxRoot: dockerHostSandboxRoot, + DockerDefaultImage: dockerDefaultImage, + MicrosandboxHome: microsandboxHome, + MicrosandboxMSBPath: microsandboxMSBPath, + MicrosandboxLibPath: microsandboxLibPath, + MicrosandboxDefaultImage: microsandboxDefaultImage, + MicrosandboxInsecure: microsandboxInsecure, + MicrosandboxBindQuotaGB: microsandboxBindQuotaGB, + DefaultImage: defaultImage, + BoxRootfsPath: boxRootfsPath, + ImageRegistry: imageRegistry, + ImageStoreMode: imageStoreMode, + ImageCacheRoot: imageCacheRoot, + ImageInsecureRegistries: imageInsecureRegistries, + BoxDiskSizeGB: boxDiskSizeGB, + BoxCacheTTL: boxCacheTTL, + ImagePullTimeout: imagePullTimeout, + GuestWorkspacePath: guestPaths.GuestWorkspacePath, + GuestHomePath: guestPaths.GuestHomePath, + GuestStateRoot: guestPaths.GuestStateRoot, + GuestRuntimeRoot: guestPaths.GuestRuntimeRoot, + GuestLogRoot: guestPaths.GuestLogRoot, + JupyterGuestPort: jupyterGuestPort, + SandboxStartTimeout: startTimeout, + SandboxStopTimeout: stopTimeout, + JupyterReadyTimeout: jupyterReadyTimeout, + JupyterProxyBasePath: jupyterProxyBase, + CapGRPCListen: strings.TrimSpace(os.Getenv("CAP_GRPC_LISTEN")), + CapGRPCTarget: strings.TrimSpace(os.Getenv("CAP_GRPC_TARGET")), + Version: BuildVersion, }, nil } @@ -526,6 +538,18 @@ func validateTCPListenAddress(name, value string) error { return nil } +func optionalIPv4Env(name string) (string, error) { + value := strings.TrimSpace(os.Getenv(name)) + if value == "" { + return "", nil + } + ip := net.ParseIP(value) + if ip == nil || ip.To4() == nil { + return "", fmt.Errorf("%s must be a valid IPv4 address: %q", name, value) + } + return ip.To4().String(), nil +} + func validateAgentComposeHost(value string) error { parsed, err := url.Parse(value) if err != nil { diff --git a/pkg/config/config_test.go b/pkg/config/config_test.go index dd5d0318..26e05a12 100644 --- a/pkg/config/config_test.go +++ b/pkg/config/config_test.go @@ -86,6 +86,36 @@ func TestNewConfigNormalizesJupyterProxyBase(t *testing.T) { } } +func TestNewConfigParsesNetworkPublishAddresses(t *testing.T) { + t.Setenv("DATA_ROOT", filepath.Join(t.TempDir(), "data")) + t.Setenv("NETWORK_DOCKER_PUBLISH_ADDRESS", " 172.23.0.1 ") + t.Setenv("NETWORK_RUNTIME_PUBLISH_ADDRESS", "172.23.0.2") + di := do.New() + do.ProvideValue(di, slog.Default()) + config, err := NewConfig(di) + if err != nil { + t.Fatalf("NewConfig() error = %v", err) + } + if config.NetworkDockerPublishAddress != "172.23.0.1" || config.NetworkRuntimePublishAddress != "172.23.0.2" { + t.Fatalf("network publish addresses = %q/%q", config.NetworkDockerPublishAddress, config.NetworkRuntimePublishAddress) + } +} + +func TestNewConfigRejectsInvalidNetworkPublishAddresses(t *testing.T) { + for _, name := range []string{"NETWORK_DOCKER_PUBLISH_ADDRESS", "NETWORK_RUNTIME_PUBLISH_ADDRESS"} { + t.Run(name, func(t *testing.T) { + t.Setenv("DATA_ROOT", filepath.Join(t.TempDir(), "data")) + t.Setenv(name, "localhost") + di := do.New() + do.ProvideValue(di, slog.Default()) + _, err := NewConfig(di) + if err == nil || !strings.Contains(err.Error(), name+" must be a valid IPv4 address") { + t.Fatalf("NewConfig() error = %v", err) + } + }) + } +} + func testNewConfigParsesEnvironment(t *testing.T) { root := t.TempDir() t.Setenv("DATA_ROOT", filepath.Join(root, "data")) diff --git a/pkg/driver/boxlite_cgo.go b/pkg/driver/boxlite_cgo.go index 3492912c..193d5206 100644 --- a/pkg/driver/boxlite_cgo.go +++ b/pkg/driver/boxlite_cgo.go @@ -1041,6 +1041,24 @@ func (r *cgoSandboxRuntime) buildBoxOptions(ctx context.Context, sandbox *Sandbo return nil, err } } + bindings, err := sandboxNetworkBindings(sandbox, NetworkPublisherDirect) + if err != nil { + return nil, err + } + for _, binding := range bindings { + hostIP := C.CString(binding.HostIP) + code := C.boxlite_options_add_port( + options, + C.uint16_t(binding.HostPort), + C.uint16_t(binding.GuestPort), + C.BoxlitePortProtocolTcp, + hostIP, + ) + C.free(unsafe.Pointer(hostIP)) + if err := boxliteStatusError(code, nil, "add sandbox network port forwarding"); err != nil { + return nil, err + } + } entrypoint, entrypointLen, freeEntrypoint := cStringArray([]string{"sh", "-lc"}) defer freeEntrypoint() diff --git a/pkg/driver/docker_runtime.go b/pkg/driver/docker_runtime.go index 5f6e04cc..4cb48f85 100644 --- a/pkg/driver/docker_runtime.go +++ b/pkg/driver/docker_runtime.go @@ -147,7 +147,7 @@ func (r *dockerRuntime) EnsureSandbox(ctx context.Context, sandbox *Sandbox, vmS } } if topology.containerized { - if err := ensureDockerContainerNetwork(ctx, dockerClient, containerInfo, string(topology.networkMode)); err != nil { + if err := ensureDockerContainerNetworks(ctx, dockerClient, containerInfo, []string{string(topology.networkMode)}); err != nil { return SandboxVMInfo{}, err } } @@ -676,11 +676,12 @@ func (r *dockerRuntime) getOrCreateContainer(ctx context.Context, dockerClient * if err != nil { return containerapi.InspectResponse{}, false, err } - var exposedPorts nat.PortSet - var portBindings nat.PortMap + exposedPorts, portBindings, err := dockerSandboxPortConfig(sandbox, proxyState) + if err != nil { + return containerapi.InspectResponse{}, false, err + } cmdText := "tail -f /dev/null" if jupyterEnabled(proxyState) { - exposedPorts, portBindings = dockerJupyterPortConfig(proxyState.GuestPort) cmdText = jupyterLaunchCommand(r.config, proxyState, false) } containerConfig := &containerapi.Config{ @@ -799,6 +800,33 @@ func dockerJupyterPortConfig(guestPort int) (nat.PortSet, nat.PortMap) { } } +func dockerSandboxPortConfig(sandbox *Sandbox, proxyState ProxyState) (nat.PortSet, nat.PortMap, error) { + var exposedPorts nat.PortSet + var portBindings nat.PortMap + if jupyterEnabled(proxyState) { + exposedPorts, portBindings = dockerJupyterPortConfig(proxyState.GuestPort) + } + bindings, err := sandboxNetworkBindings(sandbox, NetworkPublisherDocker) + if err != nil { + return nil, nil, err + } + for _, binding := range bindings { + if exposedPorts == nil { + exposedPorts = make(nat.PortSet) + } + if portBindings == nil { + portBindings = make(nat.PortMap) + } + port := nat.Port(strconv.Itoa(binding.GuestPort) + "/tcp") + exposedPorts[port] = struct{}{} + portBindings[port] = append(portBindings[port], nat.PortBinding{ + HostIP: binding.HostIP, + HostPort: strconv.Itoa(binding.HostPort), + }) + } + return exposedPorts, portBindings, nil +} + func SandboxStopContextTimeout(driver string, stopTimeout time.Duration) time.Duration { if driver != RuntimeDriverDocker || stopTimeout <= 0 { return stopTimeout @@ -816,7 +844,15 @@ func (r *dockerRuntime) dockerDaemonTopology(ctx context.Context, dockerClient * slog.Warn("current process is not running in an inspectable docker container; falling back to default docker network") return dockerDaemonTopology{networkMode: containerapi.NetworkMode("default")} } - return dockerDaemonTopology{networkMode: containerapi.NetworkMode(networkName), containerized: true} + return dockerDaemonTopology{networkMode: dockerSandboxPrimaryNetworkMode(networkName), containerized: true} +} + +func dockerSandboxPrimaryNetworkMode(daemonNetwork string) containerapi.NetworkMode { + daemonNetwork = strings.TrimSpace(daemonNetwork) + if daemonNetwork == "" || daemonNetwork == "host" { + return containerapi.NetworkMode("default") + } + return containerapi.NetworkMode(daemonNetwork) } func (r *dockerRuntime) dockerNetworkNameFromSelfContainer(ctx context.Context, dockerClient *client.Client) (string, bool, error) { @@ -1089,18 +1125,25 @@ func dockerJupyterHostPort(containerInfo containerapi.InspectResponse, guestPort return 0, fmt.Errorf("docker container %s has no valid loopback binding for jupyter port %s", containerInfo.ID, port) } -func ensureDockerContainerNetwork(ctx context.Context, dockerClient *client.Client, containerInfo containerapi.InspectResponse, networkName string) error { - networkName = strings.TrimSpace(networkName) - if networkName == "" || networkName == "default" { - return nil - } +func ensureDockerContainerNetworks(ctx context.Context, dockerClient *client.Client, containerInfo containerapi.InspectResponse, networkNames []string) error { + connected := make(map[string]struct{}, len(networkNames)) if containerInfo.NetworkSettings != nil { - if _, ok := containerInfo.NetworkSettings.Networks[networkName]; ok { - return nil + for name := range containerInfo.NetworkSettings.Networks { + connected[name] = struct{}{} } } - if err := dockerClient.NetworkConnect(ctx, networkName, containerInfo.ID, nil); err != nil { - return fmt.Errorf("connect docker container %s to daemon network %s: %w", containerInfo.ID, networkName, err) + for _, rawName := range networkNames { + name := strings.TrimSpace(rawName) + if name == "" || name == "default" || name == "host" { + continue + } + if _, ok := connected[name]; ok { + continue + } + if err := dockerClient.NetworkConnect(ctx, name, containerInfo.ID, nil); err != nil { + return fmt.Errorf("connect docker container %s to network %s: %w", containerInfo.ID, name, err) + } + connected[name] = struct{}{} } return nil } diff --git a/pkg/driver/docker_runtime_test.go b/pkg/driver/docker_runtime_test.go index 5ff821d5..70e85b34 100644 --- a/pkg/driver/docker_runtime_test.go +++ b/pkg/driver/docker_runtime_test.go @@ -500,6 +500,37 @@ func TestDockerJupyterPortConfigRequestsAutomaticLoopbackBinding(t *testing.T) { } } +func TestDockerSandboxPortConfigCombinesJupyterAndNetworkBindings(t *testing.T) { + sandbox := &Sandbox{Network: &SandboxNetwork{Bindings: []SandboxPortBinding{ + {HostIP: "10.254.1.1", HostPort: 32000, GuestPort: 8080, Protocol: "tcp", Publisher: NetworkPublisherDocker}, + {HostIP: "10.254.2.1", HostPort: 32001, GuestPort: 8080, Protocol: "tcp", Publisher: NetworkPublisherDocker}, + }}} + exposedPorts, portBindings, err := dockerSandboxPortConfig(sandbox, ProxyState{Enabled: true, GuestPort: 9999}) + if err != nil { + t.Fatalf("dockerSandboxPortConfig() error = %v", err) + } + if len(exposedPorts) != 2 { + t.Fatalf("exposed ports = %#v", exposedPorts) + } + bindings := portBindings[nat.Port("8080/tcp")] + if len(bindings) != 2 || bindings[0].HostIP != "10.254.1.1" || bindings[1].HostPort != "32001" { + t.Fatalf("network port bindings = %#v", bindings) + } + jupyter := portBindings[nat.Port("9999/tcp")] + if len(jupyter) != 1 || jupyter[0].HostIP != "127.0.0.1" || jupyter[0].HostPort != "" { + t.Fatalf("jupyter port binding = %#v", jupyter) + } +} + +func TestDockerSandboxPrimaryNetworkModeDoesNotInheritHost(t *testing.T) { + if got := dockerSandboxPrimaryNetworkMode("host"); got != containerapi.NetworkMode("default") { + t.Fatalf("dockerSandboxPrimaryNetworkMode(host) = %q", got) + } + if got := dockerSandboxPrimaryNetworkMode("project_default"); got != containerapi.NetworkMode("project_default") { + t.Fatalf("dockerSandboxPrimaryNetworkMode(project_default) = %q", got) + } +} + func TestDockerJupyterHostPortSelectsValidLoopbackBinding(t *testing.T) { containerInfo := dockerInspectWithJupyterBindings("container-1", "/runtime-ref", 9999, []nat.PortBinding{ {HostIP: "0.0.0.0", HostPort: "41000"}, diff --git a/pkg/driver/microsandbox_runtime.go b/pkg/driver/microsandbox_runtime.go index 1f386233..52bce46a 100644 --- a/pkg/driver/microsandbox_runtime.go +++ b/pkg/driver/microsandbox_runtime.go @@ -1001,6 +1001,22 @@ func (r *microsandboxRuntime) createSandbox(ctx context.Context, session *Sandbo if jupyterEnabled(proxyState) && proxyState.HostPort > 0 { options = append(options, microsandbox.WithPorts(map[uint16]uint16{uint16(proxyState.HostPort): uint16(proxyState.GuestPort)})) } + bindings, err := sandboxNetworkBindings(session, NetworkPublisherDirect) + if err != nil { + return nil, err + } + if len(bindings) > 0 { + portBindings := make([]microsandbox.PortBinding, 0, len(bindings)) + for _, binding := range bindings { + portBindings = append(portBindings, microsandbox.PortBinding{ + Bind: binding.HostIP, + HostPort: uint16(binding.HostPort), + GuestPort: uint16(binding.GuestPort), + Protocol: microsandbox.PortProtocolTCP, + }) + } + options = append(options, microsandbox.WithPortBindings(portBindings...)) + } sandbox, err := microsandbox.CreateSandbox(ctx, name, options...) if err != nil { return nil, err diff --git a/pkg/driver/network.go b/pkg/driver/network.go new file mode 100644 index 00000000..90522eb7 --- /dev/null +++ b/pkg/driver/network.go @@ -0,0 +1,63 @@ +package driver + +import ( + "fmt" + "net/netip" + "slices" + "strconv" + "strings" +) + +const ( + NetworkPublisherDocker = "docker" + NetworkPublisherDirect = "direct" +) + +func sandboxNetworkBindings(sandbox *Sandbox, publisher string) ([]SandboxPortBinding, error) { + if sandbox == nil || sandbox.Network == nil || len(sandbox.Network.Bindings) == 0 { + return nil, nil + } + bindings := make([]SandboxPortBinding, 0, len(sandbox.Network.Bindings)) + listeners := make(map[string]struct{}, len(sandbox.Network.Bindings)) + for i, binding := range sandbox.Network.Bindings { + if actual := strings.TrimSpace(binding.Publisher); actual != publisher { + return nil, fmt.Errorf("network binding %d requires publisher %q, runtime provides %q", i, actual, publisher) + } + hostIP := strings.TrimSpace(binding.HostIP) + addr, err := netip.ParseAddr(hostIP) + if err != nil || !addr.Is4() { + return nil, fmt.Errorf("network binding %d has invalid IPv4 host address %q", i, binding.HostIP) + } + if binding.HostPort < 1 || binding.HostPort > 65535 { + return nil, fmt.Errorf("network binding %d has invalid host port %d", i, binding.HostPort) + } + if binding.GuestPort < 1 || binding.GuestPort > 65535 { + return nil, fmt.Errorf("network binding %d has invalid guest port %d", i, binding.GuestPort) + } + protocol := strings.ToLower(strings.TrimSpace(binding.Protocol)) + if protocol == "" { + protocol = "tcp" + } + if protocol != "tcp" { + return nil, fmt.Errorf("network binding %d uses unsupported protocol %q", i, binding.Protocol) + } + key := strings.Join([]string{hostIP, strconv.Itoa(binding.HostPort), protocol}, "|") + if _, exists := listeners[key]; exists { + return nil, fmt.Errorf("network binding %d duplicates listener %s:%d/%s", i, hostIP, binding.HostPort, protocol) + } + listeners[key] = struct{}{} + binding.HostIP = hostIP + binding.Protocol = protocol + bindings = append(bindings, binding) + } + slices.SortFunc(bindings, func(a, b SandboxPortBinding) int { + if compare := strings.Compare(a.HostIP, b.HostIP); compare != 0 { + return compare + } + if a.HostPort != b.HostPort { + return a.HostPort - b.HostPort + } + return a.GuestPort - b.GuestPort + }) + return bindings, nil +} diff --git a/pkg/driver/network_test.go b/pkg/driver/network_test.go new file mode 100644 index 00000000..23e1719a --- /dev/null +++ b/pkg/driver/network_test.go @@ -0,0 +1,46 @@ +package driver + +import ( + "strings" + "testing" +) + +func TestSandboxNetworkBindingsValidatesAndSortsPublisher(t *testing.T) { + sandbox := &Sandbox{Network: &SandboxNetwork{Bindings: []SandboxPortBinding{ + {HostIP: "10.0.0.1", HostPort: 32000, GuestPort: 80, Publisher: NetworkPublisherDocker}, + {HostIP: "10.0.0.1", HostPort: 31999, GuestPort: 79, Protocol: "TCP", Publisher: NetworkPublisherDocker}, + }}} + bindings, err := sandboxNetworkBindings(sandbox, NetworkPublisherDocker) + if err != nil { + t.Fatalf("sandboxNetworkBindings() error = %v", err) + } + if len(bindings) != 2 || bindings[0].HostPort != 31999 || bindings[1].HostPort != 32000 || bindings[0].Protocol != "tcp" { + t.Fatalf("bindings = %#v", bindings) + } +} + +func TestSandboxNetworkBindingsRejectsInvalidBinding(t *testing.T) { + tests := []struct { + name string + bindings []SandboxPortBinding + contains string + }{ + {"host IP", []SandboxPortBinding{{HostIP: "bad", HostPort: 32000, GuestPort: 80, Publisher: NetworkPublisherDirect}}, "invalid IPv4"}, + {"host port", []SandboxPortBinding{{HostIP: "127.0.0.1", GuestPort: 80, Publisher: NetworkPublisherDirect}}, "invalid host port"}, + {"guest port", []SandboxPortBinding{{HostIP: "127.0.0.1", HostPort: 32000, Publisher: NetworkPublisherDirect}}, "invalid guest port"}, + {"protocol", []SandboxPortBinding{{HostIP: "127.0.0.1", HostPort: 32000, GuestPort: 80, Protocol: "udp", Publisher: NetworkPublisherDirect}}, "unsupported protocol"}, + {"publisher", []SandboxPortBinding{{HostIP: "127.0.0.1", HostPort: 32000, GuestPort: 80, Publisher: NetworkPublisherDocker}}, "requires publisher"}, + {"duplicate", []SandboxPortBinding{ + {HostIP: "127.0.0.1", HostPort: 32000, GuestPort: 80, Publisher: NetworkPublisherDirect}, + {HostIP: "127.0.0.1", HostPort: 32000, GuestPort: 81, Publisher: NetworkPublisherDirect}, + }, "duplicates listener"}, + } + for _, tt := range tests { + t.Run(tt.name, func(t *testing.T) { + _, err := sandboxNetworkBindings(&Sandbox{Network: &SandboxNetwork{Bindings: tt.bindings}}, NetworkPublisherDirect) + if err == nil || !strings.Contains(err.Error(), tt.contains) { + t.Fatalf("sandboxNetworkBindings() error = %v", err) + } + }) + } +} diff --git a/pkg/driver/types.go b/pkg/driver/types.go index 564bfcff..55e08f12 100644 --- a/pkg/driver/types.go +++ b/pkg/driver/types.go @@ -28,9 +28,29 @@ type Sandbox struct { Summary SandboxSummary `json:"summary"` EnvItems []SandboxEnvVar `json:"env_items,omitempty"` VolumeMounts []SandboxVolumeMount `json:"volume_mounts,omitempty"` + Network *SandboxNetwork `json:"network,omitempty"` RuntimeEnvItems []SandboxEnvVar `json:"-"` } +type SandboxNetwork struct { + Attachments []SandboxNetworkEndpoint `json:"attachments,omitempty"` + Bindings []SandboxPortBinding `json:"bindings,omitempty"` +} + +type SandboxNetworkEndpoint struct { + Name string `json:"name"` +} + +type SandboxPortBinding struct { + Networks []string `json:"networks,omitempty"` + HostIP string `json:"host_ip"` + HostPort int `json:"host_port"` + GuestPort int `json:"guest_port"` + Protocol string `json:"protocol"` + Visibility string `json:"visibility"` + Publisher string `json:"publisher"` +} + type SandboxVolumeMount struct { ID string `json:"id,omitempty"` Type string `json:"type"` diff --git a/pkg/execution/driver.go b/pkg/execution/driver.go index 9e8e3987..0b1dd3fb 100644 --- a/pkg/execution/driver.go +++ b/pkg/execution/driver.go @@ -30,6 +30,26 @@ func ToDriverSandbox(session *domain.Sandbox) *driverpkg.Sandbox { HostPath: item.HostPath, }) } + var network *driverpkg.SandboxNetwork + if session.NetworkState != nil { + network = &driverpkg.SandboxNetwork{} + for _, attachment := range session.NetworkState.Attachments { + network.Attachments = append(network.Attachments, driverpkg.SandboxNetworkEndpoint{ + Name: attachment.Name, + }) + } + for _, binding := range session.NetworkState.Bindings { + network.Bindings = append(network.Bindings, driverpkg.SandboxPortBinding{ + Networks: append([]string(nil), binding.Networks...), + HostIP: binding.HostIP, + HostPort: binding.HostPort, + GuestPort: binding.GuestPort, + Protocol: binding.Protocol, + Visibility: binding.Visibility, + Publisher: binding.Publisher, + }) + } + } return &driverpkg.Sandbox{ Summary: driverpkg.SandboxSummary{ ID: session.Summary.ID, @@ -43,6 +63,7 @@ func ToDriverSandbox(session *domain.Sandbox) *driverpkg.Sandbox { }, EnvItems: envItems, VolumeMounts: volumeMounts, + Network: network, RuntimeEnvItems: runtimeEnvItems, } } diff --git a/pkg/execution/driver_coverage_test.go b/pkg/execution/driver_coverage_test.go index 41fc00ec..8f628ca7 100644 --- a/pkg/execution/driver_coverage_test.go +++ b/pkg/execution/driver_coverage_test.go @@ -24,11 +24,18 @@ func TestDriverConversionWorkflows(t *testing.T) { }, EnvItems: []domain.SandboxEnvVar{{Name: "A", Value: "B", Secret: true}}, RuntimeEnvItems: []domain.SandboxEnvVar{{Name: "R", Value: "V"}}, + NetworkState: &domain.SandboxNetworkState{ + Attachments: []domain.SandboxNetworkEndpoint{{Name: "frontend"}}, + Bindings: []domain.SandboxPortBinding{{Networks: []string{"frontend"}, HostIP: "10.254.1.1", HostPort: 32000, GuestPort: 8080, Protocol: "tcp", Visibility: "internal", Publisher: "docker"}}, + }, } driverSession := ToDriverSandbox(session) if driverSession.Summary.ID != "sandbox-1" || len(driverSession.EnvItems) != 1 || !driverSession.EnvItems[0].Secret || len(driverSession.RuntimeEnvItems) != 1 { t.Fatalf("driver sandbox = %#v", driverSession) } + if driverSession.Network == nil || len(driverSession.Network.Attachments) != 1 || len(driverSession.Network.Bindings) != 1 || driverSession.Network.Bindings[0].HostPort != 32000 { + t.Fatalf("driver network = %#v", driverSession.Network) + } vmState := domain.VMState{Driver: "docker", Mode: "runtime", BoxName: "box", BoxID: "box-id", Image: "image", Registry: "registry", RuntimeHome: "/root", StartedAt: now, StoppedAt: now, LastError: "none", BootstrapRef: "boot"} driverVMState := ToDriverVMState(vmState) if got := FromDriverVMState(driverVMState); got != vmState { diff --git a/pkg/model/model.go b/pkg/model/model.go index cfa91c11..3dd7e2c6 100644 --- a/pkg/model/model.go +++ b/pkg/model/model.go @@ -171,6 +171,8 @@ type Sandbox struct { WorkspaceProvisioning *SandboxWorkspaceProvisioning `json:"workspace_provisioning,omitempty"` EnvItems []SandboxEnvVar `json:"env_items,omitempty"` VolumeMounts []SandboxVolumeMount `json:"volume_mounts,omitempty"` + NetworkIntent *SandboxNetworkIntent `json:"network_intent,omitempty"` + NetworkState *SandboxNetworkState `json:"network_state,omitempty"` RuntimeEnvItems []SandboxEnvVar `json:"-"` ProviderEnvItems []SandboxEnvVar `json:"-"` } diff --git a/pkg/model/sandbox_network.go b/pkg/model/sandbox_network.go new file mode 100644 index 00000000..932ef791 --- /dev/null +++ b/pkg/model/sandbox_network.go @@ -0,0 +1,71 @@ +package model + +type SandboxNetworkIntent struct { + ProjectID string `json:"project_id"` + ProjectName string `json:"project_name"` + AgentName string `json:"agent_name"` + Attachments []SandboxNetworkAttachment `json:"attachments,omitempty"` + Expose []SandboxNetworkPort `json:"expose,omitempty"` + Ports []SandboxPublishedPort `json:"ports,omitempty"` +} + +type SandboxNetworkAttachment struct { + Name string `json:"name"` + Driver string `json:"driver"` +} + +type SandboxNetworkPort struct { + Target int `json:"target"` + HostPort int `json:"host_port,omitempty"` + Protocol string `json:"protocol"` +} + +type SandboxPublishedPort struct { + HostIP string `json:"host_ip"` + Published int `json:"published,omitempty"` + Target int `json:"target"` + Protocol string `json:"protocol"` +} + +type SandboxNetworkState struct { + Attachments []SandboxNetworkEndpoint `json:"attachments,omitempty"` + Bindings []SandboxPortBinding `json:"bindings,omitempty"` +} + +type SandboxNetworkEndpoint struct { + Name string `json:"name"` +} + +type SandboxPortBinding struct { + Networks []string `json:"networks,omitempty"` + HostIP string `json:"host_ip"` + HostPort int `json:"host_port"` + GuestPort int `json:"guest_port"` + Protocol string `json:"protocol"` + Visibility string `json:"visibility"` + Publisher string `json:"publisher"` +} + +func CloneSandboxNetworkIntent(intent *SandboxNetworkIntent) *SandboxNetworkIntent { + if intent == nil { + return nil + } + clone := *intent + clone.Attachments = append([]SandboxNetworkAttachment(nil), intent.Attachments...) + clone.Expose = append([]SandboxNetworkPort(nil), intent.Expose...) + clone.Ports = append([]SandboxPublishedPort(nil), intent.Ports...) + return &clone +} + +func CloneSandboxNetworkState(state *SandboxNetworkState) *SandboxNetworkState { + if state == nil { + return nil + } + clone := *state + clone.Attachments = append([]SandboxNetworkEndpoint(nil), state.Attachments...) + clone.Bindings = append([]SandboxPortBinding(nil), state.Bindings...) + for index := range clone.Bindings { + clone.Bindings[index].Networks = append([]string(nil), state.Bindings[index].Networks...) + } + return &clone +} diff --git a/pkg/networks/manager.go b/pkg/networks/manager.go new file mode 100644 index 00000000..c87b2d0f --- /dev/null +++ b/pkg/networks/manager.go @@ -0,0 +1,224 @@ +package networks + +import ( + "context" + "fmt" + "slices" + "strings" + + driverpkg "agent-compose/pkg/driver" + domain "agent-compose/pkg/model" +) + +const ( + VisibilityInternal = "internal" + VisibilityExternal = "external" + + PublisherDocker = "docker" + PublisherDirect = "direct" +) + +type PublishAddressProvider interface { + DefaultPublishAddress(context.Context) (string, error) +} + +type PortAllocator interface { + AllocateHostPort(context.Context, string) (int, error) +} + +type Manager struct { + PublishAddresses PublishAddressProvider + Ports PortAllocator + DockerPublishAddress string + RuntimePublishAddress string +} + +func (m *Manager) PrepareSandbox(ctx context.Context, sandbox *domain.Sandbox) error { + if sandbox == nil { + return fmt.Errorf("sandbox is required") + } + intent := sandbox.NetworkIntent + if intent == nil || (len(intent.Attachments) == 0 && len(intent.Ports) == 0) { + return nil + } + if m == nil { + return fmt.Errorf("network manager is required") + } + if m.Ports == nil && (hasDynamicExposedPort(intent.Expose) || hasDynamicPublishedPort(intent.Ports)) { + return fmt.Errorf("network port allocator is required") + } + + state := &domain.SandboxNetworkState{} + networkNames := make([]string, 0, len(intent.Attachments)) + for _, attachment := range intent.Attachments { + state.Attachments = append(state.Attachments, domain.SandboxNetworkEndpoint{ + Name: attachment.Name, + }) + networkNames = append(networkNames, attachment.Name) + } + + existing := existingBindingPorts(sandbox.NetworkState) + if len(networkNames) > 0 && len(intent.Expose) > 0 { + publishAddress, err := m.internalPublishAddress(ctx, sandbox.Summary.Driver) + if err != nil { + return err + } + for _, port := range intent.Expose { + binding, err := m.internalBinding(ctx, sandbox.Summary.ID, networkNames, publishAddress, sandbox.Summary.Driver, port, existing) + if err != nil { + return err + } + state.Bindings = append(state.Bindings, binding) + } + } + for _, port := range intent.Ports { + binding, err := m.externalBinding(ctx, sandbox.Summary.ID, sandbox.Summary.Driver, port, existing) + if err != nil { + return err + } + state.Bindings = append(state.Bindings, binding) + } + slices.SortFunc(state.Bindings, compareBindings) + sandbox.NetworkState = state + return nil +} + +func (m *Manager) internalPublishAddress(ctx context.Context, runtimeDriver string) (string, error) { + address := strings.TrimSpace(m.RuntimePublishAddress) + if runtimeDriver == driverpkg.RuntimeDriverDocker { + address = strings.TrimSpace(m.DockerPublishAddress) + } + if address != "" { + return address, nil + } + if m.PublishAddresses == nil { + return "", fmt.Errorf("network publish address provider is required") + } + address, err := m.PublishAddresses.DefaultPublishAddress(ctx) + if err != nil { + return "", fmt.Errorf("resolve default network publish address: %w", err) + } + if strings.TrimSpace(address) == "" { + return "", fmt.Errorf("default network publish address is empty") + } + return strings.TrimSpace(address), nil +} + +func (m *Manager) internalBinding(ctx context.Context, sandboxID string, networks []string, hostIP, runtimeDriver string, port domain.SandboxNetworkPort, existing map[string]int) (domain.SandboxPortBinding, error) { + binding := domain.SandboxPortBinding{ + Networks: append([]string(nil), networks...), + HostIP: hostIP, + HostPort: port.HostPort, + GuestPort: port.Target, + Protocol: normalizeProtocol(port.Protocol), + Visibility: VisibilityInternal, + Publisher: publisherForRuntime(runtimeDriver), + } + if binding.HostPort == 0 { + binding.HostPort = existing[bindingKey(binding)] + } + if binding.HostPort == 0 { + allocated, err := m.Ports.AllocateHostPort(ctx, sandboxID) + if err != nil { + return domain.SandboxPortBinding{}, fmt.Errorf("allocate internal host port: %w", err) + } + binding.HostPort = allocated + } + return binding, nil +} + +func hasDynamicExposedPort(ports []domain.SandboxNetworkPort) bool { + for _, port := range ports { + if port.HostPort == 0 { + return true + } + } + return false +} + +func (m *Manager) externalBinding(ctx context.Context, sandboxID, runtimeDriver string, port domain.SandboxPublishedPort, existing map[string]int) (domain.SandboxPortBinding, error) { + binding := domain.SandboxPortBinding{ + HostIP: firstNonEmpty(strings.TrimSpace(port.HostIP), "127.0.0.1"), + HostPort: port.Published, + GuestPort: port.Target, + Protocol: normalizeProtocol(port.Protocol), + Visibility: VisibilityExternal, + Publisher: publisherForRuntime(runtimeDriver), + } + if binding.HostPort == 0 { + binding.HostPort = existing[bindingKey(binding)] + } + if binding.HostPort == 0 { + allocated, err := m.Ports.AllocateHostPort(ctx, sandboxID) + if err != nil { + return domain.SandboxPortBinding{}, fmt.Errorf("allocate published host port: %w", err) + } + binding.HostPort = allocated + } + return binding, nil +} + +func hasDynamicPublishedPort(ports []domain.SandboxPublishedPort) bool { + for _, port := range ports { + if port.Published == 0 { + return true + } + } + return false +} + +func existingBindingPorts(state *domain.SandboxNetworkState) map[string]int { + result := make(map[string]int) + if state == nil { + return result + } + for _, binding := range state.Bindings { + if binding.HostPort > 0 { + result[bindingKey(binding)] = binding.HostPort + } + } + return result +} + +func bindingKey(binding domain.SandboxPortBinding) string { + return strings.Join([]string{binding.Visibility, strings.Join(binding.Networks, ","), binding.HostIP, fmt.Sprint(binding.GuestPort), normalizeProtocol(binding.Protocol)}, "|") +} + +func compareBindings(a, b domain.SandboxPortBinding) int { + if compare := strings.Compare(a.Visibility, b.Visibility); compare != 0 { + return compare + } + if compare := strings.Compare(strings.Join(a.Networks, ","), strings.Join(b.Networks, ",")); compare != 0 { + return compare + } + if compare := strings.Compare(a.HostIP, b.HostIP); compare != 0 { + return compare + } + if a.HostPort != b.HostPort { + return a.HostPort - b.HostPort + } + return a.GuestPort - b.GuestPort +} + +func publisherForRuntime(runtimeDriver string) string { + if runtimeDriver == driverpkg.RuntimeDriverDocker { + return PublisherDocker + } + return PublisherDirect +} + +func normalizeProtocol(protocol string) string { + if strings.TrimSpace(protocol) == "" { + return "tcp" + } + return strings.ToLower(strings.TrimSpace(protocol)) +} + +func firstNonEmpty(values ...string) string { + for _, value := range values { + if value != "" { + return value + } + } + return "" +} diff --git a/pkg/networks/manager_test.go b/pkg/networks/manager_test.go new file mode 100644 index 00000000..30c4d002 --- /dev/null +++ b/pkg/networks/manager_test.go @@ -0,0 +1,233 @@ +package networks + +import ( + "context" + "errors" + "slices" + "testing" + + driverpkg "agent-compose/pkg/driver" + domain "agent-compose/pkg/model" +) + +func TestManagerUsesConfiguredRuntimePublishAddress(t *testing.T) { + provider := &publishAddressProviderStub{} + manager := &Manager{ + PublishAddresses: provider, + Ports: &portAllocatorStub{next: 32000}, + DockerPublishAddress: "172.23.0.1", + RuntimePublishAddress: "172.23.0.2", + } + sandbox := networkTestSandbox(driverpkg.RuntimeDriverMicrosandbox) + + if err := manager.PrepareSandbox(context.Background(), sandbox); err != nil { + t.Fatalf("PrepareSandbox() error = %v", err) + } + if provider.defaultCalls != 0 { + t.Fatalf("DefaultPublishAddress() calls = %d", provider.defaultCalls) + } + binding := sandbox.NetworkState.Bindings[0] + if binding.HostIP != "172.23.0.2" || binding.HostPort != 32000 || binding.GuestPort != 8080 || binding.Publisher != PublisherDirect { + t.Fatalf("binding = %#v", binding) + } + if !slices.Equal(binding.Networks, []string{"frontend"}) { + t.Fatalf("binding networks = %#v", binding.Networks) + } +} + +func TestManagerUsesConfiguredDockerPublishAddress(t *testing.T) { + manager := &Manager{ + Ports: &portAllocatorStub{next: 32000}, + DockerPublishAddress: "172.23.0.1", + RuntimePublishAddress: "172.23.0.2", + } + sandbox := networkTestSandbox(driverpkg.RuntimeDriverDocker) + sandbox.NetworkIntent.Ports = []domain.SandboxPublishedPort{{HostIP: "192.0.2.10", Published: 19000, Target: 9000, Protocol: "tcp"}} + + if err := manager.PrepareSandbox(context.Background(), sandbox); err != nil { + t.Fatalf("PrepareSandbox() error = %v", err) + } + internal := bindingWithVisibility(t, sandbox.NetworkState.Bindings, VisibilityInternal) + if internal.HostIP != "172.23.0.1" || internal.Publisher != PublisherDocker { + t.Fatalf("internal binding = %#v", internal) + } + external := bindingWithVisibility(t, sandbox.NetworkState.Bindings, VisibilityExternal) + if external.HostIP != "192.0.2.10" || external.HostPort != 19000 || external.Publisher != PublisherDocker { + t.Fatalf("external binding = %#v", external) + } +} + +func TestManagerFallsBackToDefaultBridgeGateway(t *testing.T) { + provider := &publishAddressProviderStub{ + defaultAddress: "172.17.0.1", + } + manager := &Manager{PublishAddresses: provider, Ports: &portAllocatorStub{next: 32000}} + + if err := manager.PrepareSandbox(context.Background(), networkTestSandbox(driverpkg.RuntimeDriverBoxlite)); err != nil { + t.Fatalf("PrepareSandbox() error = %v", err) + } + if provider.defaultCalls != 1 { + t.Fatalf("DefaultPublishAddress() calls = %d", provider.defaultCalls) + } +} + +func TestManagerCreatesOneListenerForMultipleNetworks(t *testing.T) { + manager := &Manager{Ports: &portAllocatorStub{next: 32000}, DockerPublishAddress: "172.17.0.1"} + sandbox := networkTestSandbox(driverpkg.RuntimeDriverDocker) + sandbox.NetworkIntent.Attachments = append(sandbox.NetworkIntent.Attachments, + domain.SandboxNetworkAttachment{Name: "backend", Driver: "port_mapping"}) + + if err := manager.PrepareSandbox(context.Background(), sandbox); err != nil { + t.Fatalf("PrepareSandbox() error = %v", err) + } + if len(sandbox.NetworkState.Attachments) != 2 || len(sandbox.NetworkState.Bindings) != 1 { + t.Fatalf("network state = %#v", sandbox.NetworkState) + } + if !slices.Equal(sandbox.NetworkState.Bindings[0].Networks, []string{"frontend", "backend"}) { + t.Fatalf("binding networks = %#v", sandbox.NetworkState.Bindings[0].Networks) + } +} + +func TestManagerAllowsFixedExternalPortWithoutPublishAddressProviderOrAllocator(t *testing.T) { + manager := &Manager{} + sandbox := networkTestSandbox(driverpkg.RuntimeDriverBoxlite) + sandbox.NetworkIntent.Attachments = nil + sandbox.NetworkIntent.Expose = nil + sandbox.NetworkIntent.Ports = []domain.SandboxPublishedPort{{HostIP: "127.0.0.1", Published: 19000, Target: 9000, Protocol: "tcp"}} + + if err := manager.PrepareSandbox(context.Background(), sandbox); err != nil { + t.Fatalf("PrepareSandbox() error = %v", err) + } + binding := bindingWithVisibility(t, sandbox.NetworkState.Bindings, VisibilityExternal) + if binding.HostPort != 19000 || binding.GuestPort != 9000 { + t.Fatalf("binding = %#v", binding) + } +} + +func TestManagerUsesFixedInternalListenerPortWithoutAllocator(t *testing.T) { + manager := &Manager{RuntimePublishAddress: "172.23.0.2"} + sandbox := networkTestSandbox(driverpkg.RuntimeDriverBoxlite) + sandbox.NetworkIntent.Expose[0].HostPort = 18080 + + if err := manager.PrepareSandbox(context.Background(), sandbox); err != nil { + t.Fatalf("PrepareSandbox() error = %v", err) + } + binding := bindingWithVisibility(t, sandbox.NetworkState.Bindings, VisibilityInternal) + if binding.HostIP != "172.23.0.2" || binding.HostPort != 18080 || binding.GuestPort != 8080 { + t.Fatalf("binding = %#v", binding) + } +} + +func TestManagerFixedInternalListenerPortOverridesPreviousDynamicPort(t *testing.T) { + manager := &Manager{DockerPublishAddress: "172.23.0.1"} + sandbox := networkTestSandbox(driverpkg.RuntimeDriverDocker) + sandbox.NetworkIntent.Expose[0].HostPort = 18080 + sandbox.NetworkState = &domain.SandboxNetworkState{Bindings: []domain.SandboxPortBinding{{ + Networks: []string{"frontend"}, + HostIP: "172.23.0.1", + HostPort: 32000, + GuestPort: 8080, + Protocol: "tcp", + Visibility: VisibilityInternal, + }}} + + if err := manager.PrepareSandbox(context.Background(), sandbox); err != nil { + t.Fatalf("PrepareSandbox() error = %v", err) + } + if got := sandbox.NetworkState.Bindings[0].HostPort; got != 18080 { + t.Fatalf("fixed listener port = %d, want 18080", got) + } +} + +func TestManagerReturnsDefaultPublishAddressError(t *testing.T) { + manager := &Manager{ + PublishAddresses: &publishAddressProviderStub{ + defaultErr: errors.New("Docker unavailable"), + }, + Ports: &portAllocatorStub{next: 32000}, + } + err := manager.PrepareSandbox(context.Background(), networkTestSandbox(driverpkg.RuntimeDriverDocker)) + if err == nil || err.Error() != "resolve default network publish address: Docker unavailable" { + t.Fatalf("PrepareSandbox() error = %v", err) + } +} + +func TestManagerReturnsPortAllocationError(t *testing.T) { + manager := &Manager{ + Ports: &portAllocatorStub{err: errors.New("no ports")}, + DockerPublishAddress: "172.17.0.1", + } + err := manager.PrepareSandbox(context.Background(), networkTestSandbox(driverpkg.RuntimeDriverDocker)) + if err == nil || err.Error() != "allocate internal host port: no ports" { + t.Fatalf("PrepareSandbox() error = %v", err) + } +} + +func TestManagerPreservesAllocatedPortsAcrossResume(t *testing.T) { + manager := &Manager{ + Ports: &portAllocatorStub{next: 32000}, + DockerPublishAddress: "172.17.0.1", + } + sandbox := networkTestSandbox(driverpkg.RuntimeDriverDocker) + if err := manager.PrepareSandbox(context.Background(), sandbox); err != nil { + t.Fatalf("first PrepareSandbox() error = %v", err) + } + first := sandbox.NetworkState.Bindings[0].HostPort + if err := manager.PrepareSandbox(context.Background(), sandbox); err != nil { + t.Fatalf("second PrepareSandbox() error = %v", err) + } + if got := sandbox.NetworkState.Bindings[0].HostPort; got != first { + t.Fatalf("resumed host port = %d, want %d", got, first) + } +} + +func networkTestSandbox(runtimeDriver string) *domain.Sandbox { + return &domain.Sandbox{ + Summary: domain.SandboxSummary{ID: "sandbox-1", Driver: runtimeDriver}, + NetworkIntent: &domain.SandboxNetworkIntent{ + ProjectID: "project-1", + ProjectName: "demo", + AgentName: "api", + Attachments: []domain.SandboxNetworkAttachment{{Name: "frontend", Driver: "port_mapping"}}, + Expose: []domain.SandboxNetworkPort{{Target: 8080, Protocol: "tcp"}}, + }, + } +} + +func bindingWithVisibility(t *testing.T, bindings []domain.SandboxPortBinding, visibility string) domain.SandboxPortBinding { + t.Helper() + for _, binding := range bindings { + if binding.Visibility == visibility { + return binding + } + } + t.Fatalf("binding with visibility %q not found in %#v", visibility, bindings) + return domain.SandboxPortBinding{} +} + +type publishAddressProviderStub struct { + defaultAddress string + defaultErr error + defaultCalls int +} + +func (s *publishAddressProviderStub) DefaultPublishAddress(context.Context) (string, error) { + s.defaultCalls++ + return s.defaultAddress, s.defaultErr +} + +type portAllocatorStub struct { + next int + err error + calls int +} + +func (s *portAllocatorStub) AllocateHostPort(context.Context, string) (int, error) { + s.calls++ + if s.err != nil { + return 0, s.err + } + port := s.next + s.next++ + return port, nil +} diff --git a/pkg/runs/controller.go b/pkg/runs/controller.go index 2cde2cbc..7a482387 100644 --- a/pkg/runs/controller.go +++ b/pkg/runs/controller.go @@ -105,7 +105,7 @@ type SandboxRuntimeStore interface { GetVMState(id string) (sessionstore.VMState, error) GetProxyState(id string) (sessionstore.ProxyState, error) SaveProxyState(id string, state sessionstore.ProxyState) error - AllocateHostPortForJupyter() (int, error) + AllocateHostPortForSandbox(string) (int, error) } type Controller struct { @@ -2005,6 +2005,7 @@ func (c *Controller) ensureProjectRunSandbox(ctx context.Context, run domain.Pro return SandboxResult{}, err } jupyterOptions.VolumeMounts = volumeMounts + jupyterOptions.NetworkIntent = prepared.NetworkIntent sandbox, err := c.store.CreateSandboxWithOptions(ctx, SandboxTitle(run), "", @@ -2086,7 +2087,7 @@ func (c *Controller) applyJupyterOptionsToSandbox(sandbox *domain.Sandbox, optio return err } if driver != driverpkg.RuntimeDriverDocker && proxyState.HostPort == 0 { - hostPort, err := c.store.AllocateHostPortForJupyter() + hostPort, err := c.store.AllocateHostPortForSandbox(sandbox.Summary.ID) if err != nil { return err } diff --git a/pkg/runs/coverage_shape_workflows_test.go b/pkg/runs/coverage_shape_workflows_test.go index ebc89b44..70dcc3bf 100644 --- a/pkg/runs/coverage_shape_workflows_test.go +++ b/pkg/runs/coverage_shape_workflows_test.go @@ -2768,6 +2768,6 @@ func (s *fakeGuideSandboxStore) SaveProxyState(string, sessionstore.ProxyState) return errors.New("not implemented") } -func (s *fakeGuideSandboxStore) AllocateHostPortForJupyter() (int, error) { +func (s *fakeGuideSandboxStore) AllocateHostPortForSandbox(string) (int, error) { return 0, errors.New("not implemented") } diff --git a/pkg/runs/network_preparation_test.go b/pkg/runs/network_preparation_test.go new file mode 100644 index 00000000..dc76c62e --- /dev/null +++ b/pkg/runs/network_preparation_test.go @@ -0,0 +1,74 @@ +package runs + +import ( + "strings" + "testing" + + domain "agent-compose/pkg/model" + agentcomposev2 "agent-compose/proto/agentcompose/v2" +) + +func TestSandboxNetworkIntentFromV2(t *testing.T) { + run := domain.ProjectRunRecord{ProjectID: "project-1", ProjectName: "demo", AgentName: "api"} + intent, err := SandboxNetworkIntentFromV2(run, + []*agentcomposev2.NamedNetworkSpec{{Name: "frontend", Driver: "port_mapping"}}, + &agentcomposev2.AgentSpec{ + Networks: []string{"frontend"}, + Expose: []*agentcomposev2.ExposedPortSpec{{Target: 8080, HostPort: 18080, Protocol: "tcp"}}, + Ports: []*agentcomposev2.PublishedPortSpec{{HostIp: "127.0.0.1", Published: 19000, Target: 9000, Protocol: "tcp"}}, + }, + ) + if err != nil { + t.Fatalf("SandboxNetworkIntentFromV2() error = %v", err) + } + if intent.ProjectID != "project-1" || intent.ProjectName != "demo" || intent.AgentName != "api" { + t.Fatalf("identity = %#v", intent) + } + if len(intent.Attachments) != 1 || intent.Attachments[0].Name != "frontend" || intent.Attachments[0].Driver != "port_mapping" { + t.Fatalf("attachments = %#v", intent.Attachments) + } + if len(intent.Expose) != 1 || intent.Expose[0].Target != 8080 || intent.Expose[0].HostPort != 18080 || len(intent.Ports) != 1 || intent.Ports[0].Published != 19000 { + t.Fatalf("ports = expose %#v published %#v", intent.Expose, intent.Ports) + } +} + +func TestSandboxNetworkIntentFromV2ReturnsNilWithoutConfiguration(t *testing.T) { + intent, err := SandboxNetworkIntentFromV2(domain.ProjectRunRecord{}, nil, &agentcomposev2.AgentSpec{}) + if err != nil || intent != nil { + t.Fatalf("SandboxNetworkIntentFromV2() = %#v, %v", intent, err) + } +} + +func TestSandboxNetworkIntentFromV2RejectsInvalidRevisionNetworkData(t *testing.T) { + tests := []struct { + name string + networks []*agentcomposev2.NamedNetworkSpec + agent *agentcomposev2.AgentSpec + contains string + }{ + { + name: "unknown attachment", + networks: []*agentcomposev2.NamedNetworkSpec{{Name: "frontend", Driver: "port_mapping"}}, + agent: &agentcomposev2.AgentSpec{Networks: []string{"missing"}}, + contains: "unknown project network", + }, + { + name: "expose without attachment", + agent: &agentcomposev2.AgentSpec{Expose: []*agentcomposev2.ExposedPortSpec{{Target: 8080}}}, + contains: "requires at least one network attachment", + }, + { + name: "udp", + agent: &agentcomposev2.AgentSpec{Ports: []*agentcomposev2.PublishedPortSpec{{Target: 8080, Protocol: "udp"}}}, + contains: "only TCP ports are supported", + }, + } + for _, tt := range tests { + t.Run(tt.name, func(t *testing.T) { + _, err := SandboxNetworkIntentFromV2(domain.ProjectRunRecord{}, tt.networks, tt.agent) + if err == nil || !strings.Contains(err.Error(), tt.contains) { + t.Fatalf("SandboxNetworkIntentFromV2() error = %v", err) + } + }) + } +} diff --git a/pkg/runs/preparation.go b/pkg/runs/preparation.go index ef8d1cf8..c912a64b 100644 --- a/pkg/runs/preparation.go +++ b/pkg/runs/preparation.go @@ -38,6 +38,7 @@ type Preparation struct { ProjectRoot string ProjectVolumes map[string]domain.VolumeRecord Jupyter sessionstore.CreateSandboxOptions + NetworkIntent *domain.SandboxNetworkIntent } func PrepareProjectRun(ctx context.Context, store PreparationStore, resolver WorkspaceResolver, run domain.ProjectRunRecord, requestEnv []*agentcomposev2.EnvVarSpec) (Preparation, error) { @@ -76,6 +77,10 @@ func PrepareProjectRun(ctx context.Context, store PreparationStore, resolver Wor ) providerEnvItems := envItems envItems = llms.FilterPersistedRuntimeEnv(envItems) + networkIntent, err := SandboxNetworkIntentFromV2(run, spec.GetNetworks(), agentSpec) + if err != nil { + return Preparation{}, err + } prepared := Preparation{ EnvItems: envItems, ProviderEnvItems: providerEnvItems, @@ -83,6 +88,7 @@ func PrepareProjectRun(ctx context.Context, store PreparationStore, resolver Wor Volumes: agent.Volumes, ProjectRoot: ProjectRoot(project), Jupyter: jupyterOptionsFromAgentSpec(agentSpec), + NetworkIntent: networkIntent, } projectVolumes, err := store.ListProjectVolumes(ctx, project.ID) if err != nil { @@ -107,6 +113,88 @@ func PrepareProjectRun(ctx context.Context, store PreparationStore, resolver Wor return prepared, nil } +func SandboxNetworkIntentFromV2(run domain.ProjectRunRecord, projectNetworks []*agentcomposev2.NamedNetworkSpec, agent *agentcomposev2.AgentSpec) (*domain.SandboxNetworkIntent, error) { + if agent == nil || (len(agent.GetNetworks()) == 0 && len(agent.GetExpose()) == 0 && len(agent.GetPorts()) == 0) { + return nil, nil + } + available := make(map[string]string, len(projectNetworks)) + for i, network := range projectNetworks { + name := strings.TrimSpace(network.GetName()) + if name == "" { + return nil, fmt.Errorf("project network %d name is required", i) + } + if _, exists := available[name]; exists { + return nil, fmt.Errorf("duplicate project network %q", name) + } + driver := strings.ToLower(strings.TrimSpace(network.GetDriver())) + if driver == "" { + driver = compose.NetworkDriverPortMapping + } + if driver != compose.NetworkDriverPortMapping { + return nil, fmt.Errorf("project network %q uses unsupported driver %q", name, driver) + } + available[name] = driver + } + intent := &domain.SandboxNetworkIntent{ + ProjectID: strings.TrimSpace(run.ProjectID), + ProjectName: strings.TrimSpace(run.ProjectName), + AgentName: strings.TrimSpace(run.AgentName), + } + for i, rawName := range agent.GetNetworks() { + name := strings.TrimSpace(rawName) + driver, ok := available[name] + if !ok { + return nil, fmt.Errorf("agent network %d references unknown project network %q", i, name) + } + intent.Attachments = append(intent.Attachments, domain.SandboxNetworkAttachment{Name: name, Driver: driver}) + } + if len(agent.GetExpose()) > 0 && len(intent.Attachments) == 0 { + return nil, fmt.Errorf("agent expose requires at least one network attachment") + } + for i, port := range agent.GetExpose() { + target, protocol, err := sandboxTCPPort(int(port.GetTarget()), port.GetProtocol()) + if err != nil { + return nil, fmt.Errorf("agent expose %d: %w", i, err) + } + hostPort := int(port.GetHostPort()) + if hostPort < 0 || hostPort > 65535 { + return nil, fmt.Errorf("agent expose %d: host port must be between 1 and 65535 or omitted", i) + } + intent.Expose = append(intent.Expose, domain.SandboxNetworkPort{Target: target, HostPort: hostPort, Protocol: protocol}) + } + for i, port := range agent.GetPorts() { + target, protocol, err := sandboxTCPPort(int(port.GetTarget()), port.GetProtocol()) + if err != nil { + return nil, fmt.Errorf("agent ports %d: %w", i, err) + } + published := int(port.GetPublished()) + if published < 0 || published > 65535 { + return nil, fmt.Errorf("agent ports %d: published port must be between 1 and 65535 or omitted", i) + } + intent.Ports = append(intent.Ports, domain.SandboxPublishedPort{ + HostIP: strings.TrimSpace(port.GetHostIp()), + Published: published, + Target: target, + Protocol: protocol, + }) + } + return intent, nil +} + +func sandboxTCPPort(target int, rawProtocol string) (int, string, error) { + if target < 1 || target > 65535 { + return 0, "", fmt.Errorf("target port must be between 1 and 65535") + } + protocol := strings.ToLower(strings.TrimSpace(rawProtocol)) + if protocol == "" { + protocol = "tcp" + } + if protocol != "tcp" { + return 0, "", fmt.Errorf("only TCP ports are supported") + } + return target, protocol, nil +} + func ProjectRoot(project domain.ProjectRecord) string { sourcePath := strings.TrimSpace(project.SourcePath) if sourcePath == "" { diff --git a/pkg/storage/sessionstore/store.go b/pkg/storage/sessionstore/store.go index 2d3768e0..06b889a7 100644 --- a/pkg/storage/sessionstore/store.go +++ b/pkg/storage/sessionstore/store.go @@ -52,8 +52,10 @@ type ( ) type Store struct { - config *appconfig.Config - sandboxLocks sync.Map + config *appconfig.Config + sandboxLocks sync.Map + hostPortMu sync.Mutex + reservedHostPorts map[int]string } func NewStore(di do.Injector) (*Store, error) { @@ -85,6 +87,7 @@ type CreateSandboxOptions struct { JupyterGuestPort int JupyterExpose bool VolumeMounts []domain.SandboxVolumeMount + NetworkIntent *domain.SandboxNetworkIntent } func (s *Store) CreateSandbox(ctx context.Context, title, baseWorkspace, driver, guestImage, workspaceID, triggerSource string, workspace *SandboxWorkspace, envItems []SandboxEnvVar, tags []SandboxTag) (*Sandbox, error) { @@ -151,6 +154,7 @@ func (s *Store) CreateSandboxWithOptions(_ context.Context, title, baseWorkspace WorkspaceProvisioning: workspaceProvisioning, EnvItems: append([]SandboxEnvVar(nil), envItems...), VolumeMounts: domain.NormalizeSandboxVolumeMounts(options.VolumeMounts), + NetworkIntent: domain.CloneSandboxNetworkIntent(options.NetworkIntent), } if session.Summary.Title == "" { @@ -182,7 +186,7 @@ func (s *Store) CreateSandboxWithOptions(_ context.Context, title, baseWorkspace guestPort = s.config.JupyterGuestPort } if driver != driverpkg.RuntimeDriverDocker { - hostPort, err := s.allocateHostPort() + hostPort, err := s.allocateHostPort(id) if err != nil { return nil, err } @@ -288,6 +292,7 @@ func (s *Store) RemoveSandbox(_ context.Context, id string) error { if err := os.RemoveAll(path); err != nil { return fmt.Errorf("remove sandbox dir %s: %w", id, err) } + s.releaseHostPorts(id) s.sandboxLocks.Delete(sandboxLockKey(id)) return nil } @@ -933,20 +938,114 @@ func (s *Store) SaveProxyState(id string, state ProxyState) error { } func (s *Store) AllocateHostPortForJupyter() (int, error) { - return s.allocateHostPort() + return s.AllocateHostPort() } -func (s *Store) allocateHostPort() (int, error) { - listener, err := net.Listen("tcp", "127.0.0.1:0") +func (s *Store) AllocateHostPort() (int, error) { + return s.allocateHostPort("") +} + +func (s *Store) AllocateHostPortForSandbox(sandboxID string) (int, error) { + return s.allocateHostPort(strings.TrimSpace(sandboxID)) +} + +func (s *Store) allocateHostPort(owner string) (int, error) { + s.hostPortMu.Lock() + defer s.hostPortMu.Unlock() + used, err := s.persistedHostPorts() if err != nil { - return 0, fmt.Errorf("allocate host port: %w", err) + return 0, err + } + if s.reservedHostPorts == nil { + s.reservedHostPorts = make(map[int]string) } - defer func() { _ = listener.Close() }() - addr, ok := listener.Addr().(*net.TCPAddr) - if !ok { - return 0, fmt.Errorf("allocate host port: unexpected addr %T", listener.Addr()) + for port := range s.reservedHostPorts { + used[port] = struct{}{} } - return addr.Port, nil + var held []net.Listener + defer func() { + for _, listener := range held { + _ = listener.Close() + } + }() + for range 1024 { + listener, err := net.Listen("tcp", "0.0.0.0:0") + if err != nil { + return 0, fmt.Errorf("allocate host port: %w", err) + } + held = append(held, listener) + addr, ok := listener.Addr().(*net.TCPAddr) + if !ok { + return 0, fmt.Errorf("allocate host port: unexpected addr %T", listener.Addr()) + } + if _, exists := used[addr.Port]; exists { + continue + } + s.reservedHostPorts[addr.Port] = owner + return addr.Port, nil + } + return 0, fmt.Errorf("allocate host port: no unreserved port found") +} + +func (s *Store) releaseHostPorts(owner string) { + owner = strings.TrimSpace(owner) + if owner == "" { + return + } + s.hostPortMu.Lock() + defer s.hostPortMu.Unlock() + for port, reservedOwner := range s.reservedHostPorts { + if reservedOwner == owner { + delete(s.reservedHostPorts, port) + } + } +} + +func (s *Store) persistedHostPorts() (map[int]struct{}, error) { + result := make(map[int]struct{}) + entries, err := os.ReadDir(s.config.SandboxRoot) + if err != nil { + return nil, fmt.Errorf("scan persisted host ports: %w", err) + } + for _, entry := range entries { + if !entry.IsDir() { + continue + } + dir := filepath.Join(s.config.SandboxRoot, entry.Name()) + metadata, err := os.ReadFile(filepath.Join(dir, "metadata.json")) + if err != nil { + if os.IsNotExist(err) { + continue + } + return nil, fmt.Errorf("scan persisted host ports in %s: %w", entry.Name(), err) + } + var sandbox Sandbox + if err := json.Unmarshal(metadata, &sandbox); err != nil { + return nil, fmt.Errorf("scan persisted host ports in %s: %w", entry.Name(), err) + } + if sandbox.NetworkState != nil { + for _, binding := range sandbox.NetworkState.Bindings { + if binding.HostPort > 0 { + result[binding.HostPort] = struct{}{} + } + } + } + proxyData, err := os.ReadFile(filepath.Join(dir, "proxy", "jupyter.json")) + if err != nil { + if os.IsNotExist(err) { + continue + } + return nil, fmt.Errorf("scan persisted proxy host port in %s: %w", entry.Name(), err) + } + var proxy ProxyState + if err := json.Unmarshal(proxyData, &proxy); err != nil { + return nil, fmt.Errorf("scan persisted proxy host port in %s: %w", entry.Name(), err) + } + if proxy.HostPort > 0 { + result[proxy.HostPort] = struct{}{} + } + } + return result, nil } func (s *Store) readJSONFile(path string, target any) error { diff --git a/pkg/storage/sessionstore/store_network_test.go b/pkg/storage/sessionstore/store_network_test.go new file mode 100644 index 00000000..eab0a7ae --- /dev/null +++ b/pkg/storage/sessionstore/store_network_test.go @@ -0,0 +1,93 @@ +package sessionstore + +import ( + "context" + "testing" + + driverpkg "agent-compose/pkg/driver" + domain "agent-compose/pkg/model" +) + +func TestCreateSandboxPersistsIndependentNetworkIntent(t *testing.T) { + store := newCoverageStore(t) + intent := &domain.SandboxNetworkIntent{ + ProjectID: "project-1", + ProjectName: "demo", + AgentName: "api", + Attachments: []domain.SandboxNetworkAttachment{{Name: "frontend", Driver: "port_mapping"}}, + Expose: []domain.SandboxNetworkPort{{Target: 8080, Protocol: "tcp"}}, + } + sandbox, err := store.CreateSandboxWithOptions(context.Background(), "network", "", driverpkg.RuntimeDriverDocker, "", "", "", nil, nil, nil, CreateSandboxOptions{NetworkIntent: intent}) + if err != nil { + t.Fatalf("CreateSandboxWithOptions() error = %v", err) + } + intent.Attachments[0].Name = "mutated" + intent.Expose[0].Target = 9999 + if sandbox.NetworkIntent.Attachments[0].Name != "frontend" || sandbox.NetworkIntent.Expose[0].Target != 8080 { + t.Fatalf("created network intent was aliased: %#v", sandbox.NetworkIntent) + } + loaded, err := store.GetSandbox(context.Background(), sandbox.Summary.ID) + if err != nil { + t.Fatalf("GetSandbox() error = %v", err) + } + if loaded.NetworkIntent == nil || loaded.NetworkIntent.ProjectID != "project-1" || loaded.NetworkIntent.Attachments[0].Name != "frontend" { + t.Fatalf("persisted network intent = %#v", loaded.NetworkIntent) + } +} + +func TestAllocateHostPortDoesNotReuseStoppedSandboxAllocationAfterRestart(t *testing.T) { + store := newCoverageStore(t) + ctx := context.Background() + sandbox, err := store.CreateSandbox(ctx, "network", "", driverpkg.RuntimeDriverDocker, "", "", "", nil, nil, nil) + if err != nil { + t.Fatal(err) + } + allocated, err := store.AllocateHostPortForSandbox(sandbox.Summary.ID) + if err != nil { + t.Fatal(err) + } + sandbox.NetworkState = &domain.SandboxNetworkState{Bindings: []domain.SandboxPortBinding{{HostIP: "127.0.0.1", HostPort: allocated, GuestPort: 8080, Protocol: "tcp"}}} + if err := store.UpdateSandbox(ctx, sandbox); err != nil { + t.Fatal(err) + } + restarted, err := NewWithConfig(store.config) + if err != nil { + t.Fatal(err) + } + used, err := restarted.persistedHostPorts() + if err != nil { + t.Fatal(err) + } + if _, ok := used[allocated]; !ok { + t.Fatalf("persisted host ports do not include %d: %#v", allocated, used) + } + next, err := restarted.AllocateHostPort() + if err != nil { + t.Fatal(err) + } + if next == allocated { + t.Fatalf("reused persisted host port %d", allocated) + } +} + +func TestRemoveSandboxReleasesOwnedHostPortReservations(t *testing.T) { + store := newCoverageStore(t) + ctx := context.Background() + sandbox, err := store.CreateSandbox(ctx, "network", "", driverpkg.RuntimeDriverDocker, "", "", "", nil, nil, nil) + if err != nil { + t.Fatal(err) + } + port, err := store.AllocateHostPortForSandbox(sandbox.Summary.ID) + if err != nil { + t.Fatal(err) + } + if owner := store.reservedHostPorts[port]; owner != sandbox.Summary.ID { + t.Fatalf("reservation owner = %q", owner) + } + if err := store.RemoveSandbox(ctx, sandbox.Summary.ID); err != nil { + t.Fatal(err) + } + if _, exists := store.reservedHostPorts[port]; exists { + t.Fatalf("host port %d reservation was not released", port) + } +} diff --git a/proto/agentcompose/v2/agentcompose.pb.go b/proto/agentcompose/v2/agentcompose.pb.go index 824f438c..71c31f66 100644 --- a/proto/agentcompose/v2/agentcompose.pb.go +++ b/proto/agentcompose/v2/agentcompose.pb.go @@ -1,7 +1,7 @@ // Code generated by protoc-gen-go. DO NOT EDIT. // versions: // protoc-gen-go v1.36.11 -// protoc (unknown) +// protoc v3.21.12 // source: agentcompose/v2/agentcompose.proto package agentcomposev2 @@ -3655,6 +3655,7 @@ type ProjectSpec struct { Volumes []*ProjectVolumeSpec `protobuf:"bytes,6,rep,name=volumes,proto3" json:"volumes,omitempty"` Workspaces []*NamedWorkspaceSpec `protobuf:"bytes,7,rep,name=workspaces,proto3" json:"workspaces,omitempty"` Mcps []*MCPServerSpec `protobuf:"bytes,8,rep,name=mcps,proto3" json:"mcps,omitempty"` + Networks []*NamedNetworkSpec `protobuf:"bytes,9,rep,name=networks,proto3" json:"networks,omitempty"` unknownFields protoimpl.UnknownFields sizeCache protoimpl.SizeCache } @@ -3738,6 +3739,13 @@ func (x *ProjectSpec) GetMcps() []*MCPServerSpec { return nil } +func (x *ProjectSpec) GetNetworks() []*NamedNetworkSpec { + if x != nil { + return x.Networks + } + return nil +} + type NamedWorkspaceSpec struct { state protoimpl.MessageState `protogen:"open.v1"` Name string `protobuf:"bytes,1,opt,name=name,proto3" json:"name,omitempty"` @@ -3808,6 +3816,9 @@ type AgentSpec struct { Mcps []*MCPServerSpec `protobuf:"bytes,14,rep,name=mcps,proto3" json:"mcps,omitempty"` Skills []*SkillSpec `protobuf:"bytes,15,rep,name=skills,proto3" json:"skills,omitempty"` Status AgentStatus `protobuf:"varint,16,opt,name=status,proto3,enum=agentcompose.v2.AgentStatus" json:"status,omitempty"` + Networks []string `protobuf:"bytes,17,rep,name=networks,proto3" json:"networks,omitempty"` + Expose []*ExposedPortSpec `protobuf:"bytes,18,rep,name=expose,proto3" json:"expose,omitempty"` + Ports []*PublishedPortSpec `protobuf:"bytes,19,rep,name=ports,proto3" json:"ports,omitempty"` unknownFields protoimpl.UnknownFields sizeCache protoimpl.SizeCache } @@ -3954,6 +3965,27 @@ func (x *AgentSpec) GetStatus() AgentStatus { return AgentStatus_AGENT_STATUS_UNSPECIFIED } +func (x *AgentSpec) GetNetworks() []string { + if x != nil { + return x.Networks + } + return nil +} + +func (x *AgentSpec) GetExpose() []*ExposedPortSpec { + if x != nil { + return x.Expose + } + return nil +} + +func (x *AgentSpec) GetPorts() []*PublishedPortSpec { + if x != nil { + return x.Ports + } + return nil +} + type MCPServerSpec struct { state protoimpl.MessageState `protogen:"open.v1"` Name string `protobuf:"bytes,1,opt,name=name,proto3" json:"name,omitempty"` @@ -4546,6 +4578,186 @@ func (x *NetworkSpec) GetMode() string { return "" } +type NamedNetworkSpec struct { + state protoimpl.MessageState `protogen:"open.v1"` + Name string `protobuf:"bytes,1,opt,name=name,proto3" json:"name,omitempty"` + Driver string `protobuf:"bytes,2,opt,name=driver,proto3" json:"driver,omitempty"` + unknownFields protoimpl.UnknownFields + sizeCache protoimpl.SizeCache +} + +func (x *NamedNetworkSpec) Reset() { + *x = NamedNetworkSpec{} + mi := &file_agentcompose_v2_agentcompose_proto_msgTypes[47] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) +} + +func (x *NamedNetworkSpec) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*NamedNetworkSpec) ProtoMessage() {} + +func (x *NamedNetworkSpec) ProtoReflect() protoreflect.Message { + mi := &file_agentcompose_v2_agentcompose_proto_msgTypes[47] + if x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use NamedNetworkSpec.ProtoReflect.Descriptor instead. +func (*NamedNetworkSpec) Descriptor() ([]byte, []int) { + return file_agentcompose_v2_agentcompose_proto_rawDescGZIP(), []int{47} +} + +func (x *NamedNetworkSpec) GetName() string { + if x != nil { + return x.Name + } + return "" +} + +func (x *NamedNetworkSpec) GetDriver() string { + if x != nil { + return x.Driver + } + return "" +} + +type ExposedPortSpec struct { + state protoimpl.MessageState `protogen:"open.v1"` + Target uint32 `protobuf:"varint,1,opt,name=target,proto3" json:"target,omitempty"` + Protocol string `protobuf:"bytes,2,opt,name=protocol,proto3" json:"protocol,omitempty"` + HostPort uint32 `protobuf:"varint,3,opt,name=host_port,json=hostPort,proto3" json:"host_port,omitempty"` + unknownFields protoimpl.UnknownFields + sizeCache protoimpl.SizeCache +} + +func (x *ExposedPortSpec) Reset() { + *x = ExposedPortSpec{} + mi := &file_agentcompose_v2_agentcompose_proto_msgTypes[48] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) +} + +func (x *ExposedPortSpec) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*ExposedPortSpec) ProtoMessage() {} + +func (x *ExposedPortSpec) ProtoReflect() protoreflect.Message { + mi := &file_agentcompose_v2_agentcompose_proto_msgTypes[48] + if x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use ExposedPortSpec.ProtoReflect.Descriptor instead. +func (*ExposedPortSpec) Descriptor() ([]byte, []int) { + return file_agentcompose_v2_agentcompose_proto_rawDescGZIP(), []int{48} +} + +func (x *ExposedPortSpec) GetTarget() uint32 { + if x != nil { + return x.Target + } + return 0 +} + +func (x *ExposedPortSpec) GetProtocol() string { + if x != nil { + return x.Protocol + } + return "" +} + +func (x *ExposedPortSpec) GetHostPort() uint32 { + if x != nil { + return x.HostPort + } + return 0 +} + +type PublishedPortSpec struct { + state protoimpl.MessageState `protogen:"open.v1"` + HostIp string `protobuf:"bytes,1,opt,name=host_ip,json=hostIp,proto3" json:"host_ip,omitempty"` + Published uint32 `protobuf:"varint,2,opt,name=published,proto3" json:"published,omitempty"` + Target uint32 `protobuf:"varint,3,opt,name=target,proto3" json:"target,omitempty"` + Protocol string `protobuf:"bytes,4,opt,name=protocol,proto3" json:"protocol,omitempty"` + unknownFields protoimpl.UnknownFields + sizeCache protoimpl.SizeCache +} + +func (x *PublishedPortSpec) Reset() { + *x = PublishedPortSpec{} + mi := &file_agentcompose_v2_agentcompose_proto_msgTypes[49] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) +} + +func (x *PublishedPortSpec) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*PublishedPortSpec) ProtoMessage() {} + +func (x *PublishedPortSpec) ProtoReflect() protoreflect.Message { + mi := &file_agentcompose_v2_agentcompose_proto_msgTypes[49] + if x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use PublishedPortSpec.ProtoReflect.Descriptor instead. +func (*PublishedPortSpec) Descriptor() ([]byte, []int) { + return file_agentcompose_v2_agentcompose_proto_rawDescGZIP(), []int{49} +} + +func (x *PublishedPortSpec) GetHostIp() string { + if x != nil { + return x.HostIp + } + return "" +} + +func (x *PublishedPortSpec) GetPublished() uint32 { + if x != nil { + return x.Published + } + return 0 +} + +func (x *PublishedPortSpec) GetTarget() uint32 { + if x != nil { + return x.Target + } + return 0 +} + +func (x *PublishedPortSpec) GetProtocol() string { + if x != nil { + return x.Protocol + } + return "" +} + type SchedulerSpec struct { state protoimpl.MessageState `protogen:"open.v1"` Enabled bool `protobuf:"varint,1,opt,name=enabled,proto3" json:"enabled,omitempty"` @@ -4558,7 +4770,7 @@ type SchedulerSpec struct { func (x *SchedulerSpec) Reset() { *x = SchedulerSpec{} - mi := &file_agentcompose_v2_agentcompose_proto_msgTypes[47] + mi := &file_agentcompose_v2_agentcompose_proto_msgTypes[50] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -4570,7 +4782,7 @@ func (x *SchedulerSpec) String() string { func (*SchedulerSpec) ProtoMessage() {} func (x *SchedulerSpec) ProtoReflect() protoreflect.Message { - mi := &file_agentcompose_v2_agentcompose_proto_msgTypes[47] + mi := &file_agentcompose_v2_agentcompose_proto_msgTypes[50] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -4583,7 +4795,7 @@ func (x *SchedulerSpec) ProtoReflect() protoreflect.Message { // Deprecated: Use SchedulerSpec.ProtoReflect.Descriptor instead. func (*SchedulerSpec) Descriptor() ([]byte, []int) { - return file_agentcompose_v2_agentcompose_proto_rawDescGZIP(), []int{47} + return file_agentcompose_v2_agentcompose_proto_rawDescGZIP(), []int{50} } func (x *SchedulerSpec) GetEnabled() bool { @@ -4630,7 +4842,7 @@ type TriggerSpec struct { func (x *TriggerSpec) Reset() { *x = TriggerSpec{} - mi := &file_agentcompose_v2_agentcompose_proto_msgTypes[48] + mi := &file_agentcompose_v2_agentcompose_proto_msgTypes[51] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -4642,7 +4854,7 @@ func (x *TriggerSpec) String() string { func (*TriggerSpec) ProtoMessage() {} func (x *TriggerSpec) ProtoReflect() protoreflect.Message { - mi := &file_agentcompose_v2_agentcompose_proto_msgTypes[48] + mi := &file_agentcompose_v2_agentcompose_proto_msgTypes[51] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -4655,7 +4867,7 @@ func (x *TriggerSpec) ProtoReflect() protoreflect.Message { // Deprecated: Use TriggerSpec.ProtoReflect.Descriptor instead. func (*TriggerSpec) Descriptor() ([]byte, []int) { - return file_agentcompose_v2_agentcompose_proto_rawDescGZIP(), []int{48} + return file_agentcompose_v2_agentcompose_proto_rawDescGZIP(), []int{51} } func (x *TriggerSpec) GetName() string { @@ -4723,7 +4935,7 @@ type EventTriggerSpec struct { func (x *EventTriggerSpec) Reset() { *x = EventTriggerSpec{} - mi := &file_agentcompose_v2_agentcompose_proto_msgTypes[49] + mi := &file_agentcompose_v2_agentcompose_proto_msgTypes[52] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -4735,7 +4947,7 @@ func (x *EventTriggerSpec) String() string { func (*EventTriggerSpec) ProtoMessage() {} func (x *EventTriggerSpec) ProtoReflect() protoreflect.Message { - mi := &file_agentcompose_v2_agentcompose_proto_msgTypes[49] + mi := &file_agentcompose_v2_agentcompose_proto_msgTypes[52] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -4748,7 +4960,7 @@ func (x *EventTriggerSpec) ProtoReflect() protoreflect.Message { // Deprecated: Use EventTriggerSpec.ProtoReflect.Descriptor instead. func (*EventTriggerSpec) Descriptor() ([]byte, []int) { - return file_agentcompose_v2_agentcompose_proto_rawDescGZIP(), []int{49} + return file_agentcompose_v2_agentcompose_proto_rawDescGZIP(), []int{52} } func (x *EventTriggerSpec) GetTopic() string { @@ -4770,7 +4982,7 @@ type DriverSpec struct { func (x *DriverSpec) Reset() { *x = DriverSpec{} - mi := &file_agentcompose_v2_agentcompose_proto_msgTypes[50] + mi := &file_agentcompose_v2_agentcompose_proto_msgTypes[53] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -4782,7 +4994,7 @@ func (x *DriverSpec) String() string { func (*DriverSpec) ProtoMessage() {} func (x *DriverSpec) ProtoReflect() protoreflect.Message { - mi := &file_agentcompose_v2_agentcompose_proto_msgTypes[50] + mi := &file_agentcompose_v2_agentcompose_proto_msgTypes[53] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -4795,7 +5007,7 @@ func (x *DriverSpec) ProtoReflect() protoreflect.Message { // Deprecated: Use DriverSpec.ProtoReflect.Descriptor instead. func (*DriverSpec) Descriptor() ([]byte, []int) { - return file_agentcompose_v2_agentcompose_proto_rawDescGZIP(), []int{50} + return file_agentcompose_v2_agentcompose_proto_rawDescGZIP(), []int{53} } func (x *DriverSpec) GetName() string { @@ -4836,7 +5048,7 @@ type BoxliteDriverSpec struct { func (x *BoxliteDriverSpec) Reset() { *x = BoxliteDriverSpec{} - mi := &file_agentcompose_v2_agentcompose_proto_msgTypes[51] + mi := &file_agentcompose_v2_agentcompose_proto_msgTypes[54] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -4848,7 +5060,7 @@ func (x *BoxliteDriverSpec) String() string { func (*BoxliteDriverSpec) ProtoMessage() {} func (x *BoxliteDriverSpec) ProtoReflect() protoreflect.Message { - mi := &file_agentcompose_v2_agentcompose_proto_msgTypes[51] + mi := &file_agentcompose_v2_agentcompose_proto_msgTypes[54] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -4861,7 +5073,7 @@ func (x *BoxliteDriverSpec) ProtoReflect() protoreflect.Message { // Deprecated: Use BoxliteDriverSpec.ProtoReflect.Descriptor instead. func (*BoxliteDriverSpec) Descriptor() ([]byte, []int) { - return file_agentcompose_v2_agentcompose_proto_rawDescGZIP(), []int{51} + return file_agentcompose_v2_agentcompose_proto_rawDescGZIP(), []int{54} } func (x *BoxliteDriverSpec) GetKernel() string { @@ -4887,7 +5099,7 @@ type DockerDriverSpec struct { func (x *DockerDriverSpec) Reset() { *x = DockerDriverSpec{} - mi := &file_agentcompose_v2_agentcompose_proto_msgTypes[52] + mi := &file_agentcompose_v2_agentcompose_proto_msgTypes[55] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -4899,7 +5111,7 @@ func (x *DockerDriverSpec) String() string { func (*DockerDriverSpec) ProtoMessage() {} func (x *DockerDriverSpec) ProtoReflect() protoreflect.Message { - mi := &file_agentcompose_v2_agentcompose_proto_msgTypes[52] + mi := &file_agentcompose_v2_agentcompose_proto_msgTypes[55] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -4912,7 +5124,7 @@ func (x *DockerDriverSpec) ProtoReflect() protoreflect.Message { // Deprecated: Use DockerDriverSpec.ProtoReflect.Descriptor instead. func (*DockerDriverSpec) Descriptor() ([]byte, []int) { - return file_agentcompose_v2_agentcompose_proto_rawDescGZIP(), []int{52} + return file_agentcompose_v2_agentcompose_proto_rawDescGZIP(), []int{55} } func (x *DockerDriverSpec) GetHost() string { @@ -4931,7 +5143,7 @@ type MicrosandboxDriverSpec struct { func (x *MicrosandboxDriverSpec) Reset() { *x = MicrosandboxDriverSpec{} - mi := &file_agentcompose_v2_agentcompose_proto_msgTypes[53] + mi := &file_agentcompose_v2_agentcompose_proto_msgTypes[56] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -4943,7 +5155,7 @@ func (x *MicrosandboxDriverSpec) String() string { func (*MicrosandboxDriverSpec) ProtoMessage() {} func (x *MicrosandboxDriverSpec) ProtoReflect() protoreflect.Message { - mi := &file_agentcompose_v2_agentcompose_proto_msgTypes[53] + mi := &file_agentcompose_v2_agentcompose_proto_msgTypes[56] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -4956,7 +5168,7 @@ func (x *MicrosandboxDriverSpec) ProtoReflect() protoreflect.Message { // Deprecated: Use MicrosandboxDriverSpec.ProtoReflect.Descriptor instead. func (*MicrosandboxDriverSpec) Descriptor() ([]byte, []int) { - return file_agentcompose_v2_agentcompose_proto_rawDescGZIP(), []int{53} + return file_agentcompose_v2_agentcompose_proto_rawDescGZIP(), []int{56} } func (x *MicrosandboxDriverSpec) GetProfile() string { @@ -4990,7 +5202,7 @@ type RunAgentRequest struct { func (x *RunAgentRequest) Reset() { *x = RunAgentRequest{} - mi := &file_agentcompose_v2_agentcompose_proto_msgTypes[54] + mi := &file_agentcompose_v2_agentcompose_proto_msgTypes[57] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -5002,7 +5214,7 @@ func (x *RunAgentRequest) String() string { func (*RunAgentRequest) ProtoMessage() {} func (x *RunAgentRequest) ProtoReflect() protoreflect.Message { - mi := &file_agentcompose_v2_agentcompose_proto_msgTypes[54] + mi := &file_agentcompose_v2_agentcompose_proto_msgTypes[57] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -5015,7 +5227,7 @@ func (x *RunAgentRequest) ProtoReflect() protoreflect.Message { // Deprecated: Use RunAgentRequest.ProtoReflect.Descriptor instead. func (*RunAgentRequest) Descriptor() ([]byte, []int) { - return file_agentcompose_v2_agentcompose_proto_rawDescGZIP(), []int{54} + return file_agentcompose_v2_agentcompose_proto_rawDescGZIP(), []int{57} } func (x *RunAgentRequest) GetProjectId() string { @@ -5140,7 +5352,7 @@ type RunAgentResponse struct { func (x *RunAgentResponse) Reset() { *x = RunAgentResponse{} - mi := &file_agentcompose_v2_agentcompose_proto_msgTypes[55] + mi := &file_agentcompose_v2_agentcompose_proto_msgTypes[58] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -5152,7 +5364,7 @@ func (x *RunAgentResponse) String() string { func (*RunAgentResponse) ProtoMessage() {} func (x *RunAgentResponse) ProtoReflect() protoreflect.Message { - mi := &file_agentcompose_v2_agentcompose_proto_msgTypes[55] + mi := &file_agentcompose_v2_agentcompose_proto_msgTypes[58] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -5165,7 +5377,7 @@ func (x *RunAgentResponse) ProtoReflect() protoreflect.Message { // Deprecated: Use RunAgentResponse.ProtoReflect.Descriptor instead. func (*RunAgentResponse) Descriptor() ([]byte, []int) { - return file_agentcompose_v2_agentcompose_proto_rawDescGZIP(), []int{55} + return file_agentcompose_v2_agentcompose_proto_rawDescGZIP(), []int{58} } func (x *RunAgentResponse) GetRun() *RunDetail { @@ -5198,7 +5410,7 @@ type RunAgentStreamResponse struct { func (x *RunAgentStreamResponse) Reset() { *x = RunAgentStreamResponse{} - mi := &file_agentcompose_v2_agentcompose_proto_msgTypes[56] + mi := &file_agentcompose_v2_agentcompose_proto_msgTypes[59] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -5210,7 +5422,7 @@ func (x *RunAgentStreamResponse) String() string { func (*RunAgentStreamResponse) ProtoMessage() {} func (x *RunAgentStreamResponse) ProtoReflect() protoreflect.Message { - mi := &file_agentcompose_v2_agentcompose_proto_msgTypes[56] + mi := &file_agentcompose_v2_agentcompose_proto_msgTypes[59] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -5223,7 +5435,7 @@ func (x *RunAgentStreamResponse) ProtoReflect() protoreflect.Message { // Deprecated: Use RunAgentStreamResponse.ProtoReflect.Descriptor instead. func (*RunAgentStreamResponse) Descriptor() ([]byte, []int) { - return file_agentcompose_v2_agentcompose_proto_rawDescGZIP(), []int{56} + return file_agentcompose_v2_agentcompose_proto_rawDescGZIP(), []int{59} } func (x *RunAgentStreamResponse) GetEventType() RunAgentStreamEventType { @@ -5301,7 +5513,7 @@ type RunAttachRequest struct { func (x *RunAttachRequest) Reset() { *x = RunAttachRequest{} - mi := &file_agentcompose_v2_agentcompose_proto_msgTypes[57] + mi := &file_agentcompose_v2_agentcompose_proto_msgTypes[60] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -5313,7 +5525,7 @@ func (x *RunAttachRequest) String() string { func (*RunAttachRequest) ProtoMessage() {} func (x *RunAttachRequest) ProtoReflect() protoreflect.Message { - mi := &file_agentcompose_v2_agentcompose_proto_msgTypes[57] + mi := &file_agentcompose_v2_agentcompose_proto_msgTypes[60] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -5326,7 +5538,7 @@ func (x *RunAttachRequest) ProtoReflect() protoreflect.Message { // Deprecated: Use RunAttachRequest.ProtoReflect.Descriptor instead. func (*RunAttachRequest) Descriptor() ([]byte, []int) { - return file_agentcompose_v2_agentcompose_proto_rawDescGZIP(), []int{57} + return file_agentcompose_v2_agentcompose_proto_rawDescGZIP(), []int{60} } func (x *RunAttachRequest) GetClientFrameId() string { @@ -5471,7 +5683,7 @@ type RunAttachResponse struct { func (x *RunAttachResponse) Reset() { *x = RunAttachResponse{} - mi := &file_agentcompose_v2_agentcompose_proto_msgTypes[58] + mi := &file_agentcompose_v2_agentcompose_proto_msgTypes[61] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -5483,7 +5695,7 @@ func (x *RunAttachResponse) String() string { func (*RunAttachResponse) ProtoMessage() {} func (x *RunAttachResponse) ProtoReflect() protoreflect.Message { - mi := &file_agentcompose_v2_agentcompose_proto_msgTypes[58] + mi := &file_agentcompose_v2_agentcompose_proto_msgTypes[61] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -5496,7 +5708,7 @@ func (x *RunAttachResponse) ProtoReflect() protoreflect.Message { // Deprecated: Use RunAttachResponse.ProtoReflect.Descriptor instead. func (*RunAttachResponse) Descriptor() ([]byte, []int) { - return file_agentcompose_v2_agentcompose_proto_rawDescGZIP(), []int{58} + return file_agentcompose_v2_agentcompose_proto_rawDescGZIP(), []int{61} } func (x *RunAttachResponse) GetServerFrameId() string { @@ -5627,7 +5839,7 @@ type RunAttachStart struct { func (x *RunAttachStart) Reset() { *x = RunAttachStart{} - mi := &file_agentcompose_v2_agentcompose_proto_msgTypes[59] + mi := &file_agentcompose_v2_agentcompose_proto_msgTypes[62] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -5639,7 +5851,7 @@ func (x *RunAttachStart) String() string { func (*RunAttachStart) ProtoMessage() {} func (x *RunAttachStart) ProtoReflect() protoreflect.Message { - mi := &file_agentcompose_v2_agentcompose_proto_msgTypes[59] + mi := &file_agentcompose_v2_agentcompose_proto_msgTypes[62] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -5652,7 +5864,7 @@ func (x *RunAttachStart) ProtoReflect() protoreflect.Message { // Deprecated: Use RunAttachStart.ProtoReflect.Descriptor instead. func (*RunAttachStart) Descriptor() ([]byte, []int) { - return file_agentcompose_v2_agentcompose_proto_rawDescGZIP(), []int{59} + return file_agentcompose_v2_agentcompose_proto_rawDescGZIP(), []int{62} } func (x *RunAttachStart) GetRequest() *RunAgentRequest { @@ -5703,7 +5915,7 @@ type TranscriptEvent struct { func (x *TranscriptEvent) Reset() { *x = TranscriptEvent{} - mi := &file_agentcompose_v2_agentcompose_proto_msgTypes[60] + mi := &file_agentcompose_v2_agentcompose_proto_msgTypes[63] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -5715,7 +5927,7 @@ func (x *TranscriptEvent) String() string { func (*TranscriptEvent) ProtoMessage() {} func (x *TranscriptEvent) ProtoReflect() protoreflect.Message { - mi := &file_agentcompose_v2_agentcompose_proto_msgTypes[60] + mi := &file_agentcompose_v2_agentcompose_proto_msgTypes[63] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -5728,7 +5940,7 @@ func (x *TranscriptEvent) ProtoReflect() protoreflect.Message { // Deprecated: Use TranscriptEvent.ProtoReflect.Descriptor instead. func (*TranscriptEvent) Descriptor() ([]byte, []int) { - return file_agentcompose_v2_agentcompose_proto_rawDescGZIP(), []int{60} + return file_agentcompose_v2_agentcompose_proto_rawDescGZIP(), []int{63} } func (x *TranscriptEvent) GetStream() StdioStream { @@ -5776,7 +5988,7 @@ type GetRunRequest struct { func (x *GetRunRequest) Reset() { *x = GetRunRequest{} - mi := &file_agentcompose_v2_agentcompose_proto_msgTypes[61] + mi := &file_agentcompose_v2_agentcompose_proto_msgTypes[64] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -5788,7 +6000,7 @@ func (x *GetRunRequest) String() string { func (*GetRunRequest) ProtoMessage() {} func (x *GetRunRequest) ProtoReflect() protoreflect.Message { - mi := &file_agentcompose_v2_agentcompose_proto_msgTypes[61] + mi := &file_agentcompose_v2_agentcompose_proto_msgTypes[64] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -5801,7 +6013,7 @@ func (x *GetRunRequest) ProtoReflect() protoreflect.Message { // Deprecated: Use GetRunRequest.ProtoReflect.Descriptor instead. func (*GetRunRequest) Descriptor() ([]byte, []int) { - return file_agentcompose_v2_agentcompose_proto_rawDescGZIP(), []int{61} + return file_agentcompose_v2_agentcompose_proto_rawDescGZIP(), []int{64} } func (x *GetRunRequest) GetRunId() string { @@ -5827,7 +6039,7 @@ type GetRunResponse struct { func (x *GetRunResponse) Reset() { *x = GetRunResponse{} - mi := &file_agentcompose_v2_agentcompose_proto_msgTypes[62] + mi := &file_agentcompose_v2_agentcompose_proto_msgTypes[65] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -5839,7 +6051,7 @@ func (x *GetRunResponse) String() string { func (*GetRunResponse) ProtoMessage() {} func (x *GetRunResponse) ProtoReflect() protoreflect.Message { - mi := &file_agentcompose_v2_agentcompose_proto_msgTypes[62] + mi := &file_agentcompose_v2_agentcompose_proto_msgTypes[65] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -5852,7 +6064,7 @@ func (x *GetRunResponse) ProtoReflect() protoreflect.Message { // Deprecated: Use GetRunResponse.ProtoReflect.Descriptor instead. func (*GetRunResponse) Descriptor() ([]byte, []int) { - return file_agentcompose_v2_agentcompose_proto_rawDescGZIP(), []int{62} + return file_agentcompose_v2_agentcompose_proto_rawDescGZIP(), []int{65} } func (x *GetRunResponse) GetRun() *RunDetail { @@ -5880,7 +6092,7 @@ type ListRunsRequest struct { func (x *ListRunsRequest) Reset() { *x = ListRunsRequest{} - mi := &file_agentcompose_v2_agentcompose_proto_msgTypes[63] + mi := &file_agentcompose_v2_agentcompose_proto_msgTypes[66] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -5892,7 +6104,7 @@ func (x *ListRunsRequest) String() string { func (*ListRunsRequest) ProtoMessage() {} func (x *ListRunsRequest) ProtoReflect() protoreflect.Message { - mi := &file_agentcompose_v2_agentcompose_proto_msgTypes[63] + mi := &file_agentcompose_v2_agentcompose_proto_msgTypes[66] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -5905,7 +6117,7 @@ func (x *ListRunsRequest) ProtoReflect() protoreflect.Message { // Deprecated: Use ListRunsRequest.ProtoReflect.Descriptor instead. func (*ListRunsRequest) Descriptor() ([]byte, []int) { - return file_agentcompose_v2_agentcompose_proto_rawDescGZIP(), []int{63} + return file_agentcompose_v2_agentcompose_proto_rawDescGZIP(), []int{66} } func (x *ListRunsRequest) GetProjectId() string { @@ -5987,7 +6199,7 @@ type ListRunsResponse struct { func (x *ListRunsResponse) Reset() { *x = ListRunsResponse{} - mi := &file_agentcompose_v2_agentcompose_proto_msgTypes[64] + mi := &file_agentcompose_v2_agentcompose_proto_msgTypes[67] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -5999,7 +6211,7 @@ func (x *ListRunsResponse) String() string { func (*ListRunsResponse) ProtoMessage() {} func (x *ListRunsResponse) ProtoReflect() protoreflect.Message { - mi := &file_agentcompose_v2_agentcompose_proto_msgTypes[64] + mi := &file_agentcompose_v2_agentcompose_proto_msgTypes[67] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -6012,7 +6224,7 @@ func (x *ListRunsResponse) ProtoReflect() protoreflect.Message { // Deprecated: Use ListRunsResponse.ProtoReflect.Descriptor instead. func (*ListRunsResponse) Descriptor() ([]byte, []int) { - return file_agentcompose_v2_agentcompose_proto_rawDescGZIP(), []int{64} + return file_agentcompose_v2_agentcompose_proto_rawDescGZIP(), []int{67} } func (x *ListRunsResponse) GetRuns() []*RunSummary { @@ -6035,7 +6247,7 @@ type FollowRunLogsRequest struct { func (x *FollowRunLogsRequest) Reset() { *x = FollowRunLogsRequest{} - mi := &file_agentcompose_v2_agentcompose_proto_msgTypes[65] + mi := &file_agentcompose_v2_agentcompose_proto_msgTypes[68] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -6047,7 +6259,7 @@ func (x *FollowRunLogsRequest) String() string { func (*FollowRunLogsRequest) ProtoMessage() {} func (x *FollowRunLogsRequest) ProtoReflect() protoreflect.Message { - mi := &file_agentcompose_v2_agentcompose_proto_msgTypes[65] + mi := &file_agentcompose_v2_agentcompose_proto_msgTypes[68] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -6060,7 +6272,7 @@ func (x *FollowRunLogsRequest) ProtoReflect() protoreflect.Message { // Deprecated: Use FollowRunLogsRequest.ProtoReflect.Descriptor instead. func (*FollowRunLogsRequest) Descriptor() ([]byte, []int) { - return file_agentcompose_v2_agentcompose_proto_rawDescGZIP(), []int{65} + return file_agentcompose_v2_agentcompose_proto_rawDescGZIP(), []int{68} } func (x *FollowRunLogsRequest) GetProjectId() string { @@ -6111,7 +6323,7 @@ type RunLogChunk struct { func (x *RunLogChunk) Reset() { *x = RunLogChunk{} - mi := &file_agentcompose_v2_agentcompose_proto_msgTypes[66] + mi := &file_agentcompose_v2_agentcompose_proto_msgTypes[69] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -6123,7 +6335,7 @@ func (x *RunLogChunk) String() string { func (*RunLogChunk) ProtoMessage() {} func (x *RunLogChunk) ProtoReflect() protoreflect.Message { - mi := &file_agentcompose_v2_agentcompose_proto_msgTypes[66] + mi := &file_agentcompose_v2_agentcompose_proto_msgTypes[69] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -6136,7 +6348,7 @@ func (x *RunLogChunk) ProtoReflect() protoreflect.Message { // Deprecated: Use RunLogChunk.ProtoReflect.Descriptor instead. func (*RunLogChunk) Descriptor() ([]byte, []int) { - return file_agentcompose_v2_agentcompose_proto_rawDescGZIP(), []int{66} + return file_agentcompose_v2_agentcompose_proto_rawDescGZIP(), []int{69} } func (x *RunLogChunk) GetData() string { @@ -6184,7 +6396,7 @@ type StopRunRequest struct { func (x *StopRunRequest) Reset() { *x = StopRunRequest{} - mi := &file_agentcompose_v2_agentcompose_proto_msgTypes[67] + mi := &file_agentcompose_v2_agentcompose_proto_msgTypes[70] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -6196,7 +6408,7 @@ func (x *StopRunRequest) String() string { func (*StopRunRequest) ProtoMessage() {} func (x *StopRunRequest) ProtoReflect() protoreflect.Message { - mi := &file_agentcompose_v2_agentcompose_proto_msgTypes[67] + mi := &file_agentcompose_v2_agentcompose_proto_msgTypes[70] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -6209,7 +6421,7 @@ func (x *StopRunRequest) ProtoReflect() protoreflect.Message { // Deprecated: Use StopRunRequest.ProtoReflect.Descriptor instead. func (*StopRunRequest) Descriptor() ([]byte, []int) { - return file_agentcompose_v2_agentcompose_proto_rawDescGZIP(), []int{67} + return file_agentcompose_v2_agentcompose_proto_rawDescGZIP(), []int{70} } func (x *StopRunRequest) GetRunId() string { @@ -6236,7 +6448,7 @@ type StopRunResponse struct { func (x *StopRunResponse) Reset() { *x = StopRunResponse{} - mi := &file_agentcompose_v2_agentcompose_proto_msgTypes[68] + mi := &file_agentcompose_v2_agentcompose_proto_msgTypes[71] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -6248,7 +6460,7 @@ func (x *StopRunResponse) String() string { func (*StopRunResponse) ProtoMessage() {} func (x *StopRunResponse) ProtoReflect() protoreflect.Message { - mi := &file_agentcompose_v2_agentcompose_proto_msgTypes[68] + mi := &file_agentcompose_v2_agentcompose_proto_msgTypes[71] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -6261,7 +6473,7 @@ func (x *StopRunResponse) ProtoReflect() protoreflect.Message { // Deprecated: Use StopRunResponse.ProtoReflect.Descriptor instead. func (*StopRunResponse) Descriptor() ([]byte, []int) { - return file_agentcompose_v2_agentcompose_proto_rawDescGZIP(), []int{68} + return file_agentcompose_v2_agentcompose_proto_rawDescGZIP(), []int{71} } func (x *StopRunResponse) GetRun() *RunDetail { @@ -6289,7 +6501,7 @@ type ListRunEventsRequest struct { func (x *ListRunEventsRequest) Reset() { *x = ListRunEventsRequest{} - mi := &file_agentcompose_v2_agentcompose_proto_msgTypes[69] + mi := &file_agentcompose_v2_agentcompose_proto_msgTypes[72] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -6301,7 +6513,7 @@ func (x *ListRunEventsRequest) String() string { func (*ListRunEventsRequest) ProtoMessage() {} func (x *ListRunEventsRequest) ProtoReflect() protoreflect.Message { - mi := &file_agentcompose_v2_agentcompose_proto_msgTypes[69] + mi := &file_agentcompose_v2_agentcompose_proto_msgTypes[72] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -6314,7 +6526,7 @@ func (x *ListRunEventsRequest) ProtoReflect() protoreflect.Message { // Deprecated: Use ListRunEventsRequest.ProtoReflect.Descriptor instead. func (*ListRunEventsRequest) Descriptor() ([]byte, []int) { - return file_agentcompose_v2_agentcompose_proto_rawDescGZIP(), []int{69} + return file_agentcompose_v2_agentcompose_proto_rawDescGZIP(), []int{72} } func (x *ListRunEventsRequest) GetRunId() string { @@ -6358,7 +6570,7 @@ type RunEvent struct { func (x *RunEvent) Reset() { *x = RunEvent{} - mi := &file_agentcompose_v2_agentcompose_proto_msgTypes[70] + mi := &file_agentcompose_v2_agentcompose_proto_msgTypes[73] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -6370,7 +6582,7 @@ func (x *RunEvent) String() string { func (*RunEvent) ProtoMessage() {} func (x *RunEvent) ProtoReflect() protoreflect.Message { - mi := &file_agentcompose_v2_agentcompose_proto_msgTypes[70] + mi := &file_agentcompose_v2_agentcompose_proto_msgTypes[73] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -6383,7 +6595,7 @@ func (x *RunEvent) ProtoReflect() protoreflect.Message { // Deprecated: Use RunEvent.ProtoReflect.Descriptor instead. func (*RunEvent) Descriptor() ([]byte, []int) { - return file_agentcompose_v2_agentcompose_proto_rawDescGZIP(), []int{70} + return file_agentcompose_v2_agentcompose_proto_rawDescGZIP(), []int{73} } func (x *RunEvent) GetId() string { @@ -6481,7 +6693,7 @@ type ListRunEventsResponse struct { func (x *ListRunEventsResponse) Reset() { *x = ListRunEventsResponse{} - mi := &file_agentcompose_v2_agentcompose_proto_msgTypes[71] + mi := &file_agentcompose_v2_agentcompose_proto_msgTypes[74] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -6493,7 +6705,7 @@ func (x *ListRunEventsResponse) String() string { func (*ListRunEventsResponse) ProtoMessage() {} func (x *ListRunEventsResponse) ProtoReflect() protoreflect.Message { - mi := &file_agentcompose_v2_agentcompose_proto_msgTypes[71] + mi := &file_agentcompose_v2_agentcompose_proto_msgTypes[74] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -6506,7 +6718,7 @@ func (x *ListRunEventsResponse) ProtoReflect() protoreflect.Message { // Deprecated: Use ListRunEventsResponse.ProtoReflect.Descriptor instead. func (*ListRunEventsResponse) Descriptor() ([]byte, []int) { - return file_agentcompose_v2_agentcompose_proto_rawDescGZIP(), []int{71} + return file_agentcompose_v2_agentcompose_proto_rawDescGZIP(), []int{74} } func (x *ListRunEventsResponse) GetEvents() []*RunEvent { @@ -6541,7 +6753,7 @@ type ListSandboxRunEventsRequest struct { func (x *ListSandboxRunEventsRequest) Reset() { *x = ListSandboxRunEventsRequest{} - mi := &file_agentcompose_v2_agentcompose_proto_msgTypes[72] + mi := &file_agentcompose_v2_agentcompose_proto_msgTypes[75] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -6553,7 +6765,7 @@ func (x *ListSandboxRunEventsRequest) String() string { func (*ListSandboxRunEventsRequest) ProtoMessage() {} func (x *ListSandboxRunEventsRequest) ProtoReflect() protoreflect.Message { - mi := &file_agentcompose_v2_agentcompose_proto_msgTypes[72] + mi := &file_agentcompose_v2_agentcompose_proto_msgTypes[75] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -6566,7 +6778,7 @@ func (x *ListSandboxRunEventsRequest) ProtoReflect() protoreflect.Message { // Deprecated: Use ListSandboxRunEventsRequest.ProtoReflect.Descriptor instead. func (*ListSandboxRunEventsRequest) Descriptor() ([]byte, []int) { - return file_agentcompose_v2_agentcompose_proto_rawDescGZIP(), []int{72} + return file_agentcompose_v2_agentcompose_proto_rawDescGZIP(), []int{75} } func (x *ListSandboxRunEventsRequest) GetSandboxId() string { @@ -6601,7 +6813,7 @@ type ListSandboxRunEventsResponse struct { func (x *ListSandboxRunEventsResponse) Reset() { *x = ListSandboxRunEventsResponse{} - mi := &file_agentcompose_v2_agentcompose_proto_msgTypes[73] + mi := &file_agentcompose_v2_agentcompose_proto_msgTypes[76] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -6613,7 +6825,7 @@ func (x *ListSandboxRunEventsResponse) String() string { func (*ListSandboxRunEventsResponse) ProtoMessage() {} func (x *ListSandboxRunEventsResponse) ProtoReflect() protoreflect.Message { - mi := &file_agentcompose_v2_agentcompose_proto_msgTypes[73] + mi := &file_agentcompose_v2_agentcompose_proto_msgTypes[76] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -6626,7 +6838,7 @@ func (x *ListSandboxRunEventsResponse) ProtoReflect() protoreflect.Message { // Deprecated: Use ListSandboxRunEventsResponse.ProtoReflect.Descriptor instead. func (*ListSandboxRunEventsResponse) Descriptor() ([]byte, []int) { - return file_agentcompose_v2_agentcompose_proto_rawDescGZIP(), []int{73} + return file_agentcompose_v2_agentcompose_proto_rawDescGZIP(), []int{76} } func (x *ListSandboxRunEventsResponse) GetEvents() []*RunEvent { @@ -6660,7 +6872,7 @@ type RemoveSandboxRequest struct { func (x *RemoveSandboxRequest) Reset() { *x = RemoveSandboxRequest{} - mi := &file_agentcompose_v2_agentcompose_proto_msgTypes[74] + mi := &file_agentcompose_v2_agentcompose_proto_msgTypes[77] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -6672,7 +6884,7 @@ func (x *RemoveSandboxRequest) String() string { func (*RemoveSandboxRequest) ProtoMessage() {} func (x *RemoveSandboxRequest) ProtoReflect() protoreflect.Message { - mi := &file_agentcompose_v2_agentcompose_proto_msgTypes[74] + mi := &file_agentcompose_v2_agentcompose_proto_msgTypes[77] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -6685,7 +6897,7 @@ func (x *RemoveSandboxRequest) ProtoReflect() protoreflect.Message { // Deprecated: Use RemoveSandboxRequest.ProtoReflect.Descriptor instead. func (*RemoveSandboxRequest) Descriptor() ([]byte, []int) { - return file_agentcompose_v2_agentcompose_proto_rawDescGZIP(), []int{74} + return file_agentcompose_v2_agentcompose_proto_rawDescGZIP(), []int{77} } func (x *RemoveSandboxRequest) GetSandboxId() string { @@ -6713,7 +6925,7 @@ type RemoveSandboxResponse struct { func (x *RemoveSandboxResponse) Reset() { *x = RemoveSandboxResponse{} - mi := &file_agentcompose_v2_agentcompose_proto_msgTypes[75] + mi := &file_agentcompose_v2_agentcompose_proto_msgTypes[78] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -6725,7 +6937,7 @@ func (x *RemoveSandboxResponse) String() string { func (*RemoveSandboxResponse) ProtoMessage() {} func (x *RemoveSandboxResponse) ProtoReflect() protoreflect.Message { - mi := &file_agentcompose_v2_agentcompose_proto_msgTypes[75] + mi := &file_agentcompose_v2_agentcompose_proto_msgTypes[78] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -6738,7 +6950,7 @@ func (x *RemoveSandboxResponse) ProtoReflect() protoreflect.Message { // Deprecated: Use RemoveSandboxResponse.ProtoReflect.Descriptor instead. func (*RemoveSandboxResponse) Descriptor() ([]byte, []int) { - return file_agentcompose_v2_agentcompose_proto_rawDescGZIP(), []int{75} + return file_agentcompose_v2_agentcompose_proto_rawDescGZIP(), []int{78} } func (x *RemoveSandboxResponse) GetSandboxId() string { @@ -6771,7 +6983,7 @@ type GetSandboxStatsRequest struct { func (x *GetSandboxStatsRequest) Reset() { *x = GetSandboxStatsRequest{} - mi := &file_agentcompose_v2_agentcompose_proto_msgTypes[76] + mi := &file_agentcompose_v2_agentcompose_proto_msgTypes[79] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -6783,7 +6995,7 @@ func (x *GetSandboxStatsRequest) String() string { func (*GetSandboxStatsRequest) ProtoMessage() {} func (x *GetSandboxStatsRequest) ProtoReflect() protoreflect.Message { - mi := &file_agentcompose_v2_agentcompose_proto_msgTypes[76] + mi := &file_agentcompose_v2_agentcompose_proto_msgTypes[79] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -6796,7 +7008,7 @@ func (x *GetSandboxStatsRequest) ProtoReflect() protoreflect.Message { // Deprecated: Use GetSandboxStatsRequest.ProtoReflect.Descriptor instead. func (*GetSandboxStatsRequest) Descriptor() ([]byte, []int) { - return file_agentcompose_v2_agentcompose_proto_rawDescGZIP(), []int{76} + return file_agentcompose_v2_agentcompose_proto_rawDescGZIP(), []int{79} } func (x *GetSandboxStatsRequest) GetSandboxId() string { @@ -6815,7 +7027,7 @@ type GetSandboxStatsResponse struct { func (x *GetSandboxStatsResponse) Reset() { *x = GetSandboxStatsResponse{} - mi := &file_agentcompose_v2_agentcompose_proto_msgTypes[77] + mi := &file_agentcompose_v2_agentcompose_proto_msgTypes[80] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -6827,7 +7039,7 @@ func (x *GetSandboxStatsResponse) String() string { func (*GetSandboxStatsResponse) ProtoMessage() {} func (x *GetSandboxStatsResponse) ProtoReflect() protoreflect.Message { - mi := &file_agentcompose_v2_agentcompose_proto_msgTypes[77] + mi := &file_agentcompose_v2_agentcompose_proto_msgTypes[80] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -6840,7 +7052,7 @@ func (x *GetSandboxStatsResponse) ProtoReflect() protoreflect.Message { // Deprecated: Use GetSandboxStatsResponse.ProtoReflect.Descriptor instead. func (*GetSandboxStatsResponse) Descriptor() ([]byte, []int) { - return file_agentcompose_v2_agentcompose_proto_rawDescGZIP(), []int{77} + return file_agentcompose_v2_agentcompose_proto_rawDescGZIP(), []int{80} } func (x *GetSandboxStatsResponse) GetStats() *SandboxStats { @@ -6859,7 +7071,7 @@ type GetSandboxRequest struct { func (x *GetSandboxRequest) Reset() { *x = GetSandboxRequest{} - mi := &file_agentcompose_v2_agentcompose_proto_msgTypes[78] + mi := &file_agentcompose_v2_agentcompose_proto_msgTypes[81] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -6871,7 +7083,7 @@ func (x *GetSandboxRequest) String() string { func (*GetSandboxRequest) ProtoMessage() {} func (x *GetSandboxRequest) ProtoReflect() protoreflect.Message { - mi := &file_agentcompose_v2_agentcompose_proto_msgTypes[78] + mi := &file_agentcompose_v2_agentcompose_proto_msgTypes[81] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -6884,7 +7096,7 @@ func (x *GetSandboxRequest) ProtoReflect() protoreflect.Message { // Deprecated: Use GetSandboxRequest.ProtoReflect.Descriptor instead. func (*GetSandboxRequest) Descriptor() ([]byte, []int) { - return file_agentcompose_v2_agentcompose_proto_rawDescGZIP(), []int{78} + return file_agentcompose_v2_agentcompose_proto_rawDescGZIP(), []int{81} } func (x *GetSandboxRequest) GetSandboxId() string { @@ -6912,13 +7124,14 @@ type Sandbox struct { CellCount uint32 `protobuf:"varint,14,opt,name=cell_count,json=cellCount,proto3" json:"cell_count,omitempty"` EventCount uint32 `protobuf:"varint,15,opt,name=event_count,json=eventCount,proto3" json:"event_count,omitempty"` NotebookUrl string `protobuf:"bytes,16,opt,name=notebook_url,json=notebookUrl,proto3" json:"notebook_url,omitempty"` + Network *SandboxNetworkState `protobuf:"bytes,17,opt,name=network,proto3" json:"network,omitempty"` unknownFields protoimpl.UnknownFields sizeCache protoimpl.SizeCache } func (x *Sandbox) Reset() { *x = Sandbox{} - mi := &file_agentcompose_v2_agentcompose_proto_msgTypes[79] + mi := &file_agentcompose_v2_agentcompose_proto_msgTypes[82] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -6930,7 +7143,7 @@ func (x *Sandbox) String() string { func (*Sandbox) ProtoMessage() {} func (x *Sandbox) ProtoReflect() protoreflect.Message { - mi := &file_agentcompose_v2_agentcompose_proto_msgTypes[79] + mi := &file_agentcompose_v2_agentcompose_proto_msgTypes[82] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -6943,7 +7156,7 @@ func (x *Sandbox) ProtoReflect() protoreflect.Message { // Deprecated: Use Sandbox.ProtoReflect.Descriptor instead. func (*Sandbox) Descriptor() ([]byte, []int) { - return file_agentcompose_v2_agentcompose_proto_rawDescGZIP(), []int{79} + return file_agentcompose_v2_agentcompose_proto_rawDescGZIP(), []int{82} } func (x *Sandbox) GetSandboxId() string { @@ -6981,79 +7194,274 @@ func (x *Sandbox) GetAgentName() string { return "" } -func (x *Sandbox) GetCreatedAt() *timestamppb.Timestamp { - if x != nil { - return x.CreatedAt - } - return nil +func (x *Sandbox) GetCreatedAt() *timestamppb.Timestamp { + if x != nil { + return x.CreatedAt + } + return nil +} + +func (x *Sandbox) GetUpdatedAt() *timestamppb.Timestamp { + if x != nil { + return x.UpdatedAt + } + return nil +} + +func (x *Sandbox) GetImage() string { + if x != nil { + return x.Image + } + return "" +} + +func (x *Sandbox) GetWorkspacePath() string { + if x != nil { + return x.WorkspacePath + } + return "" +} + +func (x *Sandbox) GetTags() []*SandboxTag { + if x != nil { + return x.Tags + } + return nil +} + +func (x *Sandbox) GetTitle() string { + if x != nil { + return x.Title + } + return "" +} + +func (x *Sandbox) GetProxyPath() string { + if x != nil { + return x.ProxyPath + } + return "" +} + +func (x *Sandbox) GetTriggerSource() string { + if x != nil { + return x.TriggerSource + } + return "" +} + +func (x *Sandbox) GetCellCount() uint32 { + if x != nil { + return x.CellCount + } + return 0 +} + +func (x *Sandbox) GetEventCount() uint32 { + if x != nil { + return x.EventCount + } + return 0 +} + +func (x *Sandbox) GetNotebookUrl() string { + if x != nil { + return x.NotebookUrl + } + return "" +} + +func (x *Sandbox) GetNetwork() *SandboxNetworkState { + if x != nil { + return x.Network + } + return nil +} + +type SandboxNetworkState struct { + state protoimpl.MessageState `protogen:"open.v1"` + Attachments []*SandboxNetworkEndpoint `protobuf:"bytes,1,rep,name=attachments,proto3" json:"attachments,omitempty"` + Bindings []*SandboxPortBinding `protobuf:"bytes,2,rep,name=bindings,proto3" json:"bindings,omitempty"` + unknownFields protoimpl.UnknownFields + sizeCache protoimpl.SizeCache +} + +func (x *SandboxNetworkState) Reset() { + *x = SandboxNetworkState{} + mi := &file_agentcompose_v2_agentcompose_proto_msgTypes[83] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) +} + +func (x *SandboxNetworkState) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*SandboxNetworkState) ProtoMessage() {} + +func (x *SandboxNetworkState) ProtoReflect() protoreflect.Message { + mi := &file_agentcompose_v2_agentcompose_proto_msgTypes[83] + if x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use SandboxNetworkState.ProtoReflect.Descriptor instead. +func (*SandboxNetworkState) Descriptor() ([]byte, []int) { + return file_agentcompose_v2_agentcompose_proto_rawDescGZIP(), []int{83} +} + +func (x *SandboxNetworkState) GetAttachments() []*SandboxNetworkEndpoint { + if x != nil { + return x.Attachments + } + return nil +} + +func (x *SandboxNetworkState) GetBindings() []*SandboxPortBinding { + if x != nil { + return x.Bindings + } + return nil +} + +type SandboxNetworkEndpoint struct { + state protoimpl.MessageState `protogen:"open.v1"` + Name string `protobuf:"bytes,1,opt,name=name,proto3" json:"name,omitempty"` + unknownFields protoimpl.UnknownFields + sizeCache protoimpl.SizeCache +} + +func (x *SandboxNetworkEndpoint) Reset() { + *x = SandboxNetworkEndpoint{} + mi := &file_agentcompose_v2_agentcompose_proto_msgTypes[84] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) +} + +func (x *SandboxNetworkEndpoint) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*SandboxNetworkEndpoint) ProtoMessage() {} + +func (x *SandboxNetworkEndpoint) ProtoReflect() protoreflect.Message { + mi := &file_agentcompose_v2_agentcompose_proto_msgTypes[84] + if x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use SandboxNetworkEndpoint.ProtoReflect.Descriptor instead. +func (*SandboxNetworkEndpoint) Descriptor() ([]byte, []int) { + return file_agentcompose_v2_agentcompose_proto_rawDescGZIP(), []int{84} +} + +func (x *SandboxNetworkEndpoint) GetName() string { + if x != nil { + return x.Name + } + return "" +} + +type SandboxPortBinding struct { + state protoimpl.MessageState `protogen:"open.v1"` + Networks []string `protobuf:"bytes,1,rep,name=networks,proto3" json:"networks,omitempty"` + HostIp string `protobuf:"bytes,2,opt,name=host_ip,json=hostIp,proto3" json:"host_ip,omitempty"` + HostPort uint32 `protobuf:"varint,3,opt,name=host_port,json=hostPort,proto3" json:"host_port,omitempty"` + GuestPort uint32 `protobuf:"varint,4,opt,name=guest_port,json=guestPort,proto3" json:"guest_port,omitempty"` + Protocol string `protobuf:"bytes,5,opt,name=protocol,proto3" json:"protocol,omitempty"` + Visibility string `protobuf:"bytes,6,opt,name=visibility,proto3" json:"visibility,omitempty"` + Publisher string `protobuf:"bytes,7,opt,name=publisher,proto3" json:"publisher,omitempty"` + unknownFields protoimpl.UnknownFields + sizeCache protoimpl.SizeCache } -func (x *Sandbox) GetUpdatedAt() *timestamppb.Timestamp { - if x != nil { - return x.UpdatedAt - } - return nil +func (x *SandboxPortBinding) Reset() { + *x = SandboxPortBinding{} + mi := &file_agentcompose_v2_agentcompose_proto_msgTypes[85] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) } -func (x *Sandbox) GetImage() string { - if x != nil { - return x.Image - } - return "" +func (x *SandboxPortBinding) String() string { + return protoimpl.X.MessageStringOf(x) } -func (x *Sandbox) GetWorkspacePath() string { +func (*SandboxPortBinding) ProtoMessage() {} + +func (x *SandboxPortBinding) ProtoReflect() protoreflect.Message { + mi := &file_agentcompose_v2_agentcompose_proto_msgTypes[85] if x != nil { - return x.WorkspacePath + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms } - return "" + return mi.MessageOf(x) } -func (x *Sandbox) GetTags() []*SandboxTag { +// Deprecated: Use SandboxPortBinding.ProtoReflect.Descriptor instead. +func (*SandboxPortBinding) Descriptor() ([]byte, []int) { + return file_agentcompose_v2_agentcompose_proto_rawDescGZIP(), []int{85} +} + +func (x *SandboxPortBinding) GetNetworks() []string { if x != nil { - return x.Tags + return x.Networks } return nil } -func (x *Sandbox) GetTitle() string { +func (x *SandboxPortBinding) GetHostIp() string { if x != nil { - return x.Title + return x.HostIp } return "" } -func (x *Sandbox) GetProxyPath() string { +func (x *SandboxPortBinding) GetHostPort() uint32 { if x != nil { - return x.ProxyPath + return x.HostPort } - return "" + return 0 } -func (x *Sandbox) GetTriggerSource() string { +func (x *SandboxPortBinding) GetGuestPort() uint32 { if x != nil { - return x.TriggerSource + return x.GuestPort } - return "" + return 0 } -func (x *Sandbox) GetCellCount() uint32 { +func (x *SandboxPortBinding) GetProtocol() string { if x != nil { - return x.CellCount + return x.Protocol } - return 0 + return "" } -func (x *Sandbox) GetEventCount() uint32 { +func (x *SandboxPortBinding) GetVisibility() string { if x != nil { - return x.EventCount + return x.Visibility } - return 0 + return "" } -func (x *Sandbox) GetNotebookUrl() string { +func (x *SandboxPortBinding) GetPublisher() string { if x != nil { - return x.NotebookUrl + return x.Publisher } return "" } @@ -7068,7 +7476,7 @@ type SandboxTag struct { func (x *SandboxTag) Reset() { *x = SandboxTag{} - mi := &file_agentcompose_v2_agentcompose_proto_msgTypes[80] + mi := &file_agentcompose_v2_agentcompose_proto_msgTypes[86] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -7080,7 +7488,7 @@ func (x *SandboxTag) String() string { func (*SandboxTag) ProtoMessage() {} func (x *SandboxTag) ProtoReflect() protoreflect.Message { - mi := &file_agentcompose_v2_agentcompose_proto_msgTypes[80] + mi := &file_agentcompose_v2_agentcompose_proto_msgTypes[86] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -7093,7 +7501,7 @@ func (x *SandboxTag) ProtoReflect() protoreflect.Message { // Deprecated: Use SandboxTag.ProtoReflect.Descriptor instead. func (*SandboxTag) Descriptor() ([]byte, []int) { - return file_agentcompose_v2_agentcompose_proto_rawDescGZIP(), []int{80} + return file_agentcompose_v2_agentcompose_proto_rawDescGZIP(), []int{86} } func (x *SandboxTag) GetName() string { @@ -7120,7 +7528,7 @@ type ListSandboxesRequest struct { func (x *ListSandboxesRequest) Reset() { *x = ListSandboxesRequest{} - mi := &file_agentcompose_v2_agentcompose_proto_msgTypes[81] + mi := &file_agentcompose_v2_agentcompose_proto_msgTypes[87] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -7132,7 +7540,7 @@ func (x *ListSandboxesRequest) String() string { func (*ListSandboxesRequest) ProtoMessage() {} func (x *ListSandboxesRequest) ProtoReflect() protoreflect.Message { - mi := &file_agentcompose_v2_agentcompose_proto_msgTypes[81] + mi := &file_agentcompose_v2_agentcompose_proto_msgTypes[87] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -7145,7 +7553,7 @@ func (x *ListSandboxesRequest) ProtoReflect() protoreflect.Message { // Deprecated: Use ListSandboxesRequest.ProtoReflect.Descriptor instead. func (*ListSandboxesRequest) Descriptor() ([]byte, []int) { - return file_agentcompose_v2_agentcompose_proto_rawDescGZIP(), []int{81} + return file_agentcompose_v2_agentcompose_proto_rawDescGZIP(), []int{87} } func (x *ListSandboxesRequest) GetLimit() uint32 { @@ -7172,7 +7580,7 @@ type ListSandboxesResponse struct { func (x *ListSandboxesResponse) Reset() { *x = ListSandboxesResponse{} - mi := &file_agentcompose_v2_agentcompose_proto_msgTypes[82] + mi := &file_agentcompose_v2_agentcompose_proto_msgTypes[88] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -7184,7 +7592,7 @@ func (x *ListSandboxesResponse) String() string { func (*ListSandboxesResponse) ProtoMessage() {} func (x *ListSandboxesResponse) ProtoReflect() protoreflect.Message { - mi := &file_agentcompose_v2_agentcompose_proto_msgTypes[82] + mi := &file_agentcompose_v2_agentcompose_proto_msgTypes[88] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -7197,7 +7605,7 @@ func (x *ListSandboxesResponse) ProtoReflect() protoreflect.Message { // Deprecated: Use ListSandboxesResponse.ProtoReflect.Descriptor instead. func (*ListSandboxesResponse) Descriptor() ([]byte, []int) { - return file_agentcompose_v2_agentcompose_proto_rawDescGZIP(), []int{82} + return file_agentcompose_v2_agentcompose_proto_rawDescGZIP(), []int{88} } func (x *ListSandboxesResponse) GetSandboxes() []*Sandbox { @@ -7223,7 +7631,7 @@ type GetSandboxResponse struct { func (x *GetSandboxResponse) Reset() { *x = GetSandboxResponse{} - mi := &file_agentcompose_v2_agentcompose_proto_msgTypes[83] + mi := &file_agentcompose_v2_agentcompose_proto_msgTypes[89] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -7235,7 +7643,7 @@ func (x *GetSandboxResponse) String() string { func (*GetSandboxResponse) ProtoMessage() {} func (x *GetSandboxResponse) ProtoReflect() protoreflect.Message { - mi := &file_agentcompose_v2_agentcompose_proto_msgTypes[83] + mi := &file_agentcompose_v2_agentcompose_proto_msgTypes[89] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -7248,7 +7656,7 @@ func (x *GetSandboxResponse) ProtoReflect() protoreflect.Message { // Deprecated: Use GetSandboxResponse.ProtoReflect.Descriptor instead. func (*GetSandboxResponse) Descriptor() ([]byte, []int) { - return file_agentcompose_v2_agentcompose_proto_rawDescGZIP(), []int{83} + return file_agentcompose_v2_agentcompose_proto_rawDescGZIP(), []int{89} } func (x *GetSandboxResponse) GetSandbox() *Sandbox { @@ -7267,7 +7675,7 @@ type StopSandboxRequest struct { func (x *StopSandboxRequest) Reset() { *x = StopSandboxRequest{} - mi := &file_agentcompose_v2_agentcompose_proto_msgTypes[84] + mi := &file_agentcompose_v2_agentcompose_proto_msgTypes[90] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -7279,7 +7687,7 @@ func (x *StopSandboxRequest) String() string { func (*StopSandboxRequest) ProtoMessage() {} func (x *StopSandboxRequest) ProtoReflect() protoreflect.Message { - mi := &file_agentcompose_v2_agentcompose_proto_msgTypes[84] + mi := &file_agentcompose_v2_agentcompose_proto_msgTypes[90] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -7292,7 +7700,7 @@ func (x *StopSandboxRequest) ProtoReflect() protoreflect.Message { // Deprecated: Use StopSandboxRequest.ProtoReflect.Descriptor instead. func (*StopSandboxRequest) Descriptor() ([]byte, []int) { - return file_agentcompose_v2_agentcompose_proto_rawDescGZIP(), []int{84} + return file_agentcompose_v2_agentcompose_proto_rawDescGZIP(), []int{90} } func (x *StopSandboxRequest) GetSandboxId() string { @@ -7311,7 +7719,7 @@ type StopSandboxResponse struct { func (x *StopSandboxResponse) Reset() { *x = StopSandboxResponse{} - mi := &file_agentcompose_v2_agentcompose_proto_msgTypes[85] + mi := &file_agentcompose_v2_agentcompose_proto_msgTypes[91] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -7323,7 +7731,7 @@ func (x *StopSandboxResponse) String() string { func (*StopSandboxResponse) ProtoMessage() {} func (x *StopSandboxResponse) ProtoReflect() protoreflect.Message { - mi := &file_agentcompose_v2_agentcompose_proto_msgTypes[85] + mi := &file_agentcompose_v2_agentcompose_proto_msgTypes[91] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -7336,7 +7744,7 @@ func (x *StopSandboxResponse) ProtoReflect() protoreflect.Message { // Deprecated: Use StopSandboxResponse.ProtoReflect.Descriptor instead. func (*StopSandboxResponse) Descriptor() ([]byte, []int) { - return file_agentcompose_v2_agentcompose_proto_rawDescGZIP(), []int{85} + return file_agentcompose_v2_agentcompose_proto_rawDescGZIP(), []int{91} } func (x *StopSandboxResponse) GetSandbox() *Sandbox { @@ -7355,7 +7763,7 @@ type ResumeSandboxRequest struct { func (x *ResumeSandboxRequest) Reset() { *x = ResumeSandboxRequest{} - mi := &file_agentcompose_v2_agentcompose_proto_msgTypes[86] + mi := &file_agentcompose_v2_agentcompose_proto_msgTypes[92] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -7367,7 +7775,7 @@ func (x *ResumeSandboxRequest) String() string { func (*ResumeSandboxRequest) ProtoMessage() {} func (x *ResumeSandboxRequest) ProtoReflect() protoreflect.Message { - mi := &file_agentcompose_v2_agentcompose_proto_msgTypes[86] + mi := &file_agentcompose_v2_agentcompose_proto_msgTypes[92] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -7380,7 +7788,7 @@ func (x *ResumeSandboxRequest) ProtoReflect() protoreflect.Message { // Deprecated: Use ResumeSandboxRequest.ProtoReflect.Descriptor instead. func (*ResumeSandboxRequest) Descriptor() ([]byte, []int) { - return file_agentcompose_v2_agentcompose_proto_rawDescGZIP(), []int{86} + return file_agentcompose_v2_agentcompose_proto_rawDescGZIP(), []int{92} } func (x *ResumeSandboxRequest) GetSandboxId() string { @@ -7399,7 +7807,7 @@ type ResumeSandboxResponse struct { func (x *ResumeSandboxResponse) Reset() { *x = ResumeSandboxResponse{} - mi := &file_agentcompose_v2_agentcompose_proto_msgTypes[87] + mi := &file_agentcompose_v2_agentcompose_proto_msgTypes[93] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -7411,7 +7819,7 @@ func (x *ResumeSandboxResponse) String() string { func (*ResumeSandboxResponse) ProtoMessage() {} func (x *ResumeSandboxResponse) ProtoReflect() protoreflect.Message { - mi := &file_agentcompose_v2_agentcompose_proto_msgTypes[87] + mi := &file_agentcompose_v2_agentcompose_proto_msgTypes[93] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -7424,7 +7832,7 @@ func (x *ResumeSandboxResponse) ProtoReflect() protoreflect.Message { // Deprecated: Use ResumeSandboxResponse.ProtoReflect.Descriptor instead. func (*ResumeSandboxResponse) Descriptor() ([]byte, []int) { - return file_agentcompose_v2_agentcompose_proto_rawDescGZIP(), []int{87} + return file_agentcompose_v2_agentcompose_proto_rawDescGZIP(), []int{93} } func (x *ResumeSandboxResponse) GetSandbox() *Sandbox { @@ -7446,7 +7854,7 @@ type MetricValue struct { func (x *MetricValue) Reset() { *x = MetricValue{} - mi := &file_agentcompose_v2_agentcompose_proto_msgTypes[88] + mi := &file_agentcompose_v2_agentcompose_proto_msgTypes[94] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -7458,7 +7866,7 @@ func (x *MetricValue) String() string { func (*MetricValue) ProtoMessage() {} func (x *MetricValue) ProtoReflect() protoreflect.Message { - mi := &file_agentcompose_v2_agentcompose_proto_msgTypes[88] + mi := &file_agentcompose_v2_agentcompose_proto_msgTypes[94] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -7471,7 +7879,7 @@ func (x *MetricValue) ProtoReflect() protoreflect.Message { // Deprecated: Use MetricValue.ProtoReflect.Descriptor instead. func (*MetricValue) Descriptor() ([]byte, []int) { - return file_agentcompose_v2_agentcompose_proto_rawDescGZIP(), []int{88} + return file_agentcompose_v2_agentcompose_proto_rawDescGZIP(), []int{94} } func (x *MetricValue) GetValue() float64 { @@ -7522,7 +7930,7 @@ type SandboxStats struct { func (x *SandboxStats) Reset() { *x = SandboxStats{} - mi := &file_agentcompose_v2_agentcompose_proto_msgTypes[89] + mi := &file_agentcompose_v2_agentcompose_proto_msgTypes[95] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -7534,7 +7942,7 @@ func (x *SandboxStats) String() string { func (*SandboxStats) ProtoMessage() {} func (x *SandboxStats) ProtoReflect() protoreflect.Message { - mi := &file_agentcompose_v2_agentcompose_proto_msgTypes[89] + mi := &file_agentcompose_v2_agentcompose_proto_msgTypes[95] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -7547,7 +7955,7 @@ func (x *SandboxStats) ProtoReflect() protoreflect.Message { // Deprecated: Use SandboxStats.ProtoReflect.Descriptor instead. func (*SandboxStats) Descriptor() ([]byte, []int) { - return file_agentcompose_v2_agentcompose_proto_rawDescGZIP(), []int{89} + return file_agentcompose_v2_agentcompose_proto_rawDescGZIP(), []int{95} } func (x *SandboxStats) GetSandboxId() string { @@ -7663,7 +8071,7 @@ type RunSummary struct { func (x *RunSummary) Reset() { *x = RunSummary{} - mi := &file_agentcompose_v2_agentcompose_proto_msgTypes[90] + mi := &file_agentcompose_v2_agentcompose_proto_msgTypes[96] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -7675,7 +8083,7 @@ func (x *RunSummary) String() string { func (*RunSummary) ProtoMessage() {} func (x *RunSummary) ProtoReflect() protoreflect.Message { - mi := &file_agentcompose_v2_agentcompose_proto_msgTypes[90] + mi := &file_agentcompose_v2_agentcompose_proto_msgTypes[96] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -7688,7 +8096,7 @@ func (x *RunSummary) ProtoReflect() protoreflect.Message { // Deprecated: Use RunSummary.ProtoReflect.Descriptor instead. func (*RunSummary) Descriptor() ([]byte, []int) { - return file_agentcompose_v2_agentcompose_proto_rawDescGZIP(), []int{90} + return file_agentcompose_v2_agentcompose_proto_rawDescGZIP(), []int{96} } func (x *RunSummary) GetRunId() string { @@ -7856,7 +8264,7 @@ type RunDetail struct { func (x *RunDetail) Reset() { *x = RunDetail{} - mi := &file_agentcompose_v2_agentcompose_proto_msgTypes[91] + mi := &file_agentcompose_v2_agentcompose_proto_msgTypes[97] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -7868,7 +8276,7 @@ func (x *RunDetail) String() string { func (*RunDetail) ProtoMessage() {} func (x *RunDetail) ProtoReflect() protoreflect.Message { - mi := &file_agentcompose_v2_agentcompose_proto_msgTypes[91] + mi := &file_agentcompose_v2_agentcompose_proto_msgTypes[97] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -7881,7 +8289,7 @@ func (x *RunDetail) ProtoReflect() protoreflect.Message { // Deprecated: Use RunDetail.ProtoReflect.Descriptor instead. func (*RunDetail) Descriptor() ([]byte, []int) { - return file_agentcompose_v2_agentcompose_proto_rawDescGZIP(), []int{91} + return file_agentcompose_v2_agentcompose_proto_rawDescGZIP(), []int{97} } func (x *RunDetail) GetSummary() *RunSummary { @@ -7973,7 +8381,7 @@ type ExecRequest struct { func (x *ExecRequest) Reset() { *x = ExecRequest{} - mi := &file_agentcompose_v2_agentcompose_proto_msgTypes[92] + mi := &file_agentcompose_v2_agentcompose_proto_msgTypes[98] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -7985,7 +8393,7 @@ func (x *ExecRequest) String() string { func (*ExecRequest) ProtoMessage() {} func (x *ExecRequest) ProtoReflect() protoreflect.Message { - mi := &file_agentcompose_v2_agentcompose_proto_msgTypes[92] + mi := &file_agentcompose_v2_agentcompose_proto_msgTypes[98] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -7998,7 +8406,7 @@ func (x *ExecRequest) ProtoReflect() protoreflect.Message { // Deprecated: Use ExecRequest.ProtoReflect.Descriptor instead. func (*ExecRequest) Descriptor() ([]byte, []int) { - return file_agentcompose_v2_agentcompose_proto_rawDescGZIP(), []int{92} + return file_agentcompose_v2_agentcompose_proto_rawDescGZIP(), []int{98} } func (x *ExecRequest) GetTarget() isExecRequest_Target { @@ -8103,7 +8511,7 @@ type ExecSandboxSelector struct { func (x *ExecSandboxSelector) Reset() { *x = ExecSandboxSelector{} - mi := &file_agentcompose_v2_agentcompose_proto_msgTypes[93] + mi := &file_agentcompose_v2_agentcompose_proto_msgTypes[99] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -8115,7 +8523,7 @@ func (x *ExecSandboxSelector) String() string { func (*ExecSandboxSelector) ProtoMessage() {} func (x *ExecSandboxSelector) ProtoReflect() protoreflect.Message { - mi := &file_agentcompose_v2_agentcompose_proto_msgTypes[93] + mi := &file_agentcompose_v2_agentcompose_proto_msgTypes[99] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -8128,7 +8536,7 @@ func (x *ExecSandboxSelector) ProtoReflect() protoreflect.Message { // Deprecated: Use ExecSandboxSelector.ProtoReflect.Descriptor instead. func (*ExecSandboxSelector) Descriptor() ([]byte, []int) { - return file_agentcompose_v2_agentcompose_proto_rawDescGZIP(), []int{93} + return file_agentcompose_v2_agentcompose_proto_rawDescGZIP(), []int{99} } func (x *ExecSandboxSelector) GetProjectId() string { @@ -8162,7 +8570,7 @@ type ExecCommand struct { func (x *ExecCommand) Reset() { *x = ExecCommand{} - mi := &file_agentcompose_v2_agentcompose_proto_msgTypes[94] + mi := &file_agentcompose_v2_agentcompose_proto_msgTypes[100] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -8174,7 +8582,7 @@ func (x *ExecCommand) String() string { func (*ExecCommand) ProtoMessage() {} func (x *ExecCommand) ProtoReflect() protoreflect.Message { - mi := &file_agentcompose_v2_agentcompose_proto_msgTypes[94] + mi := &file_agentcompose_v2_agentcompose_proto_msgTypes[100] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -8187,7 +8595,7 @@ func (x *ExecCommand) ProtoReflect() protoreflect.Message { // Deprecated: Use ExecCommand.ProtoReflect.Descriptor instead. func (*ExecCommand) Descriptor() ([]byte, []int) { - return file_agentcompose_v2_agentcompose_proto_rawDescGZIP(), []int{94} + return file_agentcompose_v2_agentcompose_proto_rawDescGZIP(), []int{100} } func (x *ExecCommand) GetCommand() string { @@ -8213,7 +8621,7 @@ type ExecResponse struct { func (x *ExecResponse) Reset() { *x = ExecResponse{} - mi := &file_agentcompose_v2_agentcompose_proto_msgTypes[95] + mi := &file_agentcompose_v2_agentcompose_proto_msgTypes[101] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -8225,7 +8633,7 @@ func (x *ExecResponse) String() string { func (*ExecResponse) ProtoMessage() {} func (x *ExecResponse) ProtoReflect() protoreflect.Message { - mi := &file_agentcompose_v2_agentcompose_proto_msgTypes[95] + mi := &file_agentcompose_v2_agentcompose_proto_msgTypes[101] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -8238,7 +8646,7 @@ func (x *ExecResponse) ProtoReflect() protoreflect.Message { // Deprecated: Use ExecResponse.ProtoReflect.Descriptor instead. func (*ExecResponse) Descriptor() ([]byte, []int) { - return file_agentcompose_v2_agentcompose_proto_rawDescGZIP(), []int{95} + return file_agentcompose_v2_agentcompose_proto_rawDescGZIP(), []int{101} } func (x *ExecResponse) GetResult() *ExecResult { @@ -8264,7 +8672,7 @@ type ExecStreamResponse struct { func (x *ExecStreamResponse) Reset() { *x = ExecStreamResponse{} - mi := &file_agentcompose_v2_agentcompose_proto_msgTypes[96] + mi := &file_agentcompose_v2_agentcompose_proto_msgTypes[102] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -8276,7 +8684,7 @@ func (x *ExecStreamResponse) String() string { func (*ExecStreamResponse) ProtoMessage() {} func (x *ExecStreamResponse) ProtoReflect() protoreflect.Message { - mi := &file_agentcompose_v2_agentcompose_proto_msgTypes[96] + mi := &file_agentcompose_v2_agentcompose_proto_msgTypes[102] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -8289,7 +8697,7 @@ func (x *ExecStreamResponse) ProtoReflect() protoreflect.Message { // Deprecated: Use ExecStreamResponse.ProtoReflect.Descriptor instead. func (*ExecStreamResponse) Descriptor() ([]byte, []int) { - return file_agentcompose_v2_agentcompose_proto_rawDescGZIP(), []int{96} + return file_agentcompose_v2_agentcompose_proto_rawDescGZIP(), []int{102} } func (x *ExecStreamResponse) GetEventType() ExecStreamEventType { @@ -8367,7 +8775,7 @@ type ExecAttachRequest struct { func (x *ExecAttachRequest) Reset() { *x = ExecAttachRequest{} - mi := &file_agentcompose_v2_agentcompose_proto_msgTypes[97] + mi := &file_agentcompose_v2_agentcompose_proto_msgTypes[103] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -8379,7 +8787,7 @@ func (x *ExecAttachRequest) String() string { func (*ExecAttachRequest) ProtoMessage() {} func (x *ExecAttachRequest) ProtoReflect() protoreflect.Message { - mi := &file_agentcompose_v2_agentcompose_proto_msgTypes[97] + mi := &file_agentcompose_v2_agentcompose_proto_msgTypes[103] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -8392,7 +8800,7 @@ func (x *ExecAttachRequest) ProtoReflect() protoreflect.Message { // Deprecated: Use ExecAttachRequest.ProtoReflect.Descriptor instead. func (*ExecAttachRequest) Descriptor() ([]byte, []int) { - return file_agentcompose_v2_agentcompose_proto_rawDescGZIP(), []int{97} + return file_agentcompose_v2_agentcompose_proto_rawDescGZIP(), []int{103} } func (x *ExecAttachRequest) GetClientFrameId() string { @@ -8537,7 +8945,7 @@ type ExecAttachResponse struct { func (x *ExecAttachResponse) Reset() { *x = ExecAttachResponse{} - mi := &file_agentcompose_v2_agentcompose_proto_msgTypes[98] + mi := &file_agentcompose_v2_agentcompose_proto_msgTypes[104] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -8549,7 +8957,7 @@ func (x *ExecAttachResponse) String() string { func (*ExecAttachResponse) ProtoMessage() {} func (x *ExecAttachResponse) ProtoReflect() protoreflect.Message { - mi := &file_agentcompose_v2_agentcompose_proto_msgTypes[98] + mi := &file_agentcompose_v2_agentcompose_proto_msgTypes[104] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -8562,7 +8970,7 @@ func (x *ExecAttachResponse) ProtoReflect() protoreflect.Message { // Deprecated: Use ExecAttachResponse.ProtoReflect.Descriptor instead. func (*ExecAttachResponse) Descriptor() ([]byte, []int) { - return file_agentcompose_v2_agentcompose_proto_rawDescGZIP(), []int{98} + return file_agentcompose_v2_agentcompose_proto_rawDescGZIP(), []int{104} } func (x *ExecAttachResponse) GetServerFrameId() string { @@ -8694,7 +9102,7 @@ type ExecAttachStart struct { func (x *ExecAttachStart) Reset() { *x = ExecAttachStart{} - mi := &file_agentcompose_v2_agentcompose_proto_msgTypes[99] + mi := &file_agentcompose_v2_agentcompose_proto_msgTypes[105] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -8706,7 +9114,7 @@ func (x *ExecAttachStart) String() string { func (*ExecAttachStart) ProtoMessage() {} func (x *ExecAttachStart) ProtoReflect() protoreflect.Message { - mi := &file_agentcompose_v2_agentcompose_proto_msgTypes[99] + mi := &file_agentcompose_v2_agentcompose_proto_msgTypes[105] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -8719,7 +9127,7 @@ func (x *ExecAttachStart) ProtoReflect() protoreflect.Message { // Deprecated: Use ExecAttachStart.ProtoReflect.Descriptor instead. func (*ExecAttachStart) Descriptor() ([]byte, []int) { - return file_agentcompose_v2_agentcompose_proto_rawDescGZIP(), []int{99} + return file_agentcompose_v2_agentcompose_proto_rawDescGZIP(), []int{105} } func (x *ExecAttachStart) GetRequest() *ExecRequest { @@ -8774,7 +9182,7 @@ type AttachTerminalSize struct { func (x *AttachTerminalSize) Reset() { *x = AttachTerminalSize{} - mi := &file_agentcompose_v2_agentcompose_proto_msgTypes[100] + mi := &file_agentcompose_v2_agentcompose_proto_msgTypes[106] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -8786,7 +9194,7 @@ func (x *AttachTerminalSize) String() string { func (*AttachTerminalSize) ProtoMessage() {} func (x *AttachTerminalSize) ProtoReflect() protoreflect.Message { - mi := &file_agentcompose_v2_agentcompose_proto_msgTypes[100] + mi := &file_agentcompose_v2_agentcompose_proto_msgTypes[106] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -8799,7 +9207,7 @@ func (x *AttachTerminalSize) ProtoReflect() protoreflect.Message { // Deprecated: Use AttachTerminalSize.ProtoReflect.Descriptor instead. func (*AttachTerminalSize) Descriptor() ([]byte, []int) { - return file_agentcompose_v2_agentcompose_proto_rawDescGZIP(), []int{100} + return file_agentcompose_v2_agentcompose_proto_rawDescGZIP(), []int{106} } func (x *AttachTerminalSize) GetRows() uint32 { @@ -8825,7 +9233,7 @@ type AttachStdin struct { func (x *AttachStdin) Reset() { *x = AttachStdin{} - mi := &file_agentcompose_v2_agentcompose_proto_msgTypes[101] + mi := &file_agentcompose_v2_agentcompose_proto_msgTypes[107] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -8837,7 +9245,7 @@ func (x *AttachStdin) String() string { func (*AttachStdin) ProtoMessage() {} func (x *AttachStdin) ProtoReflect() protoreflect.Message { - mi := &file_agentcompose_v2_agentcompose_proto_msgTypes[101] + mi := &file_agentcompose_v2_agentcompose_proto_msgTypes[107] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -8850,7 +9258,7 @@ func (x *AttachStdin) ProtoReflect() protoreflect.Message { // Deprecated: Use AttachStdin.ProtoReflect.Descriptor instead. func (*AttachStdin) Descriptor() ([]byte, []int) { - return file_agentcompose_v2_agentcompose_proto_rawDescGZIP(), []int{101} + return file_agentcompose_v2_agentcompose_proto_rawDescGZIP(), []int{107} } func (x *AttachStdin) GetData() []byte { @@ -8868,7 +9276,7 @@ type AttachStdinEOF struct { func (x *AttachStdinEOF) Reset() { *x = AttachStdinEOF{} - mi := &file_agentcompose_v2_agentcompose_proto_msgTypes[102] + mi := &file_agentcompose_v2_agentcompose_proto_msgTypes[108] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -8880,7 +9288,7 @@ func (x *AttachStdinEOF) String() string { func (*AttachStdinEOF) ProtoMessage() {} func (x *AttachStdinEOF) ProtoReflect() protoreflect.Message { - mi := &file_agentcompose_v2_agentcompose_proto_msgTypes[102] + mi := &file_agentcompose_v2_agentcompose_proto_msgTypes[108] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -8893,7 +9301,7 @@ func (x *AttachStdinEOF) ProtoReflect() protoreflect.Message { // Deprecated: Use AttachStdinEOF.ProtoReflect.Descriptor instead. func (*AttachStdinEOF) Descriptor() ([]byte, []int) { - return file_agentcompose_v2_agentcompose_proto_rawDescGZIP(), []int{102} + return file_agentcompose_v2_agentcompose_proto_rawDescGZIP(), []int{108} } type AttachResize struct { @@ -8905,7 +9313,7 @@ type AttachResize struct { func (x *AttachResize) Reset() { *x = AttachResize{} - mi := &file_agentcompose_v2_agentcompose_proto_msgTypes[103] + mi := &file_agentcompose_v2_agentcompose_proto_msgTypes[109] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -8917,7 +9325,7 @@ func (x *AttachResize) String() string { func (*AttachResize) ProtoMessage() {} func (x *AttachResize) ProtoReflect() protoreflect.Message { - mi := &file_agentcompose_v2_agentcompose_proto_msgTypes[103] + mi := &file_agentcompose_v2_agentcompose_proto_msgTypes[109] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -8930,7 +9338,7 @@ func (x *AttachResize) ProtoReflect() protoreflect.Message { // Deprecated: Use AttachResize.ProtoReflect.Descriptor instead. func (*AttachResize) Descriptor() ([]byte, []int) { - return file_agentcompose_v2_agentcompose_proto_rawDescGZIP(), []int{103} + return file_agentcompose_v2_agentcompose_proto_rawDescGZIP(), []int{109} } func (x *AttachResize) GetTerminalSize() *AttachTerminalSize { @@ -8949,7 +9357,7 @@ type AttachSignal struct { func (x *AttachSignal) Reset() { *x = AttachSignal{} - mi := &file_agentcompose_v2_agentcompose_proto_msgTypes[104] + mi := &file_agentcompose_v2_agentcompose_proto_msgTypes[110] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -8961,7 +9369,7 @@ func (x *AttachSignal) String() string { func (*AttachSignal) ProtoMessage() {} func (x *AttachSignal) ProtoReflect() protoreflect.Message { - mi := &file_agentcompose_v2_agentcompose_proto_msgTypes[104] + mi := &file_agentcompose_v2_agentcompose_proto_msgTypes[110] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -8974,7 +9382,7 @@ func (x *AttachSignal) ProtoReflect() protoreflect.Message { // Deprecated: Use AttachSignal.ProtoReflect.Descriptor instead. func (*AttachSignal) Descriptor() ([]byte, []int) { - return file_agentcompose_v2_agentcompose_proto_rawDescGZIP(), []int{104} + return file_agentcompose_v2_agentcompose_proto_rawDescGZIP(), []int{110} } func (x *AttachSignal) GetSignal() string { @@ -8994,7 +9402,7 @@ type AttachHumanMessage struct { func (x *AttachHumanMessage) Reset() { *x = AttachHumanMessage{} - mi := &file_agentcompose_v2_agentcompose_proto_msgTypes[105] + mi := &file_agentcompose_v2_agentcompose_proto_msgTypes[111] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -9006,7 +9414,7 @@ func (x *AttachHumanMessage) String() string { func (*AttachHumanMessage) ProtoMessage() {} func (x *AttachHumanMessage) ProtoReflect() protoreflect.Message { - mi := &file_agentcompose_v2_agentcompose_proto_msgTypes[105] + mi := &file_agentcompose_v2_agentcompose_proto_msgTypes[111] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -9019,7 +9427,7 @@ func (x *AttachHumanMessage) ProtoReflect() protoreflect.Message { // Deprecated: Use AttachHumanMessage.ProtoReflect.Descriptor instead. func (*AttachHumanMessage) Descriptor() ([]byte, []int) { - return file_agentcompose_v2_agentcompose_proto_rawDescGZIP(), []int{105} + return file_agentcompose_v2_agentcompose_proto_rawDescGZIP(), []int{111} } func (x *AttachHumanMessage) GetText() string { @@ -9045,7 +9453,7 @@ type AttachCancel struct { func (x *AttachCancel) Reset() { *x = AttachCancel{} - mi := &file_agentcompose_v2_agentcompose_proto_msgTypes[106] + mi := &file_agentcompose_v2_agentcompose_proto_msgTypes[112] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -9057,7 +9465,7 @@ func (x *AttachCancel) String() string { func (*AttachCancel) ProtoMessage() {} func (x *AttachCancel) ProtoReflect() protoreflect.Message { - mi := &file_agentcompose_v2_agentcompose_proto_msgTypes[106] + mi := &file_agentcompose_v2_agentcompose_proto_msgTypes[112] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -9070,7 +9478,7 @@ func (x *AttachCancel) ProtoReflect() protoreflect.Message { // Deprecated: Use AttachCancel.ProtoReflect.Descriptor instead. func (*AttachCancel) Descriptor() ([]byte, []int) { - return file_agentcompose_v2_agentcompose_proto_rawDescGZIP(), []int{106} + return file_agentcompose_v2_agentcompose_proto_rawDescGZIP(), []int{112} } func (x *AttachCancel) GetReason() string { @@ -9094,7 +9502,7 @@ type AttachStarted struct { func (x *AttachStarted) Reset() { *x = AttachStarted{} - mi := &file_agentcompose_v2_agentcompose_proto_msgTypes[107] + mi := &file_agentcompose_v2_agentcompose_proto_msgTypes[113] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -9106,7 +9514,7 @@ func (x *AttachStarted) String() string { func (*AttachStarted) ProtoMessage() {} func (x *AttachStarted) ProtoReflect() protoreflect.Message { - mi := &file_agentcompose_v2_agentcompose_proto_msgTypes[107] + mi := &file_agentcompose_v2_agentcompose_proto_msgTypes[113] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -9119,7 +9527,7 @@ func (x *AttachStarted) ProtoReflect() protoreflect.Message { // Deprecated: Use AttachStarted.ProtoReflect.Descriptor instead. func (*AttachStarted) Descriptor() ([]byte, []int) { - return file_agentcompose_v2_agentcompose_proto_rawDescGZIP(), []int{107} + return file_agentcompose_v2_agentcompose_proto_rawDescGZIP(), []int{113} } func (x *AttachStarted) GetOperationId() string { @@ -9176,7 +9584,7 @@ type AttachOutput struct { func (x *AttachOutput) Reset() { *x = AttachOutput{} - mi := &file_agentcompose_v2_agentcompose_proto_msgTypes[108] + mi := &file_agentcompose_v2_agentcompose_proto_msgTypes[114] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -9188,7 +9596,7 @@ func (x *AttachOutput) String() string { func (*AttachOutput) ProtoMessage() {} func (x *AttachOutput) ProtoReflect() protoreflect.Message { - mi := &file_agentcompose_v2_agentcompose_proto_msgTypes[108] + mi := &file_agentcompose_v2_agentcompose_proto_msgTypes[114] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -9201,7 +9609,7 @@ func (x *AttachOutput) ProtoReflect() protoreflect.Message { // Deprecated: Use AttachOutput.ProtoReflect.Descriptor instead. func (*AttachOutput) Descriptor() ([]byte, []int) { - return file_agentcompose_v2_agentcompose_proto_rawDescGZIP(), []int{108} + return file_agentcompose_v2_agentcompose_proto_rawDescGZIP(), []int{114} } func (x *AttachOutput) GetData() []byte { @@ -9244,7 +9652,7 @@ type AttachAgentEvent struct { func (x *AttachAgentEvent) Reset() { *x = AttachAgentEvent{} - mi := &file_agentcompose_v2_agentcompose_proto_msgTypes[109] + mi := &file_agentcompose_v2_agentcompose_proto_msgTypes[115] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -9256,7 +9664,7 @@ func (x *AttachAgentEvent) String() string { func (*AttachAgentEvent) ProtoMessage() {} func (x *AttachAgentEvent) ProtoReflect() protoreflect.Message { - mi := &file_agentcompose_v2_agentcompose_proto_msgTypes[109] + mi := &file_agentcompose_v2_agentcompose_proto_msgTypes[115] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -9269,7 +9677,7 @@ func (x *AttachAgentEvent) ProtoReflect() protoreflect.Message { // Deprecated: Use AttachAgentEvent.ProtoReflect.Descriptor instead. func (*AttachAgentEvent) Descriptor() ([]byte, []int) { - return file_agentcompose_v2_agentcompose_proto_rawDescGZIP(), []int{109} + return file_agentcompose_v2_agentcompose_proto_rawDescGZIP(), []int{115} } func (x *AttachAgentEvent) GetName() string { @@ -9311,7 +9719,7 @@ type AttachAgentTurnCompleted struct { func (x *AttachAgentTurnCompleted) Reset() { *x = AttachAgentTurnCompleted{} - mi := &file_agentcompose_v2_agentcompose_proto_msgTypes[110] + mi := &file_agentcompose_v2_agentcompose_proto_msgTypes[116] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -9323,7 +9731,7 @@ func (x *AttachAgentTurnCompleted) String() string { func (*AttachAgentTurnCompleted) ProtoMessage() {} func (x *AttachAgentTurnCompleted) ProtoReflect() protoreflect.Message { - mi := &file_agentcompose_v2_agentcompose_proto_msgTypes[110] + mi := &file_agentcompose_v2_agentcompose_proto_msgTypes[116] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -9336,7 +9744,7 @@ func (x *AttachAgentTurnCompleted) ProtoReflect() protoreflect.Message { // Deprecated: Use AttachAgentTurnCompleted.ProtoReflect.Descriptor instead. func (*AttachAgentTurnCompleted) Descriptor() ([]byte, []int) { - return file_agentcompose_v2_agentcompose_proto_rawDescGZIP(), []int{110} + return file_agentcompose_v2_agentcompose_proto_rawDescGZIP(), []int{116} } func (x *AttachAgentTurnCompleted) GetRunId() string { @@ -9375,7 +9783,7 @@ type AttachResult struct { func (x *AttachResult) Reset() { *x = AttachResult{} - mi := &file_agentcompose_v2_agentcompose_proto_msgTypes[111] + mi := &file_agentcompose_v2_agentcompose_proto_msgTypes[117] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -9387,7 +9795,7 @@ func (x *AttachResult) String() string { func (*AttachResult) ProtoMessage() {} func (x *AttachResult) ProtoReflect() protoreflect.Message { - mi := &file_agentcompose_v2_agentcompose_proto_msgTypes[111] + mi := &file_agentcompose_v2_agentcompose_proto_msgTypes[117] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -9400,7 +9808,7 @@ func (x *AttachResult) ProtoReflect() protoreflect.Message { // Deprecated: Use AttachResult.ProtoReflect.Descriptor instead. func (*AttachResult) Descriptor() ([]byte, []int) { - return file_agentcompose_v2_agentcompose_proto_rawDescGZIP(), []int{111} + return file_agentcompose_v2_agentcompose_proto_rawDescGZIP(), []int{117} } func (x *AttachResult) GetExitCode() int32 { @@ -9464,7 +9872,7 @@ type AttachError struct { func (x *AttachError) Reset() { *x = AttachError{} - mi := &file_agentcompose_v2_agentcompose_proto_msgTypes[112] + mi := &file_agentcompose_v2_agentcompose_proto_msgTypes[118] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -9476,7 +9884,7 @@ func (x *AttachError) String() string { func (*AttachError) ProtoMessage() {} func (x *AttachError) ProtoReflect() protoreflect.Message { - mi := &file_agentcompose_v2_agentcompose_proto_msgTypes[112] + mi := &file_agentcompose_v2_agentcompose_proto_msgTypes[118] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -9489,7 +9897,7 @@ func (x *AttachError) ProtoReflect() protoreflect.Message { // Deprecated: Use AttachError.ProtoReflect.Descriptor instead. func (*AttachError) Descriptor() ([]byte, []int) { - return file_agentcompose_v2_agentcompose_proto_rawDescGZIP(), []int{112} + return file_agentcompose_v2_agentcompose_proto_rawDescGZIP(), []int{118} } func (x *AttachError) GetCode() string { @@ -9542,7 +9950,7 @@ type ExecResult struct { func (x *ExecResult) Reset() { *x = ExecResult{} - mi := &file_agentcompose_v2_agentcompose_proto_msgTypes[113] + mi := &file_agentcompose_v2_agentcompose_proto_msgTypes[119] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -9554,7 +9962,7 @@ func (x *ExecResult) String() string { func (*ExecResult) ProtoMessage() {} func (x *ExecResult) ProtoReflect() protoreflect.Message { - mi := &file_agentcompose_v2_agentcompose_proto_msgTypes[113] + mi := &file_agentcompose_v2_agentcompose_proto_msgTypes[119] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -9567,7 +9975,7 @@ func (x *ExecResult) ProtoReflect() protoreflect.Message { // Deprecated: Use ExecResult.ProtoReflect.Descriptor instead. func (*ExecResult) Descriptor() ([]byte, []int) { - return file_agentcompose_v2_agentcompose_proto_rawDescGZIP(), []int{113} + return file_agentcompose_v2_agentcompose_proto_rawDescGZIP(), []int{119} } func (x *ExecResult) GetExecId() string { @@ -9682,7 +10090,7 @@ type ListImagesRequest struct { func (x *ListImagesRequest) Reset() { *x = ListImagesRequest{} - mi := &file_agentcompose_v2_agentcompose_proto_msgTypes[114] + mi := &file_agentcompose_v2_agentcompose_proto_msgTypes[120] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -9694,7 +10102,7 @@ func (x *ListImagesRequest) String() string { func (*ListImagesRequest) ProtoMessage() {} func (x *ListImagesRequest) ProtoReflect() protoreflect.Message { - mi := &file_agentcompose_v2_agentcompose_proto_msgTypes[114] + mi := &file_agentcompose_v2_agentcompose_proto_msgTypes[120] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -9707,7 +10115,7 @@ func (x *ListImagesRequest) ProtoReflect() protoreflect.Message { // Deprecated: Use ListImagesRequest.ProtoReflect.Descriptor instead. func (*ListImagesRequest) Descriptor() ([]byte, []int) { - return file_agentcompose_v2_agentcompose_proto_rawDescGZIP(), []int{114} + return file_agentcompose_v2_agentcompose_proto_rawDescGZIP(), []int{120} } func (x *ListImagesRequest) GetStore() ImageStoreKind { @@ -9765,7 +10173,7 @@ type ListImagesResponse struct { func (x *ListImagesResponse) Reset() { *x = ListImagesResponse{} - mi := &file_agentcompose_v2_agentcompose_proto_msgTypes[115] + mi := &file_agentcompose_v2_agentcompose_proto_msgTypes[121] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -9777,7 +10185,7 @@ func (x *ListImagesResponse) String() string { func (*ListImagesResponse) ProtoMessage() {} func (x *ListImagesResponse) ProtoReflect() protoreflect.Message { - mi := &file_agentcompose_v2_agentcompose_proto_msgTypes[115] + mi := &file_agentcompose_v2_agentcompose_proto_msgTypes[121] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -9790,7 +10198,7 @@ func (x *ListImagesResponse) ProtoReflect() protoreflect.Message { // Deprecated: Use ListImagesResponse.ProtoReflect.Descriptor instead. func (*ListImagesResponse) Descriptor() ([]byte, []int) { - return file_agentcompose_v2_agentcompose_proto_rawDescGZIP(), []int{115} + return file_agentcompose_v2_agentcompose_proto_rawDescGZIP(), []int{121} } func (x *ListImagesResponse) GetImages() []*Image { @@ -9839,7 +10247,7 @@ type PullImageRequest struct { func (x *PullImageRequest) Reset() { *x = PullImageRequest{} - mi := &file_agentcompose_v2_agentcompose_proto_msgTypes[116] + mi := &file_agentcompose_v2_agentcompose_proto_msgTypes[122] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -9851,7 +10259,7 @@ func (x *PullImageRequest) String() string { func (*PullImageRequest) ProtoMessage() {} func (x *PullImageRequest) ProtoReflect() protoreflect.Message { - mi := &file_agentcompose_v2_agentcompose_proto_msgTypes[116] + mi := &file_agentcompose_v2_agentcompose_proto_msgTypes[122] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -9864,7 +10272,7 @@ func (x *PullImageRequest) ProtoReflect() protoreflect.Message { // Deprecated: Use PullImageRequest.ProtoReflect.Descriptor instead. func (*PullImageRequest) Descriptor() ([]byte, []int) { - return file_agentcompose_v2_agentcompose_proto_rawDescGZIP(), []int{116} + return file_agentcompose_v2_agentcompose_proto_rawDescGZIP(), []int{122} } func (x *PullImageRequest) GetImageRef() string { @@ -9901,7 +10309,7 @@ type PullImageResponse struct { func (x *PullImageResponse) Reset() { *x = PullImageResponse{} - mi := &file_agentcompose_v2_agentcompose_proto_msgTypes[117] + mi := &file_agentcompose_v2_agentcompose_proto_msgTypes[123] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -9913,7 +10321,7 @@ func (x *PullImageResponse) String() string { func (*PullImageResponse) ProtoMessage() {} func (x *PullImageResponse) ProtoReflect() protoreflect.Message { - mi := &file_agentcompose_v2_agentcompose_proto_msgTypes[117] + mi := &file_agentcompose_v2_agentcompose_proto_msgTypes[123] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -9926,7 +10334,7 @@ func (x *PullImageResponse) ProtoReflect() protoreflect.Message { // Deprecated: Use PullImageResponse.ProtoReflect.Descriptor instead. func (*PullImageResponse) Descriptor() ([]byte, []int) { - return file_agentcompose_v2_agentcompose_proto_rawDescGZIP(), []int{117} + return file_agentcompose_v2_agentcompose_proto_rawDescGZIP(), []int{123} } func (x *PullImageResponse) GetImage() *Image { @@ -9975,7 +10383,7 @@ type InspectImageRequest struct { func (x *InspectImageRequest) Reset() { *x = InspectImageRequest{} - mi := &file_agentcompose_v2_agentcompose_proto_msgTypes[118] + mi := &file_agentcompose_v2_agentcompose_proto_msgTypes[124] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -9987,7 +10395,7 @@ func (x *InspectImageRequest) String() string { func (*InspectImageRequest) ProtoMessage() {} func (x *InspectImageRequest) ProtoReflect() protoreflect.Message { - mi := &file_agentcompose_v2_agentcompose_proto_msgTypes[118] + mi := &file_agentcompose_v2_agentcompose_proto_msgTypes[124] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -10000,7 +10408,7 @@ func (x *InspectImageRequest) ProtoReflect() protoreflect.Message { // Deprecated: Use InspectImageRequest.ProtoReflect.Descriptor instead. func (*InspectImageRequest) Descriptor() ([]byte, []int) { - return file_agentcompose_v2_agentcompose_proto_rawDescGZIP(), []int{118} + return file_agentcompose_v2_agentcompose_proto_rawDescGZIP(), []int{124} } func (x *InspectImageRequest) GetImageRef() string { @@ -10034,7 +10442,7 @@ type InspectImageResponse struct { func (x *InspectImageResponse) Reset() { *x = InspectImageResponse{} - mi := &file_agentcompose_v2_agentcompose_proto_msgTypes[119] + mi := &file_agentcompose_v2_agentcompose_proto_msgTypes[125] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -10046,7 +10454,7 @@ func (x *InspectImageResponse) String() string { func (*InspectImageResponse) ProtoMessage() {} func (x *InspectImageResponse) ProtoReflect() protoreflect.Message { - mi := &file_agentcompose_v2_agentcompose_proto_msgTypes[119] + mi := &file_agentcompose_v2_agentcompose_proto_msgTypes[125] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -10059,7 +10467,7 @@ func (x *InspectImageResponse) ProtoReflect() protoreflect.Message { // Deprecated: Use InspectImageResponse.ProtoReflect.Descriptor instead. func (*InspectImageResponse) Descriptor() ([]byte, []int) { - return file_agentcompose_v2_agentcompose_proto_rawDescGZIP(), []int{119} + return file_agentcompose_v2_agentcompose_proto_rawDescGZIP(), []int{125} } func (x *InspectImageResponse) GetImage() *Image { @@ -10088,7 +10496,7 @@ type RemoveImageRequest struct { func (x *RemoveImageRequest) Reset() { *x = RemoveImageRequest{} - mi := &file_agentcompose_v2_agentcompose_proto_msgTypes[120] + mi := &file_agentcompose_v2_agentcompose_proto_msgTypes[126] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -10100,7 +10508,7 @@ func (x *RemoveImageRequest) String() string { func (*RemoveImageRequest) ProtoMessage() {} func (x *RemoveImageRequest) ProtoReflect() protoreflect.Message { - mi := &file_agentcompose_v2_agentcompose_proto_msgTypes[120] + mi := &file_agentcompose_v2_agentcompose_proto_msgTypes[126] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -10113,7 +10521,7 @@ func (x *RemoveImageRequest) ProtoReflect() protoreflect.Message { // Deprecated: Use RemoveImageRequest.ProtoReflect.Descriptor instead. func (*RemoveImageRequest) Descriptor() ([]byte, []int) { - return file_agentcompose_v2_agentcompose_proto_rawDescGZIP(), []int{120} + return file_agentcompose_v2_agentcompose_proto_rawDescGZIP(), []int{126} } func (x *RemoveImageRequest) GetImageRef() string { @@ -10156,7 +10564,7 @@ type RemoveImageResponse struct { func (x *RemoveImageResponse) Reset() { *x = RemoveImageResponse{} - mi := &file_agentcompose_v2_agentcompose_proto_msgTypes[121] + mi := &file_agentcompose_v2_agentcompose_proto_msgTypes[127] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -10168,7 +10576,7 @@ func (x *RemoveImageResponse) String() string { func (*RemoveImageResponse) ProtoMessage() {} func (x *RemoveImageResponse) ProtoReflect() protoreflect.Message { - mi := &file_agentcompose_v2_agentcompose_proto_msgTypes[121] + mi := &file_agentcompose_v2_agentcompose_proto_msgTypes[127] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -10181,7 +10589,7 @@ func (x *RemoveImageResponse) ProtoReflect() protoreflect.Message { // Deprecated: Use RemoveImageResponse.ProtoReflect.Descriptor instead. func (*RemoveImageResponse) Descriptor() ([]byte, []int) { - return file_agentcompose_v2_agentcompose_proto_rawDescGZIP(), []int{121} + return file_agentcompose_v2_agentcompose_proto_rawDescGZIP(), []int{127} } func (x *RemoveImageResponse) GetImageRef() string { @@ -10229,7 +10637,7 @@ type BuildImageRequest struct { func (x *BuildImageRequest) Reset() { *x = BuildImageRequest{} - mi := &file_agentcompose_v2_agentcompose_proto_msgTypes[122] + mi := &file_agentcompose_v2_agentcompose_proto_msgTypes[128] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -10241,7 +10649,7 @@ func (x *BuildImageRequest) String() string { func (*BuildImageRequest) ProtoMessage() {} func (x *BuildImageRequest) ProtoReflect() protoreflect.Message { - mi := &file_agentcompose_v2_agentcompose_proto_msgTypes[122] + mi := &file_agentcompose_v2_agentcompose_proto_msgTypes[128] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -10254,7 +10662,7 @@ func (x *BuildImageRequest) ProtoReflect() protoreflect.Message { // Deprecated: Use BuildImageRequest.ProtoReflect.Descriptor instead. func (*BuildImageRequest) Descriptor() ([]byte, []int) { - return file_agentcompose_v2_agentcompose_proto_rawDescGZIP(), []int{122} + return file_agentcompose_v2_agentcompose_proto_rawDescGZIP(), []int{128} } func (x *BuildImageRequest) GetContextDir() string { @@ -10335,7 +10743,7 @@ type BuildImageEvent struct { func (x *BuildImageEvent) Reset() { *x = BuildImageEvent{} - mi := &file_agentcompose_v2_agentcompose_proto_msgTypes[123] + mi := &file_agentcompose_v2_agentcompose_proto_msgTypes[129] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -10347,7 +10755,7 @@ func (x *BuildImageEvent) String() string { func (*BuildImageEvent) ProtoMessage() {} func (x *BuildImageEvent) ProtoReflect() protoreflect.Message { - mi := &file_agentcompose_v2_agentcompose_proto_msgTypes[123] + mi := &file_agentcompose_v2_agentcompose_proto_msgTypes[129] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -10360,7 +10768,7 @@ func (x *BuildImageEvent) ProtoReflect() protoreflect.Message { // Deprecated: Use BuildImageEvent.ProtoReflect.Descriptor instead. func (*BuildImageEvent) Descriptor() ([]byte, []int) { - return file_agentcompose_v2_agentcompose_proto_rawDescGZIP(), []int{123} + return file_agentcompose_v2_agentcompose_proto_rawDescGZIP(), []int{129} } func (x *BuildImageEvent) GetStatus() ImageOperationStatus { @@ -10426,7 +10834,7 @@ type CacheFilter struct { func (x *CacheFilter) Reset() { *x = CacheFilter{} - mi := &file_agentcompose_v2_agentcompose_proto_msgTypes[124] + mi := &file_agentcompose_v2_agentcompose_proto_msgTypes[130] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -10438,7 +10846,7 @@ func (x *CacheFilter) String() string { func (*CacheFilter) ProtoMessage() {} func (x *CacheFilter) ProtoReflect() protoreflect.Message { - mi := &file_agentcompose_v2_agentcompose_proto_msgTypes[124] + mi := &file_agentcompose_v2_agentcompose_proto_msgTypes[130] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -10451,7 +10859,7 @@ func (x *CacheFilter) ProtoReflect() protoreflect.Message { // Deprecated: Use CacheFilter.ProtoReflect.Descriptor instead. func (*CacheFilter) Descriptor() ([]byte, []int) { - return file_agentcompose_v2_agentcompose_proto_rawDescGZIP(), []int{124} + return file_agentcompose_v2_agentcompose_proto_rawDescGZIP(), []int{130} } func (x *CacheFilter) GetDriver() string { @@ -10505,7 +10913,7 @@ type ListCachesRequest struct { func (x *ListCachesRequest) Reset() { *x = ListCachesRequest{} - mi := &file_agentcompose_v2_agentcompose_proto_msgTypes[125] + mi := &file_agentcompose_v2_agentcompose_proto_msgTypes[131] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -10517,7 +10925,7 @@ func (x *ListCachesRequest) String() string { func (*ListCachesRequest) ProtoMessage() {} func (x *ListCachesRequest) ProtoReflect() protoreflect.Message { - mi := &file_agentcompose_v2_agentcompose_proto_msgTypes[125] + mi := &file_agentcompose_v2_agentcompose_proto_msgTypes[131] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -10530,7 +10938,7 @@ func (x *ListCachesRequest) ProtoReflect() protoreflect.Message { // Deprecated: Use ListCachesRequest.ProtoReflect.Descriptor instead. func (*ListCachesRequest) Descriptor() ([]byte, []int) { - return file_agentcompose_v2_agentcompose_proto_rawDescGZIP(), []int{125} + return file_agentcompose_v2_agentcompose_proto_rawDescGZIP(), []int{131} } func (x *ListCachesRequest) GetFilter() *CacheFilter { @@ -10550,7 +10958,7 @@ type ListCachesResponse struct { func (x *ListCachesResponse) Reset() { *x = ListCachesResponse{} - mi := &file_agentcompose_v2_agentcompose_proto_msgTypes[126] + mi := &file_agentcompose_v2_agentcompose_proto_msgTypes[132] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -10562,7 +10970,7 @@ func (x *ListCachesResponse) String() string { func (*ListCachesResponse) ProtoMessage() {} func (x *ListCachesResponse) ProtoReflect() protoreflect.Message { - mi := &file_agentcompose_v2_agentcompose_proto_msgTypes[126] + mi := &file_agentcompose_v2_agentcompose_proto_msgTypes[132] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -10575,7 +10983,7 @@ func (x *ListCachesResponse) ProtoReflect() protoreflect.Message { // Deprecated: Use ListCachesResponse.ProtoReflect.Descriptor instead. func (*ListCachesResponse) Descriptor() ([]byte, []int) { - return file_agentcompose_v2_agentcompose_proto_rawDescGZIP(), []int{126} + return file_agentcompose_v2_agentcompose_proto_rawDescGZIP(), []int{132} } func (x *ListCachesResponse) GetCaches() []*CacheItem { @@ -10601,7 +11009,7 @@ type InspectCacheRequest struct { func (x *InspectCacheRequest) Reset() { *x = InspectCacheRequest{} - mi := &file_agentcompose_v2_agentcompose_proto_msgTypes[127] + mi := &file_agentcompose_v2_agentcompose_proto_msgTypes[133] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -10613,7 +11021,7 @@ func (x *InspectCacheRequest) String() string { func (*InspectCacheRequest) ProtoMessage() {} func (x *InspectCacheRequest) ProtoReflect() protoreflect.Message { - mi := &file_agentcompose_v2_agentcompose_proto_msgTypes[127] + mi := &file_agentcompose_v2_agentcompose_proto_msgTypes[133] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -10626,7 +11034,7 @@ func (x *InspectCacheRequest) ProtoReflect() protoreflect.Message { // Deprecated: Use InspectCacheRequest.ProtoReflect.Descriptor instead. func (*InspectCacheRequest) Descriptor() ([]byte, []int) { - return file_agentcompose_v2_agentcompose_proto_rawDescGZIP(), []int{127} + return file_agentcompose_v2_agentcompose_proto_rawDescGZIP(), []int{133} } func (x *InspectCacheRequest) GetCacheId() string { @@ -10646,7 +11054,7 @@ type InspectCacheResponse struct { func (x *InspectCacheResponse) Reset() { *x = InspectCacheResponse{} - mi := &file_agentcompose_v2_agentcompose_proto_msgTypes[128] + mi := &file_agentcompose_v2_agentcompose_proto_msgTypes[134] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -10658,7 +11066,7 @@ func (x *InspectCacheResponse) String() string { func (*InspectCacheResponse) ProtoMessage() {} func (x *InspectCacheResponse) ProtoReflect() protoreflect.Message { - mi := &file_agentcompose_v2_agentcompose_proto_msgTypes[128] + mi := &file_agentcompose_v2_agentcompose_proto_msgTypes[134] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -10671,7 +11079,7 @@ func (x *InspectCacheResponse) ProtoReflect() protoreflect.Message { // Deprecated: Use InspectCacheResponse.ProtoReflect.Descriptor instead. func (*InspectCacheResponse) Descriptor() ([]byte, []int) { - return file_agentcompose_v2_agentcompose_proto_rawDescGZIP(), []int{128} + return file_agentcompose_v2_agentcompose_proto_rawDescGZIP(), []int{134} } func (x *InspectCacheResponse) GetCache() *CacheItem { @@ -10699,7 +11107,7 @@ type PruneCachesRequest struct { func (x *PruneCachesRequest) Reset() { *x = PruneCachesRequest{} - mi := &file_agentcompose_v2_agentcompose_proto_msgTypes[129] + mi := &file_agentcompose_v2_agentcompose_proto_msgTypes[135] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -10711,7 +11119,7 @@ func (x *PruneCachesRequest) String() string { func (*PruneCachesRequest) ProtoMessage() {} func (x *PruneCachesRequest) ProtoReflect() protoreflect.Message { - mi := &file_agentcompose_v2_agentcompose_proto_msgTypes[129] + mi := &file_agentcompose_v2_agentcompose_proto_msgTypes[135] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -10724,7 +11132,7 @@ func (x *PruneCachesRequest) ProtoReflect() protoreflect.Message { // Deprecated: Use PruneCachesRequest.ProtoReflect.Descriptor instead. func (*PruneCachesRequest) Descriptor() ([]byte, []int) { - return file_agentcompose_v2_agentcompose_proto_rawDescGZIP(), []int{129} + return file_agentcompose_v2_agentcompose_proto_rawDescGZIP(), []int{135} } func (x *PruneCachesRequest) GetFilter() *CacheFilter { @@ -10761,7 +11169,7 @@ type PruneCachesResponse struct { func (x *PruneCachesResponse) Reset() { *x = PruneCachesResponse{} - mi := &file_agentcompose_v2_agentcompose_proto_msgTypes[130] + mi := &file_agentcompose_v2_agentcompose_proto_msgTypes[136] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -10773,7 +11181,7 @@ func (x *PruneCachesResponse) String() string { func (*PruneCachesResponse) ProtoMessage() {} func (x *PruneCachesResponse) ProtoReflect() protoreflect.Message { - mi := &file_agentcompose_v2_agentcompose_proto_msgTypes[130] + mi := &file_agentcompose_v2_agentcompose_proto_msgTypes[136] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -10786,7 +11194,7 @@ func (x *PruneCachesResponse) ProtoReflect() protoreflect.Message { // Deprecated: Use PruneCachesResponse.ProtoReflect.Descriptor instead. func (*PruneCachesResponse) Descriptor() ([]byte, []int) { - return file_agentcompose_v2_agentcompose_proto_rawDescGZIP(), []int{130} + return file_agentcompose_v2_agentcompose_proto_rawDescGZIP(), []int{136} } func (x *PruneCachesResponse) GetDryRun() bool { @@ -10834,7 +11242,7 @@ type RemoveCacheRequest struct { func (x *RemoveCacheRequest) Reset() { *x = RemoveCacheRequest{} - mi := &file_agentcompose_v2_agentcompose_proto_msgTypes[131] + mi := &file_agentcompose_v2_agentcompose_proto_msgTypes[137] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -10846,7 +11254,7 @@ func (x *RemoveCacheRequest) String() string { func (*RemoveCacheRequest) ProtoMessage() {} func (x *RemoveCacheRequest) ProtoReflect() protoreflect.Message { - mi := &file_agentcompose_v2_agentcompose_proto_msgTypes[131] + mi := &file_agentcompose_v2_agentcompose_proto_msgTypes[137] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -10859,7 +11267,7 @@ func (x *RemoveCacheRequest) ProtoReflect() protoreflect.Message { // Deprecated: Use RemoveCacheRequest.ProtoReflect.Descriptor instead. func (*RemoveCacheRequest) Descriptor() ([]byte, []int) { - return file_agentcompose_v2_agentcompose_proto_rawDescGZIP(), []int{131} + return file_agentcompose_v2_agentcompose_proto_rawDescGZIP(), []int{137} } func (x *RemoveCacheRequest) GetCacheId() string { @@ -10889,7 +11297,7 @@ type RemoveCacheResponse struct { func (x *RemoveCacheResponse) Reset() { *x = RemoveCacheResponse{} - mi := &file_agentcompose_v2_agentcompose_proto_msgTypes[132] + mi := &file_agentcompose_v2_agentcompose_proto_msgTypes[138] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -10901,7 +11309,7 @@ func (x *RemoveCacheResponse) String() string { func (*RemoveCacheResponse) ProtoMessage() {} func (x *RemoveCacheResponse) ProtoReflect() protoreflect.Message { - mi := &file_agentcompose_v2_agentcompose_proto_msgTypes[132] + mi := &file_agentcompose_v2_agentcompose_proto_msgTypes[138] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -10914,7 +11322,7 @@ func (x *RemoveCacheResponse) ProtoReflect() protoreflect.Message { // Deprecated: Use RemoveCacheResponse.ProtoReflect.Descriptor instead. func (*RemoveCacheResponse) Descriptor() ([]byte, []int) { - return file_agentcompose_v2_agentcompose_proto_rawDescGZIP(), []int{132} + return file_agentcompose_v2_agentcompose_proto_rawDescGZIP(), []int{138} } func (x *RemoveCacheResponse) GetDryRun() bool { @@ -10977,7 +11385,7 @@ type CacheItem struct { func (x *CacheItem) Reset() { *x = CacheItem{} - mi := &file_agentcompose_v2_agentcompose_proto_msgTypes[133] + mi := &file_agentcompose_v2_agentcompose_proto_msgTypes[139] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -10989,7 +11397,7 @@ func (x *CacheItem) String() string { func (*CacheItem) ProtoMessage() {} func (x *CacheItem) ProtoReflect() protoreflect.Message { - mi := &file_agentcompose_v2_agentcompose_proto_msgTypes[133] + mi := &file_agentcompose_v2_agentcompose_proto_msgTypes[139] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -11002,7 +11410,7 @@ func (x *CacheItem) ProtoReflect() protoreflect.Message { // Deprecated: Use CacheItem.ProtoReflect.Descriptor instead. func (*CacheItem) Descriptor() ([]byte, []int) { - return file_agentcompose_v2_agentcompose_proto_rawDescGZIP(), []int{133} + return file_agentcompose_v2_agentcompose_proto_rawDescGZIP(), []int{139} } func (x *CacheItem) GetCacheId() string { @@ -11138,7 +11546,7 @@ type CacheReference struct { func (x *CacheReference) Reset() { *x = CacheReference{} - mi := &file_agentcompose_v2_agentcompose_proto_msgTypes[134] + mi := &file_agentcompose_v2_agentcompose_proto_msgTypes[140] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -11150,7 +11558,7 @@ func (x *CacheReference) String() string { func (*CacheReference) ProtoMessage() {} func (x *CacheReference) ProtoReflect() protoreflect.Message { - mi := &file_agentcompose_v2_agentcompose_proto_msgTypes[134] + mi := &file_agentcompose_v2_agentcompose_proto_msgTypes[140] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -11163,7 +11571,7 @@ func (x *CacheReference) ProtoReflect() protoreflect.Message { // Deprecated: Use CacheReference.ProtoReflect.Descriptor instead. func (*CacheReference) Descriptor() ([]byte, []int) { - return file_agentcompose_v2_agentcompose_proto_rawDescGZIP(), []int{134} + return file_agentcompose_v2_agentcompose_proto_rawDescGZIP(), []int{140} } func (x *CacheReference) GetType() string { @@ -11219,7 +11627,7 @@ type ListVolumesRequest struct { func (x *ListVolumesRequest) Reset() { *x = ListVolumesRequest{} - mi := &file_agentcompose_v2_agentcompose_proto_msgTypes[135] + mi := &file_agentcompose_v2_agentcompose_proto_msgTypes[141] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -11231,7 +11639,7 @@ func (x *ListVolumesRequest) String() string { func (*ListVolumesRequest) ProtoMessage() {} func (x *ListVolumesRequest) ProtoReflect() protoreflect.Message { - mi := &file_agentcompose_v2_agentcompose_proto_msgTypes[135] + mi := &file_agentcompose_v2_agentcompose_proto_msgTypes[141] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -11244,7 +11652,7 @@ func (x *ListVolumesRequest) ProtoReflect() protoreflect.Message { // Deprecated: Use ListVolumesRequest.ProtoReflect.Descriptor instead. func (*ListVolumesRequest) Descriptor() ([]byte, []int) { - return file_agentcompose_v2_agentcompose_proto_rawDescGZIP(), []int{135} + return file_agentcompose_v2_agentcompose_proto_rawDescGZIP(), []int{141} } func (x *ListVolumesRequest) GetQuery() string { @@ -11277,7 +11685,7 @@ type ListVolumesResponse struct { func (x *ListVolumesResponse) Reset() { *x = ListVolumesResponse{} - mi := &file_agentcompose_v2_agentcompose_proto_msgTypes[136] + mi := &file_agentcompose_v2_agentcompose_proto_msgTypes[142] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -11289,7 +11697,7 @@ func (x *ListVolumesResponse) String() string { func (*ListVolumesResponse) ProtoMessage() {} func (x *ListVolumesResponse) ProtoReflect() protoreflect.Message { - mi := &file_agentcompose_v2_agentcompose_proto_msgTypes[136] + mi := &file_agentcompose_v2_agentcompose_proto_msgTypes[142] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -11302,7 +11710,7 @@ func (x *ListVolumesResponse) ProtoReflect() protoreflect.Message { // Deprecated: Use ListVolumesResponse.ProtoReflect.Descriptor instead. func (*ListVolumesResponse) Descriptor() ([]byte, []int) { - return file_agentcompose_v2_agentcompose_proto_rawDescGZIP(), []int{136} + return file_agentcompose_v2_agentcompose_proto_rawDescGZIP(), []int{142} } func (x *ListVolumesResponse) GetVolumes() []*Volume { @@ -11324,7 +11732,7 @@ type CreateVolumeRequest struct { func (x *CreateVolumeRequest) Reset() { *x = CreateVolumeRequest{} - mi := &file_agentcompose_v2_agentcompose_proto_msgTypes[137] + mi := &file_agentcompose_v2_agentcompose_proto_msgTypes[143] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -11336,7 +11744,7 @@ func (x *CreateVolumeRequest) String() string { func (*CreateVolumeRequest) ProtoMessage() {} func (x *CreateVolumeRequest) ProtoReflect() protoreflect.Message { - mi := &file_agentcompose_v2_agentcompose_proto_msgTypes[137] + mi := &file_agentcompose_v2_agentcompose_proto_msgTypes[143] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -11349,7 +11757,7 @@ func (x *CreateVolumeRequest) ProtoReflect() protoreflect.Message { // Deprecated: Use CreateVolumeRequest.ProtoReflect.Descriptor instead. func (*CreateVolumeRequest) Descriptor() ([]byte, []int) { - return file_agentcompose_v2_agentcompose_proto_rawDescGZIP(), []int{137} + return file_agentcompose_v2_agentcompose_proto_rawDescGZIP(), []int{143} } func (x *CreateVolumeRequest) GetName() string { @@ -11390,7 +11798,7 @@ type CreateVolumeResponse struct { func (x *CreateVolumeResponse) Reset() { *x = CreateVolumeResponse{} - mi := &file_agentcompose_v2_agentcompose_proto_msgTypes[138] + mi := &file_agentcompose_v2_agentcompose_proto_msgTypes[144] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -11402,7 +11810,7 @@ func (x *CreateVolumeResponse) String() string { func (*CreateVolumeResponse) ProtoMessage() {} func (x *CreateVolumeResponse) ProtoReflect() protoreflect.Message { - mi := &file_agentcompose_v2_agentcompose_proto_msgTypes[138] + mi := &file_agentcompose_v2_agentcompose_proto_msgTypes[144] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -11415,7 +11823,7 @@ func (x *CreateVolumeResponse) ProtoReflect() protoreflect.Message { // Deprecated: Use CreateVolumeResponse.ProtoReflect.Descriptor instead. func (*CreateVolumeResponse) Descriptor() ([]byte, []int) { - return file_agentcompose_v2_agentcompose_proto_rawDescGZIP(), []int{138} + return file_agentcompose_v2_agentcompose_proto_rawDescGZIP(), []int{144} } func (x *CreateVolumeResponse) GetVolume() *Volume { @@ -11441,7 +11849,7 @@ type InspectVolumeRequest struct { func (x *InspectVolumeRequest) Reset() { *x = InspectVolumeRequest{} - mi := &file_agentcompose_v2_agentcompose_proto_msgTypes[139] + mi := &file_agentcompose_v2_agentcompose_proto_msgTypes[145] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -11453,7 +11861,7 @@ func (x *InspectVolumeRequest) String() string { func (*InspectVolumeRequest) ProtoMessage() {} func (x *InspectVolumeRequest) ProtoReflect() protoreflect.Message { - mi := &file_agentcompose_v2_agentcompose_proto_msgTypes[139] + mi := &file_agentcompose_v2_agentcompose_proto_msgTypes[145] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -11466,7 +11874,7 @@ func (x *InspectVolumeRequest) ProtoReflect() protoreflect.Message { // Deprecated: Use InspectVolumeRequest.ProtoReflect.Descriptor instead. func (*InspectVolumeRequest) Descriptor() ([]byte, []int) { - return file_agentcompose_v2_agentcompose_proto_rawDescGZIP(), []int{139} + return file_agentcompose_v2_agentcompose_proto_rawDescGZIP(), []int{145} } func (x *InspectVolumeRequest) GetName() string { @@ -11485,7 +11893,7 @@ type InspectVolumeResponse struct { func (x *InspectVolumeResponse) Reset() { *x = InspectVolumeResponse{} - mi := &file_agentcompose_v2_agentcompose_proto_msgTypes[140] + mi := &file_agentcompose_v2_agentcompose_proto_msgTypes[146] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -11497,7 +11905,7 @@ func (x *InspectVolumeResponse) String() string { func (*InspectVolumeResponse) ProtoMessage() {} func (x *InspectVolumeResponse) ProtoReflect() protoreflect.Message { - mi := &file_agentcompose_v2_agentcompose_proto_msgTypes[140] + mi := &file_agentcompose_v2_agentcompose_proto_msgTypes[146] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -11510,7 +11918,7 @@ func (x *InspectVolumeResponse) ProtoReflect() protoreflect.Message { // Deprecated: Use InspectVolumeResponse.ProtoReflect.Descriptor instead. func (*InspectVolumeResponse) Descriptor() ([]byte, []int) { - return file_agentcompose_v2_agentcompose_proto_rawDescGZIP(), []int{140} + return file_agentcompose_v2_agentcompose_proto_rawDescGZIP(), []int{146} } func (x *InspectVolumeResponse) GetVolume() *Volume { @@ -11530,7 +11938,7 @@ type RemoveVolumeRequest struct { func (x *RemoveVolumeRequest) Reset() { *x = RemoveVolumeRequest{} - mi := &file_agentcompose_v2_agentcompose_proto_msgTypes[141] + mi := &file_agentcompose_v2_agentcompose_proto_msgTypes[147] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -11542,7 +11950,7 @@ func (x *RemoveVolumeRequest) String() string { func (*RemoveVolumeRequest) ProtoMessage() {} func (x *RemoveVolumeRequest) ProtoReflect() protoreflect.Message { - mi := &file_agentcompose_v2_agentcompose_proto_msgTypes[141] + mi := &file_agentcompose_v2_agentcompose_proto_msgTypes[147] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -11555,7 +11963,7 @@ func (x *RemoveVolumeRequest) ProtoReflect() protoreflect.Message { // Deprecated: Use RemoveVolumeRequest.ProtoReflect.Descriptor instead. func (*RemoveVolumeRequest) Descriptor() ([]byte, []int) { - return file_agentcompose_v2_agentcompose_proto_rawDescGZIP(), []int{141} + return file_agentcompose_v2_agentcompose_proto_rawDescGZIP(), []int{147} } func (x *RemoveVolumeRequest) GetName() string { @@ -11582,7 +11990,7 @@ type RemoveVolumeResponse struct { func (x *RemoveVolumeResponse) Reset() { *x = RemoveVolumeResponse{} - mi := &file_agentcompose_v2_agentcompose_proto_msgTypes[142] + mi := &file_agentcompose_v2_agentcompose_proto_msgTypes[148] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -11594,7 +12002,7 @@ func (x *RemoveVolumeResponse) String() string { func (*RemoveVolumeResponse) ProtoMessage() {} func (x *RemoveVolumeResponse) ProtoReflect() protoreflect.Message { - mi := &file_agentcompose_v2_agentcompose_proto_msgTypes[142] + mi := &file_agentcompose_v2_agentcompose_proto_msgTypes[148] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -11607,7 +12015,7 @@ func (x *RemoveVolumeResponse) ProtoReflect() protoreflect.Message { // Deprecated: Use RemoveVolumeResponse.ProtoReflect.Descriptor instead. func (*RemoveVolumeResponse) Descriptor() ([]byte, []int) { - return file_agentcompose_v2_agentcompose_proto_rawDescGZIP(), []int{142} + return file_agentcompose_v2_agentcompose_proto_rawDescGZIP(), []int{148} } func (x *RemoveVolumeResponse) GetName() string { @@ -11636,7 +12044,7 @@ type PruneVolumesRequest struct { func (x *PruneVolumesRequest) Reset() { *x = PruneVolumesRequest{} - mi := &file_agentcompose_v2_agentcompose_proto_msgTypes[143] + mi := &file_agentcompose_v2_agentcompose_proto_msgTypes[149] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -11648,7 +12056,7 @@ func (x *PruneVolumesRequest) String() string { func (*PruneVolumesRequest) ProtoMessage() {} func (x *PruneVolumesRequest) ProtoReflect() protoreflect.Message { - mi := &file_agentcompose_v2_agentcompose_proto_msgTypes[143] + mi := &file_agentcompose_v2_agentcompose_proto_msgTypes[149] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -11661,7 +12069,7 @@ func (x *PruneVolumesRequest) ProtoReflect() protoreflect.Message { // Deprecated: Use PruneVolumesRequest.ProtoReflect.Descriptor instead. func (*PruneVolumesRequest) Descriptor() ([]byte, []int) { - return file_agentcompose_v2_agentcompose_proto_rawDescGZIP(), []int{143} + return file_agentcompose_v2_agentcompose_proto_rawDescGZIP(), []int{149} } func (x *PruneVolumesRequest) GetQuery() string { @@ -11704,7 +12112,7 @@ type PruneVolumesResponse struct { func (x *PruneVolumesResponse) Reset() { *x = PruneVolumesResponse{} - mi := &file_agentcompose_v2_agentcompose_proto_msgTypes[144] + mi := &file_agentcompose_v2_agentcompose_proto_msgTypes[150] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -11716,7 +12124,7 @@ func (x *PruneVolumesResponse) String() string { func (*PruneVolumesResponse) ProtoMessage() {} func (x *PruneVolumesResponse) ProtoReflect() protoreflect.Message { - mi := &file_agentcompose_v2_agentcompose_proto_msgTypes[144] + mi := &file_agentcompose_v2_agentcompose_proto_msgTypes[150] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -11729,7 +12137,7 @@ func (x *PruneVolumesResponse) ProtoReflect() protoreflect.Message { // Deprecated: Use PruneVolumesResponse.ProtoReflect.Descriptor instead. func (*PruneVolumesResponse) Descriptor() ([]byte, []int) { - return file_agentcompose_v2_agentcompose_proto_rawDescGZIP(), []int{144} + return file_agentcompose_v2_agentcompose_proto_rawDescGZIP(), []int{150} } func (x *PruneVolumesResponse) GetDryRun() bool { @@ -11776,7 +12184,7 @@ type Volume struct { func (x *Volume) Reset() { *x = Volume{} - mi := &file_agentcompose_v2_agentcompose_proto_msgTypes[145] + mi := &file_agentcompose_v2_agentcompose_proto_msgTypes[151] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -11788,7 +12196,7 @@ func (x *Volume) String() string { func (*Volume) ProtoMessage() {} func (x *Volume) ProtoReflect() protoreflect.Message { - mi := &file_agentcompose_v2_agentcompose_proto_msgTypes[145] + mi := &file_agentcompose_v2_agentcompose_proto_msgTypes[151] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -11801,7 +12209,7 @@ func (x *Volume) ProtoReflect() protoreflect.Message { // Deprecated: Use Volume.ProtoReflect.Descriptor instead. func (*Volume) Descriptor() ([]byte, []int) { - return file_agentcompose_v2_agentcompose_proto_rawDescGZIP(), []int{145} + return file_agentcompose_v2_agentcompose_proto_rawDescGZIP(), []int{151} } func (x *Volume) GetName() string { @@ -11885,7 +12293,7 @@ type Image struct { func (x *Image) Reset() { *x = Image{} - mi := &file_agentcompose_v2_agentcompose_proto_msgTypes[146] + mi := &file_agentcompose_v2_agentcompose_proto_msgTypes[152] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -11897,7 +12305,7 @@ func (x *Image) String() string { func (*Image) ProtoMessage() {} func (x *Image) ProtoReflect() protoreflect.Message { - mi := &file_agentcompose_v2_agentcompose_proto_msgTypes[146] + mi := &file_agentcompose_v2_agentcompose_proto_msgTypes[152] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -11910,7 +12318,7 @@ func (x *Image) ProtoReflect() protoreflect.Message { // Deprecated: Use Image.ProtoReflect.Descriptor instead. func (*Image) Descriptor() ([]byte, []int) { - return file_agentcompose_v2_agentcompose_proto_rawDescGZIP(), []int{146} + return file_agentcompose_v2_agentcompose_proto_rawDescGZIP(), []int{152} } func (x *Image) GetImageId() string { @@ -12044,7 +12452,7 @@ type ImagePlatform struct { func (x *ImagePlatform) Reset() { *x = ImagePlatform{} - mi := &file_agentcompose_v2_agentcompose_proto_msgTypes[147] + mi := &file_agentcompose_v2_agentcompose_proto_msgTypes[153] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -12056,7 +12464,7 @@ func (x *ImagePlatform) String() string { func (*ImagePlatform) ProtoMessage() {} func (x *ImagePlatform) ProtoReflect() protoreflect.Message { - mi := &file_agentcompose_v2_agentcompose_proto_msgTypes[147] + mi := &file_agentcompose_v2_agentcompose_proto_msgTypes[153] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -12069,7 +12477,7 @@ func (x *ImagePlatform) ProtoReflect() protoreflect.Message { // Deprecated: Use ImagePlatform.ProtoReflect.Descriptor instead. func (*ImagePlatform) Descriptor() ([]byte, []int) { - return file_agentcompose_v2_agentcompose_proto_rawDescGZIP(), []int{147} + return file_agentcompose_v2_agentcompose_proto_rawDescGZIP(), []int{153} } func (x *ImagePlatform) GetOs() string { @@ -12112,7 +12520,7 @@ type ImageStoreStatus struct { func (x *ImageStoreStatus) Reset() { *x = ImageStoreStatus{} - mi := &file_agentcompose_v2_agentcompose_proto_msgTypes[148] + mi := &file_agentcompose_v2_agentcompose_proto_msgTypes[154] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -12124,7 +12532,7 @@ func (x *ImageStoreStatus) String() string { func (*ImageStoreStatus) ProtoMessage() {} func (x *ImageStoreStatus) ProtoReflect() protoreflect.Message { - mi := &file_agentcompose_v2_agentcompose_proto_msgTypes[148] + mi := &file_agentcompose_v2_agentcompose_proto_msgTypes[154] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -12137,7 +12545,7 @@ func (x *ImageStoreStatus) ProtoReflect() protoreflect.Message { // Deprecated: Use ImageStoreStatus.ProtoReflect.Descriptor instead. func (*ImageStoreStatus) Descriptor() ([]byte, []int) { - return file_agentcompose_v2_agentcompose_proto_rawDescGZIP(), []int{148} + return file_agentcompose_v2_agentcompose_proto_rawDescGZIP(), []int{154} } func (x *ImageStoreStatus) GetStore() ImageStoreKind { @@ -12179,7 +12587,7 @@ type DockerImageStatus struct { func (x *DockerImageStatus) Reset() { *x = DockerImageStatus{} - mi := &file_agentcompose_v2_agentcompose_proto_msgTypes[149] + mi := &file_agentcompose_v2_agentcompose_proto_msgTypes[155] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -12191,7 +12599,7 @@ func (x *DockerImageStatus) String() string { func (*DockerImageStatus) ProtoMessage() {} func (x *DockerImageStatus) ProtoReflect() protoreflect.Message { - mi := &file_agentcompose_v2_agentcompose_proto_msgTypes[149] + mi := &file_agentcompose_v2_agentcompose_proto_msgTypes[155] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -12204,7 +12612,7 @@ func (x *DockerImageStatus) ProtoReflect() protoreflect.Message { // Deprecated: Use DockerImageStatus.ProtoReflect.Descriptor instead. func (*DockerImageStatus) Descriptor() ([]byte, []int) { - return file_agentcompose_v2_agentcompose_proto_rawDescGZIP(), []int{149} + return file_agentcompose_v2_agentcompose_proto_rawDescGZIP(), []int{155} } func (x *DockerImageStatus) GetLocal() bool { @@ -12242,7 +12650,7 @@ type OCIImageStatus struct { func (x *OCIImageStatus) Reset() { *x = OCIImageStatus{} - mi := &file_agentcompose_v2_agentcompose_proto_msgTypes[150] + mi := &file_agentcompose_v2_agentcompose_proto_msgTypes[156] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -12254,7 +12662,7 @@ func (x *OCIImageStatus) String() string { func (*OCIImageStatus) ProtoMessage() {} func (x *OCIImageStatus) ProtoReflect() protoreflect.Message { - mi := &file_agentcompose_v2_agentcompose_proto_msgTypes[150] + mi := &file_agentcompose_v2_agentcompose_proto_msgTypes[156] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -12267,7 +12675,7 @@ func (x *OCIImageStatus) ProtoReflect() protoreflect.Message { // Deprecated: Use OCIImageStatus.ProtoReflect.Descriptor instead. func (*OCIImageStatus) Descriptor() ([]byte, []int) { - return file_agentcompose_v2_agentcompose_proto_rawDescGZIP(), []int{150} + return file_agentcompose_v2_agentcompose_proto_rawDescGZIP(), []int{156} } func (x *OCIImageStatus) GetLayoutCached() bool { @@ -12325,7 +12733,7 @@ type ImagePullProgress struct { func (x *ImagePullProgress) Reset() { *x = ImagePullProgress{} - mi := &file_agentcompose_v2_agentcompose_proto_msgTypes[151] + mi := &file_agentcompose_v2_agentcompose_proto_msgTypes[157] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -12337,7 +12745,7 @@ func (x *ImagePullProgress) String() string { func (*ImagePullProgress) ProtoMessage() {} func (x *ImagePullProgress) ProtoReflect() protoreflect.Message { - mi := &file_agentcompose_v2_agentcompose_proto_msgTypes[151] + mi := &file_agentcompose_v2_agentcompose_proto_msgTypes[157] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -12350,7 +12758,7 @@ func (x *ImagePullProgress) ProtoReflect() protoreflect.Message { // Deprecated: Use ImagePullProgress.ProtoReflect.Descriptor instead. func (*ImagePullProgress) Descriptor() ([]byte, []int) { - return file_agentcompose_v2_agentcompose_proto_rawDescGZIP(), []int{151} + return file_agentcompose_v2_agentcompose_proto_rawDescGZIP(), []int{157} } func (x *ImagePullProgress) GetId() string { @@ -12398,7 +12806,7 @@ type JupyterSpec struct { func (x *JupyterSpec) Reset() { *x = JupyterSpec{} - mi := &file_agentcompose_v2_agentcompose_proto_msgTypes[152] + mi := &file_agentcompose_v2_agentcompose_proto_msgTypes[158] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -12410,7 +12818,7 @@ func (x *JupyterSpec) String() string { func (*JupyterSpec) ProtoMessage() {} func (x *JupyterSpec) ProtoReflect() protoreflect.Message { - mi := &file_agentcompose_v2_agentcompose_proto_msgTypes[152] + mi := &file_agentcompose_v2_agentcompose_proto_msgTypes[158] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -12423,7 +12831,7 @@ func (x *JupyterSpec) ProtoReflect() protoreflect.Message { // Deprecated: Use JupyterSpec.ProtoReflect.Descriptor instead. func (*JupyterSpec) Descriptor() ([]byte, []int) { - return file_agentcompose_v2_agentcompose_proto_rawDescGZIP(), []int{152} + return file_agentcompose_v2_agentcompose_proto_rawDescGZIP(), []int{158} } func (x *JupyterSpec) GetEnabled() bool { @@ -12451,7 +12859,7 @@ type RunJupyterSpec struct { func (x *RunJupyterSpec) Reset() { *x = RunJupyterSpec{} - mi := &file_agentcompose_v2_agentcompose_proto_msgTypes[153] + mi := &file_agentcompose_v2_agentcompose_proto_msgTypes[159] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -12463,7 +12871,7 @@ func (x *RunJupyterSpec) String() string { func (*RunJupyterSpec) ProtoMessage() {} func (x *RunJupyterSpec) ProtoReflect() protoreflect.Message { - mi := &file_agentcompose_v2_agentcompose_proto_msgTypes[153] + mi := &file_agentcompose_v2_agentcompose_proto_msgTypes[159] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -12476,7 +12884,7 @@ func (x *RunJupyterSpec) ProtoReflect() protoreflect.Message { // Deprecated: Use RunJupyterSpec.ProtoReflect.Descriptor instead. func (*RunJupyterSpec) Descriptor() ([]byte, []int) { - return file_agentcompose_v2_agentcompose_proto_rawDescGZIP(), []int{153} + return file_agentcompose_v2_agentcompose_proto_rawDescGZIP(), []int{159} } func (x *RunJupyterSpec) GetEnabled() bool { @@ -12509,7 +12917,7 @@ type StartRunRequest struct { func (x *StartRunRequest) Reset() { *x = StartRunRequest{} - mi := &file_agentcompose_v2_agentcompose_proto_msgTypes[154] + mi := &file_agentcompose_v2_agentcompose_proto_msgTypes[160] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -12521,7 +12929,7 @@ func (x *StartRunRequest) String() string { func (*StartRunRequest) ProtoMessage() {} func (x *StartRunRequest) ProtoReflect() protoreflect.Message { - mi := &file_agentcompose_v2_agentcompose_proto_msgTypes[154] + mi := &file_agentcompose_v2_agentcompose_proto_msgTypes[160] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -12534,7 +12942,7 @@ func (x *StartRunRequest) ProtoReflect() protoreflect.Message { // Deprecated: Use StartRunRequest.ProtoReflect.Descriptor instead. func (*StartRunRequest) Descriptor() ([]byte, []int) { - return file_agentcompose_v2_agentcompose_proto_rawDescGZIP(), []int{154} + return file_agentcompose_v2_agentcompose_proto_rawDescGZIP(), []int{160} } func (x *StartRunRequest) GetRun() *RunAgentRequest { @@ -12555,7 +12963,7 @@ type StartRunResponse struct { func (x *StartRunResponse) Reset() { *x = StartRunResponse{} - mi := &file_agentcompose_v2_agentcompose_proto_msgTypes[155] + mi := &file_agentcompose_v2_agentcompose_proto_msgTypes[161] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -12567,7 +12975,7 @@ func (x *StartRunResponse) String() string { func (*StartRunResponse) ProtoMessage() {} func (x *StartRunResponse) ProtoReflect() protoreflect.Message { - mi := &file_agentcompose_v2_agentcompose_proto_msgTypes[155] + mi := &file_agentcompose_v2_agentcompose_proto_msgTypes[161] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -12580,7 +12988,7 @@ func (x *StartRunResponse) ProtoReflect() protoreflect.Message { // Deprecated: Use StartRunResponse.ProtoReflect.Descriptor instead. func (*StartRunResponse) Descriptor() ([]byte, []int) { - return file_agentcompose_v2_agentcompose_proto_rawDescGZIP(), []int{155} + return file_agentcompose_v2_agentcompose_proto_rawDescGZIP(), []int{161} } func (x *StartRunResponse) GetRun() *RunSummary { @@ -12620,7 +13028,7 @@ type SkillSpec struct { func (x *SkillSpec) Reset() { *x = SkillSpec{} - mi := &file_agentcompose_v2_agentcompose_proto_msgTypes[156] + mi := &file_agentcompose_v2_agentcompose_proto_msgTypes[162] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -12632,7 +13040,7 @@ func (x *SkillSpec) String() string { func (*SkillSpec) ProtoMessage() {} func (x *SkillSpec) ProtoReflect() protoreflect.Message { - mi := &file_agentcompose_v2_agentcompose_proto_msgTypes[156] + mi := &file_agentcompose_v2_agentcompose_proto_msgTypes[162] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -12645,7 +13053,7 @@ func (x *SkillSpec) ProtoReflect() protoreflect.Message { // Deprecated: Use SkillSpec.ProtoReflect.Descriptor instead. func (*SkillSpec) Descriptor() ([]byte, []int) { - return file_agentcompose_v2_agentcompose_proto_rawDescGZIP(), []int{156} + return file_agentcompose_v2_agentcompose_proto_rawDescGZIP(), []int{162} } func (x *SkillSpec) GetName() string { @@ -12714,7 +13122,7 @@ type ResolveResourceIDRequest struct { func (x *ResolveResourceIDRequest) Reset() { *x = ResolveResourceIDRequest{} - mi := &file_agentcompose_v2_agentcompose_proto_msgTypes[157] + mi := &file_agentcompose_v2_agentcompose_proto_msgTypes[163] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -12726,7 +13134,7 @@ func (x *ResolveResourceIDRequest) String() string { func (*ResolveResourceIDRequest) ProtoMessage() {} func (x *ResolveResourceIDRequest) ProtoReflect() protoreflect.Message { - mi := &file_agentcompose_v2_agentcompose_proto_msgTypes[157] + mi := &file_agentcompose_v2_agentcompose_proto_msgTypes[163] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -12739,7 +13147,7 @@ func (x *ResolveResourceIDRequest) ProtoReflect() protoreflect.Message { // Deprecated: Use ResolveResourceIDRequest.ProtoReflect.Descriptor instead. func (*ResolveResourceIDRequest) Descriptor() ([]byte, []int) { - return file_agentcompose_v2_agentcompose_proto_rawDescGZIP(), []int{157} + return file_agentcompose_v2_agentcompose_proto_rawDescGZIP(), []int{163} } func (x *ResolveResourceIDRequest) GetId() string { @@ -12766,7 +13174,7 @@ type ResolveResourceIDResponse struct { func (x *ResolveResourceIDResponse) Reset() { *x = ResolveResourceIDResponse{} - mi := &file_agentcompose_v2_agentcompose_proto_msgTypes[158] + mi := &file_agentcompose_v2_agentcompose_proto_msgTypes[164] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -12778,7 +13186,7 @@ func (x *ResolveResourceIDResponse) String() string { func (*ResolveResourceIDResponse) ProtoMessage() {} func (x *ResolveResourceIDResponse) ProtoReflect() protoreflect.Message { - mi := &file_agentcompose_v2_agentcompose_proto_msgTypes[158] + mi := &file_agentcompose_v2_agentcompose_proto_msgTypes[164] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -12791,7 +13199,7 @@ func (x *ResolveResourceIDResponse) ProtoReflect() protoreflect.Message { // Deprecated: Use ResolveResourceIDResponse.ProtoReflect.Descriptor instead. func (*ResolveResourceIDResponse) Descriptor() ([]byte, []int) { - return file_agentcompose_v2_agentcompose_proto_rawDescGZIP(), []int{158} + return file_agentcompose_v2_agentcompose_proto_rawDescGZIP(), []int{164} } func (x *ResolveResourceIDResponse) GetTargets() []*ResourceTarget { @@ -12822,7 +13230,7 @@ type ResourceTarget struct { func (x *ResourceTarget) Reset() { *x = ResourceTarget{} - mi := &file_agentcompose_v2_agentcompose_proto_msgTypes[159] + mi := &file_agentcompose_v2_agentcompose_proto_msgTypes[165] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -12834,7 +13242,7 @@ func (x *ResourceTarget) String() string { func (*ResourceTarget) ProtoMessage() {} func (x *ResourceTarget) ProtoReflect() protoreflect.Message { - mi := &file_agentcompose_v2_agentcompose_proto_msgTypes[159] + mi := &file_agentcompose_v2_agentcompose_proto_msgTypes[165] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -12847,7 +13255,7 @@ func (x *ResourceTarget) ProtoReflect() protoreflect.Message { // Deprecated: Use ResourceTarget.ProtoReflect.Descriptor instead. func (*ResourceTarget) Descriptor() ([]byte, []int) { - return file_agentcompose_v2_agentcompose_proto_rawDescGZIP(), []int{159} + return file_agentcompose_v2_agentcompose_proto_rawDescGZIP(), []int{165} } func (x *ResourceTarget) GetKind() ResourceKind { @@ -12900,7 +13308,7 @@ type GetDashboardOverviewRequest struct { func (x *GetDashboardOverviewRequest) Reset() { *x = GetDashboardOverviewRequest{} - mi := &file_agentcompose_v2_agentcompose_proto_msgTypes[160] + mi := &file_agentcompose_v2_agentcompose_proto_msgTypes[166] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -12912,7 +13320,7 @@ func (x *GetDashboardOverviewRequest) String() string { func (*GetDashboardOverviewRequest) ProtoMessage() {} func (x *GetDashboardOverviewRequest) ProtoReflect() protoreflect.Message { - mi := &file_agentcompose_v2_agentcompose_proto_msgTypes[160] + mi := &file_agentcompose_v2_agentcompose_proto_msgTypes[166] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -12925,7 +13333,7 @@ func (x *GetDashboardOverviewRequest) ProtoReflect() protoreflect.Message { // Deprecated: Use GetDashboardOverviewRequest.ProtoReflect.Descriptor instead. func (*GetDashboardOverviewRequest) Descriptor() ([]byte, []int) { - return file_agentcompose_v2_agentcompose_proto_rawDescGZIP(), []int{160} + return file_agentcompose_v2_agentcompose_proto_rawDescGZIP(), []int{166} } type WatchDashboardOverviewRequest struct { @@ -12936,7 +13344,7 @@ type WatchDashboardOverviewRequest struct { func (x *WatchDashboardOverviewRequest) Reset() { *x = WatchDashboardOverviewRequest{} - mi := &file_agentcompose_v2_agentcompose_proto_msgTypes[161] + mi := &file_agentcompose_v2_agentcompose_proto_msgTypes[167] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -12948,7 +13356,7 @@ func (x *WatchDashboardOverviewRequest) String() string { func (*WatchDashboardOverviewRequest) ProtoMessage() {} func (x *WatchDashboardOverviewRequest) ProtoReflect() protoreflect.Message { - mi := &file_agentcompose_v2_agentcompose_proto_msgTypes[161] + mi := &file_agentcompose_v2_agentcompose_proto_msgTypes[167] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -12961,7 +13369,7 @@ func (x *WatchDashboardOverviewRequest) ProtoReflect() protoreflect.Message { // Deprecated: Use WatchDashboardOverviewRequest.ProtoReflect.Descriptor instead. func (*WatchDashboardOverviewRequest) Descriptor() ([]byte, []int) { - return file_agentcompose_v2_agentcompose_proto_rawDescGZIP(), []int{161} + return file_agentcompose_v2_agentcompose_proto_rawDescGZIP(), []int{167} } type RunOverview struct { @@ -12975,7 +13383,7 @@ type RunOverview struct { func (x *RunOverview) Reset() { *x = RunOverview{} - mi := &file_agentcompose_v2_agentcompose_proto_msgTypes[162] + mi := &file_agentcompose_v2_agentcompose_proto_msgTypes[168] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -12987,7 +13395,7 @@ func (x *RunOverview) String() string { func (*RunOverview) ProtoMessage() {} func (x *RunOverview) ProtoReflect() protoreflect.Message { - mi := &file_agentcompose_v2_agentcompose_proto_msgTypes[162] + mi := &file_agentcompose_v2_agentcompose_proto_msgTypes[168] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -13000,7 +13408,7 @@ func (x *RunOverview) ProtoReflect() protoreflect.Message { // Deprecated: Use RunOverview.ProtoReflect.Descriptor instead. func (*RunOverview) Descriptor() ([]byte, []int) { - return file_agentcompose_v2_agentcompose_proto_rawDescGZIP(), []int{162} + return file_agentcompose_v2_agentcompose_proto_rawDescGZIP(), []int{168} } func (x *RunOverview) GetRunningCount() uint32 { @@ -13034,7 +13442,7 @@ type DashboardOverview struct { func (x *DashboardOverview) Reset() { *x = DashboardOverview{} - mi := &file_agentcompose_v2_agentcompose_proto_msgTypes[163] + mi := &file_agentcompose_v2_agentcompose_proto_msgTypes[169] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -13046,7 +13454,7 @@ func (x *DashboardOverview) String() string { func (*DashboardOverview) ProtoMessage() {} func (x *DashboardOverview) ProtoReflect() protoreflect.Message { - mi := &file_agentcompose_v2_agentcompose_proto_msgTypes[163] + mi := &file_agentcompose_v2_agentcompose_proto_msgTypes[169] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -13059,7 +13467,7 @@ func (x *DashboardOverview) ProtoReflect() protoreflect.Message { // Deprecated: Use DashboardOverview.ProtoReflect.Descriptor instead. func (*DashboardOverview) Descriptor() ([]byte, []int) { - return file_agentcompose_v2_agentcompose_proto_rawDescGZIP(), []int{163} + return file_agentcompose_v2_agentcompose_proto_rawDescGZIP(), []int{169} } func (x *DashboardOverview) GetRuns() *RunOverview { @@ -13085,7 +13493,7 @@ type GetDashboardOverviewResponse struct { func (x *GetDashboardOverviewResponse) Reset() { *x = GetDashboardOverviewResponse{} - mi := &file_agentcompose_v2_agentcompose_proto_msgTypes[164] + mi := &file_agentcompose_v2_agentcompose_proto_msgTypes[170] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -13097,7 +13505,7 @@ func (x *GetDashboardOverviewResponse) String() string { func (*GetDashboardOverviewResponse) ProtoMessage() {} func (x *GetDashboardOverviewResponse) ProtoReflect() protoreflect.Message { - mi := &file_agentcompose_v2_agentcompose_proto_msgTypes[164] + mi := &file_agentcompose_v2_agentcompose_proto_msgTypes[170] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -13110,7 +13518,7 @@ func (x *GetDashboardOverviewResponse) ProtoReflect() protoreflect.Message { // Deprecated: Use GetDashboardOverviewResponse.ProtoReflect.Descriptor instead. func (*GetDashboardOverviewResponse) Descriptor() ([]byte, []int) { - return file_agentcompose_v2_agentcompose_proto_rawDescGZIP(), []int{164} + return file_agentcompose_v2_agentcompose_proto_rawDescGZIP(), []int{170} } func (x *GetDashboardOverviewResponse) GetOverview() *DashboardOverview { @@ -13130,7 +13538,7 @@ type WatchDashboardOverviewResponse struct { func (x *WatchDashboardOverviewResponse) Reset() { *x = WatchDashboardOverviewResponse{} - mi := &file_agentcompose_v2_agentcompose_proto_msgTypes[165] + mi := &file_agentcompose_v2_agentcompose_proto_msgTypes[171] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -13142,7 +13550,7 @@ func (x *WatchDashboardOverviewResponse) String() string { func (*WatchDashboardOverviewResponse) ProtoMessage() {} func (x *WatchDashboardOverviewResponse) ProtoReflect() protoreflect.Message { - mi := &file_agentcompose_v2_agentcompose_proto_msgTypes[165] + mi := &file_agentcompose_v2_agentcompose_proto_msgTypes[171] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -13155,7 +13563,7 @@ func (x *WatchDashboardOverviewResponse) ProtoReflect() protoreflect.Message { // Deprecated: Use WatchDashboardOverviewResponse.ProtoReflect.Descriptor instead. func (*WatchDashboardOverviewResponse) Descriptor() ([]byte, []int) { - return file_agentcompose_v2_agentcompose_proto_rawDescGZIP(), []int{165} + return file_agentcompose_v2_agentcompose_proto_rawDescGZIP(), []int{171} } func (x *WatchDashboardOverviewResponse) GetOverview() *DashboardOverview { @@ -13180,7 +13588,7 @@ type GetGlobalEnvRequest struct { func (x *GetGlobalEnvRequest) Reset() { *x = GetGlobalEnvRequest{} - mi := &file_agentcompose_v2_agentcompose_proto_msgTypes[166] + mi := &file_agentcompose_v2_agentcompose_proto_msgTypes[172] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -13192,7 +13600,7 @@ func (x *GetGlobalEnvRequest) String() string { func (*GetGlobalEnvRequest) ProtoMessage() {} func (x *GetGlobalEnvRequest) ProtoReflect() protoreflect.Message { - mi := &file_agentcompose_v2_agentcompose_proto_msgTypes[166] + mi := &file_agentcompose_v2_agentcompose_proto_msgTypes[172] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -13205,7 +13613,7 @@ func (x *GetGlobalEnvRequest) ProtoReflect() protoreflect.Message { // Deprecated: Use GetGlobalEnvRequest.ProtoReflect.Descriptor instead. func (*GetGlobalEnvRequest) Descriptor() ([]byte, []int) { - return file_agentcompose_v2_agentcompose_proto_rawDescGZIP(), []int{166} + return file_agentcompose_v2_agentcompose_proto_rawDescGZIP(), []int{172} } type GetGlobalEnvResponse struct { @@ -13217,7 +13625,7 @@ type GetGlobalEnvResponse struct { func (x *GetGlobalEnvResponse) Reset() { *x = GetGlobalEnvResponse{} - mi := &file_agentcompose_v2_agentcompose_proto_msgTypes[167] + mi := &file_agentcompose_v2_agentcompose_proto_msgTypes[173] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -13229,7 +13637,7 @@ func (x *GetGlobalEnvResponse) String() string { func (*GetGlobalEnvResponse) ProtoMessage() {} func (x *GetGlobalEnvResponse) ProtoReflect() protoreflect.Message { - mi := &file_agentcompose_v2_agentcompose_proto_msgTypes[167] + mi := &file_agentcompose_v2_agentcompose_proto_msgTypes[173] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -13242,7 +13650,7 @@ func (x *GetGlobalEnvResponse) ProtoReflect() protoreflect.Message { // Deprecated: Use GetGlobalEnvResponse.ProtoReflect.Descriptor instead. func (*GetGlobalEnvResponse) Descriptor() ([]byte, []int) { - return file_agentcompose_v2_agentcompose_proto_rawDescGZIP(), []int{167} + return file_agentcompose_v2_agentcompose_proto_rawDescGZIP(), []int{173} } func (x *GetGlobalEnvResponse) GetEnv() []*EnvVarSpec { @@ -13261,7 +13669,7 @@ type UpdateGlobalEnvRequest struct { func (x *UpdateGlobalEnvRequest) Reset() { *x = UpdateGlobalEnvRequest{} - mi := &file_agentcompose_v2_agentcompose_proto_msgTypes[168] + mi := &file_agentcompose_v2_agentcompose_proto_msgTypes[174] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -13273,7 +13681,7 @@ func (x *UpdateGlobalEnvRequest) String() string { func (*UpdateGlobalEnvRequest) ProtoMessage() {} func (x *UpdateGlobalEnvRequest) ProtoReflect() protoreflect.Message { - mi := &file_agentcompose_v2_agentcompose_proto_msgTypes[168] + mi := &file_agentcompose_v2_agentcompose_proto_msgTypes[174] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -13286,7 +13694,7 @@ func (x *UpdateGlobalEnvRequest) ProtoReflect() protoreflect.Message { // Deprecated: Use UpdateGlobalEnvRequest.ProtoReflect.Descriptor instead. func (*UpdateGlobalEnvRequest) Descriptor() ([]byte, []int) { - return file_agentcompose_v2_agentcompose_proto_rawDescGZIP(), []int{168} + return file_agentcompose_v2_agentcompose_proto_rawDescGZIP(), []int{174} } func (x *UpdateGlobalEnvRequest) GetEnv() []*EnvVarUpdateSpec { @@ -13305,7 +13713,7 @@ type UpdateGlobalEnvResponse struct { func (x *UpdateGlobalEnvResponse) Reset() { *x = UpdateGlobalEnvResponse{} - mi := &file_agentcompose_v2_agentcompose_proto_msgTypes[169] + mi := &file_agentcompose_v2_agentcompose_proto_msgTypes[175] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -13317,7 +13725,7 @@ func (x *UpdateGlobalEnvResponse) String() string { func (*UpdateGlobalEnvResponse) ProtoMessage() {} func (x *UpdateGlobalEnvResponse) ProtoReflect() protoreflect.Message { - mi := &file_agentcompose_v2_agentcompose_proto_msgTypes[169] + mi := &file_agentcompose_v2_agentcompose_proto_msgTypes[175] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -13330,7 +13738,7 @@ func (x *UpdateGlobalEnvResponse) ProtoReflect() protoreflect.Message { // Deprecated: Use UpdateGlobalEnvResponse.ProtoReflect.Descriptor instead. func (*UpdateGlobalEnvResponse) Descriptor() ([]byte, []int) { - return file_agentcompose_v2_agentcompose_proto_rawDescGZIP(), []int{169} + return file_agentcompose_v2_agentcompose_proto_rawDescGZIP(), []int{175} } func (x *UpdateGlobalEnvResponse) GetEnv() []*EnvVarSpec { @@ -13348,7 +13756,7 @@ type GetCapabilityGatewayConfigRequest struct { func (x *GetCapabilityGatewayConfigRequest) Reset() { *x = GetCapabilityGatewayConfigRequest{} - mi := &file_agentcompose_v2_agentcompose_proto_msgTypes[170] + mi := &file_agentcompose_v2_agentcompose_proto_msgTypes[176] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -13360,7 +13768,7 @@ func (x *GetCapabilityGatewayConfigRequest) String() string { func (*GetCapabilityGatewayConfigRequest) ProtoMessage() {} func (x *GetCapabilityGatewayConfigRequest) ProtoReflect() protoreflect.Message { - mi := &file_agentcompose_v2_agentcompose_proto_msgTypes[170] + mi := &file_agentcompose_v2_agentcompose_proto_msgTypes[176] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -13373,7 +13781,7 @@ func (x *GetCapabilityGatewayConfigRequest) ProtoReflect() protoreflect.Message // Deprecated: Use GetCapabilityGatewayConfigRequest.ProtoReflect.Descriptor instead. func (*GetCapabilityGatewayConfigRequest) Descriptor() ([]byte, []int) { - return file_agentcompose_v2_agentcompose_proto_rawDescGZIP(), []int{170} + return file_agentcompose_v2_agentcompose_proto_rawDescGZIP(), []int{176} } type CapabilityGatewayConfig struct { @@ -13386,7 +13794,7 @@ type CapabilityGatewayConfig struct { func (x *CapabilityGatewayConfig) Reset() { *x = CapabilityGatewayConfig{} - mi := &file_agentcompose_v2_agentcompose_proto_msgTypes[171] + mi := &file_agentcompose_v2_agentcompose_proto_msgTypes[177] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -13398,7 +13806,7 @@ func (x *CapabilityGatewayConfig) String() string { func (*CapabilityGatewayConfig) ProtoMessage() {} func (x *CapabilityGatewayConfig) ProtoReflect() protoreflect.Message { - mi := &file_agentcompose_v2_agentcompose_proto_msgTypes[171] + mi := &file_agentcompose_v2_agentcompose_proto_msgTypes[177] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -13411,7 +13819,7 @@ func (x *CapabilityGatewayConfig) ProtoReflect() protoreflect.Message { // Deprecated: Use CapabilityGatewayConfig.ProtoReflect.Descriptor instead. func (*CapabilityGatewayConfig) Descriptor() ([]byte, []int) { - return file_agentcompose_v2_agentcompose_proto_rawDescGZIP(), []int{171} + return file_agentcompose_v2_agentcompose_proto_rawDescGZIP(), []int{177} } func (x *CapabilityGatewayConfig) GetAddr() string { @@ -13437,7 +13845,7 @@ type GetCapabilityGatewayConfigResponse struct { func (x *GetCapabilityGatewayConfigResponse) Reset() { *x = GetCapabilityGatewayConfigResponse{} - mi := &file_agentcompose_v2_agentcompose_proto_msgTypes[172] + mi := &file_agentcompose_v2_agentcompose_proto_msgTypes[178] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -13449,7 +13857,7 @@ func (x *GetCapabilityGatewayConfigResponse) String() string { func (*GetCapabilityGatewayConfigResponse) ProtoMessage() {} func (x *GetCapabilityGatewayConfigResponse) ProtoReflect() protoreflect.Message { - mi := &file_agentcompose_v2_agentcompose_proto_msgTypes[172] + mi := &file_agentcompose_v2_agentcompose_proto_msgTypes[178] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -13462,7 +13870,7 @@ func (x *GetCapabilityGatewayConfigResponse) ProtoReflect() protoreflect.Message // Deprecated: Use GetCapabilityGatewayConfigResponse.ProtoReflect.Descriptor instead. func (*GetCapabilityGatewayConfigResponse) Descriptor() ([]byte, []int) { - return file_agentcompose_v2_agentcompose_proto_rawDescGZIP(), []int{172} + return file_agentcompose_v2_agentcompose_proto_rawDescGZIP(), []int{178} } func (x *GetCapabilityGatewayConfigResponse) GetConfig() *CapabilityGatewayConfig { @@ -13482,7 +13890,7 @@ type UpdateCapabilityGatewayConfigRequest struct { func (x *UpdateCapabilityGatewayConfigRequest) Reset() { *x = UpdateCapabilityGatewayConfigRequest{} - mi := &file_agentcompose_v2_agentcompose_proto_msgTypes[173] + mi := &file_agentcompose_v2_agentcompose_proto_msgTypes[179] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -13494,7 +13902,7 @@ func (x *UpdateCapabilityGatewayConfigRequest) String() string { func (*UpdateCapabilityGatewayConfigRequest) ProtoMessage() {} func (x *UpdateCapabilityGatewayConfigRequest) ProtoReflect() protoreflect.Message { - mi := &file_agentcompose_v2_agentcompose_proto_msgTypes[173] + mi := &file_agentcompose_v2_agentcompose_proto_msgTypes[179] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -13507,7 +13915,7 @@ func (x *UpdateCapabilityGatewayConfigRequest) ProtoReflect() protoreflect.Messa // Deprecated: Use UpdateCapabilityGatewayConfigRequest.ProtoReflect.Descriptor instead. func (*UpdateCapabilityGatewayConfigRequest) Descriptor() ([]byte, []int) { - return file_agentcompose_v2_agentcompose_proto_rawDescGZIP(), []int{173} + return file_agentcompose_v2_agentcompose_proto_rawDescGZIP(), []int{179} } func (x *UpdateCapabilityGatewayConfigRequest) GetAddr() string { @@ -13533,7 +13941,7 @@ type UpdateCapabilityGatewayConfigResponse struct { func (x *UpdateCapabilityGatewayConfigResponse) Reset() { *x = UpdateCapabilityGatewayConfigResponse{} - mi := &file_agentcompose_v2_agentcompose_proto_msgTypes[174] + mi := &file_agentcompose_v2_agentcompose_proto_msgTypes[180] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -13545,7 +13953,7 @@ func (x *UpdateCapabilityGatewayConfigResponse) String() string { func (*UpdateCapabilityGatewayConfigResponse) ProtoMessage() {} func (x *UpdateCapabilityGatewayConfigResponse) ProtoReflect() protoreflect.Message { - mi := &file_agentcompose_v2_agentcompose_proto_msgTypes[174] + mi := &file_agentcompose_v2_agentcompose_proto_msgTypes[180] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -13558,7 +13966,7 @@ func (x *UpdateCapabilityGatewayConfigResponse) ProtoReflect() protoreflect.Mess // Deprecated: Use UpdateCapabilityGatewayConfigResponse.ProtoReflect.Descriptor instead. func (*UpdateCapabilityGatewayConfigResponse) Descriptor() ([]byte, []int) { - return file_agentcompose_v2_agentcompose_proto_rawDescGZIP(), []int{174} + return file_agentcompose_v2_agentcompose_proto_rawDescGZIP(), []int{180} } func (x *UpdateCapabilityGatewayConfigResponse) GetConfig() *CapabilityGatewayConfig { @@ -13583,7 +13991,7 @@ type WorkspacePreset struct { func (x *WorkspacePreset) Reset() { *x = WorkspacePreset{} - mi := &file_agentcompose_v2_agentcompose_proto_msgTypes[175] + mi := &file_agentcompose_v2_agentcompose_proto_msgTypes[181] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -13595,7 +14003,7 @@ func (x *WorkspacePreset) String() string { func (*WorkspacePreset) ProtoMessage() {} func (x *WorkspacePreset) ProtoReflect() protoreflect.Message { - mi := &file_agentcompose_v2_agentcompose_proto_msgTypes[175] + mi := &file_agentcompose_v2_agentcompose_proto_msgTypes[181] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -13608,7 +14016,7 @@ func (x *WorkspacePreset) ProtoReflect() protoreflect.Message { // Deprecated: Use WorkspacePreset.ProtoReflect.Descriptor instead. func (*WorkspacePreset) Descriptor() ([]byte, []int) { - return file_agentcompose_v2_agentcompose_proto_rawDescGZIP(), []int{175} + return file_agentcompose_v2_agentcompose_proto_rawDescGZIP(), []int{181} } func (x *WorkspacePreset) GetId() string { @@ -13668,7 +14076,7 @@ type ListWorkspacePresetsRequest struct { func (x *ListWorkspacePresetsRequest) Reset() { *x = ListWorkspacePresetsRequest{} - mi := &file_agentcompose_v2_agentcompose_proto_msgTypes[176] + mi := &file_agentcompose_v2_agentcompose_proto_msgTypes[182] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -13680,7 +14088,7 @@ func (x *ListWorkspacePresetsRequest) String() string { func (*ListWorkspacePresetsRequest) ProtoMessage() {} func (x *ListWorkspacePresetsRequest) ProtoReflect() protoreflect.Message { - mi := &file_agentcompose_v2_agentcompose_proto_msgTypes[176] + mi := &file_agentcompose_v2_agentcompose_proto_msgTypes[182] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -13693,7 +14101,7 @@ func (x *ListWorkspacePresetsRequest) ProtoReflect() protoreflect.Message { // Deprecated: Use ListWorkspacePresetsRequest.ProtoReflect.Descriptor instead. func (*ListWorkspacePresetsRequest) Descriptor() ([]byte, []int) { - return file_agentcompose_v2_agentcompose_proto_rawDescGZIP(), []int{176} + return file_agentcompose_v2_agentcompose_proto_rawDescGZIP(), []int{182} } type ListWorkspacePresetsResponse struct { @@ -13705,7 +14113,7 @@ type ListWorkspacePresetsResponse struct { func (x *ListWorkspacePresetsResponse) Reset() { *x = ListWorkspacePresetsResponse{} - mi := &file_agentcompose_v2_agentcompose_proto_msgTypes[177] + mi := &file_agentcompose_v2_agentcompose_proto_msgTypes[183] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -13717,7 +14125,7 @@ func (x *ListWorkspacePresetsResponse) String() string { func (*ListWorkspacePresetsResponse) ProtoMessage() {} func (x *ListWorkspacePresetsResponse) ProtoReflect() protoreflect.Message { - mi := &file_agentcompose_v2_agentcompose_proto_msgTypes[177] + mi := &file_agentcompose_v2_agentcompose_proto_msgTypes[183] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -13730,7 +14138,7 @@ func (x *ListWorkspacePresetsResponse) ProtoReflect() protoreflect.Message { // Deprecated: Use ListWorkspacePresetsResponse.ProtoReflect.Descriptor instead. func (*ListWorkspacePresetsResponse) Descriptor() ([]byte, []int) { - return file_agentcompose_v2_agentcompose_proto_rawDescGZIP(), []int{177} + return file_agentcompose_v2_agentcompose_proto_rawDescGZIP(), []int{183} } func (x *ListWorkspacePresetsResponse) GetPresets() []*WorkspacePreset { @@ -13752,7 +14160,7 @@ type CreateWorkspacePresetRequest struct { func (x *CreateWorkspacePresetRequest) Reset() { *x = CreateWorkspacePresetRequest{} - mi := &file_agentcompose_v2_agentcompose_proto_msgTypes[178] + mi := &file_agentcompose_v2_agentcompose_proto_msgTypes[184] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -13764,7 +14172,7 @@ func (x *CreateWorkspacePresetRequest) String() string { func (*CreateWorkspacePresetRequest) ProtoMessage() {} func (x *CreateWorkspacePresetRequest) ProtoReflect() protoreflect.Message { - mi := &file_agentcompose_v2_agentcompose_proto_msgTypes[178] + mi := &file_agentcompose_v2_agentcompose_proto_msgTypes[184] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -13777,7 +14185,7 @@ func (x *CreateWorkspacePresetRequest) ProtoReflect() protoreflect.Message { // Deprecated: Use CreateWorkspacePresetRequest.ProtoReflect.Descriptor instead. func (*CreateWorkspacePresetRequest) Descriptor() ([]byte, []int) { - return file_agentcompose_v2_agentcompose_proto_rawDescGZIP(), []int{178} + return file_agentcompose_v2_agentcompose_proto_rawDescGZIP(), []int{184} } func (x *CreateWorkspacePresetRequest) GetName() string { @@ -13821,7 +14229,7 @@ type UpdateWorkspacePresetRequest struct { func (x *UpdateWorkspacePresetRequest) Reset() { *x = UpdateWorkspacePresetRequest{} - mi := &file_agentcompose_v2_agentcompose_proto_msgTypes[179] + mi := &file_agentcompose_v2_agentcompose_proto_msgTypes[185] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -13833,7 +14241,7 @@ func (x *UpdateWorkspacePresetRequest) String() string { func (*UpdateWorkspacePresetRequest) ProtoMessage() {} func (x *UpdateWorkspacePresetRequest) ProtoReflect() protoreflect.Message { - mi := &file_agentcompose_v2_agentcompose_proto_msgTypes[179] + mi := &file_agentcompose_v2_agentcompose_proto_msgTypes[185] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -13846,7 +14254,7 @@ func (x *UpdateWorkspacePresetRequest) ProtoReflect() protoreflect.Message { // Deprecated: Use UpdateWorkspacePresetRequest.ProtoReflect.Descriptor instead. func (*UpdateWorkspacePresetRequest) Descriptor() ([]byte, []int) { - return file_agentcompose_v2_agentcompose_proto_rawDescGZIP(), []int{179} + return file_agentcompose_v2_agentcompose_proto_rawDescGZIP(), []int{185} } func (x *UpdateWorkspacePresetRequest) GetPresetId() string { @@ -13893,7 +14301,7 @@ type DeleteWorkspacePresetRequest struct { func (x *DeleteWorkspacePresetRequest) Reset() { *x = DeleteWorkspacePresetRequest{} - mi := &file_agentcompose_v2_agentcompose_proto_msgTypes[180] + mi := &file_agentcompose_v2_agentcompose_proto_msgTypes[186] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -13905,7 +14313,7 @@ func (x *DeleteWorkspacePresetRequest) String() string { func (*DeleteWorkspacePresetRequest) ProtoMessage() {} func (x *DeleteWorkspacePresetRequest) ProtoReflect() protoreflect.Message { - mi := &file_agentcompose_v2_agentcompose_proto_msgTypes[180] + mi := &file_agentcompose_v2_agentcompose_proto_msgTypes[186] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -13918,7 +14326,7 @@ func (x *DeleteWorkspacePresetRequest) ProtoReflect() protoreflect.Message { // Deprecated: Use DeleteWorkspacePresetRequest.ProtoReflect.Descriptor instead. func (*DeleteWorkspacePresetRequest) Descriptor() ([]byte, []int) { - return file_agentcompose_v2_agentcompose_proto_rawDescGZIP(), []int{180} + return file_agentcompose_v2_agentcompose_proto_rawDescGZIP(), []int{186} } func (x *DeleteWorkspacePresetRequest) GetPresetId() string { @@ -13936,7 +14344,7 @@ type DeleteWorkspacePresetResponse struct { func (x *DeleteWorkspacePresetResponse) Reset() { *x = DeleteWorkspacePresetResponse{} - mi := &file_agentcompose_v2_agentcompose_proto_msgTypes[181] + mi := &file_agentcompose_v2_agentcompose_proto_msgTypes[187] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -13948,7 +14356,7 @@ func (x *DeleteWorkspacePresetResponse) String() string { func (*DeleteWorkspacePresetResponse) ProtoMessage() {} func (x *DeleteWorkspacePresetResponse) ProtoReflect() protoreflect.Message { - mi := &file_agentcompose_v2_agentcompose_proto_msgTypes[181] + mi := &file_agentcompose_v2_agentcompose_proto_msgTypes[187] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -13961,7 +14369,7 @@ func (x *DeleteWorkspacePresetResponse) ProtoReflect() protoreflect.Message { // Deprecated: Use DeleteWorkspacePresetResponse.ProtoReflect.Descriptor instead. func (*DeleteWorkspacePresetResponse) Descriptor() ([]byte, []int) { - return file_agentcompose_v2_agentcompose_proto_rawDescGZIP(), []int{181} + return file_agentcompose_v2_agentcompose_proto_rawDescGZIP(), []int{187} } type WorkspacePresetResponse struct { @@ -13973,7 +14381,7 @@ type WorkspacePresetResponse struct { func (x *WorkspacePresetResponse) Reset() { *x = WorkspacePresetResponse{} - mi := &file_agentcompose_v2_agentcompose_proto_msgTypes[182] + mi := &file_agentcompose_v2_agentcompose_proto_msgTypes[188] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -13985,7 +14393,7 @@ func (x *WorkspacePresetResponse) String() string { func (*WorkspacePresetResponse) ProtoMessage() {} func (x *WorkspacePresetResponse) ProtoReflect() protoreflect.Message { - mi := &file_agentcompose_v2_agentcompose_proto_msgTypes[182] + mi := &file_agentcompose_v2_agentcompose_proto_msgTypes[188] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -13998,7 +14406,7 @@ func (x *WorkspacePresetResponse) ProtoReflect() protoreflect.Message { // Deprecated: Use WorkspacePresetResponse.ProtoReflect.Descriptor instead. func (*WorkspacePresetResponse) Descriptor() ([]byte, []int) { - return file_agentcompose_v2_agentcompose_proto_rawDescGZIP(), []int{182} + return file_agentcompose_v2_agentcompose_proto_rawDescGZIP(), []int{188} } func (x *WorkspacePresetResponse) GetPreset() *WorkspacePreset { @@ -14016,7 +14424,7 @@ type GetCapabilityStatusRequest struct { func (x *GetCapabilityStatusRequest) Reset() { *x = GetCapabilityStatusRequest{} - mi := &file_agentcompose_v2_agentcompose_proto_msgTypes[183] + mi := &file_agentcompose_v2_agentcompose_proto_msgTypes[189] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -14028,7 +14436,7 @@ func (x *GetCapabilityStatusRequest) String() string { func (*GetCapabilityStatusRequest) ProtoMessage() {} func (x *GetCapabilityStatusRequest) ProtoReflect() protoreflect.Message { - mi := &file_agentcompose_v2_agentcompose_proto_msgTypes[183] + mi := &file_agentcompose_v2_agentcompose_proto_msgTypes[189] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -14041,7 +14449,7 @@ func (x *GetCapabilityStatusRequest) ProtoReflect() protoreflect.Message { // Deprecated: Use GetCapabilityStatusRequest.ProtoReflect.Descriptor instead. func (*GetCapabilityStatusRequest) Descriptor() ([]byte, []int) { - return file_agentcompose_v2_agentcompose_proto_rawDescGZIP(), []int{183} + return file_agentcompose_v2_agentcompose_proto_rawDescGZIP(), []int{189} } type CapabilityStatusResponse struct { @@ -14060,7 +14468,7 @@ type CapabilityStatusResponse struct { func (x *CapabilityStatusResponse) Reset() { *x = CapabilityStatusResponse{} - mi := &file_agentcompose_v2_agentcompose_proto_msgTypes[184] + mi := &file_agentcompose_v2_agentcompose_proto_msgTypes[190] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -14072,7 +14480,7 @@ func (x *CapabilityStatusResponse) String() string { func (*CapabilityStatusResponse) ProtoMessage() {} func (x *CapabilityStatusResponse) ProtoReflect() protoreflect.Message { - mi := &file_agentcompose_v2_agentcompose_proto_msgTypes[184] + mi := &file_agentcompose_v2_agentcompose_proto_msgTypes[190] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -14085,7 +14493,7 @@ func (x *CapabilityStatusResponse) ProtoReflect() protoreflect.Message { // Deprecated: Use CapabilityStatusResponse.ProtoReflect.Descriptor instead. func (*CapabilityStatusResponse) Descriptor() ([]byte, []int) { - return file_agentcompose_v2_agentcompose_proto_rawDescGZIP(), []int{184} + return file_agentcompose_v2_agentcompose_proto_rawDescGZIP(), []int{190} } func (x *CapabilityStatusResponse) GetConfigured() bool { @@ -14152,7 +14560,7 @@ type ListCapabilitySetsRequest struct { func (x *ListCapabilitySetsRequest) Reset() { *x = ListCapabilitySetsRequest{} - mi := &file_agentcompose_v2_agentcompose_proto_msgTypes[185] + mi := &file_agentcompose_v2_agentcompose_proto_msgTypes[191] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -14164,7 +14572,7 @@ func (x *ListCapabilitySetsRequest) String() string { func (*ListCapabilitySetsRequest) ProtoMessage() {} func (x *ListCapabilitySetsRequest) ProtoReflect() protoreflect.Message { - mi := &file_agentcompose_v2_agentcompose_proto_msgTypes[185] + mi := &file_agentcompose_v2_agentcompose_proto_msgTypes[191] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -14177,7 +14585,7 @@ func (x *ListCapabilitySetsRequest) ProtoReflect() protoreflect.Message { // Deprecated: Use ListCapabilitySetsRequest.ProtoReflect.Descriptor instead. func (*ListCapabilitySetsRequest) Descriptor() ([]byte, []int) { - return file_agentcompose_v2_agentcompose_proto_rawDescGZIP(), []int{185} + return file_agentcompose_v2_agentcompose_proto_rawDescGZIP(), []int{191} } type CapabilitySet struct { @@ -14192,7 +14600,7 @@ type CapabilitySet struct { func (x *CapabilitySet) Reset() { *x = CapabilitySet{} - mi := &file_agentcompose_v2_agentcompose_proto_msgTypes[186] + mi := &file_agentcompose_v2_agentcompose_proto_msgTypes[192] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -14204,7 +14612,7 @@ func (x *CapabilitySet) String() string { func (*CapabilitySet) ProtoMessage() {} func (x *CapabilitySet) ProtoReflect() protoreflect.Message { - mi := &file_agentcompose_v2_agentcompose_proto_msgTypes[186] + mi := &file_agentcompose_v2_agentcompose_proto_msgTypes[192] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -14217,7 +14625,7 @@ func (x *CapabilitySet) ProtoReflect() protoreflect.Message { // Deprecated: Use CapabilitySet.ProtoReflect.Descriptor instead. func (*CapabilitySet) Descriptor() ([]byte, []int) { - return file_agentcompose_v2_agentcompose_proto_rawDescGZIP(), []int{186} + return file_agentcompose_v2_agentcompose_proto_rawDescGZIP(), []int{192} } func (x *CapabilitySet) GetId() string { @@ -14257,7 +14665,7 @@ type ListCapabilitySetsResponse struct { func (x *ListCapabilitySetsResponse) Reset() { *x = ListCapabilitySetsResponse{} - mi := &file_agentcompose_v2_agentcompose_proto_msgTypes[187] + mi := &file_agentcompose_v2_agentcompose_proto_msgTypes[193] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -14269,7 +14677,7 @@ func (x *ListCapabilitySetsResponse) String() string { func (*ListCapabilitySetsResponse) ProtoMessage() {} func (x *ListCapabilitySetsResponse) ProtoReflect() protoreflect.Message { - mi := &file_agentcompose_v2_agentcompose_proto_msgTypes[187] + mi := &file_agentcompose_v2_agentcompose_proto_msgTypes[193] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -14282,7 +14690,7 @@ func (x *ListCapabilitySetsResponse) ProtoReflect() protoreflect.Message { // Deprecated: Use ListCapabilitySetsResponse.ProtoReflect.Descriptor instead. func (*ListCapabilitySetsResponse) Descriptor() ([]byte, []int) { - return file_agentcompose_v2_agentcompose_proto_rawDescGZIP(), []int{187} + return file_agentcompose_v2_agentcompose_proto_rawDescGZIP(), []int{193} } func (x *ListCapabilitySetsResponse) GetCapsets() []*CapabilitySet { @@ -14301,7 +14709,7 @@ type GetCapabilityCatalogRequest struct { func (x *GetCapabilityCatalogRequest) Reset() { *x = GetCapabilityCatalogRequest{} - mi := &file_agentcompose_v2_agentcompose_proto_msgTypes[188] + mi := &file_agentcompose_v2_agentcompose_proto_msgTypes[194] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -14313,7 +14721,7 @@ func (x *GetCapabilityCatalogRequest) String() string { func (*GetCapabilityCatalogRequest) ProtoMessage() {} func (x *GetCapabilityCatalogRequest) ProtoReflect() protoreflect.Message { - mi := &file_agentcompose_v2_agentcompose_proto_msgTypes[188] + mi := &file_agentcompose_v2_agentcompose_proto_msgTypes[194] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -14326,7 +14734,7 @@ func (x *GetCapabilityCatalogRequest) ProtoReflect() protoreflect.Message { // Deprecated: Use GetCapabilityCatalogRequest.ProtoReflect.Descriptor instead. func (*GetCapabilityCatalogRequest) Descriptor() ([]byte, []int) { - return file_agentcompose_v2_agentcompose_proto_rawDescGZIP(), []int{188} + return file_agentcompose_v2_agentcompose_proto_rawDescGZIP(), []int{194} } func (x *GetCapabilityCatalogRequest) GetCapsetId() string { @@ -14352,7 +14760,7 @@ type CapabilityEndpoint struct { func (x *CapabilityEndpoint) Reset() { *x = CapabilityEndpoint{} - mi := &file_agentcompose_v2_agentcompose_proto_msgTypes[189] + mi := &file_agentcompose_v2_agentcompose_proto_msgTypes[195] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -14364,7 +14772,7 @@ func (x *CapabilityEndpoint) String() string { func (*CapabilityEndpoint) ProtoMessage() {} func (x *CapabilityEndpoint) ProtoReflect() protoreflect.Message { - mi := &file_agentcompose_v2_agentcompose_proto_msgTypes[189] + mi := &file_agentcompose_v2_agentcompose_proto_msgTypes[195] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -14377,7 +14785,7 @@ func (x *CapabilityEndpoint) ProtoReflect() protoreflect.Message { // Deprecated: Use CapabilityEndpoint.ProtoReflect.Descriptor instead. func (*CapabilityEndpoint) Descriptor() ([]byte, []int) { - return file_agentcompose_v2_agentcompose_proto_rawDescGZIP(), []int{189} + return file_agentcompose_v2_agentcompose_proto_rawDescGZIP(), []int{195} } func (x *CapabilityEndpoint) GetProtocol() string { @@ -14452,7 +14860,7 @@ type CapabilityMethod struct { func (x *CapabilityMethod) Reset() { *x = CapabilityMethod{} - mi := &file_agentcompose_v2_agentcompose_proto_msgTypes[190] + mi := &file_agentcompose_v2_agentcompose_proto_msgTypes[196] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -14464,7 +14872,7 @@ func (x *CapabilityMethod) String() string { func (*CapabilityMethod) ProtoMessage() {} func (x *CapabilityMethod) ProtoReflect() protoreflect.Message { - mi := &file_agentcompose_v2_agentcompose_proto_msgTypes[190] + mi := &file_agentcompose_v2_agentcompose_proto_msgTypes[196] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -14477,7 +14885,7 @@ func (x *CapabilityMethod) ProtoReflect() protoreflect.Message { // Deprecated: Use CapabilityMethod.ProtoReflect.Descriptor instead. func (*CapabilityMethod) Descriptor() ([]byte, []int) { - return file_agentcompose_v2_agentcompose_proto_rawDescGZIP(), []int{190} + return file_agentcompose_v2_agentcompose_proto_rawDescGZIP(), []int{196} } func (x *CapabilityMethod) GetServiceId() string { @@ -14548,7 +14956,7 @@ type GetCapabilityCatalogResponse struct { func (x *GetCapabilityCatalogResponse) Reset() { *x = GetCapabilityCatalogResponse{} - mi := &file_agentcompose_v2_agentcompose_proto_msgTypes[191] + mi := &file_agentcompose_v2_agentcompose_proto_msgTypes[197] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -14560,7 +14968,7 @@ func (x *GetCapabilityCatalogResponse) String() string { func (*GetCapabilityCatalogResponse) ProtoMessage() {} func (x *GetCapabilityCatalogResponse) ProtoReflect() protoreflect.Message { - mi := &file_agentcompose_v2_agentcompose_proto_msgTypes[191] + mi := &file_agentcompose_v2_agentcompose_proto_msgTypes[197] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -14573,7 +14981,7 @@ func (x *GetCapabilityCatalogResponse) ProtoReflect() protoreflect.Message { // Deprecated: Use GetCapabilityCatalogResponse.ProtoReflect.Descriptor instead. func (*GetCapabilityCatalogResponse) Descriptor() ([]byte, []int) { - return file_agentcompose_v2_agentcompose_proto_rawDescGZIP(), []int{191} + return file_agentcompose_v2_agentcompose_proto_rawDescGZIP(), []int{197} } func (x *GetCapabilityCatalogResponse) GetCapsetId() string { @@ -14613,7 +15021,7 @@ type ListSandboxHistoryRequest struct { func (x *ListSandboxHistoryRequest) Reset() { *x = ListSandboxHistoryRequest{} - mi := &file_agentcompose_v2_agentcompose_proto_msgTypes[192] + mi := &file_agentcompose_v2_agentcompose_proto_msgTypes[198] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -14625,7 +15033,7 @@ func (x *ListSandboxHistoryRequest) String() string { func (*ListSandboxHistoryRequest) ProtoMessage() {} func (x *ListSandboxHistoryRequest) ProtoReflect() protoreflect.Message { - mi := &file_agentcompose_v2_agentcompose_proto_msgTypes[192] + mi := &file_agentcompose_v2_agentcompose_proto_msgTypes[198] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -14638,7 +15046,7 @@ func (x *ListSandboxHistoryRequest) ProtoReflect() protoreflect.Message { // Deprecated: Use ListSandboxHistoryRequest.ProtoReflect.Descriptor instead. func (*ListSandboxHistoryRequest) Descriptor() ([]byte, []int) { - return file_agentcompose_v2_agentcompose_proto_rawDescGZIP(), []int{192} + return file_agentcompose_v2_agentcompose_proto_rawDescGZIP(), []int{198} } func (x *ListSandboxHistoryRequest) GetSandboxId() string { @@ -14669,7 +15077,7 @@ type SandboxHistoryCell struct { func (x *SandboxHistoryCell) Reset() { *x = SandboxHistoryCell{} - mi := &file_agentcompose_v2_agentcompose_proto_msgTypes[193] + mi := &file_agentcompose_v2_agentcompose_proto_msgTypes[199] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -14681,7 +15089,7 @@ func (x *SandboxHistoryCell) String() string { func (*SandboxHistoryCell) ProtoMessage() {} func (x *SandboxHistoryCell) ProtoReflect() protoreflect.Message { - mi := &file_agentcompose_v2_agentcompose_proto_msgTypes[193] + mi := &file_agentcompose_v2_agentcompose_proto_msgTypes[199] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -14694,7 +15102,7 @@ func (x *SandboxHistoryCell) ProtoReflect() protoreflect.Message { // Deprecated: Use SandboxHistoryCell.ProtoReflect.Descriptor instead. func (*SandboxHistoryCell) Descriptor() ([]byte, []int) { - return file_agentcompose_v2_agentcompose_proto_rawDescGZIP(), []int{193} + return file_agentcompose_v2_agentcompose_proto_rawDescGZIP(), []int{199} } func (x *SandboxHistoryCell) GetId() string { @@ -14801,7 +15209,7 @@ type SandboxHistoryEvent struct { func (x *SandboxHistoryEvent) Reset() { *x = SandboxHistoryEvent{} - mi := &file_agentcompose_v2_agentcompose_proto_msgTypes[194] + mi := &file_agentcompose_v2_agentcompose_proto_msgTypes[200] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -14813,7 +15221,7 @@ func (x *SandboxHistoryEvent) String() string { func (*SandboxHistoryEvent) ProtoMessage() {} func (x *SandboxHistoryEvent) ProtoReflect() protoreflect.Message { - mi := &file_agentcompose_v2_agentcompose_proto_msgTypes[194] + mi := &file_agentcompose_v2_agentcompose_proto_msgTypes[200] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -14826,7 +15234,7 @@ func (x *SandboxHistoryEvent) ProtoReflect() protoreflect.Message { // Deprecated: Use SandboxHistoryEvent.ProtoReflect.Descriptor instead. func (*SandboxHistoryEvent) Descriptor() ([]byte, []int) { - return file_agentcompose_v2_agentcompose_proto_rawDescGZIP(), []int{194} + return file_agentcompose_v2_agentcompose_proto_rawDescGZIP(), []int{200} } func (x *SandboxHistoryEvent) GetId() string { @@ -14875,7 +15283,7 @@ type ListSandboxHistoryResponse struct { func (x *ListSandboxHistoryResponse) Reset() { *x = ListSandboxHistoryResponse{} - mi := &file_agentcompose_v2_agentcompose_proto_msgTypes[195] + mi := &file_agentcompose_v2_agentcompose_proto_msgTypes[201] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -14887,7 +15295,7 @@ func (x *ListSandboxHistoryResponse) String() string { func (*ListSandboxHistoryResponse) ProtoMessage() {} func (x *ListSandboxHistoryResponse) ProtoReflect() protoreflect.Message { - mi := &file_agentcompose_v2_agentcompose_proto_msgTypes[195] + mi := &file_agentcompose_v2_agentcompose_proto_msgTypes[201] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -14900,7 +15308,7 @@ func (x *ListSandboxHistoryResponse) ProtoReflect() protoreflect.Message { // Deprecated: Use ListSandboxHistoryResponse.ProtoReflect.Descriptor instead. func (*ListSandboxHistoryResponse) Descriptor() ([]byte, []int) { - return file_agentcompose_v2_agentcompose_proto_rawDescGZIP(), []int{195} + return file_agentcompose_v2_agentcompose_proto_rawDescGZIP(), []int{201} } func (x *ListSandboxHistoryResponse) GetCells() []*SandboxHistoryCell { @@ -14933,7 +15341,7 @@ type WatchSandboxRequest struct { func (x *WatchSandboxRequest) Reset() { *x = WatchSandboxRequest{} - mi := &file_agentcompose_v2_agentcompose_proto_msgTypes[196] + mi := &file_agentcompose_v2_agentcompose_proto_msgTypes[202] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -14945,7 +15353,7 @@ func (x *WatchSandboxRequest) String() string { func (*WatchSandboxRequest) ProtoMessage() {} func (x *WatchSandboxRequest) ProtoReflect() protoreflect.Message { - mi := &file_agentcompose_v2_agentcompose_proto_msgTypes[196] + mi := &file_agentcompose_v2_agentcompose_proto_msgTypes[202] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -14958,7 +15366,7 @@ func (x *WatchSandboxRequest) ProtoReflect() protoreflect.Message { // Deprecated: Use WatchSandboxRequest.ProtoReflect.Descriptor instead. func (*WatchSandboxRequest) Descriptor() ([]byte, []int) { - return file_agentcompose_v2_agentcompose_proto_rawDescGZIP(), []int{196} + return file_agentcompose_v2_agentcompose_proto_rawDescGZIP(), []int{202} } func (x *WatchSandboxRequest) GetSandboxId() string { @@ -14983,7 +15391,7 @@ type WatchSandboxResponse struct { func (x *WatchSandboxResponse) Reset() { *x = WatchSandboxResponse{} - mi := &file_agentcompose_v2_agentcompose_proto_msgTypes[197] + mi := &file_agentcompose_v2_agentcompose_proto_msgTypes[203] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -14995,7 +15403,7 @@ func (x *WatchSandboxResponse) String() string { func (*WatchSandboxResponse) ProtoMessage() {} func (x *WatchSandboxResponse) ProtoReflect() protoreflect.Message { - mi := &file_agentcompose_v2_agentcompose_proto_msgTypes[197] + mi := &file_agentcompose_v2_agentcompose_proto_msgTypes[203] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -15008,7 +15416,7 @@ func (x *WatchSandboxResponse) ProtoReflect() protoreflect.Message { // Deprecated: Use WatchSandboxResponse.ProtoReflect.Descriptor instead. func (*WatchSandboxResponse) Descriptor() ([]byte, []int) { - return file_agentcompose_v2_agentcompose_proto_rawDescGZIP(), []int{197} + return file_agentcompose_v2_agentcompose_proto_rawDescGZIP(), []int{203} } func (x *WatchSandboxResponse) GetEventType() SandboxWatchEventType { @@ -15071,7 +15479,7 @@ type GenerateLLMRequest struct { func (x *GenerateLLMRequest) Reset() { *x = GenerateLLMRequest{} - mi := &file_agentcompose_v2_agentcompose_proto_msgTypes[198] + mi := &file_agentcompose_v2_agentcompose_proto_msgTypes[204] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -15083,7 +15491,7 @@ func (x *GenerateLLMRequest) String() string { func (*GenerateLLMRequest) ProtoMessage() {} func (x *GenerateLLMRequest) ProtoReflect() protoreflect.Message { - mi := &file_agentcompose_v2_agentcompose_proto_msgTypes[198] + mi := &file_agentcompose_v2_agentcompose_proto_msgTypes[204] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -15096,7 +15504,7 @@ func (x *GenerateLLMRequest) ProtoReflect() protoreflect.Message { // Deprecated: Use GenerateLLMRequest.ProtoReflect.Descriptor instead. func (*GenerateLLMRequest) Descriptor() ([]byte, []int) { - return file_agentcompose_v2_agentcompose_proto_rawDescGZIP(), []int{198} + return file_agentcompose_v2_agentcompose_proto_rawDescGZIP(), []int{204} } func (x *GenerateLLMRequest) GetPrompt() string { @@ -15133,7 +15541,7 @@ type GenerateLLMResponse struct { func (x *GenerateLLMResponse) Reset() { *x = GenerateLLMResponse{} - mi := &file_agentcompose_v2_agentcompose_proto_msgTypes[199] + mi := &file_agentcompose_v2_agentcompose_proto_msgTypes[205] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -15145,7 +15553,7 @@ func (x *GenerateLLMResponse) String() string { func (*GenerateLLMResponse) ProtoMessage() {} func (x *GenerateLLMResponse) ProtoReflect() protoreflect.Message { - mi := &file_agentcompose_v2_agentcompose_proto_msgTypes[199] + mi := &file_agentcompose_v2_agentcompose_proto_msgTypes[205] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -15158,7 +15566,7 @@ func (x *GenerateLLMResponse) ProtoReflect() protoreflect.Message { // Deprecated: Use GenerateLLMResponse.ProtoReflect.Descriptor instead. func (*GenerateLLMResponse) Descriptor() ([]byte, []int) { - return file_agentcompose_v2_agentcompose_proto_rawDescGZIP(), []int{199} + return file_agentcompose_v2_agentcompose_proto_rawDescGZIP(), []int{205} } func (x *GenerateLLMResponse) GetText() string { @@ -15428,7 +15836,7 @@ const file_agentcompose_v2_agentcompose_proto_rawDesc = "" + "\vresource_id\x18\x03 \x01(\tR\n" + "resourceId\x12\x12\n" + "\x04name\x18\x04 \x01(\tR\x04name\x12\x18\n" + - "\amessage\x18\x05 \x01(\tR\amessage\"\x90\x03\n" + + "\amessage\x18\x05 \x01(\tR\amessage\"\xcf\x03\n" + "\vProjectSpec\x12\x12\n" + "\x04name\x18\x01 \x01(\tR\x04name\x129\n" + "\tvariables\x18\x02 \x03(\v2\x1b.agentcompose.v2.EnvVarSpecR\tvariables\x122\n" + @@ -15438,10 +15846,11 @@ const file_agentcompose_v2_agentcompose_proto_rawDesc = "" + "\n" + "workspaces\x18\a \x03(\v2#.agentcompose.v2.NamedWorkspaceSpecR\n" + "workspaces\x122\n" + - "\x04mcps\x18\b \x03(\v2\x1e.agentcompose.v2.MCPServerSpecR\x04mcpsJ\x04\b\x03\x10\x04R\tworkspace\"f\n" + + "\x04mcps\x18\b \x03(\v2\x1e.agentcompose.v2.MCPServerSpecR\x04mcps\x12=\n" + + "\bnetworks\x18\t \x03(\v2!.agentcompose.v2.NamedNetworkSpecR\bnetworksJ\x04\b\x03\x10\x04R\tworkspace\"f\n" + "\x12NamedWorkspaceSpec\x12\x12\n" + "\x04name\x18\x01 \x01(\tR\x04name\x12<\n" + - "\tworkspace\x18\x02 \x01(\v2\x1e.agentcompose.v2.WorkspaceSpecR\tworkspace\"\xcf\x05\n" + + "\tworkspace\x18\x02 \x01(\v2\x1e.agentcompose.v2.WorkspaceSpecR\tworkspace\"\xdf\x06\n" + "\tAgentSpec\x12\x12\n" + "\x04name\x18\x01 \x01(\tR\x04name\x12\x1a\n" + "\bprovider\x18\x02 \x01(\tR\bprovider\x12\x14\n" + @@ -15460,7 +15869,10 @@ const file_agentcompose_v2_agentcompose_proto_rawDesc = "" + "\avolumes\x18\r \x03(\v2 .agentcompose.v2.VolumeMountSpecR\avolumes\x122\n" + "\x04mcps\x18\x0e \x03(\v2\x1e.agentcompose.v2.MCPServerSpecR\x04mcps\x122\n" + "\x06skills\x18\x0f \x03(\v2\x1a.agentcompose.v2.SkillSpecR\x06skills\x124\n" + - "\x06status\x18\x10 \x01(\x0e2\x1c.agentcompose.v2.AgentStatusR\x06status\"\xfb\x01\n" + + "\x06status\x18\x10 \x01(\x0e2\x1c.agentcompose.v2.AgentStatusR\x06status\x12\x1a\n" + + "\bnetworks\x18\x11 \x03(\tR\bnetworks\x128\n" + + "\x06expose\x18\x12 \x03(\v2 .agentcompose.v2.ExposedPortSpecR\x06expose\x128\n" + + "\x05ports\x18\x13 \x03(\v2\".agentcompose.v2.PublishedPortSpecR\x05ports\"\xfb\x01\n" + "\rMCPServerSpec\x12\x12\n" + "\x04name\x18\x01 \x01(\tR\x04name\x12\x12\n" + "\x04type\x18\x02 \x01(\tR\x04type\x12\x1c\n" + @@ -15519,7 +15931,19 @@ const file_agentcompose_v2_agentcompose_proto_rawDesc = "" + "\x04path\x18\x04 \x01(\tR\x04path\x12\x12\n" + "\x04name\x18\x05 \x01(\tR\x04name\"!\n" + "\vNetworkSpec\x12\x12\n" + - "\x04mode\x18\x01 \x01(\tR\x04mode\"\xa2\x01\n" + + "\x04mode\x18\x01 \x01(\tR\x04mode\">\n" + + "\x10NamedNetworkSpec\x12\x12\n" + + "\x04name\x18\x01 \x01(\tR\x04name\x12\x16\n" + + "\x06driver\x18\x02 \x01(\tR\x06driver\"b\n" + + "\x0fExposedPortSpec\x12\x16\n" + + "\x06target\x18\x01 \x01(\rR\x06target\x12\x1a\n" + + "\bprotocol\x18\x02 \x01(\tR\bprotocol\x12\x1b\n" + + "\thost_port\x18\x03 \x01(\rR\bhostPort\"~\n" + + "\x11PublishedPortSpec\x12\x17\n" + + "\ahost_ip\x18\x01 \x01(\tR\x06hostIp\x12\x1c\n" + + "\tpublished\x18\x02 \x01(\rR\tpublished\x12\x16\n" + + "\x06target\x18\x03 \x01(\rR\x06target\x12\x1a\n" + + "\bprotocol\x18\x04 \x01(\tR\bprotocol\"\xa2\x01\n" + "\rSchedulerSpec\x12\x18\n" + "\aenabled\x18\x01 \x01(\bR\aenabled\x128\n" + "\btriggers\x18\x02 \x03(\v2\x1c.agentcompose.v2.TriggerSpecR\btriggers\x12\x16\n" + @@ -15721,7 +16145,7 @@ const file_agentcompose_v2_agentcompose_proto_rawDesc = "" + "\x05stats\x18\x01 \x01(\v2\x1d.agentcompose.v2.SandboxStatsR\x05stats\"2\n" + "\x11GetSandboxRequest\x12\x1d\n" + "\n" + - "sandbox_id\x18\x01 \x01(\tR\tsandboxId\"\xb9\x04\n" + + "sandbox_id\x18\x01 \x01(\tR\tsandboxId\"\xf9\x04\n" + "\aSandbox\x12\x1d\n" + "\n" + "sandbox_id\x18\x01 \x01(\tR\tsandboxId\x12\x16\n" + @@ -15747,7 +16171,24 @@ const file_agentcompose_v2_agentcompose_proto_rawDesc = "" + "cell_count\x18\x0e \x01(\rR\tcellCount\x12\x1f\n" + "\vevent_count\x18\x0f \x01(\rR\n" + "eventCount\x12!\n" + - "\fnotebook_url\x18\x10 \x01(\tR\vnotebookUrl\"6\n" + + "\fnotebook_url\x18\x10 \x01(\tR\vnotebookUrl\x12>\n" + + "\anetwork\x18\x11 \x01(\v2$.agentcompose.v2.SandboxNetworkStateR\anetwork\"\xa1\x01\n" + + "\x13SandboxNetworkState\x12I\n" + + "\vattachments\x18\x01 \x03(\v2'.agentcompose.v2.SandboxNetworkEndpointR\vattachments\x12?\n" + + "\bbindings\x18\x02 \x03(\v2#.agentcompose.v2.SandboxPortBindingR\bbindings\",\n" + + "\x16SandboxNetworkEndpoint\x12\x12\n" + + "\x04name\x18\x01 \x01(\tR\x04name\"\xdf\x01\n" + + "\x12SandboxPortBinding\x12\x1a\n" + + "\bnetworks\x18\x01 \x03(\tR\bnetworks\x12\x17\n" + + "\ahost_ip\x18\x02 \x01(\tR\x06hostIp\x12\x1b\n" + + "\thost_port\x18\x03 \x01(\rR\bhostPort\x12\x1d\n" + + "\n" + + "guest_port\x18\x04 \x01(\rR\tguestPort\x12\x1a\n" + + "\bprotocol\x18\x05 \x01(\tR\bprotocol\x12\x1e\n" + + "\n" + + "visibility\x18\x06 \x01(\tR\n" + + "visibility\x12\x1c\n" + + "\tpublisher\x18\a \x01(\tR\tpublisher\"6\n" + "\n" + "SandboxTag\x12\x12\n" + "\x04name\x18\x01 \x01(\tR\x04name\x12\x14\n" + @@ -16665,7 +17106,7 @@ func file_agentcompose_v2_agentcompose_proto_rawDescGZIP() []byte { } var file_agentcompose_v2_agentcompose_proto_enumTypes = make([]protoimpl.EnumInfo, 22) -var file_agentcompose_v2_agentcompose_proto_msgTypes = make([]protoimpl.MessageInfo, 212) +var file_agentcompose_v2_agentcompose_proto_msgTypes = make([]protoimpl.MessageInfo, 218) var file_agentcompose_v2_agentcompose_proto_goTypes = []any{ (ProjectValidationSeverity)(0), // 0: agentcompose.v2.ProjectValidationSeverity (ProjectChangeAction)(0), // 1: agentcompose.v2.ProjectChangeAction @@ -16736,172 +17177,178 @@ var file_agentcompose_v2_agentcompose_proto_goTypes = []any{ (*EnvVarUpdateSpec)(nil), // 66: agentcompose.v2.EnvVarUpdateSpec (*WorkspaceSpec)(nil), // 67: agentcompose.v2.WorkspaceSpec (*NetworkSpec)(nil), // 68: agentcompose.v2.NetworkSpec - (*SchedulerSpec)(nil), // 69: agentcompose.v2.SchedulerSpec - (*TriggerSpec)(nil), // 70: agentcompose.v2.TriggerSpec - (*EventTriggerSpec)(nil), // 71: agentcompose.v2.EventTriggerSpec - (*DriverSpec)(nil), // 72: agentcompose.v2.DriverSpec - (*BoxliteDriverSpec)(nil), // 73: agentcompose.v2.BoxliteDriverSpec - (*DockerDriverSpec)(nil), // 74: agentcompose.v2.DockerDriverSpec - (*MicrosandboxDriverSpec)(nil), // 75: agentcompose.v2.MicrosandboxDriverSpec - (*RunAgentRequest)(nil), // 76: agentcompose.v2.RunAgentRequest - (*RunAgentResponse)(nil), // 77: agentcompose.v2.RunAgentResponse - (*RunAgentStreamResponse)(nil), // 78: agentcompose.v2.RunAgentStreamResponse - (*RunAttachRequest)(nil), // 79: agentcompose.v2.RunAttachRequest - (*RunAttachResponse)(nil), // 80: agentcompose.v2.RunAttachResponse - (*RunAttachStart)(nil), // 81: agentcompose.v2.RunAttachStart - (*TranscriptEvent)(nil), // 82: agentcompose.v2.TranscriptEvent - (*GetRunRequest)(nil), // 83: agentcompose.v2.GetRunRequest - (*GetRunResponse)(nil), // 84: agentcompose.v2.GetRunResponse - (*ListRunsRequest)(nil), // 85: agentcompose.v2.ListRunsRequest - (*ListRunsResponse)(nil), // 86: agentcompose.v2.ListRunsResponse - (*FollowRunLogsRequest)(nil), // 87: agentcompose.v2.FollowRunLogsRequest - (*RunLogChunk)(nil), // 88: agentcompose.v2.RunLogChunk - (*StopRunRequest)(nil), // 89: agentcompose.v2.StopRunRequest - (*StopRunResponse)(nil), // 90: agentcompose.v2.StopRunResponse - (*ListRunEventsRequest)(nil), // 91: agentcompose.v2.ListRunEventsRequest - (*RunEvent)(nil), // 92: agentcompose.v2.RunEvent - (*ListRunEventsResponse)(nil), // 93: agentcompose.v2.ListRunEventsResponse - (*ListSandboxRunEventsRequest)(nil), // 94: agentcompose.v2.ListSandboxRunEventsRequest - (*ListSandboxRunEventsResponse)(nil), // 95: agentcompose.v2.ListSandboxRunEventsResponse - (*RemoveSandboxRequest)(nil), // 96: agentcompose.v2.RemoveSandboxRequest - (*RemoveSandboxResponse)(nil), // 97: agentcompose.v2.RemoveSandboxResponse - (*GetSandboxStatsRequest)(nil), // 98: agentcompose.v2.GetSandboxStatsRequest - (*GetSandboxStatsResponse)(nil), // 99: agentcompose.v2.GetSandboxStatsResponse - (*GetSandboxRequest)(nil), // 100: agentcompose.v2.GetSandboxRequest - (*Sandbox)(nil), // 101: agentcompose.v2.Sandbox - (*SandboxTag)(nil), // 102: agentcompose.v2.SandboxTag - (*ListSandboxesRequest)(nil), // 103: agentcompose.v2.ListSandboxesRequest - (*ListSandboxesResponse)(nil), // 104: agentcompose.v2.ListSandboxesResponse - (*GetSandboxResponse)(nil), // 105: agentcompose.v2.GetSandboxResponse - (*StopSandboxRequest)(nil), // 106: agentcompose.v2.StopSandboxRequest - (*StopSandboxResponse)(nil), // 107: agentcompose.v2.StopSandboxResponse - (*ResumeSandboxRequest)(nil), // 108: agentcompose.v2.ResumeSandboxRequest - (*ResumeSandboxResponse)(nil), // 109: agentcompose.v2.ResumeSandboxResponse - (*MetricValue)(nil), // 110: agentcompose.v2.MetricValue - (*SandboxStats)(nil), // 111: agentcompose.v2.SandboxStats - (*RunSummary)(nil), // 112: agentcompose.v2.RunSummary - (*RunDetail)(nil), // 113: agentcompose.v2.RunDetail - (*ExecRequest)(nil), // 114: agentcompose.v2.ExecRequest - (*ExecSandboxSelector)(nil), // 115: agentcompose.v2.ExecSandboxSelector - (*ExecCommand)(nil), // 116: agentcompose.v2.ExecCommand - (*ExecResponse)(nil), // 117: agentcompose.v2.ExecResponse - (*ExecStreamResponse)(nil), // 118: agentcompose.v2.ExecStreamResponse - (*ExecAttachRequest)(nil), // 119: agentcompose.v2.ExecAttachRequest - (*ExecAttachResponse)(nil), // 120: agentcompose.v2.ExecAttachResponse - (*ExecAttachStart)(nil), // 121: agentcompose.v2.ExecAttachStart - (*AttachTerminalSize)(nil), // 122: agentcompose.v2.AttachTerminalSize - (*AttachStdin)(nil), // 123: agentcompose.v2.AttachStdin - (*AttachStdinEOF)(nil), // 124: agentcompose.v2.AttachStdinEOF - (*AttachResize)(nil), // 125: agentcompose.v2.AttachResize - (*AttachSignal)(nil), // 126: agentcompose.v2.AttachSignal - (*AttachHumanMessage)(nil), // 127: agentcompose.v2.AttachHumanMessage - (*AttachCancel)(nil), // 128: agentcompose.v2.AttachCancel - (*AttachStarted)(nil), // 129: agentcompose.v2.AttachStarted - (*AttachOutput)(nil), // 130: agentcompose.v2.AttachOutput - (*AttachAgentEvent)(nil), // 131: agentcompose.v2.AttachAgentEvent - (*AttachAgentTurnCompleted)(nil), // 132: agentcompose.v2.AttachAgentTurnCompleted - (*AttachResult)(nil), // 133: agentcompose.v2.AttachResult - (*AttachError)(nil), // 134: agentcompose.v2.AttachError - (*ExecResult)(nil), // 135: agentcompose.v2.ExecResult - (*ListImagesRequest)(nil), // 136: agentcompose.v2.ListImagesRequest - (*ListImagesResponse)(nil), // 137: agentcompose.v2.ListImagesResponse - (*PullImageRequest)(nil), // 138: agentcompose.v2.PullImageRequest - (*PullImageResponse)(nil), // 139: agentcompose.v2.PullImageResponse - (*InspectImageRequest)(nil), // 140: agentcompose.v2.InspectImageRequest - (*InspectImageResponse)(nil), // 141: agentcompose.v2.InspectImageResponse - (*RemoveImageRequest)(nil), // 142: agentcompose.v2.RemoveImageRequest - (*RemoveImageResponse)(nil), // 143: agentcompose.v2.RemoveImageResponse - (*BuildImageRequest)(nil), // 144: agentcompose.v2.BuildImageRequest - (*BuildImageEvent)(nil), // 145: agentcompose.v2.BuildImageEvent - (*CacheFilter)(nil), // 146: agentcompose.v2.CacheFilter - (*ListCachesRequest)(nil), // 147: agentcompose.v2.ListCachesRequest - (*ListCachesResponse)(nil), // 148: agentcompose.v2.ListCachesResponse - (*InspectCacheRequest)(nil), // 149: agentcompose.v2.InspectCacheRequest - (*InspectCacheResponse)(nil), // 150: agentcompose.v2.InspectCacheResponse - (*PruneCachesRequest)(nil), // 151: agentcompose.v2.PruneCachesRequest - (*PruneCachesResponse)(nil), // 152: agentcompose.v2.PruneCachesResponse - (*RemoveCacheRequest)(nil), // 153: agentcompose.v2.RemoveCacheRequest - (*RemoveCacheResponse)(nil), // 154: agentcompose.v2.RemoveCacheResponse - (*CacheItem)(nil), // 155: agentcompose.v2.CacheItem - (*CacheReference)(nil), // 156: agentcompose.v2.CacheReference - (*ListVolumesRequest)(nil), // 157: agentcompose.v2.ListVolumesRequest - (*ListVolumesResponse)(nil), // 158: agentcompose.v2.ListVolumesResponse - (*CreateVolumeRequest)(nil), // 159: agentcompose.v2.CreateVolumeRequest - (*CreateVolumeResponse)(nil), // 160: agentcompose.v2.CreateVolumeResponse - (*InspectVolumeRequest)(nil), // 161: agentcompose.v2.InspectVolumeRequest - (*InspectVolumeResponse)(nil), // 162: agentcompose.v2.InspectVolumeResponse - (*RemoveVolumeRequest)(nil), // 163: agentcompose.v2.RemoveVolumeRequest - (*RemoveVolumeResponse)(nil), // 164: agentcompose.v2.RemoveVolumeResponse - (*PruneVolumesRequest)(nil), // 165: agentcompose.v2.PruneVolumesRequest - (*PruneVolumesResponse)(nil), // 166: agentcompose.v2.PruneVolumesResponse - (*Volume)(nil), // 167: agentcompose.v2.Volume - (*Image)(nil), // 168: agentcompose.v2.Image - (*ImagePlatform)(nil), // 169: agentcompose.v2.ImagePlatform - (*ImageStoreStatus)(nil), // 170: agentcompose.v2.ImageStoreStatus - (*DockerImageStatus)(nil), // 171: agentcompose.v2.DockerImageStatus - (*OCIImageStatus)(nil), // 172: agentcompose.v2.OCIImageStatus - (*ImagePullProgress)(nil), // 173: agentcompose.v2.ImagePullProgress - (*JupyterSpec)(nil), // 174: agentcompose.v2.JupyterSpec - (*RunJupyterSpec)(nil), // 175: agentcompose.v2.RunJupyterSpec - (*StartRunRequest)(nil), // 176: agentcompose.v2.StartRunRequest - (*StartRunResponse)(nil), // 177: agentcompose.v2.StartRunResponse - (*SkillSpec)(nil), // 178: agentcompose.v2.SkillSpec - (*ResolveResourceIDRequest)(nil), // 179: agentcompose.v2.ResolveResourceIDRequest - (*ResolveResourceIDResponse)(nil), // 180: agentcompose.v2.ResolveResourceIDResponse - (*ResourceTarget)(nil), // 181: agentcompose.v2.ResourceTarget - (*GetDashboardOverviewRequest)(nil), // 182: agentcompose.v2.GetDashboardOverviewRequest - (*WatchDashboardOverviewRequest)(nil), // 183: agentcompose.v2.WatchDashboardOverviewRequest - (*RunOverview)(nil), // 184: agentcompose.v2.RunOverview - (*DashboardOverview)(nil), // 185: agentcompose.v2.DashboardOverview - (*GetDashboardOverviewResponse)(nil), // 186: agentcompose.v2.GetDashboardOverviewResponse - (*WatchDashboardOverviewResponse)(nil), // 187: agentcompose.v2.WatchDashboardOverviewResponse - (*GetGlobalEnvRequest)(nil), // 188: agentcompose.v2.GetGlobalEnvRequest - (*GetGlobalEnvResponse)(nil), // 189: agentcompose.v2.GetGlobalEnvResponse - (*UpdateGlobalEnvRequest)(nil), // 190: agentcompose.v2.UpdateGlobalEnvRequest - (*UpdateGlobalEnvResponse)(nil), // 191: agentcompose.v2.UpdateGlobalEnvResponse - (*GetCapabilityGatewayConfigRequest)(nil), // 192: agentcompose.v2.GetCapabilityGatewayConfigRequest - (*CapabilityGatewayConfig)(nil), // 193: agentcompose.v2.CapabilityGatewayConfig - (*GetCapabilityGatewayConfigResponse)(nil), // 194: agentcompose.v2.GetCapabilityGatewayConfigResponse - (*UpdateCapabilityGatewayConfigRequest)(nil), // 195: agentcompose.v2.UpdateCapabilityGatewayConfigRequest - (*UpdateCapabilityGatewayConfigResponse)(nil), // 196: agentcompose.v2.UpdateCapabilityGatewayConfigResponse - (*WorkspacePreset)(nil), // 197: agentcompose.v2.WorkspacePreset - (*ListWorkspacePresetsRequest)(nil), // 198: agentcompose.v2.ListWorkspacePresetsRequest - (*ListWorkspacePresetsResponse)(nil), // 199: agentcompose.v2.ListWorkspacePresetsResponse - (*CreateWorkspacePresetRequest)(nil), // 200: agentcompose.v2.CreateWorkspacePresetRequest - (*UpdateWorkspacePresetRequest)(nil), // 201: agentcompose.v2.UpdateWorkspacePresetRequest - (*DeleteWorkspacePresetRequest)(nil), // 202: agentcompose.v2.DeleteWorkspacePresetRequest - (*DeleteWorkspacePresetResponse)(nil), // 203: agentcompose.v2.DeleteWorkspacePresetResponse - (*WorkspacePresetResponse)(nil), // 204: agentcompose.v2.WorkspacePresetResponse - (*GetCapabilityStatusRequest)(nil), // 205: agentcompose.v2.GetCapabilityStatusRequest - (*CapabilityStatusResponse)(nil), // 206: agentcompose.v2.CapabilityStatusResponse - (*ListCapabilitySetsRequest)(nil), // 207: agentcompose.v2.ListCapabilitySetsRequest - (*CapabilitySet)(nil), // 208: agentcompose.v2.CapabilitySet - (*ListCapabilitySetsResponse)(nil), // 209: agentcompose.v2.ListCapabilitySetsResponse - (*GetCapabilityCatalogRequest)(nil), // 210: agentcompose.v2.GetCapabilityCatalogRequest - (*CapabilityEndpoint)(nil), // 211: agentcompose.v2.CapabilityEndpoint - (*CapabilityMethod)(nil), // 212: agentcompose.v2.CapabilityMethod - (*GetCapabilityCatalogResponse)(nil), // 213: agentcompose.v2.GetCapabilityCatalogResponse - (*ListSandboxHistoryRequest)(nil), // 214: agentcompose.v2.ListSandboxHistoryRequest - (*SandboxHistoryCell)(nil), // 215: agentcompose.v2.SandboxHistoryCell - (*SandboxHistoryEvent)(nil), // 216: agentcompose.v2.SandboxHistoryEvent - (*ListSandboxHistoryResponse)(nil), // 217: agentcompose.v2.ListSandboxHistoryResponse - (*WatchSandboxRequest)(nil), // 218: agentcompose.v2.WatchSandboxRequest - (*WatchSandboxResponse)(nil), // 219: agentcompose.v2.WatchSandboxResponse - (*GenerateLLMRequest)(nil), // 220: agentcompose.v2.GenerateLLMRequest - (*GenerateLLMResponse)(nil), // 221: agentcompose.v2.GenerateLLMResponse - nil, // 222: agentcompose.v2.ProjectVolumeSpec.LabelsEntry - nil, // 223: agentcompose.v2.ProjectVolumeSpec.OptionsEntry - nil, // 224: agentcompose.v2.BuildSpec.ArgsEntry - nil, // 225: agentcompose.v2.AttachHumanMessage.MetadataEntry - nil, // 226: agentcompose.v2.AttachError.DetailsEntry - nil, // 227: agentcompose.v2.BuildImageRequest.BuildArgsEntry - nil, // 228: agentcompose.v2.CreateVolumeRequest.LabelsEntry - nil, // 229: agentcompose.v2.CreateVolumeRequest.OptionsEntry - nil, // 230: agentcompose.v2.Volume.LabelsEntry - nil, // 231: agentcompose.v2.Volume.OptionsEntry - nil, // 232: agentcompose.v2.Image.LabelsEntry - nil, // 233: agentcompose.v2.CapabilityEndpoint.MetadataEntry - (*timestamppb.Timestamp)(nil), // 234: google.protobuf.Timestamp + (*NamedNetworkSpec)(nil), // 69: agentcompose.v2.NamedNetworkSpec + (*ExposedPortSpec)(nil), // 70: agentcompose.v2.ExposedPortSpec + (*PublishedPortSpec)(nil), // 71: agentcompose.v2.PublishedPortSpec + (*SchedulerSpec)(nil), // 72: agentcompose.v2.SchedulerSpec + (*TriggerSpec)(nil), // 73: agentcompose.v2.TriggerSpec + (*EventTriggerSpec)(nil), // 74: agentcompose.v2.EventTriggerSpec + (*DriverSpec)(nil), // 75: agentcompose.v2.DriverSpec + (*BoxliteDriverSpec)(nil), // 76: agentcompose.v2.BoxliteDriverSpec + (*DockerDriverSpec)(nil), // 77: agentcompose.v2.DockerDriverSpec + (*MicrosandboxDriverSpec)(nil), // 78: agentcompose.v2.MicrosandboxDriverSpec + (*RunAgentRequest)(nil), // 79: agentcompose.v2.RunAgentRequest + (*RunAgentResponse)(nil), // 80: agentcompose.v2.RunAgentResponse + (*RunAgentStreamResponse)(nil), // 81: agentcompose.v2.RunAgentStreamResponse + (*RunAttachRequest)(nil), // 82: agentcompose.v2.RunAttachRequest + (*RunAttachResponse)(nil), // 83: agentcompose.v2.RunAttachResponse + (*RunAttachStart)(nil), // 84: agentcompose.v2.RunAttachStart + (*TranscriptEvent)(nil), // 85: agentcompose.v2.TranscriptEvent + (*GetRunRequest)(nil), // 86: agentcompose.v2.GetRunRequest + (*GetRunResponse)(nil), // 87: agentcompose.v2.GetRunResponse + (*ListRunsRequest)(nil), // 88: agentcompose.v2.ListRunsRequest + (*ListRunsResponse)(nil), // 89: agentcompose.v2.ListRunsResponse + (*FollowRunLogsRequest)(nil), // 90: agentcompose.v2.FollowRunLogsRequest + (*RunLogChunk)(nil), // 91: agentcompose.v2.RunLogChunk + (*StopRunRequest)(nil), // 92: agentcompose.v2.StopRunRequest + (*StopRunResponse)(nil), // 93: agentcompose.v2.StopRunResponse + (*ListRunEventsRequest)(nil), // 94: agentcompose.v2.ListRunEventsRequest + (*RunEvent)(nil), // 95: agentcompose.v2.RunEvent + (*ListRunEventsResponse)(nil), // 96: agentcompose.v2.ListRunEventsResponse + (*ListSandboxRunEventsRequest)(nil), // 97: agentcompose.v2.ListSandboxRunEventsRequest + (*ListSandboxRunEventsResponse)(nil), // 98: agentcompose.v2.ListSandboxRunEventsResponse + (*RemoveSandboxRequest)(nil), // 99: agentcompose.v2.RemoveSandboxRequest + (*RemoveSandboxResponse)(nil), // 100: agentcompose.v2.RemoveSandboxResponse + (*GetSandboxStatsRequest)(nil), // 101: agentcompose.v2.GetSandboxStatsRequest + (*GetSandboxStatsResponse)(nil), // 102: agentcompose.v2.GetSandboxStatsResponse + (*GetSandboxRequest)(nil), // 103: agentcompose.v2.GetSandboxRequest + (*Sandbox)(nil), // 104: agentcompose.v2.Sandbox + (*SandboxNetworkState)(nil), // 105: agentcompose.v2.SandboxNetworkState + (*SandboxNetworkEndpoint)(nil), // 106: agentcompose.v2.SandboxNetworkEndpoint + (*SandboxPortBinding)(nil), // 107: agentcompose.v2.SandboxPortBinding + (*SandboxTag)(nil), // 108: agentcompose.v2.SandboxTag + (*ListSandboxesRequest)(nil), // 109: agentcompose.v2.ListSandboxesRequest + (*ListSandboxesResponse)(nil), // 110: agentcompose.v2.ListSandboxesResponse + (*GetSandboxResponse)(nil), // 111: agentcompose.v2.GetSandboxResponse + (*StopSandboxRequest)(nil), // 112: agentcompose.v2.StopSandboxRequest + (*StopSandboxResponse)(nil), // 113: agentcompose.v2.StopSandboxResponse + (*ResumeSandboxRequest)(nil), // 114: agentcompose.v2.ResumeSandboxRequest + (*ResumeSandboxResponse)(nil), // 115: agentcompose.v2.ResumeSandboxResponse + (*MetricValue)(nil), // 116: agentcompose.v2.MetricValue + (*SandboxStats)(nil), // 117: agentcompose.v2.SandboxStats + (*RunSummary)(nil), // 118: agentcompose.v2.RunSummary + (*RunDetail)(nil), // 119: agentcompose.v2.RunDetail + (*ExecRequest)(nil), // 120: agentcompose.v2.ExecRequest + (*ExecSandboxSelector)(nil), // 121: agentcompose.v2.ExecSandboxSelector + (*ExecCommand)(nil), // 122: agentcompose.v2.ExecCommand + (*ExecResponse)(nil), // 123: agentcompose.v2.ExecResponse + (*ExecStreamResponse)(nil), // 124: agentcompose.v2.ExecStreamResponse + (*ExecAttachRequest)(nil), // 125: agentcompose.v2.ExecAttachRequest + (*ExecAttachResponse)(nil), // 126: agentcompose.v2.ExecAttachResponse + (*ExecAttachStart)(nil), // 127: agentcompose.v2.ExecAttachStart + (*AttachTerminalSize)(nil), // 128: agentcompose.v2.AttachTerminalSize + (*AttachStdin)(nil), // 129: agentcompose.v2.AttachStdin + (*AttachStdinEOF)(nil), // 130: agentcompose.v2.AttachStdinEOF + (*AttachResize)(nil), // 131: agentcompose.v2.AttachResize + (*AttachSignal)(nil), // 132: agentcompose.v2.AttachSignal + (*AttachHumanMessage)(nil), // 133: agentcompose.v2.AttachHumanMessage + (*AttachCancel)(nil), // 134: agentcompose.v2.AttachCancel + (*AttachStarted)(nil), // 135: agentcompose.v2.AttachStarted + (*AttachOutput)(nil), // 136: agentcompose.v2.AttachOutput + (*AttachAgentEvent)(nil), // 137: agentcompose.v2.AttachAgentEvent + (*AttachAgentTurnCompleted)(nil), // 138: agentcompose.v2.AttachAgentTurnCompleted + (*AttachResult)(nil), // 139: agentcompose.v2.AttachResult + (*AttachError)(nil), // 140: agentcompose.v2.AttachError + (*ExecResult)(nil), // 141: agentcompose.v2.ExecResult + (*ListImagesRequest)(nil), // 142: agentcompose.v2.ListImagesRequest + (*ListImagesResponse)(nil), // 143: agentcompose.v2.ListImagesResponse + (*PullImageRequest)(nil), // 144: agentcompose.v2.PullImageRequest + (*PullImageResponse)(nil), // 145: agentcompose.v2.PullImageResponse + (*InspectImageRequest)(nil), // 146: agentcompose.v2.InspectImageRequest + (*InspectImageResponse)(nil), // 147: agentcompose.v2.InspectImageResponse + (*RemoveImageRequest)(nil), // 148: agentcompose.v2.RemoveImageRequest + (*RemoveImageResponse)(nil), // 149: agentcompose.v2.RemoveImageResponse + (*BuildImageRequest)(nil), // 150: agentcompose.v2.BuildImageRequest + (*BuildImageEvent)(nil), // 151: agentcompose.v2.BuildImageEvent + (*CacheFilter)(nil), // 152: agentcompose.v2.CacheFilter + (*ListCachesRequest)(nil), // 153: agentcompose.v2.ListCachesRequest + (*ListCachesResponse)(nil), // 154: agentcompose.v2.ListCachesResponse + (*InspectCacheRequest)(nil), // 155: agentcompose.v2.InspectCacheRequest + (*InspectCacheResponse)(nil), // 156: agentcompose.v2.InspectCacheResponse + (*PruneCachesRequest)(nil), // 157: agentcompose.v2.PruneCachesRequest + (*PruneCachesResponse)(nil), // 158: agentcompose.v2.PruneCachesResponse + (*RemoveCacheRequest)(nil), // 159: agentcompose.v2.RemoveCacheRequest + (*RemoveCacheResponse)(nil), // 160: agentcompose.v2.RemoveCacheResponse + (*CacheItem)(nil), // 161: agentcompose.v2.CacheItem + (*CacheReference)(nil), // 162: agentcompose.v2.CacheReference + (*ListVolumesRequest)(nil), // 163: agentcompose.v2.ListVolumesRequest + (*ListVolumesResponse)(nil), // 164: agentcompose.v2.ListVolumesResponse + (*CreateVolumeRequest)(nil), // 165: agentcompose.v2.CreateVolumeRequest + (*CreateVolumeResponse)(nil), // 166: agentcompose.v2.CreateVolumeResponse + (*InspectVolumeRequest)(nil), // 167: agentcompose.v2.InspectVolumeRequest + (*InspectVolumeResponse)(nil), // 168: agentcompose.v2.InspectVolumeResponse + (*RemoveVolumeRequest)(nil), // 169: agentcompose.v2.RemoveVolumeRequest + (*RemoveVolumeResponse)(nil), // 170: agentcompose.v2.RemoveVolumeResponse + (*PruneVolumesRequest)(nil), // 171: agentcompose.v2.PruneVolumesRequest + (*PruneVolumesResponse)(nil), // 172: agentcompose.v2.PruneVolumesResponse + (*Volume)(nil), // 173: agentcompose.v2.Volume + (*Image)(nil), // 174: agentcompose.v2.Image + (*ImagePlatform)(nil), // 175: agentcompose.v2.ImagePlatform + (*ImageStoreStatus)(nil), // 176: agentcompose.v2.ImageStoreStatus + (*DockerImageStatus)(nil), // 177: agentcompose.v2.DockerImageStatus + (*OCIImageStatus)(nil), // 178: agentcompose.v2.OCIImageStatus + (*ImagePullProgress)(nil), // 179: agentcompose.v2.ImagePullProgress + (*JupyterSpec)(nil), // 180: agentcompose.v2.JupyterSpec + (*RunJupyterSpec)(nil), // 181: agentcompose.v2.RunJupyterSpec + (*StartRunRequest)(nil), // 182: agentcompose.v2.StartRunRequest + (*StartRunResponse)(nil), // 183: agentcompose.v2.StartRunResponse + (*SkillSpec)(nil), // 184: agentcompose.v2.SkillSpec + (*ResolveResourceIDRequest)(nil), // 185: agentcompose.v2.ResolveResourceIDRequest + (*ResolveResourceIDResponse)(nil), // 186: agentcompose.v2.ResolveResourceIDResponse + (*ResourceTarget)(nil), // 187: agentcompose.v2.ResourceTarget + (*GetDashboardOverviewRequest)(nil), // 188: agentcompose.v2.GetDashboardOverviewRequest + (*WatchDashboardOverviewRequest)(nil), // 189: agentcompose.v2.WatchDashboardOverviewRequest + (*RunOverview)(nil), // 190: agentcompose.v2.RunOverview + (*DashboardOverview)(nil), // 191: agentcompose.v2.DashboardOverview + (*GetDashboardOverviewResponse)(nil), // 192: agentcompose.v2.GetDashboardOverviewResponse + (*WatchDashboardOverviewResponse)(nil), // 193: agentcompose.v2.WatchDashboardOverviewResponse + (*GetGlobalEnvRequest)(nil), // 194: agentcompose.v2.GetGlobalEnvRequest + (*GetGlobalEnvResponse)(nil), // 195: agentcompose.v2.GetGlobalEnvResponse + (*UpdateGlobalEnvRequest)(nil), // 196: agentcompose.v2.UpdateGlobalEnvRequest + (*UpdateGlobalEnvResponse)(nil), // 197: agentcompose.v2.UpdateGlobalEnvResponse + (*GetCapabilityGatewayConfigRequest)(nil), // 198: agentcompose.v2.GetCapabilityGatewayConfigRequest + (*CapabilityGatewayConfig)(nil), // 199: agentcompose.v2.CapabilityGatewayConfig + (*GetCapabilityGatewayConfigResponse)(nil), // 200: agentcompose.v2.GetCapabilityGatewayConfigResponse + (*UpdateCapabilityGatewayConfigRequest)(nil), // 201: agentcompose.v2.UpdateCapabilityGatewayConfigRequest + (*UpdateCapabilityGatewayConfigResponse)(nil), // 202: agentcompose.v2.UpdateCapabilityGatewayConfigResponse + (*WorkspacePreset)(nil), // 203: agentcompose.v2.WorkspacePreset + (*ListWorkspacePresetsRequest)(nil), // 204: agentcompose.v2.ListWorkspacePresetsRequest + (*ListWorkspacePresetsResponse)(nil), // 205: agentcompose.v2.ListWorkspacePresetsResponse + (*CreateWorkspacePresetRequest)(nil), // 206: agentcompose.v2.CreateWorkspacePresetRequest + (*UpdateWorkspacePresetRequest)(nil), // 207: agentcompose.v2.UpdateWorkspacePresetRequest + (*DeleteWorkspacePresetRequest)(nil), // 208: agentcompose.v2.DeleteWorkspacePresetRequest + (*DeleteWorkspacePresetResponse)(nil), // 209: agentcompose.v2.DeleteWorkspacePresetResponse + (*WorkspacePresetResponse)(nil), // 210: agentcompose.v2.WorkspacePresetResponse + (*GetCapabilityStatusRequest)(nil), // 211: agentcompose.v2.GetCapabilityStatusRequest + (*CapabilityStatusResponse)(nil), // 212: agentcompose.v2.CapabilityStatusResponse + (*ListCapabilitySetsRequest)(nil), // 213: agentcompose.v2.ListCapabilitySetsRequest + (*CapabilitySet)(nil), // 214: agentcompose.v2.CapabilitySet + (*ListCapabilitySetsResponse)(nil), // 215: agentcompose.v2.ListCapabilitySetsResponse + (*GetCapabilityCatalogRequest)(nil), // 216: agentcompose.v2.GetCapabilityCatalogRequest + (*CapabilityEndpoint)(nil), // 217: agentcompose.v2.CapabilityEndpoint + (*CapabilityMethod)(nil), // 218: agentcompose.v2.CapabilityMethod + (*GetCapabilityCatalogResponse)(nil), // 219: agentcompose.v2.GetCapabilityCatalogResponse + (*ListSandboxHistoryRequest)(nil), // 220: agentcompose.v2.ListSandboxHistoryRequest + (*SandboxHistoryCell)(nil), // 221: agentcompose.v2.SandboxHistoryCell + (*SandboxHistoryEvent)(nil), // 222: agentcompose.v2.SandboxHistoryEvent + (*ListSandboxHistoryResponse)(nil), // 223: agentcompose.v2.ListSandboxHistoryResponse + (*WatchSandboxRequest)(nil), // 224: agentcompose.v2.WatchSandboxRequest + (*WatchSandboxResponse)(nil), // 225: agentcompose.v2.WatchSandboxResponse + (*GenerateLLMRequest)(nil), // 226: agentcompose.v2.GenerateLLMRequest + (*GenerateLLMResponse)(nil), // 227: agentcompose.v2.GenerateLLMResponse + nil, // 228: agentcompose.v2.ProjectVolumeSpec.LabelsEntry + nil, // 229: agentcompose.v2.ProjectVolumeSpec.OptionsEntry + nil, // 230: agentcompose.v2.BuildSpec.ArgsEntry + nil, // 231: agentcompose.v2.AttachHumanMessage.MetadataEntry + nil, // 232: agentcompose.v2.AttachError.DetailsEntry + nil, // 233: agentcompose.v2.BuildImageRequest.BuildArgsEntry + nil, // 234: agentcompose.v2.CreateVolumeRequest.LabelsEntry + nil, // 235: agentcompose.v2.CreateVolumeRequest.OptionsEntry + nil, // 236: agentcompose.v2.Volume.LabelsEntry + nil, // 237: agentcompose.v2.Volume.OptionsEntry + nil, // 238: agentcompose.v2.Image.LabelsEntry + nil, // 239: agentcompose.v2.CapabilityEndpoint.MetadataEntry + (*timestamppb.Timestamp)(nil), // 240: google.protobuf.Timestamp } var file_agentcompose_v2_agentcompose_proto_depIdxs = []int32{ 58, // 0: agentcompose.v2.ValidateProjectRequest.spec:type_name -> agentcompose.v2.ProjectSpec @@ -16935,18 +17382,18 @@ var file_agentcompose_v2_agentcompose_proto_depIdxs = []int32{ 41, // 28: agentcompose.v2.ProjectAgent.latest_run:type_name -> agentcompose.v2.ProjectAgentLatestRun 3, // 29: agentcompose.v2.ProjectAgentLatestRun.status:type_name -> agentcompose.v2.RunStatus 4, // 30: agentcompose.v2.ProjectAgentLatestRun.source:type_name -> agentcompose.v2.RunSource - 234, // 31: agentcompose.v2.ProjectAgentLatestRun.at:type_name -> google.protobuf.Timestamp + 240, // 31: agentcompose.v2.ProjectAgentLatestRun.at:type_name -> google.protobuf.Timestamp 34, // 32: agentcompose.v2.GetSchedulerRequest.project:type_name -> agentcompose.v2.ProjectRef 42, // 33: agentcompose.v2.GetSchedulerResponse.scheduler:type_name -> agentcompose.v2.ProjectScheduler - 69, // 34: agentcompose.v2.GetSchedulerResponse.spec:type_name -> agentcompose.v2.SchedulerSpec + 72, // 34: agentcompose.v2.GetSchedulerResponse.spec:type_name -> agentcompose.v2.SchedulerSpec 45, // 35: agentcompose.v2.GetSchedulerResponse.triggers:type_name -> agentcompose.v2.ResolvedTrigger - 70, // 36: agentcompose.v2.ResolvedTrigger.spec:type_name -> agentcompose.v2.TriggerSpec - 234, // 37: agentcompose.v2.ResolvedTrigger.next_fire_at:type_name -> google.protobuf.Timestamp - 234, // 38: agentcompose.v2.ResolvedTrigger.last_fired_at:type_name -> google.protobuf.Timestamp - 234, // 39: agentcompose.v2.SchedulerSummary.latest_run_at:type_name -> google.protobuf.Timestamp + 73, // 36: agentcompose.v2.ResolvedTrigger.spec:type_name -> agentcompose.v2.TriggerSpec + 240, // 37: agentcompose.v2.ResolvedTrigger.next_fire_at:type_name -> google.protobuf.Timestamp + 240, // 38: agentcompose.v2.ResolvedTrigger.last_fired_at:type_name -> google.protobuf.Timestamp + 240, // 39: agentcompose.v2.SchedulerSummary.latest_run_at:type_name -> google.protobuf.Timestamp 47, // 40: agentcompose.v2.ListSchedulersResponse.schedulers:type_name -> agentcompose.v2.SchedulerSummary 34, // 41: agentcompose.v2.ListSchedulerEventsRequest.project:type_name -> agentcompose.v2.ProjectRef - 234, // 42: agentcompose.v2.SchedulerEvent.created_at:type_name -> google.protobuf.Timestamp + 240, // 42: agentcompose.v2.SchedulerEvent.created_at:type_name -> google.protobuf.Timestamp 50, // 43: agentcompose.v2.ListSchedulerEventsResponse.events:type_name -> agentcompose.v2.SchedulerEvent 34, // 44: agentcompose.v2.SetSchedulerEnabledRequest.project:type_name -> agentcompose.v2.ProjectRef 42, // 45: agentcompose.v2.SetSchedulerEnabledResponse.scheduler:type_name -> agentcompose.v2.ProjectScheduler @@ -16960,323 +17407,329 @@ var file_agentcompose_v2_agentcompose_proto_depIdxs = []int32{ 62, // 53: agentcompose.v2.ProjectSpec.volumes:type_name -> agentcompose.v2.ProjectVolumeSpec 59, // 54: agentcompose.v2.ProjectSpec.workspaces:type_name -> agentcompose.v2.NamedWorkspaceSpec 61, // 55: agentcompose.v2.ProjectSpec.mcps:type_name -> agentcompose.v2.MCPServerSpec - 67, // 56: agentcompose.v2.NamedWorkspaceSpec.workspace:type_name -> agentcompose.v2.WorkspaceSpec - 72, // 57: agentcompose.v2.AgentSpec.driver:type_name -> agentcompose.v2.DriverSpec - 65, // 58: agentcompose.v2.AgentSpec.env:type_name -> agentcompose.v2.EnvVarSpec - 67, // 59: agentcompose.v2.AgentSpec.workspace:type_name -> agentcompose.v2.WorkspaceSpec - 69, // 60: agentcompose.v2.AgentSpec.scheduler:type_name -> agentcompose.v2.SchedulerSpec - 174, // 61: agentcompose.v2.AgentSpec.jupyter:type_name -> agentcompose.v2.JupyterSpec - 64, // 62: agentcompose.v2.AgentSpec.build:type_name -> agentcompose.v2.BuildSpec - 63, // 63: agentcompose.v2.AgentSpec.volumes:type_name -> agentcompose.v2.VolumeMountSpec - 61, // 64: agentcompose.v2.AgentSpec.mcps:type_name -> agentcompose.v2.MCPServerSpec - 178, // 65: agentcompose.v2.AgentSpec.skills:type_name -> agentcompose.v2.SkillSpec - 5, // 66: agentcompose.v2.AgentSpec.status:type_name -> agentcompose.v2.AgentStatus - 65, // 67: agentcompose.v2.MCPServerSpec.env:type_name -> agentcompose.v2.EnvVarSpec - 65, // 68: agentcompose.v2.MCPServerSpec.headers:type_name -> agentcompose.v2.EnvVarSpec - 222, // 69: agentcompose.v2.ProjectVolumeSpec.labels:type_name -> agentcompose.v2.ProjectVolumeSpec.LabelsEntry - 223, // 70: agentcompose.v2.ProjectVolumeSpec.options:type_name -> agentcompose.v2.ProjectVolumeSpec.OptionsEntry - 224, // 71: agentcompose.v2.BuildSpec.args:type_name -> agentcompose.v2.BuildSpec.ArgsEntry - 70, // 72: agentcompose.v2.SchedulerSpec.triggers:type_name -> agentcompose.v2.TriggerSpec - 71, // 73: agentcompose.v2.TriggerSpec.event:type_name -> agentcompose.v2.EventTriggerSpec - 73, // 74: agentcompose.v2.DriverSpec.boxlite:type_name -> agentcompose.v2.BoxliteDriverSpec - 74, // 75: agentcompose.v2.DriverSpec.docker:type_name -> agentcompose.v2.DockerDriverSpec - 75, // 76: agentcompose.v2.DriverSpec.microsandbox:type_name -> agentcompose.v2.MicrosandboxDriverSpec - 4, // 77: agentcompose.v2.RunAgentRequest.source:type_name -> agentcompose.v2.RunSource - 65, // 78: agentcompose.v2.RunAgentRequest.env:type_name -> agentcompose.v2.EnvVarSpec - 10, // 79: agentcompose.v2.RunAgentRequest.cleanup_policy:type_name -> agentcompose.v2.RunSandboxCleanupPolicy - 175, // 80: agentcompose.v2.RunAgentRequest.jupyter:type_name -> agentcompose.v2.RunJupyterSpec - 63, // 81: agentcompose.v2.RunAgentRequest.volumes:type_name -> agentcompose.v2.VolumeMountSpec - 113, // 82: agentcompose.v2.RunAgentResponse.run:type_name -> agentcompose.v2.RunDetail - 9, // 83: agentcompose.v2.RunAgentStreamResponse.event_type:type_name -> agentcompose.v2.RunAgentStreamEventType - 112, // 84: agentcompose.v2.RunAgentStreamResponse.run:type_name -> agentcompose.v2.RunSummary - 13, // 85: agentcompose.v2.RunAgentStreamResponse.stream:type_name -> agentcompose.v2.StdioStream - 82, // 86: agentcompose.v2.RunAgentStreamResponse.transcript:type_name -> agentcompose.v2.TranscriptEvent - 81, // 87: agentcompose.v2.RunAttachRequest.start:type_name -> agentcompose.v2.RunAttachStart - 123, // 88: agentcompose.v2.RunAttachRequest.stdin:type_name -> agentcompose.v2.AttachStdin - 124, // 89: agentcompose.v2.RunAttachRequest.stdin_eof:type_name -> agentcompose.v2.AttachStdinEOF - 125, // 90: agentcompose.v2.RunAttachRequest.resize:type_name -> agentcompose.v2.AttachResize - 126, // 91: agentcompose.v2.RunAttachRequest.signal:type_name -> agentcompose.v2.AttachSignal - 127, // 92: agentcompose.v2.RunAttachRequest.human_message:type_name -> agentcompose.v2.AttachHumanMessage - 128, // 93: agentcompose.v2.RunAttachRequest.cancel:type_name -> agentcompose.v2.AttachCancel - 129, // 94: agentcompose.v2.RunAttachResponse.started:type_name -> agentcompose.v2.AttachStarted - 130, // 95: agentcompose.v2.RunAttachResponse.output:type_name -> agentcompose.v2.AttachOutput - 131, // 96: agentcompose.v2.RunAttachResponse.agent_event:type_name -> agentcompose.v2.AttachAgentEvent - 132, // 97: agentcompose.v2.RunAttachResponse.agent_turn_completed:type_name -> agentcompose.v2.AttachAgentTurnCompleted - 133, // 98: agentcompose.v2.RunAttachResponse.result:type_name -> agentcompose.v2.AttachResult - 134, // 99: agentcompose.v2.RunAttachResponse.error:type_name -> agentcompose.v2.AttachError - 76, // 100: agentcompose.v2.RunAttachStart.request:type_name -> agentcompose.v2.RunAgentRequest - 12, // 101: agentcompose.v2.RunAttachStart.mode:type_name -> agentcompose.v2.AttachRunMode - 122, // 102: agentcompose.v2.RunAttachStart.terminal_size:type_name -> agentcompose.v2.AttachTerminalSize - 13, // 103: agentcompose.v2.TranscriptEvent.stream:type_name -> agentcompose.v2.StdioStream - 113, // 104: agentcompose.v2.GetRunResponse.run:type_name -> agentcompose.v2.RunDetail - 3, // 105: agentcompose.v2.ListRunsRequest.status:type_name -> agentcompose.v2.RunStatus - 4, // 106: agentcompose.v2.ListRunsRequest.source:type_name -> agentcompose.v2.RunSource - 112, // 107: agentcompose.v2.ListRunsResponse.runs:type_name -> agentcompose.v2.RunSummary - 3, // 108: agentcompose.v2.RunLogChunk.run_status:type_name -> agentcompose.v2.RunStatus - 113, // 109: agentcompose.v2.StopRunResponse.run:type_name -> agentcompose.v2.RunDetail - 8, // 110: agentcompose.v2.RunEvent.kind:type_name -> agentcompose.v2.RunEventKind - 234, // 111: agentcompose.v2.RunEvent.created_at:type_name -> google.protobuf.Timestamp - 92, // 112: agentcompose.v2.ListRunEventsResponse.events:type_name -> agentcompose.v2.RunEvent - 92, // 113: agentcompose.v2.ListSandboxRunEventsResponse.events:type_name -> agentcompose.v2.RunEvent - 111, // 114: agentcompose.v2.GetSandboxStatsResponse.stats:type_name -> agentcompose.v2.SandboxStats - 234, // 115: agentcompose.v2.Sandbox.created_at:type_name -> google.protobuf.Timestamp - 234, // 116: agentcompose.v2.Sandbox.updated_at:type_name -> google.protobuf.Timestamp - 102, // 117: agentcompose.v2.Sandbox.tags:type_name -> agentcompose.v2.SandboxTag - 101, // 118: agentcompose.v2.ListSandboxesResponse.sandboxes:type_name -> agentcompose.v2.Sandbox - 101, // 119: agentcompose.v2.GetSandboxResponse.sandbox:type_name -> agentcompose.v2.Sandbox - 101, // 120: agentcompose.v2.StopSandboxResponse.sandbox:type_name -> agentcompose.v2.Sandbox - 101, // 121: agentcompose.v2.ResumeSandboxResponse.sandbox:type_name -> agentcompose.v2.Sandbox - 17, // 122: agentcompose.v2.MetricValue.status:type_name -> agentcompose.v2.MetricStatus - 110, // 123: agentcompose.v2.SandboxStats.cpu_percent:type_name -> agentcompose.v2.MetricValue - 110, // 124: agentcompose.v2.SandboxStats.memory_usage_bytes:type_name -> agentcompose.v2.MetricValue - 110, // 125: agentcompose.v2.SandboxStats.memory_limit_bytes:type_name -> agentcompose.v2.MetricValue - 110, // 126: agentcompose.v2.SandboxStats.memory_percent:type_name -> agentcompose.v2.MetricValue - 110, // 127: agentcompose.v2.SandboxStats.network_rx_bytes:type_name -> agentcompose.v2.MetricValue - 110, // 128: agentcompose.v2.SandboxStats.network_tx_bytes:type_name -> agentcompose.v2.MetricValue - 110, // 129: agentcompose.v2.SandboxStats.block_read_bytes:type_name -> agentcompose.v2.MetricValue - 110, // 130: agentcompose.v2.SandboxStats.block_write_bytes:type_name -> agentcompose.v2.MetricValue - 110, // 131: agentcompose.v2.SandboxStats.uptime_seconds:type_name -> agentcompose.v2.MetricValue - 4, // 132: agentcompose.v2.RunSummary.source:type_name -> agentcompose.v2.RunSource - 3, // 133: agentcompose.v2.RunSummary.status:type_name -> agentcompose.v2.RunStatus - 112, // 134: agentcompose.v2.RunDetail.summary:type_name -> agentcompose.v2.RunSummary - 115, // 135: agentcompose.v2.ExecRequest.selector:type_name -> agentcompose.v2.ExecSandboxSelector - 116, // 136: agentcompose.v2.ExecRequest.command:type_name -> agentcompose.v2.ExecCommand - 65, // 137: agentcompose.v2.ExecRequest.env:type_name -> agentcompose.v2.EnvVarSpec - 135, // 138: agentcompose.v2.ExecResponse.result:type_name -> agentcompose.v2.ExecResult - 11, // 139: agentcompose.v2.ExecStreamResponse.event_type:type_name -> agentcompose.v2.ExecStreamEventType - 13, // 140: agentcompose.v2.ExecStreamResponse.stream:type_name -> agentcompose.v2.StdioStream - 135, // 141: agentcompose.v2.ExecStreamResponse.result:type_name -> agentcompose.v2.ExecResult - 82, // 142: agentcompose.v2.ExecStreamResponse.transcript:type_name -> agentcompose.v2.TranscriptEvent - 121, // 143: agentcompose.v2.ExecAttachRequest.start:type_name -> agentcompose.v2.ExecAttachStart - 123, // 144: agentcompose.v2.ExecAttachRequest.stdin:type_name -> agentcompose.v2.AttachStdin - 124, // 145: agentcompose.v2.ExecAttachRequest.stdin_eof:type_name -> agentcompose.v2.AttachStdinEOF - 125, // 146: agentcompose.v2.ExecAttachRequest.resize:type_name -> agentcompose.v2.AttachResize - 126, // 147: agentcompose.v2.ExecAttachRequest.signal:type_name -> agentcompose.v2.AttachSignal - 128, // 148: agentcompose.v2.ExecAttachRequest.cancel:type_name -> agentcompose.v2.AttachCancel - 127, // 149: agentcompose.v2.ExecAttachRequest.human_message:type_name -> agentcompose.v2.AttachHumanMessage - 129, // 150: agentcompose.v2.ExecAttachResponse.started:type_name -> agentcompose.v2.AttachStarted - 130, // 151: agentcompose.v2.ExecAttachResponse.output:type_name -> agentcompose.v2.AttachOutput - 133, // 152: agentcompose.v2.ExecAttachResponse.result:type_name -> agentcompose.v2.AttachResult - 134, // 153: agentcompose.v2.ExecAttachResponse.error:type_name -> agentcompose.v2.AttachError - 131, // 154: agentcompose.v2.ExecAttachResponse.agent_event:type_name -> agentcompose.v2.AttachAgentEvent - 132, // 155: agentcompose.v2.ExecAttachResponse.agent_turn_completed:type_name -> agentcompose.v2.AttachAgentTurnCompleted - 114, // 156: agentcompose.v2.ExecAttachStart.request:type_name -> agentcompose.v2.ExecRequest - 122, // 157: agentcompose.v2.ExecAttachStart.terminal_size:type_name -> agentcompose.v2.AttachTerminalSize - 12, // 158: agentcompose.v2.ExecAttachStart.mode:type_name -> agentcompose.v2.AttachRunMode - 122, // 159: agentcompose.v2.AttachResize.terminal_size:type_name -> agentcompose.v2.AttachTerminalSize - 225, // 160: agentcompose.v2.AttachHumanMessage.metadata:type_name -> agentcompose.v2.AttachHumanMessage.MetadataEntry - 112, // 161: agentcompose.v2.AttachStarted.run:type_name -> agentcompose.v2.RunSummary - 13, // 162: agentcompose.v2.AttachOutput.stream:type_name -> agentcompose.v2.StdioStream - 82, // 163: agentcompose.v2.AttachOutput.transcript:type_name -> agentcompose.v2.TranscriptEvent - 135, // 164: agentcompose.v2.AttachResult.exec_result:type_name -> agentcompose.v2.ExecResult - 112, // 165: agentcompose.v2.AttachResult.run:type_name -> agentcompose.v2.RunSummary - 226, // 166: agentcompose.v2.AttachError.details:type_name -> agentcompose.v2.AttachError.DetailsEntry - 116, // 167: agentcompose.v2.ExecResult.command:type_name -> agentcompose.v2.ExecCommand - 14, // 168: agentcompose.v2.ListImagesRequest.store:type_name -> agentcompose.v2.ImageStoreKind - 168, // 169: agentcompose.v2.ListImagesResponse.images:type_name -> agentcompose.v2.Image - 170, // 170: agentcompose.v2.ListImagesResponse.store_status:type_name -> agentcompose.v2.ImageStoreStatus - 14, // 171: agentcompose.v2.PullImageRequest.store:type_name -> agentcompose.v2.ImageStoreKind - 169, // 172: agentcompose.v2.PullImageRequest.platform:type_name -> agentcompose.v2.ImagePlatform - 168, // 173: agentcompose.v2.PullImageResponse.image:type_name -> agentcompose.v2.Image - 16, // 174: agentcompose.v2.PullImageResponse.status:type_name -> agentcompose.v2.ImageOperationStatus - 173, // 175: agentcompose.v2.PullImageResponse.progress:type_name -> agentcompose.v2.ImagePullProgress - 14, // 176: agentcompose.v2.InspectImageRequest.store:type_name -> agentcompose.v2.ImageStoreKind - 168, // 177: agentcompose.v2.InspectImageResponse.image:type_name -> agentcompose.v2.Image - 170, // 178: agentcompose.v2.InspectImageResponse.store_status:type_name -> agentcompose.v2.ImageStoreStatus - 14, // 179: agentcompose.v2.RemoveImageRequest.store:type_name -> agentcompose.v2.ImageStoreKind - 227, // 180: agentcompose.v2.BuildImageRequest.build_args:type_name -> agentcompose.v2.BuildImageRequest.BuildArgsEntry - 14, // 181: agentcompose.v2.BuildImageRequest.store:type_name -> agentcompose.v2.ImageStoreKind - 169, // 182: agentcompose.v2.BuildImageRequest.platform:type_name -> agentcompose.v2.ImagePlatform - 16, // 183: agentcompose.v2.BuildImageEvent.status:type_name -> agentcompose.v2.ImageOperationStatus - 168, // 184: agentcompose.v2.BuildImageEvent.image:type_name -> agentcompose.v2.Image - 18, // 185: agentcompose.v2.CacheFilter.domain:type_name -> agentcompose.v2.CacheDomain - 19, // 186: agentcompose.v2.CacheFilter.status:type_name -> agentcompose.v2.CacheStatus - 146, // 187: agentcompose.v2.ListCachesRequest.filter:type_name -> agentcompose.v2.CacheFilter - 155, // 188: agentcompose.v2.ListCachesResponse.caches:type_name -> agentcompose.v2.CacheItem - 155, // 189: agentcompose.v2.InspectCacheResponse.cache:type_name -> agentcompose.v2.CacheItem - 146, // 190: agentcompose.v2.PruneCachesRequest.filter:type_name -> agentcompose.v2.CacheFilter - 155, // 191: agentcompose.v2.PruneCachesResponse.matched:type_name -> agentcompose.v2.CacheItem - 155, // 192: agentcompose.v2.PruneCachesResponse.skipped:type_name -> agentcompose.v2.CacheItem - 155, // 193: agentcompose.v2.RemoveCacheResponse.matched:type_name -> agentcompose.v2.CacheItem - 155, // 194: agentcompose.v2.RemoveCacheResponse.skipped:type_name -> agentcompose.v2.CacheItem - 18, // 195: agentcompose.v2.CacheItem.domain:type_name -> agentcompose.v2.CacheDomain - 19, // 196: agentcompose.v2.CacheItem.status:type_name -> agentcompose.v2.CacheStatus - 156, // 197: agentcompose.v2.CacheItem.references:type_name -> agentcompose.v2.CacheReference - 167, // 198: agentcompose.v2.ListVolumesResponse.volumes:type_name -> agentcompose.v2.Volume - 228, // 199: agentcompose.v2.CreateVolumeRequest.labels:type_name -> agentcompose.v2.CreateVolumeRequest.LabelsEntry - 229, // 200: agentcompose.v2.CreateVolumeRequest.options:type_name -> agentcompose.v2.CreateVolumeRequest.OptionsEntry - 167, // 201: agentcompose.v2.CreateVolumeResponse.volume:type_name -> agentcompose.v2.Volume - 167, // 202: agentcompose.v2.InspectVolumeResponse.volume:type_name -> agentcompose.v2.Volume - 167, // 203: agentcompose.v2.PruneVolumesResponse.matched:type_name -> agentcompose.v2.Volume - 167, // 204: agentcompose.v2.PruneVolumesResponse.removed:type_name -> agentcompose.v2.Volume - 167, // 205: agentcompose.v2.PruneVolumesResponse.skipped:type_name -> agentcompose.v2.Volume - 230, // 206: agentcompose.v2.Volume.labels:type_name -> agentcompose.v2.Volume.LabelsEntry - 231, // 207: agentcompose.v2.Volume.options:type_name -> agentcompose.v2.Volume.OptionsEntry - 14, // 208: agentcompose.v2.Image.store:type_name -> agentcompose.v2.ImageStoreKind - 15, // 209: agentcompose.v2.Image.availability_status:type_name -> agentcompose.v2.ImageAvailabilityStatus - 169, // 210: agentcompose.v2.Image.platform:type_name -> agentcompose.v2.ImagePlatform - 171, // 211: agentcompose.v2.Image.docker:type_name -> agentcompose.v2.DockerImageStatus - 172, // 212: agentcompose.v2.Image.oci:type_name -> agentcompose.v2.OCIImageStatus - 232, // 213: agentcompose.v2.Image.labels:type_name -> agentcompose.v2.Image.LabelsEntry - 14, // 214: agentcompose.v2.ImageStoreStatus.store:type_name -> agentcompose.v2.ImageStoreKind - 76, // 215: agentcompose.v2.StartRunRequest.run:type_name -> agentcompose.v2.RunAgentRequest - 112, // 216: agentcompose.v2.StartRunResponse.run:type_name -> agentcompose.v2.RunSummary - 20, // 217: agentcompose.v2.ResolveResourceIDRequest.kinds:type_name -> agentcompose.v2.ResourceKind - 181, // 218: agentcompose.v2.ResolveResourceIDResponse.targets:type_name -> agentcompose.v2.ResourceTarget - 20, // 219: agentcompose.v2.ResourceTarget.kind:type_name -> agentcompose.v2.ResourceKind - 184, // 220: agentcompose.v2.DashboardOverview.runs:type_name -> agentcompose.v2.RunOverview - 234, // 221: agentcompose.v2.DashboardOverview.updated_at:type_name -> google.protobuf.Timestamp - 185, // 222: agentcompose.v2.GetDashboardOverviewResponse.overview:type_name -> agentcompose.v2.DashboardOverview - 185, // 223: agentcompose.v2.WatchDashboardOverviewResponse.overview:type_name -> agentcompose.v2.DashboardOverview - 65, // 224: agentcompose.v2.GetGlobalEnvResponse.env:type_name -> agentcompose.v2.EnvVarSpec - 66, // 225: agentcompose.v2.UpdateGlobalEnvRequest.env:type_name -> agentcompose.v2.EnvVarUpdateSpec - 65, // 226: agentcompose.v2.UpdateGlobalEnvResponse.env:type_name -> agentcompose.v2.EnvVarSpec - 193, // 227: agentcompose.v2.GetCapabilityGatewayConfigResponse.config:type_name -> agentcompose.v2.CapabilityGatewayConfig - 193, // 228: agentcompose.v2.UpdateCapabilityGatewayConfigResponse.config:type_name -> agentcompose.v2.CapabilityGatewayConfig - 234, // 229: agentcompose.v2.WorkspacePreset.created_at:type_name -> google.protobuf.Timestamp - 234, // 230: agentcompose.v2.WorkspacePreset.updated_at:type_name -> google.protobuf.Timestamp - 197, // 231: agentcompose.v2.ListWorkspacePresetsResponse.presets:type_name -> agentcompose.v2.WorkspacePreset - 197, // 232: agentcompose.v2.WorkspacePresetResponse.preset:type_name -> agentcompose.v2.WorkspacePreset - 208, // 233: agentcompose.v2.ListCapabilitySetsResponse.capsets:type_name -> agentcompose.v2.CapabilitySet - 233, // 234: agentcompose.v2.CapabilityEndpoint.metadata:type_name -> agentcompose.v2.CapabilityEndpoint.MetadataEntry - 211, // 235: agentcompose.v2.CapabilityMethod.endpoints:type_name -> agentcompose.v2.CapabilityEndpoint - 212, // 236: agentcompose.v2.GetCapabilityCatalogResponse.methods:type_name -> agentcompose.v2.CapabilityMethod - 234, // 237: agentcompose.v2.SandboxHistoryCell.created_at:type_name -> google.protobuf.Timestamp - 234, // 238: agentcompose.v2.SandboxHistoryEvent.created_at:type_name -> google.protobuf.Timestamp - 215, // 239: agentcompose.v2.ListSandboxHistoryResponse.cells:type_name -> agentcompose.v2.SandboxHistoryCell - 216, // 240: agentcompose.v2.ListSandboxHistoryResponse.events:type_name -> agentcompose.v2.SandboxHistoryEvent - 21, // 241: agentcompose.v2.WatchSandboxResponse.event_type:type_name -> agentcompose.v2.SandboxWatchEventType - 101, // 242: agentcompose.v2.WatchSandboxResponse.sandbox:type_name -> agentcompose.v2.Sandbox - 215, // 243: agentcompose.v2.WatchSandboxResponse.cell:type_name -> agentcompose.v2.SandboxHistoryCell - 216, // 244: agentcompose.v2.WatchSandboxResponse.event:type_name -> agentcompose.v2.SandboxHistoryEvent - 13, // 245: agentcompose.v2.WatchSandboxResponse.stream:type_name -> agentcompose.v2.StdioStream - 22, // 246: agentcompose.v2.ProjectService.ValidateProject:input_type -> agentcompose.v2.ValidateProjectRequest - 24, // 247: agentcompose.v2.ProjectService.ApplyProject:input_type -> agentcompose.v2.ApplyProjectRequest - 26, // 248: agentcompose.v2.ProjectService.GetProject:input_type -> agentcompose.v2.GetProjectRequest - 28, // 249: agentcompose.v2.ProjectService.ListProjects:input_type -> agentcompose.v2.ListProjectsRequest - 30, // 250: agentcompose.v2.ProjectService.RemoveProject:input_type -> agentcompose.v2.RemoveProjectRequest - 32, // 251: agentcompose.v2.ProjectService.WatchProject:input_type -> agentcompose.v2.WatchProjectRequest - 43, // 252: agentcompose.v2.ProjectService.GetScheduler:input_type -> agentcompose.v2.GetSchedulerRequest - 46, // 253: agentcompose.v2.ProjectService.ListSchedulers:input_type -> agentcompose.v2.ListSchedulersRequest - 49, // 254: agentcompose.v2.ProjectService.ListSchedulerEvents:input_type -> agentcompose.v2.ListSchedulerEventsRequest - 52, // 255: agentcompose.v2.ProjectService.SetSchedulerEnabled:input_type -> agentcompose.v2.SetSchedulerEnabledRequest - 54, // 256: agentcompose.v2.ProjectService.SetSchedulerTriggerEnabled:input_type -> agentcompose.v2.SetSchedulerTriggerEnabledRequest - 76, // 257: agentcompose.v2.RunService.RunAgent:input_type -> agentcompose.v2.RunAgentRequest - 176, // 258: agentcompose.v2.RunService.StartRun:input_type -> agentcompose.v2.StartRunRequest - 76, // 259: agentcompose.v2.RunService.RunAgentStream:input_type -> agentcompose.v2.RunAgentRequest - 79, // 260: agentcompose.v2.RunService.RunAttach:input_type -> agentcompose.v2.RunAttachRequest - 83, // 261: agentcompose.v2.RunService.GetRun:input_type -> agentcompose.v2.GetRunRequest - 85, // 262: agentcompose.v2.RunService.ListRuns:input_type -> agentcompose.v2.ListRunsRequest - 87, // 263: agentcompose.v2.RunService.FollowRunLogs:input_type -> agentcompose.v2.FollowRunLogsRequest - 89, // 264: agentcompose.v2.RunService.StopRun:input_type -> agentcompose.v2.StopRunRequest - 91, // 265: agentcompose.v2.RunService.ListRunEvents:input_type -> agentcompose.v2.ListRunEventsRequest - 94, // 266: agentcompose.v2.RunService.ListSandboxRunEvents:input_type -> agentcompose.v2.ListSandboxRunEventsRequest - 114, // 267: agentcompose.v2.ExecService.Exec:input_type -> agentcompose.v2.ExecRequest - 114, // 268: agentcompose.v2.ExecService.ExecStream:input_type -> agentcompose.v2.ExecRequest - 119, // 269: agentcompose.v2.ExecService.ExecAttach:input_type -> agentcompose.v2.ExecAttachRequest - 136, // 270: agentcompose.v2.ImageService.ListImages:input_type -> agentcompose.v2.ListImagesRequest - 138, // 271: agentcompose.v2.ImageService.PullImage:input_type -> agentcompose.v2.PullImageRequest - 140, // 272: agentcompose.v2.ImageService.InspectImage:input_type -> agentcompose.v2.InspectImageRequest - 142, // 273: agentcompose.v2.ImageService.RemoveImage:input_type -> agentcompose.v2.RemoveImageRequest - 144, // 274: agentcompose.v2.ImageService.BuildImage:input_type -> agentcompose.v2.BuildImageRequest - 147, // 275: agentcompose.v2.CacheService.ListCaches:input_type -> agentcompose.v2.ListCachesRequest - 149, // 276: agentcompose.v2.CacheService.InspectCache:input_type -> agentcompose.v2.InspectCacheRequest - 151, // 277: agentcompose.v2.CacheService.PruneCaches:input_type -> agentcompose.v2.PruneCachesRequest - 153, // 278: agentcompose.v2.CacheService.RemoveCache:input_type -> agentcompose.v2.RemoveCacheRequest - 157, // 279: agentcompose.v2.VolumeService.ListVolumes:input_type -> agentcompose.v2.ListVolumesRequest - 159, // 280: agentcompose.v2.VolumeService.CreateVolume:input_type -> agentcompose.v2.CreateVolumeRequest - 161, // 281: agentcompose.v2.VolumeService.InspectVolume:input_type -> agentcompose.v2.InspectVolumeRequest - 163, // 282: agentcompose.v2.VolumeService.RemoveVolume:input_type -> agentcompose.v2.RemoveVolumeRequest - 165, // 283: agentcompose.v2.VolumeService.PruneVolumes:input_type -> agentcompose.v2.PruneVolumesRequest - 96, // 284: agentcompose.v2.SandboxService.RemoveSandbox:input_type -> agentcompose.v2.RemoveSandboxRequest - 98, // 285: agentcompose.v2.SandboxService.GetSandboxStats:input_type -> agentcompose.v2.GetSandboxStatsRequest - 100, // 286: agentcompose.v2.SandboxService.GetSandbox:input_type -> agentcompose.v2.GetSandboxRequest - 106, // 287: agentcompose.v2.SandboxService.StopSandbox:input_type -> agentcompose.v2.StopSandboxRequest - 108, // 288: agentcompose.v2.SandboxService.ResumeSandbox:input_type -> agentcompose.v2.ResumeSandboxRequest - 103, // 289: agentcompose.v2.SandboxService.ListSandboxes:input_type -> agentcompose.v2.ListSandboxesRequest - 214, // 290: agentcompose.v2.SandboxService.ListSandboxHistory:input_type -> agentcompose.v2.ListSandboxHistoryRequest - 218, // 291: agentcompose.v2.SandboxService.WatchSandbox:input_type -> agentcompose.v2.WatchSandboxRequest - 182, // 292: agentcompose.v2.DashboardService.GetDashboardOverview:input_type -> agentcompose.v2.GetDashboardOverviewRequest - 183, // 293: agentcompose.v2.DashboardService.WatchDashboardOverview:input_type -> agentcompose.v2.WatchDashboardOverviewRequest - 188, // 294: agentcompose.v2.SettingsService.GetGlobalEnv:input_type -> agentcompose.v2.GetGlobalEnvRequest - 190, // 295: agentcompose.v2.SettingsService.UpdateGlobalEnv:input_type -> agentcompose.v2.UpdateGlobalEnvRequest - 192, // 296: agentcompose.v2.SettingsService.GetCapabilityGatewayConfig:input_type -> agentcompose.v2.GetCapabilityGatewayConfigRequest - 195, // 297: agentcompose.v2.SettingsService.UpdateCapabilityGatewayConfig:input_type -> agentcompose.v2.UpdateCapabilityGatewayConfigRequest - 198, // 298: agentcompose.v2.SettingsService.ListWorkspacePresets:input_type -> agentcompose.v2.ListWorkspacePresetsRequest - 200, // 299: agentcompose.v2.SettingsService.CreateWorkspacePreset:input_type -> agentcompose.v2.CreateWorkspacePresetRequest - 201, // 300: agentcompose.v2.SettingsService.UpdateWorkspacePreset:input_type -> agentcompose.v2.UpdateWorkspacePresetRequest - 202, // 301: agentcompose.v2.SettingsService.DeleteWorkspacePreset:input_type -> agentcompose.v2.DeleteWorkspacePresetRequest - 205, // 302: agentcompose.v2.CapabilityService.GetCapabilityStatus:input_type -> agentcompose.v2.GetCapabilityStatusRequest - 207, // 303: agentcompose.v2.CapabilityService.ListCapabilitySets:input_type -> agentcompose.v2.ListCapabilitySetsRequest - 210, // 304: agentcompose.v2.CapabilityService.GetCapabilityCatalog:input_type -> agentcompose.v2.GetCapabilityCatalogRequest - 220, // 305: agentcompose.v2.LLMService.Generate:input_type -> agentcompose.v2.GenerateLLMRequest - 179, // 306: agentcompose.v2.ResourceService.ResolveID:input_type -> agentcompose.v2.ResolveResourceIDRequest - 23, // 307: agentcompose.v2.ProjectService.ValidateProject:output_type -> agentcompose.v2.ValidateProjectResponse - 25, // 308: agentcompose.v2.ProjectService.ApplyProject:output_type -> agentcompose.v2.ApplyProjectResponse - 27, // 309: agentcompose.v2.ProjectService.GetProject:output_type -> agentcompose.v2.GetProjectResponse - 29, // 310: agentcompose.v2.ProjectService.ListProjects:output_type -> agentcompose.v2.ListProjectsResponse - 31, // 311: agentcompose.v2.ProjectService.RemoveProject:output_type -> agentcompose.v2.RemoveProjectResponse - 33, // 312: agentcompose.v2.ProjectService.WatchProject:output_type -> agentcompose.v2.WatchProjectResponse - 44, // 313: agentcompose.v2.ProjectService.GetScheduler:output_type -> agentcompose.v2.GetSchedulerResponse - 48, // 314: agentcompose.v2.ProjectService.ListSchedulers:output_type -> agentcompose.v2.ListSchedulersResponse - 51, // 315: agentcompose.v2.ProjectService.ListSchedulerEvents:output_type -> agentcompose.v2.ListSchedulerEventsResponse - 53, // 316: agentcompose.v2.ProjectService.SetSchedulerEnabled:output_type -> agentcompose.v2.SetSchedulerEnabledResponse - 55, // 317: agentcompose.v2.ProjectService.SetSchedulerTriggerEnabled:output_type -> agentcompose.v2.SetSchedulerTriggerEnabledResponse - 77, // 318: agentcompose.v2.RunService.RunAgent:output_type -> agentcompose.v2.RunAgentResponse - 177, // 319: agentcompose.v2.RunService.StartRun:output_type -> agentcompose.v2.StartRunResponse - 78, // 320: agentcompose.v2.RunService.RunAgentStream:output_type -> agentcompose.v2.RunAgentStreamResponse - 80, // 321: agentcompose.v2.RunService.RunAttach:output_type -> agentcompose.v2.RunAttachResponse - 84, // 322: agentcompose.v2.RunService.GetRun:output_type -> agentcompose.v2.GetRunResponse - 86, // 323: agentcompose.v2.RunService.ListRuns:output_type -> agentcompose.v2.ListRunsResponse - 88, // 324: agentcompose.v2.RunService.FollowRunLogs:output_type -> agentcompose.v2.RunLogChunk - 90, // 325: agentcompose.v2.RunService.StopRun:output_type -> agentcompose.v2.StopRunResponse - 93, // 326: agentcompose.v2.RunService.ListRunEvents:output_type -> agentcompose.v2.ListRunEventsResponse - 95, // 327: agentcompose.v2.RunService.ListSandboxRunEvents:output_type -> agentcompose.v2.ListSandboxRunEventsResponse - 117, // 328: agentcompose.v2.ExecService.Exec:output_type -> agentcompose.v2.ExecResponse - 118, // 329: agentcompose.v2.ExecService.ExecStream:output_type -> agentcompose.v2.ExecStreamResponse - 120, // 330: agentcompose.v2.ExecService.ExecAttach:output_type -> agentcompose.v2.ExecAttachResponse - 137, // 331: agentcompose.v2.ImageService.ListImages:output_type -> agentcompose.v2.ListImagesResponse - 139, // 332: agentcompose.v2.ImageService.PullImage:output_type -> agentcompose.v2.PullImageResponse - 141, // 333: agentcompose.v2.ImageService.InspectImage:output_type -> agentcompose.v2.InspectImageResponse - 143, // 334: agentcompose.v2.ImageService.RemoveImage:output_type -> agentcompose.v2.RemoveImageResponse - 145, // 335: agentcompose.v2.ImageService.BuildImage:output_type -> agentcompose.v2.BuildImageEvent - 148, // 336: agentcompose.v2.CacheService.ListCaches:output_type -> agentcompose.v2.ListCachesResponse - 150, // 337: agentcompose.v2.CacheService.InspectCache:output_type -> agentcompose.v2.InspectCacheResponse - 152, // 338: agentcompose.v2.CacheService.PruneCaches:output_type -> agentcompose.v2.PruneCachesResponse - 154, // 339: agentcompose.v2.CacheService.RemoveCache:output_type -> agentcompose.v2.RemoveCacheResponse - 158, // 340: agentcompose.v2.VolumeService.ListVolumes:output_type -> agentcompose.v2.ListVolumesResponse - 160, // 341: agentcompose.v2.VolumeService.CreateVolume:output_type -> agentcompose.v2.CreateVolumeResponse - 162, // 342: agentcompose.v2.VolumeService.InspectVolume:output_type -> agentcompose.v2.InspectVolumeResponse - 164, // 343: agentcompose.v2.VolumeService.RemoveVolume:output_type -> agentcompose.v2.RemoveVolumeResponse - 166, // 344: agentcompose.v2.VolumeService.PruneVolumes:output_type -> agentcompose.v2.PruneVolumesResponse - 97, // 345: agentcompose.v2.SandboxService.RemoveSandbox:output_type -> agentcompose.v2.RemoveSandboxResponse - 99, // 346: agentcompose.v2.SandboxService.GetSandboxStats:output_type -> agentcompose.v2.GetSandboxStatsResponse - 105, // 347: agentcompose.v2.SandboxService.GetSandbox:output_type -> agentcompose.v2.GetSandboxResponse - 107, // 348: agentcompose.v2.SandboxService.StopSandbox:output_type -> agentcompose.v2.StopSandboxResponse - 109, // 349: agentcompose.v2.SandboxService.ResumeSandbox:output_type -> agentcompose.v2.ResumeSandboxResponse - 104, // 350: agentcompose.v2.SandboxService.ListSandboxes:output_type -> agentcompose.v2.ListSandboxesResponse - 217, // 351: agentcompose.v2.SandboxService.ListSandboxHistory:output_type -> agentcompose.v2.ListSandboxHistoryResponse - 219, // 352: agentcompose.v2.SandboxService.WatchSandbox:output_type -> agentcompose.v2.WatchSandboxResponse - 186, // 353: agentcompose.v2.DashboardService.GetDashboardOverview:output_type -> agentcompose.v2.GetDashboardOverviewResponse - 187, // 354: agentcompose.v2.DashboardService.WatchDashboardOverview:output_type -> agentcompose.v2.WatchDashboardOverviewResponse - 189, // 355: agentcompose.v2.SettingsService.GetGlobalEnv:output_type -> agentcompose.v2.GetGlobalEnvResponse - 191, // 356: agentcompose.v2.SettingsService.UpdateGlobalEnv:output_type -> agentcompose.v2.UpdateGlobalEnvResponse - 194, // 357: agentcompose.v2.SettingsService.GetCapabilityGatewayConfig:output_type -> agentcompose.v2.GetCapabilityGatewayConfigResponse - 196, // 358: agentcompose.v2.SettingsService.UpdateCapabilityGatewayConfig:output_type -> agentcompose.v2.UpdateCapabilityGatewayConfigResponse - 199, // 359: agentcompose.v2.SettingsService.ListWorkspacePresets:output_type -> agentcompose.v2.ListWorkspacePresetsResponse - 204, // 360: agentcompose.v2.SettingsService.CreateWorkspacePreset:output_type -> agentcompose.v2.WorkspacePresetResponse - 204, // 361: agentcompose.v2.SettingsService.UpdateWorkspacePreset:output_type -> agentcompose.v2.WorkspacePresetResponse - 203, // 362: agentcompose.v2.SettingsService.DeleteWorkspacePreset:output_type -> agentcompose.v2.DeleteWorkspacePresetResponse - 206, // 363: agentcompose.v2.CapabilityService.GetCapabilityStatus:output_type -> agentcompose.v2.CapabilityStatusResponse - 209, // 364: agentcompose.v2.CapabilityService.ListCapabilitySets:output_type -> agentcompose.v2.ListCapabilitySetsResponse - 213, // 365: agentcompose.v2.CapabilityService.GetCapabilityCatalog:output_type -> agentcompose.v2.GetCapabilityCatalogResponse - 221, // 366: agentcompose.v2.LLMService.Generate:output_type -> agentcompose.v2.GenerateLLMResponse - 180, // 367: agentcompose.v2.ResourceService.ResolveID:output_type -> agentcompose.v2.ResolveResourceIDResponse - 307, // [307:368] is the sub-list for method output_type - 246, // [246:307] is the sub-list for method input_type - 246, // [246:246] is the sub-list for extension type_name - 246, // [246:246] is the sub-list for extension extendee - 0, // [0:246] is the sub-list for field type_name + 69, // 56: agentcompose.v2.ProjectSpec.networks:type_name -> agentcompose.v2.NamedNetworkSpec + 67, // 57: agentcompose.v2.NamedWorkspaceSpec.workspace:type_name -> agentcompose.v2.WorkspaceSpec + 75, // 58: agentcompose.v2.AgentSpec.driver:type_name -> agentcompose.v2.DriverSpec + 65, // 59: agentcompose.v2.AgentSpec.env:type_name -> agentcompose.v2.EnvVarSpec + 67, // 60: agentcompose.v2.AgentSpec.workspace:type_name -> agentcompose.v2.WorkspaceSpec + 72, // 61: agentcompose.v2.AgentSpec.scheduler:type_name -> agentcompose.v2.SchedulerSpec + 180, // 62: agentcompose.v2.AgentSpec.jupyter:type_name -> agentcompose.v2.JupyterSpec + 64, // 63: agentcompose.v2.AgentSpec.build:type_name -> agentcompose.v2.BuildSpec + 63, // 64: agentcompose.v2.AgentSpec.volumes:type_name -> agentcompose.v2.VolumeMountSpec + 61, // 65: agentcompose.v2.AgentSpec.mcps:type_name -> agentcompose.v2.MCPServerSpec + 184, // 66: agentcompose.v2.AgentSpec.skills:type_name -> agentcompose.v2.SkillSpec + 5, // 67: agentcompose.v2.AgentSpec.status:type_name -> agentcompose.v2.AgentStatus + 70, // 68: agentcompose.v2.AgentSpec.expose:type_name -> agentcompose.v2.ExposedPortSpec + 71, // 69: agentcompose.v2.AgentSpec.ports:type_name -> agentcompose.v2.PublishedPortSpec + 65, // 70: agentcompose.v2.MCPServerSpec.env:type_name -> agentcompose.v2.EnvVarSpec + 65, // 71: agentcompose.v2.MCPServerSpec.headers:type_name -> agentcompose.v2.EnvVarSpec + 228, // 72: agentcompose.v2.ProjectVolumeSpec.labels:type_name -> agentcompose.v2.ProjectVolumeSpec.LabelsEntry + 229, // 73: agentcompose.v2.ProjectVolumeSpec.options:type_name -> agentcompose.v2.ProjectVolumeSpec.OptionsEntry + 230, // 74: agentcompose.v2.BuildSpec.args:type_name -> agentcompose.v2.BuildSpec.ArgsEntry + 73, // 75: agentcompose.v2.SchedulerSpec.triggers:type_name -> agentcompose.v2.TriggerSpec + 74, // 76: agentcompose.v2.TriggerSpec.event:type_name -> agentcompose.v2.EventTriggerSpec + 76, // 77: agentcompose.v2.DriverSpec.boxlite:type_name -> agentcompose.v2.BoxliteDriverSpec + 77, // 78: agentcompose.v2.DriverSpec.docker:type_name -> agentcompose.v2.DockerDriverSpec + 78, // 79: agentcompose.v2.DriverSpec.microsandbox:type_name -> agentcompose.v2.MicrosandboxDriverSpec + 4, // 80: agentcompose.v2.RunAgentRequest.source:type_name -> agentcompose.v2.RunSource + 65, // 81: agentcompose.v2.RunAgentRequest.env:type_name -> agentcompose.v2.EnvVarSpec + 10, // 82: agentcompose.v2.RunAgentRequest.cleanup_policy:type_name -> agentcompose.v2.RunSandboxCleanupPolicy + 181, // 83: agentcompose.v2.RunAgentRequest.jupyter:type_name -> agentcompose.v2.RunJupyterSpec + 63, // 84: agentcompose.v2.RunAgentRequest.volumes:type_name -> agentcompose.v2.VolumeMountSpec + 119, // 85: agentcompose.v2.RunAgentResponse.run:type_name -> agentcompose.v2.RunDetail + 9, // 86: agentcompose.v2.RunAgentStreamResponse.event_type:type_name -> agentcompose.v2.RunAgentStreamEventType + 118, // 87: agentcompose.v2.RunAgentStreamResponse.run:type_name -> agentcompose.v2.RunSummary + 13, // 88: agentcompose.v2.RunAgentStreamResponse.stream:type_name -> agentcompose.v2.StdioStream + 85, // 89: agentcompose.v2.RunAgentStreamResponse.transcript:type_name -> agentcompose.v2.TranscriptEvent + 84, // 90: agentcompose.v2.RunAttachRequest.start:type_name -> agentcompose.v2.RunAttachStart + 129, // 91: agentcompose.v2.RunAttachRequest.stdin:type_name -> agentcompose.v2.AttachStdin + 130, // 92: agentcompose.v2.RunAttachRequest.stdin_eof:type_name -> agentcompose.v2.AttachStdinEOF + 131, // 93: agentcompose.v2.RunAttachRequest.resize:type_name -> agentcompose.v2.AttachResize + 132, // 94: agentcompose.v2.RunAttachRequest.signal:type_name -> agentcompose.v2.AttachSignal + 133, // 95: agentcompose.v2.RunAttachRequest.human_message:type_name -> agentcompose.v2.AttachHumanMessage + 134, // 96: agentcompose.v2.RunAttachRequest.cancel:type_name -> agentcompose.v2.AttachCancel + 135, // 97: agentcompose.v2.RunAttachResponse.started:type_name -> agentcompose.v2.AttachStarted + 136, // 98: agentcompose.v2.RunAttachResponse.output:type_name -> agentcompose.v2.AttachOutput + 137, // 99: agentcompose.v2.RunAttachResponse.agent_event:type_name -> agentcompose.v2.AttachAgentEvent + 138, // 100: agentcompose.v2.RunAttachResponse.agent_turn_completed:type_name -> agentcompose.v2.AttachAgentTurnCompleted + 139, // 101: agentcompose.v2.RunAttachResponse.result:type_name -> agentcompose.v2.AttachResult + 140, // 102: agentcompose.v2.RunAttachResponse.error:type_name -> agentcompose.v2.AttachError + 79, // 103: agentcompose.v2.RunAttachStart.request:type_name -> agentcompose.v2.RunAgentRequest + 12, // 104: agentcompose.v2.RunAttachStart.mode:type_name -> agentcompose.v2.AttachRunMode + 128, // 105: agentcompose.v2.RunAttachStart.terminal_size:type_name -> agentcompose.v2.AttachTerminalSize + 13, // 106: agentcompose.v2.TranscriptEvent.stream:type_name -> agentcompose.v2.StdioStream + 119, // 107: agentcompose.v2.GetRunResponse.run:type_name -> agentcompose.v2.RunDetail + 3, // 108: agentcompose.v2.ListRunsRequest.status:type_name -> agentcompose.v2.RunStatus + 4, // 109: agentcompose.v2.ListRunsRequest.source:type_name -> agentcompose.v2.RunSource + 118, // 110: agentcompose.v2.ListRunsResponse.runs:type_name -> agentcompose.v2.RunSummary + 3, // 111: agentcompose.v2.RunLogChunk.run_status:type_name -> agentcompose.v2.RunStatus + 119, // 112: agentcompose.v2.StopRunResponse.run:type_name -> agentcompose.v2.RunDetail + 8, // 113: agentcompose.v2.RunEvent.kind:type_name -> agentcompose.v2.RunEventKind + 240, // 114: agentcompose.v2.RunEvent.created_at:type_name -> google.protobuf.Timestamp + 95, // 115: agentcompose.v2.ListRunEventsResponse.events:type_name -> agentcompose.v2.RunEvent + 95, // 116: agentcompose.v2.ListSandboxRunEventsResponse.events:type_name -> agentcompose.v2.RunEvent + 117, // 117: agentcompose.v2.GetSandboxStatsResponse.stats:type_name -> agentcompose.v2.SandboxStats + 240, // 118: agentcompose.v2.Sandbox.created_at:type_name -> google.protobuf.Timestamp + 240, // 119: agentcompose.v2.Sandbox.updated_at:type_name -> google.protobuf.Timestamp + 108, // 120: agentcompose.v2.Sandbox.tags:type_name -> agentcompose.v2.SandboxTag + 105, // 121: agentcompose.v2.Sandbox.network:type_name -> agentcompose.v2.SandboxNetworkState + 106, // 122: agentcompose.v2.SandboxNetworkState.attachments:type_name -> agentcompose.v2.SandboxNetworkEndpoint + 107, // 123: agentcompose.v2.SandboxNetworkState.bindings:type_name -> agentcompose.v2.SandboxPortBinding + 104, // 124: agentcompose.v2.ListSandboxesResponse.sandboxes:type_name -> agentcompose.v2.Sandbox + 104, // 125: agentcompose.v2.GetSandboxResponse.sandbox:type_name -> agentcompose.v2.Sandbox + 104, // 126: agentcompose.v2.StopSandboxResponse.sandbox:type_name -> agentcompose.v2.Sandbox + 104, // 127: agentcompose.v2.ResumeSandboxResponse.sandbox:type_name -> agentcompose.v2.Sandbox + 17, // 128: agentcompose.v2.MetricValue.status:type_name -> agentcompose.v2.MetricStatus + 116, // 129: agentcompose.v2.SandboxStats.cpu_percent:type_name -> agentcompose.v2.MetricValue + 116, // 130: agentcompose.v2.SandboxStats.memory_usage_bytes:type_name -> agentcompose.v2.MetricValue + 116, // 131: agentcompose.v2.SandboxStats.memory_limit_bytes:type_name -> agentcompose.v2.MetricValue + 116, // 132: agentcompose.v2.SandboxStats.memory_percent:type_name -> agentcompose.v2.MetricValue + 116, // 133: agentcompose.v2.SandboxStats.network_rx_bytes:type_name -> agentcompose.v2.MetricValue + 116, // 134: agentcompose.v2.SandboxStats.network_tx_bytes:type_name -> agentcompose.v2.MetricValue + 116, // 135: agentcompose.v2.SandboxStats.block_read_bytes:type_name -> agentcompose.v2.MetricValue + 116, // 136: agentcompose.v2.SandboxStats.block_write_bytes:type_name -> agentcompose.v2.MetricValue + 116, // 137: agentcompose.v2.SandboxStats.uptime_seconds:type_name -> agentcompose.v2.MetricValue + 4, // 138: agentcompose.v2.RunSummary.source:type_name -> agentcompose.v2.RunSource + 3, // 139: agentcompose.v2.RunSummary.status:type_name -> agentcompose.v2.RunStatus + 118, // 140: agentcompose.v2.RunDetail.summary:type_name -> agentcompose.v2.RunSummary + 121, // 141: agentcompose.v2.ExecRequest.selector:type_name -> agentcompose.v2.ExecSandboxSelector + 122, // 142: agentcompose.v2.ExecRequest.command:type_name -> agentcompose.v2.ExecCommand + 65, // 143: agentcompose.v2.ExecRequest.env:type_name -> agentcompose.v2.EnvVarSpec + 141, // 144: agentcompose.v2.ExecResponse.result:type_name -> agentcompose.v2.ExecResult + 11, // 145: agentcompose.v2.ExecStreamResponse.event_type:type_name -> agentcompose.v2.ExecStreamEventType + 13, // 146: agentcompose.v2.ExecStreamResponse.stream:type_name -> agentcompose.v2.StdioStream + 141, // 147: agentcompose.v2.ExecStreamResponse.result:type_name -> agentcompose.v2.ExecResult + 85, // 148: agentcompose.v2.ExecStreamResponse.transcript:type_name -> agentcompose.v2.TranscriptEvent + 127, // 149: agentcompose.v2.ExecAttachRequest.start:type_name -> agentcompose.v2.ExecAttachStart + 129, // 150: agentcompose.v2.ExecAttachRequest.stdin:type_name -> agentcompose.v2.AttachStdin + 130, // 151: agentcompose.v2.ExecAttachRequest.stdin_eof:type_name -> agentcompose.v2.AttachStdinEOF + 131, // 152: agentcompose.v2.ExecAttachRequest.resize:type_name -> agentcompose.v2.AttachResize + 132, // 153: agentcompose.v2.ExecAttachRequest.signal:type_name -> agentcompose.v2.AttachSignal + 134, // 154: agentcompose.v2.ExecAttachRequest.cancel:type_name -> agentcompose.v2.AttachCancel + 133, // 155: agentcompose.v2.ExecAttachRequest.human_message:type_name -> agentcompose.v2.AttachHumanMessage + 135, // 156: agentcompose.v2.ExecAttachResponse.started:type_name -> agentcompose.v2.AttachStarted + 136, // 157: agentcompose.v2.ExecAttachResponse.output:type_name -> agentcompose.v2.AttachOutput + 139, // 158: agentcompose.v2.ExecAttachResponse.result:type_name -> agentcompose.v2.AttachResult + 140, // 159: agentcompose.v2.ExecAttachResponse.error:type_name -> agentcompose.v2.AttachError + 137, // 160: agentcompose.v2.ExecAttachResponse.agent_event:type_name -> agentcompose.v2.AttachAgentEvent + 138, // 161: agentcompose.v2.ExecAttachResponse.agent_turn_completed:type_name -> agentcompose.v2.AttachAgentTurnCompleted + 120, // 162: agentcompose.v2.ExecAttachStart.request:type_name -> agentcompose.v2.ExecRequest + 128, // 163: agentcompose.v2.ExecAttachStart.terminal_size:type_name -> agentcompose.v2.AttachTerminalSize + 12, // 164: agentcompose.v2.ExecAttachStart.mode:type_name -> agentcompose.v2.AttachRunMode + 128, // 165: agentcompose.v2.AttachResize.terminal_size:type_name -> agentcompose.v2.AttachTerminalSize + 231, // 166: agentcompose.v2.AttachHumanMessage.metadata:type_name -> agentcompose.v2.AttachHumanMessage.MetadataEntry + 118, // 167: agentcompose.v2.AttachStarted.run:type_name -> agentcompose.v2.RunSummary + 13, // 168: agentcompose.v2.AttachOutput.stream:type_name -> agentcompose.v2.StdioStream + 85, // 169: agentcompose.v2.AttachOutput.transcript:type_name -> agentcompose.v2.TranscriptEvent + 141, // 170: agentcompose.v2.AttachResult.exec_result:type_name -> agentcompose.v2.ExecResult + 118, // 171: agentcompose.v2.AttachResult.run:type_name -> agentcompose.v2.RunSummary + 232, // 172: agentcompose.v2.AttachError.details:type_name -> agentcompose.v2.AttachError.DetailsEntry + 122, // 173: agentcompose.v2.ExecResult.command:type_name -> agentcompose.v2.ExecCommand + 14, // 174: agentcompose.v2.ListImagesRequest.store:type_name -> agentcompose.v2.ImageStoreKind + 174, // 175: agentcompose.v2.ListImagesResponse.images:type_name -> agentcompose.v2.Image + 176, // 176: agentcompose.v2.ListImagesResponse.store_status:type_name -> agentcompose.v2.ImageStoreStatus + 14, // 177: agentcompose.v2.PullImageRequest.store:type_name -> agentcompose.v2.ImageStoreKind + 175, // 178: agentcompose.v2.PullImageRequest.platform:type_name -> agentcompose.v2.ImagePlatform + 174, // 179: agentcompose.v2.PullImageResponse.image:type_name -> agentcompose.v2.Image + 16, // 180: agentcompose.v2.PullImageResponse.status:type_name -> agentcompose.v2.ImageOperationStatus + 179, // 181: agentcompose.v2.PullImageResponse.progress:type_name -> agentcompose.v2.ImagePullProgress + 14, // 182: agentcompose.v2.InspectImageRequest.store:type_name -> agentcompose.v2.ImageStoreKind + 174, // 183: agentcompose.v2.InspectImageResponse.image:type_name -> agentcompose.v2.Image + 176, // 184: agentcompose.v2.InspectImageResponse.store_status:type_name -> agentcompose.v2.ImageStoreStatus + 14, // 185: agentcompose.v2.RemoveImageRequest.store:type_name -> agentcompose.v2.ImageStoreKind + 233, // 186: agentcompose.v2.BuildImageRequest.build_args:type_name -> agentcompose.v2.BuildImageRequest.BuildArgsEntry + 14, // 187: agentcompose.v2.BuildImageRequest.store:type_name -> agentcompose.v2.ImageStoreKind + 175, // 188: agentcompose.v2.BuildImageRequest.platform:type_name -> agentcompose.v2.ImagePlatform + 16, // 189: agentcompose.v2.BuildImageEvent.status:type_name -> agentcompose.v2.ImageOperationStatus + 174, // 190: agentcompose.v2.BuildImageEvent.image:type_name -> agentcompose.v2.Image + 18, // 191: agentcompose.v2.CacheFilter.domain:type_name -> agentcompose.v2.CacheDomain + 19, // 192: agentcompose.v2.CacheFilter.status:type_name -> agentcompose.v2.CacheStatus + 152, // 193: agentcompose.v2.ListCachesRequest.filter:type_name -> agentcompose.v2.CacheFilter + 161, // 194: agentcompose.v2.ListCachesResponse.caches:type_name -> agentcompose.v2.CacheItem + 161, // 195: agentcompose.v2.InspectCacheResponse.cache:type_name -> agentcompose.v2.CacheItem + 152, // 196: agentcompose.v2.PruneCachesRequest.filter:type_name -> agentcompose.v2.CacheFilter + 161, // 197: agentcompose.v2.PruneCachesResponse.matched:type_name -> agentcompose.v2.CacheItem + 161, // 198: agentcompose.v2.PruneCachesResponse.skipped:type_name -> agentcompose.v2.CacheItem + 161, // 199: agentcompose.v2.RemoveCacheResponse.matched:type_name -> agentcompose.v2.CacheItem + 161, // 200: agentcompose.v2.RemoveCacheResponse.skipped:type_name -> agentcompose.v2.CacheItem + 18, // 201: agentcompose.v2.CacheItem.domain:type_name -> agentcompose.v2.CacheDomain + 19, // 202: agentcompose.v2.CacheItem.status:type_name -> agentcompose.v2.CacheStatus + 162, // 203: agentcompose.v2.CacheItem.references:type_name -> agentcompose.v2.CacheReference + 173, // 204: agentcompose.v2.ListVolumesResponse.volumes:type_name -> agentcompose.v2.Volume + 234, // 205: agentcompose.v2.CreateVolumeRequest.labels:type_name -> agentcompose.v2.CreateVolumeRequest.LabelsEntry + 235, // 206: agentcompose.v2.CreateVolumeRequest.options:type_name -> agentcompose.v2.CreateVolumeRequest.OptionsEntry + 173, // 207: agentcompose.v2.CreateVolumeResponse.volume:type_name -> agentcompose.v2.Volume + 173, // 208: agentcompose.v2.InspectVolumeResponse.volume:type_name -> agentcompose.v2.Volume + 173, // 209: agentcompose.v2.PruneVolumesResponse.matched:type_name -> agentcompose.v2.Volume + 173, // 210: agentcompose.v2.PruneVolumesResponse.removed:type_name -> agentcompose.v2.Volume + 173, // 211: agentcompose.v2.PruneVolumesResponse.skipped:type_name -> agentcompose.v2.Volume + 236, // 212: agentcompose.v2.Volume.labels:type_name -> agentcompose.v2.Volume.LabelsEntry + 237, // 213: agentcompose.v2.Volume.options:type_name -> agentcompose.v2.Volume.OptionsEntry + 14, // 214: agentcompose.v2.Image.store:type_name -> agentcompose.v2.ImageStoreKind + 15, // 215: agentcompose.v2.Image.availability_status:type_name -> agentcompose.v2.ImageAvailabilityStatus + 175, // 216: agentcompose.v2.Image.platform:type_name -> agentcompose.v2.ImagePlatform + 177, // 217: agentcompose.v2.Image.docker:type_name -> agentcompose.v2.DockerImageStatus + 178, // 218: agentcompose.v2.Image.oci:type_name -> agentcompose.v2.OCIImageStatus + 238, // 219: agentcompose.v2.Image.labels:type_name -> agentcompose.v2.Image.LabelsEntry + 14, // 220: agentcompose.v2.ImageStoreStatus.store:type_name -> agentcompose.v2.ImageStoreKind + 79, // 221: agentcompose.v2.StartRunRequest.run:type_name -> agentcompose.v2.RunAgentRequest + 118, // 222: agentcompose.v2.StartRunResponse.run:type_name -> agentcompose.v2.RunSummary + 20, // 223: agentcompose.v2.ResolveResourceIDRequest.kinds:type_name -> agentcompose.v2.ResourceKind + 187, // 224: agentcompose.v2.ResolveResourceIDResponse.targets:type_name -> agentcompose.v2.ResourceTarget + 20, // 225: agentcompose.v2.ResourceTarget.kind:type_name -> agentcompose.v2.ResourceKind + 190, // 226: agentcompose.v2.DashboardOverview.runs:type_name -> agentcompose.v2.RunOverview + 240, // 227: agentcompose.v2.DashboardOverview.updated_at:type_name -> google.protobuf.Timestamp + 191, // 228: agentcompose.v2.GetDashboardOverviewResponse.overview:type_name -> agentcompose.v2.DashboardOverview + 191, // 229: agentcompose.v2.WatchDashboardOverviewResponse.overview:type_name -> agentcompose.v2.DashboardOverview + 65, // 230: agentcompose.v2.GetGlobalEnvResponse.env:type_name -> agentcompose.v2.EnvVarSpec + 66, // 231: agentcompose.v2.UpdateGlobalEnvRequest.env:type_name -> agentcompose.v2.EnvVarUpdateSpec + 65, // 232: agentcompose.v2.UpdateGlobalEnvResponse.env:type_name -> agentcompose.v2.EnvVarSpec + 199, // 233: agentcompose.v2.GetCapabilityGatewayConfigResponse.config:type_name -> agentcompose.v2.CapabilityGatewayConfig + 199, // 234: agentcompose.v2.UpdateCapabilityGatewayConfigResponse.config:type_name -> agentcompose.v2.CapabilityGatewayConfig + 240, // 235: agentcompose.v2.WorkspacePreset.created_at:type_name -> google.protobuf.Timestamp + 240, // 236: agentcompose.v2.WorkspacePreset.updated_at:type_name -> google.protobuf.Timestamp + 203, // 237: agentcompose.v2.ListWorkspacePresetsResponse.presets:type_name -> agentcompose.v2.WorkspacePreset + 203, // 238: agentcompose.v2.WorkspacePresetResponse.preset:type_name -> agentcompose.v2.WorkspacePreset + 214, // 239: agentcompose.v2.ListCapabilitySetsResponse.capsets:type_name -> agentcompose.v2.CapabilitySet + 239, // 240: agentcompose.v2.CapabilityEndpoint.metadata:type_name -> agentcompose.v2.CapabilityEndpoint.MetadataEntry + 217, // 241: agentcompose.v2.CapabilityMethod.endpoints:type_name -> agentcompose.v2.CapabilityEndpoint + 218, // 242: agentcompose.v2.GetCapabilityCatalogResponse.methods:type_name -> agentcompose.v2.CapabilityMethod + 240, // 243: agentcompose.v2.SandboxHistoryCell.created_at:type_name -> google.protobuf.Timestamp + 240, // 244: agentcompose.v2.SandboxHistoryEvent.created_at:type_name -> google.protobuf.Timestamp + 221, // 245: agentcompose.v2.ListSandboxHistoryResponse.cells:type_name -> agentcompose.v2.SandboxHistoryCell + 222, // 246: agentcompose.v2.ListSandboxHistoryResponse.events:type_name -> agentcompose.v2.SandboxHistoryEvent + 21, // 247: agentcompose.v2.WatchSandboxResponse.event_type:type_name -> agentcompose.v2.SandboxWatchEventType + 104, // 248: agentcompose.v2.WatchSandboxResponse.sandbox:type_name -> agentcompose.v2.Sandbox + 221, // 249: agentcompose.v2.WatchSandboxResponse.cell:type_name -> agentcompose.v2.SandboxHistoryCell + 222, // 250: agentcompose.v2.WatchSandboxResponse.event:type_name -> agentcompose.v2.SandboxHistoryEvent + 13, // 251: agentcompose.v2.WatchSandboxResponse.stream:type_name -> agentcompose.v2.StdioStream + 22, // 252: agentcompose.v2.ProjectService.ValidateProject:input_type -> agentcompose.v2.ValidateProjectRequest + 24, // 253: agentcompose.v2.ProjectService.ApplyProject:input_type -> agentcompose.v2.ApplyProjectRequest + 26, // 254: agentcompose.v2.ProjectService.GetProject:input_type -> agentcompose.v2.GetProjectRequest + 28, // 255: agentcompose.v2.ProjectService.ListProjects:input_type -> agentcompose.v2.ListProjectsRequest + 30, // 256: agentcompose.v2.ProjectService.RemoveProject:input_type -> agentcompose.v2.RemoveProjectRequest + 32, // 257: agentcompose.v2.ProjectService.WatchProject:input_type -> agentcompose.v2.WatchProjectRequest + 43, // 258: agentcompose.v2.ProjectService.GetScheduler:input_type -> agentcompose.v2.GetSchedulerRequest + 46, // 259: agentcompose.v2.ProjectService.ListSchedulers:input_type -> agentcompose.v2.ListSchedulersRequest + 49, // 260: agentcompose.v2.ProjectService.ListSchedulerEvents:input_type -> agentcompose.v2.ListSchedulerEventsRequest + 52, // 261: agentcompose.v2.ProjectService.SetSchedulerEnabled:input_type -> agentcompose.v2.SetSchedulerEnabledRequest + 54, // 262: agentcompose.v2.ProjectService.SetSchedulerTriggerEnabled:input_type -> agentcompose.v2.SetSchedulerTriggerEnabledRequest + 79, // 263: agentcompose.v2.RunService.RunAgent:input_type -> agentcompose.v2.RunAgentRequest + 182, // 264: agentcompose.v2.RunService.StartRun:input_type -> agentcompose.v2.StartRunRequest + 79, // 265: agentcompose.v2.RunService.RunAgentStream:input_type -> agentcompose.v2.RunAgentRequest + 82, // 266: agentcompose.v2.RunService.RunAttach:input_type -> agentcompose.v2.RunAttachRequest + 86, // 267: agentcompose.v2.RunService.GetRun:input_type -> agentcompose.v2.GetRunRequest + 88, // 268: agentcompose.v2.RunService.ListRuns:input_type -> agentcompose.v2.ListRunsRequest + 90, // 269: agentcompose.v2.RunService.FollowRunLogs:input_type -> agentcompose.v2.FollowRunLogsRequest + 92, // 270: agentcompose.v2.RunService.StopRun:input_type -> agentcompose.v2.StopRunRequest + 94, // 271: agentcompose.v2.RunService.ListRunEvents:input_type -> agentcompose.v2.ListRunEventsRequest + 97, // 272: agentcompose.v2.RunService.ListSandboxRunEvents:input_type -> agentcompose.v2.ListSandboxRunEventsRequest + 120, // 273: agentcompose.v2.ExecService.Exec:input_type -> agentcompose.v2.ExecRequest + 120, // 274: agentcompose.v2.ExecService.ExecStream:input_type -> agentcompose.v2.ExecRequest + 125, // 275: agentcompose.v2.ExecService.ExecAttach:input_type -> agentcompose.v2.ExecAttachRequest + 142, // 276: agentcompose.v2.ImageService.ListImages:input_type -> agentcompose.v2.ListImagesRequest + 144, // 277: agentcompose.v2.ImageService.PullImage:input_type -> agentcompose.v2.PullImageRequest + 146, // 278: agentcompose.v2.ImageService.InspectImage:input_type -> agentcompose.v2.InspectImageRequest + 148, // 279: agentcompose.v2.ImageService.RemoveImage:input_type -> agentcompose.v2.RemoveImageRequest + 150, // 280: agentcompose.v2.ImageService.BuildImage:input_type -> agentcompose.v2.BuildImageRequest + 153, // 281: agentcompose.v2.CacheService.ListCaches:input_type -> agentcompose.v2.ListCachesRequest + 155, // 282: agentcompose.v2.CacheService.InspectCache:input_type -> agentcompose.v2.InspectCacheRequest + 157, // 283: agentcompose.v2.CacheService.PruneCaches:input_type -> agentcompose.v2.PruneCachesRequest + 159, // 284: agentcompose.v2.CacheService.RemoveCache:input_type -> agentcompose.v2.RemoveCacheRequest + 163, // 285: agentcompose.v2.VolumeService.ListVolumes:input_type -> agentcompose.v2.ListVolumesRequest + 165, // 286: agentcompose.v2.VolumeService.CreateVolume:input_type -> agentcompose.v2.CreateVolumeRequest + 167, // 287: agentcompose.v2.VolumeService.InspectVolume:input_type -> agentcompose.v2.InspectVolumeRequest + 169, // 288: agentcompose.v2.VolumeService.RemoveVolume:input_type -> agentcompose.v2.RemoveVolumeRequest + 171, // 289: agentcompose.v2.VolumeService.PruneVolumes:input_type -> agentcompose.v2.PruneVolumesRequest + 99, // 290: agentcompose.v2.SandboxService.RemoveSandbox:input_type -> agentcompose.v2.RemoveSandboxRequest + 101, // 291: agentcompose.v2.SandboxService.GetSandboxStats:input_type -> agentcompose.v2.GetSandboxStatsRequest + 103, // 292: agentcompose.v2.SandboxService.GetSandbox:input_type -> agentcompose.v2.GetSandboxRequest + 112, // 293: agentcompose.v2.SandboxService.StopSandbox:input_type -> agentcompose.v2.StopSandboxRequest + 114, // 294: agentcompose.v2.SandboxService.ResumeSandbox:input_type -> agentcompose.v2.ResumeSandboxRequest + 109, // 295: agentcompose.v2.SandboxService.ListSandboxes:input_type -> agentcompose.v2.ListSandboxesRequest + 220, // 296: agentcompose.v2.SandboxService.ListSandboxHistory:input_type -> agentcompose.v2.ListSandboxHistoryRequest + 224, // 297: agentcompose.v2.SandboxService.WatchSandbox:input_type -> agentcompose.v2.WatchSandboxRequest + 188, // 298: agentcompose.v2.DashboardService.GetDashboardOverview:input_type -> agentcompose.v2.GetDashboardOverviewRequest + 189, // 299: agentcompose.v2.DashboardService.WatchDashboardOverview:input_type -> agentcompose.v2.WatchDashboardOverviewRequest + 194, // 300: agentcompose.v2.SettingsService.GetGlobalEnv:input_type -> agentcompose.v2.GetGlobalEnvRequest + 196, // 301: agentcompose.v2.SettingsService.UpdateGlobalEnv:input_type -> agentcompose.v2.UpdateGlobalEnvRequest + 198, // 302: agentcompose.v2.SettingsService.GetCapabilityGatewayConfig:input_type -> agentcompose.v2.GetCapabilityGatewayConfigRequest + 201, // 303: agentcompose.v2.SettingsService.UpdateCapabilityGatewayConfig:input_type -> agentcompose.v2.UpdateCapabilityGatewayConfigRequest + 204, // 304: agentcompose.v2.SettingsService.ListWorkspacePresets:input_type -> agentcompose.v2.ListWorkspacePresetsRequest + 206, // 305: agentcompose.v2.SettingsService.CreateWorkspacePreset:input_type -> agentcompose.v2.CreateWorkspacePresetRequest + 207, // 306: agentcompose.v2.SettingsService.UpdateWorkspacePreset:input_type -> agentcompose.v2.UpdateWorkspacePresetRequest + 208, // 307: agentcompose.v2.SettingsService.DeleteWorkspacePreset:input_type -> agentcompose.v2.DeleteWorkspacePresetRequest + 211, // 308: agentcompose.v2.CapabilityService.GetCapabilityStatus:input_type -> agentcompose.v2.GetCapabilityStatusRequest + 213, // 309: agentcompose.v2.CapabilityService.ListCapabilitySets:input_type -> agentcompose.v2.ListCapabilitySetsRequest + 216, // 310: agentcompose.v2.CapabilityService.GetCapabilityCatalog:input_type -> agentcompose.v2.GetCapabilityCatalogRequest + 226, // 311: agentcompose.v2.LLMService.Generate:input_type -> agentcompose.v2.GenerateLLMRequest + 185, // 312: agentcompose.v2.ResourceService.ResolveID:input_type -> agentcompose.v2.ResolveResourceIDRequest + 23, // 313: agentcompose.v2.ProjectService.ValidateProject:output_type -> agentcompose.v2.ValidateProjectResponse + 25, // 314: agentcompose.v2.ProjectService.ApplyProject:output_type -> agentcompose.v2.ApplyProjectResponse + 27, // 315: agentcompose.v2.ProjectService.GetProject:output_type -> agentcompose.v2.GetProjectResponse + 29, // 316: agentcompose.v2.ProjectService.ListProjects:output_type -> agentcompose.v2.ListProjectsResponse + 31, // 317: agentcompose.v2.ProjectService.RemoveProject:output_type -> agentcompose.v2.RemoveProjectResponse + 33, // 318: agentcompose.v2.ProjectService.WatchProject:output_type -> agentcompose.v2.WatchProjectResponse + 44, // 319: agentcompose.v2.ProjectService.GetScheduler:output_type -> agentcompose.v2.GetSchedulerResponse + 48, // 320: agentcompose.v2.ProjectService.ListSchedulers:output_type -> agentcompose.v2.ListSchedulersResponse + 51, // 321: agentcompose.v2.ProjectService.ListSchedulerEvents:output_type -> agentcompose.v2.ListSchedulerEventsResponse + 53, // 322: agentcompose.v2.ProjectService.SetSchedulerEnabled:output_type -> agentcompose.v2.SetSchedulerEnabledResponse + 55, // 323: agentcompose.v2.ProjectService.SetSchedulerTriggerEnabled:output_type -> agentcompose.v2.SetSchedulerTriggerEnabledResponse + 80, // 324: agentcompose.v2.RunService.RunAgent:output_type -> agentcompose.v2.RunAgentResponse + 183, // 325: agentcompose.v2.RunService.StartRun:output_type -> agentcompose.v2.StartRunResponse + 81, // 326: agentcompose.v2.RunService.RunAgentStream:output_type -> agentcompose.v2.RunAgentStreamResponse + 83, // 327: agentcompose.v2.RunService.RunAttach:output_type -> agentcompose.v2.RunAttachResponse + 87, // 328: agentcompose.v2.RunService.GetRun:output_type -> agentcompose.v2.GetRunResponse + 89, // 329: agentcompose.v2.RunService.ListRuns:output_type -> agentcompose.v2.ListRunsResponse + 91, // 330: agentcompose.v2.RunService.FollowRunLogs:output_type -> agentcompose.v2.RunLogChunk + 93, // 331: agentcompose.v2.RunService.StopRun:output_type -> agentcompose.v2.StopRunResponse + 96, // 332: agentcompose.v2.RunService.ListRunEvents:output_type -> agentcompose.v2.ListRunEventsResponse + 98, // 333: agentcompose.v2.RunService.ListSandboxRunEvents:output_type -> agentcompose.v2.ListSandboxRunEventsResponse + 123, // 334: agentcompose.v2.ExecService.Exec:output_type -> agentcompose.v2.ExecResponse + 124, // 335: agentcompose.v2.ExecService.ExecStream:output_type -> agentcompose.v2.ExecStreamResponse + 126, // 336: agentcompose.v2.ExecService.ExecAttach:output_type -> agentcompose.v2.ExecAttachResponse + 143, // 337: agentcompose.v2.ImageService.ListImages:output_type -> agentcompose.v2.ListImagesResponse + 145, // 338: agentcompose.v2.ImageService.PullImage:output_type -> agentcompose.v2.PullImageResponse + 147, // 339: agentcompose.v2.ImageService.InspectImage:output_type -> agentcompose.v2.InspectImageResponse + 149, // 340: agentcompose.v2.ImageService.RemoveImage:output_type -> agentcompose.v2.RemoveImageResponse + 151, // 341: agentcompose.v2.ImageService.BuildImage:output_type -> agentcompose.v2.BuildImageEvent + 154, // 342: agentcompose.v2.CacheService.ListCaches:output_type -> agentcompose.v2.ListCachesResponse + 156, // 343: agentcompose.v2.CacheService.InspectCache:output_type -> agentcompose.v2.InspectCacheResponse + 158, // 344: agentcompose.v2.CacheService.PruneCaches:output_type -> agentcompose.v2.PruneCachesResponse + 160, // 345: agentcompose.v2.CacheService.RemoveCache:output_type -> agentcompose.v2.RemoveCacheResponse + 164, // 346: agentcompose.v2.VolumeService.ListVolumes:output_type -> agentcompose.v2.ListVolumesResponse + 166, // 347: agentcompose.v2.VolumeService.CreateVolume:output_type -> agentcompose.v2.CreateVolumeResponse + 168, // 348: agentcompose.v2.VolumeService.InspectVolume:output_type -> agentcompose.v2.InspectVolumeResponse + 170, // 349: agentcompose.v2.VolumeService.RemoveVolume:output_type -> agentcompose.v2.RemoveVolumeResponse + 172, // 350: agentcompose.v2.VolumeService.PruneVolumes:output_type -> agentcompose.v2.PruneVolumesResponse + 100, // 351: agentcompose.v2.SandboxService.RemoveSandbox:output_type -> agentcompose.v2.RemoveSandboxResponse + 102, // 352: agentcompose.v2.SandboxService.GetSandboxStats:output_type -> agentcompose.v2.GetSandboxStatsResponse + 111, // 353: agentcompose.v2.SandboxService.GetSandbox:output_type -> agentcompose.v2.GetSandboxResponse + 113, // 354: agentcompose.v2.SandboxService.StopSandbox:output_type -> agentcompose.v2.StopSandboxResponse + 115, // 355: agentcompose.v2.SandboxService.ResumeSandbox:output_type -> agentcompose.v2.ResumeSandboxResponse + 110, // 356: agentcompose.v2.SandboxService.ListSandboxes:output_type -> agentcompose.v2.ListSandboxesResponse + 223, // 357: agentcompose.v2.SandboxService.ListSandboxHistory:output_type -> agentcompose.v2.ListSandboxHistoryResponse + 225, // 358: agentcompose.v2.SandboxService.WatchSandbox:output_type -> agentcompose.v2.WatchSandboxResponse + 192, // 359: agentcompose.v2.DashboardService.GetDashboardOverview:output_type -> agentcompose.v2.GetDashboardOverviewResponse + 193, // 360: agentcompose.v2.DashboardService.WatchDashboardOverview:output_type -> agentcompose.v2.WatchDashboardOverviewResponse + 195, // 361: agentcompose.v2.SettingsService.GetGlobalEnv:output_type -> agentcompose.v2.GetGlobalEnvResponse + 197, // 362: agentcompose.v2.SettingsService.UpdateGlobalEnv:output_type -> agentcompose.v2.UpdateGlobalEnvResponse + 200, // 363: agentcompose.v2.SettingsService.GetCapabilityGatewayConfig:output_type -> agentcompose.v2.GetCapabilityGatewayConfigResponse + 202, // 364: agentcompose.v2.SettingsService.UpdateCapabilityGatewayConfig:output_type -> agentcompose.v2.UpdateCapabilityGatewayConfigResponse + 205, // 365: agentcompose.v2.SettingsService.ListWorkspacePresets:output_type -> agentcompose.v2.ListWorkspacePresetsResponse + 210, // 366: agentcompose.v2.SettingsService.CreateWorkspacePreset:output_type -> agentcompose.v2.WorkspacePresetResponse + 210, // 367: agentcompose.v2.SettingsService.UpdateWorkspacePreset:output_type -> agentcompose.v2.WorkspacePresetResponse + 209, // 368: agentcompose.v2.SettingsService.DeleteWorkspacePreset:output_type -> agentcompose.v2.DeleteWorkspacePresetResponse + 212, // 369: agentcompose.v2.CapabilityService.GetCapabilityStatus:output_type -> agentcompose.v2.CapabilityStatusResponse + 215, // 370: agentcompose.v2.CapabilityService.ListCapabilitySets:output_type -> agentcompose.v2.ListCapabilitySetsResponse + 219, // 371: agentcompose.v2.CapabilityService.GetCapabilityCatalog:output_type -> agentcompose.v2.GetCapabilityCatalogResponse + 227, // 372: agentcompose.v2.LLMService.Generate:output_type -> agentcompose.v2.GenerateLLMResponse + 186, // 373: agentcompose.v2.ResourceService.ResolveID:output_type -> agentcompose.v2.ResolveResourceIDResponse + 313, // [313:374] is the sub-list for method output_type + 252, // [252:313] is the sub-list for method input_type + 252, // [252:252] is the sub-list for extension type_name + 252, // [252:252] is the sub-list for extension extendee + 0, // [0:252] is the sub-list for field type_name } func init() { file_agentcompose_v2_agentcompose_proto_init() } @@ -17285,7 +17738,7 @@ func file_agentcompose_v2_agentcompose_proto_init() { return } file_agentcompose_v2_agentcompose_proto_msgTypes[44].OneofWrappers = []any{} - file_agentcompose_v2_agentcompose_proto_msgTypes[57].OneofWrappers = []any{ + file_agentcompose_v2_agentcompose_proto_msgTypes[60].OneofWrappers = []any{ (*RunAttachRequest_Start)(nil), (*RunAttachRequest_Stdin)(nil), (*RunAttachRequest_StdinEof)(nil), @@ -17294,7 +17747,7 @@ func file_agentcompose_v2_agentcompose_proto_init() { (*RunAttachRequest_HumanMessage)(nil), (*RunAttachRequest_Cancel)(nil), } - file_agentcompose_v2_agentcompose_proto_msgTypes[58].OneofWrappers = []any{ + file_agentcompose_v2_agentcompose_proto_msgTypes[61].OneofWrappers = []any{ (*RunAttachResponse_Started)(nil), (*RunAttachResponse_Output)(nil), (*RunAttachResponse_AgentEvent)(nil), @@ -17302,13 +17755,13 @@ func file_agentcompose_v2_agentcompose_proto_init() { (*RunAttachResponse_Result)(nil), (*RunAttachResponse_Error)(nil), } - file_agentcompose_v2_agentcompose_proto_msgTypes[88].OneofWrappers = []any{} - file_agentcompose_v2_agentcompose_proto_msgTypes[92].OneofWrappers = []any{ + file_agentcompose_v2_agentcompose_proto_msgTypes[94].OneofWrappers = []any{} + file_agentcompose_v2_agentcompose_proto_msgTypes[98].OneofWrappers = []any{ (*ExecRequest_SandboxId)(nil), (*ExecRequest_RunId)(nil), (*ExecRequest_Selector)(nil), } - file_agentcompose_v2_agentcompose_proto_msgTypes[97].OneofWrappers = []any{ + file_agentcompose_v2_agentcompose_proto_msgTypes[103].OneofWrappers = []any{ (*ExecAttachRequest_Start)(nil), (*ExecAttachRequest_Stdin)(nil), (*ExecAttachRequest_StdinEof)(nil), @@ -17317,7 +17770,7 @@ func file_agentcompose_v2_agentcompose_proto_init() { (*ExecAttachRequest_Cancel)(nil), (*ExecAttachRequest_HumanMessage)(nil), } - file_agentcompose_v2_agentcompose_proto_msgTypes[98].OneofWrappers = []any{ + file_agentcompose_v2_agentcompose_proto_msgTypes[104].OneofWrappers = []any{ (*ExecAttachResponse_Started)(nil), (*ExecAttachResponse_Output)(nil), (*ExecAttachResponse_Result)(nil), @@ -17325,14 +17778,14 @@ func file_agentcompose_v2_agentcompose_proto_init() { (*ExecAttachResponse_AgentEvent)(nil), (*ExecAttachResponse_AgentTurnCompleted)(nil), } - file_agentcompose_v2_agentcompose_proto_msgTypes[173].OneofWrappers = []any{} + file_agentcompose_v2_agentcompose_proto_msgTypes[179].OneofWrappers = []any{} type x struct{} out := protoimpl.TypeBuilder{ File: protoimpl.DescBuilder{ GoPackagePath: reflect.TypeOf(x{}).PkgPath(), RawDescriptor: unsafe.Slice(unsafe.StringData(file_agentcompose_v2_agentcompose_proto_rawDesc), len(file_agentcompose_v2_agentcompose_proto_rawDesc)), NumEnums: 22, - NumMessages: 212, + NumMessages: 218, NumExtensions: 0, NumServices: 12, }, diff --git a/proto/agentcompose/v2/agentcompose.proto b/proto/agentcompose/v2/agentcompose.proto index d9372f6e..6de1b06c 100644 --- a/proto/agentcompose/v2/agentcompose.proto +++ b/proto/agentcompose/v2/agentcompose.proto @@ -537,6 +537,7 @@ message ProjectSpec { repeated ProjectVolumeSpec volumes = 6; repeated NamedWorkspaceSpec workspaces = 7; repeated MCPServerSpec mcps = 8; + repeated NamedNetworkSpec networks = 9; } message NamedWorkspaceSpec { @@ -561,6 +562,9 @@ message AgentSpec { repeated MCPServerSpec mcps = 14; repeated SkillSpec skills = 15; AgentStatus status = 16; + repeated string networks = 17; + repeated ExposedPortSpec expose = 18; + repeated PublishedPortSpec ports = 19; } message MCPServerSpec { @@ -625,6 +629,24 @@ message NetworkSpec { string mode = 1; } +message NamedNetworkSpec { + string name = 1; + string driver = 2; +} + +message ExposedPortSpec { + uint32 target = 1; + string protocol = 2; + uint32 host_port = 3; +} + +message PublishedPortSpec { + string host_ip = 1; + uint32 published = 2; + uint32 target = 3; + string protocol = 4; +} + message SchedulerSpec { bool enabled = 1; repeated TriggerSpec triggers = 2; @@ -883,6 +905,26 @@ message Sandbox { uint32 cell_count = 14; uint32 event_count = 15; string notebook_url = 16; + SandboxNetworkState network = 17; +} + +message SandboxNetworkState { + repeated SandboxNetworkEndpoint attachments = 1; + repeated SandboxPortBinding bindings = 2; +} + +message SandboxNetworkEndpoint { + string name = 1; +} + +message SandboxPortBinding { + repeated string networks = 1; + string host_ip = 2; + uint32 host_port = 3; + uint32 guest_port = 4; + string protocol = 5; + string visibility = 6; + string publisher = 7; } message SandboxTag {