bma-executor-sdk

go get github.com/beeos-ai/bma-executor-sdk@v1.3.0

npm install @beeos-ai/bma-executor-sdk@1.3.0

pip install bma-executor-sdk==1.3.0

client, err := bmaexecutor.NewClient(bmaexecutor.Options{
	BaseURL:        os.Getenv("BMA_BASE_URL"), // API origin, without a path
	EnvironmentKey: os.Getenv("BMA_ENVIRONMENT_KEY"),
	EnvironmentID:  os.Getenv("BMA_ENVIRONMENT_ID"),
	Executor:       bmaexecutor.ExecutorInfo{Name: "my-executor", OS: "linux", Arch: "arm64", Version: "0.1.0"},
})
if err != nil {
	log.Fatal(err)
}
// input: BashInput; only registered tools are advertised
client.Tools.Bash.Handle(func(ctx context.Context, in bmaexecutor.BashInput, tool bmaexecutor.ToolContext) (bmaexecutor.ToolOutput, error) {
	tool.Progress("running")
	r, err := run(ctx, in.Command, in.Cwd)
	if err != nil {
		return bmaexecutor.ToolOutput{}, err // outcome failed
	}
	return bmaexecutor.BashResult{Stdout: r.Stdout, Stderr: r.Stderr, ExitCode: r.Code}.Output(), nil
})
if _, err := client.Start(context.Background()); err != nil {
	log.Fatal(err)
}
select {}

import { ExecutorClient } from "@beeos-ai/bma-executor-sdk";

const client = new ExecutorClient({
  baseUrl: process.env.BMA_BASE_URL, // API origin, without a path
  environmentKey: process.env.BMA_ENVIRONMENT_KEY,
  environmentId: process.env.BMA_ENVIRONMENT_ID!,
  executor: { name: "my-executor", os: process.platform, arch: process.arch, version: "0.1.0" },
});
client.tools.bash.handle(async ({ command, cwd }, { signal, progress }) => { // input: BashInput; rendered as stdout, stderr, exit_code: N
  progress("running");
  const r = await run(command, { cwd, signal });
  return { stdout: r.stdout, stderr: r.stderr, exitCode: r.code };
});
await client.start();

import asyncio, os
from bma_executor_sdk import BashInput, BashResult, ExecutorClient, ToolContext

async def main() -> None:
    client = ExecutorClient(
        base_url=os.environ["BMA_BASE_URL"],  # API origin, without a path
        environment_key=os.environ["BMA_ENVIRONMENT_KEY"],
        environment_id=os.environ["BMA_ENVIRONMENT_ID"],
        executor={"name": "my-executor", "os": "linux", "arch": "arm64", "version": "0.1.0"},
    )

    @client.tools.bash.handler  # input: BashInput; only registered tools are advertised
    async def bash(input: BashInput, ctx: ToolContext) -> BashResult:
        ctx.progress("running")
        r = await run(input["command"], cwd=input.get("cwd"))
        return BashResult(stdout=r.stdout, stderr=r.stderr, exit_code=r.code)

    await client.start()
    await asyncio.Event().wait()

asyncio.run(main())

harness := bmaexecutor.NewHarness(bmaexecutor.HarnessOptions{
	Authenticate: authenticate, // nil only on loopback
})
go http.Serve(listener, harness)

executor, _ := harness.WaitExecutor(ctx)
session, _ := executor.AssignSession(ctx, bmaexecutor.SessionAssignParams{SessionID: "sess_1"})
_ = session.Ready(ctx)
result, _ := session.Tools.Bash.Call(ctx, bmaexecutor.BashInput{Command: "ls"}, bmaexecutor.CallToolOptions{})
_ = session.Stop(ctx, "done")

import { Harness } from "@beeos-ai/bma-executor-sdk";

const harness = new Harness({ authenticate: (request) => verify(request) }); // omit only on loopback
const { url } = await harness.listen();

const executor = await harness.waitExecutor();
const session = await executor.assignSession({ session_id: "sess_1" });
await session.ready();
const result = await session.tools.bash.call({ command: "ls" }); // or session.callTool("bash", { command: "ls" }, { toolCallId })
await session.stop("done");

from bma_executor_sdk import Harness

harness = Harness(authenticate=authenticate)  # omit only in-process or on a private socket
server = await harness.serve("127.0.0.1", 0)  # or await harness.serve_unix(path)

executor = await harness.wait_executor()
session = await executor.assign_session({"session_id": "ses_1"})
await session.ready()
result = await session.tools.bash.call({"command": "ls"})  # or session.call_tool("bash", {"command": "ls"}, tool_call_id=...)
await session.stop("done")

client.serveAgent(
  {
    openTurn: async (p) => ({ accepted: true, turn_id: p.turn_id, executor_session_ref: "conv_1", resumed: false, effective: {} }),
    runTurn: async (turn, signal) => {
      turn.emit({ type: "agent.message", content: [{ type: "text", text: "hello from my brain" }] });
    },
    closeSession: async () => {},
  },
  { models: [{ id: "my-model" }] },
);

client.ServeAgent(myAgent, bmaexecutor.AgentCapability{
	Models:          []bmaexecutor.AgentModel{{ID: "my-model", ThinkingLevels: []string{"low", "high"}}},
	PermissionModes: []string{"default", "accept_edits"},
})
// myAgent implements bmaexecutor.AgentHandler: OpenTurn, RunTurn, CloseSession.

client.serve_agent(handler, {"models": [{"id": "my-model"}]})
# handler implements async open_turn, run_turn and close_session;
# run_turn uses turn.emit, await turn.delta(...), turn.inputs and turn.request_interaction.