wehub-resource-sync
398 lines
14 KiB
Python
398 lines
14 KiB
Python
import json
|
|
import os
|
|
import subprocess
|
|
from collections.abc import Awaitable, Callable
|
|
from pathlib import Path
|
|
from typing import Any, Literal, TypeAlias, cast
|
|
|
|
from openai.types.responses import (
|
|
ResponseComputerToolCall,
|
|
ResponseFileSearchToolCall,
|
|
ResponseFunctionToolCall,
|
|
ResponseFunctionWebSearch,
|
|
)
|
|
from openai.types.responses.response_code_interpreter_tool_call import (
|
|
ResponseCodeInterpreterToolCall,
|
|
)
|
|
from openai.types.responses.response_output_item import ImageGenerationCall, LocalShellCall, McpCall
|
|
from pydantic import BaseModel, Field
|
|
from rich import box
|
|
from rich.console import Console, Group
|
|
from rich.markdown import Markdown
|
|
from rich.panel import Panel
|
|
from rich.pretty import Pretty
|
|
from rich.prompt import Prompt
|
|
from rich.syntax import Syntax
|
|
from rich.text import Text
|
|
from typing_extensions import TypedDict
|
|
|
|
from agents import ItemHelpers, TResponseInputItem
|
|
from agents.items import (
|
|
CompactionItem,
|
|
HandoffCallItem,
|
|
HandoffOutputItem,
|
|
MCPApprovalRequestItem,
|
|
MCPApprovalResponseItem,
|
|
MCPListToolsItem,
|
|
MessageOutputItem,
|
|
ReasoningItem,
|
|
ToolApprovalItem,
|
|
ToolCallItem,
|
|
ToolCallOutputItem,
|
|
ToolSearchCallItem,
|
|
ToolSearchOutputItem,
|
|
)
|
|
from agents.sandbox import Manifest
|
|
from agents.sandbox.sandboxes.docker import DockerSandboxClient, DockerSandboxClientOptions
|
|
from agents.sandbox.sandboxes.unix_local import UnixLocalSandboxClient
|
|
from agents.sandbox.session import BaseSandboxClient, SandboxSession
|
|
from agents.stream_events import (
|
|
AgentUpdatedStreamEvent,
|
|
RawResponsesStreamEvent,
|
|
StreamEvent,
|
|
)
|
|
from examples.auto_mode import input_with_fallback, is_auto_mode
|
|
|
|
DEFAULT_SANDBOX_IMAGE = "sandbox-tutorials:latest"
|
|
console = Console()
|
|
PanelBody = Group | Pretty | Text
|
|
PrintableEvent: TypeAlias = StreamEvent | str
|
|
SandboxClient: TypeAlias = BaseSandboxClient[Any]
|
|
InteractiveTurnRunner: TypeAlias = Callable[
|
|
[list[TResponseInputItem]], Awaitable[list[TResponseInputItem]]
|
|
]
|
|
|
|
|
|
class ApplyPatchOperationPayload(TypedDict):
|
|
path: str
|
|
type: Literal["create_file", "update_file", "delete_file"]
|
|
diff: str
|
|
|
|
|
|
class ApplyPatchCallPayload(TypedDict):
|
|
type: Literal["apply_patch_call"]
|
|
call_id: str
|
|
operation: ApplyPatchOperationPayload
|
|
|
|
|
|
class Question(BaseModel):
|
|
query: str = Field(description="User-facing question to ask.")
|
|
options: list[str] = Field(
|
|
default_factory=list,
|
|
description="Suggested answer options. The UI always adds a custom free-text choice.",
|
|
)
|
|
|
|
|
|
class QuestionAnswer(BaseModel):
|
|
question: str = Field(description="The question that was asked.")
|
|
answer: str = Field(description="The user's selected or free-text answer.")
|
|
|
|
|
|
def load_env_defaults(env_path: Path) -> None:
|
|
if not env_path.exists():
|
|
return
|
|
|
|
for raw_line in env_path.read_text(encoding="utf-8").splitlines():
|
|
line = raw_line.strip()
|
|
if not line or line.startswith("#") or "=" not in line:
|
|
continue
|
|
|
|
key, value = line.split("=", 1)
|
|
normalized_key = key.strip()
|
|
normalized_value = value.strip().strip('"').strip("'")
|
|
if normalized_key:
|
|
os.environ.setdefault(normalized_key, normalized_value)
|
|
|
|
|
|
async def create_sandbox_client_and_session(
|
|
*,
|
|
manifest: Manifest,
|
|
use_docker: bool,
|
|
image: str = DEFAULT_SANDBOX_IMAGE,
|
|
) -> tuple[SandboxClient, SandboxSession]:
|
|
if use_docker:
|
|
try:
|
|
from docker import from_env as docker_from_env # type: ignore[import-untyped]
|
|
except ImportError as exc:
|
|
raise SystemExit(
|
|
"Docker-backed runs require the Docker SDK. Install repo dependencies with `make sync`."
|
|
) from exc
|
|
|
|
client: SandboxClient = DockerSandboxClient(
|
|
docker_from_env(environment=build_docker_environment())
|
|
)
|
|
sandbox = await client.create(
|
|
manifest=manifest,
|
|
options=DockerSandboxClientOptions(image=image),
|
|
)
|
|
return client, sandbox
|
|
|
|
client = UnixLocalSandboxClient()
|
|
sandbox = await client.create(manifest=manifest)
|
|
return client, sandbox
|
|
|
|
|
|
def build_docker_environment() -> dict[str, str]:
|
|
environment = os.environ.copy()
|
|
if environment.get("DOCKER_HOST") or environment.get("DOCKER_CONTEXT"):
|
|
return environment
|
|
|
|
# Respect whichever Docker context the CLI is currently using, including Docker Desktop
|
|
# and Colima, without taking a direct dependency on a specific daemon provider.
|
|
try:
|
|
result = subprocess.run(
|
|
["docker", "context", "inspect", "--format", "{{json .Endpoints.docker.Host}}"],
|
|
capture_output=True,
|
|
check=True,
|
|
text=True,
|
|
)
|
|
docker_host = json.loads(result.stdout.strip() or "null")
|
|
except (OSError, subprocess.SubprocessError, json.JSONDecodeError):
|
|
return environment
|
|
|
|
if isinstance(docker_host, str) and docker_host:
|
|
environment["DOCKER_HOST"] = docker_host
|
|
return environment
|
|
|
|
|
|
def prompt_with_fallback(prompt: str, fallback: str) -> str:
|
|
if is_auto_mode():
|
|
return input_with_fallback(prompt, fallback).strip()
|
|
|
|
try:
|
|
return Prompt.ask(prompt).strip()
|
|
except (EOFError, KeyboardInterrupt):
|
|
return fallback
|
|
|
|
|
|
def ask_user_questions(questions: list[Question]) -> list[QuestionAnswer]:
|
|
answers: list[QuestionAnswer] = []
|
|
|
|
for question_index, question in enumerate(questions, start=1):
|
|
suggested_options = [option.strip() for option in question.options if option.strip()]
|
|
custom_choice_index = len(suggested_options) + 1
|
|
options_text = Text.from_markup(
|
|
"\n".join(
|
|
[
|
|
*(
|
|
f"[cyan]{index}.[/cyan] {option}"
|
|
for index, option in enumerate(
|
|
suggested_options,
|
|
start=1,
|
|
)
|
|
),
|
|
f"[cyan]{custom_choice_index}.[/cyan] Use your own text",
|
|
]
|
|
)
|
|
)
|
|
|
|
console.print(
|
|
Panel(
|
|
Group(
|
|
Text(question.query),
|
|
options_text,
|
|
),
|
|
title=f"Question {question_index}",
|
|
border_style="magenta",
|
|
box=box.ROUNDED,
|
|
expand=False,
|
|
)
|
|
)
|
|
|
|
while True:
|
|
choice = prompt_with_fallback(
|
|
f"[bold cyan]Select[/bold cyan] 1-{custom_choice_index}",
|
|
"1" if suggested_options else str(custom_choice_index),
|
|
)
|
|
if choice.isdigit() and 1 <= int(choice) <= len(suggested_options):
|
|
answer = suggested_options[int(choice) - 1]
|
|
break
|
|
if choice.isdigit() and int(choice) == custom_choice_index:
|
|
answer = prompt_with_fallback(
|
|
"[bold cyan]Your answer[/bold cyan]",
|
|
suggested_options[0] if suggested_options else "Use a conservative assumption.",
|
|
)
|
|
if answer:
|
|
break
|
|
continue
|
|
if choice and not choice.isdigit():
|
|
answer = choice
|
|
break
|
|
|
|
console.print(
|
|
f"[red]Please enter a number from 1 to {custom_choice_index}, or custom text.[/red]"
|
|
)
|
|
|
|
answers.append(QuestionAnswer(question=question.query, answer=answer))
|
|
|
|
console.print(
|
|
Panel(
|
|
Pretty([answer.model_dump(mode="json") for answer in answers], expand_all=True),
|
|
title="Question answers",
|
|
border_style="magenta",
|
|
box=box.ROUNDED,
|
|
expand=False,
|
|
)
|
|
)
|
|
return answers
|
|
|
|
|
|
async def run_interactive_loop(
|
|
*,
|
|
conversation: list[TResponseInputItem],
|
|
no_interactive: bool,
|
|
run_turn: InteractiveTurnRunner,
|
|
) -> list[TResponseInputItem]:
|
|
if no_interactive or is_auto_mode():
|
|
return conversation
|
|
|
|
console.print("[dim]Enter follow-up prompts. Press Ctrl-D or Ctrl-C to finish.[/dim]")
|
|
while True:
|
|
try:
|
|
next_message = Prompt.ask("[bold cyan]user[/bold cyan]").strip()
|
|
except (EOFError, KeyboardInterrupt):
|
|
break
|
|
|
|
if not next_message:
|
|
continue
|
|
|
|
conversation.append({"role": "user", "content": next_message})
|
|
conversation = await run_turn(conversation)
|
|
|
|
return conversation
|
|
|
|
|
|
def print_event(event: PrintableEvent) -> None:
|
|
if isinstance(event, str):
|
|
console.print()
|
|
console.rule("[bold green]Final output[/bold green]", style="green")
|
|
console.print(
|
|
Panel(
|
|
Markdown(event or "_No final output returned._"),
|
|
border_style="green",
|
|
box=box.ROUNDED,
|
|
expand=False,
|
|
)
|
|
)
|
|
return
|
|
|
|
if isinstance(event, AgentUpdatedStreamEvent):
|
|
console.print(
|
|
Panel(
|
|
Pretty(event.new_agent.name, expand_all=True),
|
|
title="Agent updated",
|
|
border_style="cyan",
|
|
box=box.ROUNDED,
|
|
expand=False,
|
|
)
|
|
)
|
|
return
|
|
|
|
if isinstance(event, RawResponsesStreamEvent):
|
|
return
|
|
|
|
body: PanelBody
|
|
match event.item:
|
|
case ReasoningItem() as item:
|
|
body = Pretty(item, expand_all=True)
|
|
title = f"Reasoning item: {event.name.replace('_', ' ')}"
|
|
case ToolCallItem() as item:
|
|
tool_name = "tool"
|
|
body = Pretty(item.raw_item, expand_all=True)
|
|
match item.raw_item:
|
|
case ResponseFunctionToolCall() as raw_item:
|
|
tool_name = raw_item.name
|
|
payload = json.loads(raw_item.arguments) if raw_item.arguments else {}
|
|
if tool_name == "exec_command":
|
|
command = payload["cmd"]
|
|
if "\\n" in command and "\n" not in command:
|
|
command = command.replace("\\n", "\n")
|
|
body = Group(
|
|
Pretty(
|
|
{key: value for key, value in payload.items() if key != "cmd"},
|
|
expand_all=True,
|
|
),
|
|
Syntax(command, "bash", theme="ansi_dark", word_wrap=True),
|
|
)
|
|
else:
|
|
body = Pretty(payload, expand_all=True)
|
|
case ResponseComputerToolCall() as raw_item:
|
|
tool_name = "computer"
|
|
body = Pretty(raw_item, expand_all=True)
|
|
case ResponseFileSearchToolCall() as raw_item:
|
|
tool_name = "file_search"
|
|
body = Pretty(raw_item, expand_all=True)
|
|
case ResponseFunctionWebSearch() as raw_item:
|
|
tool_name = "web_search"
|
|
body = Pretty(raw_item, expand_all=True)
|
|
case McpCall() as raw_item:
|
|
tool_name = "mcp"
|
|
body = Pretty(raw_item, expand_all=True)
|
|
case ResponseCodeInterpreterToolCall() as raw_item:
|
|
tool_name = "code_interpreter"
|
|
body = Pretty(raw_item, expand_all=True)
|
|
case ImageGenerationCall() as raw_item:
|
|
tool_name = "image_generation"
|
|
body = Pretty(raw_item, expand_all=True)
|
|
case LocalShellCall() as raw_item:
|
|
tool_name = "local_shell"
|
|
body = Pretty(raw_item, expand_all=True)
|
|
case dict() as raw_item:
|
|
tool_name = "apply_patch"
|
|
payload = cast(ApplyPatchCallPayload, raw_item)["operation"]
|
|
body = Group(
|
|
Pretty(
|
|
{
|
|
"path": payload["path"],
|
|
"type": payload["type"],
|
|
},
|
|
expand_all=True,
|
|
),
|
|
Syntax(payload["diff"], "diff", theme="ansi_dark", word_wrap=True),
|
|
)
|
|
title = f"Tool call: {tool_name}"
|
|
case ToolCallOutputItem() as item:
|
|
body = Text(item.output) if isinstance(item.output, str) else Pretty(item.output)
|
|
title = "Tool output"
|
|
case MessageOutputItem() as item:
|
|
output = ItemHelpers.text_message_output(item)
|
|
body = Text(output) if isinstance(output, str) else Pretty(output, expand_all=True)
|
|
title = "Message output"
|
|
case ToolSearchCallItem() as item:
|
|
body = Pretty(item.raw_item, expand_all=True)
|
|
title = "Tool search call"
|
|
case ToolSearchOutputItem() as item:
|
|
body = Pretty(item.raw_item, expand_all=True)
|
|
title = "Tool search output"
|
|
case HandoffCallItem() as item:
|
|
body = Pretty(item.raw_item, expand_all=True)
|
|
title = "Handoff call"
|
|
case HandoffOutputItem() as item:
|
|
body = Pretty(item.raw_item, expand_all=True)
|
|
title = "Handoff output"
|
|
case MCPListToolsItem() as item:
|
|
body = Pretty(item.raw_item, expand_all=True)
|
|
title = "MCP list tools"
|
|
case MCPApprovalRequestItem() as item:
|
|
body = Pretty(item.raw_item, expand_all=True)
|
|
title = "MCP approval request"
|
|
case MCPApprovalResponseItem() as item:
|
|
body = Pretty(item.raw_item, expand_all=True)
|
|
title = "MCP approval response"
|
|
case CompactionItem() as item:
|
|
body = Pretty(item.raw_item, expand_all=True)
|
|
title = "Compaction"
|
|
case ToolApprovalItem() as item:
|
|
body = Pretty(item.raw_item, expand_all=True)
|
|
title = "Tool approval"
|
|
|
|
console.print(
|
|
Panel(
|
|
body,
|
|
title=title,
|
|
border_style="cyan",
|
|
box=box.ROUNDED,
|
|
expand=False,
|
|
)
|
|
)
|