bma-sdk

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

npm install @beeos-ai/bma-sdk@0.4.2

pip install bma-sdk==0.4.1   # 0.4.2 is tagged but not yet on PyPI

client, err := bmarest.New(bmarest.Options{
	BaseURL: os.Getenv("BMA_BASE_URL") + "/api/v1",
	Token:   os.Getenv("BMA_API_KEY"),
})

import { BmaClient, unwrap } from "@beeos-ai/bma-sdk";

const bma = new BmaClient({ baseUrl: `${process.env.BMA_BASE_URL}/api/v1`, token: process.env.BMA_API_KEY! });

import os
from bma_sdk import BmaClient, unwrap

bma = BmaClient(os.environ["BMA_API_KEY"], os.environ["BMA_BASE_URL"] + "/api/v1")

created, err := client.CreateAgentSessionWithResponse(ctx, org, project, agentID,
	bmarest.CreateAgentSessionJSONRequestBody{IdempotencyKey: ptr("task-1")})
if err != nil {
	log.Fatal(err)
}
if err := bmarest.CheckResponse(created.HTTPResponse, created.Body); err != nil {
	log.Fatal(err)
}
sessionID := created.JSON201.Session.Id

sent, err := client.CreateAgentInputWithResponse(ctx, org, project, agentID,
	&bmarest.CreateAgentInputParams{SessionId: &sessionID},
	bmarest.CreateAgentInputJSONRequestBody{
		ContentBlocks: []bmarest.CreateAgentInputContentBlock{bmarest.NewTextInputBlock("Start the task.")},
	})
if err != nil {
	log.Fatal(err)
}
if err := bmarest.CheckResponse(sent.HTTPResponse, sent.Body); err != nil {
	log.Fatal(err)
}

stream, err := client.OpenEventStream(ctx, org, project, agentID,
	&bmarest.StreamEventsParams{SessionId: &sessionID, StreamDeltas: ptr(true)})
if err != nil {
	log.Fatal(err)
}
defer stream.Close()
for {
	frame, err := stream.Next()
	if errors.Is(err, io.EOF) {
		break
	}
	if err != nil {
		log.Fatal(err)
	}
	if frame.AgentEvent != nil {
		kind, _ := frame.AgentEvent.Discriminator()
		log.Printf("event %s sequence %d", kind, frame.Sequence)
	}
}

// func ptr[T any](v T) *T { return &v }

const path = { orgID, projectID, agentID };

const { session } = unwrap(
  await bma.rest.POST("/orgs/{orgID}/projects/{projectID}/agents/{agentID}/sessions", {
    params: { path },
    body: { idempotency_key: "task-1" },
  }),
);
unwrap(
  await bma.rest.POST("/orgs/{orgID}/projects/{projectID}/agents/{agentID}/inputs", {
    params: { path, query: { session_id: session.id } },
    body: { content_blocks: [{ type: "text", text: "Start the task." }] },
  }),
);
for await (const frame of bma.streamEvents({ ...path, sessionId: session.id, streamDeltas: true })) {
  console.log(frame.event, frame.sequence);
}

from bma_sdk.rest.api.agents import create_agent_input, create_agent_session
from bma_sdk.rest.models import CreateAgentInputRequest, CreateAgentSessionRequest, TextContentBlock

with bma:
    session = unwrap(create_agent_session.sync_detailed(
        org, project, agent_id, client=bma.rest,
        body=CreateAgentSessionRequest(idempotency_key="task-1"),
    )).session
    unwrap(create_agent_input.sync_detailed(
        org, project, agent_id, client=bma.rest, session_id=session.id,
        body=CreateAgentInputRequest(content_blocks=[TextContentBlock(type_="text", text="Start the task.")]),
    ))
    for frame in bma.stream_events(org, project, agent_id, session_id=session.id, stream_deltas=True):
        print(frame.event, frame.sequence)

ext, err := facadeext.New(facadeext.Options{
	BaseURL:   os.Getenv("BMA_BASE_URL"),
	APIKey:    os.Getenv("BMA_API_KEY"),
	ProjectID: os.Getenv("BMA_PROJECT_ID"),
})
if err != nil {
	log.Fatal(err)
}
file, err := ext.UploadSessionFile(ctx, sessionID, "report.pdf", reader)
page, err := ext.ListSessionFiles(ctx, sessionID, 100, "")

import { FacadeExtensionsClient, bmaSequence } from "@beeos-ai/bma-sdk/facade-extensions";

const ext = new FacadeExtensionsClient({
  baseUrl: process.env.BMA_BASE_URL!,
  apiKey: process.env.BMA_API_KEY!,
  projectId: process.env.BMA_PROJECT_ID,
});
const file = await ext.uploadSessionFile(sessionId, new Blob([bytes]), "report.pdf");
const page = await ext.listSessionFiles(sessionId, { limit: 100 });
const ticket = await ext.getSessionDesktopStream(sessionId, { desktopSessionId, origin: location.origin });

from bma_sdk.facade_extensions import FacadeExtensionsClient, bma_sequence

with FacadeExtensionsClient(api_key, base_url, project_id=project_id) as ext:
    file = ext.upload_session_file(session_id, "report.pdf", data)
    page = ext.list_session_files(session_id, limit=100)
    ticket = ext.get_session_desktop_stream(session_id, desktop_session_id=desktop_id)