bma-executor-sdk

go get github.com/beeos-ai/bma-executor-sdk@v0.4.9

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

pip install bma-executor-sdk==0.4.8   # 0.4.9 is tagged but not yet on PyPI

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)
}
client.OnToolCall(func(ctx context.Context, call bmaexecutor.ToolCallParams) (bmaexecutor.ToolResultParams, error) {
	return bmaexecutor.ToolResultParams{
		SessionID:  call.SessionID,
		ToolCallID: call.ToolCallID,
		Outcome:    bmaexecutor.ToolOutcomeSucceeded,
		Content:    []bmaexecutor.ContentBlock{{Type: bmaexecutor.ContentBlockTypeText, Text: "ok"}},
	}, 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" },
  capabilities: { shell: { enabled: true } },
});
client.handleTool("bash", async (call, { signal, progress }) => {
  progress("running");
  return { outcome: "succeeded", is_error: false, content: [{ type: "text", text: "ok" }] };
});
await client.start();

import asyncio, os
from bma_executor_sdk import ExecutorClient

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"},
    )

    async def on_tool_call(call):
        return {"session_id": call["session_id"], "tool_call_id": call["tool_call_id"],
                "outcome": "succeeded", "is_error": False,
                "content": [{"type": "text", "text": "ok"}]}

    client.on_tool_call(on_tool_call)
    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.CallTool(ctx, bmaexecutor.ToolCallParams{
	Tool: bmaexecutor.ToolNameBash, Input: bmaexecutor.NewToolInput(bmaexecutor.ToolInput{Command: "ls"}),
})
_ = 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.callTool({ tool: "bash", input: { command: "ls" } });
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.call_tool({"tool": "bash", "input": {"command": "ls"}})
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.