Qwen Code

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

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

Qwen Code — агент для работы с файлами и командами с выбором провайдера модели. В AgentBox он доступен в готовом шаблоне qwen. Один и тот же SDK управляет входными файлами, процессом CLI и результатом.

Подключение

Установите SDK AgentBox и задайте AGENTBOX_API_KEY.

Примеры используют модель qwen/qwen3-coder-next через OpenRouter. Приложение читает OPENROUTER_API_KEY и передаёт его Qwen в OPENAI_API_KEY, потому что выбран OpenAI-совместимый протокол. OPENAI_BASE_URL указывает на https://openrouter.ai/api/v1, а OPENAI_MODEL задаёт модель. Флаг --auth-type openai выбирает способ подключения без интерактивного входа.

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

В примерах HTTPS_PROXY, HTTP_PROXY и NO_PROXY передаются процессу агента. Эти настройки могут влиять и на другие запросы агента и его дочерних процессов. Соединения с localhost и 127.0.0.1 остаются прямыми.

Соберите список неоплаченных счетов

Пример загружает выгрузку счетов. Qwen записывает сводку по неоплаченным счетам в receivables.md, после чего приложение читает её через SDK.

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("qwen", { timeoutMs: 600_000 });
try {
  await sandbox.files.makeDir("/home/user/work");
  await sandbox.files.write(
    "/home/user/work/invoices.csv",
    `invoice,customer,amount,currency,status
INV-101,Acme,1200,EUR,paid
INV-102,Northwind,850,EUR,unpaid
INV-103,Contoso,420,EUR,unpaid
`,
  );
  await sandbox.files.write(
    "/home/user/work/task.txt",
    "Read invoices.csv and write receivables.md: unpaid invoices grouped by customer and the total unpaid amount.",
  );
  const result = await sandbox.commands.run(
    "qwen --auth-type openai --approval-mode yolo < task.txt",
    {
      cwd: "/home/user/work",
      timeoutMs: 300_000,
      envs: {
        HTTPS_PROXY: proxy,
        HTTP_PROXY: proxy,
        NO_PROXY: "localhost,127.0.0.1",
        OPENAI_API_KEY: apiKey,
        OPENAI_BASE_URL: "https://openrouter.ai/api/v1",
        OPENAI_MODEL: "qwen/qwen3-coder-next",
      },
      onStderr: (chunk) => process.stderr.write(chunk),
    },
  );
  console.log(result.stdout);
  console.log(
    "receivables.md\n" +
      (await sandbox.files.read("/home/user/work/receivables.md")),
  );
} finally {
  await sandbox.kill();
}

import os
import sys
from agentbox import Sandbox

api_key = os.environ["OPENROUTER_API_KEY"]
proxy = os.getenv("SANDBOX_PROXY_URL", "https://sandbox-proxy.agentbox.ru:65181")
sandbox = Sandbox.create("qwen", timeout=600)
try:
    sandbox.files.make_dir("/home/user/work")
    sandbox.files.write(
        "/home/user/work/invoices.csv",
        """invoice,customer,amount,currency,status
INV-101,Acme,1200,EUR,paid
INV-102,Northwind,850,EUR,unpaid
INV-103,Contoso,420,EUR,unpaid
""",
    )
    sandbox.files.write(
        "/home/user/work/task.txt",
        "Read invoices.csv and write receivables.md: unpaid invoices grouped by customer and the total unpaid amount.",
    )
    result = sandbox.commands.run(
        "qwen --auth-type openai --approval-mode yolo < task.txt",
        cwd="/home/user/work",
        timeout=300,
        envs={
            "HTTPS_PROXY": proxy,
            "HTTP_PROXY": proxy,
            "NO_PROXY": "localhost,127.0.0.1",
            "OPENAI_API_KEY": api_key,
            "OPENAI_BASE_URL": "https://openrouter.ai/api/v1",
            "OPENAI_MODEL": "qwen/qwen3-coder-next",
        },
        on_stderr=lambda chunk: print(chunk, end="", file=sys.stderr),
    )
    print(result.stdout)
    print("receivables.md\n" + sandbox.files.read("/home/user/work/receivables.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")
	if apiKey == "" {
		return errors.New("OPENROUTER_API_KEY is required")
	}
	proxy := os.Getenv("SANDBOX_PROXY_URL")
	if proxy == "" {
		proxy = "https://sandbox-proxy.agentbox.ru:65181"
	}
	ctx, cancel := context.WithTimeout(context.Background(), 5*time.Minute)
	defer cancel()
	client, err := agentbox.NewClient()
	if err != nil {
		return err
	}
	sandbox, err := client.Sandboxes.Create(ctx, &agentbox.CreateSandboxOptions{Template: "qwen", Timeout: 10 * time.Minute})
	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/invoices.csv", `invoice,customer,amount,currency,status
INV-101,Acme,1200,EUR,paid
INV-102,Northwind,850,EUR,unpaid
INV-103,Contoso,420,EUR,unpaid
`, nil); err != nil {
		return err
	}
	if _, err := sandbox.Files.WriteText(ctx, "/home/user/work/task.txt", "Read invoices.csv and write receivables.md: unpaid invoices grouped by customer and the total unpaid amount.", nil); err != nil {
		return err
	}
	result, err := sandbox.Commands.Run(ctx, "sh", &agentbox.CommandOptions{
		Args: []string{"-lc", "qwen --auth-type openai --approval-mode yolo < task.txt"},
		Cwd:  "/home/user/work",
		Env: map[string]string{
			"HTTPS_PROXY":     proxy,
			"HTTP_PROXY":      proxy,
			"NO_PROXY":        "localhost,127.0.0.1",
			"OPENAI_API_KEY":  apiKey,
			"OPENAI_BASE_URL": "https://openrouter.ai/api/v1",
			"OPENAI_MODEL":    "qwen/qwen3-coder-next",
		},
		OnStderr: func(chunk []byte) { fmt.Fprint(os.Stderr, string(chunk)) },
	})
	if err != nil {
		return err
	}
	fmt.Println(string(result.Stdout))
	report, err := sandbox.Files.ReadText(ctx, "/home/user/work/receivables.md", "")
	if err != nil {
		return err
	}
	fmt.Println("receivables.md\n" + report)
	return nil
}

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

Задание хранится в task.txt и передаётся CLI через stdin. Режим --approval-mode yolo разрешает все штатные инструменты без запросов подтверждения. Файлы и команды остаются внутри песочницы AgentBox.

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

События и следующий запрос

Пример запускает Qwen с --output-format stream-json --include-partial-messages, показывает фрагменты ответа и вызовы инструментов. Затем передаёт сообщение об оплате и продолжает сессию через --resume.

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("qwen", { timeoutMs: 600_000 });
try {
  await sandbox.files.makeDir("/home/user/work");
  await sandbox.files.write(
    "/home/user/work/invoices.csv",
    `invoice,customer,amount,currency,status
INV-101,Acme,1200,EUR,paid
INV-102,Northwind,850,EUR,unpaid
INV-103,Contoso,420,EUR,unpaid
`,
  );
  async function execute(prompt, sessionId) {
    await sandbox.files.write("/home/user/work/task.txt", prompt);
    let pending = "",
      nextSessionId,
      terminal,
      failure;
    function event(message) {
      if (message.session_id) nextSessionId = message.session_id;
      if (
        message.type === "stream_event" &&
        message.event?.delta?.type === "text_delta"
      )
        process.stdout.write(message.event.delta.text);
      if (message.type === "assistant")
        for (const block of message.message.content) {
          if (block.type === "tool_use") console.log("Tool:", block.name);
        }
      if (message.type === "result") {
        terminal = message.subtype;
        if (message.is_error)
          failure = new Error(message.result ?? JSON.stringify(message));
      }
    }
    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));
      }
    }
    await sandbox.commands.run(
      "qwen --auth-type openai --approval-mode yolo --output-format stream-json --include-partial-messages" +
        (sessionId ? ' --resume "$AGENT_SESSION_ID"' : "") +
        " < task.txt",
      {
        cwd: "/home/user/work",
        timeoutMs: 300_000,
        envs: {
          HTTPS_PROXY: proxy,
          HTTP_PROXY: proxy,
          NO_PROXY: "localhost,127.0.0.1",
          OPENAI_API_KEY: apiKey,
          OPENAI_BASE_URL: "https://openrouter.ai/api/v1",
          OPENAI_MODEL: "qwen/qwen3-coder-next",
          AGENT_SESSION_ID: sessionId ?? "",
        },
        onStdout,
        onStderr: (chunk) => process.stderr.write(chunk),
      },
    );
    if (pending.trim()) event(JSON.parse(pending));
    if (failure) throw failure;
    if (terminal !== "success")
      throw new Error("Agent did not finish normally: " + terminal);
    if (!nextSessionId) throw new Error("Agent did not return a session ID");
    console.log("\nSession:", nextSessionId);
    return nextSessionId;
  }
  const sessionId = await execute(
    "Read invoices.csv and write receivables.md: unpaid invoices grouped by customer and the total unpaid amount.",
  );
  await execute(
    "Invoice INV-102 has now been paid. Update receivables.md to reflect this payment.",
    sessionId,
  );
  console.log(
    "receivables.md\n" +
      (await sandbox.files.read("/home/user/work/receivables.md")),
  );
} finally {
  await sandbox.kill();
}

import json
import os
import sys
from agentbox import Sandbox

api_key = os.environ["OPENROUTER_API_KEY"]
proxy = os.getenv("SANDBOX_PROXY_URL", "https://sandbox-proxy.agentbox.ru:65181")
sandbox = Sandbox.create("qwen", timeout=600)
try:
    sandbox.files.make_dir("/home/user/work")
    sandbox.files.write(
        "/home/user/work/invoices.csv",
        """invoice,customer,amount,currency,status
INV-101,Acme,1200,EUR,paid
INV-102,Northwind,850,EUR,unpaid
INV-103,Contoso,420,EUR,unpaid
""",
    )

    def execute(prompt, session_id=None):
        sandbox.files.write("/home/user/work/task.txt", prompt)
        pending = ""
        next_session_id = None
        terminal = None
        failure = None

        def event(message):
            nonlocal next_session_id, terminal, failure
            if message.get("session_id"):
                next_session_id = message["session_id"]
            if message.get("type") == "stream_event":
                delta = message.get("event", {}).get("delta", {})
                if delta.get("type") == "text_delta":
                    print(delta["text"], end="", flush=True)
            if message.get("type") == "assistant":
                for block in message["message"]["content"]:
                    if block.get("type") == "tool_use":
                        print("Tool:", block["name"])
            if message.get("type") == "result":
                terminal = message.get("subtype")
                if message.get("is_error"):
                    failure = message.get("result") or str(message)

        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))

        sandbox.commands.run(
            "qwen --auth-type openai --approval-mode yolo --output-format stream-json --include-partial-messages"
            + (' --resume "$AGENT_SESSION_ID"' if session_id else "")
            + " < task.txt",
            cwd="/home/user/work",
            timeout=300,
            envs={
                "HTTPS_PROXY": proxy,
                "HTTP_PROXY": proxy,
                "NO_PROXY": "localhost,127.0.0.1",
                "OPENAI_API_KEY": api_key,
                "OPENAI_BASE_URL": "https://openrouter.ai/api/v1",
                "OPENAI_MODEL": "qwen/qwen3-coder-next",
                "AGENT_SESSION_ID": session_id or "",
            },
            on_stdout=on_stdout,
            on_stderr=lambda chunk: print(chunk, end="", file=sys.stderr),
        )
        if pending.strip():
            event(json.loads(pending))
        if failure:
            raise RuntimeError(failure)
        if terminal != "success":
            raise RuntimeError(f"Agent did not finish normally: {terminal}")
        if not next_session_id:
            raise RuntimeError("Agent did not return a session ID")
        print("\nSession:", next_session_id)
        return next_session_id

    session_id = execute(
        "Read invoices.csv and write receivables.md: unpaid invoices grouped by customer and the total unpaid amount."
    )
    execute(
        "Invoice INV-102 has now been paid. Update receivables.md to reflect this payment.",
        session_id,
    )
    print("receivables.md\n" + sandbox.files.read("/home/user/work/receivables.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")
	if apiKey == "" {
		return errors.New("OPENROUTER_API_KEY is required")
	}
	proxy := os.Getenv("SANDBOX_PROXY_URL")
	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: "qwen", Timeout: 10 * time.Minute})
	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/invoices.csv", `invoice,customer,amount,currency,status
INV-101,Acme,1200,EUR,paid
INV-102,Northwind,850,EUR,unpaid
INV-103,Contoso,420,EUR,unpaid
`, nil); err != nil {
		return err
	}
	execute := func(prompt, sessionID string) (string, error) {
		if _, err := sandbox.Files.WriteText(ctx, "/home/user/work/task.txt", prompt, nil); err != nil {
			return "", err
		}
		var pending, nextSessionID string
		var streamErr error
		var terminal string
		event := func(line string) {
			if strings.TrimSpace(line) == "" || streamErr != nil {
				return
			}
			var message struct {
				Type      string `json:"type"`
				Subtype   string `json:"subtype"`
				SessionID string `json:"session_id"`
				IsError   bool   `json:"is_error"`
				Result    string `json:"result"`
				Event     struct {
					Delta struct {
						Type string `json:"type"`
						Text string `json:"text"`
					} `json:"delta"`
				} `json:"event"`
				Message struct {
					Content []struct {
						Type string `json:"type"`
						Name string `json:"name"`
					} `json:"content"`
				} `json:"message"`
			}
			if err := json.Unmarshal([]byte(line), &message); err != nil {
				streamErr = err
				return
			}
			if message.SessionID != "" {
				nextSessionID = message.SessionID
			}
			switch message.Type {
			case "stream_event":
				if message.Event.Delta.Type == "text_delta" {
					fmt.Print(message.Event.Delta.Text)
				}
			case "assistant":
				for _, block := range message.Message.Content {
					if block.Type == "tool_use" {
						fmt.Println("Tool:", block.Name)
					}
				}
			case "result":
				terminal = message.Subtype
				if message.IsError {
					streamErr = fmt.Errorf("Qwen Code failed: %s", message.Result)
				}
			}
		}
		command := "qwen --auth-type openai --approval-mode yolo --output-format stream-json --include-partial-messages"
		if sessionID != "" {
			command += " --resume \"$AGENT_SESSION_ID\""
		}
		command += " < task.txt"
		commandCtx, stop := context.WithTimeout(ctx, 5*time.Minute)
		defer stop()
		_, err := sandbox.Commands.Run(commandCtx, "sh", &agentbox.CommandOptions{
			Args: []string{"-lc", command},
			Cwd:  "/home/user/work",
			Env: map[string]string{
				"HTTPS_PROXY":      proxy,
				"HTTP_PROXY":       proxy,
				"NO_PROXY":         "localhost,127.0.0.1",
				"OPENAI_API_KEY":   apiKey,
				"OPENAI_BASE_URL":  "https://openrouter.ai/api/v1",
				"OPENAI_MODEL":     "qwen/qwen3-coder-next",
				"AGENT_SESSION_ID": sessionID,
			},
			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
		}
		event(pending)
		if streamErr != nil {
			return "", streamErr
		}
		if terminal != "success" {
			return "", fmt.Errorf("agent did not finish normally: %s", terminal)
		}
		if nextSessionID == "" {
			return "", errors.New("agent did not return a session ID")
		}
		fmt.Println("\nSession:", nextSessionID)
		return nextSessionID, nil
	}
	sessionID, err := execute("Read invoices.csv and write receivables.md: unpaid invoices grouped by customer and the total unpaid amount.", "")
	if err != nil {
		return err
	}
	if _, err := execute("Invoice INV-102 has now been paid. Update receivables.md to reflect this payment.", sessionID); err != nil {
		return err
	}
	report, err := sandbox.Files.ReadText(ctx, "/home/user/work/receivables.md", "")
	if err != nil {
		return err
	}
	fmt.Println("receivables.md\n" + report)
	return nil
}

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

Событие system с subtype: init сообщает session_id. Части ответа приходят в stream_event → event.delta с типом text_delta. Сообщения assistant содержат вызовы инструментов в блоках tool_use. Завершение подтверждает result с subtype: success и is_error: false. Обработчик собирает строки JSON из частей stdout, поскольку один вызов callback не обязательно содержит целое событие.

История сессии и файлы находятся в песочнице. Для следующего вызова сохраните её вместе с ID сессии или поставьте на паузу. Полный протокол и параметры CLI описаны в документации Qwen Code.

Qwen Code ​

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

Соберите список неоплаченных счетов ​

События и следующий запрос ​

Qwen Code

Подключение

Соберите список неоплаченных счетов

События и следующий запрос