Agent Integration

import OpenAI from "openai";
import { DriftGateClient } from "@driftgate/sdk";
 
const openai = new OpenAI({ apiKey: process.env.OPENAI_API_KEY! });
const executionRouteId = process.env.DRIFTGATE_EXECUTION_ROUTE_ID!;
const driftgate = new DriftGateClient({
  sessionToken: process.env.DRIFTGATE_SESSION_TOKEN!,
  baseUrl: "https://api-staging.driftgate.ai"
});
 
const session = await driftgate.session.start({
  agent: "support-agent",
  executionRouteId
});
const execution = await session.execute({
  input: { prompt: "Summarize refund policy for order #123" },
  executionRouteId
});
 
if (!execution.ok || !execution.data) throw new Error(execution.error?.code ?? "INTERNAL");
 
const response = await openai.responses.create({
  model: "gpt-4.1-mini",
  input: [
    { role: "system", content: "Use the governance payload as ground truth." },
    { role: "user", content: JSON.stringify(execution.data) }
  ]
});
 
console.log(response.output_text);

import { DriftGateClient } from "@driftgate/sdk";
import { ChatOpenAI } from "@langchain/openai";
 
const dg = new DriftGateClient({ sessionToken: process.env.DRIFTGATE_SESSION_TOKEN! });
const llm = new ChatOpenAI({ model: "gpt-4.1-mini" });
const executionRouteId = process.env.DRIFTGATE_EXECUTION_ROUTE_ID!;
 
const session = await dg.session.start({
  agent: "claims-agent",
  executionRouteId
});
const gated = await session.execute({
  input: { claimId: "C-42" },
  executionRouteId
});
 
if (!gated.ok || !gated.data) throw new Error(gated.error?.code ?? "INTERNAL");
 
const answer = await llm.invoke([
  ["system", "Answer only with approved details from payload."],
  ["human", JSON.stringify(gated.data)]
]);
 
console.log(answer.content);

import os
 
from driftgate_sdk import DriftGateClient
from langgraph.graph import StateGraph
 
client = DriftGateClient(
    bearer_token=os.environ["DRIFTGATE_SESSION_TOKEN"],
    base_url="https://api-staging.driftgate.ai",
)
execution_route_id = os.environ["DRIFTGATE_EXECUTION_ROUTE_ID"]
 
def gate_node(state: dict) -> dict:
    session = client.session.start(
        agent="review-agent",
        execution_route_id=execution_route_id,
    )
    result = session.execute(
        input=state["input"],
        execution_route_id=execution_route_id,
    )
    if not result.ok or result.data is None:
        raise RuntimeError(result.error.code if result.error else "INTERNAL")
    state["driftgate"] = result.data
    return state
 
graph = StateGraph(dict)
graph.add_node("gate", gate_node)
graph.set_entry_point("gate")
app = graph.compile()
 
print(app.invoke({"input": {"ticket_id": "T-100"}}))

{
  "ok": true,
  "data": {
    "execution": {
      "id": "exec_123",
      "executionRouteId": "routev_123",
      "state": "queued"
    }
  },
  "meta": {
    "requestId": "req_123",
    "executionId": "exec_123",
    "timingMs": {
      "total": 128
    }
  },
  "error": null
}