Struct GraphsClient 

pub struct GraphsClient<'a> { /* private fields */ }

Graphs API client.

Use this for graph completions and verifier inference.

Implementations

impl<'a> GraphsClient<'a>

pub async fn complete( &self, request: GraphCompletionRequest, ) -> Result<GraphCompletionResponse, CoreError>

Execute a graph completion.

Arguments

• request - The graph completion request

Returns

The graph output.

Example

let response = client.graphs().complete(GraphCompletionRequest {
    job_id: "my-graph".into(),
    input: json!({"prompt": "Hello"}),
    model: None,
    stream: None,
}).await?;

pub async fn list_graphs( &self, kind: Option<&str>, limit: Option<i32>, ) -> Result<Value, CoreError>

List graphs registered to the org.

pub async fn complete_raw(&self, request: Value) -> Result<Value, CoreError>

Execute a raw graph completion from a JSON value.

pub async fn verify( &self, trace: Value, rubric: Value, options: Option<VerifierOptions>, ) -> Result<VerifierResponse, CoreError>

Run verifier inference on a trace.

This evaluates a trace against a rubric using the verifier graph.

Arguments

• trace - The trace to verify (JSON object with events)
• rubric - The rubric to evaluate against
• options - Optional verifier configuration

Returns

The verification result with scores and reviews.

Example

let result = client.graphs().verify(
    json!({
        "events": [
            {"type": "user_message", "content": "Hello"},
            {"type": "assistant_message", "content": "Hi there!"}
        ]
    }),
    json!({
        "objectives": [
            {"name": "helpfulness", "description": "Be helpful"}
        ]
    }),
    None,
).await?;
println!("Objectives: {:?}", result.objectives);

pub async fn rlm_inference( &self, query: &str, context: Value, options: Option<RlmOptions>, ) -> Result<Value, CoreError>

Run RLM (Retrieval-augmented LM) inference.

This is useful for large context scenarios where the full trace doesn’t fit in a single context window.

Arguments

• query - The query/question to answer
• context - The context to search through
• options - Optional RLM configuration

Returns

The RLM output as a JSON value.

pub async fn policy_inference( &self, job_id: &str, input: Value, model: Option<&str>, ) -> Result<Value, CoreError>

Execute a policy/prompt from a job.

This runs inference using a trained policy from a completed optimization job.

Arguments

• job_id - The optimization job ID
• input - The input to the policy
• model - Optional model override

Returns

The policy output.