agents llm machine-learning ai-agent architecture typescript

《实用笔记》：构建私有云编码代理——OpenCode与本地大语言模型

《实用笔记》操作指南：构建私有云编码代理——OpenCode与本地大语言模型：适用于采用该模式的团队的合同、检查项及可直接插入的代码模块。

发布者：REACTAPP.TOP加入本站 2026年9月27日阅读约 24 分钟5502 词

来源: Building a Private Cloud Coding Agent: OpenCode + a Local LLM, Running on Serverless GPUs

以下笔记为“构建私有云编程代理：OpenCode + 本地大语言模型，运行在无服务器GPU上”提供了实用的实施路径。重点在于契约、校验机制以及可直接插入的代码占位符，而非激励性描述。在完成概览阶段时，首先明确契约内容：所需输入、成功信号以及部分失败时的处理方式。这样的检查清单能确保后续的代码修改保持一致性。优先选择小型、可测试的单元，而非庞大的脚本。当某个步骤失败时，故障应能指向单一责任模块，而非复杂的流程链。

为何选择这种架构

为何将这种架构视为可度量的界面时效果最佳？在扩大范围之前，先记录一个成功的案例、一个失败案例以及回滚说明。将此阶段视为输入与已验证输出之间的契约，为相关成果命名、明确成功标准，绝不允许出现悄无声息的半完成状态。需为每轮及每次会话设定token预算，因为智能工具会大量消耗上下文资源，设置上限可避免演示过程突然产生额外费用。

构建模块

将这些构成要素视为可测量的界面时，其效果最佳。在扩大范围之前，先记录一个成功的案例、一个失败案例以及回滚说明。在功能结果旁同时记录处理时间以及令牌或查询成本。提前了解成本情况，就能避免在从演示环境过渡到共享环境时出现意外账单。为每轮及每次会话设定令牌预算。智能工具会大量消耗上下文资源，设置上限可防止演示过程变成意外收费的源头。

模态

将 Modal 视为可度量的对象时，其效果最佳。在扩大应用范围之前，先记录一份理想的操作日志、一个故障案例以及回滚说明。应将配置置于应用程序代码之外。环境文件、密钥存储和功能开关应集中存放，以便操作人员无需查看整个系统结构即可进行审计。为每轮对话和每次会话设定token预算。智能工具往往会过度扩展上下文，设置上限可避免演示过程变成意外的费用账单。将 Modal 视为可度量的对象时，其效果最佳。在扩大应用范围之前，先记录一份理想的操作日志、一个故障案例以及回滚说明。相比庞大的脚本，应优先使用小型且可测试的单元。当某个步骤出现故障时，故障原因应能明确指向单一责任模块，而非复杂的流程链。

Ollama

对于 Ollama 阶段，在修改代码之前需明确输入内容、该步骤的负责人以及终止条件。操作员应能够从已知的检查点重新运行该步骤，而无需猜测隐藏状态。应将此阶段视为输入与经过验证的输出之间的契约。为相关成果命名，定义成功判定标准，并拒绝默许的半完成状态。将客户端构建与消息循环分开，这样即便更换提供者也不必重写对话状态机。

OpenCode

在OpenCode阶段，应在修改代码之前明确输入参数、该步骤的负责人以及结束标准。操作人员应能够从已知的检查点重新运行该步骤，而无需猜测隐藏状态。应在功能结果旁记录执行时间以及令牌或查询成本。提前了解成本情况，可避免在从演示环境过渡到共享环境时出现意外费用。当下一步操作是编写代码或调用工具时，优先选择具有架构验证的结构化输出，而非自由形式的文字描述。

隧道

在“隧道阶段”，在修改代码之前需明确输入参数、该步骤的负责人以及终止条件。操作人员应能够从已知的检查点重新运行该步骤，而无需猜测隐藏状态。配置信息应置于应用程序代码之外。环境文件、密钥存储以及功能标志应集中存放于一个位置，以便操作人员无需查看整个流程即可进行审计。当下一步是代码执行或工具调用时，应优先使用具有结构化格式且经过模式验证的输出，而非自由形式的文本。在“隧道阶段”，在修改代码之前需明确输入参数、该步骤的负责人以及终止条件。操作人员应能够从已知的检查点重新运行该步骤，而无需猜测隐藏状态。相比庞大的脚本，应优先选择小型且可测试的单元。当某个步骤失败时，故障原因应能明确指向某个特定功能，而非整个复杂的流程。

前提条件与设置

在完成前置条件准备和设置阶段时，首先写下相关契约：所需的输入参数、成功信号以及部分失败时的处理方式。这样的检查清单能确保后续的代码修改保持一致性。将这一阶段视为输入与验证后输出之间的契约。为相关产物命名，明确成功判定标准，杜绝无声的半完成状态。缓存稳定的系统指令和工具架构。重复发送相同的开头信息是导致资源浪费的常见原因。

pip install modal
modal setup

设计容器镜像

在“设计容器镜像”阶段工作时，首先列出相关规范：所需的输入参数、成功信号以及部分失败时的处理方式。这样的检查清单能确保后续的代码修改保持一致性。在功能结果旁记录执行时间以及令牌或查询成本。提前了解成本情况，可避免在从演示环境过渡到共享环境时出现意外费用。缓存稳定的系统指令和工具架构。重复发送相同的开头信息是造成资源浪费的常见原因。

import modal

image = (
    modal.Image.from_registry(
        "nvidia/cuda:13.0.0-devel-ubuntu24.04",
        add_python="3.12",
    )
    .apt_install(
        "curl",
        "git",
        "ca-certificates",
        "zstd",
    )
    .run_commands(
        "curl -fsSL https://ollama.com/install.sh | sh",
    )
    .run_commands(
        "curl -fsSL https://opencode.ai/install | bash",
    )
    .env(
        {
            "OLLAMA_MODELS": "/models/.ollama/models",
            "OLLAMA_HOST": "127.0.0.1:11434",
            "PATH": "/root/.opencode/bin:/usr/local/bin:/usr/bin:/bin",
        }
    )
)

启动脚本：协调 Ollama 与 OpenCode

在处理启动脚本的协调阶段时，首先需明确相关规范：所需的输入参数、成功信号以及部分失败时的处理方式。这样的清单能确保后续的代码修改保持一致性。应将配置信息与应用程序代码分开存放。环境文件、密钥存储以及功能开关应集中于一个位置，以便操作人员无需查看整个系统结构即可进行审计。每次调用时都要记录请求ID、模型ID以及响应延迟时间。如果没有这些记录，偶尔出现的服务错误就会被视为应用程序的故障。在处理启动脚本的协调阶段时，首先需明确相关规范：所需的输入参数、成功信号以及部分失败时的处理方式。这样的清单能确保后续的代码修改保持一致性。相比庞大的脚本，更应优先使用小型且可测试的单元。当某个步骤出现故障时，故障原因应能明确指向某个具体的功能模块，而非整个复杂的流程。

步骤1 — 在后台启动Ollama，确认进程没有立即终止

将“步骤1：启动Ollama”视为可度量的环节最为有效。在扩大范围之前，需记录一个成功的案例、一个失败的案例以及回滚说明。将该阶段视为输入与经过验证的输出之间的契约。为相关成果命名，明确成功标准，杜绝无声的半完成状态。在设置循环之前先锁定解释器及依赖项。在笔记本电脑与持续集成环境之间的差异是API演示中最常见的无声故障原因。

ollama serve > /tmp/ollama.log 2>&1 &
OLLAMA_PID=$!

sleep 3
if ! kill -0 "$OLLAMA_PID" 2>/dev/null; then
    echo "OLLAMA FAILED TO START"
    cat /tmp/ollama.log
    exit 1
fi

步骤2 — 持续轮询，直到API真正开始提供服务而非仅处于运行状态

将第二阶段的投票机制视为可测量的指标时，其效果最佳。在扩大范围之前，需记录一个成功的案例、一个失败案例以及回滚说明。在功能结果旁还需记录执行时间以及令牌或查询成本。提前了解成本情况，可避免在从演示环境过渡到共享环境时出现意外账单。为每轮及每次会话设定令牌预算，因为智能工具会大量消耗上下文资源，设置上限能防止演示过程产生意外费用。

READY=0

for i in $(seq 1 120); do
    if curl -sf http://127.0.0.1:11434/api/tags > /dev/null 2>&1; then
        READY=1
        echo "Ollama is ready."
        break
    fi
    sleep 1
done

if [ "$READY" != "1" ]; then
    echo "Ollama failed to start."
    cat /tmp/ollama.log
    exit 1
fi

第三步——仅在没有模型时才拉取模型

将“第三步：拉取阶段”视为可度量的对象来处理时效果最佳。在扩大范围之前，先记录一份理想的操作日志、一个故障案例以及回滚说明。应将配置与应用程序代码分开。环境文件、密钥存储和功能开关应集中存放于一个位置，以便操作人员无需查看整个系统结构即可进行审计。为每轮次和每次会话设定预算令牌限制。智能工具往往会过度扩展上下文，设置上限可避免演示过程突然产生额外费用。

if ollama list | grep -F "qwen3-coder" > /dev/null 2>&1; then
    echo "Model already exists:"
    ollama list
else
    echo "Downloading: qwen3-coder:30b"
    ollama pull "qwen3-coder:30b"
fi

将“第三步：拉取阶段”视为可度量的对象来处理时效果最佳。在扩大范围之前，先记录一份理想的操作日志、一个故障案例以及回滚说明。相比庞大的脚本，应优先使用小型且可测试的单元。当某一步骤出现故障时，故障原因应能明确指向某个特定模块，而非整个复杂的流程。

第四步——克隆包含真实故障路径的仓库

在第四步“克隆阶段”中，应在修改代码之前明确输入参数、该步骤的负责人以及结束标准。操作人员应能够从已知的检查点重新运行该步骤，而无需猜测隐藏状态。将此阶段视为输入与经过验证的输出之间的契约。为相关成果命名，定义成功判定标准，并拒绝默许的半完成状态。当下一步是代码编写或工具调用时，优先采用具有架构验证的结构化输出，而非自由形式的文字描述。

if [ ! -d /workspace/.git ]; then
    if GIT_TERMINAL_PROMPT=0 git clone \
        --branch "main" \
        --depth 1 \
        "https://github.com/yourname/yourrepo.git" \
        /workspace
    then
        echo "Clone succeeded."
    else
        echo "WARNING: git clone failed. Continuing without the repo."
        mkdir -p /workspace
    fi
else
    echo "Repository already exists."
fi

第五步 — 编写OpenCode的配置

在第五步“编写OpenCode”阶段，应在修改代码之前明确输入参数、该步骤的负责人以及结束标准。操作人员应能够从已知的检查点重新运行该步骤，而无需猜测隐藏状态。除了功能结果外，还需记录执行时间以及令牌或查询成本。提前了解这些成本可以避免在从演示环境切换到共享环境时出现意外费用。当下一步操作是编写代码或调用工具时，建议使用具有架构验证的结构化输出，而非自由形式的文字描述。

mkdir -p /root/.config/opencode
cat > /root/.config/opencode/opencode.json <<'EOF'
{
    "$schema": "https://opencode.ai/config.json",
    "model": "ollama/qwen3-coder:30b",
    "provider": {
        "ollama": {
            "npm": "@ai-sdk/openai-compatible",
            "name": "Ollama - Qwen3 Coder 30B",
            "options": {
                "baseURL": "http://127.0.0.1:11434/v1"
            },
            "models": {
                "qwen3-coder:30b": {
                    "name": "Qwen3-Coder 30B",
                    "limit": {
                        "context": 32768,
                        "output": 16384
                    }
                }
            }
        }
    }
}
EOF

第六步 — 在前台启动OpenCode

在第六步的Start OpenCode阶段，应在修改代码之前明确输入参数、该步骤的负责人以及结束标准。操作人员应能够从已知的检查点重新运行该步骤，而无需猜测隐藏状态。配置信息应置于应用程序代码之外。环境文件、密钥存储以及功能标志应集中存放于一个位置，以便操作人员无需查看整个系统结构即可进行审核。当下一步操作为代码编写或工具调用时，应优先使用具有架构验证的结构化输出，而非自由形式的文本描述。

exec opencode serve \
    --hostname 0.0.0.0 \
    --port 4096 \
    --print-logs

在第六步的Start OpenCode阶段，应在修改代码之前明确输入参数、该步骤的负责人以及结束标准。操作人员应能够从已知的检查点重新运行该步骤，而无需猜测隐藏状态。相比冗长的脚本，更应采用小型且可测试的单元。当某一步骤失败时，故障原因应能明确指向某个具体责任方，而非整个复杂的流程。

模型权重的持久化

在处理“持久化模型权重”阶段时，首先需明确相关约定：所需输入、成功信号以及部分失败时的处理方式。这样的检查清单能确保后续的代码修改始终符合要求。将此阶段视为输入与验证后输出之间的契约。为相关产物命名，定义成功判定标准，杜绝无声的半完成状态。缓存稳定的系统指令和工具架构。重复发送相同的前置信息是造成资源浪费的常见原因。

volume = modal.Volume.from_name(
    "opencode-ollama-models",
    create_if_missing=True,
)

volumes={
    "/models": volume,
},

创建沙箱

在“创建沙箱”阶段工作时，首先写下合约的详细内容：所需的输入参数、成功信号以及部分失败时的处理方式。这样的清单能确保后续的代码修改保持一致性。在功能结果旁记录执行时间以及代币或查询成本。提前了解成本情况，可避免在从演示环境过渡到共享环境时出现意外费用。缓存稳定的系统指令和工具架构。重复发送相同的开头信息是导致资源浪费的常见原因。

def create_sandbox():
    script = startup_script()
    secrets = []
    if GITHUB_REPO_IS_PRIVATE:
        secrets.append(modal.Secret.from_name(GITHUB_SECRET_NAME))
    sandbox = modal.Sandbox.create(
        "bash", "-lc", script,
        app=app,
        image=image,
        gpu="H100",
        cpu=8,
        memory=32768,
        secrets=secrets,
        timeout=12 * 60 * 60,
        idle_timeout=300,
        volumes={"/models": volume},
        encrypted_ports=[OPENCODE_PORT],
        workdir="/workspace",
    )
    return sandbox

处理私有仓库

在处理“管理私有仓库”阶段时，首先需明确相关规范：所需的输入参数、成功信号以及部分失败时的处理方式。这样的清单能确保后续的代码修改保持一致性。应将配置信息与应用程序代码分开存放。环境文件、密钥存储以及功能开关应集中管理，以便操作人员无需查看整个系统结构即可进行审计。需缓存系统中稳定的指令和工具架构。重复发送相同的开头信息是导致资源浪费的常见原因。在处理“管理私有仓库”阶段时，首先需明确相关规范：所需的输入参数、成功信号以及部分失败时的处理方式。这样的清单能确保后续的代码修改保持一致性。相比庞大的脚本，应优先使用小型且可测试的单元。当某个步骤出现故障时，故障原因应能明确指向某个具体的功能模块，而非整个复杂的流程。

modal secret create github-token GITHUB_TOKEN=ghp_your_token_here

if GITHUB_REPO_IS_PRIVATE:
    secrets.append(modal.Secret.from_name("github-token"))

clone_url = f"https://${{GITHUB_TOKEN}}@github.com/{GITHUB_REPO}.git"

本地入口点：维持沙箱运行

将负责维持运行的本地入口点视为可度量的环节，这样效果最佳。在扩大范围之前，先记录一份理想的运行日志、一个故障案例以及回滚说明。应将此环节视为输入与经过验证的输出之间的契约。为相关成果命名，明确成功标准，杜绝默许部分完成的情况。需为每轮及每次会话设定令牌预算。智能工具往往会过度扩展上下文；设置上限可避免演示过程变成意外的费用账单。

try:
    while True:
        time.sleep(5)
        returncode = sandbox.poll()
        if returncode is not None:
            print(f"Sandbox process exited with code {returncode}.")
            break
except KeyboardInterrupt:
    print("Ctrl+C received. Terminating sandbox...")
    sandbox.terminate()

modal run --detach opencode.py

modal shell sb-abc123xyz

完整实现方案

当将其视为可测量的界面时，完整实现才能发挥最佳效果。在扩大范围之前，先记录一个成功的案例、一个失败案例以及回滚说明。在功能结果旁同时记录执行时间以及令牌或查询成本。提前了解成本情况，可避免在从演示环境过渡到共享环境时出现意外账单。为每轮及每次会话设定令牌预算。智能工具往往会大量消耗上下文资源，设置上限能防止演示过程变成意外收费的源头。

import time

import modal


# ============================================================
# Configuration
# ============================================================

APP_NAME = "opencode-ollama"

MODEL = "qwen3-coder:30b"

OPENCODE_PORT = 4096
OLLAMA_PORT = 11434

VOLUME_NAME = "opencode-ollama-models"

# Set this to the repo you want cloned into the sandbox.
# Leave as None or "" to skip cloning entirely.
GITHUB_REPO = "yourusername/your-repository"
GITHUB_BRANCH = "main"

# If GITHUB_REPO is private, create a Modal Secret containing
# a GitHub Personal Access Token (fine-grained, read-only, scoped
# to this one repo) with:
#   modal secret create github-token GITHUB_TOKEN=ghp_xxx
# and set this to True.
GITHUB_REPO_IS_PRIVATE = False
GITHUB_SECRET_NAME = "github-token"


# ============================================================
# Modal app + persistent volume
# ============================================================

app = modal.App(APP_NAME)

volume = modal.Volume.from_name(
    VOLUME_NAME,
    create_if_missing=True,
)


# ============================================================
# Container image
# ============================================================

image = (
    modal.Image.from_registry(
        "nvidia/cuda:13.0.0-devel-ubuntu24.04",
        add_python="3.12",
    )
    .apt_install(
        "curl",
        "git",
        "ca-certificates",
        "zstd",
    )
    .run_commands(
        "curl -fsSL https://ollama.com/install.sh | sh",
    )
    .run_commands(
        "curl -fsSL https://opencode.ai/install | bash",
    )
    .env(
        {
            "OLLAMA_MODELS": "/models/.ollama/models",
            "OLLAMA_HOST": "127.0.0.1:11434",
            "PATH": "/root/.opencode/bin:/usr/local/bin:/usr/bin:/bin",
        }
    )
)


# ============================================================
# Sandbox startup script
# ============================================================

def startup_script():

    repo_setup = ""

    if GITHUB_REPO:

        if GITHUB_REPO_IS_PRIVATE:
            clone_url = (
                f"https://${{GITHUB_TOKEN}}@github.com/{GITHUB_REPO}.git"
            )
        else:
            clone_url = f"https://github.com/{GITHUB_REPO}.git"

        repo_setup = f"""
echo "=============================================="
echo "Cloning repository"
echo "=============================================="
nvidia-smi || true

if [ ! -d /workspace/.git ]; then

    if GIT_TERMINAL_PROMPT=0 git clone \\
        --branch "{GITHUB_BRANCH}" \\
        --depth 1 \\
        "{clone_url}" \\
        /workspace
    then
        echo "Clone succeeded."
    else
        echo ""
        echo "=============================================="
        echo "WARNING: git clone failed."
        echo "=============================================="
        echo "This is usually because the repository is"
        echo "private (set GITHUB_REPO_IS_PRIVATE = True and"
        echo "attach a token) or the repo/branch name is"
        echo "wrong. Continuing without the repo so OpenCode"
        echo "still starts."
        echo ""
        mkdir -p /workspace
    fi

else

    echo "Repository already exists."

fi
"""

    else:

        repo_setup = """
echo "=============================================="
echo "No GitHub repository configured"
echo "=============================================="

mkdir -p /workspace
"""

    return f"""
#!/bin/bash

set -e

echo "=============================================="
echo "Modal OpenCode + Ollama"
echo "=============================================="

echo "Model: {MODEL}"
echo "OpenCode port: {OPENCODE_PORT}"
echo "Ollama port: {OLLAMA_PORT}"

# ------------------------------------------------------------
# Ollama model directory
# ------------------------------------------------------------

mkdir -p /models/.ollama/models

export OLLAMA_MODELS=/models/.ollama/models
export OLLAMA_HOST=127.0.0.1:11434

# ------------------------------------------------------------
# Start Ollama
# ------------------------------------------------------------

echo ""
echo "Starting Ollama..."

ollama serve \\
    > /tmp/ollama.log \\
    2>&1 &

OLLAMA_PID=$!

sleep 3

if ! kill -0 "$OLLAMA_PID" 2>/dev/null; then
    echo ""
    echo "=============================================="
    echo "OLLAMA FAILED TO START"
    echo "=============================================="
    echo ""
    cat /tmp/ollama.log
    echo ""
    exit 1
fi

echo "Ollama PID: $OLLAMA_PID"

# ------------------------------------------------------------
# Wait for Ollama to be ready
# ------------------------------------------------------------

echo ""
echo "Waiting for Ollama..."

READY=0

for i in $(seq 1 120); do

    if curl -sf \\
        http://127.0.0.1:11434/api/tags \\
        > /dev/null 2>&1
    then

        READY=1
        echo "Ollama is ready."
        break

    fi

    sleep 1

done

if [ "$READY" != "1" ]; then

    echo ""
    echo "Ollama failed to start."
    echo ""
    cat /tmp/ollama.log

    exit 1

fi

# ------------------------------------------------------------
# Pull the model (skipped if already present in the volume)
# ------------------------------------------------------------

echo ""
echo "=============================================="
echo "Checking Ollama model"
echo "=============================================="

if ollama list | grep -F \\
    "qwen3-coder" \\
    > /dev/null 2>&1
then

    echo "Model already exists:"
    ollama list

else

    echo ""
    echo "Model not found."
    echo ""
    echo "Downloading:"
    echo "  {MODEL}"
    echo ""
    echo "This can take some time on first startup."
    echo ""

    ollama pull "{MODEL}"

fi

echo ""
echo "=============================================="
echo "Available Ollama models"
echo "=============================================="

ollama list

# ------------------------------------------------------------
# Repository
# ------------------------------------------------------------

{repo_setup}

cd /workspace

# ------------------------------------------------------------
# OpenCode configuration
# ------------------------------------------------------------

mkdir -p /root/.config/opencode

cat > /root/.config/opencode/opencode.json <<'EOF'
{{
    "$schema": "https://opencode.ai/config.json",

    "model": "ollama/{MODEL}",

    "provider": {{
        "ollama": {{
            "npm": "@ai-sdk/openai-compatible",

            "name": "Ollama - Qwen3 Coder 30B",

            "options": {{
                "baseURL": "http://127.0.0.1:11434/v1"
            }},

            "models": {{
                "{MODEL}": {{
                    "name": "Qwen3-Coder 30B",

                    "limit": {{
                        "context": 32768,
                        "output": 16384
                    }}
                }}
            }}
        }}
    }}
}}
EOF

echo ""
echo "=============================================="
echo "OpenCode configuration"
echo "=============================================="

cat /root/.config/opencode/opencode.json

# ------------------------------------------------------------
# Start OpenCode
# ------------------------------------------------------------

echo ""
echo "=============================================="
echo "Starting OpenCode server"
echo "=============================================="

exec opencode serve \\
    --hostname 0.0.0.0 \\
    --port {OPENCODE_PORT} \\
    --print-logs
"""


# ============================================================
# Create Sandbox
# ============================================================

def create_sandbox():

    script = startup_script()

    secrets = []

    if GITHUB_REPO_IS_PRIVATE:
        secrets.append(modal.Secret.from_name(GITHUB_SECRET_NAME))

    sandbox = modal.Sandbox.create(
        "bash",
        "-lc",
        script,

        app=app,

        image=image,

        gpu="H100",

        cpu=8,

        memory=32768,

        secrets=secrets,

        timeout=12 * 60 * 60,

        idle_timeout=300,

        volumes={
            "/models": volume,
        },

        encrypted_ports=[
            OPENCODE_PORT,
        ],

        workdir="/workspace",
    )

    return sandbox


# ============================================================
# Local entrypoint
# ============================================================

@app.local_entrypoint()
def main():

    print()
    print("==============================================")
    print("Creating Modal Sandbox")
    print("==============================================")
    print()

    sandbox = create_sandbox()

    print()
    print("Sandbox created:")
    print(sandbox.object_id)

    print()
    print("Waiting for OpenCode server...")
    print()

    time.sleep(5)

    tunnel_url = None

    try:

        tunnels = sandbox.tunnels()
        tunnel = tunnels[OPENCODE_PORT]
        tunnel_url = tunnel.url

        print()
        print("==============================================")
        print("OPEN CODE IS READY")
        print("==============================================")
        print()
        print("Sandbox ID (save this to reconnect):")
        print(sandbox.object_id)
        print()
        print("Browser:")
        print()
        print(tunnel_url)
        print()
        print("Your OpenCode server is backed by:")
        print()
        print("  Ollama")
        print("  Qwen3-Coder 30B")
        print()
        print("Ollama endpoint (inside the sandbox only):")
        print("http://127.0.0.1:11434")
        print()
        print("==============================================")
        print()

    except Exception as e:

        print()
        print("Sandbox started, but tunnel information")
        print("could not be retrieved automatically.")
        print()
        print(f"Error: {e}")
        print()
        print("The Sandbox ID is:")
        print(sandbox.object_id)

    print("Sandbox is running. Press Ctrl+C to stop it.")
    print("(Run with `modal run --detach opencode.py` to keep")
    print(" it alive after you disconnect.)")
    print()

    try:
        while True:
            time.sleep(5)

            returncode = sandbox.poll()

            if returncode is not None:
                print(f"Sandbox process exited with code {returncode}.")
                break

    except KeyboardInterrupt:
        print()
        print("Ctrl+C received. Terminating sandbox...")
        sandbox.terminate()
        print("Sandbox terminated.")

运行方法

将其视为可度量的对象来运行效果最佳。在扩大范围之前，先记录一份理想的操作日志、一个故障案例以及回滚说明。将配置置于应用程序代码之外。环境文件、密钥存储和功能开关应集中存放，以便操作人员无需查看全部内容即可进行审计。为每轮及每次会话设定预算令牌限制。智能工具往往会过度扩展上下文，设置上限可避免演示过程突然产生额外费用。将其视为可度量的对象来运行效果最佳。在扩大范围之前，先记录一份理想的操作日志、一个故障案例以及回滚说明。优先选择小型且可测试的单元，而非庞大的脚本。当某一步骤出错时，故障应指向单一责任模块，而非复杂的流程链。

modal run opencode.py

==============================================
OPEN CODE IS READY
==============================================

Sandbox ID (save this to reconnect):
sb-abc123xyz

Browser:

https://your-generated-subdomain-4096.modal.host

modal run --detach opencode.py

modal shell sb-abc123xyz

sandbox = modal.Sandbox.from_id("sb-abc123xyz")
sandbox.terminate()

扩展系统

在系统扩展阶段，应在修改代码之前明确输入参数、该步骤的负责人以及结束标准。操作人员应能够从已知的检查点重新运行该步骤，而无需猜测隐藏状态。将此阶段视为输入与经过验证的输出之间的契约。为相关成果命名，定义成功判定标准，并拒绝默许的半完成状态。当下一步操作为代码编写或工具调用时，优先采用具有架构验证的结构化输出，而非自由形式的文本描述。

安全考量

在安全考量阶段，应在修改代码之前明确输入参数、该步骤的负责人以及结束标准。操作人员应能够从已知的检查点重新运行该步骤，而无需猜测隐藏状态。应在功能结果旁记录执行时间以及令牌或查询成本。提前了解成本情况，可避免在从演示环境过渡到共享环境时出现意外费用。当下一步操作为编写代码或调用工具时，宜使用经过模式验证的结构化输出，而非自由形式的文本。

结论

在“结束”阶段，修改代码之前需明确输入参数、该步骤的负责人以及终止标准。操作人员应能够从已知的检查点重新运行该步骤，而无需猜测隐藏状态。配置信息应置于应用程序代码之外。环境文件、密钥存储以及功能标志应集中存放于一个位置，以便操作人员无需查看整个流程即可进行审计。当后续步骤为代码或工具调用时，宜使用具有结构化格式且经过模式验证的输出，而非自由形式的文本。在“结束”阶段，修改代码之前需明确输入参数、该步骤的负责人以及终止标准。操作人员应能够从已知的检查点重新运行该步骤，而无需猜测隐藏状态。相比庞大的脚本，应优先使用小型且可测试的单元。当某个步骤失败时，故障原因应能明确指向某个特定功能，而非整个复杂的流程。

操作检查清单

在操作检查清单阶段，应在修改代码之前明确输入内容、该步骤的负责人以及结束标准。操作人员应能够从已知的检查点重新运行该步骤，而无需猜测隐藏状态。

需同时记录正常流程和故障恢复流程。重试机制、人工审核环节以及错误处理方式都是产品的一部分，而非后续需要补充的内容。

当下一步操作为代码编写或工具调用时，应优先使用具有结构化格式且经过模式验证的输出，而非自由形式的文字描述。

在耗时较长的步骤之后设置检查点。当操作人员重新执行后续节点时，系统不应再次计费相同的大型语言模型调用费用。

需锁定依赖项的版本，并记录用于演示的镜像摘要。可重复性远比经验知识更重要。

在功能结果旁记录执行时间以及令牌或查询成本。提前了解成本情况，可避免在系统从演示环境切换到共享环境时出现意外账单。

在推广该技术栈之前，先冻结版本，为关键路径生成标准记录，并明确回滚步骤。共享环境需要设置速率限制、租户验证机制，以及明确的密钥轮换负责人。与其追求花哨的一次性演示，不如注重扎实的可靠性。

关于0b5d2687b03c的批注：请将提供商密钥存放在仓库之外，设定每会话的令牌上限，并将记录与评估用文件一起保存，以便后续更换模型时仍能保持数据可比性。

在实施强化措施的第0阶段，应在修改代码之前明确输入参数、该步骤的负责人以及结束标准。操作人员应能够从已知的检查点重新运行该步骤，而无需猜测隐藏状态。配置信息应置于应用程序代码之外。环境文件、密钥存储以及功能标志应集中存放于一个位置，这样操作人员无需查看整个系统结构即可进行审计。

强化措施细节0/810：需统计该措施的墙钟时间、错误类型以及令牌消耗情况，然后依据固定的评估标准而非主观经验来决定是否保留该变更。

在处理强化措施的第一阶段时，首先写下相关契约：所需的输入参数、成功信号以及部分失败时的处理方式。这样的检查清单能确保后续的代码修改始终符合要求。相比冗长的脚本，更应采用小型且可测试的单元。当某个步骤失败时，故障应能指向单一的责任模块，而非复杂的流程链。

强化措施细节 1/810：需测量该步骤的运行时间、错误类型以及代币消耗情况，然后依据固定的评估标准而非主观判断来决定是否保留该修改。

将强化措施2视为可度量的对象会更有助于其实施。在扩大范围之前，先记录一份理想的运行示例、一个失败案例以及回滚方案。在功能结果旁同时记录时间消耗及代币或查询成本。提前了解成本情况，可避免在从演示环境过渡到共享环境时出现意外支出。

强化措施细节2/810：为该记录测量运行时间、错误类型以及令牌消耗情况，然后依据固定的问题集而非个别案例来决定是否保留该变更。

对于强化措施的第3阶段，在修改代码之前需明确输入参数、该步骤的负责人以及完成标准。操作人员应能够从已知的检查点重新执行该步骤，而无需猜测隐藏状态。同时需将正常流程与故障恢复流程一并记录下来。重试机制、人工审核环节以及错误处理方式都是产品本身的组成部分，而非后续需要补充的内容。

强化措施细节3/810：为该记录测量运行时间、错误类型以及令牌消耗情况，然后依据固定的问题集而非个别案例来决定是否保留该变更。

在处理强化措施的第4阶段时，首先写下相关契约：所需的输入参数、成功信号以及部分失败时的处理方式。这样的检查清单能确保后续的代码修改始终符合约定。将这一阶段视为输入与验证后输出之间的契约。为相关产物命名，明确成功判定标准，杜绝默许的部分完成情况。

强化措施细节4/810：需测量该步骤的耗时、错误类型以及令牌消耗情况，然后依据固定的评估标准而非个人经验来决定是否保留该变更。

将强化措施第5阶段视为可量化的目标面处理效果最佳。在扩大范围之前，先记录一份标准操作示例、一个失败案例以及回滚说明。配置信息应与应用程序代码分开存放。环境文件、密钥存储和功能开关应集中于一个位置，以便操作人员无需查看全部代码结构即可进行审计。

强化措施细节5/810：为该记录测量运行时间、错误类型以及令牌消耗情况，然后依据固定的问题集而非个人经验来判断是否保留该变更。

在强化措施的第6阶段，应在修改代码之前明确输入参数、该步骤的负责人以及完成标准。操作人员应能够从已知的检查点重新运行该步骤，而无需猜测隐藏状态。相比复杂的脚本，更应采用小型且可测试的单元。当某一步骤失败时，故障原因应能指向单一责任方，而非混乱的整个流程。

强化措施细节6/810：为该记录测量运行时间、错误类型以及令牌消耗情况，然后依据固定的问题集而非个人经验来判断是否保留该变更。

在处理强化措施的第7阶段时，首先写下相关约定：所需的输入参数、成功信号以及部分失败时的处理方式。这样的检查清单能确保后续的代码修改保持一致性。

在功能结果旁记录执行时间以及令牌或查询成本。提前了解成本情况，可避免在系统从演示环境过渡到共享环境时出现意外费用。

强化措施细节7/810：为该阶段测量实际执行时间、错误类型以及令牌消耗情况，然后依据固定的评估标准而非个人经验来决定是否保留相关修改。

将强化措施第8阶段视为可度量的对象来处理效果最佳。在扩大范围之前，先记录一个理想运行案例、一个失败案例以及回滚说明。

应同时记录正常流程和故障恢复流程。重试机制、人工审核环节以及错误处理方式都是产品本身的组成部分，而非后续需要补充的内容。

强化细节 8/810：测量该笔记的耗时、错误类型以及令牌消耗情况，然后依据固定的问题集而非个人经验来决定是否保留该更改。

0b5d2687b03c的重写标记1：用操作符语言重新表述相关内容，保持[[CODE_n]]占位符不变，避免重复源文本句子。

0b5d2687b03c的重写标记2：用操作符语言重新表述相关内容，保持[[CODE_n]]占位符不变，避免重复源文本句子。

0b5d2687b03c的重写标记3：用操作符语言重新表述相关内容，保持[[CODE_n]]占位符不变，避免重复源文本句子。

0b5d2687b03c的重写标记4：用操作符语言重新表述相关内容，保持[[CODE_n]]占位符不变，避免重复源文本句子。

为 0b5d2687b03c 的标记 5 进行重写：用操作符语言重新表述周围的陈述，保持 [[CODE_n]] 占位符不变，避免重复源文本句子。

为 0b5d2687b03c 的标记 6 进行重写：用操作符语言重新表述周围的陈述，保持 [[CODE_n]] 占位符不变，避免重复源文本句子。

为 0b5d2687b03c 的标记 7 进行重写：用操作符语言重新表述周围的陈述，保持 [[CODE_n]] 占位符不变，避免重复源文本句子。

为 0b5d2687b03c 的标记 8 进行重写：用操作符语言重新表述周围的陈述，保持 [[CODE_n]] 占位符不变，避免重复源文本句子。

为 0b5d2687b03c 的标记 9 进行重写：用操作符语言重新表述周围的陈述，保持 [[CODE_n]] 占位符不变，避免重复源文本句子。

将标记10的数值改为0b5d2687b03c：用操作符语言重写相关描述，保持[[CODE_n]]占位符不变，且避免重复原文句子。

← 全部文章发送简报