Responses

curl -X POST https://api.modelrelay.ai/api/v1/responses \
  -H "Authorization: Bearer mr_sk_..." \
  -H "Content-Type: application/json" \
  -d '{
    "model": "claude-sonnet-4-20250514",
    "input": [
      {
        "type": "message",
        "role": "user",
        "content": [{"type": "text", "text": "What is 2 + 2?"}]
      }
    ]
  }'

import { ModelRelay } from "@modelrelay/sdk";

const mr = ModelRelay.fromSecretKey(process.env.MODELRELAY_SECRET_KEY!);

const response = await mr.responses.create({
  model: "claude-sonnet-4-20250514",
  input: [
    {
      type: "message",
      role: "user",
      content: [{ type: "text", text: "What is 2 + 2?" }],
    },
  ],
});

console.log(response.output);

response, err := client.Responses.Create(ctx, sdk.ResponseRequest{
    Model: "claude-sonnet-4-20250514",
    Input: []sdk.InputItem{
        {
            Type: "message",
            Role: "user",
            Content: []sdk.ContentPart{
                {Type: "text", Text: "What is 2 + 2?"},
            },
        },
    },
})
if err != nil {
    return err
}

fmt.Println(response.Output)

let response = client.responses().create(ResponseRequest {
    model: Some("claude-sonnet-4-20250514".to_string()),
    input: vec![
        InputItem {
            r#type: "message".to_string(),
            role: Some("user".to_string()),
            content: Some(vec![
                ContentPart { r#type: "text".to_string(), text: Some("What is 2 + 2?".to_string()) }
            ]),
            ..Default::default()
        }
    ],
    ..Default::default()
}).await?;

println!("{:?}", response.output);

curl -X POST https://api.modelrelay.ai/api/v1/responses \
  -H "Authorization: Bearer mr_sk_..." \
  -H "Content-Type: application/json" \
  -d '{
    "model": "claude-sonnet-4-20250514",
    "input": [
      {
        "type": "message",
        "role": "user",
        "content": [{"type": "text", "text": "Extract: John is 30 years old"}]
      }
    ],
    "output_format": {
      "type": "json_schema",
      "json_schema": {
        "name": "person",
        "schema": {
          "type": "object",
          "properties": {
            "name": {"type": "string"},
            "age": {"type": "integer"}
          },
          "required": ["name", "age"]
        }
      }
    }
  }'

const response = await mr.responses.create({
  model: "claude-sonnet-4-20250514",
  input: [
    {
      type: "message",
      role: "user",
      content: [{ type: "text", text: "Extract: John is 30 years old" }],
    },
  ],
  output_format: {
    type: "json_schema",
    json_schema: {
      name: "person",
      schema: {
        type: "object",
        properties: {
          name: { type: "string" },
          age: { type: "integer" },
        },
        required: ["name", "age"],
      },
    },
  },
});

response, err := client.Responses.Create(ctx, sdk.ResponseRequest{
    Model: "claude-sonnet-4-20250514",
    Input: []sdk.InputItem{
        {
            Type: "message",
            Role: "user",
            Content: []sdk.ContentPart{
                {Type: "text", Text: "Extract: John is 30 years old"},
            },
        },
    },
    OutputFormat: &sdk.OutputFormat{
        Type: "json_schema",
        JSONSchema: &sdk.JSONSchemaFormat{
            Name: "person",
            Schema: map[string]any{
                "type": "object",
                "properties": map[string]any{
                    "name": map[string]any{"type": "string"},
                    "age":  map[string]any{"type": "integer"},
                },
                "required": []string{"name", "age"},
            },
        },
    },
})

use serde_json::json;

let response = client.responses().create(ResponseRequest {
    model: Some("claude-sonnet-4-20250514".to_string()),
    input: vec![
        InputItem {
            r#type: "message".to_string(),
            role: Some("user".to_string()),
            content: Some(vec![
                ContentPart { r#type: "text".to_string(), text: Some("Extract: John is 30 years old".to_string()) }
            ]),
            ..Default::default()
        }
    ],
    output_format: Some(OutputFormat {
        r#type: "json_schema".to_string(),
        json_schema: Some(JsonSchemaFormat {
            name: "person".to_string(),
            schema: Some(json!({
                "type": "object",
                "properties": {
                    "name": {"type": "string"},
                    "age": {"type": "integer"}
                },
                "required": ["name", "age"]
            })),
            ..Default::default()
        }),
    }),
    ..Default::default()
}).await?;

curl -X POST https://api.modelrelay.ai/api/v1/responses \
  -H "Authorization: Bearer mr_sk_..." \
  -H "Content-Type: application/json" \
  -d '{
    "model": "claude-sonnet-4-20250514",
    "input": [
      {
        "type": "message",
        "role": "user",
        "content": [{"type": "text", "text": "What is the weather in London?"}]
      }
    ],
    "tools": [
      {
        "type": "function",
        "function": {
          "name": "get_weather",
          "description": "Get current weather for a location",
          "parameters": {
            "type": "object",
            "properties": {
              "location": {"type": "string"}
            },
            "required": ["location"]
          }
        }
      }
    ]
  }'

const response = await mr.responses.create({
  model: "claude-sonnet-4-20250514",
  input: [
    {
      type: "message",
      role: "user",
      content: [{ type: "text", text: "What is the weather in London?" }],
    },
  ],
  tools: [
    {
      type: "function",
      function: {
        name: "get_weather",
        description: "Get current weather for a location",
        parameters: {
          type: "object",
          properties: {
            location: { type: "string" },
          },
          required: ["location"],
        },
      },
    },
  ],
});

// Check for tool calls
for (const output of response.output) {
  if (output.tool_calls) {
    for (const call of output.tool_calls) {
      console.log(`Tool: ${call.function?.name}`);
      console.log(`Args: ${call.function?.arguments}`);
    }
  }
}

const stream = await mr.responses.stream({
  model: "claude-sonnet-4-20250514",
  input: [
    {
      type: "message",
      role: "user",
      content: [{ type: "text", text: "Tell me a story" }],
    },
  ],
});

for await (const event of stream) {
  if (event.type === "update" && event.delta) {
    process.stdout.write(event.delta);
  }
}

stream, err := client.Responses.Stream(ctx, sdk.ResponseRequest{
    Model: "claude-sonnet-4-20250514",
    Input: []sdk.InputItem{
        {
            Type: "message",
            Role: "user",
            Content: []sdk.ContentPart{
                {Type: "text", Text: "Tell me a story"},
            },
        },
    },
})
if err != nil {
    return err
}
defer stream.Close()

for event := range stream.Events() {
    if event.Type == "update" && event.Delta != "" {
        fmt.Print(event.Delta)
    }
}

use futures_util::StreamExt;

let mut stream = client.responses().stream(ResponseRequest {
    model: Some("claude-sonnet-4-20250514".to_string()),
    input: vec![
        InputItem {
            r#type: "message".to_string(),
            role: Some("user".to_string()),
            content: Some(vec![
                ContentPart { r#type: "text".to_string(), text: Some("Tell me a story".to_string()) }
            ]),
            ..Default::default()
        }
    ],
    ..Default::default()
}).await?;

while let Some(event) = stream.next().await {
    let event = event?;
    if event.r#type == "update" {
        if let Some(delta) = &event.delta {
            print!("{}", delta);
        }
    }
}