OpenCode

Обновление образов

Готовые образы агентов обновляются каждое утро и содержат актуальную версию CLI. Чтобы использовать фиксированную версию образа, закрепите версию шаблона.

OpenCode — AI-агент с поддержкой разных моделей и провайдеров. Он работает с файлами и выполняет команды внутри песочницы AgentBox. Готовый шаблон opencode уже содержит CLI агента. Приложение передаёт задание, данные и ключ выбранного провайдера.

Подключение

Установите SDK AgentBox и задайте AGENTBOX_API_KEY. В этом примере модель вызывается через OpenRouter: ключ берётся из OPENROUTER_API_KEY и передаётся в песочницу. Выбранная модель — openrouter/qwen/qwen3-coder-next. Для другого провайдера измените модель и его настройку авторизации вместе.

Для доступа к модели можно использовать HTTPS-прокси AgentBox https://sandbox-proxy.agentbox.ru:65181.

Переменные HTTPS_PROXY, HTTP_PROXY и NO_PROXY передаются только команде агента и наследуются её дочерними процессами. Это общие настройки сети процесса: другие запросы агента тоже могут идти через прокси. NO_PROXY оставляет соединения с localhost и 127.0.0.1 прямыми.

Разберите очередь поддержки

Входные данные — три обращения в tickets.csv и правила приоритизации в policy.md. Двойное списание получает высокий приоритет и направляется в биллинг. Задержки доставки — обычный приоритет и запрос в логистику. Агент не должен обещать возврат денег или точную дату доставки без подтверждения.

mjs

import { Sandbox } from "@abox-dev/sdk";

const apiKey = process.env.OPENROUTER_API_KEY;
if (!apiKey) throw new Error("OPENROUTER_API_KEY is required");
const proxy =
  process.env.SANDBOX_PROXY_URL ?? "https://sandbox-proxy.agentbox.ru:65181";

const sandbox = await Sandbox.create("opencode", {
  timeoutMs: 600_000,
  envs: {
    OPENROUTER_API_KEY: apiKey,
    OPENCODE_CONFIG_CONTENT: '{"autoupdate":false,"permission":"allow"}',
  },
});
try {
  await sandbox.files.makeDir("/home/user/work");
  await sandbox.files.write(
    "/home/user/work/tickets.csv",
    "id,topic,message\n101,delivery,Order arrived two days late\n102,payment,Card charged twice for one order\n103,delivery,Tracking has not changed for three days\n",
  );
  await sandbox.files.write(
    "/home/user/work/policy.md",
    "Payment duplicates: high priority, route to billing. Delivery delays: normal priority, ask logistics. Never promise a refund or a delivery date without confirmation.\n",
  );
  await sandbox.commands.run(
    "opencode run --auto --model openrouter/qwen/qwen3-coder-next 'Read tickets.csv. Write triage.md with one row per ticket: id, priority, reason, and a draft reply. Apply policy.md.'",
    {
      envs: {
        HTTPS_PROXY: proxy,
        HTTP_PROXY: proxy,
        NO_PROXY: "localhost,127.0.0.1",
      },
      cwd: "/home/user/work",
      timeoutMs: 300_000,
      onStderr: (chunk) => process.stderr.write(chunk),
    },
  );
  console.log(
    "triage.md\n" + (await sandbox.files.read("/home/user/work/triage.md")),
  );
} finally {
  await sandbox.kill();
}

import os
import sys
from agentbox import Sandbox

api_key = os.environ["OPENROUTER_API_KEY"]
proxy = os.environ.get("SANDBOX_PROXY_URL", "https://sandbox-proxy.agentbox.ru:65181")
sandbox = Sandbox.create(
    "opencode",
    timeout=600,
    envs={
        "OPENROUTER_API_KEY": api_key,
        "OPENCODE_CONFIG_CONTENT": '{"autoupdate":false,"permission":"allow"}',
    },
)
try:
    sandbox.files.make_dir("/home/user/work")
    sandbox.files.write(
        "/home/user/work/tickets.csv",
        "id,topic,message\n101,delivery,Order arrived two days late\n102,payment,Card charged twice for one order\n103,delivery,Tracking has not changed for three days\n",
    )
    sandbox.files.write(
        "/home/user/work/policy.md",
        "Payment duplicates: high priority, route to billing. Delivery delays: normal priority, ask logistics. Never promise a refund or a delivery date without confirmation.\n",
    )
    sandbox.commands.run(
        "opencode run --auto --model openrouter/qwen/qwen3-coder-next 'Read tickets.csv. Write triage.md with one row per ticket: id, priority, reason, and a draft reply. Apply policy.md.'",
        envs={
            "HTTPS_PROXY": proxy,
            "HTTP_PROXY": proxy,
            "NO_PROXY": "localhost,127.0.0.1",
        },
        cwd="/home/user/work",
        timeout=300,
        on_stderr=lambda chunk: print(chunk, end="", file=sys.stderr),
    )
    print("triage.md\n" + sandbox.files.read("/home/user/work/triage.md"))
finally:
    sandbox.kill()

package main

import (
	"context"
	"errors"
	"fmt"
	"log"
	"os"
	"time"

	"github.com/abox-dev/sdk/packages/go-sdk"
)

func run() (err error) {
	apiKey := os.Getenv("OPENROUTER_API_KEY")
	proxy := os.Getenv("SANDBOX_PROXY_URL")
	if apiKey == "" {
		return fmt.Errorf("OPENROUTER_API_KEY is required")
	}
	if proxy == "" {
		proxy = "https://sandbox-proxy.agentbox.ru:65181"
	}
	ctx, cancel := context.WithTimeout(context.Background(), 8*time.Minute)
	defer cancel()
	client, err := agentbox.NewClient()
	if err != nil {
		return err
	}
	sandbox, err := client.Sandboxes.Create(ctx, &agentbox.CreateSandboxOptions{
		Template: "opencode", Timeout: 10 * time.Minute,
		Env: map[string]string{"OPENROUTER_API_KEY": apiKey,
			"OPENCODE_CONFIG_CONTENT": "{\"autoupdate\":false,\"permission\":\"allow\"}"},
	})
	if err != nil {
		return err
	}
	defer func() {
		cleanupCtx, stop := context.WithTimeout(context.Background(), 30*time.Second)
		defer stop()
		_, cleanupErr := sandbox.Kill(cleanupCtx)
		err = errors.Join(err, cleanupErr)
	}()
	if _, err := sandbox.Files.MakeDir(ctx, "/home/user/work"); err != nil {
		return err
	}
	if _, err := sandbox.Files.WriteText(ctx, "/home/user/work/tickets.csv", "id,topic,message\n101,delivery,Order arrived two days late\n102,payment,Card charged twice for one order\n103,delivery,Tracking has not changed for three days\n", nil); err != nil {
		return err
	}
	if _, err := sandbox.Files.WriteText(ctx, "/home/user/work/policy.md", "Payment duplicates: high priority, route to billing. Delivery delays: normal priority, ask logistics. Never promise a refund or a delivery date without confirmation.\n", nil); err != nil {
		return err
	}
	commandCtx, stopCommand := context.WithTimeout(ctx, 5*time.Minute)
	defer stopCommand()
	if _, err := sandbox.Commands.Run(commandCtx, "sh", &agentbox.CommandOptions{
		Args: []string{"-lc", "opencode run --auto --model openrouter/qwen/qwen3-coder-next 'Read tickets.csv. Write triage.md with one row per ticket: id, priority, reason, and a draft reply. Apply policy.md.'"}, Cwd: "/home/user/work",
		Env:      map[string]string{"HTTPS_PROXY": proxy, "HTTP_PROXY": proxy, "NO_PROXY": "localhost,127.0.0.1"},
		OnStderr: func(chunk []byte) { fmt.Fprint(os.Stderr, string(chunk)) },
	}); err != nil {
		return err
	}
	report, err := sandbox.Files.ReadText(ctx, "/home/user/work/triage.md", "")
	if err != nil {
		return err
	}
	fmt.Println("triage.md\n" + report)
	return nil
}

func main() {
	if err := run(); err != nil {
		log.Fatal(err)
	}
}

opencode run выполняет задание без терминального интерфейса. permission: "allow" в OPENCODE_CONFIG_CONTENT разрешает все инструменты, а --auto включает автоматическое подтверждение запросов. Изоляцию обеспечивает AgentBox. Агент может читать и менять файлы песочницы. Здесь он сохраняет triage.md. Приложение читает файл до завершения песочницы.

OPENCODE_CONFIG_CONTENT отключает автоматическое обновление CLI во время запуска. Для воспроизводимой версии агента также закрепите версию шаблона.

Вывод и продолжение работы

Пример разбирает обращения и показывает события по ходу работы. Затем приложение передаёт уточнение из биллинга: двойное списание по обращению 102 подтверждено, создана заявка BILL-204. Агент продолжает ту же сессию и обновляет ответ в triage.md, сохраняя остальные обращения.

mjs

import { Sandbox } from "@abox-dev/sdk";

const apiKey = process.env.OPENROUTER_API_KEY;
if (!apiKey) throw new Error("OPENROUTER_API_KEY is required");
const proxy =
  process.env.SANDBOX_PROXY_URL ?? "https://sandbox-proxy.agentbox.ru:65181";

const sandbox = await Sandbox.create("opencode", {
  timeoutMs: 600_000,
  envs: {
    OPENROUTER_API_KEY: apiKey,
    OPENCODE_CONFIG_CONTENT: '{"autoupdate":false,"permission":"allow"}',
  },
});
try {
  await sandbox.files.makeDir("/home/user/work");
  await sandbox.files.write(
    "/home/user/work/tickets.csv",
    "id,topic,message\n101,delivery,Order arrived two days late\n102,payment,Card charged twice for one order\n103,delivery,Tracking has not changed for three days\n",
  );
  await sandbox.files.write(
    "/home/user/work/policy.md",
    "Payment duplicates: high priority, route to billing. Delivery delays: normal priority, ask logistics. Never promise a refund or a delivery date without confirmation.\n",
  );
  async function execute(prompt, sessionId) {
    let pending = "";
    let result;
    let failure;
    let nextSessionId;
    function event(message) {
      if (message.sessionID) nextSessionId = message.sessionID;
      if (message.type === "text") console.log(message.part.text);
      if (message.type === "tool_use")
        console.log("Tool:", message.part.tool, message.part.state.status);
      if (message.type === "step_finish") result = message.part;
      if (message.type === "error")
        failure = new Error(
          message.error?.data?.message ?? JSON.stringify(message.error),
        );
    }
    function onStdout(chunk) {
      pending += chunk;
      let newline;
      while ((newline = pending.indexOf("\n")) !== -1) {
        const line = pending.slice(0, newline);
        pending = pending.slice(newline + 1);
        if (line.trim()) event(JSON.parse(line));
      }
    }
    const handle = await sandbox.commands.run(
      "opencode run --auto --model openrouter/qwen/qwen3-coder-next --format json" +
        (sessionId ? ' --session "$AGENT_SESSION_ID"' : ""),
      {
        cwd: "/home/user/work",
        timeoutMs: 300_000,
        background: true,
        stdin: true,
        envs: {
          OPENROUTER_API_KEY: apiKey,
          HTTPS_PROXY: proxy,
          HTTP_PROXY: proxy,
          NO_PROXY: "localhost,127.0.0.1",
          AGENT_SESSION_ID: sessionId ?? "",
        },
        onStdout,
        onStderr: (chunk) => process.stderr.write(chunk),
      },
    );
    await handle.sendStdin(prompt);
    await handle.closeStdin();
    await handle.wait();
    if (pending.trim()) event(JSON.parse(pending));
    if (failure) throw failure;
    if (result?.reason !== "stop")
      throw new Error("OpenCode did not finish normally: " + result?.reason);
    if (!nextSessionId) throw new Error("OpenCode did not return a session ID");
    console.log("\nSession:", nextSessionId);
    return nextSessionId;
  }
  const sessionId = await execute(
    "Read tickets.csv. Write triage.md with one row per ticket: id, priority, reason, and a draft reply. Apply policy.md.",
  );
  await execute(
    "Billing confirmed a duplicate charge for ticket 102 and opened case BILL-204. Update its draft reply in triage.md with this case number. Keep the other tickets and do not promise a refund date.",
    sessionId,
  );
  console.log(
    "triage.md\n" + (await sandbox.files.read("/home/user/work/triage.md")),
  );
} finally {
  await sandbox.kill();
}

import json
import os
import sys
from agentbox import Sandbox

api_key = os.environ["OPENROUTER_API_KEY"]
proxy = os.environ.get("SANDBOX_PROXY_URL", "https://sandbox-proxy.agentbox.ru:65181")
sandbox = Sandbox.create(
    "opencode",
    timeout=600,
    envs={
        "OPENROUTER_API_KEY": api_key,
        "OPENCODE_CONFIG_CONTENT": '{"autoupdate":false,"permission":"allow"}',
    },
)
try:
    sandbox.files.make_dir("/home/user/work")
    sandbox.files.write(
        "/home/user/work/tickets.csv",
        "id,topic,message\n101,delivery,Order arrived two days late\n102,payment,Card charged twice for one order\n103,delivery,Tracking has not changed for three days\n",
    )
    sandbox.files.write(
        "/home/user/work/policy.md",
        "Payment duplicates: high priority, route to billing. Delivery delays: normal priority, ask logistics. Never promise a refund or a delivery date without confirmation.\n",
    )

    def execute(prompt, session_id=None):
        pending = ""
        result = None
        failure = None
        next_session_id = None

        def event(message):
            nonlocal result, failure, next_session_id
            if message.get("sessionID"):
                next_session_id = message["sessionID"]
            if message["type"] == "text":
                print(message["part"]["text"], flush=True)
            elif message["type"] == "tool_use":
                print(
                    "Tool:",
                    message["part"]["tool"],
                    message["part"]["state"]["status"],
                    flush=True,
                )
            elif message["type"] == "step_finish":
                result = message["part"]
            elif message["type"] == "error":
                failure = RuntimeError(json.dumps(message["error"]))

        def on_stdout(chunk):
            nonlocal pending
            pending += chunk
            while "\n" in pending:
                line, pending = pending.split("\n", 1)
                if line.strip():
                    event(json.loads(line))

        handle = sandbox.commands.run(
            "opencode run --auto --model openrouter/qwen/qwen3-coder-next --format json"
            + (' --session "$AGENT_SESSION_ID"' if session_id else ""),
            cwd="/home/user/work",
            timeout=300,
            background=True,
            stdin=True,
            envs={
                "OPENROUTER_API_KEY": api_key,
                "HTTPS_PROXY": proxy,
                "HTTP_PROXY": proxy,
                "NO_PROXY": "localhost,127.0.0.1",
                "AGENT_SESSION_ID": session_id or "",
            },
        )
        handle.send_stdin(prompt)
        handle.close_stdin()
        handle.wait(
            on_stdout=on_stdout,
            on_stderr=lambda chunk: print(chunk, end="", file=sys.stderr),
        )
        if pending.strip():
            event(json.loads(pending))
        if failure:
            raise failure
        if result is None or result.get("reason") != "stop":
            raise RuntimeError(f"OpenCode did not finish normally: {result}")
        if not next_session_id:
            raise RuntimeError("OpenCode did not return a session ID")
        print("\nSession:", next_session_id)
        return next_session_id

    session_id = execute(
        "Read tickets.csv. Write triage.md with one row per ticket: id, priority, reason, and a draft reply. Apply policy.md."
    )
    execute(
        "Billing confirmed a duplicate charge for ticket 102 and opened case BILL-204. Update its draft reply in triage.md with this case number. Keep the other tickets and do not promise a refund date.",
        session_id,
    )
    print("triage.md\n" + sandbox.files.read("/home/user/work/triage.md"))
finally:
    sandbox.kill()

package main

import (
	"context"
	"encoding/json"
	"errors"
	"fmt"
	"log"
	"os"
	"strings"
	"time"

	"github.com/abox-dev/sdk/packages/go-sdk"
)

func run() (err error) {
	apiKey := os.Getenv("OPENROUTER_API_KEY")
	proxy := os.Getenv("SANDBOX_PROXY_URL")
	if apiKey == "" {
		return fmt.Errorf("OPENROUTER_API_KEY is required")
	}
	if proxy == "" {
		proxy = "https://sandbox-proxy.agentbox.ru:65181"
	}
	ctx, cancel := context.WithTimeout(context.Background(), 8*time.Minute)
	defer cancel()
	client, err := agentbox.NewClient()
	if err != nil {
		return err
	}
	sandbox, err := client.Sandboxes.Create(ctx, &agentbox.CreateSandboxOptions{
		Template: "opencode", Timeout: 10 * time.Minute,
		Env: map[string]string{"OPENROUTER_API_KEY": apiKey,
			"OPENCODE_CONFIG_CONTENT": "{\"autoupdate\":false,\"permission\":\"allow\"}"},
	})
	if err != nil {
		return err
	}
	defer func() {
		cleanupCtx, stop := context.WithTimeout(context.Background(), 30*time.Second)
		defer stop()
		_, cleanupErr := sandbox.Kill(cleanupCtx)
		err = errors.Join(err, cleanupErr)
	}()
	if _, err := sandbox.Files.MakeDir(ctx, "/home/user/work"); err != nil {
		return err
	}
	if _, err := sandbox.Files.WriteText(ctx, "/home/user/work/tickets.csv", "id,topic,message\n101,delivery,Order arrived two days late\n102,payment,Card charged twice for one order\n103,delivery,Tracking has not changed for three days\n", nil); err != nil {
		return err
	}
	if _, err := sandbox.Files.WriteText(ctx, "/home/user/work/policy.md", "Payment duplicates: high priority, route to billing. Delivery delays: normal priority, ask logistics. Never promise a refund or a delivery date without confirmation.\n", nil); err != nil {
		return err
	}
	execute := func(prompt, sessionID string) (string, error) {
		var pending, nextSessionID string
		var streamErr error
		var finishReason string
		event := func(line string) {
			if strings.TrimSpace(line) == "" || streamErr != nil {
				return
			}
			var message struct {
				Type      string `json:"type"`
				SessionID string `json:"sessionID"`
				Part      struct {
					Text   string `json:"text"`
					Tool   string `json:"tool"`
					Reason string `json:"reason"`
					State  struct {
						Status string `json:"status"`
					} `json:"state"`
				} `json:"part"`
				Error json.RawMessage `json:"error"`
			}
			if err := json.Unmarshal([]byte(line), &message); err != nil {
				streamErr = err
				return
			}
			if message.SessionID != "" {
				nextSessionID = message.SessionID
			}
			switch message.Type {
			case "text":
				fmt.Println(message.Part.Text)
			case "tool_use":
				fmt.Println("Tool:", message.Part.Tool, message.Part.State.Status)
			case "step_finish":
				finishReason = message.Part.Reason
			case "error":
				streamErr = fmt.Errorf("OpenCode: %s", message.Error)
			}
		}
		commandCtx, stopCommand := context.WithTimeout(ctx, 5*time.Minute)
		defer stopCommand()
		args := []string{"run", "--auto", "--model", "openrouter/qwen/qwen3-coder-next", "--format", "json"}
		if sessionID != "" {
			args = append(args, "--session", sessionID)
		}
		handle, err := sandbox.Commands.Start(commandCtx, "opencode", &agentbox.CommandOptions{
			Args: args, Cwd: "/home/user/work", Stdin: true,
			Env: map[string]string{"OPENROUTER_API_KEY": apiKey, "HTTPS_PROXY": proxy, "HTTP_PROXY": proxy, "NO_PROXY": "localhost,127.0.0.1"},
			OnStdout: func(chunk []byte) {
				pending += string(chunk)
				for {
					line, rest, found := strings.Cut(pending, "\n")
					if !found {
						break
					}
					pending = rest
					event(line)
				}
			},
			OnStderr: func(chunk []byte) { fmt.Fprint(os.Stderr, string(chunk)) },
		})
		if err != nil {
			return "", err
		}
		if _, err := handle.Write(commandCtx, []byte(prompt)); err != nil {
			return "", err
		}
		if err := handle.CloseStdin(commandCtx); err != nil {
			return "", err
		}
		if _, err := handle.Wait(commandCtx); err != nil {
			return "", err
		}
		event(pending)
		if streamErr != nil {
			return "", streamErr
		}
		if finishReason != "stop" {
			return "", fmt.Errorf("OpenCode did not finish normally: %s", finishReason)
		}
		if nextSessionID == "" {
			return "", errors.New("OpenCode did not return a session ID")
		}
		fmt.Println("\nSession:", nextSessionID)
		return nextSessionID, nil
	}
	sessionID, err := execute("Read tickets.csv. Write triage.md with one row per ticket: id, priority, reason, and a draft reply. Apply policy.md.", "")
	if err != nil {
		return err
	}
	if _, err := execute("Billing confirmed a duplicate charge for ticket 102 and opened case BILL-204. Update its draft reply in triage.md with this case number. Keep the other tickets and do not promise a refund date.", sessionID); err != nil {
		return err
	}
	report, err := sandbox.Files.ReadText(ctx, "/home/user/work/triage.md", "")
	if err != nil {
		return err
	}
	fmt.Println("triage.md\n" + report)
	return nil
}

func main() {
	if err := run(); err != nil {
		log.Fatal(err)
	}
}

--format json выводит по одному событию на строку. text содержит готовый текстовый блок в part.text, а tool_use сообщает о завершении инструмента и его статусе. Этот режим CLI не выводит текст по отдельным токенам.

Обработчик сохраняет sessionID из событий и передаёт его в --session для второго запроса. Он также обрабатывает error и проверяет причину последнего step_finish: stop означает, что модель закончила ответ. Промежуточные шаги могут завершаться вызовом инструментов. Файл читается после успешного завершения команды, затем песочница удаляется вместе с локальной историей.

Другие параметры — в справочнике OpenCode.

Ошибки и завершение

При ошибке ключа, модели или сетевого доступа не показывайте пустой результат как готовую работу. Обработайте ошибку команды и сохраните диагностику без ключей. Отсутствие triage.md также означает, что ожидаемый результат не получен.

Время команды ограничено пятью минутами, жизнь песочницы — десятью. После чтения файла finally завершает песочницу и освобождает ресурсы.

OpenCode ​

Подключение ​

Разберите очередь поддержки ​

Вывод и продолжение работы ​

Ошибки и завершение ​

OpenCode

Подключение

Разберите очередь поддержки

Вывод и продолжение работы

Ошибки и завершение