Making a request

# One dict, sent unchanged on every request.
request = dict(
    model=MODEL,
    max_output_tokens=4096,
    store=False,
    include=["reasoning.encrypted_content"],
    instructions=INSTRUCTIONS,
    tools=TOOLS,
    reasoning={"effort": REASONING_EFFORT},
    extra_body={"sid": {"tool_examples": TOOL_EXAMPLES, "reward": REWARD}},
    extra_headers={"x-session-affinity": session_id},
)

history = [{"role": "user", "content": QUESTION}]
response = client.responses.create(input=history, **request)

import { randomUUID } from "node:crypto";
import type { ResponseCreateParamsNonStreaming, ResponseInput } from "openai/resources/responses/responses";

const sessionId = randomUUID();
const request: Omit<ResponseCreateParamsNonStreaming, "input"> & { sid: object } = {
  model: MODEL,
  max_output_tokens: 4096,
  store: false,
  include: ["reasoning.encrypted_content"],
  instructions: INSTRUCTIONS,
  tools: TOOLS,
  reasoning: { effort: REASONING_EFFORT },
  sid: { tool_examples: TOOL_EXAMPLES, reward: REWARD },
};
const options = { headers: { "x-session-affinity": sessionId } };
const history: ResponseInput = [{ role: "user", content: QUESTION }];
let response = await client.responses.create({ ...request, input: history }, options);

import (
	"crypto/rand"

	"github.com/openai/openai-go/v3"
	"github.com/openai/openai-go/v3/option"
	"github.com/openai/openai-go/v3/responses"
	"github.com/openai/openai-go/v3/shared"
)

// One request, sent unchanged on every turn.
request := responses.ResponseNewParams{
	Model:           model,
	MaxOutputTokens: openai.Int(4096),
	Store:           openai.Bool(false),
	Include:         []responses.ResponseIncludable{responses.ResponseIncludableReasoningEncryptedContent},
	Instructions:    openai.String(instructions),
	Reasoning:       shared.ReasoningParam{Effort: reasoningEffort},
}
// The tools and the sid extension are plain JSON, set on the request body.
options := []option.RequestOption{
	option.WithJSONSet("tools", tools),
	option.WithJSONSet("sid", map[string]any{"tool_examples": toolExamples, "reward": reward}),
	option.WithHeader("x-session-affinity", rand.Text()), // a new session ID for every episode
}

history := responses.ResponseInputParam{
	responses.ResponseInputItemParamOfMessage(question, responses.EasyInputMessageRoleUser),
}
request.Input = responses.ResponseNewParamsInputUnion{OfInputItemList: history}
resp, err := client.Responses.New(ctx, request, options...)
if err != nil {
	log.Fatal(err)
}

history += [item.model_dump(mode="json", exclude_none=True) for item in response.output]
history += [
    {"type": "function_call_output", "call_id": call.call_id, "output": observation}
    for call, observation in zip(calls, observations)
]
history.append({"role": "user", "content": f"You have {remaining} turns remaining out of {MAX_TURNS} total."})

response = client.responses.create(input=history, **request)

history.push(...response.output as ResponseInput);
history.push(...calls.map((call, index) => ({
  type: "function_call_output" as const,
  call_id: call.call_id,
  output: observations[index],
})));
history.push({ role: "user", content: `You have ${remaining} turns remaining out of ${MAX_TURNS} total.` });

response = await client.responses.create({ ...request, input: history }, options);

var calls []responses.ResponseFunctionToolCall
for _, item := range resp.Output {
	// Verbatim, including the encrypted reasoning.
	history = append(history, param.Override[responses.ResponseInputItemUnionParam](json.RawMessage(item.RawJSON())))
	if item.Type == "function_call" {
		calls = append(calls, item.AsFunctionCall())
	}
}
// ... run the calls and render their observations ...
for i, call := range calls {
	output := responses.ResponseInputItemParamOfFunctionCallOutput(observations[i])
	output.OfFunctionCallOutput.CallID = openai.String(call.CallID)
	history = append(history, output)
}
history = append(history, responses.ResponseInputItemParamOfMessage(
	fmt.Sprintf("You have %d turns remaining out of %d total.", remaining, maxTurns),
	responses.EasyInputMessageRoleUser,
))

request.Input = responses.ResponseNewParamsInputUnion{OfInputItemList: history}
resp, err = client.Responses.New(ctx, request, options...)

TOOL_EXAMPLES = [
    {
        "caption": "Use the semantic search tool with a long, descriptive query:",
        "name": "search",
        "arguments": {
            "query": "what makes SID's approach to retrieval different from standard search pipelines?",
            "limit": 5,
        },
    },
    {
        "caption": "Use the keyword search tool to find documents containing specific words:",
        "name": "text_search",
        "arguments": {"query": "SID AI retrieval posttraining", "limit": 5},
    },
    ...
]

const TOOL_EXAMPLES = [
  {
    caption: "Use the semantic search tool with a long, descriptive query:",
    name: "search",
    arguments: {
      query: "what makes SID's approach to retrieval different from standard search pipelines?",
      limit: 5,
    },
  },
  {
    caption: "Use the keyword search tool to find documents containing specific words:",
    name: "text_search",
    arguments: { query: "SID AI retrieval posttraining", limit: 5 },
  },
  // Add an example for each remaining tool.
];

var toolExamples = []map[string]any{
	{
		"caption": "Use the semantic search tool with a long, descriptive query:",
		"name":    "search",
		"arguments": map[string]any{
			"query": "what makes SID's approach to retrieval different from standard search pipelines?",
			"limit": 5,
		},
	},
	{
		"caption":   "Use the keyword search tool to find documents containing specific words:",
		"name":      "text_search",
		"arguments": map[string]any{"query": "SID AI retrieval posttraining", "limit": 5},
	},
	// Add an example for each remaining tool.
}

x-ratelimit-limit: 5
x-ratelimit-remaining: 4
x-ratelimit-scope: model:sid-2
retry-after: 1                     # on a 429 only