Pi

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

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

Pi — расширяемый AI-агент с выбором модели и провайдера. Его базовые инструменты читают, записывают и редактируют файлы, а также выполняют команды. Навыки и расширения добавляют другие возможности. В AgentBox используйте готовый шаблон pi.

Подключение

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

Pi поддерживает и других провайдеров. При замене провайдера согласуйте --provider, --model и переменную ключа: например, ANTHROPIC_API_KEY для Anthropic или OPENAI_API_KEY для OpenAI. Полный перечень находится в документации Pi.

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

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

Разберите итоги встречи

Пример загружает заметки и просит Pi выделить согласованные действия, ответственных и сроки в actions.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("pi", { timeoutMs: 600_000 });
try {
  await sandbox.files.makeDir("/home/user/work");
  await sandbox.files.write(
    "/home/user/work/meeting.md",
    "Meeting: 2026-09-18\nOlga will send a revised quote to Acme by 2026-09-21.\nPavel will check stock for the next delivery; no deadline was agreed.\nThe marketing budget was discussed but no decision was made.\n",
  );
  const handle = await sandbox.commands.run(
    "pi --provider openrouter --model qwen/qwen3-coder-next --no-session -p",
    {
      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",
      },
      onStderr: (chunk) => process.stderr.write(chunk),
    },
  );
  await handle.sendStdin(
    "Read meeting.md and write actions.md: agreed actions, owners, and deadlines. Mark missing deadlines as not agreed. Keep discussion without a decision separate.",
  );
  await handle.closeStdin();
  const result = await handle.wait();
  console.log(result.stdout);
  console.log(
    "actions.md\n" + (await sandbox.files.read("/home/user/work/actions.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("pi", timeout=600)
try:
    sandbox.files.make_dir("/home/user/work")
    sandbox.files.write(
        "/home/user/work/meeting.md",
        "Meeting: 2026-09-18\nOlga will send a revised quote to Acme by 2026-09-21.\nPavel will check stock for the next delivery; no deadline was agreed.\nThe marketing budget was discussed but no decision was made.\n",
    )
    handle = sandbox.commands.run(
        "pi --provider openrouter --model qwen/qwen3-coder-next --no-session -p",
        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",
        },
    )
    handle.send_stdin(
        "Read meeting.md and write actions.md: agreed actions, owners, and deadlines. Mark missing deadlines as not agreed. Keep discussion without a decision separate."
    )
    handle.close_stdin()
    result = handle.wait(on_stderr=lambda chunk: print(chunk, end="", file=sys.stderr))
    print(result.stdout)
    print("actions.md\n" + sandbox.files.read("/home/user/work/actions.md"))
finally:
    sandbox.kill()

package main

import (
	"context"
	"errors"
	"fmt"
	"github.com/abox-dev/sdk/packages/go-sdk"
	"log"
	"os"
	"time"
)

func run() (err error) {
	apiKey, proxy := os.Getenv("OPENROUTER_API_KEY"), os.Getenv("SANDBOX_PROXY_URL")
	if apiKey == "" {
		return errors.New("OPENROUTER_API_KEY is required")
	}
	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: "pi", 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/meeting.md", "Meeting: 2026-09-18\nOlga will send a revised quote to Acme by 2026-09-21.\nPavel will check stock for the next delivery; no deadline was agreed.\nThe marketing budget was discussed but no decision was made.\n", nil); err != nil {
		return err
	}
	handle, err := sandbox.Commands.Start(ctx, "sh", &agentbox.CommandOptions{
		Args: []string{"-lc", "pi --provider openrouter --model qwen/qwen3-coder-next --no-session -p"}, 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"},
		OnStderr: func(chunk []byte) { fmt.Fprint(os.Stderr, string(chunk)) },
	})
	if err != nil {
		return err
	}
	if _, err := handle.Write(ctx, []byte("Read meeting.md and write actions.md: agreed actions, owners, and deadlines. Mark missing deadlines as not agreed. Keep discussion without a decision separate.")); err != nil {
		return err
	}
	if err := handle.CloseStdin(ctx); err != nil {
		return err
	}
	result, err := handle.Wait(ctx)
	if err != nil {
		return err
	}
	fmt.Println(string(result.Stdout))
	report, err := sandbox.Files.ReadText(ctx, "/home/user/work/actions.md", "")
	if err != nil {
		return err
	}
	fmt.Println("actions.md\n" + report)
	return nil
}
func main() {
	if err := run(); err != nil {
		log.Fatal(err)
	}
}

-p печатает финальный ответ и завершает процесс. Задание передаётся через stdin. Закрытие ввода сообщает агенту, что текст получен целиком. Pi использует стандартный набор инструментов, включая чтение, запись, редактирование файлов и выполнение команд через bash. Дополнительные ограничения инструментов не задаются. Изоляцию обеспечивает песочница AgentBox. --no-session отключает сохранение истории, но не мешает записать итоговый файл.

Приложение читает actions.md до завершения песочницы. Ошибки запуска или чтения файла передаются вызывающему коду, а finally удаляет песочницу.

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

Пример запускает Pi с --mode rpc: приложение отправляет JSON-команды в stdin и получает события из stdout. Сначала агент составляет список действий по встрече, затем получает уточнённый срок и обновляет тот же файл, сохраняя контекст разговора.

mjs

import { Readable } from "node:stream";
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("pi", { timeoutMs: 600_000 });
try {
  await sandbox.files.write(
    "/home/user/meeting.md",
    "Olga will send a revised quote to Acme by 2026-09-21. Pavel will check stock; no deadline was agreed.\n",
  );
  const messages = new Readable({ objectMode: true, read() {} });
  let buffer = "";
  const agent = await sandbox.commands.run(
    "pi --mode rpc --provider openrouter --model qwen/qwen3-coder-next",
    {
      cwd: "/home/user",
      background: true,
      stdin: true,
      timeoutMs: 300_000,
      envs: {
        OPENROUTER_API_KEY: apiKey,
        HTTPS_PROXY: proxy,
        HTTP_PROXY: proxy,
        NO_PROXY: "localhost,127.0.0.1",
      },
      onStdout(chunk) {
        buffer += chunk;
        let end;
        while ((end = buffer.indexOf("\n")) !== -1) {
          const line = buffer.slice(0, end);
          buffer = buffer.slice(end + 1);
          try {
            if (line.trim()) messages.push(JSON.parse(line));
          } catch (error) {
            messages.destroy(error);
          }
        }
      },
      onStderr: (chunk) => process.stderr.write(chunk),
    },
  );
  agent.wait().then(
    () => messages.push(null),
    (error) => messages.destroy(error),
  );
  const incoming = messages[Symbol.asyncIterator]();
  let nextId = 0;
  async function prompt(text) {
    const id = String(++nextId);
    await agent.sendStdin(
      JSON.stringify({ id, type: "prompt", message: text }) + "\n",
    );
    let accepted = false,
      settled = false,
      lastAssistant;
    while (!accepted || !settled) {
      const { value: event, done } = await incoming.next();
      if (done) throw new Error("Pi closed before completing the task");
      if (event.type === "response" && event.id === id) {
        if (!event.success) throw new Error(event.error);
        accepted = true;
      }
      if (
        event.type === "message_update" &&
        event.assistantMessageEvent.type === "text_delta"
      ) {
        process.stdout.write(event.assistantMessageEvent.delta);
      }
      if (event.type === "message_end" && event.message.role === "assistant")
        lastAssistant = event.message;
      if (event.type === "agent_settled") settled = true;
    }
    if (
      !lastAssistant ||
      ["error", "aborted"].includes(lastAssistant.stopReason)
    ) {
      throw new Error(
        lastAssistant?.errorMessage ?? "Pi did not complete the response",
      );
    }
    console.log();
  }
  await prompt(
    "Read meeting.md and write actions.md with actions, owners and deadlines. Mark unagreed deadlines explicitly.",
  );
  await prompt(
    "Pavel has now confirmed a deadline of 2026-09-22. Update his action in actions.md; keep the other action unchanged.",
  );
  console.log(
    "actions.md\n" + (await sandbox.files.read("/home/user/actions.md")),
  );
} finally {
  await sandbox.kill();
}

import json
import os
import sys
from queue import Queue
from threading import Thread
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("pi", timeout=600)
try:
    sandbox.files.write(
        "/home/user/meeting.md",
        "Olga will send a revised quote to Acme by 2026-09-21. Pavel will check stock; no deadline was agreed.\n",
    )
    messages = Queue()
    buffer = ""

    def on_stdout(chunk):
        global buffer
        buffer += chunk
        while "\n" in buffer:
            line, buffer = buffer.split("\n", 1)
            if line.strip():
                messages.put(json.loads(line))

    agent = sandbox.commands.run(
        "pi --mode rpc --provider openrouter --model qwen/qwen3-coder-next",
        cwd="/home/user",
        background=True,
        stdin=True,
        timeout=300,
        envs={
            "OPENROUTER_API_KEY": api_key,
            "HTTPS_PROXY": proxy,
            "HTTP_PROXY": proxy,
            "NO_PROXY": "localhost,127.0.0.1",
        },
    )

    def read_messages():
        try:
            agent.wait(
                on_stdout=on_stdout,
                on_stderr=lambda chunk: print(chunk, end="", file=sys.stderr),
            )
            messages.put(RuntimeError("Pi closed before completing the task"))
        except Exception as error:
            messages.put(error)

    reader = Thread(target=read_messages, daemon=True)
    reader.start()
    next_id = 0

    def prompt(text):
        global next_id
        next_id += 1
        request_id = str(next_id)
        agent.send_stdin(
            json.dumps({"id": request_id, "type": "prompt", "message": text}) + "\n"
        )
        accepted = settled = False
        last_assistant = None
        while not accepted or not settled:
            event = messages.get(timeout=300)
            if isinstance(event, Exception):
                raise event
            if event["type"] == "response" and event.get("id") == request_id:
                if not event["success"]:
                    raise RuntimeError(event["error"])
                accepted = True
            if (
                event["type"] == "message_update"
                and event["assistantMessageEvent"]["type"] == "text_delta"
            ):
                print(event["assistantMessageEvent"]["delta"], end="", flush=True)
            if (
                event["type"] == "message_end"
                and event["message"]["role"] == "assistant"
            ):
                last_assistant = event["message"]
            if event["type"] == "agent_settled":
                settled = True
        if last_assistant is None or last_assistant["stopReason"] in (
            "error",
            "aborted",
        ):
            raise RuntimeError(
                (last_assistant or {}).get(
                    "errorMessage", "Pi did not complete the response"
                )
            )
        print()

    prompt(
        "Read meeting.md and write actions.md with actions, owners and deadlines. Mark unagreed deadlines explicitly."
    )
    prompt(
        "Pavel has now confirmed a deadline of 2026-09-22. Update his action in actions.md; keep the other action unchanged."
    )
    print("actions.md\n" + sandbox.files.read("/home/user/actions.md"))
finally:
    sandbox.kill()

package main

import (
	"context"
	"encoding/json"
	"errors"
	"fmt"
	"github.com/abox-dev/sdk/packages/go-sdk"
	"log"
	"os"
	"strconv"
	"strings"
	"time"
)

type assistantMessage struct {
	Role         string `json:"role"`
	StopReason   string `json:"stopReason"`
	ErrorMessage string `json:"errorMessage"`
}
type event struct {
	ID                    string           `json:"id"`
	Type                  string           `json:"type"`
	Success               bool             `json:"success"`
	Error                 string           `json:"error"`
	Message               assistantMessage `json:"message"`
	AssistantMessageEvent struct {
		Type  string `json:"type"`
		Delta string `json:"delta"`
	} `json:"assistantMessageEvent"`
}

func run() (err error) {
	apiKey, proxy := os.Getenv("OPENROUTER_API_KEY"), os.Getenv("SANDBOX_PROXY_URL")
	if apiKey == "" {
		return errors.New("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: "pi", 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.WriteText(ctx, "/home/user/meeting.md", "Olga will send a revised quote to Acme by 2026-09-21. Pavel will check stock; no deadline was agreed.\n", nil); err != nil {
		return err
	}
	messages := make(chan event, 64)
	parseErrors := make(chan error, 1)
	var buffer string
	agent, err := sandbox.Commands.Start(ctx, "pi", &agentbox.CommandOptions{
		Args: []string{"--mode", "rpc", "--provider", "openrouter", "--model", "qwen/qwen3-coder-next"},
		Cwd:  "/home/user", 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) {
			buffer += string(chunk)
			for {
				line, rest, found := strings.Cut(buffer, "\n")
				if !found {
					return
				}
				buffer = rest
				if strings.TrimSpace(line) == "" {
					continue
				}
				var msg event
				if err := json.Unmarshal([]byte(line), &msg); err != nil {
					select {
					case parseErrors <- err:
					default:
					}
					return
				}
				select {
				case messages <- msg:
				case <-ctx.Done():
					return
				}
			}
		},
		OnStderr: func(chunk []byte) { fmt.Fprint(os.Stderr, string(chunk)) },
	})
	if err != nil {
		return err
	}
	nextID := 0
	prompt := func(text string) error {
		nextID++
		id := strconv.Itoa(nextID)
		data, err := json.Marshal(map[string]string{"id": id, "type": "prompt", "message": text})
		if err != nil {
			return err
		}
		if _, err := agent.Write(ctx, append(data, '\n')); err != nil {
			return err
		}
		accepted, settled := false, false
		var lastAssistant assistantMessage
		for !accepted || !settled {
			select {
			case msg := <-messages:
				switch msg.Type {
				case "response":
					if msg.ID == id {
						if !msg.Success {
							return errors.New(msg.Error)
						}
						accepted = true
					}
				case "message_update":
					if msg.AssistantMessageEvent.Type == "text_delta" {
						fmt.Print(msg.AssistantMessageEvent.Delta)
					}
				case "message_end":
					if msg.Message.Role == "assistant" {
						lastAssistant = msg.Message
					}
				case "agent_settled":
					settled = true
				}
			case err := <-parseErrors:
				return err
			case <-agent.Done:
				return errors.New("Pi closed before completing the task")
			case <-ctx.Done():
				return ctx.Err()
			}
		}
		if lastAssistant.Role == "" || lastAssistant.StopReason == "error" || lastAssistant.StopReason == "aborted" {
			return fmt.Errorf("Pi did not complete the response: %s", lastAssistant.ErrorMessage)
		}
		fmt.Println()
		return nil
	}
	if err := prompt("Read meeting.md and write actions.md with actions, owners and deadlines. Mark unagreed deadlines explicitly."); err != nil {
		return err
	}
	if err := prompt("Pavel has now confirmed a deadline of 2026-09-22. Update his action in actions.md; keep the other action unchanged."); err != nil {
		return err
	}
	report, err := sandbox.Files.ReadText(ctx, "/home/user/actions.md", "")
	if err != nil {
		return err
	}
	fmt.Println("actions.md\n" + report)
	return nil
}
func main() {
	if err := run(); err != nil {
		log.Fatal(err)
	}
}

response с success: true подтверждает приём задания. Текст для интерфейса приходит в message_update → assistantMessageEvent → text_delta. Обработчик ждёт agent_settled и проверяет итоговое сообщение: после agent_end Pi ещё может автоматически повторить запрос.

Второй prompt отправляется тому же процессу после завершения первого задания. Песочница удаляется только после чтения обновлённого actions.md. Другие команды, включая остановку задания и выбор сохранённой сессии, описаны в протоколе Pi.

Pi ​

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

Разберите итоги встречи ​

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

Pi

Подключение

Разберите итоги встречи

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