template_overwrite:
  GUIDE_DOC: "Guide_Doc"

# default basic settings for UCAgent
lang: "zh"

# init commands to run at the start of the agent
init_cmds: []

# Idle timeout for VerifyPDB bash commands, in seconds. The timer resets when
# stdout/stderr output arrives. Set to 0 or "off" to disable.
cmd_timeout: 300

# backend
backend:
  key_name: "langchain"  # options: langchain, claude, opencode, copilot, etc.
  langchain:
    clss: ucagent.abackend.langchain.UCAgentLangChainBackend
  claude:
    clss: ucagent.abackend.UCAgentCmdLineBackend
    args:
      cli_cmd_new: "claude {UC_ENV_CMD_BACKEND_EX_ARGS} {UC_ENV_CMD_BACKEND_EX_ARGS_N} --dangerously-skip-permissions -p < {MSG_FILE}"
      cli_cmd_ctx: "claude {UC_ENV_CMD_BACKEND_EX_ARGS} {UC_ENV_CMD_BACKEND_EX_ARGS_C} --dangerously-skip-permissions -c -p < {MSG_FILE}"
      render_files:
        "{ASSETS}/mcp_claude.json": "{CWD}/.mcp.json"
      cfg_bash_enable: false

  opencode:
    clss: ucagent.abackend.UCAgentCmdLineBackend
    args:
      cli_cmd_new: "opencode run {UC_ENV_CMD_BACKEND_EX_ARGS} {UC_ENV_CMD_BACKEND_EX_ARGS_N} < {MSG_FILE}"
      cli_cmd_ctx: "opencode run {UC_ENV_CMD_BACKEND_EX_ARGS} {UC_ENV_CMD_BACKEND_EX_ARGS_C} -c < {MSG_FILE}"
      render_files:
        "{ASSETS}/mcp_opencode.json": "{CWD}/opencode.json"
      cfg_bash_enable: false

  copilot:
    clss: ucagent.abackend.UCAgentCmdLineBackend
    args:
      cli_cmd_new: "copilot {UC_ENV_CMD_BACKEND_EX_ARGS} {UC_ENV_CMD_BACKEND_EX_ARGS_N} --allow-all-tools < {MSG_FILE}"
      cli_cmd_ctx: "copilot {UC_ENV_CMD_BACKEND_EX_ARGS} {UC_ENV_CMD_BACKEND_EX_ARGS_C} --allow-all-tools --continue < {MSG_FILE}"
      pre_bash_cmd:
        - "mkdir -p {CWD}/.copilot/"
      render_files:
        "{ASSETS}/mcp_copilot.json": "{CWD}/.copilot/mcp-config.json"
      cfg_bash_enable: false

  qwen:
    clss: ucagent.abackend.UCAgentCmdLineBackend
    args:
      cli_cmd_new: "qwen {UC_ENV_CMD_BACKEND_EX_ARGS} {UC_ENV_CMD_BACKEND_EX_ARGS_N} -y -p < {MSG_FILE}"
      cli_cmd_ctx: "qwen {UC_ENV_CMD_BACKEND_EX_ARGS} {UC_ENV_CMD_BACKEND_EX_ARGS_C} -y -c -p < {MSG_FILE}"
      pre_bash_cmd:
        - "mkdir -p {CWD}/.qwen/"
      render_files:
        "{ASSETS}/mcp_qwen.json": "{CWD}/.qwen/settings.json"
      cfg_bash_enable: false

  iflow:
    clss: ucagent.abackend.UCAgentCmdLineBackend
    args:
      cli_cmd_new: "iflow {UC_ENV_CMD_BACKEND_EX_ARGS} {UC_ENV_CMD_BACKEND_EX_ARGS_N} -y < {MSG_FILE}"
      cli_cmd_ctx: "iflow {UC_ENV_CMD_BACKEND_EX_ARGS} {UC_ENV_CMD_BACKEND_EX_ARGS_C} -y < {MSG_FILE}"
      pre_bash_cmd:
        - "mkdir -p {CWD}/.iflow/"
      render_files:
        "{ASSETS}/mcp_iflow.json": "{CWD}/.iflow/settings.json"
      cfg_bash_enable: false

  kilo:
    clss: ucagent.abackend.UCAgentCmdLineBackend
    args:
      cli_cmd_new: "kilo run {UC_ENV_CMD_BACKEND_EX_ARGS} {UC_ENV_CMD_BACKEND_EX_ARGS_N} < {MSG_FILE}"
      cli_cmd_ctx: "kilo run {UC_ENV_CMD_BACKEND_EX_ARGS} {UC_ENV_CMD_BACKEND_EX_ARGS_C} -c < {MSG_FILE}"
      pre_bash_cmd:
        - "mkdir -p {CWD}/.kilo/"
      render_files:
        "{ASSETS}/mcp_kilo.json": "{CWD}/.kilo/kilo.jsonc"
      cfg_bash_enable: false

  codex:
    clss: ucagent.abackend.UCAgentCmdLineBackend
    args:
      cli_cmd_new: "codex exec {UC_ENV_CMD_BACKEND_EX_ARGS} {UC_ENV_CMD_BACKEND_EX_ARGS_N} --yolo < {MSG_FILE}"
      cli_cmd_ctx: "codex exec {UC_ENV_CMD_BACKEND_EX_ARGS} {UC_ENV_CMD_BACKEND_EX_ARGS_C} resume --last --yolo < {MSG_FILE}"
      pre_bash_cmd:
        - "mkdir -p {CWD}/.codex/"
      render_files:
        "{ASSETS}/mcp_codex.toml": "{CWD}/.codex/config.toml"
      cfg_bash_cmd:
        - "mkdir -p ~/.codex"
        - "cp {CWD}/.codex/config.toml ~/.codex/config.toml"
      cfg_bash_enable: false

mcp_server:
  host: 127.0.0.1
  port: 5000

cmd_api:
  host: 127.0.0.1
  port: 8765

master_api:
  host: 0.0.0.0
  port: 8800
  sync_workspace:
    on_stage_complete: true  # client uploads workspace back to master after each completed stage when supported
    on_exit: true            # client uploads zipped workspace back to master on exit when supported
    ignore_patterns:         # file patterns to ignore when syncing/downloading workspace archives (glob patterns, relative to workspace root)
      - "*.pyc"
      - "*.pyd"
      - "*.dat"
      - "*.vdb"
      - "*.fst"
      - "*.fdb"
      - "*.vcd"
      - "__pycache__"
      - ".pytest_cache"
      - "{OUT}/tests/data/"
      - "uc_test_report/"
      - ".gitignore"
      - ".git/"

launch:
  file_browser_roots: []              # empty means fallback to <cli.py parent>/examples
  default_args:
    launch_mode: ["process"]          # full support: ["process", "docker", "docker_swarm", "k8s"]
    output: "unity_test"              # output directory name
    stream_output: true               # -s flag
    human: true                       # -hm flag
    tui: true                         # --tui flag
    backend: "langchain"              # --backend flag, options: langchain, claude, opencode, copilot, qwen, iflow, kilo, codex
    mcp_server_no_file_tools: false
    force_stage_index: 0              # stage index to start
    exit_on_completion: true          # --exit-on-completion flag
    web_console: "0.0.0.0:-1"         # --web-console flag
    loop: true                        # -l flag
    use_skill: false
    extra_skill_path: ""
    use_zip_workspace: true           # if true, launch task with a master-hosted workspace .tar.gz URL
    picker_args: []                   # additional picker export arguments used by Compile DUT
    workspace_base:                   # default --workspace-base for launched tasks using zipped workspace
      "process": "/tmp/ucagent_workspace_base"
      "*": "{WORKSPACE}"
    extra_args: []                    # additional CLI arguments
    configs:                          # predefined config options for dropdown
      UT:
        cfg: "default.yaml"
      Formal:
        cfg: "formal.yaml"
        use_skill: true
      Vibe:
        cfg: "vibe.yaml"
        tui: false
        exit_on_completion: false
        use_skill: true
        loop: false
      Increment:
        cfg: "inc.yaml"
  cluster:
    image: "ghcr.nju.edu.cn/xs-mlvp/ucagent:latest" # container image used by docker, docker_swarm, and k8s launch modes
    container_command: "ucagent"                    # command inside the image; local python/cli prefix is replaced with this command
    master_ip:                                      # master address used by launched tasks for each launch mode
      - process: "127.0.0.1"
      - docker: "host.docker.internal"
      - docker_swarm: "ucagent_master"
      - k8s: "ucagent_master"
    docker_network: "ucagent_net"
    docker_extra_args: ["--rm"]
    swarm_extra_args: []
    k8s_namespace: "default"
    k8s_image_pull_policy: "IfNotPresent"
    k8s_service_account: ""
    k8s_node_selector: {}
    k8s_tolerations: []
    k8s_resources: {}
    extra_mounts: []                  # optional bind mounts, e.g. [{source: /host/path, target: /container/path}]
  default_env:
    - "OPENAI_MODEL"
    - "OPENAI_API_KEY"
    - "OPENAI_API_BASE"
    - "ENABLE_LLM_SUGGESTION": true
    - "NEED_REF_MODEL": false
    - "IGNORE_MOCK_COMPONENT": true
    - "ENABLE_LLM_FAIL_SUGGESTION": "$ENABLE_LLM_SUGGESTION"
    - "FAIL_SUGGESTION_MODEL": "$OPENAI_MODEL"
    - "FAIL_SUGGESTION_API_BASE": "$OPENAI_API_BASE"
    - "FAIL_SUGGESTION_API_KEY": "$OPENAI_API_KEY"
    - "ENABLE_LLM_PASS_SUGGESTION": "$ENABLE_LLM_SUGGESTION"
    - "PASS_SUGGESTION_MODEL": "$OPENAI_MODEL"
    - "PASS_SUGGESTION_API_BASE": "$OPENAI_API_BASE"
    - "PASS_SUGGESTION_API_KEY": "$OPENAI_API_KEY"
    - "CLAUDE_CODE_ENABLE_TELEMETRY": "0"
    - "CLAUDE_CODE_DISABLE_NONESSENTIAL_TRAFFIC": "1"
    - "CLAUDE_CODE_ATTRIBUTION_HEADER": "0"
    - "ANTHROPIC_BASE_URL": "$OPENAI_API_BASE"
    - "ANTHROPIC_AUTH_TOKEN": "$OPENAI_API_KEY"
    - "ANTHROPIC_BIG_MODEL": "$OPENAI_MODEL"
    - "ANTHROPIC_SML_MODEL": "$OPENAI_MODEL"
    - "ANTHROPIC_MODEL": "$ANTHROPIC_BIG_MODEL"
    - "ANTHROPIC_DEFAULT_OPUS_MODEL": "$ANTHROPIC_BIG_MODEL"
    - "ANTHROPIC_DEFAULT_SONNET_MODEL": "$ANTHROPIC_BIG_MODEL"
    - "ANTHROPIC_DEFAULT_HAIKU_MODEL": "$ANTHROPIC_SML_MODEL"
    - "CLAUDE_CODE_SUBAGENT_MODEL": "$ANTHROPIC_SML_MODEL"
    - "CLAUDE_CODE_EFFORT_LEVEL": "max"

# Model support: openai, anthropic, google_genai
model_type: $(UC_MODEL_TYPE: openai)

openai:
  model_name: "$(OPENAI_MODEL: <your_chat_model_name>)"
  openai_api_key: "$(OPENAI_API_KEY: [your_api_key])"
  openai_api_base: "$(OPENAI_API_BASE: http://<your_chat_model_url>/v1)"
  temperature: $(OPENAI_TEMPERATURE: null) # eg: 0.7
  top_p: $(OPENAI_TOP_P: null)             # eg: 0.9
  model_kwargs:
    stop: ["."]

# export ANTHROPIC_API_KEY="your-api-key"
anthropic:
  model_name: "$(ANTHROPIC_MODEL: claude-3-7-sonnet-20250219)"
  base_url: "$(ANTHROPIC_BASE_URL: http://<your_anthropic_model_url>/v1)"
  api_key: "$(ANTHROPIC_AUTH_TOKEN: [your_api_key])"

# export GOOGLE_GENAI_API_KEY="your-api-key"
google_genai:
  model_name: "$(GOOGLE_GENAI_MODEL: gemini-2.5-pro)"
  api_key: "$(GOOGLE_GENAI_API_KEY: [your_api_key])"

embed:
  model_name: "$(EMBED_MODEL: <your_embedding_model_name>)"
  openai_api_key: "$(EMBED_OPENAI_API_KEY: [your_api_key])"
  openai_api_base: "$(EMBED_OPENAI_API_BASE: http://<your_embedding_model_url>/v1)"
  dims: 4096

langfuse:
  enable: $(ENABLE_LANGFUSE, false)
  public_key: $(LANGFUSE_PUBLIC_KEY, <YOUR_LANGFUSE_PUBLIC_KEY>)
  secret_key: $(LANGFUSE_SECRET_KEY, <YOUR_LANGFUSE_SECRET_KEY>)
  base_url: $(LANGFUSE_URL, http://localhost:3000)

skill:
  use_skill: false # Enable SKILL
  extra_skill_path: "" # path for additional skills, only works when use_skill is True
  max_skill_list_count: 15  # max number of skills to list
  enable_skill_list: [] # skills can be used, if empty, all skills are enabled
  disable_skill_list: [] # skills that are not able to use, if empty, all skills are enabled
  general_skill_list: [] # skills that are general to use for all stage

# This is the setting for conversation summary
# Adjust the max_tokens and max_summary_tokens according to your needs and model capabilities
# Reference doc: https://langchain-ai.lang.chat/langmem/reference/short_term/#langmem.short_term.SummarizationNode
conversation_summary:
  context_management_strategy: TrimAndSummaryMiddleware    # default use TrimAndSummaryMiddleware strategy to manage conversation history
  max_tokens: $(SUMMARY_MAX_CTX_TOKEN: 51200)    # default 50k tokens for 128k context model
  max_summary_tokens: $(SUMMARY_MAX_SUM_TOKEN: 1024)  # suggested 10% of the model's context length
  max_keep_msgs: $(SUMMARY_MAX_KEEP_MSG: 100)    # max messages to keep in memory, older messages will be removed (not the messages to LLM)
  tail_keep_msgs: $(SUMMARY_TAIL_KEEP_MSG: 10)   # keep the last N messages to the LLM no matter what

rate_limiter:
  enabled: $(ENABLE_LLM_RATE_LIMIT: false)
  # The following settings are used when rate_limiter.enabled is true
  requests_per_second: $(LLM_MAX_RPS: 10)    # default 10 req/s
  check_every_n_seconds: 0.1 # default 0.1s, wake up every 100 ms to check whether allowed to make a request
  max_bucket_size: 1         # default 1, controls the maximum burst size

template: unity_test

un_write_dirs:
  - "{DUT}"
  - "{GUIDE_DOC}"
write_dirs:
  - "{OUT}"

guide_doc:
  path: "{GUIDE_DOC}"
  enable: true

tools:
  RunTestCases:
    test_dir: "{OUT}/tests"
  ignore_tools: ["WorkDiff", "WorkCommit", "RunBashCommand"] # List of tool names to ignore
  selected_tools: []     # List of tool names to enable, if empty, all tools are enabled except those in ignore_tools

# Tool call timeout
call_time_out: 300  # seconds

# TUI layout settings
tui:
  task_width: 84
  console_height: 13
  status_height: 7

loop_settings:
  max_loop_retry: 10       # maximum number of retries for a loop
  retry_delay_start: 5     # initial delay time in seconds before retrying
  retry_delay_end: 10      # maximum delay time in seconds before retrying
  loop_alive_time: 120     # time in seconds to consider a loop alive before resetting retry count

hooks:
  continue: >
    You have not completed all the tasks yet. Please continue. Use the `Check` and `Complete` tools to determine whether you have finished the current stage's tasks.
    Please verify the results of the `Check` and `Complete` tool calls, and adjust your work based on the feedback until all `Check` and `Complete` calls are passed.
    If a timeout error occurs, please increase the timeout parameter and retry, or use the RunTestCases tool to identify any stuck test cases and fix them.

  cagent_init: >
    Please get your role information and basic guidance through tool `RoleInfo`, and then complete the task.
    Please make sure to use the tool `ReadTextFile` to read the file, so that UCAgent can know which files you have read.

  quit: "/quit"

  exit: "/exit"


vmanager:
  llm_suggestion:
    check_fail_refinement:
      enable: $(ENABLE_LLM_FAIL_SUGGESTION: false)
      clss: ucagent.stage.llm_suggestion.OpenAILLMFailSuggestion
      args:
        model_name: $(FAIL_SUGGESTION_MODEL: <your_chat_model_name>)
        openai_api_key: $(FAIL_SUGGESTION_API_KEY: <your_api_key>)
        openai_api_base: $(FAIL_SUGGESTION_API_BASE: http://<your_chat_model_url>/v1)
        min_fail_count: $(FAIL_SUGGESTION_MFCOUNT: 3)
        temperature: $(FAIL_SUGGESTION_TEMPERATURE: null)
        top_p: $(FAIL_SUGGESTION_TOP_P: null)
      system_prompt: >
        You are a professional testing assistant. An LLM expert is testing a Device Under Test (DUT) (Current DUT is `{DUT}`) based on the high-level task requirements.
        Your job is to analyze the current task fail information, identify the reason
        why the current stage of 'Check' did not pass, and then provide him precise recommendations to pass it.
        In your recommendations:
        1. Key information from the test data must be retained, such as important details from std error.
        2. The proposed solutions should be clear and actionable.
        3. Prioritize suggestions that have the most significant impact on passing the Checker.
        4. Ensure that your suggestions are actionable and easy to understand.
        5. Avoid suggesting changes that are too complex or require significant refactoring unless absolutely necessary.
        6. Do not include any thought process or analysis in your final suggestion, only provide the actionable suggestion.
        Note:
          Your tool has a limited call quota, so make sure to use them wisely.
          The goal of the high-level task is to identify and document DUT bugs, not to make reasonable fail cases pass.
          The tasks and test information is dynamic, you should keep updating your analysis and suggestions based on the latest test information.
          You are not care about the bugs in the DUT, only focus on helping the LLM expert to pass the 'Check' tasks.
      suggestion_prompt: >
        Now, the tasks corresponding 'Check' did not pass.
        Please analyze the above test information, then provide the precise recommendations to pass it.
      bypass_stages: []
      target_stages: []
      default_apply_all_stages: true
    check_pass_refinement:
      enable: $(ENABLE_LLM_PASS_SUGGESTION: false)
      clss: ucagent.stage.llm_suggestion.OpenAILLMPassSuggestion
      args:
        model_name: $(PASS_SUGGESTION_MODEL: <your_chat_model_name>)
        openai_api_key: $(PASS_SUGGESTION_API_KEY: <your_api_key>)
        openai_api_base: $(PASS_SUGGESTION_API_BASE: http://<your_chat_model_url>/v1)
        temperature: $(PASS_SUGGESTION_TEMPERATURE: null)
        top_p: $(PASS_SUGGESTION_TOP_P: null)
      system_prompt: >
        You are a verification expert, highly skilled at identifying issues in others' verification work, with extremely high standards for the quality of verification projects.
        Another LLM verification expert is currently verifying the DUT ({DUT}). At the end of each critical stage, it requires your evaluation of the results.
        Only after you confirm that there are no issues can it proceed to subsequent stages. Therefore, your role is crucial.
        Your specific responsibilities are as follows:
        (1) Clarify the specific tasks for the current stage and define evaluation criteria based on the stage's requirements.
        (2) If issues are identified, provide clear and actionable suggestions for improvement.
        (3) Ensure the verification results align with the requirements outlined in the reference documentation.
        (4) If no issues are found, call tool `ApproveStagePass` to approve the current stage.
        (5) You must prevent the LLM verification expert from focusing solely on passing `Checker` inspections at the expense of thoroughly and properly completing the actual verification work.
        Important Notes:
        • For verification work, you place great emphasis on ensuring no functional points are missing.
        • Checkpoints must be clearly described and highly actionable.
        • Your suggestions should be concise and to the point, avoiding unnecessary length.
        • You can use tool `StageDiff` to help you analyze the differences in the work results before and after the current stage.
        • You can use tool `StageCommit` to help you commit the current stage's work results for better analysis.
      suggestion_prompt: >
        Now, the LLM verification expert has completed the tasks for the current stage.
        Please evaluate whether the tasks have been completed properly based on the above requirements.
        If you find any issues, please provide clear and actionable suggestions for improvement.
        You Must use `ApproveStagePass` to approve or not approve the current stage to be passed.
      bypass_stages: []
      target_stages: []
      default_apply_all_stages: true


# history version control settings
hist_ignore_pattern:
  - ".pytest_cache"
  - "__pycache__"
  - "*.pyc"
  - ".*"
  - "data"
  - ".git"


vibe_coding:
  short_prompts:
    continue: "Please continue until all stage-tasks are completed."
    review: |
      Please analyze the error messages in the Check/Complete response,
      resolve these errors, and avoid being distracted by other information.
    summarize: |
      Please summarize your task and your completion status.