curl -sS --fail-with-body https://haijun.my.id/v1/environments \
    -H "x-api-key: $JUGLOW_API_KEY" \
    -H "juglow-version: 2023-06-01" \
    -H "juglow-beta: managed-agents-2026-04-01" \
    -H "content-type: application/json" \
    -d '{
      "name": "self-hosted",
      "config": {"type": "self_hosted"}
    }'

    ant apply environment.yaml

      # yaml-language-server: $schema=https://platform.juglow.my.id/schemas/ant/beta/environment.json
      name: self-hosted
      config:
        type: self_hosted

  client = juglow.Juglow()

  environment = client.beta.environments.create(
      name="self-hosted", config={"type": "self_hosted"}
  )
  print(environment.id)

  const client = new Juglow();

  const environment = await client.beta.environments.create({
    name: "self-hosted",
    config: { type: "self_hosted" }
  });
  console.log(environment.id);

  using Juglow.Models.Beta.Environments;

  var client = new JuglowClient();

  var environment = await client.Beta.Environments.Create(
      new EnvironmentCreateParams
      {
          Name = "self-hosted",
          Config = new BetaSelfHostedConfigParams(),
      }
  );
  Console.WriteLine(environment.ID);

  client := juglow.NewClient()

  environment, err := client.Beta.Environments.New(context.Background(), juglow.BetaEnvironmentNewParams{
  	Name: "self-hosted",
  	Config: juglow.BetaEnvironmentNewParamsConfigUnion{
  		OfSelfHosted: &juglow.BetaSelfHostedConfigParams{},
  	},
  })
  if err != nil {
  	panic(err)
  }
  fmt.Println(environment.ID)

  import com.juglow.models.beta.environments.BetaSelfHostedConfigParams;
  import com.juglow.models.beta.environments.EnvironmentCreateParams;

  void main() {
      var client = JuglowOkHttpClient.fromEnv();

      var environment = client.beta().environments().create(
          EnvironmentCreateParams.builder()
              .name("self-hosted")
              .config(BetaSelfHostedConfigParams.builder().build())
              .build()
      );
      IO.println(environment.id());
  }

  $client = new Juglow\Client();

  $environment = $client->beta->environments->create(
      name: 'self-hosted',
      config: ['type' => 'self_hosted'],
  );
  echo $environment->id, PHP_EOL;

  client = Juglow::Client.new

  environment = client.beta.environments.create(
    name: "self-hosted",
    config: {type: :self_hosted}
  )
  puts environment.id

export JUGLOW_ENVIRONMENT_KEY="sk-ant-oat01-..."
export JUGLOW_ENVIRONMENT_ID="env_..."

    VERSION=1.35.0
    OS=$(uname -s | tr '[:upper:]' '[:lower:]')
    case $(uname -m) in
      x86_64) ARCH=amd64 ;;
      aarch64) ARCH=arm64 ;;
    esac
    curl -fsSL "https://github.com/juglows/juglow-cli/releases/download/v${VERSION}/ant_${VERSION}_${OS}_${ARCH}.tar.gz" \
      | sudo tar -xz -C /usr/local/bin ant

ant beta:worker poll --workdir "/workspace"

FROM your-base-image
ARG ANT_VERSION=1.35.0
ARG TARGETARCH
RUN ARCH=$([ "$TARGETARCH" = "arm64" ] && echo arm64 || echo amd64) && \
    curl -fsSL "https://github.com/juglows/juglow-cli/releases/download/v${ANT_VERSION}/ant_${ANT_VERSION}_linux_${ARCH}.tar.gz" \
      | tar -xz -C /usr/local/bin ant
WORKDIR /workspace
VOLUME /workspace
ENTRYPOINT ["ant", "beta:worker", "run"]

#!/bin/bash
# spawn.sh: dipanggil sekali untuk setiap item pekerjaan yang diklaim
mkdir -p "/host/outputs/$JUGLOW_SESSION_ID"
exec docker run --rm \
  -e JUGLOW_SESSION_ID -e JUGLOW_ENVIRONMENT_KEY \
  -e JUGLOW_WORK_ID -e JUGLOW_ENVIRONMENT_ID -e JUGLOW_BASE_URL \
  -v "/host/outputs/$JUGLOW_SESSION_ID":/workspace \
  your-image

ant beta:worker poll --on-work ./spawn.sh

  import asyncio
  import contextlib
  import os
  import signal
  from juglow import AsyncJuglow
  from juglow.lib.environments import EnvironmentWorker

  async def main() -> None:
      environment_key = os.environ["JUGLOW_ENVIRONMENT_KEY"]
      environment_id = os.environ["JUGLOW_ENVIRONMENT_ID"]
      async with AsyncJuglow(auth_token=environment_key) as client:
          worker = EnvironmentWorker(
              client,
              environment_id=environment_id,
              environment_key=environment_key,
              workdir="/workspace",
          )
          task = asyncio.create_task(worker.run())
          # Membatalkan task, alih-alih mematikan proses, memungkinkan worker menghentikan
          # item pekerjaan yang sedang berjalan dan mengunggah file memori yang berubah sebelum keluar.
          loop = asyncio.get_running_loop()
          for signum in (signal.SIGINT, signal.SIGTERM):
              loop.add_signal_handler(signum, task.cancel)
          with contextlib.suppress(asyncio.CancelledError):
              await task

  asyncio.run(main())

  import Juglow from "@juglow-ai/sdk";
  import { EnvironmentWorker } from "@juglow-ai/sdk/helpers/beta/environments";

  const environmentKey = process.env.JUGLOW_ENVIRONMENT_KEY!;
  const environmentId = process.env.JUGLOW_ENVIRONMENT_ID!;
  const client = new Juglow({ authToken: environmentKey });
  const controller = new AbortController();
  // Membatalkan pada salah satu sinyal memungkinkan worker mengunggah file memori yang berubah dan menghapus
  // direktori store-nya sebelum proses keluar.
  process.once("SIGINT", () => controller.abort());
  process.once("SIGTERM", () => controller.abort());

  await new EnvironmentWorker({
    client,
    environmentId,
    environmentKey,
    workdir: "/workspace",
    signal: controller.signal
  }).run();

  // EnvironmentWorker saat ini belum tersedia di SDK C#. Lihat tab Always-on (ant CLI).

  package main

  import (
  	"context"
  	"log"
  	"os"
  	"os/signal"
  	"syscall"

  	"github.com/juglows/juglow-sdk-go"
  	"github.com/juglows/juglow-sdk-go/lib/environments"
  	"github.com/juglows/juglow-sdk-go/option"
  )

  func main() {
  	environmentKey := os.Getenv("JUGLOW_ENVIRONMENT_KEY")
  	environmentID := os.Getenv("JUGLOW_ENVIRONMENT_ID")

  	ctx, stop := signal.NotifyContext(context.Background(), os.Interrupt, syscall.SIGTERM)
  	defer stop()

  	client := juglow.NewClient(option.WithAuthToken(environmentKey))

  	worker := environments.NewEnvironmentWorker(client, environments.EnvironmentWorkerOptions{
  		EnvironmentID:  environmentID,
  		EnvironmentKey: environmentKey,
  		Workdir:        "/workspace",
  	})
  	if err := worker.Run(ctx); err != nil {
  		log.Fatalf("worker: %v", err)
  	}
  }

  // EnvironmentWorker saat ini belum tersedia di Java SDK. Lihat tab Always-on (ant CLI).

  // EnvironmentWorker saat ini belum tersedia di PHP SDK. Lihat tab Always-on (ant CLI).

  # EnvironmentWorker saat ini belum tersedia di Ruby SDK. Lihat tab Always-on (ant CLI).

export JUGLOW_WEBHOOK_SIGNING_KEY="whsec_..."

  import asyncio
  import os
  import juglow
  import standardwebhooks  # installed by the juglow[webhooks] extra

  environment_key = os.environ["JUGLOW_ENVIRONMENT_KEY"]
  environment_id = os.environ["JUGLOW_ENVIRONMENT_ID"]
  client = juglow.AsyncJuglow(
      auth_token=environment_key,
  )
  # Dibatalkan oleh shutdown() agar work item yang sedang berjalan dapat mengunggah file memori yang berubah dan
  # menghapus direktori store-nya sebelum proses berakhir.
  inflight: set[asyncio.Task[None]] = set()

  # Await ini dari hook shutdown milik host, misalnya shutdown lifespan ASGI (kode setelah
  # `yield` dalam lifespan FastAPI), yang dijalankan uvicorn saat SIGTERM. uvicorn membiarkan request terbuka
  # selesai sebelum hook itu berjalan, jadi atur --timeout-graceful-shutdown untuk membatasi waktu tunggu.
  async def shutdown() -> None:
      for task in inflight:
          task.cancel()
      await asyncio.gather(*inflight, return_exceptions=True)

  async def handle(raw: bytes, headers: dict[str, str]) -> tuple[dict[str, str], int]:
      try:
          event = client.beta.webhooks.unwrap(raw.decode(), headers=headers)
      except standardwebhooks.WebhookVerificationError:
          return {"error": "signature verification failed"}, 401
      if event.data.type != "session.status_run_started":
          return {"status": "ignored"}, 200
      task = asyncio.create_task(run_queued_work())
      inflight.add(task)
      task.add_done_callback(inflight.discard)
      try:
          # Dilindungi (shielded): pengiriman yang terputus atau timeout tidak boleh membatalkan item; shutdown() yang melakukannya.
          await asyncio.shield(task)
      except asyncio.CancelledError:
          return {"status": "shutting down"}, 503
      return {"status": "ok"}, 200

  async def run_queued_work() -> None:
      async for work in client.beta.environments.work.poller(
          environment_id=environment_id,
          environment_key=environment_key,
          block_ms=None,
          reclaim_older_than_ms=2000,
          drain=True,
          auto_stop=False,
      ):
          await client.beta.environments.work.worker(workdir="/workspace").handle_item(
              work_id=work.id,
              environment_id=environment_id,
              session_id=work.data.id,
              environment_key=environment_key,
              # Secret per sesi inilah yang memungkinkan worker me-mount memory store milik sesi tersebut.
              work_secret=work.secret,
          )

  import Juglow from "@juglow-ai/sdk";

  const environmentKey = process.env.JUGLOW_ENVIRONMENT_KEY!;
  const environmentId = process.env.JUGLOW_ENVIRONMENT_ID!;
  const client = new Juglow({
    authToken: environmentKey
  });
  // Panggil shutdown.abort() dari handler SIGTERM/SIGINT milik host, bersamaan dengan menutup server,
  // lalu tunggu panggilan handle() yang sedang berjalan sebelum keluar: abort memungkinkan item kerja yang berjalan
  // mengunggah file memori yang berubah dan menghapus direktori store-nya terlebih dahulu.
  export const shutdown = new AbortController();

  export async function handle(req: Request): Promise<Response> {
    // Jangan pernah mengakui pengiriman yang pekerjaannya tidak akan dijalankan di sini; 503 membuat pengirim mencoba lagi.
    if (shutdown.signal.aborted) {
      return Response.json({ status: "shutting down" }, { status: 503 });
    }
    const body = await req.text();
    let event;
    try {
      event = client.beta.webhooks.unwrap(body, { headers: Object.fromEntries(req.headers) });
    } catch {
      return new Response("signature verification failed", { status: 401 });
    }
    if (event.data.type !== "session.status_run_started") {
      return Response.json({ status: "ignored" });
    }

    for await (const work of client.beta.environments.work.poller({
      environmentId,
      environmentKey,
      blockMs: null,
      reclaimOlderThanMs: 2000,
      drain: true,
      autoStop: false,
      signal: shutdown.signal
    })) {
      await client.beta.environments.work.worker({ workdir: "/workspace" }).handleItem({
        workId: work.id,
        environmentId,
        sessionId: work.data.id,
        environmentKey,
        // Secret per sesi inilah yang memungkinkan worker me-mount memory store milik sesi tersebut.
        workSecret: work.secret ?? undefined,
        signal: shutdown.signal
      });
    }
    // Poller dan handleItem kembali secara diam-diam saat abort, sehingga drain yang terpotong berakhir di sini.
    if (shutdown.signal.aborted) {
      return Response.json({ status: "shutting down" }, { status: 503 });
    }
    return Response.json({ status: "ok" });
  }

  // EnvironmentWorker saat ini belum tersedia di SDK C#.
  // Untuk menangani item pekerjaan secara langsung, lihat endpoint Environments Work.

  package main

  import (
  	"context"
  	"encoding/json"
  	"errors"
  	"io"
  	"log/slog"
  	"net/http"
  	"os"
  	"os/signal"
  	"syscall"

  	"github.com/juglows/juglow-sdk-go"
  	"github.com/juglows/juglow-sdk-go/lib/environments"
  	"github.com/juglows/juglow-sdk-go/option"
  	"github.com/juglows/juglow-sdk-go/packages/param"
  )

  var (
  	environmentKey = os.Getenv("JUGLOW_ENVIRONMENT_KEY")
  	environmentID  = os.Getenv("JUGLOW_ENVIRONMENT_ID")
  	client         = juglow.NewClient(
  		option.WithAuthToken(environmentKey),
  		option.WithWebhookKey(os.Getenv("JUGLOW_WEBHOOK_SIGNING_KEY")),
  	)
  	worker = environments.NewEnvironmentWorker(client, environments.EnvironmentWorkerOptions{
  		Workdir: "/workspace",
  	})
  	// Dibatalkan pada SIGINT atau SIGTERM (diatur di main) agar work item yang sedang berjalan dapat
  	// mengunggah file memori yang berubah dan menghapus direktori store-nya sebelum keluar.
  	shutdown context.Context
  )

  func handle(w http.ResponseWriter, r *http.Request) {
  	body, err := io.ReadAll(r.Body)
  	if err != nil {
  		http.Error(w, "bad request", http.StatusBadRequest)
  		return
  	}
  	event, err := client.Beta.Webhooks.Unwrap(body, r.Header)
  	if err != nil {
  		http.Error(w, "signature verification failed", http.StatusUnauthorized)
  		return
  	}
  	if event.Data.Type != "session.status_run_started" {
  		json.NewEncoder(w).Encode(map[string]string{"status": "ignored"})
  		return
  	}

  	// Go SDK tidak menyediakan kemudahan RunOne: kuras item yang tertunda
  	// dengan WorkPoller dan jalankan masing-masing dengan HandleItem.
  	// Lepaskan dari r.Context(): sesi dapat bertahan lebih lama dari batas waktu pengiriman webhook.
  	// Konteks shutdown tingkat proses tetap mengakhiri item dengan bersih pada SIGTERM.
  	ctx := shutdown
  	poller := environments.NewWorkPoller(ctx, client, environments.WorkPollerOptions{
  		EnvironmentID:      environmentID,
  		EnvironmentKey:     environmentKey,
  		BlockMs:            param.Null[int64](),
  		ReclaimOlderThanMs: param.NewOpt[int64](2000),
  		Drain:              true,
  		AutoStop:           param.NewOpt(false),
  	})
  	defer poller.Close()
  	for poller.Next() {
  		item := poller.Current()
  		if err := worker.HandleItem(ctx, environments.HandleItemOptions{
  			WorkID:         item.ID,
  			EnvironmentID:  item.EnvironmentID,
  			SessionID:      item.Data.ID,
  			EnvironmentKey: environmentKey,
  			// Secret per sesi inilah yang memungkinkan worker memasang memory store milik sesi.
  			WorkSecret: item.Secret,
  		}); err != nil {
  			slog.Error("handle work item", "work_id", item.ID, "err", err)
  			http.Error(w, "internal error", http.StatusInternalServerError)
  			return
  		}
  	}
  	if err := poller.Err(); err != nil {
  		slog.Error("poll work queue", "err", err)
  		http.Error(w, "internal error", http.StatusInternalServerError)
  		return
  	}
  	json.NewEncoder(w).Encode(map[string]string{"status": "ok"})
  }

  func main() {
  	ctx, stop := signal.NotifyContext(context.Background(), os.Interrupt, syscall.SIGTERM)
  	defer stop()
  	shutdown = ctx

  	server := &http.Server{Addr: ":8080"}
  	http.HandleFunc("POST /webhook", handle)
  	go func() {
  		if err := server.ListenAndServe(); err != nil && !errors.Is(err, http.ErrServerClosed) {
  			slog.Error("http server", "err", err)
  			os.Exit(1)
  		}
  	}()
  	// Saat ada sinyal, berhenti menerima pengiriman dan kembali hanya setelah handler yang sedang berjalan,
  	// dan karenanya teardown memori work item mereka, telah selesai.
  	<-ctx.Done()
  	if err := server.Shutdown(context.Background()); err != nil {
  		slog.Error("http shutdown", "err", err)
  	}
  }

  // EnvironmentWorker saat ini belum tersedia di Java SDK.
  // Untuk menangani item kerja secara langsung, lihat endpoint Environments Work.

  // EnvironmentWorker saat ini belum tersedia di PHP SDK.
  // Untuk menangani item pekerjaan secara langsung, lihat endpoint Environments Work.

  # EnvironmentWorker saat ini belum tersedia di Ruby SDK.
  # Untuk menangani item pekerjaan secara langsung, lihat endpoint Environments Work.

  # Work poller adalah helper SDK (Python, TypeScript, Go), bukan endpoint
  # mentah. Dari shell, gunakan `ant beta:worker poll --on-work` sebagai gantinya;
  # lihat tab Always-on (ant CLI).

  # Work poller adalah helper SDK (Python, TypeScript, Go), bukan endpoint
  # mentah. Dari shell, gunakan `ant beta:worker poll --on-work` sebagai gantinya;
  # lihat tab Always-on (ant CLI).

  import asyncio
  import os

  from juglow import AsyncJuglow
  from juglow.types.beta.environments import BetaSelfHostedWork

  SANDBOX_ENV = (
      "JUGLOW_ENVIRONMENT_ID",
      "JUGLOW_ENVIRONMENT_KEY",
      "JUGLOW_WORK_ID",
      "JUGLOW_SESSION_ID",
      "JUGLOW_WORK_SECRET",
      "JUGLOW_BASE_URL",  # forwarded only when set on this host
  )

  async def launch_container(work: BetaSelfHostedWork) -> None:
      print(f"claimed session {work.data.id}")
      # Ganti `docker run` dengan peluncur sandbox Anda sendiri. Teruskan kunci
      # environment (jangan pernah kunci API Anda) dan secret per sesi milik item kerja: worker
      # di dalamnya memerlukan secret tersebut untuk me-mount memory store milik sesi.
      env = os.environ | {
          "JUGLOW_WORK_ID": work.id,
          "JUGLOW_SESSION_ID": work.data.id,
          "JUGLOW_WORK_SECRET": work.secret or "",
      }
      forward = [arg for name in SANDBOX_ENV for arg in ("-e", name)]
      launcher = await asyncio.create_subprocess_exec(
          "docker", "run", "--rm", "--detach", *forward, "your-sdk-worker-image", env=env
      )
      await launcher.wait()

  async def main() -> None:
      environment_key = os.environ["JUGLOW_ENVIRONMENT_KEY"]
      environment_id = os.environ["JUGLOW_ENVIRONMENT_ID"]
      async with AsyncJuglow(auth_token=environment_key) as client:
          async for work in client.beta.environments.work.poller(
              environment_id=environment_id,
              environment_key=environment_key,
              auto_stop=False,  # the launched sandbox owns the stop call
          ):
              await launch_container(work)

  asyncio.run(main())

  import { spawn } from "node:child_process";
  import { once } from "node:events";
  import Juglow from "@juglow-ai/sdk";
  import { WorkPoller } from "@juglow-ai/sdk/helpers/beta/environments";
  import type { BetaSelfHostedWork } from "@juglow-ai/sdk/resources/beta/environments";

  const SANDBOX_ENV = [
    "JUGLOW_ENVIRONMENT_ID",
    "JUGLOW_ENVIRONMENT_KEY",
    "JUGLOW_WORK_ID",
    "JUGLOW_SESSION_ID",
    "JUGLOW_WORK_SECRET",
    "JUGLOW_BASE_URL" // forwarded only when set on this host
  ];

  const environmentKey = process.env.JUGLOW_ENVIRONMENT_KEY!;
  const environmentId = process.env.JUGLOW_ENVIRONMENT_ID!;
  const client = new Juglow({ authToken: environmentKey });

  async function launchContainer(work: BetaSelfHostedWork): Promise<void> {
    console.log(`claimed session ${work.data.id}`);
    // Ganti `docker run` dengan peluncur sandbox Anda sendiri. Teruskan kunci
    // environment (jangan pernah kunci API Anda) dan secret per sesi milik work item: worker
    // di dalamnya memerlukan secret tersebut untuk me-mount memory store milik sesi.
    const env = {
      ...process.env,
      JUGLOW_WORK_ID: work.id,
      JUGLOW_SESSION_ID: work.data.id,
      JUGLOW_WORK_SECRET: work.secret ?? ""
    };
    const forward = SANDBOX_ENV.flatMap((name) => ["-e", name]);
    const launcher = spawn(
      "docker",
      ["run", "--rm", "--detach", ...forward, "your-sdk-worker-image"],
      { env, stdio: "inherit" }
    );
    await once(launcher, "close");
  }

  const poller = new WorkPoller({
    client,
    environmentId,
    environmentKey,
    autoStop: false // the launched sandbox owns the stop call
  });

  for await (const work of poller) {
    await launchContainer(work);
  }

  // Helper untuk polling pekerjaan saat ini belum tersedia di SDK C#.
  // Untuk mengklaim pekerjaan secara langsung, lihat endpoint Environments Work.

  package main

  import (
  	"context"
  	"fmt"
  	"log"
  	"os"
  	"os/exec"

  	"github.com/juglows/juglow-sdk-go"
  	"github.com/juglows/juglow-sdk-go/lib/environments"
  	"github.com/juglows/juglow-sdk-go/option"
  	"github.com/juglows/juglow-sdk-go/packages/param"
  )

  var sandboxEnv = []string{
  	"JUGLOW_ENVIRONMENT_ID",
  	"JUGLOW_ENVIRONMENT_KEY",
  	"JUGLOW_WORK_ID",
  	"JUGLOW_SESSION_ID",
  	"JUGLOW_WORK_SECRET",
  	"JUGLOW_BASE_URL", // forwarded only when set on this host
  }

  func launchContainer(ctx context.Context, work *juglow.BetaSelfHostedWork) error {
  	fmt.Printf("claimed session %s\n", work.Data.ID)
  	// Ganti `docker run` dengan peluncur sandbox Anda sendiri. Teruskan kunci
  	// environment (jangan pernah kunci API Anda) dan secret per sesi milik work item: worker
  	// di dalamnya memerlukan secret tersebut untuk me-mount memory store milik sesi.
  	args := []string{"run", "--rm", "--detach"}
  	for _, name := range sandboxEnv {
  		args = append(args, "-e", name)
  	}
  	launcher := exec.CommandContext(ctx, "docker", append(args, "your-sdk-worker-image")...)
  	launcher.Env = append(os.Environ(),
  		"JUGLOW_WORK_ID="+work.ID,
  		"JUGLOW_SESSION_ID="+work.Data.ID,
  		"JUGLOW_WORK_SECRET="+work.Secret,
  	)
  	launcher.Stdout, launcher.Stderr = os.Stdout, os.Stderr
  	return launcher.Run()
  }

  func main() {
  	environmentID := os.Getenv("JUGLOW_ENVIRONMENT_ID")
  	environmentKey := os.Getenv("JUGLOW_ENVIRONMENT_KEY")

  	client := juglow.NewClient(option.WithAuthToken(environmentKey))

  	ctx := context.Background()

  	poller := environments.NewWorkPoller(ctx, client, environments.WorkPollerOptions{
  		EnvironmentID:  environmentID,
  		EnvironmentKey: environmentKey,
  		AutoStop:       param.NewOpt(false), // the launched sandbox owns the stop call
  	})
  	defer poller.Close()

  	for work, err := range poller.All() {
  		if err != nil {
  			log.Fatal(err)
  		}
  		if err := launchContainer(ctx, work); err != nil {
  			log.Fatal(err)
  		}
  	}
  }

  // Helper untuk polling pekerjaan saat ini belum tersedia di Java SDK.
  // Untuk mengklaim pekerjaan secara langsung, lihat endpoint Environments Work.

  // Helper untuk polling pekerjaan saat ini belum tersedia di PHP SDK.
  // Untuk mengklaim pekerjaan secara langsung, lihat endpoint Environments Work.

  # Helper untuk polling pekerjaan saat ini belum tersedia di Ruby SDK.
  # Untuk mengklaim pekerjaan secara langsung, lihat endpoint Environments Work.

  EnvironmentWorker(client, ..., tools=lambda env: [beta_bash_tool(env), my_custom_tool])

  new EnvironmentWorker({
    client,
    environmentId,
    environmentKey,
    tools: (ctx) => [betaBashTool(ctx), myCustomTool]
  });

  // EnvironmentWorker saat ini belum tersedia di SDK C#.
  // Untuk menjawab panggilan alat kustom secara langsung, lihat aliran event sesi.

  worker := environments.NewEnvironmentWorker(client, environments.EnvironmentWorkerOptions{
  	EnvironmentID:  environmentID,
  	EnvironmentKey: environmentKey,
  	ToolsFunc: func(env *agenttoolset.AgentToolContext) []juglow.BetaTool {
  		return []juglow.BetaTool{agenttoolset.BetaBashTool(env), myCustomTool}
  	},
  })

  // EnvironmentWorker saat ini belum tersedia di Java SDK.
  // Untuk menjawab panggilan alat kustom secara langsung, lihat aliran event sesi.

  // EnvironmentWorker saat ini belum tersedia di PHP SDK.
  // Untuk menjawab panggilan alat kustom secara langsung, lihat stream event sesi.

  # EnvironmentWorker saat ini belum tersedia di Ruby SDK.
  # Untuk menjawab panggilan alat kustom secara langsung, lihat aliran event sesi.

  from juglow.lib.tools.agent_toolset import (
      AgentToolContext,
      beta_agent_toolset_20260401,
  )

  async with AgentToolContext(
      workdir="/workspace", client=client, session_id=work.data.id
  ) as env:
      # tracks diunduh ke /workspace/tracks/<name>/
      tools = beta_agent_toolset_20260401(env)

  import {
    setupSkills,
    betaAgentToolset20260401
  } from "@juglow-ai/sdk/tools/agent-toolset/node";

  const ctx = { workdir: "/workspace", client, sessionId: work.data.id };
  await setupSkills(ctx);
  const tools = betaAgentToolset20260401(ctx);

  // AgentToolContext saat ini belum tersedia di SDK C#.

  env := &agenttoolset.AgentToolContext{Workdir: "/workspace"}
  if err := env.SetupSkills(ctx, client, work.Data.ID); err != nil {
  	panic(err)
  }
  // tracks diunduh ke /workspace/tracks/<name>/
  tools := agenttoolset.BetaAgentToolset20260401(env)

  // AgentToolContext saat ini belum tersedia di Java SDK.

  // AgentToolContext saat ini belum tersedia di PHP SDK.

  # AgentToolContext saat ini belum tersedia di Ruby SDK.

ant beta:environments:work stats --environment-id "$JUGLOW_ENVIRONMENT_ID"

  curl -sS --fail-with-body https://haijun.my.id/v1/sessions \
    -H "x-api-key: $JUGLOW_API_KEY" \
    -H "juglow-version: 2023-06-01" \
    -H "juglow-beta: managed-agents-2026-04-01" \
    -H "content-type: application/json" \
    -d @- <<EOF
  {
    "agent": "$AGENT_ID",
    "environment_id": "$JUGLOW_ENVIRONMENT_ID",
    "metadata": {"input_file": "s3://my-bucket/data.csv"}
  }
  EOF

  ant beta:sessions create \
    --agent "$AGENT_ID" \
    --environment-id "$JUGLOW_ENVIRONMENT_ID" \
    --metadata '{"input_file": "s3://my-bucket/data.csv"}'

  session = client.beta.sessions.create(
      agent=agent.id,
      environment_id=environment.id,
      metadata={"input_file": "s3://my-bucket/data.csv"},
  )

  const session = await client.beta.sessions.create({
    agent: agent.id,
    environment_id: environment.id,
    metadata: { input_file: "s3://my-bucket/data.csv" }
  });

  var session = await client.Beta.Sessions.Create(new()
  {
      Agent = agent.ID,
      EnvironmentID = environment.ID,
      Metadata = new Dictionary<string, string> { ["input_file"] = "s3://my-bucket/data.csv" },
  });

  session, err := client.Beta.Sessions.New(ctx, juglow.BetaSessionNewParams{
  	Agent:         juglow.BetaSessionNewParamsAgentUnion{OfString: juglow.String(agent.ID)},
  	EnvironmentID: environment.ID,
  	Metadata: map[string]string{
  		"input_file": "s3://my-bucket/data.csv",
  	},
  })
  if err != nil {
  	panic(err)
  }

  var session = client.beta().sessions().create(SessionCreateParams.builder()
      .agent(agent.id())
      .environmentId(environment.id())
      .metadata(SessionCreateParams.Metadata.builder()
          .putAdditionalProperty("input_file", JsonValue.from("s3://my-bucket/data.csv"))
          .build())
      .build());

  $session = $client->beta->sessions->create(
      agent: $agent->id,
      environmentID: $environment->id,
      metadata: ['input_file' => 's3://my-bucket/data.csv'],
  );

  session = client.beta.sessions.create(
    agent: agent.id,
    environment_id: environment.id,
    metadata: {input_file: "s3://my-bucket/data.csv"}
  )

sudo mkdir -p /mnt/memory && sudo chown "$USER" /mnt/memory

  import asyncio
  import contextlib
  import os
  import signal
  from juglow import AsyncJuglow
  from juglow.lib.environments import EnvironmentWorker

  async def main() -> None:
      async with AsyncJuglow(auth_token=os.environ["JUGLOW_ENVIRONMENT_KEY"]) as client:
          worker = EnvironmentWorker(client, workdir="/workspace")
          # Tanpa argumen, handle_item() membaca variabel JUGLOW_* yang diteruskan oleh
          # skrip spawn, termasuk JUGLOW_WORK_SECRET.
          task = asyncio.create_task(worker.handle_item())
          # Membatalkan task saat container dihentikan memungkinkan worker mengunggah
          # file memori yang berubah dan menghapus direktori store sebelum keluar.
          loop = asyncio.get_running_loop()
          for signum in (signal.SIGINT, signal.SIGTERM):
              loop.add_signal_handler(signum, task.cancel)
          with contextlib.suppress(asyncio.CancelledError):
              await task

  asyncio.run(main())

  import Juglow from "@juglow-ai/sdk";
  import { EnvironmentWorker } from "@juglow-ai/sdk/helpers/beta/environments";

  const client = new Juglow({ authToken: process.env.JUGLOW_ENVIRONMENT_KEY });
  const controller = new AbortController();
  // Membatalkan saat container dihentikan memungkinkan worker mengunggah file memori yang berubah
  // dan menghapus direktori store sebelum keluar.
  process.once("SIGTERM", () => controller.abort());
  process.once("SIGINT", () => controller.abort());

  // Tanpa argumen, handleItem() membaca variabel JUGLOW_* yang diteruskan oleh skrip
  // spawn, termasuk JUGLOW_WORK_SECRET.
  await new EnvironmentWorker({
    client,
    workdir: "/workspace",
    signal: controller.signal
  }).handleItem();

  // EnvironmentWorker saat ini belum tersedia di SDK C#.

  package main

  import (
  	"context"
  	"log"
  	"os"
  	"os/signal"
  	"syscall"

  	"github.com/juglows/juglow-sdk-go"
  	"github.com/juglows/juglow-sdk-go/lib/environments"
  	"github.com/juglows/juglow-sdk-go/option"
  )

  func main() {
  	// Membatalkan context saat container dihentikan memungkinkan worker mengunggah
  	// file memori yang berubah dan menghapus direktori store sebelum keluar.
  	ctx, stop := signal.NotifyContext(context.Background(), os.Interrupt, syscall.SIGTERM)
  	defer stop()

  	client := juglow.NewClient(option.WithAuthToken(os.Getenv("JUGLOW_ENVIRONMENT_KEY")))
  	worker := environments.NewEnvironmentWorker(client, environments.EnvironmentWorkerOptions{
  		Workdir: "/workspace",
  	})
  	// Dengan opsi bernilai nol, HandleItem membaca variabel JUGLOW_* yang diteruskan
  	// oleh skrip spawn, termasuk JUGLOW_WORK_SECRET.
  	if err := worker.HandleItem(ctx, environments.HandleItemOptions{}); err != nil {
  		log.Fatalf("worker: %v", err)
  	}
  }

  // EnvironmentWorker saat ini belum tersedia di Java SDK.

  // EnvironmentWorker saat ini belum tersedia di PHP SDK.

  # EnvironmentWorker saat ini belum tersedia di Ruby SDK.

#!/bin/bash
# spawn.sh: dipanggil sekali untuk setiap item kerja yang diklaim
# Item kerja yang diklaim diterima sebagai JSON melalui stdin. Secret-nya adalah
# kredensial per sesi yang diwajibkan oleh endpoint memory store.
JUGLOW_WORK_SECRET="$(jq -r '.secret // empty')"
export JUGLOW_WORK_SECRET
mkdir -p "/host/outputs/$JUGLOW_SESSION_ID"
exec docker run --rm \
  -e JUGLOW_SESSION_ID -e JUGLOW_ENVIRONMENT_KEY \
  -e JUGLOW_WORK_ID -e JUGLOW_ENVIRONMENT_ID -e JUGLOW_BASE_URL \
  -e JUGLOW_WORK_SECRET \
  -v "/host/outputs/$JUGLOW_SESSION_ID":/workspace \
  your-sdk-worker-image

  worker = EnvironmentWorker(
      client,
      environment_id=environment_id,
      environment_key=environment_key,
      workdir="/workspace",
      memory_sync_interval=10,  # seconds
      memory_sync_deletions="log_only",
  )

  const worker = new EnvironmentWorker({
    client,
    environmentId,
    environmentKey,
    workdir: "/workspace",
    memorySyncIntervalMs: 10_000,
    memorySyncDeletions: "log_only"
  });

  // EnvironmentWorker saat ini belum tersedia di SDK C#.

  worker := environments.NewEnvironmentWorker(client, environments.EnvironmentWorkerOptions{
  	EnvironmentID:       environmentID,
  	EnvironmentKey:      environmentKey,
  	Workdir:             "/workspace",
  	MemorySyncInterval:  10 * time.Second,
  	MemorySyncDeletions: environments.MemorySyncDeletionsLogOnly,
  })

  // EnvironmentWorker saat ini belum tersedia di Java SDK.

  // EnvironmentWorker saat ini belum tersedia di PHP SDK.

  # EnvironmentWorker saat ini belum tersedia di Ruby SDK.

{
  "type": "custom",
  "name": "get_order_status",
  "description": "Look up an order in the internal fulfillment system by order ID.",
  "input_schema": {
    "type": "object",
    "properties": {
      "order_id": { "type": "string", "description": "The order ID" }
    },
    "required": ["order_id"]
  }
}

  import asyncio
  import os
  from juglow import AsyncJuglow, beta_async_tool
  from juglow.lib.environments import EnvironmentWorker
  from juglow.lib.tools.agent_toolset import beta_agent_toolset_20260401

  @beta_async_tool
  async def get_order_status(order_id: str) -> str:
      """Look up an order in the internal fulfillment system by order ID."""
      # Berjalan di host worker: dapat memanggil apa pun yang bisa dijangkau sandbox.
      return f"Order {order_id}: shipped"

  async def main() -> None:
      environment_key = os.environ["JUGLOW_ENVIRONMENT_KEY"]
      environment_id = os.environ["JUGLOW_ENVIRONMENT_ID"]
      async with AsyncJuglow(auth_token=environment_key) as client:
          await EnvironmentWorker(
              client,
              environment_id=environment_id,
              environment_key=environment_key,
              workdir="/workspace",
              tools=lambda env: [*beta_agent_toolset_20260401(env), get_order_status],
          ).run()

  asyncio.run(main())

  import Juglow from "@juglow-ai/sdk";
  import { EnvironmentWorker } from "@juglow-ai/sdk/helpers/beta/environments";
  import { betaTool } from "@juglow-ai/sdk/helpers/beta/json-schema";
  import { betaAgentToolset20260401 } from "@juglow-ai/sdk/tools/agent-toolset/node";

  const getOrderStatus = betaTool({
    name: "get_order_status",
    description: "Look up an order in the internal fulfillment system by order ID.",
    inputSchema: {
      type: "object",
      properties: { order_id: { type: "string", description: "The order ID" } },
      required: ["order_id"]
    },
    // Berjalan di host worker: panggil apa pun yang dapat dijangkau sandbox.
    run: async ({ order_id }) => `Order ${order_id}: shipped`
  });

  const environmentKey = process.env.JUGLOW_ENVIRONMENT_KEY!;
  const environmentId = process.env.JUGLOW_ENVIRONMENT_ID!;
  const client = new Juglow({ authToken: environmentKey });
  const controller = new AbortController();
  process.once("SIGTERM", () => controller.abort());

  await new EnvironmentWorker({
    client,
    environmentId,
    environmentKey,
    workdir: "/workspace",
    signal: controller.signal,
    tools: (ctx) => [...betaAgentToolset20260401(ctx), getOrderStatus]
  }).run();

  // EnvironmentWorker saat ini belum tersedia di SDK C#.
  // Untuk menjawab panggilan alat kustom secara langsung, lihat aliran event sesi.

  package main

  import (
  	"context"
  	"log"
  	"os"
  	"os/signal"
  	"syscall"

  	"github.com/juglows/juglow-sdk-go"
  	"github.com/juglows/juglow-sdk-go/lib/environments"
  	"github.com/juglows/juglow-sdk-go/option"
  	"github.com/juglows/juglow-sdk-go/toolrunner"
  	"github.com/juglows/juglow-sdk-go/tools/agenttoolset"
  )

  type orderStatusInput struct {
  	OrderID string `json:"order_id"`
  }

  func main() {
  	environmentKey := os.Getenv("JUGLOW_ENVIRONMENT_KEY")
  	environmentID := os.Getenv("JUGLOW_ENVIRONMENT_ID")

  	ctx, stop := signal.NotifyContext(context.Background(), os.Interrupt, syscall.SIGTERM)
  	defer stop()

  	getOrderStatus := toolrunner.NewBetaTool(
  		"get_order_status",
  		"Look up an order in the internal fulfillment system by order ID.",
  		juglow.BetaToolInputSchemaParam{
  			Properties: map[string]any{
  				"order_id": map[string]any{"type": "string", "description": "The order ID"},
  			},
  			Required: []string{"order_id"},
  		},
  		// Berjalan di host worker: dapat memanggil apa pun yang bisa dijangkau sandbox.
  		func(ctx context.Context, input orderStatusInput) (juglow.BetaToolResultBlockParamContentUnion, error) {
  			return juglow.BetaToolResultBlockParamContentUnion{
  				OfText: &juglow.BetaTextBlockParam{Text: "Order " + input.OrderID + ": shipped"},
  			}, nil
  		},
  	)

  	client := juglow.NewClient(option.WithAuthToken(environmentKey))

  	worker := environments.NewEnvironmentWorker(client, environments.EnvironmentWorkerOptions{
  		EnvironmentID:  environmentID,
  		EnvironmentKey: environmentKey,
  		Workdir:        "/workspace",
  		ToolsFunc: func(env *agenttoolset.AgentToolContext) []juglow.BetaTool {
  			return append(agenttoolset.BetaAgentToolset20260401(env), getOrderStatus)
  		},
  	})
  	if err := worker.Run(ctx); err != nil {
  		log.Fatalf("worker: %v", err)
  	}
  }

  // EnvironmentWorker saat ini belum tersedia di Java SDK.
  // Untuk menjawab panggilan alat kustom secara langsung, lihat aliran event sesi.

  // EnvironmentWorker saat ini belum tersedia di PHP SDK.
  // Untuk menjawab panggilan alat kustom secara langsung, lihat event stream sesi.

  # EnvironmentWorker saat ini belum tersedia di Ruby SDK.
  # Untuk menjawab panggilan alat kustom secara langsung, lihat aliran event sesi.

  import asyncio
  from typing import Any, cast
  from juglow import AsyncJuglow
  from juglow.types.beta import BetaManagedAgentsCustomToolParams
  from mcp import ClientSession, types
  # Memerlukan mcp >= 1.24, yang mengganti nama streamablehttp_client menjadi streamable_http_client.
  from mcp.client.streamable_http import streamable_http_client

  MCP_SERVER_URL = "http://mcp.internal.example.com:8000/mcp"

  def to_custom_tool(tool: types.Tool) -> BetaManagedAgentsCustomToolParams:
      # Field MCP dipetakan satu-ke-satu ke deklarasi alat kustom. Cast ini
      # meneruskan dictionary skema ke parameter bertipe milik SDK tanpa perubahan.
      return {
          "type": "custom",
          "name": tool.name,
          "description": tool.description or tool.name,
          "input_schema": cast(Any, tool.inputSchema),
      }

  async def main() -> None:
      # Jalankan ini di tempat Anda membuat agen, bukan di host worker: skrip ini
      # melakukan autentikasi dengan kunci API Haijun Anda (JUGLOW_API_KEY).
      async with (
          streamable_http_client(MCP_SERVER_URL) as (read, write, _),
          ClientSession(read, write) as mcp_session,
          AsyncJuglow() as client,
      ):
          await mcp_session.initialize()
          listed = await mcp_session.list_tools()
          agent = await client.beta.agents.create(
              name="Internal tools agent",
              model="haijun-opus-5-5",
              tools=[
                  {"type": "agent_toolset_20260401"},
                  *[to_custom_tool(tool) for tool in listed.tools],
              ],
          )
          print(agent.id)

  asyncio.run(main())

  import Juglow from "@juglow-ai/sdk";
  import { Client } from "@modelcontextprotocol/sdk/client/index.js";
  import { StreamableHTTPClientTransport } from "@modelcontextprotocol/sdk/client/streamableHttp.js";

  const MCP_SERVER_URL = "http://mcp.internal.example.com:8000/mcp";

  // Jalankan ini di tempat Anda membuat agen, bukan di host worker: kode ini
  // melakukan autentikasi dengan kunci API Haijun Anda (JUGLOW_API_KEY).
  const client = new Juglow();

  const mcpClient = new Client({ name: "declare-agent-tools", version: "1.0.0" });
  await mcpClient.connect(new StreamableHTTPClientTransport(new URL(MCP_SERVER_URL)));
  const { tools } = await mcpClient.listTools();

  const agent = await client.beta.agents.create({
    name: "Internal tools agent",
    model: "haijun-opus-5-5",
    tools: [
      { type: "agent_toolset_20260401" },
      // Field MCP dipetakan satu-ke-satu ke deklarasi alat kustom.
      ...tools.map((tool) => ({
        type: "custom" as const,
        name: tool.name,
        description: tool.description || tool.name,
        input_schema: tool.inputSchema
      }))
    ]
  });
  console.log(agent.id);

  await mcpClient.close();

  // Lihat tab Python, TypeScript, dan Go. Mendeklarasikan alat kustom dari
  // C# bekerja dengan cara yang sama setelah Anda mencantumkan alat server dengan klien MCP.

  package main

  import (
  	"context"
  	"encoding/json"
  	"fmt"
  	"log"

  	"github.com/juglows/juglow-sdk-go"
  	mcpsdk "github.com/modelcontextprotocol/go-sdk/mcp"
  )

  const mcpServerURL = "http://mcp.internal.example.com:8000/mcp"

  // toCustomTool memetakan satu definisi alat MCP ke deklarasi alat kustom.
  // Field-nya dipetakan satu ke satu: parameter bertipe membawa `properties` dan
  // `required`, dan setiap kata kunci JSON Schema lain yang dikeluarkan server disalurkan di
  // ExtraFields sehingga skema yang dideklarasikan cocok dengan skema server.
  func toCustomTool(tool *mcpsdk.Tool) (juglow.BetaAgentNewParamsToolUnion, error) {
  	raw, err := json.Marshal(tool.InputSchema)
  	if err != nil {
  		return juglow.BetaAgentNewParamsToolUnion{}, err
  	}
  	var schema map[string]any
  	if err := json.Unmarshal(raw, &schema); err != nil {
  		return juglow.BetaAgentNewParamsToolUnion{}, err
  	}

  	inputSchema := juglow.BetaManagedAgentsCustomToolInputSchemaParam{ExtraFields: map[string]any{}}
  	for keyword, value := range schema {
  		switch keyword {
  		case "type":
  			// Tipe parameter selalu di-marshal sebagai "type": "object".
  		case "properties":
  			properties, _ := value.(map[string]any)
  			inputSchema.Properties = properties
  		case "required":
  			entries, _ := value.([]any)
  			for _, entry := range entries {
  				if name, isString := entry.(string); isString {
  					inputSchema.Required = append(inputSchema.Required, name)
  				}
  			}
  		default:
  			inputSchema.ExtraFields[keyword] = value
  		}
  	}

  	description := tool.Description
  	if description == "" {
  		description = tool.Name
  	}
  	return juglow.BetaAgentNewParamsToolUnion{
  		OfCustom: &juglow.BetaManagedAgentsCustomToolParams{
  			Type:        juglow.BetaManagedAgentsCustomToolParamsTypeCustom,
  			Name:        tool.Name,
  			Description: description,
  			InputSchema: inputSchema,
  		},
  	}, nil
  }

  func main() {
  	ctx := context.Background()

  	// Jalankan ini di mana pun Anda membuat agen, bukan di host worker: ini
  	// mengautentikasi dengan kunci API Haijun Anda (JUGLOW_API_KEY).
  	client := juglow.NewClient()

  	mcpClient := mcpsdk.NewClient(&mcpsdk.Implementation{Name: "declare-agent-tools", Version: "1.0.0"}, nil)
  	session, err := mcpClient.Connect(ctx, &mcpsdk.StreamableClientTransport{Endpoint: mcpServerURL}, nil)
  	if err != nil {
  		log.Fatalf("connect to MCP server: %v", err)
  	}
  	defer session.Close()

  	listed, err := session.ListTools(ctx, nil)
  	if err != nil {
  		log.Fatalf("list MCP tools: %v", err)
  	}

  	tools := []juglow.BetaAgentNewParamsToolUnion{
  		{OfAgentToolset20260401: &juglow.BetaManagedAgentsAgentToolset20260401Params{
  			Type: juglow.BetaManagedAgentsAgentToolset20260401ParamsTypeAgentToolset20260401,
  		}},
  	}
  	for _, tool := range listed.Tools {
  		custom, err := toCustomTool(tool)
  		if err != nil {
  			log.Fatalf("convert MCP tool %s: %v", tool.Name, err)
  		}
  		tools = append(tools, custom)
  	}

  	agent, err := client.Beta.Agents.New(ctx, juglow.BetaAgentNewParams{
  		Name:  "Internal tools agent",
  		Model: juglow.BetaManagedAgentsModelConfigParams{ID: juglow.BetaManagedAgentsModelHaijunOpus5_5},
  		Tools: tools,
  	})
  	if err != nil {
  		log.Fatalf("create agent: %v", err)
  	}
  	fmt.Println(agent.ID)
  }

  // Lihat tab Python, TypeScript, dan Go. Mendeklarasikan alat kustom dari
  // Java bekerja dengan cara yang sama setelah Anda mencantumkan alat server dengan klien MCP.

  // Lihat tab Python, TypeScript, dan Go. Mendeklarasikan alat kustom dari
  // PHP bekerja dengan cara yang sama setelah Anda mencantumkan alat server dengan klien MCP.

  # Lihat tab Python, TypeScript, dan Go. Mendeklarasikan alat kustom dari
  # Ruby bekerja dengan cara yang sama setelah Anda mendaftar alat server dengan klien MCP.

  import asyncio
  import os
  from datetime import timedelta
  from juglow import AsyncJuglow
  from juglow.lib.environments import EnvironmentWorker
  from juglow.lib.tools.agent_toolset import beta_agent_toolset_20260401
  from juglow.lib.tools.mcp import async_mcp_tool
  from mcp import ClientSession
  # Memerlukan mcp >= 1.24, yang mengganti nama streamablehttp_client menjadi streamable_http_client.
  from mcp.client.streamable_http import streamable_http_client

  MCP_SERVER_URL = "http://mcp.internal.example.com:8000/mcp"

  async def main() -> None:
      environment_key = os.environ["JUGLOW_ENVIRONMENT_KEY"]
      environment_id = os.environ["JUGLOW_ENVIRONMENT_ID"]
      # Hubungkan ke server MCP sekali saat startup dan biarkan sesi tetap terbuka selama
      # masa hidup worker. Timeout mengubah panggilan alat yang macet menjadi hasil
      # error alih-alih panggilan yang terhenti.
      async with (
          streamable_http_client(MCP_SERVER_URL) as (read, write, _),
          ClientSession(read, write, read_timeout_seconds=timedelta(seconds=60)) as mcp_session,
          AsyncJuglow(auth_token=environment_key) as client,
      ):
          await mcp_session.initialize()
          listed = await mcp_session.list_tools()
          mcp_tools = [async_mcp_tool(tool, mcp_session) for tool in listed.tools]
          await EnvironmentWorker(
              client,
              environment_id=environment_id,
              environment_key=environment_key,
              workdir="/workspace",
              tools=lambda env: [*beta_agent_toolset_20260401(env), *mcp_tools],
          ).run()

  asyncio.run(main())

  import Juglow from "@juglow-ai/sdk";
  import { EnvironmentWorker } from "@juglow-ai/sdk/helpers/beta/environments";
  import {
    mcpTools,
    type MCPCallToolResultLike,
    type MCPClientLike
  } from "@juglow-ai/sdk/helpers/beta/mcp";
  import { betaAgentToolset20260401 } from "@juglow-ai/sdk/tools/agent-toolset/node";
  import { Client } from "@modelcontextprotocol/sdk/client/index.js";
  import { StreamableHTTPClientTransport } from "@modelcontextprotocol/sdk/client/streamableHttp.js";

  const MCP_SERVER_URL = "http://mcp.internal.example.com:8000/mcp";

  const environmentKey = process.env.JUGLOW_ENVIRONMENT_KEY!;
  const environmentId = process.env.JUGLOW_ENVIRONMENT_ID!;
  const client = new Juglow({ authToken: environmentKey });
  const controller = new AbortController();
  process.once("SIGTERM", () => controller.abort());

  // Hubungkan ke server MCP sekali saat startup dan pertahankan koneksi tetap terbuka
  // selama worker berjalan.
  const mcpClient = new Client({ name: "sandbox-worker", version: "1.0.0" });
  await mcpClient.connect(new StreamableHTTPClientTransport(new URL(MCP_SERVER_URL)));
  const { tools } = await mcpClient.listTools();

  // Tipe kembalian callTool dari MCP SDK masih menyertakan bentuk hasil lawas yang
  // tidak diterima mcpTools; persempit tipenya. Hapus ini setelah MCPClientLike diperluas.
  const mcpClientForTools: MCPClientLike = {
    callTool: (params) => mcpClient.callTool(params) as Promise<MCPCallToolResultLike>
  };

  await new EnvironmentWorker({
    client,
    environmentId,
    environmentKey,
    workdir: "/workspace",
    signal: controller.signal,
    tools: (ctx) => [...betaAgentToolset20260401(ctx), ...mcpTools(tools, mcpClientForTools)]
  }).run();

  // EnvironmentWorker saat ini belum tersedia di SDK C#.

  package main

  import (
  	"context"
  	"log"
  	"os"
  	"os/signal"
  	"syscall"

  	"github.com/juglows/juglow-sdk-go"
  	"github.com/juglows/juglow-sdk-go/lib/environments"
  	"github.com/juglows/juglow-sdk-go/mcp"
  	"github.com/juglows/juglow-sdk-go/option"
  	"github.com/juglows/juglow-sdk-go/tools/agenttoolset"
  	mcpsdk "github.com/modelcontextprotocol/go-sdk/mcp"
  )

  const mcpServerURL = "http://mcp.internal.example.com:8000/mcp"

  func main() {
  	environmentKey := os.Getenv("JUGLOW_ENVIRONMENT_KEY")
  	environmentID := os.Getenv("JUGLOW_ENVIRONMENT_ID")

  	ctx, stop := signal.NotifyContext(context.Background(), os.Interrupt, syscall.SIGTERM)
  	defer stop()

  	client := juglow.NewClient(option.WithAuthToken(environmentKey))

  	// Hubungkan ke server MCP sekali saat startup dan biarkan sesi tetap terbuka selama
  	// worker berjalan.
  	mcpClient := mcpsdk.NewClient(&mcpsdk.Implementation{Name: "sandbox-worker", Version: "1.0.0"}, nil)
  	session, err := mcpClient.Connect(ctx, &mcpsdk.StreamableClientTransport{Endpoint: mcpServerURL}, nil)
  	if err != nil {
  		log.Fatalf("connect to MCP server: %v", err)
  	}
  	defer session.Close()

  	listed, err := session.ListTools(ctx, nil)
  	if err != nil {
  		log.Fatalf("list MCP tools: %v", err)
  	}
  	mcpTools, err := mcp.NewBetaTools(listed.Tools, session)
  	if err != nil {
  		log.Fatalf("convert MCP tools: %v", err)
  	}

  	worker := environments.NewEnvironmentWorker(client, environments.EnvironmentWorkerOptions{
  		EnvironmentID:  environmentID,
  		EnvironmentKey: environmentKey,
  		Workdir:        "/workspace",
  		ToolsFunc: func(env *agenttoolset.AgentToolContext) []juglow.BetaTool {
  			return append(agenttoolset.BetaAgentToolset20260401(env), mcpTools...)
  		},
  	})
  	if err := worker.Run(ctx); err != nil {
  		log.Fatalf("worker: %v", err)
  	}
  }

  // EnvironmentWorker saat ini belum tersedia di Java SDK.

  // EnvironmentWorker saat ini belum tersedia di PHP SDK.

  # EnvironmentWorker saat ini belum tersedia di Ruby SDK.

  curl -sS "https://haijun.my.id/v1/environments/$JUGLOW_ENVIRONMENT_ID/work/stats" \
    -H "x-api-key: $JUGLOW_API_KEY" \
    -H "juglow-beta: managed-agents-2026-04-01" \
    -H "juglow-version: 2023-06-01"

  ant beta:environments:work stats --environment-id "$JUGLOW_ENVIRONMENT_ID"

  import os

  import juglow

  client = juglow.Juglow()

  stats = client.beta.environments.work.stats(os.environ["JUGLOW_ENVIRONMENT_ID"])
  print(f"depth={stats.depth} pending={stats.pending}")

  import Juglow from "@juglow-ai/sdk";

  const client = new Juglow();

  const stats = await client.beta.environments.work.stats(process.env.JUGLOW_ENVIRONMENT_ID!);

  console.log(`depth=${stats.depth} pending=${stats.pending}`);

  using Juglow;

  var client = new JuglowClient();

  var environmentId = Environment.GetEnvironmentVariable("JUGLOW_ENVIRONMENT_ID")!;

  var stats = await client.Beta.Environments.Work.Stats(environmentId);

  Console.WriteLine($"depth={stats.Depth} pending={stats.Pending}");

  package main

  import (
  	"context"
  	"fmt"
  	"os"

  	"github.com/juglows/juglow-sdk-go"
  )

  func main() {
  	client := juglow.NewClient()
  	environmentID := os.Getenv("JUGLOW_ENVIRONMENT_ID")

  	stats, err := client.Beta.Environments.Work.Stats(
  		context.Background(),
  		environmentID,
  		juglow.BetaEnvironmentWorkStatsParams{},
  	)
  	if err != nil {
  		panic(err)
  	}

  	fmt.Printf("depth=%d pending=%d\n", stats.Depth, stats.Pending)
  }

  import com.juglow.client.JuglowClient;
  import com.juglow.client.okhttp.JuglowOkHttpClient;
  import com.juglow.models.beta.environments.work.BetaSelfHostedWorkQueueStats;

  void main() {
      JuglowClient client = JuglowOkHttpClient.fromEnv();

      BetaSelfHostedWorkQueueStats stats = client.beta()
          .environments()
          .work()
          .stats(System.getenv("JUGLOW_ENVIRONMENT_ID"));

      IO.println("depth=" + stats.depth() + " pending=" + stats.pending());
  }

  <?php

  use Juglow\Client;

  $client = new Client();

  $stats = $client->beta->environments->work->stats(getenv('JUGLOW_ENVIRONMENT_ID'));

  printf("depth=%d pending=%d\n", $stats->depth, $stats->pending);

  require "juglow"

  client = Juglow::Client.new

  stats = client.beta.environments.work.stats(ENV.fetch("JUGLOW_ENVIRONMENT_ID"))

  puts "depth=#{stats.depth} pending=#{stats.pending}"

{
  "type": "work_queue_stats",
  "depth": 0,
  "pending": 0,
  "oldest_queued_at": null,
  "workers_polling": 0
}

  curl -sS "https://haijun.my.id/v1/environments/$JUGLOW_ENVIRONMENT_ID/work/$JUGLOW_WORK_ID/stop" \
    -H "x-api-key: $JUGLOW_API_KEY" \
    -H "juglow-beta: managed-agents-2026-04-01" \
    -H "juglow-version: 2023-06-01" \
    -H "content-type: application/json" \
    -d '{}'

  ant beta:environments:work stop \
    --environment-id "$JUGLOW_ENVIRONMENT_ID" \
    --work-id "$JUGLOW_WORK_ID"

  import os

  import juglow

  client = juglow.Juglow()

  work = client.beta.environments.work.stop(
      os.environ["JUGLOW_WORK_ID"],
      environment_id=os.environ["JUGLOW_ENVIRONMENT_ID"],
  )
  print(work.state)

  import Juglow from "@juglow-ai/sdk";

  const client = new Juglow();

  const work = await client.beta.environments.work.stop(process.env.JUGLOW_WORK_ID!, {
    environment_id: process.env.JUGLOW_ENVIRONMENT_ID!
  });

  console.log(work.state);

  using Juglow;

  var client = new JuglowClient();

  var work = await client.Beta.Environments.Work.Stop(
      Environment.GetEnvironmentVariable("JUGLOW_WORK_ID")!,
      new()
      {
          EnvironmentID = Environment.GetEnvironmentVariable("JUGLOW_ENVIRONMENT_ID")!
      }
  );

  Console.WriteLine(work.State);

  package main

  import (
  	"context"
  	"fmt"
  	"os"

  	"github.com/juglows/juglow-sdk-go"
  )

  func main() {
  	client := juglow.NewClient()

  	work, err := client.Beta.Environments.Work.Stop(
  		context.Background(),
  		os.Getenv("JUGLOW_WORK_ID"),
  		juglow.BetaEnvironmentWorkStopParams{
  			EnvironmentID: os.Getenv("JUGLOW_ENVIRONMENT_ID"),
  		},
  	)
  	if err != nil {
  		panic(err)
  	}
  	fmt.Println(work.State)
  }

  import com.juglow.client.JuglowClient;
  import com.juglow.client.okhttp.JuglowOkHttpClient;
  import com.juglow.models.beta.environments.work.BetaSelfHostedWork;
  import com.juglow.models.beta.environments.work.BetaSelfHostedWorkStopRequest;
  import com.juglow.models.beta.environments.work.WorkStopParams;

  void main() {
      JuglowClient client = JuglowOkHttpClient.fromEnv();

      BetaSelfHostedWork work = client.beta().environments().work().stop(
          WorkStopParams.builder()
              .environmentId(System.getenv("JUGLOW_ENVIRONMENT_ID"))
              .workId(System.getenv("JUGLOW_WORK_ID"))
              .betaSelfHostedWorkStopRequest(BetaSelfHostedWorkStopRequest.builder().build())
              .build()
      );

      IO.println(work.state());
  }

  <?php

  use Juglow\Client;

  $client = new Client();

  $work = $client->beta->environments->work->stop(
      getenv('JUGLOW_WORK_ID'),
      environmentID: getenv('JUGLOW_ENVIRONMENT_ID'),
  );

  echo $work->state . "\n";

  require "juglow"

  client = Juglow::Client.new

  work = client.beta.environments.work.stop(
    ENV.fetch("JUGLOW_WORK_ID"),
    environment_id: ENV.fetch("JUGLOW_ENVIRONMENT_ID")
  )

  puts work.state