Run tasks from your backend

import { IntrospectionClient } from "@introspection-sdk/introspection-node";
import { IntrospectionLogs } from "@introspection-sdk/introspection-node/otel";
 
const credentials = {
  clientId: process.env.INTROSPECTION_SERVICE_ACCOUNT_CLIENT_ID!,
  clientSecret: process.env.INTROSPECTION_SERVICE_ACCOUNT_CLIENT_SECRET!,
  project: process.env.INTROSPECTION_PROJECT!,
};
 
const client = await IntrospectionClient.fromServiceAccount(credentials);
const outcomes = new IntrospectionLogs({ token: process.env.INTROSPECTION_API_KEY, serviceName: "refund-app" }); // an API key: this client keeps one token for life
 
const runner = await client.runtimes("refund-agent").run({
  identity: { user_id: session.user.id },
});

client = IntrospectionClient.from_service_account(
    client_id=os.environ["INTROSPECTION_SERVICE_ACCOUNT_CLIENT_ID"],
    client_secret=os.environ[
        "INTROSPECTION_SERVICE_ACCOUNT_CLIENT_SECRET"
    ],
    project=os.environ["INTROSPECTION_PROJECT"],
)
# An API key: this logger keeps one token for life.
outcomes = IntrospectionLogs(
    token=os.environ["INTROSPECTION_API_KEY"], service_name="refund-app"
)
 
runner = client.runtimes(runtime).run(identity={"user_id": user_id})

let credentials = ServiceAccountTokenParams::builder()
    .client_id(std::env::var("INTROSPECTION_SERVICE_ACCOUNT_CLIENT_ID")?)
    .client_secret(std::env::var(
        "INTROSPECTION_SERVICE_ACCOUNT_CLIENT_SECRET",
    )?)
    .project(std::env::var("INTROSPECTION_PROJECT")?)
    .build()?;
 
let client = IntrospectionClient::from_service_account(credentials, None).await?;
// An API key: this client keeps one token for life.
let outcomes = IntrospectionLogs::builder()
    .token(std::env::var("INTROSPECTION_API_KEY")?)
    .service_name("refund-app")
    .build()?;
 
let runner = client
    .runtime("refund-agent")
    .await?
    .run(RunRequest {
        identity: Some(RunnerIdentity {
            user_id: Some(user_id.clone()),
            ..Default::default()
        }),
        ..Default::default()
    })
    .await?;

let env = ProcessInfo.processInfo.environment
let client = try await IntrospectionClient.fromServiceAccount(
    clientId: env["INTROSPECTION_SERVICE_ACCOUNT_CLIENT_ID"]!,
    clientSecret: env["INTROSPECTION_SERVICE_ACCOUNT_CLIENT_SECRET"]!,
    project: env["INTROSPECTION_PROJECT"]!
)
 
let runner = try await client.runtimes("refund-agent").run(identity: RunnerIdentity(userId: user.id))

// Your app's code: the order store and the push to the browser.
const bindings = new Map<string, { taskId: string; userId: string }>();
const orders = {
  async saveAgentBinding(orderId: string, binding: { taskId: string; userId: string }) {
    bindings.set(orderId, binding);
  },
};
async function sendEventToBrowser(event: { type: string }) {
  console.log(`[${event.type}]`);
}
 
const handle = await runner.tasks.start({
  prompt: "Review order 1842 against the refund policy and draft the next response.",
  metadata: { order_id: "1842" },
});
await orders.saveAgentBinding(order.id, { taskId: handle.run.task_id, userId: session.user.id });
 
for await (const event of handle.stream()) {
  await sendEventToBrowser(event);
}

# Your app's code: store which task works on which order.
def save_agent_binding(
    order_id: str, *, task_id: str, user_id: str
) -> None:
    print(f"  saved task {task_id} for order {order_id} ({user_id})")
 
# Your app's code: push the event over server-sent events or a WebSocket.
def send_event_to_browser(event: AGUIEvent) -> None:
    print(f"  -> browser: {event.type}")
 
handle = runner.tasks.start(
    prompt="Review order 1842 against the refund policy and draft the next response.",
    metadata={"order_id": "1842"},
)
save_agent_binding(
    order_id, task_id=str(handle.run.task_id), user_id=user_id
)
 
for event in handle.stream():
    send_event_to_browser(event)

// Your app's code: store the task next to the order and forward events to the browser.
struct AgentBinding {
    task_id: String,
    user_id: String,
}
async fn save_agent_binding(order_id: &str, binding: &AgentBinding) {
    println!(
        "order {order_id} -> task {} (user {})",
        binding.task_id, binding.user_id
    );
}
async fn send_event_to_browser(event: AgUiEvent) {
    println!("{event:?}");
}
 
let handle = runner
    .tasks()
    .start(&TaskCreate {
        prompt: Some(
            "Review order 1842 against the refund policy and draft the next response."
                .into(),
        ),
        metadata: Some(HashMap::from([("order_id".into(), "1842".into())])),
        ..Default::default()
    })
    .await?;
let binding = AgentBinding {
    task_id: handle.run.task_id.to_string(),
    user_id: user_id.clone(),
};
save_agent_binding(order_id, &binding).await;
 
let stream = handle.stream().await?;
tokio::pin!(stream);
while let Some(event) = stream.next().await {
    send_event_to_browser(event?).await;
}

// Your app's code: remember which task belongs to the order, and forward events to the browser.
func saveAgentBinding(orderId: String, taskId: String, userId: String) async throws {}
func sendEventToBrowser(_ event: AGUIEvent) async throws {}
 
let handle = try await runner.tasks.start(
    prompt: "Review order 1842 against the refund policy and draft the next response.",
    TaskCreate(metadata: ["order_id": "1842"])
)
try await saveAgentBinding(orderId: "1842", taskId: handle.run.taskId, userId: user.id)
 
for try await event in handle.stream() {
    try await sendEventToBrowser(event)
}

// Your app's code: push the event to the browser.
async function sendEventToBrowser(event: { type: string }) {
  console.log(`[${event.type}]`);
}
 
const task = await runner.tasks.get(binding.taskId);
const runId = (task.metadata?.active_run_id ?? task.metadata?.latest_run_id) as string;
for await (const event of runner.tasks.runs.stream(binding.taskId, runId)) {
  await sendEventToBrowser(event);
}

# Your app's code: push the event over server-sent events or a WebSocket.
def send_event_to_browser(event: AGUIEvent) -> None:
    print(f"  -> browser: {event.type}")
 
task = runner.tasks.get(binding.task_id)
metadata = task.metadata or {}
run_id = metadata.get("active_run_id") or metadata["latest_run_id"]
for event in runner.tasks.runs.stream(binding.task_id, run_id):
    send_event_to_browser(event)

// Your app's code: forward each event to the browser.
async fn send_event_to_browser(event: AgUiEvent) {
    println!("{event:?}");
}
 
let task = runner.tasks().get(task_id).await?;
let metadata = task.metadata.unwrap_or_default();
let run_id = metadata
    .get("active_run_id")
    .or_else(|| metadata.get("latest_run_id"))
    .and_then(|id| id.as_str())
    .ok_or("task has no run")?;
let stream = runner.tasks().runs.stream(task_id, run_id).await?;
tokio::pin!(stream);
while let Some(event) = stream.next().await {
    send_event_to_browser(event?).await;
}

// Your app's code: forward one event to the browser, for example over server-sent events.
func sendEventToBrowser(_ event: AGUIEvent) async throws {}
 
let task = try await runner.tasks.get(binding.taskId)
let runId = task.metadata?["active_run_id"]?.stringValue ?? task.metadata?["latest_run_id"]?.stringValue
guard let runId else { return }
 
for try await event in runner.tasks.runs.stream(binding.taskId, runId) {
    try await sendEventToBrowser(event)
}

const latest = await runner.tasks.get(binding.taskId);
outcomes.feedback("thumbs_down", {
  conversationId: binding.taskId,
  previousResponseId: (latest.metadata?.last_response as { response_id?: string } | undefined)?.response_id,
  comments: "Missed the final-sale rule",
});
await outcomes.flush();

task = runner.tasks.get(binding.task_id)
last_response = (task.metadata or {}).get("last_response") or {}
outcomes.feedback(
    "thumbs_down",
    conversation_id=binding.task_id,
    previous_response_id=last_response.get("response_id"),
    comments="Missed the final-sale rule",
)
outcomes.flush()

let task = runner.tasks().get(task_id).await?;
let response_id = task
    .metadata
    .as_ref()
    .and_then(|m| m.get("last_response"))
    .and_then(|r| r["response_id"].as_str());
let mut options = FeedbackOptions::new()
    .with_conversation_id(task_id)
    .with_comments("Missed the final-sale rule");
if let Some(id) = response_id {
    options = options.with_previous_response_id(id);
}
outcomes.feedback("thumbs_down", options);
outcomes.flush()?;

// An API key: this client keeps one token for life.
let outcomes = try IntrospectionLogs(
    token: ProcessInfo.processInfo.environment["INTROSPECTION_API_KEY"], serviceName: "refund-app"
)
 
let task = try await runner.tasks.get(binding.taskId)
outcomes.feedback(
    "thumbs_down",
    comments: "Missed the final-sale rule",
    conversationId: task.conversationId,
    previousResponseId: task.metadata?["last_response"]?["response_id"]?.stringValue
)
await outcomes.flush()