"
63 | return prompt_text
64 |
65 |
66 | def create_swift_description_prompt(
67 | image1: str,
68 | image2: str,
69 | action: str,
70 | answer: str,
71 | ) -> dict:
72 | """
73 | Create a text prompt and attach images in a separate field.
74 | This might be used by a Swift client or a different consumer that
75 | expects separate 'messages' and 'images' structure.
76 | """
77 | prompt_text = create_description_text(action, with_image=True)
78 | return {
79 | "messages": [
80 | {
81 | "role": "user",
82 | "content": prompt_text,
83 | },
84 | {
85 | "role": "assistant",
86 | "content": answer,
87 | },
88 | ],
89 | "images": [image1, image2],
90 | }
91 |
92 |
93 | def create_swift_reason_prompt(
94 | image1: str,
95 | image2: str,
96 | action: str,
97 | task_description: str,
98 | answer: str,
99 | ) -> dict:
100 | prompt_text = create_reason_text(action, task_description, with_image=True)
101 | return {
102 | "messages": [
103 | {
104 | "role": "user",
105 | "content": prompt_text,
106 | },
107 | {
108 | "role": "assistant",
109 | "content": answer,
110 | },
111 | ],
112 | "images": [image1, image2],
113 | }
114 |
115 |
116 | def create_swift_validation_prompt(
117 | image1: str,
118 | image2: str,
119 | action: str,
120 | task_description: str,
121 | answer: str,
122 | ) -> dict:
123 | prompt_text = create_validation_text(action, task_description, with_image=True)
124 | return {
125 | "messages": [
126 | {
127 | "role": "user",
128 | "content": prompt_text,
129 | },
130 | {
131 | "role": "assistant",
132 | "content": answer,
133 | },
134 | ],
135 | "images": [image1, image2],
136 | }
137 |
138 |
139 | def create_orign_description_prompt(
140 | image1: str,
141 | image2: str,
142 | action: str,
143 | ) -> ChatRequest:
144 | """
145 | Create a single batch task for the OpenAI API, returning a ChatRequest
146 | describing the difference between two images based on an action.
147 | """
148 | prompt_text = create_description_text(action, with_image=False)
149 | return ChatRequest(
150 | prompt=Prompt(
151 | messages=[
152 | MessageItem(
153 | role="user",
154 | content=[
155 | ContentItem(type="text", text=prompt_text),
156 | ContentItem(
157 | type="image_url", image_url=ImageUrlContent(url=image1)
158 | ),
159 | ContentItem(
160 | type="image_url", image_url=ImageUrlContent(url=image2)
161 | ),
162 | ],
163 | )
164 | ]
165 | ),
166 | max_tokens=500,
167 | )
168 |
169 |
170 | def create_orign_reason_prompt(
171 | image1: str,
172 | image2: str,
173 | action: str,
174 | task_description: str,
175 | ) -> ChatRequest:
176 | """
177 | Create a single batch task for the OpenAI API, returning a ChatRequest
178 | that requests a reasoning chain tying the action and the task.
179 | """
180 | prompt_text = create_reason_text(action, task_description, with_image=False)
181 | return ChatRequest(
182 | prompt=Prompt(
183 | messages=[
184 | MessageItem(
185 | role="user",
186 | content=[
187 | ContentItem(type="text", text=prompt_text),
188 | ContentItem(
189 | type="image_url", image_url=ImageUrlContent(url=image1)
190 | ),
191 | ContentItem(
192 | type="image_url", image_url=ImageUrlContent(url=image2)
193 | ),
194 | ],
195 | )
196 | ]
197 | ),
198 | max_tokens=500,
199 | )
200 |
201 |
202 | def create_orign_validation_prompt(
203 | image1: str,
204 | image2: str,
205 | action: str,
206 | task_description: str,
207 | ) -> ChatRequest:
208 | """
209 | Create a single batch task for the OpenAI API, returning a ChatRequest
210 | that asks for validation on whether the action matched the desired task outcome.
211 | """
212 | prompt_text = create_validation_text(action, task_description, with_image=False)
213 | return ChatRequest(
214 | prompt=Prompt(
215 | messages=[
216 | MessageItem(
217 | role="user",
218 | content=[
219 | ContentItem(type="text", text=prompt_text),
220 | ContentItem(
221 | type="image_url", image_url=ImageUrlContent(url=image1)
222 | ),
223 | ContentItem(
224 | type="image_url", image_url=ImageUrlContent(url=image2)
225 | ),
226 | ],
227 | )
228 | ]
229 | ),
230 | max_tokens=500,
231 | )
232 |
--------------------------------------------------------------------------------
/surfkit/runtime/agent/hub.py:
--------------------------------------------------------------------------------
1 | # type: ignore
2 | from typing import Iterator, List, Optional, Type, Union
3 |
4 | from pydantic import BaseModel
5 | from taskara import V1Task
6 |
7 | from surfkit.server.models import V1AgentInstance, V1SolveTask
8 | from surfkit.types import AgentType
9 |
10 | from .base import AgentInstance, AgentRuntime
11 |
12 |
13 | class ConnectConfig(BaseModel):
14 | timeout: Optional[int] = None
15 |
16 |
17 | class HubAgentRuntime(AgentRuntime):
18 | @classmethod
19 | def name(cls) -> str:
20 | return cls.__name__
21 |
22 | @classmethod
23 | def connect_config_type(cls) -> Type[ConnectConfig]:
24 | return ConnectConfig
25 |
26 | @classmethod
27 | def connect(cls, cfg: ConnectConfig) -> "HubAgentRuntime":
28 | pass
29 |
30 | def run(
31 | self,
32 | agent_type: AgentType,
33 | name: str,
34 | version: Optional[str] = None,
35 | env_vars: Optional[dict] = None,
36 | llm_providers_local: bool = False,
37 | owner_id: Optional[str] = None,
38 | ) -> AgentInstance:
39 | pass
40 |
41 | def solve_task(
42 | self,
43 | agent_name: str,
44 | task: V1SolveTask,
45 | follow_logs: bool = False,
46 | attach: bool = False,
47 | ) -> None:
48 | pass
49 |
50 | def list(self) -> List[AgentInstance]:
51 | pass
52 |
53 | def get(self, name: str) -> AgentInstance:
54 | pass
55 |
56 | def proxy(
57 | self,
58 | name: str,
59 | local_port: Optional[int] = None,
60 | pod_port: int = 8000,
61 | background: bool = True,
62 | ) -> None:
63 | pass
64 |
65 | def delete(self, name: str) -> None:
66 | pass
67 |
68 | def clean(self) -> None:
69 | pass
70 |
71 | def logs(self, name: str, follow: bool = False) -> Union[str, Iterator[str]]:
72 | """
73 | Fetches the logs from the specified pod.
74 |
75 | Parameters:
76 | name (str): The name of the pod.
77 |
78 | Returns:
79 | str: The logs from the pod.
80 | """
81 | pass
82 |
83 | def runtime_local_addr(self, name: str, owner_id: Optional[str] = None) -> str:
84 | """
85 | Returns the local address of the agent with respect to the runtime
86 | """
87 | instances = AgentInstance.find(name=name, owner_id=owner_id)
88 | if not instances:
89 | raise ValueError(f"No instances found for name '{name}'")
90 | instance = instances[0]
91 | pass
92 |
--------------------------------------------------------------------------------
/surfkit/runtime/agent/load.py:
--------------------------------------------------------------------------------
1 | from typing import List, Optional, Type
2 |
3 | from pydantic import BaseModel
4 |
5 | from surfkit.server.models import V1RuntimeConnect
6 |
7 | from .base import AgentRuntime
8 | from .docker import DockerAgentRuntime, DockerConnectConfig
9 | from .kube import KubeAgentRuntime, KubeConnectConfig
10 | from .process import ProcessAgentRuntime, ProcessConnectConfig
11 |
12 |
13 | class AgentRuntimeConfig(BaseModel):
14 | provider: Optional[str] = None
15 | docker_config: Optional[DockerConnectConfig] = None
16 | kube_config: Optional[KubeConnectConfig] = None
17 | process_config: Optional[ProcessConnectConfig] = None
18 | preference: List[str] = ["kube", "docker", "process"]
19 |
20 |
21 | def runtime_from_name(name: str) -> Type[AgentRuntime]:
22 | for runt in RUNTIMES:
23 | if runt.name() == name:
24 | return runt
25 | raise ValueError(f"Unknown runtime '{name}'")
26 |
27 |
28 | def load_agent_runtime(cfg: AgentRuntimeConfig) -> AgentRuntime:
29 | for pref in cfg.preference:
30 | if pref == KubeAgentRuntime.name() and cfg.kube_config:
31 | return KubeAgentRuntime.connect(cfg.kube_config)
32 | elif pref == DockerAgentRuntime.name() and cfg.docker_config:
33 | return DockerAgentRuntime.connect(cfg.docker_config)
34 | elif pref == ProcessAgentRuntime.name() and cfg.process_config:
35 | return ProcessAgentRuntime.connect(cfg.process_config)
36 | raise ValueError(f"Unknown provider: {cfg.provider}")
37 |
38 |
39 | RUNTIMES: List[Type[AgentRuntime]] = [DockerAgentRuntime, KubeAgentRuntime, ProcessAgentRuntime] # type: ignore
40 |
41 |
42 | def load_from_connect(connect: V1RuntimeConnect) -> AgentRuntime:
43 | for runt in RUNTIMES:
44 | if connect.name == runt.name():
45 | print("connect config: ", connect.connect_config)
46 | print("type: ", type(connect.connect_config))
47 | cfg = runt.connect_config_type().model_validate(connect.connect_config)
48 | return runt.connect(cfg)
49 |
50 | raise ValueError(f"Unknown runtime: {connect.name}")
51 |
--------------------------------------------------------------------------------
/surfkit/runtime/agent/util.py:
--------------------------------------------------------------------------------
1 | import random
2 | import string
3 |
4 | from docker.api.client import APIClient
5 | from docker.errors import APIError
6 | from namesgenerator import get_random_name
7 | from tqdm import tqdm
8 |
9 | from surfkit.types import AgentType
10 |
11 |
12 | def instance_name(type: AgentType) -> str:
13 | random_string = "".join(random.choices(string.ascii_letters + string.digits, k=5))
14 | random_name = get_random_name("-")
15 | if not random_name:
16 | raise ValueError("Could not generate a random name")
17 | name_parts = random_name.split("-")
18 | if len(name_parts) != 2:
19 | raise ValueError("Could not generate a random name with 2 parts")
20 | name_only = name_parts[1]
21 |
22 | return f"{type.name.lower()}-{name_only.lower()}-{random_string.lower()}"
23 |
24 |
25 | def pull_image(img: str, api_client: APIClient):
26 | """
27 | Pulls a Docker image with progress bars for each layer.
28 |
29 | Args:
30 | img (str): The Docker image to pull.
31 | api_client (APIClient): The Docker API client.
32 | """
33 |
34 | print(f"Pulling Docker image '{img}'...")
35 |
36 | progress_bars = {}
37 | layers = {}
38 |
39 | try:
40 | for line in api_client.pull(img, stream=True, decode=True):
41 | if "id" in line and "progressDetail" in line:
42 | layer_id = line["id"]
43 | progress_detail = line["progressDetail"]
44 | current = progress_detail.get("current", 0)
45 | total = progress_detail.get("total", 0)
46 |
47 | if total:
48 | if layer_id not in layers:
49 | progress_bars[layer_id] = tqdm(
50 | total=total,
51 | desc=f"Layer {layer_id}",
52 | leave=False,
53 | ncols=100,
54 | )
55 | layers[layer_id] = 0
56 |
57 | layers[layer_id] = current
58 | progress_bars[layer_id].n = current
59 | progress_bars[layer_id].refresh()
60 | elif "status" in line and "id" in line:
61 | print(f"Status update for {line['id']}: {line['status']}")
62 | elif "error" in line:
63 | raise APIError(line["error"])
64 |
65 | except APIError as e:
66 | print(f"Error pulling Docker image: {e.explanation}")
67 | except Exception as e:
68 | print(f"An unexpected error occurred: {str(e)}")
69 | finally:
70 | # Close all progress bars
71 | for bar in progress_bars.values():
72 | bar.n = bar.total # Ensure the progress bar is full before closing
73 | bar.refresh()
74 | bar.close()
75 |
76 | print("")
77 |
--------------------------------------------------------------------------------
/surfkit/runtime/container/base.py:
--------------------------------------------------------------------------------
1 | from abc import ABC, abstractmethod
2 | from typing import Generic, List, Optional, Tuple, Type, TypeVar
3 |
4 | from pydantic import BaseModel
5 |
6 | R = TypeVar("R", bound="ContainerRuntime")
7 | C = TypeVar("C", bound="BaseModel")
8 |
9 |
10 | class ContainerRuntime(Generic[C, R], ABC):
11 |
12 | @classmethod
13 | def name(cls) -> str:
14 | return cls.__name__
15 |
16 | @classmethod
17 | @abstractmethod
18 | def connect_config_type(cls) -> Type[C]:
19 | pass
20 |
21 | @classmethod
22 | @abstractmethod
23 | def connect(cls, cfg: C) -> R:
24 | pass
25 |
26 | @abstractmethod
27 | def create(
28 | self,
29 | image: str,
30 | name: Optional[str] = None,
31 | env_vars: Optional[dict] = None,
32 | mem_request: Optional[str] = "500m",
33 | mem_limit: Optional[str] = "2Gi",
34 | cpu_request: Optional[str] = "1",
35 | cpu_limit: Optional[str] = "4",
36 | gpu_mem: Optional[str] = None,
37 | ) -> None:
38 | pass
39 |
40 | @abstractmethod
41 | def call(
42 | self,
43 | name: str,
44 | path: str,
45 | method: str,
46 | port: int = 8080,
47 | data: Optional[dict] = None,
48 | headers: Optional[dict] = None,
49 | ) -> Tuple[int, str]:
50 | pass
51 |
52 | @abstractmethod
53 | def delete(self, name: str) -> None:
54 | pass
55 |
56 | @abstractmethod
57 | def list(self) -> List[str]:
58 | pass
59 |
60 | @abstractmethod
61 | def clean(self) -> None:
62 | pass
63 |
64 | @abstractmethod
65 | def logs(self, name: str) -> str:
66 | pass
67 |
--------------------------------------------------------------------------------
/surfkit/runtime/container/docker.py:
--------------------------------------------------------------------------------
1 | from typing import List, Optional, Tuple, Type, TypeVar
2 |
3 | import docker
4 | import requests
5 | from agentdesk.util import find_open_port
6 | from docker.errors import NotFound
7 | from namesgenerator import get_random_name
8 | from pydantic import BaseModel
9 |
10 | from .base import ContainerRuntime
11 |
12 |
13 | class ConnectConfig(BaseModel):
14 | pass
15 |
16 |
17 | class DockerRuntime(ContainerRuntime):
18 | """A container runtime that uses docker"""
19 |
20 | def __init__(self) -> None:
21 | self.client = docker.from_env()
22 |
23 | @classmethod
24 | def name(cls) -> str:
25 | return "docker"
26 |
27 | @classmethod
28 | def connect_config_type(cls) -> Type[ConnectConfig]:
29 | return ConnectConfig
30 |
31 | @classmethod
32 | def connect(cls, cfg: ConnectConfig) -> "DockerRuntime":
33 | return cls()
34 |
35 | def create(
36 | self,
37 | image: str,
38 | name: Optional[str] = None,
39 | env_vars: Optional[dict] = None,
40 | mem_request: Optional[str] = "500m",
41 | mem_limit: Optional[str] = "2Gi",
42 | cpu_request: Optional[str] = "1",
43 | cpu_limit: Optional[str] = "4",
44 | gpu_mem: Optional[str] = None,
45 | ) -> None:
46 | if not name:
47 | name = get_random_name("-")
48 |
49 | labels = {
50 | "provisioner": "surfkit",
51 | }
52 |
53 | port = find_open_port(9090, 10090)
54 | print("running container")
55 | container = self.client.containers.run(
56 | image,
57 | network_mode="host",
58 | environment=env_vars,
59 | detach=True,
60 | labels=labels,
61 | name=name,
62 | mem_limit=mem_limit,
63 | mem_reservation=mem_request,
64 | nano_cpus=int(float(cpu_limit) * 1e9), # type: ignore
65 | )
66 | if container and type(container) != bytes:
67 | print(f"ran container '{container.id}'") # type: ignore
68 |
69 | def call(
70 | self,
71 | name: str,
72 | path: str,
73 | method: str,
74 | port: int = 8080,
75 | data: Optional[dict] = None,
76 | headers: Optional[dict] = None,
77 | ) -> Tuple[int, str]:
78 | """
79 | Makes an HTTP request to the specified container.
80 |
81 | Parameters:
82 | name (str): The name of the container.
83 | route (str): The endpoint route (e.g., 'api/data').
84 | method (str): HTTP method (e.g., 'GET', 'POST').
85 | port (int): The port on which the container's server is listening.
86 | params (dict, optional): The URL parameters for GET or DELETE requests.
87 | body (dict, optional): The JSON body for POST, PUT requests.
88 | headers (dict, optional): HTTP headers.
89 |
90 | Returns:
91 | requests.Response: The HTTP response.
92 | """
93 | try:
94 | container = self.client.containers.get(name)
95 | print(f"Container '{name}' found.")
96 | except NotFound:
97 | print(f"Container '{name}' does not exist.")
98 | raise
99 | except Exception as e:
100 | print(f"An unexpected error occurred calling docker container: {e}")
101 | raise
102 |
103 | url = f"http://localhost:{port}{path}"
104 |
105 | # Dynamically calling the method based on 'method' parameter
106 | http_request = getattr(requests, method.lower(), requests.get)
107 |
108 | if not callable(http_request):
109 | raise ValueError(f"Unsupported HTTP method: {method}")
110 |
111 | if method.upper() in ["GET", "DELETE"]: # These methods should use params
112 | response = http_request(url, params=data, headers=headers)
113 | return response.status_code, response.text
114 | else:
115 | response = http_request(url, json=data, headers=headers)
116 | return response.status_code, response.text
117 |
118 | def list(self) -> List[str]:
119 | label_filter = {"label": ["provisioner=surfkit"]}
120 | containers = self.client.containers.list(filters=label_filter)
121 |
122 | container_names_or_ids = [container.name for container in containers] # type: ignore
123 |
124 | return container_names_or_ids
125 |
126 | def delete(self, name: str) -> None:
127 | try:
128 | # Attempt to get the container by name
129 | container = self.client.containers.get(name)
130 |
131 | # If found, remove the container
132 | container.remove(force=True) # type: ignore
133 | print(f"Successfully deleted container: {name}")
134 | except NotFound:
135 | # Handle the case where the container does not exist
136 | raise
137 | except Exception as e:
138 | # Handle other potential errors
139 | print(f"Failed to delete container '{name}': {e}")
140 |
141 | def clean(self) -> None:
142 | # Define the filter for containers with the specific label
143 | label_filter = {"label": ["provisioner=surfkit"]}
144 |
145 | # Use the filter to list containers
146 | containers = self.client.containers.list(filters=label_filter, all=True)
147 |
148 | # Initialize a list to keep track of deleted container names or IDs
149 | deleted_containers = []
150 |
151 | for container in containers:
152 | try:
153 | container_name_or_id = (
154 | container.name # type: ignore
155 | ) # or container.id for container ID
156 | container.remove(force=True) # type: ignore
157 | print(f"Deleted container: {container_name_or_id}")
158 | deleted_containers.append(container_name_or_id)
159 | except Exception as e:
160 | print(f"Failed to delete container: {e}")
161 |
162 | return
163 |
164 | def logs(self, name: str) -> str:
165 | """
166 | Fetches the logs from the specified container.
167 |
168 | Parameters:
169 | name (str): The name of the container.
170 |
171 | Returns:
172 | str: The logs from the container.
173 | """
174 | try:
175 | container = self.client.containers.get(name)
176 | return container.logs().decode("utf-8") # type: ignore
177 | except NotFound:
178 | print(f"Container '{name}' does not exist.")
179 | raise
180 | except Exception as e:
181 | print(f"An unexpected error occurred retrieving logs: {e}")
182 | raise
183 |
--------------------------------------------------------------------------------
/surfkit/runtime/container/kube.py:
--------------------------------------------------------------------------------
1 | import base64
2 | import json
3 | import os
4 | from typing import Literal, List, Optional, Tuple, Type
5 |
6 | import httpx
7 | from google.auth.transport.requests import Request
8 | from google.cloud import container_v1
9 | from google.oauth2 import service_account
10 | from kubernetes import client, config
11 | from kubernetes.client.rest import ApiException
12 | from namesgenerator import get_random_name
13 | from pydantic import BaseModel
14 | from tenacity import retry, stop_after_attempt
15 |
16 | from .base import ContainerRuntime
17 |
18 |
19 | class GKEOpts(BaseModel):
20 | cluster_name: str
21 | region: str
22 | service_account_json: str
23 |
24 |
25 | class LocalOpts(BaseModel):
26 | path: Optional[str] = os.getenv("KUBECONFIG", os.path.expanduser("~/.kube/config"))
27 |
28 |
29 | class ConnectConfig(BaseModel):
30 | provider: Literal["gke", "local"] = "local"
31 | namespace: str = "default"
32 | gke_opts: Optional[GKEOpts] = None
33 | local_opts: Optional[LocalOpts] = None
34 | branch: Optional[str] = None
35 |
36 |
37 | def gke_opts_from_env(
38 | gke_sa_json=os.getenv("GKE_SA_JSON"),
39 | cluster_name=os.getenv("CLUSTER_NAME"),
40 | region=os.getenv("CLUSTER_REGION"),
41 | ) -> GKEOpts:
42 | if not gke_sa_json:
43 | raise ValueError("GKE_SA_JSON not set")
44 | if not cluster_name:
45 | raise ValueError("CLUSTER_NAME not set")
46 | if not region:
47 | raise ValueError("CLUSTER_REGION not set")
48 | return GKEOpts(
49 | service_account_json=gke_sa_json,
50 | cluster_name=cluster_name,
51 | region=region,
52 | )
53 |
54 |
55 | class KubernetesRuntime(ContainerRuntime):
56 | """A container runtime that uses Kubernetes to manage Pods directly"""
57 |
58 | def __init__(self, cfg: ConnectConfig) -> None:
59 | self.cfg = cfg or ConnectConfig()
60 |
61 | self.kubeconfig = None
62 | if cfg.provider == "gke":
63 | opts = cfg.gke_opts
64 | if not opts:
65 | raise ValueError("GKE opts missing")
66 | self.connect_to_gke(opts)
67 | elif cfg.provider == "local":
68 | opts = cfg.local_opts
69 | if not opts:
70 | opts = LocalOpts()
71 | if opts.path:
72 | config.load_kube_config(opts.path)
73 | self.kubeconfig = opts.path
74 | else:
75 | raise ValueError("Unsupported provider: " + cfg.provider)
76 |
77 | self.core_api = client.CoreV1Api()
78 |
79 | self.namespace = cfg.namespace
80 |
81 | self.branch = cfg.branch
82 |
83 | @classmethod
84 | def name(cls) -> str:
85 | return "kube"
86 |
87 | def create(
88 | self,
89 | image: str,
90 | name: Optional[str] = None,
91 | env_vars: Optional[dict] = None,
92 | mem_request: Optional[str] = "500m",
93 | mem_limit: Optional[str] = "2Gi",
94 | cpu_request: Optional[str] = "1",
95 | cpu_limit: Optional[str] = "4",
96 | gpu_mem: Optional[str] = None,
97 | ) -> None:
98 | if not name:
99 | name = get_random_name("-")
100 |
101 | labels = {"provisioner": "surfkit"}
102 |
103 | # Define resource requirements
104 | resources = client.V1ResourceRequirements(
105 | requests={"memory": mem_request, "cpu": cpu_request},
106 | limits={"memory": mem_limit, "cpu": cpu_limit},
107 | )
108 |
109 | if gpu_mem:
110 | if "limits" in resources: # type: ignore
111 | resources.limits["nvidia.com/gpu"] = gpu_mem # type: ignore
112 | else:
113 | resources.limits = {"nvidia.com/gpu": gpu_mem}
114 |
115 | # Define the container with environment variables
116 | env_list = []
117 | if env_vars:
118 | for key, value in env_vars.items():
119 | env_list.append(client.V1EnvVar(name=key, value=value))
120 |
121 | container = client.V1Container(
122 | name=name,
123 | image=image,
124 | ports=[client.V1ContainerPort(container_port=8080)],
125 | resources=resources,
126 | env=env_list,
127 | )
128 |
129 | # Create a Pod specification
130 | pod_spec = client.V1PodSpec(
131 | containers=[container],
132 | restart_policy="Never", # 'Always' if you want the pod to restart on failure
133 | )
134 |
135 | # Create the Pod
136 | pod = client.V1Pod(
137 | api_version="v1",
138 | kind="Pod",
139 | metadata=client.V1ObjectMeta(name=name, labels=labels),
140 | spec=pod_spec,
141 | )
142 |
143 | # Launch the Pod
144 | print("Creating pod")
145 | try:
146 | self.core_api.create_namespaced_pod(namespace="default", body=pod)
147 | print(f"Pod created. name='{name}'")
148 | except ApiException as e:
149 | print(f"Exception when creating pod: {e}")
150 |
151 | @classmethod
152 | def connect_config_type(cls) -> Type[ConnectConfig]:
153 | return ConnectConfig
154 |
155 | @classmethod
156 | def connect(cls, cfg: ConnectConfig) -> "KubernetesRuntime":
157 | return cls(cfg)
158 |
159 | @retry(stop=stop_after_attempt(15))
160 | def connect_to_gke(self, opts: GKEOpts) -> Tuple[client.CoreV1Api, str, str]:
161 | """
162 | Sets up and returns a configured Kubernetes client (CoreV1Api) and cluster details.
163 |
164 | Returns:
165 | Tuple containing the Kubernetes CoreV1Api client object, the project ID, and the cluster name.
166 | """
167 | service_account_info = json.loads(opts.service_account_json)
168 | credentials = service_account.Credentials.from_service_account_info(
169 | service_account_info,
170 | scopes=["https://www.googleapis.com/auth/cloud-platform"],
171 | )
172 |
173 | # Setup GKE client to get cluster information
174 | gke_service = container_v1.ClusterManagerClient(credentials=credentials)
175 | project_id = service_account_info.get("project_id")
176 | if not project_id or not opts.cluster_name or not opts.region:
177 | raise ValueError(
178 | "Missing project_id, cluster_name, or region in credentials or metadata"
179 | )
180 |
181 | print("\nK8s getting cluster...")
182 | cluster_request = container_v1.GetClusterRequest(
183 | name=f"projects/{project_id}/locations/{opts.region}/clusters/{opts.cluster_name}"
184 | )
185 | cluster = gke_service.get_cluster(request=cluster_request)
186 |
187 | # Configure Kubernetes client
188 | print("\nK8s getting token...")
189 | ca_cert = base64.b64decode(cluster.master_auth.cluster_ca_certificate)
190 | try:
191 | print("\nK8s refreshing token...")
192 | credentials.refresh(Request())
193 | except Exception as e:
194 | print("\nK8s token refresh failed: ", e)
195 | raise e
196 | access_token = credentials.token
197 | print("\nK8s got token: ", access_token)
198 |
199 | cluster_name = opts.cluster_name
200 |
201 | kubeconfig = {
202 | "apiVersion": "v1",
203 | "kind": "Config",
204 | "clusters": [
205 | {
206 | "name": cluster_name,
207 | "cluster": {
208 | "server": f"https://{cluster.endpoint}",
209 | "certificate-authority-data": base64.b64encode(
210 | ca_cert
211 | ).decode(),
212 | },
213 | }
214 | ],
215 | "contexts": [
216 | {
217 | "name": cluster_name,
218 | "context": {
219 | "cluster": cluster_name,
220 | "user": cluster_name,
221 | },
222 | }
223 | ],
224 | "current-context": cluster_name,
225 | "users": [
226 | {
227 | "name": cluster_name,
228 | "user": {
229 | "token": access_token,
230 | },
231 | }
232 | ],
233 | }
234 |
235 | config.load_kube_config_from_dict(config_dict=kubeconfig)
236 | v1_client = client.CoreV1Api()
237 | print("\nK8s returning client...")
238 |
239 | return v1_client, project_id, cluster_name
240 |
241 | @retry(stop=stop_after_attempt(15))
242 | def call(
243 | self,
244 | name: str,
245 | path: str,
246 | method: str,
247 | port: int = 8080,
248 | data: Optional[dict] = None,
249 | headers: Optional[dict] = None,
250 | ) -> Tuple[int, str]:
251 | data = data or {}
252 | headers = headers or {}
253 |
254 | workload_proxy_url = os.getenv("WORKLOAD_PROXY_URL")
255 | if workload_proxy_url is not None:
256 | print("Using workload proxy at", workload_proxy_url)
257 | client_cert = os.getenv("WORKLOAD_PROXY_CLIENT_CERT")
258 | client_key = os.getenv("WORKLOAD_PROXY_CLIENT_KEY")
259 | ca_cert = os.getenv("WORKLOAD_PROXY_CA_CERT")
260 |
261 | workload_proxy_client = httpx.Client(
262 | verify=ca_cert, cert=(client_cert, client_key)
263 | )
264 |
265 | merged_headers = {
266 | **headers,
267 | "X-Pod-Name": name,
268 | "X-Namespace": self.cfg.namespace,
269 | "X-Port": str(port),
270 | }
271 | else:
272 | print("Using direct connection to workload service")
273 | workload_proxy_client = httpx.Client()
274 | merged_headers = headers
275 | workload_proxy_url = (
276 | f"http://{name}.{self.cfg.namespace}.svc.cluster.local:{port}"
277 | )
278 |
279 | json_data = None if method == "GET" else data
280 | query_parameters = ""
281 | if method == "GET" and data:
282 | query_parameters = "?" + "&".join([f"{k}={v}" for k, v in data.items()])
283 |
284 | url = f"{workload_proxy_url.rstrip('/')}/{path.lstrip('/')}" + query_parameters
285 |
286 | print("Method: ", method)
287 | print("URL: ", url)
288 | print("Headers: ", merged_headers)
289 | print("JSON Data: ", json_data)
290 |
291 | r = workload_proxy_client.request(
292 | method=method, url=url, headers=merged_headers, json=json_data
293 | )
294 |
295 | return r.status_code, r.text
296 |
297 | def logs(self, name: str) -> str:
298 | """
299 | Fetches the logs from the specified pod.
300 |
301 | Parameters:
302 | name (str): The name of the pod.
303 |
304 | Returns:
305 | str: The logs from the pod.
306 | """
307 | try:
308 | return self.core_api.read_namespaced_pod_log(name=name, namespace="default")
309 | except ApiException as e:
310 | print(f"Failed to get logs for pod '{name}': {e}")
311 | raise
312 |
313 | def list(self) -> List[str]:
314 | pods = self.core_api.list_namespaced_pod(
315 | namespace="default", label_selector="provisioner=surfkit"
316 | )
317 | return [pod.metadata.name for pod in pods.items]
318 |
319 | def delete(self, name: str) -> None:
320 | try:
321 | # Delete the pod
322 | self.core_api.delete_namespaced_pod(
323 | name=name,
324 | namespace="default",
325 | body=client.V1DeleteOptions(grace_period_seconds=5),
326 | )
327 | print(f"Successfully deleted pod: {name}")
328 | except ApiException as e:
329 | print(f"Failed to delete pod '{name}': {e}")
330 | raise
331 |
332 | def clean(self) -> None:
333 | pods = self.core_api.list_namespaced_pod(
334 | namespace="default", label_selector="provisioner=surfkit"
335 | )
336 | for pod in pods.items:
337 | try:
338 | self.core_api.delete_namespaced_pod(
339 | name=pod.metadata.name,
340 | namespace="default",
341 | body=client.V1DeleteOptions(grace_period_seconds=5),
342 | )
343 | print(f"Deleted pod: {pod.metadata.name}")
344 | except ApiException as e:
345 | print(f"Failed to delete pod '{pod.metadata.name}': {e}")
346 |
--------------------------------------------------------------------------------
/surfkit/runtime/container/load.py:
--------------------------------------------------------------------------------
1 | from typing import List, Optional
2 |
3 | from pydantic import BaseModel
4 |
5 | from .base import ContainerRuntime
6 | from .docker import ConnectConfig as DockerConnectConfig
7 | from .docker import DockerRuntime
8 | from .kube import ConnectConfig as KubeConnectConfig
9 | from .kube import KubernetesRuntime
10 |
11 |
12 | class ContainerRuntimeConfig(BaseModel):
13 | provider: Optional[str] = None
14 | docker_config: Optional[DockerConnectConfig] = None
15 | kube_config: Optional[KubeConnectConfig] = None
16 | preference: List[str] = ["kube", "docker"]
17 |
18 |
19 | def load_container_runtime(cfg: ContainerRuntimeConfig) -> ContainerRuntime:
20 | if cfg.provider == KubernetesRuntime.name():
21 | if not cfg.kube_config:
22 | raise ValueError("Kubernetes config is required")
23 | return KubernetesRuntime.connect(cfg.kube_config)
24 |
25 | elif cfg.provider == DockerRuntime.name():
26 | if not cfg.docker_config:
27 | raise ValueError("Docker config is required")
28 | return DockerRuntime.connect(cfg.docker_config)
29 |
30 | else:
31 | raise ValueError(f"Unknown provider: {cfg.provider}")
32 |
--------------------------------------------------------------------------------
/surfkit/runtime/vm/base.py:
--------------------------------------------------------------------------------
1 | from abc import ABC, abstractmethod
2 |
3 |
4 | class VM:
5 | pass
6 |
7 |
8 | class VMRuntime(ABC):
9 | """A virtual machine runntime"""
10 |
11 | @abstractmethod
12 | def create(self) -> VM:
13 | pass
14 |
15 | @abstractmethod
16 | def delete(self, name: str) -> None:
17 | pass
18 |
19 | @abstractmethod
20 | def stop(self, name: str) -> None:
21 | pass
22 |
23 | @abstractmethod
24 | def start(self, name: str) -> None:
25 | pass
26 |
--------------------------------------------------------------------------------
/surfkit/server/models.py:
--------------------------------------------------------------------------------
1 | from typing import Any, Dict, List, Optional
2 |
3 | from pydantic import BaseModel, Field
4 | from taskara import V1Task
5 | from taskara.review import V1ReviewRequirement
6 | from threadmem import V1RoleThread
7 |
8 |
9 | class V1Action(BaseModel):
10 | """An action"""
11 |
12 | name: str
13 | parameters: Dict[str, Any]
14 |
15 |
16 | class V1ActionSelection(BaseModel):
17 | """An action selection from the model"""
18 |
19 | observation: str
20 | reason: str
21 | action: V1Action
22 |
23 |
24 | class V1DeviceConfig(BaseModel):
25 | name: str
26 | provision: bool = False
27 |
28 |
29 | class V1DevicesConfig(BaseModel):
30 | preference: List[V1DeviceConfig] = []
31 |
32 |
33 | class V1Runtime(BaseModel):
34 | type: str
35 | preference: List[str] = []
36 |
37 |
38 | class V1ResourceLimits(BaseModel):
39 | cpu: str = "2"
40 | memory: str = "2Gi"
41 |
42 |
43 | class V1ResourceRequests(BaseModel):
44 | cpu: str = "1"
45 | memory: str = "500m"
46 | gpu: Optional[str] = None
47 |
48 |
49 | class V1EnvVarOpt(BaseModel):
50 | name: str
51 | description: Optional[str] = None
52 | required: bool = False
53 | default: Optional[str] = None
54 | secret: bool = False
55 | options: List[str] = []
56 |
57 |
58 | class V1LLMProviders(BaseModel):
59 | preference: List[str] = []
60 |
61 |
62 | class V1Agent(BaseModel):
63 | name: str
64 | config: Dict[str, Any]
65 |
66 |
67 | class V1SolveTask(BaseModel):
68 | task: V1Task
69 | agent: Optional[V1Agent] = None
70 |
71 |
72 | class V1CreateTask(BaseModel):
73 | task: V1Task
74 | agent: Optional[V1Agent] = None
75 |
76 |
77 | class V1Meter(BaseModel):
78 | name: str
79 | unit: str
80 | cost: float
81 | description: Optional[str] = None
82 |
83 |
84 | class V1RuntimeConnect(BaseModel):
85 | name: str
86 | connect_config: BaseModel
87 |
88 |
89 | class V1AgentType(BaseModel):
90 | version: Optional[str] = None
91 | kind: Optional[str] = None
92 | id: Optional[str] = None
93 | name: str
94 | description: str
95 | cmd: str
96 | owner_id: Optional[str] = None
97 | repo: Optional[str] = None
98 | img_repo: Optional[str] = None
99 | versions: Optional[Dict[str, str]] = None
100 | env_opts: List[V1EnvVarOpt] = []
101 | supports: List[str] = []
102 | runtimes: List[V1Runtime] = []
103 | created: Optional[float] = None
104 | updated: Optional[float] = None
105 | public: bool = False
106 | icon: Optional[str] = None
107 | resource_requests: V1ResourceRequests = V1ResourceRequests()
108 | resource_limits: V1ResourceLimits = V1ResourceLimits()
109 | llm_providers: Optional[V1LLMProviders] = None
110 | devices: List[V1DeviceConfig] = []
111 | meters: List[V1Meter] = []
112 | tags: List[str] = []
113 | labels: Dict[str, str] = {}
114 | namespace: Optional[str] = None
115 |
116 |
117 | class V1AgentTypes(BaseModel):
118 | types: List[V1AgentType]
119 |
120 |
121 | class V1AgentInstance(BaseModel):
122 | name: str
123 | type: V1AgentType
124 | runtime: V1RuntimeConnect
125 | version: Optional[str] = None
126 | port: int = 9090
127 | labels: Dict[str, str] = {}
128 | tags: List[str] = []
129 | status: str
130 | owner_id: Optional[str] = None
131 | icon: Optional[str] = None
132 | created: float
133 | updated: float
134 |
135 |
136 | class V1AgentInstances(BaseModel):
137 | instances: List[V1AgentInstance]
138 |
139 |
140 | class V1Find(BaseModel):
141 | args: dict = {}
142 |
143 |
144 | class V1CreateAgentType(BaseModel):
145 | id: str
146 | name: str
147 | description: str
148 | image: str
149 | env_opts: List[V1EnvVarOpt] = []
150 | supported_runtimes: List[str] = []
151 | versions: Dict[str, str] = {}
152 | public: bool = False
153 | icon: Optional[str] = None
154 | tags: List[str] = []
155 | labels: Dict[str, str] = {}
156 |
157 |
158 | class V1Work:
159 | remote: str
160 | check_interval: int
161 |
162 |
163 | class V1UserProfile(BaseModel):
164 | email: Optional[str] = None
165 | display_name: Optional[str] = None
166 | handle: Optional[str] = None
167 | picture: Optional[str] = None
168 | created: Optional[int] = None
169 | updated: Optional[int] = None
170 | token: Optional[str] = None
171 |
172 |
173 | class V1Meta(BaseModel):
174 | id: str
175 | tags: List[str] = []
176 | labels: Dict[str, str] = {}
177 | owner_id: Optional[str] = None
178 | created: float
179 | updated: float
180 |
181 |
182 | class UserTasks(BaseModel):
183 | """A list of tasks for a user story"""
184 |
185 | tasks: List[str] = Field(description="A list of tasks for a user story")
186 |
187 |
188 | class UserTask(BaseModel):
189 | """A task for a user story"""
190 |
191 | task: str = Field(description="A task for a user story")
192 |
193 |
194 | class V1Skill(BaseModel):
195 | id: str
196 | name: str
197 | description: str
198 | requirements: List[str]
199 | max_steps: int
200 | review_requirements: List[V1ReviewRequirement]
201 | tasks: List[V1Task]
202 | example_tasks: List[str]
203 | threads: List[V1RoleThread] = []
204 | status: Optional[str] = None
205 | min_demos: Optional[int] = None
206 | demos_outstanding: Optional[int] = None
207 | demo_queue_size: Optional[int] = None
208 | owner_id: Optional[str] = None
209 | generating_tasks: Optional[bool] = None
210 | agent_type: str
211 | kvs: Optional[Dict[str, Any]] = None
212 | remote: Optional[str] = None
213 | created: int
214 | updated: int
215 |
216 |
217 | class SkillsWithGenTasks(BaseModel):
218 | skill_id: str
219 | in_queue_count: int
220 | tasks_needed: int
221 |
222 |
223 | class V1UpdateSkill(BaseModel):
224 | name: Optional[str] = None
225 | description: Optional[str] = None
226 | requirements: Optional[List[str]] = None
227 | max_steps: Optional[int] = None
228 | review_requirements: Optional[List[V1ReviewRequirement]] = None
229 | tasks: Optional[List[str]] = None
230 | example_tasks: Optional[List[str]] = None
231 | threads: Optional[List[str]] = None
232 | status: Optional[str] = None
233 | min_demos: Optional[int] = None
234 | demos_outstanding: Optional[int] = None
235 | demo_queue_size: Optional[int] = None
236 | kvs: Optional[Dict[str, Any]] = None
237 |
238 |
239 | class V1SetKey(BaseModel):
240 | key: str
241 | value: str
242 |
243 |
244 | class V1LearnSkill(BaseModel):
245 | skill_id: str
246 | remote: Optional[str] = None
247 | agent: Optional[V1Agent] = None
248 |
249 |
250 | class V1LearnTask(BaseModel):
251 | task: V1Task
252 | remote: Optional[str] = None
253 | agent: Optional[V1Agent] = None
254 |
--------------------------------------------------------------------------------
/surfkit/server/routes.py:
--------------------------------------------------------------------------------
1 | import logging
2 | import os
3 | import time
4 | from typing import Annotated, Optional, Type
5 |
6 | import requests
7 | from agentcore.models import V1UserProfile
8 | from fastapi import APIRouter, BackgroundTasks, Depends
9 | from taskara import Task, TaskStatus
10 | from taskara.server.models import V1Task, V1Tasks, V1TaskUpdate
11 | from tenacity import retry, stop_after_attempt, wait_fixed
12 |
13 | from surfkit.agent import TaskAgent
14 | from surfkit.auth.transport import get_user_dependency
15 | from surfkit.env import AGENTESEA_HUB_API_KEY_ENV
16 | from surfkit.server.models import V1Agent, V1LearnTask, V1SolveTask
17 | from surfkit.skill import Skill
18 |
19 | DEBUG_ENV_VAR = os.getenv("DEBUG", "false").lower() == "true"
20 | log_level = logging.DEBUG if DEBUG_ENV_VAR else logging.INFO
21 | logging.basicConfig(level=log_level)
22 | logger = logging.getLogger(__name__)
23 |
24 |
25 | def task_router(Agent: Type[TaskAgent]) -> APIRouter:
26 | """API router for a task agent.
27 |
28 | Args:
29 | Agent (Type[TaskAgent]): Task agent type.
30 |
31 | Returns:
32 | APIRouter: An APIRouter for the task agent.
33 | """
34 |
35 | api_router = APIRouter()
36 |
37 | @api_router.get("/")
38 | async def root():
39 | return {"message": f"{Agent.name()} in the shell"}
40 |
41 | @api_router.get("/health")
42 | async def health():
43 | return {"status": "ok"}
44 |
45 | @api_router.post("/v1/learn")
46 | async def learn_task(
47 | current_user: Annotated[V1UserProfile, Depends(get_user_dependency())],
48 | background_tasks: BackgroundTasks,
49 | learn_model: V1LearnTask,
50 | ):
51 | task_model = learn_model.task
52 | logger.info(
53 | f"learning task: {task_model.model_dump()} with user {current_user.model_dump()}"
54 | )
55 |
56 | found = Task.find(
57 | remote=task_model.remote,
58 | id=task_model.id,
59 | owner_id=task_model.owner_id,
60 | auth_token=task_model.auth_token,
61 | )
62 | if not found:
63 | raise Exception(f"Task {task_model.id} not found")
64 |
65 | logger.info(f"found task: {found[0].to_v1().model_dump()}")
66 |
67 | task = found[0]
68 | task.remote = task_model.remote # type: ignore
69 | task.auth_token = task_model.auth_token # type: ignore
70 |
71 | skill_id = None
72 | if task.skill:
73 | skill_id = task.skill
74 | elif "skill" in task.labels:
75 | skill_id = task.labels["skill"]
76 | elif "skill_id" in task.labels:
77 | skill_id = task.labels["skill_id"]
78 | else:
79 | raise ValueError("Task skill or skill label not set")
80 |
81 | logger.info(f"finding skill_id: {skill_id}")
82 | skills = Skill.find(
83 | id=skill_id, remote=task.remote, token=task_model.auth_token
84 | )
85 | if not skills:
86 | raise ValueError(f"Skill not found: {skill_id}")
87 | skill = skills[0]
88 | logger.info(f"skill: {skill.to_v1().model_dump()}")
89 |
90 | background_tasks.add_task(
91 | _learn_task, task, skill, current_user, learn_model.agent
92 | )
93 |
94 | def _learn_task(
95 | task: Task,
96 | skill: Skill,
97 | current_user: V1UserProfile,
98 | v1_agent: Optional[V1Agent] = None,
99 | ):
100 | if v1_agent:
101 | config = Agent.config_type().model_validate(v1_agent.config)
102 | agent = Agent.from_config(config=config)
103 | else:
104 | agent = Agent.default()
105 |
106 | print(f"agent: {agent}", flush=True)
107 |
108 | if not task.remote or not task.auth_token:
109 | raise ValueError("Task remote and auth token must be set")
110 |
111 | try:
112 | print(f"labeling task as training: {task.id}", flush=True)
113 | _label_task(
114 | task.remote, task.auth_token, task, "foo/train/status", "training"
115 | )
116 | print("labeled task as training", flush=True)
117 | agent.learn_task(task, skill)
118 | print(f"labeling task as finished: {task.id}", flush=True)
119 | _label_task(
120 | task.remote, task.auth_token, task, "foo/train/status", "finished"
121 | )
122 | print("labeled task as finished", flush=True)
123 | except Exception as e:
124 | logger.error(f"error learning task: {e}")
125 | print(f"labeling task as error: {task.id}", flush=True)
126 | _label_task(task.remote, task.auth_token, task, "foo/train/status", "error")
127 | _label_task(task.remote, task.auth_token, task, "foo/train/error", str(e))
128 | print("labeled task as error", flush=True)
129 |
130 | @api_router.post("/v1/tasks")
131 | async def solve_task(
132 | current_user: Annotated[V1UserProfile, Depends(get_user_dependency())],
133 | background_tasks: BackgroundTasks,
134 | task_model: V1SolveTask,
135 | ):
136 | logger.info(
137 | f"solving task: {task_model.model_dump()} with user {current_user.email}"
138 | )
139 |
140 | background_tasks.add_task(_solve_task, task_model, current_user)
141 | logger.info("created background task...")
142 | return
143 |
144 | def _solve_task(task_model: V1SolveTask, current_user: V1UserProfile):
145 | owner_id = task_model.task.owner_id
146 | if not owner_id:
147 | owner_id = "local"
148 | task = Task.from_v1(
149 | task_model.task, owner_id=owner_id, auth_token=task_model.task.auth_token
150 | )
151 |
152 | logger.info("Saving remote tasks status to running...")
153 | task.status = TaskStatus.IN_PROGRESS
154 | task.started = time.time()
155 | task.save()
156 |
157 | if task_model.task.device:
158 | logger.info(f"connecting to device {task_model.task.device.name}...")
159 | device = None
160 | for Device in Agent.supported_devices():
161 | if Device.type() == task_model.task.device.type:
162 | logger.debug(f"found device: {task_model.task.device.model_dump()}")
163 | api_key = task_model.task.auth_token
164 | if api_key is None:
165 | logger.info("No Api key/token on Task or in Auth")
166 |
167 | try:
168 | config = Device.connect_config_type()(
169 | **{**task_model.task.device.config, "api_key": api_key} # type: ignore
170 | )
171 | device = Device.connect(config=config)
172 | except Exception as e:
173 | err = f"error connecting to device: {e}"
174 | task.error = err
175 | task.status = TaskStatus.ERROR
176 | task.save()
177 | raise Exception(err)
178 |
179 | if not device:
180 | raise ValueError(
181 | f"Device {task_model.task.device.name} provided in solve task, but not supported by agent"
182 | )
183 |
184 | logger.debug(f"connected to device: {device.__dict__}")
185 | else:
186 | raise ValueError("No device provided")
187 |
188 | logger.info("starting agent...")
189 | if task_model.agent:
190 | config = Agent.config_type().model_validate(task_model.agent.config)
191 | agent = Agent.from_config(config=config)
192 | else:
193 | agent = Agent.default()
194 |
195 | try:
196 | final_task = agent.solve_task(
197 | task=task, device=device, max_steps=task.max_steps
198 | )
199 |
200 | except Exception as e:
201 | logger.error(f"error running agent: {e}")
202 |
203 | task.refresh()
204 | task.status = TaskStatus.FAILED
205 | task.error = str(e)
206 | task.completed = time.time()
207 | task.save()
208 | task.post_message(
209 | "assistant", f"Failed to run task '{task.description}': {e}"
210 | )
211 | return
212 |
213 | finally:
214 | print(f"► task run ended '{task.id}'", flush=True)
215 |
216 | if final_task:
217 | final_task.refresh()
218 | final_task.completed = time.time()
219 | final_task.save()
220 |
221 | @api_router.get("/v1/tasks", response_model=V1Tasks)
222 | async def get_tasks(
223 | current_user: Annotated[V1UserProfile, Depends(get_user_dependency())],
224 | ):
225 | tasks = Task.find()
226 | return V1Tasks(tasks=[task.to_v1() for task in tasks])
227 |
228 | @api_router.get("/v1/tasks/{id}", response_model=V1Task)
229 | async def get_task(
230 | current_user: Annotated[V1UserProfile, Depends(get_user_dependency())], id: str
231 | ):
232 | tasks = Task.find(id=id)
233 | if not tasks:
234 | raise Exception(f"Task {id} not found")
235 | return tasks[0].to_v1()
236 |
237 | @api_router.put("/v1/tasks/{id}", response_model=V1Task)
238 | async def put_task(
239 | current_user: Annotated[V1UserProfile, Depends(get_user_dependency())],
240 | id: str,
241 | data: V1TaskUpdate,
242 | ):
243 | tasks = Task.find(id=id)
244 | if not tasks:
245 | raise Exception(f"Task {id} not found")
246 | task = tasks[0]
247 | if data.status:
248 | task.status = TaskStatus(data.status)
249 | logging.info("updated task status to: ", task.status)
250 | task.save()
251 | return task.to_v1()
252 |
253 | return api_router
254 |
255 |
256 | @retry(stop=stop_after_attempt(10), wait=wait_fixed(10))
257 | def get_remote_task(id: str, owner_id: str, server: str, auth_token: str) -> Task:
258 | HUB_API_KEY = os.environ.get(AGENTESEA_HUB_API_KEY_ENV)
259 | if not HUB_API_KEY:
260 | raise Exception(f"${AGENTESEA_HUB_API_KEY_ENV} not set")
261 |
262 | logger.debug(f"connecting to remote task: {id} key: {HUB_API_KEY}")
263 | try:
264 | tasks = Task.find(
265 | id=id,
266 | remote=server,
267 | owner_id=owner_id,
268 | auth_token=auth_token,
269 | )
270 | if not tasks:
271 | raise Exception(f"Task {id} not found")
272 | logger.debug(f"got remote task: {tasks[0].__dict__}")
273 | return tasks[0]
274 | except Exception as e:
275 | logger.error(f"error getting remote task: {e}")
276 | raise e
277 |
278 |
279 | def _label_task(remote: str, token: str, task: Task, key: str, value: str) -> None:
280 | """Label a task as trained
281 |
282 | Args:
283 | task (Task): The task
284 | """
285 | update = V1TaskUpdate(
286 | set_labels={key: value},
287 | )
288 | resp = requests.put(
289 | f"{remote}/v1/tasks/{task.id}",
290 | json=update.model_dump(),
291 | headers={"Authorization": f"Bearer {token}"},
292 | )
293 | resp.raise_for_status()
294 |
--------------------------------------------------------------------------------
/surfkit/util.py:
--------------------------------------------------------------------------------
1 | import json
2 | import re
3 | import socket
4 | from datetime import datetime
5 | from typing import Any, Dict, Optional
6 |
7 |
8 | def extract_parse_json(input_str: str) -> Dict[str, Any]:
9 | """
10 | Extracts and parses a JSON object from the input string using regex if it is tagged with 'json\n'
11 | and enclosed in backticks, otherwise returns the input string.
12 |
13 | :param input_str: A string that may contain a JSON object.
14 | :return: A dictionary if JSON is parsed, otherwise the original string.
15 | """
16 | # Regex to match 'json\n{...}' pattern enclosed in backticks
17 | match = re.search(r"```json\n([\s\S]+?)\n```", input_str)
18 | if match:
19 | json_str = match.group(1) # Extract the JSON string
20 | try:
21 | return json.loads(json_str)
22 | except json.JSONDecodeError:
23 | raise
24 | else:
25 | return json.loads(input_str)
26 |
27 |
28 | def find_open_port(start_port: int = 1024, end_port: int = 65535) -> Optional[int]:
29 | """Finds an open port on the machine"""
30 | for port in range(start_port, end_port + 1):
31 | with socket.socket(socket.AF_INET, socket.SOCK_STREAM) as s:
32 | try:
33 | s.bind(("", port))
34 | return port # Port is open
35 | except socket.error:
36 | continue # Port is in use, try the next one
37 | return None # No open port found
38 |
39 |
40 | def convert_unix_to_datetime(unix_timestamp: int) -> str:
41 | dt = datetime.utcfromtimestamp(unix_timestamp)
42 | friendly_format = dt.strftime("%Y-%m-%d %H:%M:%S")
43 | return friendly_format
44 |
--------------------------------------------------------------------------------
/ui/surfkit/.gitignore:
--------------------------------------------------------------------------------
1 | # See https://help.github.com/articles/ignoring-files/ for more about ignoring files.
2 |
3 | # dependencies
4 | /node_modules
5 | /.pnp
6 | .pnp.js
7 |
8 | # testing
9 | /coverage
10 |
11 | # production
12 | /build
13 |
14 | # misc
15 | .DS_Store
16 | .env.local
17 | .env.development.local
18 | .env.test.local
19 | .env.production.local
20 |
21 | npm-debug.log*
22 | yarn-debug.log*
23 | yarn-error.log*
24 |
--------------------------------------------------------------------------------
/ui/surfkit/Dockerfile:
--------------------------------------------------------------------------------
1 | # Step 1: Use an official Node.js runtime as a parent image
2 | FROM node:latest
3 |
4 | # Step 2: Set the working directory in the container
5 | WORKDIR /usr/src/app
6 |
7 | # Step 3: Copy the package.json files and install dependencies
8 | COPY package*.json ./
9 | RUN npm install
10 |
11 | # Step 4: Bundle app source inside Docker image
12 | COPY . .
13 |
14 | # Step 5: Your app binds to port 3000, so you'll use the EXPOSE instruction to have it mapped by the docker daemon
15 | EXPOSE 3000
16 |
17 | # Step 6: Define the command to run your app
18 | CMD ["npm", "start"]
19 |
--------------------------------------------------------------------------------
/ui/surfkit/Makefile:
--------------------------------------------------------------------------------
1 | IMAGE_REPO := us-central1-docker.pkg.dev/agentsea-dev/guisurfer/surfkit-ui
2 | TAG := latest
3 |
4 |
5 | .PHONY: serve
6 | serve:
7 | npm start
8 |
9 | .PHONY: build-img
10 | build-img:
11 | docker buildx build --platform linux/amd64,linux/arm64 --push -t ${IMAGE_REPO}:${TAG} .
12 |
13 | .PHONY: push-img
14 | push-img:
15 | docker push ${IMAGE_REPO}:${TAG}
16 |
17 | # .PHONY: deploy
18 | # deploy:
19 | # helm install -n hub -f ./deploy/helm/agentsea-hub-ui/values.yaml hubapi ./deploy/helm/agentsea-hub-api
20 |
21 | # .PHONY: package-chart
22 | # package-chart:
23 | # rm -rf ./pkg
24 | # mkdir -p ./pkg
25 | # helm package ./deploy/helm/agentsea-hub-ui -d ./pkg
26 |
27 | # .PHONY: push-chart
28 | # push-chart: package-chart
29 | # $(eval CHART_FILE=$(shell ls ./pkg | head -n1))
30 | # helm push ./pkg/$(CHART_FILE) oci://us-central1-docker.pkg.dev/agentsea-dev/hub
31 | # rm -rf ./pkg
32 |
33 | # .PHONY: release
34 | # release: build-img push-chart
--------------------------------------------------------------------------------
/ui/surfkit/README.md:
--------------------------------------------------------------------------------
1 | # Getting Started with Create React App
2 |
3 | This project was bootstrapped with [Create React App](https://github.com/facebook/create-react-app).
4 |
5 | ## Available Scripts
6 |
7 | In the project directory, you can run:
8 |
9 | ### `npm start`
10 |
11 | Runs the app in the development mode.\
12 | Open [http://localhost:3000](http://localhost:3000) to view it in your browser.
13 |
14 | The page will reload when you make changes.\
15 | You may also see any lint errors in the console.
16 |
17 | ### `npm test`
18 |
19 | Launches the test runner in the interactive watch mode.\
20 | See the section about [running tests](https://facebook.github.io/create-react-app/docs/running-tests) for more information.
21 |
22 | ### `npm run build`
23 |
24 | Builds the app for production to the `build` folder.\
25 | It correctly bundles React in production mode and optimizes the build for the best performance.
26 |
27 | The build is minified and the filenames include the hashes.\
28 | Your app is ready to be deployed!
29 |
30 | See the section about [deployment](https://facebook.github.io/create-react-app/docs/deployment) for more information.
31 |
32 | ### `npm run eject`
33 |
34 | **Note: this is a one-way operation. Once you `eject`, you can't go back!**
35 |
36 | If you aren't satisfied with the build tool and configuration choices, you can `eject` at any time. This command will remove the single build dependency from your project.
37 |
38 | Instead, it will copy all the configuration files and the transitive dependencies (webpack, Babel, ESLint, etc) right into your project so you have full control over them. All of the commands except `eject` will still work, but they will point to the copied scripts so you can tweak them. At this point you're on your own.
39 |
40 | You don't have to ever use `eject`. The curated feature set is suitable for small and middle deployments, and you shouldn't feel obligated to use this feature. However we understand that this tool wouldn't be useful if you couldn't customize it when you are ready for it.
41 |
42 | ## Learn More
43 |
44 | You can learn more in the [Create React App documentation](https://facebook.github.io/create-react-app/docs/getting-started).
45 |
46 | To learn React, check out the [React documentation](https://reactjs.org/).
47 |
48 | ### Code Splitting
49 |
50 | This section has moved here: [https://facebook.github.io/create-react-app/docs/code-splitting](https://facebook.github.io/create-react-app/docs/code-splitting)
51 |
52 | ### Analyzing the Bundle Size
53 |
54 | This section has moved here: [https://facebook.github.io/create-react-app/docs/analyzing-the-bundle-size](https://facebook.github.io/create-react-app/docs/analyzing-the-bundle-size)
55 |
56 | ### Making a Progressive Web App
57 |
58 | This section has moved here: [https://facebook.github.io/create-react-app/docs/making-a-progressive-web-app](https://facebook.github.io/create-react-app/docs/making-a-progressive-web-app)
59 |
60 | ### Advanced Configuration
61 |
62 | This section has moved here: [https://facebook.github.io/create-react-app/docs/advanced-configuration](https://facebook.github.io/create-react-app/docs/advanced-configuration)
63 |
64 | ### Deployment
65 |
66 | This section has moved here: [https://facebook.github.io/create-react-app/docs/deployment](https://facebook.github.io/create-react-app/docs/deployment)
67 |
68 | ### `npm run build` fails to minify
69 |
70 | This section has moved here: [https://facebook.github.io/create-react-app/docs/troubleshooting#npm-run-build-fails-to-minify](https://facebook.github.io/create-react-app/docs/troubleshooting#npm-run-build-fails-to-minify)
71 |
--------------------------------------------------------------------------------
/ui/surfkit/package.json:
--------------------------------------------------------------------------------
1 | {
2 | "name": "surfkit",
3 | "version": "0.0.0",
4 | "private": true,
5 | "dependencies": {
6 | "@fortawesome/fontawesome-svg-core": "^6.5.2",
7 | "@fortawesome/react-fontawesome": "^0.2.2",
8 | "@heroicons/react": "^2.1.3",
9 | "@material-tailwind/react": "2.1.8",
10 | "react": "18.2.0",
11 | "react-dom": "18.2.0",
12 | "react-router-dom": "^6.23.1",
13 | "react-scripts": "5.0.1",
14 | "react-vnc": "^1.0.0"
15 | },
16 | "scripts": {
17 | "start": "react-scripts start",
18 | "build": "react-scripts build",
19 | "test": "react-scripts test",
20 | "eject": "react-scripts eject"
21 | },
22 | "eslintConfig": {
23 | "extends": [
24 | "react-app",
25 | "react-app/jest"
26 | ]
27 | },
28 | "browserslist": {
29 | "production": [
30 | ">0.2%",
31 | "not dead",
32 | "not op_mini all"
33 | ],
34 | "development": [
35 | "last 1 chrome version",
36 | "last 1 firefox version",
37 | "last 1 safari version"
38 | ]
39 | },
40 | "devDependencies": {
41 | "tailwindcss": "3.4.0"
42 | }
43 | }
44 |
--------------------------------------------------------------------------------
/ui/surfkit/public/favicon.ico:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/agentsea/surfkit/8708abd995d45cad5e0a94a9606d6ada6b8a94dd/ui/surfkit/public/favicon.ico
--------------------------------------------------------------------------------
/ui/surfkit/public/favicon_a2.ico:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/agentsea/surfkit/8708abd995d45cad5e0a94a9606d6ada6b8a94dd/ui/surfkit/public/favicon_a2.ico
--------------------------------------------------------------------------------
/ui/surfkit/public/index.html:
--------------------------------------------------------------------------------
1 |
2 |
3 |
4 | Surfkit
28 |
29 |
30 | You need to enable JavaScript to run this app.
31 |
32 |
42 |
43 |
44 |
--------------------------------------------------------------------------------
/ui/surfkit/public/logo.svg:
--------------------------------------------------------------------------------
1 |
6 |
7 |
9 | {children}
10 |
59 |
60 |
65 |
66 | {/*
72 | SurfKit
73 | */}
74 |
75 |
77 |
setOpenNav(!openNav)}
82 | >
83 | {openNav ? (
84 |
89 |
91 |
93 |
94 | );
95 | }
96 |
--------------------------------------------------------------------------------
/ui/surfkit/src/components/Recording.js:
--------------------------------------------------------------------------------
1 | import { useState } from "react";
2 | import { Typography } from "@material-tailwind/react";
3 | import { XCircleIcon } from "@heroicons/react/24/outline";
4 |
5 | import { deleteEvent } from "../api/agentd";
6 |
7 | function EditableEvent({ data, onDelete }) {
8 | const renderEventData = () => {
9 | switch (data.type) {
10 | case "scroll":
11 | return
25 | {/* Delete button with X icon */}
26 |
27 |
29 |
30 |
31 |
35 |
39 | {renderEventData()}
40 |
70 |
71 |
75 |
79 | {renderEventData()}
80 | {/*
; */}
81 |
{JSON.stringify(value, null, 2)} ;
89 | }
90 | return {value}
;
91 | };
92 |
93 | return (
94 |
95 |
{k}:
96 | {renderValue(v)}
97 |
110 |
Current Task
111 |
112 |
113 |
117 |
Events {"\u25BC"}
118 |
119 | {data.events.map((event, index) => (
120 |
123 |
149 |
Events {"\u25BC"}
150 |
151 | {events.map((event, index) => (
152 | handleDeleteEvent(index)}
156 | />
157 | ))}
158 |
159 |
34 | {messages.map((msg, index) => (
35 |
42 |
43 | {/* Render the avatar with fallback */}
44 |
52 | {/* Role Name or Fallback */}
53 |
54 | {roleMapping[msg.role]?.user_name || msg.role}
55 |
56 |
58 | {msg.text}
59 |
60 | {/* If there are images, render them */}
61 | {msg.images &&
62 | msg.images.map((image, imgIndex) => (
63 |
72 | ))}
73 | {/* Invisible marker for scrolling */}
74 |
75 | {/* Modal for displaying the full-size image */}
76 |
setModalOpen(false)}
79 | className="max-w-full max-h-full overflow-y-auto"
80 | >
81 |
87 |
26 |
27 | {threads.map((thread) => (
28 | setSelectedThreadName(thread.name)}
37 | >
38 | #{thread.name}
39 |
40 | ))}
41 |
42 |
43 |
153 |
154 |
155 |
Task
156 | {data.status &&
157 | data.status !== "completed" &&
158 | data.status !== "failed" &&
159 | data.status !== "review" &&
160 | data.status !== "cancelled" && (
161 |
162 |
169 |
172 |
178 |
181 |
182 | )}
183 | {data.status && data.status === "review" && (
184 |
185 |
192 |
195 |
201 |
204 |
205 | )}
206 |
208 |
209 |
210 | Description
211 |
212 | {/* TODO: this should be handled better */}
213 |
214 | {data.description}
215 |
216 |
217 |
218 |
219 | Status
220 |
221 |
229 |
230 |
232 |
237 | {getActiveThreadMessages().map((msg, index) => (
238 |
239 |
243 |
249 |
250 | {msg.text}
251 |
252 |
253 |
254 | ))}
255 |
256 |
262 |
271 | )} */}
272 | {data.output && data.output !== "" && (
273 |
274 |
275 | Result
276 |
277 | {data.output}
278 |
279 | )}
280 | {data.error && data.error !== "" && (
281 |
282 |
287 | Error
288 |
289 | {data.error}
290 |
291 | )}
292 |
293 | );
294 | }
295 |
--------------------------------------------------------------------------------
/ui/surfkit/src/index.css:
--------------------------------------------------------------------------------
1 | @tailwind base;
2 | @tailwind components;
3 | @tailwind utilities;
4 |
--------------------------------------------------------------------------------
/ui/surfkit/src/index.js:
--------------------------------------------------------------------------------
1 | import React from "react";
2 | import ReactDOM from "react-dom/client";
3 | import "./index.css";
4 | import App from "./App";
5 |
6 | import { ThemeProvider } from "@material-tailwind/react";
7 |
8 | const root = ReactDOM.createRoot(document.getElementById("root"));
9 | root.render(
10 |
11 |
12 |
14 | ,
15 | );
16 |
--------------------------------------------------------------------------------
/ui/surfkit/src/pages/ContainerDesktopPage.js:
--------------------------------------------------------------------------------
1 | import React, { useRef, useEffect, useState } from "react";
2 | import Layout from "../components/Layout";
3 | import { useLocation } from "react-router-dom";
4 | import Task from "../components/Task";
5 | import { getTask } from "../api/Tasks";
6 | import { Typography } from "@material-tailwind/react";
7 |
8 | export default function ContainerDesktopPage() {
9 | const location = useLocation();
10 | const queryParams = new URLSearchParams(location.search);
11 | const agentAddr = queryParams.get("agentAddr") || "http://localhost:9090";
12 | const taskAddr = queryParams.get("taskAddr") || "http://localhost:9070";
13 | const vncAddr = queryParams.get("vncAddr") || "http://localhost:3000";
14 | const taskID = queryParams.get("taskID");
15 | const token = queryParams.get("authToken");
16 |
17 | const [agentTask, setAgentTask] = useState(null);
18 |
19 | const abortControllerRef = useRef(new AbortController());
20 | const timeoutRef = useRef(null);
21 | useEffect(() => {
22 | const handleStart = async () => {
23 | console.log("Starting fetch at:", new Date().toISOString());
24 | const task = await getTask(taskAddr, taskID, token);
25 | if (!task) {
26 | return;
27 | }
28 | setAgentTask(task);
29 | console.log("Tasks updated at:", new Date().toISOString());
30 | console.log(task);
31 | // Schedule the next call
32 | timeoutRef.current = setTimeout(handleStart, 2000);
33 | };
34 |
35 | handleStart(); // Call initially
36 |
37 | return () => {
38 | if (timeoutRef.current) {
39 | clearTimeout(timeoutRef.current); // Clear the timeout if the component unmounts
40 | }
41 | };
42 | }, [taskAddr, taskID, token]);
43 | const ref = useRef();
44 |
45 | return (
46 |
47 |
48 |
49 | {agentTask ? (
50 |
51 | ) : (
52 |
53 | No tasks
54 |
55 | )}
56 |
57 |
58 |
63 |
64 |
66 | );
67 | }
68 |
--------------------------------------------------------------------------------
/ui/surfkit/src/pages/DesktopPage.js:
--------------------------------------------------------------------------------
1 | import React, { useRef, useEffect, useState } from "react";
2 | import { VncScreen } from "react-vnc";
3 | import Layout from "../components/Layout";
4 | import { useLocation } from "react-router-dom";
5 | import Task from "../components/Task";
6 | import { getTask } from "../api/Tasks";
7 | import { Typography } from "@material-tailwind/react";
8 |
9 | export default function DesktopPage() {
10 | const location = useLocation();
11 | const queryParams = new URLSearchParams(location.search);
12 | const agentAddr = queryParams.get("agentAddr") || "http://localhost:9090";
13 | const taskAddr = queryParams.get("taskAddr") || "http://localhost:9070";
14 | const vncAddr = queryParams.get("vncAddr") || "ws://localhost:6080";
15 | const taskID = queryParams.get("taskID");
16 | const token = queryParams.get("authToken");
17 |
18 | const [agentTask, setAgentTask] = useState(null);
19 |
20 | const abortControllerRef = useRef(new AbortController());
21 | const timeoutRef = useRef(null);
22 | useEffect(() => {
23 | const handleStart = async () => {
24 | console.log("Starting fetch at:", new Date().toISOString());
25 | const task = await getTask(taskAddr, taskID, token);
26 | if (!task) {
27 | return;
28 | }
29 | setAgentTask(task);
30 | console.log("Tasks updated at:", new Date().toISOString());
31 | console.log(task);
32 | // Schedule the next call
33 | timeoutRef.current = setTimeout(handleStart, 2000);
34 | };
35 |
36 | handleStart(); // Call initially
37 |
38 | return () => {
39 | if (timeoutRef.current) {
40 | clearTimeout(timeoutRef.current); // Clear the timeout if the component unmounts
41 | }
42 | };
43 | }, [taskAddr, taskID, token]);
44 | const ref = useRef();
45 |
46 | return (
47 |
48 |
49 |
50 | {agentTask ? (
51 |
52 | ) : (
53 |
54 | No tasks
55 |
56 | )}
57 |
58 |
59 |
73 |
75 | );
76 | }
77 |
--------------------------------------------------------------------------------
/ui/surfkit/src/server/Routes.js:
--------------------------------------------------------------------------------
1 | import React from "react";
2 | import { Route, Routes } from "react-router-dom";
3 |
4 | import DesktopPage from "../pages/DesktopPage";
5 | import ContainerDesktopPage from "../pages/ContainerDesktopPage";
6 |
7 | export default function AppRoutes() {
8 | return (
9 |
10 |
13 | );
14 | }
15 |
--------------------------------------------------------------------------------
/ui/surfkit/tailwind.config.js:
--------------------------------------------------------------------------------
1 | const withMT = require("@material-tailwind/react/utils/withMT");
2 |
3 | module.exports = withMT({
4 | content: ["./src/**/*.{js,jsx,ts,tsx}"],
5 | theme: {
6 | extend: {},
7 | },
8 | plugins: [],
9 | });
10 |
--------------------------------------------------------------------------------
65 |
66 | {/* 
; */}
81 | 
handleImageClick(image)}
69 | />
70 | ))}
71 |