Qwen Code

Image updates

Ready-made agent images are updated every morning with the current CLI version. To keep a fixed image version, pin a template version.

Qwen Code is an agent with file and command tools and a choice of model provider. AgentBox provides it in the ready-made qwen template. The same SDK manages input files, the CLI process, and its output.

Connect

Install the AgentBox SDK and set AGENTBOX_API_KEY.

The examples use qwen/qwen3-coder-next through OpenRouter. The application reads OPENROUTER_API_KEY and passes it to Qwen as OPENAI_API_KEY, because the selected protocol is OpenAI-compatible. OPENAI_BASE_URL points to https://openrouter.ai/api/v1, and OPENAI_MODEL selects the model. --auth-type openai configures authentication without interactive login.

For model access, you can use the AgentBox HTTPS proxy https://sandbox-proxy.agentbox.ru:65181.

The examples pass HTTPS_PROXY, HTTP_PROXY, and NO_PROXY to the agent process. These settings may also affect other requests made by the agent and its child processes. Connections to localhost and 127.0.0.1 remain direct.

List unpaid invoices

The example uploads an invoice export. Qwen writes an unpaid-invoice summary to receivables.md, which the application reads through the 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)
	}
}

The task is stored in task.txt and passed to the CLI through stdin. --approval-mode yolo permits all standard tools without approval prompts. Files and commands stay inside the AgentBox sandbox.

The example reads the result before killing the sandbox. finally also releases it on error. The Go example uses a separate context for cleanup.

Events and the next request

The example starts Qwen with --output-format stream-json --include-partial-messages and displays response fragments and tool calls. It then reports a payment and continues the session with --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)
	}
}

The system event with subtype: init provides session_id. Response fragments arrive in stream_event → event.delta with type text_delta. assistant messages include tool invocations in tool_use blocks. A result with subtype: success and is_error: false confirms completion. The handler buffers JSON lines from stdout chunks, because a callback does not necessarily contain a complete event.

Session history and files are stored in the sandbox. For another call, keep it and the session ID, or pause it. The full protocol and CLI options are described in the Qwen Code documentation.

Qwen Code ​

Connect ​

List unpaid invoices ​

Events and the next request ​

Qwen Code

Connect

List unpaid invoices

Events and the next request