The `port 49999 not open` error

This error does not mean that you should expose a sandbox port publicly. The Code Interpreter service listens on port 49999 inside the sandbox. The runCode and run_code methods use this service to execute code.

The error occurs when a custom template starts from a generic image that does not contain the Code Interpreter service or its start command. Exposing the port does not fix the missing service.

How to fix it

Base your custom template on the managed code-interpreter template. It already includes the execution service, its start command, and the readiness check.

The important line in the following example is fromTemplate("code-interpreter"). The other calls demonstrate that you can install a package on top, build your own template, and still execute code:

mjs

const templateName = process.env.TEMPLATE_NAME ?? "custom-code-interpreter";
const template = Template()
  .fromTemplate("code-interpreter")
  .pipInstall("humanize==4.13.0");

await Template.build(template, templateName);

const sandbox = await Sandbox.create(templateName);
try {
  const execution = await sandbox.runCode(
    "import humanize; humanize.intcomma(1234567)",
  );
  console.log(execution.text);
} finally {
  await sandbox.kill();
}

template_name = os.getenv("TEMPLATE_NAME", "custom-code-interpreter")
template = (
    Template()
    .from_template("code-interpreter")
    .pip_install("humanize==4.13.0")
)

Template.build(template, template_name)

with Sandbox.create(template_name) as sandbox:
    execution = sandbox.run_code(
        "import humanize; humanize.intcomma(1234567)"
    )
    print(execution.text)

package main

import (
	"context"
	"fmt"
	"log"
	"os"

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

func kill(sandbox *agentbox.Sandbox) {
	if _, err := sandbox.Kill(context.Background()); err != nil {
		log.Printf("cleanup sandbox: %v", err)
	}
}

func run() (err error) {
	ctx := context.Background()
	core, err := agentbox.NewClient()
	if err != nil {
		return err
	}
	name := os.Getenv("TEMPLATE_NAME")
	if name == "" {
		name = "custom-code-interpreter"
	}
	builder := agentbox.NewTemplate("").
		FromTemplate("code-interpreter").
		PipInstall("humanize==4.13.0")
	if _, err := core.Templates.Build(ctx, builder, name, nil); err != nil {
		return err
	}
	client, err := codeinterpreter.NewClient()
	if err != nil {
		return err
	}
	sandbox, err := client.Create(ctx, &agentbox.CreateSandboxOptions{Template: name})
	if err != nil {
		return err
	}
	defer kill(sandbox.Sandbox)
	execution, err := sandbox.RunCode(ctx, "import humanize; humanize.intcomma(1234567)", nil)
	if err != nil {
		return err
	}
	fmt.Println(execution.Text())
	return nil
}

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

If you do not need Code Interpreter, use a regular sandbox and run programs as commands. Use the managed template, or a template derived from it, with the Code Interpreter SDK.

The port 49999 not open error ​

How to fix it ​

The `port 49999 not open` error

How to fix it