From 720ac433465ffb5e4a4ca0514f364e67d9eee8fd Mon Sep 17 00:00:00 2001 From: Sawyer Date: Fri, 30 Oct 2026 15:50:40 -0700 Subject: [PATCH 1/7] Add OpenAI Responses provider adapter Responses streams end on a semantic event while the socket stays open, which the harness reads as a hang. Stop after an adapter-reported terminal chunk instead. --- packages/inference/src/adapter.ts | 11 + packages/inference/src/harness.test.ts | 65 + packages/inference/src/harness.ts | 32 + packages/inference/src/index.ts | 1 + .../inference/src/providers/index.test.ts | 2 + packages/inference/src/providers/index.ts | 9 + .../src/providers/openai-responses.test.ts | 1009 ++++++++++++ .../src/providers/openai-responses.ts | 1399 +++++++++++++++++ packages/inference/src/providers/openai.ts | 34 +- packages/types/src/catalog.test.ts | 2 +- packages/types/src/catalog.ts | 2 + 11 files changed, 2555 insertions(+), 11 deletions(-) create mode 100644 packages/inference/src/providers/openai-responses.test.ts create mode 100644 packages/inference/src/providers/openai-responses.ts diff --git a/packages/inference/src/adapter.ts b/packages/inference/src/adapter.ts index 04c9efc52..7a21fb455 100644 --- a/packages/inference/src/adapter.ts +++ b/packages/inference/src/adapter.ts @@ -72,12 +72,23 @@ export type RetryAfterExtractor = (headers: Headers) => number | undefined; // wait before the next request, or undefined if no pacing is needed. export type PacingExtractor = (headers: Headers) => number | undefined; +// Reports whether one SSE data payload is the stream's semantic terminal +// event. Streams whose protocol ends on `[DONE]` or a socket close leave +// this absent and behave exactly as before; a present predicate lets the +// harness stop after a terminal chunk (e.g. a Responses +// `response.completed`) even when the server holds the connection open. +// The predicate sees only raw payload strings and never throws for +// malformed input — a payload that fails to parse reports "not terminal" +// and defers to `parseResponse` as the single error site. +export type StreamTerminalPredicate = (sseData: string) => boolean; + export type ProviderAdapter = { buildRequest: RequestBuilder; parseResponse: ResponseParser; parseJSONResponse: JSONResponseParser; extractRetryAfterMs?: RetryAfterExtractor; extractPacingDelayMs?: PacingExtractor; + isStreamTerminal?: StreamTerminalPredicate; }; // Builds a fresh adapter for one inference call. Invoked per call so the diff --git a/packages/inference/src/harness.test.ts b/packages/inference/src/harness.test.ts index 085b58d1a..48215b1ac 100644 --- a/packages/inference/src/harness.test.ts +++ b/packages/inference/src/harness.test.ts @@ -7,6 +7,7 @@ import { type Dependencies, type InferenceHarnessOptions, } from "./harness"; +import { ProtocolMismatchError } from "./errors"; import { createBuiltinRegistry, createDefaultDependencies, @@ -911,3 +912,67 @@ describe("runInference — non-streaming JSON responses", () => { expect(errorEvent.data.error.message).toContain("text/plain"); }); }); + +describe("runInference — response body release", () => { + const RELEASE_SOURCE: InferenceSource = { + id: "test-release:model-x", + provider: "test-release", + baseURL: "https://example.test", + credentialId: "test", + model: "model-x", + }; + + test("cancels a held-open body when parseResponse throws", async () => { + let cancelled = 0; + const stream = new ReadableStream({ + start(controller) { + controller.enqueue(new TextEncoder().encode("data: boom\n\n")); + // Never closed: the server holds the connection open past the + // terminal failure envelope, the case that pins the socket when + // the body is never released. + }, + cancel() { + cancelled += 1; + }, + }); + const throwingFactory: AdapterFactory = () => ({ + buildRequest: () => ({ + url: "https://example.test/v1/stream", + headers: {}, + body: "{}", + }), + parseResponse: () => { + // ProtocolMismatchError, like the real failure-envelope throws, + // is never retried: single attempt, deterministic test. + throw new ProtocolMismatchError("test-release: failure envelope", { + type: "response.failed", + }); + }, + parseJSONResponse: () => [], + }); + const deps: Dependencies = { + fetch: () => + Promise.resolve( + new Response(stream, { + status: 200, + headers: { "content-type": "text/event-stream" }, + }), + ), + scheduler: createDefaultScheduler(), + adapters: createAdapterRegistry({ "test-release": throwingFactory }), + }; + + let seq = 0; + const events = await collect( + runInference({ + turns: [userTurn("hi")], + source: RELEASE_SOURCE, + nextSeq: () => ++seq, + deps, + }), + ); + + expect(events.some((e) => e.type === "inference.error")).toBe(true); + expect(cancelled).toBeGreaterThanOrEqual(1); + }); +}); diff --git a/packages/inference/src/harness.ts b/packages/inference/src/harness.ts index e345a4c90..ba7b22b4f 100644 --- a/packages/inference/src/harness.ts +++ b/packages/inference/src/harness.ts @@ -375,6 +375,9 @@ async function* runSingleAttempt( const timeoutAbort = new AbortController(); let timeoutReason: "inactivity" | "total" | null = null; let cancelInactivity: (() => void) | null = null; + // The live response body, when one has been received. Released by the + // attempt `finally` so no exit path leaves a held-open socket pinned. + let openBody: ReadableStream | null = null; const armInactivity = () => { cancelInactivity?.(); cancelInactivity = scheduler.setTimeout(() => { @@ -508,7 +511,11 @@ async function* runSingleAttempt( // Captured as a const so the non-null narrowing from the guard above // carries into the SSE branch of the event-source generator below (a // bare `response.body` re-widens to nullable across the closure). + // Also assigned to the outer slot so the attempt `finally` releases + // the socket on every exit path, including a `parseResponse` throw on + // a terminal failure envelope while the server holds the connection. const responseBody = response.body; + openBody = responseBody; let responseKind: ResponseKind; try { @@ -552,11 +559,29 @@ async function* runSingleAttempt( yield adapter.parseJSONResponse(body); return; } + // The attempt `finally` releases the body only when the loop below + // stops early — on a semantic terminal chunk or a `parseResponse` + // throw — while the server holds the connection open. A drained loop + // clears the slot first, since the server already closed the socket; + // adapters without the predicate keep their `[DONE]`/close behavior + // byte-for-byte, and the predicate is never consulted for them. + let stoppedEarly = false; for await (const sseData of parseSSE(responseBody)) { // Reset inactivity timer — we just got something from the wire. armInactivity(); yield adapter.parseResponse(sseData); + if (adapter.isStreamTerminal?.(sseData) === true) { + // The protocol ended on a semantic terminal event while the + // server holds the connection open (a Responses + // `response.completed` with no `[DONE]` or close to follow). + // The batch above is already queued for the accumulator, so + // stopping here processes the terminal chunk's events — + // including usage — through the normal completion path below. + stoppedEarly = true; + break; + } } + if (!stoppedEarly) openBody = null; }; try { @@ -1328,6 +1353,13 @@ async function* runSingleAttempt( // finally). Both cleanups are idempotent. cleanupTimers(); cleanupSignal(); + // Release a held-open socket: a terminal chunk can arrive while the + // server keeps the connection open, and a `parseResponse` throw exits + // before the stream is drained. The slot is already clear when the + // stream drained naturally, so this only fires on early exits. + // Cancel is idempotent and safe on an already-cancelled body. + await openBody?.cancel().catch(() => undefined); + openBody = null; } } diff --git a/packages/inference/src/index.ts b/packages/inference/src/index.ts index 2f6deabcb..a894f9a2d 100644 --- a/packages/inference/src/index.ts +++ b/packages/inference/src/index.ts @@ -19,6 +19,7 @@ export type { BuiltRequest, AdapterRegistry, AdapterFactory, + StreamTerminalPredicate, } from "./adapter"; export { CREDENTIAL_SENTINEL, BEARER_CREDENTIAL_SENTINEL } from "./auth"; export { diff --git a/packages/inference/src/providers/index.test.ts b/packages/inference/src/providers/index.test.ts index 0ce776e71..951ffb256 100644 --- a/packages/inference/src/providers/index.test.ts +++ b/packages/inference/src/providers/index.test.ts @@ -10,6 +10,8 @@ const builtinProviders = [ "openai", "openai-compatible", "google-genai", + "openai-responses", + "openai-compatible-responses", ]; function createSource(provider: string): LastCycleSource { diff --git a/packages/inference/src/providers/index.ts b/packages/inference/src/providers/index.ts index e2e5a0dbb..d658f9714 100644 --- a/packages/inference/src/providers/index.ts +++ b/packages/inference/src/providers/index.ts @@ -7,6 +7,7 @@ import type { AdapterManifest } from "@intx/types"; import { createAnthropicAdapter } from "./anthropic"; import { createGoogleGenAIAdapter } from "./google-genai"; import { createOpenAIAdapter } from "./openai"; +import { createOpenAIResponsesAdapter } from "./openai-responses"; export { createAnthropicAdapter, @@ -16,6 +17,12 @@ export { } from "./anthropic"; export { createGoogleGenAIAdapter, GoogleGenAIQuirks } from "./google-genai"; export { createOpenAIAdapter, OpenAIQuirks } from "./openai"; +export { + createOpenAIResponsesAdapter, + ResponsesQuirks, + OPENAI_RESPONSES_PROVIDER, + OPENAI_COMPATIBLE_RESPONSES_PROVIDER, +} from "./openai-responses"; function builtinFactories(): Record { return { @@ -23,6 +30,8 @@ function builtinFactories(): Record { openai: createOpenAIAdapter, "openai-compatible": createOpenAIAdapter, "google-genai": createGoogleGenAIAdapter, + "openai-responses": createOpenAIResponsesAdapter, + "openai-compatible-responses": createOpenAIResponsesAdapter, }; } diff --git a/packages/inference/src/providers/openai-responses.test.ts b/packages/inference/src/providers/openai-responses.test.ts new file mode 100644 index 000000000..d6b32aeb7 --- /dev/null +++ b/packages/inference/src/providers/openai-responses.test.ts @@ -0,0 +1,1009 @@ +import { describe, test, expect } from "bun:test"; +import type { + ConversationTurn, + InferenceEvent, + InferenceOptions, + LastCycleSource, +} from "@intx/types/runtime"; + +import { + createDefaultScheduler, + runInference, + type Dependencies, +} from "../harness"; +import { createBuiltinRegistry } from "./index"; +import { + createOpenAIResponsesAdapter, + isResponsesStreamTerminal, + OPENAI_COMPATIBLE_RESPONSES_PROVIDER, + OPENAI_RESPONSES_PROVIDER, + tagSignature, +} from "./openai-responses"; + +function createSource( + provider: string = OPENAI_RESPONSES_PROVIDER, +): LastCycleSource { + return { sourceId: "src-1", provider, model: "gpt-5-mini" }; +} + +function userTurn(text: string): ConversationTurn { + return { role: "user", content: [{ type: "text", text }], timestamp: 0 }; +} + +function requestBodyOf( + turns: ConversationTurn[], + model: string, + options: InferenceOptions, + quirks?: unknown, + provider: string = OPENAI_RESPONSES_PROVIDER, +): Record { + const adapter = createOpenAIResponsesAdapter(createSource(provider), quirks); + const built = adapter.buildRequest(turns, model, options); + return parsedBody(built); +} + +async function collect( + iter: AsyncIterable, +): Promise { + const out: InferenceEvent[] = []; + for await (const ev of iter) out.push(ev); + return out; +} + +function isRecord(value: unknown): value is Record { + return typeof value === "object" && value !== null && !Array.isArray(value); +} + +function requestInput(body: Record): unknown[] { + const input = body["input"]; + if (!Array.isArray(input)) throw new Error("expected input to be an array"); + return input; +} + +function parsedBody(built: { body: string }): Record { + const parsed: unknown = JSON.parse(built.body); + if (!isRecord(parsed)) + throw new Error("expected request body to be a record"); + return parsed; +} + +describe("openai-responses quirks", () => { + test("absent quirks resolve to protocol-native defaults", () => { + const adapter = createOpenAIResponsesAdapter(createSource(), undefined); + const built = adapter.buildRequest([userTurn("hi")], "gpt-5-mini", {}); + expect(built.url).toBe("/responses"); + expect(built.headers["accept"]).toBe("text/event-stream"); + const body = parsedBody(built); + expect(body["store"]).toBe(false); + expect(body["stream"]).toBe(true); + expect(body).not.toHaveProperty("parallel_tool_calls"); + expect(body).not.toHaveProperty("temperature"); + expect(body).not.toHaveProperty("max_output_tokens"); + expect(body).not.toHaveProperty("reasoning"); + }); + + test("unknown quirk keys fail loudly", () => { + expect(() => + createOpenAIResponsesAdapter(createSource(), { + strom: true, + }), + ).toThrow(/invalid quirks/); + }); + + test("quirks must not set authorization", () => { + expect(() => + createOpenAIResponsesAdapter(createSource(), { + headers: { static: { Authorization: "x" } }, + }), + ).toThrow(/must not set authorization/); + }); + + test("unknown quirk keys fail loudly", () => { + for (const quirks of [ + { sessionIdOption: "sid" }, + { sessionIdHeader: "X-Session" }, + { headers: { modelHeader: "X-Model" } }, + { parallelToolCalls: false }, + { instructions: "be brief" }, + { reasoning: { effortOption: "effort" } }, + ]) { + expect(() => + createOpenAIResponsesAdapter(createSource(), quirks), + ).toThrow(/invalid quirks/); + } + }); + + test("header names are lowercased and static headers override stock", () => { + const adapter = createOpenAIResponsesAdapter(createSource(), { + headers: { static: { "X-Custom": "1", "Content-Type": "custom" } }, + }); + const built = adapter.buildRequest([userTurn("hi")], "gpt-5-mini", {}); + expect(built.headers["x-custom"]).toBe("1"); + expect(built.headers["content-type"]).toBe("custom"); + }); + + test("path quirk lands on the request", () => { + const adapter = createOpenAIResponsesAdapter(createSource(), { + path: "/v1/responses", + }); + expect(adapter.buildRequest([userTurn("hi")], "gpt-5-mini", {}).url).toBe( + "/v1/responses", + ); + }); +}); + +describe("openai-responses buildRequest", () => { + test("system prompt rides as a leading system message by default", () => { + const body = requestBodyOf([userTurn("hi")], "gpt-5-mini", { + systemPrompt: "sys", + }); + const input = requestInput(body); + expect(input[0]).toEqual({ + type: "message", + role: "system", + content: "sys", + }); + }); + + test("function tools are flat with auto tool_choice", () => { + const body = requestBodyOf([userTurn("hi")], "gpt-5-mini", { + tools: [ + { + name: "run_shell", + description: "run", + inputSchema: { type: "object" }, + }, + ], + }); + expect(body["tools"]).toEqual([ + { + type: "function", + name: "run_shell", + description: "run", + parameters: { type: "object" }, + }, + ]); + expect(body["tool_choice"]).toBe("auto"); + }); + + test("assistant text uses output_text, user text uses input_text", () => { + const body = requestBodyOf( + [ + { role: "user", content: [{ type: "text", text: "q" }], timestamp: 0 }, + { + role: "assistant", + content: [{ type: "text", text: "a" }], + model: "gpt-5-mini", + timestamp: 1, + }, + ], + "gpt-5-mini", + {}, + ); + const input = requestInput(body); + expect(input[0]).toEqual({ + type: "message", + role: "user", + content: [{ type: "input_text", text: "q" }], + }); + expect(input[1]).toEqual({ + type: "message", + role: "assistant", + content: [{ type: "output_text", text: "a" }], + }); + }); + + test("flat contentShape collapses text-only turns to strings", () => { + const body = requestBodyOf( + [userTurn("hi")], + "gpt-5-mini", + { systemPrompt: "sys" }, + { contentShape: "flat" }, + ); + const input = requestInput(body); + expect(input[0]).toEqual({ + type: "message", + role: "system", + content: "sys", + }); + expect(input[1]).toEqual({ + type: "message", + role: "user", + content: "hi", + }); + }); + + test("tool_call and tool_result become function_call items", () => { + const body = requestBodyOf( + [ + { + role: "assistant", + content: [ + { + type: "tool_call", + id: "call-1", + name: "run_shell", + arguments: { cmd: "ls" }, + }, + ], + model: "gpt-5-mini", + timestamp: 1, + }, + { + role: "user", + content: [ + { + type: "tool_result", + callId: "call-1", + content: [{ type: "text", text: "ok" }], + }, + ], + timestamp: 2, + }, + ], + "gpt-5-mini", + {}, + ); + const input = requestInput(body); + expect(input).toContainEqual({ + type: "function_call", + name: "run_shell", + arguments: JSON.stringify({ cmd: "ls" }), + call_id: "call-1", + }); + expect(input).toContainEqual({ + type: "function_call_output", + call_id: "call-1", + output: "ok", + }); + }); + + test("duplicate tool items keep the last occurrence", () => { + const body = requestBodyOf( + [ + { + role: "assistant", + content: [ + { + type: "tool_call", + id: "call-1", + name: "a", + arguments: { v: 1 }, + }, + ], + model: "gpt-5-mini", + timestamp: 1, + }, + { + role: "assistant", + content: [ + { + type: "tool_call", + id: "call-1", + name: "a", + arguments: { v: 2 }, + }, + ], + model: "gpt-5-mini", + timestamp: 2, + }, + ], + "gpt-5-mini", + {}, + ); + const input = requestInput(body); + const calls = input.filter( + (item) => isRecord(item) && item["type"] === "function_call", + ); + expect(calls).toHaveLength(1); + const call = calls[0]; + if (!isRecord(call)) throw new Error("expected function_call item"); + expect(call["arguments"]).toBe(JSON.stringify({ v: 2 })); + }); + + test("thinking replays only for matching provider and model", () => { + const thinkingTurn: ConversationTurn = { + role: "assistant", + content: [ + { + type: "thinking", + thinking: "hmm", + signature: tagSignature(OPENAI_RESPONSES_PROVIDER, "cipher"), + }, + ], + model: "gpt-5-mini", + timestamp: 1, + }; + const replayed = requestBodyOf( + [thinkingTurn], + "gpt-5-mini", + {}, + undefined, + OPENAI_RESPONSES_PROVIDER, + ); + const replayInput = requestInput(replayed); + expect(replayInput).toContainEqual({ + type: "reasoning", + summary: [], + encrypted_content: "cipher", + }); + + const otherProvider = requestBodyOf( + [thinkingTurn], + "gpt-5-mini", + {}, + undefined, + "openai-compatible-responses", + ); + expect( + requestInput(otherProvider).some( + (item) => isRecord(item) && item["type"] === "reasoning", + ), + ).toBe(false); + + const otherModel = requestBodyOf( + [thinkingTurn], + "gpt-5-other", + {}, + undefined, + OPENAI_RESPONSES_PROVIDER, + ); + expect( + requestInput(otherModel).some( + (item) => isRecord(item) && item["type"] === "reasoning", + ), + ).toBe(false); + }); + + test("untagged signatures are never replayed", () => { + const body = requestBodyOf( + [ + { + role: "assistant", + content: [{ type: "thinking", thinking: "hmm", signature: "raw" }], + model: "gpt-5-mini", + timestamp: 1, + }, + ], + "gpt-5-mini", + {}, + ); + expect(body["input"]).toEqual([]); + }); + + test("image and pdf inputs map to Responses parts", () => { + const body = requestBodyOf( + [ + { + role: "user", + content: [ + { + type: "image", + source: { + kind: "base64", + mimeType: "image/png", + data: "AAA", + }, + }, + { + type: "document", + source: { + kind: "base64", + mimeType: "application/pdf", + data: "BBB", + }, + }, + ], + timestamp: 0, + }, + ], + "gpt-5-mini", + {}, + ); + const input = requestInput(body); + expect(input[0]).toEqual({ + type: "message", + role: "user", + content: [ + { type: "input_image", image_url: "data:image/png;base64,AAA" }, + { + type: "input_file", + filename: "document.pdf", + file_data: "data:application/pdf;base64,BBB", + }, + ], + }); + }); + + test("url documents and audio blocks throw", () => { + expect(() => + requestBodyOf( + [ + { + role: "user", + content: [ + { + type: "document", + source: { + kind: "url", + mimeType: "application/pdf", + url: "https://x/y.pdf", + }, + }, + ], + timestamp: 0, + }, + ], + "gpt-5-mini", + {}, + ), + ).toThrow(/input_file does not accept url/); + expect(() => + requestBodyOf( + [ + { + role: "user", + content: [ + { + type: "audio", + source: { kind: "base64", mimeType: "audio/mp3", data: "A" }, + }, + ], + timestamp: 0, + }, + ], + "gpt-5-mini", + {}, + ), + ).toThrow(/does not yet handle audio/); + }); + + test("fromOption headers, maxTokens, and temperature land", () => { + const adapter = createOpenAIResponsesAdapter(createSource(), { + headers: { + fromOption: [{ optionKey: "uid", header: "X-User" }], + }, + }); + const built = adapter.buildRequest([userTurn("hi")], "gpt-5-mini", { + maxTokens: 10, + temperature: 0.5, + providerOptions: { uid: "u-1" }, + }); + const body = parsedBody(built); + expect(built.headers["x-user"]).toBe("u-1"); + expect(body["max_output_tokens"]).toBe(10); + expect(body["temperature"]).toBe(0.5); + }); + + test("maxOutputTokens and temperature opt out when false", () => { + const body = requestBodyOf( + [userTurn("hi")], + "gpt-5-mini", + { + maxTokens: 10, + temperature: 0.5, + }, + { + maxOutputTokens: false, + temperature: false, + }, + ); + expect(body).not.toHaveProperty("max_output_tokens"); + expect(body).not.toHaveProperty("temperature"); + }); + + test("reasoning effort passes through and max maps via maxEffort", () => { + const low = requestBodyOf([userTurn("hi")], "m", { effort: "low" }); + expect(low["reasoning"]).toEqual({ effort: "low" }); + const maxed = requestBodyOf( + [userTurn("hi")], + "m", + { effort: "max" }, + { + reasoning: { maxEffort: "xhigh" }, + }, + ); + expect(maxed).toMatchObject({ reasoning: { effort: "xhigh" } }); + }); +}); + +describe("openai-responses parseResponse", () => { + function parse( + payloads: Record[], + provider: string = OPENAI_RESPONSES_PROVIDER, + ): InferenceEvent[] { + const adapter = createOpenAIResponsesAdapter(createSource(provider)); + const out: InferenceEvent[] = []; + for (const p of payloads) { + out.push(...adapter.parseResponse(JSON.stringify(p))); + } + return out; + } + + test("text deltas carry per-item block indices", () => { + const events = parse([ + { type: "response.output_text.delta", item_id: "m1", delta: "Hello" }, + { type: "response.output_text.delta", item_id: "m1", delta: " world" }, + ]); + expect(events.map((e) => e.type)).toEqual([ + "inference.text.delta", + "inference.text.delta", + ]); + for (const e of events) { + if (e.type !== "inference.text.delta") throw new Error("mistyped"); + expect(e.data.index).toBe(0); + } + expect(events[0]?.type).toBe("inference.text.delta"); + }); + + test("reasoning deltas register thinking blocks and capture signatures", () => { + const events = parse([ + { + type: "response.output_item.added", + item: { type: "reasoning", id: "r1" }, + }, + { type: "response.reasoning_text.delta", item_id: "r1", delta: "think" }, + { + type: "response.output_item.done", + item: { type: "reasoning", id: "r1", encrypted_content: "blob" }, + }, + ]); + const thinking = events.filter( + (e) => e.type === "inference.thinking.delta", + ); + expect(thinking).toHaveLength(2); + const sig = events.find((e) => e.type === "inference.block.signature"); + if (sig?.type !== "inference.block.signature") { + throw new Error("missing signature"); + } + expect(sig.data.signature).toBe( + tagSignature(OPENAI_RESPONSES_PROVIDER, "blob"), + ); + }); + + test("tool call round trip emits start and delta", () => { + const events = parse([ + { + type: "response.output_item.added", + item: { + type: "function_call", + id: "fc1", + call_id: "call-1", + name: "run_shell", + }, + }, + { + type: "response.function_call_arguments.delta", + item_id: "fc1", + delta: '{"cmd"', + }, + { + type: "response.function_call_arguments.delta", + item_id: "fc1", + delta: ':"ls"}', + }, + ]); + expect(events.map((e) => e.type)).toEqual([ + "inference.tool_call.start", + "inference.tool_call.delta", + "inference.tool_call.delta", + ]); + }); + + test("orphan argument delta throws protocol mismatch", () => { + const adapter = createOpenAIResponsesAdapter(createSource()); + expect(() => + adapter.parseResponse( + JSON.stringify({ + type: "response.function_call_arguments.delta", + item_id: "ghost", + delta: "{}", + }), + ), + ).toThrow(/never announced by output_item.added/); + }); + + test("malformed JSON throws protocol mismatch", () => { + const adapter = createOpenAIResponsesAdapter(createSource()); + expect(() => adapter.parseResponse("{not json")).toThrow( + /malformed JSON in SSE data payload/, + ); + }); + + test("response.failed and error envelopes throw", () => { + const adapter = createOpenAIResponsesAdapter(createSource()); + expect(() => + adapter.parseResponse( + JSON.stringify({ + type: "response.failed", + response: { error: { message: "boom" } }, + }), + ), + ).toThrow(/boom/); + expect(() => + adapter.parseResponse(JSON.stringify({ type: "error", message: "bad" })), + ).toThrow(/bad/); + }); + + test("unknown and lifecycle envelopes are ignored", () => { + expect( + parse([ + { type: "response.created", response: { id: "r" } }, + { type: "response.future.envelope", anything: 1 }, + ]), + ).toEqual([]); + }); + + test("completed usage splits cached and write tokens", () => { + const events = parse([ + { + type: "response.completed", + response: { + usage: { + input_tokens: 100, + output_tokens: 20, + input_tokens_details: { + cached_tokens: 30, + cache_write_tokens: 10, + }, + output_tokens_details: { reasoning_tokens: 5 }, + }, + }, + }, + ]); + expect(events).toHaveLength(1); + const usage = events[0]; + if (usage?.type !== "inference.usage") throw new Error("mistyped"); + expect(usage.data.usage).toEqual({ + input: 60, + output: 20, + cacheRead: 30, + cacheWrite: 10, + thinking: 5, + }); + }); + + test("response.done shares the completed usage handling", () => { + const events = parse([ + { + type: "response.done", + response: { usage: { input_tokens: 4, output_tokens: 2 } }, + }, + ]); + expect(events).toHaveLength(1); + const usage = events[0]; + if (usage?.type !== "inference.usage") throw new Error("mistyped"); + expect(usage.data.usage).toMatchObject({ input: 4, output: 2 }); + }); + + test("incomplete reports usage like a completed turn", () => { + const events = parse([ + { + type: "response.incomplete", + response: { + incomplete_details: { reason: "max_output_tokens" }, + usage: { input_tokens: 4, output_tokens: 2 }, + }, + }, + ]); + expect(events).toHaveLength(1); + expect(events[0]?.type).toBe("inference.usage"); + }); + + test("incomplete with a content_filter reason emits a safety rating", () => { + const events = parse([ + { + type: "response.incomplete", + response: { + incomplete_details: { reason: "content_filter" }, + usage: { input_tokens: 4, output_tokens: 2 }, + }, + }, + ]); + expect(events.map((e) => e.type)).toEqual([ + "inference.safety_rating", + "inference.usage", + ]); + const rating = events[0]; + if (rating?.type !== "inference.safety_rating") throw new Error("mistyped"); + expect(rating.data.safetyRating).toMatchObject({ + blockReason: "content_filter", + }); + }); +}); + +describe("isResponsesStreamTerminal", () => { + test("terminal events stop the stream", () => { + for (const t of [ + "response.completed", + "response.incomplete", + "response.done", + ]) { + expect(isResponsesStreamTerminal(JSON.stringify({ type: t }))).toBe(true); + } + }); + + test("non-terminal chunks keep the stream open", () => { + expect( + isResponsesStreamTerminal( + JSON.stringify({ + type: "response.output_text.delta", + item_id: "m", + delta: "hi", + }), + ), + ).toBe(false); + expect( + isResponsesStreamTerminal(JSON.stringify({ type: "response.created" })), + ).toBe(false); + }); + + test("malformed payloads report not terminal", () => { + expect(isResponsesStreamTerminal("{not json")).toBe(false); + expect(isResponsesStreamTerminal(JSON.stringify({ nope: 1 }))).toBe(false); + }); +}); + +describe("openai-responses parseJSONResponse", () => { + function parseJson( + body: unknown, + provider: string = OPENAI_RESPONSES_PROVIDER, + ): InferenceEvent[] { + const adapter = createOpenAIResponsesAdapter(createSource(provider)); + return adapter.parseJSONResponse(JSON.stringify(body)); + } + + test("buffered body emits text, reasoning, tool, and usage events", () => { + const events = parseJson({ + output: [ + { + type: "message", + content: [{ type: "output_text", text: "hello" }], + }, + { + type: "reasoning", + id: "r1", + summary: [{ type: "summary_text", text: "thought" }], + encrypted_content: "blob", + }, + { + type: "function_call", + id: "fc1", + call_id: "call-1", + name: "run_shell", + arguments: '{"cmd":"ls"}', + }, + ], + usage: { input_tokens: 10, output_tokens: 5 }, + }); + expect(events.map((e) => e.type)).toEqual([ + "inference.text.delta", + "inference.thinking.delta", + "inference.block.signature", + "inference.tool_call.start", + "inference.tool_call.delta", + "inference.usage", + ]); + const usage = events.at(-1); + if (usage?.type !== "inference.usage") throw new Error("mistyped"); + expect(usage.data.usage).toMatchObject({ input: 10, output: 5 }); + }); + + test("failed status throws instead of decoding an empty turn", () => { + expect(() => + parseJson({ status: "failed", output: [], error: { message: "nope" } }), + ).toThrow(/status is "failed"/); + }); + + test("buffered incomplete with a content_filter reason emits a safety rating", () => { + const events = parseJson({ + status: "incomplete", + output: [ + { + type: "message", + content: [{ type: "output_text", text: "partial" }], + }, + ], + incomplete_details: { reason: "content_filter" }, + usage: { input_tokens: 1, output_tokens: 1 }, + }); + expect(events.map((e) => e.type)).toEqual([ + "inference.text.delta", + "inference.safety_rating", + "inference.usage", + ]); + }); + + test("malformed body throws protocol mismatch", () => { + const adapter = createOpenAIResponsesAdapter(createSource()); + expect(() => adapter.parseJSONResponse("{bad")).toThrow( + /malformed JSON response body/, + ); + }); +}); + +describe("openai-responses per-source quirks", () => { + const quirks = { + path: "/v1/responses", + headers: { + static: { "x-client": "test" }, + }, + reasoning: { summary: "detailed" }, + } as const; + + test("per-source quirks shape the request", () => { + const adapter = createOpenAIResponsesAdapter(createSource(), quirks); + const built = adapter.buildRequest([userTurn("hi")], "m", {}); + expect(built.url).toBe("/v1/responses"); + expect(built.headers["x-client"]).toBe("test"); + expect(parsedBody(built)["reasoning"]).toEqual({ summary: "detailed" }); + }); + + test("per-request block indices do not leak across requests", () => { + const adapter = createOpenAIResponsesAdapter(createSource(), quirks); + const first = adapter.parseResponse( + JSON.stringify({ + type: "response.output_text.delta", + item_id: "m1", + delta: "a", + }), + ); + adapter.buildRequest([userTurn("next")], "m", {}); + const second = adapter.parseResponse( + JSON.stringify({ + type: "response.output_text.delta", + item_id: "m1", + delta: "b", + }), + ); + if ( + first[0]?.type !== "inference.text.delta" || + second[0]?.type !== "inference.text.delta" + ) { + throw new Error("mistyped"); + } + expect(first[0].data.index).toBe(0); + expect(second[0].data.index).toBe(0); + }); +}); + +describe("openai-responses registration", () => { + test("both provider ids resolve to the shared Responses factory", () => { + const registry = createBuiltinRegistry(); + expect(registry.has(OPENAI_RESPONSES_PROVIDER)).toBe(true); + expect(registry.has(OPENAI_COMPATIBLE_RESPONSES_PROVIDER)).toBe(true); + for (const provider of [ + OPENAI_RESPONSES_PROVIDER, + OPENAI_COMPATIBLE_RESPONSES_PROVIDER, + ]) { + const adapter = registry.resolve(createSource(provider)); + expect(typeof adapter.buildRequest).toBe("function"); + expect(typeof adapter.isStreamTerminal).toBe("function"); + } + }); + + test("chat completions adapters carry no terminal predicate", async () => { + const { createOpenAIAdapter } = await import("./openai"); + expect( + createOpenAIAdapter(createSource("openai")).isStreamTerminal, + ).toBeUndefined(); + }); +}); + +describe("runInference with a held-open Responses stream", () => { + test("response.completed ends the call with usage preserved", async () => { + const frames = [ + { type: "response.output_text.delta", item_id: "m1", delta: "Hello" }, + { type: "response.output_text.delta", item_id: "m1", delta: " world" }, + { + type: "response.completed", + response: { usage: { input_tokens: 10, output_tokens: 5 } }, + }, + ]; + const sseBody = (): ReadableStream => { + const enc = new TextEncoder(); + return new ReadableStream({ + start(controller) { + for (const f of frames) { + controller.enqueue(enc.encode(`data: ${JSON.stringify(f)}\n\n`)); + } + // Held open: no [DONE], no close. + }, + }); + }; + const deps: Dependencies = { + fetch: () => + Promise.resolve( + new Response(sseBody(), { + status: 200, + headers: { "content-type": "text/event-stream" }, + }), + ), + scheduler: createDefaultScheduler(), + adapters: createBuiltinRegistry(), + }; + let seq = 0; + const events = await collect( + runInference({ + turns: [userTurn("hi")], + source: { + id: "openai-responses:gpt-5-mini", + provider: OPENAI_RESPONSES_PROVIDER, + baseURL: "https://api.openai.com/v1", + credentialId: "test", + model: "gpt-5-mini", + }, + nextSeq: () => ++seq, + deps, + readMaterial: () => ({ secret: "test-secret" }), + }), + ); + expect(events.map((e) => e.type)).toEqual([ + "inference.start", + "inference.text.delta", + "inference.text.delta", + "inference.usage", + "inference.done", + ]); + const usage = events.find((e) => e.type === "inference.usage"); + if (usage?.type !== "inference.usage") throw new Error("missing usage"); + expect(usage.data.usage).toMatchObject({ input: 10, output: 5 }); + const done = events.find((e) => e.type === "inference.done"); + if (done?.type !== "inference.done") throw new Error("missing done"); + expect(done.data.turn.content).toEqual([ + { type: "text", text: "Hello world" }, + ]); + }); + + test("buffered JSON body replays through the accumulator", async () => { + const deps: Dependencies = { + fetch: () => + Promise.resolve( + new Response( + JSON.stringify({ + output: [ + { + type: "message", + content: [{ type: "output_text", text: "buffered hi" }], + }, + ], + usage: { input_tokens: 7, output_tokens: 3 }, + }), + { + status: 200, + headers: { "content-type": "application/json" }, + }, + ), + ), + scheduler: createDefaultScheduler(), + adapters: createBuiltinRegistry(), + }; + let seq = 0; + const events = await collect( + runInference({ + turns: [userTurn("hi")], + source: { + id: "openai-responses:gpt-5-mini", + provider: OPENAI_RESPONSES_PROVIDER, + baseURL: "https://api.openai.com/v1", + credentialId: "test", + model: "gpt-5-mini", + }, + nextSeq: () => ++seq, + deps, + readMaterial: () => ({ secret: "test-secret" }), + }), + ); + expect(events.map((e) => e.type)).toEqual([ + "inference.start", + "inference.text.delta", + "inference.usage", + "inference.done", + ]); + const done = events.find((e) => e.type === "inference.done"); + if (done?.type !== "inference.done") throw new Error("missing done"); + expect(done.data.turn.content).toEqual([ + { type: "text", text: "buffered hi" }, + ]); + }); +}); diff --git a/packages/inference/src/providers/openai-responses.ts b/packages/inference/src/providers/openai-responses.ts new file mode 100644 index 000000000..1a39ee99a --- /dev/null +++ b/packages/inference/src/providers/openai-responses.ts @@ -0,0 +1,1399 @@ +// OpenAI Responses API provider adapter. +// +// Ported from `@corbits/openai-responses` 0.2.3 +// (https://github.com/corbitsdev/corbits-openai-responses, LGPL-2.1-only) +// and grounded in this repository's inference contracts. The port keeps the +// source's streaming and buffered parsing, tool calls, usage mapping, +// supported media, quirks validation, and provider- and model-scoped +// reasoning signature replay. Header extraction +// reuses the Chat Completions adapter's extractors (the Responses surface +// shares those headers byte-for-byte) instead of duplicating them. + +import { type } from "arktype"; + +import type { InferenceEvent } from "@intx/types/inference-events"; +import type { + ContentBlock, + ConversationTurn, + InferenceOptions, + LastCycleSource, + TokenUsage, +} from "@intx/types/runtime-core"; +import { formatSafetyRatingText } from "@intx/types/format-safety-rating"; +import type { AdapterFactory, BuiltRequest, ProviderAdapter } from "../adapter"; +import { BEARER_CREDENTIAL_SENTINEL } from "../auth"; +import { ProtocolMismatchError } from "../errors"; +import { + decodeToolName, + encodeToolName, + type ToolNameLimit, +} from "../tool-name"; +import { + extractPacingDelayMs, + extractRetryAfterMs, + filenameForDocumentMime, + wireReasoningEffort, +} from "./openai"; + +// Wire-charset limit for function names on the Responses surface: +// `^[a-zA-Z0-9_-]{1,64}$` across every vendor that speaks this protocol. +const RESPONSES_TOOL_NAME_LIMIT: ToolNameLimit = { + provider: "responses", + maxLength: 64, +}; + +// --------------------------------------------------------------------------- +// Quirks +// --------------------------------------------------------------------------- +// +// Everything a vendor (Codex, xAI/Grok, plain OpenAI, ...) needs to bend the +// shared Responses wire protocol to its own backend, expressed as data +// instead of a fork of the adapter. Every field here must be JSON-safe: the +// quirks bag rides inside an `InferenceSource`, which is persisted and sent +// over the wire, so a function-valued field would silently fail to survive +// that round trip. Fields stay only while a known backend needs them; +// a new backend need re-adds one rather than carrying speculative options. + +const HeaderFromOption = type({ + optionKey: "string", + header: "string", +}); + +const ResponsesHeaders = type({ + "static?": { "[string]": "string" }, + "fromOption?": HeaderFromOption.array(), + "+": "reject", +}); + +// `shape: "string"` sends plain string content (Grok/OpenAI); `"parts"` +// sends a single `input_text` content part (Codex, which addresses the item +// as a `developer` message). +const SystemPromptPlacement = type({ + role: "'system' | 'developer'", + shape: "'string' | 'parts'", +}); + +const ReasoningQuirks = type({ + "summary?": "'auto' | 'detailed'", + // The wire value Interchange's neutral `max` effort becomes. The highest + // level differs per model, so only the source names it. + "maxEffort?": "'xhigh' | 'max'", + "+": "reject", +}); +type ReasoningQuirks = typeof ReasoningQuirks.infer; + +// Per-source accommodations for the OpenAI Responses API wire protocol. +// Every field is optional; an absent field resolves to the strict protocol +// default, so a source that supplies no quirks gets no accommodation and +// must opt into lenient behavior explicitly. +export const ResponsesQuirks = type({ + "path?": "string", + "headers?": ResponsesHeaders, + // Codex addresses the system prompt as a `developer` message with parts + // content; every other known backend takes the protocol-native `system` + // string. + "systemPrompt?": SystemPromptPlacement, + // `typed` is the protocol-native shape (`output_text` for assistant items, + // `input_text` otherwise); `flat` collapses text-only content to a plain + // string for backends that reject typed parts (Codex). + "contentShape?": "'typed' | 'flat'", + // The Responses protocol forwards a caller-supplied maxTokens/temperature + // verbatim; these default true. Set `false` only when a vendor's backend + // rejects the field outright (the quirk opts a source OUT of protocol- + // native forwarding, not into it). + "maxOutputTokens?": "boolean", + "temperature?": "boolean", + "store?": "boolean", + "stream?": "boolean", + "reasoning?": ReasoningQuirks, + // Reject unknown keys so a mistyped quirk name fails loudly at + // construction rather than being silently ignored and running with + // default behavior. + "+": "reject", +}); +export type ResponsesQuirks = typeof ResponsesQuirks.infer; + +// Quirks resolved to concrete values at the factory edge, so interior code +// never re-decides a default. +export type ResolvedResponsesQuirks = { + path: string; + headers: { + static: Record; + fromOption: { optionKey: string; header: string }[]; + }; + systemPrompt: { role: "system" | "developer"; shape: "string" | "parts" }; + contentShape: "typed" | "flat"; + maxOutputTokens: boolean; + temperature: boolean; + store: boolean; + stream: boolean; + reasoning: ReasoningQuirks | undefined; +}; + +// Parses an adapter's `quirks` argument (an `InferenceSource.quirks` bag) +// into a validated `ResponsesQuirks` and fills in defaults. An absent bag +// (`undefined`) resolves the same as `{}` — protocol-native defaults, not a +// thrown error. Throws on shape violations rather than silently ignoring an +// unrecognized or misspelled field. +function parseResponsesQuirks(raw: unknown): ResolvedResponsesQuirks { + const validated = ResponsesQuirks(raw ?? {}); + if (validated instanceof type.errors) { + throw new Error( + `openai-responses adapter: invalid quirks: ${validated.summary}`, + ); + } + // Header names are case-insensitive; lowercasing lets a quirk header + // override the stock lowercase ones instead of being sent alongside them. + // No quirk may name the credential header, so neither a persisted bag nor + // a caller's providerOptions can replace the sentinel the harness swaps + // for the real credential. + function headerName(field: string, name: string): string { + const lower = name.toLowerCase(); + if (lower === "authorization") { + throw new Error( + `openai-responses adapter: invalid quirks: ${field} must not set authorization`, + ); + } + return lower; + } + const staticHeaders: Record = {}; + for (const [name, value] of Object.entries(validated.headers?.static ?? {})) { + staticHeaders[headerName("headers.static", name)] = value; + } + return { + path: validated.path ?? "/responses", + headers: { + static: staticHeaders, + fromOption: (validated.headers?.fromOption ?? []).map( + ({ optionKey, header }) => ({ + optionKey, + header: headerName("headers.fromOption", header), + }), + ), + }, + // Protocol-native behaviour always sends the caller's system prompt as + // a plain `system` message; a vendor whose backend addresses it + // differently (Codex: `developer` role, parts shape) overrides this + // quirk instead of opting out of sending it at all. + systemPrompt: validated.systemPrompt ?? { + role: "system", + shape: "string", + }, + contentShape: validated.contentShape ?? "typed", + maxOutputTokens: validated.maxOutputTokens ?? true, + temperature: validated.temperature ?? true, + store: validated.store ?? false, + stream: validated.stream ?? true, + reasoning: validated.reasoning, + }; +} + +// --------------------------------------------------------------------------- +// Request building +// --------------------------------------------------------------------------- + +// Tool results carry a content array; the Responses API wants a string. Join +// the text parts; non-text content is not representable here and is dropped +// with a marker so the model is not misled into thinking it went missing +// silently. Only the join and the `` wrapping match the Chat +// Completions adapter's `role: "tool"` encoding (whose schema likewise has +// no `is_error` field); the Chat adapter drops non-text content with no +// marker, so the two wires differ there. +function toolResultText( + block: Extract, +): string { + const parts: string[] = []; + for (const c of block.content) { + if (c.type === "text") parts.push(c.text); + else parts.push(`[unsupported ${c.type} content omitted]`); + } + return parts.join(""); +} + +// Grounded on the OpenAI Responses API document input shape: a base64 +// document synthesizes a deterministic filename from its mimeType, since +// MediaSource carries no filename field of its own. Only PDF is supported +// today, matching the Chat Completions adapter's own document support. +function filenameForDocumentMime(mimeType: string): string { + if (mimeType === "application/pdf") return "document.pdf"; + throw new Error( + `openai-responses adapter: document input currently supports application/pdf only; received mimeType: ${mimeType}`, + ); +} + +// Converts one content block to zero or one Responses content part. Blocks +// handled as whole `ResponsesInputItem`s elsewhere (tool_call, tool_result, +// signed thinking) are not passed here. +function toResponsesContentPart( + block: ContentBlock, + textKind: "input_text" | "output_text", +): Record | undefined { + switch (block.type) { + case "text": + return { type: textKind, text: block.text }; + case "safety_rating": + // No input wire shape for safety_rating; render it as text so a + // safety_rating-only turn is not a silently empty message. + return { type: textKind, text: formatSafetyRatingText(block) }; + case "image": { + const source = block.source; + if (source.kind === "base64") { + return { + type: "input_image", + image_url: `data:${source.mimeType};base64,${source.data}`, + }; + } + if (source.kind === "url") { + return { type: "input_image", image_url: source.url }; + } + // Unlike Chat Completions' image_url-only surface, the Responses API + // accepts an uploaded file_id directly on an input_image part. + return { type: "input_image", file_id: source.reference }; + } + case "document": { + const source = block.source; + if (source.kind === "base64") { + return { + type: "input_file", + filename: filenameForDocumentMime( + source.mimeType, + "openai-responses adapter", + ), + file_data: `data:${source.mimeType};base64,${source.data}`, + }; + } + if (source.kind === "file-reference") { + return { type: "input_file", file_id: source.reference }; + } + throw new Error( + `openai-responses adapter: input_file does not accept url document sources; the Responses API only takes base64 data (file_data) or an uploaded file_id. Received url: ${source.url}`, + ); + } + case "audio": + case "video": + throw new Error( + `openai-responses adapter: adapter does not yet handle ${block.type} content blocks.`, + ); + case "citation": + case "redacted_thinking": + // Server-emitted attribution/opaque metadata with no Responses input + // wire shape; dropping it is a silent no-op, not data loss the caller + // needs to see, matching the Chat Completions adapter's own policy. + return undefined; + case "code_execution_request": + case "code_execution_result": + throw new Error( + `openai-responses adapter: adapter does not handle ${block.type} content blocks.`, + ); + case "refusal": + throw new Error( + "openai-responses adapter: adapter does not handle refusal content blocks.", + ); + case "thinking": + case "tool_call": + case "tool_result": + // Handled as whole items in toResponsesItems, not as content parts. + return undefined; + } +} + +// Map one internal turn to zero or more Responses items. Reasoning blocks +// are echoed back only when their signature was issued by this provider for +// the requested model; otherwise only the reasoning item is dropped, and the +// function_call items it preceded are kept so each function_call_output +// still has its call. +function toResponsesItems( + turn: ConversationTurn, + requestModel: string, + requestProvider: string, + contentShape: "typed" | "flat", +): Record[] { + const items: Record[] = []; + const role = turn.role; + const textKind = + contentShape === "typed" && role === "assistant" + ? "output_text" + : "input_text"; + const parts: Record[] = []; + let hasNonTextPart = false; + const flush = (): void => { + if (parts.length === 0) return; + const content = + contentShape === "flat" && !hasNonTextPart + ? parts.map((part) => ("text" in part ? part.text : "")).join("") + : [...parts]; + items.push({ type: "message", role, content }); + parts.length = 0; + hasNonTextPart = false; + }; + for (const block of turn.content) { + if (block.type === "tool_call") { + flush(); + items.push({ + type: "function_call", + name: encodeToolName(block.name, RESPONSES_TOOL_NAME_LIMIT), + arguments: JSON.stringify(block.arguments ?? {}), + call_id: block.id, + }); + continue; + } + if (block.type === "tool_result") { + flush(); + items.push({ + type: "function_call_output", + call_id: block.callId, + output: toolResultText(block), + }); + continue; + } + if (block.type === "thinking") { + if (typeof block.signature !== "string" || block.signature.length === 0) + continue; + flush(); + const encryptedContent = signatureForModel( + turn, + requestModel, + requestProvider, + block.signature, + ); + if (encryptedContent !== undefined) + items.push({ + type: "reasoning", + summary: [], + encrypted_content: encryptedContent, + }); + continue; + } + const part = toResponsesContentPart(block, textKind); + if (part === undefined) continue; + if (part.type !== "input_text" && part.type !== "output_text") + hasNonTextPart = true; + parts.push(part); + } + flush(); + return items; +} + +// Keeps the LAST occurrence of each duplicate function_call / +// function_call_output call_id, not the first: a duplicate is most often a +// corrected retry, and discarding the retry in favor of the stale original +// silently replays the wrong tool result. Both item types are covered — a +// duplicated function_call is just as invalid on the wire as a duplicated +// output. +function dedupeToolItems( + items: Record[], +): Record[] { + const lastIndexForCall = new Map(); + items.forEach((item, i) => { + if (item.type === "function_call" || item.type === "function_call_output") { + lastIndexForCall.set(`${String(item.type)}:${String(item.call_id)}`, i); + } + }); + return items.filter((item, i) => { + if (item.type === "function_call" || item.type === "function_call_output") { + return ( + lastIndexForCall.get(`${String(item.type)}:${String(item.call_id)}`) === + i + ); + } + return true; + }); +} + +function toResponsesTools( + options: InferenceOptions, +): Record[] | undefined { + if (options.tools === undefined || options.tools.length === 0) { + return undefined; + } + // Responses function tools are FLAT — name/description/parameters sit + // beside `type`, not nested under a `function` key (unlike Chat + // Completions). + return options.tools.map((t) => ({ + type: "function", + name: encodeToolName(t.name, RESPONSES_TOOL_NAME_LIMIT), + description: t.description, + parameters: t.inputSchema, + })); +} + +function optionString( + options: InferenceOptions, + key: string, +): string | undefined { + const value = options.providerOptions?.[key]; + return typeof value === "string" && value.length > 0 ? value : undefined; +} + +function systemPromptItem( + quirks: ResolvedResponsesQuirks, + systemPrompt: string, +): Record { + const placement = quirks.systemPrompt; + const content = + placement.shape === "string" + ? systemPrompt + : [{ type: "input_text", text: systemPrompt }]; + return { type: "message", role: placement.role, content }; +} + +function reasoningField( + model: string, + quirks: ResolvedResponsesQuirks, + options: InferenceOptions, +): Record | undefined { + const reasoning = quirks.reasoning; + const field: Record = {}; + if (reasoning?.summary !== undefined) field["summary"] = reasoning.summary; + const effort = wireReasoningEffort( + model, + options.effort, + reasoning?.maxEffort ?? null, + ); + if (effort !== undefined) { + field["effort"] = effort; + } + return Object.keys(field).length > 0 ? field : undefined; +} + +export function buildResponsesRequest( + quirks: ResolvedResponsesQuirks, + messages: ConversationTurn[], + model: string, + options: InferenceOptions, + requestProvider: string, +): BuiltRequest { + const conversation = dedupeToolItems( + messages.flatMap((turn) => + toResponsesItems(turn, model, requestProvider, quirks.contentShape), + ), + ); + const leadingSystemItem = + options.systemPrompt !== undefined + ? systemPromptItem(quirks, options.systemPrompt) + : undefined; + const input = + leadingSystemItem !== undefined + ? [leadingSystemItem, ...conversation] + : conversation; + const tools = toResponsesTools(options); + const body: Record = { + model, + input, + store: quirks.store, + stream: quirks.stream, + include: ["reasoning.encrypted_content"], + }; + if (tools !== undefined) { + body["tools"] = tools; + body["tool_choice"] = "auto"; + } + if (quirks.maxOutputTokens && options.maxTokens !== undefined) { + body["max_output_tokens"] = options.maxTokens; + } + if (quirks.temperature && options.temperature !== undefined) { + body["temperature"] = options.temperature; + } + const reasoning = reasoningField(model, quirks, options); + if (reasoning !== undefined) body["reasoning"] = reasoning; + const headers: Record = { + "content-type": "application/json", + // A non-streaming request must ask for a plain JSON body: sending + // `text/event-stream` on `stream: false` gets some backends to 406, and + // others to silently ignore the header and return JSON anyway — neither + // is a wire contract to depend on. + accept: quirks.stream ? "text/event-stream" : "application/json", + authorization: BEARER_CREDENTIAL_SENTINEL, + }; + for (const [name, value] of Object.entries(quirks.headers.static)) { + headers[name] = value; + } + for (const { optionKey, header } of quirks.headers.fromOption) { + const value = optionString(options, optionKey); + if (value !== undefined) headers[header] = value; + } + return { url: quirks.path, headers, body: JSON.stringify(body) }; +} + +// A thinking block's `signature` is opaque ciphertext a specific backend +// issued for a specific model; only that backend can decrypt it. `model` is +// arbitrary catalog/user-supplied text — nothing stops two distinct backends +// (proxy aliases, two OpenAI-compatible endpoints) from declaring the same +// literal model name, so comparing `turn.model` alone treats a foreign +// signature as safe to replay. `ConversationTurn` carries no field for which +// provider produced it, so provenance rides inside the signature string +// itself: capture tags it `:` (see `tagSignature`), +// and replay only unwraps the ciphertext when both the tagged provider and +// the model match the current request. +// +// Provider, not the per-account source id, is the unit of decrypt +// capability — a backend shared across accounts can decrypt a signature +// issued to any of them, so keying on provider (rather than source id) is +// what lets an account switch keep reasoning continuity while a genuine +// cross-provider collision still gets dropped. A poisoned history self-heals +// on the next request instead of being replayed forever. +const SIGNATURE_TAG_SEPARATOR = ":"; + +export function tagSignature( + provider: string, + encryptedContent: string, +): string { + return `${provider}${SIGNATURE_TAG_SEPARATOR}${encryptedContent}`; +} + +function untagSignature( + tagged: string, +): { provider: string; encryptedContent: string } | undefined { + const idx = tagged.indexOf(SIGNATURE_TAG_SEPARATOR); + if (idx === -1) return undefined; + return { + provider: tagged.slice(0, idx), + encryptedContent: tagged.slice(idx + 1), + }; +} + +// Returns the replayable `encrypted_content` for a thinking block's +// signature, or `undefined` when it must not be replayed on this request +// (persisted-turn model mismatch, or a signature tagged for a different +// provider). +function signatureForModel( + turn: ConversationTurn, + requestModel: string, + requestProvider: string, + signature: string, +): string | undefined { + // `model` is optional on the persisted turn schema; a turn saved before + // that field existed (or otherwise missing it) is not evidence of a model + // switch — treat the absence as benign and fall through to the provider + // check, rather than dropping reasoning that never actually crossed + // models. + if (turn.model !== undefined && turn.model !== requestModel) { + return undefined; + } + const tagged = untagSignature(signature); + if (tagged === undefined) return undefined; + return tagged.provider === requestProvider + ? tagged.encryptedContent + : undefined; +} + +// --------------------------------------------------------------------------- +// Streaming response parsing +// --------------------------------------------------------------------------- +// +// Every `response.*` event type this adapter acts on gets a schema here. An +// event whose `type` is not one of these is protocol-legal but uninteresting +// (a lifecycle envelope this adapter has nothing to do with) and is ignored; +// an event whose `type` IS one of these but whose shape fails validation is +// a genuine protocol mismatch and throws. + +const EMPTY_PARTIAL = { text: "" }; + +const ResponsesEnvelope = type({ type: "string" }); +const TextDeltaEvent = type({ item_id: "string > 0", delta: "string" }); +// Every reasoning delta the Responses API emits carries the item_id of the +// reasoning item it belongs to and a delta string (possibly empty); an event +// of this type missing either field is not a lenient variant, it's a +// protocol mismatch this adapter cannot attribute to any block. +const ReasoningDeltaEvent = type({ + item_id: "string > 0", + delta: "string", +}); +const RefusalDeltaEvent = type({ item_id: "string > 0", delta: "string" }); +const RefusalDoneEvent = type({ + item_id: "string > 0", + refusal: "string", +}); +const FunctionCallArgsDeltaEvent = type({ + item_id: "string > 0", + delta: "string", +}); +const OutputItemAddedEvent = type({ + item: { + type: "string", + "id?": "string > 0", + "call_id?": "string > 0", + "name?": "string > 0", + }, +}); +const OutputItemDoneEvent = type({ + item: { + type: "string", + "id?": "string > 0", + "encrypted_content?": "string", + }, +}); +const ResponsesUsage = type({ + "input_tokens?": "number", + "output_tokens?": "number", + "input_tokens_details?": type({ + "cached_tokens?": "number", + "cache_write_tokens?": "number", + "cache_creation_tokens?": "number", + }).or("null"), + "output_tokens_details?": type({ "reasoning_tokens?": "number" }).or("null"), +}).or("null"); +const CompletedEvent = type({ response: { "usage?": ResponsesUsage } }); +const FailedEvent = type({ + "response?": { "error?": { "message?": "string" } }, +}); +const IncompleteEvent = type({ + response: { + "incomplete_details?": { "reason?": "string" }, + "usage?": ResponsesUsage, + }, +}); + +// `response.incomplete` carries why the backend stopped. A content-filter +// stop is a safety signal the caller must tell apart from a complete or +// truncated turn, so it surfaces as `inference.safety_rating` — the same +// event the Google adapter emits for a prompt-level block. Any other +// reason (e.g. max_output_tokens) reports usage alone. +function incompleteReasonEvent( + reason: string | undefined, + seq: number, +): InferenceEvent | undefined { + if (reason !== "content_filter") return undefined; + return { + type: "inference.safety_rating", + seq, + data: { + safetyRating: { type: "safety_rating", blockReason: reason }, + }, + }; +} +const ErrorEvent = type({ "message?": "string" }); + +type ResponsesUsageShape = typeof ResponsesUsage.infer | undefined; + +// Maps the Responses API's usage object onto the internal TokenUsage, +// splitting the cached-token subset out of input_tokens. Shared by the SSE +// `response.completed` handler and the non-streaming parseJSONResponse, +// whose usage objects carry the same field names. +function toInferenceUsage(usage: ResponsesUsageShape): TokenUsage { + if (usage === null || usage === undefined) { + return { input: 0, output: 0, cacheRead: 0, cacheWrite: 0, thinking: 0 }; + } + // Responses-API `input_tokens` counts the full prompt and `cached_tokens` + // is a subset of it. Downstream consumers treat `TokenUsage` fields as + // non-overlapping and sum them, so the cached subset must be split out of + // input here — emitting the wire counts verbatim double-counts every + // cached token and inflates context occupancy up to ~2x on high + // cache-hit sessions. + const totalInput = usage.input_tokens ?? 0; + const details = usage.input_tokens_details; + // Counters are non-negative quantities: a negative count off the wire is + // garbage, clamped to zero rather than propagated into sums or allowed to + // inflate input by subtracting a negative. + const cachedTokens = Math.max(0, details?.cached_tokens ?? 0); + // OpenAI (GPT-5.6+) reports cache writes as `cache_write_tokens` and + // documents them as a subset of `input_tokens`, so they must be split out + // of input exactly like `cached_tokens`. Gateways fronting OpenAI-shaped + // endpoints report the Anthropic-shaped `cache_creation_tokens` instead; + // its subset relationship to `input_tokens` is unobservable from here, so + // that fallback keeps the historic behavior of not reducing input. + const rawWriteTokens = details?.cache_write_tokens; + const openaiWriteTokens = + rawWriteTokens === undefined ? undefined : Math.max(0, rawWriteTokens); + return { + input: Math.max(0, totalInput - cachedTokens - (openaiWriteTokens ?? 0)), + output: Math.max(0, usage.output_tokens ?? 0), + cacheRead: cachedTokens, + cacheWrite: Math.max( + 0, + openaiWriteTokens ?? details?.cache_creation_tokens ?? 0, + ), + thinking: Math.max(0, usage.output_tokens_details?.reasoning_tokens ?? 0), + }; +} + +export type ResponsesBlockIndexer = { + nextIndex: number; + items: Map; +}; + +export function createResponsesBlockIndexer(): ResponsesBlockIndexer { + return { nextIndex: 0, items: new Map() }; +} + +function getOrAssignBlockIndex( + state: ResponsesBlockIndexer, + itemId: string, + kind: string, +): number { + const existing = state.items.get(itemId); + if (existing !== undefined) return existing.index; + const index = state.nextIndex; + state.nextIndex += 1; + state.items.set(itemId, { index, kind }); + return index; +} + +function protocolMismatch( + provider: string, + message: string, + raw: unknown, +): ProtocolMismatchError { + return new ProtocolMismatchError( + `${provider} parseResponse: ${message}`, + raw, + ); +} + +export function parseResponse( + sseData: string, + indexer: ResponsesBlockIndexer, + source: LastCycleSource, +): InferenceEvent[] { + const provider = source.provider; + let parsed: unknown; + try { + parsed = JSON.parse(sseData); + } catch (cause) { + throw new ProtocolMismatchError( + `${provider} parseResponse: malformed JSON in SSE data payload: ${cause instanceof Error ? cause.message : String(cause)}`, + sseData, + ); + } + const envelope = ResponsesEnvelope(parsed); + if (envelope instanceof type.errors) { + throw protocolMismatch( + provider, + `SSE envelope failed schema validation: ${envelope.summary}`, + parsed, + ); + } + const eventType: string = envelope.type; + const seq = 0; + const events: InferenceEvent[] = []; + switch (eventType) { + case "response.output_text.delta": { + const validated = TextDeltaEvent(parsed); + if (validated instanceof type.errors) { + throw protocolMismatch( + provider, + `output_text.delta failed schema validation: ${validated.summary}`, + parsed, + ); + } + if (validated.delta.length > 0) { + events.push({ + type: "inference.text.delta", + seq, + data: { + token: validated.delta, + partial: EMPTY_PARTIAL, + index: getOrAssignBlockIndex(indexer, validated.item_id, "text"), + }, + }); + } + return events; + } + case "response.reasoning_summary_text.delta": + case "response.reasoning_text.delta": { + const validated = ReasoningDeltaEvent(parsed); + if (validated instanceof type.errors) { + throw protocolMismatch( + provider, + `${eventType} failed schema validation: ${validated.summary}`, + parsed, + ); + } + // Always register the block and emit a thinking delta (even for empty + // tokens). This ensures a preceding thinking block exists for any + // subsequent signature, supporting reasoning items whose visible + // summary may be empty or delivered only via the done envelope. + const index = getOrAssignBlockIndex( + indexer, + validated.item_id, + "thinking", + ); + events.push({ + type: "inference.thinking.delta", + seq, + data: { token: validated.delta, partial: EMPTY_PARTIAL, index }, + }); + return events; + } + case "response.refusal.delta": { + const validated = RefusalDeltaEvent(parsed); + if (validated instanceof type.errors) { + throw protocolMismatch( + provider, + `refusal.delta failed schema validation: ${validated.summary}`, + parsed, + ); + } + if (validated.delta.length > 0) { + events.push({ + type: "inference.refusal.delta", + seq, + data: { + token: validated.delta, + partial: EMPTY_PARTIAL, + index: getOrAssignBlockIndex(indexer, validated.item_id, "refusal"), + }, + }); + } + return events; + } + case "response.refusal.done": { + const validated = RefusalDoneEvent(parsed); + if (validated instanceof type.errors) { + throw protocolMismatch( + provider, + `refusal.done failed schema validation: ${validated.summary}`, + parsed, + ); + } + // The deltas already streamed the full text; the done envelope carries + // no incremental payload this adapter needs. + return events; + } + case "response.output_item.added": { + const validated = OutputItemAddedEvent(parsed); + if (validated instanceof type.errors) { + throw protocolMismatch( + provider, + `output_item.added failed schema validation: ${validated.summary}`, + parsed, + ); + } + const { item } = validated; + if (item.type === "function_call") { + // A function_call start missing id/call_id/name is not a lenient + // partial to skip past — the harness would then see a + // function_call_arguments.delta with no corresponding + // inference.tool_call.start and silently drop the fragments. + if ( + item.id === undefined || + item.call_id === undefined || + item.name === undefined + ) { + throw protocolMismatch( + provider, + "output_item.added function_call is missing id, call_id, or name", + parsed, + ); + } + events.push({ + type: "inference.tool_call.start", + seq, + data: { + callId: item.call_id, + name: decodeToolName(item.name), + partial: EMPTY_PARTIAL, + index: getOrAssignBlockIndex(indexer, item.id, "tool_call"), + }, + }); + } else if (item.type === "reasoning") { + // A reasoning item with no id cannot be pre-registered, and the + // signature it will later carry on output_item.done could never be + // attached to a block — that's a protocol mismatch, not a skip. + if (item.id === undefined) { + throw protocolMismatch( + provider, + "output_item.added reasoning item is missing id", + parsed, + ); + } + // Pre-register reasoning items on added so the index is stable even + // if no text deltas follow (pure-encrypted case). + const index = getOrAssignBlockIndex(indexer, item.id, "thinking"); + events.push({ + type: "inference.thinking.delta", + seq, + data: { token: "", partial: EMPTY_PARTIAL, index }, + }); + } + return events; + } + case "response.output_item.done": { + const validated = OutputItemDoneEvent(parsed); + if (validated instanceof type.errors) { + throw protocolMismatch( + provider, + `output_item.done failed schema validation: ${validated.summary}`, + parsed, + ); + } + // Capture the encrypted reasoning blob (signature) so it can be echoed + // back on the next turn. Required for multi-turn continuity when the + // backend uses store:false + reasoning.encrypted_content. A thinking + // block is ensured to exist (emitting an empty delta if this is the + // first signal for the item) so the harness can attach the signature + // without a protocol-mismatch error. + const { item } = validated; + if (item.type === "reasoning") { + // Neither field present means the backend closed a reasoning item + // this adapter can neither index (no id) nor carry forward (no + // encrypted_content) — silently doing nothing here would drop a + // reasoning turn's continuity with no signal anywhere. + if (item.id === undefined && item.encrypted_content === undefined) { + throw protocolMismatch( + provider, + "output_item.done reasoning item has neither id nor encrypted_content", + parsed, + ); + } + if (item.encrypted_content !== undefined && item.id === undefined) { + throw protocolMismatch( + provider, + "output_item.done reasoning item carries encrypted_content but is missing id", + parsed, + ); + } + if (item.id !== undefined && item.encrypted_content !== undefined) { + const itemId = item.id; + const hadPrior = indexer.items.has(itemId); + const index = getOrAssignBlockIndex(indexer, itemId, "thinking"); + if (!hadPrior) { + events.push({ + type: "inference.thinking.delta", + seq, + data: { token: "", partial: EMPTY_PARTIAL, index }, + }); + } + events.push({ + type: "inference.block.signature", + seq, + data: { + signature: tagSignature(provider, item.encrypted_content), + index, + }, + }); + } + } + return events; + } + case "response.function_call_arguments.delta": { + const validated = FunctionCallArgsDeltaEvent(parsed); + if (validated instanceof type.errors) { + throw protocolMismatch( + provider, + `function_call_arguments.delta failed schema validation: ${validated.summary}`, + parsed, + ); + } + // The block must already have been registered by + // `response.output_item.added`; an argument fragment for an item_id + // this adapter never saw start is an orphan the harness has no + // tool_call.start to route it against, not a fresh block to + // synthesize silently. + const existing = indexer.items.get(validated.item_id); + if (existing === undefined) { + throw protocolMismatch( + provider, + `function_call_arguments.delta for item_id ${validated.item_id} was never announced by output_item.added`, + parsed, + ); + } + if (validated.delta.length > 0) { + const blockIndex = existing.index; + events.push({ + type: "inference.tool_call.delta", + seq, + data: { + // The harness routes argument fragments by a per-stream + // placeholder keyed to the block index registered on the start + // event. + callId: String(blockIndex), + argumentFragment: validated.delta, + partial: EMPTY_PARTIAL, + index: blockIndex, + }, + }); + } + return events; + } + // `response.done` is an alias some backends emit for `response.completed`; + // both carry the turn's usage on the terminal envelope, so they share + // validation and usage handling here and in `isResponsesStreamTerminal`. + case "response.completed": + case "response.done": { + const validated = CompletedEvent(parsed); + if (validated instanceof type.errors) { + throw protocolMismatch( + provider, + `${eventType} failed schema validation: ${validated.summary}`, + parsed, + ); + } + if (validated.response.usage !== undefined) { + events.push({ + type: "inference.usage", + seq, + data: { + usage: toInferenceUsage(validated.response.usage), + source, + }, + }); + } + return events; + } + case "response.failed": { + const validated = FailedEvent(parsed); + if (validated instanceof type.errors) { + throw protocolMismatch( + provider, + `response.failed failed schema validation: ${validated.summary}`, + parsed, + ); + } + const message = validated.response?.error?.message ?? "response failed"; + throw new ProtocolMismatchError(`${provider}: ${message}`, parsed); + } + // A truncated turn is still a turn: the backend stopped (often on + // max_output_tokens) after emitting usable deltas, and those deltas were + // already delivered as events by earlier envelopes. Terminal handling + // lives in isResponsesStreamTerminal; the usage is what the backend + // bills for the partial turn, so it is reported like a completed one. + case "response.incomplete": { + const validated = IncompleteEvent(parsed); + if (validated instanceof type.errors) { + throw protocolMismatch( + provider, + `response.incomplete failed schema validation: ${validated.summary}`, + parsed, + ); + } + const reasonEvent = incompleteReasonEvent( + validated.response.incomplete_details?.reason, + seq, + ); + if (reasonEvent !== undefined) events.push(reasonEvent); + if (validated.response.usage !== undefined) { + events.push({ + type: "inference.usage", + seq, + data: { + usage: toInferenceUsage(validated.response.usage), + source, + }, + }); + } + return events; + } + case "error": { + const validated = ErrorEvent(parsed); + if (validated instanceof type.errors) { + throw protocolMismatch( + provider, + `error event failed schema validation: ${validated.summary}`, + parsed, + ); + } + throw new ProtocolMismatchError( + `${provider}: ${validated.message ?? "stream error"}`, + parsed, + ); + } + default: + // Lifecycle envelopes (response.created, response.in_progress, + // content_part.*, *_text.done) carry no incremental payload a caller + // needs; ignore them. Unknown event types are protocol-legal — the + // vocabulary is expected to grow. + return events; + } +} + +// The Responses stream ends on a semantic lifecycle event, not `[DONE]` or +// a socket close: `response.completed` on success, `response.incomplete` +// when the backend truncates, `response.done` as an alias some backends +// emit. Failure envelopes (`response.failed`, `error`) already throw in +// `parseResponse`, and the harness attempt `finally` releases the +// held-open body on that throw path. +const RESPONSES_TERMINAL_EVENTS = new Set([ + "response.completed", + "response.incomplete", + "response.done", +]); + +/** True when an SSE event payload is a Responses stream's terminal event. */ +export function isResponsesStreamTerminal(sseData: string): boolean { + let parsed: unknown; + try { + parsed = JSON.parse(sseData); + } catch { + // parseResponse re-parses the same payload and raises the protocol + // error; reporting "not terminal" here defers to that single throw + // site. + return false; + } + const envelope = ResponsesEnvelope(parsed); + if (envelope instanceof type.errors) return false; + return RESPONSES_TERMINAL_EVENTS.has(envelope.type); +} + +// --------------------------------------------------------------------------- +// Non-streaming JSON parse +// +// A complete non-streaming Responses object returns the whole turn in one +// JSON body. parseJSONResponse re-expresses it as the same InferenceEvent +// vocabulary parseResponse emits from the stream, walking `output[]` in +// order and synthesizing indices the same way the streaming path assigns +// them on first observation. +// --------------------------------------------------------------------------- + +const OutputTextPart = type({ type: "'output_text'", text: "string" }); +const RefusalPart = type({ type: "'refusal'", refusal: "string" }); +// Content parts are validated individually by kind, same rationale as +// output items below: an "unknown kind, ignore it" fallback branch defeats +// narrowing on the known branches. +const MessageItem = type({ + type: "'message'", + content: type({ type: "string" }).array(), +}); +const FunctionCallItem = type({ + type: "'function_call'", + id: "string", + call_id: "string", + name: "string", + arguments: "string", +}); +const ReasoningSummaryPart = type({ type: "'summary_text'", text: "string" }); +const ReasoningItem = type({ + type: "'reasoning'", + id: "string", + "summary?": ReasoningSummaryPart.array(), + "encrypted_content?": "string", +}); +// Output items are validated individually by kind rather than as one +// discriminated array schema: a fallback "unknown item kind, ignore it" +// branch has a non-literal `type: string` discriminant, which defeats +// TypeScript's narrowing on every known branch. Validating per-item lets an +// unrecognized `type` skip validation entirely (protocol-legal, like an +// unrecognized SSE event) while a recognized `type` with the wrong shape +// still throws. +const CompleteResponse = type({ + output: type({ type: "string" }).array(), + "usage?": ResponsesUsage, + "status?": + "'completed' | 'failed' | 'incomplete' | 'in_progress' | 'cancelled' | 'queued'", + "error?": { "message?": "string" }, + "incomplete_details?": { "reason?": "string" }, +}); + +export function parseJSONResponse( + body: string, + source: LastCycleSource, +): InferenceEvent[] { + const provider = source.provider; + let parsed: unknown; + try { + parsed = JSON.parse(body); + } catch (cause) { + throw new ProtocolMismatchError( + `${provider} parseJSONResponse: malformed JSON response body: ${cause instanceof Error ? cause.message : String(cause)}`, + body, + ); + } + const response = CompleteResponse(parsed); + if (response instanceof type.errors) { + throw new ProtocolMismatchError( + `${provider} parseJSONResponse: response failed schema validation: ${response.summary}`, + parsed, + ); + } + // A non-streaming response can report failure inside a 200 body instead of + // an HTTP error code or an SSE `response.failed` event; decoding `output` + // (typically empty) as a successful empty turn would hide the failure from + // the caller entirely. + if (response.status === "failed") { + throw new ProtocolMismatchError( + `${provider} parseJSONResponse: response status is "failed": ${response.error?.message ?? "no error message"}`, + parsed, + ); + } + // A truncated body still carries the partial turn the backend managed + // to produce; throwing on it would discard usable content, so status + // "incomplete" decodes like a completed one. + const seq = 0; + const events: InferenceEvent[] = []; + // A fresh indexer per body, synthesizing indices in output[] arrival + // order — the same convention the SSE path uses on first observation of + // each item id. + let nextIndex = 0; + for (const rawItem of response.output) { + if (rawItem.type === "message") { + const item = MessageItem(rawItem); + if (item instanceof type.errors) { + throw new ProtocolMismatchError( + `${provider} parseJSONResponse: message output item failed schema validation: ${item.summary}`, + rawItem, + ); + } + for (const rawPart of item.content) { + if (rawPart.type === "output_text") { + const part = OutputTextPart(rawPart); + if (part instanceof type.errors) { + throw new ProtocolMismatchError( + `${provider} parseJSONResponse: output_text content part failed schema validation: ${part.summary}`, + rawPart, + ); + } + if (part.text.length > 0) { + events.push({ + type: "inference.text.delta", + seq, + data: { + token: part.text, + partial: EMPTY_PARTIAL, + index: nextIndex, + }, + }); + nextIndex += 1; + } + } else if (rawPart.type === "refusal") { + const part = RefusalPart(rawPart); + if (part instanceof type.errors) { + throw new ProtocolMismatchError( + `${provider} parseJSONResponse: refusal content part failed schema validation: ${part.summary}`, + rawPart, + ); + } + if (part.refusal.length > 0) { + events.push({ + type: "inference.refusal.delta", + seq, + data: { + token: part.refusal, + partial: EMPTY_PARTIAL, + index: nextIndex, + }, + }); + nextIndex += 1; + } + } + } + } else if (rawItem.type === "reasoning") { + const item = ReasoningItem(rawItem); + if (item instanceof type.errors) { + throw new ProtocolMismatchError( + `${provider} parseJSONResponse: reasoning output item failed schema validation: ${item.summary}`, + rawItem, + ); + } + const summaryText = (item.summary ?? []).map((s) => s.text).join(""); + if (summaryText.length > 0 || item.encrypted_content !== undefined) { + const index = nextIndex; + nextIndex += 1; + events.push({ + type: "inference.thinking.delta", + seq, + data: { token: summaryText, partial: EMPTY_PARTIAL, index }, + }); + if (item.encrypted_content !== undefined) { + events.push({ + type: "inference.block.signature", + seq, + data: { + signature: tagSignature(provider, item.encrypted_content), + index, + }, + }); + } + } + } else if (rawItem.type === "function_call") { + const item = FunctionCallItem(rawItem); + if (item instanceof type.errors) { + throw new ProtocolMismatchError( + `${provider} parseJSONResponse: function_call output item failed schema validation: ${item.summary}`, + rawItem, + ); + } + const index = nextIndex; + nextIndex += 1; + events.push({ + type: "inference.tool_call.start", + seq, + data: { + callId: item.call_id, + name: decodeToolName(item.name), + partial: EMPTY_PARTIAL, + index, + }, + }); + if (item.arguments.length > 0) { + events.push({ + type: "inference.tool_call.delta", + seq, + data: { + callId: String(index), + argumentFragment: item.arguments, + partial: EMPTY_PARTIAL, + index, + }, + }); + } + } + // Unknown output item kinds are protocol-legal extensions this adapter + // has nothing to do with; ignored, mirroring the SSE default case. + } + const reasonEvent = incompleteReasonEvent( + response.incomplete_details?.reason, + seq, + ); + if (reasonEvent !== undefined) events.push(reasonEvent); + events.push({ + type: "inference.usage", + seq, + data: { usage: toInferenceUsage(response.usage), source }, + }); + return events; +} + +// --------------------------------------------------------------------------- +// Factory +// --------------------------------------------------------------------------- + +function buildAdapter( + source: LastCycleSource, + quirks: ResolvedResponsesQuirks, +): ProviderAdapter { + // Re-created per request in buildRequest, not just once here — otherwise + // block indices accumulate across every request this adapter instance + // ever serves, growing the map for the life of the conversation. + let indexer = createResponsesBlockIndexer(); + const buildRequest = ( + messages: ConversationTurn[], + model: string, + options: InferenceOptions, + ): BuiltRequest => { + indexer = createResponsesBlockIndexer(); + return buildResponsesRequest( + quirks, + messages, + model, + options, + source.provider, + ); + }; + const parseResponseFromStream = (sseData: string): InferenceEvent[] => + parseResponse(sseData, indexer, source); + const parseCompleteResponse = (body: string): InferenceEvent[] => + parseJSONResponse(body, source); + return { + buildRequest, + parseResponse: parseResponseFromStream, + parseJSONResponse: parseCompleteResponse, + extractRetryAfterMs, + extractPacingDelayMs, + isStreamTerminal: isResponsesStreamTerminal, + }; +} + +/** + * `AdapterFactory` for the OpenAI Responses API wire protocol. `quirks` is + * this adapter's own `ResponsesQuirks` (an `InferenceSource.quirks` bag) + * describing exactly how this vendor's backend deviates from the shared + * protocol — headers, system-prompt placement, and content shape. An absent + * `quirks` bag resolves the same as `{}`: protocol-native defaults, not an + * error. + */ +export const createOpenAIResponsesAdapter: AdapterFactory = (source, quirks) => + buildAdapter(source, parseResponsesQuirks(quirks)); + +export const OPENAI_RESPONSES_PROVIDER = "openai-responses"; +export const OPENAI_COMPATIBLE_RESPONSES_PROVIDER = + "openai-compatible-responses"; diff --git a/packages/inference/src/providers/openai.ts b/packages/inference/src/providers/openai.ts index 867befb59..77ff6aad8 100644 --- a/packages/inference/src/providers/openai.ts +++ b/packages/inference/src/providers/openai.ts @@ -79,14 +79,15 @@ type ResolvedOpenAIQuirks = { // Request building // --------------------------------------------------------------------------- -// low, medium, and high are reasoning_effort values every OpenAI reasoning +// low, medium, and high are reasoning effort values every OpenAI reasoning // model accepts, so they pass as given. "max" names the highest level, which // is a per-model value the deployment supplies through the maxEffort quirk. -function toReasoningEffort( +// Shared with the Responses adapter so the two wires cannot drift apart. +export function wireReasoningEffort( model: string, - effort: InferenceEffort, + effort: InferenceEffort | undefined, maxEffort: "xhigh" | "max" | null, -): string { +): string | undefined { if (effort !== "max") return effort; if (maxEffort !== null) return maxEffort; warnDroppedOption( @@ -130,7 +131,7 @@ function buildRequest( model === "gpt-5.6-luna"); if (options.effort !== undefined && !forceNoReasoning) { - body["reasoning_effort"] = toReasoningEffort( + body["reasoning_effort"] = wireReasoningEffort( model, options.effort, quirks.maxEffort, @@ -352,10 +353,16 @@ function toOpenAIMessage( return [{ role: msg.role, content: "" }]; } -function filenameForDocumentMime(mimeType: string): string { +// Shared with the Responses adapter: a base64 document synthesizes a +// deterministic filename from its mimeType, since MediaSource carries no +// filename field of its own. Only PDF is supported on both wires. +export function filenameForDocumentMime( + mimeType: string, + adapter: string, +): string { if (mimeType === "application/pdf") return "document.pdf"; throw new Error( - `OpenAI Chat Completions document input currently supports ` + + `${adapter} document input currently supports ` + `application/pdf only; received mimeType: ${mimeType}`, ); } @@ -423,7 +430,10 @@ function toOpenAIContentPart(block: ContentBlock): unknown { return { type: "file", file: { - filename: filenameForDocumentMime(source.mimeType), + filename: filenameForDocumentMime( + source.mimeType, + "OpenAI Chat Completions", + ), file_data: `data:${source.mimeType};base64,${source.data}`, }, }; @@ -1055,7 +1065,9 @@ function parseJSONResponse( return events; } -function extractRetryAfterMs(headers: Headers): number | undefined { +// Shared with the Responses adapter: the Responses surface carries the same +// OpenAI rate-limit headers byte-for-byte. +export function extractRetryAfterMs(headers: Headers): number | undefined { // OpenAI's non-standard millisecond header takes priority const retryMs = headers.get("retry-after-ms"); if (retryMs !== null) { @@ -1072,7 +1084,9 @@ function extractRetryAfterMs(headers: Headers): number | undefined { return undefined; } -function extractPacingDelayMs(headers: Headers): number | undefined { +// Shared with the Responses adapter: the Responses surface carries the same +// OpenAI rate-limit headers byte-for-byte. +export function extractPacingDelayMs(headers: Headers): number | undefined { const remaining = headers.get("x-ratelimit-remaining-requests"); if (remaining === null) return undefined; const n = Number(remaining); diff --git a/packages/types/src/catalog.test.ts b/packages/types/src/catalog.test.ts index 82912db27..656c57a9f 100644 --- a/packages/types/src/catalog.test.ts +++ b/packages/types/src/catalog.test.ts @@ -13,7 +13,7 @@ import { describe("ModelProviderPlugin", () => { test("accepts every built-in key and an operator-registered key", () => { - for (const plugin of [...modelProviderPlugins, "openai-responses"]) { + for (const plugin of [...modelProviderPlugins, "my-custom-adapter"]) { expect(ModelProviderPlugin(plugin)).toBe(plugin); } }); diff --git a/packages/types/src/catalog.ts b/packages/types/src/catalog.ts index fadfbc60a..5cbc3c2fd 100644 --- a/packages/types/src/catalog.ts +++ b/packages/types/src/catalog.ts @@ -6,6 +6,8 @@ export const modelProviderPlugins = [ "anthropic", "openai", "openai-compatible", + "openai-responses", + "openai-compatible-responses", "google-genai", ] as const; // Open-ended so an operator-registered adapter (SIDECAR_ADAPTER_MANIFEST) is From 3a20bf268ebd61663d6eb000e2832bff759003ae Mon Sep 17 00:00:00 2001 From: Sawyer Date: Fri, 30 Oct 2026 15:57:01 -0700 Subject: [PATCH 2/7] Add Responses discovery builders and deployment First-party OpenAI serves a second wire protocol next to Chat Completions, and discovery can only probe what it can express, so this teaches the rig to speak Responses end to end. --- bin/lib/discover-registry.test.ts | 16 + bin/lib/discover-registry.ts | 14 + packages/inference-discovery-openai/README.md | 44 +- .../src/deployments/openai-responses.ts | 65 +++ .../inference-discovery-openai/src/index.ts | 4 + .../src/openai-responses.plugin.test.ts | 395 ++++++++++++++++++ .../src/protocol/body.ts | 4 +- .../src/protocol/iterator.ts | 48 ++- .../src/protocol/responses-body.ts | 279 +++++++++++++ .../src/protocol/responses-endpoint.ts | 3 + .../src/protocol/responses-iterator.ts | 25 ++ .../src/catalog/provider-adapter.ts | 2 + 12 files changed, 889 insertions(+), 10 deletions(-) create mode 100644 packages/inference-discovery-openai/src/deployments/openai-responses.ts create mode 100644 packages/inference-discovery-openai/src/openai-responses.plugin.test.ts create mode 100644 packages/inference-discovery-openai/src/protocol/responses-body.ts create mode 100644 packages/inference-discovery-openai/src/protocol/responses-endpoint.ts create mode 100644 packages/inference-discovery-openai/src/protocol/responses-iterator.ts diff --git a/bin/lib/discover-registry.test.ts b/bin/lib/discover-registry.test.ts index ce0f31a9c..61d33cb8b 100644 --- a/bin/lib/discover-registry.test.ts +++ b/bin/lib/discover-registry.test.ts @@ -20,6 +20,7 @@ const REQUIRED_ENV_BY_PROVIDER: Record = { "google-genai": ["GOOGLE_API_KEY"], "opencode-zen": ["OPENCODE_API_KEY", "OPENCODE_BASE_URL"], openai: ["OPENAI_API_KEY"], + "openai-responses": ["OPENAI_API_KEY"], xai: ["XAI_API_KEY"], }; @@ -31,6 +32,7 @@ describe("PLUGIN_REGISTRY provider contract", () => { "google-genai", "opencode-zen", "openai", + "openai-responses", "xai", ]); }); @@ -112,6 +114,20 @@ describe("create factory env wiring", () => { expect(() => requireEntry("openai").create({})).toThrow("OPENAI_API_KEY"); }); + test("openai-responses builds a gpt-5.5 plug-in from OPENAI_API_KEY", () => { + const plugin = requireEntry("openai-responses").create({ + OPENAI_API_KEY: "test-key", + }); + expect(plugin.name).toBe("openai-responses"); + expect(plugin.models).toContain("gpt-5.5"); + }); + + test("openai-responses raises when OPENAI_API_KEY is absent", () => { + expect(() => requireEntry("openai-responses").create({})).toThrow( + "OPENAI_API_KEY", + ); + }); + test("xai builds a grok-4.5 plug-in from XAI_API_KEY", () => { const plugin = requireEntry("xai").create({ XAI_API_KEY: "test-key", diff --git a/bin/lib/discover-registry.ts b/bin/lib/discover-registry.ts index 1f6d4eac4..945affcd8 100644 --- a/bin/lib/discover-registry.ts +++ b/bin/lib/discover-registry.ts @@ -20,6 +20,7 @@ import { } from "@intx/inference-discovery-google-genai"; import { createOpenAIPlugin, + createOpenAIResponsesPlugin, createOpencodeZenPlugin, createXaiPlugin, } from "@intx/inference-discovery-openai"; @@ -79,6 +80,14 @@ function opencodeZenCreate(env: Record): ProviderPlugin { return createOpencodeZenPlugin({ apiKey, baseUrl }); } +function openaiResponsesCreate(env: Record): ProviderPlugin { + const apiKey = env.OPENAI_API_KEY; + if (apiKey === undefined) { + throw new Error("OPENAI_API_KEY missing from validated env"); + } + return createOpenAIResponsesPlugin({ apiKey }); +} + function xaiCreate(env: Record): ProviderPlugin { const apiKey = env.XAI_API_KEY; if (apiKey === undefined) { @@ -108,6 +117,11 @@ export const PLUGIN_REGISTRY: readonly RegisteredPlugin[] = [ requiredEnv: ["OPENAI_API_KEY"], create: openaiCreate, }, + { + name: "openai-responses", + requiredEnv: ["OPENAI_API_KEY"], + create: openaiResponsesCreate, + }, { name: "xai", requiredEnv: ["XAI_API_KEY"], diff --git a/packages/inference-discovery-openai/README.md b/packages/inference-discovery-openai/README.md index 40a2645a1..e2e94a182 100644 --- a/packages/inference-discovery-openai/README.md +++ b/packages/inference-discovery-openai/README.md @@ -10,8 +10,9 @@ is organised in two layers: - `deployments/` — concrete deployments built on the protocol layer. Each deployment names a provider, lists its models, declares its auth and redaction policy, and (where needed) - overrides reasoning extraction. Three deployments ship today: the - OpenCode Zen relay, first-party OpenAI, and first-party xAI. + overrides reasoning extraction. Four deployments ship today: the + OpenCode Zen relay, first-party OpenAI (Chat Completions), first-party + OpenAI Responses, and first-party xAI. See [`@intx/inference-discovery`](../inference-discovery/README.md) for the runtime, the plug-in contract, and the `discover` CLI. @@ -88,6 +89,45 @@ limitation. | ---------------- | ------------------------------------------------------------ | | `OPENAI_API_KEY` | Sent as `Authorization: Bearer `. Redacted in fixtures. | +## OpenAI Responses + +The `openai-responses` deployment probes first-party `api.openai.com` on +the Responses wire (`/v1/responses`), under provider name +`openai-responses` (sessions land in this package's `sessions/` tree +alongside the Chat Completions deployments). The base URL is fixed to +`https://api.openai.com/v1`; the deployment reads only `OPENAI_API_KEY`. + +```ts +import { createOpenAIResponsesPlugin } from "@intx/inference-discovery-openai"; + +const plugin = createOpenAIResponsesPlugin({ + apiKey: process.env.OPENAI_API_KEY, +}); +// Hand off to runCapture from @intx/inference-discovery. +``` + +Models: the reasoning-capable first-party models (`gpt-6-astra`, +`gpt-6.1-sol`, `gpt-6.1-terra`, `gpt-6-luna`, `gpt-6-sol`, `gpt-5.6-sol`, +`gpt-5.6-terra`, `gpt-5.6-luna`, `gpt-5.5`, `gpt-5`, `gpt-5-mini`, +`gpt-5-nano`, `gpt-5.1`, `gpt-5.2`, `gpt-5.4`, `gpt-5.4-mini`, +`gpt-5.4-nano`, `o1`, `o3`, `o3-mini`, `o4-mini`). The gpt-4 family is +excluded pending verification that those models serve `/responses`. + +The Responses body builder emits `plain-text`, `plain-text-streaming`, +`function-calling`, `function-calling-multi-turn`, `reasoning-content`, +`reasoning-content-streaming`, `vision-input`, and `document-input`. +Structured output and URL-form file input are out of scope until the +runtime adapter supports them and discovery verifies them; audio, video, +image-output, code execution, and grounding are not built. Refresh the +fixtures with a live capture run (`bin/discover --provider +openai-responses --all` against a funded account). + +### Environment + +| Variable | Purpose | +| ---------------- | ------------------------------------------------------------ | +| `OPENAI_API_KEY` | Sent as `Authorization: Bearer `. Redacted in fixtures. | + ## xAI The `xai` deployment probes first-party `api.x.ai` directly, under provider diff --git a/packages/inference-discovery-openai/src/deployments/openai-responses.ts b/packages/inference-discovery-openai/src/deployments/openai-responses.ts new file mode 100644 index 000000000..049adf16f --- /dev/null +++ b/packages/inference-discovery-openai/src/deployments/openai-responses.ts @@ -0,0 +1,65 @@ +import type { ProviderPlugin } from "@intx/inference-discovery"; +import { buildAuthHeaders } from "../protocol/auth"; +import { createResponsesIterator } from "../protocol/responses-iterator"; + +const PROVIDER_NAME = "openai-responses"; + +// First-party OpenAI Responses endpoint. Like the first-party Chat +// Completions deployment, there is no configurable base URL: the deployment +// reads only OPENAI_API_KEY and always talks to api.openai.com. +const OPENAI_BASE_URL = "https://api.openai.com/v1"; + +// Reasoning-capable first-party models on the Responses wire. The gpt-4 +// family is excluded pending verification that those models serve +// `/responses`; advertising a model here only routes captures to it, while +// the support matrix stays the authority on what each model was proven to +// do. +const OPENAI_RESPONSES_MODELS: readonly string[] = [ + "gpt-6-astra", + "gpt-6.1-sol", + "gpt-6.1-terra", + "gpt-6-luna", + "gpt-6-sol", + "gpt-5.6-sol", + "gpt-5.6-terra", + "gpt-5.6-luna", + "gpt-5.5", + "gpt-5", + "gpt-5-mini", + "gpt-5-nano", + "gpt-5.1", + "gpt-5.2", + "gpt-5.4", + "gpt-5.4-mini", + "gpt-5.4-nano", + "o1", + "o3", + "o3-mini", + "o4-mini", +]; + +const REDACT_REQUEST_HEADERS: readonly string[] = ["authorization"]; +const REDACT_RESPONSE_HEADERS: readonly string[] = [ + "set-cookie", + "x-request-id", + "openai-organization", + "openai-project", +]; + +export interface CreateOpenAIResponsesPluginOpts { + apiKey: string; +} + +export function createOpenAIResponsesPlugin( + opts: CreateOpenAIResponsesPluginOpts, +): ProviderPlugin { + const { apiKey } = opts; + return { + name: PROVIDER_NAME, + models: OPENAI_RESPONSES_MODELS, + redactRequestHeaders: REDACT_REQUEST_HEADERS, + redactResponseHeaders: REDACT_RESPONSE_HEADERS, + buildAuthHeaders: () => buildAuthHeaders(apiKey), + iterateCaptureSteps: createResponsesIterator(OPENAI_BASE_URL), + }; +} diff --git a/packages/inference-discovery-openai/src/index.ts b/packages/inference-discovery-openai/src/index.ts index 26330efc5..d8bb84177 100644 --- a/packages/inference-discovery-openai/src/index.ts +++ b/packages/inference-discovery-openai/src/index.ts @@ -6,4 +6,8 @@ export { createOpenAIPlugin, type CreateOpenAIPluginOpts, } from "./deployments/openai"; +export { + createOpenAIResponsesPlugin, + type CreateOpenAIResponsesPluginOpts, +} from "./deployments/openai-responses"; export { createXaiPlugin, type CreateXaiPluginOpts } from "./deployments/xai"; diff --git a/packages/inference-discovery-openai/src/openai-responses.plugin.test.ts b/packages/inference-discovery-openai/src/openai-responses.plugin.test.ts new file mode 100644 index 000000000..5ee0159bf --- /dev/null +++ b/packages/inference-discovery-openai/src/openai-responses.plugin.test.ts @@ -0,0 +1,395 @@ +import { describe, test, expect } from "bun:test"; +import { INTENTS, SUPPORT_MATRIX } from "@intx/inference-discovery/catalog"; +import type { CaptureStep, CapturedResponse } from "@intx/inference-discovery"; +import type { Capability } from "@intx/inference-discovery/catalog"; +import { createOpenAIResponsesPlugin } from "./index"; +import { createResponsesIterator } from "./protocol/responses-iterator"; +import { + buildResponsesMultiTurnTurn1Body, + buildResponsesMultiTurnTurn2Body, + buildResponsesRequestBody, +} from "./protocol/responses-body"; + +const TEST_API_KEY = "test-key"; +const TEST_BASE_URL = "https://api.openai.com/v1"; +const TEST_RESPONSES_URL = `${TEST_BASE_URL}/responses`; + +function makePlugin() { + return createOpenAIResponsesPlugin({ apiKey: TEST_API_KEY }); +} + +function isRecord(value: unknown): value is Record { + return typeof value === "object" && value !== null && !Array.isArray(value); +} + +function collectSteps(opts: { + model: string; + capability: Capability; + responses: readonly CapturedResponse[]; +}): CaptureStep[] { + const intent = INTENTS[opts.capability]; + const iter = createResponsesIterator(TEST_BASE_URL)({ + model: opts.model, + capability: opts.capability, + intent, + }); + const steps: CaptureStep[] = []; + let i = 0; + let next = iter.next(); + while (!next.done) { + steps.push(next.value); + const response = opts.responses[i]; + i += 1; + if (response === undefined) break; + next = iter.next(response); + } + return steps; +} + +describe("createOpenAIResponsesPlugin", () => { + test("declares provider name, models, and redaction lists", () => { + const plugin = makePlugin(); + expect(plugin.name).toBe("openai-responses"); + expect([...plugin.models]).toEqual([ + "gpt-6-astra", + "gpt-6.1-sol", + "gpt-6.1-terra", + "gpt-6-luna", + "gpt-6-sol", + "gpt-5.6-sol", + "gpt-5.6-terra", + "gpt-5.6-luna", + "gpt-5.5", + "gpt-5", + "gpt-5-mini", + "gpt-5-nano", + "gpt-5.1", + "gpt-5.2", + "gpt-5.4", + "gpt-5.4-mini", + "gpt-5.4-nano", + "o1", + "o3", + "o3-mini", + "o4-mini", + ]); + expect(plugin.redactRequestHeaders).toEqual(["authorization"]); + expect(plugin.redactResponseHeaders).toEqual([ + "set-cookie", + "x-request-id", + "openai-organization", + "openai-project", + ]); + }); + + test("every openai-responses model in the support matrix is advertised", () => { + const advertised = new Set(makePlugin().models); + const matrixModels = new Set( + SUPPORT_MATRIX.filter( + (entry) => entry.provider === "openai-responses", + ).map((entry) => entry.model), + ); + const unadvertised = [...matrixModels].filter( + (model) => !advertised.has(model), + ); + expect(unadvertised).toEqual([]); + }); + + test("buildAuthHeaders attaches a Bearer token", () => { + expect(makePlugin().buildAuthHeaders()).toEqual({ + Authorization: `Bearer ${TEST_API_KEY}`, + }); + }); + + test("targets the first-party api.openai.com responses endpoint", () => { + const plugin = makePlugin(); + const iter = plugin.iterateCaptureSteps({ + model: "gpt-5.5", + capability: "plain-text", + intent: INTENTS["plain-text"], + }); + const first = iter.next(); + if (first.done) throw new Error("expected a capture step"); + expect(first.value.url).toBe("https://api.openai.com/v1/responses"); + }); +}); + +describe("buildResponsesRequestBody capability dispatch", () => { + test("plain-text returns a user message with no stream flag", () => { + const body = buildResponsesRequestBody({ + model: "gpt-5.5", + capability: "plain-text", + intent: INTENTS["plain-text"], + }); + if (!isRecord(body)) throw new Error("expected record body"); + expect(body.model).toBe("gpt-5.5"); + expect(body.stream).toBeUndefined(); + const input = body.input; + if (!Array.isArray(input)) throw new Error("expected input array"); + expect(input).toEqual([ + { type: "message", role: "user", content: INTENTS["plain-text"].prompt }, + ]); + }); + + test("plain-text-streaming sets stream: true", () => { + const body = buildResponsesRequestBody({ + model: "gpt-5.5", + capability: "plain-text-streaming", + intent: INTENTS["plain-text-streaming"], + }); + if (!isRecord(body)) throw new Error("expected record body"); + expect(body.stream).toBe(true); + }); + + test("function-calling produces flat tools with auto tool_choice", () => { + const body = buildResponsesRequestBody({ + model: "gpt-5.5", + capability: "function-calling", + intent: INTENTS["function-calling"], + }); + if (!isRecord(body)) throw new Error("expected record body"); + expect(body.tools).toEqual([ + { + type: "function", + name: "get_weather", + description: "Look up the current weather for a city.", + parameters: { + type: "object", + properties: { + location: { + type: "string", + description: "City and optional region, e.g. 'Boston, MA'.", + }, + }, + required: ["location"], + }, + }, + ]); + expect(body.tool_choice).toBe("auto"); + }); + + test("function-calling-multi-turn throws (multi-step capability)", () => { + expect(() => + buildResponsesRequestBody({ + model: "gpt-5.5", + capability: "function-calling-multi-turn", + intent: INTENTS["function-calling-multi-turn"], + }), + ).toThrow(/multi-step capability/); + }); + + test("reasoning-content requests medium effort with a detailed summary", () => { + const body = buildResponsesRequestBody({ + model: "gpt-5.5", + capability: "reasoning-content", + intent: INTENTS["reasoning-content"], + }); + if (!isRecord(body)) throw new Error("expected record body"); + expect(body.reasoning).toEqual({ effort: "medium", summary: "detailed" }); + expect(body.stream).toBeUndefined(); + }); + + test("function-calling-multi-turn-streaming streams a single tool-call turn", () => { + const body = buildResponsesRequestBody({ + model: "gpt-5-mini", + capability: "function-calling-multi-turn-streaming", + intent: INTENTS["function-calling-multi-turn-streaming"], + }); + if (!isRecord(body)) throw new Error("expected record body"); + expect(body.stream).toBe(true); + expect(body.tool_choice).toBe("auto"); + if (!Array.isArray(body.tools)) throw new Error("expected tools array"); + }); + + test("reasoning-content-streaming sets stream: true", () => { + const body = buildResponsesRequestBody({ + model: "gpt-5.5", + capability: "reasoning-content-streaming", + intent: INTENTS["reasoning-content-streaming"], + }); + if (!isRecord(body)) throw new Error("expected record body"); + expect(body.stream).toBe(true); + }); + + test("vision-input embeds image as a data URI part", () => { + const body = buildResponsesRequestBody({ + model: "gpt-5.5", + capability: "vision-input", + intent: INTENTS["vision-input"], + }); + if (!isRecord(body)) throw new Error("expected record body"); + const input = body.input; + if (!Array.isArray(input) || !isRecord(input[0])) { + throw new Error("expected input[0] to be a record"); + } + const content = input[0].content; + if (!Array.isArray(content)) throw new Error("expected content array"); + const imagePart = content.find( + (p) => isRecord(p) && p.type === "input_image", + ); + if (!isRecord(imagePart)) throw new Error("expected input_image part"); + expect(typeof imagePart.image_url).toBe("string"); + expect( + String(imagePart.image_url).startsWith("data:image/jpeg;base64,"), + ).toBe(true); + }); + + test("document-input embeds PDF as an input_file part", () => { + const body = buildResponsesRequestBody({ + model: "gpt-5.5", + capability: "document-input", + intent: INTENTS["document-input"], + }); + if (!isRecord(body)) throw new Error("expected record body"); + const input = body.input; + if (!Array.isArray(input) || !isRecord(input[0])) { + throw new Error("expected input[0] to be a record"); + } + const content = input[0].content; + if (!Array.isArray(content)) throw new Error("expected content array"); + const filePart = content.find( + (p) => isRecord(p) && p.type === "input_file", + ); + if (!isRecord(filePart)) throw new Error("expected input_file part"); + expect(filePart.filename).toBe("sample.pdf"); + expect(typeof filePart.file_data).toBe("string"); + expect( + String(filePart.file_data).startsWith("data:application/pdf;base64,"), + ).toBe(true); + }); + + test("unsupported capabilities throw CapabilityNotBuildableError", () => { + for (const capability of [ + "audio-input", + "video-input", + "structured-output", + "structured-output-streaming", + "image-output", + "code-execution", + "grounding", + ] as const) { + expect(() => + buildResponsesRequestBody({ + model: "gpt-5.5", + capability, + intent: INTENTS[capability], + }), + ).toThrow(); + } + }); +}); + +describe("responses multi-turn iterator", () => { + const turn1Response: CapturedResponse = { + status: 200, + headers: {}, + parsed: { + id: "resp-1", + output: [ + { + type: "function_call", + id: "fc-1", + call_id: "call_test", + name: "get_weather", + arguments: '{"location":"Boston, MA"}', + }, + ], + }, + bytes: null, + }; + + test("turn-2 replays the function_call and appends the tool output", () => { + const steps = collectSteps({ + model: "gpt-5.5", + capability: "function-calling-multi-turn", + responses: [turn1Response], + }); + expect(steps.length).toBe(2); + const [step1, step2] = steps; + if (step1 === undefined || step2 === undefined) { + throw new Error("expected two steps for multi-turn"); + } + expect(step1.url).toBe(TEST_RESPONSES_URL); + expect(step2.url).toBe(TEST_RESPONSES_URL); + if (!isRecord(step2.body)) throw new Error("expected record turn-2 body"); + expect(step2.body.input).toEqual([ + { + type: "message", + role: "user", + content: INTENTS["function-calling-multi-turn"].prompt, + }, + { + type: "function_call", + call_id: "call_test", + name: "get_weather", + arguments: '{"location":"Boston, MA"}', + }, + { + type: "function_call_output", + call_id: "call_test", + output: + '{"location":"Boston, MA","temperatureF":68,"conditions":"clear"}', + }, + ]); + expect(step2.body.tool_choice).toBe("auto"); + expect(step2.body.store).toBe(false); + expect(step2.body.include).toEqual(["reasoning.encrypted_content"]); + }); + + test("turn-2 replays turn-1 reasoning items in the adapter's shape", () => { + const reasoning = { + type: "reasoning", + id: "rs-1", + encrypted_content: "blob", + summary: [], + }; + const withReasoning: CapturedResponse = { + status: 200, + headers: {}, + parsed: { + id: "resp-1", + output: [ + reasoning, + { + type: "function_call", + id: "fc-1", + call_id: "call_test", + name: "get_weather", + arguments: '{"location":"Boston, MA"}', + }, + ], + }, + bytes: null, + }; + const steps = collectSteps({ + model: "gpt-5.5", + capability: "function-calling-multi-turn", + responses: [withReasoning], + }); + const step2 = steps[1]; + if (!isRecord(step2?.body)) throw new Error("expected record turn-2 body"); + const input = step2.body.input; + if (!Array.isArray(input)) throw new Error("expected input array"); + // The adapter replays only type, summary, and encrypted_content — + // never the server's id — so the fixture must prove that shape. + expect(input[1]).toEqual({ + type: "reasoning", + summary: [], + encrypted_content: "blob", + }); + }); + + test("turn-2 without a function_call in turn-1 throws", () => { + expect(() => + buildResponsesMultiTurnTurn2Body({ + model: "gpt-5.5", + intent: INTENTS["function-calling-multi-turn"], + turn1Body: buildResponsesMultiTurnTurn1Body({ + model: "gpt-5.5", + intent: INTENTS["function-calling-multi-turn"], + }), + turn1Response: { output: [{ type: "message" }] }, + }), + ).toThrow(/no function_call/); + }); +}); diff --git a/packages/inference-discovery-openai/src/protocol/body.ts b/packages/inference-discovery-openai/src/protocol/body.ts index 0e09e3af5..e0035b8d9 100644 --- a/packages/inference-discovery-openai/src/protocol/body.ts +++ b/packages/inference-discovery-openai/src/protocol/body.ts @@ -62,7 +62,7 @@ function mimeTypeFor(ref: MediaRef): string { throw new Error(`unsupported media kind: ${String(ref.kind)}`); } -function readMediaDataUri(ref: MediaRef): string { +export function readMediaDataUri(ref: MediaRef): string { const abs = resolveMediaPath(ref); const bytes = readFileSync(abs); const mime = mimeTypeFor(ref); @@ -126,7 +126,7 @@ function isRecord(value: unknown): value is Record { return typeof value === "object" && value !== null && !Array.isArray(value); } -function findToolFollowUp(intent: CapabilityIntent): { +export function findToolFollowUp(intent: CapabilityIntent): { toolName: string; content: string; } { diff --git a/packages/inference-discovery-openai/src/protocol/iterator.ts b/packages/inference-discovery-openai/src/protocol/iterator.ts index b6ddf5cab..9a959ae79 100644 --- a/packages/inference-discovery-openai/src/protocol/iterator.ts +++ b/packages/inference-discovery-openai/src/protocol/iterator.ts @@ -1,4 +1,7 @@ -import { type Capability } from "@intx/inference-discovery/catalog"; +import { + type Capability, + type CapabilityIntent, +} from "@intx/inference-discovery/catalog"; import type { CaptureStep, CapturedResponse, @@ -15,8 +18,28 @@ const MULTI_TURN_CAPABILITIES: ReadonlySet = new Set([ "function-calling-multi-turn", ]); -export function createOpenaiIterator( +// The four wire-specific pieces of a capture iterator: the endpoint URL +// plus the three body builders. The Chat and Responses iterators share +// the multi-turn/single-step flow and differ only in these functions. +export interface CaptureBuilders { + buildURL: (baseUrl: string) => string; + buildTurn1Body: (opts: { model: string; intent: CapabilityIntent }) => TBody; + buildTurn2Body: (opts: { + model: string; + intent: CapabilityIntent; + turn1Body: TBody; + turn1Response: unknown; + }) => TBody; + buildSingleBody: (opts: { + model: string; + capability: Capability; + intent: CapabilityIntent; + }) => unknown; +} + +export function createCaptureIterator( baseUrl: string, + builders: CaptureBuilders, ): ( opts: IterateCaptureStepsOpts, ) => Generator { @@ -24,16 +47,16 @@ export function createOpenaiIterator( opts: IterateCaptureStepsOpts, ): Generator { const { model, capability, intent } = opts; - const url = buildEndpointURL(baseUrl); + const url = builders.buildURL(baseUrl); if (MULTI_TURN_CAPABILITIES.has(capability)) { - const turn1 = buildMultiTurnTurn1Body({ model, intent }); + const turn1 = builders.buildTurn1Body({ model, intent }); const turn1Response = yield { kind: "json", url, body: turn1, }; - const turn2 = buildMultiTurnTurn2Body({ + const turn2 = builders.buildTurn2Body({ model, intent, turn1Body: turn1, @@ -50,7 +73,20 @@ export function createOpenaiIterator( yield { kind: "json", url, - body: buildRequestBody({ model, capability, intent }), + body: builders.buildSingleBody({ model, capability, intent }), }; }; } + +export function createOpenaiIterator( + baseUrl: string, +): ( + opts: IterateCaptureStepsOpts, +) => Generator { + return createCaptureIterator(baseUrl, { + buildURL: buildEndpointURL, + buildTurn1Body: buildMultiTurnTurn1Body, + buildTurn2Body: buildMultiTurnTurn2Body, + buildSingleBody: buildRequestBody, + }); +} diff --git a/packages/inference-discovery-openai/src/protocol/responses-body.ts b/packages/inference-discovery-openai/src/protocol/responses-body.ts new file mode 100644 index 000000000..f708a96ab --- /dev/null +++ b/packages/inference-discovery-openai/src/protocol/responses-body.ts @@ -0,0 +1,279 @@ +import { basename } from "node:path"; +import { + CapabilityNotBuildableError, + type Capability, + type CapabilityIntent, + type MediaRef, +} from "@intx/inference-discovery/catalog"; +import { findToolFollowUp, readMediaDataUri } from "./body"; + +export interface ResponsesRequest { + model: string; + input: unknown[]; + stream?: boolean; + tools?: unknown[]; + tool_choice?: "auto"; + reasoning?: { effort: string; summary?: "auto" | "detailed" }; + store?: boolean; + include?: string[]; +} + +function buildTextInput(intent: CapabilityIntent): unknown[] { + return [{ type: "message", role: "user", content: intent.prompt }]; +} + +function buildToolDecl(intent: CapabilityIntent): unknown[] { + if (!intent.tools || intent.tools.length === 0) { + throw new Error("intent has no tools but capability requires them"); + } + // Responses function tools are flat — name/description/parameters sit + // beside `type`, not nested under a `function` key (unlike Chat + // Completions). + return intent.tools.map((tool) => ({ + type: "function", + name: tool.name, + description: tool.description, + parameters: tool.parameters, + })); +} + +function buildPlainTextBody( + model: string, + intent: CapabilityIntent, + stream: boolean, +): ResponsesRequest { + const body: ResponsesRequest = { model, input: buildTextInput(intent) }; + if (stream) body.stream = true; + return body; +} + +function buildFunctionCallingBody( + model: string, + intent: CapabilityIntent, + stream: boolean, +): ResponsesRequest { + const body: ResponsesRequest = { + model, + input: buildTextInput(intent), + tools: buildToolDecl(intent), + tool_choice: "auto", + }; + if (stream) body.stream = true; + return body; +} + +export function buildResponsesMultiTurnTurn1Body(opts: { + model: string; + intent: CapabilityIntent; +}): ResponsesRequest { + return buildFunctionCallingBody(opts.model, opts.intent, false); +} + +function isRecord(value: unknown): value is Record { + return typeof value === "object" && value !== null && !Array.isArray(value); +} + +function extractOutputItems(parsed: unknown): unknown[] { + if (!isRecord(parsed)) { + throw new Error("multi-turn: turn-1 response is not a JSON object"); + } + const output = parsed.output; + if (!Array.isArray(output)) { + throw new Error("multi-turn: turn-1 response has no output array"); + } + return output; +} + +function extractFirstFunctionCall(output: unknown[]): { + callId: string; + name: string; + args: string; +} { + for (const item of output) { + if (!isRecord(item) || item.type !== "function_call") continue; + const { call_id, name, arguments: args } = item; + if ( + typeof call_id !== "string" || + call_id.length === 0 || + typeof name !== "string" || + name.length === 0 || + typeof args !== "string" + ) { + throw new Error( + "multi-turn: turn-1 function_call item has no usable call_id/name/arguments", + ); + } + return { callId: call_id, name, args }; + } + throw new Error("multi-turn: turn-1 response output has no function_call"); +} + +export function buildResponsesMultiTurnTurn2Body(opts: { + model: string; + intent: CapabilityIntent; + turn1Body: ResponsesRequest; + turn1Response: unknown; +}): ResponsesRequest { + const output = extractOutputItems(opts.turn1Response); + const call = extractFirstFunctionCall(output); + const tool = findToolFollowUp(opts.intent); + // The adapter runs with `store: false` and replays the encrypted reasoning + // item, so turn-2 exercises exactly that path: unstored, with the + // reasoning item replayed in the adapter's shape (no `id` — the adapter + // sends only type, summary, and encrypted_content). Replaying the + // server's `rs_...` id instead would prove a stored-item lookup, not the + // encrypted replay the adapter depends on. + const reasoningItems = output + .filter( + (item): item is Record => + isRecord(item) && item.type === "reasoning", + ) + .map((item) => ({ + type: "reasoning", + summary: item["summary"] ?? [], + encrypted_content: item["encrypted_content"], + })); + const input: unknown[] = [ + ...opts.turn1Body.input, + ...reasoningItems, + { + type: "function_call", + call_id: call.callId, + name: call.name, + arguments: call.args, + }, + { + type: "function_call_output", + call_id: call.callId, + output: tool.content, + }, + ]; + const body: ResponsesRequest = { + model: opts.model, + input, + store: false, + include: ["reasoning.encrypted_content"], + }; + if (opts.turn1Body.tools !== undefined) { + body.tools = opts.turn1Body.tools; + body.tool_choice = "auto"; + } + return body; +} + +function buildReasoningBody( + model: string, + intent: CapabilityIntent, + stream: boolean, +): ResponsesRequest { + // `summary: "detailed"` forces the backend to return summary text: without + // it the server reports `"summary": null` and the fixtures cannot prove + // summary text reaches `inference.thinking`. + const body: ResponsesRequest = { + model, + input: buildTextInput(intent), + reasoning: { effort: "medium", summary: "detailed" }, + }; + if (stream) body.stream = true; + return body; +} + +// Shared skeleton for Responses multimodal user turns: text prompt plus one +// typed part per media ref. Vision and document differ only in the expected +// kind and the part shape. +function buildMediaInputBody( + model: string, + intent: CapabilityIntent, + capability: string, + expectedKind: MediaRef["kind"], + toPart: (ref: MediaRef) => unknown, +): ResponsesRequest { + if (!intent.media || intent.media.length === 0) { + throw new Error(`intent has no media but ${capability} requires it`); + } + const parts: unknown[] = [{ type: "input_text", text: intent.prompt }]; + for (const ref of intent.media) { + if (ref.kind !== expectedKind) { + throw new Error( + `${capability} only accepts ${expectedKind} media, got: ${ref.kind}`, + ); + } + parts.push(toPart(ref)); + } + return { + model, + input: [{ type: "message", role: "user", content: parts }], + }; +} + +function imagePart(ref: MediaRef): unknown { + return { type: "input_image", image_url: readMediaDataUri(ref) }; +} + +function documentPart(ref: MediaRef): unknown { + const filename = basename(ref.path); + if (filename.length === 0) { + throw new Error( + "document-input media path has an empty basename; the Responses input_file part requires a filename", + ); + } + return { + type: "input_file", + filename, + file_data: readMediaDataUri(ref), + }; +} + +export interface BuildResponsesRequestBodyArgs { + model: string; + capability: Capability; + intent: CapabilityIntent; +} + +export function buildResponsesRequestBody( + args: BuildResponsesRequestBodyArgs, +): unknown { + const { model, capability, intent } = args; + switch (capability) { + case "plain-text": + return buildPlainTextBody(model, intent, false); + case "plain-text-streaming": + return buildPlainTextBody(model, intent, true); + case "function-calling": + return buildFunctionCallingBody(model, intent, false); + case "function-calling-multi-turn": + throw new Error( + "function-calling-multi-turn is a multi-step capability; use buildResponsesMultiTurnTurn1Body / buildResponsesMultiTurnTurn2Body via iterateCaptureSteps", + ); + // Single-step streamed tool call (mirrors the Anthropic plug-in): the + // live SSE proves arguments arrive as `function_call_arguments.delta` + // rather than only in the terminal `.done` envelope. + case "function-calling-multi-turn-streaming": + return buildFunctionCallingBody(model, intent, true); + case "reasoning-content": + return buildReasoningBody(model, intent, false); + case "reasoning-content-streaming": + return buildReasoningBody(model, intent, true); + case "vision-input": + return buildMediaInputBody( + model, + intent, + "vision-input", + "image", + imagePart, + ); + case "document-input": + return buildMediaInputBody( + model, + intent, + "document-input", + "document", + documentPart, + ); + default: + throw new CapabilityNotBuildableError( + capability, + `Responses protocol: capability "${capability}" not implemented`, + ); + } +} diff --git a/packages/inference-discovery-openai/src/protocol/responses-endpoint.ts b/packages/inference-discovery-openai/src/protocol/responses-endpoint.ts new file mode 100644 index 000000000..ab112f25f --- /dev/null +++ b/packages/inference-discovery-openai/src/protocol/responses-endpoint.ts @@ -0,0 +1,3 @@ +export function buildResponsesURL(baseUrl: string): string { + return `${baseUrl}/responses`; +} diff --git a/packages/inference-discovery-openai/src/protocol/responses-iterator.ts b/packages/inference-discovery-openai/src/protocol/responses-iterator.ts new file mode 100644 index 000000000..c95fbc2a5 --- /dev/null +++ b/packages/inference-discovery-openai/src/protocol/responses-iterator.ts @@ -0,0 +1,25 @@ +import type { + CaptureStep, + CapturedResponse, + IterateCaptureStepsOpts, +} from "@intx/inference-discovery"; +import { createCaptureIterator } from "./iterator"; +import { buildResponsesURL } from "./responses-endpoint"; +import { + buildResponsesMultiTurnTurn1Body, + buildResponsesMultiTurnTurn2Body, + buildResponsesRequestBody, +} from "./responses-body"; + +export function createResponsesIterator( + baseUrl: string, +): ( + opts: IterateCaptureStepsOpts, +) => Generator { + return createCaptureIterator(baseUrl, { + buildURL: buildResponsesURL, + buildTurn1Body: buildResponsesMultiTurnTurn1Body, + buildTurn2Body: buildResponsesMultiTurnTurn2Body, + buildSingleBody: buildResponsesRequestBody, + }); +} diff --git a/packages/inference-discovery/src/catalog/provider-adapter.ts b/packages/inference-discovery/src/catalog/provider-adapter.ts index 89e6dbdda..8d28d3b6f 100644 --- a/packages/inference-discovery/src/catalog/provider-adapter.ts +++ b/packages/inference-discovery/src/catalog/provider-adapter.ts @@ -22,6 +22,7 @@ const CATALOG_TO_ADAPTER: Record = { anthropic: "anthropic", openai: "openai-compatible", + "openai-responses": "openai-responses", "opencode-zen": "openai-compatible", xai: "openai-compatible", "google-genai": "google-genai", @@ -47,6 +48,7 @@ const CATALOG_TO_BASE_URL: Record = { // source the production seed data configures. "google-genai": "https://generativelanguage.googleapis.com", openai: "https://api.openai.com/v1", + "openai-responses": "https://api.openai.com/v1", "opencode-zen": "https://opencode.ai/zen/v1", xai: "https://api.x.ai/v1", }; From 8165b24ffdf6b6ea20d9d45a37fce458d1a5a67f Mon Sep 17 00:00:00 2001 From: Sawyer Date: Fri, 30 Oct 2026 15:57:27 -0700 Subject: [PATCH 3/7] Capture Responses fixtures for ten models Fifty-four live exchanges across streaming, buffered, tool follow-up, reasoning, vision, and document flows. Matrix rows cite the fixtures as captured evidence. --- .../exchanges/0/request-headers.json | 4 + .../document-input/exchanges/0/request.json | 20 + .../exchanges/0/response-headers.json | 26 + .../document-input/exchanges/0/response.json | 101 +++ .../gpt-5-mini/document-input/session.json | 11 + .../exchanges/0/request-headers.json | 4 + .../exchanges/0/request.json | 31 + .../exchanges/0/response-headers.json | 25 + .../exchanges/0/response.sse | 45 ++ .../session.json | 11 + .../dispatches/0-get_weather.json | 6 + .../exchanges/0/request-headers.json | 4 + .../exchanges/0/request.json | 30 + .../exchanges/0/response-headers.json | 26 + .../exchanges/0/response.json | 119 ++++ .../exchanges/1/request-headers.json | 4 + .../exchanges/1/request.json | 50 ++ .../exchanges/1/response-headers.json | 26 + .../exchanges/1/response.json | 118 ++++ .../function-calling-multi-turn/session.json | 11 + .../exchanges/0/request-headers.json | 4 + .../function-calling/exchanges/0/request.json | 30 + .../exchanges/0/response-headers.json | 26 + .../exchanges/0/response.json | 116 ++++ .../gpt-5-mini/function-calling/session.json | 11 + .../exchanges/0/request-headers.json | 4 + .../exchanges/0/request.json | 11 + .../exchanges/0/response-headers.json | 25 + .../exchanges/0/response.sse | 51 ++ .../plain-text-streaming/session.json | 11 + .../exchanges/0/request-headers.json | 4 + .../plain-text/exchanges/0/request.json | 10 + .../exchanges/0/response-headers.json | 26 + .../plain-text/exchanges/0/response.json | 101 +++ .../gpt-5-mini/plain-text/session.json | 11 + .../exchanges/0/request-headers.json | 4 + .../exchanges/0/request.json | 15 + .../exchanges/0/response-headers.json | 25 + .../exchanges/0/response.sse | 654 ++++++++++++++++++ .../reasoning-content-streaming/session.json | 11 + .../exchanges/0/request-headers.json | 4 + .../exchanges/0/request.json | 14 + .../exchanges/0/response-headers.json | 26 + .../exchanges/0/response.json | 106 +++ .../gpt-5-mini/reasoning-content/session.json | 11 + .../exchanges/0/request-headers.json | 4 + .../vision-input/exchanges/0/request.json | 19 + .../exchanges/0/response-headers.json | 29 + .../vision-input/exchanges/0/response.json | 101 +++ .../gpt-5-mini/vision-input/session.json | 11 + .../dispatches/0-get_weather.json | 6 + .../exchanges/0/request-headers.json | 4 + .../exchanges/0/request.json | 30 + .../exchanges/0/response-headers.json | 26 + .../exchanges/0/response.json | 109 +++ .../exchanges/1/request-headers.json | 4 + .../exchanges/1/request.json | 45 ++ .../exchanges/1/response-headers.json | 26 + .../exchanges/1/response.json | 116 ++++ .../function-calling-multi-turn/session.json | 11 + .../exchanges/0/request-headers.json | 4 + .../exchanges/0/request.json | 11 + .../exchanges/0/response-headers.json | 25 + .../exchanges/0/response.sse | 51 ++ .../gpt-5.5/plain-text-streaming/session.json | 11 + .../exchanges/0/request-headers.json | 4 + .../plain-text/exchanges/0/request.json | 10 + .../exchanges/0/response-headers.json | 26 + .../plain-text/exchanges/0/response.json | 102 +++ .../gpt-5.5/plain-text/session.json | 11 + .../exchanges/0/request-headers.json | 4 + .../exchanges/0/request.json | 14 + .../exchanges/0/response-headers.json | 26 + .../exchanges/0/response.json | 107 +++ .../gpt-5.5/reasoning-content/session.json | 11 + .../dispatches/0-get_weather.json | 6 + .../exchanges/0/request-headers.json | 4 + .../exchanges/0/request.json | 30 + .../exchanges/0/response-headers.json | 26 + .../exchanges/0/response.json | 109 +++ .../exchanges/1/request-headers.json | 4 + .../exchanges/1/request.json | 45 ++ .../exchanges/1/response-headers.json | 26 + .../exchanges/1/response.json | 116 ++++ .../function-calling-multi-turn/session.json | 11 + .../exchanges/0/request-headers.json | 4 + .../exchanges/0/request.json | 11 + .../exchanges/0/response-headers.json | 25 + .../exchanges/0/response.sse | 45 ++ .../plain-text-streaming/session.json | 11 + .../exchanges/0/request-headers.json | 4 + .../plain-text/exchanges/0/request.json | 10 + .../exchanges/0/response-headers.json | 26 + .../plain-text/exchanges/0/response.json | 95 +++ .../gpt-5.6-luna/plain-text/session.json | 11 + .../exchanges/0/request-headers.json | 4 + .../exchanges/0/request.json | 14 + .../exchanges/0/response-headers.json | 26 + .../exchanges/0/response.json | 107 +++ .../reasoning-content/session.json | 11 + .../dispatches/0-get_weather.json | 6 + .../exchanges/0/request-headers.json | 4 + .../exchanges/0/request.json | 30 + .../exchanges/0/response-headers.json | 26 + .../exchanges/0/response.json | 109 +++ .../exchanges/1/request-headers.json | 4 + .../exchanges/1/request.json | 45 ++ .../exchanges/1/response-headers.json | 26 + .../exchanges/1/response.json | 116 ++++ .../function-calling-multi-turn/session.json | 11 + .../exchanges/0/request-headers.json | 4 + .../exchanges/0/request.json | 11 + .../exchanges/0/response-headers.json | 25 + .../exchanges/0/response.sse | 45 ++ .../plain-text-streaming/session.json | 11 + .../exchanges/0/request-headers.json | 4 + .../plain-text/exchanges/0/request.json | 10 + .../exchanges/0/response-headers.json | 26 + .../plain-text/exchanges/0/response.json | 95 +++ .../gpt-5.6-sol/plain-text/session.json | 11 + .../exchanges/0/request-headers.json | 4 + .../exchanges/0/request.json | 14 + .../exchanges/0/response-headers.json | 26 + .../exchanges/0/response.json | 107 +++ .../reasoning-content/session.json | 11 + .../dispatches/0-get_weather.json | 6 + .../exchanges/0/request-headers.json | 4 + .../exchanges/0/request.json | 30 + .../exchanges/0/response-headers.json | 26 + .../exchanges/0/response.json | 109 +++ .../exchanges/1/request-headers.json | 4 + .../exchanges/1/request.json | 45 ++ .../exchanges/1/response-headers.json | 26 + .../exchanges/1/response.json | 116 ++++ .../function-calling-multi-turn/session.json | 11 + .../exchanges/0/request-headers.json | 4 + .../exchanges/0/request.json | 11 + .../exchanges/0/response-headers.json | 25 + .../exchanges/0/response.sse | 45 ++ .../plain-text-streaming/session.json | 11 + .../exchanges/0/request-headers.json | 4 + .../plain-text/exchanges/0/request.json | 10 + .../exchanges/0/response-headers.json | 26 + .../plain-text/exchanges/0/response.json | 95 +++ .../gpt-5.6-terra/plain-text/session.json | 11 + .../exchanges/0/request-headers.json | 4 + .../exchanges/0/request.json | 14 + .../exchanges/0/response-headers.json | 26 + .../exchanges/0/response.json | 107 +++ .../reasoning-content/session.json | 11 + .../dispatches/0-get_weather.json | 6 + .../exchanges/0/request-headers.json | 4 + .../exchanges/0/request.json | 30 + .../exchanges/0/response-headers.json | 26 + .../exchanges/0/response.json | 109 +++ .../exchanges/1/request-headers.json | 4 + .../exchanges/1/request.json | 45 ++ .../exchanges/1/response-headers.json | 26 + .../exchanges/1/response.json | 116 ++++ .../function-calling-multi-turn/session.json | 11 + .../exchanges/0/request-headers.json | 4 + .../exchanges/0/request.json | 11 + .../exchanges/0/response-headers.json | 25 + .../exchanges/0/response.sse | 45 ++ .../plain-text-streaming/session.json | 11 + .../exchanges/0/request-headers.json | 4 + .../plain-text/exchanges/0/request.json | 10 + .../exchanges/0/response-headers.json | 26 + .../plain-text/exchanges/0/response.json | 102 +++ .../gpt-6-astra/plain-text/session.json | 11 + .../exchanges/0/request-headers.json | 4 + .../exchanges/0/request.json | 14 + .../exchanges/0/response-headers.json | 26 + .../exchanges/0/response.json | 107 +++ .../reasoning-content/session.json | 11 + .../dispatches/0-get_weather.json | 6 + .../exchanges/0/request-headers.json | 4 + .../exchanges/0/request.json | 30 + .../exchanges/0/response-headers.json | 26 + .../exchanges/0/response.json | 109 +++ .../exchanges/1/request-headers.json | 4 + .../exchanges/1/request.json | 45 ++ .../exchanges/1/response-headers.json | 26 + .../exchanges/1/response.json | 116 ++++ .../function-calling-multi-turn/session.json | 11 + .../exchanges/0/request-headers.json | 4 + .../exchanges/0/request.json | 11 + .../exchanges/0/response-headers.json | 25 + .../exchanges/0/response.sse | 45 ++ .../plain-text-streaming/session.json | 11 + .../exchanges/0/request-headers.json | 4 + .../plain-text/exchanges/0/request.json | 10 + .../exchanges/0/response-headers.json | 26 + .../plain-text/exchanges/0/response.json | 102 +++ .../gpt-6-luna/plain-text/session.json | 11 + .../exchanges/0/request-headers.json | 4 + .../exchanges/0/request.json | 14 + .../exchanges/0/response-headers.json | 26 + .../exchanges/0/response.json | 107 +++ .../gpt-6-luna/reasoning-content/session.json | 11 + .../dispatches/0-get_weather.json | 6 + .../exchanges/0/request-headers.json | 4 + .../exchanges/0/request.json | 30 + .../exchanges/0/response-headers.json | 26 + .../exchanges/0/response.json | 109 +++ .../exchanges/1/request-headers.json | 4 + .../exchanges/1/request.json | 45 ++ .../exchanges/1/response-headers.json | 26 + .../exchanges/1/response.json | 116 ++++ .../function-calling-multi-turn/session.json | 11 + .../exchanges/0/request-headers.json | 4 + .../exchanges/0/request.json | 11 + .../exchanges/0/response-headers.json | 25 + .../exchanges/0/response.sse | 45 ++ .../plain-text-streaming/session.json | 11 + .../exchanges/0/request-headers.json | 4 + .../plain-text/exchanges/0/request.json | 10 + .../exchanges/0/response-headers.json | 26 + .../plain-text/exchanges/0/response.json | 95 +++ .../gpt-6-sol/plain-text/session.json | 11 + .../exchanges/0/request-headers.json | 4 + .../exchanges/0/request.json | 14 + .../exchanges/0/response-headers.json | 26 + .../exchanges/0/response.json | 107 +++ .../gpt-6-sol/reasoning-content/session.json | 11 + .../dispatches/0-get_weather.json | 6 + .../exchanges/0/request-headers.json | 4 + .../exchanges/0/request.json | 30 + .../exchanges/0/response-headers.json | 26 + .../exchanges/0/response.json | 109 +++ .../exchanges/1/request-headers.json | 4 + .../exchanges/1/request.json | 45 ++ .../exchanges/1/response-headers.json | 26 + .../exchanges/1/response.json | 116 ++++ .../function-calling-multi-turn/session.json | 11 + .../exchanges/0/request-headers.json | 4 + .../exchanges/0/request.json | 11 + .../exchanges/0/response-headers.json | 25 + .../exchanges/0/response.sse | 51 ++ .../plain-text-streaming/session.json | 11 + .../exchanges/0/request-headers.json | 4 + .../plain-text/exchanges/0/request.json | 10 + .../exchanges/0/response-headers.json | 26 + .../plain-text/exchanges/0/response.json | 95 +++ .../gpt-6.1-sol/plain-text/session.json | 11 + .../exchanges/0/request-headers.json | 4 + .../exchanges/0/request.json | 14 + .../exchanges/0/response-headers.json | 26 + .../exchanges/0/response.json | 107 +++ .../reasoning-content/session.json | 11 + .../dispatches/0-get_weather.json | 6 + .../exchanges/0/request-headers.json | 4 + .../exchanges/0/request.json | 30 + .../exchanges/0/response-headers.json | 26 + .../exchanges/0/response.json | 111 +++ .../exchanges/1/request-headers.json | 4 + .../exchanges/1/request.json | 45 ++ .../exchanges/1/response-headers.json | 26 + .../exchanges/1/response.json | 118 ++++ .../function-calling-multi-turn/session.json | 11 + .../exchanges/0/request-headers.json | 4 + .../exchanges/0/request.json | 11 + .../exchanges/0/response-headers.json | 25 + .../exchanges/0/response.sse | 45 ++ .../plain-text-streaming/session.json | 11 + .../exchanges/0/request-headers.json | 4 + .../plain-text/exchanges/0/request.json | 10 + .../exchanges/0/response-headers.json | 26 + .../plain-text/exchanges/0/response.json | 97 +++ .../gpt-6.1-terra/plain-text/session.json | 11 + .../exchanges/0/request-headers.json | 4 + .../exchanges/0/request.json | 14 + .../exchanges/0/response-headers.json | 26 + .../exchanges/0/response.json | 104 +++ .../reasoning-content/session.json | 11 + .../src/catalog/support-matrix.ts | 62 ++ 276 files changed, 9274 insertions(+) create mode 100644 packages/inference-discovery-openai/sessions/openai-responses/gpt-5-mini/document-input/exchanges/0/request-headers.json create mode 100644 packages/inference-discovery-openai/sessions/openai-responses/gpt-5-mini/document-input/exchanges/0/request.json create mode 100644 packages/inference-discovery-openai/sessions/openai-responses/gpt-5-mini/document-input/exchanges/0/response-headers.json create mode 100644 packages/inference-discovery-openai/sessions/openai-responses/gpt-5-mini/document-input/exchanges/0/response.json create mode 100644 packages/inference-discovery-openai/sessions/openai-responses/gpt-5-mini/document-input/session.json create mode 100644 packages/inference-discovery-openai/sessions/openai-responses/gpt-5-mini/function-calling-multi-turn-streaming/exchanges/0/request-headers.json create mode 100644 packages/inference-discovery-openai/sessions/openai-responses/gpt-5-mini/function-calling-multi-turn-streaming/exchanges/0/request.json create mode 100644 packages/inference-discovery-openai/sessions/openai-responses/gpt-5-mini/function-calling-multi-turn-streaming/exchanges/0/response-headers.json create mode 100644 packages/inference-discovery-openai/sessions/openai-responses/gpt-5-mini/function-calling-multi-turn-streaming/exchanges/0/response.sse create mode 100644 packages/inference-discovery-openai/sessions/openai-responses/gpt-5-mini/function-calling-multi-turn-streaming/session.json create mode 100644 packages/inference-discovery-openai/sessions/openai-responses/gpt-5-mini/function-calling-multi-turn/dispatches/0-get_weather.json create mode 100644 packages/inference-discovery-openai/sessions/openai-responses/gpt-5-mini/function-calling-multi-turn/exchanges/0/request-headers.json create mode 100644 packages/inference-discovery-openai/sessions/openai-responses/gpt-5-mini/function-calling-multi-turn/exchanges/0/request.json create mode 100644 packages/inference-discovery-openai/sessions/openai-responses/gpt-5-mini/function-calling-multi-turn/exchanges/0/response-headers.json create mode 100644 packages/inference-discovery-openai/sessions/openai-responses/gpt-5-mini/function-calling-multi-turn/exchanges/0/response.json create mode 100644 packages/inference-discovery-openai/sessions/openai-responses/gpt-5-mini/function-calling-multi-turn/exchanges/1/request-headers.json create mode 100644 packages/inference-discovery-openai/sessions/openai-responses/gpt-5-mini/function-calling-multi-turn/exchanges/1/request.json create mode 100644 packages/inference-discovery-openai/sessions/openai-responses/gpt-5-mini/function-calling-multi-turn/exchanges/1/response-headers.json create mode 100644 packages/inference-discovery-openai/sessions/openai-responses/gpt-5-mini/function-calling-multi-turn/exchanges/1/response.json create mode 100644 packages/inference-discovery-openai/sessions/openai-responses/gpt-5-mini/function-calling-multi-turn/session.json create mode 100644 packages/inference-discovery-openai/sessions/openai-responses/gpt-5-mini/function-calling/exchanges/0/request-headers.json create mode 100644 packages/inference-discovery-openai/sessions/openai-responses/gpt-5-mini/function-calling/exchanges/0/request.json create mode 100644 packages/inference-discovery-openai/sessions/openai-responses/gpt-5-mini/function-calling/exchanges/0/response-headers.json create mode 100644 packages/inference-discovery-openai/sessions/openai-responses/gpt-5-mini/function-calling/exchanges/0/response.json create mode 100644 packages/inference-discovery-openai/sessions/openai-responses/gpt-5-mini/function-calling/session.json create mode 100644 packages/inference-discovery-openai/sessions/openai-responses/gpt-5-mini/plain-text-streaming/exchanges/0/request-headers.json create mode 100644 packages/inference-discovery-openai/sessions/openai-responses/gpt-5-mini/plain-text-streaming/exchanges/0/request.json create mode 100644 packages/inference-discovery-openai/sessions/openai-responses/gpt-5-mini/plain-text-streaming/exchanges/0/response-headers.json create mode 100644 packages/inference-discovery-openai/sessions/openai-responses/gpt-5-mini/plain-text-streaming/exchanges/0/response.sse create mode 100644 packages/inference-discovery-openai/sessions/openai-responses/gpt-5-mini/plain-text-streaming/session.json create mode 100644 packages/inference-discovery-openai/sessions/openai-responses/gpt-5-mini/plain-text/exchanges/0/request-headers.json create mode 100644 packages/inference-discovery-openai/sessions/openai-responses/gpt-5-mini/plain-text/exchanges/0/request.json create mode 100644 packages/inference-discovery-openai/sessions/openai-responses/gpt-5-mini/plain-text/exchanges/0/response-headers.json create mode 100644 packages/inference-discovery-openai/sessions/openai-responses/gpt-5-mini/plain-text/exchanges/0/response.json create mode 100644 packages/inference-discovery-openai/sessions/openai-responses/gpt-5-mini/plain-text/session.json create mode 100644 packages/inference-discovery-openai/sessions/openai-responses/gpt-5-mini/reasoning-content-streaming/exchanges/0/request-headers.json create mode 100644 packages/inference-discovery-openai/sessions/openai-responses/gpt-5-mini/reasoning-content-streaming/exchanges/0/request.json create mode 100644 packages/inference-discovery-openai/sessions/openai-responses/gpt-5-mini/reasoning-content-streaming/exchanges/0/response-headers.json create mode 100644 packages/inference-discovery-openai/sessions/openai-responses/gpt-5-mini/reasoning-content-streaming/exchanges/0/response.sse create mode 100644 packages/inference-discovery-openai/sessions/openai-responses/gpt-5-mini/reasoning-content-streaming/session.json create mode 100644 packages/inference-discovery-openai/sessions/openai-responses/gpt-5-mini/reasoning-content/exchanges/0/request-headers.json create mode 100644 packages/inference-discovery-openai/sessions/openai-responses/gpt-5-mini/reasoning-content/exchanges/0/request.json create mode 100644 packages/inference-discovery-openai/sessions/openai-responses/gpt-5-mini/reasoning-content/exchanges/0/response-headers.json create mode 100644 packages/inference-discovery-openai/sessions/openai-responses/gpt-5-mini/reasoning-content/exchanges/0/response.json create mode 100644 packages/inference-discovery-openai/sessions/openai-responses/gpt-5-mini/reasoning-content/session.json create mode 100644 packages/inference-discovery-openai/sessions/openai-responses/gpt-5-mini/vision-input/exchanges/0/request-headers.json create mode 100644 packages/inference-discovery-openai/sessions/openai-responses/gpt-5-mini/vision-input/exchanges/0/request.json create mode 100644 packages/inference-discovery-openai/sessions/openai-responses/gpt-5-mini/vision-input/exchanges/0/response-headers.json create mode 100644 packages/inference-discovery-openai/sessions/openai-responses/gpt-5-mini/vision-input/exchanges/0/response.json create mode 100644 packages/inference-discovery-openai/sessions/openai-responses/gpt-5-mini/vision-input/session.json create mode 100644 packages/inference-discovery-openai/sessions/openai-responses/gpt-5.5/function-calling-multi-turn/dispatches/0-get_weather.json create mode 100644 packages/inference-discovery-openai/sessions/openai-responses/gpt-5.5/function-calling-multi-turn/exchanges/0/request-headers.json create mode 100644 packages/inference-discovery-openai/sessions/openai-responses/gpt-5.5/function-calling-multi-turn/exchanges/0/request.json create mode 100644 packages/inference-discovery-openai/sessions/openai-responses/gpt-5.5/function-calling-multi-turn/exchanges/0/response-headers.json create mode 100644 packages/inference-discovery-openai/sessions/openai-responses/gpt-5.5/function-calling-multi-turn/exchanges/0/response.json create mode 100644 packages/inference-discovery-openai/sessions/openai-responses/gpt-5.5/function-calling-multi-turn/exchanges/1/request-headers.json create mode 100644 packages/inference-discovery-openai/sessions/openai-responses/gpt-5.5/function-calling-multi-turn/exchanges/1/request.json create mode 100644 packages/inference-discovery-openai/sessions/openai-responses/gpt-5.5/function-calling-multi-turn/exchanges/1/response-headers.json create mode 100644 packages/inference-discovery-openai/sessions/openai-responses/gpt-5.5/function-calling-multi-turn/exchanges/1/response.json create mode 100644 packages/inference-discovery-openai/sessions/openai-responses/gpt-5.5/function-calling-multi-turn/session.json create mode 100644 packages/inference-discovery-openai/sessions/openai-responses/gpt-5.5/plain-text-streaming/exchanges/0/request-headers.json create mode 100644 packages/inference-discovery-openai/sessions/openai-responses/gpt-5.5/plain-text-streaming/exchanges/0/request.json create mode 100644 packages/inference-discovery-openai/sessions/openai-responses/gpt-5.5/plain-text-streaming/exchanges/0/response-headers.json create mode 100644 packages/inference-discovery-openai/sessions/openai-responses/gpt-5.5/plain-text-streaming/exchanges/0/response.sse create mode 100644 packages/inference-discovery-openai/sessions/openai-responses/gpt-5.5/plain-text-streaming/session.json create mode 100644 packages/inference-discovery-openai/sessions/openai-responses/gpt-5.5/plain-text/exchanges/0/request-headers.json create mode 100644 packages/inference-discovery-openai/sessions/openai-responses/gpt-5.5/plain-text/exchanges/0/request.json create mode 100644 packages/inference-discovery-openai/sessions/openai-responses/gpt-5.5/plain-text/exchanges/0/response-headers.json create mode 100644 packages/inference-discovery-openai/sessions/openai-responses/gpt-5.5/plain-text/exchanges/0/response.json create mode 100644 packages/inference-discovery-openai/sessions/openai-responses/gpt-5.5/plain-text/session.json create mode 100644 packages/inference-discovery-openai/sessions/openai-responses/gpt-5.5/reasoning-content/exchanges/0/request-headers.json create mode 100644 packages/inference-discovery-openai/sessions/openai-responses/gpt-5.5/reasoning-content/exchanges/0/request.json create mode 100644 packages/inference-discovery-openai/sessions/openai-responses/gpt-5.5/reasoning-content/exchanges/0/response-headers.json create mode 100644 packages/inference-discovery-openai/sessions/openai-responses/gpt-5.5/reasoning-content/exchanges/0/response.json create mode 100644 packages/inference-discovery-openai/sessions/openai-responses/gpt-5.5/reasoning-content/session.json create mode 100644 packages/inference-discovery-openai/sessions/openai-responses/gpt-5.6-luna/function-calling-multi-turn/dispatches/0-get_weather.json create mode 100644 packages/inference-discovery-openai/sessions/openai-responses/gpt-5.6-luna/function-calling-multi-turn/exchanges/0/request-headers.json create mode 100644 packages/inference-discovery-openai/sessions/openai-responses/gpt-5.6-luna/function-calling-multi-turn/exchanges/0/request.json create mode 100644 packages/inference-discovery-openai/sessions/openai-responses/gpt-5.6-luna/function-calling-multi-turn/exchanges/0/response-headers.json create mode 100644 packages/inference-discovery-openai/sessions/openai-responses/gpt-5.6-luna/function-calling-multi-turn/exchanges/0/response.json create mode 100644 packages/inference-discovery-openai/sessions/openai-responses/gpt-5.6-luna/function-calling-multi-turn/exchanges/1/request-headers.json create mode 100644 packages/inference-discovery-openai/sessions/openai-responses/gpt-5.6-luna/function-calling-multi-turn/exchanges/1/request.json create mode 100644 packages/inference-discovery-openai/sessions/openai-responses/gpt-5.6-luna/function-calling-multi-turn/exchanges/1/response-headers.json create mode 100644 packages/inference-discovery-openai/sessions/openai-responses/gpt-5.6-luna/function-calling-multi-turn/exchanges/1/response.json create mode 100644 packages/inference-discovery-openai/sessions/openai-responses/gpt-5.6-luna/function-calling-multi-turn/session.json create mode 100644 packages/inference-discovery-openai/sessions/openai-responses/gpt-5.6-luna/plain-text-streaming/exchanges/0/request-headers.json create mode 100644 packages/inference-discovery-openai/sessions/openai-responses/gpt-5.6-luna/plain-text-streaming/exchanges/0/request.json create mode 100644 packages/inference-discovery-openai/sessions/openai-responses/gpt-5.6-luna/plain-text-streaming/exchanges/0/response-headers.json create mode 100644 packages/inference-discovery-openai/sessions/openai-responses/gpt-5.6-luna/plain-text-streaming/exchanges/0/response.sse create mode 100644 packages/inference-discovery-openai/sessions/openai-responses/gpt-5.6-luna/plain-text-streaming/session.json create mode 100644 packages/inference-discovery-openai/sessions/openai-responses/gpt-5.6-luna/plain-text/exchanges/0/request-headers.json create mode 100644 packages/inference-discovery-openai/sessions/openai-responses/gpt-5.6-luna/plain-text/exchanges/0/request.json create mode 100644 packages/inference-discovery-openai/sessions/openai-responses/gpt-5.6-luna/plain-text/exchanges/0/response-headers.json create mode 100644 packages/inference-discovery-openai/sessions/openai-responses/gpt-5.6-luna/plain-text/exchanges/0/response.json create mode 100644 packages/inference-discovery-openai/sessions/openai-responses/gpt-5.6-luna/plain-text/session.json create mode 100644 packages/inference-discovery-openai/sessions/openai-responses/gpt-5.6-luna/reasoning-content/exchanges/0/request-headers.json create mode 100644 packages/inference-discovery-openai/sessions/openai-responses/gpt-5.6-luna/reasoning-content/exchanges/0/request.json create mode 100644 packages/inference-discovery-openai/sessions/openai-responses/gpt-5.6-luna/reasoning-content/exchanges/0/response-headers.json create mode 100644 packages/inference-discovery-openai/sessions/openai-responses/gpt-5.6-luna/reasoning-content/exchanges/0/response.json create mode 100644 packages/inference-discovery-openai/sessions/openai-responses/gpt-5.6-luna/reasoning-content/session.json create mode 100644 packages/inference-discovery-openai/sessions/openai-responses/gpt-5.6-sol/function-calling-multi-turn/dispatches/0-get_weather.json create mode 100644 packages/inference-discovery-openai/sessions/openai-responses/gpt-5.6-sol/function-calling-multi-turn/exchanges/0/request-headers.json create mode 100644 packages/inference-discovery-openai/sessions/openai-responses/gpt-5.6-sol/function-calling-multi-turn/exchanges/0/request.json create mode 100644 packages/inference-discovery-openai/sessions/openai-responses/gpt-5.6-sol/function-calling-multi-turn/exchanges/0/response-headers.json create mode 100644 packages/inference-discovery-openai/sessions/openai-responses/gpt-5.6-sol/function-calling-multi-turn/exchanges/0/response.json create mode 100644 packages/inference-discovery-openai/sessions/openai-responses/gpt-5.6-sol/function-calling-multi-turn/exchanges/1/request-headers.json create mode 100644 packages/inference-discovery-openai/sessions/openai-responses/gpt-5.6-sol/function-calling-multi-turn/exchanges/1/request.json create mode 100644 packages/inference-discovery-openai/sessions/openai-responses/gpt-5.6-sol/function-calling-multi-turn/exchanges/1/response-headers.json create mode 100644 packages/inference-discovery-openai/sessions/openai-responses/gpt-5.6-sol/function-calling-multi-turn/exchanges/1/response.json create mode 100644 packages/inference-discovery-openai/sessions/openai-responses/gpt-5.6-sol/function-calling-multi-turn/session.json create mode 100644 packages/inference-discovery-openai/sessions/openai-responses/gpt-5.6-sol/plain-text-streaming/exchanges/0/request-headers.json create mode 100644 packages/inference-discovery-openai/sessions/openai-responses/gpt-5.6-sol/plain-text-streaming/exchanges/0/request.json create mode 100644 packages/inference-discovery-openai/sessions/openai-responses/gpt-5.6-sol/plain-text-streaming/exchanges/0/response-headers.json create mode 100644 packages/inference-discovery-openai/sessions/openai-responses/gpt-5.6-sol/plain-text-streaming/exchanges/0/response.sse create mode 100644 packages/inference-discovery-openai/sessions/openai-responses/gpt-5.6-sol/plain-text-streaming/session.json create mode 100644 packages/inference-discovery-openai/sessions/openai-responses/gpt-5.6-sol/plain-text/exchanges/0/request-headers.json create mode 100644 packages/inference-discovery-openai/sessions/openai-responses/gpt-5.6-sol/plain-text/exchanges/0/request.json create mode 100644 packages/inference-discovery-openai/sessions/openai-responses/gpt-5.6-sol/plain-text/exchanges/0/response-headers.json create mode 100644 packages/inference-discovery-openai/sessions/openai-responses/gpt-5.6-sol/plain-text/exchanges/0/response.json create mode 100644 packages/inference-discovery-openai/sessions/openai-responses/gpt-5.6-sol/plain-text/session.json create mode 100644 packages/inference-discovery-openai/sessions/openai-responses/gpt-5.6-sol/reasoning-content/exchanges/0/request-headers.json create mode 100644 packages/inference-discovery-openai/sessions/openai-responses/gpt-5.6-sol/reasoning-content/exchanges/0/request.json create mode 100644 packages/inference-discovery-openai/sessions/openai-responses/gpt-5.6-sol/reasoning-content/exchanges/0/response-headers.json create mode 100644 packages/inference-discovery-openai/sessions/openai-responses/gpt-5.6-sol/reasoning-content/exchanges/0/response.json create mode 100644 packages/inference-discovery-openai/sessions/openai-responses/gpt-5.6-sol/reasoning-content/session.json create mode 100644 packages/inference-discovery-openai/sessions/openai-responses/gpt-5.6-terra/function-calling-multi-turn/dispatches/0-get_weather.json create mode 100644 packages/inference-discovery-openai/sessions/openai-responses/gpt-5.6-terra/function-calling-multi-turn/exchanges/0/request-headers.json create mode 100644 packages/inference-discovery-openai/sessions/openai-responses/gpt-5.6-terra/function-calling-multi-turn/exchanges/0/request.json create mode 100644 packages/inference-discovery-openai/sessions/openai-responses/gpt-5.6-terra/function-calling-multi-turn/exchanges/0/response-headers.json create mode 100644 packages/inference-discovery-openai/sessions/openai-responses/gpt-5.6-terra/function-calling-multi-turn/exchanges/0/response.json create mode 100644 packages/inference-discovery-openai/sessions/openai-responses/gpt-5.6-terra/function-calling-multi-turn/exchanges/1/request-headers.json create mode 100644 packages/inference-discovery-openai/sessions/openai-responses/gpt-5.6-terra/function-calling-multi-turn/exchanges/1/request.json create mode 100644 packages/inference-discovery-openai/sessions/openai-responses/gpt-5.6-terra/function-calling-multi-turn/exchanges/1/response-headers.json create mode 100644 packages/inference-discovery-openai/sessions/openai-responses/gpt-5.6-terra/function-calling-multi-turn/exchanges/1/response.json create mode 100644 packages/inference-discovery-openai/sessions/openai-responses/gpt-5.6-terra/function-calling-multi-turn/session.json create mode 100644 packages/inference-discovery-openai/sessions/openai-responses/gpt-5.6-terra/plain-text-streaming/exchanges/0/request-headers.json create mode 100644 packages/inference-discovery-openai/sessions/openai-responses/gpt-5.6-terra/plain-text-streaming/exchanges/0/request.json create mode 100644 packages/inference-discovery-openai/sessions/openai-responses/gpt-5.6-terra/plain-text-streaming/exchanges/0/response-headers.json create mode 100644 packages/inference-discovery-openai/sessions/openai-responses/gpt-5.6-terra/plain-text-streaming/exchanges/0/response.sse create mode 100644 packages/inference-discovery-openai/sessions/openai-responses/gpt-5.6-terra/plain-text-streaming/session.json create mode 100644 packages/inference-discovery-openai/sessions/openai-responses/gpt-5.6-terra/plain-text/exchanges/0/request-headers.json create mode 100644 packages/inference-discovery-openai/sessions/openai-responses/gpt-5.6-terra/plain-text/exchanges/0/request.json create mode 100644 packages/inference-discovery-openai/sessions/openai-responses/gpt-5.6-terra/plain-text/exchanges/0/response-headers.json create mode 100644 packages/inference-discovery-openai/sessions/openai-responses/gpt-5.6-terra/plain-text/exchanges/0/response.json create mode 100644 packages/inference-discovery-openai/sessions/openai-responses/gpt-5.6-terra/plain-text/session.json create mode 100644 packages/inference-discovery-openai/sessions/openai-responses/gpt-5.6-terra/reasoning-content/exchanges/0/request-headers.json create mode 100644 packages/inference-discovery-openai/sessions/openai-responses/gpt-5.6-terra/reasoning-content/exchanges/0/request.json create mode 100644 packages/inference-discovery-openai/sessions/openai-responses/gpt-5.6-terra/reasoning-content/exchanges/0/response-headers.json create mode 100644 packages/inference-discovery-openai/sessions/openai-responses/gpt-5.6-terra/reasoning-content/exchanges/0/response.json create mode 100644 packages/inference-discovery-openai/sessions/openai-responses/gpt-5.6-terra/reasoning-content/session.json create mode 100644 packages/inference-discovery-openai/sessions/openai-responses/gpt-6-astra/function-calling-multi-turn/dispatches/0-get_weather.json create mode 100644 packages/inference-discovery-openai/sessions/openai-responses/gpt-6-astra/function-calling-multi-turn/exchanges/0/request-headers.json create mode 100644 packages/inference-discovery-openai/sessions/openai-responses/gpt-6-astra/function-calling-multi-turn/exchanges/0/request.json create mode 100644 packages/inference-discovery-openai/sessions/openai-responses/gpt-6-astra/function-calling-multi-turn/exchanges/0/response-headers.json create mode 100644 packages/inference-discovery-openai/sessions/openai-responses/gpt-6-astra/function-calling-multi-turn/exchanges/0/response.json create mode 100644 packages/inference-discovery-openai/sessions/openai-responses/gpt-6-astra/function-calling-multi-turn/exchanges/1/request-headers.json create mode 100644 packages/inference-discovery-openai/sessions/openai-responses/gpt-6-astra/function-calling-multi-turn/exchanges/1/request.json create mode 100644 packages/inference-discovery-openai/sessions/openai-responses/gpt-6-astra/function-calling-multi-turn/exchanges/1/response-headers.json create mode 100644 packages/inference-discovery-openai/sessions/openai-responses/gpt-6-astra/function-calling-multi-turn/exchanges/1/response.json create mode 100644 packages/inference-discovery-openai/sessions/openai-responses/gpt-6-astra/function-calling-multi-turn/session.json create mode 100644 packages/inference-discovery-openai/sessions/openai-responses/gpt-6-astra/plain-text-streaming/exchanges/0/request-headers.json create mode 100644 packages/inference-discovery-openai/sessions/openai-responses/gpt-6-astra/plain-text-streaming/exchanges/0/request.json create mode 100644 packages/inference-discovery-openai/sessions/openai-responses/gpt-6-astra/plain-text-streaming/exchanges/0/response-headers.json create mode 100644 packages/inference-discovery-openai/sessions/openai-responses/gpt-6-astra/plain-text-streaming/exchanges/0/response.sse create mode 100644 packages/inference-discovery-openai/sessions/openai-responses/gpt-6-astra/plain-text-streaming/session.json create mode 100644 packages/inference-discovery-openai/sessions/openai-responses/gpt-6-astra/plain-text/exchanges/0/request-headers.json create mode 100644 packages/inference-discovery-openai/sessions/openai-responses/gpt-6-astra/plain-text/exchanges/0/request.json create mode 100644 packages/inference-discovery-openai/sessions/openai-responses/gpt-6-astra/plain-text/exchanges/0/response-headers.json create mode 100644 packages/inference-discovery-openai/sessions/openai-responses/gpt-6-astra/plain-text/exchanges/0/response.json create mode 100644 packages/inference-discovery-openai/sessions/openai-responses/gpt-6-astra/plain-text/session.json create mode 100644 packages/inference-discovery-openai/sessions/openai-responses/gpt-6-astra/reasoning-content/exchanges/0/request-headers.json create mode 100644 packages/inference-discovery-openai/sessions/openai-responses/gpt-6-astra/reasoning-content/exchanges/0/request.json create mode 100644 packages/inference-discovery-openai/sessions/openai-responses/gpt-6-astra/reasoning-content/exchanges/0/response-headers.json create mode 100644 packages/inference-discovery-openai/sessions/openai-responses/gpt-6-astra/reasoning-content/exchanges/0/response.json create mode 100644 packages/inference-discovery-openai/sessions/openai-responses/gpt-6-astra/reasoning-content/session.json create mode 100644 packages/inference-discovery-openai/sessions/openai-responses/gpt-6-luna/function-calling-multi-turn/dispatches/0-get_weather.json create mode 100644 packages/inference-discovery-openai/sessions/openai-responses/gpt-6-luna/function-calling-multi-turn/exchanges/0/request-headers.json create mode 100644 packages/inference-discovery-openai/sessions/openai-responses/gpt-6-luna/function-calling-multi-turn/exchanges/0/request.json create mode 100644 packages/inference-discovery-openai/sessions/openai-responses/gpt-6-luna/function-calling-multi-turn/exchanges/0/response-headers.json create mode 100644 packages/inference-discovery-openai/sessions/openai-responses/gpt-6-luna/function-calling-multi-turn/exchanges/0/response.json create mode 100644 packages/inference-discovery-openai/sessions/openai-responses/gpt-6-luna/function-calling-multi-turn/exchanges/1/request-headers.json create mode 100644 packages/inference-discovery-openai/sessions/openai-responses/gpt-6-luna/function-calling-multi-turn/exchanges/1/request.json create mode 100644 packages/inference-discovery-openai/sessions/openai-responses/gpt-6-luna/function-calling-multi-turn/exchanges/1/response-headers.json create mode 100644 packages/inference-discovery-openai/sessions/openai-responses/gpt-6-luna/function-calling-multi-turn/exchanges/1/response.json create mode 100644 packages/inference-discovery-openai/sessions/openai-responses/gpt-6-luna/function-calling-multi-turn/session.json create mode 100644 packages/inference-discovery-openai/sessions/openai-responses/gpt-6-luna/plain-text-streaming/exchanges/0/request-headers.json create mode 100644 packages/inference-discovery-openai/sessions/openai-responses/gpt-6-luna/plain-text-streaming/exchanges/0/request.json create mode 100644 packages/inference-discovery-openai/sessions/openai-responses/gpt-6-luna/plain-text-streaming/exchanges/0/response-headers.json create mode 100644 packages/inference-discovery-openai/sessions/openai-responses/gpt-6-luna/plain-text-streaming/exchanges/0/response.sse create mode 100644 packages/inference-discovery-openai/sessions/openai-responses/gpt-6-luna/plain-text-streaming/session.json create mode 100644 packages/inference-discovery-openai/sessions/openai-responses/gpt-6-luna/plain-text/exchanges/0/request-headers.json create mode 100644 packages/inference-discovery-openai/sessions/openai-responses/gpt-6-luna/plain-text/exchanges/0/request.json create mode 100644 packages/inference-discovery-openai/sessions/openai-responses/gpt-6-luna/plain-text/exchanges/0/response-headers.json create mode 100644 packages/inference-discovery-openai/sessions/openai-responses/gpt-6-luna/plain-text/exchanges/0/response.json create mode 100644 packages/inference-discovery-openai/sessions/openai-responses/gpt-6-luna/plain-text/session.json create mode 100644 packages/inference-discovery-openai/sessions/openai-responses/gpt-6-luna/reasoning-content/exchanges/0/request-headers.json create mode 100644 packages/inference-discovery-openai/sessions/openai-responses/gpt-6-luna/reasoning-content/exchanges/0/request.json create mode 100644 packages/inference-discovery-openai/sessions/openai-responses/gpt-6-luna/reasoning-content/exchanges/0/response-headers.json create mode 100644 packages/inference-discovery-openai/sessions/openai-responses/gpt-6-luna/reasoning-content/exchanges/0/response.json create mode 100644 packages/inference-discovery-openai/sessions/openai-responses/gpt-6-luna/reasoning-content/session.json create mode 100644 packages/inference-discovery-openai/sessions/openai-responses/gpt-6-sol/function-calling-multi-turn/dispatches/0-get_weather.json create mode 100644 packages/inference-discovery-openai/sessions/openai-responses/gpt-6-sol/function-calling-multi-turn/exchanges/0/request-headers.json create mode 100644 packages/inference-discovery-openai/sessions/openai-responses/gpt-6-sol/function-calling-multi-turn/exchanges/0/request.json create mode 100644 packages/inference-discovery-openai/sessions/openai-responses/gpt-6-sol/function-calling-multi-turn/exchanges/0/response-headers.json create mode 100644 packages/inference-discovery-openai/sessions/openai-responses/gpt-6-sol/function-calling-multi-turn/exchanges/0/response.json create mode 100644 packages/inference-discovery-openai/sessions/openai-responses/gpt-6-sol/function-calling-multi-turn/exchanges/1/request-headers.json create mode 100644 packages/inference-discovery-openai/sessions/openai-responses/gpt-6-sol/function-calling-multi-turn/exchanges/1/request.json create mode 100644 packages/inference-discovery-openai/sessions/openai-responses/gpt-6-sol/function-calling-multi-turn/exchanges/1/response-headers.json create mode 100644 packages/inference-discovery-openai/sessions/openai-responses/gpt-6-sol/function-calling-multi-turn/exchanges/1/response.json create mode 100644 packages/inference-discovery-openai/sessions/openai-responses/gpt-6-sol/function-calling-multi-turn/session.json create mode 100644 packages/inference-discovery-openai/sessions/openai-responses/gpt-6-sol/plain-text-streaming/exchanges/0/request-headers.json create mode 100644 packages/inference-discovery-openai/sessions/openai-responses/gpt-6-sol/plain-text-streaming/exchanges/0/request.json create mode 100644 packages/inference-discovery-openai/sessions/openai-responses/gpt-6-sol/plain-text-streaming/exchanges/0/response-headers.json create mode 100644 packages/inference-discovery-openai/sessions/openai-responses/gpt-6-sol/plain-text-streaming/exchanges/0/response.sse create mode 100644 packages/inference-discovery-openai/sessions/openai-responses/gpt-6-sol/plain-text-streaming/session.json create mode 100644 packages/inference-discovery-openai/sessions/openai-responses/gpt-6-sol/plain-text/exchanges/0/request-headers.json create mode 100644 packages/inference-discovery-openai/sessions/openai-responses/gpt-6-sol/plain-text/exchanges/0/request.json create mode 100644 packages/inference-discovery-openai/sessions/openai-responses/gpt-6-sol/plain-text/exchanges/0/response-headers.json create mode 100644 packages/inference-discovery-openai/sessions/openai-responses/gpt-6-sol/plain-text/exchanges/0/response.json create mode 100644 packages/inference-discovery-openai/sessions/openai-responses/gpt-6-sol/plain-text/session.json create mode 100644 packages/inference-discovery-openai/sessions/openai-responses/gpt-6-sol/reasoning-content/exchanges/0/request-headers.json create mode 100644 packages/inference-discovery-openai/sessions/openai-responses/gpt-6-sol/reasoning-content/exchanges/0/request.json create mode 100644 packages/inference-discovery-openai/sessions/openai-responses/gpt-6-sol/reasoning-content/exchanges/0/response-headers.json create mode 100644 packages/inference-discovery-openai/sessions/openai-responses/gpt-6-sol/reasoning-content/exchanges/0/response.json create mode 100644 packages/inference-discovery-openai/sessions/openai-responses/gpt-6-sol/reasoning-content/session.json create mode 100644 packages/inference-discovery-openai/sessions/openai-responses/gpt-6.1-sol/function-calling-multi-turn/dispatches/0-get_weather.json create mode 100644 packages/inference-discovery-openai/sessions/openai-responses/gpt-6.1-sol/function-calling-multi-turn/exchanges/0/request-headers.json create mode 100644 packages/inference-discovery-openai/sessions/openai-responses/gpt-6.1-sol/function-calling-multi-turn/exchanges/0/request.json create mode 100644 packages/inference-discovery-openai/sessions/openai-responses/gpt-6.1-sol/function-calling-multi-turn/exchanges/0/response-headers.json create mode 100644 packages/inference-discovery-openai/sessions/openai-responses/gpt-6.1-sol/function-calling-multi-turn/exchanges/0/response.json create mode 100644 packages/inference-discovery-openai/sessions/openai-responses/gpt-6.1-sol/function-calling-multi-turn/exchanges/1/request-headers.json create mode 100644 packages/inference-discovery-openai/sessions/openai-responses/gpt-6.1-sol/function-calling-multi-turn/exchanges/1/request.json create mode 100644 packages/inference-discovery-openai/sessions/openai-responses/gpt-6.1-sol/function-calling-multi-turn/exchanges/1/response-headers.json create mode 100644 packages/inference-discovery-openai/sessions/openai-responses/gpt-6.1-sol/function-calling-multi-turn/exchanges/1/response.json create mode 100644 packages/inference-discovery-openai/sessions/openai-responses/gpt-6.1-sol/function-calling-multi-turn/session.json create mode 100644 packages/inference-discovery-openai/sessions/openai-responses/gpt-6.1-sol/plain-text-streaming/exchanges/0/request-headers.json create mode 100644 packages/inference-discovery-openai/sessions/openai-responses/gpt-6.1-sol/plain-text-streaming/exchanges/0/request.json create mode 100644 packages/inference-discovery-openai/sessions/openai-responses/gpt-6.1-sol/plain-text-streaming/exchanges/0/response-headers.json create mode 100644 packages/inference-discovery-openai/sessions/openai-responses/gpt-6.1-sol/plain-text-streaming/exchanges/0/response.sse create mode 100644 packages/inference-discovery-openai/sessions/openai-responses/gpt-6.1-sol/plain-text-streaming/session.json create mode 100644 packages/inference-discovery-openai/sessions/openai-responses/gpt-6.1-sol/plain-text/exchanges/0/request-headers.json create mode 100644 packages/inference-discovery-openai/sessions/openai-responses/gpt-6.1-sol/plain-text/exchanges/0/request.json create mode 100644 packages/inference-discovery-openai/sessions/openai-responses/gpt-6.1-sol/plain-text/exchanges/0/response-headers.json create mode 100644 packages/inference-discovery-openai/sessions/openai-responses/gpt-6.1-sol/plain-text/exchanges/0/response.json create mode 100644 packages/inference-discovery-openai/sessions/openai-responses/gpt-6.1-sol/plain-text/session.json create mode 100644 packages/inference-discovery-openai/sessions/openai-responses/gpt-6.1-sol/reasoning-content/exchanges/0/request-headers.json create mode 100644 packages/inference-discovery-openai/sessions/openai-responses/gpt-6.1-sol/reasoning-content/exchanges/0/request.json create mode 100644 packages/inference-discovery-openai/sessions/openai-responses/gpt-6.1-sol/reasoning-content/exchanges/0/response-headers.json create mode 100644 packages/inference-discovery-openai/sessions/openai-responses/gpt-6.1-sol/reasoning-content/exchanges/0/response.json create mode 100644 packages/inference-discovery-openai/sessions/openai-responses/gpt-6.1-sol/reasoning-content/session.json create mode 100644 packages/inference-discovery-openai/sessions/openai-responses/gpt-6.1-terra/function-calling-multi-turn/dispatches/0-get_weather.json create mode 100644 packages/inference-discovery-openai/sessions/openai-responses/gpt-6.1-terra/function-calling-multi-turn/exchanges/0/request-headers.json create mode 100644 packages/inference-discovery-openai/sessions/openai-responses/gpt-6.1-terra/function-calling-multi-turn/exchanges/0/request.json create mode 100644 packages/inference-discovery-openai/sessions/openai-responses/gpt-6.1-terra/function-calling-multi-turn/exchanges/0/response-headers.json create mode 100644 packages/inference-discovery-openai/sessions/openai-responses/gpt-6.1-terra/function-calling-multi-turn/exchanges/0/response.json create mode 100644 packages/inference-discovery-openai/sessions/openai-responses/gpt-6.1-terra/function-calling-multi-turn/exchanges/1/request-headers.json create mode 100644 packages/inference-discovery-openai/sessions/openai-responses/gpt-6.1-terra/function-calling-multi-turn/exchanges/1/request.json create mode 100644 packages/inference-discovery-openai/sessions/openai-responses/gpt-6.1-terra/function-calling-multi-turn/exchanges/1/response-headers.json create mode 100644 packages/inference-discovery-openai/sessions/openai-responses/gpt-6.1-terra/function-calling-multi-turn/exchanges/1/response.json create mode 100644 packages/inference-discovery-openai/sessions/openai-responses/gpt-6.1-terra/function-calling-multi-turn/session.json create mode 100644 packages/inference-discovery-openai/sessions/openai-responses/gpt-6.1-terra/plain-text-streaming/exchanges/0/request-headers.json create mode 100644 packages/inference-discovery-openai/sessions/openai-responses/gpt-6.1-terra/plain-text-streaming/exchanges/0/request.json create mode 100644 packages/inference-discovery-openai/sessions/openai-responses/gpt-6.1-terra/plain-text-streaming/exchanges/0/response-headers.json create mode 100644 packages/inference-discovery-openai/sessions/openai-responses/gpt-6.1-terra/plain-text-streaming/exchanges/0/response.sse create mode 100644 packages/inference-discovery-openai/sessions/openai-responses/gpt-6.1-terra/plain-text-streaming/session.json create mode 100644 packages/inference-discovery-openai/sessions/openai-responses/gpt-6.1-terra/plain-text/exchanges/0/request-headers.json create mode 100644 packages/inference-discovery-openai/sessions/openai-responses/gpt-6.1-terra/plain-text/exchanges/0/request.json create mode 100644 packages/inference-discovery-openai/sessions/openai-responses/gpt-6.1-terra/plain-text/exchanges/0/response-headers.json create mode 100644 packages/inference-discovery-openai/sessions/openai-responses/gpt-6.1-terra/plain-text/exchanges/0/response.json create mode 100644 packages/inference-discovery-openai/sessions/openai-responses/gpt-6.1-terra/plain-text/session.json create mode 100644 packages/inference-discovery-openai/sessions/openai-responses/gpt-6.1-terra/reasoning-content/exchanges/0/request-headers.json create mode 100644 packages/inference-discovery-openai/sessions/openai-responses/gpt-6.1-terra/reasoning-content/exchanges/0/request.json create mode 100644 packages/inference-discovery-openai/sessions/openai-responses/gpt-6.1-terra/reasoning-content/exchanges/0/response-headers.json create mode 100644 packages/inference-discovery-openai/sessions/openai-responses/gpt-6.1-terra/reasoning-content/exchanges/0/response.json create mode 100644 packages/inference-discovery-openai/sessions/openai-responses/gpt-6.1-terra/reasoning-content/session.json diff --git a/packages/inference-discovery-openai/sessions/openai-responses/gpt-5-mini/document-input/exchanges/0/request-headers.json b/packages/inference-discovery-openai/sessions/openai-responses/gpt-5-mini/document-input/exchanges/0/request-headers.json new file mode 100644 index 000000000..28c14bb85 --- /dev/null +++ b/packages/inference-discovery-openai/sessions/openai-responses/gpt-5-mini/document-input/exchanges/0/request-headers.json @@ -0,0 +1,4 @@ +{ + "Content-Type": "application/json", + "Authorization": "" +} diff --git a/packages/inference-discovery-openai/sessions/openai-responses/gpt-5-mini/document-input/exchanges/0/request.json b/packages/inference-discovery-openai/sessions/openai-responses/gpt-5-mini/document-input/exchanges/0/request.json new file mode 100644 index 000000000..b06de5c02 --- /dev/null +++ b/packages/inference-discovery-openai/sessions/openai-responses/gpt-5-mini/document-input/exchanges/0/request.json @@ -0,0 +1,20 @@ +{ + "model": "gpt-5-mini", + "input": [ + { + "type": "message", + "role": "user", + "content": [ + { + "type": "input_text", + "text": "Summarize the attached document in one sentence." + }, + { + "type": "input_file", + "filename": "sample.pdf", + "file_data": "data:application/pdf;base64,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" + } + ] + } + ] +} diff --git a/packages/inference-discovery-openai/sessions/openai-responses/gpt-5-mini/document-input/exchanges/0/response-headers.json b/packages/inference-discovery-openai/sessions/openai-responses/gpt-5-mini/document-input/exchanges/0/response-headers.json new file mode 100644 index 000000000..e5f36269c --- /dev/null +++ b/packages/inference-discovery-openai/sessions/openai-responses/gpt-5-mini/document-input/exchanges/0/response-headers.json @@ -0,0 +1,26 @@ +{ + "access-control-expose-headers": "X-Request-ID, Server-Timing-Total, CF-Ray, CF-Ray", + "alt-svc": "h3=\":443\"; ma=86400", + "cf-cache-status": "DYNAMIC", + "cf-ray": "a5280fba0bd95730-LAX", + "connection": "keep-alive", + "content-encoding": "br", + "content-type": "application/json", + "date": "Fri, 30 Oct 2026 05:36:21 GMT", + "openai-organization": "", + "openai-processing-ms": "3973", + "openai-project": "", + "openai-version": "2020-10-01", + "server": "cloudflare", + "strict-transport-security": "max-age=31536000; includeSubDomains; preload", + "transfer-encoding": "chunked", + "x-content-type-options": "nosniff", + "x-ratelimit-limit-requests": "5000", + "x-ratelimit-limit-tokens": "2000000", + "x-ratelimit-remaining-requests": "4999", + "x-ratelimit-remaining-tokens": "1999964", + "x-ratelimit-reset-requests": "12ms", + "x-ratelimit-reset-tokens": "1ms", + "x-request-id": "", + "set-cookie": "" +} diff --git a/packages/inference-discovery-openai/sessions/openai-responses/gpt-5-mini/document-input/exchanges/0/response.json b/packages/inference-discovery-openai/sessions/openai-responses/gpt-5-mini/document-input/exchanges/0/response.json new file mode 100644 index 000000000..d7fffdd23 --- /dev/null +++ b/packages/inference-discovery-openai/sessions/openai-responses/gpt-5-mini/document-input/exchanges/0/response.json @@ -0,0 +1,101 @@ +{ + "id": "resp_077ce3c0e54951ad006ae42cd10ca087d0bc79270f5b98d01f", + "object": "response", + "created_at": 1793338577, + "status": "completed", + "access_programs": null, + "background": false, + "billing": { + "payer": "developer" + }, + "completed_at": 1793338580, + "error": null, + "frequency_penalty": 0.0, + "incomplete_details": null, + "instructions": null, + "max_output_tokens": null, + "max_tool_calls": null, + "model": "gpt-5-mini-2025-08-07", + "moderation": null, + "output": [ + { + "id": "rs_077ce3c0e54951ad006ae42cd186c887d0957d061c00f191c5", + "type": "reasoning", + "content": [], + "encrypted_content": "gAAAAABq5CzU0-pA6O6NMFDNyULRHSPdVlfebmU8gafE6L-Amfyb8WELznWJOmGgQhScp-oAFWgl2ggxCU3uGWPr38us9C8XTxsLjTGeZQBpxMEZfWvOX0vVJjIYwV4mysWed4BNx9a7ymD39uGS5uKZNM8Eya7xO3nhwyB3VIAJtaCiVSs9jMy7KAsbWDkxECsW8mADl6u8m5YTcchBqIZKnGnP08oq92-w-gylhKsulww4E_Kx4GO3OOGofr8JjXDBVzp-mdkyo8DdgB4e21oTm2dFluBypbGQ2-ux6pXPn-E6v-HfIwgGxNmu9zhLrZ6ApjS3Om4PpAyToDt9rt6FUgBsUPLGfn9UsP0c7_84lQDJR6fWn4iCpbzvWL4RSyvBoA1cxIiWXOqQ2uMX-OxRCVO2V12I_gh3iJjizPkQ2NK-GwICxuRDSgXS3WrddKAXOoHH4ECv82nnHc_vgZ6rsYUeYdMdfvuyT5n5tMA2wx3TJ07--kUJICC7yDM0IXiTPRi0wDKvVhnDXquF-RsTCndRvuVfxpb-fsX9RoBEOTrhmmKrbYp1acWTQ0DU5idq2HYY6D-VENgrTxoiKnNmQJTriqy7qIKCETjz4-62idnhoupUOOhTn01DefFkFbSUZFKY8vcc-kimsZ9HHbbbmZP32m5ZNzXJr5QhTUkCFMeSrI9--rXCsRNb8xVIBxmh_zqoIx27rGtVgUjGI_6fxZJ1HZ4A4HQQgiSYW-fs7I8QgDpnO9XrHLVkwt80F4Zjn_5yvaYm36Lkazr98E1u7JZl4vAq6mp0iKAZg2XpXLvGIDyoRk4oFa1QTH0nNQ19j9j4wFAuSOvGD9dPYLS91ZfqpLM2hmKgo9LvrO6YavGEYuCv0oMKZ4NfvWshr0Dd2aSZXQ3EqdsiaY5cimhB38PJXxJHUwX68ZtwTg_3SH_ESaWJ4ldAAx5FqK7GnGIOHW0HlnyOUOr0_I4DN3TWzl-U1JE69r4ATlGGx_kjDhyjKFcgMH5pRY2zewr3R6QbnfBu_NNNgIJhNCzIAYCDSg-xPJVyxhYaV0KFZKi3YVR_I1OzN6t0Vi2IAkEn04iu9c1ZbxWxI7-P_NHbQYcdD-vlzPms1Bm7QLXgPeWeBVbIncmoyOv1hhie5eXPIPz0xNHggV3-gjqt-xgHOPZGOeBzqdVU4tUxOPUlio4dEwXdAP7HkfPn6CEv9Gr42yDR8FdaPNs-DMgN9M-GwNb-o36uikIV86aslbLXUf_pca2aElT5LmVgwduZekWwWrYmU9zIHdtRsO-pHImWum-bJskfzu1Az1O2635Z0iIMRwpjRCWAFXo8ZoqoUSWGPwxTxklQij51Hclpt0NlaklwB6tvI091a4SGKUj3fSDYqbHVHLO1_77ZHTwWuo_KE5F8GNmcPDUXYqh17sNgRDeNwf5w3MyPdMh4BhC7XLCuhlS_cAgn1IWtybck7Z_8ZGV7DZnSBUZAWzfrNGV7FKzc4wqpA7AwYdpoTlI99UDY3VuLI9zTXLZGJhTIj82-lv1oBM9JtAa1Yg1eT0OnsURbYU3w6Ki9EYp9ksv92JI7ggc6NSAvjEfFjQcanVb7S5x4aWUrPa_MBMtCbkN11lUJd5viRjpIWGwkRGTnwDRatacaIuP8-Q4fIifErtDdi0wACD6rRHzUuxQkCaVmAJ_jj2J8awDl_T2DzYewPn5ZVb4CagGIK_gN6GnX3ZM4N_FcBJpCIL3Cr-HfWoNtLYlzb0yBqLqMZfjH08aDijQXFIxsaYi3-3MaHf_3OSGiQm_J8PXHgWrfRY2zbclVIc7T_eogGazNoAXeL8GVrZ-uU8AlkMafcDtYDUkZ85CgCkI0RNdgKP4STPgyBxf3kFbwzMkHja_f0ThJA7Gx7zH90jJHEOZipup6ZxA7KyWubT17Ge-2YLlCIveSsrvFZtGp8NG3hVTchwuQV_A0uVCURHZ1pZyxb2RTIoRY-t472nfeb6ar_qMeIS54mighXBDeT5eNcOEX5-keIEriu6k1ml-kRuQ0WGMJtWX_REU6SflW7CEszE2016of5hqNM_ifrheRhmpfejMIQYrHKpHMbQDY8n5LAez252XZuPpvSGe9yLQ69YxmNyUZ3X_wFLqpDauUBTCjHs0UCW76PL5Rh9mz68gjxRp7PpkZF3Vugib3Ttrgt9WmKsROrRTVPAxcj1HRh7LNjOUL0Yr3lDFhMzs-xrOr-W2-8roxFpuWjxos9BpmRZLlCV-sY1Q0mkD71OSy2xkXzquMR2JVc1bqX2Ilqdwm0tlYZMAUz_5Kb8-42OEc4ItvtY9jcdIXmW-Zl3kzAD8x0F0t_MLU4xir4PQw_iNuq01XDaRywjjtWswhT6od2lCu5RV43kMjlHOkwL5M71Q1L521v7WmHs9QSaLpbBQ_RL-1V2sguQDBjC9YL49a9HjG6AnnaJULss86RIHrAt09s3pRPLZOcQqQXA5XRU0Wk0MXSHgeB8QabuD-jNMQ7x71Oyl-ONOmzp448wk8vb7CYIfjT5dultzMoh4ba13nUN8XTgekX99xfvcdZTdU3CBZXoWz3jP3nujvvkvQ9MenJj-uGaO-fpaG9Op8FjxjbjXR8a2U_hvTZr7tpQp9KDMD7qZGMTMZ5i5mnuq4KZcf6UtIftq0Yfqyc0EWNaq-AJVbqTSfiswmyMCtZNyFLQ2kZ89OEQYUnWl-l-r48JFEw5Vs3LeQ_ToMwqNmmJGO1usMtJ2DGEBNpONI39qClUXXQT4kd_8Jh63cgJcwNjnSUpJaJMOVv3kAas2HdbeJT_UvsgrdUZ7b_r123PkU-AzDbG3vwwoiG9FwZmtQe1gd_smuIcUzveyzvpQ5djX9PQCWVoCtytjYdlLnO-8gGBE348NDvIHKa96wDaWstHlTNnc7Ei6E4R9ftyHrwsAsrCtNSv1gfxaZ9BCOk9H0W1nbg11dZBXrx7lRR8mbe-8Po4_khaLKAoL00XoQPZlDJidYkjfFviE4U0NDT2TIeF1bgFqjDzFgaEJG4czf564HfCimJ4W44USpw5__3uRKPc6lML1LS6xra3HsAAQmZlxUjXuEYTQGwEofrcwBorM5kA1o9XviaqDfiumgr-4ee3cCOK1mW83DD_uGzarTGbd1Z-K2pcImpXUxRdK_xpWD-1ujX899qWilaJKT0DPm0r2IETA8JktDVbOBazpxgtYd3TIcCcz-ugrh1P20eD_183MW8iUXGB1ZcEgu-kWM-EKWYg43Rj_gVDfoGBPi16CofD7oZh0E_9gPBze8OEVuhHksWBveWi3lbgAFv2st2eVhwForOHgxsmDzbn49f3xrlCCTf7Nk_Om62gAkokz0J-JsxJbEqwvbLp7AmEltTn-_jknSE66J0XuDiR3oQzrCge1XoIEMSQmJZk7ryTah4UGG-lQLNoZyHVMqQ-4z09hrUOwF3rEULEJEVpfveMKfD2oM2pZVnaF-E-SwZ27WmwBnouF5UevBvL4qtGGmXCpddMcjf3H0jLMEte8d66qr6OgwyZg2wA9UY-QmLVs7DVM11UkWMT26mrkzNNbxqCmIwy6V6XT7POoNQlZCQv22V74hmM672q1TkFy_t0R81860uX_pB_fOew1f1tt1E14RF5vqMmkG0zIelPO3vsbPjlaTl3qX9Y1M5_ccHW1K5re0zyjoXIg0D32P5nsmlvU50SuJQfjB5CZzK9oz4iRijqhbe2tYnAEjG2QutMqu8Sajv7pAi138SNxy2qMgcBgjBIXxk3Y4A_1srSO7NILey7oLs_IfkJLHj_JaEAT3-ND2nUbcqehtu5tgud5a1WrZ_IfxXkx7o_xlrkVWRqYCBiEAS_-8nIX6w_MW5XO72T4GMBas4ueLDRC8ArXGizbrW8OpIFb__RvVEd4xn3GFEDT3xfSH941FGq69JBFN5g==", + "summary": [] + }, + { + "id": "msg_077ce3c0e54951ad006ae42cd4205087d08c358de3aa2f12d5", + "type": "message", + "status": "completed", + "content": [ + { + "type": "output_text", + "annotations": [], + "logprobs": [], + "text": "The document is the table of contents for Mark Twain's The Adventures of Tom Sawyer, listing chapter titles that outline Tom\u2019s mischievous antics, moral struggles, friendships and adventures\u2014such as school and church scenes, forming a pirate gang, and confrontations with Injun Joe and Muff Potter\u2014across the novel." + } + ], + "role": "assistant" + } + ], + "parallel_tool_calls": true, + "presence_penalty": 0.0, + "previous_response_id": null, + "prompt_cache_key": null, + "prompt_cache_retention": "in_memory", + "reasoning": { + "context": "current_turn", + "effort": "medium", + "mode": "standard", + "summary": null + }, + "safety_identifier": null, + "service_tier": "default", + "store": true, + "temperature": 1.0, + "text": { + "format": { + "type": "text" + }, + "verbosity": "medium" + }, + "tool_choice": "auto", + "tool_usage": { + "image_gen": { + "input_tokens": 0, + "input_tokens_details": { + "image_tokens": 0, + "text_tokens": 0 + }, + "output_tokens": 0, + "output_tokens_details": { + "image_tokens": 0, + "text_tokens": 0 + }, + "total_tokens": 0 + }, + "web_search": { + "num_requests": 0 + } + }, + "tools": [], + "top_logprobs": 0, + "top_p": 1.0, + "truncation": "disabled", + "usage": { + "input_tokens": 355, + "input_tokens_details": { + "cache_write_tokens": 0, + "cached_tokens": 0 + }, + "output_tokens": 253, + "output_tokens_details": { + "reasoning_tokens": 128 + }, + "total_tokens": 608 + }, + "user": null, + "metadata": {} +} \ No newline at end of file diff --git a/packages/inference-discovery-openai/sessions/openai-responses/gpt-5-mini/document-input/session.json b/packages/inference-discovery-openai/sessions/openai-responses/gpt-5-mini/document-input/session.json new file mode 100644 index 000000000..c5d885103 --- /dev/null +++ b/packages/inference-discovery-openai/sessions/openai-responses/gpt-5-mini/document-input/session.json @@ -0,0 +1,11 @@ +{ + "schemaVersion": "2", + "source": { + "provider": "openai-responses", + "model": "gpt-5-mini", + "baseURL": "https://api.openai.com/v1" + }, + "origin": "live", + "capturedAt": "2026-10-30T05:36:21.015Z", + "capability": "document-input" +} diff --git a/packages/inference-discovery-openai/sessions/openai-responses/gpt-5-mini/function-calling-multi-turn-streaming/exchanges/0/request-headers.json b/packages/inference-discovery-openai/sessions/openai-responses/gpt-5-mini/function-calling-multi-turn-streaming/exchanges/0/request-headers.json new file mode 100644 index 000000000..28c14bb85 --- /dev/null +++ b/packages/inference-discovery-openai/sessions/openai-responses/gpt-5-mini/function-calling-multi-turn-streaming/exchanges/0/request-headers.json @@ -0,0 +1,4 @@ +{ + "Content-Type": "application/json", + "Authorization": "" +} diff --git a/packages/inference-discovery-openai/sessions/openai-responses/gpt-5-mini/function-calling-multi-turn-streaming/exchanges/0/request.json b/packages/inference-discovery-openai/sessions/openai-responses/gpt-5-mini/function-calling-multi-turn-streaming/exchanges/0/request.json new file mode 100644 index 000000000..103a9a5f5 --- /dev/null +++ b/packages/inference-discovery-openai/sessions/openai-responses/gpt-5-mini/function-calling-multi-turn-streaming/exchanges/0/request.json @@ -0,0 +1,31 @@ +{ + "model": "gpt-5-mini", + "input": [ + { + "type": "message", + "role": "user", + "content": "What is the weather in Boston, MA? Use the provided tool." + } + ], + "tools": [ + { + "type": "function", + "name": "get_weather", + "description": "Look up the current weather for a city.", + "parameters": { + "type": "object", + "properties": { + "location": { + "type": "string", + "description": "City and optional region, e.g. 'Boston, MA'." + } + }, + "required": [ + "location" + ] + } + } + ], + "tool_choice": "auto", + "stream": true +} diff --git a/packages/inference-discovery-openai/sessions/openai-responses/gpt-5-mini/function-calling-multi-turn-streaming/exchanges/0/response-headers.json b/packages/inference-discovery-openai/sessions/openai-responses/gpt-5-mini/function-calling-multi-turn-streaming/exchanges/0/response-headers.json new file mode 100644 index 000000000..4b32848f7 --- /dev/null +++ b/packages/inference-discovery-openai/sessions/openai-responses/gpt-5-mini/function-calling-multi-turn-streaming/exchanges/0/response-headers.json @@ -0,0 +1,25 @@ +{ + "access-control-expose-headers": "X-Request-ID, Server-Timing-Total, CF-Ray, CF-Ray", + "alt-svc": "h3=\":443\"; ma=86400", + "cf-cache-status": "DYNAMIC", + "cf-ray": "a52f117a8e036a29-LAX", + "connection": "keep-alive", + "content-type": "text/event-stream; charset=utf-8", + "date": "Sat, 31 Oct 2026 02:00:49 GMT", + "openai-organization": "", + "openai-processing-ms": "195", + "openai-project": "", + "openai-version": "2020-10-01", + "server": "cloudflare", + "strict-transport-security": "max-age=31536000; includeSubDomains; preload", + "transfer-encoding": "chunked", + "x-content-type-options": "nosniff", + "x-ratelimit-limit-requests": "5000", + "x-ratelimit-limit-tokens": "2000000", + "x-ratelimit-remaining-requests": "4999", + "x-ratelimit-remaining-tokens": "1999431", + "x-ratelimit-reset-requests": "12ms", + "x-ratelimit-reset-tokens": "17ms", + "x-request-id": "", + "set-cookie": "" +} diff --git a/packages/inference-discovery-openai/sessions/openai-responses/gpt-5-mini/function-calling-multi-turn-streaming/exchanges/0/response.sse b/packages/inference-discovery-openai/sessions/openai-responses/gpt-5-mini/function-calling-multi-turn-streaming/exchanges/0/response.sse new file mode 100644 index 000000000..58399a11e --- /dev/null +++ b/packages/inference-discovery-openai/sessions/openai-responses/gpt-5-mini/function-calling-multi-turn-streaming/exchanges/0/response.sse @@ -0,0 +1,45 @@ +event: response.created +data: {"type":"response.created","response":{"id":"resp_02505034650cc750006ae54bd11a9487d09609c5c1bb8775af","object":"response","created_at":1793412049,"status":"in_progress","access_programs":null,"background":false,"completed_at":null,"error":null,"frequency_penalty":0.0,"incomplete_details":null,"instructions":null,"max_output_tokens":null,"max_tool_calls":null,"model":"gpt-5-mini-2025-08-07","moderation":null,"output":[],"parallel_tool_calls":true,"presence_penalty":0.0,"previous_response_id":null,"prompt_cache_key":null,"prompt_cache_retention":"in_memory","reasoning":{"context":"current_turn","effort":"medium","mode":"standard","summary":null},"safety_identifier":null,"service_tier":"auto","store":true,"temperature":1.0,"text":{"format":{"type":"text"},"verbosity":"medium"},"tool_choice":"auto","tool_usage":{"image_gen":{"input_tokens":0,"input_tokens_details":{"image_tokens":0,"text_tokens":0},"output_tokens":0,"output_tokens_details":{"image_tokens":0,"text_tokens":0},"total_tokens":0},"web_search":{"num_requests":0}},"tools":[{"type":"function","description":"Look up the current weather for a city.","name":"get_weather","output_schema":null,"parameters":{"type":"object","properties":{"location":{"type":"string","description":"City and optional region, e.g. 'Boston, MA'."}},"required":["location"],"additionalProperties":false},"strict":true}],"top_logprobs":0,"top_p":1.0,"truncation":"disabled","usage":null,"user":null,"metadata":{}},"sequence_number":0} + +event: response.in_progress +data: {"type":"response.in_progress","response":{"id":"resp_02505034650cc750006ae54bd11a9487d09609c5c1bb8775af","object":"response","created_at":1793412049,"status":"in_progress","access_programs":null,"background":false,"completed_at":null,"error":null,"frequency_penalty":0.0,"incomplete_details":null,"instructions":null,"max_output_tokens":null,"max_tool_calls":null,"model":"gpt-5-mini-2025-08-07","moderation":null,"output":[],"parallel_tool_calls":true,"presence_penalty":0.0,"previous_response_id":null,"prompt_cache_key":null,"prompt_cache_retention":"in_memory","reasoning":{"context":"current_turn","effort":"medium","mode":"standard","summary":null},"safety_identifier":null,"service_tier":"auto","store":true,"temperature":1.0,"text":{"format":{"type":"text"},"verbosity":"medium"},"tool_choice":"auto","tool_usage":{"image_gen":{"input_tokens":0,"input_tokens_details":{"image_tokens":0,"text_tokens":0},"output_tokens":0,"output_tokens_details":{"image_tokens":0,"text_tokens":0},"total_tokens":0},"web_search":{"num_requests":0}},"tools":[{"type":"function","description":"Look up the current weather for a city.","name":"get_weather","output_schema":null,"parameters":{"type":"object","properties":{"location":{"type":"string","description":"City and optional region, e.g. 'Boston, MA'."}},"required":["location"],"additionalProperties":false},"strict":true}],"top_logprobs":0,"top_p":1.0,"truncation":"disabled","usage":null,"user":null,"metadata":{}},"sequence_number":1} + +event: response.output_item.added +data: {"type":"response.output_item.added","item":{"id":"rs_02505034650cc750006ae54bd16d3087d088d8a0556a347a1f","type":"reasoning","content":[],"encrypted_content":"gAAAAABq5UvRLEX3OA8aAKFoldPkJDmVRHKqjPE8tsGxb0rCocL-4uUniGN352zQS9fPWFYyrnZASABoUx0pe_Bu5XzYypfuOrV-POThZAtrCDGnk1oM45WYTQCbVt87XsqK1b00hY6PaIbTdJe_NnhAys6_J9z7vtzisj1CXuDyZIXUDQGzfCmWuqTbzh4z77KV3hvtD7uyLcpu8fiofub6qVySODCpIj3yrLefRqAXmSkqxTutDghE2KbiZqeqj3bHAh0M4Ylh8GYVFXJ1_EVj951lG1wwh_vJiiRalZi3DC9FcepZXZTiJEE9KIkSOemL9UokBWnMBx2C2-Z1H6C1ZKPb834OUBNV-QDTYlL2jY5EKcYwBLeXpISNjMwrZ1BNWwqs5t_hJAvZoPsg6m0HNsAci6EUuT8hkR0PMREa7FBcLw3vgVh9dawKHdVCDV0zLrwutcLyR-0uiMqz9BA4ZXNfEeSS-h5PJlVBxe2NqghOZXTno5eLWoljPzxKgHs095zLieNvYxbfiBXY4h9nrPcOsC09vxnvXGBFyHbM4oKiDrb210arE6DGpxB7NOnumDBRDBeeb0PZFHdk6u7ZpuaKfKBPCn8Coa_afhrlKfyJs5gPDBSVjQ9EBDiRcgSJM5CDsfRkqzIPIsyeD93Hc9FT4sYVhnd3fJYNjrSS8PxyMfFYJ7gn5IvBVqTsx_JPDp4wGnHqVOcNIIf8GJ2PWsW6ZvQWIzTrH9d1sM1EJFh0TtpPZriI-bV5aK4iCEUkmharWO6vuXJ6dnfMSM2f0w8oNV5pqNB7TXIXNT2-5VG3CjcQ7B8kEdR3aYQrNPhNCzXzMPNmwoR0QwCl-RlhaxctcLP5ZeZITEVF6S_l251pkRrkTLA98kJx1T38b13n-0QwfDtSF6Myeshn6EFPgh3Hda6sOpSiYdmSNNlANRC0dV7VRxUYCrPM18ujfabX11vBKuLCGfQbkkUBw64Ss8a5tPBSIwdb2Hkfv-Tppq1kGKCarMD8InnedeFx4Ra1hMDmABQHJOZWBdnAhd2RxQYbWB5BhylTUxB9p_nCx_2nEYG6TEpJwEU9YvMm9tzRdnDTFBYbDZ8YqvYY_tvmYB-OmVVVkClLSDZeo3iPlrxoE87Cd1oEkU7qtz8qL9yf-2E411ZyO07TZf9JWMLAY4aZjyvhdssZ-Nj5tHu28Qt7SFJM8w-HhKiKpnsga3ZNMU6tHbOKi-lZIKchDVS0FwoYVbIh4g==","summary":[]},"output_index":0,"sequence_number":2} + +event: response.output_item.done +data: {"type":"response.output_item.done","item":{"id":"rs_02505034650cc750006ae54bd16d3087d088d8a0556a347a1f","type":"reasoning","content":[],"encrypted_content":"gAAAAABq5UvSi9MSFcdnWIBO-nuIKPv-x63GXGwGL1hSurYQKFgiKUQZBEHENisUTE21qOj5oAEiwURQVaPhDerM_k-27On-g5wfmwsix2YopvTKGvkHzo7frnYhRuE2qdE3wkuxBo2DHF1mnIdhkAKinE2MaSIq_i9I6mGKHb5r0PLFWaeKkQr2Da9pigs9sQfHK9vpdDBMs8LQOsOZ3CPvJyiMUs3h7KYgXGBfyky1cxhGtLoB3M_aSCR24JvssNfXsGzF5oGy0_vFCgZBjQZTl7CCWRLTb2BnRiFb16IQMlhPd2JWdtQOn-5o76KdGIWJG75geAuZPH00_M_NJaSpQ-A_-DSOFPSB61Y_BUhpsPQnQB3Bz2LvnosGuJM71Qu6eS9gSq_cRyCYxdVJZ1kvcnrz0QYpsKWuAIc-HceTUM3YkvkAmm_nE-czB1KXdtXN1zhVJq0vflF-vEIr0WiOCsKdQLv6Y0hAsHw-aDIU00qa9BGLn-N36kofW8DhkTx0Xfy1ZxLUGWVkW9XuWpIefgOjZmjP3EV-rzbWp7Zfjfduaa9NvOg955rkcMi9QyuLTXSgTyQ0bO8m58Z_UaGCv9aGweFIK4WnxxhJjo0NKrSEW7n2cOdoJhhlb8xPUo5xBfHSO2YWv2TkePRGfUqP1HB0QB64S_4LzgEsP7h3zttlBZZjh3B6sp9xB3nIOcFIuYcV_N8vOPAFR2VRTE8ZRgBCJeaDkKsq3mmEtJLSOOYoaCnNxEa-u-Bd20yBK-X8bW2Kq8BeD6BxNIVRkJVE7VbXH0fs2D9XyBE5BXLRwwRkQMgpy45mx7JDocOCZbVUe1w_BCXYqmEFxKMNsa-gdhdf4Pia96wyTLHUCljZFdoOq894TO0ArE8jDj_uHmupFUYgN8ofPBr8WSLq3lpNwyGaCrk020dY2QrJfSlhTLWMzY6fO7dx0TfDXAlFBELmWpjMT4-4uQUFUjPqlAmFuE6vmxe3bob607jV_xBOrXBKVtaR23Mos-fM3eBA2lIpbtVq9p0EhT5WpK9vi9hnpycJtLuXq34qg1bmGvbALS_bP0vZdUSZtILIvNNVPX4sFEA7_f7Blssvz-R_gExsX6QqQUUxbdsMMXDcSBcGaafKcucLhJ27Lo7g7cpooAmrYItQHylZ8VG2ObdasFIY--kA4dWUkwCcwYQvzRhIJoqQV5X_2aSxmzk-z-v6iiV7Z33aXv8z10iMrYfGOYImVpzn52W13AfEzZ-tfnOqWghPPnQTXLZZKKCYT_qLgGAnlqNxgb71jrI3ERHMUlpeNt8fPhofp0V3AjlyTwO2DzO1xKZOR-tspYTKYX6K_rTsyYgGpdi72qTxEq2U7q5GUjwsUiXTk0_QowDAGtU9RNUlP2QzmVMjdVx8BZVKptFakQ0MisKLDC4LkLa6AT3X6C681ZihU6Wm3GkVWZQmF9DQEHp0sQUYelSlte3UGDOacrxX_wHVjSPuCj8_spvmgC3FIM8cVYU0p9lCmChbwKKcQkvMhe5lpqPhDJJVtR-d-rau6hMJKP093ag0WcpjQWRBtOCFeD6YYTOQyIRGcvHxx38AX42pgrW0T6bmZNv86coWKLdRbOPNoxSW2osLYNH-l_OzJfkrNt3JNe4sBbcLAnta_EjA8IsKZIhi3j17rEqABL-L22dA-YBJg9AuY8wqogkf43dgR01TlWnTSK6nhCff90mEf_Nj00X35wSgIU5NYa4m6--7MY9rjt5-A1QXSdE0j2499wAfvqc5976BgSK8s-gAgOvnR05RPfPl2iOnHtPht2y2GCBPePBEXGyVf9b0ywdHQ56F_VTwgEb50fUD7wiEJZJf0XdZZ6Y8LSPigfrK5jueKVnkRb7VnPN_22eEPbFVGhpfRcboZpza8lmeNYEavMNNZyFiF8h0ZSZIUDf_aRA573gDcZzcqLpMuf8PfbksOpFn_UUe50tCMCPatvfUwHiGdNNllAqTgbBcoJgzv2MRgvQaexfc_Y0D7cx4B7hja4ehycLfWmShuidIuBjrZjA1pfrYy9NBC4xNDnBC4gX-1-er09Kdgn74clP6hVin1zsKRqgEmnANoRtYYmLbbN23fbvNf7NmPJk12Ld_YVLbKDOTWJoO9gHI0bbfs_QDFeDb9ArB5WdlFhsJffemyMlpaEo9_2ZbJX3KeskVcRA9oOMM95JBqAEvYGO2wOcpbrrEHz73hqEcZnbrfEWhTMGhtw4JCoabCj9RvRLx","summary":[]},"output_index":0,"sequence_number":3} + +event: response.output_item.added +data: {"type":"response.output_item.added","item":{"id":"fc_02505034650cc750006ae54bd22d6887d09b031c6a5eaf2a67","type":"function_call","status":"in_progress","arguments":"","call_id":"call_BLR2XDszwFTezANzLh3bE1Pr","name":"get_weather"},"output_index":1,"sequence_number":4} + +event: response.function_call_arguments.delta +data: {"type":"response.function_call_arguments.delta","delta":"{\"","item_id":"fc_02505034650cc750006ae54bd22d6887d09b031c6a5eaf2a67","obfuscation":"zXbzLPUCfsMLmw","output_index":1,"sequence_number":5} + +event: response.function_call_arguments.delta +data: {"type":"response.function_call_arguments.delta","delta":"location","item_id":"fc_02505034650cc750006ae54bd22d6887d09b031c6a5eaf2a67","obfuscation":"I12D0O7J","output_index":1,"sequence_number":6} + +event: response.function_call_arguments.delta +data: {"type":"response.function_call_arguments.delta","delta":"\":\"","item_id":"fc_02505034650cc750006ae54bd22d6887d09b031c6a5eaf2a67","obfuscation":"dLFXPqNAt2hZn","output_index":1,"sequence_number":7} + +event: response.function_call_arguments.delta +data: {"type":"response.function_call_arguments.delta","delta":"Boston","item_id":"fc_02505034650cc750006ae54bd22d6887d09b031c6a5eaf2a67","obfuscation":"AjhyV9dPPd","output_index":1,"sequence_number":8} + +event: response.function_call_arguments.delta +data: {"type":"response.function_call_arguments.delta","delta":",","item_id":"fc_02505034650cc750006ae54bd22d6887d09b031c6a5eaf2a67","obfuscation":"CKHSGPS9scRbrch","output_index":1,"sequence_number":9} + +event: response.function_call_arguments.delta +data: {"type":"response.function_call_arguments.delta","delta":" MA","item_id":"fc_02505034650cc750006ae54bd22d6887d09b031c6a5eaf2a67","obfuscation":"w8nmuXa7ARdEy","output_index":1,"sequence_number":10} + +event: response.function_call_arguments.delta +data: {"type":"response.function_call_arguments.delta","delta":"\"}","item_id":"fc_02505034650cc750006ae54bd22d6887d09b031c6a5eaf2a67","obfuscation":"IGe5JsuCpIfN8A","output_index":1,"sequence_number":11} + +event: response.function_call_arguments.done +data: {"type":"response.function_call_arguments.done","arguments":"{\"location\":\"Boston, MA\"}","item_id":"fc_02505034650cc750006ae54bd22d6887d09b031c6a5eaf2a67","output_index":1,"sequence_number":12} + +event: response.output_item.done +data: {"type":"response.output_item.done","item":{"id":"fc_02505034650cc750006ae54bd22d6887d09b031c6a5eaf2a67","type":"function_call","status":"completed","arguments":"{\"location\":\"Boston, MA\"}","call_id":"call_BLR2XDszwFTezANzLh3bE1Pr","name":"get_weather"},"output_index":1,"sequence_number":13} + +event: response.completed +data: {"type":"response.completed","response":{"id":"resp_02505034650cc750006ae54bd11a9487d09609c5c1bb8775af","object":"response","created_at":1793412049,"status":"completed","access_programs":null,"background":false,"completed_at":1793412050,"error":null,"frequency_penalty":0.0,"incomplete_details":null,"instructions":null,"max_output_tokens":null,"max_tool_calls":null,"model":"gpt-5-mini-2025-08-07","moderation":null,"output":[{"id":"rs_02505034650cc750006ae54bd16d3087d088d8a0556a347a1f","type":"reasoning","content":[],"encrypted_content":"gAAAAABq5UvSTc-mwiWn0cEb2egAJxvQOfm2uRs4jQCQcdaj71SPBmwGMho8KJ4V4CXQcDysaMbKafkX-NWobzHke2Uwf2YNsr-nBS19ALwbhN7XxRj4aW6HjKo4XGi1XUg7vkZUYn89LVmdp25JLcS5c63ZaVwfPc8s32txEHRv7S5b_7Z1hll3WqyJZJCqotCidpcScJt9BYVZutzhlrpdAYGLx2ZKpBlcUp-k8luSkjs1Slr-RNoyMmHEI9xhVqGg9SF_RcIXYOLLx2kS0VZjO1EsYB-d81Hbd2F19labqyur2UsT1EQ2kqo3jRXQMyRFN9bSv_XmMekxhTBS6cVWiJLznbm45nhuzunCHyU5SrlD0OV9xUr0BeLZoMlq8CRsC0-RMjcPxUcHzJj02Ref2F6XfMLnqYRIlib2ZzfT_9QuNYc7CJ-GvpVf84G1EE9xuihfOfP5WCPIhGGC3DN-INnu7VNJ6NF7Bl_PQRPtFYM9nr81imq5yle1BhWsUyJan5DWoOD-uy3SVxH-vB247Zgls7KObDfv3RM7zW4l37KOPTaQg3mPw-Tx5T1DjS_q6yMO_LmH_NqOyK6nK6wGYtfYEdkwPbhL1vJimFd6qz0lhdr8yMXAbfwXUTbjvjvOxEMVF8MauZ7kVo2qKQYzhShOnaDI--ZEsOQLptelYyPvd0YeCfNY6Rh5nru3FILIqzh-40lUZ4LEYtkjXkhARTAfR9-EW1yGes5pOl5noLzpjeiMxLVFfnk1Q1R_bNGd2NwB7wV66MsDlf_7w-vGT4-MkOKwJooPb9iiTY11JZF0m9L8skU-bf91RVmJiaVm2bcR1J8KSaoTKNT-8Wul5bMljhkaK3RoOoVfql-UMEjaNL84IHKuxjhQuv9iNdSpFxNI7HF25w0a9lzFFhlXmTjtC2fp5vEGF3Nw_s_W0tKNligB4CGOuTnDakvJVclf7z3UtGyy4TTGPyAs-X9WcEp6ooD1n8fBk2kkSXoDpbX8iBouqnsBE9PJROMPZ5yMW4xtP6LlBaCmSh8XF-XiNWkh9t1l8lvbOna7cnkEXgOOv1sLze4_EIn6gAHvTB2MxFGXLEKm_U1scQkPmQ1QAOk3oFnJAkqhEYJ5R41ltaiIS1PYk7COjZ545eP0iJzB0oIIAF4I4_nboOJsB1xJ9TZfKg_NWbhK6OT5wka2nD1yBjL-_Bs3xJC7n2wKnEPSN3tiO7PfQQ553HUv7PuGoAvoQw7H_zNL3XEYRrNiGaDXiB13vd3lN5ukr8p5iQMcaTa-vuI4QttjFYUugtASyFM9AHg1lEaGldngC-_A_yAg9OiVQZ6hUg8ZiPf6dTJioBpTKEMWYquhJVfyiSesZmOKDu3leSZ83Cy0NEXc7He00rmICrQuOJ8bw0S747_nhDaA_zfYFPUfvR_WzaOdqlSNhGod3tJ9XErvY8vtot_XAUMDJvpZwLHHzEc5ZXGL-17yhL3M46a7OIYSRSL5PxfWxW6JIT4_vwlwus5ROdVoGrfG_4LAC-zaOrmxVSU9DAMZJ5K_KKUSJ9uBRVXQHpDRL83X8FaeqW6nczcAdYtlakRWWDsEQVaOo6dOQe26OicVMRRVp9-PZ8u3eRUtb1D0r3UQyZLsBUIQsZ6SOaiA9CGxqKFO4eCpLF3dpzqUKsrzsscOH5mZwIhDhDdVs2W2PvpzlhNPcV3DOkyqKNEO5beRAq1J_Lckn8i7pLk_x_5sK9vJt9ho67bTBhc5np90NsLP0wFwmRgVrmKInE4EVCTTodOKG6cAGcK29IaUS2L1LUZZVTcboPsZ1zkQKv8buh70s8aeNdBsQJloGIEk7AKqJjKQavVo7uoKEHTMhvLdkIPtVKhqX8d5v3mwxKlQXVQWi7sD_yMkk9k5t5nEr33TKT80lpIgK3w-tcUkax6ueDvB-W-5KS5qEUpBBJpUx3QAeZPCgygxYDKF8UDhXmpSX1RSiPLSS3tCqRQi0hejEEhj2caxz56x-2UrYVw24OXINn0IgLtE0urQqZo7Kon66LHHSdReK1xxHnoRtPYkarGGKWEmx57filGnBdOM3oQlpthuI9a2Ro6NEU4kCCdPffgaskWwIXK93nVoYwSxDDQ-jGdMlDQHZf4ttJlpIMSD7VffFB-y9_oR06so-4a4wLGh4yAOhtlXykIZSq0GOd8i84MrqZN4zCgVz33qhEgDISrucBbo7OmbVklt4OfT3e6RLbeQeYnYo-EKufi0g3RI","summary":[]},{"id":"fc_02505034650cc750006ae54bd22d6887d09b031c6a5eaf2a67","type":"function_call","status":"completed","arguments":"{\"location\":\"Boston, MA\"}","call_id":"call_BLR2XDszwFTezANzLh3bE1Pr","name":"get_weather"}],"parallel_tool_calls":true,"presence_penalty":0.0,"previous_response_id":null,"prompt_cache_key":null,"prompt_cache_retention":"in_memory","reasoning":{"context":"current_turn","effort":"medium","mode":"standard","summary":null},"safety_identifier":null,"service_tier":"default","store":true,"temperature":1.0,"text":{"format":{"type":"text"},"verbosity":"medium"},"tool_choice":"auto","tool_usage":{"image_gen":{"input_tokens":0,"input_tokens_details":{"image_tokens":0,"text_tokens":0},"output_tokens":0,"output_tokens_details":{"image_tokens":0,"text_tokens":0},"total_tokens":0},"web_search":{"num_requests":0}},"tools":[{"type":"function","description":"Look up the current weather for a city.","name":"get_weather","output_schema":null,"parameters":{"type":"object","properties":{"location":{"type":"string","description":"City and optional region, e.g. 'Boston, MA'."}},"required":["location"],"additionalProperties":false},"strict":true}],"top_logprobs":0,"top_p":1.0,"truncation":"disabled","usage":{"input_tokens":73,"input_tokens_details":{"cache_write_tokens":0,"cached_tokens":0},"output_tokens":78,"output_tokens_details":{"reasoning_tokens":0},"total_tokens":151},"user":null,"metadata":{}},"sequence_number":14} + diff --git a/packages/inference-discovery-openai/sessions/openai-responses/gpt-5-mini/function-calling-multi-turn-streaming/session.json b/packages/inference-discovery-openai/sessions/openai-responses/gpt-5-mini/function-calling-multi-turn-streaming/session.json new file mode 100644 index 000000000..d93e9acfb --- /dev/null +++ b/packages/inference-discovery-openai/sessions/openai-responses/gpt-5-mini/function-calling-multi-turn-streaming/session.json @@ -0,0 +1,11 @@ +{ + "schemaVersion": "2", + "source": { + "provider": "openai-responses", + "model": "gpt-5-mini", + "baseURL": "https://api.openai.com/v1" + }, + "origin": "live", + "capturedAt": "2026-10-31T02:00:50.492Z", + "capability": "function-calling-multi-turn-streaming" +} diff --git a/packages/inference-discovery-openai/sessions/openai-responses/gpt-5-mini/function-calling-multi-turn/dispatches/0-get_weather.json b/packages/inference-discovery-openai/sessions/openai-responses/gpt-5-mini/function-calling-multi-turn/dispatches/0-get_weather.json new file mode 100644 index 000000000..21f38181b --- /dev/null +++ b/packages/inference-discovery-openai/sessions/openai-responses/gpt-5-mini/function-calling-multi-turn/dispatches/0-get_weather.json @@ -0,0 +1,6 @@ +{ + "args": { + "location": "Boston, MA" + }, + "result": "{\"location\":\"Boston, MA\",\"temperatureF\":68,\"conditions\":\"clear\"}" +} diff --git a/packages/inference-discovery-openai/sessions/openai-responses/gpt-5-mini/function-calling-multi-turn/exchanges/0/request-headers.json b/packages/inference-discovery-openai/sessions/openai-responses/gpt-5-mini/function-calling-multi-turn/exchanges/0/request-headers.json new file mode 100644 index 000000000..28c14bb85 --- /dev/null +++ b/packages/inference-discovery-openai/sessions/openai-responses/gpt-5-mini/function-calling-multi-turn/exchanges/0/request-headers.json @@ -0,0 +1,4 @@ +{ + "Content-Type": "application/json", + "Authorization": "" +} diff --git a/packages/inference-discovery-openai/sessions/openai-responses/gpt-5-mini/function-calling-multi-turn/exchanges/0/request.json b/packages/inference-discovery-openai/sessions/openai-responses/gpt-5-mini/function-calling-multi-turn/exchanges/0/request.json new file mode 100644 index 000000000..9ce84831a --- /dev/null +++ b/packages/inference-discovery-openai/sessions/openai-responses/gpt-5-mini/function-calling-multi-turn/exchanges/0/request.json @@ -0,0 +1,30 @@ +{ + "model": "gpt-5-mini", + "input": [ + { + "type": "message", + "role": "user", + "content": "What is the weather in Boston, MA? Use the provided tool." + } + ], + "tools": [ + { + "type": "function", + "name": "get_weather", + "description": "Look up the current weather for a city.", + "parameters": { + "type": "object", + "properties": { + "location": { + "type": "string", + "description": "City and optional region, e.g. 'Boston, MA'." + } + }, + "required": [ + "location" + ] + } + } + ], + "tool_choice": "auto" +} diff --git a/packages/inference-discovery-openai/sessions/openai-responses/gpt-5-mini/function-calling-multi-turn/exchanges/0/response-headers.json b/packages/inference-discovery-openai/sessions/openai-responses/gpt-5-mini/function-calling-multi-turn/exchanges/0/response-headers.json new file mode 100644 index 000000000..e55342927 --- /dev/null +++ b/packages/inference-discovery-openai/sessions/openai-responses/gpt-5-mini/function-calling-multi-turn/exchanges/0/response-headers.json @@ -0,0 +1,26 @@ +{ + "access-control-expose-headers": "X-Request-ID, Server-Timing-Total, CF-Ray, CF-Ray", + "alt-svc": "h3=\":443\"; ma=86400", + "cf-cache-status": "DYNAMIC", + "cf-ray": "a54f2595baca2f1b-LAX", + "connection": "keep-alive", + "content-encoding": "br", + "content-type": "application/json", + "date": "Tue, 03 Nov 2026 23:26:59 GMT", + "openai-organization": "", + "openai-processing-ms": "1671", + "openai-project": "", + "openai-version": "2020-10-01", + "server": "cloudflare", + "strict-transport-security": "max-age=31536000; includeSubDomains; preload", + "transfer-encoding": "chunked", + "x-content-type-options": "nosniff", + "x-ratelimit-limit-requests": "5000", + "x-ratelimit-limit-tokens": "2000000", + "x-ratelimit-remaining-requests": "4999", + "x-ratelimit-remaining-tokens": "2000000", + "x-ratelimit-reset-requests": "12ms", + "x-ratelimit-reset-tokens": "0s", + "x-request-id": "", + "set-cookie": "" +} diff --git a/packages/inference-discovery-openai/sessions/openai-responses/gpt-5-mini/function-calling-multi-turn/exchanges/0/response.json b/packages/inference-discovery-openai/sessions/openai-responses/gpt-5-mini/function-calling-multi-turn/exchanges/0/response.json new file mode 100644 index 000000000..d0a053cb0 --- /dev/null +++ b/packages/inference-discovery-openai/sessions/openai-responses/gpt-5-mini/function-calling-multi-turn/exchanges/0/response.json @@ -0,0 +1,119 @@ +{ + "id": "resp_009baef098af7e3b006aea6dc1768887d089886b2e981123e7", + "object": "response", + "created_at": 1793748417, + "status": "completed", + "access_programs": null, + "background": false, + "billing": { + "payer": "developer" + }, + "completed_at": 1793748418, + "error": null, + "frequency_penalty": 0.0, + "image": { + "context_compression": "disabled" + }, + "incomplete_details": null, + "instructions": null, + "max_output_tokens": null, + "max_tool_calls": null, + "model": "gpt-5-mini-2025-08-07", + "moderation": null, + "output": [ + { + "id": "rs_009baef098af7e3b006aea6dc2214887d094b63a0556353caf", + "type": "reasoning", + "content": [], + "encrypted_content": "gAAAAABq6m3DA2YmKP3lJj9aoTiWN2OW04pCBkl18MJU_lT4jNKie5LQViUuCoYzfPTCEVRecRMiKe6_3QUhXaNqsqYWACuELi3yzkIN95J88cz6U4PixIOfPQfJqEPgs2oyuw6FkKkuM2lWK9HwkbvG44Qxh088NOlv-kq5A3W5hPjdBw-9P-LkOeiywsg6-qQM_E_i7PcLeq6fS5HfHuJB1SDnO2eL3fuTjrSK27qhoH6r_L3sgst9S0JbDXPuji4aHfCoc6JB9IoLNHchcvsOqU5FI5N6OcW__i61LnS3vY6tvEkqAuvYoA9QfaE3EXz97pl7tV6lAs4vUaRoy3OmxJAJAWecYI3qiREPmIQUjgy86U_qZZj3PbEPmjx2ohQ6rDJ4hJ7bdSBTyKll0b7RGi4jKZzDxDp_QNFS1nnQK2tqPvuKK7-BXAGTJp7qcqjIea1xeugV5j0B66hnN1ZNTdv-NPvpxoTOPsd9ZNFFPxt3YKdzbhf7gwIs6uhHLOMkOjVxCipRoglIe81dsH2QXouY4F0QmOGVFS4ctWfxvWk1Lfq_1lTC2ZOOnOq9AaSAb64b522-irijhcH8bVSVdMrLIClRG0gyd39xrrqBoxmWXdgbPQbR1oNwQH8houihQRvniOb9jP0ZRydmNiYllw6XwlL6el8ZR10Ek3lyP3NueGYBF4_JCngfdGVM1f4zsJx9M9Qi2RbZZyg3pni_Xp-lNuVpyeTS7XKWYG6sVnE08RoAu_krkFWn-BbdHvuoH78FghYjKFuK-g3c7WTqMbUR7dvWamBsupO289kBWS75GcU4cO38ZWud6mtixw9rX1gxi4Y06d7W-7NCbmmlaEzMTkt1WXI5erIOHVkXVkOeRjJysqvQOwlIM3ubqnLX5MLLNjSvcetenCNqOJG9Eu_bjNWP658JrdagxIq21lpTiLvEP1b77v76SueYIazwwXA9DTn-3C1c24ad58H6CfXP_Zts5upQibCmtfNNeuGhtgK4bJfoXcMT9-bUN9NqBauS2Z3ynjdG4Rl18Y0Q7t5SZ6OuSbuoIClyCbCUsvEJ0_0K20LVOcm2lChrpQVPUHYgQVND6YV1GyajpODdYmPfl6fT_OJARtBDN_jigvNqHuasXl-RVoKShVNthoOlW4ojgPV7Tm0nR045iJdD3qV43lVHSMBBjf--eIlM-4gcI88EsA0ZcXPsK4bmBe6ng-bJiv3_Tm5jxsD5SU7s6TS4DuBOmOj5b9kpDeB6g8vn6G3_Nm-_D7wH5pApLL693e7mGNKRg2VP6VOu1nd7UhBGYYELamVZPl5yEA2B4Qludmtju6vXE3P6BBURSfkmM5vPR57q9aUAeDuP_KWCaFCK3hmXsV1KNybJlWDLt0g1YdPncDDEXql59zgZTP3IgjPbQhAOFIgoZcrzMPO3AML0Zlk6XdX9Ck6myoLlzdIwLfaeSxGxHMigh0cDRgLU-Pkk5VleEVLE_Y_kzELQRkX536huDG9PuMdXVBTcT98JQpbb--Axo0J1S61DDw8YK2hazvOcVHDKiON_Q5X6N7ojTEnK09lXVav4mMlc3tGLWHfSkIBB-U1WGkmueLCQJoiD4kjsB6CpUUOTJEPEgb0-0isMo-7hpVLanmSpIGp6L7a7buuqYmfSaRNl4DrnrO6HRyrx6cUDBHgD1-mRLJgy8ni_ONGY-pyTGu1whi3DJ2BvEqrpMycNfe6UQiaF_M4O_3fmvj1YzcRY1oyQfPqQQRcB-licYlZ0GRh00rvMbw4yo6JdjFi9dThGo6EjMyoOS31OxjpTBmiRf6-D0zx72i2AUVVS8JiACJVqgwY5EDSGaeSVHHSbQM_OOEDzIA1XIxGZ6W3okHvrXcODlg8u72EKmmJCToWXII0LXrJmFPzf5sTKqSeKVxwlW8Lta-UdMWK8U4cuFeuj328tPN9-GTttg3JpjDl_VDPH7qTJwEagVbJzF-83XjBIoxlRI-uJljMiJX3P26plQqUJf6L4xtg4lAewVy8ug166BlViSXdqO2PMBo0KTeMSQeK4GqbinQm3fe_UkdS41C0kGXf7ctmKJ0B1ZG1WP6ukWO0WqOeccC8e0AJAWX1fc9vgd0wgd7_KqY5GmGGr45cI-L75pM9pigtLl865i_daefIUu5bVPjUWwKC7sVhFND7a316GqqumNZi0gLamjnAcRRO2WCd_SGDh18Prm9CYxDfJDwxgicGimwC_m2eQbwTXk-6UE4ZLc-RJ-WYDzDqyl3K4IQ9d18P4tTW1fctXq20TcFoWg03kHVcr3HRNC8m0cDaCjcOppn1lrB_qrCjmku6_XexK5uLByJltHaGOeRmp9cmsquAzJqP46XL1-cweH_QNQQL68LYZ89FleizLtuDlGM4wFim0H2_acKFos4qd1turAg0AR62htwhcBtu3-j2exb_mQoHwCAS8D69f_qPVcJL2VYU4RpzdPnhUplpFwBgZS7lv5GRi2rXIeg1fh5kVc6g70DcvPeHaKeZkS96MA_uiQKUUaoCeXJw7K7pXQSUrC6sHPk0qQuIFxCMZcPUdTaRg4wjsVH4oCi6NOeHRPaTRIvcPSe49e94p0G9-ES_zKn8=", + "summary": [] + }, + { + "id": "fc_009baef098af7e3b006aea6dc2ccac87d0b001eeb47de9773a", + "type": "function_call", + "status": "completed", + "arguments": "{\"location\":\"Boston, MA\"}", + "call_id": "call_rmNm2DgixDBBupimKOp3XskF", + "name": "get_weather" + } + ], + "parallel_tool_calls": true, + "presence_penalty": 0.0, + "previous_response_id": null, + "prompt_cache_key": null, + "prompt_cache_retention": "in_memory", + "reasoning": { + "context": "current_turn", + "effort": "medium", + "mode": "standard", + "summary": null + }, + "safety_identifier": null, + "service_tier": "default", + "store": true, + "temperature": 1.0, + "text": { + "format": { + "type": "text" + }, + "verbosity": "medium" + }, + "tool_choice": "auto", + "tool_usage": { + "image_gen": { + "input_tokens": 0, + "input_tokens_details": { + "image_tokens": 0, + "text_tokens": 0 + }, + "output_tokens": 0, + "output_tokens_details": { + "image_tokens": 0, + "text_tokens": 0 + }, + "total_tokens": 0 + }, + "web_search": { + "num_requests": 0 + } + }, + "tools": [ + { + "type": "function", + "description": "Look up the current weather for a city.", + "name": "get_weather", + "output_schema": null, + "parameters": { + "type": "object", + "properties": { + "location": { + "type": "string", + "description": "City and optional region, e.g. 'Boston, MA'." + } + }, + "required": [ + "location" + ], + "additionalProperties": false + }, + "strict": true + } + ], + "top_logprobs": 0, + "top_p": 1.0, + "truncation": "disabled", + "usage": { + "input_tokens": 73, + "input_tokens_details": { + "cache_write_tokens": 0, + "cached_tokens": 0 + }, + "output_tokens": 105, + "output_tokens_details": { + "reasoning_tokens": 64 + }, + "total_tokens": 178 + }, + "user": null, + "metadata": {} +} \ No newline at end of file diff --git a/packages/inference-discovery-openai/sessions/openai-responses/gpt-5-mini/function-calling-multi-turn/exchanges/1/request-headers.json b/packages/inference-discovery-openai/sessions/openai-responses/gpt-5-mini/function-calling-multi-turn/exchanges/1/request-headers.json new file mode 100644 index 000000000..28c14bb85 --- /dev/null +++ b/packages/inference-discovery-openai/sessions/openai-responses/gpt-5-mini/function-calling-multi-turn/exchanges/1/request-headers.json @@ -0,0 +1,4 @@ +{ + "Content-Type": "application/json", + "Authorization": "" +} diff --git a/packages/inference-discovery-openai/sessions/openai-responses/gpt-5-mini/function-calling-multi-turn/exchanges/1/request.json b/packages/inference-discovery-openai/sessions/openai-responses/gpt-5-mini/function-calling-multi-turn/exchanges/1/request.json new file mode 100644 index 000000000..07c2a1630 --- /dev/null +++ b/packages/inference-discovery-openai/sessions/openai-responses/gpt-5-mini/function-calling-multi-turn/exchanges/1/request.json @@ -0,0 +1,50 @@ +{ + "model": "gpt-5-mini", + "input": [ + { + "type": "message", + "role": "user", + "content": "What is the weather in Boston, MA? Use the provided tool." + }, + { + "type": "reasoning", + "summary": [], + "encrypted_content": "gAAAAABq6m3DA2YmKP3lJj9aoTiWN2OW04pCBkl18MJU_lT4jNKie5LQViUuCoYzfPTCEVRecRMiKe6_3QUhXaNqsqYWACuELi3yzkIN95J88cz6U4PixIOfPQfJqEPgs2oyuw6FkKkuM2lWK9HwkbvG44Qxh088NOlv-kq5A3W5hPjdBw-9P-LkOeiywsg6-qQM_E_i7PcLeq6fS5HfHuJB1SDnO2eL3fuTjrSK27qhoH6r_L3sgst9S0JbDXPuji4aHfCoc6JB9IoLNHchcvsOqU5FI5N6OcW__i61LnS3vY6tvEkqAuvYoA9QfaE3EXz97pl7tV6lAs4vUaRoy3OmxJAJAWecYI3qiREPmIQUjgy86U_qZZj3PbEPmjx2ohQ6rDJ4hJ7bdSBTyKll0b7RGi4jKZzDxDp_QNFS1nnQK2tqPvuKK7-BXAGTJp7qcqjIea1xeugV5j0B66hnN1ZNTdv-NPvpxoTOPsd9ZNFFPxt3YKdzbhf7gwIs6uhHLOMkOjVxCipRoglIe81dsH2QXouY4F0QmOGVFS4ctWfxvWk1Lfq_1lTC2ZOOnOq9AaSAb64b522-irijhcH8bVSVdMrLIClRG0gyd39xrrqBoxmWXdgbPQbR1oNwQH8houihQRvniOb9jP0ZRydmNiYllw6XwlL6el8ZR10Ek3lyP3NueGYBF4_JCngfdGVM1f4zsJx9M9Qi2RbZZyg3pni_Xp-lNuVpyeTS7XKWYG6sVnE08RoAu_krkFWn-BbdHvuoH78FghYjKFuK-g3c7WTqMbUR7dvWamBsupO289kBWS75GcU4cO38ZWud6mtixw9rX1gxi4Y06d7W-7NCbmmlaEzMTkt1WXI5erIOHVkXVkOeRjJysqvQOwlIM3ubqnLX5MLLNjSvcetenCNqOJG9Eu_bjNWP658JrdagxIq21lpTiLvEP1b77v76SueYIazwwXA9DTn-3C1c24ad58H6CfXP_Zts5upQibCmtfNNeuGhtgK4bJfoXcMT9-bUN9NqBauS2Z3ynjdG4Rl18Y0Q7t5SZ6OuSbuoIClyCbCUsvEJ0_0K20LVOcm2lChrpQVPUHYgQVND6YV1GyajpODdYmPfl6fT_OJARtBDN_jigvNqHuasXl-RVoKShVNthoOlW4ojgPV7Tm0nR045iJdD3qV43lVHSMBBjf--eIlM-4gcI88EsA0ZcXPsK4bmBe6ng-bJiv3_Tm5jxsD5SU7s6TS4DuBOmOj5b9kpDeB6g8vn6G3_Nm-_D7wH5pApLL693e7mGNKRg2VP6VOu1nd7UhBGYYELamVZPl5yEA2B4Qludmtju6vXE3P6BBURSfkmM5vPR57q9aUAeDuP_KWCaFCK3hmXsV1KNybJlWDLt0g1YdPncDDEXql59zgZTP3IgjPbQhAOFIgoZcrzMPO3AML0Zlk6XdX9Ck6myoLlzdIwLfaeSxGxHMigh0cDRgLU-Pkk5VleEVLE_Y_kzELQRkX536huDG9PuMdXVBTcT98JQpbb--Axo0J1S61DDw8YK2hazvOcVHDKiON_Q5X6N7ojTEnK09lXVav4mMlc3tGLWHfSkIBB-U1WGkmueLCQJoiD4kjsB6CpUUOTJEPEgb0-0isMo-7hpVLanmSpIGp6L7a7buuqYmfSaRNl4DrnrO6HRyrx6cUDBHgD1-mRLJgy8ni_ONGY-pyTGu1whi3DJ2BvEqrpMycNfe6UQiaF_M4O_3fmvj1YzcRY1oyQfPqQQRcB-licYlZ0GRh00rvMbw4yo6JdjFi9dThGo6EjMyoOS31OxjpTBmiRf6-D0zx72i2AUVVS8JiACJVqgwY5EDSGaeSVHHSbQM_OOEDzIA1XIxGZ6W3okHvrXcODlg8u72EKmmJCToWXII0LXrJmFPzf5sTKqSeKVxwlW8Lta-UdMWK8U4cuFeuj328tPN9-GTttg3JpjDl_VDPH7qTJwEagVbJzF-83XjBIoxlRI-uJljMiJX3P26plQqUJf6L4xtg4lAewVy8ug166BlViSXdqO2PMBo0KTeMSQeK4GqbinQm3fe_UkdS41C0kGXf7ctmKJ0B1ZG1WP6ukWO0WqOeccC8e0AJAWX1fc9vgd0wgd7_KqY5GmGGr45cI-L75pM9pigtLl865i_daefIUu5bVPjUWwKC7sVhFND7a316GqqumNZi0gLamjnAcRRO2WCd_SGDh18Prm9CYxDfJDwxgicGimwC_m2eQbwTXk-6UE4ZLc-RJ-WYDzDqyl3K4IQ9d18P4tTW1fctXq20TcFoWg03kHVcr3HRNC8m0cDaCjcOppn1lrB_qrCjmku6_XexK5uLByJltHaGOeRmp9cmsquAzJqP46XL1-cweH_QNQQL68LYZ89FleizLtuDlGM4wFim0H2_acKFos4qd1turAg0AR62htwhcBtu3-j2exb_mQoHwCAS8D69f_qPVcJL2VYU4RpzdPnhUplpFwBgZS7lv5GRi2rXIeg1fh5kVc6g70DcvPeHaKeZkS96MA_uiQKUUaoCeXJw7K7pXQSUrC6sHPk0qQuIFxCMZcPUdTaRg4wjsVH4oCi6NOeHRPaTRIvcPSe49e94p0G9-ES_zKn8=" + }, + { + "type": "function_call", + "call_id": "call_rmNm2DgixDBBupimKOp3XskF", + "name": "get_weather", + "arguments": "{\"location\":\"Boston, MA\"}" + }, + { + "type": "function_call_output", + "call_id": "call_rmNm2DgixDBBupimKOp3XskF", + "output": "{\"location\":\"Boston, MA\",\"temperatureF\":68,\"conditions\":\"clear\"}" + } + ], + "store": false, + "include": [ + "reasoning.encrypted_content" + ], + "tools": [ + { + "type": "function", + "name": "get_weather", + "description": "Look up the current weather for a city.", + "parameters": { + "type": "object", + "properties": { + "location": { + "type": "string", + "description": "City and optional region, e.g. 'Boston, MA'." + } + }, + "required": [ + "location" + ] + } + } + ], + "tool_choice": "auto" +} diff --git a/packages/inference-discovery-openai/sessions/openai-responses/gpt-5-mini/function-calling-multi-turn/exchanges/1/response-headers.json b/packages/inference-discovery-openai/sessions/openai-responses/gpt-5-mini/function-calling-multi-turn/exchanges/1/response-headers.json new file mode 100644 index 000000000..180b4f875 --- /dev/null +++ b/packages/inference-discovery-openai/sessions/openai-responses/gpt-5-mini/function-calling-multi-turn/exchanges/1/response-headers.json @@ -0,0 +1,26 @@ +{ + "access-control-expose-headers": "X-Request-ID, Server-Timing-Total, CF-Ray, CF-Ray", + "alt-svc": "h3=\":443\"; ma=86400", + "cf-cache-status": "DYNAMIC", + "cf-ray": "a54f25a43f562f1b-LAX", + "connection": "keep-alive", + "content-encoding": "br", + "content-type": "application/json", + "date": "Tue, 03 Nov 2026 23:26:59 GMT", + "openai-organization": "", + "openai-processing-ms": "485", + "openai-project": "", + "openai-version": "2020-10-01", + "server": "cloudflare", + "strict-transport-security": "max-age=31536000; includeSubDomains; preload", + "transfer-encoding": "chunked", + "x-content-type-options": "nosniff", + "x-ratelimit-limit-requests": "5000", + "x-ratelimit-limit-tokens": "2000000", + "x-ratelimit-remaining-requests": "4999", + "x-ratelimit-remaining-tokens": "2000000", + "x-ratelimit-reset-requests": "12ms", + "x-ratelimit-reset-tokens": "0s", + "x-request-id": "", + "set-cookie": "" +} diff --git a/packages/inference-discovery-openai/sessions/openai-responses/gpt-5-mini/function-calling-multi-turn/exchanges/1/response.json b/packages/inference-discovery-openai/sessions/openai-responses/gpt-5-mini/function-calling-multi-turn/exchanges/1/response.json new file mode 100644 index 000000000..ed09c593a --- /dev/null +++ b/packages/inference-discovery-openai/sessions/openai-responses/gpt-5-mini/function-calling-multi-turn/exchanges/1/response.json @@ -0,0 +1,118 @@ +{ + "id": "resp_0508e1f02e245a51016aea6dc35d5487d090a5057b7c600dc6", + "object": "response", + "created_at": 1793748419, + "status": "completed", + "access_programs": null, + "background": false, + "billing": { + "payer": "developer" + }, + "completed_at": 1793748419, + "error": null, + "frequency_penalty": 0.0, + "image": { + "context_compression": "disabled" + }, + "incomplete_details": null, + "instructions": null, + "max_output_tokens": null, + "max_tool_calls": null, + "model": "gpt-5-mini-2025-08-07", + "moderation": null, + "output": [ + { + "id": "msg_0508e1f02e245a51016aea6dc3aae087d0bb638de4dc8c1fa3", + "type": "message", + "status": "completed", + "content": [ + { + "type": "output_text", + "annotations": [], + "logprobs": [], + "text": "Current weather in Boston, MA: 68\u00b0F, clear skies." + } + ], + "role": "assistant" + } + ], + "parallel_tool_calls": true, + "presence_penalty": 0.0, + "previous_response_id": null, + "prompt_cache_key": null, + "prompt_cache_retention": "in_memory", + "reasoning": { + "context": "current_turn", + "effort": "medium", + "mode": "standard", + "summary": null + }, + "safety_identifier": null, + "service_tier": "default", + "store": false, + "temperature": 1.0, + "text": { + "format": { + "type": "text" + }, + "verbosity": "medium" + }, + "tool_choice": "auto", + "tool_usage": { + "image_gen": { + "input_tokens": 0, + "input_tokens_details": { + "image_tokens": 0, + "text_tokens": 0 + }, + "output_tokens": 0, + "output_tokens_details": { + "image_tokens": 0, + "text_tokens": 0 + }, + "total_tokens": 0 + }, + "web_search": { + "num_requests": 0 + } + }, + "tools": [ + { + "type": "function", + "description": "Look up the current weather for a city.", + "name": "get_weather", + "output_schema": null, + "parameters": { + "type": "object", + "properties": { + "location": { + "type": "string", + "description": "City and optional region, e.g. 'Boston, MA'." + } + }, + "required": [ + "location" + ], + "additionalProperties": false + }, + "strict": true + } + ], + "top_logprobs": 0, + "top_p": 1.0, + "truncation": "disabled", + "usage": { + "input_tokens": 202, + "input_tokens_details": { + "cache_write_tokens": 0, + "cached_tokens": 0 + }, + "output_tokens": 18, + "output_tokens_details": { + "reasoning_tokens": 0 + }, + "total_tokens": 220 + }, + "user": null, + "metadata": {} +} \ No newline at end of file diff --git a/packages/inference-discovery-openai/sessions/openai-responses/gpt-5-mini/function-calling-multi-turn/session.json b/packages/inference-discovery-openai/sessions/openai-responses/gpt-5-mini/function-calling-multi-turn/session.json new file mode 100644 index 000000000..2b7e445de --- /dev/null +++ b/packages/inference-discovery-openai/sessions/openai-responses/gpt-5-mini/function-calling-multi-turn/session.json @@ -0,0 +1,11 @@ +{ + "schemaVersion": "2", + "source": { + "provider": "openai-responses", + "model": "gpt-5-mini", + "baseURL": "https://api.openai.com/v1" + }, + "origin": "live", + "capturedAt": "2026-11-03T23:26:59.854Z", + "capability": "function-calling-multi-turn" +} diff --git a/packages/inference-discovery-openai/sessions/openai-responses/gpt-5-mini/function-calling/exchanges/0/request-headers.json b/packages/inference-discovery-openai/sessions/openai-responses/gpt-5-mini/function-calling/exchanges/0/request-headers.json new file mode 100644 index 000000000..28c14bb85 --- /dev/null +++ b/packages/inference-discovery-openai/sessions/openai-responses/gpt-5-mini/function-calling/exchanges/0/request-headers.json @@ -0,0 +1,4 @@ +{ + "Content-Type": "application/json", + "Authorization": "" +} diff --git a/packages/inference-discovery-openai/sessions/openai-responses/gpt-5-mini/function-calling/exchanges/0/request.json b/packages/inference-discovery-openai/sessions/openai-responses/gpt-5-mini/function-calling/exchanges/0/request.json new file mode 100644 index 000000000..9ce84831a --- /dev/null +++ b/packages/inference-discovery-openai/sessions/openai-responses/gpt-5-mini/function-calling/exchanges/0/request.json @@ -0,0 +1,30 @@ +{ + "model": "gpt-5-mini", + "input": [ + { + "type": "message", + "role": "user", + "content": "What is the weather in Boston, MA? Use the provided tool." + } + ], + "tools": [ + { + "type": "function", + "name": "get_weather", + "description": "Look up the current weather for a city.", + "parameters": { + "type": "object", + "properties": { + "location": { + "type": "string", + "description": "City and optional region, e.g. 'Boston, MA'." + } + }, + "required": [ + "location" + ] + } + } + ], + "tool_choice": "auto" +} diff --git a/packages/inference-discovery-openai/sessions/openai-responses/gpt-5-mini/function-calling/exchanges/0/response-headers.json b/packages/inference-discovery-openai/sessions/openai-responses/gpt-5-mini/function-calling/exchanges/0/response-headers.json new file mode 100644 index 000000000..cca6d6140 --- /dev/null +++ b/packages/inference-discovery-openai/sessions/openai-responses/gpt-5-mini/function-calling/exchanges/0/response-headers.json @@ -0,0 +1,26 @@ +{ + "access-control-expose-headers": "X-Request-ID, Server-Timing-Total, CF-Ray, CF-Ray", + "alt-svc": "h3=\":443\"; ma=86400", + "cf-cache-status": "DYNAMIC", + "cf-ray": "a5280f44b9cf5730-LAX", + "connection": "keep-alive", + "content-encoding": "br", + "content-type": "application/json", + "date": "Fri, 30 Oct 2026 05:36:00 GMT", + "openai-organization": "", + "openai-processing-ms": "2351", + "openai-project": "", + "openai-version": "2020-10-01", + "server": "cloudflare", + "strict-transport-security": "max-age=31536000; includeSubDomains; preload", + "transfer-encoding": "chunked", + "x-content-type-options": "nosniff", + "x-ratelimit-limit-requests": "5000", + "x-ratelimit-limit-tokens": "2000000", + "x-ratelimit-remaining-requests": "4999", + "x-ratelimit-remaining-tokens": "2000000", + "x-ratelimit-reset-requests": "12ms", + "x-ratelimit-reset-tokens": "0s", + "x-request-id": "", + "set-cookie": "" +} diff --git a/packages/inference-discovery-openai/sessions/openai-responses/gpt-5-mini/function-calling/exchanges/0/response.json b/packages/inference-discovery-openai/sessions/openai-responses/gpt-5-mini/function-calling/exchanges/0/response.json new file mode 100644 index 000000000..6258c3db9 --- /dev/null +++ b/packages/inference-discovery-openai/sessions/openai-responses/gpt-5-mini/function-calling/exchanges/0/response.json @@ -0,0 +1,116 @@ +{ + "id": "resp_035f7b620c6bc4e2006ae42cbe593c87d0af9484a05f0469a9", + "object": "response", + "created_at": 1793338558, + "status": "completed", + "access_programs": null, + "background": false, + "billing": { + "payer": "developer" + }, + "completed_at": 1793338560, + "error": null, + "frequency_penalty": 0.0, + "incomplete_details": null, + "instructions": null, + "max_output_tokens": null, + "max_tool_calls": null, + "model": "gpt-5-mini-2025-08-07", + "moderation": null, + "output": [ + { + "id": "rs_035f7b620c6bc4e2006ae42cbf9f7487d08ffe76ddf013d225", + "type": "reasoning", + "content": [], + "encrypted_content": "gAAAAABq5CzASO_jZA-17rBVWqR9CsmtLilE90OmYPOSKRUqFR0hkpLqY60SW9pgPWP3pB4BT_8ycO7uL6SWiBkjCjT7dVQtnCPqMAzvHX-U4NTDqi7aLatNPhV755Y91zfSt_HHigd7Bz8386Y5cPEPZDRiDXEHBKgdZG9MzpsB39ma0qV27j4DriI3f0Hr714o6kp49du8lcJFDx0gH9W0Kdqr-fcohPBPmmerwNpUtkseWWjj4Ybr7VKZcfKLmqfbkj_3us8pJYp3ilu9GQwSGImzxPLn_ClfqIZVQp3suGOCi8HCYjC_jN0PUUy2ow7qFD4tqn6gq0Ff36Yi6bR7L0IY07Ulpy2HfSFz3zOCfv5THmbolFJ7VihfXgu4-5JjAPYzl_Vw3lyA7jnl91lZzwSlXnJ0NXwqEeawX2cJ8GKmroC36U36yMQjfn8JeHdGFX9Zzf1SPSwRy8qU2JYHdbl_w3CZOD7lgx2J3IWf3wj7IGdEQnb4CQ0p6tI7TBJ7MYR8UaPlSvRZzbImPxkHzz3OKg-oAoif_a3k8p9laUxZwGiU1BGaExYbgP5uFL7PnT4LDMnoUoCh3Rn173W3WpqLhTtcrDt-uU17zKBPnn4_6xDQ6EA6XLgv_YEeQIqVlO9PO6MF5H7ItMTdfMU8N_40Auhu70cFANlH-Wl5_O25YHxsOUkS_hkFSy6pnCKS_zjKiSWJgIYCVUlpmFMIoC7c0NYfdRQxVpT6QR-OTGCPGWmAEDTOwWoI1EfdVv_j5G_TdOhmplLZe8FmPCysKkiS0OKpMHNxdDzNX4LrDufrTANQl2UZgkmIgt4uhMjygojSqo_CvEehfJap1G-EtFXmI7z-CLX1FPpXMdYUREVT6MtPw6lXBKGGTH4T8xyIo9H7qju1p6vUig8VB6Zt_BcZ04PBxIEsbTTW9wQK8n6ckIYZT4IAqXxhriQ-6nm-dH5XPOVIM78sQQrRHNnLirh9AgDOwXk-HHXg3sPLpavNnJcM-zcsYALtjOlZLU35Y0CPMcflNADXSnrSedv05sG9oA9ZSI50tEHvFw-NbiUYb_B9vTEoJOyhly0TvpdlRii0IVvK1SuFmewPnTjqb2pSUwHD9Jo2QQ4d5svbkUHVzI1SUPFP3YFo5eOO7JAej2l5eRMcnYgr0-r_bEqrcOJDUscIA-1yNptuKyWExDrNeQUkVfdGQxm0v6WHmnP6mK4HHyYwGrE6QXpEyfmZTGJKqZEeq_9z_cBo_qpEN4CbCI0EdorzTshtqbALAdLO5I07ILRI0zcnzVZeYvkNAkxqBnsauC0QROmPYnbaV46SQl9yTKGcqJsvwXCFeA9yMOj721ZzYgVQBYO3Pm7T_U5xkVFr9Bs3xF1kvkRKsyV0xs3pLI4-HqTsMg9qScZAJ_zdL68xpBCGZ-L_M5La_adHIGHaNKtydQSIIpf6Zv1KFgs2nbltuqVMuUlIk_DEpT7MC7RM0KJoqcPJlCK3vnH2UsLvYjdmt-cMxB0fo6RmGFjBxYFn7r8yJOaDMKtZAQt-0jGng9J6ycm6peIYzDmB7HKttkVnC4_zm48dyCKqUMWCuKOijgAtU7Rd-JN8vh2NRERmNCA0S6M9msMRD8o7fKfiwfYYMSJT8EgsOvnaJm9f4Gpb7UengjbNAHIGdLnRL9wWL0lFNRaVHXv_RaWIodR5zeTiYidGJglXVMZXo0hNbH70Q8kvtjuxyCxn0YJvDmmUdlnV7riK23XXg0kn-t8O7wDdiWYsxB8xEGM9JZE5c-QaCPC7Glrh0fidWrEln1s1YZ0gDsNuuxwzVyKiNIv1RLtQv_4t_zis34eVZfpZBxgazDD3vS4sqjPDzmStxC2pQZVA6VUEKw0NhimAlVBRtpVtZ25dPErkpfU1al62bR2O71dLvVBL15gh9mgLo3PYO3VtROdNF7mkphd9bhPVs-3M-_kGaHJF3XFJUdicf53EY63qv8dpYaxaVCqWJ71mR-FtOZUr1Lvb765H88Lnxgib0ABMrPC6bzbgAb1ReE19RHRKP5_eX-cnDvGOyp2l9OdJTWkyL0L5gvnj1bG7IwMJq56oxpe-8VSJpAOlvwsr2gMkmQH8bcxTC-xMNYgV1RnYCQOKamJ8T0gJiBuTw8MFuOYBzUNRuDxoXy6vh8LpTpSJJzQHf9oPxl5EjW0LkYLFSfftFSicjMTiyVijEehqKwgzjmrkj_eS7XqOD2vVApOFLmD1CW77B63qmwu_ml0PXNWzo0p0xf9ZDyTM7MOXVQUnl9yrX0ulAJGZloI=", + "summary": [] + }, + { + "id": "fc_035f7b620c6bc4e2006ae42cc03fe887d0aa42f62d667e84c6", + "type": "function_call", + "status": "completed", + "arguments": "{\"location\":\"Boston, MA\"}", + "call_id": "call_CETI8e9aBonMt2moFrzKkZrb", + "name": "get_weather" + } + ], + "parallel_tool_calls": true, + "presence_penalty": 0.0, + "previous_response_id": null, + "prompt_cache_key": null, + "prompt_cache_retention": "in_memory", + "reasoning": { + "context": "current_turn", + "effort": "medium", + "mode": "standard", + "summary": null + }, + "safety_identifier": null, + "service_tier": "default", + "store": true, + "temperature": 1.0, + "text": { + "format": { + "type": "text" + }, + "verbosity": "medium" + }, + "tool_choice": "auto", + "tool_usage": { + "image_gen": { + "input_tokens": 0, + "input_tokens_details": { + "image_tokens": 0, + "text_tokens": 0 + }, + "output_tokens": 0, + "output_tokens_details": { + "image_tokens": 0, + "text_tokens": 0 + }, + "total_tokens": 0 + }, + "web_search": { + "num_requests": 0 + } + }, + "tools": [ + { + "type": "function", + "description": "Look up the current weather for a city.", + "name": "get_weather", + "output_schema": null, + "parameters": { + "type": "object", + "properties": { + "location": { + "type": "string", + "description": "City and optional region, e.g. 'Boston, MA'." + } + }, + "required": [ + "location" + ], + "additionalProperties": false + }, + "strict": true + } + ], + "top_logprobs": 0, + "top_p": 1.0, + "truncation": "disabled", + "usage": { + "input_tokens": 73, + "input_tokens_details": { + "cache_write_tokens": 0, + "cached_tokens": 0 + }, + "output_tokens": 81, + "output_tokens_details": { + "reasoning_tokens": 0 + }, + "total_tokens": 154 + }, + "user": null, + "metadata": {} +} \ No newline at end of file diff --git a/packages/inference-discovery-openai/sessions/openai-responses/gpt-5-mini/function-calling/session.json b/packages/inference-discovery-openai/sessions/openai-responses/gpt-5-mini/function-calling/session.json new file mode 100644 index 000000000..19bee08db --- /dev/null +++ b/packages/inference-discovery-openai/sessions/openai-responses/gpt-5-mini/function-calling/session.json @@ -0,0 +1,11 @@ +{ + "schemaVersion": "2", + "source": { + "provider": "openai-responses", + "model": "gpt-5-mini", + "baseURL": "https://api.openai.com/v1" + }, + "origin": "live", + "capturedAt": "2026-10-30T05:36:00.741Z", + "capability": "function-calling" +} diff --git a/packages/inference-discovery-openai/sessions/openai-responses/gpt-5-mini/plain-text-streaming/exchanges/0/request-headers.json b/packages/inference-discovery-openai/sessions/openai-responses/gpt-5-mini/plain-text-streaming/exchanges/0/request-headers.json new file mode 100644 index 000000000..28c14bb85 --- /dev/null +++ b/packages/inference-discovery-openai/sessions/openai-responses/gpt-5-mini/plain-text-streaming/exchanges/0/request-headers.json @@ -0,0 +1,4 @@ +{ + "Content-Type": "application/json", + "Authorization": "" +} diff --git a/packages/inference-discovery-openai/sessions/openai-responses/gpt-5-mini/plain-text-streaming/exchanges/0/request.json b/packages/inference-discovery-openai/sessions/openai-responses/gpt-5-mini/plain-text-streaming/exchanges/0/request.json new file mode 100644 index 000000000..5e5324751 --- /dev/null +++ b/packages/inference-discovery-openai/sessions/openai-responses/gpt-5-mini/plain-text-streaming/exchanges/0/request.json @@ -0,0 +1,11 @@ +{ + "model": "gpt-5-mini", + "input": [ + { + "type": "message", + "role": "user", + "content": "Reply with a single sentence: the capital of France is Paris." + } + ], + "stream": true +} diff --git a/packages/inference-discovery-openai/sessions/openai-responses/gpt-5-mini/plain-text-streaming/exchanges/0/response-headers.json b/packages/inference-discovery-openai/sessions/openai-responses/gpt-5-mini/plain-text-streaming/exchanges/0/response-headers.json new file mode 100644 index 000000000..3bf07f4a3 --- /dev/null +++ b/packages/inference-discovery-openai/sessions/openai-responses/gpt-5-mini/plain-text-streaming/exchanges/0/response-headers.json @@ -0,0 +1,25 @@ +{ + "access-control-expose-headers": "X-Request-ID, Server-Timing-Total, CF-Ray, CF-Ray", + "alt-svc": "h3=\":443\"; ma=86400", + "cf-cache-status": "DYNAMIC", + "cf-ray": "a5280f357fef5730-LAX", + "connection": "keep-alive", + "content-type": "text/event-stream; charset=utf-8", + "date": "Fri, 30 Oct 2026 05:35:56 GMT", + "openai-organization": "", + "openai-processing-ms": "787", + "openai-project": "", + "openai-version": "2020-10-01", + "server": "cloudflare", + "strict-transport-security": "max-age=31536000; includeSubDomains; preload", + "transfer-encoding": "chunked", + "x-content-type-options": "nosniff", + "x-ratelimit-limit-requests": "5000", + "x-ratelimit-limit-tokens": "2000000", + "x-ratelimit-remaining-requests": "4999", + "x-ratelimit-remaining-tokens": "1999764", + "x-ratelimit-reset-requests": "12ms", + "x-ratelimit-reset-tokens": "7ms", + "x-request-id": "", + "set-cookie": "" +} diff --git a/packages/inference-discovery-openai/sessions/openai-responses/gpt-5-mini/plain-text-streaming/exchanges/0/response.sse b/packages/inference-discovery-openai/sessions/openai-responses/gpt-5-mini/plain-text-streaming/exchanges/0/response.sse new file mode 100644 index 000000000..065b7ee1c --- /dev/null +++ b/packages/inference-discovery-openai/sessions/openai-responses/gpt-5-mini/plain-text-streaming/exchanges/0/response.sse @@ -0,0 +1,51 @@ +event: response.created +data: {"type":"response.created","response":{"id":"resp_08d409809d37383a006ae42cbbdb5087d09fba11ea0c69f3c3","object":"response","created_at":1793338555,"status":"in_progress","access_programs":null,"background":false,"completed_at":null,"error":null,"frequency_penalty":0.0,"incomplete_details":null,"instructions":null,"max_output_tokens":null,"max_tool_calls":null,"model":"gpt-5-mini-2025-08-07","moderation":null,"output":[],"parallel_tool_calls":true,"presence_penalty":0.0,"previous_response_id":null,"prompt_cache_key":null,"prompt_cache_retention":"in_memory","reasoning":{"context":"current_turn","effort":"medium","mode":"standard","summary":null},"safety_identifier":null,"service_tier":"auto","store":true,"temperature":1.0,"text":{"format":{"type":"text"},"verbosity":"medium"},"tool_choice":"auto","tool_usage":{"image_gen":{"input_tokens":0,"input_tokens_details":{"image_tokens":0,"text_tokens":0},"output_tokens":0,"output_tokens_details":{"image_tokens":0,"text_tokens":0},"total_tokens":0},"web_search":{"num_requests":0}},"tools":[],"top_logprobs":0,"top_p":1.0,"truncation":"disabled","usage":null,"user":null,"metadata":{}},"sequence_number":0} + +event: response.in_progress +data: {"type":"response.in_progress","response":{"id":"resp_08d409809d37383a006ae42cbbdb5087d09fba11ea0c69f3c3","object":"response","created_at":1793338555,"status":"in_progress","access_programs":null,"background":false,"completed_at":null,"error":null,"frequency_penalty":0.0,"incomplete_details":null,"instructions":null,"max_output_tokens":null,"max_tool_calls":null,"model":"gpt-5-mini-2025-08-07","moderation":null,"output":[],"parallel_tool_calls":true,"presence_penalty":0.0,"previous_response_id":null,"prompt_cache_key":null,"prompt_cache_retention":"in_memory","reasoning":{"context":"current_turn","effort":"medium","mode":"standard","summary":null},"safety_identifier":null,"service_tier":"auto","store":true,"temperature":1.0,"text":{"format":{"type":"text"},"verbosity":"medium"},"tool_choice":"auto","tool_usage":{"image_gen":{"input_tokens":0,"input_tokens_details":{"image_tokens":0,"text_tokens":0},"output_tokens":0,"output_tokens_details":{"image_tokens":0,"text_tokens":0},"total_tokens":0},"web_search":{"num_requests":0}},"tools":[],"top_logprobs":0,"top_p":1.0,"truncation":"disabled","usage":null,"user":null,"metadata":{}},"sequence_number":1} + +event: response.output_item.added +data: {"type":"response.output_item.added","item":{"id":"rs_08d409809d37383a006ae42cbcf44c87d082e13972109e9be5","type":"reasoning","content":[],"encrypted_content":"gAAAAABq5Cy8dgm49FpSeGd6xZIwCBTJoxGic-oAkSIFLZHsyw8q7O6U7pk-MCB4rliqLVArcGnVB-oCZPnsp7VEoPxhABjEy7oyXqIBcWRuHLygMxPJKXJfEjlY61NuacBVyjYc8pi3R2wcjH-GzNorcTDwUgA5vBQNDsla3FKeDWb03og1zHGeg9zzi1MlkxUhqak-LO33cMCjdliJqk7wqNlX4DM3N-X9-djYvRqQUNtm-whI3MyWhELGyw-WnCKAMeNYPDIPLOlEz637mDIdU2uwJ2sEM70Sux8hnpqSkCpW3iYn6ttDSSe0geWpQUUeGuAgE-E_2JNk45P3trb2hsRfxOr8Cv2Ehq-DhUSl1V_2oIQt12Fuj3ZxbT3Xz2Rk0_SrQeSznn1WmT9fxKxfhNYDYsTvA7Ft8B-IEMDHzlIDDB1uy05Eu5YV-ddo7n6m5klFlJHQOr5ouGPhCkV9-UchW0IEhtTyKCoya3qbU0X5fM1I97XvN98xtpem9CMIj_PQ2VVXFjoaTXmHoJbAJXDYNW_bGtw2KgfP7q38D1eU13AkVlIy2huiH9Q8zhnyIGgUAw97JGrRKhFtYIEbwJ31JS7TXwpyPUF5NBRWeZ8lomzJ3EA9sBwQbHzV8nerVESaTulS4SK1QE6Gp-7ZowM2qBiU9PGqzhzccO_lTQEgfioDsBiEKiyFGlS-I63gi-FOkCz5v3IntS7X7-eu4m0XOG5wvzDO4u416nGX-KPhfnIxEFF53K1GUmWczbwH2FIjc_oCqZKrXEJm3xD00jKliMVYkV73BUTRNsNKIwPJ5miSKIvyDQOd7nKposKiolulegaRk5qZiVUnu1c1T9ZxVz9BcVDKE2Ips_JFUOcN0r49jqMXzVWkPFNL2DDAL-i306R9_pGRWq-wHfye6K7fFJnkxkiMiytabcIpR9RLMkS0D9uMM7psjsESd3JQh7utdinW3opdzDaqGFd-UD5_9L3XraKHkabIk9HcRXuhkmJGaIO_hh2wqnIuWU9ZLS0LB_v_m0EYHrTOyydj130daS1GorapLpXgXXN_QmajpWMJkXOX6ngCM8PNDsUHoNP2embQoQeGrc_MXdWGrIwruOAPqb-pNVw70rScjvXCL12C8-eWHAjapLU4E5i-satR6mEuyWi5LMpHI-dTDSBQN_DlhhmMy77vyZEbkY3fCcoQ5KjEOTQj_LdFsejN1kqbk66BFRoNCQQy8NgQWLFIzsDrFw==","summary":[]},"output_index":0,"sequence_number":2} + +event: response.output_item.done +data: {"type":"response.output_item.done","item":{"id":"rs_08d409809d37383a006ae42cbcf44c87d082e13972109e9be5","type":"reasoning","content":[],"encrypted_content":"gAAAAABq5Cy9eNJqFmiuFzJBYx8La7OflM3_JwlGTN7XUl8joFAMWNjfFRW_p6_MX3H48c3xJfZ6gX4klD7ua7SxNegtM71PsxAfV_6FQjNHeHSBiCvZDh2APGNCn9WzebO6TIwhd2NXnz6uQbvIsumsodySLB-CkF5RK5l84JknEsrZLyzUX9AFl-lrMzzBfqj3Onoa7oxTWFE_9ikftH1dwa4lyeqfx-AKLFGGTW8BUtougUUB5ACSFfn8GH4y9MSQ2ofyriw3qw2JV46oMEYsE59k1WqzD-arB3a9REbIWUu8oceeN8h8G-CycjJQzthv8ImyPPMKbs6ZXa0IRcJwCCizY5Xml_B5Q9qdexIuaXLH9bh9i-86LRZfASYv8I_co0Ih9-lLMkxhMLFaVyaJHJE5RBmJIwaSbM2OGFxxQO8u8F044-BFefdBaFrRFhcj9v1kqjNYge7LaqobHjXjtpr5PD40nefimp6rWuycEKK3l_pVzpV7wt1zq7aDqohaNIMkLGsl8noVHSfafsLOkgTlFlCpZYSkLctEfYS0zhEzkbydLn8ObS7rm7Cd94Lb3DCWWqMLsB5frS2AEMSebYYD01lCWaN0gE1TH-f0256fhhoHbVHiXmVvFTt8XLQnougoMsQyECYH8Xgmb4hOzBuBDXZ6-BZymprpgslvtSaQSToK5bZasgL1DbN38u-lcuBBdhgVWYaC6rXQyDafvCG32pxIMFXmLxSlFy4QG_o1h-Cq9nrIa0wM6TldXNBmKhCvkBw3Kb86JQ2nN4RxGshQ4urn8MNaM_trZFwBQA9Nn3pbR2Jmk0Ey1ZTg6dXkCC7QHfmykrl-8L3WcDl_IWiQT6fjmo-Wxf2FSVWmkQDGl869tRvXgqGl5J_cFwa_02uMH5alkbvpIYsggUFZKlehMbR1JygBJ0NbaDmJUkY7FqOnSLsF9EUAaCaHCthGdhnnwDglNkgJAj4UMjQMJFOYRWSV2R6rNL9knxnpbUMJT0qADOHs0VaTdwVgAhIYLMVJxHyqcNe3hZMZkbBpvpdVKoQdmz8uF1rsiFq6Z9_rHwlDMJPizBpcf7Y7KhOef_nDIjWdltrFRsZ8WdOs0v0A_wSqDXY8kdDZjeW3cYTq3uTacHeJ-M4RcFk8R0Cnl-3ISVlm4RWIs5zli0HqiX-Hugn5nMWZyz67u9sAprOT3_5fB7ArbTOvRiFBj4CAaLXM5nSf-uc8b2__b7Sdwx-xqzHNfkJd-UJVoUQmVTgBQwT5abuo1I-OfXbNfPHheUyZ0WsmcCMdWAqZoq7xOAChSnWom9yZmcXJ1xS7gV_VjdTdxTJOaCunTRDevIvzcNaIvvA0nu2tsqcYBfeOEZBheTiLwjLidxwk6I5Tja1x_5kGXOGZLnJ_eveDbw0xS8Qihl1ZKwfeEq1BxK7suYm9jsizK66JqC38PrDS40swt0J2Ga0qGAADjZWSMiuNeC86vFQ6XVx0tJEuG0juqqTqh2TaRMBZbsp9ZOu73EmxKBcVPqmNNuyDav5w-zY8-H2Mt4vZhPO2yE4US41jETds3Cp8b7PW_-K-XuRv-X9v9igUji5CsCHsmkU60Gd8R_Y5OkfdXm4ebWoh3urh0DRoP060830imzIS36CnyxRxNZH5Vkc9SH2XdsZK7uTSgEwHOOSAViKczjw2SwmN1BnHV72RovNx606_u08lLVL5oVSKIbPiPYk379CU6Hwh3Oomfymx9SzNtd5CK7ZtbDa1E6S7GePxOiT04IRBDyaShV7DD-KxdLctyb69p_iYoAemYqGP7RqgbcbBhI4NlgLTqKCp-sFcRVMOOTaklbVlFMmqO3wFnBU9U2hkiIFaxt4KITa0z1jHS7UtkzJuZdEAMTk20zqNqw_cEMHP-7BqyPLwB0D9nRHStiI4ukIWwq-QXSyBpzJIi6u8u82yjBh3ZDMeDrpCnRS3hOB2NCwq89eoBslqSjz_3mGNtPtiNpV-1wnPbC1XAwQ2ghTxA0PHnrd6cL1cJQPDnBYfQOxKp1xhGbVls7gXruYyiGkdbl2JgLQEj_caqAI-sCf802K4GdCtpr_Ei6mKckiaBK8JHtFWDoQ3slwXkU03rflk_qjc4pp6K4HlBh9LZWqIgug8_2lKR8gwLfhPp9wafqYyi7lLwK5v3ZC-vEhtXBLn-m7PddhP8ies1D-Dr99s3q-8AX-ccJLF5YX9bfjTAFnjT-12VcPvk3JaeFX9w6tyC2P__V_CdImNaNVjif6P_86iaEjsEZszlJhyka7lrpM1nyYvPqM5jYqkuc3zkVD3fCnuGyjWEPj0i3tWLOT8wO_4w8hyZtofF2PdYg4r0zk6HcFZEFG3uGIMb2yHtbghcObCXjK3WdEs8R8klUz8C3WCG8vlWkY3g5f5wuQzdSOJDGCGMRECd8UuTl3pF1a_wC8LPo6RgLlKNt2qGXBDBYXmpABHl6UpPyfoXcusxe6ZSWJPQJovpq4laeB9oFRJdZ1Oyv_-1_Wpn_CoZhb-hoX2o2I5OYNt2TknOZMzT1pkhzb431E-v7gwSQLmoI9XPOP3Y8Km3mjKCH8OIyZ-2rCASuw-zicYg0XF-Wv1MAH-0uqWZ-8IPXS8XcUtIwSz5AKV46TpG8LlQydrrkKS5yDgLuDoOA_UpfPB-Z9PbsWdxmxIZl6UKDybPhZrTG8HtsWsKC2Vb88QTVhZAWuJexC8GcJ8cg0KyGxD6YqbKpvzZdG7sgda7ckeU5eUTijsVFbTS2fU","summary":[]},"output_index":0,"sequence_number":3} + +event: response.output_item.added +data: {"type":"response.output_item.added","item":{"id":"msg_08d409809d37383a006ae42cbdc51c87d09531890aa3d93ccf","type":"message","status":"in_progress","content":[],"role":"assistant"},"output_index":1,"sequence_number":4} + +event: response.content_part.added +data: {"type":"response.content_part.added","content_index":0,"item_id":"msg_08d409809d37383a006ae42cbdc51c87d09531890aa3d93ccf","output_index":1,"part":{"type":"output_text","annotations":[],"logprobs":[],"text":""},"sequence_number":5} + +event: response.output_text.delta +data: {"type":"response.output_text.delta","content_index":0,"delta":"The","item_id":"msg_08d409809d37383a006ae42cbdc51c87d09531890aa3d93ccf","logprobs":[],"obfuscation":"NIbfR0HIJmDSV","output_index":1,"sequence_number":6} + +event: response.output_text.delta +data: {"type":"response.output_text.delta","content_index":0,"delta":" capital","item_id":"msg_08d409809d37383a006ae42cbdc51c87d09531890aa3d93ccf","logprobs":[],"obfuscation":"qhiDzKkZ","output_index":1,"sequence_number":7} + +event: response.output_text.delta +data: {"type":"response.output_text.delta","content_index":0,"delta":" of","item_id":"msg_08d409809d37383a006ae42cbdc51c87d09531890aa3d93ccf","logprobs":[],"obfuscation":"H9fr2kmawE4bH","output_index":1,"sequence_number":8} + +event: response.output_text.delta +data: {"type":"response.output_text.delta","content_index":0,"delta":" France","item_id":"msg_08d409809d37383a006ae42cbdc51c87d09531890aa3d93ccf","logprobs":[],"obfuscation":"w22PfmVDB","output_index":1,"sequence_number":9} + +event: response.output_text.delta +data: {"type":"response.output_text.delta","content_index":0,"delta":" is","item_id":"msg_08d409809d37383a006ae42cbdc51c87d09531890aa3d93ccf","logprobs":[],"obfuscation":"U1L4KtMTV8gSv","output_index":1,"sequence_number":10} + +event: response.output_text.delta +data: {"type":"response.output_text.delta","content_index":0,"delta":" Paris","item_id":"msg_08d409809d37383a006ae42cbdc51c87d09531890aa3d93ccf","logprobs":[],"obfuscation":"n264SAYlGY","output_index":1,"sequence_number":11} + +event: response.output_text.delta +data: {"type":"response.output_text.delta","content_index":0,"delta":".","item_id":"msg_08d409809d37383a006ae42cbdc51c87d09531890aa3d93ccf","logprobs":[],"obfuscation":"C6JnGc0YoXaNvur","output_index":1,"sequence_number":12} + +event: response.output_text.done +data: {"type":"response.output_text.done","content_index":0,"item_id":"msg_08d409809d37383a006ae42cbdc51c87d09531890aa3d93ccf","logprobs":[],"output_index":1,"sequence_number":13,"text":"The capital of France is Paris."} + +event: response.content_part.done +data: {"type":"response.content_part.done","content_index":0,"item_id":"msg_08d409809d37383a006ae42cbdc51c87d09531890aa3d93ccf","output_index":1,"part":{"type":"output_text","annotations":[],"logprobs":[],"text":"The capital of France is Paris."},"sequence_number":14} + +event: response.output_item.done +data: {"type":"response.output_item.done","item":{"id":"msg_08d409809d37383a006ae42cbdc51c87d09531890aa3d93ccf","type":"message","status":"completed","content":[{"type":"output_text","annotations":[],"logprobs":[],"text":"The capital of France is Paris."}],"role":"assistant"},"output_index":1,"sequence_number":15} + +event: response.completed +data: {"type":"response.completed","response":{"id":"resp_08d409809d37383a006ae42cbbdb5087d09fba11ea0c69f3c3","object":"response","created_at":1793338555,"status":"completed","access_programs":null,"background":false,"completed_at":1793338557,"error":null,"frequency_penalty":0.0,"incomplete_details":null,"instructions":null,"max_output_tokens":null,"max_tool_calls":null,"model":"gpt-5-mini-2025-08-07","moderation":null,"output":[{"id":"rs_08d409809d37383a006ae42cbcf44c87d082e13972109e9be5","type":"reasoning","content":[],"encrypted_content":"gAAAAABq5Cy9jA0BDQZ95Y9d3bBpz9caZdMLDXngrIG31EdJsSRvdqlaNSjnsJsGV9qtHpRAZ4FfYici5MD_etT_Lsyp7qevtCU-hPROJ2UkEhJoUk_zyZcqNGFzDL0p6jU4qPRMuQArB-st41mmTA_IAPW01U_FE9BkpRhNhYbxygSEDOBqBhzrwwNf9iEh_DwGtzcwIMThHn3CrE20MKH2YSzOQe1f6b0r-Tu6O9oZa1v10RBLoaZBe4euRBRFMyABl6rmb82q_6OVS3xT-IMPvBIeGAGN-uFK1yH_NMW9Htr-4It8yIWhdmsCokIk8FdgSb_xaUmv7uDDS9eFqtT66R26K01mc280yFbd4c_9VDvDjGVLUu7ay9SHNYYV8TYjBvY7JQeLB8HnM8tArwIGU7ayiyc-ix0ZrLb2eorJVp2mM91dtwKHU5ojwG6IZl-KAwL0mmP92yrflOuwazmUDZLkfIzd0w8lLORLX3ZYnWDWs-Sic7zbIUkke-mcCnMdpgLsDNXJFRhheE_h6Vsfe0Y-xUTtchrq7S4LLhDoHGArvkHGkrNUVvQyaODYAsorBXcAxFzJ6ZVkXqRFlPb-2XLgDdKI18b2K-WeaADuRp2zHBQn2YUDBmeWE8s6mNbpTRUsmSsfufCE3TXwBHV9HJLky3SrG35PhnSUZGQ9QPQUTpp-IXmvG4IjNcTRjag6Wqx8SaoEeMvDy33AuoCW0HMo0J9JmeG4RZtudj6IjxQWF4BBY2bvmj2gnPi2aoAUUOUnPFgcxF0pZPQTnqWVRGoVap4e1dV88JteShTOKhs6TzE8upkZFIs97K7wvDcWtFmIE0pu3faEdCMdhAHBPOwd1uJK6MVPJR04BAP2TZwxiMM0GcowwWFU1zj-dHu8N6RPxYpoXPNt8f9YbRrJNWbKMQjbXysDbfiS7_zD5L20H5upqumXcY7zGGmc8ZSJCqWcqMZF5pJxf9wMKi5xF9ZFrflgdK2n1k_BBVCGHgm1iG5jxk64kmyMsctovhprsFTA7rIunvTbKm3tY3_CaNbtSId7bE0TSMJAVlrMpK3x4u1vTCGhIRxOrneQiki6tV0YK8teL9STX_NmAPkgATHlEFDT5ZNGRnTQHrXZAEbbC153lzPlD5W-jrr_q7aOooLruxnpcIOwCh0qsD6JScJQK0PQHuL6U-pRXe2jpBoRPhGJSojrYX07smvBmL_E7eNbV4NHfd_BGTTyOZhWsotofyN1ViOA8T4mjGicx0_oD1EdX4NIegPDnmHvu3RBCGuRTKvqiR-gjG1kuRbmcin9ToaYzeb9KElk2QVemJ17rKTR-952mZTSRwWcyDO36AUAF07oI6QbLEXyD11-qzaHMsIZCjYwxEm9pNjR3GuHKVoYW8CyDt4LiK6mELPsw9cJ-HCpZhdHVG0zWzl5N4BhCyZEgOI43V6-0v6jn7cShEkIUl2xoCO0I8_B6wz6SXUkL-GCiIXl9g2WGkCiyJNIz6ZQN4T1as2DSFUehgb3hLOivXYdpFQzeQcQ_Cyl5i4GUXwJey-I7QYrieQB0lEJbBGgE92QRZnGFMWdJmx6SqOdGTpRfE5dRsjiT22KHFm3fIf2YjPoKtBovZyYhQI_UmM6j_Cfq06W17zgM0fjRnJFc4AZPw6yRDgjEWdHQZ2Tc22ly-ftLsNOgMYnvRb4D6xWxgnT4eIVsDvbDXs-3xQpjuj10mAaIQ3v8kgYAUkPnbR2Rt29kvUH39I4JcOdShUHjd6bCO1i8m_88J_jz7_la_Tmj7duVNIa1V9WtRCEABWnER0ofXfch_blZQFBnQ_o_UYStfj1pHJHM6aJzBymmgCOfCdaIPSIjU2muznxLCmoWuTvhTDnCkYdidnPmevS-adZJMC7u9owQcVI1IXqzHUMLV8YSD0KGwIyPdaQULdVx0rafwQceeIVP-lazvuclg4Kr5sKltGdSpXO5PHW2N1sV8ojWubEtLThzJqHT-3Y9evedKxLvz26QH7iM3b43rMbEE3uWxPq4v3zLK7YjISva3saYVbfxat7iWqSoHQlkra6WLIRQZ9yTB3T1BY2YVMC0mN55m5fpasT_ecxbVEjdCXmL5-P57FcEJtomPp6Rml-ImGJkeD1Tm48bYE7ynAZWqoM8YjczCSRsBjeujntyiCyc8ZJ4W7oLVrNOdSSiuJWJqdLthFDSAj7L8UKGn7daYmx_sf_o2rZ9qKon5PxJE--e7r6Xpandh0K4OH0YR4vSj0L2ifNSGTq6hPn8cGUpyGfOwPk8IPuUo2IDYm6Lw5mOc3uAtdM5OPtNoooFRruw10EW-CP2y3kb74j0wRQIJwFYXDdKQVZ_sXQ1gou7usSEVjXHFrItZJMNYMvnPEHrxth5YQWaVaIVky2pJc5cCJOwLAb1UDBw3dr4vFmcIplzp5t9cUD7MlOkfWCFXEzYNi7W4lYrkfR4dMd5SpLwiOqUJuSZyh5ZUVq-Cfkh2mZHDTmrge22rd0VCaq25Qe-E3N3iBhDykgqA9UiMowdaSfyKTSE8mpr5Qwi_Eg-PXBq-XOKj3k4vPi1HMZb4eFy2nnn0LH7A7Zq8R6I8IuH3YGx43hY7GpxbGBbEtqQtT6PSVI_QpMz8_7KgWigkCSWRPQbPd_PIpbJWbB8ub8OFCMEhyxvY1cR7XuPaRIUWBqHpM3-9aOPGl9StDMQFmzgdrlxJ7UGVkCT1YCBBe7j0lJKCrmUDXq7maDF2JEvkLdrEUt5WfMLAo-1Rgv","summary":[]},{"id":"msg_08d409809d37383a006ae42cbdc51c87d09531890aa3d93ccf","type":"message","status":"completed","content":[{"type":"output_text","annotations":[],"logprobs":[],"text":"The capital of France is Paris."}],"role":"assistant"}],"parallel_tool_calls":true,"presence_penalty":0.0,"previous_response_id":null,"prompt_cache_key":null,"prompt_cache_retention":"in_memory","reasoning":{"context":"current_turn","effort":"medium","mode":"standard","summary":null},"safety_identifier":null,"service_tier":"default","store":true,"temperature":1.0,"text":{"format":{"type":"text"},"verbosity":"medium"},"tool_choice":"auto","tool_usage":{"image_gen":{"input_tokens":0,"input_tokens_details":{"image_tokens":0,"text_tokens":0},"output_tokens":0,"output_tokens_details":{"image_tokens":0,"text_tokens":0},"total_tokens":0},"web_search":{"num_requests":0}},"tools":[],"top_logprobs":0,"top_p":1.0,"truncation":"disabled","usage":{"input_tokens":19,"input_tokens_details":{"cache_write_tokens":0,"cached_tokens":0},"output_tokens":110,"output_tokens_details":{"reasoning_tokens":64},"total_tokens":129},"user":null,"metadata":{}},"sequence_number":16} + diff --git a/packages/inference-discovery-openai/sessions/openai-responses/gpt-5-mini/plain-text-streaming/session.json b/packages/inference-discovery-openai/sessions/openai-responses/gpt-5-mini/plain-text-streaming/session.json new file mode 100644 index 000000000..9dfca8644 --- /dev/null +++ b/packages/inference-discovery-openai/sessions/openai-responses/gpt-5-mini/plain-text-streaming/session.json @@ -0,0 +1,11 @@ +{ + "schemaVersion": "2", + "source": { + "provider": "openai-responses", + "model": "gpt-5-mini", + "baseURL": "https://api.openai.com/v1" + }, + "origin": "live", + "capturedAt": "2026-10-30T05:35:58.177Z", + "capability": "plain-text-streaming" +} diff --git a/packages/inference-discovery-openai/sessions/openai-responses/gpt-5-mini/plain-text/exchanges/0/request-headers.json b/packages/inference-discovery-openai/sessions/openai-responses/gpt-5-mini/plain-text/exchanges/0/request-headers.json new file mode 100644 index 000000000..28c14bb85 --- /dev/null +++ b/packages/inference-discovery-openai/sessions/openai-responses/gpt-5-mini/plain-text/exchanges/0/request-headers.json @@ -0,0 +1,4 @@ +{ + "Content-Type": "application/json", + "Authorization": "" +} diff --git a/packages/inference-discovery-openai/sessions/openai-responses/gpt-5-mini/plain-text/exchanges/0/request.json b/packages/inference-discovery-openai/sessions/openai-responses/gpt-5-mini/plain-text/exchanges/0/request.json new file mode 100644 index 000000000..95ccaa525 --- /dev/null +++ b/packages/inference-discovery-openai/sessions/openai-responses/gpt-5-mini/plain-text/exchanges/0/request.json @@ -0,0 +1,10 @@ +{ + "model": "gpt-5-mini", + "input": [ + { + "type": "message", + "role": "user", + "content": "Reply with a single sentence: the capital of France is Paris." + } + ] +} diff --git a/packages/inference-discovery-openai/sessions/openai-responses/gpt-5-mini/plain-text/exchanges/0/response-headers.json b/packages/inference-discovery-openai/sessions/openai-responses/gpt-5-mini/plain-text/exchanges/0/response-headers.json new file mode 100644 index 000000000..e1cdbbcbe --- /dev/null +++ b/packages/inference-discovery-openai/sessions/openai-responses/gpt-5-mini/plain-text/exchanges/0/response-headers.json @@ -0,0 +1,26 @@ +{ + "access-control-expose-headers": "X-Request-ID, Server-Timing-Total, CF-Ray, CF-Ray", + "alt-svc": "h3=\":443\"; ma=86400", + "cf-cache-status": "DYNAMIC", + "cf-ray": "a5280f240f465730-LAX", + "connection": "keep-alive", + "content-encoding": "br", + "content-type": "application/json", + "date": "Fri, 30 Oct 2026 05:35:55 GMT", + "openai-organization": "", + "openai-processing-ms": "2165", + "openai-project": "", + "openai-version": "2020-10-01", + "server": "cloudflare", + "strict-transport-security": "max-age=31536000; includeSubDomains; preload", + "transfer-encoding": "chunked", + "x-content-type-options": "nosniff", + "x-ratelimit-limit-requests": "5000", + "x-ratelimit-limit-tokens": "2000000", + "x-ratelimit-remaining-requests": "4999", + "x-ratelimit-remaining-tokens": "2000000", + "x-ratelimit-reset-requests": "12ms", + "x-ratelimit-reset-tokens": "0s", + "x-request-id": "", + "set-cookie": "" +} diff --git a/packages/inference-discovery-openai/sessions/openai-responses/gpt-5-mini/plain-text/exchanges/0/response.json b/packages/inference-discovery-openai/sessions/openai-responses/gpt-5-mini/plain-text/exchanges/0/response.json new file mode 100644 index 000000000..42714d163 --- /dev/null +++ b/packages/inference-discovery-openai/sessions/openai-responses/gpt-5-mini/plain-text/exchanges/0/response.json @@ -0,0 +1,101 @@ +{ + "id": "resp_0e09d99ab68ac6b2006ae42cb98f8487d0a2b1af785477fa15", + "object": "response", + "created_at": 1793338553, + "status": "completed", + "access_programs": null, + "background": false, + "billing": { + "payer": "developer" + }, + "completed_at": 1793338555, + "error": null, + "frequency_penalty": 0.0, + "incomplete_details": null, + "instructions": null, + "max_output_tokens": null, + "max_tool_calls": null, + "model": "gpt-5-mini-2025-08-07", + "moderation": null, + "output": [ + { + "id": "rs_0e09d99ab68ac6b2006ae42cba9c8c87d0aa8386be908c6fb4", + "type": "reasoning", + "content": [], + "encrypted_content": "gAAAAABq5Cy7HYlMq67RvitrMwRh42XumJcW-cb6YHf-4suIqyKkzQD7Jm6sf7gXBCNm2w_FinuwaTWf9Mw8gswSUx6Xoc5UitakT4n2nFJBI3R1_yXS_6POwlSQ3BsQ95K7gKsXH_Webk_qIS7B-w76Tv3z47QEJ97Z3TZzE-CzEXpHrq7y-SkERv6aKqhdm6Fo8wNQ60_cHHf9DqFdx5sfD7-_vsEvefYMjQR5jEdkTlOX2oSQPP1dol04SEuKH7nhIvd5FGAvJJPK1paSYDVAufj55bVjb97O3jxAvnM0CwRFgsbWIj7NFzzh5GZ-po-0LFl6jGjOjfuw_RwCeJuubWPK3Te68Es-2uE7re8njsRhKBM_5yqzuhfma43OasOXBbn0Y-0KIUdoBYCm1kpoS5RKVTWI6nFimCGnko-R5Rje1QL0T8qJRUTpf0X8kSlG_bV_Rdwu2iS_vPscBc2-b76rfMmwaVccxTwUl2Kacckp1nf3C2pPjJsQeEx7cFtg8dIM9ZVFvhEms9mjQsuZrc_GmCQm6JmY3TXIBnPe9VoccZ7sRQgJlJOUB7bwFI3dWAHqm6kFSdUMsFdr4dH5d6rOINnvhJ2JRZHjmj-O8YQesCGKqFtXeEi1YPajPlXUTwu93iWkHhZ19zOwvOJooq-Cso1KlfhwxPmlyOJwbH_zdRJC-XZ_WyMEvqFVC1GAYpSN05D-L59pm_1tn13RFYtyOfjHKV3LcVTZwc6qb7WUTxWEcfLJkVeUEGZG6MWZK0HaCltn3z21IUQjTWy3iy0hppPjF1N3F6RroRCShf-7gu_y_IXxw9drsV6h6VVbqd0tXNBMecbKqYETZDubgNAS9o8MAIh5yWCE7zfPyZKUCJODq_A6aezWvM6Rh7mbyTOUbHUdOd7jJInhK1Y05RxxHAHe96_p56HmHn3mSx82uT1I4tFUGAkMLC0e1dPDBGSvey2bnRqVw32Qc2JDXiAeUgJD-L3WzCWvpLdmQTvdPeyd17AUYPUPSECQqluAd1jlY72rxGArLDuP7fRM1pXAf-x-oxJ3TESwdKXiP2tYVzyPcouLMFZqZpWNT1U6t154s1U1qCvqbthjC3HaOGuxLiCz9oqvK2Gx6R8iSdmSz-X1nlaL4N95ivAaUrrCx_YKgWSqMl-pYFw8c5UO-l-63ObDstgn8wvo1YyfFUqBr7gxt8bmXia5K8lXmto7s0Q6oOS2sUPLuNZ5WcpdBAnq3mNbe8NeqROgXpAGUE5UBpYo-rnR1ceSPTc4d6-6IhaC22CrEC9ItnQDqQNYbQwoyRbZjnEs9pgdkMhuQ6x_kxPd-CrEcikrXxHGtQrMQNXrl_kFg3XHoNfGG1prEBhvxrpBsD_A-ku0f-FdamfpIDVO9_bHLKug4EMCElRoYwLcqUwQQKPLhQs9cix4bMQvmCkepHZy7_0MyrkMgbNRAHvmnSMXpKzFu2UFEX7jLmOFAI_OULELySbOsLRF_19cbxgvmiOJI48xzM5MuAmXGw4cBb7lktbwf_wRZxaxGVS5zDHC7US5FvxCwk4uM_AElHPeIlkUdKJ9mMzcpadmQJayR7Yrec_Mp47ExIz-nwquvT0dARSJEWRPmdmNnNP-zWeOrYgK5qMi2CugXeyJB_R25XAy-t2vuzxLTTloKGoU3EDTMWQzpViHq2kQBgB33CZZ_ZEkcM2cXE0_DmiOAqSub-hkdtRbKMHGGxGU2TC-VJYv3j1sCywg8hIaFZ7viWqmuGi8_kJ2VdWOZeB7UGPyeTPDpkbvXlpa5__dbhCOX14xgq3TT59V77otjTcM_x7XyXgQCYtrK-NZ2moKMDEx2-pl1_2yTQ-vo02k6NYge5VFvWOBRjY-24ICk9qIYPTKigqcxoAevul_AWk6VlrLj-vrYDnJUG1oziex_4FRhFDHj8MUide-gNn20I6g7PRkG3wD7O0UdO3EyolD3rtrB-e49kRZ4H0o6gW8EvqYDCJ1MOc9HgYKsnka5XQi_0eayeqgc_IvPNKDIV7KZk1uRhndcbGMTFu6qjbbzio9hq_YonpkQz_LYKWzlF9vl2B5UsgJ4cBxYgyA-68Tw4l_5udPlWHzwHPLWun3u-O3HrZx7wG5FOuLrd5kl7qAtv7-boSZCLS97AmpYjK0_KuZ-dkPSxH-tB-Ehr5zkEKZ_77F6O8C8ZgTJ_V_4m2zFhKBlbVJpOd1r43LWj2nik6JIN6GdCR4fs9o4x136BopD33GLBdaXkum5ZXbdMJnOaShK3sWmHJytdo7D6WPxZ3LEo6zCYQQsvgsetVvVfSZEWaUsackBao7jCsu7IwcUkCmhFRE2QR69sT1EJzt5zoFLiWfgJ9KYQG_GlihToiVxnvjPCGYpvmU_m5JSalw5C2OL40llZRthkIvJ3wkwtaBGTxPVHeBjgGDtsjnixgLijqZzSgpg5O3rKLFhP4lfLH7wUQ5NeXXGpDHrCkt17PVH6YDXG339VkBTiFjNdg88Xrz9c9NDKD1wFQXZYq05h0fX3XVOjcNasOFXrzGEfDYR-8PndC1RWwctL0j3xKrolRVdwEoFqaFI6qtVdZ54RfnrGWliy5YsOGy0yuh3BbqL8Ev8khSRppCcoTZzE0Knkc65egkX5Kt0eHj-BYv8MEQxf9u6w8PPZP2k3xABdiPRTcZ32uehdssRuc32xvwxgAs", + "summary": [] + }, + { + "id": "msg_0e09d99ab68ac6b2006ae42cbb657887d0aa63e5e4538fa52f", + "type": "message", + "status": "completed", + "content": [ + { + "type": "output_text", + "annotations": [], + "logprobs": [], + "text": "The capital of France is Paris." + } + ], + "role": "assistant" + } + ], + "parallel_tool_calls": true, + "presence_penalty": 0.0, + "previous_response_id": null, + "prompt_cache_key": null, + "prompt_cache_retention": "in_memory", + "reasoning": { + "context": "current_turn", + "effort": "medium", + "mode": "standard", + "summary": null + }, + "safety_identifier": null, + "service_tier": "default", + "store": true, + "temperature": 1.0, + "text": { + "format": { + "type": "text" + }, + "verbosity": "medium" + }, + "tool_choice": "auto", + "tool_usage": { + "image_gen": { + "input_tokens": 0, + "input_tokens_details": { + "image_tokens": 0, + "text_tokens": 0 + }, + "output_tokens": 0, + "output_tokens_details": { + "image_tokens": 0, + "text_tokens": 0 + }, + "total_tokens": 0 + }, + "web_search": { + "num_requests": 0 + } + }, + "tools": [], + "top_logprobs": 0, + "top_p": 1.0, + "truncation": "disabled", + "usage": { + "input_tokens": 19, + "input_tokens_details": { + "cache_write_tokens": 0, + "cached_tokens": 0 + }, + "output_tokens": 104, + "output_tokens_details": { + "reasoning_tokens": 64 + }, + "total_tokens": 123 + }, + "user": null, + "metadata": {} +} \ No newline at end of file diff --git a/packages/inference-discovery-openai/sessions/openai-responses/gpt-5-mini/plain-text/session.json b/packages/inference-discovery-openai/sessions/openai-responses/gpt-5-mini/plain-text/session.json new file mode 100644 index 000000000..7251ba2b4 --- /dev/null +++ b/packages/inference-discovery-openai/sessions/openai-responses/gpt-5-mini/plain-text/session.json @@ -0,0 +1,11 @@ +{ + "schemaVersion": "2", + "source": { + "provider": "openai-responses", + "model": "gpt-5-mini", + "baseURL": "https://api.openai.com/v1" + }, + "origin": "live", + "capturedAt": "2026-10-30T05:35:55.733Z", + "capability": "plain-text" +} diff --git a/packages/inference-discovery-openai/sessions/openai-responses/gpt-5-mini/reasoning-content-streaming/exchanges/0/request-headers.json b/packages/inference-discovery-openai/sessions/openai-responses/gpt-5-mini/reasoning-content-streaming/exchanges/0/request-headers.json new file mode 100644 index 000000000..28c14bb85 --- /dev/null +++ b/packages/inference-discovery-openai/sessions/openai-responses/gpt-5-mini/reasoning-content-streaming/exchanges/0/request-headers.json @@ -0,0 +1,4 @@ +{ + "Content-Type": "application/json", + "Authorization": "" +} diff --git a/packages/inference-discovery-openai/sessions/openai-responses/gpt-5-mini/reasoning-content-streaming/exchanges/0/request.json b/packages/inference-discovery-openai/sessions/openai-responses/gpt-5-mini/reasoning-content-streaming/exchanges/0/request.json new file mode 100644 index 000000000..b307402d1 --- /dev/null +++ b/packages/inference-discovery-openai/sessions/openai-responses/gpt-5-mini/reasoning-content-streaming/exchanges/0/request.json @@ -0,0 +1,15 @@ +{ + "model": "gpt-5-mini", + "input": [ + { + "type": "message", + "role": "user", + "content": "A bat and a ball cost $1.10 together. The bat costs $1.00 more than the ball. How much does the ball cost? Show your reasoning before the final answer." + } + ], + "reasoning": { + "effort": "medium", + "summary": "detailed" + }, + "stream": true +} diff --git a/packages/inference-discovery-openai/sessions/openai-responses/gpt-5-mini/reasoning-content-streaming/exchanges/0/response-headers.json b/packages/inference-discovery-openai/sessions/openai-responses/gpt-5-mini/reasoning-content-streaming/exchanges/0/response-headers.json new file mode 100644 index 000000000..6bf931324 --- /dev/null +++ b/packages/inference-discovery-openai/sessions/openai-responses/gpt-5-mini/reasoning-content-streaming/exchanges/0/response-headers.json @@ -0,0 +1,25 @@ +{ + "access-control-expose-headers": "X-Request-ID, Server-Timing-Total, CF-Ray, CF-Ray", + "alt-svc": "h3=\":443\"; ma=86400", + "cf-cache-status": "DYNAMIC", + "cf-ray": "a52f11a93a436a29-LAX", + "connection": "keep-alive", + "content-type": "text/event-stream; charset=utf-8", + "date": "Sat, 31 Oct 2026 02:00:57 GMT", + "openai-organization": "", + "openai-processing-ms": "861", + "openai-project": "", + "openai-version": "2020-10-01", + "server": "cloudflare", + "strict-transport-security": "max-age=31536000; includeSubDomains; preload", + "transfer-encoding": "chunked", + "x-content-type-options": "nosniff", + "x-ratelimit-limit-requests": "5000", + "x-ratelimit-limit-tokens": "2000000", + "x-ratelimit-remaining-requests": "4999", + "x-ratelimit-remaining-tokens": "1999738", + "x-ratelimit-reset-requests": "12ms", + "x-ratelimit-reset-tokens": "7ms", + "x-request-id": "", + "set-cookie": "" +} diff --git a/packages/inference-discovery-openai/sessions/openai-responses/gpt-5-mini/reasoning-content-streaming/exchanges/0/response.sse b/packages/inference-discovery-openai/sessions/openai-responses/gpt-5-mini/reasoning-content-streaming/exchanges/0/response.sse new file mode 100644 index 000000000..ed53dd266 --- /dev/null +++ b/packages/inference-discovery-openai/sessions/openai-responses/gpt-5-mini/reasoning-content-streaming/exchanges/0/response.sse @@ -0,0 +1,654 @@ +event: response.created +data: {"type":"response.created","response":{"id":"resp_0fdb43b6db871f01006ae54bd8a67c87d08338ee42a336c82b","object":"response","created_at":1793412056,"status":"in_progress","access_programs":null,"background":false,"completed_at":null,"error":null,"frequency_penalty":0.0,"incomplete_details":null,"instructions":null,"max_output_tokens":null,"max_tool_calls":null,"model":"gpt-5-mini-2025-08-07","moderation":null,"output":[],"parallel_tool_calls":true,"presence_penalty":0.0,"previous_response_id":null,"prompt_cache_key":null,"prompt_cache_retention":"in_memory","reasoning":{"context":"current_turn","effort":"medium","mode":"standard","summary":"detailed"},"safety_identifier":null,"service_tier":"auto","store":true,"temperature":1.0,"text":{"format":{"type":"text"},"verbosity":"medium"},"tool_choice":"auto","tool_usage":{"image_gen":{"input_tokens":0,"input_tokens_details":{"image_tokens":0,"text_tokens":0},"output_tokens":0,"output_tokens_details":{"image_tokens":0,"text_tokens":0},"total_tokens":0},"web_search":{"num_requests":0}},"tools":[],"top_logprobs":0,"top_p":1.0,"truncation":"disabled","usage":null,"user":null,"metadata":{}},"sequence_number":0} + +event: response.in_progress +data: {"type":"response.in_progress","response":{"id":"resp_0fdb43b6db871f01006ae54bd8a67c87d08338ee42a336c82b","object":"response","created_at":1793412056,"status":"in_progress","access_programs":null,"background":false,"completed_at":null,"error":null,"frequency_penalty":0.0,"incomplete_details":null,"instructions":null,"max_output_tokens":null,"max_tool_calls":null,"model":"gpt-5-mini-2025-08-07","moderation":null,"output":[],"parallel_tool_calls":true,"presence_penalty":0.0,"previous_response_id":null,"prompt_cache_key":null,"prompt_cache_retention":"in_memory","reasoning":{"context":"current_turn","effort":"medium","mode":"standard","summary":"detailed"},"safety_identifier":null,"service_tier":"auto","store":true,"temperature":1.0,"text":{"format":{"type":"text"},"verbosity":"medium"},"tool_choice":"auto","tool_usage":{"image_gen":{"input_tokens":0,"input_tokens_details":{"image_tokens":0,"text_tokens":0},"output_tokens":0,"output_tokens_details":{"image_tokens":0,"text_tokens":0},"total_tokens":0},"web_search":{"num_requests":0}},"tools":[],"top_logprobs":0,"top_p":1.0,"truncation":"disabled","usage":null,"user":null,"metadata":{}},"sequence_number":1} + +event: response.output_item.added +data: {"type":"response.output_item.added","item":{"id":"rs_0fdb43b6db871f01006ae54bd9c5d887d08a0100ce0c172528","type":"reasoning","content":[],"encrypted_content":"gAAAAABq5UvZw5B4G44u57uTwfJhYTMGFijMg09ASrtHV2lA7NxgD6tczRgwcFFGiPeGPYQaN8OrjpIbBn0qCcr-aq2QeEGVmOI6Cj6-iybCHTGLofU1B9Dff9NWBT4q1_5fLpC0ZdbVuvPUKFVwzhh8a49bZXd57mH25as3-iQee7W4w3LAoNnzH79K19jv2jwAPo0ZKJFPc-TtCSYFXAfpNgEHfPXrkbW_KIutk04Az6835Bjqa4aWk8z8N41SymC73opg0-uBxzwiqsjzlL3JBAZqVnhdKkNNU9nKoIbB848KerTli8UHh_co03ff1b8syhEEWjgDwUXAOCxbN10kgcj2-UoTLUHpkCKlzx4jnMKe9wcAzbguaI4LM5Khi5z639BFBYJvLyrE-NOjwBtRr1Q_HNu1dgaKEZ633MMv6hMWLE7T_d6WyWAxSWeBpaWEeR-SA1V-2-kG4mB827fviP1xfk_wUVWuBnS0yJ-onv6DP_4Z7NzVxlUaBeL0s8uymBdjOCvfNQ29SBvlwkKbZhzyoi-aUr5HSU-u7shvPTReHJ8ZXB0Yq6Ofy326PzmsadETP3Xw70w4f4EK1MKVka9rllXrB3UugMdv1owMF9f_yvPc8T0sF-zz9j_4EABTdum2vZWk262CZnqrBP36PhuqUhxrwYxLZcEHY-KKXI78zlSVtxdsuBrs0YsY-eW780qZsF6A9lIDVjJJEv5BqzhPkw9w8qiCoEGn1Zdm9kHLzwjhLFh2_pUHI7NVIfKs9p9uYBXeqf0GABzocr-8JLuvnx_MrJUyVKRUcHh6SOEvv4Z_vPvEFT6NOxURIrz4Oym-i-_KIMt_YY9gQOJslcibgTsEj1LOvYt0lBiOjojlyPf8Cv8geaytKU3F64dWnHs7Jw3gUGTNhb73jE6vGzscNbAa9gJ-RX7dhFwDM2ro6C5D9I9sG2ns1YI40PZD9rQS57R9MK_q702R4WVcHZaa4uNDpyWvaH9qrpklZ2cwvHkgpNzYLbcQcNsUgxf9WPB1SPmJjlCCbkUz4aC3MRFcCUL2HR3vmLB3HCMvxYOsqZj-N8YYyGvq9EeNVP4eT5zMbEnSOy5Ew3zqBxQ2x_GFd6b3YFTgSVzU7E2wb9EqpiJRZH8S46pCCIX3O5wQq7gfL6d-BLxivMzEjycVlaSd5oU4sZcc-Pu6PEOthq3NW799JameQwAL2r-luqofCB7fbtDWe3jC5FGlNONZwtzJWmcEHQ==","summary":[]},"output_index":0,"sequence_number":2} + +event: response.reasoning_summary_part.added +data: {"type":"response.reasoning_summary_part.added","item_id":"rs_0fdb43b6db871f01006ae54bd9c5d887d08a0100ce0c172528","output_index":0,"part":{"type":"summary_text","text":""},"sequence_number":3,"summary_index":0} + +event: response.reasoning_summary_text.delta +data: {"type":"response.reasoning_summary_text.delta","delta":"**Explaining the puzzle**\n\nAlright","item_id":"rs_0fdb43b6db871f01006ae54bd9c5d887d08a0100ce0c172528","obfuscation":"Sm9EJO17vD9F5V","output_index":0,"sequence_number":4,"summary_index":0} + +event: response.reasoning_summary_text.delta +data: {"type":"response.reasoning_summary_text.delta","delta":",","item_id":"rs_0fdb43b6db871f01006ae54bd9c5d887d08a0100ce0c172528","obfuscation":"HrXKrkMPmynddM6","output_index":0,"sequence_number":5,"summary_index":0} + +event: response.reasoning_summary_text.delta +data: {"type":"response.reasoning_summary_text.delta","delta":" I'm","item_id":"rs_0fdb43b6db871f01006ae54bd9c5d887d08a0100ce0c172528","obfuscation":"eU0L9RZZoiJe","output_index":0,"sequence_number":6,"summary_index":0} + +event: response.reasoning_summary_text.delta +data: {"type":"response.reasoning_summary_text.delta","delta":" working","item_id":"rs_0fdb43b6db871f01006ae54bd9c5d887d08a0100ce0c172528","obfuscation":"DPCjHLlt","output_index":0,"sequence_number":7,"summary_index":0} + +event: response.reasoning_summary_text.delta +data: {"type":"response.reasoning_summary_text.delta","delta":" through","item_id":"rs_0fdb43b6db871f01006ae54bd9c5d887d08a0100ce0c172528","obfuscation":"tb5QBVfW","output_index":0,"sequence_number":8,"summary_index":0} + +event: response.reasoning_summary_text.delta +data: {"type":"response.reasoning_summary_text.delta","delta":" this","item_id":"rs_0fdb43b6db871f01006ae54bd9c5d887d08a0100ce0c172528","obfuscation":"1dYAcNMKR4e","output_index":0,"sequence_number":9,"summary_index":0} + +event: response.reasoning_summary_text.delta +data: {"type":"response.reasoning_summary_text.delta","delta":" classic","item_id":"rs_0fdb43b6db871f01006ae54bd9c5d887d08a0100ce0c172528","obfuscation":"6XoPgRhp","output_index":0,"sequence_number":10,"summary_index":0} + +event: response.reasoning_summary_text.delta +data: {"type":"response.reasoning_summary_text.delta","delta":" puzzle","item_id":"rs_0fdb43b6db871f01006ae54bd9c5d887d08a0100ce0c172528","obfuscation":"p2gT7mSKD","output_index":0,"sequence_number":11,"summary_index":0} + +event: response.reasoning_summary_text.delta +data: {"type":"response.reasoning_summary_text.delta","delta":".","item_id":"rs_0fdb43b6db871f01006ae54bd9c5d887d08a0100ce0c172528","obfuscation":"xeBgZqCj7CCeNji","output_index":0,"sequence_number":12,"summary_index":0} + +event: response.reasoning_summary_text.delta +data: {"type":"response.reasoning_summary_text.delta","delta":" I","item_id":"rs_0fdb43b6db871f01006ae54bd9c5d887d08a0100ce0c172528","obfuscation":"eHa422eZQ1Ebwd","output_index":0,"sequence_number":13,"summary_index":0} + +event: response.reasoning_summary_text.delta +data: {"type":"response.reasoning_summary_text.delta","delta":" need","item_id":"rs_0fdb43b6db871f01006ae54bd9c5d887d08a0100ce0c172528","obfuscation":"FPDva40wuA7","output_index":0,"sequence_number":14,"summary_index":0} + +event: response.reasoning_summary_text.delta +data: {"type":"response.reasoning_summary_text.delta","delta":" to","item_id":"rs_0fdb43b6db871f01006ae54bd9c5d887d08a0100ce0c172528","obfuscation":"3bPdjkgRp6qVR","output_index":0,"sequence_number":15,"summary_index":0} + +event: response.reasoning_summary_text.delta +data: {"type":"response.reasoning_summary_text.delta","delta":" show","item_id":"rs_0fdb43b6db871f01006ae54bd9c5d887d08a0100ce0c172528","obfuscation":"IU18uufDt7W","output_index":0,"sequence_number":16,"summary_index":0} + +event: response.reasoning_summary_text.delta +data: {"type":"response.reasoning_summary_text.delta","delta":" my","item_id":"rs_0fdb43b6db871f01006ae54bd9c5d887d08a0100ce0c172528","obfuscation":"VNkwM6L5I4FqC","output_index":0,"sequence_number":17,"summary_index":0} + +event: response.reasoning_summary_text.delta +data: {"type":"response.reasoning_summary_text.delta","delta":" reasoning","item_id":"rs_0fdb43b6db871f01006ae54bd9c5d887d08a0100ce0c172528","obfuscation":"ErY5SP","output_index":0,"sequence_number":18,"summary_index":0} + +event: response.reasoning_summary_text.delta +data: {"type":"response.reasoning_summary_text.delta","delta":" clearly","item_id":"rs_0fdb43b6db871f01006ae54bd9c5d887d08a0100ce0c172528","obfuscation":"xuhE35R8","output_index":0,"sequence_number":19,"summary_index":0} + +event: response.reasoning_summary_text.delta +data: {"type":"response.reasoning_summary_text.delta","delta":" before","item_id":"rs_0fdb43b6db871f01006ae54bd9c5d887d08a0100ce0c172528","obfuscation":"BA4JVvDUB","output_index":0,"sequence_number":20,"summary_index":0} + +event: response.reasoning_summary_text.delta +data: {"type":"response.reasoning_summary_text.delta","delta":" giving","item_id":"rs_0fdb43b6db871f01006ae54bd9c5d887d08a0100ce0c172528","obfuscation":"DRSVwkcjQ","output_index":0,"sequence_number":21,"summary_index":0} + +event: response.reasoning_summary_text.delta +data: {"type":"response.reasoning_summary_text.delta","delta":" the","item_id":"rs_0fdb43b6db871f01006ae54bd9c5d887d08a0100ce0c172528","obfuscation":"rhYuP6mh9PsH","output_index":0,"sequence_number":22,"summary_index":0} + +event: response.reasoning_summary_text.delta +data: {"type":"response.reasoning_summary_text.delta","delta":" final","item_id":"rs_0fdb43b6db871f01006ae54bd9c5d887d08a0100ce0c172528","obfuscation":"mcQyC92Tbf","output_index":0,"sequence_number":23,"summary_index":0} + +event: response.reasoning_summary_text.delta +data: {"type":"response.reasoning_summary_text.delta","delta":" answer","item_id":"rs_0fdb43b6db871f01006ae54bd9c5d887d08a0100ce0c172528","obfuscation":"QL2WdVPbD","output_index":0,"sequence_number":24,"summary_index":0} + +event: response.reasoning_summary_text.delta +data: {"type":"response.reasoning_summary_text.delta","delta":".","item_id":"rs_0fdb43b6db871f01006ae54bd9c5d887d08a0100ce0c172528","obfuscation":"AL5zZ1SDSJbckpj","output_index":0,"sequence_number":25,"summary_index":0} + +event: response.reasoning_summary_text.delta +data: {"type":"response.reasoning_summary_text.delta","delta":" If","item_id":"rs_0fdb43b6db871f01006ae54bd9c5d887d08a0100ce0c172528","obfuscation":"X9lYdhceal3Dh","output_index":0,"sequence_number":26,"summary_index":0} + +event: response.reasoning_summary_text.delta +data: {"type":"response.reasoning_summary_text.delta","delta":" I","item_id":"rs_0fdb43b6db871f01006ae54bd9c5d887d08a0100ce0c172528","obfuscation":"5RM1JSQEcoHeKM","output_index":0,"sequence_number":27,"summary_index":0} + +event: response.reasoning_summary_text.delta +data: {"type":"response.reasoning_summary_text.delta","delta":" let","item_id":"rs_0fdb43b6db871f01006ae54bd9c5d887d08a0100ce0c172528","obfuscation":"YTf6CPBrhZyI","output_index":0,"sequence_number":28,"summary_index":0} + +event: response.reasoning_summary_text.delta +data: {"type":"response.reasoning_summary_text.delta","delta":" the","item_id":"rs_0fdb43b6db871f01006ae54bd9c5d887d08a0100ce0c172528","obfuscation":"5Jz2TzSWnpPm","output_index":0,"sequence_number":29,"summary_index":0} + +event: response.reasoning_summary_text.delta +data: {"type":"response.reasoning_summary_text.delta","delta":" ball","item_id":"rs_0fdb43b6db871f01006ae54bd9c5d887d08a0100ce0c172528","obfuscation":"SrUtLpk2lp3","output_index":0,"sequence_number":30,"summary_index":0} + +event: response.reasoning_summary_text.delta +data: {"type":"response.reasoning_summary_text.delta","delta":"’s","item_id":"rs_0fdb43b6db871f01006ae54bd9c5d887d08a0100ce0c172528","obfuscation":"Irp7l5zp4ETKMi","output_index":0,"sequence_number":31,"summary_index":0} + +event: response.reasoning_summary_text.delta +data: {"type":"response.reasoning_summary_text.delta","delta":" cost","item_id":"rs_0fdb43b6db871f01006ae54bd9c5d887d08a0100ce0c172528","obfuscation":"jr3DJ68abVA","output_index":0,"sequence_number":32,"summary_index":0} + +event: response.reasoning_summary_text.delta +data: {"type":"response.reasoning_summary_text.delta","delta":" be","item_id":"rs_0fdb43b6db871f01006ae54bd9c5d887d08a0100ce0c172528","obfuscation":"NBL6wYvrt6r9L","output_index":0,"sequence_number":33,"summary_index":0} + +event: response.reasoning_summary_text.delta +data: {"type":"response.reasoning_summary_text.delta","delta":" x","item_id":"rs_0fdb43b6db871f01006ae54bd9c5d887d08a0100ce0c172528","obfuscation":"pgPyPZSDIOyiBb","output_index":0,"sequence_number":34,"summary_index":0} + +event: response.reasoning_summary_text.delta +data: {"type":"response.reasoning_summary_text.delta","delta":",","item_id":"rs_0fdb43b6db871f01006ae54bd9c5d887d08a0100ce0c172528","obfuscation":"pJ3iqYLBCv7lQoZ","output_index":0,"sequence_number":35,"summary_index":0} + +event: response.reasoning_summary_text.delta +data: {"type":"response.reasoning_summary_text.delta","delta":" then","item_id":"rs_0fdb43b6db871f01006ae54bd9c5d887d08a0100ce0c172528","obfuscation":"a5DUP55mjhL","output_index":0,"sequence_number":36,"summary_index":0} + +event: response.reasoning_summary_text.delta +data: {"type":"response.reasoning_summary_text.delta","delta":" the","item_id":"rs_0fdb43b6db871f01006ae54bd9c5d887d08a0100ce0c172528","obfuscation":"QUxUE1GGiDB3","output_index":0,"sequence_number":37,"summary_index":0} + +event: response.reasoning_summary_text.delta +data: {"type":"response.reasoning_summary_text.delta","delta":" bat","item_id":"rs_0fdb43b6db871f01006ae54bd9c5d887d08a0100ce0c172528","obfuscation":"MLZunLQmrihD","output_index":0,"sequence_number":38,"summary_index":0} + +event: response.reasoning_summary_text.delta +data: {"type":"response.reasoning_summary_text.delta","delta":" is","item_id":"rs_0fdb43b6db871f01006ae54bd9c5d887d08a0100ce0c172528","obfuscation":"kq0GAjyy0pcJx","output_index":0,"sequence_number":39,"summary_index":0} + +event: response.reasoning_summary_text.delta +data: {"type":"response.reasoning_summary_text.delta","delta":" x","item_id":"rs_0fdb43b6db871f01006ae54bd9c5d887d08a0100ce0c172528","obfuscation":"fiVxzSxswNWaLH","output_index":0,"sequence_number":40,"summary_index":0} + +event: response.reasoning_summary_text.delta +data: {"type":"response.reasoning_summary_text.delta","delta":" +","item_id":"rs_0fdb43b6db871f01006ae54bd9c5d887d08a0100ce0c172528","obfuscation":"U6Ur2CUWTho24u","output_index":0,"sequence_number":41,"summary_index":0} + +event: response.reasoning_summary_text.delta +data: {"type":"response.reasoning_summary_text.delta","delta":" $","item_id":"rs_0fdb43b6db871f01006ae54bd9c5d887d08a0100ce0c172528","obfuscation":"1DZ01M7YpnHbt8","output_index":0,"sequence_number":42,"summary_index":0} + +event: response.reasoning_summary_text.delta +data: {"type":"response.reasoning_summary_text.delta","delta":"1","item_id":"rs_0fdb43b6db871f01006ae54bd9c5d887d08a0100ce0c172528","obfuscation":"liskANXdzNlxDe6","output_index":0,"sequence_number":43,"summary_index":0} + +event: response.reasoning_summary_text.delta +data: {"type":"response.reasoning_summary_text.delta","delta":".","item_id":"rs_0fdb43b6db871f01006ae54bd9c5d887d08a0100ce0c172528","obfuscation":"H2DNxjsrphQTAzF","output_index":0,"sequence_number":44,"summary_index":0} + +event: response.reasoning_summary_text.delta +data: {"type":"response.reasoning_summary_text.delta","delta":"00","item_id":"rs_0fdb43b6db871f01006ae54bd9c5d887d08a0100ce0c172528","obfuscation":"C9wU8KqBIpgqNo","output_index":0,"sequence_number":45,"summary_index":0} + +event: response.reasoning_summary_text.delta +data: {"type":"response.reasoning_summary_text.delta","delta":".","item_id":"rs_0fdb43b6db871f01006ae54bd9c5d887d08a0100ce0c172528","obfuscation":"lxmgcsc3rg6TtJc","output_index":0,"sequence_number":46,"summary_index":0} + +event: response.reasoning_summary_text.delta +data: {"type":"response.reasoning_summary_text.delta","delta":" Setting","item_id":"rs_0fdb43b6db871f01006ae54bd9c5d887d08a0100ce0c172528","obfuscation":"VkWmZzXV","output_index":0,"sequence_number":47,"summary_index":0} + +event: response.reasoning_summary_text.delta +data: {"type":"response.reasoning_summary_text.delta","delta":" up","item_id":"rs_0fdb43b6db871f01006ae54bd9c5d887d08a0100ce0c172528","obfuscation":"QSxxuYlOc8Wcc","output_index":0,"sequence_number":48,"summary_index":0} + +event: response.reasoning_summary_text.delta +data: {"type":"response.reasoning_summary_text.delta","delta":" the","item_id":"rs_0fdb43b6db871f01006ae54bd9c5d887d08a0100ce0c172528","obfuscation":"yWsblWQansQq","output_index":0,"sequence_number":49,"summary_index":0} + +event: response.reasoning_summary_text.delta +data: {"type":"response.reasoning_summary_text.delta","delta":" equation","item_id":"rs_0fdb43b6db871f01006ae54bd9c5d887d08a0100ce0c172528","obfuscation":"31ikU6k","output_index":0,"sequence_number":50,"summary_index":0} + +event: response.reasoning_summary_text.delta +data: {"type":"response.reasoning_summary_text.delta","delta":" x","item_id":"rs_0fdb43b6db871f01006ae54bd9c5d887d08a0100ce0c172528","obfuscation":"QsmoPMhe3FSgjh","output_index":0,"sequence_number":51,"summary_index":0} + +event: response.reasoning_summary_text.delta +data: {"type":"response.reasoning_summary_text.delta","delta":" +","item_id":"rs_0fdb43b6db871f01006ae54bd9c5d887d08a0100ce0c172528","obfuscation":"I1RZfSre7Tptwm","output_index":0,"sequence_number":52,"summary_index":0} + +event: response.reasoning_summary_text.delta +data: {"type":"response.reasoning_summary_text.delta","delta":" (","item_id":"rs_0fdb43b6db871f01006ae54bd9c5d887d08a0100ce0c172528","obfuscation":"OdUfjfE7S9cnYQ","output_index":0,"sequence_number":53,"summary_index":0} + +event: response.reasoning_summary_text.delta +data: {"type":"response.reasoning_summary_text.delta","delta":"x","item_id":"rs_0fdb43b6db871f01006ae54bd9c5d887d08a0100ce0c172528","obfuscation":"wUXPO4uNDooRML4","output_index":0,"sequence_number":54,"summary_index":0} + +event: response.reasoning_summary_text.delta +data: {"type":"response.reasoning_summary_text.delta","delta":" +","item_id":"rs_0fdb43b6db871f01006ae54bd9c5d887d08a0100ce0c172528","obfuscation":"0oMvlbxR7hmwQ0","output_index":0,"sequence_number":55,"summary_index":0} + +event: response.reasoning_summary_text.delta +data: {"type":"response.reasoning_summary_text.delta","delta":" 1","item_id":"rs_0fdb43b6db871f01006ae54bd9c5d887d08a0100ce0c172528","obfuscation":"uxeRJLQQ6mexos","output_index":0,"sequence_number":56,"summary_index":0} + +event: response.reasoning_summary_text.delta +data: {"type":"response.reasoning_summary_text.delta","delta":".","item_id":"rs_0fdb43b6db871f01006ae54bd9c5d887d08a0100ce0c172528","obfuscation":"1x6OHwBTpPL4MJZ","output_index":0,"sequence_number":57,"summary_index":0} + +event: response.reasoning_summary_text.delta +data: {"type":"response.reasoning_summary_text.delta","delta":"00","item_id":"rs_0fdb43b6db871f01006ae54bd9c5d887d08a0100ce0c172528","obfuscation":"I65MpEeuGecnqw","output_index":0,"sequence_number":58,"summary_index":0} + +event: response.reasoning_summary_text.delta +data: {"type":"response.reasoning_summary_text.delta","delta":")","item_id":"rs_0fdb43b6db871f01006ae54bd9c5d887d08a0100ce0c172528","obfuscation":"KGEWoW7O4YZ01Sk","output_index":0,"sequence_number":59,"summary_index":0} + +event: response.reasoning_summary_text.delta +data: {"type":"response.reasoning_summary_text.delta","delta":" =","item_id":"rs_0fdb43b6db871f01006ae54bd9c5d887d08a0100ce0c172528","obfuscation":"d1G2zTMGBu9slz","output_index":0,"sequence_number":60,"summary_index":0} + +event: response.reasoning_summary_text.delta +data: {"type":"response.reasoning_summary_text.delta","delta":" 1","item_id":"rs_0fdb43b6db871f01006ae54bd9c5d887d08a0100ce0c172528","obfuscation":"aie45PYARaTcWM","output_index":0,"sequence_number":61,"summary_index":0} + +event: response.reasoning_summary_text.delta +data: {"type":"response.reasoning_summary_text.delta","delta":".","item_id":"rs_0fdb43b6db871f01006ae54bd9c5d887d08a0100ce0c172528","obfuscation":"RuhDUZasXmD0VmV","output_index":0,"sequence_number":62,"summary_index":0} + +event: response.reasoning_summary_text.delta +data: {"type":"response.reasoning_summary_text.delta","delta":"10","item_id":"rs_0fdb43b6db871f01006ae54bd9c5d887d08a0100ce0c172528","obfuscation":"V8Q3r5H3Ou95gz","output_index":0,"sequence_number":63,"summary_index":0} + +event: response.reasoning_summary_text.delta +data: {"type":"response.reasoning_summary_text.delta","delta":" leads","item_id":"rs_0fdb43b6db871f01006ae54bd9c5d887d08a0100ce0c172528","obfuscation":"1ESsWJgQ8v","output_index":0,"sequence_number":64,"summary_index":0} + +event: response.reasoning_summary_text.delta +data: {"type":"response.reasoning_summary_text.delta","delta":" me","item_id":"rs_0fdb43b6db871f01006ae54bd9c5d887d08a0100ce0c172528","obfuscation":"rI7VNm0xcU81T","output_index":0,"sequence_number":65,"summary_index":0} + +event: response.reasoning_summary_text.delta +data: {"type":"response.reasoning_summary_text.delta","delta":" to","item_id":"rs_0fdb43b6db871f01006ae54bd9c5d887d08a0100ce0c172528","obfuscation":"oo7FvxJ1CKMio","output_index":0,"sequence_number":66,"summary_index":0} + +event: response.reasoning_summary_text.delta +data: {"type":"response.reasoning_summary_text.delta","delta":" find","item_id":"rs_0fdb43b6db871f01006ae54bd9c5d887d08a0100ce0c172528","obfuscation":"xytmPjCNnWt","output_index":0,"sequence_number":67,"summary_index":0} + +event: response.reasoning_summary_text.delta +data: {"type":"response.reasoning_summary_text.delta","delta":" x","item_id":"rs_0fdb43b6db871f01006ae54bd9c5d887d08a0100ce0c172528","obfuscation":"hQUhTjVLcVXvZj","output_index":0,"sequence_number":68,"summary_index":0} + +event: response.reasoning_summary_text.delta +data: {"type":"response.reasoning_summary_text.delta","delta":" as","item_id":"rs_0fdb43b6db871f01006ae54bd9c5d887d08a0100ce0c172528","obfuscation":"83Hq5QJvd5QUu","output_index":0,"sequence_number":69,"summary_index":0} + +event: response.reasoning_summary_text.delta +data: {"type":"response.reasoning_summary_text.delta","delta":" $","item_id":"rs_0fdb43b6db871f01006ae54bd9c5d887d08a0100ce0c172528","obfuscation":"Z06JCQWmL2YEMN","output_index":0,"sequence_number":70,"summary_index":0} + +event: response.reasoning_summary_text.delta +data: {"type":"response.reasoning_summary_text.delta","delta":"0","item_id":"rs_0fdb43b6db871f01006ae54bd9c5d887d08a0100ce0c172528","obfuscation":"Dk2x6G6tYhzLx83","output_index":0,"sequence_number":71,"summary_index":0} + +event: response.reasoning_summary_text.delta +data: {"type":"response.reasoning_summary_text.delta","delta":".","item_id":"rs_0fdb43b6db871f01006ae54bd9c5d887d08a0100ce0c172528","obfuscation":"WTump4ZLmgjSAcA","output_index":0,"sequence_number":72,"summary_index":0} + +event: response.reasoning_summary_text.delta +data: {"type":"response.reasoning_summary_text.delta","delta":"05","item_id":"rs_0fdb43b6db871f01006ae54bd9c5d887d08a0100ce0c172528","obfuscation":"kTSGT68lDv0wLt","output_index":0,"sequence_number":73,"summary_index":0} + +event: response.reasoning_summary_text.delta +data: {"type":"response.reasoning_summary_text.delta","delta":".","item_id":"rs_0fdb43b6db871f01006ae54bd9c5d887d08a0100ce0c172528","obfuscation":"oygDO2onoqYU6lu","output_index":0,"sequence_number":74,"summary_index":0} + +event: response.reasoning_summary_text.delta +data: {"type":"response.reasoning_summary_text.delta","delta":" Many","item_id":"rs_0fdb43b6db871f01006ae54bd9c5d887d08a0100ce0c172528","obfuscation":"q2DjqTYJr45","output_index":0,"sequence_number":75,"summary_index":0} + +event: response.reasoning_summary_text.delta +data: {"type":"response.reasoning_summary_text.delta","delta":" might","item_id":"rs_0fdb43b6db871f01006ae54bd9c5d887d08a0100ce0c172528","obfuscation":"d5x38vjcWR","output_index":0,"sequence_number":76,"summary_index":0} + +event: response.reasoning_summary_text.delta +data: {"type":"response.reasoning_summary_text.delta","delta":" mistakenly","item_id":"rs_0fdb43b6db871f01006ae54bd9c5d887d08a0100ce0c172528","obfuscation":"RkUI7","output_index":0,"sequence_number":77,"summary_index":0} + +event: response.reasoning_summary_text.delta +data: {"type":"response.reasoning_summary_text.delta","delta":" say","item_id":"rs_0fdb43b6db871f01006ae54bd9c5d887d08a0100ce0c172528","obfuscation":"Bl23t27qyD9T","output_index":0,"sequence_number":78,"summary_index":0} + +event: response.reasoning_summary_text.delta +data: {"type":"response.reasoning_summary_text.delta","delta":" the","item_id":"rs_0fdb43b6db871f01006ae54bd9c5d887d08a0100ce0c172528","obfuscation":"iXh2Rg50af8f","output_index":0,"sequence_number":79,"summary_index":0} + +event: response.reasoning_summary_text.delta +data: {"type":"response.reasoning_summary_text.delta","delta":" ball","item_id":"rs_0fdb43b6db871f01006ae54bd9c5d887d08a0100ce0c172528","obfuscation":"nicoCw4AnCQ","output_index":0,"sequence_number":80,"summary_index":0} + +event: response.reasoning_summary_text.delta +data: {"type":"response.reasoning_summary_text.delta","delta":" costs","item_id":"rs_0fdb43b6db871f01006ae54bd9c5d887d08a0100ce0c172528","obfuscation":"FiDZ6AhDc3","output_index":0,"sequence_number":81,"summary_index":0} + +event: response.reasoning_summary_text.delta +data: {"type":"response.reasoning_summary_text.delta","delta":" $","item_id":"rs_0fdb43b6db871f01006ae54bd9c5d887d08a0100ce0c172528","obfuscation":"eFjICDQNqq2Gye","output_index":0,"sequence_number":82,"summary_index":0} + +event: response.reasoning_summary_text.delta +data: {"type":"response.reasoning_summary_text.delta","delta":"0","item_id":"rs_0fdb43b6db871f01006ae54bd9c5d887d08a0100ce0c172528","obfuscation":"Ei0jUA8lt79he2b","output_index":0,"sequence_number":83,"summary_index":0} + +event: response.reasoning_summary_text.delta +data: {"type":"response.reasoning_summary_text.delta","delta":".","item_id":"rs_0fdb43b6db871f01006ae54bd9c5d887d08a0100ce0c172528","obfuscation":"h5lv8CDNaWmYjYm","output_index":0,"sequence_number":84,"summary_index":0} + +event: response.reasoning_summary_text.delta +data: {"type":"response.reasoning_summary_text.delta","delta":"10","item_id":"rs_0fdb43b6db871f01006ae54bd9c5d887d08a0100ce0c172528","obfuscation":"JRabBuVKMmQ8wC","output_index":0,"sequence_number":85,"summary_index":0} + +event: response.reasoning_summary_text.delta +data: {"type":"response.reasoning_summary_text.delta","delta":" because","item_id":"rs_0fdb43b6db871f01006ae54bd9c5d887d08a0100ce0c172528","obfuscation":"KWrL8wjn","output_index":0,"sequence_number":86,"summary_index":0} + +event: response.reasoning_summary_text.delta +data: {"type":"response.reasoning_summary_text.delta","delta":" it","item_id":"rs_0fdb43b6db871f01006ae54bd9c5d887d08a0100ce0c172528","obfuscation":"f81FtnWl4mYPw","output_index":0,"sequence_number":87,"summary_index":0} + +event: response.reasoning_summary_text.delta +data: {"type":"response.reasoning_summary_text.delta","delta":" seems","item_id":"rs_0fdb43b6db871f01006ae54bd9c5d887d08a0100ce0c172528","obfuscation":"nmH16Mc2ny","output_index":0,"sequence_number":88,"summary_index":0} + +event: response.reasoning_summary_text.delta +data: {"type":"response.reasoning_summary_text.delta","delta":" intuitive","item_id":"rs_0fdb43b6db871f01006ae54bd9c5d887d08a0100ce0c172528","obfuscation":"3n7n64","output_index":0,"sequence_number":89,"summary_index":0} + +event: response.reasoning_summary_text.delta +data: {"type":"response.reasoning_summary_text.delta","delta":",","item_id":"rs_0fdb43b6db871f01006ae54bd9c5d887d08a0100ce0c172528","obfuscation":"bUdbPFbPifLWnI2","output_index":0,"sequence_number":90,"summary_index":0} + +event: response.reasoning_summary_text.delta +data: {"type":"response.reasoning_summary_text.delta","delta":" but","item_id":"rs_0fdb43b6db871f01006ae54bd9c5d887d08a0100ce0c172528","obfuscation":"bNyaxa8UZqsg","output_index":0,"sequence_number":91,"summary_index":0} + +event: response.reasoning_summary_text.delta +data: {"type":"response.reasoning_summary_text.delta","delta":" if","item_id":"rs_0fdb43b6db871f01006ae54bd9c5d887d08a0100ce0c172528","obfuscation":"2lTUfDZbTm21G","output_index":0,"sequence_number":92,"summary_index":0} + +event: response.reasoning_summary_text.delta +data: {"type":"response.reasoning_summary_text.delta","delta":" that","item_id":"rs_0fdb43b6db871f01006ae54bd9c5d887d08a0100ce0c172528","obfuscation":"ZdGXu8CeD83","output_index":0,"sequence_number":93,"summary_index":0} + +event: response.reasoning_summary_text.delta +data: {"type":"response.reasoning_summary_text.delta","delta":" were","item_id":"rs_0fdb43b6db871f01006ae54bd9c5d887d08a0100ce0c172528","obfuscation":"tmcJCpnBzFL","output_index":0,"sequence_number":94,"summary_index":0} + +event: response.reasoning_summary_text.delta +data: {"type":"response.reasoning_summary_text.delta","delta":" true","item_id":"rs_0fdb43b6db871f01006ae54bd9c5d887d08a0100ce0c172528","obfuscation":"Wyf19UDjdym","output_index":0,"sequence_number":95,"summary_index":0} + +event: response.reasoning_summary_text.delta +data: {"type":"response.reasoning_summary_text.delta","delta":",","item_id":"rs_0fdb43b6db871f01006ae54bd9c5d887d08a0100ce0c172528","obfuscation":"lhh8WTESAcQMjzO","output_index":0,"sequence_number":96,"summary_index":0} + +event: response.reasoning_summary_text.delta +data: {"type":"response.reasoning_summary_text.delta","delta":" the","item_id":"rs_0fdb43b6db871f01006ae54bd9c5d887d08a0100ce0c172528","obfuscation":"A2zQX3oDOI95","output_index":0,"sequence_number":97,"summary_index":0} + +event: response.reasoning_summary_text.delta +data: {"type":"response.reasoning_summary_text.delta","delta":" bat","item_id":"rs_0fdb43b6db871f01006ae54bd9c5d887d08a0100ce0c172528","obfuscation":"pOY2BwBq9WqL","output_index":0,"sequence_number":98,"summary_index":0} + +event: response.reasoning_summary_text.delta +data: {"type":"response.reasoning_summary_text.delta","delta":" would","item_id":"rs_0fdb43b6db871f01006ae54bd9c5d887d08a0100ce0c172528","obfuscation":"58qXAU2CHk","output_index":0,"sequence_number":99,"summary_index":0} + +event: response.reasoning_summary_text.delta +data: {"type":"response.reasoning_summary_text.delta","delta":" be","item_id":"rs_0fdb43b6db871f01006ae54bd9c5d887d08a0100ce0c172528","obfuscation":"vWuaMjLw0Vjcd","output_index":0,"sequence_number":100,"summary_index":0} + +event: response.reasoning_summary_text.delta +data: {"type":"response.reasoning_summary_text.delta","delta":" $","item_id":"rs_0fdb43b6db871f01006ae54bd9c5d887d08a0100ce0c172528","obfuscation":"l7LAuEfmMbrkTd","output_index":0,"sequence_number":101,"summary_index":0} + +event: response.reasoning_summary_text.delta +data: {"type":"response.reasoning_summary_text.delta","delta":"1","item_id":"rs_0fdb43b6db871f01006ae54bd9c5d887d08a0100ce0c172528","obfuscation":"AkTfkWVekTcxLzC","output_index":0,"sequence_number":102,"summary_index":0} + +event: response.reasoning_summary_text.delta +data: {"type":"response.reasoning_summary_text.delta","delta":".","item_id":"rs_0fdb43b6db871f01006ae54bd9c5d887d08a0100ce0c172528","obfuscation":"ZiGdstDf0W89Xka","output_index":0,"sequence_number":103,"summary_index":0} + +event: response.reasoning_summary_text.delta +data: {"type":"response.reasoning_summary_text.delta","delta":"10","item_id":"rs_0fdb43b6db871f01006ae54bd9c5d887d08a0100ce0c172528","obfuscation":"JqK16Fe0rNmbBv","output_index":0,"sequence_number":104,"summary_index":0} + +event: response.reasoning_summary_text.delta +data: {"type":"response.reasoning_summary_text.delta","delta":",","item_id":"rs_0fdb43b6db871f01006ae54bd9c5d887d08a0100ce0c172528","obfuscation":"aooZfazrHzUL5pK","output_index":0,"sequence_number":105,"summary_index":0} + +event: response.reasoning_summary_text.delta +data: {"type":"response.reasoning_summary_text.delta","delta":" totaling","item_id":"rs_0fdb43b6db871f01006ae54bd9c5d887d08a0100ce0c172528","obfuscation":"L5AGIMs","output_index":0,"sequence_number":106,"summary_index":0} + +event: response.reasoning_summary_text.delta +data: {"type":"response.reasoning_summary_text.delta","delta":" $","item_id":"rs_0fdb43b6db871f01006ae54bd9c5d887d08a0100ce0c172528","obfuscation":"falsqBjBve1n0z","output_index":0,"sequence_number":107,"summary_index":0} + +event: response.reasoning_summary_text.delta +data: {"type":"response.reasoning_summary_text.delta","delta":"1","item_id":"rs_0fdb43b6db871f01006ae54bd9c5d887d08a0100ce0c172528","obfuscation":"I6hqGYPhoiqC1Iz","output_index":0,"sequence_number":108,"summary_index":0} + +event: response.reasoning_summary_text.delta +data: {"type":"response.reasoning_summary_text.delta","delta":".","item_id":"rs_0fdb43b6db871f01006ae54bd9c5d887d08a0100ce0c172528","obfuscation":"AxZzoiISup66fXG","output_index":0,"sequence_number":109,"summary_index":0} + +event: response.reasoning_summary_text.delta +data: {"type":"response.reasoning_summary_text.delta","delta":"20","item_id":"rs_0fdb43b6db871f01006ae54bd9c5d887d08a0100ce0c172528","obfuscation":"wo2HSDbDHij9MX","output_index":0,"sequence_number":110,"summary_index":0} + +event: response.reasoning_summary_text.delta +data: {"type":"response.reasoning_summary_text.delta","delta":"—","item_id":"rs_0fdb43b6db871f01006ae54bd9c5d887d08a0100ce0c172528","obfuscation":"bTV7atNM4fexNXo","output_index":0,"sequence_number":111,"summary_index":0} + +event: response.reasoning_summary_text.delta +data: {"type":"response.reasoning_summary_text.delta","delta":"cle","item_id":"rs_0fdb43b6db871f01006ae54bd9c5d887d08a0100ce0c172528","obfuscation":"MCUrGGRidtbkk","output_index":0,"sequence_number":112,"summary_index":0} + +event: response.reasoning_summary_text.delta +data: {"type":"response.reasoning_summary_text.delta","delta":"arly","item_id":"rs_0fdb43b6db871f01006ae54bd9c5d887d08a0100ce0c172528","obfuscation":"6mGpHrjMnBZi","output_index":0,"sequence_number":113,"summary_index":0} + +event: response.reasoning_summary_text.delta +data: {"type":"response.reasoning_summary_text.delta","delta":" wrong","item_id":"rs_0fdb43b6db871f01006ae54bd9c5d887d08a0100ce0c172528","obfuscation":"y2N8QyzbKW","output_index":0,"sequence_number":114,"summary_index":0} + +event: response.reasoning_summary_text.delta +data: {"type":"response.reasoning_summary_text.delta","delta":"!","item_id":"rs_0fdb43b6db871f01006ae54bd9c5d887d08a0100ce0c172528","obfuscation":"tYLrQR35l6vb6P7","output_index":0,"sequence_number":115,"summary_index":0} + +event: response.reasoning_summary_text.delta +data: {"type":"response.reasoning_summary_text.delta","delta":" So","item_id":"rs_0fdb43b6db871f01006ae54bd9c5d887d08a0100ce0c172528","obfuscation":"RyW8mtwewdipm","output_index":0,"sequence_number":116,"summary_index":0} + +event: response.reasoning_summary_text.delta +data: {"type":"response.reasoning_summary_text.delta","delta":",","item_id":"rs_0fdb43b6db871f01006ae54bd9c5d887d08a0100ce0c172528","obfuscation":"uaCT4ORosmY0YuX","output_index":0,"sequence_number":117,"summary_index":0} + +event: response.reasoning_summary_text.delta +data: {"type":"response.reasoning_summary_text.delta","delta":" the","item_id":"rs_0fdb43b6db871f01006ae54bd9c5d887d08a0100ce0c172528","obfuscation":"JcsO4tpSfJUG","output_index":0,"sequence_number":118,"summary_index":0} + +event: response.reasoning_summary_text.delta +data: {"type":"response.reasoning_summary_text.delta","delta":" ball","item_id":"rs_0fdb43b6db871f01006ae54bd9c5d887d08a0100ce0c172528","obfuscation":"GqH4oyw68BP","output_index":0,"sequence_number":119,"summary_index":0} + +event: response.reasoning_summary_text.delta +data: {"type":"response.reasoning_summary_text.delta","delta":" is","item_id":"rs_0fdb43b6db871f01006ae54bd9c5d887d08a0100ce0c172528","obfuscation":"rspNlMsYLJAzO","output_index":0,"sequence_number":120,"summary_index":0} + +event: response.reasoning_summary_text.delta +data: {"type":"response.reasoning_summary_text.delta","delta":" $","item_id":"rs_0fdb43b6db871f01006ae54bd9c5d887d08a0100ce0c172528","obfuscation":"1bgalrvzYPCISF","output_index":0,"sequence_number":121,"summary_index":0} + +event: response.reasoning_summary_text.delta +data: {"type":"response.reasoning_summary_text.delta","delta":"0","item_id":"rs_0fdb43b6db871f01006ae54bd9c5d887d08a0100ce0c172528","obfuscation":"jS9xYgAQdi1NwDV","output_index":0,"sequence_number":122,"summary_index":0} + +event: response.reasoning_summary_text.delta +data: {"type":"response.reasoning_summary_text.delta","delta":".","item_id":"rs_0fdb43b6db871f01006ae54bd9c5d887d08a0100ce0c172528","obfuscation":"aWJjzM2oOHZTWPN","output_index":0,"sequence_number":123,"summary_index":0} + +event: response.reasoning_summary_text.delta +data: {"type":"response.reasoning_summary_text.delta","delta":"05","item_id":"rs_0fdb43b6db871f01006ae54bd9c5d887d08a0100ce0c172528","obfuscation":"ksLgO6T10vaZG9","output_index":0,"sequence_number":124,"summary_index":0} + +event: response.reasoning_summary_text.delta +data: {"type":"response.reasoning_summary_text.delta","delta":".","item_id":"rs_0fdb43b6db871f01006ae54bd9c5d887d08a0100ce0c172528","obfuscation":"bvv1dxxFpLsYUM8","output_index":0,"sequence_number":125,"summary_index":0} + +event: response.reasoning_summary_text.done +data: {"type":"response.reasoning_summary_text.done","item_id":"rs_0fdb43b6db871f01006ae54bd9c5d887d08a0100ce0c172528","output_index":0,"sequence_number":126,"summary_index":0,"text":"**Explaining the puzzle**\n\nAlright, I'm working through this classic puzzle. I need to show my reasoning clearly before giving the final answer. If I let the ball’s cost be x, then the bat is x + $1.00. Setting up the equation x + (x + 1.00) = 1.10 leads me to find x as $0.05. Many might mistakenly say the ball costs $0.10 because it seems intuitive, but if that were true, the bat would be $1.10, totaling $1.20—clearly wrong! So, the ball is $0.05."} + +event: response.reasoning_summary_part.done +data: {"type":"response.reasoning_summary_part.done","item_id":"rs_0fdb43b6db871f01006ae54bd9c5d887d08a0100ce0c172528","output_index":0,"part":{"type":"summary_text","text":"**Explaining the puzzle**\n\nAlright, I'm working through this classic puzzle. I need to show my reasoning clearly before giving the final answer. If I let the ball’s cost be x, then the bat is x + $1.00. Setting up the equation x + (x + 1.00) = 1.10 leads me to find x as $0.05. Many might mistakenly say the ball costs $0.10 because it seems intuitive, but if that were true, the bat would be $1.10, totaling $1.20—clearly wrong! So, the ball is $0.05."},"sequence_number":127,"summary_index":0} + +event: response.output_item.done +data: {"type":"response.output_item.done","item":{"id":"rs_0fdb43b6db871f01006ae54bd9c5d887d08a0100ce0c172528","type":"reasoning","content":[],"encrypted_content":"gAAAAABq5Uvfllu9NxJuCts4uhL9k2vZ2-2rama-6RVzm02DpEZ_9nTZcV1x-QNtByvKHkD5yUasDpJvNaK1scIfCkqDGl1i4lEgT_n2DGQ7ZMQQzv1kIHBHZuY-Jzl4aVKzIDi-sIv3sc74X9xYx3SLQwdmWWsoaj5qNNP1tXNbqUwl9Sbu-gEEib1Oq5B-Fj8monBBNIl1xk6AWhGE0A2bTLETLihcJPyTPFxXMa88Y3vbpFNaq6PzKn_gmZW7xgj_NAUda10SiRhbdjDkCt09zWmBrh2l4OfBl34fpxE-h_XLbYoJ7E0K0ZRJxPMc5XKZW_SobudW2zmFRKulq1-5OGn6I_R25phLC7qigCwPOhb-7q44IaWF2Ux2epriN-eyKAWg71rnsaKu62AqDSFd8vKVlRcXroIbyE-sQrYG2bWK7wnsV1yP1fcZ8fMaQM02-T8pRMTD9DFk1D3DzTUOF3rBRdzG6LBFWWH8MEngc0q7nox0SGcDnlbsRkzxncjW14g3YmKymceXaj-htWG8azVPTpVwDowV-XUUTMYrSfVNrsxKehVBhh9Vn_7Fpw93Q00S-J3Xh-1OS1DXgbl_Ms7PFZsClYBTMkzfnxH1LuRG9nN6TCyDdeak1cGnBLYkfdrDblr3xHDLBHL29Zt1AarAeWJCOmrL7SFsyWsQzwooCx3IQiy4hxo1yn90yzMay1nt6UQN-zc27As4rTM72nTnEeypDZTqG8IlD21hjwUwGhD8gocVBsMyLg4DXlsdnDkwGz69yy0TQKtziss2xTBgA-G79souAFbWbQ-PSQ5zh87_Bdoi9dd036bfz99RyoENuV1YoD439uW0gjkbS5xz04-RtgzON7M3fTfyu9T85lkGBG7LGHNZ1jcQS7BlYg_WN3ngtTyjpqyemutghMxZZIX8o7FZzhzWGaVrHVbYB_1S9hx2Un9_1UeOntx47mFywe9HuM3lTJseSnqA7Bc9YCSsjDPRK4_DyqMEZlUo-mOXEDjND3Eb4nvo_qizeQW3W6SZ_8zVi8TzegQhhyobl3udi9kZm-m5c8VdjA6CeFse5Uak0KfMvbT1T3Cw6Wkb9lgtraRaKJ33roVYxyLtDbNvAabPDrJ3UQz_R4IjjJyQZ5qTkdfmpjoHdxEXJWRcPKHVyYzKuu1GwymYMxJEbZeleM6EAwnbsHcl_XVhkAz6q5fKhTE4h8nD7SONqvDCY33qx5ui5fARKsaoP7tf5hCkHB_MVd1C3DEVwIyWAF1ak17GMm06DdL7r7yrTwF2GW3KjEix7QOpbhFF8aVhZnw64DZShEPBv9zXWZ1DjpDSSe9mb-2SPPYsA5T9VeaSvvrJl1zdbv-PgBjJZOyehqpgMXx4t5P-tIp4f_8itB_o8ARdWPa5GLiHnhV-ovnwcYBFN5TWwlCo7CreZrPXm5Z3wivc7514tKvbAkIjkxQs8t3jEMlE43G_XXS--zOOkIaXQQ7Gh5EfoVVTpUa7Rps3WlzpEi7wP46_BKuIQmRrSdoGWfwyKblKHmMyBoEfxMzGCmflTMMxSNrH5keD8Zp9ZYRkxYJNHuHfA17ykMM6FkoaVsOszjlUZvvuCI4Fshl-XKMnb-uZESTlLvGNnPAPZwma0Rxrcncfd3Uz63J_zaHfSH7fAJhNCqqi8qDEnJ-RgcVS74xfH1dICKW3Jh7UYNzHHP724KZl9BZfZju_ufbYTFtMd4lrWds33cVUzo-GE76L0qlpiVxDKTOm9Nkh_HSUIYD3Y7DmXfCseLxfMQlFYkSY9HGvt7mzVPa1BGEQu1TIPX6pN0XMbxLwBSwqmksae0F2ArwsKO2kcdyFG475w-Ro8yYQFSTcsdS31ZrmM8WSO1KnBpKYRryD2bnlzhK_-TG9YhcYCPL8pL6qtKnQ_W-RRDSQlS8o-IRW4idYo4XxliwpeOpgS0gQV3n1yt3u7FCwdG7rKi9PALyA_k0iI9RkextI5C_YmNtO6duu3W1wR_pkKITYqSjQ5R6nS5oaPVLeVE3hwYnIneWoKUsXjrQpakRmVWvuesSiSGsAd6nykvV--IVTI2cI4Zb29f7_9LW9qNIW9LGrIjA_2Npk7z9OhagU2xPY41MLevZvAPpqGSmq2RcYVVFT-TZyW22HiXwdo7Io7Nrj26cC5e8iLKffejpmp-pfDPdTsNqfk3EvmnJK46-7-mVGdC1mwRVsMyH2k_vKf3vObNmqS_tuh4R3x4_SQc2CWDy7mXspn810hGLjCnveu_v6Om4vjsI-Y7dzdeX0AmEG9BkUWES8owQJrh2z89SVinMqr4QHrJNBqoDkHbs3rVaXwSOoUeFJ-9DhY8z4WqbzQLXk4SmVesTXFKnDDnInJgYVHYgY-L_YeyspwWbvSPJ1UFQXooUHlGBPgGa-zqSeEixRVkqtTop-6vCknXfBWTf33f4UOipP28zHSivwgrYmgWPWudVNDeDwdIWqaOaeEv_OlTRZoZkYyZKBaNjKUys2_mY9m7fEbImh0HmoDZr2P6r713Wbf7vQ2cj8y3YR1xZzQPuVKAZX2va4ZCddAKyLpkBHswhvXZrSvnb9x4baps0NI28NFghU83zzf1d5XkSm8qk9e_qf-K3qWpBOEwHY2MOz7jKHHOxHDMxUupi436GYrxo1Ja-TDdzto35ziro9CqadC29utn7Mtv68CDiubUsHJ7PVrIyL4oNJQhvr3L2N7xnOr77fVEYW3I_3zVM1us38Mg5GnBpTT8xvaI6GOITJH7uuRBFWNpunMVgqXsyFvCS0-JHTiR_nnZXqbZumUq4ur9HvuRcperN8bOSGi1ueLY_eoisw97RWhQR2akXxdG3HgsGdp0VXhHqXvv0T627ZdZEwsSIL0_sDiHDrsBSQF3JgW1EGrAmyRW7DJ6z1NYeWlquhcOTldfKHHZoWRSO5SEKgM03zuL-eTBqJPYTl2i4c77MKn_iSGAMD3nw20bydKeMaSCvMuG8sprgipEwYEsL2_hiBZVDbwF-40MrHGdN0woiu8-432CwHRbysY4EAQ0_DYjy5p0Gb03VMIp19t9G7UA5SXmcvYrEkvylGT9qJFmmPkn8dTl_RyuFGu6SD_O20990tR_yYYCDjW8CxCwTdPVz152ypmjf2_bQdURRdrevrl_B4LkmXoxK4VfOBHGTLY3ibCukbFbqcruKNGyV-RBTjb4QXdr6GJ_9uYR7SIEZ3IB7LGHUY2MgM7VrP_iReZxPaOGsksvWmJ9rmQ9ho2hlhy-DT0oK-DSYWEnhNmhN07bWltVHePLiYnnwqKvuJDG3U8lpmPeFCLAy8fwjhEcSZ4By8vgaMW5Lo77FD_BE1DJVWicF6Z9U09VgTDCjuFimCy054ZdBXWMVEIyPPRHxf3MHhnOY9L6SWPNdXoer6WPYIrqzWGxQ25Dn_AxSA9zArfkSqbmIelnFTRgIrubGk1_FEsMW0tMxWIDAxY80uv13ApBCYWGGSYVTFmaw-kNJple0NpIxgouQUDynNhrd75-lnhpbTfcJ4mELtrCdVeTX39tmFuo1Bme5ZoeAh_CjhHwoX5T90QdkxJtlK6z9HDxNJU0y_NYs0qxiywpo5PcevhRK6cidZtDPqivhHbwqBL6cYSsoxVweEO8na7ooRgjSeF7nqXHtz24jSvXliXGXz3TAErllC8ZXEpiqU9n8OhwB5YTEBnvXm0-MJIOlcjhBL4TnmBYQ8Le64JQoml4GYHdSFjmaWaPR_UISea7LvnphV4FqQyNxWxcd3niEIJIPyduoB-jx_yt2-y5HWWrXfvKzKsMcoYtoRaa_psa6MisJUpoti_0j92GSxOkoAXgyvGom4iFlN-CR7bA9kmt5E2IsUUtiyIpklT1z9Im_pJVXB4xN3C04W5QU4b2yQoHJpo2VFRkJ5tBT5c8Jbe_z8iUSE7utJRsO01sle5F7vyF4f4X0WijO9VpoKwyp425RkjrJVc93gzyfuiohId-M8vqcXnijx3B2dXVfoVV6EPYAgkgwISqQ3DH_m0591A60C2fglNxQ4tUWmPOhxpv1bpKohZ2qPbS2RTaNFbc-mLYnWfgBe28O0u2pCYlxknoHGKYPY3sTmtgtrO_B-4d-I2UNadg0Xjm1qG_iXinJLI_QO9Krox1Vg8VYmtX3M6s4fvfv2puzU3Tljua2AH-dxWurwI1vpU-lZ8sb589u1xciR3mmCXbypLIu0ukcVeMkiMdfIPa_eMm3nee4AnLr1g48YxxSrWAEboO91L0JxFsgqf2SKmfA=","summary":[{"type":"summary_text","text":"**Explaining the puzzle**\n\nAlright, I'm working through this classic puzzle. I need to show my reasoning clearly before giving the final answer. If I let the ball’s cost be x, then the bat is x + $1.00. Setting up the equation x + (x + 1.00) = 1.10 leads me to find x as $0.05. Many might mistakenly say the ball costs $0.10 because it seems intuitive, but if that were true, the bat would be $1.10, totaling $1.20—clearly wrong! So, the ball is $0.05."}]},"output_index":0,"sequence_number":128} + +event: response.output_item.added +data: {"type":"response.output_item.added","item":{"id":"msg_0fdb43b6db871f01006ae54bdf513c87d097974366a6747c64","type":"message","status":"in_progress","content":[],"role":"assistant"},"output_index":1,"sequence_number":129} + +event: response.content_part.added +data: {"type":"response.content_part.added","content_index":0,"item_id":"msg_0fdb43b6db871f01006ae54bdf513c87d097974366a6747c64","output_index":1,"part":{"type":"output_text","annotations":[],"logprobs":[],"text":""},"sequence_number":130} + +event: response.output_text.delta +data: {"type":"response.output_text.delta","content_index":0,"delta":"Let","item_id":"msg_0fdb43b6db871f01006ae54bdf513c87d097974366a6747c64","logprobs":[],"obfuscation":"J62pAiRTcknmS","output_index":1,"sequence_number":131} + +event: response.output_text.delta +data: {"type":"response.output_text.delta","content_index":0,"delta":" the","item_id":"msg_0fdb43b6db871f01006ae54bdf513c87d097974366a6747c64","logprobs":[],"obfuscation":"X77X5hDt0u5A","output_index":1,"sequence_number":132} + +event: response.output_text.delta +data: {"type":"response.output_text.delta","content_index":0,"delta":" ball","item_id":"msg_0fdb43b6db871f01006ae54bdf513c87d097974366a6747c64","logprobs":[],"obfuscation":"pSItZO9rfWe","output_index":1,"sequence_number":133} + +event: response.output_text.delta +data: {"type":"response.output_text.delta","content_index":0,"delta":" cost","item_id":"msg_0fdb43b6db871f01006ae54bdf513c87d097974366a6747c64","logprobs":[],"obfuscation":"U6d9xofx2CI","output_index":1,"sequence_number":134} + +event: response.output_text.delta +data: {"type":"response.output_text.delta","content_index":0,"delta":" x","item_id":"msg_0fdb43b6db871f01006ae54bdf513c87d097974366a6747c64","logprobs":[],"obfuscation":"73pKUhs4cDVZUE","output_index":1,"sequence_number":135} + +event: response.output_text.delta +data: {"type":"response.output_text.delta","content_index":0,"delta":" dollars","item_id":"msg_0fdb43b6db871f01006ae54bdf513c87d097974366a6747c64","logprobs":[],"obfuscation":"0bxyuw0Y","output_index":1,"sequence_number":136} + +event: response.output_text.delta +data: {"type":"response.output_text.delta","content_index":0,"delta":".","item_id":"msg_0fdb43b6db871f01006ae54bdf513c87d097974366a6747c64","logprobs":[],"obfuscation":"RKsfLgP9O2RxUeW","output_index":1,"sequence_number":137} + +event: response.output_text.delta +data: {"type":"response.output_text.delta","content_index":0,"delta":" Then","item_id":"msg_0fdb43b6db871f01006ae54bdf513c87d097974366a6747c64","logprobs":[],"obfuscation":"XZ1USa8U12O","output_index":1,"sequence_number":138} + +event: response.output_text.delta +data: {"type":"response.output_text.delta","content_index":0,"delta":" the","item_id":"msg_0fdb43b6db871f01006ae54bdf513c87d097974366a6747c64","logprobs":[],"obfuscation":"4AjEzvzw2xK8","output_index":1,"sequence_number":139} + +event: response.output_text.delta +data: {"type":"response.output_text.delta","content_index":0,"delta":" bat","item_id":"msg_0fdb43b6db871f01006ae54bdf513c87d097974366a6747c64","logprobs":[],"obfuscation":"oXZZ5PGDZ5FT","output_index":1,"sequence_number":140} + +event: response.output_text.delta +data: {"type":"response.output_text.delta","content_index":0,"delta":" costs","item_id":"msg_0fdb43b6db871f01006ae54bdf513c87d097974366a6747c64","logprobs":[],"obfuscation":"TOLxVqclDD","output_index":1,"sequence_number":141} + +event: response.output_text.delta +data: {"type":"response.output_text.delta","content_index":0,"delta":" x","item_id":"msg_0fdb43b6db871f01006ae54bdf513c87d097974366a6747c64","logprobs":[],"obfuscation":"5dyeB7voqzKwZQ","output_index":1,"sequence_number":142} + +event: response.output_text.delta +data: {"type":"response.output_text.delta","content_index":0,"delta":" +","item_id":"msg_0fdb43b6db871f01006ae54bdf513c87d097974366a6747c64","logprobs":[],"obfuscation":"rgkxZttzwLCS2v","output_index":1,"sequence_number":143} + +event: response.output_text.delta +data: {"type":"response.output_text.delta","content_index":0,"delta":" ","item_id":"msg_0fdb43b6db871f01006ae54bdf513c87d097974366a6747c64","logprobs":[],"obfuscation":"tsjfb4Ne3QAAZxb","output_index":1,"sequence_number":144} + +event: response.output_text.delta +data: {"type":"response.output_text.delta","content_index":0,"delta":"1","item_id":"msg_0fdb43b6db871f01006ae54bdf513c87d097974366a6747c64","logprobs":[],"obfuscation":"tLcnGsBlsTqaq6z","output_index":1,"sequence_number":145} + +event: response.output_text.delta +data: {"type":"response.output_text.delta","content_index":0,"delta":".","item_id":"msg_0fdb43b6db871f01006ae54bdf513c87d097974366a6747c64","logprobs":[],"obfuscation":"LxOLToc7jX42QcN","output_index":1,"sequence_number":146} + +event: response.output_text.delta +data: {"type":"response.output_text.delta","content_index":0,"delta":"00","item_id":"msg_0fdb43b6db871f01006ae54bdf513c87d097974366a6747c64","logprobs":[],"obfuscation":"tBBOAvQjvH1wnA","output_index":1,"sequence_number":147} + +event: response.output_text.delta +data: {"type":"response.output_text.delta","content_index":0,"delta":" dollars","item_id":"msg_0fdb43b6db871f01006ae54bdf513c87d097974366a6747c64","logprobs":[],"obfuscation":"cUPPJojS","output_index":1,"sequence_number":148} + +event: response.output_text.delta +data: {"type":"response.output_text.delta","content_index":0,"delta":".","item_id":"msg_0fdb43b6db871f01006ae54bdf513c87d097974366a6747c64","logprobs":[],"obfuscation":"gd4JZXECMfDxGwi","output_index":1,"sequence_number":149} + +event: response.output_text.delta +data: {"type":"response.output_text.delta","content_index":0,"delta":" \n","item_id":"msg_0fdb43b6db871f01006ae54bdf513c87d097974366a6747c64","logprobs":[],"obfuscation":"lUjZ7gAXqgf51","output_index":1,"sequence_number":150} + +event: response.output_text.delta +data: {"type":"response.output_text.delta","content_index":0,"delta":"Their","item_id":"msg_0fdb43b6db871f01006ae54bdf513c87d097974366a6747c64","logprobs":[],"obfuscation":"VIoV5rKQGWJ","output_index":1,"sequence_number":151} + +event: response.output_text.delta +data: {"type":"response.output_text.delta","content_index":0,"delta":" total","item_id":"msg_0fdb43b6db871f01006ae54bdf513c87d097974366a6747c64","logprobs":[],"obfuscation":"tQrzTRdgPh","output_index":1,"sequence_number":152} + +event: response.output_text.delta +data: {"type":"response.output_text.delta","content_index":0,"delta":":","item_id":"msg_0fdb43b6db871f01006ae54bdf513c87d097974366a6747c64","logprobs":[],"obfuscation":"yPpiMjwXiPZHeQB","output_index":1,"sequence_number":153} + +event: response.output_text.delta +data: {"type":"response.output_text.delta","content_index":0,"delta":" x","item_id":"msg_0fdb43b6db871f01006ae54bdf513c87d097974366a6747c64","logprobs":[],"obfuscation":"ALMoFcyqWfcdJL","output_index":1,"sequence_number":154} + +event: response.output_text.delta +data: {"type":"response.output_text.delta","content_index":0,"delta":" +","item_id":"msg_0fdb43b6db871f01006ae54bdf513c87d097974366a6747c64","logprobs":[],"obfuscation":"tetSndyQKplJfZ","output_index":1,"sequence_number":155} + +event: response.output_text.delta +data: {"type":"response.output_text.delta","content_index":0,"delta":" (","item_id":"msg_0fdb43b6db871f01006ae54bdf513c87d097974366a6747c64","logprobs":[],"obfuscation":"NvlasM4q356CIH","output_index":1,"sequence_number":156} + +event: response.output_text.delta +data: {"type":"response.output_text.delta","content_index":0,"delta":"x","item_id":"msg_0fdb43b6db871f01006ae54bdf513c87d097974366a6747c64","logprobs":[],"obfuscation":"m6Lu7OxNvJgwAcq","output_index":1,"sequence_number":157} + +event: response.output_text.delta +data: {"type":"response.output_text.delta","content_index":0,"delta":" +","item_id":"msg_0fdb43b6db871f01006ae54bdf513c87d097974366a6747c64","logprobs":[],"obfuscation":"vYHABv0hw8ctEe","output_index":1,"sequence_number":158} + +event: response.output_text.delta +data: {"type":"response.output_text.delta","content_index":0,"delta":" ","item_id":"msg_0fdb43b6db871f01006ae54bdf513c87d097974366a6747c64","logprobs":[],"obfuscation":"uk6mvWnnBZ7yXr9","output_index":1,"sequence_number":159} + +event: response.output_text.delta +data: {"type":"response.output_text.delta","content_index":0,"delta":"1","item_id":"msg_0fdb43b6db871f01006ae54bdf513c87d097974366a6747c64","logprobs":[],"obfuscation":"fZUYNNX9QaqR9Cc","output_index":1,"sequence_number":160} + +event: response.output_text.delta +data: {"type":"response.output_text.delta","content_index":0,"delta":".","item_id":"msg_0fdb43b6db871f01006ae54bdf513c87d097974366a6747c64","logprobs":[],"obfuscation":"kn4xwuRO6SLcE0A","output_index":1,"sequence_number":161} + +event: response.output_text.delta +data: {"type":"response.output_text.delta","content_index":0,"delta":"00","item_id":"msg_0fdb43b6db871f01006ae54bdf513c87d097974366a6747c64","logprobs":[],"obfuscation":"HtDyaQm2iqtVgL","output_index":1,"sequence_number":162} + +event: response.output_text.delta +data: {"type":"response.output_text.delta","content_index":0,"delta":")","item_id":"msg_0fdb43b6db871f01006ae54bdf513c87d097974366a6747c64","logprobs":[],"obfuscation":"lyWxBU28HIMAWIa","output_index":1,"sequence_number":163} + +event: response.output_text.delta +data: {"type":"response.output_text.delta","content_index":0,"delta":" =","item_id":"msg_0fdb43b6db871f01006ae54bdf513c87d097974366a6747c64","logprobs":[],"obfuscation":"SKlq21LXbHnLrQ","output_index":1,"sequence_number":164} + +event: response.output_text.delta +data: {"type":"response.output_text.delta","content_index":0,"delta":" ","item_id":"msg_0fdb43b6db871f01006ae54bdf513c87d097974366a6747c64","logprobs":[],"obfuscation":"9m406lwjZWyRi6n","output_index":1,"sequence_number":165} + +event: response.output_text.delta +data: {"type":"response.output_text.delta","content_index":0,"delta":"1","item_id":"msg_0fdb43b6db871f01006ae54bdf513c87d097974366a6747c64","logprobs":[],"obfuscation":"170XnO5fOCvrZp0","output_index":1,"sequence_number":166} + +event: response.output_text.delta +data: {"type":"response.output_text.delta","content_index":0,"delta":".","item_id":"msg_0fdb43b6db871f01006ae54bdf513c87d097974366a6747c64","logprobs":[],"obfuscation":"0Kquh2T4ZDBpr31","output_index":1,"sequence_number":167} + +event: response.output_text.delta +data: {"type":"response.output_text.delta","content_index":0,"delta":"10","item_id":"msg_0fdb43b6db871f01006ae54bdf513c87d097974366a6747c64","logprobs":[],"obfuscation":"v5egl97AsjKW93","output_index":1,"sequence_number":168} + +event: response.output_text.delta +data: {"type":"response.output_text.delta","content_index":0,"delta":",","item_id":"msg_0fdb43b6db871f01006ae54bdf513c87d097974366a6747c64","logprobs":[],"obfuscation":"29snG7vKLEijfRE","output_index":1,"sequence_number":169} + +event: response.output_text.delta +data: {"type":"response.output_text.delta","content_index":0,"delta":" so","item_id":"msg_0fdb43b6db871f01006ae54bdf513c87d097974366a6747c64","logprobs":[],"obfuscation":"TrrX37USaK8u7","output_index":1,"sequence_number":170} + +event: response.output_text.delta +data: {"type":"response.output_text.delta","content_index":0,"delta":" ","item_id":"msg_0fdb43b6db871f01006ae54bdf513c87d097974366a6747c64","logprobs":[],"obfuscation":"32j8tBPCAAHhofU","output_index":1,"sequence_number":171} + +event: response.output_text.delta +data: {"type":"response.output_text.delta","content_index":0,"delta":"2","item_id":"msg_0fdb43b6db871f01006ae54bdf513c87d097974366a6747c64","logprobs":[],"obfuscation":"6GN0FQ1rqnywVYV","output_index":1,"sequence_number":172} + +event: response.output_text.delta +data: {"type":"response.output_text.delta","content_index":0,"delta":"x","item_id":"msg_0fdb43b6db871f01006ae54bdf513c87d097974366a6747c64","logprobs":[],"obfuscation":"mgZlmrqdmVczhTy","output_index":1,"sequence_number":173} + +event: response.output_text.delta +data: {"type":"response.output_text.delta","content_index":0,"delta":" +","item_id":"msg_0fdb43b6db871f01006ae54bdf513c87d097974366a6747c64","logprobs":[],"obfuscation":"7Va0t9f9UpR4mq","output_index":1,"sequence_number":174} + +event: response.output_text.delta +data: {"type":"response.output_text.delta","content_index":0,"delta":" ","item_id":"msg_0fdb43b6db871f01006ae54bdf513c87d097974366a6747c64","logprobs":[],"obfuscation":"ATvd8hygoO16ksX","output_index":1,"sequence_number":175} + +event: response.output_text.delta +data: {"type":"response.output_text.delta","content_index":0,"delta":"1","item_id":"msg_0fdb43b6db871f01006ae54bdf513c87d097974366a6747c64","logprobs":[],"obfuscation":"74J9pBHW8c0SJIH","output_index":1,"sequence_number":176} + +event: response.output_text.delta +data: {"type":"response.output_text.delta","content_index":0,"delta":".","item_id":"msg_0fdb43b6db871f01006ae54bdf513c87d097974366a6747c64","logprobs":[],"obfuscation":"yEWftMVcHOEV1tJ","output_index":1,"sequence_number":177} + +event: response.output_text.delta +data: {"type":"response.output_text.delta","content_index":0,"delta":"00","item_id":"msg_0fdb43b6db871f01006ae54bdf513c87d097974366a6747c64","logprobs":[],"obfuscation":"ClK6A1UCUj9ovA","output_index":1,"sequence_number":178} + +event: response.output_text.delta +data: {"type":"response.output_text.delta","content_index":0,"delta":" =","item_id":"msg_0fdb43b6db871f01006ae54bdf513c87d097974366a6747c64","logprobs":[],"obfuscation":"J8MWfyw2MYNq4n","output_index":1,"sequence_number":179} + +event: response.output_text.delta +data: {"type":"response.output_text.delta","content_index":0,"delta":" ","item_id":"msg_0fdb43b6db871f01006ae54bdf513c87d097974366a6747c64","logprobs":[],"obfuscation":"A1mSsj7iGAqSGDd","output_index":1,"sequence_number":180} + +event: response.output_text.delta +data: {"type":"response.output_text.delta","content_index":0,"delta":"1","item_id":"msg_0fdb43b6db871f01006ae54bdf513c87d097974366a6747c64","logprobs":[],"obfuscation":"syKLKOEb0WclKDr","output_index":1,"sequence_number":181} + +event: response.output_text.delta +data: {"type":"response.output_text.delta","content_index":0,"delta":".","item_id":"msg_0fdb43b6db871f01006ae54bdf513c87d097974366a6747c64","logprobs":[],"obfuscation":"SrSAxZeeRoURElk","output_index":1,"sequence_number":182} + +event: response.output_text.delta +data: {"type":"response.output_text.delta","content_index":0,"delta":"10","item_id":"msg_0fdb43b6db871f01006ae54bdf513c87d097974366a6747c64","logprobs":[],"obfuscation":"mEXqkhjCKoIC2r","output_index":1,"sequence_number":183} + +event: response.output_text.delta +data: {"type":"response.output_text.delta","content_index":0,"delta":".","item_id":"msg_0fdb43b6db871f01006ae54bdf513c87d097974366a6747c64","logprobs":[],"obfuscation":"qmEj6arPyU3sXuK","output_index":1,"sequence_number":184} + +event: response.output_text.delta +data: {"type":"response.output_text.delta","content_index":0,"delta":" \n","item_id":"msg_0fdb43b6db871f01006ae54bdf513c87d097974366a6747c64","logprobs":[],"obfuscation":"yfQqSS5NAOXNL","output_index":1,"sequence_number":185} + +event: response.output_text.delta +data: {"type":"response.output_text.delta","content_index":0,"delta":"Thus","item_id":"msg_0fdb43b6db871f01006ae54bdf513c87d097974366a6747c64","logprobs":[],"obfuscation":"3iAQW3BF8enT","output_index":1,"sequence_number":186} + +event: response.output_text.delta +data: {"type":"response.output_text.delta","content_index":0,"delta":" ","item_id":"msg_0fdb43b6db871f01006ae54bdf513c87d097974366a6747c64","logprobs":[],"obfuscation":"5jdWld8Q0wCNRiJ","output_index":1,"sequence_number":187} + +event: response.output_text.delta +data: {"type":"response.output_text.delta","content_index":0,"delta":"2","item_id":"msg_0fdb43b6db871f01006ae54bdf513c87d097974366a6747c64","logprobs":[],"obfuscation":"R9XCp01tU2KiA86","output_index":1,"sequence_number":188} + +event: response.output_text.delta +data: {"type":"response.output_text.delta","content_index":0,"delta":"x","item_id":"msg_0fdb43b6db871f01006ae54bdf513c87d097974366a6747c64","logprobs":[],"obfuscation":"T9lqvGMhqnlIaGG","output_index":1,"sequence_number":189} + +event: response.output_text.delta +data: {"type":"response.output_text.delta","content_index":0,"delta":" =","item_id":"msg_0fdb43b6db871f01006ae54bdf513c87d097974366a6747c64","logprobs":[],"obfuscation":"VVxonEeAFuVUZH","output_index":1,"sequence_number":190} + +event: response.output_text.delta +data: {"type":"response.output_text.delta","content_index":0,"delta":" ","item_id":"msg_0fdb43b6db871f01006ae54bdf513c87d097974366a6747c64","logprobs":[],"obfuscation":"2jwZPjBhLSrkzTT","output_index":1,"sequence_number":191} + +event: response.output_text.delta +data: {"type":"response.output_text.delta","content_index":0,"delta":"0","item_id":"msg_0fdb43b6db871f01006ae54bdf513c87d097974366a6747c64","logprobs":[],"obfuscation":"JGpXnWR9zCELWY8","output_index":1,"sequence_number":192} + +event: response.output_text.delta +data: {"type":"response.output_text.delta","content_index":0,"delta":".","item_id":"msg_0fdb43b6db871f01006ae54bdf513c87d097974366a6747c64","logprobs":[],"obfuscation":"K5iAJSdGz2GdnaR","output_index":1,"sequence_number":193} + +event: response.output_text.delta +data: {"type":"response.output_text.delta","content_index":0,"delta":"10","item_id":"msg_0fdb43b6db871f01006ae54bdf513c87d097974366a6747c64","logprobs":[],"obfuscation":"AG4HTIsOZUdws4","output_index":1,"sequence_number":194} + +event: response.output_text.delta +data: {"type":"response.output_text.delta","content_index":0,"delta":" and","item_id":"msg_0fdb43b6db871f01006ae54bdf513c87d097974366a6747c64","logprobs":[],"obfuscation":"1rnlyApvX9c8","output_index":1,"sequence_number":195} + +event: response.output_text.delta +data: {"type":"response.output_text.delta","content_index":0,"delta":" x","item_id":"msg_0fdb43b6db871f01006ae54bdf513c87d097974366a6747c64","logprobs":[],"obfuscation":"KfJGJuWIsIOU4D","output_index":1,"sequence_number":196} + +event: response.output_text.delta +data: {"type":"response.output_text.delta","content_index":0,"delta":" =","item_id":"msg_0fdb43b6db871f01006ae54bdf513c87d097974366a6747c64","logprobs":[],"obfuscation":"zF1xdjrsfGBG16","output_index":1,"sequence_number":197} + +event: response.output_text.delta +data: {"type":"response.output_text.delta","content_index":0,"delta":" ","item_id":"msg_0fdb43b6db871f01006ae54bdf513c87d097974366a6747c64","logprobs":[],"obfuscation":"60HmEl1m2f9cQH6","output_index":1,"sequence_number":198} + +event: response.output_text.delta +data: {"type":"response.output_text.delta","content_index":0,"delta":"0","item_id":"msg_0fdb43b6db871f01006ae54bdf513c87d097974366a6747c64","logprobs":[],"obfuscation":"tn1LQmuWkyDPSjh","output_index":1,"sequence_number":199} + +event: response.output_text.delta +data: {"type":"response.output_text.delta","content_index":0,"delta":".","item_id":"msg_0fdb43b6db871f01006ae54bdf513c87d097974366a6747c64","logprobs":[],"obfuscation":"Xo5KKnkbZsVSwco","output_index":1,"sequence_number":200} + +event: response.output_text.delta +data: {"type":"response.output_text.delta","content_index":0,"delta":"05","item_id":"msg_0fdb43b6db871f01006ae54bdf513c87d097974366a6747c64","logprobs":[],"obfuscation":"Sqjh2G0l6zs2Ff","output_index":1,"sequence_number":201} + +event: response.output_text.delta +data: {"type":"response.output_text.delta","content_index":0,"delta":".\n\n","item_id":"msg_0fdb43b6db871f01006ae54bdf513c87d097974366a6747c64","logprobs":[],"obfuscation":"BpU1tcvheqMB8","output_index":1,"sequence_number":202} + +event: response.output_text.delta +data: {"type":"response.output_text.delta","content_index":0,"delta":"Final","item_id":"msg_0fdb43b6db871f01006ae54bdf513c87d097974366a6747c64","logprobs":[],"obfuscation":"xkoegalLgVK","output_index":1,"sequence_number":203} + +event: response.output_text.delta +data: {"type":"response.output_text.delta","content_index":0,"delta":" answer","item_id":"msg_0fdb43b6db871f01006ae54bdf513c87d097974366a6747c64","logprobs":[],"obfuscation":"OHoSzjzrF","output_index":1,"sequence_number":204} + +event: response.output_text.delta +data: {"type":"response.output_text.delta","content_index":0,"delta":":","item_id":"msg_0fdb43b6db871f01006ae54bdf513c87d097974366a6747c64","logprobs":[],"obfuscation":"Gu4bMyobVsqkdoq","output_index":1,"sequence_number":205} + +event: response.output_text.delta +data: {"type":"response.output_text.delta","content_index":0,"delta":" The","item_id":"msg_0fdb43b6db871f01006ae54bdf513c87d097974366a6747c64","logprobs":[],"obfuscation":"xOsikAAQeRwE","output_index":1,"sequence_number":206} + +event: response.output_text.delta +data: {"type":"response.output_text.delta","content_index":0,"delta":" ball","item_id":"msg_0fdb43b6db871f01006ae54bdf513c87d097974366a6747c64","logprobs":[],"obfuscation":"11E23X2qakG","output_index":1,"sequence_number":207} + +event: response.output_text.delta +data: {"type":"response.output_text.delta","content_index":0,"delta":" costs","item_id":"msg_0fdb43b6db871f01006ae54bdf513c87d097974366a6747c64","logprobs":[],"obfuscation":"jQdtLWgtw9","output_index":1,"sequence_number":208} + +event: response.output_text.delta +data: {"type":"response.output_text.delta","content_index":0,"delta":" $","item_id":"msg_0fdb43b6db871f01006ae54bdf513c87d097974366a6747c64","logprobs":[],"obfuscation":"R3G5fpFqCjwvix","output_index":1,"sequence_number":209} + +event: response.output_text.delta +data: {"type":"response.output_text.delta","content_index":0,"delta":"0","item_id":"msg_0fdb43b6db871f01006ae54bdf513c87d097974366a6747c64","logprobs":[],"obfuscation":"rPozE7lWBXsIlOS","output_index":1,"sequence_number":210} + +event: response.output_text.delta +data: {"type":"response.output_text.delta","content_index":0,"delta":".","item_id":"msg_0fdb43b6db871f01006ae54bdf513c87d097974366a6747c64","logprobs":[],"obfuscation":"dmyp5nLLgq70Wwl","output_index":1,"sequence_number":211} + +event: response.output_text.delta +data: {"type":"response.output_text.delta","content_index":0,"delta":"05","item_id":"msg_0fdb43b6db871f01006ae54bdf513c87d097974366a6747c64","logprobs":[],"obfuscation":"S0QsIh36ek3zgo","output_index":1,"sequence_number":212} + +event: response.output_text.delta +data: {"type":"response.output_text.delta","content_index":0,"delta":".","item_id":"msg_0fdb43b6db871f01006ae54bdf513c87d097974366a6747c64","logprobs":[],"obfuscation":"nEGYp7ISR4PWaNv","output_index":1,"sequence_number":213} + +event: response.output_text.done +data: {"type":"response.output_text.done","content_index":0,"item_id":"msg_0fdb43b6db871f01006ae54bdf513c87d097974366a6747c64","logprobs":[],"output_index":1,"sequence_number":214,"text":"Let the ball cost x dollars. Then the bat costs x + 1.00 dollars. \nTheir total: x + (x + 1.00) = 1.10, so 2x + 1.00 = 1.10. \nThus 2x = 0.10 and x = 0.05.\n\nFinal answer: The ball costs $0.05."} + +event: response.content_part.done +data: {"type":"response.content_part.done","content_index":0,"item_id":"msg_0fdb43b6db871f01006ae54bdf513c87d097974366a6747c64","output_index":1,"part":{"type":"output_text","annotations":[],"logprobs":[],"text":"Let the ball cost x dollars. Then the bat costs x + 1.00 dollars. \nTheir total: x + (x + 1.00) = 1.10, so 2x + 1.00 = 1.10. \nThus 2x = 0.10 and x = 0.05.\n\nFinal answer: The ball costs $0.05."},"sequence_number":215} + +event: response.output_item.done +data: {"type":"response.output_item.done","item":{"id":"msg_0fdb43b6db871f01006ae54bdf513c87d097974366a6747c64","type":"message","status":"completed","content":[{"type":"output_text","annotations":[],"logprobs":[],"text":"Let the ball cost x dollars. Then the bat costs x + 1.00 dollars. \nTheir total: x + (x + 1.00) = 1.10, so 2x + 1.00 = 1.10. \nThus 2x = 0.10 and x = 0.05.\n\nFinal answer: The ball costs $0.05."}],"role":"assistant"},"output_index":1,"sequence_number":216} + +event: response.completed +data: {"type":"response.completed","response":{"id":"resp_0fdb43b6db871f01006ae54bd8a67c87d08338ee42a336c82b","object":"response","created_at":1793412056,"status":"completed","access_programs":null,"background":false,"completed_at":1793412063,"error":null,"frequency_penalty":0.0,"incomplete_details":null,"instructions":null,"max_output_tokens":null,"max_tool_calls":null,"model":"gpt-5-mini-2025-08-07","moderation":null,"output":[{"id":"rs_0fdb43b6db871f01006ae54bd9c5d887d08a0100ce0c172528","type":"reasoning","content":[],"encrypted_content":"gAAAAABq5Uvfo3xO6qpDl79QbrMSKhDXvuTfwsTb7MVKa1OHWz4uRMDDSKqQS64OCZ0n00M00nhP9v3nGos6KqJryitgbL6lWp5kH1iKa5jbOqt4rKyef-Fyv1jDDWpYSEKB7oO0x-TNQwsMeJQZuTjA1cLdHoBxzbzHyzQs9gWDtdPOenuqL1NkTnLmwcyBUrsPy0SIHZPhEaSZKp8mw6Gm2QMaTARaH95V0659SoG_LgQwYFCcDISPUx8NVbdnv-ftU4OBMmkkUPfvk3NpY-xx4QeohWAiDjzkhloXD6CVnrtd6GJ6OC7zXhhdl4NL0I86-MQn3H2kODNbAXyXlgH-CWx7mGClposdIcaOs9UVEtCUHV7SUYZAC-kDQkV3rKTg40mK0zSqOv7AqUejXvq630eI8xpgj5l5l0KiGSyVbijBU8hiltmBUEtbnr-TPpD2vCp-HYUGIkfBhm5qFWcZ-MKSEBj3UfCq5l9BjADlWPVlgG2XQCWX8KB8aY_PUnt2JjY7UY_WWhmf7-2WjAHI3OXqBQI1GT0ENHzEuu0dyPJ7oXRrXeQCa4TBL3NVlpIp1jVZxiMOr_qC6aHq2RIxH1ODmGd4YYbqzGN5DALv8Z5ON6vI5rRQB11dqCtIuZH6s2eWB7MC5czBl5Mw-IXxFZbhkDVzzylQ1NhdUfoR1vTAmz454wQxCCMcR3lZ44qpmUS6UgpHy9kW3p7nEMW9fPa9M20TQhAV2KLNXx2NLpmgbDW4GRpiM-D9DiQXleaTL0uql0xtM3fWkMjbk09qWA3ZCEZ4QlzczU9Yc9KXsBiYf712p9VWuApvFFkOS7Uz7-2S1QY_2JunD93n1hkYD8OqoxS9IGVfJ9b-dw2WdrBfyRXEe6Hjm8mznAI1mBVRcFB6orYFqnSR-WEI34nYUWXOj-IhfdwLB3unr7JuEJnfDluaWwOWsx2_l83O9Nn6yLsRyIV8Rcy8yTk4Ss5NLMwGhr0XoaGMO2x3MlCPuTati9e1x6LVDPf_0j51riIbQAMsViS7uMmTkN2mIya857JgsGLagloxYGuxk7wd91sOVJSjApfOmbhEkqJSWIIIhpPCsXM1Lc4s098qDghlYJar4Om9ou5Uz-XxsX2zTuBN2NWdcuMtNVjeA5L_JRIX6qbWmqubrLNSjVdJzSvmQTGcYKdWCPucKaR5SK8cNyTk5cS-IEVNK-bXTzp3IdkAZPbEFP_Xp7nFvNId5O-MUF408C0F7F_5XrvqeuBmCjy-xOqDRZAL1CILdKFCWwiLCkyeIdt1DL4dkzM48AzhZX1CLCrZ9ctN42JWtZRPgNgRtz0fxZfXCBle-ihDgqHoRo96IsGQYZuAV5RD9Sgg8F252fsPEwASjs54pkV5NKSNWWClgeTKoL_AZL2bbfPOq5DeSyFVQArvcfGGH_V-xxVnU27gQiLMJx6WRrpkVCCxXmfP-6D0uTgOuSSDTr7IokojY1dAgJbIhKhKrADITMrVx9ZLBFqSDfVhk8Cdfe_UAWkM7NdSSp8o3DlpGbICyDoVOxBmc_ZDH0tHkjwrJDfF0r9VBUgnJYIRF5ZLRsD9jM59GQQm9fVrLImgmkHeDFVMNNMYw8INYYCV4uRoYk_HGrb7SEbqCfivT1izfdXK2BAvJFRNGTgTRbKQ5Tf5foyw6h4uxnWQow2JQJWlCK5N6QebvIAEM_rW8AnUAxxyP5BNbDbeLQ1vcC7gNvT5Sdxp7I6GaRxD40KqDI4pxh1jZxE1nNUu9hmGHNLsb0ZHvm00TxW_Hle3zlBbmKT0ijAQU7dMYua09nCKIDi_a5KKM-t5vt45yRYajGwnj6qpxmNVvX1u-Mo_quk6jQYnEuxxMRhH21-R6QVO-Cgh2AhhYFdQkcNLVR0R_XB0_hyLC34ria2ykIip92rRfjaTlbllPj4RZYq6RGHUSdJL9FFuaCp9BhEBj__-LQqH3JbHtQjH05rHzSFJbzQUgIFa8IMeBB4Xg_5TLVHhFvCRXjB3wnaoGrgaacVt4rBFAxXPvwXf__IpCby1pmJAW9nrd3RoR678GxFqd5_JNd-Ojc3KXH3sM1fvIbzBtsv_EMYwaxu1BhSutUuT5Gw1sZ6sijzsKHZoVtuwzSySldeJojZy31tO0_QmM2zUeKKY1XPZgzwB3bT_bCUOTzdsCA3j6QnlXo41tsPj3Z-h2bGzOrCUv17dRgnijQPoCWY58PoOsDiBzAgAYA5m7HbCDXIoNy9-zQdaKGoL6PV17JBAF65jK-o7AZoP5ygLiXOCK0hLr7XBGHy9IDu5UDQrraTRXdE-lVcXXghNlFo_k7zmQsWoOJotVAkd8Z95vCQBmB63AIE1Sr9X5FFwoW9BR_PFIHotCFyMEPX2CJbF-KiHdvfm5eS7OPKhjcxDXm4gvRObNADcTFgnwDSU3E2ET82Q8tZzfrGGXpqPFjR-bneaGGFgJQSTdE2PsXy1qMij1lT2k8MK6EjWUfryF6cWeBnYECiok8bDMSq8BvMiaHtoUHg0TokwqyTOO4ABzMYCbivceDEUT7FXIwMnq461KQSb-36XJ_5kux92_P99tvrlJCyMusx_X31wjdPwRlOeGYQdg1y1sYHNtETSV3PrkKjcLjaAAytl0v_p1s2qJrnbsb_PchQPQp3uh8quw9lM2ScL7rqYmkwQBEVtc3AXY66LOKKYwEqAh0-qjMhQIcWcRx_UWAwlNv4ODBSYPyFoN9QxUM63NcMpFZGbfuQCmKDaDGomfTSh10kmx3EMuMSuBq33bKhsSKfjqT1KYFUrj8qMlJGhGrLxJIeYZNxjuK3CF1EJnvs9Kbh5O4QMUzUSXHyPhmZaJp5-I3GHrO_aZ1xzWO7ar6zJeDyqu3NUPYdDI1S-d1zjZeUJUKiv04ZYLgqmOHiMvcESo3SOBEeM-QYxa4gwVHyP4X5EJ-Dlrzl5Cfz-a0uRUisRGVZurYNxsvmn2J1MXA7DiVUqm2zFcmJec04enlfje20Ss9EFEMB5R9B9Kb0UHPzpdwI1b9BqpcEkHxiN0kTv1d9yBCRdELRW3usgNVicVgUpcmJJvw2JVwMTW86UNDEyIpb3DvhBze8C__l56byBsX1fp7Bmid8r8V1KiaJ1-LyXH9y0Jv8_ZpSgGwGjqY1TlVxwQgMROPslJ3n6bIV3eBKbmqLvbMkMOk7jDcfZKJLw6MMFiylUyQkBad7W-W76n3ZebfylOQawXVJJ7YO7cgAJ-ifGxxugEtdWzKYDHlL8YPmOeO5AZJqN1F0NA-c4tpXhZtmfH1CCkfPB5XBdaWyDqXCKMQpwplfl5USf--aTlBRN_JPUGqXoAEg89OGF6DediEAl-ZZzv1hPfu7Y6OViSF5bV9DXQ-yogCg36XbcTXp68j4pWWB3SzXa6w8cWzPJby2a3e7e7EkxK5pt1kzG5411We4dkZj-jGtO349zLuGOS_LOJFzcthAOjL1DC2B4eZl0BRd4mp1-Kqg_mfJ805JejNpTXWFRuP2OVGEcP8WAzpuQ4O4V1PXAzYw1lrJRknW_X8Kyk2dsXyI9gBAVes2qXiI5sVEafV8u9fmiMi2CFrFyNi3VIpi9VQfJesrciEe_00R-3BinS65UVlDj47NMvpv9ZzLpWxqy0Y8qj7_85DIMzX0oyHBDmO52WaY9BIJr4BjG2HEHVXRV3T3dfe6_v8DVnRRHwirc7aeLEHZTFHxK7KZJ6P08ojfMhGX9jK7BZ6GkELIHFDlYjVl2t5NbjFU4mQn-f9DgmI2GmVFVOK8_pr5kQ3P3pCaFfaLjG3cRNkAswz2aFBL9ztwX0aJhFQJSFqog06kQYFVr1d3zG2rlwLQ1AOAy1bow5tFZUe6qxJmJymkkpnSJQit6yaJ9eTFCMuuT0xbAFjgp42Ka2acGcCa1cd1HcNAGkKDTbbMU_HLtmkYSLhcPXObE6wHJNSoaXM35Ko4-34F4nTTiSaj_ESA6X8wrfunFwbPisEHYdlwXQiSByDhqoqeXW4hJZlODj5Jek2w_hJRQY1qFxeZcFnEOUMY2DAhFQrM6Jbrzgzs6FyxvsXTQ5rOCR2u-mshA9P1mwAdv8-XNGXVC2Pa82Jz89jJ8Q-CQS2efnugDNyo2rQr8JX0TDW_K4h5kGeyBcbmoB3Ox2PSzSkLwC9lTzsxntKdYcG02xudkkpsZvidzHsdVTivTdgUwGUb9GILBDK1Rpv7-mmbMFgAfl-vsok9J700XHxPBjUSXRMvwS_O4j_uZqiF7K-bOa6Q6oj7O5vr5EDQ=","summary":[{"type":"summary_text","text":"**Explaining the puzzle**\n\nAlright, I'm working through this classic puzzle. I need to show my reasoning clearly before giving the final answer. If I let the ball’s cost be x, then the bat is x + $1.00. Setting up the equation x + (x + 1.00) = 1.10 leads me to find x as $0.05. Many might mistakenly say the ball costs $0.10 because it seems intuitive, but if that were true, the bat would be $1.10, totaling $1.20—clearly wrong! So, the ball is $0.05."}]},{"id":"msg_0fdb43b6db871f01006ae54bdf513c87d097974366a6747c64","type":"message","status":"completed","content":[{"type":"output_text","annotations":[],"logprobs":[],"text":"Let the ball cost x dollars. Then the bat costs x + 1.00 dollars. \nTheir total: x + (x + 1.00) = 1.10, so 2x + 1.00 = 1.10. \nThus 2x = 0.10 and x = 0.05.\n\nFinal answer: The ball costs $0.05."}],"role":"assistant"}],"parallel_tool_calls":true,"presence_penalty":0.0,"previous_response_id":null,"prompt_cache_key":null,"prompt_cache_retention":"in_memory","reasoning":{"context":"current_turn","effort":"medium","mode":"standard","summary":"detailed"},"safety_identifier":null,"service_tier":"default","store":true,"temperature":1.0,"text":{"format":{"type":"text"},"verbosity":"medium"},"tool_choice":"auto","tool_usage":{"image_gen":{"input_tokens":0,"input_tokens_details":{"image_tokens":0,"text_tokens":0},"output_tokens":0,"output_tokens_details":{"image_tokens":0,"text_tokens":0},"total_tokens":0},"web_search":{"num_requests":0}},"tools":[],"top_logprobs":0,"top_p":1.0,"truncation":"disabled","usage":{"input_tokens":45,"input_tokens_details":{"cache_write_tokens":0,"cached_tokens":0},"output_tokens":359,"output_tokens_details":{"reasoning_tokens":256},"total_tokens":404},"user":null,"metadata":{}},"sequence_number":217} + diff --git a/packages/inference-discovery-openai/sessions/openai-responses/gpt-5-mini/reasoning-content-streaming/session.json b/packages/inference-discovery-openai/sessions/openai-responses/gpt-5-mini/reasoning-content-streaming/session.json new file mode 100644 index 000000000..0f42c9db2 --- /dev/null +++ b/packages/inference-discovery-openai/sessions/openai-responses/gpt-5-mini/reasoning-content-streaming/session.json @@ -0,0 +1,11 @@ +{ + "schemaVersion": "2", + "source": { + "provider": "openai-responses", + "model": "gpt-5-mini", + "baseURL": "https://api.openai.com/v1" + }, + "origin": "live", + "capturedAt": "2026-10-31T02:01:03.782Z", + "capability": "reasoning-content-streaming" +} diff --git a/packages/inference-discovery-openai/sessions/openai-responses/gpt-5-mini/reasoning-content/exchanges/0/request-headers.json b/packages/inference-discovery-openai/sessions/openai-responses/gpt-5-mini/reasoning-content/exchanges/0/request-headers.json new file mode 100644 index 000000000..28c14bb85 --- /dev/null +++ b/packages/inference-discovery-openai/sessions/openai-responses/gpt-5-mini/reasoning-content/exchanges/0/request-headers.json @@ -0,0 +1,4 @@ +{ + "Content-Type": "application/json", + "Authorization": "" +} diff --git a/packages/inference-discovery-openai/sessions/openai-responses/gpt-5-mini/reasoning-content/exchanges/0/request.json b/packages/inference-discovery-openai/sessions/openai-responses/gpt-5-mini/reasoning-content/exchanges/0/request.json new file mode 100644 index 000000000..e827b21b8 --- /dev/null +++ b/packages/inference-discovery-openai/sessions/openai-responses/gpt-5-mini/reasoning-content/exchanges/0/request.json @@ -0,0 +1,14 @@ +{ + "model": "gpt-5-mini", + "input": [ + { + "type": "message", + "role": "user", + "content": "A bat and a ball cost $1.10 together. The bat costs $1.00 more than the ball. How much does the ball cost? Show your reasoning before the final answer." + } + ], + "reasoning": { + "effort": "medium", + "summary": "detailed" + } +} diff --git a/packages/inference-discovery-openai/sessions/openai-responses/gpt-5-mini/reasoning-content/exchanges/0/response-headers.json b/packages/inference-discovery-openai/sessions/openai-responses/gpt-5-mini/reasoning-content/exchanges/0/response-headers.json new file mode 100644 index 000000000..10c978168 --- /dev/null +++ b/packages/inference-discovery-openai/sessions/openai-responses/gpt-5-mini/reasoning-content/exchanges/0/response-headers.json @@ -0,0 +1,26 @@ +{ + "access-control-expose-headers": "X-Request-ID, Server-Timing-Total, CF-Ray, CF-Ray", + "alt-svc": "h3=\":443\"; ma=86400", + "cf-cache-status": "DYNAMIC", + "cf-ray": "a52f1183ab856a29-LAX", + "connection": "keep-alive", + "content-encoding": "br", + "content-type": "application/json", + "date": "Sat, 31 Oct 2026 02:00:56 GMT", + "openai-organization": "", + "openai-processing-ms": "5747", + "openai-project": "", + "openai-version": "2020-10-01", + "server": "cloudflare", + "strict-transport-security": "max-age=31536000; includeSubDomains; preload", + "transfer-encoding": "chunked", + "x-content-type-options": "nosniff", + "x-ratelimit-limit-requests": "5000", + "x-ratelimit-limit-tokens": "2000000", + "x-ratelimit-remaining-requests": "4999", + "x-ratelimit-remaining-tokens": "1999899", + "x-ratelimit-reset-requests": "12ms", + "x-ratelimit-reset-tokens": "3ms", + "x-request-id": "", + "set-cookie": "" +} diff --git a/packages/inference-discovery-openai/sessions/openai-responses/gpt-5-mini/reasoning-content/exchanges/0/response.json b/packages/inference-discovery-openai/sessions/openai-responses/gpt-5-mini/reasoning-content/exchanges/0/response.json new file mode 100644 index 000000000..81e04eb26 --- /dev/null +++ b/packages/inference-discovery-openai/sessions/openai-responses/gpt-5-mini/reasoning-content/exchanges/0/response.json @@ -0,0 +1,106 @@ +{ + "id": "resp_003202f94aa67c2c006ae54bd2be7887d0b57cc7727e8a35e5", + "object": "response", + "created_at": 1793412050, + "status": "completed", + "access_programs": null, + "background": false, + "billing": { + "payer": "developer" + }, + "completed_at": 1793412056, + "error": null, + "frequency_penalty": 0.0, + "incomplete_details": null, + "instructions": null, + "max_output_tokens": null, + "max_tool_calls": null, + "model": "gpt-5-mini-2025-08-07", + "moderation": null, + "output": [ + { + "id": "rs_003202f94aa67c2c006ae54bd3192c87d0b2a531a66d21033a", + "type": "reasoning", + "content": [], + "encrypted_content": "gAAAAABq5UvYt3Dt7EqbBRxTU0fh5mShdUSbUP12FGVLkEhrXRcb1F1PFHPoMjRp6ctoaHz21nqaMhhfUHebKOEtGs9fMV9VQ48iue1-BA614qihiAk6tFrOvAtz2qnH6x4MJcuSTk-26UK3j17qwtIoZLW3svxPSn5Xdu8Ba5Cr1fujQhwUIP4xas-p74Ek5prQ-ivcGoz5-rv3DicpmftTm3XUSC02i70Zjfk9FQD9aUQOTuTp7khzBXbdItcD6iafHn5MLSTq2SDbiwUiah29VR7iSogPzZCVrmF8vysI2OnoKRDCDaTWK5YMmO2YJM7x161MKE3QgOvds2-IqK5S0p-cw7M8UPmXmbHzr_JXZl8cw7puCqQzClsx1qoc_9LbOakr55QcjfpckjLHf_wsNTBRLrxsSsVnpKeBTC9ZFZYxuovbtxmEk4b_f87Hmzlh2nyRkr7wKaraXcFewzasG-JvErVBr2p2cjyLEwQJxN6CaAlTaAvcmF-sIdAWyBT-aAGBpfkvDxJorNIo9NlJk64LOvUxsbemZQR3atXYM_ehIoqB4DBPnUUXuSUjR4c1NXLaG8G0oDhvuqpeKlbQPkCBql78VDMHYGeGVd4kut7NlU_2X2pM2isuvc2XR_C7LOQjkGJPaCP-j7Zuv5_VvzkPjMAI0yNXH2v0S1JugdiO7vIXuFVthVLHyWiqWcIk13o9fYP58zXUGdhq4i30tAzIo8Z-KvZ9Vjqof48niNP9H3kvLk1infgFxrsXYpZxPVED5_gBsi2a_WBnaoU5nPhsuPnvkVpAS-kSHATb0bKdkIBDy7bkvghxbXQmpvFlH_f6aNhB5NDvopGaBjUh3tN6gLmqsV80u1aoVFIDu-QrhpHLdzwv61cZZZDT4t3iyD2vAe4qotLBZW_Nmbj6w7cQIVwMQDZ22L8KB5eZaId7wHIJHzPCm7r6GTsxP67hI7DzKL63cDsQItQMy1KlesKexXKw793MkQvDMiig_jJhgs1oolZgo7TzG0fouc1H0sM_M9m2O6ifgI8aPGk-T9AjbIi3GgeXDq9_-LTIF8xjtLY_W9Va21x25V0L3g_Bn6Zqr3QpIBPoi_iplKy-SugWHzuCpGtuJenPF37bRa--JvivShGvT778UrNZtZ1I0q69BO_dEj6SX9w2NRoWBcD6oCHNLMl8_Z1hflzXKldqxMo5eULVNvhs5gS1tmQN9pgJiHz0xUyy8tMvGnVfzvhfTu7L-bfH5dN7BAQQVg218HN8RL98d9ky5rchUe-fGozyCnXf5_75cShQ_aIEhvucv1hRqPFy0gni7U3zmaOgsuxwz4YhYGLGw3AHVjRocd82pmA5N0L8gdhb0iXaDfWkGG7fvDOgBVACzRB9wo45DQOYsuUPO2LtTBDk6XvDPg83cK8sP9w4vyFWN9uEJA33Uuz9jDJwf3EIIIEAizUjJBgbVAdu4Q3NJ1aG2umtDA24K-ERxh-pvfGT4jI4S8XmdOySR11fNKTGSVdYOs5Yq1ezSgqypENqQ2swbel8FW63SHw9ngEoRWuCDeeU6iqwNT_aiW5FNj0zyYQtszcIE25EcaASx_sp1uGMkmZ1Q-Q_-bymK72uUmdGXBhbci_KBnZk2wO9s62gteafVy9Mz7WjU4SIUeDLsQiD_EiKGsVq44DYGsJ7dOQYkvoC4jVXtjs9ocq98n8Gx219KfYSbMIt5eBKWuImTiv87uP-w0n4l_C-hgpSPtosWTQGzm7UUDLgYRPVKjRmgsXmVfa9NSxE94MS1mFEox_-a0zT-s90KnIreXCAG5iPqzzD48-akEmmNHbP3gN0r4PzOyPUER9lRbU7rV9v4in0_nwaxMGfeRXZluHv-33cLVRRrULguXy3DoEqcx4A39O1M_t8EGs9qPpGzOn8YOVqJ1pzrPbgYerWB5sGUBb0H728DWXtWmrkqH3DQjrDkKhG3EZ-a573hOrYQBQLdhslcZB5XjeKIjQSwvb9bkP7xJBcEBZhiIRkiujf4WaaTqr7gqCjAlfxyMkr_UYqL6EjfEmYmREdkV4qSNmwzjZWLPcAIXrcuVtUdwB-stlKno7inr1H7GOPsPYb46qDdIEyepreMbDOeVStx5nZUCNA_9k0zC0w82xv7EIi-vbWvldTzLrJdMQt2RCsYscyWI3H6T9Bv4KwB0KsxyjeLykd22iPgo9W1mIMpkrzdHd8LqzFDT_xTMW7WEhrC9J3aFPFrkuaXk-TqfpCviLX3OUSBtu0y2BFtOqzAuvQygFkp8Nq_1WM6cPkqWzkZ49QMHlvr6NwgIaNwBX5AVWJotzyUGfnckPq3rxxYBlUpnU8C0XtYiwjjQxqcAlR0kvTbb2ip2qYVf3U_UK2tYYT5ZqJDPkcuSFnSSt65wYikviwKCB4S4RRhCbxDWno5muEgFPMacpVNhjMmOX-yHY_kV6shj7fpt5-zK3UubaL8Kzm_aKX-lDXmj2wWORxUeaGkxVRZ6cpEknyT01dNPlQbp6Ou97DqlBK1D82yyLZy6xkewpjJBWUEH-qZ7um8GDNpqz1Sg3yhKDfHDnaSEIm860LLmmH2v43jRpYxowrqyOpw5dRAZAHMYAhWTOUFv1H0HPHsQ6RHeMYagqhGu5fkiXWtcMxWSTEEIP07sY75m4RI1KuIAqL-XOaACKjkAos2acUR1GnB4l6bcSOOX9C6uLC31G4-isBpTGDvncbY4WShrtlEvoet9Iq_yl2BM7HlvfBSLagg2BdpXG6Xw0hlovhVD9FB5TY2tbfnjtEJhlCMpn9paHoe4_-WvAsZS4Qm--81gtGeZxdNisorh_yCHOUJONuIKABQVJrKESrXjVFkhXnZMcqTMHkREDJ1ibO6xAj1K_60espH9DncQ3gdLAga0fOkm8vr6MNn0687llJ6qpMoHvhuEf6BQP5DU_pMCQJ62YvLmaQMWY8qSnVW9KiFjEMRl2KGVdQy-IQcmp95MDmwrTBXa6b0LmuRlPselxH3NSvpheDFr-RuF_6iBF7yOTiZrm5U96ZDCUqWrvYnbTOwurDzvPKK7DCVwR2eK6hnrtIhjlW3C5LfWTF-Af07WnFqeTOEfoQrHHlD1iO4XpHu0P98WtanegPptHsXEKqJk4NoKHgWW7-2USrhEdHGup1snBuVGyUxgd27_jQPop3tZd77AmI5MqSHb4Ouvp-bAvYTRN1wgQSGauJPuxFSCoaAx10xXJePWzTf05NkePsiXg6wj6sKONJ_YyC1q0Gc9Q3svYhEy08Wn7sr-G-ZbXr899qN7PZqdGWTpxxEZ7mju7R76rP-WMx336pGXh7XN3a_BhioFQjACF2xP5tpBtbWuC2hZeaZZs5F4HqaZUDvanuPTEplUT76XfXhJliApbjkmqDffgxGeLnQnpcou7MHfAW1HpufvzADbjqWAzQj3E9SJ02-kAe24KLg5fpZYYDhedgCMmy_TBD1juXrXQB2kSz3_MByn-Mhy9qKhD5UDcWfULYtQoZ7b0LWYHSN5d4W-kVItRAWFwhRTkoEamM-a-5JEWRz2KG952_ulNuudCLdfB8vvActyMXAH7YJICQOivllzGWO8XUz0bguA-ZZEi9WvdnWnr22EOfbg63lz-pNhXunIlNVFknfoLUKVzZ7CAMPkJS4ONc3I19XIeDxdUCxI-xUu0N_miWpwrEC6pG04soiC1z2sOw8qd2AI2VW0tJrehSmWJekwT0j4J3E8YPLemwVeOCpivR-BGwyrbAkhR_FYUARJ96CPJuPZ7M3UyQROEP20lVXZbrcH3AhR4Xfrip8B9tMjrbk9zxZt7qqtqW83hBKoVrByIiKl-TbPufokIliXzeZUb9ufh3jiqVaLerRd8-OOO-hwNfR4o3UA7J4EuLAHX_uQOofcadeH7xFfStaWAtOhJSW5JqshHnJDFALbIYhWDpGDmJdhLFXThDtBW8ho22tWi674uYFt6pXrMVcy6HBfYKH1IP_GVMgzTqMQ==", + "summary": [ + { + "type": "summary_text", + "text": "**Explaining the cognitive reflection test**\n\nI'm working through the classic cognitive reflection test. First, I define variables: let the ball be x and the bat be x + $1.00. So, the equation is x + (x + 1) = $1.10. Solving it leads to: 2x + 1 = 1.10, then 2x = 0.10, giving x = $0.05. I might also mention the common intuitive trap of thinking it's $0.10, but I\u2019ll stick to showing my reasoning and then conclude with my final answer: $0.05." + } + ] + }, + { + "id": "msg_003202f94aa67c2c006ae54bd8176c87d08c7fbcf0cd694146", + "type": "message", + "status": "completed", + "content": [ + { + "type": "output_text", + "annotations": [], + "logprobs": [], + "text": "Let the ball cost x dollars. Then the bat costs x + 1.00 dollars. \nTogether: x + (x + 1.00) = 1.10. \nSo 2x + 1.00 = 1.10 \u2192 2x = 0.10 \u2192 x = 0.05.\n\nFinal answer: The ball costs $0.05 (5 cents)." + } + ], + "role": "assistant" + } + ], + "parallel_tool_calls": true, + "presence_penalty": 0.0, + "previous_response_id": null, + "prompt_cache_key": null, + "prompt_cache_retention": "in_memory", + "reasoning": { + "context": "current_turn", + "effort": "medium", + "mode": "standard", + "summary": "detailed" + }, + "safety_identifier": null, + "service_tier": "default", + "store": true, + "temperature": 1.0, + "text": { + "format": { + "type": "text" + }, + "verbosity": "medium" + }, + "tool_choice": "auto", + "tool_usage": { + "image_gen": { + "input_tokens": 0, + "input_tokens_details": { + "image_tokens": 0, + "text_tokens": 0 + }, + "output_tokens": 0, + "output_tokens_details": { + "image_tokens": 0, + "text_tokens": 0 + }, + "total_tokens": 0 + }, + "web_search": { + "num_requests": 0 + } + }, + "tools": [], + "top_logprobs": 0, + "top_p": 1.0, + "truncation": "disabled", + "usage": { + "input_tokens": 45, + "input_tokens_details": { + "cache_write_tokens": 0, + "cached_tokens": 0 + }, + "output_tokens": 318, + "output_tokens_details": { + "reasoning_tokens": 192 + }, + "total_tokens": 363 + }, + "user": null, + "metadata": {} +} \ No newline at end of file diff --git a/packages/inference-discovery-openai/sessions/openai-responses/gpt-5-mini/reasoning-content/session.json b/packages/inference-discovery-openai/sessions/openai-responses/gpt-5-mini/reasoning-content/session.json new file mode 100644 index 000000000..09c237b6e --- /dev/null +++ b/packages/inference-discovery-openai/sessions/openai-responses/gpt-5-mini/reasoning-content/session.json @@ -0,0 +1,11 @@ +{ + "schemaVersion": "2", + "source": { + "provider": "openai-responses", + "model": "gpt-5-mini", + "baseURL": "https://api.openai.com/v1" + }, + "origin": "live", + "capturedAt": "2026-10-31T02:00:56.505Z", + "capability": "reasoning-content" +} diff --git a/packages/inference-discovery-openai/sessions/openai-responses/gpt-5-mini/vision-input/exchanges/0/request-headers.json b/packages/inference-discovery-openai/sessions/openai-responses/gpt-5-mini/vision-input/exchanges/0/request-headers.json new file mode 100644 index 000000000..28c14bb85 --- /dev/null +++ b/packages/inference-discovery-openai/sessions/openai-responses/gpt-5-mini/vision-input/exchanges/0/request-headers.json @@ -0,0 +1,4 @@ +{ + "Content-Type": "application/json", + "Authorization": "" +} diff --git a/packages/inference-discovery-openai/sessions/openai-responses/gpt-5-mini/vision-input/exchanges/0/request.json b/packages/inference-discovery-openai/sessions/openai-responses/gpt-5-mini/vision-input/exchanges/0/request.json new file mode 100644 index 000000000..35ed76fc7 --- /dev/null +++ b/packages/inference-discovery-openai/sessions/openai-responses/gpt-5-mini/vision-input/exchanges/0/request.json @@ -0,0 +1,19 @@ +{ + "model": "gpt-5-mini", + "input": [ + { + "type": "message", + "role": "user", + "content": [ + { + "type": "input_text", + "text": "Describe the attached image in one short sentence." + }, + { + "type": "input_image", + "image_url": "data:image/jpeg;base64,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" + } + ] + } + ] +} diff --git a/packages/inference-discovery-openai/sessions/openai-responses/gpt-5-mini/vision-input/exchanges/0/response-headers.json b/packages/inference-discovery-openai/sessions/openai-responses/gpt-5-mini/vision-input/exchanges/0/response-headers.json new file mode 100644 index 000000000..e7acc24a8 --- /dev/null +++ b/packages/inference-discovery-openai/sessions/openai-responses/gpt-5-mini/vision-input/exchanges/0/response-headers.json @@ -0,0 +1,29 @@ +{ + "access-control-expose-headers": "X-Request-ID, Server-Timing-Total, CF-Ray, CF-Ray", + "alt-svc": "h3=\":443\"; ma=86400", + "cf-cache-status": "DYNAMIC", + "cf-ray": "a5280fa928e95730-LAX", + "connection": "keep-alive", + "content-encoding": "br", + "content-type": "application/json", + "date": "Fri, 30 Oct 2026 05:36:16 GMT", + "openai-organization": "", + "openai-processing-ms": "2527", + "openai-project": "", + "openai-version": "2020-10-01", + "server": "cloudflare", + "strict-transport-security": "max-age=31536000; includeSubDomains; preload", + "transfer-encoding": "chunked", + "x-content-type-options": "nosniff", + "x-ratelimit-limit-input-images": "50000", + "x-ratelimit-limit-requests": "5000", + "x-ratelimit-limit-tokens": "2000000", + "x-ratelimit-remaining-input-images": "49999", + "x-ratelimit-remaining-requests": "4999", + "x-ratelimit-remaining-tokens": "2000000", + "x-ratelimit-reset-input-images": "1ms", + "x-ratelimit-reset-requests": "12ms", + "x-ratelimit-reset-tokens": "0s", + "x-request-id": "", + "set-cookie": "" +} diff --git a/packages/inference-discovery-openai/sessions/openai-responses/gpt-5-mini/vision-input/exchanges/0/response.json b/packages/inference-discovery-openai/sessions/openai-responses/gpt-5-mini/vision-input/exchanges/0/response.json new file mode 100644 index 000000000..751f288e0 --- /dev/null +++ b/packages/inference-discovery-openai/sessions/openai-responses/gpt-5-mini/vision-input/exchanges/0/response.json @@ -0,0 +1,101 @@ +{ + "id": "resp_0c453493ebf05b5a006ae42cce692887d08e4569fb86824905", + "object": "response", + "created_at": 1793338574, + "status": "completed", + "access_programs": null, + "background": false, + "billing": { + "payer": "developer" + }, + "completed_at": 1793338576, + "error": null, + "frequency_penalty": 0.0, + "incomplete_details": null, + "instructions": null, + "max_output_tokens": null, + "max_tool_calls": null, + "model": "gpt-5-mini-2025-08-07", + "moderation": null, + "output": [ + { + "id": "rs_0c453493ebf05b5a006ae42ccf87a487d0b178d3191413d055", + "type": "reasoning", + "content": [], + "encrypted_content": "gAAAAABq5CzQ3LByndBrOA3oCiiq03cEiM7J-Kaw54-FkIVGQbnIe9dK328142vJRRHHtxmHJIxlwgNsL0Q7RgT8ivzv9zdMTHsegR1XER7HMmTVO6X0J-ZoYnKSnpuVrwv5dCHEBsBKryJh2LAXKexsOb5YPRBbeC6vbgshZrRw6HqdjYiZ4YCwQhVf4xPKPNLiUItrtxR46V5c1IF-WiSEMJlUyLx_KteOqou5qr8CbpJo7mCo3hx5wCnDk7HN-GzIO3DYCXuj1dJFcWDDtjS4P7EWVZK0_gnTto_Ri9KKZKImmBRwruOPGPmHTS53rdwfIMR4E2hBcE_sqoHcv8ulmkOMvvXesPth3ifZX8SV8FYrx3PMMWps_Hc37gD7Bxm8bMGQ_BnfMATjZOHaWoyfl4UEF6NO1gefEm1hlspe-PrwqI9MVNo3g0gdA4E-fLIXaBCMg77YL_PwkzYF-5RchGD58P3ZVfYj_GOGMRLJTrAwT4cc6jjtaChUaFRrMyjmZ475hJDZrqDDSxvpqKvVcNKNPGD0j2sS6u3ltmF3uKfiMyzBKQHpWjFAuuKNGyEytlh6tYZs9CCYpEsGU1olp19MSKRBeR5ZllTpo564tZfW44zsTsY3Tnzc0tly2UmwKINDZNbzfBk56r7pmI6M4yb3r16ii1h3vBHDWR_xYi_hDNUCUUuz1mEKezPmSv9bNjxW0zWm2XQENgg6ZWeXOzyjHl4VTbEhDfYWz_F5vE08i5t6-geYMIUxivTRqolpzxXNckq3YuZHea_KWy1zZ1TPoRx9E5tyNtXj0BWuMqQHlvT6uoJRiMqyA-YASIwDbZx9c39Tm16BxywzBwGVLUTW4t3osjlXj02jrpsQUzL1OcxYCIR8Q1VhN8o3yEMFDFwRMSD9WuHQASf10s5nt7CfnJBMQQG8OY9K8J_Q32MjCI_p8VutDWy08F_huW7smbCLa56uanStmC3BpRGFrRhbrzYKMkTiXcr678N21DahDeEFXU9qhwao7obx9dpOG_dwZobSxS3AP3wjldqhUxSGP1e0r2j0lq4zJnz-zXf9mSF8vVY3pAkjpKWZyvqkYqf-ebfz8XcgHesExQq_D67yJEd59JohE10myH_DCygCpYUl53frU_g9QR9D-lqPn-rHdFiUFcj4JiIQm09soeuA4yOWT2HfJZS0-gzB9ZaUCOTvylVe5vCmnNmwdrXyOUTtsCZAlzNVKlRZH-r-It-VJ5AveR9VtBRItGXO3Pyfif1Yr280txbgfO5U-6SUyyxYwhqi_u43PVbiRGE2jUZIzbgF-JRN8iGbs1JUqFtwGM3px9x_bESvy5d6pZAkYiZeb0t_TN5BnIIv5Ej6aEVqNuyDXJ-DWXxHk53ATznZeabqwq1z_FeLqyQkeFFjhUeOnooSnr5-ITJn0v5uiTVQc8rLNaVKz-H2FNm9Kl6InPh8q2EMdh1e6cs5WAZglzS388ut3cgV56b-IX7LDM1NKgC65se1z8whmKsSNEbU3ZmDtGwFV-86tVIaPfGlVrArvPNJgICIuUN8fGHkyY3L93EeVvxr7XbhyG-I2xhCqFBXZonBKNk7HdzfL7sw25avmDTCoLihzXl5llCzioQnJSFMT1xPl_ByqfyNRDYI5UcZPnpyGKKtWjv6iw7kzsyvABiBlIOaB6dCJagkCBpRhkq52gYCwaxsDY8RWAbi3pAouuRRzz5kq4y01S6PbS2XdR8KGF0usCV3GYkqZDMdmaHJopegLONRMGdxIL12YmYPtheXRpfu5ohQnOqhRQbs1iNz-vUFxeqLhu4hBoPHDXWQXQzHDdzspt9CcGRzP4M2xqtQkLuYpRRCJzJFuTasDtAM_csHAC_NiE13K7JoC1bX8lEqtpPeINqRvJ23k-xsIRULPdcl5gmfyK7ZWQczNo8c4SktWgDP5wRUaRhWadS3MrwZ1UpEVGorapKW62qdLzc9fvZBcABiwk6mmlx4r1Dgj0emPtRKJeKSS5OofsGEqHlLvHbPbE2xpVKO2B_Y6qOqsUPBDLEbbud-IHIKQ3jaYTZrFKVOLKdrbZPsbHGxFRuaFhHHq5zG-LgOIEZIQ_LEnH6ZwLRP1X0baxIObm5mEdjx1EGN_SotvOKcB5zOX0rH41I3rSaQnGC3m1KJ9rx7hgRa5AYlgTsHRGHOzOdEwZSOE_iBEkkAi94qk65hv73_iNtL0mwX3Y3XP2gZ3ci5VG8C_5_I8-cBDCnV1iQoVRd0eIY5yneuXva7UAqw6THaP9tK0ZVvUsoO4Wtlds7UxSJZTCVHmHPArXeZefP47gu5QP4i01Y3tPs58pjx_xmQ0fQbe3hV5VznsQmfsStXcQozjyRkneF3IJxw7sUMl7CKAwCED-yNqPpaoZEMRyq24mdRYX0-gqZkeWQvc0M-yiPSt9MnKPC_CY2YiFFTOPIlKtgfnO8BUY8WUhq8WlrW1ONq7h9w5tzs6M54_Ks-TgUnH-ue-praXEEY1w61giohDl4eN7DTRFJKourtWcXBbMZEhTxgHdL4NVQBrpC-Zn5BkOTJXofTCYmeIrXP", + "summary": [] + }, + { + "id": "msg_0c453493ebf05b5a006ae42cd05b5487d095ca78bb37d2728b", + "type": "message", + "status": "completed", + "content": [ + { + "type": "output_text", + "annotations": [], + "logprobs": [], + "text": "Side-by-side spherical maps labeled \"Albedo\" and \"Water Signature\" showing vertical data stripes, with a blue arrow marking a water signal on the right." + } + ], + "role": "assistant" + } + ], + "parallel_tool_calls": true, + "presence_penalty": 0.0, + "previous_response_id": null, + "prompt_cache_key": null, + "prompt_cache_retention": "in_memory", + "reasoning": { + "context": "current_turn", + "effort": "medium", + "mode": "standard", + "summary": null + }, + "safety_identifier": null, + "service_tier": "default", + "store": true, + "temperature": 1.0, + "text": { + "format": { + "type": "text" + }, + "verbosity": "medium" + }, + "tool_choice": "auto", + "tool_usage": { + "image_gen": { + "input_tokens": 0, + "input_tokens_details": { + "image_tokens": 0, + "text_tokens": 0 + }, + "output_tokens": 0, + "output_tokens_details": { + "image_tokens": 0, + "text_tokens": 0 + }, + "total_tokens": 0 + }, + "web_search": { + "num_requests": 0 + } + }, + "tools": [], + "top_logprobs": 0, + "top_p": 1.0, + "truncation": "disabled", + "usage": { + "input_tokens": 246, + "input_tokens_details": { + "cache_write_tokens": 0, + "cached_tokens": 0 + }, + "output_tokens": 115, + "output_tokens_details": { + "reasoning_tokens": 64 + }, + "total_tokens": 361 + }, + "user": null, + "metadata": {} +} \ No newline at end of file diff --git a/packages/inference-discovery-openai/sessions/openai-responses/gpt-5-mini/vision-input/session.json b/packages/inference-discovery-openai/sessions/openai-responses/gpt-5-mini/vision-input/session.json new file mode 100644 index 000000000..7202b1d0e --- /dev/null +++ b/packages/inference-discovery-openai/sessions/openai-responses/gpt-5-mini/vision-input/session.json @@ -0,0 +1,11 @@ +{ + "schemaVersion": "2", + "source": { + "provider": "openai-responses", + "model": "gpt-5-mini", + "baseURL": "https://api.openai.com/v1" + }, + "origin": "live", + "capturedAt": "2026-10-30T05:36:16.941Z", + "capability": "vision-input" +} diff --git a/packages/inference-discovery-openai/sessions/openai-responses/gpt-5.5/function-calling-multi-turn/dispatches/0-get_weather.json b/packages/inference-discovery-openai/sessions/openai-responses/gpt-5.5/function-calling-multi-turn/dispatches/0-get_weather.json new file mode 100644 index 000000000..21f38181b --- /dev/null +++ b/packages/inference-discovery-openai/sessions/openai-responses/gpt-5.5/function-calling-multi-turn/dispatches/0-get_weather.json @@ -0,0 +1,6 @@ +{ + "args": { + "location": "Boston, MA" + }, + "result": "{\"location\":\"Boston, MA\",\"temperatureF\":68,\"conditions\":\"clear\"}" +} diff --git a/packages/inference-discovery-openai/sessions/openai-responses/gpt-5.5/function-calling-multi-turn/exchanges/0/request-headers.json b/packages/inference-discovery-openai/sessions/openai-responses/gpt-5.5/function-calling-multi-turn/exchanges/0/request-headers.json new file mode 100644 index 000000000..28c14bb85 --- /dev/null +++ b/packages/inference-discovery-openai/sessions/openai-responses/gpt-5.5/function-calling-multi-turn/exchanges/0/request-headers.json @@ -0,0 +1,4 @@ +{ + "Content-Type": "application/json", + "Authorization": "" +} diff --git a/packages/inference-discovery-openai/sessions/openai-responses/gpt-5.5/function-calling-multi-turn/exchanges/0/request.json b/packages/inference-discovery-openai/sessions/openai-responses/gpt-5.5/function-calling-multi-turn/exchanges/0/request.json new file mode 100644 index 000000000..8939044fe --- /dev/null +++ b/packages/inference-discovery-openai/sessions/openai-responses/gpt-5.5/function-calling-multi-turn/exchanges/0/request.json @@ -0,0 +1,30 @@ +{ + "model": "gpt-5.5", + "input": [ + { + "type": "message", + "role": "user", + "content": "What is the weather in Boston, MA? Use the provided tool." + } + ], + "tools": [ + { + "type": "function", + "name": "get_weather", + "description": "Look up the current weather for a city.", + "parameters": { + "type": "object", + "properties": { + "location": { + "type": "string", + "description": "City and optional region, e.g. 'Boston, MA'." + } + }, + "required": [ + "location" + ] + } + } + ], + "tool_choice": "auto" +} diff --git a/packages/inference-discovery-openai/sessions/openai-responses/gpt-5.5/function-calling-multi-turn/exchanges/0/response-headers.json b/packages/inference-discovery-openai/sessions/openai-responses/gpt-5.5/function-calling-multi-turn/exchanges/0/response-headers.json new file mode 100644 index 000000000..75fde258c --- /dev/null +++ b/packages/inference-discovery-openai/sessions/openai-responses/gpt-5.5/function-calling-multi-turn/exchanges/0/response-headers.json @@ -0,0 +1,26 @@ +{ + "access-control-expose-headers": "X-Request-ID, Server-Timing-Total, CF-Ray, CF-Ray", + "alt-svc": "h3=\":443\"; ma=86400", + "cf-cache-status": "DYNAMIC", + "cf-ray": "a52f11d6bbef6a29-LAX", + "connection": "keep-alive", + "content-encoding": "br", + "content-type": "application/json", + "date": "Sat, 31 Oct 2026 02:01:05 GMT", + "openai-organization": "", + "openai-processing-ms": "1375", + "openai-project": "", + "openai-version": "2020-10-01", + "server": "cloudflare", + "strict-transport-security": "max-age=31536000; includeSubDomains; preload", + "transfer-encoding": "chunked", + "x-content-type-options": "nosniff", + "x-ratelimit-limit-requests": "5000", + "x-ratelimit-limit-tokens": "1000000", + "x-ratelimit-remaining-requests": "4999", + "x-ratelimit-remaining-tokens": "1000000", + "x-ratelimit-reset-requests": "12ms", + "x-ratelimit-reset-tokens": "0s", + "x-request-id": "", + "set-cookie": "" +} diff --git a/packages/inference-discovery-openai/sessions/openai-responses/gpt-5.5/function-calling-multi-turn/exchanges/0/response.json b/packages/inference-discovery-openai/sessions/openai-responses/gpt-5.5/function-calling-multi-turn/exchanges/0/response.json new file mode 100644 index 000000000..d6668fd40 --- /dev/null +++ b/packages/inference-discovery-openai/sessions/openai-responses/gpt-5.5/function-calling-multi-turn/exchanges/0/response.json @@ -0,0 +1,109 @@ +{ + "id": "resp_0cc4029d54da3e94006ae54bdfdbf087d093bf1f4cdc7afffc", + "object": "response", + "created_at": 1793412063, + "status": "completed", + "access_programs": null, + "background": false, + "billing": { + "payer": "developer" + }, + "completed_at": 1793412065, + "error": null, + "frequency_penalty": 0.0, + "incomplete_details": null, + "instructions": null, + "max_output_tokens": null, + "max_tool_calls": null, + "model": "gpt-5.5-2026-04-23", + "moderation": null, + "output": [ + { + "id": "fc_0cc4029d54da3e94006ae54be0b85487d0b243f8ca49e4a1ac", + "type": "function_call", + "status": "completed", + "arguments": "{\"location\":\"Boston, MA\"}", + "call_id": "call_Gok9Z3WIVQm6JhYpraESrlW5", + "name": "get_weather" + } + ], + "parallel_tool_calls": true, + "presence_penalty": 0.0, + "previous_response_id": null, + "prompt_cache_key": null, + "prompt_cache_retention": "24h", + "reasoning": { + "context": "current_turn", + "effort": "medium", + "mode": "standard", + "summary": null + }, + "safety_identifier": null, + "service_tier": "default", + "store": true, + "temperature": 1.0, + "text": { + "format": { + "type": "text" + }, + "verbosity": "medium" + }, + "tool_choice": "auto", + "tool_usage": { + "image_gen": { + "input_tokens": 0, + "input_tokens_details": { + "image_tokens": 0, + "text_tokens": 0 + }, + "output_tokens": 0, + "output_tokens_details": { + "image_tokens": 0, + "text_tokens": 0 + }, + "total_tokens": 0 + }, + "web_search": { + "num_requests": 0 + } + }, + "tools": [ + { + "type": "function", + "description": "Look up the current weather for a city.", + "name": "get_weather", + "output_schema": null, + "parameters": { + "type": "object", + "properties": { + "location": { + "type": "string", + "description": "City and optional region, e.g. 'Boston, MA'." + } + }, + "required": [ + "location" + ], + "additionalProperties": false + }, + "strict": true + } + ], + "top_logprobs": 0, + "top_p": 0.98, + "truncation": "disabled", + "usage": { + "input_tokens": 73, + "input_tokens_details": { + "cache_write_tokens": 0, + "cached_tokens": 0 + }, + "output_tokens": 20, + "output_tokens_details": { + "reasoning_tokens": 0 + }, + "total_tokens": 93 + }, + "user": null, + "metadata": {} +} \ No newline at end of file diff --git a/packages/inference-discovery-openai/sessions/openai-responses/gpt-5.5/function-calling-multi-turn/exchanges/1/request-headers.json b/packages/inference-discovery-openai/sessions/openai-responses/gpt-5.5/function-calling-multi-turn/exchanges/1/request-headers.json new file mode 100644 index 000000000..28c14bb85 --- /dev/null +++ b/packages/inference-discovery-openai/sessions/openai-responses/gpt-5.5/function-calling-multi-turn/exchanges/1/request-headers.json @@ -0,0 +1,4 @@ +{ + "Content-Type": "application/json", + "Authorization": "" +} diff --git a/packages/inference-discovery-openai/sessions/openai-responses/gpt-5.5/function-calling-multi-turn/exchanges/1/request.json b/packages/inference-discovery-openai/sessions/openai-responses/gpt-5.5/function-calling-multi-turn/exchanges/1/request.json new file mode 100644 index 000000000..031b2ce43 --- /dev/null +++ b/packages/inference-discovery-openai/sessions/openai-responses/gpt-5.5/function-calling-multi-turn/exchanges/1/request.json @@ -0,0 +1,45 @@ +{ + "model": "gpt-5.5", + "input": [ + { + "type": "message", + "role": "user", + "content": "What is the weather in Boston, MA? Use the provided tool." + }, + { + "type": "function_call", + "call_id": "call_Gok9Z3WIVQm6JhYpraESrlW5", + "name": "get_weather", + "arguments": "{\"location\":\"Boston, MA\"}" + }, + { + "type": "function_call_output", + "call_id": "call_Gok9Z3WIVQm6JhYpraESrlW5", + "output": "{\"location\":\"Boston, MA\",\"temperatureF\":68,\"conditions\":\"clear\"}" + } + ], + "store": false, + "include": [ + "reasoning.encrypted_content" + ], + "tools": [ + { + "type": "function", + "name": "get_weather", + "description": "Look up the current weather for a city.", + "parameters": { + "type": "object", + "properties": { + "location": { + "type": "string", + "description": "City and optional region, e.g. 'Boston, MA'." + } + }, + "required": [ + "location" + ] + } + } + ], + "tool_choice": "auto" +} diff --git a/packages/inference-discovery-openai/sessions/openai-responses/gpt-5.5/function-calling-multi-turn/exchanges/1/response-headers.json b/packages/inference-discovery-openai/sessions/openai-responses/gpt-5.5/function-calling-multi-turn/exchanges/1/response-headers.json new file mode 100644 index 000000000..73653fba0 --- /dev/null +++ b/packages/inference-discovery-openai/sessions/openai-responses/gpt-5.5/function-calling-multi-turn/exchanges/1/response-headers.json @@ -0,0 +1,26 @@ +{ + "access-control-expose-headers": "X-Request-ID, Server-Timing-Total, CF-Ray, CF-Ray", + "alt-svc": "h3=\":443\"; ma=86400", + "cf-cache-status": "DYNAMIC", + "cf-ray": "a52f11dfdb0b6a29-LAX", + "connection": "keep-alive", + "content-encoding": "br", + "content-type": "application/json", + "date": "Sat, 31 Oct 2026 02:01:06 GMT", + "openai-organization": "", + "openai-processing-ms": "1314", + "openai-project": "", + "openai-version": "2020-10-01", + "server": "cloudflare", + "strict-transport-security": "max-age=31536000; includeSubDomains; preload", + "transfer-encoding": "chunked", + "x-content-type-options": "nosniff", + "x-ratelimit-limit-requests": "5000", + "x-ratelimit-limit-tokens": "1000000", + "x-ratelimit-remaining-requests": "4999", + "x-ratelimit-remaining-tokens": "1000000", + "x-ratelimit-reset-requests": "12ms", + "x-ratelimit-reset-tokens": "0s", + "x-request-id": "", + "set-cookie": "" +} diff --git a/packages/inference-discovery-openai/sessions/openai-responses/gpt-5.5/function-calling-multi-turn/exchanges/1/response.json b/packages/inference-discovery-openai/sessions/openai-responses/gpt-5.5/function-calling-multi-turn/exchanges/1/response.json new file mode 100644 index 000000000..74b1b4a70 --- /dev/null +++ b/packages/inference-discovery-openai/sessions/openai-responses/gpt-5.5/function-calling-multi-turn/exchanges/1/response.json @@ -0,0 +1,116 @@ +{ + "id": "resp_03f26387b3f45e2b016ae54be15b3887d0af2e478c4bff45d1", + "object": "response", + "created_at": 1793412065, + "status": "completed", + "access_programs": null, + "background": false, + "billing": { + "payer": "developer" + }, + "completed_at": 1793412066, + "error": null, + "frequency_penalty": 0.0, + "incomplete_details": null, + "instructions": null, + "max_output_tokens": null, + "max_tool_calls": null, + "model": "gpt-5.5-2026-04-23", + "moderation": null, + "output": [ + { + "id": "msg_03f26387b3f45e2b016ae54be244d087d0915f1b9fa79df8df", + "type": "message", + "status": "completed", + "content": [ + { + "type": "output_text", + "annotations": [], + "logprobs": [], + "text": "The weather in Boston, MA is currently 68\u00b0F and clear." + } + ], + "phase": "final_answer", + "role": "assistant" + } + ], + "parallel_tool_calls": true, + "presence_penalty": 0.0, + "previous_response_id": null, + "prompt_cache_key": null, + "prompt_cache_retention": "24h", + "reasoning": { + "context": "current_turn", + "effort": "medium", + "mode": "standard", + "summary": null + }, + "safety_identifier": null, + "service_tier": "default", + "store": false, + "temperature": 1.0, + "text": { + "format": { + "type": "text" + }, + "verbosity": "medium" + }, + "tool_choice": "auto", + "tool_usage": { + "image_gen": { + "input_tokens": 0, + "input_tokens_details": { + "image_tokens": 0, + "text_tokens": 0 + }, + "output_tokens": 0, + "output_tokens_details": { + "image_tokens": 0, + "text_tokens": 0 + }, + "total_tokens": 0 + }, + "web_search": { + "num_requests": 0 + } + }, + "tools": [ + { + "type": "function", + "description": "Look up the current weather for a city.", + "name": "get_weather", + "output_schema": null, + "parameters": { + "type": "object", + "properties": { + "location": { + "type": "string", + "description": "City and optional region, e.g. 'Boston, MA'." + } + }, + "required": [ + "location" + ], + "additionalProperties": false + }, + "strict": true + } + ], + "top_logprobs": 0, + "top_p": 0.98, + "truncation": "disabled", + "usage": { + "input_tokens": 120, + "input_tokens_details": { + "cache_write_tokens": 0, + "cached_tokens": 0 + }, + "output_tokens": 18, + "output_tokens_details": { + "reasoning_tokens": 0 + }, + "total_tokens": 138 + }, + "user": null, + "metadata": {} +} \ No newline at end of file diff --git a/packages/inference-discovery-openai/sessions/openai-responses/gpt-5.5/function-calling-multi-turn/session.json b/packages/inference-discovery-openai/sessions/openai-responses/gpt-5.5/function-calling-multi-turn/session.json new file mode 100644 index 000000000..75975a75f --- /dev/null +++ b/packages/inference-discovery-openai/sessions/openai-responses/gpt-5.5/function-calling-multi-turn/session.json @@ -0,0 +1,11 @@ +{ + "schemaVersion": "2", + "source": { + "provider": "openai-responses", + "model": "gpt-5.5", + "baseURL": "https://api.openai.com/v1" + }, + "origin": "live", + "capturedAt": "2026-10-31T02:01:06.673Z", + "capability": "function-calling-multi-turn" +} diff --git a/packages/inference-discovery-openai/sessions/openai-responses/gpt-5.5/plain-text-streaming/exchanges/0/request-headers.json b/packages/inference-discovery-openai/sessions/openai-responses/gpt-5.5/plain-text-streaming/exchanges/0/request-headers.json new file mode 100644 index 000000000..28c14bb85 --- /dev/null +++ b/packages/inference-discovery-openai/sessions/openai-responses/gpt-5.5/plain-text-streaming/exchanges/0/request-headers.json @@ -0,0 +1,4 @@ +{ + "Content-Type": "application/json", + "Authorization": "" +} diff --git a/packages/inference-discovery-openai/sessions/openai-responses/gpt-5.5/plain-text-streaming/exchanges/0/request.json b/packages/inference-discovery-openai/sessions/openai-responses/gpt-5.5/plain-text-streaming/exchanges/0/request.json new file mode 100644 index 000000000..4345764dd --- /dev/null +++ b/packages/inference-discovery-openai/sessions/openai-responses/gpt-5.5/plain-text-streaming/exchanges/0/request.json @@ -0,0 +1,11 @@ +{ + "model": "gpt-5.5", + "input": [ + { + "type": "message", + "role": "user", + "content": "Reply with a single sentence: the capital of France is Paris." + } + ], + "stream": true +} diff --git a/packages/inference-discovery-openai/sessions/openai-responses/gpt-5.5/plain-text-streaming/exchanges/0/response-headers.json b/packages/inference-discovery-openai/sessions/openai-responses/gpt-5.5/plain-text-streaming/exchanges/0/response-headers.json new file mode 100644 index 000000000..1c568887b --- /dev/null +++ b/packages/inference-discovery-openai/sessions/openai-responses/gpt-5.5/plain-text-streaming/exchanges/0/response-headers.json @@ -0,0 +1,25 @@ +{ + "access-control-expose-headers": "X-Request-ID, Server-Timing-Total, CF-Ray, CF-Ray", + "alt-svc": "h3=\":443\"; ma=86400", + "cf-cache-status": "DYNAMIC", + "cf-ray": "a5280fdf09ed5730-LAX", + "connection": "keep-alive", + "content-type": "text/event-stream; charset=utf-8", + "date": "Fri, 30 Oct 2026 05:36:23 GMT", + "openai-organization": "", + "openai-processing-ms": "273", + "openai-project": "", + "openai-version": "2020-10-01", + "server": "cloudflare", + "strict-transport-security": "max-age=31536000; includeSubDomains; preload", + "transfer-encoding": "chunked", + "x-content-type-options": "nosniff", + "x-ratelimit-limit-requests": "5000", + "x-ratelimit-limit-tokens": "1000000", + "x-ratelimit-remaining-requests": "4999", + "x-ratelimit-remaining-tokens": "999818", + "x-ratelimit-reset-requests": "12ms", + "x-ratelimit-reset-tokens": "10ms", + "x-request-id": "", + "set-cookie": "" +} diff --git a/packages/inference-discovery-openai/sessions/openai-responses/gpt-5.5/plain-text-streaming/exchanges/0/response.sse b/packages/inference-discovery-openai/sessions/openai-responses/gpt-5.5/plain-text-streaming/exchanges/0/response.sse new file mode 100644 index 000000000..893a63300 --- /dev/null +++ b/packages/inference-discovery-openai/sessions/openai-responses/gpt-5.5/plain-text-streaming/exchanges/0/response.sse @@ -0,0 +1,51 @@ +event: response.created +data: {"type":"response.created","response":{"id":"resp_00ef2381b97d6536006ae42cd6f31487d0a962b8926b1ae687","object":"response","created_at":1793338583,"status":"in_progress","access_programs":null,"background":false,"completed_at":null,"error":null,"frequency_penalty":0.0,"incomplete_details":null,"instructions":null,"max_output_tokens":null,"max_tool_calls":null,"model":"gpt-5.5-2026-04-23","moderation":null,"output":[],"parallel_tool_calls":true,"presence_penalty":0.0,"previous_response_id":null,"prompt_cache_key":null,"prompt_cache_retention":"24h","reasoning":{"context":"current_turn","effort":"medium","mode":"standard","summary":null},"safety_identifier":null,"service_tier":"auto","store":true,"temperature":1.0,"text":{"format":{"type":"text"},"verbosity":"medium"},"tool_choice":"auto","tool_usage":{"image_gen":{"input_tokens":0,"input_tokens_details":{"image_tokens":0,"text_tokens":0},"output_tokens":0,"output_tokens_details":{"image_tokens":0,"text_tokens":0},"total_tokens":0},"web_search":{"num_requests":0}},"tools":[],"top_logprobs":0,"top_p":0.98,"truncation":"disabled","usage":null,"user":null,"metadata":{}},"sequence_number":0} + +event: response.in_progress +data: {"type":"response.in_progress","response":{"id":"resp_00ef2381b97d6536006ae42cd6f31487d0a962b8926b1ae687","object":"response","created_at":1793338583,"status":"in_progress","access_programs":null,"background":false,"completed_at":null,"error":null,"frequency_penalty":0.0,"incomplete_details":null,"instructions":null,"max_output_tokens":null,"max_tool_calls":null,"model":"gpt-5.5-2026-04-23","moderation":null,"output":[],"parallel_tool_calls":true,"presence_penalty":0.0,"previous_response_id":null,"prompt_cache_key":null,"prompt_cache_retention":"24h","reasoning":{"context":"current_turn","effort":"medium","mode":"standard","summary":null},"safety_identifier":null,"service_tier":"auto","store":true,"temperature":1.0,"text":{"format":{"type":"text"},"verbosity":"medium"},"tool_choice":"auto","tool_usage":{"image_gen":{"input_tokens":0,"input_tokens_details":{"image_tokens":0,"text_tokens":0},"output_tokens":0,"output_tokens_details":{"image_tokens":0,"text_tokens":0},"total_tokens":0},"web_search":{"num_requests":0}},"tools":[],"top_logprobs":0,"top_p":0.98,"truncation":"disabled","usage":null,"user":null,"metadata":{}},"sequence_number":1} + +event: response.output_item.added +data: {"type":"response.output_item.added","item":{"id":"rs_00ef2381b97d6536006ae42cd7aa4c87d0bae4237755ccf89b","type":"reasoning","content":[],"encrypted_content":"gAAAAABq5CzXdE9zQQAHWt4V0fBP-VcUJMq82us4-bMIhKpzp2Wr8EQcL9VqQV_vUaMNZkTypmbv8z7s0rfVLjQuiDBhAogGtPdxwqwe57_Rl6jyCUmo8UBLxslCL5f1cKxS1bTwPkuslpeUWr_OhNdn6OyCFuFrPQHw307ooOM93a7gz9ssbbyMkpXTWhc9tioqdIqVQkvwOMXYfj93SSqA7PVOHZbSdVw9_8lYAhzdPosSME9cekN4cHuztfAPZwc-ItFpf0qUke9RkBBK7e9_xdvW23mAg5eTJLEZIsGee4wnKCYyqPRfgkQ6FsVOJKdI3yyAm-iQUTVay8RgFp0vbzxN8ltA-_5xlvqNyO26AI3K5FMgh-1CHHXI_1a0dM_NeyeOpzVSyZnkv63yat9dV3SyeSMzMwUUUHSpPKoQQ0swI-wU6AE8l6o-YCidIRT5kavPxg1UEBv_wNGt-TwvOs82i_T9mXUynP1jcRwQSr5I6k1g-DpuZIWt0J886Psm7d364-YGoFOUZwKjLn96AlW7D_prJDscKlnDn3HydBsn-gFsEB80bN_Hjt2NphMHFz_j8jbNelCLX74spY_Tr7iAsptaNYtOuQNAzt9R2WTY_eYFYuuiYMgQhdZ7VNFNIb9WsoUjbQWwOLFQ59kTI5Iqmj4FgHeUQ9PQPPHh1IbuVLuGB17B3f3yHV1_8h_K_VHxNJWYnH3amGLJZvAlU0V5j-BTSxmavd5h2OmkXxSdQA_1Y7k9znND5N5o2oAz2biMtwpWZS_rPmC_EbrRJTD938jw-SYP04gzpdTbg7FIkNOy3aGKdTWJS-QW8N80uX3z28rrhcTNQqFOD-gT52wQPDdduXoHZStYYzLWzYAb5j05Ra-mmnoFW8vgew90q06y3cAdVP-46VzjuXdFv4Z3GZd0bXzy4uFRvoz5ZvGyecyEBQNzePI3IEMnXWoEiwN8Fts72DEPUe9YLDTUgoEXZQvSjFHd3ZEnAF9hnUApyyYAEsjXYUOw4Pa9DrljmyQqcu6NDqS5D8yj1NorW-amzeedu3f654PdSQiwmdaFxmJ-Nhyi8C6DqFz91Msxnbo_r8c4B4cajAEfW2HQL4x8AZmV2Up9oR6bnT751BqZMQXMxOTEn_Wpl90H8Ayw5Ndwdxj-I4AwwTSuhVMPjQi5xnlFaOTQQZEUjq79xgKzE9AagyekSsA3etaf0qu3rnaZGcTE","summary":[]},"output_index":0,"sequence_number":2} + +event: response.output_item.done +data: {"type":"response.output_item.done","item":{"id":"rs_00ef2381b97d6536006ae42cd7aa4c87d0bae4237755ccf89b","type":"reasoning","content":[],"encrypted_content":"gAAAAABq5CzXMshRMgTbYJmlps2-Jed8AHeThfQpvgi0-xT9555x9wBzvia328JV1XqPfN0gKfQZfXergveyTRIolkioh2JGXK5-n9a1TUa7yYNYk7kBwWD_y9Mib0uiSUBIpDyYTX9OtY2lf0N466L_1LTy2ZL-9u75j9kbLVvM1qAwdSqvAL4yWtsJnz4tKCEdtbFx8yMkWUWmdLLyhA6E12ysF3RNZLvdlW-TdM_y6kPFHuJoSQLgOBREl4t8n_2EYLjupHv5-mQx9AvvqK9Pm6rYdzsEc9h_Q-FonIAQLJOpUJ43WAqxzRiM5ZEM2oe9mXHPXat72mS_dstEZwAs3SygNMxDSZV-ZSCfOSU7fKdCULUHD1qWGi-L-igAUUeEgItKONktc6eGB6JKGwJuqh0qRLdwg_mt-lIzsYgiKo8tXqUm8MkytYGS_uouXWOPksq6bk1ykbXbB3ujRWEgPO7i3a9UxzXpbe91YsKqJNV6JcUO_-_o3jG1h88Wm0TObMwkSqtv_pHnyRnz1bOpU7jSGx8ObYlLGCf5g5Ni4xsCpkls5KTQyTImefR0BEfk9qEr0I_D12Xc5d8dXuvgS64Y5BL7QzPzqbtTWfVCIW9ZS9Sn5XYYVuczueMYNuVHQ9UOjhy1XbsdgkYkrqDQ8AM0jjfekE2PD7KfkrH3YksumVgwRwQ8KYxHBJUMHBgIANuUqqd7-1Xpg1tR6EWUuRiuU5jm6CNUaXxtcgb9D32R64RYdRYeWK3jYrzUfhv-MkgURMq7PlQqPgF9MYfI4naAb1cS1zDv6eeXN3FUvAYYP7MEBuoPotq52b9VQv_6MBUWqgDsdAXrrN_RhPAXuFonrChiXDfcQBQm_MuPBldi9dJ5O8aG1KMxarLPHl5rByA4rRt3O8dHQIPhxWNgUmtzEynakJi3Bx97h0da7kx6NcHfzL0EUvW5T1TTHDWtn0CK84JVUmZPNsRqOfkZMnxPg35I0Sq4kRli9XQGcKr844d1HLXQoaAf0Xoz_Jy-IuItHNQy5j6hCRhknYPdI5qwXAW2-uexCC6R3IBL32LlQTJ5pFu2zPUkSw949DV2iTPMqUv0W6roS7dZaPNr1qKyICRifu7Js244qDFEjiztuodKAX91ra9YVLDVXZ5kIlrwZXdNidFyFDVIqy_DJSCt1EpRdoYqYI9ZNq6YQyLCGX870ZRwmjJSzfHyRx1ytPDmYX6gfKNOEaGY2VxlsmvvxIQyFUCyflJAs_B_pWx5Le9vuaEB8-Zb67FFcBI1z63VxlNa-eecLVed1ty14Qr7WObiSmOpxQN3b6QSD1YDoizCGkwFMnLhIfTWbOEU5UNfVoX0s5NnLHoEerK3SxfqxAvvk6-dvLyMgVIACI2hsPtcBseOm6vTIU4OcHHYsztCV4hcznnZDcTjD0WQPQOwok05eL0QVuKs3yUCIzpNB1lBcypzID5FHQNnf1Z7TvaHLE7QTbox0tqT9jw5Vh_xgEy9l-vszypQYkpJGmyI45ePJeIWVo3jzjVLJz6V6cuSSOq0I5Osc0Wb8FCtLMOg58LIw2FF2QWIhuMOm_QkB2wkduE=","summary":[]},"output_index":0,"sequence_number":3} + +event: response.output_item.added +data: {"type":"response.output_item.added","item":{"id":"msg_00ef2381b97d6536006ae42cd7ebdc87d09fc923a67148b083","type":"message","status":"in_progress","content":[],"phase":"final_answer","role":"assistant"},"output_index":1,"sequence_number":4} + +event: response.content_part.added +data: {"type":"response.content_part.added","content_index":0,"item_id":"msg_00ef2381b97d6536006ae42cd7ebdc87d09fc923a67148b083","output_index":1,"part":{"type":"output_text","annotations":[],"logprobs":[],"text":""},"sequence_number":5} + +event: response.output_text.delta +data: {"type":"response.output_text.delta","content_index":0,"delta":"The","item_id":"msg_00ef2381b97d6536006ae42cd7ebdc87d09fc923a67148b083","logprobs":[],"obfuscation":"QqhuO8ch02t0F","output_index":1,"sequence_number":6} + +event: response.output_text.delta +data: {"type":"response.output_text.delta","content_index":0,"delta":" capital","item_id":"msg_00ef2381b97d6536006ae42cd7ebdc87d09fc923a67148b083","logprobs":[],"obfuscation":"y7Lg3O1Y","output_index":1,"sequence_number":7} + +event: response.output_text.delta +data: {"type":"response.output_text.delta","content_index":0,"delta":" of","item_id":"msg_00ef2381b97d6536006ae42cd7ebdc87d09fc923a67148b083","logprobs":[],"obfuscation":"e1n9yn5BUZQfG","output_index":1,"sequence_number":8} + +event: response.output_text.delta +data: {"type":"response.output_text.delta","content_index":0,"delta":" France","item_id":"msg_00ef2381b97d6536006ae42cd7ebdc87d09fc923a67148b083","logprobs":[],"obfuscation":"jwDBu4oI0","output_index":1,"sequence_number":9} + +event: response.output_text.delta +data: {"type":"response.output_text.delta","content_index":0,"delta":" is","item_id":"msg_00ef2381b97d6536006ae42cd7ebdc87d09fc923a67148b083","logprobs":[],"obfuscation":"9zHP42QlAm2Xk","output_index":1,"sequence_number":10} + +event: response.output_text.delta +data: {"type":"response.output_text.delta","content_index":0,"delta":" Paris","item_id":"msg_00ef2381b97d6536006ae42cd7ebdc87d09fc923a67148b083","logprobs":[],"obfuscation":"5XokrQkR3K","output_index":1,"sequence_number":11} + +event: response.output_text.delta +data: {"type":"response.output_text.delta","content_index":0,"delta":".","item_id":"msg_00ef2381b97d6536006ae42cd7ebdc87d09fc923a67148b083","logprobs":[],"obfuscation":"u03kK93bnG4shuY","output_index":1,"sequence_number":12} + +event: response.output_text.done +data: {"type":"response.output_text.done","content_index":0,"item_id":"msg_00ef2381b97d6536006ae42cd7ebdc87d09fc923a67148b083","logprobs":[],"output_index":1,"sequence_number":13,"text":"The capital of France is Paris."} + +event: response.content_part.done +data: {"type":"response.content_part.done","content_index":0,"item_id":"msg_00ef2381b97d6536006ae42cd7ebdc87d09fc923a67148b083","output_index":1,"part":{"type":"output_text","annotations":[],"logprobs":[],"text":"The capital of France is Paris."},"sequence_number":14} + +event: response.output_item.done +data: {"type":"response.output_item.done","item":{"id":"msg_00ef2381b97d6536006ae42cd7ebdc87d09fc923a67148b083","type":"message","status":"completed","content":[{"type":"output_text","annotations":[],"logprobs":[],"text":"The capital of France is Paris."}],"phase":"final_answer","role":"assistant"},"output_index":1,"sequence_number":15} + +event: response.completed +data: {"type":"response.completed","response":{"id":"resp_00ef2381b97d6536006ae42cd6f31487d0a962b8926b1ae687","object":"response","created_at":1793338583,"status":"completed","access_programs":null,"background":false,"completed_at":1793338584,"error":null,"frequency_penalty":0.0,"incomplete_details":null,"instructions":null,"max_output_tokens":null,"max_tool_calls":null,"model":"gpt-5.5-2026-04-23","moderation":null,"output":[{"id":"rs_00ef2381b97d6536006ae42cd7aa4c87d0bae4237755ccf89b","type":"reasoning","content":[],"encrypted_content":"gAAAAABq5CzYfPsQb4MmWQ5LPftUXZS7BDo65WcKbkQxWkHoaNuCmNd57YjYPz2GaC1lv5pEdc7e1xleZPhLoqWQrj5C-poT3mpb91jnMqGTnkcv574IqVAJWNhGA1AcvH6Yqs157ErldZbLbTZ6eMBMOd2sfzmX9NjRb4Lu4lDAmHRvAv0o3M4xtzbQESh_Ju4CpMPWY98vDzf6DneQ_uD49XzuPjZCyX01RW8-V6x5x9rHUk5DP2rsm5uQ3TtizAASii3PXkpffrfYwBD6YTP-M0wvDDqJ9GoI-fOF8KT9tQKFBREv8Ks3L7rvu-KS7ZJs_8aB-QJDkjjS0yEznvGiu56EOuXCJW6u3sfG2Hs5w1CavumeX6b_io_aoSK98RsjMmOYjZmS4xz66cpkLOUGdCgAZ9exc0bPboDrskedA8vEU26n4V3TgRJegNdghbDUqY-W2zuPpU0y8-Vn6W0Lw4eObqQZXxBVtxbgh8owdx99yEUV8y6Umn7n48nGZErNrjvK_2qiwnOGzyS3CoKpL1XBgcD-cUWMcgUWehEXIetLYU9qv3z95i66Hfe1vFg24QWuVSQMq00yMf9YTGvJB14XWB3eYr0lpu-KycIiLHXWKtWomtKA9TezDAG27z37PyH8385klDFrW8r7Dhk68F-dTeCzaKr-9NwJBK9QyqnfwVnZ6Ow6FRzoS-EDDZiFDTH5MFebIH95tcGyzRH15JlUTB7T030JHDlIBBbHxou0GIHD9P25jmlgBjrjpiUhSrawEUli2zyN5PWidJbsWgnHt8FGRoLGvGS7TM-NnRhqjarlHM5PaAwKndhTicvWEQCj040-t2d9FKYu7UT_iL0xnsPDgIkdb69MWNrCuQYXtSqhjmkjFVTwSqn5KMs2Br_NxRv3Nc1iCUECCoV98xTdbKqukUmTtlIFImkUOABJKvkT5EyyrT9hsON6TT5u2C85O-KWgHQ9QEnuWEtR93Qnth_baTu6gXWpue359oTqtJ9gzGiODsgvMdjIBFndiWfGf1w6IaYIpUGj6aLeonbgx4jnGL5ovUBNAUCKSGAJl3X4U4knY4dPkPt57sNLrrZQlLnoEWJ7EOO4HNczsU4lN1932DUFZ7102pspDBA5SOc8YQaT51lZz9NQIKoXzOHse0zR2WgJ6RBKg7Et2fvoP-9hW-LPl1sJAyoMtlkPGbb1wRR8PXcyClS8wCK_5zUuoMUUbwFEzqRTsJSxi9XzKpa7Ig7VLzm9f9SKZKitLlrlaD22cGyAi4QP87s0MS6gEtRuJggjHBuUxYcji0FeQb6VHhJPOKfWH7LxN7N9jU-ycQI9FRMegO5W4pk3D1g7R_ceiV4WTbNIIsclGzbvH0nyv_xYEKisveXu7KkikQGhzehyGxYrx2ZBg5mdSlWyH5eWpmJcnYHY5cZuQNyV9h0U7iWCA8pxnHxY41E--Y51jIaTynZZgnDEFi3AwBgFo83Hoe66bBUsLmmf4qu1UD5hDis85WswPoIlLcGWYnMRx1e5lVHhwiEgFzGN5YMfJffERr7qNpPPSnz97aWSpIvj5sSnRmgQjmXmGqxynHlnMEQ=","summary":[]},{"id":"msg_00ef2381b97d6536006ae42cd7ebdc87d09fc923a67148b083","type":"message","status":"completed","content":[{"type":"output_text","annotations":[],"logprobs":[],"text":"The capital of France is Paris."}],"phase":"final_answer","role":"assistant"}],"parallel_tool_calls":true,"presence_penalty":0.0,"previous_response_id":null,"prompt_cache_key":null,"prompt_cache_retention":"24h","reasoning":{"context":"current_turn","effort":"medium","mode":"standard","summary":null},"safety_identifier":null,"service_tier":"default","store":true,"temperature":1.0,"text":{"format":{"type":"text"},"verbosity":"medium"},"tool_choice":"auto","tool_usage":{"image_gen":{"input_tokens":0,"input_tokens_details":{"image_tokens":0,"text_tokens":0},"output_tokens":0,"output_tokens_details":{"image_tokens":0,"text_tokens":0},"total_tokens":0},"web_search":{"num_requests":0}},"tools":[],"top_logprobs":0,"top_p":0.98,"truncation":"disabled","usage":{"input_tokens":19,"input_tokens_details":{"cache_write_tokens":0,"cached_tokens":0},"output_tokens":24,"output_tokens_details":{"reasoning_tokens":11},"total_tokens":43},"user":null,"metadata":{}},"sequence_number":16} + diff --git a/packages/inference-discovery-openai/sessions/openai-responses/gpt-5.5/plain-text-streaming/session.json b/packages/inference-discovery-openai/sessions/openai-responses/gpt-5.5/plain-text-streaming/session.json new file mode 100644 index 000000000..486d1a24f --- /dev/null +++ b/packages/inference-discovery-openai/sessions/openai-responses/gpt-5.5/plain-text-streaming/session.json @@ -0,0 +1,11 @@ +{ + "schemaVersion": "2", + "source": { + "provider": "openai-responses", + "model": "gpt-5.5", + "baseURL": "https://api.openai.com/v1" + }, + "origin": "live", + "capturedAt": "2026-10-30T05:36:24.525Z", + "capability": "plain-text-streaming" +} diff --git a/packages/inference-discovery-openai/sessions/openai-responses/gpt-5.5/plain-text/exchanges/0/request-headers.json b/packages/inference-discovery-openai/sessions/openai-responses/gpt-5.5/plain-text/exchanges/0/request-headers.json new file mode 100644 index 000000000..28c14bb85 --- /dev/null +++ b/packages/inference-discovery-openai/sessions/openai-responses/gpt-5.5/plain-text/exchanges/0/request-headers.json @@ -0,0 +1,4 @@ +{ + "Content-Type": "application/json", + "Authorization": "" +} diff --git a/packages/inference-discovery-openai/sessions/openai-responses/gpt-5.5/plain-text/exchanges/0/request.json b/packages/inference-discovery-openai/sessions/openai-responses/gpt-5.5/plain-text/exchanges/0/request.json new file mode 100644 index 000000000..6d10965f8 --- /dev/null +++ b/packages/inference-discovery-openai/sessions/openai-responses/gpt-5.5/plain-text/exchanges/0/request.json @@ -0,0 +1,10 @@ +{ + "model": "gpt-5.5", + "input": [ + { + "type": "message", + "role": "user", + "content": "Reply with a single sentence: the capital of France is Paris." + } + ] +} diff --git a/packages/inference-discovery-openai/sessions/openai-responses/gpt-5.5/plain-text/exchanges/0/response-headers.json b/packages/inference-discovery-openai/sessions/openai-responses/gpt-5.5/plain-text/exchanges/0/response-headers.json new file mode 100644 index 000000000..8c3ff832c --- /dev/null +++ b/packages/inference-discovery-openai/sessions/openai-responses/gpt-5.5/plain-text/exchanges/0/response-headers.json @@ -0,0 +1,26 @@ +{ + "access-control-expose-headers": "X-Request-ID, Server-Timing-Total, CF-Ray, CF-Ray", + "alt-svc": "h3=\":443\"; ma=86400", + "cf-cache-status": "DYNAMIC", + "cf-ray": "a5280fd37d105730-LAX", + "connection": "keep-alive", + "content-encoding": "br", + "content-type": "application/json", + "date": "Fri, 30 Oct 2026 05:36:22 GMT", + "openai-organization": "", + "openai-processing-ms": "1735", + "openai-project": "", + "openai-version": "2020-10-01", + "server": "cloudflare", + "strict-transport-security": "max-age=31536000; includeSubDomains; preload", + "transfer-encoding": "chunked", + "x-content-type-options": "nosniff", + "x-ratelimit-limit-requests": "5000", + "x-ratelimit-limit-tokens": "1000000", + "x-ratelimit-remaining-requests": "4999", + "x-ratelimit-remaining-tokens": "1000000", + "x-ratelimit-reset-requests": "12ms", + "x-ratelimit-reset-tokens": "0s", + "x-request-id": "", + "set-cookie": "" +} diff --git a/packages/inference-discovery-openai/sessions/openai-responses/gpt-5.5/plain-text/exchanges/0/response.json b/packages/inference-discovery-openai/sessions/openai-responses/gpt-5.5/plain-text/exchanges/0/response.json new file mode 100644 index 000000000..fc9df176d --- /dev/null +++ b/packages/inference-discovery-openai/sessions/openai-responses/gpt-5.5/plain-text/exchanges/0/response.json @@ -0,0 +1,102 @@ +{ + "id": "resp_00cce71b2be0bb23006ae42cd51fd887d09600b0f2509022ef", + "object": "response", + "created_at": 1793338581, + "status": "completed", + "access_programs": null, + "background": false, + "billing": { + "payer": "developer" + }, + "completed_at": 1793338582, + "error": null, + "frequency_penalty": 0.0, + "incomplete_details": null, + "instructions": null, + "max_output_tokens": null, + "max_tool_calls": null, + "model": "gpt-5.5-2026-04-23", + "moderation": null, + "output": [ + { + "id": "rs_00cce71b2be0bb23006ae42cd6087087d08ee5217964220591", + "type": "reasoning", + "content": [], + "encrypted_content": "gAAAAABq5CzWDhrOwP-NtAxhdIWCFIsDxFydGh0Po0hNJpockT3uxtNV6AOZEg_igSDaMs6XYHVz94hYtjtuCLfecJntjDVYt-1kbhVLIRuhKz_VWZFTOOcQ_xM-tSEBoOJxkMcGd6qqA9oalHlLed4aFlhT1wLumlkvCz66cavtxXzHmcSupnSEehFcE4llos3PiZT9TVGeSgo5C4jQI513hekGTpFHxwSTAdTHQkZSgD0YBUYGNVqMMgFFGjvfJei9nJ4FoFPy42dC5tpvjuAQbTg1UvWsyaHDwztbLp_ZYuvL2HFC-IE0510yGOj7MCjVJdH1iip1tdUvZiWlHwg5glr0DE2YIeeg25PHXEzxxoBXq27dHkOH_aX7nl7QB6c5K5Fv_jxIT9IjK_RQKACDTSazDzeSphL7iMRfpmp99cj9x6vT9llbMKtz0GCsrlPG2sCt40MkhkcWlRLEpbyILLNQiTcWAYfQb8G7UmCi3tH_paf1s7AvMzyzw1FO_PRB8YuK-FJ4D5AXMldpJLPjYsshA-NaQkvyKMl4u9BIvUoyXKEpG0R29danTutq9_4ciTPGK3wHHYh6K3Xs_rNRpqlUN8kcSoESgwgaeQHNhNp48kyBoLrJVzYKMIVPJwHt8kusAk2pagT5ObT8C638tAOhwvnBnSr5shD57o6k5eiaEq0YEAbvmWc-cfut0RNsGd7Nu7Ln_LdFV_Tnd2rjBmbY5DEyhUCKFxwhcxcTePcoCrxDKs317CzS1umShWv3WLDxSQ-9DknRyDtoaTYnmoD2PrNcA8dlcAg1cay0YooWTdsUiyYQUjZZFt-2ltC7SgWOyM1gO8t-moqqoBwoEOWw4darXpr24lDsjzH87SHAnprBZzS2gGN4pJaXFQtQLHpb6dO-7cm4d2X3X_jjVQSR5pbwFsD0YL7WW35qJjg7W7DunifjLY7tS6isiY2VLslDkBhL5EtqndnGY6j9gD2wIGkIe5imEhU4MXDsh35w8ZnICQq0dKvGHlVIbhfpaZfUCUmArbJLHqtTTgyxDJ77e8uyoy5pDuvmnrZkTnyPhtpH74z5rKXc8ce7NtzzwZDkqTaTXCgNGu20PjOxPdOMh3T9GDD8flOyTp-y9Z4QT5C7EPpIkW6bZ2beuBVrs8GysBHNBbjqKzFfd_5ucoerzSPRcOy1hvs0F-38TNGfKUdxTCuBcL1Lr9xzJRIw4HpRq0XXixZbHBmVLIJeizN6aWF_AzNykXl6b27HnVBNPeJQe1p73GCTIMAam4tJSpBllQRkdyIpKTJJIHMEGprMii2syG2hbFZZsbzqvtAd57RLD-NXPzRw9n-qX7Z1Z9OjYS2-y2mj2kwCeXZ1U6-N2uKECbtwI6O9f3GdSmxrESX4oSpdfiN2aUUJ2JO6Y9-e1hApoaaNLnMfP_C0OAsggPUNv6EkhMFAOMCmVh7FjBE2K_oBSQRXmDP0iUcO5maeCyP9n-gbHn1XGoCXkDBng1WxfKpjCMyHPYbSZokR_YRBVOFPiTsWwE_PcMbDCk8Xi7TmUkXdPq4CPBMLW-aV0fR9WpaHjv89stUVaXTkn7cpkb0=", + "summary": [] + }, + { + "id": "msg_00cce71b2be0bb23006ae42cd649f487d0a521032b90dc4c44", + "type": "message", + "status": "completed", + "content": [ + { + "type": "output_text", + "annotations": [], + "logprobs": [], + "text": "The capital of France is Paris." + } + ], + "phase": "final_answer", + "role": "assistant" + } + ], + "parallel_tool_calls": true, + "presence_penalty": 0.0, + "previous_response_id": null, + "prompt_cache_key": null, + "prompt_cache_retention": "24h", + "reasoning": { + "context": "current_turn", + "effort": "medium", + "mode": "standard", + "summary": null + }, + "safety_identifier": null, + "service_tier": "default", + "store": true, + "temperature": 1.0, + "text": { + "format": { + "type": "text" + }, + "verbosity": "medium" + }, + "tool_choice": "auto", + "tool_usage": { + "image_gen": { + "input_tokens": 0, + "input_tokens_details": { + "image_tokens": 0, + "text_tokens": 0 + }, + "output_tokens": 0, + "output_tokens_details": { + "image_tokens": 0, + "text_tokens": 0 + }, + "total_tokens": 0 + }, + "web_search": { + "num_requests": 0 + } + }, + "tools": [], + "top_logprobs": 0, + "top_p": 0.98, + "truncation": "disabled", + "usage": { + "input_tokens": 19, + "input_tokens_details": { + "cache_write_tokens": 0, + "cached_tokens": 0 + }, + "output_tokens": 24, + "output_tokens_details": { + "reasoning_tokens": 11 + }, + "total_tokens": 43 + }, + "user": null, + "metadata": {} +} \ No newline at end of file diff --git a/packages/inference-discovery-openai/sessions/openai-responses/gpt-5.5/plain-text/session.json b/packages/inference-discovery-openai/sessions/openai-responses/gpt-5.5/plain-text/session.json new file mode 100644 index 000000000..f3d9d3063 --- /dev/null +++ b/packages/inference-discovery-openai/sessions/openai-responses/gpt-5.5/plain-text/session.json @@ -0,0 +1,11 @@ +{ + "schemaVersion": "2", + "source": { + "provider": "openai-responses", + "model": "gpt-5.5", + "baseURL": "https://api.openai.com/v1" + }, + "origin": "live", + "capturedAt": "2026-10-30T05:36:22.867Z", + "capability": "plain-text" +} diff --git a/packages/inference-discovery-openai/sessions/openai-responses/gpt-5.5/reasoning-content/exchanges/0/request-headers.json b/packages/inference-discovery-openai/sessions/openai-responses/gpt-5.5/reasoning-content/exchanges/0/request-headers.json new file mode 100644 index 000000000..28c14bb85 --- /dev/null +++ b/packages/inference-discovery-openai/sessions/openai-responses/gpt-5.5/reasoning-content/exchanges/0/request-headers.json @@ -0,0 +1,4 @@ +{ + "Content-Type": "application/json", + "Authorization": "" +} diff --git a/packages/inference-discovery-openai/sessions/openai-responses/gpt-5.5/reasoning-content/exchanges/0/request.json b/packages/inference-discovery-openai/sessions/openai-responses/gpt-5.5/reasoning-content/exchanges/0/request.json new file mode 100644 index 000000000..c4fa76207 --- /dev/null +++ b/packages/inference-discovery-openai/sessions/openai-responses/gpt-5.5/reasoning-content/exchanges/0/request.json @@ -0,0 +1,14 @@ +{ + "model": "gpt-5.5", + "input": [ + { + "type": "message", + "role": "user", + "content": "A bat and a ball cost $1.10 together. The bat costs $1.00 more than the ball. How much does the ball cost? Show your reasoning before the final answer." + } + ], + "reasoning": { + "effort": "medium", + "summary": "detailed" + } +} diff --git a/packages/inference-discovery-openai/sessions/openai-responses/gpt-5.5/reasoning-content/exchanges/0/response-headers.json b/packages/inference-discovery-openai/sessions/openai-responses/gpt-5.5/reasoning-content/exchanges/0/response-headers.json new file mode 100644 index 000000000..3bc594584 --- /dev/null +++ b/packages/inference-discovery-openai/sessions/openai-responses/gpt-5.5/reasoning-content/exchanges/0/response-headers.json @@ -0,0 +1,26 @@ +{ + "access-control-expose-headers": "X-Request-ID, Server-Timing-Total, CF-Ray, CF-Ray", + "alt-svc": "h3=\":443\"; ma=86400", + "cf-cache-status": "DYNAMIC", + "cf-ray": "a52f11e8ca416a29-LAX", + "connection": "keep-alive", + "content-encoding": "br", + "content-type": "application/json", + "date": "Sat, 31 Oct 2026 02:01:09 GMT", + "openai-organization": "", + "openai-processing-ms": "2540", + "openai-project": "", + "openai-version": "2020-10-01", + "server": "cloudflare", + "strict-transport-security": "max-age=31536000; includeSubDomains; preload", + "transfer-encoding": "chunked", + "x-content-type-options": "nosniff", + "x-ratelimit-limit-requests": "5000", + "x-ratelimit-limit-tokens": "1000000", + "x-ratelimit-remaining-requests": "4999", + "x-ratelimit-remaining-tokens": "1000000", + "x-ratelimit-reset-requests": "12ms", + "x-ratelimit-reset-tokens": "0s", + "x-request-id": "", + "set-cookie": "" +} diff --git a/packages/inference-discovery-openai/sessions/openai-responses/gpt-5.5/reasoning-content/exchanges/0/response.json b/packages/inference-discovery-openai/sessions/openai-responses/gpt-5.5/reasoning-content/exchanges/0/response.json new file mode 100644 index 000000000..75feb2a08 --- /dev/null +++ b/packages/inference-discovery-openai/sessions/openai-responses/gpt-5.5/reasoning-content/exchanges/0/response.json @@ -0,0 +1,107 @@ +{ + "id": "resp_05932fc289e2c490006ae54be2c85887d0946bacd22f3e5a55", + "object": "response", + "created_at": 1793412066, + "status": "completed", + "access_programs": null, + "background": false, + "billing": { + "payer": "developer" + }, + "completed_at": 1793412069, + "error": null, + "frequency_penalty": 0.0, + "incomplete_details": null, + "instructions": null, + "max_output_tokens": null, + "max_tool_calls": null, + "model": "gpt-5.5-2026-04-23", + "moderation": null, + "output": [ + { + "id": "rs_05932fc289e2c490006ae54be392f087d096598f7d9b80b25f", + "type": "reasoning", + "content": [], + "encrypted_content": "gAAAAABq5Uvl6eiF4I8eTWC177QLenDms4k7CCVOko-YOgj_gGurufVyvt-yakUjEHjp8FVybMqtx1rwQODCS-pqzVyq755XvrXVFyP2AaCBffb_NSZ7F9u3UkQe0IZpY1YEGu-0ECQjeKW4sW7w9Bqz7Lqdz2G0RO6TP-oDUnU6cVRLzKpZlsxV9qSOkX7FTpi0WdbQmq7InwF-s2lC2UxxrCzRetIbhbGESt3LhG42GB4so9KSc1CzsRhqkQnpFyuhSVQsnxxBKq0nlPRyiZV9V_XkE408W1osMH_jAhC5tmLfir0YX3ENLZNuGlWve-axTuF_dOPd9PA0KW6-RmqUNRlzE8P93PX1ZVEyueu0Ng-2IRqpCDuz7WL_VEkRcGaR2V4LfT7JYiy3JFoqXwEUhNJ6w268jCEiD7ai8pCpUi5I2QFXlNvrjPom_MV9M8okUkIEb41ZgjGi9-NwQOHkzwEg4XAwtu4uD6SxFtFCpBnnv7Eb5XP9qTNRexm4zElnx2DK59wv5z1K5K4Jh1ic1UM1WvAU7qZORKHtGV0sAG9lBcGTffSP-Nf3CfVX0zYopEwax08Bg3XDM4QsWO4VttHYXAG_mXhChbsKQsJ42xTNOb8HyywaSduKOP8z3ZTxKwT-eZ5iidNDv3rk9fwW9CBdtN6jT31Zz1heOrphHFevy4mbchzBzpFAckTtxFLlGkUFZBsLUA2XKVWgzQTuS0_IaE5XSAGr5F9xPQoISlguzw6uhhLqI1Qr3jSr09PuVnk3uXGaqZBHClGUmfP8zKSMwNPewig0xukv9evwooZ8AnRIuIBM5bb2eS8VssLiHFYboJzE4KMznVckBoiAfVK8Mpl3QTFiG1nT0Ap1_3X6pIwzDPrnqx15htnucQl2EOyUWx4K0orPbHK_5KRGqRy9pB5e5dm2RRdHZkAigDiSACzqiGurS_UQZ5NxY4mPHXAZP92wzxEc9-fHuUSxz5DlDSf-W201NSG-_1qqZ6Upwca17Y0tL_TTLCrNdH9jMnyoe_X2saSNYCScsTGnz4NhWkklshHmKnkkud42XAKe2Cr53SP2CbHwhGqwClKoGdi_O66NvlAJbTdEINrTqCnXXzo_2ub0T83se7lAsa_hpg-3R9nFPK3d9pNObzYlUaGf3DpS8vGde2soEXDpatpfWcq8B3ZOtClADpicivXW8tvpxWeMosnCevcDLwZ3C4g1LtIdnSBGqsZuF_dH20Nq3vfomu6aceUMAqCd8EiTq5NIiiowQR-KzD-6hPeFQ5v_tw_u6Zw4XmMWwEQ5hOODtrohoo2Uoa91EUeLrk6Y7ewwz9gbc6fM3HjHaUkyfJOyn3LJG5eg6AMiGdg9ZkqCig9wTkMr2PVMFumWAlxu-82MmgJM-uQwhJFtf9AArsXtAM0R6hFzrqNFMf8cLFWPSYlsyxKV6S9q_YddT6fTDFRrfs-vzDZjpQyPkfMm_qceGrRmENsw-mFnwDMA0Pm8w8X0IQsRls36dD4qdseFtqCrybxD_4eujzduO7jdx6ts2d18LGjsFAvm5_lf5XIC5PmR1fqBui5GZGoB742_7acB81EZLgkU3Vzgfuf8wwLUI-Tx6zz9Agh3UjDH-HTU8WKG7Fc2ApKWriGhTWNpOQKOTnYx9fbxGyO2i4P7kSOA7pCtv3bcK2nLG-Xj7M0f-S0MBOv4cXlWSy8beNL0YGmJw3UQAGmP7TVUX22e5Wt1hBgX", + "summary": [ + { + "type": "summary_text", + "text": "**Clarifying my approach**\n\nI realize I need to provide an answer with clear reasoning before getting to the final conclusion. I want to make sure it's concise, sticking to the point without unnecessary fluff. I'm thinking it's important to be careful in how I express my thoughts, so the reasoning is solid and easily understood. Let\u2019s keep it classic, like the good old five-cent advice! I\u2019m just trying to make it as straightforward as possible." + } + ] + }, + { + "id": "msg_05932fc289e2c490006ae54be4b75487d0b8495fe27b3cc2b4", + "type": "message", + "status": "completed", + "content": [ + { + "type": "output_text", + "annotations": [], + "logprobs": [], + "text": "Let the ball cost **x** dollars.\n\nThen the bat costs **x + 1.00** dollars.\n\nTogether they cost $1.10:\n\n\\[\nx + (x + 1.00) = 1.10\n\\]\n\n\\[\n2x + 1.00 = 1.10\n\\]\n\n\\[\n2x = 0.10\n\\]\n\n\\[\nx = 0.05\n\\]\n\nSo the ball costs **$0.05**, or **5 cents**." + } + ], + "phase": "final_answer", + "role": "assistant" + } + ], + "parallel_tool_calls": true, + "presence_penalty": 0.0, + "previous_response_id": null, + "prompt_cache_key": null, + "prompt_cache_retention": "24h", + "reasoning": { + "context": "current_turn", + "effort": "medium", + "mode": "standard", + "summary": "detailed" + }, + "safety_identifier": null, + "service_tier": "default", + "store": true, + "temperature": 1.0, + "text": { + "format": { + "type": "text" + }, + "verbosity": "medium" + }, + "tool_choice": "auto", + "tool_usage": { + "image_gen": { + "input_tokens": 0, + "input_tokens_details": { + "image_tokens": 0, + "text_tokens": 0 + }, + "output_tokens": 0, + "output_tokens_details": { + "image_tokens": 0, + "text_tokens": 0 + }, + "total_tokens": 0 + }, + "web_search": { + "num_requests": 0 + } + }, + "tools": [], + "top_logprobs": 0, + "top_p": 0.98, + "truncation": "disabled", + "usage": { + "input_tokens": 45, + "input_tokens_details": { + "cache_write_tokens": 0, + "cached_tokens": 0 + }, + "output_tokens": 137, + "output_tokens_details": { + "reasoning_tokens": 24 + }, + "total_tokens": 182 + }, + "user": null, + "metadata": {} +} \ No newline at end of file diff --git a/packages/inference-discovery-openai/sessions/openai-responses/gpt-5.5/reasoning-content/session.json b/packages/inference-discovery-openai/sessions/openai-responses/gpt-5.5/reasoning-content/session.json new file mode 100644 index 000000000..d80a67c64 --- /dev/null +++ b/packages/inference-discovery-openai/sessions/openai-responses/gpt-5.5/reasoning-content/session.json @@ -0,0 +1,11 @@ +{ + "schemaVersion": "2", + "source": { + "provider": "openai-responses", + "model": "gpt-5.5", + "baseURL": "https://api.openai.com/v1" + }, + "origin": "live", + "capturedAt": "2026-10-31T02:01:09.333Z", + "capability": "reasoning-content" +} diff --git a/packages/inference-discovery-openai/sessions/openai-responses/gpt-5.6-luna/function-calling-multi-turn/dispatches/0-get_weather.json b/packages/inference-discovery-openai/sessions/openai-responses/gpt-5.6-luna/function-calling-multi-turn/dispatches/0-get_weather.json new file mode 100644 index 000000000..21f38181b --- /dev/null +++ b/packages/inference-discovery-openai/sessions/openai-responses/gpt-5.6-luna/function-calling-multi-turn/dispatches/0-get_weather.json @@ -0,0 +1,6 @@ +{ + "args": { + "location": "Boston, MA" + }, + "result": "{\"location\":\"Boston, MA\",\"temperatureF\":68,\"conditions\":\"clear\"}" +} diff --git a/packages/inference-discovery-openai/sessions/openai-responses/gpt-5.6-luna/function-calling-multi-turn/exchanges/0/request-headers.json b/packages/inference-discovery-openai/sessions/openai-responses/gpt-5.6-luna/function-calling-multi-turn/exchanges/0/request-headers.json new file mode 100644 index 000000000..28c14bb85 --- /dev/null +++ b/packages/inference-discovery-openai/sessions/openai-responses/gpt-5.6-luna/function-calling-multi-turn/exchanges/0/request-headers.json @@ -0,0 +1,4 @@ +{ + "Content-Type": "application/json", + "Authorization": "" +} diff --git a/packages/inference-discovery-openai/sessions/openai-responses/gpt-5.6-luna/function-calling-multi-turn/exchanges/0/request.json b/packages/inference-discovery-openai/sessions/openai-responses/gpt-5.6-luna/function-calling-multi-turn/exchanges/0/request.json new file mode 100644 index 000000000..5b37c5984 --- /dev/null +++ b/packages/inference-discovery-openai/sessions/openai-responses/gpt-5.6-luna/function-calling-multi-turn/exchanges/0/request.json @@ -0,0 +1,30 @@ +{ + "model": "gpt-5.6-luna", + "input": [ + { + "type": "message", + "role": "user", + "content": "What is the weather in Boston, MA? Use the provided tool." + } + ], + "tools": [ + { + "type": "function", + "name": "get_weather", + "description": "Look up the current weather for a city.", + "parameters": { + "type": "object", + "properties": { + "location": { + "type": "string", + "description": "City and optional region, e.g. 'Boston, MA'." + } + }, + "required": [ + "location" + ] + } + } + ], + "tool_choice": "auto" +} diff --git a/packages/inference-discovery-openai/sessions/openai-responses/gpt-5.6-luna/function-calling-multi-turn/exchanges/0/response-headers.json b/packages/inference-discovery-openai/sessions/openai-responses/gpt-5.6-luna/function-calling-multi-turn/exchanges/0/response-headers.json new file mode 100644 index 000000000..6dad1d172 --- /dev/null +++ b/packages/inference-discovery-openai/sessions/openai-responses/gpt-5.6-luna/function-calling-multi-turn/exchanges/0/response-headers.json @@ -0,0 +1,26 @@ +{ + "access-control-expose-headers": "X-Request-ID, Server-Timing-Total, CF-Ray, CF-Ray", + "alt-svc": "h3=\":443\"; ma=86400", + "cf-cache-status": "DYNAMIC", + "cf-ray": "a52f12e37b986a29-LAX", + "connection": "keep-alive", + "content-encoding": "br", + "content-type": "application/json", + "date": "Sat, 31 Oct 2026 02:01:47 GMT", + "openai-organization": "", + "openai-processing-ms": "907", + "openai-project": "", + "openai-version": "2020-10-01", + "server": "cloudflare", + "strict-transport-security": "max-age=31536000; includeSubDomains; preload", + "transfer-encoding": "chunked", + "x-content-type-options": "nosniff", + "x-ratelimit-limit-requests": "5000", + "x-ratelimit-limit-tokens": "2000000", + "x-ratelimit-remaining-requests": "4999", + "x-ratelimit-remaining-tokens": "2000000", + "x-ratelimit-reset-requests": "12ms", + "x-ratelimit-reset-tokens": "0s", + "x-request-id": "", + "set-cookie": "" +} diff --git a/packages/inference-discovery-openai/sessions/openai-responses/gpt-5.6-luna/function-calling-multi-turn/exchanges/0/response.json b/packages/inference-discovery-openai/sessions/openai-responses/gpt-5.6-luna/function-calling-multi-turn/exchanges/0/response.json new file mode 100644 index 000000000..336956c9e --- /dev/null +++ b/packages/inference-discovery-openai/sessions/openai-responses/gpt-5.6-luna/function-calling-multi-turn/exchanges/0/response.json @@ -0,0 +1,109 @@ +{ + "id": "resp_0cb6ce11918fc1a3006ae54c0adb9487d0948b402aca2b5b03", + "object": "response", + "created_at": 1793412106, + "status": "completed", + "access_programs": null, + "background": false, + "billing": { + "payer": "developer" + }, + "completed_at": 1793412107, + "error": null, + "frequency_penalty": 0.0, + "incomplete_details": null, + "instructions": null, + "max_output_tokens": null, + "max_tool_calls": null, + "model": "gpt-5.6-luna", + "moderation": null, + "output": [ + { + "id": "fc_0cb6ce11918fc1a3006ae54c0b779c87d09ed4efff7421c617", + "type": "function_call", + "status": "completed", + "arguments": "{\"location\":\"Boston, MA\"}", + "call_id": "call_UNhxCsAd5fOWUfmM9TuteCuM", + "name": "get_weather" + } + ], + "parallel_tool_calls": true, + "presence_penalty": 0.0, + "previous_response_id": null, + "prompt_cache_key": null, + "prompt_cache_retention": "24h", + "reasoning": { + "context": "all_turns", + "effort": "medium", + "mode": "standard", + "summary": null + }, + "safety_identifier": null, + "service_tier": "default", + "store": true, + "temperature": 1.0, + "text": { + "format": { + "type": "text" + }, + "verbosity": "medium" + }, + "tool_choice": "auto", + "tool_usage": { + "image_gen": { + "input_tokens": 0, + "input_tokens_details": { + "image_tokens": 0, + "text_tokens": 0 + }, + "output_tokens": 0, + "output_tokens_details": { + "image_tokens": 0, + "text_tokens": 0 + }, + "total_tokens": 0 + }, + "web_search": { + "num_requests": 0 + } + }, + "tools": [ + { + "type": "function", + "description": "Look up the current weather for a city.", + "name": "get_weather", + "output_schema": null, + "parameters": { + "type": "object", + "properties": { + "location": { + "type": "string", + "description": "City and optional region, e.g. 'Boston, MA'." + } + }, + "required": [ + "location" + ], + "additionalProperties": false + }, + "strict": true + } + ], + "top_logprobs": 0, + "top_p": 0.98, + "truncation": "disabled", + "usage": { + "input_tokens": 73, + "input_tokens_details": { + "cache_write_tokens": 0, + "cached_tokens": 0 + }, + "output_tokens": 20, + "output_tokens_details": { + "reasoning_tokens": 0 + }, + "total_tokens": 93 + }, + "user": null, + "metadata": {} +} \ No newline at end of file diff --git a/packages/inference-discovery-openai/sessions/openai-responses/gpt-5.6-luna/function-calling-multi-turn/exchanges/1/request-headers.json b/packages/inference-discovery-openai/sessions/openai-responses/gpt-5.6-luna/function-calling-multi-turn/exchanges/1/request-headers.json new file mode 100644 index 000000000..28c14bb85 --- /dev/null +++ b/packages/inference-discovery-openai/sessions/openai-responses/gpt-5.6-luna/function-calling-multi-turn/exchanges/1/request-headers.json @@ -0,0 +1,4 @@ +{ + "Content-Type": "application/json", + "Authorization": "" +} diff --git a/packages/inference-discovery-openai/sessions/openai-responses/gpt-5.6-luna/function-calling-multi-turn/exchanges/1/request.json b/packages/inference-discovery-openai/sessions/openai-responses/gpt-5.6-luna/function-calling-multi-turn/exchanges/1/request.json new file mode 100644 index 000000000..3d9bd0cbe --- /dev/null +++ b/packages/inference-discovery-openai/sessions/openai-responses/gpt-5.6-luna/function-calling-multi-turn/exchanges/1/request.json @@ -0,0 +1,45 @@ +{ + "model": "gpt-5.6-luna", + "input": [ + { + "type": "message", + "role": "user", + "content": "What is the weather in Boston, MA? Use the provided tool." + }, + { + "type": "function_call", + "call_id": "call_UNhxCsAd5fOWUfmM9TuteCuM", + "name": "get_weather", + "arguments": "{\"location\":\"Boston, MA\"}" + }, + { + "type": "function_call_output", + "call_id": "call_UNhxCsAd5fOWUfmM9TuteCuM", + "output": "{\"location\":\"Boston, MA\",\"temperatureF\":68,\"conditions\":\"clear\"}" + } + ], + "store": false, + "include": [ + "reasoning.encrypted_content" + ], + "tools": [ + { + "type": "function", + "name": "get_weather", + "description": "Look up the current weather for a city.", + "parameters": { + "type": "object", + "properties": { + "location": { + "type": "string", + "description": "City and optional region, e.g. 'Boston, MA'." + } + }, + "required": [ + "location" + ] + } + } + ], + "tool_choice": "auto" +} diff --git a/packages/inference-discovery-openai/sessions/openai-responses/gpt-5.6-luna/function-calling-multi-turn/exchanges/1/response-headers.json b/packages/inference-discovery-openai/sessions/openai-responses/gpt-5.6-luna/function-calling-multi-turn/exchanges/1/response-headers.json new file mode 100644 index 000000000..fe8eed529 --- /dev/null +++ b/packages/inference-discovery-openai/sessions/openai-responses/gpt-5.6-luna/function-calling-multi-turn/exchanges/1/response-headers.json @@ -0,0 +1,26 @@ +{ + "access-control-expose-headers": "X-Request-ID, Server-Timing-Total, CF-Ray, CF-Ray", + "alt-svc": "h3=\":443\"; ma=86400", + "cf-cache-status": "DYNAMIC", + "cf-ray": "a52f12e9bc696a29-LAX", + "connection": "keep-alive", + "content-encoding": "br", + "content-type": "application/json", + "date": "Sat, 31 Oct 2026 02:01:48 GMT", + "openai-organization": "", + "openai-processing-ms": "768", + "openai-project": "", + "openai-version": "2020-10-01", + "server": "cloudflare", + "strict-transport-security": "max-age=31536000; includeSubDomains; preload", + "transfer-encoding": "chunked", + "x-content-type-options": "nosniff", + "x-ratelimit-limit-requests": "5000", + "x-ratelimit-limit-tokens": "2000000", + "x-ratelimit-remaining-requests": "4999", + "x-ratelimit-remaining-tokens": "2000000", + "x-ratelimit-reset-requests": "12ms", + "x-ratelimit-reset-tokens": "0s", + "x-request-id": "", + "set-cookie": "" +} diff --git a/packages/inference-discovery-openai/sessions/openai-responses/gpt-5.6-luna/function-calling-multi-turn/exchanges/1/response.json b/packages/inference-discovery-openai/sessions/openai-responses/gpt-5.6-luna/function-calling-multi-turn/exchanges/1/response.json new file mode 100644 index 000000000..ad4c42a86 --- /dev/null +++ b/packages/inference-discovery-openai/sessions/openai-responses/gpt-5.6-luna/function-calling-multi-turn/exchanges/1/response.json @@ -0,0 +1,116 @@ +{ + "id": "resp_0aeafec834147341016ae54c0be0d087d0a455822a5763bc20", + "object": "response", + "created_at": 1793412107, + "status": "completed", + "access_programs": null, + "background": false, + "billing": { + "payer": "developer" + }, + "completed_at": 1793412108, + "error": null, + "frequency_penalty": 0.0, + "incomplete_details": null, + "instructions": null, + "max_output_tokens": null, + "max_tool_calls": null, + "model": "gpt-5.6-luna", + "moderation": null, + "output": [ + { + "id": "msg_0aeafec834147341016ae54c0c4b2087d09e6e15e9cb4ef69e", + "type": "message", + "status": "completed", + "content": [ + { + "type": "output_text", + "annotations": [], + "logprobs": [], + "text": "The weather in Boston, MA is **68\u00b0F and clear**." + } + ], + "phase": "final_answer", + "role": "assistant" + } + ], + "parallel_tool_calls": true, + "presence_penalty": 0.0, + "previous_response_id": null, + "prompt_cache_key": null, + "prompt_cache_retention": "24h", + "reasoning": { + "context": "all_turns", + "effort": "medium", + "mode": "standard", + "summary": null + }, + "safety_identifier": null, + "service_tier": "default", + "store": false, + "temperature": 1.0, + "text": { + "format": { + "type": "text" + }, + "verbosity": "medium" + }, + "tool_choice": "auto", + "tool_usage": { + "image_gen": { + "input_tokens": 0, + "input_tokens_details": { + "image_tokens": 0, + "text_tokens": 0 + }, + "output_tokens": 0, + "output_tokens_details": { + "image_tokens": 0, + "text_tokens": 0 + }, + "total_tokens": 0 + }, + "web_search": { + "num_requests": 0 + } + }, + "tools": [ + { + "type": "function", + "description": "Look up the current weather for a city.", + "name": "get_weather", + "output_schema": null, + "parameters": { + "type": "object", + "properties": { + "location": { + "type": "string", + "description": "City and optional region, e.g. 'Boston, MA'." + } + }, + "required": [ + "location" + ], + "additionalProperties": false + }, + "strict": true + } + ], + "top_logprobs": 0, + "top_p": 0.98, + "truncation": "disabled", + "usage": { + "input_tokens": 120, + "input_tokens_details": { + "cache_write_tokens": 0, + "cached_tokens": 0 + }, + "output_tokens": 18, + "output_tokens_details": { + "reasoning_tokens": 0 + }, + "total_tokens": 138 + }, + "user": null, + "metadata": {} +} \ No newline at end of file diff --git a/packages/inference-discovery-openai/sessions/openai-responses/gpt-5.6-luna/function-calling-multi-turn/session.json b/packages/inference-discovery-openai/sessions/openai-responses/gpt-5.6-luna/function-calling-multi-turn/session.json new file mode 100644 index 000000000..dab10be69 --- /dev/null +++ b/packages/inference-discovery-openai/sessions/openai-responses/gpt-5.6-luna/function-calling-multi-turn/session.json @@ -0,0 +1,11 @@ +{ + "schemaVersion": "2", + "source": { + "provider": "openai-responses", + "model": "gpt-5.6-luna", + "baseURL": "https://api.openai.com/v1" + }, + "origin": "live", + "capturedAt": "2026-10-31T02:01:48.652Z", + "capability": "function-calling-multi-turn" +} diff --git a/packages/inference-discovery-openai/sessions/openai-responses/gpt-5.6-luna/plain-text-streaming/exchanges/0/request-headers.json b/packages/inference-discovery-openai/sessions/openai-responses/gpt-5.6-luna/plain-text-streaming/exchanges/0/request-headers.json new file mode 100644 index 000000000..28c14bb85 --- /dev/null +++ b/packages/inference-discovery-openai/sessions/openai-responses/gpt-5.6-luna/plain-text-streaming/exchanges/0/request-headers.json @@ -0,0 +1,4 @@ +{ + "Content-Type": "application/json", + "Authorization": "" +} diff --git a/packages/inference-discovery-openai/sessions/openai-responses/gpt-5.6-luna/plain-text-streaming/exchanges/0/request.json b/packages/inference-discovery-openai/sessions/openai-responses/gpt-5.6-luna/plain-text-streaming/exchanges/0/request.json new file mode 100644 index 000000000..b11f87ff1 --- /dev/null +++ b/packages/inference-discovery-openai/sessions/openai-responses/gpt-5.6-luna/plain-text-streaming/exchanges/0/request.json @@ -0,0 +1,11 @@ +{ + "model": "gpt-5.6-luna", + "input": [ + { + "type": "message", + "role": "user", + "content": "Reply with a single sentence: the capital of France is Paris." + } + ], + "stream": true +} diff --git a/packages/inference-discovery-openai/sessions/openai-responses/gpt-5.6-luna/plain-text-streaming/exchanges/0/response-headers.json b/packages/inference-discovery-openai/sessions/openai-responses/gpt-5.6-luna/plain-text-streaming/exchanges/0/response-headers.json new file mode 100644 index 000000000..f3f23ef82 --- /dev/null +++ b/packages/inference-discovery-openai/sessions/openai-responses/gpt-5.6-luna/plain-text-streaming/exchanges/0/response-headers.json @@ -0,0 +1,25 @@ +{ + "access-control-expose-headers": "X-Request-ID, Server-Timing-Total, CF-Ray, CF-Ray", + "alt-svc": "h3=\":443\"; ma=86400", + "cf-cache-status": "DYNAMIC", + "cf-ray": "a5281b4c9b03b860-LAX", + "connection": "keep-alive", + "content-type": "text/event-stream; charset=utf-8", + "date": "Fri, 30 Oct 2026 05:44:11 GMT", + "openai-organization": "", + "openai-processing-ms": "263", + "openai-project": "", + "openai-version": "2020-10-01", + "server": "cloudflare", + "strict-transport-security": "max-age=31536000; includeSubDomains; preload", + "transfer-encoding": "chunked", + "x-content-type-options": "nosniff", + "x-ratelimit-limit-requests": "5000", + "x-ratelimit-limit-tokens": "2000000", + "x-ratelimit-remaining-requests": "4999", + "x-ratelimit-remaining-tokens": "1999838", + "x-ratelimit-reset-requests": "12ms", + "x-ratelimit-reset-tokens": "4ms", + "x-request-id": "", + "set-cookie": "" +} diff --git a/packages/inference-discovery-openai/sessions/openai-responses/gpt-5.6-luna/plain-text-streaming/exchanges/0/response.sse b/packages/inference-discovery-openai/sessions/openai-responses/gpt-5.6-luna/plain-text-streaming/exchanges/0/response.sse new file mode 100644 index 000000000..523445756 --- /dev/null +++ b/packages/inference-discovery-openai/sessions/openai-responses/gpt-5.6-luna/plain-text-streaming/exchanges/0/response.sse @@ -0,0 +1,45 @@ +event: response.created +data: {"type":"response.created","response":{"id":"resp_0ea38739c4a392f7006ae42eab0f9487d08ecf62d95ad2e194","object":"response","created_at":1793339051,"status":"in_progress","access_programs":null,"background":false,"completed_at":null,"error":null,"frequency_penalty":0.0,"incomplete_details":null,"instructions":null,"max_output_tokens":null,"max_tool_calls":null,"model":"gpt-5.6-luna","moderation":null,"output":[],"parallel_tool_calls":true,"presence_penalty":0.0,"previous_response_id":null,"prompt_cache_key":null,"prompt_cache_retention":"24h","reasoning":{"context":"all_turns","effort":"medium","mode":"standard","summary":null},"safety_identifier":null,"service_tier":"auto","store":true,"temperature":1.0,"text":{"format":{"type":"text"},"verbosity":"medium"},"tool_choice":"auto","tool_usage":{"image_gen":{"input_tokens":0,"input_tokens_details":{"image_tokens":0,"text_tokens":0},"output_tokens":0,"output_tokens_details":{"image_tokens":0,"text_tokens":0},"total_tokens":0},"web_search":{"num_requests":0}},"tools":[],"top_logprobs":0,"top_p":0.98,"truncation":"disabled","usage":null,"user":null,"metadata":{}},"sequence_number":0} + +event: response.in_progress +data: {"type":"response.in_progress","response":{"id":"resp_0ea38739c4a392f7006ae42eab0f9487d08ecf62d95ad2e194","object":"response","created_at":1793339051,"status":"in_progress","access_programs":null,"background":false,"completed_at":null,"error":null,"frequency_penalty":0.0,"incomplete_details":null,"instructions":null,"max_output_tokens":null,"max_tool_calls":null,"model":"gpt-5.6-luna","moderation":null,"output":[],"parallel_tool_calls":true,"presence_penalty":0.0,"previous_response_id":null,"prompt_cache_key":null,"prompt_cache_retention":"24h","reasoning":{"context":"all_turns","effort":"medium","mode":"standard","summary":null},"safety_identifier":null,"service_tier":"auto","store":true,"temperature":1.0,"text":{"format":{"type":"text"},"verbosity":"medium"},"tool_choice":"auto","tool_usage":{"image_gen":{"input_tokens":0,"input_tokens_details":{"image_tokens":0,"text_tokens":0},"output_tokens":0,"output_tokens_details":{"image_tokens":0,"text_tokens":0},"total_tokens":0},"web_search":{"num_requests":0}},"tools":[],"top_logprobs":0,"top_p":0.98,"truncation":"disabled","usage":null,"user":null,"metadata":{}},"sequence_number":1} + +event: response.output_item.added +data: {"type":"response.output_item.added","item":{"id":"msg_0ea38739c4a392f7006ae42eab88a087d097837e246f4be04c","type":"message","status":"in_progress","content":[],"phase":"final_answer","role":"assistant"},"output_index":0,"sequence_number":2} + +event: response.content_part.added +data: {"type":"response.content_part.added","content_index":0,"item_id":"msg_0ea38739c4a392f7006ae42eab88a087d097837e246f4be04c","output_index":0,"part":{"type":"output_text","annotations":[],"logprobs":[],"text":""},"sequence_number":3} + +event: response.output_text.delta +data: {"type":"response.output_text.delta","content_index":0,"delta":"The","item_id":"msg_0ea38739c4a392f7006ae42eab88a087d097837e246f4be04c","logprobs":[],"obfuscation":"Hd2hBQ4PxSKFs","output_index":0,"sequence_number":4} + +event: response.output_text.delta +data: {"type":"response.output_text.delta","content_index":0,"delta":" capital","item_id":"msg_0ea38739c4a392f7006ae42eab88a087d097837e246f4be04c","logprobs":[],"obfuscation":"QQDU0rTi","output_index":0,"sequence_number":5} + +event: response.output_text.delta +data: {"type":"response.output_text.delta","content_index":0,"delta":" of","item_id":"msg_0ea38739c4a392f7006ae42eab88a087d097837e246f4be04c","logprobs":[],"obfuscation":"ZciKvNgnBUZsu","output_index":0,"sequence_number":6} + +event: response.output_text.delta +data: {"type":"response.output_text.delta","content_index":0,"delta":" France","item_id":"msg_0ea38739c4a392f7006ae42eab88a087d097837e246f4be04c","logprobs":[],"obfuscation":"8s3wtIB8Z","output_index":0,"sequence_number":7} + +event: response.output_text.delta +data: {"type":"response.output_text.delta","content_index":0,"delta":" is","item_id":"msg_0ea38739c4a392f7006ae42eab88a087d097837e246f4be04c","logprobs":[],"obfuscation":"1olNjsr0wywD9","output_index":0,"sequence_number":8} + +event: response.output_text.delta +data: {"type":"response.output_text.delta","content_index":0,"delta":" Paris","item_id":"msg_0ea38739c4a392f7006ae42eab88a087d097837e246f4be04c","logprobs":[],"obfuscation":"a0SvlSOHPg","output_index":0,"sequence_number":9} + +event: response.output_text.delta +data: {"type":"response.output_text.delta","content_index":0,"delta":".","item_id":"msg_0ea38739c4a392f7006ae42eab88a087d097837e246f4be04c","logprobs":[],"obfuscation":"X9hdfBiLEiMoC2Y","output_index":0,"sequence_number":10} + +event: response.output_text.done +data: {"type":"response.output_text.done","content_index":0,"item_id":"msg_0ea38739c4a392f7006ae42eab88a087d097837e246f4be04c","logprobs":[],"output_index":0,"sequence_number":11,"text":"The capital of France is Paris."} + +event: response.content_part.done +data: {"type":"response.content_part.done","content_index":0,"item_id":"msg_0ea38739c4a392f7006ae42eab88a087d097837e246f4be04c","output_index":0,"part":{"type":"output_text","annotations":[],"logprobs":[],"text":"The capital of France is Paris."},"sequence_number":12} + +event: response.output_item.done +data: {"type":"response.output_item.done","item":{"id":"msg_0ea38739c4a392f7006ae42eab88a087d097837e246f4be04c","type":"message","status":"completed","content":[{"type":"output_text","annotations":[],"logprobs":[],"text":"The capital of France is Paris."}],"phase":"final_answer","role":"assistant"},"output_index":0,"sequence_number":13} + +event: response.completed +data: {"type":"response.completed","response":{"id":"resp_0ea38739c4a392f7006ae42eab0f9487d08ecf62d95ad2e194","object":"response","created_at":1793339051,"status":"completed","access_programs":null,"background":false,"completed_at":1793339051,"error":null,"frequency_penalty":0.0,"incomplete_details":null,"instructions":null,"max_output_tokens":null,"max_tool_calls":null,"model":"gpt-5.6-luna","moderation":null,"output":[{"id":"msg_0ea38739c4a392f7006ae42eab88a087d097837e246f4be04c","type":"message","status":"completed","content":[{"type":"output_text","annotations":[],"logprobs":[],"text":"The capital of France is Paris."}],"phase":"final_answer","role":"assistant"}],"parallel_tool_calls":true,"presence_penalty":0.0,"previous_response_id":null,"prompt_cache_key":null,"prompt_cache_retention":"24h","reasoning":{"context":"all_turns","effort":"medium","mode":"standard","summary":null},"safety_identifier":null,"service_tier":"default","store":true,"temperature":1.0,"text":{"format":{"type":"text"},"verbosity":"medium"},"tool_choice":"auto","tool_usage":{"image_gen":{"input_tokens":0,"input_tokens_details":{"image_tokens":0,"text_tokens":0},"output_tokens":0,"output_tokens_details":{"image_tokens":0,"text_tokens":0},"total_tokens":0},"web_search":{"num_requests":0}},"tools":[],"top_logprobs":0,"top_p":0.98,"truncation":"disabled","usage":{"input_tokens":19,"input_tokens_details":{"cache_write_tokens":0,"cached_tokens":0},"output_tokens":11,"output_tokens_details":{"reasoning_tokens":0},"total_tokens":30},"user":null,"metadata":{}},"sequence_number":14} + diff --git a/packages/inference-discovery-openai/sessions/openai-responses/gpt-5.6-luna/plain-text-streaming/session.json b/packages/inference-discovery-openai/sessions/openai-responses/gpt-5.6-luna/plain-text-streaming/session.json new file mode 100644 index 000000000..5c996bac2 --- /dev/null +++ b/packages/inference-discovery-openai/sessions/openai-responses/gpt-5.6-luna/plain-text-streaming/session.json @@ -0,0 +1,11 @@ +{ + "schemaVersion": "2", + "source": { + "provider": "openai-responses", + "model": "gpt-5.6-luna", + "baseURL": "https://api.openai.com/v1" + }, + "origin": "live", + "capturedAt": "2026-10-30T05:44:11.844Z", + "capability": "plain-text-streaming" +} diff --git a/packages/inference-discovery-openai/sessions/openai-responses/gpt-5.6-luna/plain-text/exchanges/0/request-headers.json b/packages/inference-discovery-openai/sessions/openai-responses/gpt-5.6-luna/plain-text/exchanges/0/request-headers.json new file mode 100644 index 000000000..28c14bb85 --- /dev/null +++ b/packages/inference-discovery-openai/sessions/openai-responses/gpt-5.6-luna/plain-text/exchanges/0/request-headers.json @@ -0,0 +1,4 @@ +{ + "Content-Type": "application/json", + "Authorization": "" +} diff --git a/packages/inference-discovery-openai/sessions/openai-responses/gpt-5.6-luna/plain-text/exchanges/0/request.json b/packages/inference-discovery-openai/sessions/openai-responses/gpt-5.6-luna/plain-text/exchanges/0/request.json new file mode 100644 index 000000000..586cf78a8 --- /dev/null +++ b/packages/inference-discovery-openai/sessions/openai-responses/gpt-5.6-luna/plain-text/exchanges/0/request.json @@ -0,0 +1,10 @@ +{ + "model": "gpt-5.6-luna", + "input": [ + { + "type": "message", + "role": "user", + "content": "Reply with a single sentence: the capital of France is Paris." + } + ] +} diff --git a/packages/inference-discovery-openai/sessions/openai-responses/gpt-5.6-luna/plain-text/exchanges/0/response-headers.json b/packages/inference-discovery-openai/sessions/openai-responses/gpt-5.6-luna/plain-text/exchanges/0/response-headers.json new file mode 100644 index 000000000..62793021d --- /dev/null +++ b/packages/inference-discovery-openai/sessions/openai-responses/gpt-5.6-luna/plain-text/exchanges/0/response-headers.json @@ -0,0 +1,26 @@ +{ + "access-control-expose-headers": "X-Request-ID, Server-Timing-Total, CF-Ray, CF-Ray", + "alt-svc": "h3=\":443\"; ma=86400", + "cf-cache-status": "DYNAMIC", + "cf-ray": "a5281b472a57b860-LAX", + "connection": "keep-alive", + "content-encoding": "br", + "content-type": "application/json", + "date": "Fri, 30 Oct 2026 05:44:10 GMT", + "openai-organization": "", + "openai-processing-ms": "791", + "openai-project": "", + "openai-version": "2020-10-01", + "server": "cloudflare", + "strict-transport-security": "max-age=31536000; includeSubDomains; preload", + "transfer-encoding": "chunked", + "x-content-type-options": "nosniff", + "x-ratelimit-limit-requests": "5000", + "x-ratelimit-limit-tokens": "2000000", + "x-ratelimit-remaining-requests": "4999", + "x-ratelimit-remaining-tokens": "2000000", + "x-ratelimit-reset-requests": "12ms", + "x-ratelimit-reset-tokens": "0s", + "x-request-id": "", + "set-cookie": "" +} diff --git a/packages/inference-discovery-openai/sessions/openai-responses/gpt-5.6-luna/plain-text/exchanges/0/response.json b/packages/inference-discovery-openai/sessions/openai-responses/gpt-5.6-luna/plain-text/exchanges/0/response.json new file mode 100644 index 000000000..ca4b95326 --- /dev/null +++ b/packages/inference-discovery-openai/sessions/openai-responses/gpt-5.6-luna/plain-text/exchanges/0/response.json @@ -0,0 +1,95 @@ +{ + "id": "resp_083740cbe565bc57006ae42eaa29e087d08890c91336059505", + "object": "response", + "created_at": 1793339050, + "status": "completed", + "access_programs": null, + "background": false, + "billing": { + "payer": "developer" + }, + "completed_at": 1793339050, + "error": null, + "frequency_penalty": 0.0, + "incomplete_details": null, + "instructions": null, + "max_output_tokens": null, + "max_tool_calls": null, + "model": "gpt-5.6-luna", + "moderation": null, + "output": [ + { + "id": "msg_083740cbe565bc57006ae42eaab31487d08427ab605ae7f528", + "type": "message", + "status": "completed", + "content": [ + { + "type": "output_text", + "annotations": [], + "logprobs": [], + "text": "The capital of France is Paris." + } + ], + "phase": "final_answer", + "role": "assistant" + } + ], + "parallel_tool_calls": true, + "presence_penalty": 0.0, + "previous_response_id": null, + "prompt_cache_key": null, + "prompt_cache_retention": "24h", + "reasoning": { + "context": "all_turns", + "effort": "medium", + "mode": "standard", + "summary": null + }, + "safety_identifier": null, + "service_tier": "default", + "store": true, + "temperature": 1.0, + "text": { + "format": { + "type": "text" + }, + "verbosity": "medium" + }, + "tool_choice": "auto", + "tool_usage": { + "image_gen": { + "input_tokens": 0, + "input_tokens_details": { + "image_tokens": 0, + "text_tokens": 0 + }, + "output_tokens": 0, + "output_tokens_details": { + "image_tokens": 0, + "text_tokens": 0 + }, + "total_tokens": 0 + }, + "web_search": { + "num_requests": 0 + } + }, + "tools": [], + "top_logprobs": 0, + "top_p": 0.98, + "truncation": "disabled", + "usage": { + "input_tokens": 19, + "input_tokens_details": { + "cache_write_tokens": 0, + "cached_tokens": 0 + }, + "output_tokens": 11, + "output_tokens_details": { + "reasoning_tokens": 0 + }, + "total_tokens": 30 + }, + "user": null, + "metadata": {} +} \ No newline at end of file diff --git a/packages/inference-discovery-openai/sessions/openai-responses/gpt-5.6-luna/plain-text/session.json b/packages/inference-discovery-openai/sessions/openai-responses/gpt-5.6-luna/plain-text/session.json new file mode 100644 index 000000000..11a6ad3c7 --- /dev/null +++ b/packages/inference-discovery-openai/sessions/openai-responses/gpt-5.6-luna/plain-text/session.json @@ -0,0 +1,11 @@ +{ + "schemaVersion": "2", + "source": { + "provider": "openai-responses", + "model": "gpt-5.6-luna", + "baseURL": "https://api.openai.com/v1" + }, + "origin": "live", + "capturedAt": "2026-10-30T05:44:10.961Z", + "capability": "plain-text" +} diff --git a/packages/inference-discovery-openai/sessions/openai-responses/gpt-5.6-luna/reasoning-content/exchanges/0/request-headers.json b/packages/inference-discovery-openai/sessions/openai-responses/gpt-5.6-luna/reasoning-content/exchanges/0/request-headers.json new file mode 100644 index 000000000..28c14bb85 --- /dev/null +++ b/packages/inference-discovery-openai/sessions/openai-responses/gpt-5.6-luna/reasoning-content/exchanges/0/request-headers.json @@ -0,0 +1,4 @@ +{ + "Content-Type": "application/json", + "Authorization": "" +} diff --git a/packages/inference-discovery-openai/sessions/openai-responses/gpt-5.6-luna/reasoning-content/exchanges/0/request.json b/packages/inference-discovery-openai/sessions/openai-responses/gpt-5.6-luna/reasoning-content/exchanges/0/request.json new file mode 100644 index 000000000..83212b4ad --- /dev/null +++ b/packages/inference-discovery-openai/sessions/openai-responses/gpt-5.6-luna/reasoning-content/exchanges/0/request.json @@ -0,0 +1,14 @@ +{ + "model": "gpt-5.6-luna", + "input": [ + { + "type": "message", + "role": "user", + "content": "A bat and a ball cost $1.10 together. The bat costs $1.00 more than the ball. How much does the ball cost? Show your reasoning before the final answer." + } + ], + "reasoning": { + "effort": "medium", + "summary": "detailed" + } +} diff --git a/packages/inference-discovery-openai/sessions/openai-responses/gpt-5.6-luna/reasoning-content/exchanges/0/response-headers.json b/packages/inference-discovery-openai/sessions/openai-responses/gpt-5.6-luna/reasoning-content/exchanges/0/response-headers.json new file mode 100644 index 000000000..be171ae5e --- /dev/null +++ b/packages/inference-discovery-openai/sessions/openai-responses/gpt-5.6-luna/reasoning-content/exchanges/0/response-headers.json @@ -0,0 +1,26 @@ +{ + "access-control-expose-headers": "X-Request-ID, Server-Timing-Total, CF-Ray, CF-Ray", + "alt-svc": "h3=\":443\"; ma=86400", + "cf-cache-status": "DYNAMIC", + "cf-ray": "a52f12ef2e466a29-LAX", + "connection": "keep-alive", + "content-encoding": "br", + "content-type": "application/json", + "date": "Sat, 31 Oct 2026 02:01:51 GMT", + "openai-organization": "", + "openai-processing-ms": "2594", + "openai-project": "", + "openai-version": "2020-10-01", + "server": "cloudflare", + "strict-transport-security": "max-age=31536000; includeSubDomains; preload", + "transfer-encoding": "chunked", + "x-content-type-options": "nosniff", + "x-ratelimit-limit-requests": "5000", + "x-ratelimit-limit-tokens": "2000000", + "x-ratelimit-remaining-requests": "4999", + "x-ratelimit-remaining-tokens": "2000000", + "x-ratelimit-reset-requests": "12ms", + "x-ratelimit-reset-tokens": "0s", + "x-request-id": "", + "set-cookie": "" +} diff --git a/packages/inference-discovery-openai/sessions/openai-responses/gpt-5.6-luna/reasoning-content/exchanges/0/response.json b/packages/inference-discovery-openai/sessions/openai-responses/gpt-5.6-luna/reasoning-content/exchanges/0/response.json new file mode 100644 index 000000000..9bda03f2a --- /dev/null +++ b/packages/inference-discovery-openai/sessions/openai-responses/gpt-5.6-luna/reasoning-content/exchanges/0/response.json @@ -0,0 +1,107 @@ +{ + "id": "resp_02a9b72448a865c5006ae54c0cbbfc87d0b18d8f23ab7a2073", + "object": "response", + "created_at": 1793412108, + "status": "completed", + "access_programs": null, + "background": false, + "billing": { + "payer": "developer" + }, + "completed_at": 1793412111, + "error": null, + "frequency_penalty": 0.0, + "incomplete_details": null, + "instructions": null, + "max_output_tokens": null, + "max_tool_calls": null, + "model": "gpt-5.6-luna", + "moderation": null, + "output": [ + { + "id": "rs_02a9b72448a865c5006ae54c0d339087d097a802c5cc797649", + "type": "reasoning", + "content": [], + "encrypted_content": "gAAAAABq5UwP90cORDa30IpnHUBL8cxiwDQj-D2eXT6z1GZyhG9Md4-eUOCH1tpxJhaedMSj3d--dVijDdw9XisBwBUw9LjWvzf6-ebenfrFv1PLPpoHpIZrTLfjuzzh0rMrcaGlO_jI845Dcwl1rEwxcZCcnFbP_umdH-b9LztWVnKeCEHbj0uTm4M1Ag4LRD4qYTw1H8qvD-an3WKnq8jC_cvWQbA_-lRlv6OeSAny3KAYRJWx3Hr8bQ1Aaw-NvMt0KJ6gyc_dQCEGZN8HrQJWy-VL1fPfStnoOHym13SxHNFvtiZ53QPZZejDQje2rB6vKcPLGyp1t8nt7flEOOiGEbAyvqTCvUKI53RGcByusq8YkkLvLXSD-T5eGchu027EHsLlbk5btxUwm4UAG-tW2oZikJ7T56cNosgPaJEF7vRFgEVjRRjh3--Gze8fCpZ8hJDsvt-mpQsJNw_RYoo4mUc3YjoOuYg4Yu-_UNgearTg0mPgRixIDcjuunCXiOEx6bwmHZu3GQ67yotIkYKXiSTb-QKbr212TCxwABqW1zyZW0jCqhhD8Zvnp_ZDHwGl8Gj6TZ15VDfxUbC6x4SARWzFuFFXCFyHMkrQk5rBpf5rEfIdmUzTN2wsjZFn-MDQWH6NyeiXyRK2UCUf7uRGKojfbbjv3NMGr4TSVGQ_g04K2Wmeva79TaAxFv492SFSxgdcUNSIURSikxvmM85lF8N8pk9qmIHuvgVksgJRjYEwnE77E4etHZqdjuME6Ba5NK99ZIZ5e1qZ0vfrPp-pGt3vk_iwKjAdyDHfKnoyfu5eeC7vFaFjIxZKEmB9yp6OIW98fKdoFDaCItSFoYk1125tqEI4ghOpv3IuBT9zcQttN3utkHegvFDOJ3BfqY9IVsTzZDMkrd0A8ZGZ6wc0IOfLUTNfSEDPDZP50N7sBLJFZ-Y4Huu_QB_gRE3kc6lgogQtX-noN_JcYJQfnZioqgHPVQW2BB_U1cT3n30iNcBDvXdgGPoEcY-BZIQwPmDhe5ULVhSYp6gVgUfqaYKAlG5G0RNhpf9XT4powsDvYDwlUGonJBcvfeyg_RQ6CTAdSdd-ME1K1DT620SCEbLghRBm4V5d4l4Au2NsrNCGbq0Pk48sGIFg-_6Pl3PtQAg_FDQcNHn0ZpQH7awl8ltvcLNx29jRGJh5zuaJoqXfa1Bizm7aR0fW9PLLGysug8ofTAIdqZWNtKrEa2HepCRAfQq224iuLa8v2p8m3YiweBahSFHyhnWO9EVvZekP4m62Q9gh4ylk3zsgSrxJfso2fM6w1P_6kA21ocVhgyYaAUynOvaW2NZsgUmAYMnQPa8DTdCaO3YxbsD8xIRvgXwKy2soCbZv06le36EfKhbm5n9SsWOfNlcRKLMfty-cXEa_GMkhByxYvdxMiAU_RJrPzMIPO6cFbqDGAdX9i44O2pxFHnaZIh4UncRrg_HFWsUqKRyWXXo4Mr1tH2IVQaMBnH3aGnYuQT1OP23yFdsPJ-yxqz3O_TtdfFN0C5zNhyJ1RO0ksCpz9CkDj7ioBHfELpwnAJqkMXTbE1-Kp3J35rI9l2eI6kQnARGkCAdyznmgZubAzlHFEbqUvy_VWBnOIdaDlEaWWiW3EXDhxw0-1yXE5LyiHbZZnIp0CrJemYIY5PupFy82ymHlCZ5zjP-nwjC25PUrdjLwnIdXn4xSxmDrbFq_az8=", + "summary": [ + { + "type": "summary_text", + "text": "**Explaining the reasoning trap**\n\nI need to provide reasoning here and be careful about a potential trap. For the equation, x + x + 1 = 1.10, it may lead to confusion. I should clarify that simplifying it leads to 2x + 1 = 1.10, which requires careful manipulation to avoid mistakes. I want to ensure the user understands how to isolate x correctly and find its value as 0.05. It\u2019s crucial to break this down step by step!" + } + ] + }, + { + "id": "msg_02a9b72448a865c5006ae54c0e7f9c87d0a94fe11de5870cee", + "type": "message", + "status": "completed", + "content": [ + { + "type": "output_text", + "annotations": [], + "logprobs": [], + "text": "Let the ball cost \\(x\\) dollars. Then the bat costs \\(x + \\$1.00\\).\n\n\\[\nx + (x + 1.00) = 1.10\n\\]\n\n\\[\n2x + 1.00 = 1.10\n\\]\n\n\\[\n2x = 0.10\n\\]\n\n\\[\nx = 0.05\n\\]\n\nThe ball costs **\\$0.05 (5 cents)**." + } + ], + "phase": "final_answer", + "role": "assistant" + } + ], + "parallel_tool_calls": true, + "presence_penalty": 0.0, + "previous_response_id": null, + "prompt_cache_key": null, + "prompt_cache_retention": "24h", + "reasoning": { + "context": "all_turns", + "effort": "medium", + "mode": "standard", + "summary": "detailed" + }, + "safety_identifier": null, + "service_tier": "default", + "store": true, + "temperature": 1.0, + "text": { + "format": { + "type": "text" + }, + "verbosity": "medium" + }, + "tool_choice": "auto", + "tool_usage": { + "image_gen": { + "input_tokens": 0, + "input_tokens_details": { + "image_tokens": 0, + "text_tokens": 0 + }, + "output_tokens": 0, + "output_tokens_details": { + "image_tokens": 0, + "text_tokens": 0 + }, + "total_tokens": 0 + }, + "web_search": { + "num_requests": 0 + } + }, + "tools": [], + "top_logprobs": 0, + "top_p": 0.98, + "truncation": "disabled", + "usage": { + "input_tokens": 45, + "input_tokens_details": { + "cache_write_tokens": 0, + "cached_tokens": 0 + }, + "output_tokens": 130, + "output_tokens_details": { + "reasoning_tokens": 28 + }, + "total_tokens": 175 + }, + "user": null, + "metadata": {} +} \ No newline at end of file diff --git a/packages/inference-discovery-openai/sessions/openai-responses/gpt-5.6-luna/reasoning-content/session.json b/packages/inference-discovery-openai/sessions/openai-responses/gpt-5.6-luna/reasoning-content/session.json new file mode 100644 index 000000000..51d13521c --- /dev/null +++ b/packages/inference-discovery-openai/sessions/openai-responses/gpt-5.6-luna/reasoning-content/session.json @@ -0,0 +1,11 @@ +{ + "schemaVersion": "2", + "source": { + "provider": "openai-responses", + "model": "gpt-5.6-luna", + "baseURL": "https://api.openai.com/v1" + }, + "origin": "live", + "capturedAt": "2026-10-31T02:01:51.347Z", + "capability": "reasoning-content" +} diff --git a/packages/inference-discovery-openai/sessions/openai-responses/gpt-5.6-sol/function-calling-multi-turn/dispatches/0-get_weather.json b/packages/inference-discovery-openai/sessions/openai-responses/gpt-5.6-sol/function-calling-multi-turn/dispatches/0-get_weather.json new file mode 100644 index 000000000..21f38181b --- /dev/null +++ b/packages/inference-discovery-openai/sessions/openai-responses/gpt-5.6-sol/function-calling-multi-turn/dispatches/0-get_weather.json @@ -0,0 +1,6 @@ +{ + "args": { + "location": "Boston, MA" + }, + "result": "{\"location\":\"Boston, MA\",\"temperatureF\":68,\"conditions\":\"clear\"}" +} diff --git a/packages/inference-discovery-openai/sessions/openai-responses/gpt-5.6-sol/function-calling-multi-turn/exchanges/0/request-headers.json b/packages/inference-discovery-openai/sessions/openai-responses/gpt-5.6-sol/function-calling-multi-turn/exchanges/0/request-headers.json new file mode 100644 index 000000000..28c14bb85 --- /dev/null +++ b/packages/inference-discovery-openai/sessions/openai-responses/gpt-5.6-sol/function-calling-multi-turn/exchanges/0/request-headers.json @@ -0,0 +1,4 @@ +{ + "Content-Type": "application/json", + "Authorization": "" +} diff --git a/packages/inference-discovery-openai/sessions/openai-responses/gpt-5.6-sol/function-calling-multi-turn/exchanges/0/request.json b/packages/inference-discovery-openai/sessions/openai-responses/gpt-5.6-sol/function-calling-multi-turn/exchanges/0/request.json new file mode 100644 index 000000000..1c3146823 --- /dev/null +++ b/packages/inference-discovery-openai/sessions/openai-responses/gpt-5.6-sol/function-calling-multi-turn/exchanges/0/request.json @@ -0,0 +1,30 @@ +{ + "model": "gpt-5.6-sol", + "input": [ + { + "type": "message", + "role": "user", + "content": "What is the weather in Boston, MA? Use the provided tool." + } + ], + "tools": [ + { + "type": "function", + "name": "get_weather", + "description": "Look up the current weather for a city.", + "parameters": { + "type": "object", + "properties": { + "location": { + "type": "string", + "description": "City and optional region, e.g. 'Boston, MA'." + } + }, + "required": [ + "location" + ] + } + } + ], + "tool_choice": "auto" +} diff --git a/packages/inference-discovery-openai/sessions/openai-responses/gpt-5.6-sol/function-calling-multi-turn/exchanges/0/response-headers.json b/packages/inference-discovery-openai/sessions/openai-responses/gpt-5.6-sol/function-calling-multi-turn/exchanges/0/response-headers.json new file mode 100644 index 000000000..688c26dcf --- /dev/null +++ b/packages/inference-discovery-openai/sessions/openai-responses/gpt-5.6-sol/function-calling-multi-turn/exchanges/0/response-headers.json @@ -0,0 +1,26 @@ +{ + "access-control-expose-headers": "X-Request-ID, Server-Timing-Total, CF-Ray, CF-Ray", + "alt-svc": "h3=\":443\"; ma=86400", + "cf-cache-status": "DYNAMIC", + "cf-ray": "a52f12a42d1c6a29-LAX", + "connection": "keep-alive", + "content-encoding": "br", + "content-type": "application/json", + "date": "Sat, 31 Oct 2026 02:01:37 GMT", + "openai-organization": "", + "openai-processing-ms": "980", + "openai-project": "", + "openai-version": "2020-10-01", + "server": "cloudflare", + "strict-transport-security": "max-age=31536000; includeSubDomains; preload", + "transfer-encoding": "chunked", + "x-content-type-options": "nosniff", + "x-ratelimit-limit-requests": "5000", + "x-ratelimit-limit-tokens": "1000000", + "x-ratelimit-remaining-requests": "4999", + "x-ratelimit-remaining-tokens": "1000000", + "x-ratelimit-reset-requests": "12ms", + "x-ratelimit-reset-tokens": "0s", + "x-request-id": "", + "set-cookie": "" +} diff --git a/packages/inference-discovery-openai/sessions/openai-responses/gpt-5.6-sol/function-calling-multi-turn/exchanges/0/response.json b/packages/inference-discovery-openai/sessions/openai-responses/gpt-5.6-sol/function-calling-multi-turn/exchanges/0/response.json new file mode 100644 index 000000000..c0d95fb94 --- /dev/null +++ b/packages/inference-discovery-openai/sessions/openai-responses/gpt-5.6-sol/function-calling-multi-turn/exchanges/0/response.json @@ -0,0 +1,109 @@ +{ + "id": "resp_09c645473826a18e006ae54c00b80c87d0b5fa5cb29fc3a847", + "object": "response", + "created_at": 1793412096, + "status": "completed", + "access_programs": null, + "background": false, + "billing": { + "payer": "developer" + }, + "completed_at": 1793412097, + "error": null, + "frequency_penalty": 0.0, + "incomplete_details": null, + "instructions": null, + "max_output_tokens": null, + "max_tool_calls": null, + "model": "gpt-5.6-sol", + "moderation": null, + "output": [ + { + "id": "fc_09c645473826a18e006ae54c016c8887d08fc5d87f94e36049", + "type": "function_call", + "status": "completed", + "arguments": "{\"location\":\"Boston, MA\"}", + "call_id": "call_a7YgeYGzw9IjhVcU1lVAmpo0", + "name": "get_weather" + } + ], + "parallel_tool_calls": true, + "presence_penalty": 0.0, + "previous_response_id": null, + "prompt_cache_key": null, + "prompt_cache_retention": "24h", + "reasoning": { + "context": "all_turns", + "effort": "medium", + "mode": "standard", + "summary": null + }, + "safety_identifier": null, + "service_tier": "default", + "store": true, + "temperature": 1.0, + "text": { + "format": { + "type": "text" + }, + "verbosity": "medium" + }, + "tool_choice": "auto", + "tool_usage": { + "image_gen": { + "input_tokens": 0, + "input_tokens_details": { + "image_tokens": 0, + "text_tokens": 0 + }, + "output_tokens": 0, + "output_tokens_details": { + "image_tokens": 0, + "text_tokens": 0 + }, + "total_tokens": 0 + }, + "web_search": { + "num_requests": 0 + } + }, + "tools": [ + { + "type": "function", + "description": "Look up the current weather for a city.", + "name": "get_weather", + "output_schema": null, + "parameters": { + "type": "object", + "properties": { + "location": { + "type": "string", + "description": "City and optional region, e.g. 'Boston, MA'." + } + }, + "required": [ + "location" + ], + "additionalProperties": false + }, + "strict": true + } + ], + "top_logprobs": 0, + "top_p": 0.98, + "truncation": "disabled", + "usage": { + "input_tokens": 73, + "input_tokens_details": { + "cache_write_tokens": 0, + "cached_tokens": 0 + }, + "output_tokens": 20, + "output_tokens_details": { + "reasoning_tokens": 0 + }, + "total_tokens": 93 + }, + "user": null, + "metadata": {} +} \ No newline at end of file diff --git a/packages/inference-discovery-openai/sessions/openai-responses/gpt-5.6-sol/function-calling-multi-turn/exchanges/1/request-headers.json b/packages/inference-discovery-openai/sessions/openai-responses/gpt-5.6-sol/function-calling-multi-turn/exchanges/1/request-headers.json new file mode 100644 index 000000000..28c14bb85 --- /dev/null +++ b/packages/inference-discovery-openai/sessions/openai-responses/gpt-5.6-sol/function-calling-multi-turn/exchanges/1/request-headers.json @@ -0,0 +1,4 @@ +{ + "Content-Type": "application/json", + "Authorization": "" +} diff --git a/packages/inference-discovery-openai/sessions/openai-responses/gpt-5.6-sol/function-calling-multi-turn/exchanges/1/request.json b/packages/inference-discovery-openai/sessions/openai-responses/gpt-5.6-sol/function-calling-multi-turn/exchanges/1/request.json new file mode 100644 index 000000000..75f2d262b --- /dev/null +++ b/packages/inference-discovery-openai/sessions/openai-responses/gpt-5.6-sol/function-calling-multi-turn/exchanges/1/request.json @@ -0,0 +1,45 @@ +{ + "model": "gpt-5.6-sol", + "input": [ + { + "type": "message", + "role": "user", + "content": "What is the weather in Boston, MA? Use the provided tool." + }, + { + "type": "function_call", + "call_id": "call_a7YgeYGzw9IjhVcU1lVAmpo0", + "name": "get_weather", + "arguments": "{\"location\":\"Boston, MA\"}" + }, + { + "type": "function_call_output", + "call_id": "call_a7YgeYGzw9IjhVcU1lVAmpo0", + "output": "{\"location\":\"Boston, MA\",\"temperatureF\":68,\"conditions\":\"clear\"}" + } + ], + "store": false, + "include": [ + "reasoning.encrypted_content" + ], + "tools": [ + { + "type": "function", + "name": "get_weather", + "description": "Look up the current weather for a city.", + "parameters": { + "type": "object", + "properties": { + "location": { + "type": "string", + "description": "City and optional region, e.g. 'Boston, MA'." + } + }, + "required": [ + "location" + ] + } + } + ], + "tool_choice": "auto" +} diff --git a/packages/inference-discovery-openai/sessions/openai-responses/gpt-5.6-sol/function-calling-multi-turn/exchanges/1/response-headers.json b/packages/inference-discovery-openai/sessions/openai-responses/gpt-5.6-sol/function-calling-multi-turn/exchanges/1/response-headers.json new file mode 100644 index 000000000..23716d547 --- /dev/null +++ b/packages/inference-discovery-openai/sessions/openai-responses/gpt-5.6-sol/function-calling-multi-turn/exchanges/1/response-headers.json @@ -0,0 +1,26 @@ +{ + "access-control-expose-headers": "X-Request-ID, Server-Timing-Total, CF-Ray, CF-Ray", + "alt-svc": "h3=\":443\"; ma=86400", + "cf-cache-status": "DYNAMIC", + "cf-ray": "a52f12aabfbc6a29-LAX", + "connection": "keep-alive", + "content-encoding": "br", + "content-type": "application/json", + "date": "Sat, 31 Oct 2026 02:01:38 GMT", + "openai-organization": "", + "openai-processing-ms": "1136", + "openai-project": "", + "openai-version": "2020-10-01", + "server": "cloudflare", + "strict-transport-security": "max-age=31536000; includeSubDomains; preload", + "transfer-encoding": "chunked", + "x-content-type-options": "nosniff", + "x-ratelimit-limit-requests": "5000", + "x-ratelimit-limit-tokens": "1000000", + "x-ratelimit-remaining-requests": "4999", + "x-ratelimit-remaining-tokens": "1000000", + "x-ratelimit-reset-requests": "12ms", + "x-ratelimit-reset-tokens": "0s", + "x-request-id": "", + "set-cookie": "" +} diff --git a/packages/inference-discovery-openai/sessions/openai-responses/gpt-5.6-sol/function-calling-multi-turn/exchanges/1/response.json b/packages/inference-discovery-openai/sessions/openai-responses/gpt-5.6-sol/function-calling-multi-turn/exchanges/1/response.json new file mode 100644 index 000000000..63205b331 --- /dev/null +++ b/packages/inference-discovery-openai/sessions/openai-responses/gpt-5.6-sol/function-calling-multi-turn/exchanges/1/response.json @@ -0,0 +1,116 @@ +{ + "id": "resp_0f2f07b578924b20016ae54c01c8ec87d0bc5d22d33ab47468", + "object": "response", + "created_at": 1793412097, + "status": "completed", + "access_programs": null, + "background": false, + "billing": { + "payer": "developer" + }, + "completed_at": 1793412098, + "error": null, + "frequency_penalty": 0.0, + "incomplete_details": null, + "instructions": null, + "max_output_tokens": null, + "max_tool_calls": null, + "model": "gpt-5.6-sol", + "moderation": null, + "output": [ + { + "id": "msg_0f2f07b578924b20016ae54c02a9b087d0b88904c2aaf81b76", + "type": "message", + "status": "completed", + "content": [ + { + "type": "output_text", + "annotations": [], + "logprobs": [], + "text": "Boston, MA is **68\u00b0F and clear**." + } + ], + "phase": "final_answer", + "role": "assistant" + } + ], + "parallel_tool_calls": true, + "presence_penalty": 0.0, + "previous_response_id": null, + "prompt_cache_key": null, + "prompt_cache_retention": "24h", + "reasoning": { + "context": "all_turns", + "effort": "medium", + "mode": "standard", + "summary": null + }, + "safety_identifier": null, + "service_tier": "default", + "store": false, + "temperature": 1.0, + "text": { + "format": { + "type": "text" + }, + "verbosity": "medium" + }, + "tool_choice": "auto", + "tool_usage": { + "image_gen": { + "input_tokens": 0, + "input_tokens_details": { + "image_tokens": 0, + "text_tokens": 0 + }, + "output_tokens": 0, + "output_tokens_details": { + "image_tokens": 0, + "text_tokens": 0 + }, + "total_tokens": 0 + }, + "web_search": { + "num_requests": 0 + } + }, + "tools": [ + { + "type": "function", + "description": "Look up the current weather for a city.", + "name": "get_weather", + "output_schema": null, + "parameters": { + "type": "object", + "properties": { + "location": { + "type": "string", + "description": "City and optional region, e.g. 'Boston, MA'." + } + }, + "required": [ + "location" + ], + "additionalProperties": false + }, + "strict": true + } + ], + "top_logprobs": 0, + "top_p": 0.98, + "truncation": "disabled", + "usage": { + "input_tokens": 120, + "input_tokens_details": { + "cache_write_tokens": 0, + "cached_tokens": 0 + }, + "output_tokens": 15, + "output_tokens_details": { + "reasoning_tokens": 0 + }, + "total_tokens": 135 + }, + "user": null, + "metadata": {} +} \ No newline at end of file diff --git a/packages/inference-discovery-openai/sessions/openai-responses/gpt-5.6-sol/function-calling-multi-turn/session.json b/packages/inference-discovery-openai/sessions/openai-responses/gpt-5.6-sol/function-calling-multi-turn/session.json new file mode 100644 index 000000000..1a1285599 --- /dev/null +++ b/packages/inference-discovery-openai/sessions/openai-responses/gpt-5.6-sol/function-calling-multi-turn/session.json @@ -0,0 +1,11 @@ +{ + "schemaVersion": "2", + "source": { + "provider": "openai-responses", + "model": "gpt-5.6-sol", + "baseURL": "https://api.openai.com/v1" + }, + "origin": "live", + "capturedAt": "2026-10-31T02:01:38.953Z", + "capability": "function-calling-multi-turn" +} diff --git a/packages/inference-discovery-openai/sessions/openai-responses/gpt-5.6-sol/plain-text-streaming/exchanges/0/request-headers.json b/packages/inference-discovery-openai/sessions/openai-responses/gpt-5.6-sol/plain-text-streaming/exchanges/0/request-headers.json new file mode 100644 index 000000000..28c14bb85 --- /dev/null +++ b/packages/inference-discovery-openai/sessions/openai-responses/gpt-5.6-sol/plain-text-streaming/exchanges/0/request-headers.json @@ -0,0 +1,4 @@ +{ + "Content-Type": "application/json", + "Authorization": "" +} diff --git a/packages/inference-discovery-openai/sessions/openai-responses/gpt-5.6-sol/plain-text-streaming/exchanges/0/request.json b/packages/inference-discovery-openai/sessions/openai-responses/gpt-5.6-sol/plain-text-streaming/exchanges/0/request.json new file mode 100644 index 000000000..a36bacdfa --- /dev/null +++ b/packages/inference-discovery-openai/sessions/openai-responses/gpt-5.6-sol/plain-text-streaming/exchanges/0/request.json @@ -0,0 +1,11 @@ +{ + "model": "gpt-5.6-sol", + "input": [ + { + "type": "message", + "role": "user", + "content": "Reply with a single sentence: the capital of France is Paris." + } + ], + "stream": true +} diff --git a/packages/inference-discovery-openai/sessions/openai-responses/gpt-5.6-sol/plain-text-streaming/exchanges/0/response-headers.json b/packages/inference-discovery-openai/sessions/openai-responses/gpt-5.6-sol/plain-text-streaming/exchanges/0/response-headers.json new file mode 100644 index 000000000..58dbf4dba --- /dev/null +++ b/packages/inference-discovery-openai/sessions/openai-responses/gpt-5.6-sol/plain-text-streaming/exchanges/0/response-headers.json @@ -0,0 +1,25 @@ +{ + "access-control-expose-headers": "X-Request-ID, Server-Timing-Total, CF-Ray, CF-Ray", + "alt-svc": "h3=\":443\"; ma=86400", + "cf-cache-status": "DYNAMIC", + "cf-ray": "a5281af9eaa7ec6b-LAX", + "connection": "keep-alive", + "content-type": "text/event-stream; charset=utf-8", + "date": "Fri, 30 Oct 2026 05:43:58 GMT", + "openai-organization": "", + "openai-processing-ms": "340", + "openai-project": "", + "openai-version": "2020-10-01", + "server": "cloudflare", + "strict-transport-security": "max-age=31536000; includeSubDomains; preload", + "transfer-encoding": "chunked", + "x-content-type-options": "nosniff", + "x-ratelimit-limit-requests": "5000", + "x-ratelimit-limit-tokens": "1000000", + "x-ratelimit-remaining-requests": "4999", + "x-ratelimit-remaining-tokens": "999838", + "x-ratelimit-reset-requests": "12ms", + "x-ratelimit-reset-tokens": "9ms", + "x-request-id": "", + "set-cookie": "" +} diff --git a/packages/inference-discovery-openai/sessions/openai-responses/gpt-5.6-sol/plain-text-streaming/exchanges/0/response.sse b/packages/inference-discovery-openai/sessions/openai-responses/gpt-5.6-sol/plain-text-streaming/exchanges/0/response.sse new file mode 100644 index 000000000..1ad0d1ff8 --- /dev/null +++ b/packages/inference-discovery-openai/sessions/openai-responses/gpt-5.6-sol/plain-text-streaming/exchanges/0/response.sse @@ -0,0 +1,45 @@ +event: response.created +data: {"type":"response.created","response":{"id":"resp_0714999177dfe31b006ae42e9dd2e487d08c834820c054a6fc","object":"response","created_at":1793339037,"status":"in_progress","access_programs":null,"background":false,"completed_at":null,"error":null,"frequency_penalty":0.0,"incomplete_details":null,"instructions":null,"max_output_tokens":null,"max_tool_calls":null,"model":"gpt-5.6-sol","moderation":null,"output":[],"parallel_tool_calls":true,"presence_penalty":0.0,"previous_response_id":null,"prompt_cache_key":null,"prompt_cache_retention":"24h","reasoning":{"context":"all_turns","effort":"medium","mode":"standard","summary":null},"safety_identifier":null,"service_tier":"auto","store":true,"temperature":1.0,"text":{"format":{"type":"text"},"verbosity":"medium"},"tool_choice":"auto","tool_usage":{"image_gen":{"input_tokens":0,"input_tokens_details":{"image_tokens":0,"text_tokens":0},"output_tokens":0,"output_tokens_details":{"image_tokens":0,"text_tokens":0},"total_tokens":0},"web_search":{"num_requests":0}},"tools":[],"top_logprobs":0,"top_p":0.98,"truncation":"disabled","usage":null,"user":null,"metadata":{}},"sequence_number":0} + +event: response.in_progress +data: {"type":"response.in_progress","response":{"id":"resp_0714999177dfe31b006ae42e9dd2e487d08c834820c054a6fc","object":"response","created_at":1793339037,"status":"in_progress","access_programs":null,"background":false,"completed_at":null,"error":null,"frequency_penalty":0.0,"incomplete_details":null,"instructions":null,"max_output_tokens":null,"max_tool_calls":null,"model":"gpt-5.6-sol","moderation":null,"output":[],"parallel_tool_calls":true,"presence_penalty":0.0,"previous_response_id":null,"prompt_cache_key":null,"prompt_cache_retention":"24h","reasoning":{"context":"all_turns","effort":"medium","mode":"standard","summary":null},"safety_identifier":null,"service_tier":"auto","store":true,"temperature":1.0,"text":{"format":{"type":"text"},"verbosity":"medium"},"tool_choice":"auto","tool_usage":{"image_gen":{"input_tokens":0,"input_tokens_details":{"image_tokens":0,"text_tokens":0},"output_tokens":0,"output_tokens_details":{"image_tokens":0,"text_tokens":0},"total_tokens":0},"web_search":{"num_requests":0}},"tools":[],"top_logprobs":0,"top_p":0.98,"truncation":"disabled","usage":null,"user":null,"metadata":{}},"sequence_number":1} + +event: response.output_item.added +data: {"type":"response.output_item.added","item":{"id":"msg_0714999177dfe31b006ae42e9e782087d089ef798a21c781e2","type":"message","status":"in_progress","content":[],"phase":"final_answer","role":"assistant"},"output_index":0,"sequence_number":2} + +event: response.content_part.added +data: {"type":"response.content_part.added","content_index":0,"item_id":"msg_0714999177dfe31b006ae42e9e782087d089ef798a21c781e2","output_index":0,"part":{"type":"output_text","annotations":[],"logprobs":[],"text":""},"sequence_number":3} + +event: response.output_text.delta +data: {"type":"response.output_text.delta","content_index":0,"delta":"The","item_id":"msg_0714999177dfe31b006ae42e9e782087d089ef798a21c781e2","logprobs":[],"obfuscation":"bHq1MZT3H90jK","output_index":0,"sequence_number":4} + +event: response.output_text.delta +data: {"type":"response.output_text.delta","content_index":0,"delta":" capital","item_id":"msg_0714999177dfe31b006ae42e9e782087d089ef798a21c781e2","logprobs":[],"obfuscation":"mCq9QHTe","output_index":0,"sequence_number":5} + +event: response.output_text.delta +data: {"type":"response.output_text.delta","content_index":0,"delta":" of","item_id":"msg_0714999177dfe31b006ae42e9e782087d089ef798a21c781e2","logprobs":[],"obfuscation":"5qCqEXeAemcrq","output_index":0,"sequence_number":6} + +event: response.output_text.delta +data: {"type":"response.output_text.delta","content_index":0,"delta":" France","item_id":"msg_0714999177dfe31b006ae42e9e782087d089ef798a21c781e2","logprobs":[],"obfuscation":"fxOW0mHUW","output_index":0,"sequence_number":7} + +event: response.output_text.delta +data: {"type":"response.output_text.delta","content_index":0,"delta":" is","item_id":"msg_0714999177dfe31b006ae42e9e782087d089ef798a21c781e2","logprobs":[],"obfuscation":"a83LNIYV9rb1o","output_index":0,"sequence_number":8} + +event: response.output_text.delta +data: {"type":"response.output_text.delta","content_index":0,"delta":" Paris","item_id":"msg_0714999177dfe31b006ae42e9e782087d089ef798a21c781e2","logprobs":[],"obfuscation":"e1IWwhYxLa","output_index":0,"sequence_number":9} + +event: response.output_text.delta +data: {"type":"response.output_text.delta","content_index":0,"delta":".","item_id":"msg_0714999177dfe31b006ae42e9e782087d089ef798a21c781e2","logprobs":[],"obfuscation":"6Dd9XbQDzqbPXTn","output_index":0,"sequence_number":10} + +event: response.output_text.done +data: {"type":"response.output_text.done","content_index":0,"item_id":"msg_0714999177dfe31b006ae42e9e782087d089ef798a21c781e2","logprobs":[],"output_index":0,"sequence_number":11,"text":"The capital of France is Paris."} + +event: response.content_part.done +data: {"type":"response.content_part.done","content_index":0,"item_id":"msg_0714999177dfe31b006ae42e9e782087d089ef798a21c781e2","output_index":0,"part":{"type":"output_text","annotations":[],"logprobs":[],"text":"The capital of France is Paris."},"sequence_number":12} + +event: response.output_item.done +data: {"type":"response.output_item.done","item":{"id":"msg_0714999177dfe31b006ae42e9e782087d089ef798a21c781e2","type":"message","status":"completed","content":[{"type":"output_text","annotations":[],"logprobs":[],"text":"The capital of France is Paris."}],"phase":"final_answer","role":"assistant"},"output_index":0,"sequence_number":13} + +event: response.completed +data: {"type":"response.completed","response":{"id":"resp_0714999177dfe31b006ae42e9dd2e487d08c834820c054a6fc","object":"response","created_at":1793339037,"status":"completed","access_programs":null,"background":false,"completed_at":1793339038,"error":null,"frequency_penalty":0.0,"incomplete_details":null,"instructions":null,"max_output_tokens":null,"max_tool_calls":null,"model":"gpt-5.6-sol","moderation":null,"output":[{"id":"msg_0714999177dfe31b006ae42e9e782087d089ef798a21c781e2","type":"message","status":"completed","content":[{"type":"output_text","annotations":[],"logprobs":[],"text":"The capital of France is Paris."}],"phase":"final_answer","role":"assistant"}],"parallel_tool_calls":true,"presence_penalty":0.0,"previous_response_id":null,"prompt_cache_key":null,"prompt_cache_retention":"24h","reasoning":{"context":"all_turns","effort":"medium","mode":"standard","summary":null},"safety_identifier":null,"service_tier":"default","store":true,"temperature":1.0,"text":{"format":{"type":"text"},"verbosity":"medium"},"tool_choice":"auto","tool_usage":{"image_gen":{"input_tokens":0,"input_tokens_details":{"image_tokens":0,"text_tokens":0},"output_tokens":0,"output_tokens_details":{"image_tokens":0,"text_tokens":0},"total_tokens":0},"web_search":{"num_requests":0}},"tools":[],"top_logprobs":0,"top_p":0.98,"truncation":"disabled","usage":{"input_tokens":19,"input_tokens_details":{"cache_write_tokens":0,"cached_tokens":0},"output_tokens":11,"output_tokens_details":{"reasoning_tokens":0},"total_tokens":30},"user":null,"metadata":{}},"sequence_number":14} + diff --git a/packages/inference-discovery-openai/sessions/openai-responses/gpt-5.6-sol/plain-text-streaming/session.json b/packages/inference-discovery-openai/sessions/openai-responses/gpt-5.6-sol/plain-text-streaming/session.json new file mode 100644 index 000000000..4a81b0de6 --- /dev/null +++ b/packages/inference-discovery-openai/sessions/openai-responses/gpt-5.6-sol/plain-text-streaming/session.json @@ -0,0 +1,11 @@ +{ + "schemaVersion": "2", + "source": { + "provider": "openai-responses", + "model": "gpt-5.6-sol", + "baseURL": "https://api.openai.com/v1" + }, + "origin": "live", + "capturedAt": "2026-10-30T05:43:58.744Z", + "capability": "plain-text-streaming" +} diff --git a/packages/inference-discovery-openai/sessions/openai-responses/gpt-5.6-sol/plain-text/exchanges/0/request-headers.json b/packages/inference-discovery-openai/sessions/openai-responses/gpt-5.6-sol/plain-text/exchanges/0/request-headers.json new file mode 100644 index 000000000..28c14bb85 --- /dev/null +++ b/packages/inference-discovery-openai/sessions/openai-responses/gpt-5.6-sol/plain-text/exchanges/0/request-headers.json @@ -0,0 +1,4 @@ +{ + "Content-Type": "application/json", + "Authorization": "" +} diff --git a/packages/inference-discovery-openai/sessions/openai-responses/gpt-5.6-sol/plain-text/exchanges/0/request.json b/packages/inference-discovery-openai/sessions/openai-responses/gpt-5.6-sol/plain-text/exchanges/0/request.json new file mode 100644 index 000000000..2673a56ee --- /dev/null +++ b/packages/inference-discovery-openai/sessions/openai-responses/gpt-5.6-sol/plain-text/exchanges/0/request.json @@ -0,0 +1,10 @@ +{ + "model": "gpt-5.6-sol", + "input": [ + { + "type": "message", + "role": "user", + "content": "Reply with a single sentence: the capital of France is Paris." + } + ] +} diff --git a/packages/inference-discovery-openai/sessions/openai-responses/gpt-5.6-sol/plain-text/exchanges/0/response-headers.json b/packages/inference-discovery-openai/sessions/openai-responses/gpt-5.6-sol/plain-text/exchanges/0/response-headers.json new file mode 100644 index 000000000..2da84264e --- /dev/null +++ b/packages/inference-discovery-openai/sessions/openai-responses/gpt-5.6-sol/plain-text/exchanges/0/response-headers.json @@ -0,0 +1,26 @@ +{ + "access-control-expose-headers": "X-Request-ID, Server-Timing-Total, CF-Ray, CF-Ray", + "alt-svc": "h3=\":443\"; ma=86400", + "cf-cache-status": "DYNAMIC", + "cf-ray": "a5281af43b1dec6b-LAX", + "connection": "keep-alive", + "content-encoding": "br", + "content-type": "application/json", + "date": "Fri, 30 Oct 2026 05:43:57 GMT", + "openai-organization": "", + "openai-processing-ms": "812", + "openai-project": "", + "openai-version": "2020-10-01", + "server": "cloudflare", + "strict-transport-security": "max-age=31536000; includeSubDomains; preload", + "transfer-encoding": "chunked", + "x-content-type-options": "nosniff", + "x-ratelimit-limit-requests": "5000", + "x-ratelimit-limit-tokens": "1000000", + "x-ratelimit-remaining-requests": "4999", + "x-ratelimit-remaining-tokens": "1000000", + "x-ratelimit-reset-requests": "12ms", + "x-ratelimit-reset-tokens": "0s", + "x-request-id": "", + "set-cookie": "" +} diff --git a/packages/inference-discovery-openai/sessions/openai-responses/gpt-5.6-sol/plain-text/exchanges/0/response.json b/packages/inference-discovery-openai/sessions/openai-responses/gpt-5.6-sol/plain-text/exchanges/0/response.json new file mode 100644 index 000000000..aaf031322 --- /dev/null +++ b/packages/inference-discovery-openai/sessions/openai-responses/gpt-5.6-sol/plain-text/exchanges/0/response.json @@ -0,0 +1,95 @@ +{ + "id": "resp_067a89d87e7024c5006ae42e9ce87887d089265facc3f9763a", + "object": "response", + "created_at": 1793339036, + "status": "completed", + "access_programs": null, + "background": false, + "billing": { + "payer": "developer" + }, + "completed_at": 1793339037, + "error": null, + "frequency_penalty": 0.0, + "incomplete_details": null, + "instructions": null, + "max_output_tokens": null, + "max_tool_calls": null, + "model": "gpt-5.6-sol", + "moderation": null, + "output": [ + { + "id": "msg_067a89d87e7024c5006ae42e9d773487d0beaae49260f92dc7", + "type": "message", + "status": "completed", + "content": [ + { + "type": "output_text", + "annotations": [], + "logprobs": [], + "text": "The capital of France is Paris." + } + ], + "phase": "final_answer", + "role": "assistant" + } + ], + "parallel_tool_calls": true, + "presence_penalty": 0.0, + "previous_response_id": null, + "prompt_cache_key": null, + "prompt_cache_retention": "24h", + "reasoning": { + "context": "all_turns", + "effort": "medium", + "mode": "standard", + "summary": null + }, + "safety_identifier": null, + "service_tier": "default", + "store": true, + "temperature": 1.0, + "text": { + "format": { + "type": "text" + }, + "verbosity": "medium" + }, + "tool_choice": "auto", + "tool_usage": { + "image_gen": { + "input_tokens": 0, + "input_tokens_details": { + "image_tokens": 0, + "text_tokens": 0 + }, + "output_tokens": 0, + "output_tokens_details": { + "image_tokens": 0, + "text_tokens": 0 + }, + "total_tokens": 0 + }, + "web_search": { + "num_requests": 0 + } + }, + "tools": [], + "top_logprobs": 0, + "top_p": 0.98, + "truncation": "disabled", + "usage": { + "input_tokens": 19, + "input_tokens_details": { + "cache_write_tokens": 0, + "cached_tokens": 0 + }, + "output_tokens": 11, + "output_tokens_details": { + "reasoning_tokens": 0 + }, + "total_tokens": 30 + }, + "user": null, + "metadata": {} +} \ No newline at end of file diff --git a/packages/inference-discovery-openai/sessions/openai-responses/gpt-5.6-sol/plain-text/session.json b/packages/inference-discovery-openai/sessions/openai-responses/gpt-5.6-sol/plain-text/session.json new file mode 100644 index 000000000..f104c2725 --- /dev/null +++ b/packages/inference-discovery-openai/sessions/openai-responses/gpt-5.6-sol/plain-text/session.json @@ -0,0 +1,11 @@ +{ + "schemaVersion": "2", + "source": { + "provider": "openai-responses", + "model": "gpt-5.6-sol", + "baseURL": "https://api.openai.com/v1" + }, + "origin": "live", + "capturedAt": "2026-10-30T05:43:57.736Z", + "capability": "plain-text" +} diff --git a/packages/inference-discovery-openai/sessions/openai-responses/gpt-5.6-sol/reasoning-content/exchanges/0/request-headers.json b/packages/inference-discovery-openai/sessions/openai-responses/gpt-5.6-sol/reasoning-content/exchanges/0/request-headers.json new file mode 100644 index 000000000..28c14bb85 --- /dev/null +++ b/packages/inference-discovery-openai/sessions/openai-responses/gpt-5.6-sol/reasoning-content/exchanges/0/request-headers.json @@ -0,0 +1,4 @@ +{ + "Content-Type": "application/json", + "Authorization": "" +} diff --git a/packages/inference-discovery-openai/sessions/openai-responses/gpt-5.6-sol/reasoning-content/exchanges/0/request.json b/packages/inference-discovery-openai/sessions/openai-responses/gpt-5.6-sol/reasoning-content/exchanges/0/request.json new file mode 100644 index 000000000..c552e3254 --- /dev/null +++ b/packages/inference-discovery-openai/sessions/openai-responses/gpt-5.6-sol/reasoning-content/exchanges/0/request.json @@ -0,0 +1,14 @@ +{ + "model": "gpt-5.6-sol", + "input": [ + { + "type": "message", + "role": "user", + "content": "A bat and a ball cost $1.10 together. The bat costs $1.00 more than the ball. How much does the ball cost? Show your reasoning before the final answer." + } + ], + "reasoning": { + "effort": "medium", + "summary": "detailed" + } +} diff --git a/packages/inference-discovery-openai/sessions/openai-responses/gpt-5.6-sol/reasoning-content/exchanges/0/response-headers.json b/packages/inference-discovery-openai/sessions/openai-responses/gpt-5.6-sol/reasoning-content/exchanges/0/response-headers.json new file mode 100644 index 000000000..cde930cce --- /dev/null +++ b/packages/inference-discovery-openai/sessions/openai-responses/gpt-5.6-sol/reasoning-content/exchanges/0/response-headers.json @@ -0,0 +1,26 @@ +{ + "access-control-expose-headers": "X-Request-ID, Server-Timing-Total, CF-Ray, CF-Ray", + "alt-svc": "h3=\":443\"; ma=86400", + "cf-cache-status": "DYNAMIC", + "cf-ray": "a52f12b28e246a29-LAX", + "connection": "keep-alive", + "content-encoding": "br", + "content-type": "application/json", + "date": "Sat, 31 Oct 2026 02:01:41 GMT", + "openai-organization": "", + "openai-processing-ms": "2532", + "openai-project": "", + "openai-version": "2020-10-01", + "server": "cloudflare", + "strict-transport-security": "max-age=31536000; includeSubDomains; preload", + "transfer-encoding": "chunked", + "x-content-type-options": "nosniff", + "x-ratelimit-limit-requests": "5000", + "x-ratelimit-limit-tokens": "1000000", + "x-ratelimit-remaining-requests": "4999", + "x-ratelimit-remaining-tokens": "1000000", + "x-ratelimit-reset-requests": "12ms", + "x-ratelimit-reset-tokens": "0s", + "x-request-id": "", + "set-cookie": "" +} diff --git a/packages/inference-discovery-openai/sessions/openai-responses/gpt-5.6-sol/reasoning-content/exchanges/0/response.json b/packages/inference-discovery-openai/sessions/openai-responses/gpt-5.6-sol/reasoning-content/exchanges/0/response.json new file mode 100644 index 000000000..c1676e364 --- /dev/null +++ b/packages/inference-discovery-openai/sessions/openai-responses/gpt-5.6-sol/reasoning-content/exchanges/0/response.json @@ -0,0 +1,107 @@ +{ + "id": "resp_0156f31c49625c42006ae54c0310e487d0ba43c1df483c19e5", + "object": "response", + "created_at": 1793412099, + "status": "completed", + "access_programs": null, + "background": false, + "billing": { + "payer": "developer" + }, + "completed_at": 1793412101, + "error": null, + "frequency_penalty": 0.0, + "incomplete_details": null, + "instructions": null, + "max_output_tokens": null, + "max_tool_calls": null, + "model": "gpt-5.6-sol", + "moderation": null, + "output": [ + { + "id": "rs_0156f31c49625c42006ae54c03c3ac87d09d39a0f05f228ba3", + "type": "reasoning", + "content": [], + "encrypted_content": "gAAAAABq5UwFQp4yIO3HtUVi2P5uHv2Yt7X81NyfEqanfPpoIC95k7VU9Wko1Nk6Trk07bE0IVs_fb9Jr-t0njcPvOpbf0eq3-wtSX5Xm3o09YNP3MGQZQ1MpZw5S_ivtfZIFRAmV2vG2xEZcmq5CIDnTBE1NsTEUB6fYKXqcuXOkDbhC6keUj-H9dUF3tmCXmTnGe0J0iaMTDdXW8CMWqePAruIgjlw6B7RlgOAERFgWiBYOC-6yoqfsZsDUCUnGmHvnol4Zif0WUhDmd1gfqatnP5_DeBjZnkeIyxq-fMEV758G0cljnWi04keJ084AvvCxLW5nhAJ7rlMzCIMwSUPAwBComVh5By02uyth1GLiz7M_CxrYHPhsoj0V5G3vD_JWlG1UBmTg9eyLs64RQ1TfafdqozG555Innc0Ofe4-zcPJ5WkBQr6GC4p96eFBAtBidkE-gqSHkVlpRZ6hFmkS55zXZdxJPT92fC5QyAXKpPdGKkrh8lT1TDTo5COYwRskP9Nb99AJnODJaXKIDIatuwGXPeQO4Jm4xU9fMdcxgHlsyiHf6A1A9FJL8VkSFnoBEDmGUqbVQPDdRp9YiSs_zA2tHaA-vbKfDjKPTb41zkstQ_VWuTwz73OaGDvnz9xC26Lxld3wNX1GPqPp7VATMw5gUBmjC9c0mV-ViF6ue0IIogZ93bnxc6CeEWEi1d6dqxudqoRnMWxOcBNql4kk2rGmU55TNXHmnyIeuICf7N4O3jRbTVabERF-5nP6hyNwsg1fpDTchDn7vdhd1MHkiNanqAVDPfzEUBSff97eDs4sj1r4Tf5PVsYKL6AIHGqRunEC9ag_hQLKQeiVBCHqtuOol1_Sba_NnNhUkWIiI_3H9q6YOOG7ddQQubwXdKTxANrXWZKrapM9meCyCUBk4CPiJWD-CuEKrqCJ-GiApU1_8Flqbb7AjdUvsY7efYfIrf9AfFNlahPgGcBy2Gei6kKBPdm0XU0Wzwmjuo5C5LST4EIJT8JxjNLJh8uIiamcdX6CKRCdl1CNLFRtQeszsDjckrOc8bZVtk_5qPiF0ndd6I2-H-sB-gfhUMB592Q8LvRlViBTj0vr0ilZI3c_z0cZ2RvKYASxYoaWSinyVQcQMbB4Mlrw9xI66Zk_NNz96S9fIr-wd6Z5fZHZIoD1v95HakAWZ4U8Fhb7s5vyWsZ1FY-waT9msAwqbM54Toqd5aW8DCAB5gmz849G8uvL1bOOpxqzFOgPXFXHYTwTwJHW4PuFmGYvkjJW-IddK87ITZaBAf9g-QsSXse1E-0xGD6c9c3SzZHmizoM8z0W5fH0ImbSWYZ7HR2u_V4nufnXZkIgNYHBvjrFBZwTb85hiyp9qc3YKHtu48Ya5rUY_MvTUlLcYZOeCb_WEnp0aLHooDSfxljqFxz9MTCN3y1dWyMFAMTqsbtVs61vB_4hLShjnXVtcXNpwMt7ZaW-60DvZSrEeFmOH1fpsg-a4IekVL_3V4dZ77oJc8phQeMOI8OcuGAGWMgx3rp1CPEeI2TRynwCSFGWaMq58BNFdYltsH869bE23sBjjSJO6mR_-eEbMEFcbqixSkyrsua1ArHHifplRGZw3vFp6TIR1jMYNWkYhoZOpnhF3jcSdq32RGRl4g1btcqCPBs6GjGVN2htWqiTRssdgkMTXq33TtD5EOh__q1PKnu5egQOX1WlLJFIgSt1ly2224ylDZPGoVNmFjc3jJEuhLcNtKFnn3PfiZyAB8Tz6ppfv4jYFBZSdBXBPnNHADjl3EEDo3dZivo6Jh7Ku21ZHD9jZ8uXM2Xj14pEhVFQxCvHAVKhJoiPnmmgml_YwQTMX19IkZkRbCnTuqwcr9iKmJuEKU5D92OEggy34o5_A==", + "summary": [ + { + "type": "summary_text", + "text": "**Clarifying a math problem**\n\nI\u2019m working through a math equation, needing to reason out my answer clearly. I have the equation: x + x + 1 = 1.10. Simplifying, I get 2x = 0.10, which gives me x = 0.05. But, wait\u2014I think I need to distinguish that maybe the intuitive answer of 10 cents seems wrong. I really want to ensure everything is making sense here!" + } + ] + }, + { + "id": "msg_0156f31c49625c42006ae54c0529e087d090db1a2dffecbedf", + "type": "message", + "status": "completed", + "content": [ + { + "type": "output_text", + "annotations": [], + "logprobs": [], + "text": "Let the ball cost \\(x\\) dollars. Then the bat costs \\(x + 1.00\\).\n\n\\[\nx + (x + 1.00) = 1.10\n\\]\n\n\\[\n2x = 0.10\n\\]\n\n\\[\nx = 0.05\n\\]\n\n**Final answer: The ball costs \\(\\boxed{\\$0.05}\\).**" + } + ], + "phase": "final_answer", + "role": "assistant" + } + ], + "parallel_tool_calls": true, + "presence_penalty": 0.0, + "previous_response_id": null, + "prompt_cache_key": null, + "prompt_cache_retention": "24h", + "reasoning": { + "context": "all_turns", + "effort": "medium", + "mode": "standard", + "summary": "detailed" + }, + "safety_identifier": null, + "service_tier": "default", + "store": true, + "temperature": 1.0, + "text": { + "format": { + "type": "text" + }, + "verbosity": "medium" + }, + "tool_choice": "auto", + "tool_usage": { + "image_gen": { + "input_tokens": 0, + "input_tokens_details": { + "image_tokens": 0, + "text_tokens": 0 + }, + "output_tokens": 0, + "output_tokens_details": { + "image_tokens": 0, + "text_tokens": 0 + }, + "total_tokens": 0 + }, + "web_search": { + "num_requests": 0 + } + }, + "tools": [], + "top_logprobs": 0, + "top_p": 0.98, + "truncation": "disabled", + "usage": { + "input_tokens": 45, + "input_tokens_details": { + "cache_write_tokens": 0, + "cached_tokens": 0 + }, + "output_tokens": 135, + "output_tokens_details": { + "reasoning_tokens": 45 + }, + "total_tokens": 180 + }, + "user": null, + "metadata": {} +} \ No newline at end of file diff --git a/packages/inference-discovery-openai/sessions/openai-responses/gpt-5.6-sol/reasoning-content/session.json b/packages/inference-discovery-openai/sessions/openai-responses/gpt-5.6-sol/reasoning-content/session.json new file mode 100644 index 000000000..37848670f --- /dev/null +++ b/packages/inference-discovery-openai/sessions/openai-responses/gpt-5.6-sol/reasoning-content/session.json @@ -0,0 +1,11 @@ +{ + "schemaVersion": "2", + "source": { + "provider": "openai-responses", + "model": "gpt-5.6-sol", + "baseURL": "https://api.openai.com/v1" + }, + "origin": "live", + "capturedAt": "2026-10-31T02:01:41.590Z", + "capability": "reasoning-content" +} diff --git a/packages/inference-discovery-openai/sessions/openai-responses/gpt-5.6-terra/function-calling-multi-turn/dispatches/0-get_weather.json b/packages/inference-discovery-openai/sessions/openai-responses/gpt-5.6-terra/function-calling-multi-turn/dispatches/0-get_weather.json new file mode 100644 index 000000000..21f38181b --- /dev/null +++ b/packages/inference-discovery-openai/sessions/openai-responses/gpt-5.6-terra/function-calling-multi-turn/dispatches/0-get_weather.json @@ -0,0 +1,6 @@ +{ + "args": { + "location": "Boston, MA" + }, + "result": "{\"location\":\"Boston, MA\",\"temperatureF\":68,\"conditions\":\"clear\"}" +} diff --git a/packages/inference-discovery-openai/sessions/openai-responses/gpt-5.6-terra/function-calling-multi-turn/exchanges/0/request-headers.json b/packages/inference-discovery-openai/sessions/openai-responses/gpt-5.6-terra/function-calling-multi-turn/exchanges/0/request-headers.json new file mode 100644 index 000000000..28c14bb85 --- /dev/null +++ b/packages/inference-discovery-openai/sessions/openai-responses/gpt-5.6-terra/function-calling-multi-turn/exchanges/0/request-headers.json @@ -0,0 +1,4 @@ +{ + "Content-Type": "application/json", + "Authorization": "" +} diff --git a/packages/inference-discovery-openai/sessions/openai-responses/gpt-5.6-terra/function-calling-multi-turn/exchanges/0/request.json b/packages/inference-discovery-openai/sessions/openai-responses/gpt-5.6-terra/function-calling-multi-turn/exchanges/0/request.json new file mode 100644 index 000000000..7daebb38e --- /dev/null +++ b/packages/inference-discovery-openai/sessions/openai-responses/gpt-5.6-terra/function-calling-multi-turn/exchanges/0/request.json @@ -0,0 +1,30 @@ +{ + "model": "gpt-5.6-terra", + "input": [ + { + "type": "message", + "role": "user", + "content": "What is the weather in Boston, MA? Use the provided tool." + } + ], + "tools": [ + { + "type": "function", + "name": "get_weather", + "description": "Look up the current weather for a city.", + "parameters": { + "type": "object", + "properties": { + "location": { + "type": "string", + "description": "City and optional region, e.g. 'Boston, MA'." + } + }, + "required": [ + "location" + ] + } + } + ], + "tool_choice": "auto" +} diff --git a/packages/inference-discovery-openai/sessions/openai-responses/gpt-5.6-terra/function-calling-multi-turn/exchanges/0/response-headers.json b/packages/inference-discovery-openai/sessions/openai-responses/gpt-5.6-terra/function-calling-multi-turn/exchanges/0/response-headers.json new file mode 100644 index 000000000..b8bd31061 --- /dev/null +++ b/packages/inference-discovery-openai/sessions/openai-responses/gpt-5.6-terra/function-calling-multi-turn/exchanges/0/response-headers.json @@ -0,0 +1,26 @@ +{ + "access-control-expose-headers": "X-Request-ID, Server-Timing-Total, CF-Ray, CF-Ray", + "alt-svc": "h3=\":443\"; ma=86400", + "cf-cache-status": "DYNAMIC", + "cf-ray": "a52f12c30f936a29-LAX", + "connection": "keep-alive", + "content-encoding": "br", + "content-type": "application/json", + "date": "Sat, 31 Oct 2026 02:01:42 GMT", + "openai-organization": "", + "openai-processing-ms": "1040", + "openai-project": "", + "openai-version": "2020-10-01", + "server": "cloudflare", + "strict-transport-security": "max-age=31536000; includeSubDomains; preload", + "transfer-encoding": "chunked", + "x-content-type-options": "nosniff", + "x-ratelimit-limit-requests": "5000", + "x-ratelimit-limit-tokens": "1000000", + "x-ratelimit-remaining-requests": "4999", + "x-ratelimit-remaining-tokens": "1000000", + "x-ratelimit-reset-requests": "12ms", + "x-ratelimit-reset-tokens": "0s", + "x-request-id": "", + "set-cookie": "" +} diff --git a/packages/inference-discovery-openai/sessions/openai-responses/gpt-5.6-terra/function-calling-multi-turn/exchanges/0/response.json b/packages/inference-discovery-openai/sessions/openai-responses/gpt-5.6-terra/function-calling-multi-turn/exchanges/0/response.json new file mode 100644 index 000000000..fb100d717 --- /dev/null +++ b/packages/inference-discovery-openai/sessions/openai-responses/gpt-5.6-terra/function-calling-multi-turn/exchanges/0/response.json @@ -0,0 +1,109 @@ +{ + "id": "resp_0e0087ecda37dfd7006ae54c05b69c87d09aba23845ca9521c", + "object": "response", + "created_at": 1793412101, + "status": "completed", + "access_programs": null, + "background": false, + "billing": { + "payer": "developer" + }, + "completed_at": 1793412102, + "error": null, + "frequency_penalty": 0.0, + "incomplete_details": null, + "instructions": null, + "max_output_tokens": null, + "max_tool_calls": null, + "model": "gpt-5.6-terra", + "moderation": null, + "output": [ + { + "id": "fc_0e0087ecda37dfd7006ae54c06731487d084a6e848bfcc4913", + "type": "function_call", + "status": "completed", + "arguments": "{\"location\":\"Boston, MA\"}", + "call_id": "call_qZ0JSHTmAsc4wvbx1W5Ld72e", + "name": "get_weather" + } + ], + "parallel_tool_calls": true, + "presence_penalty": 0.0, + "previous_response_id": null, + "prompt_cache_key": null, + "prompt_cache_retention": "24h", + "reasoning": { + "context": "all_turns", + "effort": "medium", + "mode": "standard", + "summary": null + }, + "safety_identifier": null, + "service_tier": "default", + "store": true, + "temperature": 1.0, + "text": { + "format": { + "type": "text" + }, + "verbosity": "medium" + }, + "tool_choice": "auto", + "tool_usage": { + "image_gen": { + "input_tokens": 0, + "input_tokens_details": { + "image_tokens": 0, + "text_tokens": 0 + }, + "output_tokens": 0, + "output_tokens_details": { + "image_tokens": 0, + "text_tokens": 0 + }, + "total_tokens": 0 + }, + "web_search": { + "num_requests": 0 + } + }, + "tools": [ + { + "type": "function", + "description": "Look up the current weather for a city.", + "name": "get_weather", + "output_schema": null, + "parameters": { + "type": "object", + "properties": { + "location": { + "type": "string", + "description": "City and optional region, e.g. 'Boston, MA'." + } + }, + "required": [ + "location" + ], + "additionalProperties": false + }, + "strict": true + } + ], + "top_logprobs": 0, + "top_p": 0.98, + "truncation": "disabled", + "usage": { + "input_tokens": 73, + "input_tokens_details": { + "cache_write_tokens": 0, + "cached_tokens": 0 + }, + "output_tokens": 20, + "output_tokens_details": { + "reasoning_tokens": 0 + }, + "total_tokens": 93 + }, + "user": null, + "metadata": {} +} \ No newline at end of file diff --git a/packages/inference-discovery-openai/sessions/openai-responses/gpt-5.6-terra/function-calling-multi-turn/exchanges/1/request-headers.json b/packages/inference-discovery-openai/sessions/openai-responses/gpt-5.6-terra/function-calling-multi-turn/exchanges/1/request-headers.json new file mode 100644 index 000000000..28c14bb85 --- /dev/null +++ b/packages/inference-discovery-openai/sessions/openai-responses/gpt-5.6-terra/function-calling-multi-turn/exchanges/1/request-headers.json @@ -0,0 +1,4 @@ +{ + "Content-Type": "application/json", + "Authorization": "" +} diff --git a/packages/inference-discovery-openai/sessions/openai-responses/gpt-5.6-terra/function-calling-multi-turn/exchanges/1/request.json b/packages/inference-discovery-openai/sessions/openai-responses/gpt-5.6-terra/function-calling-multi-turn/exchanges/1/request.json new file mode 100644 index 000000000..2b8cb7d3d --- /dev/null +++ b/packages/inference-discovery-openai/sessions/openai-responses/gpt-5.6-terra/function-calling-multi-turn/exchanges/1/request.json @@ -0,0 +1,45 @@ +{ + "model": "gpt-5.6-terra", + "input": [ + { + "type": "message", + "role": "user", + "content": "What is the weather in Boston, MA? Use the provided tool." + }, + { + "type": "function_call", + "call_id": "call_qZ0JSHTmAsc4wvbx1W5Ld72e", + "name": "get_weather", + "arguments": "{\"location\":\"Boston, MA\"}" + }, + { + "type": "function_call_output", + "call_id": "call_qZ0JSHTmAsc4wvbx1W5Ld72e", + "output": "{\"location\":\"Boston, MA\",\"temperatureF\":68,\"conditions\":\"clear\"}" + } + ], + "store": false, + "include": [ + "reasoning.encrypted_content" + ], + "tools": [ + { + "type": "function", + "name": "get_weather", + "description": "Look up the current weather for a city.", + "parameters": { + "type": "object", + "properties": { + "location": { + "type": "string", + "description": "City and optional region, e.g. 'Boston, MA'." + } + }, + "required": [ + "location" + ] + } + } + ], + "tool_choice": "auto" +} diff --git a/packages/inference-discovery-openai/sessions/openai-responses/gpt-5.6-terra/function-calling-multi-turn/exchanges/1/response-headers.json b/packages/inference-discovery-openai/sessions/openai-responses/gpt-5.6-terra/function-calling-multi-turn/exchanges/1/response-headers.json new file mode 100644 index 000000000..8ac8a3dfa --- /dev/null +++ b/packages/inference-discovery-openai/sessions/openai-responses/gpt-5.6-terra/function-calling-multi-turn/exchanges/1/response-headers.json @@ -0,0 +1,26 @@ +{ + "access-control-expose-headers": "X-Request-ID, Server-Timing-Total, CF-Ray, CF-Ray", + "alt-svc": "h3=\":443\"; ma=86400", + "cf-cache-status": "DYNAMIC", + "cf-ray": "a52f12ca7b266a29-LAX", + "connection": "keep-alive", + "content-encoding": "br", + "content-type": "application/json", + "date": "Sat, 31 Oct 2026 02:01:44 GMT", + "openai-organization": "", + "openai-processing-ms": "1077", + "openai-project": "", + "openai-version": "2020-10-01", + "server": "cloudflare", + "strict-transport-security": "max-age=31536000; includeSubDomains; preload", + "transfer-encoding": "chunked", + "x-content-type-options": "nosniff", + "x-ratelimit-limit-requests": "5000", + "x-ratelimit-limit-tokens": "1000000", + "x-ratelimit-remaining-requests": "4999", + "x-ratelimit-remaining-tokens": "1000000", + "x-ratelimit-reset-requests": "12ms", + "x-ratelimit-reset-tokens": "0s", + "x-request-id": "", + "set-cookie": "" +} diff --git a/packages/inference-discovery-openai/sessions/openai-responses/gpt-5.6-terra/function-calling-multi-turn/exchanges/1/response.json b/packages/inference-discovery-openai/sessions/openai-responses/gpt-5.6-terra/function-calling-multi-turn/exchanges/1/response.json new file mode 100644 index 000000000..192428f0d --- /dev/null +++ b/packages/inference-discovery-openai/sessions/openai-responses/gpt-5.6-terra/function-calling-multi-turn/exchanges/1/response.json @@ -0,0 +1,116 @@ +{ + "id": "resp_092ffee451912e46016ae54c06e72c87d0b2126fe469e217ae", + "object": "response", + "created_at": 1793412102, + "status": "completed", + "access_programs": null, + "background": false, + "billing": { + "payer": "developer" + }, + "completed_at": 1793412103, + "error": null, + "frequency_penalty": 0.0, + "incomplete_details": null, + "instructions": null, + "max_output_tokens": null, + "max_tool_calls": null, + "model": "gpt-5.6-terra", + "moderation": null, + "output": [ + { + "id": "msg_092ffee451912e46016ae54c07905887d0b54d62eff99ef239", + "type": "message", + "status": "completed", + "content": [ + { + "type": "output_text", + "annotations": [], + "logprobs": [], + "text": "Boston, MA is currently **clear** with a temperature of **68\u00b0F**." + } + ], + "phase": "final_answer", + "role": "assistant" + } + ], + "parallel_tool_calls": true, + "presence_penalty": 0.0, + "previous_response_id": null, + "prompt_cache_key": null, + "prompt_cache_retention": "24h", + "reasoning": { + "context": "all_turns", + "effort": "medium", + "mode": "standard", + "summary": null + }, + "safety_identifier": null, + "service_tier": "default", + "store": false, + "temperature": 1.0, + "text": { + "format": { + "type": "text" + }, + "verbosity": "medium" + }, + "tool_choice": "auto", + "tool_usage": { + "image_gen": { + "input_tokens": 0, + "input_tokens_details": { + "image_tokens": 0, + "text_tokens": 0 + }, + "output_tokens": 0, + "output_tokens_details": { + "image_tokens": 0, + "text_tokens": 0 + }, + "total_tokens": 0 + }, + "web_search": { + "num_requests": 0 + } + }, + "tools": [ + { + "type": "function", + "description": "Look up the current weather for a city.", + "name": "get_weather", + "output_schema": null, + "parameters": { + "type": "object", + "properties": { + "location": { + "type": "string", + "description": "City and optional region, e.g. 'Boston, MA'." + } + }, + "required": [ + "location" + ], + "additionalProperties": false + }, + "strict": true + } + ], + "top_logprobs": 0, + "top_p": 0.98, + "truncation": "disabled", + "usage": { + "input_tokens": 120, + "input_tokens_details": { + "cache_write_tokens": 0, + "cached_tokens": 0 + }, + "output_tokens": 21, + "output_tokens_details": { + "reasoning_tokens": 0 + }, + "total_tokens": 141 + }, + "user": null, + "metadata": {} +} \ No newline at end of file diff --git a/packages/inference-discovery-openai/sessions/openai-responses/gpt-5.6-terra/function-calling-multi-turn/session.json b/packages/inference-discovery-openai/sessions/openai-responses/gpt-5.6-terra/function-calling-multi-turn/session.json new file mode 100644 index 000000000..3bfc2ddcf --- /dev/null +++ b/packages/inference-discovery-openai/sessions/openai-responses/gpt-5.6-terra/function-calling-multi-turn/session.json @@ -0,0 +1,11 @@ +{ + "schemaVersion": "2", + "source": { + "provider": "openai-responses", + "model": "gpt-5.6-terra", + "baseURL": "https://api.openai.com/v1" + }, + "origin": "live", + "capturedAt": "2026-10-31T02:01:44.042Z", + "capability": "function-calling-multi-turn" +} diff --git a/packages/inference-discovery-openai/sessions/openai-responses/gpt-5.6-terra/plain-text-streaming/exchanges/0/request-headers.json b/packages/inference-discovery-openai/sessions/openai-responses/gpt-5.6-terra/plain-text-streaming/exchanges/0/request-headers.json new file mode 100644 index 000000000..28c14bb85 --- /dev/null +++ b/packages/inference-discovery-openai/sessions/openai-responses/gpt-5.6-terra/plain-text-streaming/exchanges/0/request-headers.json @@ -0,0 +1,4 @@ +{ + "Content-Type": "application/json", + "Authorization": "" +} diff --git a/packages/inference-discovery-openai/sessions/openai-responses/gpt-5.6-terra/plain-text-streaming/exchanges/0/request.json b/packages/inference-discovery-openai/sessions/openai-responses/gpt-5.6-terra/plain-text-streaming/exchanges/0/request.json new file mode 100644 index 000000000..25e350003 --- /dev/null +++ b/packages/inference-discovery-openai/sessions/openai-responses/gpt-5.6-terra/plain-text-streaming/exchanges/0/request.json @@ -0,0 +1,11 @@ +{ + "model": "gpt-5.6-terra", + "input": [ + { + "type": "message", + "role": "user", + "content": "Reply with a single sentence: the capital of France is Paris." + } + ], + "stream": true +} diff --git a/packages/inference-discovery-openai/sessions/openai-responses/gpt-5.6-terra/plain-text-streaming/exchanges/0/response-headers.json b/packages/inference-discovery-openai/sessions/openai-responses/gpt-5.6-terra/plain-text-streaming/exchanges/0/response-headers.json new file mode 100644 index 000000000..2068133ea --- /dev/null +++ b/packages/inference-discovery-openai/sessions/openai-responses/gpt-5.6-terra/plain-text-streaming/exchanges/0/response-headers.json @@ -0,0 +1,25 @@ +{ + "access-control-expose-headers": "X-Request-ID, Server-Timing-Total, CF-Ray, CF-Ray", + "alt-svc": "h3=\":443\"; ma=86400", + "cf-cache-status": "DYNAMIC", + "cf-ray": "a5281b22ea5bfb77-LAX", + "connection": "keep-alive", + "content-type": "text/event-stream; charset=utf-8", + "date": "Fri, 30 Oct 2026 05:44:04 GMT", + "openai-organization": "", + "openai-processing-ms": "236", + "openai-project": "", + "openai-version": "2020-10-01", + "server": "cloudflare", + "strict-transport-security": "max-age=31536000; includeSubDomains; preload", + "transfer-encoding": "chunked", + "x-content-type-options": "nosniff", + "x-ratelimit-limit-requests": "5000", + "x-ratelimit-limit-tokens": "1000000", + "x-ratelimit-remaining-requests": "4999", + "x-ratelimit-remaining-tokens": "999838", + "x-ratelimit-reset-requests": "12ms", + "x-ratelimit-reset-tokens": "9ms", + "x-request-id": "", + "set-cookie": "" +} diff --git a/packages/inference-discovery-openai/sessions/openai-responses/gpt-5.6-terra/plain-text-streaming/exchanges/0/response.sse b/packages/inference-discovery-openai/sessions/openai-responses/gpt-5.6-terra/plain-text-streaming/exchanges/0/response.sse new file mode 100644 index 000000000..457e06afa --- /dev/null +++ b/packages/inference-discovery-openai/sessions/openai-responses/gpt-5.6-terra/plain-text-streaming/exchanges/0/response.sse @@ -0,0 +1,45 @@ +event: response.created +data: {"type":"response.created","response":{"id":"resp_03d7aaff082e3143006ae42ea45e3887d0b451cbf043e3c74f","object":"response","created_at":1793339044,"status":"in_progress","access_programs":null,"background":false,"completed_at":null,"error":null,"frequency_penalty":0.0,"incomplete_details":null,"instructions":null,"max_output_tokens":null,"max_tool_calls":null,"model":"gpt-5.6-terra","moderation":null,"output":[],"parallel_tool_calls":true,"presence_penalty":0.0,"previous_response_id":null,"prompt_cache_key":null,"prompt_cache_retention":"24h","reasoning":{"context":"all_turns","effort":"medium","mode":"standard","summary":null},"safety_identifier":null,"service_tier":"auto","store":true,"temperature":1.0,"text":{"format":{"type":"text"},"verbosity":"medium"},"tool_choice":"auto","tool_usage":{"image_gen":{"input_tokens":0,"input_tokens_details":{"image_tokens":0,"text_tokens":0},"output_tokens":0,"output_tokens_details":{"image_tokens":0,"text_tokens":0},"total_tokens":0},"web_search":{"num_requests":0}},"tools":[],"top_logprobs":0,"top_p":0.98,"truncation":"disabled","usage":null,"user":null,"metadata":{}},"sequence_number":0} + +event: response.in_progress +data: {"type":"response.in_progress","response":{"id":"resp_03d7aaff082e3143006ae42ea45e3887d0b451cbf043e3c74f","object":"response","created_at":1793339044,"status":"in_progress","access_programs":null,"background":false,"completed_at":null,"error":null,"frequency_penalty":0.0,"incomplete_details":null,"instructions":null,"max_output_tokens":null,"max_tool_calls":null,"model":"gpt-5.6-terra","moderation":null,"output":[],"parallel_tool_calls":true,"presence_penalty":0.0,"previous_response_id":null,"prompt_cache_key":null,"prompt_cache_retention":"24h","reasoning":{"context":"all_turns","effort":"medium","mode":"standard","summary":null},"safety_identifier":null,"service_tier":"auto","store":true,"temperature":1.0,"text":{"format":{"type":"text"},"verbosity":"medium"},"tool_choice":"auto","tool_usage":{"image_gen":{"input_tokens":0,"input_tokens_details":{"image_tokens":0,"text_tokens":0},"output_tokens":0,"output_tokens_details":{"image_tokens":0,"text_tokens":0},"total_tokens":0},"web_search":{"num_requests":0}},"tools":[],"top_logprobs":0,"top_p":0.98,"truncation":"disabled","usage":null,"user":null,"metadata":{}},"sequence_number":1} + +event: response.output_item.added +data: {"type":"response.output_item.added","item":{"id":"msg_03d7aaff082e3143006ae42ea4f67087d0acc36cc0082132c5","type":"message","status":"in_progress","content":[],"phase":"final_answer","role":"assistant"},"output_index":0,"sequence_number":2} + +event: response.content_part.added +data: {"type":"response.content_part.added","content_index":0,"item_id":"msg_03d7aaff082e3143006ae42ea4f67087d0acc36cc0082132c5","output_index":0,"part":{"type":"output_text","annotations":[],"logprobs":[],"text":""},"sequence_number":3} + +event: response.output_text.delta +data: {"type":"response.output_text.delta","content_index":0,"delta":"The","item_id":"msg_03d7aaff082e3143006ae42ea4f67087d0acc36cc0082132c5","logprobs":[],"obfuscation":"OV112O4p8qTGN","output_index":0,"sequence_number":4} + +event: response.output_text.delta +data: {"type":"response.output_text.delta","content_index":0,"delta":" capital","item_id":"msg_03d7aaff082e3143006ae42ea4f67087d0acc36cc0082132c5","logprobs":[],"obfuscation":"LSh2fnUT","output_index":0,"sequence_number":5} + +event: response.output_text.delta +data: {"type":"response.output_text.delta","content_index":0,"delta":" of","item_id":"msg_03d7aaff082e3143006ae42ea4f67087d0acc36cc0082132c5","logprobs":[],"obfuscation":"7EKeOJLR93thO","output_index":0,"sequence_number":6} + +event: response.output_text.delta +data: {"type":"response.output_text.delta","content_index":0,"delta":" France","item_id":"msg_03d7aaff082e3143006ae42ea4f67087d0acc36cc0082132c5","logprobs":[],"obfuscation":"JBHAwiOUk","output_index":0,"sequence_number":7} + +event: response.output_text.delta +data: {"type":"response.output_text.delta","content_index":0,"delta":" is","item_id":"msg_03d7aaff082e3143006ae42ea4f67087d0acc36cc0082132c5","logprobs":[],"obfuscation":"6kjGukjTGhpsf","output_index":0,"sequence_number":8} + +event: response.output_text.delta +data: {"type":"response.output_text.delta","content_index":0,"delta":" Paris","item_id":"msg_03d7aaff082e3143006ae42ea4f67087d0acc36cc0082132c5","logprobs":[],"obfuscation":"d8FFEc5sn5","output_index":0,"sequence_number":9} + +event: response.output_text.delta +data: {"type":"response.output_text.delta","content_index":0,"delta":".","item_id":"msg_03d7aaff082e3143006ae42ea4f67087d0acc36cc0082132c5","logprobs":[],"obfuscation":"pQU2eNUs0obXwDG","output_index":0,"sequence_number":10} + +event: response.output_text.done +data: {"type":"response.output_text.done","content_index":0,"item_id":"msg_03d7aaff082e3143006ae42ea4f67087d0acc36cc0082132c5","logprobs":[],"output_index":0,"sequence_number":11,"text":"The capital of France is Paris."} + +event: response.content_part.done +data: {"type":"response.content_part.done","content_index":0,"item_id":"msg_03d7aaff082e3143006ae42ea4f67087d0acc36cc0082132c5","output_index":0,"part":{"type":"output_text","annotations":[],"logprobs":[],"text":"The capital of France is Paris."},"sequence_number":12} + +event: response.output_item.done +data: {"type":"response.output_item.done","item":{"id":"msg_03d7aaff082e3143006ae42ea4f67087d0acc36cc0082132c5","type":"message","status":"completed","content":[{"type":"output_text","annotations":[],"logprobs":[],"text":"The capital of France is Paris."}],"phase":"final_answer","role":"assistant"},"output_index":0,"sequence_number":13} + +event: response.completed +data: {"type":"response.completed","response":{"id":"resp_03d7aaff082e3143006ae42ea45e3887d0b451cbf043e3c74f","object":"response","created_at":1793339044,"status":"completed","access_programs":null,"background":false,"completed_at":1793339045,"error":null,"frequency_penalty":0.0,"incomplete_details":null,"instructions":null,"max_output_tokens":null,"max_tool_calls":null,"model":"gpt-5.6-terra","moderation":null,"output":[{"id":"msg_03d7aaff082e3143006ae42ea4f67087d0acc36cc0082132c5","type":"message","status":"completed","content":[{"type":"output_text","annotations":[],"logprobs":[],"text":"The capital of France is Paris."}],"phase":"final_answer","role":"assistant"}],"parallel_tool_calls":true,"presence_penalty":0.0,"previous_response_id":null,"prompt_cache_key":null,"prompt_cache_retention":"24h","reasoning":{"context":"all_turns","effort":"medium","mode":"standard","summary":null},"safety_identifier":null,"service_tier":"default","store":true,"temperature":1.0,"text":{"format":{"type":"text"},"verbosity":"medium"},"tool_choice":"auto","tool_usage":{"image_gen":{"input_tokens":0,"input_tokens_details":{"image_tokens":0,"text_tokens":0},"output_tokens":0,"output_tokens_details":{"image_tokens":0,"text_tokens":0},"total_tokens":0},"web_search":{"num_requests":0}},"tools":[],"top_logprobs":0,"top_p":0.98,"truncation":"disabled","usage":{"input_tokens":19,"input_tokens_details":{"cache_write_tokens":0,"cached_tokens":0},"output_tokens":11,"output_tokens_details":{"reasoning_tokens":0},"total_tokens":30},"user":null,"metadata":{}},"sequence_number":14} + diff --git a/packages/inference-discovery-openai/sessions/openai-responses/gpt-5.6-terra/plain-text-streaming/session.json b/packages/inference-discovery-openai/sessions/openai-responses/gpt-5.6-terra/plain-text-streaming/session.json new file mode 100644 index 000000000..a1f8f3ace --- /dev/null +++ b/packages/inference-discovery-openai/sessions/openai-responses/gpt-5.6-terra/plain-text-streaming/session.json @@ -0,0 +1,11 @@ +{ + "schemaVersion": "2", + "source": { + "provider": "openai-responses", + "model": "gpt-5.6-terra", + "baseURL": "https://api.openai.com/v1" + }, + "origin": "live", + "capturedAt": "2026-10-30T05:44:05.321Z", + "capability": "plain-text-streaming" +} diff --git a/packages/inference-discovery-openai/sessions/openai-responses/gpt-5.6-terra/plain-text/exchanges/0/request-headers.json b/packages/inference-discovery-openai/sessions/openai-responses/gpt-5.6-terra/plain-text/exchanges/0/request-headers.json new file mode 100644 index 000000000..28c14bb85 --- /dev/null +++ b/packages/inference-discovery-openai/sessions/openai-responses/gpt-5.6-terra/plain-text/exchanges/0/request-headers.json @@ -0,0 +1,4 @@ +{ + "Content-Type": "application/json", + "Authorization": "" +} diff --git a/packages/inference-discovery-openai/sessions/openai-responses/gpt-5.6-terra/plain-text/exchanges/0/request.json b/packages/inference-discovery-openai/sessions/openai-responses/gpt-5.6-terra/plain-text/exchanges/0/request.json new file mode 100644 index 000000000..6ca23583f --- /dev/null +++ b/packages/inference-discovery-openai/sessions/openai-responses/gpt-5.6-terra/plain-text/exchanges/0/request.json @@ -0,0 +1,10 @@ +{ + "model": "gpt-5.6-terra", + "input": [ + { + "type": "message", + "role": "user", + "content": "Reply with a single sentence: the capital of France is Paris." + } + ] +} diff --git a/packages/inference-discovery-openai/sessions/openai-responses/gpt-5.6-terra/plain-text/exchanges/0/response-headers.json b/packages/inference-discovery-openai/sessions/openai-responses/gpt-5.6-terra/plain-text/exchanges/0/response-headers.json new file mode 100644 index 000000000..069723060 --- /dev/null +++ b/packages/inference-discovery-openai/sessions/openai-responses/gpt-5.6-terra/plain-text/exchanges/0/response-headers.json @@ -0,0 +1,26 @@ +{ + "access-control-expose-headers": "X-Request-ID, Server-Timing-Total, CF-Ray, CF-Ray", + "alt-svc": "h3=\":443\"; ma=86400", + "cf-cache-status": "DYNAMIC", + "cf-ray": "a5281b1d4926fb77-LAX", + "connection": "keep-alive", + "content-encoding": "br", + "content-type": "application/json", + "date": "Fri, 30 Oct 2026 05:44:04 GMT", + "openai-organization": "", + "openai-processing-ms": "816", + "openai-project": "", + "openai-version": "2020-10-01", + "server": "cloudflare", + "strict-transport-security": "max-age=31536000; includeSubDomains; preload", + "transfer-encoding": "chunked", + "x-content-type-options": "nosniff", + "x-ratelimit-limit-requests": "5000", + "x-ratelimit-limit-tokens": "1000000", + "x-ratelimit-remaining-requests": "4999", + "x-ratelimit-remaining-tokens": "1000000", + "x-ratelimit-reset-requests": "12ms", + "x-ratelimit-reset-tokens": "0s", + "x-request-id": "", + "set-cookie": "" +} diff --git a/packages/inference-discovery-openai/sessions/openai-responses/gpt-5.6-terra/plain-text/exchanges/0/response.json b/packages/inference-discovery-openai/sessions/openai-responses/gpt-5.6-terra/plain-text/exchanges/0/response.json new file mode 100644 index 000000000..ecb0602c4 --- /dev/null +++ b/packages/inference-discovery-openai/sessions/openai-responses/gpt-5.6-terra/plain-text/exchanges/0/response.json @@ -0,0 +1,95 @@ +{ + "id": "resp_02f13e0c3ba3e8b6006ae42ea379b887d0a49f5b156968dc55", + "object": "response", + "created_at": 1793339043, + "status": "completed", + "access_programs": null, + "background": false, + "billing": { + "payer": "developer" + }, + "completed_at": 1793339044, + "error": null, + "frequency_penalty": 0.0, + "incomplete_details": null, + "instructions": null, + "max_output_tokens": null, + "max_tool_calls": null, + "model": "gpt-5.6-terra", + "moderation": null, + "output": [ + { + "id": "msg_02f13e0c3ba3e8b6006ae42ea4092c87d0abba0983f3062b42", + "type": "message", + "status": "completed", + "content": [ + { + "type": "output_text", + "annotations": [], + "logprobs": [], + "text": "The capital of France is Paris." + } + ], + "phase": "final_answer", + "role": "assistant" + } + ], + "parallel_tool_calls": true, + "presence_penalty": 0.0, + "previous_response_id": null, + "prompt_cache_key": null, + "prompt_cache_retention": "24h", + "reasoning": { + "context": "all_turns", + "effort": "medium", + "mode": "standard", + "summary": null + }, + "safety_identifier": null, + "service_tier": "default", + "store": true, + "temperature": 1.0, + "text": { + "format": { + "type": "text" + }, + "verbosity": "medium" + }, + "tool_choice": "auto", + "tool_usage": { + "image_gen": { + "input_tokens": 0, + "input_tokens_details": { + "image_tokens": 0, + "text_tokens": 0 + }, + "output_tokens": 0, + "output_tokens_details": { + "image_tokens": 0, + "text_tokens": 0 + }, + "total_tokens": 0 + }, + "web_search": { + "num_requests": 0 + } + }, + "tools": [], + "top_logprobs": 0, + "top_p": 0.98, + "truncation": "disabled", + "usage": { + "input_tokens": 19, + "input_tokens_details": { + "cache_write_tokens": 0, + "cached_tokens": 0 + }, + "output_tokens": 11, + "output_tokens_details": { + "reasoning_tokens": 0 + }, + "total_tokens": 30 + }, + "user": null, + "metadata": {} +} \ No newline at end of file diff --git a/packages/inference-discovery-openai/sessions/openai-responses/gpt-5.6-terra/plain-text/session.json b/packages/inference-discovery-openai/sessions/openai-responses/gpt-5.6-terra/plain-text/session.json new file mode 100644 index 000000000..15553fbd0 --- /dev/null +++ b/packages/inference-discovery-openai/sessions/openai-responses/gpt-5.6-terra/plain-text/session.json @@ -0,0 +1,11 @@ +{ + "schemaVersion": "2", + "source": { + "provider": "openai-responses", + "model": "gpt-5.6-terra", + "baseURL": "https://api.openai.com/v1" + }, + "origin": "live", + "capturedAt": "2026-10-30T05:44:04.297Z", + "capability": "plain-text" +} diff --git a/packages/inference-discovery-openai/sessions/openai-responses/gpt-5.6-terra/reasoning-content/exchanges/0/request-headers.json b/packages/inference-discovery-openai/sessions/openai-responses/gpt-5.6-terra/reasoning-content/exchanges/0/request-headers.json new file mode 100644 index 000000000..28c14bb85 --- /dev/null +++ b/packages/inference-discovery-openai/sessions/openai-responses/gpt-5.6-terra/reasoning-content/exchanges/0/request-headers.json @@ -0,0 +1,4 @@ +{ + "Content-Type": "application/json", + "Authorization": "" +} diff --git a/packages/inference-discovery-openai/sessions/openai-responses/gpt-5.6-terra/reasoning-content/exchanges/0/request.json b/packages/inference-discovery-openai/sessions/openai-responses/gpt-5.6-terra/reasoning-content/exchanges/0/request.json new file mode 100644 index 000000000..2a51b9396 --- /dev/null +++ b/packages/inference-discovery-openai/sessions/openai-responses/gpt-5.6-terra/reasoning-content/exchanges/0/request.json @@ -0,0 +1,14 @@ +{ + "model": "gpt-5.6-terra", + "input": [ + { + "type": "message", + "role": "user", + "content": "A bat and a ball cost $1.10 together. The bat costs $1.00 more than the ball. How much does the ball cost? Show your reasoning before the final answer." + } + ], + "reasoning": { + "effort": "medium", + "summary": "detailed" + } +} diff --git a/packages/inference-discovery-openai/sessions/openai-responses/gpt-5.6-terra/reasoning-content/exchanges/0/response-headers.json b/packages/inference-discovery-openai/sessions/openai-responses/gpt-5.6-terra/reasoning-content/exchanges/0/response-headers.json new file mode 100644 index 000000000..3f9bc7da0 --- /dev/null +++ b/packages/inference-discovery-openai/sessions/openai-responses/gpt-5.6-terra/reasoning-content/exchanges/0/response-headers.json @@ -0,0 +1,26 @@ +{ + "access-control-expose-headers": "X-Request-ID, Server-Timing-Total, CF-Ray, CF-Ray", + "alt-svc": "h3=\":443\"; ma=86400", + "cf-cache-status": "DYNAMIC", + "cf-ray": "a52f12d259256a29-LAX", + "connection": "keep-alive", + "content-encoding": "br", + "content-type": "application/json", + "date": "Sat, 31 Oct 2026 02:01:46 GMT", + "openai-organization": "", + "openai-processing-ms": "2672", + "openai-project": "", + "openai-version": "2020-10-01", + "server": "cloudflare", + "strict-transport-security": "max-age=31536000; includeSubDomains; preload", + "transfer-encoding": "chunked", + "x-content-type-options": "nosniff", + "x-ratelimit-limit-requests": "5000", + "x-ratelimit-limit-tokens": "1000000", + "x-ratelimit-remaining-requests": "4999", + "x-ratelimit-remaining-tokens": "1000000", + "x-ratelimit-reset-requests": "12ms", + "x-ratelimit-reset-tokens": "0s", + "x-request-id": "", + "set-cookie": "" +} diff --git a/packages/inference-discovery-openai/sessions/openai-responses/gpt-5.6-terra/reasoning-content/exchanges/0/response.json b/packages/inference-discovery-openai/sessions/openai-responses/gpt-5.6-terra/reasoning-content/exchanges/0/response.json new file mode 100644 index 000000000..d2ce7fefa --- /dev/null +++ b/packages/inference-discovery-openai/sessions/openai-responses/gpt-5.6-terra/reasoning-content/exchanges/0/response.json @@ -0,0 +1,107 @@ +{ + "id": "resp_0e0153589798e224006ae54c081dac87d091908a6f014ea6e9", + "object": "response", + "created_at": 1793412104, + "status": "completed", + "access_programs": null, + "background": false, + "billing": { + "payer": "developer" + }, + "completed_at": 1793412106, + "error": null, + "frequency_penalty": 0.0, + "incomplete_details": null, + "instructions": null, + "max_output_tokens": null, + "max_tool_calls": null, + "model": "gpt-5.6-terra", + "moderation": null, + "output": [ + { + "id": "rs_0e0153589798e224006ae54c08cdbc87d0948bea17c3683321", + "type": "reasoning", + "content": [], + "encrypted_content": "gAAAAABq5UwKsMky_MVpinRxlq_amcomHbkYAPOlPSmqAKa8LRNEoa1aZMq7QAt22SGVwASpRLFyBCrwbgoqFB3At_DNa0Ty6mhxAOc6GnC9fakb1njppHSYx5Nki81BP6SgM_8t3nQix_ciILWV7DSZtYGQyxuGbOwLOZa-EWI8cBKhFklxonUV0jhQsM_qA_rjiKkzE2JZF1bF_OiGDti4DJkS2je-THhxTlmJVOAf6Rc2G82i60jtDOwN6JRrxyfUNz3d1zL5ACiWqOwRerFves7i29OGF2f2YICicarmZNtsg-wU9wE5mGzdN9vAwAQqyWtTW_5us9bg17HYufjCzMZZ7EafoKRQ30rsCp-9LETBm_K0ihNHEihA7zGUJk3xuqmoWgu4Ya2llA8gM1J8b1xHUF94fjrwzEyLmr51LZu1FEUJ1h59iwHE3taXWUvINBUzPRaQj341igrjl6Zn2KuPAKKJvLhAyAdSYfmW9Ap28FgI1HUhA11u1Kp_RqAyephhmoQRtZGkP4FLqBHD2ymSFNPVDHkm40KVXetdcRDNkceH6UyMSWEW71DU_NoFjnyzDeVBggTiePHupUfA8quln1_0sCtw8u_XbLDcVTb6Wfuo5eE7VU1vmv2tkJw2JlkCBLDf6b1OjnlzFN_-aONy941M2jlg6KjmO-N-dIrOCWoKuvMCFTuaMjHd4zUcMi0pEzAJ_l_0egZkefrKOUcIzibT-eRavi8l0OEYLXRze9inleLi5QcXvkVOKDr5cRJBXYz5RIwehLWi7RLwt2UWlIB_SmAFDKeekPQdrEZ2tF5FFLUxzehDzd9e0gz2tS3zktptRbxBPjPAO__tRiRdwxSLefokwn_AtKWOek0IBoliMpXuQ4XrQjnXs9UBRo4-qeS9YaU4Zev_qsfBJp_E4Y5CIeXE7WrMw9KKxju9xJ2C738TbjuVli0AqDVYkVT61LQdUqd175ebiKycozeVTTclZ7VGiw_mIrSdjR1DbAKrJ3tMSN6TlK-w2xeOzqTb8Nfhf037RfjmWpdrRsOEfYBQviyhy9LUwIFUJGTpBz-UuRMn4BxK1AS6tkvzgxwxyWo8d6a0lJOFDhQmx5mYx-riIQdJwKj75GgInDKj0iYZvEnhyKK7dfIQFCGo7gaaRNocLcwsqH7DWRbGm-wftOlJvulPmTpsWLzjJzJIpGLISyeQFJTlCT5pu2OBRGZryks7svGZ6i0LCjVKkBVSFNMfyFTKD67T7_XaazXyILzNv25T7WeseNTNAnxYYC3mHIX2jCurbN5Nmweh98PGdK3igbCibobPlDV_RvzQLMafMYP3i9OiEdcgtyi3JriMYp4UOlo-Hep7rGbC9d5cduygoGDBNXNBTiLxfY0mkY1zzPvMtnTZgCUcWkxiMRc9yTYTTDCpxbRyrb6OuE9SzYNuAAqCDbuLUOh_XOpYtdcSd6SJcDX5I9HO0D4UZdQ3kq9o0--oQwDqgJ2QcdvWQj4PGdaWn2xsST49fml586V0KtkMtuZ2PnBvQUyHR4vmhdhjlVR_SYIxINdHwPlHqdpY_kNFITv73sN-0S-RMSxW7UKmQYOD8xBe-moS-i9AR5HFQhh2thIwO9vN5EKSoUJXvQ==", + "summary": [ + { + "type": "summary_text", + "text": "**Explaining algebra concisely**\n\nI'm focusing on how to explain algebra clearly! It's important for me to be concise and straightforward. I want to make sure I highlight key concepts without overwhelming details. One thing I should keep in mind is to avoid confusing jargon and stick to the essentials, like operations and equations. I wonder if drawing diagrams might help too. I really want to communicate these ideas effectively while being mindful of clarity!" + } + ] + }, + { + "id": "msg_0e0153589798e224006ae54c0a398487d0b4ac4a0dd193f6f3", + "type": "message", + "status": "completed", + "content": [ + { + "type": "output_text", + "annotations": [], + "logprobs": [], + "text": "Let the ball cost \\(x\\) dollars.\n\nThen the bat costs \\(x + 1.00\\) dollars.\n\nTogether:\n\n\\[\nx + (x + 1.00) = 1.10\n\\]\n\n\\[\n2x + 1.00 = 1.10\n\\]\n\n\\[\n2x = 0.10\n\\]\n\n\\[\nx = 0.05\n\\]\n\n**The ball costs 5 cents.**" + } + ], + "phase": "final_answer", + "role": "assistant" + } + ], + "parallel_tool_calls": true, + "presence_penalty": 0.0, + "previous_response_id": null, + "prompt_cache_key": null, + "prompt_cache_retention": "24h", + "reasoning": { + "context": "all_turns", + "effort": "medium", + "mode": "standard", + "summary": "detailed" + }, + "safety_identifier": null, + "service_tier": "default", + "store": true, + "temperature": 1.0, + "text": { + "format": { + "type": "text" + }, + "verbosity": "medium" + }, + "tool_choice": "auto", + "tool_usage": { + "image_gen": { + "input_tokens": 0, + "input_tokens_details": { + "image_tokens": 0, + "text_tokens": 0 + }, + "output_tokens": 0, + "output_tokens_details": { + "image_tokens": 0, + "text_tokens": 0 + }, + "total_tokens": 0 + }, + "web_search": { + "num_requests": 0 + } + }, + "tools": [], + "top_logprobs": 0, + "top_p": 0.98, + "truncation": "disabled", + "usage": { + "input_tokens": 45, + "input_tokens_details": { + "cache_write_tokens": 0, + "cached_tokens": 0 + }, + "output_tokens": 120, + "output_tokens_details": { + "reasoning_tokens": 18 + }, + "total_tokens": 165 + }, + "user": null, + "metadata": {} +} \ No newline at end of file diff --git a/packages/inference-discovery-openai/sessions/openai-responses/gpt-5.6-terra/reasoning-content/session.json b/packages/inference-discovery-openai/sessions/openai-responses/gpt-5.6-terra/reasoning-content/session.json new file mode 100644 index 000000000..2ce79f48f --- /dev/null +++ b/packages/inference-discovery-openai/sessions/openai-responses/gpt-5.6-terra/reasoning-content/session.json @@ -0,0 +1,11 @@ +{ + "schemaVersion": "2", + "source": { + "provider": "openai-responses", + "model": "gpt-5.6-terra", + "baseURL": "https://api.openai.com/v1" + }, + "origin": "live", + "capturedAt": "2026-10-31T02:01:46.790Z", + "capability": "reasoning-content" +} diff --git a/packages/inference-discovery-openai/sessions/openai-responses/gpt-6-astra/function-calling-multi-turn/dispatches/0-get_weather.json b/packages/inference-discovery-openai/sessions/openai-responses/gpt-6-astra/function-calling-multi-turn/dispatches/0-get_weather.json new file mode 100644 index 000000000..21f38181b --- /dev/null +++ b/packages/inference-discovery-openai/sessions/openai-responses/gpt-6-astra/function-calling-multi-turn/dispatches/0-get_weather.json @@ -0,0 +1,6 @@ +{ + "args": { + "location": "Boston, MA" + }, + "result": "{\"location\":\"Boston, MA\",\"temperatureF\":68,\"conditions\":\"clear\"}" +} diff --git a/packages/inference-discovery-openai/sessions/openai-responses/gpt-6-astra/function-calling-multi-turn/exchanges/0/request-headers.json b/packages/inference-discovery-openai/sessions/openai-responses/gpt-6-astra/function-calling-multi-turn/exchanges/0/request-headers.json new file mode 100644 index 000000000..28c14bb85 --- /dev/null +++ b/packages/inference-discovery-openai/sessions/openai-responses/gpt-6-astra/function-calling-multi-turn/exchanges/0/request-headers.json @@ -0,0 +1,4 @@ +{ + "Content-Type": "application/json", + "Authorization": "" +} diff --git a/packages/inference-discovery-openai/sessions/openai-responses/gpt-6-astra/function-calling-multi-turn/exchanges/0/request.json b/packages/inference-discovery-openai/sessions/openai-responses/gpt-6-astra/function-calling-multi-turn/exchanges/0/request.json new file mode 100644 index 000000000..80eaf2300 --- /dev/null +++ b/packages/inference-discovery-openai/sessions/openai-responses/gpt-6-astra/function-calling-multi-turn/exchanges/0/request.json @@ -0,0 +1,30 @@ +{ + "model": "gpt-6-astra", + "input": [ + { + "type": "message", + "role": "user", + "content": "What is the weather in Boston, MA? Use the provided tool." + } + ], + "tools": [ + { + "type": "function", + "name": "get_weather", + "description": "Look up the current weather for a city.", + "parameters": { + "type": "object", + "properties": { + "location": { + "type": "string", + "description": "City and optional region, e.g. 'Boston, MA'." + } + }, + "required": [ + "location" + ] + } + } + ], + "tool_choice": "auto" +} diff --git a/packages/inference-discovery-openai/sessions/openai-responses/gpt-6-astra/function-calling-multi-turn/exchanges/0/response-headers.json b/packages/inference-discovery-openai/sessions/openai-responses/gpt-6-astra/function-calling-multi-turn/exchanges/0/response-headers.json new file mode 100644 index 000000000..6d8badfd5 --- /dev/null +++ b/packages/inference-discovery-openai/sessions/openai-responses/gpt-6-astra/function-calling-multi-turn/exchanges/0/response-headers.json @@ -0,0 +1,26 @@ +{ + "access-control-expose-headers": "X-Request-ID, Server-Timing-Total, CF-Ray, CF-Ray", + "alt-svc": "h3=\":443\"; ma=86400", + "cf-cache-status": "DYNAMIC", + "cf-ray": "a52f11f96de06a29-LAX", + "connection": "keep-alive", + "content-encoding": "br", + "content-type": "application/json", + "date": "Sat, 31 Oct 2026 02:01:10 GMT", + "openai-organization": "", + "openai-processing-ms": "1394", + "openai-project": "", + "openai-version": "2020-10-01", + "server": "cloudflare", + "strict-transport-security": "max-age=31536000; includeSubDomains; preload", + "transfer-encoding": "chunked", + "x-content-type-options": "nosniff", + "x-ratelimit-limit-requests": "5000", + "x-ratelimit-limit-tokens": "1000000", + "x-ratelimit-remaining-requests": "4999", + "x-ratelimit-remaining-tokens": "1000000", + "x-ratelimit-reset-requests": "12ms", + "x-ratelimit-reset-tokens": "0s", + "x-request-id": "", + "set-cookie": "" +} diff --git a/packages/inference-discovery-openai/sessions/openai-responses/gpt-6-astra/function-calling-multi-turn/exchanges/0/response.json b/packages/inference-discovery-openai/sessions/openai-responses/gpt-6-astra/function-calling-multi-turn/exchanges/0/response.json new file mode 100644 index 000000000..3657eb40f --- /dev/null +++ b/packages/inference-discovery-openai/sessions/openai-responses/gpt-6-astra/function-calling-multi-turn/exchanges/0/response.json @@ -0,0 +1,109 @@ +{ + "id": "resp_07d1cb11bb8f3394006ae54be569a887d08f2a074d50e7c50d", + "object": "response", + "created_at": 1793412069, + "status": "completed", + "access_programs": null, + "background": false, + "billing": { + "payer": "developer" + }, + "completed_at": 1793412070, + "error": null, + "frequency_penalty": 0.0, + "incomplete_details": null, + "instructions": null, + "max_output_tokens": null, + "max_tool_calls": null, + "model": "gpt-6-astra", + "moderation": null, + "output": [ + { + "id": "fc_07d1cb11bb8f3394006ae54be677ec87d088bb93e0945afb6a", + "type": "function_call", + "status": "completed", + "arguments": "{\"location\":\"Boston, MA\"}", + "call_id": "call_NI7Z4k00UAS7qWiNqrA9P8z8", + "name": "get_weather" + } + ], + "parallel_tool_calls": true, + "presence_penalty": 0.0, + "previous_response_id": null, + "prompt_cache_key": null, + "prompt_cache_retention": "24h", + "reasoning": { + "context": "all_turns", + "effort": "medium", + "mode": "standard", + "summary": null + }, + "safety_identifier": null, + "service_tier": "default", + "store": true, + "temperature": 1.0, + "text": { + "format": { + "type": "text" + }, + "verbosity": "medium" + }, + "tool_choice": "auto", + "tool_usage": { + "image_gen": { + "input_tokens": 0, + "input_tokens_details": { + "image_tokens": 0, + "text_tokens": 0 + }, + "output_tokens": 0, + "output_tokens_details": { + "image_tokens": 0, + "text_tokens": 0 + }, + "total_tokens": 0 + }, + "web_search": { + "num_requests": 0 + } + }, + "tools": [ + { + "type": "function", + "description": "Look up the current weather for a city.", + "name": "get_weather", + "output_schema": null, + "parameters": { + "type": "object", + "properties": { + "location": { + "type": "string", + "description": "City and optional region, e.g. 'Boston, MA'." + } + }, + "required": [ + "location" + ], + "additionalProperties": false + }, + "strict": true + } + ], + "top_logprobs": 0, + "top_p": 0.98, + "truncation": "disabled", + "usage": { + "input_tokens": 73, + "input_tokens_details": { + "cache_write_tokens": 0, + "cached_tokens": 0 + }, + "output_tokens": 20, + "output_tokens_details": { + "reasoning_tokens": 0 + }, + "total_tokens": 93 + }, + "user": null, + "metadata": {} +} \ No newline at end of file diff --git a/packages/inference-discovery-openai/sessions/openai-responses/gpt-6-astra/function-calling-multi-turn/exchanges/1/request-headers.json b/packages/inference-discovery-openai/sessions/openai-responses/gpt-6-astra/function-calling-multi-turn/exchanges/1/request-headers.json new file mode 100644 index 000000000..28c14bb85 --- /dev/null +++ b/packages/inference-discovery-openai/sessions/openai-responses/gpt-6-astra/function-calling-multi-turn/exchanges/1/request-headers.json @@ -0,0 +1,4 @@ +{ + "Content-Type": "application/json", + "Authorization": "" +} diff --git a/packages/inference-discovery-openai/sessions/openai-responses/gpt-6-astra/function-calling-multi-turn/exchanges/1/request.json b/packages/inference-discovery-openai/sessions/openai-responses/gpt-6-astra/function-calling-multi-turn/exchanges/1/request.json new file mode 100644 index 000000000..fd64ae0dc --- /dev/null +++ b/packages/inference-discovery-openai/sessions/openai-responses/gpt-6-astra/function-calling-multi-turn/exchanges/1/request.json @@ -0,0 +1,45 @@ +{ + "model": "gpt-6-astra", + "input": [ + { + "type": "message", + "role": "user", + "content": "What is the weather in Boston, MA? Use the provided tool." + }, + { + "type": "function_call", + "call_id": "call_NI7Z4k00UAS7qWiNqrA9P8z8", + "name": "get_weather", + "arguments": "{\"location\":\"Boston, MA\"}" + }, + { + "type": "function_call_output", + "call_id": "call_NI7Z4k00UAS7qWiNqrA9P8z8", + "output": "{\"location\":\"Boston, MA\",\"temperatureF\":68,\"conditions\":\"clear\"}" + } + ], + "store": false, + "include": [ + "reasoning.encrypted_content" + ], + "tools": [ + { + "type": "function", + "name": "get_weather", + "description": "Look up the current weather for a city.", + "parameters": { + "type": "object", + "properties": { + "location": { + "type": "string", + "description": "City and optional region, e.g. 'Boston, MA'." + } + }, + "required": [ + "location" + ] + } + } + ], + "tool_choice": "auto" +} diff --git a/packages/inference-discovery-openai/sessions/openai-responses/gpt-6-astra/function-calling-multi-turn/exchanges/1/response-headers.json b/packages/inference-discovery-openai/sessions/openai-responses/gpt-6-astra/function-calling-multi-turn/exchanges/1/response-headers.json new file mode 100644 index 000000000..45b87e378 --- /dev/null +++ b/packages/inference-discovery-openai/sessions/openai-responses/gpt-6-astra/function-calling-multi-turn/exchanges/1/response-headers.json @@ -0,0 +1,26 @@ +{ + "access-control-expose-headers": "X-Request-ID, Server-Timing-Total, CF-Ray, CF-Ray", + "alt-svc": "h3=\":443\"; ma=86400", + "cf-cache-status": "DYNAMIC", + "cf-ray": "a52f1202df636a29-LAX", + "connection": "keep-alive", + "content-encoding": "br", + "content-type": "application/json", + "date": "Sat, 31 Oct 2026 02:01:12 GMT", + "openai-organization": "", + "openai-processing-ms": "1457", + "openai-project": "", + "openai-version": "2020-10-01", + "server": "cloudflare", + "strict-transport-security": "max-age=31536000; includeSubDomains; preload", + "transfer-encoding": "chunked", + "x-content-type-options": "nosniff", + "x-ratelimit-limit-requests": "5000", + "x-ratelimit-limit-tokens": "1000000", + "x-ratelimit-remaining-requests": "4999", + "x-ratelimit-remaining-tokens": "1000000", + "x-ratelimit-reset-requests": "12ms", + "x-ratelimit-reset-tokens": "0s", + "x-request-id": "", + "set-cookie": "" +} diff --git a/packages/inference-discovery-openai/sessions/openai-responses/gpt-6-astra/function-calling-multi-turn/exchanges/1/response.json b/packages/inference-discovery-openai/sessions/openai-responses/gpt-6-astra/function-calling-multi-turn/exchanges/1/response.json new file mode 100644 index 000000000..61fa2d23d --- /dev/null +++ b/packages/inference-discovery-openai/sessions/openai-responses/gpt-6-astra/function-calling-multi-turn/exchanges/1/response.json @@ -0,0 +1,116 @@ +{ + "id": "resp_05ad9a15bba334cc016ae54be6ef2c87d0b7b4e7af937412c6", + "object": "response", + "created_at": 1793412070, + "status": "completed", + "access_programs": null, + "background": false, + "billing": { + "payer": "developer" + }, + "completed_at": 1793412072, + "error": null, + "frequency_penalty": 0.0, + "incomplete_details": null, + "instructions": null, + "max_output_tokens": null, + "max_tool_calls": null, + "model": "gpt-6-astra", + "moderation": null, + "output": [ + { + "id": "msg_05ad9a15bba334cc016ae54be7d60087d0a1ae4b6643cb4a71", + "type": "message", + "status": "completed", + "content": [ + { + "type": "output_text", + "annotations": [], + "logprobs": [], + "text": "It\u2019s currently clear and 68\u00b0F (20\u00b0C) in Boston, MA." + } + ], + "phase": "final_answer", + "role": "assistant" + } + ], + "parallel_tool_calls": true, + "presence_penalty": 0.0, + "previous_response_id": null, + "prompt_cache_key": null, + "prompt_cache_retention": "24h", + "reasoning": { + "context": "all_turns", + "effort": "medium", + "mode": "standard", + "summary": null + }, + "safety_identifier": null, + "service_tier": "default", + "store": false, + "temperature": 1.0, + "text": { + "format": { + "type": "text" + }, + "verbosity": "medium" + }, + "tool_choice": "auto", + "tool_usage": { + "image_gen": { + "input_tokens": 0, + "input_tokens_details": { + "image_tokens": 0, + "text_tokens": 0 + }, + "output_tokens": 0, + "output_tokens_details": { + "image_tokens": 0, + "text_tokens": 0 + }, + "total_tokens": 0 + }, + "web_search": { + "num_requests": 0 + } + }, + "tools": [ + { + "type": "function", + "description": "Look up the current weather for a city.", + "name": "get_weather", + "output_schema": null, + "parameters": { + "type": "object", + "properties": { + "location": { + "type": "string", + "description": "City and optional region, e.g. 'Boston, MA'." + } + }, + "required": [ + "location" + ], + "additionalProperties": false + }, + "strict": true + } + ], + "top_logprobs": 0, + "top_p": 0.98, + "truncation": "disabled", + "usage": { + "input_tokens": 120, + "input_tokens_details": { + "cache_write_tokens": 0, + "cached_tokens": 0 + }, + "output_tokens": 21, + "output_tokens_details": { + "reasoning_tokens": 0 + }, + "total_tokens": 141 + }, + "user": null, + "metadata": {} +} \ No newline at end of file diff --git a/packages/inference-discovery-openai/sessions/openai-responses/gpt-6-astra/function-calling-multi-turn/session.json b/packages/inference-discovery-openai/sessions/openai-responses/gpt-6-astra/function-calling-multi-turn/session.json new file mode 100644 index 000000000..b675bcfae --- /dev/null +++ b/packages/inference-discovery-openai/sessions/openai-responses/gpt-6-astra/function-calling-multi-turn/session.json @@ -0,0 +1,11 @@ +{ + "schemaVersion": "2", + "source": { + "provider": "openai-responses", + "model": "gpt-6-astra", + "baseURL": "https://api.openai.com/v1" + }, + "origin": "live", + "capturedAt": "2026-10-31T02:01:12.417Z", + "capability": "function-calling-multi-turn" +} diff --git a/packages/inference-discovery-openai/sessions/openai-responses/gpt-6-astra/plain-text-streaming/exchanges/0/request-headers.json b/packages/inference-discovery-openai/sessions/openai-responses/gpt-6-astra/plain-text-streaming/exchanges/0/request-headers.json new file mode 100644 index 000000000..28c14bb85 --- /dev/null +++ b/packages/inference-discovery-openai/sessions/openai-responses/gpt-6-astra/plain-text-streaming/exchanges/0/request-headers.json @@ -0,0 +1,4 @@ +{ + "Content-Type": "application/json", + "Authorization": "" +} diff --git a/packages/inference-discovery-openai/sessions/openai-responses/gpt-6-astra/plain-text-streaming/exchanges/0/request.json b/packages/inference-discovery-openai/sessions/openai-responses/gpt-6-astra/plain-text-streaming/exchanges/0/request.json new file mode 100644 index 000000000..de48a7421 --- /dev/null +++ b/packages/inference-discovery-openai/sessions/openai-responses/gpt-6-astra/plain-text-streaming/exchanges/0/request.json @@ -0,0 +1,11 @@ +{ + "model": "gpt-6-astra", + "input": [ + { + "type": "message", + "role": "user", + "content": "Reply with a single sentence: the capital of France is Paris." + } + ], + "stream": true +} diff --git a/packages/inference-discovery-openai/sessions/openai-responses/gpt-6-astra/plain-text-streaming/exchanges/0/response-headers.json b/packages/inference-discovery-openai/sessions/openai-responses/gpt-6-astra/plain-text-streaming/exchanges/0/response-headers.json new file mode 100644 index 000000000..fb1d2a464 --- /dev/null +++ b/packages/inference-discovery-openai/sessions/openai-responses/gpt-6-astra/plain-text-streaming/exchanges/0/response-headers.json @@ -0,0 +1,25 @@ +{ + "access-control-expose-headers": "X-Request-ID, Server-Timing-Total, CF-Ray, CF-Ray", + "alt-svc": "h3=\":443\"; ma=86400", + "cf-cache-status": "DYNAMIC", + "cf-ray": "a52817478830581e-LAX", + "connection": "keep-alive", + "content-type": "text/event-stream; charset=utf-8", + "date": "Fri, 30 Oct 2026 05:41:26 GMT", + "openai-organization": "", + "openai-processing-ms": "261", + "openai-project": "", + "openai-version": "2020-10-01", + "server": "cloudflare", + "strict-transport-security": "max-age=31536000; includeSubDomains; preload", + "transfer-encoding": "chunked", + "x-content-type-options": "nosniff", + "x-ratelimit-limit-requests": "5000", + "x-ratelimit-limit-tokens": "1000000", + "x-ratelimit-remaining-requests": "4999", + "x-ratelimit-remaining-tokens": "999838", + "x-ratelimit-reset-requests": "12ms", + "x-ratelimit-reset-tokens": "9ms", + "x-request-id": "", + "set-cookie": "" +} diff --git a/packages/inference-discovery-openai/sessions/openai-responses/gpt-6-astra/plain-text-streaming/exchanges/0/response.sse b/packages/inference-discovery-openai/sessions/openai-responses/gpt-6-astra/plain-text-streaming/exchanges/0/response.sse new file mode 100644 index 000000000..a64e647dd --- /dev/null +++ b/packages/inference-discovery-openai/sessions/openai-responses/gpt-6-astra/plain-text-streaming/exchanges/0/response.sse @@ -0,0 +1,45 @@ +event: response.created +data: {"type":"response.created","response":{"id":"resp_00b8a8b988d13b80006ae42e0666b087d094a28848d7e10f08","object":"response","created_at":1793338886,"status":"in_progress","access_programs":null,"background":false,"completed_at":null,"error":null,"frequency_penalty":0.0,"incomplete_details":null,"instructions":null,"max_output_tokens":null,"max_tool_calls":null,"model":"gpt-6-astra","moderation":null,"output":[],"parallel_tool_calls":true,"presence_penalty":0.0,"previous_response_id":null,"prompt_cache_key":null,"prompt_cache_retention":"24h","reasoning":{"context":"all_turns","effort":"medium","mode":"standard","summary":null},"safety_identifier":null,"service_tier":"auto","store":true,"temperature":1.0,"text":{"format":{"type":"text"},"verbosity":"medium"},"tool_choice":"auto","tool_usage":{"image_gen":{"input_tokens":0,"input_tokens_details":{"image_tokens":0,"text_tokens":0},"output_tokens":0,"output_tokens_details":{"image_tokens":0,"text_tokens":0},"total_tokens":0},"web_search":{"num_requests":0}},"tools":[],"top_logprobs":0,"top_p":0.98,"truncation":"disabled","usage":null,"user":null,"metadata":{}},"sequence_number":0} + +event: response.in_progress +data: {"type":"response.in_progress","response":{"id":"resp_00b8a8b988d13b80006ae42e0666b087d094a28848d7e10f08","object":"response","created_at":1793338886,"status":"in_progress","access_programs":null,"background":false,"completed_at":null,"error":null,"frequency_penalty":0.0,"incomplete_details":null,"instructions":null,"max_output_tokens":null,"max_tool_calls":null,"model":"gpt-6-astra","moderation":null,"output":[],"parallel_tool_calls":true,"presence_penalty":0.0,"previous_response_id":null,"prompt_cache_key":null,"prompt_cache_retention":"24h","reasoning":{"context":"all_turns","effort":"medium","mode":"standard","summary":null},"safety_identifier":null,"service_tier":"auto","store":true,"temperature":1.0,"text":{"format":{"type":"text"},"verbosity":"medium"},"tool_choice":"auto","tool_usage":{"image_gen":{"input_tokens":0,"input_tokens_details":{"image_tokens":0,"text_tokens":0},"output_tokens":0,"output_tokens_details":{"image_tokens":0,"text_tokens":0},"total_tokens":0},"web_search":{"num_requests":0}},"tools":[],"top_logprobs":0,"top_p":0.98,"truncation":"disabled","usage":null,"user":null,"metadata":{}},"sequence_number":1} + +event: response.output_item.added +data: {"type":"response.output_item.added","item":{"id":"msg_00b8a8b988d13b80006ae42e06fbc487d0ba3e7e184a78ce23","type":"message","status":"in_progress","content":[],"phase":"final_answer","role":"assistant"},"output_index":0,"sequence_number":2} + +event: response.content_part.added +data: {"type":"response.content_part.added","content_index":0,"item_id":"msg_00b8a8b988d13b80006ae42e06fbc487d0ba3e7e184a78ce23","output_index":0,"part":{"type":"output_text","annotations":[],"logprobs":[],"text":""},"sequence_number":3} + +event: response.output_text.delta +data: {"type":"response.output_text.delta","content_index":0,"delta":"The","item_id":"msg_00b8a8b988d13b80006ae42e06fbc487d0ba3e7e184a78ce23","logprobs":[],"obfuscation":"p7imJJ8ky9Mw3","output_index":0,"sequence_number":4} + +event: response.output_text.delta +data: {"type":"response.output_text.delta","content_index":0,"delta":" capital","item_id":"msg_00b8a8b988d13b80006ae42e06fbc487d0ba3e7e184a78ce23","logprobs":[],"obfuscation":"dF66KSGc","output_index":0,"sequence_number":5} + +event: response.output_text.delta +data: {"type":"response.output_text.delta","content_index":0,"delta":" of","item_id":"msg_00b8a8b988d13b80006ae42e06fbc487d0ba3e7e184a78ce23","logprobs":[],"obfuscation":"ejwHt8LsxbKyx","output_index":0,"sequence_number":6} + +event: response.output_text.delta +data: {"type":"response.output_text.delta","content_index":0,"delta":" France","item_id":"msg_00b8a8b988d13b80006ae42e06fbc487d0ba3e7e184a78ce23","logprobs":[],"obfuscation":"aUf6FRfkT","output_index":0,"sequence_number":7} + +event: response.output_text.delta +data: {"type":"response.output_text.delta","content_index":0,"delta":" is","item_id":"msg_00b8a8b988d13b80006ae42e06fbc487d0ba3e7e184a78ce23","logprobs":[],"obfuscation":"75g5bNqaDp6LT","output_index":0,"sequence_number":8} + +event: response.output_text.delta +data: {"type":"response.output_text.delta","content_index":0,"delta":" Paris","item_id":"msg_00b8a8b988d13b80006ae42e06fbc487d0ba3e7e184a78ce23","logprobs":[],"obfuscation":"oYWQBPbZ3D","output_index":0,"sequence_number":9} + +event: response.output_text.delta +data: {"type":"response.output_text.delta","content_index":0,"delta":".","item_id":"msg_00b8a8b988d13b80006ae42e06fbc487d0ba3e7e184a78ce23","logprobs":[],"obfuscation":"QlRQiIbrG6yIZAl","output_index":0,"sequence_number":10} + +event: response.output_text.done +data: {"type":"response.output_text.done","content_index":0,"item_id":"msg_00b8a8b988d13b80006ae42e06fbc487d0ba3e7e184a78ce23","logprobs":[],"output_index":0,"sequence_number":11,"text":"The capital of France is Paris."} + +event: response.content_part.done +data: {"type":"response.content_part.done","content_index":0,"item_id":"msg_00b8a8b988d13b80006ae42e06fbc487d0ba3e7e184a78ce23","output_index":0,"part":{"type":"output_text","annotations":[],"logprobs":[],"text":"The capital of France is Paris."},"sequence_number":12} + +event: response.output_item.done +data: {"type":"response.output_item.done","item":{"id":"msg_00b8a8b988d13b80006ae42e06fbc487d0ba3e7e184a78ce23","type":"message","status":"completed","content":[{"type":"output_text","annotations":[],"logprobs":[],"text":"The capital of France is Paris."}],"phase":"final_answer","role":"assistant"},"output_index":0,"sequence_number":13} + +event: response.completed +data: {"type":"response.completed","response":{"id":"resp_00b8a8b988d13b80006ae42e0666b087d094a28848d7e10f08","object":"response","created_at":1793338886,"status":"completed","access_programs":null,"background":false,"completed_at":1793338887,"error":null,"frequency_penalty":0.0,"incomplete_details":null,"instructions":null,"max_output_tokens":null,"max_tool_calls":null,"model":"gpt-6-astra","moderation":null,"output":[{"id":"msg_00b8a8b988d13b80006ae42e06fbc487d0ba3e7e184a78ce23","type":"message","status":"completed","content":[{"type":"output_text","annotations":[],"logprobs":[],"text":"The capital of France is Paris."}],"phase":"final_answer","role":"assistant"}],"parallel_tool_calls":true,"presence_penalty":0.0,"previous_response_id":null,"prompt_cache_key":null,"prompt_cache_retention":"24h","reasoning":{"context":"all_turns","effort":"medium","mode":"standard","summary":null},"safety_identifier":null,"service_tier":"default","store":true,"temperature":1.0,"text":{"format":{"type":"text"},"verbosity":"medium"},"tool_choice":"auto","tool_usage":{"image_gen":{"input_tokens":0,"input_tokens_details":{"image_tokens":0,"text_tokens":0},"output_tokens":0,"output_tokens_details":{"image_tokens":0,"text_tokens":0},"total_tokens":0},"web_search":{"num_requests":0}},"tools":[],"top_logprobs":0,"top_p":0.98,"truncation":"disabled","usage":{"input_tokens":19,"input_tokens_details":{"cache_write_tokens":0,"cached_tokens":0},"output_tokens":11,"output_tokens_details":{"reasoning_tokens":0},"total_tokens":30},"user":null,"metadata":{}},"sequence_number":14} + diff --git a/packages/inference-discovery-openai/sessions/openai-responses/gpt-6-astra/plain-text-streaming/session.json b/packages/inference-discovery-openai/sessions/openai-responses/gpt-6-astra/plain-text-streaming/session.json new file mode 100644 index 000000000..80586e9e0 --- /dev/null +++ b/packages/inference-discovery-openai/sessions/openai-responses/gpt-6-astra/plain-text-streaming/session.json @@ -0,0 +1,11 @@ +{ + "schemaVersion": "2", + "source": { + "provider": "openai-responses", + "model": "gpt-6-astra", + "baseURL": "https://api.openai.com/v1" + }, + "origin": "live", + "capturedAt": "2026-10-30T05:41:27.321Z", + "capability": "plain-text-streaming" +} diff --git a/packages/inference-discovery-openai/sessions/openai-responses/gpt-6-astra/plain-text/exchanges/0/request-headers.json b/packages/inference-discovery-openai/sessions/openai-responses/gpt-6-astra/plain-text/exchanges/0/request-headers.json new file mode 100644 index 000000000..28c14bb85 --- /dev/null +++ b/packages/inference-discovery-openai/sessions/openai-responses/gpt-6-astra/plain-text/exchanges/0/request-headers.json @@ -0,0 +1,4 @@ +{ + "Content-Type": "application/json", + "Authorization": "" +} diff --git a/packages/inference-discovery-openai/sessions/openai-responses/gpt-6-astra/plain-text/exchanges/0/request.json b/packages/inference-discovery-openai/sessions/openai-responses/gpt-6-astra/plain-text/exchanges/0/request.json new file mode 100644 index 000000000..87fee25f0 --- /dev/null +++ b/packages/inference-discovery-openai/sessions/openai-responses/gpt-6-astra/plain-text/exchanges/0/request.json @@ -0,0 +1,10 @@ +{ + "model": "gpt-6-astra", + "input": [ + { + "type": "message", + "role": "user", + "content": "Reply with a single sentence: the capital of France is Paris." + } + ] +} diff --git a/packages/inference-discovery-openai/sessions/openai-responses/gpt-6-astra/plain-text/exchanges/0/response-headers.json b/packages/inference-discovery-openai/sessions/openai-responses/gpt-6-astra/plain-text/exchanges/0/response-headers.json new file mode 100644 index 000000000..8a0269554 --- /dev/null +++ b/packages/inference-discovery-openai/sessions/openai-responses/gpt-6-astra/plain-text/exchanges/0/response-headers.json @@ -0,0 +1,26 @@ +{ + "access-control-expose-headers": "X-Request-ID, Server-Timing-Total, CF-Ray, CF-Ray", + "alt-svc": "h3=\":443\"; ma=86400", + "cf-cache-status": "DYNAMIC", + "cf-ray": "a528173dcbe5581e-LAX", + "connection": "keep-alive", + "content-encoding": "br", + "content-type": "application/json", + "date": "Fri, 30 Oct 2026 05:41:26 GMT", + "openai-organization": "", + "openai-processing-ms": "1474", + "openai-project": "", + "openai-version": "2020-10-01", + "server": "cloudflare", + "strict-transport-security": "max-age=31536000; includeSubDomains; preload", + "transfer-encoding": "chunked", + "x-content-type-options": "nosniff", + "x-ratelimit-limit-requests": "5000", + "x-ratelimit-limit-tokens": "1000000", + "x-ratelimit-remaining-requests": "4999", + "x-ratelimit-remaining-tokens": "1000000", + "x-ratelimit-reset-requests": "12ms", + "x-ratelimit-reset-tokens": "0s", + "x-request-id": "", + "set-cookie": "" +} diff --git a/packages/inference-discovery-openai/sessions/openai-responses/gpt-6-astra/plain-text/exchanges/0/response.json b/packages/inference-discovery-openai/sessions/openai-responses/gpt-6-astra/plain-text/exchanges/0/response.json new file mode 100644 index 000000000..5892926a3 --- /dev/null +++ b/packages/inference-discovery-openai/sessions/openai-responses/gpt-6-astra/plain-text/exchanges/0/response.json @@ -0,0 +1,102 @@ +{ + "id": "resp_041b00c211a3dc0c006ae42e04d57c87d0a3d6aa89ef5a3e52", + "object": "response", + "created_at": 1793338884, + "status": "completed", + "access_programs": null, + "background": false, + "billing": { + "payer": "developer" + }, + "completed_at": 1793338886, + "error": null, + "frequency_penalty": 0.0, + "incomplete_details": null, + "instructions": null, + "max_output_tokens": null, + "max_tool_calls": null, + "model": "gpt-6-astra", + "moderation": null, + "output": [ + { + "id": "rs_041b00c211a3dc0c006ae42e05d15887d08cb91982589038b9", + "type": "reasoning", + "content": [], + "encrypted_content": "gAAAAABq5C4Gj5iyQA0ckSma-l6izbc4H5YEvPT-eOGmVlFlN8clORnfrIpk16fKAdJAE-e0atEPWRSVGBK0D3ldtU4QxqVLpiG3eL6VP6IZda-DI-P7Y6ZRTaw6i616MYAGiK4kCHSFZfsLijDFa9-SGP_1VRXpIp7_Gg6SBF3FayPtm9zvgfEPt_OCKuLUZhNeOzZka7y2-NCjPu2u4ZZs8gEw-xQo45UuPPJ5XKuK5Zy7crE5E3IF3m8Ptjrd7CuU2khxY96fsG8QBi4FylWTAkadogeovP7ZE5IteX0NBYzAAksJ-lhb92xqiQBQ7T2QEHL1qiuAfeTv0446lwedyFU7_dCzAzVVVM6TsMZRGO4Ety_6cnOQDzimlskAY7eWnUJPpl-NbwezE5lJ6nRM8DjmtRGpOc8RzESPqkLGqinpq5TXR2PAkJDuekCklfNhDoAJ6dF3z7-U64GzT-KcKvlpFX3LmaNMbXOb2SeBI5O4DMlLcYVecZIYotn5N7MC7P0MUteylBcIkorFMvzxt1Dk8eyY2uyvnyJ6RQyNlZWrFLDGiEXllfxuTTMpD7SxUIYoDxvkZWobDnfHYcuoT864-7-V3ROoxeyKDSddoGBRi9h3-ABROHY1RQ7lbgdjQSVAogUgg8EpZwvBvkSVDeTzBNtikImRgNTbYfh8Z1wn20JFORVjhf-H78rTsaw8Td0Zxyt6ejREbhrNgGGmgIKL0SCXPcWhl8TSd8Hnebf7R8cNkVpRFSC8u5nvcTpjioCpQySmOHAo59rWrPiWHOlJlM-_8a6K32eOP1lNInhIX5n8KverLvf4-JL7B39HiO23D7GUeO8rhMKHGFbxN17i8a3qONzEeh77YSPE4tsIQX5p6-aHXFT1msGbMwhF9os_3eYTzvBcAiFF2XUwdbujdjSu3EbuKUZ5pG0YRop6akbZHmWW8bE3bsiWtDg2G6mfqI8kcS2rXTV6rM72ThO2vGCO7_ZTmMu0jKKPOVnkRO8YRqLlP3504Vp-yIfNXpt5c4ECh0jkYRsE36Q7wn_4gmenS-BESePTc8xwUUbnPX0fLyVAvAtKu7lso-8R8ZR6z7crlREErWdzYk_6lgIqVs86vn8ll8IeN5Rq8lTSjYkmOXcDWTeXiDePAF0XjbO5-rBzKqqQeqWKdIdrF0XmQilnaJlstjiE3xkBoD1faMpuHriwt6rbyAl47gT44_tA24sm1TYQ2ElAXFnKDiWZOrqwMcEMwaVF5sscqzR4GXUiO2AJaHrchAElL-Gq6VFj0_fpQOwFq9SVQHTfasNCVbm5XSqhZvUfZ_BRLYLx8sujRdeeBGLLWXUnoxlJxKzW7aHAw9FBCySn6Vj-p-4ytbdLXKPUAE194LTlrXDuszc2GBjTMFGTLC_we6WG4BKuyN-eXPTMZK9ZZGmdAJCgL7A5QhWwVmmL6-bNz4x-1LEWuiPIqhMicc2VCale5lj_49tP1W8pnAB7ie0QJ6qhkF8RKaQ4dW-K82n52hVtsvlKrwPdIQ_P-1M6fA4ioX_5dBszUiRnt_n8HJGt4EOyXoGxtMPJyEqMJj-QdFQrtqchyiaP8tQfO1RrYNmI7yCyowrf_5CtZ1Afz5xNZnPujuLnvJD-4FSTyLMKzAEvQitiJi_5efCjjX7mMeXL3TE1vMVQhA_z2r76Sa3lVcVOLpvFUmQO7U8P-z60ge41Ag3gqLME24gULTkjsB9QJQ-RuyKHtvhTaGpsvZmrT7YcKza6xw==", + "summary": [] + }, + { + "id": "msg_041b00c211a3dc0c006ae42e05f9d887d0a70c9ded6d46bf43", + "type": "message", + "status": "completed", + "content": [ + { + "type": "output_text", + "annotations": [], + "logprobs": [], + "text": "The capital of France is Paris." + } + ], + "phase": "final_answer", + "role": "assistant" + } + ], + "parallel_tool_calls": true, + "presence_penalty": 0.0, + "previous_response_id": null, + "prompt_cache_key": null, + "prompt_cache_retention": "24h", + "reasoning": { + "context": "all_turns", + "effort": "medium", + "mode": "standard", + "summary": null + }, + "safety_identifier": null, + "service_tier": "default", + "store": true, + "temperature": 1.0, + "text": { + "format": { + "type": "text" + }, + "verbosity": "medium" + }, + "tool_choice": "auto", + "tool_usage": { + "image_gen": { + "input_tokens": 0, + "input_tokens_details": { + "image_tokens": 0, + "text_tokens": 0 + }, + "output_tokens": 0, + "output_tokens_details": { + "image_tokens": 0, + "text_tokens": 0 + }, + "total_tokens": 0 + }, + "web_search": { + "num_requests": 0 + } + }, + "tools": [], + "top_logprobs": 0, + "top_p": 0.98, + "truncation": "disabled", + "usage": { + "input_tokens": 19, + "input_tokens_details": { + "cache_write_tokens": 0, + "cached_tokens": 0 + }, + "output_tokens": 38, + "output_tokens_details": { + "reasoning_tokens": 25 + }, + "total_tokens": 57 + }, + "user": null, + "metadata": {} +} \ No newline at end of file diff --git a/packages/inference-discovery-openai/sessions/openai-responses/gpt-6-astra/plain-text/session.json b/packages/inference-discovery-openai/sessions/openai-responses/gpt-6-astra/plain-text/session.json new file mode 100644 index 000000000..0d84a1310 --- /dev/null +++ b/packages/inference-discovery-openai/sessions/openai-responses/gpt-6-astra/plain-text/session.json @@ -0,0 +1,11 @@ +{ + "schemaVersion": "2", + "source": { + "provider": "openai-responses", + "model": "gpt-6-astra", + "baseURL": "https://api.openai.com/v1" + }, + "origin": "live", + "capturedAt": "2026-10-30T05:41:26.313Z", + "capability": "plain-text" +} diff --git a/packages/inference-discovery-openai/sessions/openai-responses/gpt-6-astra/reasoning-content/exchanges/0/request-headers.json b/packages/inference-discovery-openai/sessions/openai-responses/gpt-6-astra/reasoning-content/exchanges/0/request-headers.json new file mode 100644 index 000000000..28c14bb85 --- /dev/null +++ b/packages/inference-discovery-openai/sessions/openai-responses/gpt-6-astra/reasoning-content/exchanges/0/request-headers.json @@ -0,0 +1,4 @@ +{ + "Content-Type": "application/json", + "Authorization": "" +} diff --git a/packages/inference-discovery-openai/sessions/openai-responses/gpt-6-astra/reasoning-content/exchanges/0/request.json b/packages/inference-discovery-openai/sessions/openai-responses/gpt-6-astra/reasoning-content/exchanges/0/request.json new file mode 100644 index 000000000..743c0cd38 --- /dev/null +++ b/packages/inference-discovery-openai/sessions/openai-responses/gpt-6-astra/reasoning-content/exchanges/0/request.json @@ -0,0 +1,14 @@ +{ + "model": "gpt-6-astra", + "input": [ + { + "type": "message", + "role": "user", + "content": "A bat and a ball cost $1.10 together. The bat costs $1.00 more than the ball. How much does the ball cost? Show your reasoning before the final answer." + } + ], + "reasoning": { + "effort": "medium", + "summary": "detailed" + } +} diff --git a/packages/inference-discovery-openai/sessions/openai-responses/gpt-6-astra/reasoning-content/exchanges/0/response-headers.json b/packages/inference-discovery-openai/sessions/openai-responses/gpt-6-astra/reasoning-content/exchanges/0/response-headers.json new file mode 100644 index 000000000..9b4aa5793 --- /dev/null +++ b/packages/inference-discovery-openai/sessions/openai-responses/gpt-6-astra/reasoning-content/exchanges/0/response-headers.json @@ -0,0 +1,26 @@ +{ + "access-control-expose-headers": "X-Request-ID, Server-Timing-Total, CF-Ray, CF-Ray", + "alt-svc": "h3=\":443\"; ma=86400", + "cf-cache-status": "DYNAMIC", + "cf-ray": "a52f120cae876a29-LAX", + "connection": "keep-alive", + "content-encoding": "br", + "content-type": "application/json", + "date": "Sat, 31 Oct 2026 02:01:15 GMT", + "openai-organization": "", + "openai-processing-ms": "2744", + "openai-project": "", + "openai-version": "2020-10-01", + "server": "cloudflare", + "strict-transport-security": "max-age=31536000; includeSubDomains; preload", + "transfer-encoding": "chunked", + "x-content-type-options": "nosniff", + "x-ratelimit-limit-requests": "5000", + "x-ratelimit-limit-tokens": "1000000", + "x-ratelimit-remaining-requests": "4999", + "x-ratelimit-remaining-tokens": "1000000", + "x-ratelimit-reset-requests": "12ms", + "x-ratelimit-reset-tokens": "0s", + "x-request-id": "", + "set-cookie": "" +} diff --git a/packages/inference-discovery-openai/sessions/openai-responses/gpt-6-astra/reasoning-content/exchanges/0/response.json b/packages/inference-discovery-openai/sessions/openai-responses/gpt-6-astra/reasoning-content/exchanges/0/response.json new file mode 100644 index 000000000..2f33c94cc --- /dev/null +++ b/packages/inference-discovery-openai/sessions/openai-responses/gpt-6-astra/reasoning-content/exchanges/0/response.json @@ -0,0 +1,107 @@ +{ + "id": "resp_074e98c169121fe1006ae54be87c2c87d0b80b312b1a6afc91", + "object": "response", + "created_at": 1793412072, + "status": "completed", + "access_programs": null, + "background": false, + "billing": { + "payer": "developer" + }, + "completed_at": 1793412075, + "error": null, + "frequency_penalty": 0.0, + "incomplete_details": null, + "instructions": null, + "max_output_tokens": null, + "max_tool_calls": null, + "model": "gpt-6-astra", + "moderation": null, + "output": [ + { + "id": "rs_074e98c169121fe1006ae54be9576c87d09d8ac56eea182c06", + "type": "reasoning", + "content": [], + "encrypted_content": "gAAAAABq5UvrYdosv3Rs8C9B66Xe5ptSz6zNUr10rY57rMZ9vv_RfJsWwnroiO0Ul4to6Pd7DcmcAqg2cpFB-jvOPoSDSb0KaokEFOJgp_CD521vbSNDQCqbf8dlYt0-E1HYcVKAzsMDgCJIN0jWZV8ZKH3YV45O2dBJuTyYAn-PdAWBh41b6wZl0Tm9yL4lv2ss6TYPEHOlZN0IfCQCIYvkb5gmCEUW-y6fnowEvOQvabtYgGcIoHaLaEWuayh6vRMe4nA_7038tVvLmtsjhkTa6GHp9ojMwLkadwMdJnIzvYddzSEaoeAhvBXyvONEAv9npLIbNcVI13zOg6hnNlzSMWTNdHUx1dDzL9Nl6BB00RVAcPSRPZ39I9VjbOstheKJ9Qdl7MtMihrd5YCBC5qpRfXc4ilLF2hAXwFBdwml3kIV2Hvv5o1v_Mioff5qOFNRHa6v7H0Xft1_0DnotWPlDaDP4BzQnYEZsV5f_s9cKKUM2THdx7ujpawqvmZN8AWqk83JU_ygco1HqXwRZkdzOoP3s63cqXWdE-c53ANDZlDk8UR64qLaibCsjR_vJ1G--E3uLtXR-DkJq1EvMmZBFkEDqtQOuwToAuzWlM72Vdfr_57eyc7VLzI492RPSCENL9clX2-u20NP6uQ3Kh9uR9IVXRn9Va17g9GLKZCT8qZaIHbJa_Ar_hbV_Uu-08yNmzJQACvbWUhvbTGPk6KqjMALSBi9ecgsgrErOZg5NbcyV700BPrwiiXMyiV_Bu9iU13k6xp2zX5SgCAKDBVg9Z5-ZD0S5SS2L0l_7Me3QMsWZ_GGicjBbaA3SNSfG3M0XiEFaDymP5Mvqc5Ynoe9bzwFcds7UcT3-3k4UTX4tlhPVkCXGYa2JWJsOgw16N4QI3LRPGoYI8vTrbBJAjPmz_U5DyWrIuhKqfKZ3Sqo_25FpdOCaeLEFnbnculQH8VjWF6XVKFJPQ5l5SIE5H0dFRhkEKP01G2WUt7oYAhm4eknxsVnrLK15r_YozEETMF78EzimLOYmN8XcffkoTboM3NIiFd_5tJoflq6--mQq0SRMHldcaH1czBYmHzZ2pBAZe18j3PHhyTmSpf42H1EauO_92vu6YdZzzAl6sM4JccUhFzxHY5OngnesiU5-jaEVdtToFbFbwy6vJaEM6rSPB8gI__9EYN6lnbYoRnJs6xcz_9LlIxXFfYskm7nBR9uef1Ban4WWuO6tI6V8WBle0iVZQ2k9Qcyl8ON1baRDmbjBXL910U89q4Lu6OfQAI7Smnld-wEHZjANYxEzUZxvZw1BKR-zkGs-KvlnF-skDiyKCu6OqhSRGCqdInyHdqFM_nQtQ513tUwUWei8q6S1HM1XNhH9OR8BN5zYer1Yo0--0PVQQCZCZX5ulWnEnfAnQ-zMqICqvGpGiK3rg2c-Tn4gtOPrcjzGPe-r549bLad8gzEDWV_8eKZ_hcWsyK9DWRzJ9VGyqBWZC5_qyQwiEWJNp3OZalIRFr8eq2Dr9wM6aHXMOWak7UEw2pGYPMBAtkgP71BSg6QGATnduNxiDaarGJnIg==", + "summary": [ + { + "type": "summary_text", + "text": "**Simplifying equation reasoning**\n\nI recognize the need for concise equation reasoning. It feels important to express ideas clearly and efficiently, especially in mathematical contexts. I might focus on key principles and strip away unnecessary complexity. I'll aim to develop straightforward strategies that break down concepts into manageable parts. This way, anyone can grasp the essence of the equations without getting lost in the details. Let's work together to clarify and simplify these equations!" + } + ] + }, + { + "id": "msg_074e98c169121fe1006ae54beaa84487d0a0938e0021b408b7", + "type": "message", + "status": "completed", + "content": [ + { + "type": "output_text", + "annotations": [], + "logprobs": [], + "text": "Let the ball cost \\(x\\) dollars. The bat costs \\(x + 1.00\\) dollars.\n\nTogether:\n\\[\nx + (x + 1.00) = 1.10\n\\]\n\\[\n2x = 0.10 \\quad\\Rightarrow\\quad x = 0.05\n\\]\n\n**The ball costs $0.05 (5 cents).**" + } + ], + "phase": "final_answer", + "role": "assistant" + } + ], + "parallel_tool_calls": true, + "presence_penalty": 0.0, + "previous_response_id": null, + "prompt_cache_key": null, + "prompt_cache_retention": "24h", + "reasoning": { + "context": "all_turns", + "effort": "medium", + "mode": "standard", + "summary": "detailed" + }, + "safety_identifier": null, + "service_tier": "default", + "store": true, + "temperature": 1.0, + "text": { + "format": { + "type": "text" + }, + "verbosity": "medium" + }, + "tool_choice": "auto", + "tool_usage": { + "image_gen": { + "input_tokens": 0, + "input_tokens_details": { + "image_tokens": 0, + "text_tokens": 0 + }, + "output_tokens": 0, + "output_tokens_details": { + "image_tokens": 0, + "text_tokens": 0 + }, + "total_tokens": 0 + }, + "web_search": { + "num_requests": 0 + } + }, + "tools": [], + "top_logprobs": 0, + "top_p": 0.98, + "truncation": "disabled", + "usage": { + "input_tokens": 45, + "input_tokens_details": { + "cache_write_tokens": 0, + "cached_tokens": 0 + }, + "output_tokens": 100, + "output_tokens_details": { + "reasoning_tokens": 10 + }, + "total_tokens": 145 + }, + "user": null, + "metadata": {} +} \ No newline at end of file diff --git a/packages/inference-discovery-openai/sessions/openai-responses/gpt-6-astra/reasoning-content/session.json b/packages/inference-discovery-openai/sessions/openai-responses/gpt-6-astra/reasoning-content/session.json new file mode 100644 index 000000000..7b3c5d863 --- /dev/null +++ b/packages/inference-discovery-openai/sessions/openai-responses/gpt-6-astra/reasoning-content/session.json @@ -0,0 +1,11 @@ +{ + "schemaVersion": "2", + "source": { + "provider": "openai-responses", + "model": "gpt-6-astra", + "baseURL": "https://api.openai.com/v1" + }, + "origin": "live", + "capturedAt": "2026-10-31T02:01:15.236Z", + "capability": "reasoning-content" +} diff --git a/packages/inference-discovery-openai/sessions/openai-responses/gpt-6-luna/function-calling-multi-turn/dispatches/0-get_weather.json b/packages/inference-discovery-openai/sessions/openai-responses/gpt-6-luna/function-calling-multi-turn/dispatches/0-get_weather.json new file mode 100644 index 000000000..21f38181b --- /dev/null +++ b/packages/inference-discovery-openai/sessions/openai-responses/gpt-6-luna/function-calling-multi-turn/dispatches/0-get_weather.json @@ -0,0 +1,6 @@ +{ + "args": { + "location": "Boston, MA" + }, + "result": "{\"location\":\"Boston, MA\",\"temperatureF\":68,\"conditions\":\"clear\"}" +} diff --git a/packages/inference-discovery-openai/sessions/openai-responses/gpt-6-luna/function-calling-multi-turn/exchanges/0/request-headers.json b/packages/inference-discovery-openai/sessions/openai-responses/gpt-6-luna/function-calling-multi-turn/exchanges/0/request-headers.json new file mode 100644 index 000000000..28c14bb85 --- /dev/null +++ b/packages/inference-discovery-openai/sessions/openai-responses/gpt-6-luna/function-calling-multi-turn/exchanges/0/request-headers.json @@ -0,0 +1,4 @@ +{ + "Content-Type": "application/json", + "Authorization": "" +} diff --git a/packages/inference-discovery-openai/sessions/openai-responses/gpt-6-luna/function-calling-multi-turn/exchanges/0/request.json b/packages/inference-discovery-openai/sessions/openai-responses/gpt-6-luna/function-calling-multi-turn/exchanges/0/request.json new file mode 100644 index 000000000..57ce2c272 --- /dev/null +++ b/packages/inference-discovery-openai/sessions/openai-responses/gpt-6-luna/function-calling-multi-turn/exchanges/0/request.json @@ -0,0 +1,30 @@ +{ + "model": "gpt-6-luna", + "input": [ + { + "type": "message", + "role": "user", + "content": "What is the weather in Boston, MA? Use the provided tool." + } + ], + "tools": [ + { + "type": "function", + "name": "get_weather", + "description": "Look up the current weather for a city.", + "parameters": { + "type": "object", + "properties": { + "location": { + "type": "string", + "description": "City and optional region, e.g. 'Boston, MA'." + } + }, + "required": [ + "location" + ] + } + } + ], + "tool_choice": "auto" +} diff --git a/packages/inference-discovery-openai/sessions/openai-responses/gpt-6-luna/function-calling-multi-turn/exchanges/0/response-headers.json b/packages/inference-discovery-openai/sessions/openai-responses/gpt-6-luna/function-calling-multi-turn/exchanges/0/response-headers.json new file mode 100644 index 000000000..cd7c96ee5 --- /dev/null +++ b/packages/inference-discovery-openai/sessions/openai-responses/gpt-6-luna/function-calling-multi-turn/exchanges/0/response-headers.json @@ -0,0 +1,26 @@ +{ + "access-control-expose-headers": "X-Request-ID, Server-Timing-Total, CF-Ray, CF-Ray", + "alt-svc": "h3=\":443\"; ma=86400", + "cf-cache-status": "DYNAMIC", + "cf-ray": "a52f126a2aa96a29-LAX", + "connection": "keep-alive", + "content-encoding": "br", + "content-type": "application/json", + "date": "Sat, 31 Oct 2026 02:01:28 GMT", + "openai-organization": "", + "openai-processing-ms": "925", + "openai-project": "", + "openai-version": "2020-10-01", + "server": "cloudflare", + "strict-transport-security": "max-age=31536000; includeSubDomains; preload", + "transfer-encoding": "chunked", + "x-content-type-options": "nosniff", + "x-ratelimit-limit-requests": "5000", + "x-ratelimit-limit-tokens": "2000000", + "x-ratelimit-remaining-requests": "4999", + "x-ratelimit-remaining-tokens": "2000000", + "x-ratelimit-reset-requests": "12ms", + "x-ratelimit-reset-tokens": "0s", + "x-request-id": "", + "set-cookie": "" +} diff --git a/packages/inference-discovery-openai/sessions/openai-responses/gpt-6-luna/function-calling-multi-turn/exchanges/0/response.json b/packages/inference-discovery-openai/sessions/openai-responses/gpt-6-luna/function-calling-multi-turn/exchanges/0/response.json new file mode 100644 index 000000000..c952c58d6 --- /dev/null +++ b/packages/inference-discovery-openai/sessions/openai-responses/gpt-6-luna/function-calling-multi-turn/exchanges/0/response.json @@ -0,0 +1,109 @@ +{ + "id": "resp_080ddc392d117c78006ae54bf7708c87d0a4755654d05f7a08", + "object": "response", + "created_at": 1793412087, + "status": "completed", + "access_programs": null, + "background": false, + "billing": { + "payer": "developer" + }, + "completed_at": 1793412088, + "error": null, + "frequency_penalty": 0.0, + "incomplete_details": null, + "instructions": null, + "max_output_tokens": null, + "max_tool_calls": null, + "model": "gpt-6-luna", + "moderation": null, + "output": [ + { + "id": "fc_080ddc392d117c78006ae54bf80c1c87d0a3a4c5fe76f893cc", + "type": "function_call", + "status": "completed", + "arguments": "{\"location\":\"Boston, MA\"}", + "call_id": "call_Ti4ZOG45EjvzgXj1Ak2MHqnj", + "name": "get_weather" + } + ], + "parallel_tool_calls": true, + "presence_penalty": 0.0, + "previous_response_id": null, + "prompt_cache_key": null, + "prompt_cache_retention": "24h", + "reasoning": { + "context": "all_turns", + "effort": "medium", + "mode": "standard", + "summary": null + }, + "safety_identifier": null, + "service_tier": "default", + "store": true, + "temperature": 1.0, + "text": { + "format": { + "type": "text" + }, + "verbosity": "medium" + }, + "tool_choice": "auto", + "tool_usage": { + "image_gen": { + "input_tokens": 0, + "input_tokens_details": { + "image_tokens": 0, + "text_tokens": 0 + }, + "output_tokens": 0, + "output_tokens_details": { + "image_tokens": 0, + "text_tokens": 0 + }, + "total_tokens": 0 + }, + "web_search": { + "num_requests": 0 + } + }, + "tools": [ + { + "type": "function", + "description": "Look up the current weather for a city.", + "name": "get_weather", + "output_schema": null, + "parameters": { + "type": "object", + "properties": { + "location": { + "type": "string", + "description": "City and optional region, e.g. 'Boston, MA'." + } + }, + "required": [ + "location" + ], + "additionalProperties": false + }, + "strict": true + } + ], + "top_logprobs": 0, + "top_p": 0.98, + "truncation": "disabled", + "usage": { + "input_tokens": 73, + "input_tokens_details": { + "cache_write_tokens": 0, + "cached_tokens": 0 + }, + "output_tokens": 20, + "output_tokens_details": { + "reasoning_tokens": 0 + }, + "total_tokens": 93 + }, + "user": null, + "metadata": {} +} \ No newline at end of file diff --git a/packages/inference-discovery-openai/sessions/openai-responses/gpt-6-luna/function-calling-multi-turn/exchanges/1/request-headers.json b/packages/inference-discovery-openai/sessions/openai-responses/gpt-6-luna/function-calling-multi-turn/exchanges/1/request-headers.json new file mode 100644 index 000000000..28c14bb85 --- /dev/null +++ b/packages/inference-discovery-openai/sessions/openai-responses/gpt-6-luna/function-calling-multi-turn/exchanges/1/request-headers.json @@ -0,0 +1,4 @@ +{ + "Content-Type": "application/json", + "Authorization": "" +} diff --git a/packages/inference-discovery-openai/sessions/openai-responses/gpt-6-luna/function-calling-multi-turn/exchanges/1/request.json b/packages/inference-discovery-openai/sessions/openai-responses/gpt-6-luna/function-calling-multi-turn/exchanges/1/request.json new file mode 100644 index 000000000..933bdac58 --- /dev/null +++ b/packages/inference-discovery-openai/sessions/openai-responses/gpt-6-luna/function-calling-multi-turn/exchanges/1/request.json @@ -0,0 +1,45 @@ +{ + "model": "gpt-6-luna", + "input": [ + { + "type": "message", + "role": "user", + "content": "What is the weather in Boston, MA? Use the provided tool." + }, + { + "type": "function_call", + "call_id": "call_Ti4ZOG45EjvzgXj1Ak2MHqnj", + "name": "get_weather", + "arguments": "{\"location\":\"Boston, MA\"}" + }, + { + "type": "function_call_output", + "call_id": "call_Ti4ZOG45EjvzgXj1Ak2MHqnj", + "output": "{\"location\":\"Boston, MA\",\"temperatureF\":68,\"conditions\":\"clear\"}" + } + ], + "store": false, + "include": [ + "reasoning.encrypted_content" + ], + "tools": [ + { + "type": "function", + "name": "get_weather", + "description": "Look up the current weather for a city.", + "parameters": { + "type": "object", + "properties": { + "location": { + "type": "string", + "description": "City and optional region, e.g. 'Boston, MA'." + } + }, + "required": [ + "location" + ] + } + } + ], + "tool_choice": "auto" +} diff --git a/packages/inference-discovery-openai/sessions/openai-responses/gpt-6-luna/function-calling-multi-turn/exchanges/1/response-headers.json b/packages/inference-discovery-openai/sessions/openai-responses/gpt-6-luna/function-calling-multi-turn/exchanges/1/response-headers.json new file mode 100644 index 000000000..67a835fe5 --- /dev/null +++ b/packages/inference-discovery-openai/sessions/openai-responses/gpt-6-luna/function-calling-multi-turn/exchanges/1/response-headers.json @@ -0,0 +1,26 @@ +{ + "access-control-expose-headers": "X-Request-ID, Server-Timing-Total, CF-Ray, CF-Ray", + "alt-svc": "h3=\":443\"; ma=86400", + "cf-cache-status": "DYNAMIC", + "cf-ray": "a52f12705c046a29-LAX", + "connection": "keep-alive", + "content-encoding": "br", + "content-type": "application/json", + "date": "Sat, 31 Oct 2026 02:01:29 GMT", + "openai-organization": "", + "openai-processing-ms": "1153", + "openai-project": "", + "openai-version": "2020-10-01", + "server": "cloudflare", + "strict-transport-security": "max-age=31536000; includeSubDomains; preload", + "transfer-encoding": "chunked", + "x-content-type-options": "nosniff", + "x-ratelimit-limit-requests": "5000", + "x-ratelimit-limit-tokens": "2000000", + "x-ratelimit-remaining-requests": "4999", + "x-ratelimit-remaining-tokens": "2000000", + "x-ratelimit-reset-requests": "12ms", + "x-ratelimit-reset-tokens": "0s", + "x-request-id": "", + "set-cookie": "" +} diff --git a/packages/inference-discovery-openai/sessions/openai-responses/gpt-6-luna/function-calling-multi-turn/exchanges/1/response.json b/packages/inference-discovery-openai/sessions/openai-responses/gpt-6-luna/function-calling-multi-turn/exchanges/1/response.json new file mode 100644 index 000000000..a8aa9bbc3 --- /dev/null +++ b/packages/inference-discovery-openai/sessions/openai-responses/gpt-6-luna/function-calling-multi-turn/exchanges/1/response.json @@ -0,0 +1,116 @@ +{ + "id": "resp_07f53bc6d6700042016ae54bf86bd887d0a32b7ac76177fe89", + "object": "response", + "created_at": 1793412088, + "status": "completed", + "access_programs": null, + "background": false, + "billing": { + "payer": "developer" + }, + "completed_at": 1793412089, + "error": null, + "frequency_penalty": 0.0, + "incomplete_details": null, + "instructions": null, + "max_output_tokens": null, + "max_tool_calls": null, + "model": "gpt-6-luna", + "moderation": null, + "output": [ + { + "id": "msg_07f53bc6d6700042016ae54bf9335c87d094ef13c306ff56ac", + "type": "message", + "status": "completed", + "content": [ + { + "type": "output_text", + "annotations": [], + "logprobs": [], + "text": "Boston, MA is currently 68\u00b0F and clear." + } + ], + "phase": "final_answer", + "role": "assistant" + } + ], + "parallel_tool_calls": true, + "presence_penalty": 0.0, + "previous_response_id": null, + "prompt_cache_key": null, + "prompt_cache_retention": "24h", + "reasoning": { + "context": "all_turns", + "effort": "medium", + "mode": "standard", + "summary": null + }, + "safety_identifier": null, + "service_tier": "default", + "store": false, + "temperature": 1.0, + "text": { + "format": { + "type": "text" + }, + "verbosity": "medium" + }, + "tool_choice": "auto", + "tool_usage": { + "image_gen": { + "input_tokens": 0, + "input_tokens_details": { + "image_tokens": 0, + "text_tokens": 0 + }, + "output_tokens": 0, + "output_tokens_details": { + "image_tokens": 0, + "text_tokens": 0 + }, + "total_tokens": 0 + }, + "web_search": { + "num_requests": 0 + } + }, + "tools": [ + { + "type": "function", + "description": "Look up the current weather for a city.", + "name": "get_weather", + "output_schema": null, + "parameters": { + "type": "object", + "properties": { + "location": { + "type": "string", + "description": "City and optional region, e.g. 'Boston, MA'." + } + }, + "required": [ + "location" + ], + "additionalProperties": false + }, + "strict": true + } + ], + "top_logprobs": 0, + "top_p": 0.98, + "truncation": "disabled", + "usage": { + "input_tokens": 120, + "input_tokens_details": { + "cache_write_tokens": 0, + "cached_tokens": 0 + }, + "output_tokens": 15, + "output_tokens_details": { + "reasoning_tokens": 0 + }, + "total_tokens": 135 + }, + "user": null, + "metadata": {} +} \ No newline at end of file diff --git a/packages/inference-discovery-openai/sessions/openai-responses/gpt-6-luna/function-calling-multi-turn/session.json b/packages/inference-discovery-openai/sessions/openai-responses/gpt-6-luna/function-calling-multi-turn/session.json new file mode 100644 index 000000000..e28736341 --- /dev/null +++ b/packages/inference-discovery-openai/sessions/openai-responses/gpt-6-luna/function-calling-multi-turn/session.json @@ -0,0 +1,11 @@ +{ + "schemaVersion": "2", + "source": { + "provider": "openai-responses", + "model": "gpt-6-luna", + "baseURL": "https://api.openai.com/v1" + }, + "origin": "live", + "capturedAt": "2026-10-31T02:01:29.585Z", + "capability": "function-calling-multi-turn" +} diff --git a/packages/inference-discovery-openai/sessions/openai-responses/gpt-6-luna/plain-text-streaming/exchanges/0/request-headers.json b/packages/inference-discovery-openai/sessions/openai-responses/gpt-6-luna/plain-text-streaming/exchanges/0/request-headers.json new file mode 100644 index 000000000..28c14bb85 --- /dev/null +++ b/packages/inference-discovery-openai/sessions/openai-responses/gpt-6-luna/plain-text-streaming/exchanges/0/request-headers.json @@ -0,0 +1,4 @@ +{ + "Content-Type": "application/json", + "Authorization": "" +} diff --git a/packages/inference-discovery-openai/sessions/openai-responses/gpt-6-luna/plain-text-streaming/exchanges/0/request.json b/packages/inference-discovery-openai/sessions/openai-responses/gpt-6-luna/plain-text-streaming/exchanges/0/request.json new file mode 100644 index 000000000..5f66a340b --- /dev/null +++ b/packages/inference-discovery-openai/sessions/openai-responses/gpt-6-luna/plain-text-streaming/exchanges/0/request.json @@ -0,0 +1,11 @@ +{ + "model": "gpt-6-luna", + "input": [ + { + "type": "message", + "role": "user", + "content": "Reply with a single sentence: the capital of France is Paris." + } + ], + "stream": true +} diff --git a/packages/inference-discovery-openai/sessions/openai-responses/gpt-6-luna/plain-text-streaming/exchanges/0/response-headers.json b/packages/inference-discovery-openai/sessions/openai-responses/gpt-6-luna/plain-text-streaming/exchanges/0/response-headers.json new file mode 100644 index 000000000..fc33e1692 --- /dev/null +++ b/packages/inference-discovery-openai/sessions/openai-responses/gpt-6-luna/plain-text-streaming/exchanges/0/response-headers.json @@ -0,0 +1,25 @@ +{ + "access-control-expose-headers": "X-Request-ID, Server-Timing-Total, CF-Ray, CF-Ray", + "alt-svc": "h3=\":443\"; ma=86400", + "cf-cache-status": "DYNAMIC", + "cf-ray": "a5281db76c492f47-LAX", + "connection": "keep-alive", + "content-type": "text/event-stream; charset=utf-8", + "date": "Fri, 30 Oct 2026 05:45:50 GMT", + "openai-organization": "", + "openai-processing-ms": "282", + "openai-project": "", + "openai-version": "2020-10-01", + "server": "cloudflare", + "strict-transport-security": "max-age=31536000; includeSubDomains; preload", + "transfer-encoding": "chunked", + "x-content-type-options": "nosniff", + "x-ratelimit-limit-requests": "5000", + "x-ratelimit-limit-tokens": "2000000", + "x-ratelimit-remaining-requests": "4999", + "x-ratelimit-remaining-tokens": "1999837", + "x-ratelimit-reset-requests": "12ms", + "x-ratelimit-reset-tokens": "4ms", + "x-request-id": "", + "set-cookie": "" +} diff --git a/packages/inference-discovery-openai/sessions/openai-responses/gpt-6-luna/plain-text-streaming/exchanges/0/response.sse b/packages/inference-discovery-openai/sessions/openai-responses/gpt-6-luna/plain-text-streaming/exchanges/0/response.sse new file mode 100644 index 000000000..3c2ae3298 --- /dev/null +++ b/packages/inference-discovery-openai/sessions/openai-responses/gpt-6-luna/plain-text-streaming/exchanges/0/response.sse @@ -0,0 +1,45 @@ +event: response.created +data: {"type":"response.created","response":{"id":"resp_02ca5dc37afae822006ae42f0e298887d089541505923750f2","object":"response","created_at":1793339150,"status":"in_progress","access_programs":null,"background":false,"completed_at":null,"error":null,"frequency_penalty":0.0,"incomplete_details":null,"instructions":null,"max_output_tokens":null,"max_tool_calls":null,"model":"gpt-6-luna","moderation":null,"output":[],"parallel_tool_calls":true,"presence_penalty":0.0,"previous_response_id":null,"prompt_cache_key":null,"prompt_cache_retention":"24h","reasoning":{"context":"all_turns","effort":"medium","mode":"standard","summary":null},"safety_identifier":null,"service_tier":"auto","store":true,"temperature":1.0,"text":{"format":{"type":"text"},"verbosity":"medium"},"tool_choice":"auto","tool_usage":{"image_gen":{"input_tokens":0,"input_tokens_details":{"image_tokens":0,"text_tokens":0},"output_tokens":0,"output_tokens_details":{"image_tokens":0,"text_tokens":0},"total_tokens":0},"web_search":{"num_requests":0}},"tools":[],"top_logprobs":0,"top_p":0.98,"truncation":"disabled","usage":null,"user":null,"metadata":{}},"sequence_number":0} + +event: response.in_progress +data: {"type":"response.in_progress","response":{"id":"resp_02ca5dc37afae822006ae42f0e298887d089541505923750f2","object":"response","created_at":1793339150,"status":"in_progress","access_programs":null,"background":false,"completed_at":null,"error":null,"frequency_penalty":0.0,"incomplete_details":null,"instructions":null,"max_output_tokens":null,"max_tool_calls":null,"model":"gpt-6-luna","moderation":null,"output":[],"parallel_tool_calls":true,"presence_penalty":0.0,"previous_response_id":null,"prompt_cache_key":null,"prompt_cache_retention":"24h","reasoning":{"context":"all_turns","effort":"medium","mode":"standard","summary":null},"safety_identifier":null,"service_tier":"auto","store":true,"temperature":1.0,"text":{"format":{"type":"text"},"verbosity":"medium"},"tool_choice":"auto","tool_usage":{"image_gen":{"input_tokens":0,"input_tokens_details":{"image_tokens":0,"text_tokens":0},"output_tokens":0,"output_tokens_details":{"image_tokens":0,"text_tokens":0},"total_tokens":0},"web_search":{"num_requests":0}},"tools":[],"top_logprobs":0,"top_p":0.98,"truncation":"disabled","usage":null,"user":null,"metadata":{}},"sequence_number":1} + +event: response.output_item.added +data: {"type":"response.output_item.added","item":{"id":"msg_02ca5dc37afae822006ae42f0ebd5c87d0a58331bc1c81d1c9","type":"message","status":"in_progress","content":[],"phase":"final_answer","role":"assistant"},"output_index":0,"sequence_number":2} + +event: response.content_part.added +data: {"type":"response.content_part.added","content_index":0,"item_id":"msg_02ca5dc37afae822006ae42f0ebd5c87d0a58331bc1c81d1c9","output_index":0,"part":{"type":"output_text","annotations":[],"logprobs":[],"text":""},"sequence_number":3} + +event: response.output_text.delta +data: {"type":"response.output_text.delta","content_index":0,"delta":"The","item_id":"msg_02ca5dc37afae822006ae42f0ebd5c87d0a58331bc1c81d1c9","logprobs":[],"obfuscation":"o0SjsxGvdZwq6","output_index":0,"sequence_number":4} + +event: response.output_text.delta +data: {"type":"response.output_text.delta","content_index":0,"delta":" capital","item_id":"msg_02ca5dc37afae822006ae42f0ebd5c87d0a58331bc1c81d1c9","logprobs":[],"obfuscation":"4S877prf","output_index":0,"sequence_number":5} + +event: response.output_text.delta +data: {"type":"response.output_text.delta","content_index":0,"delta":" of","item_id":"msg_02ca5dc37afae822006ae42f0ebd5c87d0a58331bc1c81d1c9","logprobs":[],"obfuscation":"g6f0gi5MetpRs","output_index":0,"sequence_number":6} + +event: response.output_text.delta +data: {"type":"response.output_text.delta","content_index":0,"delta":" France","item_id":"msg_02ca5dc37afae822006ae42f0ebd5c87d0a58331bc1c81d1c9","logprobs":[],"obfuscation":"lQ4saWKtt","output_index":0,"sequence_number":7} + +event: response.output_text.delta +data: {"type":"response.output_text.delta","content_index":0,"delta":" is","item_id":"msg_02ca5dc37afae822006ae42f0ebd5c87d0a58331bc1c81d1c9","logprobs":[],"obfuscation":"kUfTg5e3LKBuy","output_index":0,"sequence_number":8} + +event: response.output_text.delta +data: {"type":"response.output_text.delta","content_index":0,"delta":" Paris","item_id":"msg_02ca5dc37afae822006ae42f0ebd5c87d0a58331bc1c81d1c9","logprobs":[],"obfuscation":"QeUwjfiLKp","output_index":0,"sequence_number":9} + +event: response.output_text.delta +data: {"type":"response.output_text.delta","content_index":0,"delta":".","item_id":"msg_02ca5dc37afae822006ae42f0ebd5c87d0a58331bc1c81d1c9","logprobs":[],"obfuscation":"xomWuhhNxJSV1J8","output_index":0,"sequence_number":10} + +event: response.output_text.done +data: {"type":"response.output_text.done","content_index":0,"item_id":"msg_02ca5dc37afae822006ae42f0ebd5c87d0a58331bc1c81d1c9","logprobs":[],"output_index":0,"sequence_number":11,"text":"The capital of France is Paris."} + +event: response.content_part.done +data: {"type":"response.content_part.done","content_index":0,"item_id":"msg_02ca5dc37afae822006ae42f0ebd5c87d0a58331bc1c81d1c9","output_index":0,"part":{"type":"output_text","annotations":[],"logprobs":[],"text":"The capital of France is Paris."},"sequence_number":12} + +event: response.output_item.done +data: {"type":"response.output_item.done","item":{"id":"msg_02ca5dc37afae822006ae42f0ebd5c87d0a58331bc1c81d1c9","type":"message","status":"completed","content":[{"type":"output_text","annotations":[],"logprobs":[],"text":"The capital of France is Paris."}],"phase":"final_answer","role":"assistant"},"output_index":0,"sequence_number":13} + +event: response.completed +data: {"type":"response.completed","response":{"id":"resp_02ca5dc37afae822006ae42f0e298887d089541505923750f2","object":"response","created_at":1793339150,"status":"completed","access_programs":null,"background":false,"completed_at":1793339150,"error":null,"frequency_penalty":0.0,"incomplete_details":null,"instructions":null,"max_output_tokens":null,"max_tool_calls":null,"model":"gpt-6-luna","moderation":null,"output":[{"id":"msg_02ca5dc37afae822006ae42f0ebd5c87d0a58331bc1c81d1c9","type":"message","status":"completed","content":[{"type":"output_text","annotations":[],"logprobs":[],"text":"The capital of France is Paris."}],"phase":"final_answer","role":"assistant"}],"parallel_tool_calls":true,"presence_penalty":0.0,"previous_response_id":null,"prompt_cache_key":null,"prompt_cache_retention":"24h","reasoning":{"context":"all_turns","effort":"medium","mode":"standard","summary":null},"safety_identifier":null,"service_tier":"default","store":true,"temperature":1.0,"text":{"format":{"type":"text"},"verbosity":"medium"},"tool_choice":"auto","tool_usage":{"image_gen":{"input_tokens":0,"input_tokens_details":{"image_tokens":0,"text_tokens":0},"output_tokens":0,"output_tokens_details":{"image_tokens":0,"text_tokens":0},"total_tokens":0},"web_search":{"num_requests":0}},"tools":[],"top_logprobs":0,"top_p":0.98,"truncation":"disabled","usage":{"input_tokens":19,"input_tokens_details":{"cache_write_tokens":0,"cached_tokens":0},"output_tokens":11,"output_tokens_details":{"reasoning_tokens":0},"total_tokens":30},"user":null,"metadata":{}},"sequence_number":14} + diff --git a/packages/inference-discovery-openai/sessions/openai-responses/gpt-6-luna/plain-text-streaming/session.json b/packages/inference-discovery-openai/sessions/openai-responses/gpt-6-luna/plain-text-streaming/session.json new file mode 100644 index 000000000..cef047856 --- /dev/null +++ b/packages/inference-discovery-openai/sessions/openai-responses/gpt-6-luna/plain-text-streaming/session.json @@ -0,0 +1,11 @@ +{ + "schemaVersion": "2", + "source": { + "provider": "openai-responses", + "model": "gpt-6-luna", + "baseURL": "https://api.openai.com/v1" + }, + "origin": "live", + "capturedAt": "2026-10-30T05:45:51.075Z", + "capability": "plain-text-streaming" +} diff --git a/packages/inference-discovery-openai/sessions/openai-responses/gpt-6-luna/plain-text/exchanges/0/request-headers.json b/packages/inference-discovery-openai/sessions/openai-responses/gpt-6-luna/plain-text/exchanges/0/request-headers.json new file mode 100644 index 000000000..28c14bb85 --- /dev/null +++ b/packages/inference-discovery-openai/sessions/openai-responses/gpt-6-luna/plain-text/exchanges/0/request-headers.json @@ -0,0 +1,4 @@ +{ + "Content-Type": "application/json", + "Authorization": "" +} diff --git a/packages/inference-discovery-openai/sessions/openai-responses/gpt-6-luna/plain-text/exchanges/0/request.json b/packages/inference-discovery-openai/sessions/openai-responses/gpt-6-luna/plain-text/exchanges/0/request.json new file mode 100644 index 000000000..635ccdcc5 --- /dev/null +++ b/packages/inference-discovery-openai/sessions/openai-responses/gpt-6-luna/plain-text/exchanges/0/request.json @@ -0,0 +1,10 @@ +{ + "model": "gpt-6-luna", + "input": [ + { + "type": "message", + "role": "user", + "content": "Reply with a single sentence: the capital of France is Paris." + } + ] +} diff --git a/packages/inference-discovery-openai/sessions/openai-responses/gpt-6-luna/plain-text/exchanges/0/response-headers.json b/packages/inference-discovery-openai/sessions/openai-responses/gpt-6-luna/plain-text/exchanges/0/response-headers.json new file mode 100644 index 000000000..3f0cab66c --- /dev/null +++ b/packages/inference-discovery-openai/sessions/openai-responses/gpt-6-luna/plain-text/exchanges/0/response-headers.json @@ -0,0 +1,26 @@ +{ + "access-control-expose-headers": "X-Request-ID, Server-Timing-Total, CF-Ray, CF-Ray", + "alt-svc": "h3=\":443\"; ma=86400", + "cf-cache-status": "DYNAMIC", + "cf-ray": "a5281643d9e62d61-LAX", + "connection": "keep-alive", + "content-encoding": "br", + "content-type": "application/json", + "date": "Fri, 30 Oct 2026 05:40:46 GMT", + "openai-organization": "", + "openai-processing-ms": "1151", + "openai-project": "", + "openai-version": "2020-10-01", + "server": "cloudflare", + "strict-transport-security": "max-age=31536000; includeSubDomains; preload", + "transfer-encoding": "chunked", + "x-content-type-options": "nosniff", + "x-ratelimit-limit-requests": "5000", + "x-ratelimit-limit-tokens": "2000000", + "x-ratelimit-remaining-requests": "4999", + "x-ratelimit-remaining-tokens": "2000000", + "x-ratelimit-reset-requests": "12ms", + "x-ratelimit-reset-tokens": "0s", + "x-request-id": "", + "set-cookie": "" +} diff --git a/packages/inference-discovery-openai/sessions/openai-responses/gpt-6-luna/plain-text/exchanges/0/response.json b/packages/inference-discovery-openai/sessions/openai-responses/gpt-6-luna/plain-text/exchanges/0/response.json new file mode 100644 index 000000000..92abc071b --- /dev/null +++ b/packages/inference-discovery-openai/sessions/openai-responses/gpt-6-luna/plain-text/exchanges/0/response.json @@ -0,0 +1,102 @@ +{ + "id": "resp_0ba5f6c9f6a0bdf5006ae42ddcef2c87d0ae6e79349d6d2fd5", + "object": "response", + "created_at": 1793338844, + "status": "completed", + "access_programs": null, + "background": false, + "billing": { + "payer": "developer" + }, + "completed_at": 1793338845, + "error": null, + "frequency_penalty": 0.0, + "incomplete_details": null, + "instructions": null, + "max_output_tokens": null, + "max_tool_calls": null, + "model": "gpt-6-luna", + "moderation": null, + "output": [ + { + "id": "rs_0ba5f6c9f6a0bdf5006ae42ddd87f487d0a4452802d80bccae", + "type": "reasoning", + "content": [], + "encrypted_content": "gAAAAABq5C3epAXEZyv9ISpwsywkVjzUSQN2JyGVYgOtKAknoGoNnhuti0EIxg0lRvYqlFUnRxLOu7bidvj5Df7y0ClDt9yQ836YhjKf94VLSIkTdEjjIiGf_pL5tVXX0qzMapZBqd2qyq0_EpL79rHuPq2RTlUUTkBqnBSIpcm6AywF8GF9ZzncMpP8iGsCe2oDoe4O61BcD3kaCt1h3Irl1_JluB30opu5Ry7idTeTglCJQTshGNbqAYwUGrJQFf65S_JKX93_06aJp1hcgEbAuMUdbHGisD4dv9-BVwTABgtapiJS-YIuPKcAaysPN4Jb_QZS_pPpmWy1Qngxg5o3oN28Wxfx9DdzN1xBpNmfkriCM3MCnAZY1oZWsfHK98XIpX1s06x1-2facGU26UxeyI34ZyTkYQ-mJwfn2v3dTXCmAjTewGD2DVN4I_6huNpWi3QLs9We6FQ7kjIGIQ5_axAy3TDifooU-jheM5f73z1EWHHqepxY9Byv1BVgnu5cJTb2Uk38d25J22B7mlu3dIRPBXEhECyZUHJppQs9Aotf_aOeQKK0nQEijL-jXOF4XygSguYO577VoXuM0LjOH515WLgW5w0N281fFUcGx0GnksDi8Ctz43fW2ub9e1Vhl9sZP5xyndwJHHUmjud0aqMIPO84qjs6gL1qIFHcil8S6HTUS1MzfrwjkuJyAOgVpQA6ROYzxbH4reNshl8OgsTMZvaKzjiUPMljIkOdYuSHMM9B3N15ztxfhItPgy75-eoO5y1EzMlh1I96y4HKJ2xFHvmTLTldet6c59v-CYCEWr-Pt-kcSaxaJYbShwanT-BQzVilyURjTZDmOruNSiop-4vflWXkM7EFeNHfBJmZrR8Kz39vW1-gJdnpH_qNDM6rMNXWBY5qsyD5hIk-Vu4LG0nX7Y8DBhAheJ3_zdVdlzkpuFM9rRHxNhKSyrOXuLXChRJt8BAqDfg5_xe1z3X-suiGrae5dauNZiXx82ri0TYNuD01rW1PJsM4ifxVuXFj-TjumL0XByrz2eCIbCvhXT8yM2uWJebc2jI5PhXR-3yQweuuypIIt53LR5gnLNqHqwGgofnNdE6kclJCLsFYJec1PAJjd8nC4ZHohFPBNF30UnCoBdIm9b7oYe9fO-NRL8GFTVXb2_I263FAE6s8A9iurUlwmN3RsUTzcZFK57cxqucNzJBYjO6JuMib9WMYfwXTZHQJnR9KjD4VEQU0e4AunVxMKYSPzxKNWbQWBy3VEL5yN4yekqpac69TJmH-23y9TU5OnyXASFW_1CEqRx8WPPHRvKx2GEwtdrAMOUesf0xBc-Od0QYbV9vjKaTz2NQvOkxokgYhFeL9OBDWRU-OeTJRvhty-oxnYzqJ7dL0mFPoaVXIMP7pTEE4ZN3HbZSmSzeb9j2MjtiNvEbEAcEUKJF7OcVnfTxtk3zNDCk45vg36DqosnFiurTDEkpmI7ViJ-hCBryTr0iUXTa0Ukh6A_E29ZPtWHTWzBRLpDv9gfkS0J9TCUKcNC5QTDRjTfuZd5WQn7HiVUnp-zn24skyAL278rR03TKK-r8ZgKkaLzkfV1TFNUgBeSoRXr98xwp8-Lx-u19wS8Hc8w-CsZcoHF4GyrYcnNTfESaIN7f7WEaalvFYRCrX7BhgOdggR0jz4HhmWAl5MRuVOOOeedav_ncJlNnXOaPzaY9rN7vMUcvAbNT6-u27Lnux5gKfOreVLg7gQkiQNVsKhOxdYDeWZZIiG2PWkm6qob6zChCnx4fuwLeNl7lrr4lDHdmITrQjHh7vIhu-J2KQLPi947TG7G_6z1UmC5DIUqgvlh0SFpyuIFiG-lfp82vKozdoaDZk-o3zLrOzPf73U_HM62MgIg==", + "summary": [] + }, + { + "id": "msg_0ba5f6c9f6a0bdf5006ae42dddcf2487d094e6ffcf2e78d39c", + "type": "message", + "status": "completed", + "content": [ + { + "type": "output_text", + "annotations": [], + "logprobs": [], + "text": "The capital of France is Paris." + } + ], + "phase": "final_answer", + "role": "assistant" + } + ], + "parallel_tool_calls": true, + "presence_penalty": 0.0, + "previous_response_id": null, + "prompt_cache_key": null, + "prompt_cache_retention": "24h", + "reasoning": { + "context": "all_turns", + "effort": "medium", + "mode": "standard", + "summary": null + }, + "safety_identifier": null, + "service_tier": "default", + "store": true, + "temperature": 1.0, + "text": { + "format": { + "type": "text" + }, + "verbosity": "medium" + }, + "tool_choice": "auto", + "tool_usage": { + "image_gen": { + "input_tokens": 0, + "input_tokens_details": { + "image_tokens": 0, + "text_tokens": 0 + }, + "output_tokens": 0, + "output_tokens_details": { + "image_tokens": 0, + "text_tokens": 0 + }, + "total_tokens": 0 + }, + "web_search": { + "num_requests": 0 + } + }, + "tools": [], + "top_logprobs": 0, + "top_p": 0.98, + "truncation": "disabled", + "usage": { + "input_tokens": 19, + "input_tokens_details": { + "cache_write_tokens": 0, + "cached_tokens": 0 + }, + "output_tokens": 48, + "output_tokens_details": { + "reasoning_tokens": 35 + }, + "total_tokens": 67 + }, + "user": null, + "metadata": {} +} \ No newline at end of file diff --git a/packages/inference-discovery-openai/sessions/openai-responses/gpt-6-luna/plain-text/session.json b/packages/inference-discovery-openai/sessions/openai-responses/gpt-6-luna/plain-text/session.json new file mode 100644 index 000000000..0192c2d97 --- /dev/null +++ b/packages/inference-discovery-openai/sessions/openai-responses/gpt-6-luna/plain-text/session.json @@ -0,0 +1,11 @@ +{ + "schemaVersion": "2", + "source": { + "provider": "openai-responses", + "model": "gpt-6-luna", + "baseURL": "https://api.openai.com/v1" + }, + "origin": "live", + "capturedAt": "2026-10-30T05:40:46.100Z", + "capability": "plain-text" +} diff --git a/packages/inference-discovery-openai/sessions/openai-responses/gpt-6-luna/reasoning-content/exchanges/0/request-headers.json b/packages/inference-discovery-openai/sessions/openai-responses/gpt-6-luna/reasoning-content/exchanges/0/request-headers.json new file mode 100644 index 000000000..28c14bb85 --- /dev/null +++ b/packages/inference-discovery-openai/sessions/openai-responses/gpt-6-luna/reasoning-content/exchanges/0/request-headers.json @@ -0,0 +1,4 @@ +{ + "Content-Type": "application/json", + "Authorization": "" +} diff --git a/packages/inference-discovery-openai/sessions/openai-responses/gpt-6-luna/reasoning-content/exchanges/0/request.json b/packages/inference-discovery-openai/sessions/openai-responses/gpt-6-luna/reasoning-content/exchanges/0/request.json new file mode 100644 index 000000000..4e28a2aae --- /dev/null +++ b/packages/inference-discovery-openai/sessions/openai-responses/gpt-6-luna/reasoning-content/exchanges/0/request.json @@ -0,0 +1,14 @@ +{ + "model": "gpt-6-luna", + "input": [ + { + "type": "message", + "role": "user", + "content": "A bat and a ball cost $1.10 together. The bat costs $1.00 more than the ball. How much does the ball cost? Show your reasoning before the final answer." + } + ], + "reasoning": { + "effort": "medium", + "summary": "detailed" + } +} diff --git a/packages/inference-discovery-openai/sessions/openai-responses/gpt-6-luna/reasoning-content/exchanges/0/response-headers.json b/packages/inference-discovery-openai/sessions/openai-responses/gpt-6-luna/reasoning-content/exchanges/0/response-headers.json new file mode 100644 index 000000000..65a9e2108 --- /dev/null +++ b/packages/inference-discovery-openai/sessions/openai-responses/gpt-6-luna/reasoning-content/exchanges/0/response-headers.json @@ -0,0 +1,26 @@ +{ + "access-control-expose-headers": "X-Request-ID, Server-Timing-Total, CF-Ray, CF-Ray", + "alt-svc": "h3=\":443\"; ma=86400", + "cf-cache-status": "DYNAMIC", + "cf-ray": "a52f1277f9496a29-LAX", + "connection": "keep-alive", + "content-encoding": "br", + "content-type": "application/json", + "date": "Sat, 31 Oct 2026 02:01:31 GMT", + "openai-organization": "", + "openai-processing-ms": "2076", + "openai-project": "", + "openai-version": "2020-10-01", + "server": "cloudflare", + "strict-transport-security": "max-age=31536000; includeSubDomains; preload", + "transfer-encoding": "chunked", + "x-content-type-options": "nosniff", + "x-ratelimit-limit-requests": "5000", + "x-ratelimit-limit-tokens": "2000000", + "x-ratelimit-remaining-requests": "4999", + "x-ratelimit-remaining-tokens": "2000000", + "x-ratelimit-reset-requests": "12ms", + "x-ratelimit-reset-tokens": "0s", + "x-request-id": "", + "set-cookie": "" +} diff --git a/packages/inference-discovery-openai/sessions/openai-responses/gpt-6-luna/reasoning-content/exchanges/0/response.json b/packages/inference-discovery-openai/sessions/openai-responses/gpt-6-luna/reasoning-content/exchanges/0/response.json new file mode 100644 index 000000000..bb1992ab5 --- /dev/null +++ b/packages/inference-discovery-openai/sessions/openai-responses/gpt-6-luna/reasoning-content/exchanges/0/response.json @@ -0,0 +1,107 @@ +{ + "id": "resp_091f8a39efebfea0006ae54bf9aa4c87d0a0c430bbece5b595", + "object": "response", + "created_at": 1793412089, + "status": "completed", + "access_programs": null, + "background": false, + "billing": { + "payer": "developer" + }, + "completed_at": 1793412091, + "error": null, + "frequency_penalty": 0.0, + "incomplete_details": null, + "instructions": null, + "max_output_tokens": null, + "max_tool_calls": null, + "model": "gpt-6-luna", + "moderation": null, + "output": [ + { + "id": "rs_091f8a39efebfea0006ae54bfa135087d09fb31aaad2077d64", + "type": "reasoning", + "content": [], + "encrypted_content": "gAAAAABq5Uv76AdE-q0KSPngkytJFQ9VYHR5Gpd-lQUa6kOA0XMjuBlKV_yv7EuaqUwzdljIN9gKps9tisyz0ewL-nEDwfXcKxN8yXBcmzEjj4Gt1qk7506KczLdLXowLM5Bycb-WmmZzGfRU9jLBvqx6IfRuvYVGA1wYmA5H320pm3tPp5KtdrRg2niC7JJDw1FcqPOu1jsqRNl9Ega6Yekw-IxdsdorYhgXGg_QRcIHra1JG0ugkTaII9tmO1JSHuPbTMh9bBzdVED_v2TcyN-XVbF4yAnHLyYHxEXgtGkPiK4tx11PBsZUV1IKIO-JdvWHfPLpEm5Cmg_f04Hjn484wHeCyXL-9zg8zFub_AI6cZNUp79DqGhFUSik2O5OSCu3COekTUSto6Vu-V7mgKjGROnf_7jOO-3aIzRsr4Hl-DYpoE9qsY-4NqpnDmjvm82-1Dl6isp6deb-jkcYmuqBRBFcPnx1ivbA2t0_jNWvOinf8BlXAJ9rlc1Jdq6Ye35QeBTnrrLGTUCOu5nl8fkRivA64zT4xDY5CKh9v37CLVZppVgAVWEGsHddr4SU_y4v4VMdZ0UbyR_TshxXECqiLwbyLkTQDRomSe65HcnueaGirnP-CiIU3qvrOfLwObrc33At_v-3zj4j_Jjio5Vejq97ewjP31JhrxUfCSRNi6St39UiW-2f_uZkK6dAW_15th4gQI0FyJfSFJotku7S4yoJPYbYY89g___ScX_L7d9qv2qPlpl8X2pdqmVSaSxR_gosdo7LT2_Sn3q505nh8_bxPsdyq7LwrkE-TnNDyR1KmKX4gKVo2cFwb0oJQPEfB57gWP2A9iJvcTGWtZpHDu_htVZUXuMxB-alEZU4wjzOWtjrW0zA7jWMQpPbHjCgbVIA-7j9RfaXtWdHT-hxXDlFVt8kE5SdmeC1-QOiW2fETNr6YAT_KU_TwlCg9dSEeJCbfAqPUmFtoIBRdmSbe9h-L9t5tqGwwQ3QHjiXC8mOvlEnxpFAlDDFwcmUTIcfyebpduLePI9E_tjo65YQ7_-5QnuFriR21Uz_kRLvMVB_nA4IqhjVRLyRbLUaID_uKRr4Jghkl9_L5zc-sYh6SGdBLwZ6McippJPqGKItTZnfRgP6nGPeGJztu-59fQnYYyPJdfxrsUXo2l3t1olg25LESmGzUw3SHdPMo4Ozwlt-rMbQLFfmRE8Pn3jiJRfoe1wLWNVJF_hnOiaWaPRYddwXPvzVMpCoWOvhHSh_R2a8k0IpPANF0Pcxf-FZrAzprySJvLYSPZpscEbEpiMtXiaUi5_bHeFhlY6L7i8cKclfo8Rv2Mcwdr5LLYOhy7Mzem_z_17yl0uqyFG0gJXH1JdamzxyAkn8gvcnUVwLi1yuoRgA_vKoq2Lhio3RvKs6JbhS-uElf_e_JbiO09K9cfg9igBmdwlZ7cMeYKzuiy1dWB9M9F5TYkilbE5T4I4kAzARZ2K7Sn9aU3ZpP3pw1JwtDz0o4ouWSG57KupZ8uyXmNe_V25TydagkoSJasp1oUvcIzzNBV3Pb0B1xsLtHcjiDAXeHBrg9K2Z-X28X2kSthtqJP52pNbnoudTmdmkhm7ekNoHFN_acP84PZHfUd_tU_Ne0T7-Uf2zjcxtnvUjWRohwe5ZZiReF2YrJjpJKVuGDlr2XvZUWFMEQqF05mExFhLdHJZC62-PTHO4CzdgD1XV7cbkeg1ZLePeTH7a5FRL6agLlVBNlZ963isHgqAJCLcnUQRGLeGKSypX1jyH7cI16VcC8dwYvRdZnCqH9JPA7vGzVg_A6wwtQPB1xM7BIQTQa88Q95mTn6thsn8sOca-XGLeQ_7Bf6LcpVO3LnFirvOeL1dat1EyIUGuoXzF2dj5A==", + "summary": [ + { + "type": "summary_text", + "text": "**Explaining the trap scenario**\n\nI need to provide a clear explanation of a trap in this context. I\u2019ll assign a variable, let\u2019s say ball is represented by x, and bat by x+1. The sum comes to 2x + 1, which equals 1.10. So when I divide .10 by 2, I get .05. I have to ensure the reasoning is laid out logically before I give the final answer, making everything easy to understand for the user." + } + ] + }, + { + "id": "msg_091f8a39efebfea0006ae54bfb443c87d0a2ea2c648bb4ce43", + "type": "message", + "status": "completed", + "content": [ + { + "type": "output_text", + "annotations": [], + "logprobs": [], + "text": "Let the ball cost \\(x\\) dollars. Then the bat costs \\(x + \\$1.00\\).\n\nTogether they cost:\n\\[\nx + (x + \\$1.00) = \\$1.10\n\\]\nSo \\(2x = \\$0.10\\), which means \\(x = \\$0.05\\).\n\n**The ball costs 5 cents.**" + } + ], + "phase": "final_answer", + "role": "assistant" + } + ], + "parallel_tool_calls": true, + "presence_penalty": 0.0, + "previous_response_id": null, + "prompt_cache_key": null, + "prompt_cache_retention": "24h", + "reasoning": { + "context": "all_turns", + "effort": "medium", + "mode": "standard", + "summary": "detailed" + }, + "safety_identifier": null, + "service_tier": "default", + "store": true, + "temperature": 1.0, + "text": { + "format": { + "type": "text" + }, + "verbosity": "medium" + }, + "tool_choice": "auto", + "tool_usage": { + "image_gen": { + "input_tokens": 0, + "input_tokens_details": { + "image_tokens": 0, + "text_tokens": 0 + }, + "output_tokens": 0, + "output_tokens_details": { + "image_tokens": 0, + "text_tokens": 0 + }, + "total_tokens": 0 + }, + "web_search": { + "num_requests": 0 + } + }, + "tools": [], + "top_logprobs": 0, + "top_p": 0.98, + "truncation": "disabled", + "usage": { + "input_tokens": 45, + "input_tokens_details": { + "cache_write_tokens": 0, + "cached_tokens": 0 + }, + "output_tokens": 131, + "output_tokens_details": { + "reasoning_tokens": 47 + }, + "total_tokens": 176 + }, + "user": null, + "metadata": {} +} \ No newline at end of file diff --git a/packages/inference-discovery-openai/sessions/openai-responses/gpt-6-luna/reasoning-content/session.json b/packages/inference-discovery-openai/sessions/openai-responses/gpt-6-luna/reasoning-content/session.json new file mode 100644 index 000000000..2edf0b52d --- /dev/null +++ b/packages/inference-discovery-openai/sessions/openai-responses/gpt-6-luna/reasoning-content/session.json @@ -0,0 +1,11 @@ +{ + "schemaVersion": "2", + "source": { + "provider": "openai-responses", + "model": "gpt-6-luna", + "baseURL": "https://api.openai.com/v1" + }, + "origin": "live", + "capturedAt": "2026-10-31T02:01:31.761Z", + "capability": "reasoning-content" +} diff --git a/packages/inference-discovery-openai/sessions/openai-responses/gpt-6-sol/function-calling-multi-turn/dispatches/0-get_weather.json b/packages/inference-discovery-openai/sessions/openai-responses/gpt-6-sol/function-calling-multi-turn/dispatches/0-get_weather.json new file mode 100644 index 000000000..21f38181b --- /dev/null +++ b/packages/inference-discovery-openai/sessions/openai-responses/gpt-6-sol/function-calling-multi-turn/dispatches/0-get_weather.json @@ -0,0 +1,6 @@ +{ + "args": { + "location": "Boston, MA" + }, + "result": "{\"location\":\"Boston, MA\",\"temperatureF\":68,\"conditions\":\"clear\"}" +} diff --git a/packages/inference-discovery-openai/sessions/openai-responses/gpt-6-sol/function-calling-multi-turn/exchanges/0/request-headers.json b/packages/inference-discovery-openai/sessions/openai-responses/gpt-6-sol/function-calling-multi-turn/exchanges/0/request-headers.json new file mode 100644 index 000000000..28c14bb85 --- /dev/null +++ b/packages/inference-discovery-openai/sessions/openai-responses/gpt-6-sol/function-calling-multi-turn/exchanges/0/request-headers.json @@ -0,0 +1,4 @@ +{ + "Content-Type": "application/json", + "Authorization": "" +} diff --git a/packages/inference-discovery-openai/sessions/openai-responses/gpt-6-sol/function-calling-multi-turn/exchanges/0/request.json b/packages/inference-discovery-openai/sessions/openai-responses/gpt-6-sol/function-calling-multi-turn/exchanges/0/request.json new file mode 100644 index 000000000..0ed66f481 --- /dev/null +++ b/packages/inference-discovery-openai/sessions/openai-responses/gpt-6-sol/function-calling-multi-turn/exchanges/0/request.json @@ -0,0 +1,30 @@ +{ + "model": "gpt-6-sol", + "input": [ + { + "type": "message", + "role": "user", + "content": "What is the weather in Boston, MA? Use the provided tool." + } + ], + "tools": [ + { + "type": "function", + "name": "get_weather", + "description": "Look up the current weather for a city.", + "parameters": { + "type": "object", + "properties": { + "location": { + "type": "string", + "description": "City and optional region, e.g. 'Boston, MA'." + } + }, + "required": [ + "location" + ] + } + } + ], + "tool_choice": "auto" +} diff --git a/packages/inference-discovery-openai/sessions/openai-responses/gpt-6-sol/function-calling-multi-turn/exchanges/0/response-headers.json b/packages/inference-discovery-openai/sessions/openai-responses/gpt-6-sol/function-calling-multi-turn/exchanges/0/response-headers.json new file mode 100644 index 000000000..fa556cfb8 --- /dev/null +++ b/packages/inference-discovery-openai/sessions/openai-responses/gpt-6-sol/function-calling-multi-turn/exchanges/0/response-headers.json @@ -0,0 +1,26 @@ +{ + "access-control-expose-headers": "X-Request-ID, Server-Timing-Total, CF-Ray, CF-Ray", + "alt-svc": "h3=\":443\"; ma=86400", + "cf-cache-status": "DYNAMIC", + "cf-ray": "a52f12859e126a29-LAX", + "connection": "keep-alive", + "content-encoding": "br", + "content-type": "application/json", + "date": "Sat, 31 Oct 2026 02:01:32 GMT", + "openai-organization": "", + "openai-processing-ms": "941", + "openai-project": "", + "openai-version": "2020-10-01", + "server": "cloudflare", + "strict-transport-security": "max-age=31536000; includeSubDomains; preload", + "transfer-encoding": "chunked", + "x-content-type-options": "nosniff", + "x-ratelimit-limit-requests": "5000", + "x-ratelimit-limit-tokens": "1000000", + "x-ratelimit-remaining-requests": "4999", + "x-ratelimit-remaining-tokens": "1000000", + "x-ratelimit-reset-requests": "12ms", + "x-ratelimit-reset-tokens": "0s", + "x-request-id": "", + "set-cookie": "" +} diff --git a/packages/inference-discovery-openai/sessions/openai-responses/gpt-6-sol/function-calling-multi-turn/exchanges/0/response.json b/packages/inference-discovery-openai/sessions/openai-responses/gpt-6-sol/function-calling-multi-turn/exchanges/0/response.json new file mode 100644 index 000000000..68f4bf16a --- /dev/null +++ b/packages/inference-discovery-openai/sessions/openai-responses/gpt-6-sol/function-calling-multi-turn/exchanges/0/response.json @@ -0,0 +1,109 @@ +{ + "id": "resp_0a69069772348f0c006ae54bfbd4b887d0b6f161e1856bbfd7", + "object": "response", + "created_at": 1793412091, + "status": "completed", + "access_programs": null, + "background": false, + "billing": { + "payer": "developer" + }, + "completed_at": 1793412092, + "error": null, + "frequency_penalty": 0.0, + "incomplete_details": null, + "instructions": null, + "max_output_tokens": null, + "max_tool_calls": null, + "model": "gpt-6-sol", + "moderation": null, + "output": [ + { + "id": "fc_0a69069772348f0c006ae54bfc713c87d0b1282bc30ada9739", + "type": "function_call", + "status": "completed", + "arguments": "{\"location\":\"Boston, MA\"}", + "call_id": "call_e7LgbSE5lTZKp6QfwIzD8FKt", + "name": "get_weather" + } + ], + "parallel_tool_calls": true, + "presence_penalty": 0.0, + "previous_response_id": null, + "prompt_cache_key": null, + "prompt_cache_retention": "24h", + "reasoning": { + "context": "all_turns", + "effort": "medium", + "mode": "standard", + "summary": null + }, + "safety_identifier": null, + "service_tier": "default", + "store": true, + "temperature": 1.0, + "text": { + "format": { + "type": "text" + }, + "verbosity": "medium" + }, + "tool_choice": "auto", + "tool_usage": { + "image_gen": { + "input_tokens": 0, + "input_tokens_details": { + "image_tokens": 0, + "text_tokens": 0 + }, + "output_tokens": 0, + "output_tokens_details": { + "image_tokens": 0, + "text_tokens": 0 + }, + "total_tokens": 0 + }, + "web_search": { + "num_requests": 0 + } + }, + "tools": [ + { + "type": "function", + "description": "Look up the current weather for a city.", + "name": "get_weather", + "output_schema": null, + "parameters": { + "type": "object", + "properties": { + "location": { + "type": "string", + "description": "City and optional region, e.g. 'Boston, MA'." + } + }, + "required": [ + "location" + ], + "additionalProperties": false + }, + "strict": true + } + ], + "top_logprobs": 0, + "top_p": 0.98, + "truncation": "disabled", + "usage": { + "input_tokens": 73, + "input_tokens_details": { + "cache_write_tokens": 0, + "cached_tokens": 0 + }, + "output_tokens": 20, + "output_tokens_details": { + "reasoning_tokens": 0 + }, + "total_tokens": 93 + }, + "user": null, + "metadata": {} +} \ No newline at end of file diff --git a/packages/inference-discovery-openai/sessions/openai-responses/gpt-6-sol/function-calling-multi-turn/exchanges/1/request-headers.json b/packages/inference-discovery-openai/sessions/openai-responses/gpt-6-sol/function-calling-multi-turn/exchanges/1/request-headers.json new file mode 100644 index 000000000..28c14bb85 --- /dev/null +++ b/packages/inference-discovery-openai/sessions/openai-responses/gpt-6-sol/function-calling-multi-turn/exchanges/1/request-headers.json @@ -0,0 +1,4 @@ +{ + "Content-Type": "application/json", + "Authorization": "" +} diff --git a/packages/inference-discovery-openai/sessions/openai-responses/gpt-6-sol/function-calling-multi-turn/exchanges/1/request.json b/packages/inference-discovery-openai/sessions/openai-responses/gpt-6-sol/function-calling-multi-turn/exchanges/1/request.json new file mode 100644 index 000000000..4415ef1eb --- /dev/null +++ b/packages/inference-discovery-openai/sessions/openai-responses/gpt-6-sol/function-calling-multi-turn/exchanges/1/request.json @@ -0,0 +1,45 @@ +{ + "model": "gpt-6-sol", + "input": [ + { + "type": "message", + "role": "user", + "content": "What is the weather in Boston, MA? Use the provided tool." + }, + { + "type": "function_call", + "call_id": "call_e7LgbSE5lTZKp6QfwIzD8FKt", + "name": "get_weather", + "arguments": "{\"location\":\"Boston, MA\"}" + }, + { + "type": "function_call_output", + "call_id": "call_e7LgbSE5lTZKp6QfwIzD8FKt", + "output": "{\"location\":\"Boston, MA\",\"temperatureF\":68,\"conditions\":\"clear\"}" + } + ], + "store": false, + "include": [ + "reasoning.encrypted_content" + ], + "tools": [ + { + "type": "function", + "name": "get_weather", + "description": "Look up the current weather for a city.", + "parameters": { + "type": "object", + "properties": { + "location": { + "type": "string", + "description": "City and optional region, e.g. 'Boston, MA'." + } + }, + "required": [ + "location" + ] + } + } + ], + "tool_choice": "auto" +} diff --git a/packages/inference-discovery-openai/sessions/openai-responses/gpt-6-sol/function-calling-multi-turn/exchanges/1/response-headers.json b/packages/inference-discovery-openai/sessions/openai-responses/gpt-6-sol/function-calling-multi-turn/exchanges/1/response-headers.json new file mode 100644 index 000000000..ab5c25f8a --- /dev/null +++ b/packages/inference-discovery-openai/sessions/openai-responses/gpt-6-sol/function-calling-multi-turn/exchanges/1/response-headers.json @@ -0,0 +1,26 @@ +{ + "access-control-expose-headers": "X-Request-ID, Server-Timing-Total, CF-Ray, CF-Ray", + "alt-svc": "h3=\":443\"; ma=86400", + "cf-cache-status": "DYNAMIC", + "cf-ray": "a52f128be8686a29-LAX", + "connection": "keep-alive", + "content-encoding": "br", + "content-type": "application/json", + "date": "Sat, 31 Oct 2026 02:01:33 GMT", + "openai-organization": "", + "openai-processing-ms": "976", + "openai-project": "", + "openai-version": "2020-10-01", + "server": "cloudflare", + "strict-transport-security": "max-age=31536000; includeSubDomains; preload", + "transfer-encoding": "chunked", + "x-content-type-options": "nosniff", + "x-ratelimit-limit-requests": "5000", + "x-ratelimit-limit-tokens": "1000000", + "x-ratelimit-remaining-requests": "4999", + "x-ratelimit-remaining-tokens": "1000000", + "x-ratelimit-reset-requests": "12ms", + "x-ratelimit-reset-tokens": "0s", + "x-request-id": "", + "set-cookie": "" +} diff --git a/packages/inference-discovery-openai/sessions/openai-responses/gpt-6-sol/function-calling-multi-turn/exchanges/1/response.json b/packages/inference-discovery-openai/sessions/openai-responses/gpt-6-sol/function-calling-multi-turn/exchanges/1/response.json new file mode 100644 index 000000000..6eb6ddd9e --- /dev/null +++ b/packages/inference-discovery-openai/sessions/openai-responses/gpt-6-sol/function-calling-multi-turn/exchanges/1/response.json @@ -0,0 +1,116 @@ +{ + "id": "resp_07f7875387ca8e4f016ae54bfcdc5887d0914b4a3b09505e29", + "object": "response", + "created_at": 1793412092, + "status": "completed", + "access_programs": null, + "background": false, + "billing": { + "payer": "developer" + }, + "completed_at": 1793412093, + "error": null, + "frequency_penalty": 0.0, + "incomplete_details": null, + "instructions": null, + "max_output_tokens": null, + "max_tool_calls": null, + "model": "gpt-6-sol", + "moderation": null, + "output": [ + { + "id": "msg_07f7875387ca8e4f016ae54bfd914087d0a7e09e6c8b8a243a", + "type": "message", + "status": "completed", + "content": [ + { + "type": "output_text", + "annotations": [], + "logprobs": [], + "text": "It\u2019s 68\u00b0F and clear in Boston, MA." + } + ], + "phase": "final_answer", + "role": "assistant" + } + ], + "parallel_tool_calls": true, + "presence_penalty": 0.0, + "previous_response_id": null, + "prompt_cache_key": null, + "prompt_cache_retention": "24h", + "reasoning": { + "context": "all_turns", + "effort": "medium", + "mode": "standard", + "summary": null + }, + "safety_identifier": null, + "service_tier": "default", + "store": false, + "temperature": 1.0, + "text": { + "format": { + "type": "text" + }, + "verbosity": "medium" + }, + "tool_choice": "auto", + "tool_usage": { + "image_gen": { + "input_tokens": 0, + "input_tokens_details": { + "image_tokens": 0, + "text_tokens": 0 + }, + "output_tokens": 0, + "output_tokens_details": { + "image_tokens": 0, + "text_tokens": 0 + }, + "total_tokens": 0 + }, + "web_search": { + "num_requests": 0 + } + }, + "tools": [ + { + "type": "function", + "description": "Look up the current weather for a city.", + "name": "get_weather", + "output_schema": null, + "parameters": { + "type": "object", + "properties": { + "location": { + "type": "string", + "description": "City and optional region, e.g. 'Boston, MA'." + } + }, + "required": [ + "location" + ], + "additionalProperties": false + }, + "strict": true + } + ], + "top_logprobs": 0, + "top_p": 0.98, + "truncation": "disabled", + "usage": { + "input_tokens": 120, + "input_tokens_details": { + "cache_write_tokens": 0, + "cached_tokens": 0 + }, + "output_tokens": 16, + "output_tokens_details": { + "reasoning_tokens": 0 + }, + "total_tokens": 136 + }, + "user": null, + "metadata": {} +} \ No newline at end of file diff --git a/packages/inference-discovery-openai/sessions/openai-responses/gpt-6-sol/function-calling-multi-turn/session.json b/packages/inference-discovery-openai/sessions/openai-responses/gpt-6-sol/function-calling-multi-turn/session.json new file mode 100644 index 000000000..199dbc5ba --- /dev/null +++ b/packages/inference-discovery-openai/sessions/openai-responses/gpt-6-sol/function-calling-multi-turn/session.json @@ -0,0 +1,11 @@ +{ + "schemaVersion": "2", + "source": { + "provider": "openai-responses", + "model": "gpt-6-sol", + "baseURL": "https://api.openai.com/v1" + }, + "origin": "live", + "capturedAt": "2026-10-31T02:01:33.854Z", + "capability": "function-calling-multi-turn" +} diff --git a/packages/inference-discovery-openai/sessions/openai-responses/gpt-6-sol/plain-text-streaming/exchanges/0/request-headers.json b/packages/inference-discovery-openai/sessions/openai-responses/gpt-6-sol/plain-text-streaming/exchanges/0/request-headers.json new file mode 100644 index 000000000..28c14bb85 --- /dev/null +++ b/packages/inference-discovery-openai/sessions/openai-responses/gpt-6-sol/plain-text-streaming/exchanges/0/request-headers.json @@ -0,0 +1,4 @@ +{ + "Content-Type": "application/json", + "Authorization": "" +} diff --git a/packages/inference-discovery-openai/sessions/openai-responses/gpt-6-sol/plain-text-streaming/exchanges/0/request.json b/packages/inference-discovery-openai/sessions/openai-responses/gpt-6-sol/plain-text-streaming/exchanges/0/request.json new file mode 100644 index 000000000..2df8f7c92 --- /dev/null +++ b/packages/inference-discovery-openai/sessions/openai-responses/gpt-6-sol/plain-text-streaming/exchanges/0/request.json @@ -0,0 +1,11 @@ +{ + "model": "gpt-6-sol", + "input": [ + { + "type": "message", + "role": "user", + "content": "Reply with a single sentence: the capital of France is Paris." + } + ], + "stream": true +} diff --git a/packages/inference-discovery-openai/sessions/openai-responses/gpt-6-sol/plain-text-streaming/exchanges/0/response-headers.json b/packages/inference-discovery-openai/sessions/openai-responses/gpt-6-sol/plain-text-streaming/exchanges/0/response-headers.json new file mode 100644 index 000000000..a8e46c852 --- /dev/null +++ b/packages/inference-discovery-openai/sessions/openai-responses/gpt-6-sol/plain-text-streaming/exchanges/0/response-headers.json @@ -0,0 +1,25 @@ +{ + "access-control-expose-headers": "X-Request-ID, Server-Timing-Total, CF-Ray, CF-Ray", + "alt-svc": "h3=\":443\"; ma=86400", + "cf-cache-status": "DYNAMIC", + "cf-ray": "a5281ac3ef1a6150-LAX", + "connection": "keep-alive", + "content-type": "text/event-stream; charset=utf-8", + "date": "Fri, 30 Oct 2026 05:43:50 GMT", + "openai-organization": "", + "openai-processing-ms": "1775", + "openai-project": "", + "openai-version": "2020-10-01", + "server": "cloudflare", + "strict-transport-security": "max-age=31536000; includeSubDomains; preload", + "transfer-encoding": "chunked", + "x-content-type-options": "nosniff", + "x-ratelimit-limit-requests": "5000", + "x-ratelimit-limit-tokens": "1000000", + "x-ratelimit-remaining-requests": "4999", + "x-ratelimit-remaining-tokens": "999838", + "x-ratelimit-reset-requests": "12ms", + "x-ratelimit-reset-tokens": "9ms", + "x-request-id": "", + "set-cookie": "" +} diff --git a/packages/inference-discovery-openai/sessions/openai-responses/gpt-6-sol/plain-text-streaming/exchanges/0/response.sse b/packages/inference-discovery-openai/sessions/openai-responses/gpt-6-sol/plain-text-streaming/exchanges/0/response.sse new file mode 100644 index 000000000..ba8c3fc5c --- /dev/null +++ b/packages/inference-discovery-openai/sessions/openai-responses/gpt-6-sol/plain-text-streaming/exchanges/0/response.sse @@ -0,0 +1,45 @@ +event: response.created +data: {"type":"response.created","response":{"id":"resp_0d6a9e7b5986aa57006ae42e9535d087d0b01f3d930d6dbc07","object":"response","created_at":1793339029,"status":"in_progress","access_programs":null,"background":false,"completed_at":null,"error":null,"frequency_penalty":0.0,"incomplete_details":null,"instructions":null,"max_output_tokens":null,"max_tool_calls":null,"model":"gpt-6-sol","moderation":null,"output":[],"parallel_tool_calls":true,"presence_penalty":0.0,"previous_response_id":null,"prompt_cache_key":null,"prompt_cache_retention":"24h","reasoning":{"context":"all_turns","effort":"medium","mode":"standard","summary":null},"safety_identifier":null,"service_tier":"auto","store":true,"temperature":1.0,"text":{"format":{"type":"text"},"verbosity":"medium"},"tool_choice":"auto","tool_usage":{"image_gen":{"input_tokens":0,"input_tokens_details":{"image_tokens":0,"text_tokens":0},"output_tokens":0,"output_tokens_details":{"image_tokens":0,"text_tokens":0},"total_tokens":0},"web_search":{"num_requests":0}},"tools":[],"top_logprobs":0,"top_p":0.98,"truncation":"disabled","usage":null,"user":null,"metadata":{}},"sequence_number":0} + +event: response.in_progress +data: {"type":"response.in_progress","response":{"id":"resp_0d6a9e7b5986aa57006ae42e9535d087d0b01f3d930d6dbc07","object":"response","created_at":1793339029,"status":"in_progress","access_programs":null,"background":false,"completed_at":null,"error":null,"frequency_penalty":0.0,"incomplete_details":null,"instructions":null,"max_output_tokens":null,"max_tool_calls":null,"model":"gpt-6-sol","moderation":null,"output":[],"parallel_tool_calls":true,"presence_penalty":0.0,"previous_response_id":null,"prompt_cache_key":null,"prompt_cache_retention":"24h","reasoning":{"context":"all_turns","effort":"medium","mode":"standard","summary":null},"safety_identifier":null,"service_tier":"auto","store":true,"temperature":1.0,"text":{"format":{"type":"text"},"verbosity":"medium"},"tool_choice":"auto","tool_usage":{"image_gen":{"input_tokens":0,"input_tokens_details":{"image_tokens":0,"text_tokens":0},"output_tokens":0,"output_tokens_details":{"image_tokens":0,"text_tokens":0},"total_tokens":0},"web_search":{"num_requests":0}},"tools":[],"top_logprobs":0,"top_p":0.98,"truncation":"disabled","usage":null,"user":null,"metadata":{}},"sequence_number":1} + +event: response.output_item.added +data: {"type":"response.output_item.added","item":{"id":"msg_0d6a9e7b5986aa57006ae42e9746a887d0b4186143c2b963d6","type":"message","status":"in_progress","content":[],"phase":"final_answer","role":"assistant"},"output_index":0,"sequence_number":2} + +event: response.content_part.added +data: {"type":"response.content_part.added","content_index":0,"item_id":"msg_0d6a9e7b5986aa57006ae42e9746a887d0b4186143c2b963d6","output_index":0,"part":{"type":"output_text","annotations":[],"logprobs":[],"text":""},"sequence_number":3} + +event: response.output_text.delta +data: {"type":"response.output_text.delta","content_index":0,"delta":"The","item_id":"msg_0d6a9e7b5986aa57006ae42e9746a887d0b4186143c2b963d6","logprobs":[],"obfuscation":"cz7X4Vif9fcPr","output_index":0,"sequence_number":4} + +event: response.output_text.delta +data: {"type":"response.output_text.delta","content_index":0,"delta":" capital","item_id":"msg_0d6a9e7b5986aa57006ae42e9746a887d0b4186143c2b963d6","logprobs":[],"obfuscation":"O8RqxSpL","output_index":0,"sequence_number":5} + +event: response.output_text.delta +data: {"type":"response.output_text.delta","content_index":0,"delta":" of","item_id":"msg_0d6a9e7b5986aa57006ae42e9746a887d0b4186143c2b963d6","logprobs":[],"obfuscation":"WrpQCnMqGcCZI","output_index":0,"sequence_number":6} + +event: response.output_text.delta +data: {"type":"response.output_text.delta","content_index":0,"delta":" France","item_id":"msg_0d6a9e7b5986aa57006ae42e9746a887d0b4186143c2b963d6","logprobs":[],"obfuscation":"zC3EeoHA0","output_index":0,"sequence_number":7} + +event: response.output_text.delta +data: {"type":"response.output_text.delta","content_index":0,"delta":" is","item_id":"msg_0d6a9e7b5986aa57006ae42e9746a887d0b4186143c2b963d6","logprobs":[],"obfuscation":"Fyr3Yq3spEHBh","output_index":0,"sequence_number":8} + +event: response.output_text.delta +data: {"type":"response.output_text.delta","content_index":0,"delta":" Paris","item_id":"msg_0d6a9e7b5986aa57006ae42e9746a887d0b4186143c2b963d6","logprobs":[],"obfuscation":"Eoae5Tv20M","output_index":0,"sequence_number":9} + +event: response.output_text.delta +data: {"type":"response.output_text.delta","content_index":0,"delta":".","item_id":"msg_0d6a9e7b5986aa57006ae42e9746a887d0b4186143c2b963d6","logprobs":[],"obfuscation":"W56bY6MXfhvAEeM","output_index":0,"sequence_number":10} + +event: response.output_text.done +data: {"type":"response.output_text.done","content_index":0,"item_id":"msg_0d6a9e7b5986aa57006ae42e9746a887d0b4186143c2b963d6","logprobs":[],"output_index":0,"sequence_number":11,"text":"The capital of France is Paris."} + +event: response.content_part.done +data: {"type":"response.content_part.done","content_index":0,"item_id":"msg_0d6a9e7b5986aa57006ae42e9746a887d0b4186143c2b963d6","output_index":0,"part":{"type":"output_text","annotations":[],"logprobs":[],"text":"The capital of France is Paris."},"sequence_number":12} + +event: response.output_item.done +data: {"type":"response.output_item.done","item":{"id":"msg_0d6a9e7b5986aa57006ae42e9746a887d0b4186143c2b963d6","type":"message","status":"completed","content":[{"type":"output_text","annotations":[],"logprobs":[],"text":"The capital of France is Paris."}],"phase":"final_answer","role":"assistant"},"output_index":0,"sequence_number":13} + +event: response.completed +data: {"type":"response.completed","response":{"id":"resp_0d6a9e7b5986aa57006ae42e9535d087d0b01f3d930d6dbc07","object":"response","created_at":1793339029,"status":"completed","access_programs":null,"background":false,"completed_at":1793339031,"error":null,"frequency_penalty":0.0,"incomplete_details":null,"instructions":null,"max_output_tokens":null,"max_tool_calls":null,"model":"gpt-6-sol","moderation":null,"output":[{"id":"msg_0d6a9e7b5986aa57006ae42e9746a887d0b4186143c2b963d6","type":"message","status":"completed","content":[{"type":"output_text","annotations":[],"logprobs":[],"text":"The capital of France is Paris."}],"phase":"final_answer","role":"assistant"}],"parallel_tool_calls":true,"presence_penalty":0.0,"previous_response_id":null,"prompt_cache_key":null,"prompt_cache_retention":"24h","reasoning":{"context":"all_turns","effort":"medium","mode":"standard","summary":null},"safety_identifier":null,"service_tier":"default","store":true,"temperature":1.0,"text":{"format":{"type":"text"},"verbosity":"medium"},"tool_choice":"auto","tool_usage":{"image_gen":{"input_tokens":0,"input_tokens_details":{"image_tokens":0,"text_tokens":0},"output_tokens":0,"output_tokens_details":{"image_tokens":0,"text_tokens":0},"total_tokens":0},"web_search":{"num_requests":0}},"tools":[],"top_logprobs":0,"top_p":0.98,"truncation":"disabled","usage":{"input_tokens":19,"input_tokens_details":{"cache_write_tokens":0,"cached_tokens":0},"output_tokens":11,"output_tokens_details":{"reasoning_tokens":0},"total_tokens":30},"user":null,"metadata":{}},"sequence_number":14} + diff --git a/packages/inference-discovery-openai/sessions/openai-responses/gpt-6-sol/plain-text-streaming/session.json b/packages/inference-discovery-openai/sessions/openai-responses/gpt-6-sol/plain-text-streaming/session.json new file mode 100644 index 000000000..72115ba20 --- /dev/null +++ b/packages/inference-discovery-openai/sessions/openai-responses/gpt-6-sol/plain-text-streaming/session.json @@ -0,0 +1,11 @@ +{ + "schemaVersion": "2", + "source": { + "provider": "openai-responses", + "model": "gpt-6-sol", + "baseURL": "https://api.openai.com/v1" + }, + "origin": "live", + "capturedAt": "2026-10-30T05:43:51.743Z", + "capability": "plain-text-streaming" +} diff --git a/packages/inference-discovery-openai/sessions/openai-responses/gpt-6-sol/plain-text/exchanges/0/request-headers.json b/packages/inference-discovery-openai/sessions/openai-responses/gpt-6-sol/plain-text/exchanges/0/request-headers.json new file mode 100644 index 000000000..28c14bb85 --- /dev/null +++ b/packages/inference-discovery-openai/sessions/openai-responses/gpt-6-sol/plain-text/exchanges/0/request-headers.json @@ -0,0 +1,4 @@ +{ + "Content-Type": "application/json", + "Authorization": "" +} diff --git a/packages/inference-discovery-openai/sessions/openai-responses/gpt-6-sol/plain-text/exchanges/0/request.json b/packages/inference-discovery-openai/sessions/openai-responses/gpt-6-sol/plain-text/exchanges/0/request.json new file mode 100644 index 000000000..ff489dca2 --- /dev/null +++ b/packages/inference-discovery-openai/sessions/openai-responses/gpt-6-sol/plain-text/exchanges/0/request.json @@ -0,0 +1,10 @@ +{ + "model": "gpt-6-sol", + "input": [ + { + "type": "message", + "role": "user", + "content": "Reply with a single sentence: the capital of France is Paris." + } + ] +} diff --git a/packages/inference-discovery-openai/sessions/openai-responses/gpt-6-sol/plain-text/exchanges/0/response-headers.json b/packages/inference-discovery-openai/sessions/openai-responses/gpt-6-sol/plain-text/exchanges/0/response-headers.json new file mode 100644 index 000000000..a31a02159 --- /dev/null +++ b/packages/inference-discovery-openai/sessions/openai-responses/gpt-6-sol/plain-text/exchanges/0/response-headers.json @@ -0,0 +1,26 @@ +{ + "access-control-expose-headers": "X-Request-ID, Server-Timing-Total, CF-Ray, CF-Ray", + "alt-svc": "h3=\":443\"; ma=86400", + "cf-cache-status": "DYNAMIC", + "cf-ray": "a5281abcaecd6150-LAX", + "connection": "keep-alive", + "content-encoding": "br", + "content-type": "application/json", + "date": "Fri, 30 Oct 2026 05:43:49 GMT", + "openai-organization": "", + "openai-processing-ms": "1037", + "openai-project": "", + "openai-version": "2020-10-01", + "server": "cloudflare", + "strict-transport-security": "max-age=31536000; includeSubDomains; preload", + "transfer-encoding": "chunked", + "x-content-type-options": "nosniff", + "x-ratelimit-limit-requests": "5000", + "x-ratelimit-limit-tokens": "1000000", + "x-ratelimit-remaining-requests": "4999", + "x-ratelimit-remaining-tokens": "1000000", + "x-ratelimit-reset-requests": "12ms", + "x-ratelimit-reset-tokens": "0s", + "x-request-id": "", + "set-cookie": "" +} diff --git a/packages/inference-discovery-openai/sessions/openai-responses/gpt-6-sol/plain-text/exchanges/0/response.json b/packages/inference-discovery-openai/sessions/openai-responses/gpt-6-sol/plain-text/exchanges/0/response.json new file mode 100644 index 000000000..fc600cbb5 --- /dev/null +++ b/packages/inference-discovery-openai/sessions/openai-responses/gpt-6-sol/plain-text/exchanges/0/response.json @@ -0,0 +1,95 @@ +{ + "id": "resp_0f462de54485f3f0006ae42e94090487d0882d09b28f26556c", + "object": "response", + "created_at": 1793339028, + "status": "completed", + "access_programs": null, + "background": false, + "billing": { + "payer": "developer" + }, + "completed_at": 1793339028, + "error": null, + "frequency_penalty": 0.0, + "incomplete_details": null, + "instructions": null, + "max_output_tokens": null, + "max_tool_calls": null, + "model": "gpt-6-sol", + "moderation": null, + "output": [ + { + "id": "msg_0f462de54485f3f0006ae42e94b90c87d0a951af7bfa57aeb8", + "type": "message", + "status": "completed", + "content": [ + { + "type": "output_text", + "annotations": [], + "logprobs": [], + "text": "The capital of France is Paris." + } + ], + "phase": "final_answer", + "role": "assistant" + } + ], + "parallel_tool_calls": true, + "presence_penalty": 0.0, + "previous_response_id": null, + "prompt_cache_key": null, + "prompt_cache_retention": "24h", + "reasoning": { + "context": "all_turns", + "effort": "medium", + "mode": "standard", + "summary": null + }, + "safety_identifier": null, + "service_tier": "default", + "store": true, + "temperature": 1.0, + "text": { + "format": { + "type": "text" + }, + "verbosity": "medium" + }, + "tool_choice": "auto", + "tool_usage": { + "image_gen": { + "input_tokens": 0, + "input_tokens_details": { + "image_tokens": 0, + "text_tokens": 0 + }, + "output_tokens": 0, + "output_tokens_details": { + "image_tokens": 0, + "text_tokens": 0 + }, + "total_tokens": 0 + }, + "web_search": { + "num_requests": 0 + } + }, + "tools": [], + "top_logprobs": 0, + "top_p": 0.98, + "truncation": "disabled", + "usage": { + "input_tokens": 19, + "input_tokens_details": { + "cache_write_tokens": 0, + "cached_tokens": 0 + }, + "output_tokens": 11, + "output_tokens_details": { + "reasoning_tokens": 0 + }, + "total_tokens": 30 + }, + "user": null, + "metadata": {} +} \ No newline at end of file diff --git a/packages/inference-discovery-openai/sessions/openai-responses/gpt-6-sol/plain-text/session.json b/packages/inference-discovery-openai/sessions/openai-responses/gpt-6-sol/plain-text/session.json new file mode 100644 index 000000000..7813c0611 --- /dev/null +++ b/packages/inference-discovery-openai/sessions/openai-responses/gpt-6-sol/plain-text/session.json @@ -0,0 +1,11 @@ +{ + "schemaVersion": "2", + "source": { + "provider": "openai-responses", + "model": "gpt-6-sol", + "baseURL": "https://api.openai.com/v1" + }, + "origin": "live", + "capturedAt": "2026-10-30T05:43:49.090Z", + "capability": "plain-text" +} diff --git a/packages/inference-discovery-openai/sessions/openai-responses/gpt-6-sol/reasoning-content/exchanges/0/request-headers.json b/packages/inference-discovery-openai/sessions/openai-responses/gpt-6-sol/reasoning-content/exchanges/0/request-headers.json new file mode 100644 index 000000000..28c14bb85 --- /dev/null +++ b/packages/inference-discovery-openai/sessions/openai-responses/gpt-6-sol/reasoning-content/exchanges/0/request-headers.json @@ -0,0 +1,4 @@ +{ + "Content-Type": "application/json", + "Authorization": "" +} diff --git a/packages/inference-discovery-openai/sessions/openai-responses/gpt-6-sol/reasoning-content/exchanges/0/request.json b/packages/inference-discovery-openai/sessions/openai-responses/gpt-6-sol/reasoning-content/exchanges/0/request.json new file mode 100644 index 000000000..d4b5789c0 --- /dev/null +++ b/packages/inference-discovery-openai/sessions/openai-responses/gpt-6-sol/reasoning-content/exchanges/0/request.json @@ -0,0 +1,14 @@ +{ + "model": "gpt-6-sol", + "input": [ + { + "type": "message", + "role": "user", + "content": "A bat and a ball cost $1.10 together. The bat costs $1.00 more than the ball. How much does the ball cost? Show your reasoning before the final answer." + } + ], + "reasoning": { + "effort": "medium", + "summary": "detailed" + } +} diff --git a/packages/inference-discovery-openai/sessions/openai-responses/gpt-6-sol/reasoning-content/exchanges/0/response-headers.json b/packages/inference-discovery-openai/sessions/openai-responses/gpt-6-sol/reasoning-content/exchanges/0/response-headers.json new file mode 100644 index 000000000..ce206d5ff --- /dev/null +++ b/packages/inference-discovery-openai/sessions/openai-responses/gpt-6-sol/reasoning-content/exchanges/0/response-headers.json @@ -0,0 +1,26 @@ +{ + "access-control-expose-headers": "X-Request-ID, Server-Timing-Total, CF-Ray, CF-Ray", + "alt-svc": "h3=\":443\"; ma=86400", + "cf-cache-status": "DYNAMIC", + "cf-ray": "a52f1292aae56a29-LAX", + "connection": "keep-alive", + "content-encoding": "br", + "content-type": "application/json", + "date": "Sat, 31 Oct 2026 02:01:36 GMT", + "openai-organization": "", + "openai-processing-ms": "2668", + "openai-project": "", + "openai-version": "2020-10-01", + "server": "cloudflare", + "strict-transport-security": "max-age=31536000; includeSubDomains; preload", + "transfer-encoding": "chunked", + "x-content-type-options": "nosniff", + "x-ratelimit-limit-requests": "5000", + "x-ratelimit-limit-tokens": "1000000", + "x-ratelimit-remaining-requests": "4999", + "x-ratelimit-remaining-tokens": "1000000", + "x-ratelimit-reset-requests": "12ms", + "x-ratelimit-reset-tokens": "0s", + "x-request-id": "", + "set-cookie": "" +} diff --git a/packages/inference-discovery-openai/sessions/openai-responses/gpt-6-sol/reasoning-content/exchanges/0/response.json b/packages/inference-discovery-openai/sessions/openai-responses/gpt-6-sol/reasoning-content/exchanges/0/response.json new file mode 100644 index 000000000..749ad7a08 --- /dev/null +++ b/packages/inference-discovery-openai/sessions/openai-responses/gpt-6-sol/reasoning-content/exchanges/0/response.json @@ -0,0 +1,107 @@ +{ + "id": "resp_09215fbd697d8199006ae54bfdf5e087d0be79dd7115349d6b", + "object": "response", + "created_at": 1793412094, + "status": "completed", + "access_programs": null, + "background": false, + "billing": { + "payer": "developer" + }, + "completed_at": 1793412096, + "error": null, + "frequency_penalty": 0.0, + "incomplete_details": null, + "instructions": null, + "max_output_tokens": null, + "max_tool_calls": null, + "model": "gpt-6-sol", + "moderation": null, + "output": [ + { + "id": "rs_09215fbd697d8199006ae54bfea05487d0b03419afaa946d84", + "type": "reasoning", + "content": [], + "encrypted_content": "gAAAAABq5UwAfQQic6HjoL6z6OCZntUsIsSeHWbNZn_ukhK_YqFzTM-wxPpjDJN26PKDuKCFw3slvCPwfjwfLWU8q1c018mF4k5y0W7aCx2VbNkscvalN2enaKKxfxQ2Z2Tqn4T91LTlqyKGffdEbJ8ylTyrA5J1IeB8ELpADpjwL1dAjCyIImhOCsLbdWJg3kE8ltBMH3PV-CsatPX-tF1w3wzUidQ0t6Ywt82BdGRZXiFcDsRl8cS3JH0csRdSRGjxJbZlXWxPVk1TTwMNp8h3mez__Y4H6MAH2XWMzJHJGzfh3h4vNMfbor9Jb6yJpzEDliEp8WlBHT9jxBQyHvTNrN0yhSWZ_etEsrzdjRqLBIHoe3O5WlVFh8VXymZhmlZn9-0Ff6Qal0I7EHsbS75-3P6nb68yEf-_BoMbAnO3fyYdpOwWWTzzLW4fihvI9BTcUhZprKChjgmVDHCwBakK9rAHBCv4SwBB-QSYPjERa16s5Qz89vCmwdehS6rHBhjoxiIW9suTanQwQOZ0zT5FndZRv-YkZL5xy0_br9DcBLD6cCLfeMDnlpQfaen5-KL0L429642-M9ZTL1oIEYAHPSzPh5-N5S_bEQtHosto36ELbMlV8phbMbhHpXdZyr8YGx7G-fcrdUUg-i9xJLsY4ndi_RSN7nGTn1U3SD2fjx2OHZlCLUIpHpHZGOtRg5vzYJva1kYeE2dvMMlZbGAuSRFPwJPUICGAdIXdvgTdhiol4MCoQNJ9lZOlZZ7GDTkeQyahkUV4sv3GD2MN-2mNQOKyJHkPwFIdoJM8C5JPSG5GbCEF9xsw84jWso-b_3cd81m2gaXQpSuUnsngIW7KTryzapN4b-vgcPKUrPBFdVqlw16Xd2pePTYS5rNHAfTrK4guqs4f7UNX1TvHXnrVxvANBnq3lLWPShrLy0wK28cM9pSAqG0lyMAfAJWl4lbnLwJjLzgClGQl_DGrv3e2Tz6WLo-DdOSn4nso6R7TJU_9Zn3vqWEakk1yY6u7wvFlQw_HmhXKOCLXszqfzTrX4T2oS-pUxZqUeGKxN8VRyhLUFiKY-vy5rHwlWUj-dZzNGnh3hJ82ynREMUegpPf7WrD2EfRqZKARn1bxb0Gu-Ly2-kVhrb1MCi1WyIV0BgGxLl4OJbnkUIkz8BUdrF6qMOWhJB2vG0zTAYYhnOLrbfUTTlo_FafaNIOTifNborgteb6h9_fgThcPEZSre5aKX2WjzYpihCoQKE9FAZfmuiiUt6eNk4gejwGjRsP9DmTsX3pD84jmVSUoC7eMIlUQLlITblYdPYfO53Up7xivNokqeGXChNIKQP776vfVgni2KBr2-PemFoytVTXxruiXZOmXoSD_la8uBi4rNIaZNjZLe1TMeyO-DfKO0cXyE--2gP9zm_-EfItjH9pDBZJM5cCiIAVCMN6YfN7Rcx8_a2EgQryM-yrbvO1NW0l0lFSWxpK-_ZjbvTy_CFyoa13l_RDw4c5WBsF2f0cKESGKfEokhDZEFqM8WBA6259_sQMJC8wSvho6uB2JEN03_4voQve4zdvCYUUgFzL8akM3hhlSg36k2rmPWjcPPzxsXPCDM3iufzNRdyaMaEdvc57LRKMDB_o09MWkTXvTDWoaGfVCxPW9IQj66G0AXcLBn8SDsdLHQyh9bshSMHOtWFB-9s-rzjGX9EeJ65LDcF86r_UKXglyKDFFJd9l0yduTLcrrPZcYHHEdZNSK8gWPMpikDhMS-tenMm_68_tgWDBb1jvC8yelpQ=", + "summary": [ + { + "type": "summary_text", + "text": "**Solving for values**\n\nI need to reason through the problem before arriving at the final answer. I'll set up a simple algebraic equation where I let the ball be represented as x, and the bat as x+1. This leads me to the equation 2x + 1 = 1.10, which allows me to solve for x. Solving that gives me x = 0.05. So, I'll use this approach to get to the correct values." + } + ] + }, + { + "id": "msg_09215fbd697d8199006ae54bffd6a487d0ae11de0c541f7b3d", + "type": "message", + "status": "completed", + "content": [ + { + "type": "output_text", + "annotations": [], + "logprobs": [], + "text": "Let the ball cost \\(x\\) dollars. Then the bat costs \\(x+1.00\\), so\n\n\\[\nx+(x+1.00)=1.10\n\\]\n\nThus \\(2x=0.10\\), and \\(x=0.05\\).\n\n**The ball costs 5 cents.**" + } + ], + "phase": "final_answer", + "role": "assistant" + } + ], + "parallel_tool_calls": true, + "presence_penalty": 0.0, + "previous_response_id": null, + "prompt_cache_key": null, + "prompt_cache_retention": "24h", + "reasoning": { + "context": "all_turns", + "effort": "medium", + "mode": "standard", + "summary": "detailed" + }, + "safety_identifier": null, + "service_tier": "default", + "store": true, + "temperature": 1.0, + "text": { + "format": { + "type": "text" + }, + "verbosity": "medium" + }, + "tool_choice": "auto", + "tool_usage": { + "image_gen": { + "input_tokens": 0, + "input_tokens_details": { + "image_tokens": 0, + "text_tokens": 0 + }, + "output_tokens": 0, + "output_tokens_details": { + "image_tokens": 0, + "text_tokens": 0 + }, + "total_tokens": 0 + }, + "web_search": { + "num_requests": 0 + } + }, + "tools": [], + "top_logprobs": 0, + "top_p": 0.98, + "truncation": "disabled", + "usage": { + "input_tokens": 45, + "input_tokens_details": { + "cache_write_tokens": 0, + "cached_tokens": 0 + }, + "output_tokens": 110, + "output_tokens_details": { + "reasoning_tokens": 36 + }, + "total_tokens": 155 + }, + "user": null, + "metadata": {} +} \ No newline at end of file diff --git a/packages/inference-discovery-openai/sessions/openai-responses/gpt-6-sol/reasoning-content/session.json b/packages/inference-discovery-openai/sessions/openai-responses/gpt-6-sol/reasoning-content/session.json new file mode 100644 index 000000000..afe41100b --- /dev/null +++ b/packages/inference-discovery-openai/sessions/openai-responses/gpt-6-sol/reasoning-content/session.json @@ -0,0 +1,11 @@ +{ + "schemaVersion": "2", + "source": { + "provider": "openai-responses", + "model": "gpt-6-sol", + "baseURL": "https://api.openai.com/v1" + }, + "origin": "live", + "capturedAt": "2026-10-31T02:01:36.654Z", + "capability": "reasoning-content" +} diff --git a/packages/inference-discovery-openai/sessions/openai-responses/gpt-6.1-sol/function-calling-multi-turn/dispatches/0-get_weather.json b/packages/inference-discovery-openai/sessions/openai-responses/gpt-6.1-sol/function-calling-multi-turn/dispatches/0-get_weather.json new file mode 100644 index 000000000..21f38181b --- /dev/null +++ b/packages/inference-discovery-openai/sessions/openai-responses/gpt-6.1-sol/function-calling-multi-turn/dispatches/0-get_weather.json @@ -0,0 +1,6 @@ +{ + "args": { + "location": "Boston, MA" + }, + "result": "{\"location\":\"Boston, MA\",\"temperatureF\":68,\"conditions\":\"clear\"}" +} diff --git a/packages/inference-discovery-openai/sessions/openai-responses/gpt-6.1-sol/function-calling-multi-turn/exchanges/0/request-headers.json b/packages/inference-discovery-openai/sessions/openai-responses/gpt-6.1-sol/function-calling-multi-turn/exchanges/0/request-headers.json new file mode 100644 index 000000000..28c14bb85 --- /dev/null +++ b/packages/inference-discovery-openai/sessions/openai-responses/gpt-6.1-sol/function-calling-multi-turn/exchanges/0/request-headers.json @@ -0,0 +1,4 @@ +{ + "Content-Type": "application/json", + "Authorization": "" +} diff --git a/packages/inference-discovery-openai/sessions/openai-responses/gpt-6.1-sol/function-calling-multi-turn/exchanges/0/request.json b/packages/inference-discovery-openai/sessions/openai-responses/gpt-6.1-sol/function-calling-multi-turn/exchanges/0/request.json new file mode 100644 index 000000000..86768cced --- /dev/null +++ b/packages/inference-discovery-openai/sessions/openai-responses/gpt-6.1-sol/function-calling-multi-turn/exchanges/0/request.json @@ -0,0 +1,30 @@ +{ + "model": "gpt-6.1-sol", + "input": [ + { + "type": "message", + "role": "user", + "content": "What is the weather in Boston, MA? Use the provided tool." + } + ], + "tools": [ + { + "type": "function", + "name": "get_weather", + "description": "Look up the current weather for a city.", + "parameters": { + "type": "object", + "properties": { + "location": { + "type": "string", + "description": "City and optional region, e.g. 'Boston, MA'." + } + }, + "required": [ + "location" + ] + } + } + ], + "tool_choice": "auto" +} diff --git a/packages/inference-discovery-openai/sessions/openai-responses/gpt-6.1-sol/function-calling-multi-turn/exchanges/0/response-headers.json b/packages/inference-discovery-openai/sessions/openai-responses/gpt-6.1-sol/function-calling-multi-turn/exchanges/0/response-headers.json new file mode 100644 index 000000000..fbbaf735f --- /dev/null +++ b/packages/inference-discovery-openai/sessions/openai-responses/gpt-6.1-sol/function-calling-multi-turn/exchanges/0/response-headers.json @@ -0,0 +1,26 @@ +{ + "access-control-expose-headers": "X-Request-ID, Server-Timing-Total, CF-Ray, CF-Ray", + "alt-svc": "h3=\":443\"; ma=86400", + "cf-cache-status": "DYNAMIC", + "cf-ray": "a52f121e4aa96a29-LAX", + "connection": "keep-alive", + "content-encoding": "br", + "content-type": "application/json", + "date": "Sat, 31 Oct 2026 02:01:17 GMT", + "openai-organization": "", + "openai-processing-ms": "2086", + "openai-project": "", + "openai-version": "2020-10-01", + "server": "cloudflare", + "strict-transport-security": "max-age=31536000; includeSubDomains; preload", + "transfer-encoding": "chunked", + "x-content-type-options": "nosniff", + "x-ratelimit-limit-requests": "5000", + "x-ratelimit-limit-tokens": "1000000", + "x-ratelimit-remaining-requests": "4999", + "x-ratelimit-remaining-tokens": "1000000", + "x-ratelimit-reset-requests": "12ms", + "x-ratelimit-reset-tokens": "0s", + "x-request-id": "", + "set-cookie": "" +} diff --git a/packages/inference-discovery-openai/sessions/openai-responses/gpt-6.1-sol/function-calling-multi-turn/exchanges/0/response.json b/packages/inference-discovery-openai/sessions/openai-responses/gpt-6.1-sol/function-calling-multi-turn/exchanges/0/response.json new file mode 100644 index 000000000..8f7f11e4d --- /dev/null +++ b/packages/inference-discovery-openai/sessions/openai-responses/gpt-6.1-sol/function-calling-multi-turn/exchanges/0/response.json @@ -0,0 +1,109 @@ +{ + "id": "resp_00ad7cef37861379006ae54beb58e087d08401e1f07f2c6347", + "object": "response", + "created_at": 1793412075, + "status": "completed", + "access_programs": null, + "background": false, + "billing": { + "payer": "developer" + }, + "completed_at": 1793412077, + "error": null, + "frequency_penalty": 0.0, + "incomplete_details": null, + "instructions": null, + "max_output_tokens": null, + "max_tool_calls": null, + "model": "gpt-6.1-sol", + "moderation": null, + "output": [ + { + "id": "fc_00ad7cef37861379006ae54becc0c887d0a92c7b816a9c8d76", + "type": "function_call", + "status": "completed", + "arguments": "{\"location\":\"Boston, MA\"}", + "call_id": "call_rljVy327w41CwpBYsMJLrZ6K", + "name": "get_weather" + } + ], + "parallel_tool_calls": true, + "presence_penalty": 0.0, + "previous_response_id": null, + "prompt_cache_key": null, + "prompt_cache_retention": "24h", + "reasoning": { + "context": "all_turns", + "effort": "medium", + "mode": "standard", + "summary": null + }, + "safety_identifier": null, + "service_tier": "default", + "store": true, + "temperature": 1.0, + "text": { + "format": { + "type": "text" + }, + "verbosity": "medium" + }, + "tool_choice": "auto", + "tool_usage": { + "image_gen": { + "input_tokens": 0, + "input_tokens_details": { + "image_tokens": 0, + "text_tokens": 0 + }, + "output_tokens": 0, + "output_tokens_details": { + "image_tokens": 0, + "text_tokens": 0 + }, + "total_tokens": 0 + }, + "web_search": { + "num_requests": 0 + } + }, + "tools": [ + { + "type": "function", + "description": "Look up the current weather for a city.", + "name": "get_weather", + "output_schema": null, + "parameters": { + "type": "object", + "properties": { + "location": { + "type": "string", + "description": "City and optional region, e.g. 'Boston, MA'." + } + }, + "required": [ + "location" + ], + "additionalProperties": false + }, + "strict": true + } + ], + "top_logprobs": 0, + "top_p": 0.98, + "truncation": "disabled", + "usage": { + "input_tokens": 73, + "input_tokens_details": { + "cache_write_tokens": 0, + "cached_tokens": 0 + }, + "output_tokens": 20, + "output_tokens_details": { + "reasoning_tokens": 0 + }, + "total_tokens": 93 + }, + "user": null, + "metadata": {} +} \ No newline at end of file diff --git a/packages/inference-discovery-openai/sessions/openai-responses/gpt-6.1-sol/function-calling-multi-turn/exchanges/1/request-headers.json b/packages/inference-discovery-openai/sessions/openai-responses/gpt-6.1-sol/function-calling-multi-turn/exchanges/1/request-headers.json new file mode 100644 index 000000000..28c14bb85 --- /dev/null +++ b/packages/inference-discovery-openai/sessions/openai-responses/gpt-6.1-sol/function-calling-multi-turn/exchanges/1/request-headers.json @@ -0,0 +1,4 @@ +{ + "Content-Type": "application/json", + "Authorization": "" +} diff --git a/packages/inference-discovery-openai/sessions/openai-responses/gpt-6.1-sol/function-calling-multi-turn/exchanges/1/request.json b/packages/inference-discovery-openai/sessions/openai-responses/gpt-6.1-sol/function-calling-multi-turn/exchanges/1/request.json new file mode 100644 index 000000000..227569330 --- /dev/null +++ b/packages/inference-discovery-openai/sessions/openai-responses/gpt-6.1-sol/function-calling-multi-turn/exchanges/1/request.json @@ -0,0 +1,45 @@ +{ + "model": "gpt-6.1-sol", + "input": [ + { + "type": "message", + "role": "user", + "content": "What is the weather in Boston, MA? Use the provided tool." + }, + { + "type": "function_call", + "call_id": "call_rljVy327w41CwpBYsMJLrZ6K", + "name": "get_weather", + "arguments": "{\"location\":\"Boston, MA\"}" + }, + { + "type": "function_call_output", + "call_id": "call_rljVy327w41CwpBYsMJLrZ6K", + "output": "{\"location\":\"Boston, MA\",\"temperatureF\":68,\"conditions\":\"clear\"}" + } + ], + "store": false, + "include": [ + "reasoning.encrypted_content" + ], + "tools": [ + { + "type": "function", + "name": "get_weather", + "description": "Look up the current weather for a city.", + "parameters": { + "type": "object", + "properties": { + "location": { + "type": "string", + "description": "City and optional region, e.g. 'Boston, MA'." + } + }, + "required": [ + "location" + ] + } + } + ], + "tool_choice": "auto" +} diff --git a/packages/inference-discovery-openai/sessions/openai-responses/gpt-6.1-sol/function-calling-multi-turn/exchanges/1/response-headers.json b/packages/inference-discovery-openai/sessions/openai-responses/gpt-6.1-sol/function-calling-multi-turn/exchanges/1/response-headers.json new file mode 100644 index 000000000..94b4b6dec --- /dev/null +++ b/packages/inference-discovery-openai/sessions/openai-responses/gpt-6.1-sol/function-calling-multi-turn/exchanges/1/response-headers.json @@ -0,0 +1,26 @@ +{ + "access-control-expose-headers": "X-Request-ID, Server-Timing-Total, CF-Ray, CF-Ray", + "alt-svc": "h3=\":443\"; ma=86400", + "cf-cache-status": "DYNAMIC", + "cf-ray": "a52f122c1e756a29-LAX", + "connection": "keep-alive", + "content-encoding": "br", + "content-type": "application/json", + "date": "Sat, 31 Oct 2026 02:01:19 GMT", + "openai-organization": "", + "openai-processing-ms": "1593", + "openai-project": "", + "openai-version": "2020-10-01", + "server": "cloudflare", + "strict-transport-security": "max-age=31536000; includeSubDomains; preload", + "transfer-encoding": "chunked", + "x-content-type-options": "nosniff", + "x-ratelimit-limit-requests": "5000", + "x-ratelimit-limit-tokens": "1000000", + "x-ratelimit-remaining-requests": "4999", + "x-ratelimit-remaining-tokens": "1000000", + "x-ratelimit-reset-requests": "12ms", + "x-ratelimit-reset-tokens": "0s", + "x-request-id": "", + "set-cookie": "" +} diff --git a/packages/inference-discovery-openai/sessions/openai-responses/gpt-6.1-sol/function-calling-multi-turn/exchanges/1/response.json b/packages/inference-discovery-openai/sessions/openai-responses/gpt-6.1-sol/function-calling-multi-turn/exchanges/1/response.json new file mode 100644 index 000000000..24faa5b54 --- /dev/null +++ b/packages/inference-discovery-openai/sessions/openai-responses/gpt-6.1-sol/function-calling-multi-turn/exchanges/1/response.json @@ -0,0 +1,116 @@ +{ + "id": "resp_002c4aa69c3f3283016ae54bed840487d098b213700823ff7e", + "object": "response", + "created_at": 1793412077, + "status": "completed", + "access_programs": null, + "background": false, + "billing": { + "payer": "developer" + }, + "completed_at": 1793412079, + "error": null, + "frequency_penalty": 0.0, + "incomplete_details": null, + "instructions": null, + "max_output_tokens": null, + "max_tool_calls": null, + "model": "gpt-6.1-sol", + "moderation": null, + "output": [ + { + "id": "msg_002c4aa69c3f3283016ae54bee5fa887d089527d91ec0b5718", + "type": "message", + "status": "completed", + "content": [ + { + "type": "output_text", + "annotations": [], + "logprobs": [], + "text": "It\u2019s currently 68\u00b0F and clear in Boston, MA." + } + ], + "phase": "final_answer", + "role": "assistant" + } + ], + "parallel_tool_calls": true, + "presence_penalty": 0.0, + "previous_response_id": null, + "prompt_cache_key": null, + "prompt_cache_retention": "24h", + "reasoning": { + "context": "all_turns", + "effort": "medium", + "mode": "standard", + "summary": null + }, + "safety_identifier": null, + "service_tier": "default", + "store": false, + "temperature": 1.0, + "text": { + "format": { + "type": "text" + }, + "verbosity": "medium" + }, + "tool_choice": "auto", + "tool_usage": { + "image_gen": { + "input_tokens": 0, + "input_tokens_details": { + "image_tokens": 0, + "text_tokens": 0 + }, + "output_tokens": 0, + "output_tokens_details": { + "image_tokens": 0, + "text_tokens": 0 + }, + "total_tokens": 0 + }, + "web_search": { + "num_requests": 0 + } + }, + "tools": [ + { + "type": "function", + "description": "Look up the current weather for a city.", + "name": "get_weather", + "output_schema": null, + "parameters": { + "type": "object", + "properties": { + "location": { + "type": "string", + "description": "City and optional region, e.g. 'Boston, MA'." + } + }, + "required": [ + "location" + ], + "additionalProperties": false + }, + "strict": true + } + ], + "top_logprobs": 0, + "top_p": 0.98, + "truncation": "disabled", + "usage": { + "input_tokens": 120, + "input_tokens_details": { + "cache_write_tokens": 0, + "cached_tokens": 0 + }, + "output_tokens": 17, + "output_tokens_details": { + "reasoning_tokens": 0 + }, + "total_tokens": 137 + }, + "user": null, + "metadata": {} +} \ No newline at end of file diff --git a/packages/inference-discovery-openai/sessions/openai-responses/gpt-6.1-sol/function-calling-multi-turn/session.json b/packages/inference-discovery-openai/sessions/openai-responses/gpt-6.1-sol/function-calling-multi-turn/session.json new file mode 100644 index 000000000..c3d567f92 --- /dev/null +++ b/packages/inference-discovery-openai/sessions/openai-responses/gpt-6.1-sol/function-calling-multi-turn/session.json @@ -0,0 +1,11 @@ +{ + "schemaVersion": "2", + "source": { + "provider": "openai-responses", + "model": "gpt-6.1-sol", + "baseURL": "https://api.openai.com/v1" + }, + "origin": "live", + "capturedAt": "2026-10-31T02:01:19.124Z", + "capability": "function-calling-multi-turn" +} diff --git a/packages/inference-discovery-openai/sessions/openai-responses/gpt-6.1-sol/plain-text-streaming/exchanges/0/request-headers.json b/packages/inference-discovery-openai/sessions/openai-responses/gpt-6.1-sol/plain-text-streaming/exchanges/0/request-headers.json new file mode 100644 index 000000000..28c14bb85 --- /dev/null +++ b/packages/inference-discovery-openai/sessions/openai-responses/gpt-6.1-sol/plain-text-streaming/exchanges/0/request-headers.json @@ -0,0 +1,4 @@ +{ + "Content-Type": "application/json", + "Authorization": "" +} diff --git a/packages/inference-discovery-openai/sessions/openai-responses/gpt-6.1-sol/plain-text-streaming/exchanges/0/request.json b/packages/inference-discovery-openai/sessions/openai-responses/gpt-6.1-sol/plain-text-streaming/exchanges/0/request.json new file mode 100644 index 000000000..78b979aa2 --- /dev/null +++ b/packages/inference-discovery-openai/sessions/openai-responses/gpt-6.1-sol/plain-text-streaming/exchanges/0/request.json @@ -0,0 +1,11 @@ +{ + "model": "gpt-6.1-sol", + "input": [ + { + "type": "message", + "role": "user", + "content": "Reply with a single sentence: the capital of France is Paris." + } + ], + "stream": true +} diff --git a/packages/inference-discovery-openai/sessions/openai-responses/gpt-6.1-sol/plain-text-streaming/exchanges/0/response-headers.json b/packages/inference-discovery-openai/sessions/openai-responses/gpt-6.1-sol/plain-text-streaming/exchanges/0/response-headers.json new file mode 100644 index 000000000..563761f70 --- /dev/null +++ b/packages/inference-discovery-openai/sessions/openai-responses/gpt-6.1-sol/plain-text-streaming/exchanges/0/response-headers.json @@ -0,0 +1,25 @@ +{ + "access-control-expose-headers": "X-Request-ID, Server-Timing-Total, CF-Ray, CF-Ray", + "alt-svc": "h3=\":443\"; ma=86400", + "cf-cache-status": "DYNAMIC", + "cf-ray": "a5281a5d1e7ea0bf-LAX", + "connection": "keep-alive", + "content-type": "text/event-stream; charset=utf-8", + "date": "Fri, 30 Oct 2026 05:43:33 GMT", + "openai-organization": "", + "openai-processing-ms": "474", + "openai-project": "", + "openai-version": "2020-10-01", + "server": "cloudflare", + "strict-transport-security": "max-age=31536000; includeSubDomains; preload", + "transfer-encoding": "chunked", + "x-content-type-options": "nosniff", + "x-ratelimit-limit-requests": "5000", + "x-ratelimit-limit-tokens": "1000000", + "x-ratelimit-remaining-requests": "4999", + "x-ratelimit-remaining-tokens": "999838", + "x-ratelimit-reset-requests": "12ms", + "x-ratelimit-reset-tokens": "9ms", + "x-request-id": "", + "set-cookie": "" +} diff --git a/packages/inference-discovery-openai/sessions/openai-responses/gpt-6.1-sol/plain-text-streaming/exchanges/0/response.sse b/packages/inference-discovery-openai/sessions/openai-responses/gpt-6.1-sol/plain-text-streaming/exchanges/0/response.sse new file mode 100644 index 000000000..70143f52d --- /dev/null +++ b/packages/inference-discovery-openai/sessions/openai-responses/gpt-6.1-sol/plain-text-streaming/exchanges/0/response.sse @@ -0,0 +1,51 @@ +event: response.created +data: {"type":"response.created","response":{"id":"resp_019bd57f1b7e5233006ae42e84c0d487d0bf4b025ae3d3943a","object":"response","created_at":1793339012,"status":"in_progress","access_programs":null,"background":false,"completed_at":null,"error":null,"frequency_penalty":0.0,"incomplete_details":null,"instructions":null,"max_output_tokens":null,"max_tool_calls":null,"model":"gpt-6.1-sol","moderation":null,"output":[],"parallel_tool_calls":true,"presence_penalty":0.0,"previous_response_id":null,"prompt_cache_key":null,"prompt_cache_retention":"24h","reasoning":{"context":"all_turns","effort":"medium","mode":"standard","summary":null},"safety_identifier":null,"service_tier":"auto","store":true,"temperature":1.0,"text":{"format":{"type":"text"},"verbosity":"medium"},"tool_choice":"auto","tool_usage":{"image_gen":{"input_tokens":0,"input_tokens_details":{"image_tokens":0,"text_tokens":0},"output_tokens":0,"output_tokens_details":{"image_tokens":0,"text_tokens":0},"total_tokens":0},"web_search":{"num_requests":0}},"tools":[],"top_logprobs":0,"top_p":0.98,"truncation":"disabled","usage":null,"user":null,"metadata":{}},"sequence_number":0} + +event: response.in_progress +data: {"type":"response.in_progress","response":{"id":"resp_019bd57f1b7e5233006ae42e84c0d487d0bf4b025ae3d3943a","object":"response","created_at":1793339012,"status":"in_progress","access_programs":null,"background":false,"completed_at":null,"error":null,"frequency_penalty":0.0,"incomplete_details":null,"instructions":null,"max_output_tokens":null,"max_tool_calls":null,"model":"gpt-6.1-sol","moderation":null,"output":[],"parallel_tool_calls":true,"presence_penalty":0.0,"previous_response_id":null,"prompt_cache_key":null,"prompt_cache_retention":"24h","reasoning":{"context":"all_turns","effort":"medium","mode":"standard","summary":null},"safety_identifier":null,"service_tier":"auto","store":true,"temperature":1.0,"text":{"format":{"type":"text"},"verbosity":"medium"},"tool_choice":"auto","tool_usage":{"image_gen":{"input_tokens":0,"input_tokens_details":{"image_tokens":0,"text_tokens":0},"output_tokens":0,"output_tokens_details":{"image_tokens":0,"text_tokens":0},"total_tokens":0},"web_search":{"num_requests":0}},"tools":[],"top_logprobs":0,"top_p":0.98,"truncation":"disabled","usage":null,"user":null,"metadata":{}},"sequence_number":1} + +event: response.output_item.added +data: {"type":"response.output_item.added","item":{"id":"rs_019bd57f1b7e5233006ae42e85a7b487d0b9c480f041c931e4","type":"reasoning","content":[],"encrypted_content":"gAAAAABq5C6FZUlVBOq4LyAfuhQZfBUBiVU4z0nTLGQ0dhxd9tt2_MdRqTvs47ilmT0_6XGGJ5e705on4ypOJUWUwP9zXhVM_GiDydas4ui0M8y7NNjPTdn4zT7HXIZ7fGxaH8pvvg-uhUyuT8flkE-zY_e5GSwQQ77NO5aqdG6L_UKO5OJOcd3WAnVOG1oGjWEOMwk8yzjWIiUad0ocgL-uRYp74loZMm1msVlyfugKigfjTSPkbgvtPrHGjuxf1YbzEsf6S3yHoy5ZDGoIeYOZbXniiD_uJmFo_EXVC8JRYAg7w6KkMKw6KJ6TQNRL7mw4s4HjgFJCj3cj8HEr6d9Yl-p8NFeZ26FDNoi_IbfEmE-l_VplI9gD0zxc2dImTQnuuZbOsJkugn8X7ahR7BY4ycYRcFB3YUecxAwtuyipPFMXIiSCkIZbO9YMS5C-FF2QWx0Xq6tIX0OZsg1oqmW8Z_IaASxDM7gQLtLM3_NQSnIeIM9IWHMlYed9PHmdp_yyXZwpAfbzxQ4gHArtkvdqKN_UOb5I0dlsz32J1Q_2JubFwv_ygWijtcoSXx2RE1ZtaX0TUFeZzVoknuGWVaRXZvplirNqFqb5CKYHqaY2Vv_MvJu34oIPZNWQKD5elp0-xsHw3NCK0zuhS-Rn8wuM_GdUVnvQGN5Q9OqD7ZCRgE9xG0qfYHZ0CGs0e8DsEk_LXtBqqKnknH8WQab3jJj3LhsenpCMYQGETyzsf58lig4HOpp18HaLKadsZQqTKrmZqlbgNVqWFMc7CVuGqYsfD0YH-iNpRhQ6v_k66JWsQ_8kNmNeGuuPmZjIi6aLyHP56NuO_3yhfJv440OnGbPVPcX7cuGKonkYYG_QVRgo009DOQOmU6JzG8Jsyiazwz5xNKxHni28DxekVKOvonpqQdKmchD-UJsZCZlRz0usJbi66XMwOHsTBTxvk8HE4_NSTmmhBcHI0gNNfTaPHCXU5WmevsKxT_EXS2AZi1KJuEXO_BYy78FlAicHXLCO7vWDk2YtFK6jF61yprTkWy9du-BNBwYmPd5u75Id1MWPJ01fITqjSQ7LETYg2hduKnJbSNGVJh66gp0zdj5toqiGf-kdqwJ8O0AGLQU1GasWMSRj4HNaJG5hmCux1nqHOeBOt43lkLBF6AB2UIJAA_EJWLm6NreoVr0JrZTLAF9LPyosB-Dip3gMi2HG00FpjQDDQIq445FN","summary":[]},"output_index":0,"sequence_number":2} + +event: response.output_item.done +data: {"type":"response.output_item.done","item":{"id":"rs_019bd57f1b7e5233006ae42e85a7b487d0b9c480f041c931e4","type":"reasoning","content":[],"encrypted_content":"gAAAAABq5C6GYIhmnwtZfLF-4RHIPl-V_THy2UHCMo5ZMU2LNRwJllB_9GP5liZqrdWZn077fjCFZUOPwEZRrCg9BVqrBCV6WwD_WcreGYm2qH3A00ewHfcUTRhlci7mm8Pfwo1TNO5blyjISgq_3XITKYK6sEQHH3tKeWsO36jeILIXiIF8h7iNC9CEbOxndWw5HpLrycvawvxKkek9SAWqqoOgNU1aDUmos_0zq7LDeIchN5p9kGBlOGgxDnUNiQOLQEdk_4ykY3nkQI3uxiI_uC9t5tuD91sEhNaYSm7Ct_6HAZgcNPW439I5Cb1VpPJY3fE36nnAT6BlQwMZVwR3ZBic-IWBjfJ7oLL8qDdhVw3ABTK0Xp1CYN89YnuA9jK--url0idoOMm6-LHt-x1gDjO3_3-sTXa84a6A0TnjKJPoQ8lCXcx4EeO0KaTahWxZivPyp88-KiiDioWE73GLpFRPwHqeajDzKYgxnZdu1Tu9eNkgzoZA_ebKKt-VdIFy-f46z-mxq3E_Nfb89lALIO6LqQIRT6P-ydHaUExRxL8QOoaQA0Jkkfg16if7R5Y2G2oOpiW8P2Fos9Rg94thi7_sM_ax7V6XdNMzX76aJASTr7HnQRvr97ciKO6NfMUBj6uXe8SUTPJuHNDzHL5a2nuUidn0kEESDt0KUyFDcAupuBmYJ_q-k4OUcgkBxlYI_bAkInU8AHQnBwf4vN6YKHdbu_MVcdEIFlM8kl4YuDsOGCbGzdpHEsteXv27srNiUifn85trs-HIqFcuOfqhraKa6NH3JeFF12MPlz0DaG21D622x0Wii1fENtZPmgRZkXF47fhv_ta0wSaENcdGHyXAjVbCHTxow1Lsxb6P5ZCVLv48aMgkdPoePGkxrmtJev8hKMUna51zBQ0Y91lndss64zz_XCK4YJwyPIUL0QQcR1HrFbWDT74YnQR9c7GLCRsh3Ju6V3tJDrsOChi3qx5-CllCDBP7-M26bRn8ZsgZTiVZILja6eP31OFp4p4TXwJ7fcTMcw00KNHooBEeT1JEKwUO3x-6aT1dkHZUccmddIkDNPeQgD_MNdqyBjGCmBWHO-po0nt1KzL4fKrTW1L-USWBm9zTPkrbwuq2-KbGnREJz9Vfs95TWJKtFa3muzk0xCUEBu6lxzM5cKrwj81WOjQQ1TZz8XKQFWqC5ggTMkOoHuDhvd9g7eWcvWOrM_x7XB4xO1vOuvNbuaNKmYuuGRBNjfV47kkv2e2lewCOlo62DeioQnnqX28P12hopnX1_rlr1dvUOIVvS92VATjIL9DrO3gWnLUGYSaUQgBAUe3No4nR6c1Z0qp6dGuf_MnxXJehi7j4F75F76ue6pSgVZuQGU9NmwQuFB9YhJayMXggpTYKkLqikOWfbGiJ3R0wfOwM0IRBDqNWtiRxei4gSu6aLc6q2_46_d85O-HhlsWaXDJLN1Hb4w0UuewFp2WkqGkbWm00pOZ5bjA5Nid84Qbcg53C-KOS33ZrdT9JZVw1Qs3os7DDJ7eIYyixEF2NygRU0SNDDFbfHl9v9z3wXQjs3KyKOT6zGXvjVS_D5jM1c_n1V5aYrXfnVOAPVeyjArByH1YsSKC0mwPVHvFliCxIbpjsMPfIqz_Y4ySH60gFBcgjsJVpUDmyxsKJLWT3nW5Z9K6d2x27Cb8UxEV1NCd6d-6J0H93bmksF8d5WNLYuDw0n2T0Q_VJvCOT951b1wWWnhCmSCWvgJoxn-AZ2WbLq4PAgwKJcvUnCQkZiymH4NmtXmUtgPiqun_TWtWpQkuPvtQELJaqeSgd3jrIyfLEbEMp4gWCOi6qRYdDsgSO6os=","summary":[]},"output_index":0,"sequence_number":3} + +event: response.output_item.added +data: {"type":"response.output_item.added","item":{"id":"msg_019bd57f1b7e5233006ae42e8637c087d09d9c99575973f818","type":"message","status":"in_progress","content":[],"phase":"final_answer","role":"assistant"},"output_index":1,"sequence_number":4} + +event: response.content_part.added +data: {"type":"response.content_part.added","content_index":0,"item_id":"msg_019bd57f1b7e5233006ae42e8637c087d09d9c99575973f818","output_index":1,"part":{"type":"output_text","annotations":[],"logprobs":[],"text":""},"sequence_number":5} + +event: response.output_text.delta +data: {"type":"response.output_text.delta","content_index":0,"delta":"The","item_id":"msg_019bd57f1b7e5233006ae42e8637c087d09d9c99575973f818","logprobs":[],"obfuscation":"9SVa2JAew9MgJ","output_index":1,"sequence_number":6} + +event: response.output_text.delta +data: {"type":"response.output_text.delta","content_index":0,"delta":" capital","item_id":"msg_019bd57f1b7e5233006ae42e8637c087d09d9c99575973f818","logprobs":[],"obfuscation":"i2om1vRf","output_index":1,"sequence_number":7} + +event: response.output_text.delta +data: {"type":"response.output_text.delta","content_index":0,"delta":" of","item_id":"msg_019bd57f1b7e5233006ae42e8637c087d09d9c99575973f818","logprobs":[],"obfuscation":"jrbCM8j4Z0mdC","output_index":1,"sequence_number":8} + +event: response.output_text.delta +data: {"type":"response.output_text.delta","content_index":0,"delta":" France","item_id":"msg_019bd57f1b7e5233006ae42e8637c087d09d9c99575973f818","logprobs":[],"obfuscation":"D1V7nNDRV","output_index":1,"sequence_number":9} + +event: response.output_text.delta +data: {"type":"response.output_text.delta","content_index":0,"delta":" is","item_id":"msg_019bd57f1b7e5233006ae42e8637c087d09d9c99575973f818","logprobs":[],"obfuscation":"nfZj4ZMKOnG8I","output_index":1,"sequence_number":10} + +event: response.output_text.delta +data: {"type":"response.output_text.delta","content_index":0,"delta":" Paris","item_id":"msg_019bd57f1b7e5233006ae42e8637c087d09d9c99575973f818","logprobs":[],"obfuscation":"G8cljyS3z6","output_index":1,"sequence_number":11} + +event: response.output_text.delta +data: {"type":"response.output_text.delta","content_index":0,"delta":".","item_id":"msg_019bd57f1b7e5233006ae42e8637c087d09d9c99575973f818","logprobs":[],"obfuscation":"mrq7vbBuKEct8tV","output_index":1,"sequence_number":12} + +event: response.output_text.done +data: {"type":"response.output_text.done","content_index":0,"item_id":"msg_019bd57f1b7e5233006ae42e8637c087d09d9c99575973f818","logprobs":[],"output_index":1,"sequence_number":13,"text":"The capital of France is Paris."} + +event: response.content_part.done +data: {"type":"response.content_part.done","content_index":0,"item_id":"msg_019bd57f1b7e5233006ae42e8637c087d09d9c99575973f818","output_index":1,"part":{"type":"output_text","annotations":[],"logprobs":[],"text":"The capital of France is Paris."},"sequence_number":14} + +event: response.output_item.done +data: {"type":"response.output_item.done","item":{"id":"msg_019bd57f1b7e5233006ae42e8637c087d09d9c99575973f818","type":"message","status":"completed","content":[{"type":"output_text","annotations":[],"logprobs":[],"text":"The capital of France is Paris."}],"phase":"final_answer","role":"assistant"},"output_index":1,"sequence_number":15} + +event: response.completed +data: {"type":"response.completed","response":{"id":"resp_019bd57f1b7e5233006ae42e84c0d487d0bf4b025ae3d3943a","object":"response","created_at":1793339012,"status":"completed","access_programs":null,"background":false,"completed_at":1793339014,"error":null,"frequency_penalty":0.0,"incomplete_details":null,"instructions":null,"max_output_tokens":null,"max_tool_calls":null,"model":"gpt-6.1-sol","moderation":null,"output":[{"id":"rs_019bd57f1b7e5233006ae42e85a7b487d0b9c480f041c931e4","type":"reasoning","content":[],"encrypted_content":"gAAAAABq5C6GUvisILn5bvloSMi_LhsBZknBz5OeFTlJWcreGx9_0uqjWudvgktXL2fehmNF79ft4huc0j1IfvXfxARjZIwMwX7dxL-LsLSrF5bwEYzkoBfw6V2KhOTX2Tw-lWpnqbZIvSHnkuWpRUjiw26oJsU3WXWL9qFQo1PANcz_NuZ9Oxeyh631n0Fqe0zd53-F8NNT17i_ApQH5_ujutFTHcGUW9Y73TTtHDTD1bScxPkW7ZzGoP9JJfkT3B9Ay7lUv9GP_3obNf7p32_NntsHerx7_t6TaDTRkhjMDlRE02yf14ZJCtvQOi3x8my4ivTuA6nguFHOUjwcjyhmgb-y0teyhjQX2SI-zQ-OJO7eayYW_G0SO5QTWK-0Ef_vkCIhQh1leh9JQ1xBxOUiJDwEL8DLfP0fmk4YNuJzFOnWbihK152hVDddMNBWCsws52HrXNwaOwIZqUk1LxmaDrEtAA2Ai3_t_w1wTCX2lBM4WSv6ew1Am0atqwodSgqlJZMShGEUZycJHHrgUYX_64hem4DciFilhwIqqU95TK6GzIfyBIg6aAa9KQ1ByA_qpR0BAalfodmb-OvP4mnObMZ6fg9yez7WR1MPwpmx5Hr5DqbaNPrdCMjRND78OEOwNv0kF8Ps2hdXz3VXQ7HG8zN1sTLcZTCsVrvXWuJYt8Lxg2xk45-N7ACyimxotbEx-K_1VsdP0JFVdEnj3vaaOCvES1LPtuy7jcPHGYpPnUPzaiAJKruZVrJMpck0ridn1iK5_7Kt0Qyw7gOICQ74iQBiatZYjM5d4cHdk9LyRiuRs15ErWiXI3u4f0ymf-GqDrYTTIxN9EAVkPruMF4vD1P6es42ZhIglPIv_n1BxWls2w1Pwig-y8-KAp3uOR8l1GXVspVsGRDXRqxD0J-lHc37h_gwdLoNPdZLqZzgP-cTR70vU7sI5qo8hOOqL17jksNl1zbz55uB3Tn81SuRUjPq1awOj5WoE95r6kYPf1mEEvfhPasTijLVhuZ5AM_NrYQegoTiYCUSG_oykLyhreXC7cYW9P2giqMmfjgBhyr3QMeQI_eIAhpu00u1wh6Qm69NR6j-ofd-_Kc2PTdZLijM2cR7RomQBTZOrXcOckSesc8JehnOK5CrhQbYWnY6DfBZ73q_H0fFoUgSYP663tXyE9m42ac9OpjIZuw7swiFZCrWUQspK7ZWFuznjXdSASllsmAKePeAN1CXi40ozqWPf51FRbpkslXP4dnOrXZTfaGWu3aDA48qFkVcAf4Hd4CSOOLCDF7e-FpxJpPGNbCUpQFNmmgwxE1iImGe98MZarNDvhGTUFj0Y-sSd5J_js_aDhqk2wsNAav207lED9zxd42h3qAHu2vLjulUHulYh4TJ_sRD7X3yuGw1dbL05BQvCz3PylLavmuYCUYrQHYoFoidldG6YvLozn4K2EO_qhEnP9p5HsnfnAEbngH5GR3wPOM-7LizKM8Jdam9qNodZEndEsAuUsBdfl2oHrLD1pYyYfbpEexiaJBWshSTCFkhXaju0yO1Qsmo_dgEngTn-F3aLyablUIaiqaCqT7DcTaxMVUS7ArLtlwStS8RJ2LYQ7_URa5aabioGZgPNCeAH7Uwqi32BJrpCmzHl2JbGySd0YO8hGEPjWw000LuoOZbIVE0KrFFMGScrH02dQiZ-0UVHqbQNBDSqCCDGXnlQCWbdko1S2gQ-LjkynXly9jFFvZJBw1UYJOcjy8Z4QEux6yiNoJ-zpglbAiR1WzFoIkyd6jLWhu23ZU1o3DBSyvDtCpo9hppnLk3O0EDYYZ-5h3JeLp9bSls4bz5u0eTsXXgXh4=","summary":[]},{"id":"msg_019bd57f1b7e5233006ae42e8637c087d09d9c99575973f818","type":"message","status":"completed","content":[{"type":"output_text","annotations":[],"logprobs":[],"text":"The capital of France is Paris."}],"phase":"final_answer","role":"assistant"}],"parallel_tool_calls":true,"presence_penalty":0.0,"previous_response_id":null,"prompt_cache_key":null,"prompt_cache_retention":"24h","reasoning":{"context":"all_turns","effort":"medium","mode":"standard","summary":null},"safety_identifier":null,"service_tier":"default","store":true,"temperature":1.0,"text":{"format":{"type":"text"},"verbosity":"medium"},"tool_choice":"auto","tool_usage":{"image_gen":{"input_tokens":0,"input_tokens_details":{"image_tokens":0,"text_tokens":0},"output_tokens":0,"output_tokens_details":{"image_tokens":0,"text_tokens":0},"total_tokens":0},"web_search":{"num_requests":0}},"tools":[],"top_logprobs":0,"top_p":0.98,"truncation":"disabled","usage":{"input_tokens":19,"input_tokens_details":{"cache_write_tokens":0,"cached_tokens":0},"output_tokens":43,"output_tokens_details":{"reasoning_tokens":30},"total_tokens":62},"user":null,"metadata":{}},"sequence_number":16} + diff --git a/packages/inference-discovery-openai/sessions/openai-responses/gpt-6.1-sol/plain-text-streaming/session.json b/packages/inference-discovery-openai/sessions/openai-responses/gpt-6.1-sol/plain-text-streaming/session.json new file mode 100644 index 000000000..23c9e9237 --- /dev/null +++ b/packages/inference-discovery-openai/sessions/openai-responses/gpt-6.1-sol/plain-text-streaming/session.json @@ -0,0 +1,11 @@ +{ + "schemaVersion": "2", + "source": { + "provider": "openai-responses", + "model": "gpt-6.1-sol", + "baseURL": "https://api.openai.com/v1" + }, + "origin": "live", + "capturedAt": "2026-10-30T05:43:34.576Z", + "capability": "plain-text-streaming" +} diff --git a/packages/inference-discovery-openai/sessions/openai-responses/gpt-6.1-sol/plain-text/exchanges/0/request-headers.json b/packages/inference-discovery-openai/sessions/openai-responses/gpt-6.1-sol/plain-text/exchanges/0/request-headers.json new file mode 100644 index 000000000..28c14bb85 --- /dev/null +++ b/packages/inference-discovery-openai/sessions/openai-responses/gpt-6.1-sol/plain-text/exchanges/0/request-headers.json @@ -0,0 +1,4 @@ +{ + "Content-Type": "application/json", + "Authorization": "" +} diff --git a/packages/inference-discovery-openai/sessions/openai-responses/gpt-6.1-sol/plain-text/exchanges/0/request.json b/packages/inference-discovery-openai/sessions/openai-responses/gpt-6.1-sol/plain-text/exchanges/0/request.json new file mode 100644 index 000000000..bc2086e37 --- /dev/null +++ b/packages/inference-discovery-openai/sessions/openai-responses/gpt-6.1-sol/plain-text/exchanges/0/request.json @@ -0,0 +1,10 @@ +{ + "model": "gpt-6.1-sol", + "input": [ + { + "type": "message", + "role": "user", + "content": "Reply with a single sentence: the capital of France is Paris." + } + ] +} diff --git a/packages/inference-discovery-openai/sessions/openai-responses/gpt-6.1-sol/plain-text/exchanges/0/response-headers.json b/packages/inference-discovery-openai/sessions/openai-responses/gpt-6.1-sol/plain-text/exchanges/0/response-headers.json new file mode 100644 index 000000000..cc9c47724 --- /dev/null +++ b/packages/inference-discovery-openai/sessions/openai-responses/gpt-6.1-sol/plain-text/exchanges/0/response-headers.json @@ -0,0 +1,26 @@ +{ + "access-control-expose-headers": "X-Request-ID, Server-Timing-Total, CF-Ray, CF-Ray", + "alt-svc": "h3=\":443\"; ma=86400", + "cf-cache-status": "DYNAMIC", + "cf-ray": "a5281a536fada0bf-LAX", + "connection": "keep-alive", + "content-encoding": "br", + "content-type": "application/json", + "date": "Fri, 30 Oct 2026 05:43:32 GMT", + "openai-organization": "", + "openai-processing-ms": "1335", + "openai-project": "", + "openai-version": "2020-10-01", + "server": "cloudflare", + "strict-transport-security": "max-age=31536000; includeSubDomains; preload", + "transfer-encoding": "chunked", + "x-content-type-options": "nosniff", + "x-ratelimit-limit-requests": "5000", + "x-ratelimit-limit-tokens": "1000000", + "x-ratelimit-remaining-requests": "4999", + "x-ratelimit-remaining-tokens": "1000000", + "x-ratelimit-reset-requests": "12ms", + "x-ratelimit-reset-tokens": "0s", + "x-request-id": "", + "set-cookie": "" +} diff --git a/packages/inference-discovery-openai/sessions/openai-responses/gpt-6.1-sol/plain-text/exchanges/0/response.json b/packages/inference-discovery-openai/sessions/openai-responses/gpt-6.1-sol/plain-text/exchanges/0/response.json new file mode 100644 index 000000000..f85cc07aa --- /dev/null +++ b/packages/inference-discovery-openai/sessions/openai-responses/gpt-6.1-sol/plain-text/exchanges/0/response.json @@ -0,0 +1,95 @@ +{ + "id": "resp_03c1db281962fdcc006ae42e834b0487d0b2cdf8712a37119d", + "object": "response", + "created_at": 1793339011, + "status": "completed", + "access_programs": null, + "background": false, + "billing": { + "payer": "developer" + }, + "completed_at": 1793339012, + "error": null, + "frequency_penalty": 0.0, + "incomplete_details": null, + "instructions": null, + "max_output_tokens": null, + "max_tool_calls": null, + "model": "gpt-6.1-sol", + "moderation": null, + "output": [ + { + "id": "msg_03c1db281962fdcc006ae42e84369c87d089533a492f95f6b7", + "type": "message", + "status": "completed", + "content": [ + { + "type": "output_text", + "annotations": [], + "logprobs": [], + "text": "The capital of France is Paris." + } + ], + "phase": "final_answer", + "role": "assistant" + } + ], + "parallel_tool_calls": true, + "presence_penalty": 0.0, + "previous_response_id": null, + "prompt_cache_key": null, + "prompt_cache_retention": "24h", + "reasoning": { + "context": "all_turns", + "effort": "medium", + "mode": "standard", + "summary": null + }, + "safety_identifier": null, + "service_tier": "default", + "store": true, + "temperature": 1.0, + "text": { + "format": { + "type": "text" + }, + "verbosity": "medium" + }, + "tool_choice": "auto", + "tool_usage": { + "image_gen": { + "input_tokens": 0, + "input_tokens_details": { + "image_tokens": 0, + "text_tokens": 0 + }, + "output_tokens": 0, + "output_tokens_details": { + "image_tokens": 0, + "text_tokens": 0 + }, + "total_tokens": 0 + }, + "web_search": { + "num_requests": 0 + } + }, + "tools": [], + "top_logprobs": 0, + "top_p": 0.98, + "truncation": "disabled", + "usage": { + "input_tokens": 19, + "input_tokens_details": { + "cache_write_tokens": 0, + "cached_tokens": 0 + }, + "output_tokens": 11, + "output_tokens_details": { + "reasoning_tokens": 0 + }, + "total_tokens": 30 + }, + "user": null, + "metadata": {} +} \ No newline at end of file diff --git a/packages/inference-discovery-openai/sessions/openai-responses/gpt-6.1-sol/plain-text/session.json b/packages/inference-discovery-openai/sessions/openai-responses/gpt-6.1-sol/plain-text/session.json new file mode 100644 index 000000000..8b272fa5b --- /dev/null +++ b/packages/inference-discovery-openai/sessions/openai-responses/gpt-6.1-sol/plain-text/session.json @@ -0,0 +1,11 @@ +{ + "schemaVersion": "2", + "source": { + "provider": "openai-responses", + "model": "gpt-6.1-sol", + "baseURL": "https://api.openai.com/v1" + }, + "origin": "live", + "capturedAt": "2026-10-30T05:43:32.642Z", + "capability": "plain-text" +} diff --git a/packages/inference-discovery-openai/sessions/openai-responses/gpt-6.1-sol/reasoning-content/exchanges/0/request-headers.json b/packages/inference-discovery-openai/sessions/openai-responses/gpt-6.1-sol/reasoning-content/exchanges/0/request-headers.json new file mode 100644 index 000000000..28c14bb85 --- /dev/null +++ b/packages/inference-discovery-openai/sessions/openai-responses/gpt-6.1-sol/reasoning-content/exchanges/0/request-headers.json @@ -0,0 +1,4 @@ +{ + "Content-Type": "application/json", + "Authorization": "" +} diff --git a/packages/inference-discovery-openai/sessions/openai-responses/gpt-6.1-sol/reasoning-content/exchanges/0/request.json b/packages/inference-discovery-openai/sessions/openai-responses/gpt-6.1-sol/reasoning-content/exchanges/0/request.json new file mode 100644 index 000000000..fc6e10287 --- /dev/null +++ b/packages/inference-discovery-openai/sessions/openai-responses/gpt-6.1-sol/reasoning-content/exchanges/0/request.json @@ -0,0 +1,14 @@ +{ + "model": "gpt-6.1-sol", + "input": [ + { + "type": "message", + "role": "user", + "content": "A bat and a ball cost $1.10 together. The bat costs $1.00 more than the ball. How much does the ball cost? Show your reasoning before the final answer." + } + ], + "reasoning": { + "effort": "medium", + "summary": "detailed" + } +} diff --git a/packages/inference-discovery-openai/sessions/openai-responses/gpt-6.1-sol/reasoning-content/exchanges/0/response-headers.json b/packages/inference-discovery-openai/sessions/openai-responses/gpt-6.1-sol/reasoning-content/exchanges/0/response-headers.json new file mode 100644 index 000000000..234684684 --- /dev/null +++ b/packages/inference-discovery-openai/sessions/openai-responses/gpt-6.1-sol/reasoning-content/exchanges/0/response-headers.json @@ -0,0 +1,26 @@ +{ + "access-control-expose-headers": "X-Request-ID, Server-Timing-Total, CF-Ray, CF-Ray", + "alt-svc": "h3=\":443\"; ma=86400", + "cf-cache-status": "DYNAMIC", + "cf-ray": "a52f12369e886a29-LAX", + "connection": "keep-alive", + "content-encoding": "br", + "content-type": "application/json", + "date": "Sat, 31 Oct 2026 02:01:22 GMT", + "openai-organization": "", + "openai-processing-ms": "3189", + "openai-project": "", + "openai-version": "2020-10-01", + "server": "cloudflare", + "strict-transport-security": "max-age=31536000; includeSubDomains; preload", + "transfer-encoding": "chunked", + "x-content-type-options": "nosniff", + "x-ratelimit-limit-requests": "5000", + "x-ratelimit-limit-tokens": "1000000", + "x-ratelimit-remaining-requests": "4999", + "x-ratelimit-remaining-tokens": "1000000", + "x-ratelimit-reset-requests": "12ms", + "x-ratelimit-reset-tokens": "0s", + "x-request-id": "", + "set-cookie": "" +} diff --git a/packages/inference-discovery-openai/sessions/openai-responses/gpt-6.1-sol/reasoning-content/exchanges/0/response.json b/packages/inference-discovery-openai/sessions/openai-responses/gpt-6.1-sol/reasoning-content/exchanges/0/response.json new file mode 100644 index 000000000..740c4f39d --- /dev/null +++ b/packages/inference-discovery-openai/sessions/openai-responses/gpt-6.1-sol/reasoning-content/exchanges/0/response.json @@ -0,0 +1,107 @@ +{ + "id": "resp_05a6d27313fc952f006ae54bef397487d087a049ad1ca58448", + "object": "response", + "created_at": 1793412079, + "status": "completed", + "access_programs": null, + "background": false, + "billing": { + "payer": "developer" + }, + "completed_at": 1793412082, + "error": null, + "frequency_penalty": 0.0, + "incomplete_details": null, + "instructions": null, + "max_output_tokens": null, + "max_tool_calls": null, + "model": "gpt-6.1-sol", + "moderation": null, + "output": [ + { + "id": "rs_05a6d27313fc952f006ae54bf0092c87d08dbf77de28d920c9", + "type": "reasoning", + "content": [], + "encrypted_content": "gAAAAABq5Uvytc-03J3ka6UqtpTSBhqWtOPzg3tP9RVtpJcmWbaC6_ZOBOEW9Ayt-bzl-n9dI7wTkwE5AdqI_H3HekFn6tMCjs3e4-feRpna1tpJcBRo6-a15NG6pSUWxh6wblB_x7rkc6Jj5FHrXowcbRSxonA3WpHgCxpxbJm4X5sZrOBwCVkBheZSoLitNiM-9-m6Bv5qdyekltG2WVybE6AwC_Mdunsc_yUDXIDtwFo9UwL1BJpqclYdk86_MvochPSxerL0RNs8hfesJ6lbhVrImP7sX54n2W--Jnqeol7mkMjg4KGHakAShulfzD-dwKB672JEnXaI9O6QMNXmkFQJWTlBqVumsn2JAHzu9GP-HrCrKw_Y9XwG-4rC6SP9BUz0XvkG1Bv2Du6RtDv5m8g_D2zCvoD9qSKzkVJWEw8ONUmLWZ9AC5_yH5k2x8Amk1zQ1da6S4eQziaQYQI86EHFYw6bqg1IzNDK2DRROGb00KtCb1WKcON9NbVnn1kxGSEn5-XDIOev5932NErjho0HCbzuqCLiBZ3hI-27hlsPtpknSdh9DpWBP-5-AR2gN-U-EAPMYxfn9PjoV2HLuc60ujsbLghICAvd7c2YSGSp6D5610E25FFEB-Pif952HsJ-zphj-2x8m8Yjfi7T-zX0KZ2_xAV687QJG9-ukwcthzoBgiTSvfaeAu3Cpt9tk1GSolUPxkgAQ74u6L3cHG_GPMCCzib09A-MhVd2tKcG3iMojhvo4YaBHLea6ovRNY4exDSWrFRebn07eho4gYaqYHgVeJmATd8k-f5kElpJVgvwvFSuPcLMSdDBohUyV52CE3GK4LV_QWatcZgdwJEQtyOPUvGPc4Lmh7ao-Jf3TegmZcFV2B7JTEA2eu28i16o4GlGGn4qcZA9nQfA0vuPOmPWFGL57XUZWv5Em04csSus5h_wngXp2Ux6JhGPVvb1bt5rx7vbZ64_xqhUbnZOUoityIr1a0E7bB4z1e-7SMTKTrYZwPBKo6Wk7EMCbFI-azJvoTjXAhUOlpJjyaGImaRkhctSUE_ujGJw5qm2a2YRpEsEHp59byacdkVRjkJ3NJ-WdXWsnDIEZGhT6GT0mqp2GhYyZHVy0-jM31ErL75QJ9EzdHAj8GiJr-hDjYUJxsAkai07wTTNzvsvksCfpcmDcKIS1DScjRGslyzzFXOz6Nq107rrdKsv1HdtGlN6CjwcPS3KytKA-6vQMOhD3798wLinMRO1DwqTecw_I2NnSQ4z0eOiLbTkUT3XNlp0f3qPtgLdbikRji9p1wWnVxQSF8BDyYxqsJmXbWyS4VhDPG2ApjJjmY7fiOrNAtAApXQIzLDdzfWdZaG1fwmomxS0n1J-VyBwMuQnPmfyAPoTEUuvHFN-DVymj9E3dfMYoUzaUgsYiA-XgU_JX1F_k6tlKjuIsQtmPx9XJy1H6H2qtWPjXWQAo6Xs3eyS_GNOGAVfqhWl6bK5CxeVyEHSPwt6hdhXQbkQyQX647P8aXp4NHejJoXS8THk8z0Njs4sKM4LTigZrWRF00YDAi1xNlZ7BkYwNr6lFkiMeKG9QPXcwGxC_fP3wxQul_UD7mJivQ8oAej8wc7C7y7rDNwxZUjc1XD2_m3vk3EUtU4V7_dvx97ciWvqXgMFCOVrqd1bEdFbf_jKEswvGOWDuBVWa1eCjsQZbWxlHDMSen6O_OUY2aFYAgsyBwAye48DrRpZCnIffCXJbN7K4qgWkwQ9JFUrQc4UeCvS5e5N8eSim6v3ePAELmQUL3XdjT-byfrfTniub9PQvKl_MVxbuGzqArVtE1HXQRiFn66pmhgOQ53jP5CYVAU0n1Cm_uhb_BGwswFG", + "summary": [ + { + "type": "summary_text", + "text": "**Clarifying math reasoning**\n\nI need to ensure I'm providing clear and straightforward math reasoning based on the user\u2019s request. I'll keep the equations concise, like showing how to calculate x, x+1, and 2x + 1 using simple terms. For instance, I can break down factors like 1.10, x, and 0.05. The goal is to present everything in a way that's conventional and easily comprehensible for the user. Let's get into it!" + } + ] + }, + { + "id": "msg_05a6d27313fc952f006ae54bf1c5f887d0aba2381475a5e35d", + "type": "message", + "status": "completed", + "content": [ + { + "type": "output_text", + "annotations": [], + "logprobs": [], + "text": "Let the ball cost \\(x\\) dollars. Then the bat costs \\(x + 1.00\\) dollars.\n\nTogether:\n\\[\nx + (x + 1.00) = 1.10\n\\]\n\\[\n2x = 0.10 \\quad\\Rightarrow\\quad x = 0.05\n\\]\n\n**The ball costs $0.05 (5 cents).**" + } + ], + "phase": "final_answer", + "role": "assistant" + } + ], + "parallel_tool_calls": true, + "presence_penalty": 0.0, + "previous_response_id": null, + "prompt_cache_key": null, + "prompt_cache_retention": "24h", + "reasoning": { + "context": "all_turns", + "effort": "medium", + "mode": "standard", + "summary": "detailed" + }, + "safety_identifier": null, + "service_tier": "default", + "store": true, + "temperature": 1.0, + "text": { + "format": { + "type": "text" + }, + "verbosity": "medium" + }, + "tool_choice": "auto", + "tool_usage": { + "image_gen": { + "input_tokens": 0, + "input_tokens_details": { + "image_tokens": 0, + "text_tokens": 0 + }, + "output_tokens": 0, + "output_tokens_details": { + "image_tokens": 0, + "text_tokens": 0 + }, + "total_tokens": 0 + }, + "web_search": { + "num_requests": 0 + } + }, + "tools": [], + "top_logprobs": 0, + "top_p": 0.98, + "truncation": "disabled", + "usage": { + "input_tokens": 45, + "input_tokens_details": { + "cache_write_tokens": 0, + "cached_tokens": 0 + }, + "output_tokens": 130, + "output_tokens_details": { + "reasoning_tokens": 39 + }, + "total_tokens": 175 + }, + "user": null, + "metadata": {} +} \ No newline at end of file diff --git a/packages/inference-discovery-openai/sessions/openai-responses/gpt-6.1-sol/reasoning-content/session.json b/packages/inference-discovery-openai/sessions/openai-responses/gpt-6.1-sol/reasoning-content/session.json new file mode 100644 index 000000000..c82c2cfc9 --- /dev/null +++ b/packages/inference-discovery-openai/sessions/openai-responses/gpt-6.1-sol/reasoning-content/session.json @@ -0,0 +1,11 @@ +{ + "schemaVersion": "2", + "source": { + "provider": "openai-responses", + "model": "gpt-6.1-sol", + "baseURL": "https://api.openai.com/v1" + }, + "origin": "live", + "capturedAt": "2026-10-31T02:01:22.431Z", + "capability": "reasoning-content" +} diff --git a/packages/inference-discovery-openai/sessions/openai-responses/gpt-6.1-terra/function-calling-multi-turn/dispatches/0-get_weather.json b/packages/inference-discovery-openai/sessions/openai-responses/gpt-6.1-terra/function-calling-multi-turn/dispatches/0-get_weather.json new file mode 100644 index 000000000..21f38181b --- /dev/null +++ b/packages/inference-discovery-openai/sessions/openai-responses/gpt-6.1-terra/function-calling-multi-turn/dispatches/0-get_weather.json @@ -0,0 +1,6 @@ +{ + "args": { + "location": "Boston, MA" + }, + "result": "{\"location\":\"Boston, MA\",\"temperatureF\":68,\"conditions\":\"clear\"}" +} diff --git a/packages/inference-discovery-openai/sessions/openai-responses/gpt-6.1-terra/function-calling-multi-turn/exchanges/0/request-headers.json b/packages/inference-discovery-openai/sessions/openai-responses/gpt-6.1-terra/function-calling-multi-turn/exchanges/0/request-headers.json new file mode 100644 index 000000000..28c14bb85 --- /dev/null +++ b/packages/inference-discovery-openai/sessions/openai-responses/gpt-6.1-terra/function-calling-multi-turn/exchanges/0/request-headers.json @@ -0,0 +1,4 @@ +{ + "Content-Type": "application/json", + "Authorization": "" +} diff --git a/packages/inference-discovery-openai/sessions/openai-responses/gpt-6.1-terra/function-calling-multi-turn/exchanges/0/request.json b/packages/inference-discovery-openai/sessions/openai-responses/gpt-6.1-terra/function-calling-multi-turn/exchanges/0/request.json new file mode 100644 index 000000000..14e16dcb2 --- /dev/null +++ b/packages/inference-discovery-openai/sessions/openai-responses/gpt-6.1-terra/function-calling-multi-turn/exchanges/0/request.json @@ -0,0 +1,30 @@ +{ + "model": "gpt-6.1-terra", + "input": [ + { + "type": "message", + "role": "user", + "content": "What is the weather in Boston, MA? Use the provided tool." + } + ], + "tools": [ + { + "type": "function", + "name": "get_weather", + "description": "Look up the current weather for a city.", + "parameters": { + "type": "object", + "properties": { + "location": { + "type": "string", + "description": "City and optional region, e.g. 'Boston, MA'." + } + }, + "required": [ + "location" + ] + } + } + ], + "tool_choice": "auto" +} diff --git a/packages/inference-discovery-openai/sessions/openai-responses/gpt-6.1-terra/function-calling-multi-turn/exchanges/0/response-headers.json b/packages/inference-discovery-openai/sessions/openai-responses/gpt-6.1-terra/function-calling-multi-turn/exchanges/0/response-headers.json new file mode 100644 index 000000000..ced842be4 --- /dev/null +++ b/packages/inference-discovery-openai/sessions/openai-responses/gpt-6.1-terra/function-calling-multi-turn/exchanges/0/response-headers.json @@ -0,0 +1,26 @@ +{ + "access-control-expose-headers": "X-Request-ID, Server-Timing-Total, CF-Ray, CF-Ray", + "alt-svc": "h3=\":443\"; ma=86400", + "cf-cache-status": "DYNAMIC", + "cf-ray": "a52f124b4e466a29-LAX", + "connection": "keep-alive", + "content-encoding": "br", + "content-type": "application/json", + "date": "Sat, 31 Oct 2026 02:01:23 GMT", + "openai-organization": "", + "openai-processing-ms": "1000", + "openai-project": "", + "openai-version": "2020-10-01", + "server": "cloudflare", + "strict-transport-security": "max-age=31536000; includeSubDomains; preload", + "transfer-encoding": "chunked", + "x-content-type-options": "nosniff", + "x-ratelimit-limit-requests": "5000", + "x-ratelimit-limit-tokens": "1000000", + "x-ratelimit-remaining-requests": "4999", + "x-ratelimit-remaining-tokens": "1000000", + "x-ratelimit-reset-requests": "12ms", + "x-ratelimit-reset-tokens": "0s", + "x-request-id": "", + "set-cookie": "" +} diff --git a/packages/inference-discovery-openai/sessions/openai-responses/gpt-6.1-terra/function-calling-multi-turn/exchanges/0/response.json b/packages/inference-discovery-openai/sessions/openai-responses/gpt-6.1-terra/function-calling-multi-turn/exchanges/0/response.json new file mode 100644 index 000000000..22445a410 --- /dev/null +++ b/packages/inference-discovery-openai/sessions/openai-responses/gpt-6.1-terra/function-calling-multi-turn/exchanges/0/response.json @@ -0,0 +1,111 @@ +{ + "id": "resp_076513ee41669195006ae54bf283ac87d0be687bfcdf1ce1b7", + "object": "response", + "created_at": 1793412082, + "status": "completed", + "access_programs": { + "cyber": "standard" + }, + "background": false, + "billing": { + "payer": "developer" + }, + "completed_at": 1793412083, + "error": null, + "frequency_penalty": 0.0, + "incomplete_details": null, + "instructions": null, + "max_output_tokens": null, + "max_tool_calls": null, + "model": "gpt-6.1-terra", + "moderation": null, + "output": [ + { + "id": "fc_076513ee41669195006ae54bf32f0487d091ed42241e40a7a5", + "type": "function_call", + "status": "completed", + "arguments": "{\"location\":\"Boston, MA\"}", + "call_id": "call_xavUZfYMT2LWqFB9PBfgwTd2", + "name": "get_weather" + } + ], + "parallel_tool_calls": true, + "presence_penalty": 0.0, + "previous_response_id": null, + "prompt_cache_key": null, + "prompt_cache_retention": "24h", + "reasoning": { + "context": "all_turns", + "effort": "medium", + "mode": "standard", + "summary": null + }, + "safety_identifier": null, + "service_tier": "default", + "store": true, + "temperature": 1.0, + "text": { + "format": { + "type": "text" + }, + "verbosity": "medium" + }, + "tool_choice": "auto", + "tool_usage": { + "image_gen": { + "input_tokens": 0, + "input_tokens_details": { + "image_tokens": 0, + "text_tokens": 0 + }, + "output_tokens": 0, + "output_tokens_details": { + "image_tokens": 0, + "text_tokens": 0 + }, + "total_tokens": 0 + }, + "web_search": { + "num_requests": 0 + } + }, + "tools": [ + { + "type": "function", + "description": "Look up the current weather for a city.", + "name": "get_weather", + "output_schema": null, + "parameters": { + "type": "object", + "properties": { + "location": { + "type": "string", + "description": "City and optional region, e.g. 'Boston, MA'." + } + }, + "required": [ + "location" + ], + "additionalProperties": false + }, + "strict": true + } + ], + "top_logprobs": 0, + "top_p": 0.98, + "truncation": "disabled", + "usage": { + "input_tokens": 73, + "input_tokens_details": { + "cache_write_tokens": 0, + "cached_tokens": 0 + }, + "output_tokens": 20, + "output_tokens_details": { + "reasoning_tokens": 0 + }, + "total_tokens": 93 + }, + "user": null, + "metadata": {} +} \ No newline at end of file diff --git a/packages/inference-discovery-openai/sessions/openai-responses/gpt-6.1-terra/function-calling-multi-turn/exchanges/1/request-headers.json b/packages/inference-discovery-openai/sessions/openai-responses/gpt-6.1-terra/function-calling-multi-turn/exchanges/1/request-headers.json new file mode 100644 index 000000000..28c14bb85 --- /dev/null +++ b/packages/inference-discovery-openai/sessions/openai-responses/gpt-6.1-terra/function-calling-multi-turn/exchanges/1/request-headers.json @@ -0,0 +1,4 @@ +{ + "Content-Type": "application/json", + "Authorization": "" +} diff --git a/packages/inference-discovery-openai/sessions/openai-responses/gpt-6.1-terra/function-calling-multi-turn/exchanges/1/request.json b/packages/inference-discovery-openai/sessions/openai-responses/gpt-6.1-terra/function-calling-multi-turn/exchanges/1/request.json new file mode 100644 index 000000000..8e6d27bfe --- /dev/null +++ b/packages/inference-discovery-openai/sessions/openai-responses/gpt-6.1-terra/function-calling-multi-turn/exchanges/1/request.json @@ -0,0 +1,45 @@ +{ + "model": "gpt-6.1-terra", + "input": [ + { + "type": "message", + "role": "user", + "content": "What is the weather in Boston, MA? Use the provided tool." + }, + { + "type": "function_call", + "call_id": "call_xavUZfYMT2LWqFB9PBfgwTd2", + "name": "get_weather", + "arguments": "{\"location\":\"Boston, MA\"}" + }, + { + "type": "function_call_output", + "call_id": "call_xavUZfYMT2LWqFB9PBfgwTd2", + "output": "{\"location\":\"Boston, MA\",\"temperatureF\":68,\"conditions\":\"clear\"}" + } + ], + "store": false, + "include": [ + "reasoning.encrypted_content" + ], + "tools": [ + { + "type": "function", + "name": "get_weather", + "description": "Look up the current weather for a city.", + "parameters": { + "type": "object", + "properties": { + "location": { + "type": "string", + "description": "City and optional region, e.g. 'Boston, MA'." + } + }, + "required": [ + "location" + ] + } + } + ], + "tool_choice": "auto" +} diff --git a/packages/inference-discovery-openai/sessions/openai-responses/gpt-6.1-terra/function-calling-multi-turn/exchanges/1/response-headers.json b/packages/inference-discovery-openai/sessions/openai-responses/gpt-6.1-terra/function-calling-multi-turn/exchanges/1/response-headers.json new file mode 100644 index 000000000..482f0687b --- /dev/null +++ b/packages/inference-discovery-openai/sessions/openai-responses/gpt-6.1-terra/function-calling-multi-turn/exchanges/1/response-headers.json @@ -0,0 +1,26 @@ +{ + "access-control-expose-headers": "X-Request-ID, Server-Timing-Total, CF-Ray, CF-Ray", + "alt-svc": "h3=\":443\"; ma=86400", + "cf-cache-status": "DYNAMIC", + "cf-ray": "a52f125208266a29-LAX", + "connection": "keep-alive", + "content-encoding": "br", + "content-type": "application/json", + "date": "Sat, 31 Oct 2026 02:01:24 GMT", + "openai-organization": "", + "openai-processing-ms": "1183", + "openai-project": "", + "openai-version": "2020-10-01", + "server": "cloudflare", + "strict-transport-security": "max-age=31536000; includeSubDomains; preload", + "transfer-encoding": "chunked", + "x-content-type-options": "nosniff", + "x-ratelimit-limit-requests": "5000", + "x-ratelimit-limit-tokens": "1000000", + "x-ratelimit-remaining-requests": "4999", + "x-ratelimit-remaining-tokens": "1000000", + "x-ratelimit-reset-requests": "12ms", + "x-ratelimit-reset-tokens": "0s", + "x-request-id": "", + "set-cookie": "" +} diff --git a/packages/inference-discovery-openai/sessions/openai-responses/gpt-6.1-terra/function-calling-multi-turn/exchanges/1/response.json b/packages/inference-discovery-openai/sessions/openai-responses/gpt-6.1-terra/function-calling-multi-turn/exchanges/1/response.json new file mode 100644 index 000000000..8f5d8ec4c --- /dev/null +++ b/packages/inference-discovery-openai/sessions/openai-responses/gpt-6.1-terra/function-calling-multi-turn/exchanges/1/response.json @@ -0,0 +1,118 @@ +{ + "id": "resp_0578cceba4466363016ae54bf3981c87d0a28677d7ef56dfca", + "object": "response", + "created_at": 1793412083, + "status": "completed", + "access_programs": { + "cyber": "standard" + }, + "background": false, + "billing": { + "payer": "developer" + }, + "completed_at": 1793412084, + "error": null, + "frequency_penalty": 0.0, + "incomplete_details": null, + "instructions": null, + "max_output_tokens": null, + "max_tool_calls": null, + "model": "gpt-6.1-terra", + "moderation": null, + "output": [ + { + "id": "msg_0578cceba4466363016ae54bf423f087d084eb9caf81271a0d", + "type": "message", + "status": "completed", + "content": [ + { + "type": "output_text", + "annotations": [], + "logprobs": [], + "text": "The weather in Boston, MA, is clear and 68\u00b0F (20\u00b0C)." + } + ], + "phase": "final_answer", + "role": "assistant" + } + ], + "parallel_tool_calls": true, + "presence_penalty": 0.0, + "previous_response_id": null, + "prompt_cache_key": null, + "prompt_cache_retention": "24h", + "reasoning": { + "context": "all_turns", + "effort": "medium", + "mode": "standard", + "summary": null + }, + "safety_identifier": null, + "service_tier": "default", + "store": false, + "temperature": 1.0, + "text": { + "format": { + "type": "text" + }, + "verbosity": "medium" + }, + "tool_choice": "auto", + "tool_usage": { + "image_gen": { + "input_tokens": 0, + "input_tokens_details": { + "image_tokens": 0, + "text_tokens": 0 + }, + "output_tokens": 0, + "output_tokens_details": { + "image_tokens": 0, + "text_tokens": 0 + }, + "total_tokens": 0 + }, + "web_search": { + "num_requests": 0 + } + }, + "tools": [ + { + "type": "function", + "description": "Look up the current weather for a city.", + "name": "get_weather", + "output_schema": null, + "parameters": { + "type": "object", + "properties": { + "location": { + "type": "string", + "description": "City and optional region, e.g. 'Boston, MA'." + } + }, + "required": [ + "location" + ], + "additionalProperties": false + }, + "strict": true + } + ], + "top_logprobs": 0, + "top_p": 0.98, + "truncation": "disabled", + "usage": { + "input_tokens": 120, + "input_tokens_details": { + "cache_write_tokens": 0, + "cached_tokens": 0 + }, + "output_tokens": 21, + "output_tokens_details": { + "reasoning_tokens": 0 + }, + "total_tokens": 141 + }, + "user": null, + "metadata": {} +} \ No newline at end of file diff --git a/packages/inference-discovery-openai/sessions/openai-responses/gpt-6.1-terra/function-calling-multi-turn/session.json b/packages/inference-discovery-openai/sessions/openai-responses/gpt-6.1-terra/function-calling-multi-turn/session.json new file mode 100644 index 000000000..79700057c --- /dev/null +++ b/packages/inference-discovery-openai/sessions/openai-responses/gpt-6.1-terra/function-calling-multi-turn/session.json @@ -0,0 +1,11 @@ +{ + "schemaVersion": "2", + "source": { + "provider": "openai-responses", + "model": "gpt-6.1-terra", + "baseURL": "https://api.openai.com/v1" + }, + "origin": "live", + "capturedAt": "2026-10-31T02:01:24.778Z", + "capability": "function-calling-multi-turn" +} diff --git a/packages/inference-discovery-openai/sessions/openai-responses/gpt-6.1-terra/plain-text-streaming/exchanges/0/request-headers.json b/packages/inference-discovery-openai/sessions/openai-responses/gpt-6.1-terra/plain-text-streaming/exchanges/0/request-headers.json new file mode 100644 index 000000000..28c14bb85 --- /dev/null +++ b/packages/inference-discovery-openai/sessions/openai-responses/gpt-6.1-terra/plain-text-streaming/exchanges/0/request-headers.json @@ -0,0 +1,4 @@ +{ + "Content-Type": "application/json", + "Authorization": "" +} diff --git a/packages/inference-discovery-openai/sessions/openai-responses/gpt-6.1-terra/plain-text-streaming/exchanges/0/request.json b/packages/inference-discovery-openai/sessions/openai-responses/gpt-6.1-terra/plain-text-streaming/exchanges/0/request.json new file mode 100644 index 000000000..123c8da85 --- /dev/null +++ b/packages/inference-discovery-openai/sessions/openai-responses/gpt-6.1-terra/plain-text-streaming/exchanges/0/request.json @@ -0,0 +1,11 @@ +{ + "model": "gpt-6.1-terra", + "input": [ + { + "type": "message", + "role": "user", + "content": "Reply with a single sentence: the capital of France is Paris." + } + ], + "stream": true +} diff --git a/packages/inference-discovery-openai/sessions/openai-responses/gpt-6.1-terra/plain-text-streaming/exchanges/0/response-headers.json b/packages/inference-discovery-openai/sessions/openai-responses/gpt-6.1-terra/plain-text-streaming/exchanges/0/response-headers.json new file mode 100644 index 000000000..2f5115110 --- /dev/null +++ b/packages/inference-discovery-openai/sessions/openai-responses/gpt-6.1-terra/plain-text-streaming/exchanges/0/response-headers.json @@ -0,0 +1,25 @@ +{ + "access-control-expose-headers": "X-Request-ID, Server-Timing-Total, CF-Ray, CF-Ray", + "alt-svc": "h3=\":443\"; ma=86400", + "cf-cache-status": "DYNAMIC", + "cf-ray": "a5281a926d48cb96-LAX", + "connection": "keep-alive", + "content-type": "text/event-stream; charset=utf-8", + "date": "Fri, 30 Oct 2026 05:43:41 GMT", + "openai-organization": "", + "openai-processing-ms": "214", + "openai-project": "", + "openai-version": "2020-10-01", + "server": "cloudflare", + "strict-transport-security": "max-age=31536000; includeSubDomains; preload", + "transfer-encoding": "chunked", + "x-content-type-options": "nosniff", + "x-ratelimit-limit-requests": "5000", + "x-ratelimit-limit-tokens": "1000000", + "x-ratelimit-remaining-requests": "4999", + "x-ratelimit-remaining-tokens": "999829", + "x-ratelimit-reset-requests": "12ms", + "x-ratelimit-reset-tokens": "10ms", + "x-request-id": "", + "set-cookie": "" +} diff --git a/packages/inference-discovery-openai/sessions/openai-responses/gpt-6.1-terra/plain-text-streaming/exchanges/0/response.sse b/packages/inference-discovery-openai/sessions/openai-responses/gpt-6.1-terra/plain-text-streaming/exchanges/0/response.sse new file mode 100644 index 000000000..6c9f2ffe5 --- /dev/null +++ b/packages/inference-discovery-openai/sessions/openai-responses/gpt-6.1-terra/plain-text-streaming/exchanges/0/response.sse @@ -0,0 +1,45 @@ +event: response.created +data: {"type":"response.created","response":{"id":"resp_00485925f6963e86006ae42e8d3ed087d099628fcb74d801f9","object":"response","created_at":1793339021,"status":"in_progress","access_programs":{"cyber":"standard"},"background":false,"completed_at":null,"error":null,"frequency_penalty":0.0,"incomplete_details":null,"instructions":null,"max_output_tokens":null,"max_tool_calls":null,"model":"gpt-6.1-terra","moderation":null,"output":[],"parallel_tool_calls":true,"presence_penalty":0.0,"previous_response_id":null,"prompt_cache_key":null,"prompt_cache_retention":"24h","reasoning":{"context":"all_turns","effort":"medium","mode":"standard","summary":null},"safety_identifier":null,"service_tier":"auto","store":true,"temperature":1.0,"text":{"format":{"type":"text"},"verbosity":"medium"},"tool_choice":"auto","tool_usage":{"image_gen":{"input_tokens":0,"input_tokens_details":{"image_tokens":0,"text_tokens":0},"output_tokens":0,"output_tokens_details":{"image_tokens":0,"text_tokens":0},"total_tokens":0},"web_search":{"num_requests":0}},"tools":[],"top_logprobs":0,"top_p":0.98,"truncation":"disabled","usage":null,"user":null,"metadata":{}},"sequence_number":0} + +event: response.in_progress +data: {"type":"response.in_progress","response":{"id":"resp_00485925f6963e86006ae42e8d3ed087d099628fcb74d801f9","object":"response","created_at":1793339021,"status":"in_progress","access_programs":{"cyber":"standard"},"background":false,"completed_at":null,"error":null,"frequency_penalty":0.0,"incomplete_details":null,"instructions":null,"max_output_tokens":null,"max_tool_calls":null,"model":"gpt-6.1-terra","moderation":null,"output":[],"parallel_tool_calls":true,"presence_penalty":0.0,"previous_response_id":null,"prompt_cache_key":null,"prompt_cache_retention":"24h","reasoning":{"context":"all_turns","effort":"medium","mode":"standard","summary":null},"safety_identifier":null,"service_tier":"auto","store":true,"temperature":1.0,"text":{"format":{"type":"text"},"verbosity":"medium"},"tool_choice":"auto","tool_usage":{"image_gen":{"input_tokens":0,"input_tokens_details":{"image_tokens":0,"text_tokens":0},"output_tokens":0,"output_tokens_details":{"image_tokens":0,"text_tokens":0},"total_tokens":0},"web_search":{"num_requests":0}},"tools":[],"top_logprobs":0,"top_p":0.98,"truncation":"disabled","usage":null,"user":null,"metadata":{}},"sequence_number":1} + +event: response.output_item.added +data: {"type":"response.output_item.added","item":{"id":"msg_00485925f6963e86006ae42e8dec3887d08921ab8f100c2bd5","type":"message","status":"in_progress","content":[],"phase":"final_answer","role":"assistant"},"output_index":0,"sequence_number":2} + +event: response.content_part.added +data: {"type":"response.content_part.added","content_index":0,"item_id":"msg_00485925f6963e86006ae42e8dec3887d08921ab8f100c2bd5","output_index":0,"part":{"type":"output_text","annotations":[],"logprobs":[],"text":""},"sequence_number":3} + +event: response.output_text.delta +data: {"type":"response.output_text.delta","content_index":0,"delta":"The","item_id":"msg_00485925f6963e86006ae42e8dec3887d08921ab8f100c2bd5","logprobs":[],"obfuscation":"El0PRzXf2E8s5","output_index":0,"sequence_number":4} + +event: response.output_text.delta +data: {"type":"response.output_text.delta","content_index":0,"delta":" capital","item_id":"msg_00485925f6963e86006ae42e8dec3887d08921ab8f100c2bd5","logprobs":[],"obfuscation":"Sq0vthd7","output_index":0,"sequence_number":5} + +event: response.output_text.delta +data: {"type":"response.output_text.delta","content_index":0,"delta":" of","item_id":"msg_00485925f6963e86006ae42e8dec3887d08921ab8f100c2bd5","logprobs":[],"obfuscation":"NvbDSmv6RkOZ4","output_index":0,"sequence_number":6} + +event: response.output_text.delta +data: {"type":"response.output_text.delta","content_index":0,"delta":" France","item_id":"msg_00485925f6963e86006ae42e8dec3887d08921ab8f100c2bd5","logprobs":[],"obfuscation":"y5zRU0sU3","output_index":0,"sequence_number":7} + +event: response.output_text.delta +data: {"type":"response.output_text.delta","content_index":0,"delta":" is","item_id":"msg_00485925f6963e86006ae42e8dec3887d08921ab8f100c2bd5","logprobs":[],"obfuscation":"5asM60j15aytY","output_index":0,"sequence_number":8} + +event: response.output_text.delta +data: {"type":"response.output_text.delta","content_index":0,"delta":" Paris","item_id":"msg_00485925f6963e86006ae42e8dec3887d08921ab8f100c2bd5","logprobs":[],"obfuscation":"cqyIajezls","output_index":0,"sequence_number":9} + +event: response.output_text.delta +data: {"type":"response.output_text.delta","content_index":0,"delta":".","item_id":"msg_00485925f6963e86006ae42e8dec3887d08921ab8f100c2bd5","logprobs":[],"obfuscation":"g5tVhVsky08MQVc","output_index":0,"sequence_number":10} + +event: response.output_text.done +data: {"type":"response.output_text.done","content_index":0,"item_id":"msg_00485925f6963e86006ae42e8dec3887d08921ab8f100c2bd5","logprobs":[],"output_index":0,"sequence_number":11,"text":"The capital of France is Paris."} + +event: response.content_part.done +data: {"type":"response.content_part.done","content_index":0,"item_id":"msg_00485925f6963e86006ae42e8dec3887d08921ab8f100c2bd5","output_index":0,"part":{"type":"output_text","annotations":[],"logprobs":[],"text":"The capital of France is Paris."},"sequence_number":12} + +event: response.output_item.done +data: {"type":"response.output_item.done","item":{"id":"msg_00485925f6963e86006ae42e8dec3887d08921ab8f100c2bd5","type":"message","status":"completed","content":[{"type":"output_text","annotations":[],"logprobs":[],"text":"The capital of France is Paris."}],"phase":"final_answer","role":"assistant"},"output_index":0,"sequence_number":13} + +event: response.completed +data: {"type":"response.completed","response":{"id":"resp_00485925f6963e86006ae42e8d3ed087d099628fcb74d801f9","object":"response","created_at":1793339021,"status":"completed","access_programs":{"cyber":"standard"},"background":false,"completed_at":1793339022,"error":null,"frequency_penalty":0.0,"incomplete_details":null,"instructions":null,"max_output_tokens":null,"max_tool_calls":null,"model":"gpt-6.1-terra","moderation":null,"output":[{"id":"msg_00485925f6963e86006ae42e8dec3887d08921ab8f100c2bd5","type":"message","status":"completed","content":[{"type":"output_text","annotations":[],"logprobs":[],"text":"The capital of France is Paris."}],"phase":"final_answer","role":"assistant"}],"parallel_tool_calls":true,"presence_penalty":0.0,"previous_response_id":null,"prompt_cache_key":null,"prompt_cache_retention":"24h","reasoning":{"context":"all_turns","effort":"medium","mode":"standard","summary":null},"safety_identifier":null,"service_tier":"default","store":true,"temperature":1.0,"text":{"format":{"type":"text"},"verbosity":"medium"},"tool_choice":"auto","tool_usage":{"image_gen":{"input_tokens":0,"input_tokens_details":{"image_tokens":0,"text_tokens":0},"output_tokens":0,"output_tokens_details":{"image_tokens":0,"text_tokens":0},"total_tokens":0},"web_search":{"num_requests":0}},"tools":[],"top_logprobs":0,"top_p":0.98,"truncation":"disabled","usage":{"input_tokens":19,"input_tokens_details":{"cache_write_tokens":0,"cached_tokens":0},"output_tokens":11,"output_tokens_details":{"reasoning_tokens":0},"total_tokens":30},"user":null,"metadata":{}},"sequence_number":14} + diff --git a/packages/inference-discovery-openai/sessions/openai-responses/gpt-6.1-terra/plain-text-streaming/session.json b/packages/inference-discovery-openai/sessions/openai-responses/gpt-6.1-terra/plain-text-streaming/session.json new file mode 100644 index 000000000..a57d77c81 --- /dev/null +++ b/packages/inference-discovery-openai/sessions/openai-responses/gpt-6.1-terra/plain-text-streaming/session.json @@ -0,0 +1,11 @@ +{ + "schemaVersion": "2", + "source": { + "provider": "openai-responses", + "model": "gpt-6.1-terra", + "baseURL": "https://api.openai.com/v1" + }, + "origin": "live", + "capturedAt": "2026-10-30T05:43:42.192Z", + "capability": "plain-text-streaming" +} diff --git a/packages/inference-discovery-openai/sessions/openai-responses/gpt-6.1-terra/plain-text/exchanges/0/request-headers.json b/packages/inference-discovery-openai/sessions/openai-responses/gpt-6.1-terra/plain-text/exchanges/0/request-headers.json new file mode 100644 index 000000000..28c14bb85 --- /dev/null +++ b/packages/inference-discovery-openai/sessions/openai-responses/gpt-6.1-terra/plain-text/exchanges/0/request-headers.json @@ -0,0 +1,4 @@ +{ + "Content-Type": "application/json", + "Authorization": "" +} diff --git a/packages/inference-discovery-openai/sessions/openai-responses/gpt-6.1-terra/plain-text/exchanges/0/request.json b/packages/inference-discovery-openai/sessions/openai-responses/gpt-6.1-terra/plain-text/exchanges/0/request.json new file mode 100644 index 000000000..be016b98f --- /dev/null +++ b/packages/inference-discovery-openai/sessions/openai-responses/gpt-6.1-terra/plain-text/exchanges/0/request.json @@ -0,0 +1,10 @@ +{ + "model": "gpt-6.1-terra", + "input": [ + { + "type": "message", + "role": "user", + "content": "Reply with a single sentence: the capital of France is Paris." + } + ] +} diff --git a/packages/inference-discovery-openai/sessions/openai-responses/gpt-6.1-terra/plain-text/exchanges/0/response-headers.json b/packages/inference-discovery-openai/sessions/openai-responses/gpt-6.1-terra/plain-text/exchanges/0/response-headers.json new file mode 100644 index 000000000..5ff723369 --- /dev/null +++ b/packages/inference-discovery-openai/sessions/openai-responses/gpt-6.1-terra/plain-text/exchanges/0/response-headers.json @@ -0,0 +1,26 @@ +{ + "access-control-expose-headers": "X-Request-ID, Server-Timing-Total, CF-Ray, CF-Ray", + "alt-svc": "h3=\":443\"; ma=86400", + "cf-cache-status": "DYNAMIC", + "cf-ray": "a5281a8c2b8ccb96-LAX", + "connection": "keep-alive", + "content-encoding": "br", + "content-type": "application/json", + "date": "Fri, 30 Oct 2026 05:43:41 GMT", + "openai-organization": "", + "openai-processing-ms": "904", + "openai-project": "", + "openai-version": "2020-10-01", + "server": "cloudflare", + "strict-transport-security": "max-age=31536000; includeSubDomains; preload", + "transfer-encoding": "chunked", + "x-content-type-options": "nosniff", + "x-ratelimit-limit-requests": "5000", + "x-ratelimit-limit-tokens": "1000000", + "x-ratelimit-remaining-requests": "4999", + "x-ratelimit-remaining-tokens": "1000000", + "x-ratelimit-reset-requests": "12ms", + "x-ratelimit-reset-tokens": "0s", + "x-request-id": "", + "set-cookie": "" +} diff --git a/packages/inference-discovery-openai/sessions/openai-responses/gpt-6.1-terra/plain-text/exchanges/0/response.json b/packages/inference-discovery-openai/sessions/openai-responses/gpt-6.1-terra/plain-text/exchanges/0/response.json new file mode 100644 index 000000000..2775d3016 --- /dev/null +++ b/packages/inference-discovery-openai/sessions/openai-responses/gpt-6.1-terra/plain-text/exchanges/0/response.json @@ -0,0 +1,97 @@ +{ + "id": "resp_07fac5832ed754d6006ae42e8c406c87d0b666c1e27d3a2bab", + "object": "response", + "created_at": 1793339020, + "status": "completed", + "access_programs": { + "cyber": "standard" + }, + "background": false, + "billing": { + "payer": "developer" + }, + "completed_at": 1793339021, + "error": null, + "frequency_penalty": 0.0, + "incomplete_details": null, + "instructions": null, + "max_output_tokens": null, + "max_tool_calls": null, + "model": "gpt-6.1-terra", + "moderation": null, + "output": [ + { + "id": "msg_07fac5832ed754d6006ae42e8ce10c87d0bd4a0e9d7efb4a22", + "type": "message", + "status": "completed", + "content": [ + { + "type": "output_text", + "annotations": [], + "logprobs": [], + "text": "The capital of France is Paris." + } + ], + "phase": "final_answer", + "role": "assistant" + } + ], + "parallel_tool_calls": true, + "presence_penalty": 0.0, + "previous_response_id": null, + "prompt_cache_key": null, + "prompt_cache_retention": "24h", + "reasoning": { + "context": "all_turns", + "effort": "medium", + "mode": "standard", + "summary": null + }, + "safety_identifier": null, + "service_tier": "default", + "store": true, + "temperature": 1.0, + "text": { + "format": { + "type": "text" + }, + "verbosity": "medium" + }, + "tool_choice": "auto", + "tool_usage": { + "image_gen": { + "input_tokens": 0, + "input_tokens_details": { + "image_tokens": 0, + "text_tokens": 0 + }, + "output_tokens": 0, + "output_tokens_details": { + "image_tokens": 0, + "text_tokens": 0 + }, + "total_tokens": 0 + }, + "web_search": { + "num_requests": 0 + } + }, + "tools": [], + "top_logprobs": 0, + "top_p": 0.98, + "truncation": "disabled", + "usage": { + "input_tokens": 19, + "input_tokens_details": { + "cache_write_tokens": 0, + "cached_tokens": 0 + }, + "output_tokens": 11, + "output_tokens_details": { + "reasoning_tokens": 0 + }, + "total_tokens": 30 + }, + "user": null, + "metadata": {} +} \ No newline at end of file diff --git a/packages/inference-discovery-openai/sessions/openai-responses/gpt-6.1-terra/plain-text/session.json b/packages/inference-discovery-openai/sessions/openai-responses/gpt-6.1-terra/plain-text/session.json new file mode 100644 index 000000000..ae48905bb --- /dev/null +++ b/packages/inference-discovery-openai/sessions/openai-responses/gpt-6.1-terra/plain-text/session.json @@ -0,0 +1,11 @@ +{ + "schemaVersion": "2", + "source": { + "provider": "openai-responses", + "model": "gpt-6.1-terra", + "baseURL": "https://api.openai.com/v1" + }, + "origin": "live", + "capturedAt": "2026-10-30T05:43:41.165Z", + "capability": "plain-text" +} diff --git a/packages/inference-discovery-openai/sessions/openai-responses/gpt-6.1-terra/reasoning-content/exchanges/0/request-headers.json b/packages/inference-discovery-openai/sessions/openai-responses/gpt-6.1-terra/reasoning-content/exchanges/0/request-headers.json new file mode 100644 index 000000000..28c14bb85 --- /dev/null +++ b/packages/inference-discovery-openai/sessions/openai-responses/gpt-6.1-terra/reasoning-content/exchanges/0/request-headers.json @@ -0,0 +1,4 @@ +{ + "Content-Type": "application/json", + "Authorization": "" +} diff --git a/packages/inference-discovery-openai/sessions/openai-responses/gpt-6.1-terra/reasoning-content/exchanges/0/request.json b/packages/inference-discovery-openai/sessions/openai-responses/gpt-6.1-terra/reasoning-content/exchanges/0/request.json new file mode 100644 index 000000000..829668163 --- /dev/null +++ b/packages/inference-discovery-openai/sessions/openai-responses/gpt-6.1-terra/reasoning-content/exchanges/0/request.json @@ -0,0 +1,14 @@ +{ + "model": "gpt-6.1-terra", + "input": [ + { + "type": "message", + "role": "user", + "content": "A bat and a ball cost $1.10 together. The bat costs $1.00 more than the ball. How much does the ball cost? Show your reasoning before the final answer." + } + ], + "reasoning": { + "effort": "medium", + "summary": "detailed" + } +} diff --git a/packages/inference-discovery-openai/sessions/openai-responses/gpt-6.1-terra/reasoning-content/exchanges/0/response-headers.json b/packages/inference-discovery-openai/sessions/openai-responses/gpt-6.1-terra/reasoning-content/exchanges/0/response-headers.json new file mode 100644 index 000000000..77b72dd27 --- /dev/null +++ b/packages/inference-discovery-openai/sessions/openai-responses/gpt-6.1-terra/reasoning-content/exchanges/0/response-headers.json @@ -0,0 +1,26 @@ +{ + "access-control-expose-headers": "X-Request-ID, Server-Timing-Total, CF-Ray, CF-Ray", + "alt-svc": "h3=\":443\"; ma=86400", + "cf-cache-status": "DYNAMIC", + "cf-ray": "a52f1259eaa26a29-LAX", + "connection": "keep-alive", + "content-encoding": "br", + "content-type": "application/json", + "date": "Sat, 31 Oct 2026 02:01:27 GMT", + "openai-organization": "", + "openai-processing-ms": "2503", + "openai-project": "", + "openai-version": "2020-10-01", + "server": "cloudflare", + "strict-transport-security": "max-age=31536000; includeSubDomains; preload", + "transfer-encoding": "chunked", + "x-content-type-options": "nosniff", + "x-ratelimit-limit-requests": "5000", + "x-ratelimit-limit-tokens": "1000000", + "x-ratelimit-remaining-requests": "4999", + "x-ratelimit-remaining-tokens": "1000000", + "x-ratelimit-reset-requests": "12ms", + "x-ratelimit-reset-tokens": "0s", + "x-request-id": "", + "set-cookie": "" +} diff --git a/packages/inference-discovery-openai/sessions/openai-responses/gpt-6.1-terra/reasoning-content/exchanges/0/response.json b/packages/inference-discovery-openai/sessions/openai-responses/gpt-6.1-terra/reasoning-content/exchanges/0/response.json new file mode 100644 index 000000000..3b4a3b7f8 --- /dev/null +++ b/packages/inference-discovery-openai/sessions/openai-responses/gpt-6.1-terra/reasoning-content/exchanges/0/response.json @@ -0,0 +1,104 @@ +{ + "id": "resp_0b764a5e13cab0ee006ae54bf4dae887d0b8a3e51dd5345210", + "object": "response", + "created_at": 1793412084, + "status": "completed", + "access_programs": { + "cyber": "standard" + }, + "background": false, + "billing": { + "payer": "developer" + }, + "completed_at": 1793412087, + "error": null, + "frequency_penalty": 0.0, + "incomplete_details": null, + "instructions": null, + "max_output_tokens": null, + "max_tool_calls": null, + "model": "gpt-6.1-terra", + "moderation": null, + "output": [ + { + "id": "rs_0b764a5e13cab0ee006ae54bf5b03887d0bd0f9cfe2e80ecc5", + "type": "reasoning", + "content": [], + "encrypted_content": "gAAAAABq5Uv3djV-hCRUL1KabtOmmUN6zLqo8WUid9MA3KyjaJO67Igl9d2rRiyxgwyudxr-RZKHybJSfSqFy_OPi_OCsNauYIR-h5tMC4kq9LxoBYcV-Yd4BOvV04nL-UZCCiibKxNoTgOleJ7fkDn_Z64MT2TCMyuADcCkbPaa8Zwng4Y8ESUGieRzWYW8xjpu6LYh9IEuaHENFSQddJHy7l0Bz_e8CFpHd_Exu_ZGpmzoIXeDnJSpalF4fdm8yyw2kW94adCAXEWT1Pjj6wI74Lw8WgJXadzLeXoyrE5-W2QoqxM7XaMkaC3HJ93vwy_qrWgZ2k0yH7whqoLaJ0Jly8q_M8sNm8YT_KXyivn2292l2eMbgd_rztsXw0MrZAascHZaLsGekuoceii9krlE1mh4wpQEPP8zQgeAbwcH5J0enmDoIu8m1JHBN3u5dYx3ZCyK_PrmuU7soUoPddyLCytzgoxflSq-edhDjRbOnqO2I0Q4vWe5eSTCFpNe4yiPrrrf0E_KWcNPkdNev3Yc6JpplUnQF2i6r3iCCDqbhCZ6RxCReDYSXfl_hNCOzqQVnU45N6kWdDnkrVDAAHsIIzaK0UMNgEN1tDBBKOMyuujaHP-Lw1pT0tW5qkhDmIFDMLtXwn_Z2VT7r1ZDzKeNhkCeTawWqdfLe_J0wX5ZT_ICkF4n5iiU7vCrCxFHMIz-dPDp0fUw-_UG5Ht8m4mqrxDJdpEyWrTWn_P-ZCfEH1Ky6Yko5tbFlDNY5I_SU0pq6OxudbtOHrSqJqpAQHXrFa0JzljXSX_OVxB15PAqRanof2rWLT2YxX4I4pVzYkPo_yfDdvrbTyQkdW95jv-g3Ao67G4mPPB5yOi9AkdUZ9DchRYBKYxXWLklK9gjq-kKDtzGG0LbRF9a-SYPllxT4KaA-alfwxb1tFagMMsUaoumg0y2nYR3OwZ9Cf0dEyo85htDxIy2h1Fgl23oTPAervnQKDOaFretXksVUL7mkI6-Cqfk_LWNly23_idpq9VxlXBccKaGNOcx7n2ULroIgyjdNgp3rZBCFGM7ViHRAqaNog-BrTvHN-M6TmRH9Bhg8JrSlQnH44xBZbaDdqCIa2z9x9AHs2F1QxRJ_DoMPp_KSmaPLAIrHqun7ly_iEfECY9fp2jy7lTEvCVzkqtsvrZetrxgztZ3Y_8JbZML3bRdrnwVzjP1p85qd7SdaeDxxvMBZZZxOf2zoIhi1TnS6BHjAaM9ztX6X8vnBj_WLHWTda9_cqRkziZwwLeTy6FfpTC5HfrRTA-qnGeaJV7krQaOqOluFrMSC_WnLasD8m5WcBEyu70Z86FcNhkmD7zMgn5y6m0KGYY5hBb-zVDy3vp1uxVjKLTnAhVg9Ssk2-Z0L60wJwh35ELfVl81ur9j7ykKk3hBjGoU9UEGSGTKpAQi-t67ktgOTa2EvkHWVZYnrevg6aWRUUY982_8otWOODk3i4pJUQ_nsjyrOrPnp4OyCYH9r3ST0PhGCCw7VazOU2EVuYmV9o9pN_GBaVt9zBAS-4QuzZYwemVUXSqkVnylkY1RBkV7Sx63juu-vydMkPWcIlub0wfeANbrey-AftgNXu9wi2LM95ES_TmleUWIzrM9GcpLJ7MrxsAHHZhnNjqigN54-euNbM_k45R533-o9NodU9fbsnfqSEIcvOChK1uFloe4sB7EIsjbpNjZaajyDxBV8Bl7ZQJFuMX91NMTnGmD-Kz7VS4FUNNi6LGZq5rsBpCw3vdvsZf4LXv9Rk7QLWKsy8wQZzVOFDjs0ja6EqXG", + "summary": [] + }, + { + "id": "msg_0b764a5e13cab0ee006ae54bf640dc87d0bcfbeaceef8a6926", + "type": "message", + "status": "completed", + "content": [ + { + "type": "output_text", + "annotations": [], + "logprobs": [], + "text": "Let the ball cost \\(x\\) dollars. Then the bat costs \\(x + 1.00\\).\n\n\\[\nx + (x + 1.00) = 1.10\n\\]\n\nSo \\(2x = 0.10\\), and \\(x = 0.05\\).\n\n**The ball costs 5 cents.**" + } + ], + "phase": "final_answer", + "role": "assistant" + } + ], + "parallel_tool_calls": true, + "presence_penalty": 0.0, + "previous_response_id": null, + "prompt_cache_key": null, + "prompt_cache_retention": "24h", + "reasoning": { + "context": "all_turns", + "effort": "medium", + "mode": "standard", + "summary": "detailed" + }, + "safety_identifier": null, + "service_tier": "default", + "store": true, + "temperature": 1.0, + "text": { + "format": { + "type": "text" + }, + "verbosity": "medium" + }, + "tool_choice": "auto", + "tool_usage": { + "image_gen": { + "input_tokens": 0, + "input_tokens_details": { + "image_tokens": 0, + "text_tokens": 0 + }, + "output_tokens": 0, + "output_tokens_details": { + "image_tokens": 0, + "text_tokens": 0 + }, + "total_tokens": 0 + }, + "web_search": { + "num_requests": 0 + } + }, + "tools": [], + "top_logprobs": 0, + "top_p": 0.98, + "truncation": "disabled", + "usage": { + "input_tokens": 45, + "input_tokens_details": { + "cache_write_tokens": 0, + "cached_tokens": 0 + }, + "output_tokens": 115, + "output_tokens_details": { + "reasoning_tokens": 36 + }, + "total_tokens": 160 + }, + "user": null, + "metadata": {} +} \ No newline at end of file diff --git a/packages/inference-discovery-openai/sessions/openai-responses/gpt-6.1-terra/reasoning-content/session.json b/packages/inference-discovery-openai/sessions/openai-responses/gpt-6.1-terra/reasoning-content/session.json new file mode 100644 index 000000000..fbd49b75a --- /dev/null +++ b/packages/inference-discovery-openai/sessions/openai-responses/gpt-6.1-terra/reasoning-content/session.json @@ -0,0 +1,11 @@ +{ + "schemaVersion": "2", + "source": { + "provider": "openai-responses", + "model": "gpt-6.1-terra", + "baseURL": "https://api.openai.com/v1" + }, + "origin": "live", + "capturedAt": "2026-10-31T02:01:27.368Z", + "capability": "reasoning-content" +} diff --git a/packages/inference-discovery/src/catalog/support-matrix.ts b/packages/inference-discovery/src/catalog/support-matrix.ts index b7e38695a..45f13e32b 100644 --- a/packages/inference-discovery/src/catalog/support-matrix.ts +++ b/packages/inference-discovery/src/catalog/support-matrix.ts @@ -236,6 +236,47 @@ const OPENAI_GPT4_MULTIMODAL_NOTE = "image or document content parts. Multimodal input on this Chat Completions " + "wire arrived with gpt-4o and gpt-4-turbo, not gpt-4."; +const OPENAI_RESPONSES_PROVIDER = "openai-responses"; + +// First-party OpenAI on the Responses wire (`/v1/responses`), probed by the +// openai-responses plug-in. gpt-5-mini carries the full surface the Responses +// body builder builds; gpt-5.5 carries the representative streaming, +// buffered, reasoning, and tool follow-up subset. Structured output and +// URL-form file input stay out until the runtime adapter supports them and +// discovery verifies them. +const OPENAI_RESPONSES_FULL_CAPABILITIES = [ + "plain-text", + "plain-text-streaming", + "function-calling", + "function-calling-multi-turn", + "function-calling-multi-turn-streaming", + "reasoning-content", + "reasoning-content-streaming", + "vision-input", + "document-input", +] as const satisfies readonly SupportEntry["capability"][]; + +const OPENAI_RESPONSES_REPRESENTATIVE_CAPABILITIES = [ + "plain-text", + "plain-text-streaming", + "function-calling-multi-turn", + "reasoning-content", +] as const satisfies readonly SupportEntry["capability"][]; + +// The current GPT-6 / 6.1 lines and the 5.6 variants, carried at the same +// representative subset to bound capture cost on the pricey flagships +// (gpt-6-astra lists at $10/M input, $50/M output). +const OPENAI_RESPONSES_NEWLINEUP_MODELS = [ + "gpt-6-astra", + "gpt-6.1-sol", + "gpt-6.1-terra", + "gpt-6-luna", + "gpt-6-sol", + "gpt-5.6-sol", + "gpt-5.6-terra", + "gpt-5.6-luna", +] as const; + // Builds one SupportEntry per capability for a single (provider, model, // outcome). notes is included only when supplied, so captured rows stay // notes-free while misled/unsupported rows carry their explanation. rows does @@ -705,6 +746,26 @@ const MATRIX: SupportEntry[] = [ "unsupported", OPENAI_GPT4_MULTIMODAL_NOTE, ), + ...rows( + OPENAI_RESPONSES_PROVIDER, + "gpt-5-mini", + OPENAI_RESPONSES_FULL_CAPABILITIES, + "captured", + ), + ...rows( + OPENAI_RESPONSES_PROVIDER, + "gpt-5.5", + OPENAI_RESPONSES_REPRESENTATIVE_CAPABILITIES, + "captured", + ), + ...OPENAI_RESPONSES_NEWLINEUP_MODELS.flatMap((model) => + rows( + OPENAI_RESPONSES_PROVIDER, + model, + OPENAI_RESPONSES_REPRESENTATIVE_CAPABILITIES, + "captured", + ), + ), ...XAI_MODELS.flatMap((model) => rows(XAI_PROVIDER, model, XAI_BASE_CAPTURED_CAPABILITIES, "captured"), ), @@ -750,6 +811,7 @@ const SESSION_ROOTS: Record = { "google-genai": "packages/inference-discovery-google-genai/sessions", "opencode-zen": "packages/inference-discovery-openai/sessions", openai: "packages/inference-discovery-openai/sessions", + "openai-responses": "packages/inference-discovery-openai/sessions", xai: "packages/inference-discovery-openai/sessions", }; From 46699fd664525e081aa53cdbeda1f58a76d9dc21 Mon Sep 17 00:00:00 2001 From: Sawyer Date: Fri, 30 Oct 2026 15:57:31 -0700 Subject: [PATCH 4/7] Reconstruct Responses dispatches Multi-turn captures cannot replay unless each function call is paired with the tool output that answered it, so the runner rebuilds that pairing when it reassembles dispatches. --- .../src/dispatch-reconstruction.test.ts | 79 +++++++++++++++++++ .../src/dispatch-reconstruction.ts | 41 +++++++++- 2 files changed, 119 insertions(+), 1 deletion(-) create mode 100644 packages/inference-discovery/src/dispatch-reconstruction.test.ts diff --git a/packages/inference-discovery/src/dispatch-reconstruction.test.ts b/packages/inference-discovery/src/dispatch-reconstruction.test.ts new file mode 100644 index 000000000..584968787 --- /dev/null +++ b/packages/inference-discovery/src/dispatch-reconstruction.test.ts @@ -0,0 +1,79 @@ +import { describe, test, expect } from "bun:test"; +import { extractDispatches } from "./dispatch-reconstruction"; + +function responsesBody(): Record { + return { + model: "gpt-5.5", + input: [ + { + type: "message", + role: "user", + content: "What is the weather in Boston, MA? Use the provided tool.", + }, + { + type: "function_call", + call_id: "call_test", + name: "get_weather", + arguments: '{"location":"Boston, MA"}', + }, + { + type: "function_call_output", + call_id: "call_test", + output: + '{"location":"Boston, MA","temperatureF":68,"conditions":"clear"}', + }, + ], + tools: [ + { + type: "function", + name: "get_weather", + description: "Look up the current weather for a city.", + parameters: { type: "object" }, + }, + ], + tool_choice: "auto", + }; +} + +describe("extractDispatches openai-responses", () => { + test("pairs function_call items with their outputs in call order", () => { + expect(extractDispatches("openai-responses", responsesBody())).toEqual([ + { + toolName: "get_weather", + args: { location: "Boston, MA" }, + result: + '{"location":"Boston, MA","temperatureF":68,"conditions":"clear"}', + }, + ]); + }); + + test("a body with no input array throws", () => { + expect(() => + extractDispatches("openai-responses", { model: "gpt-5.5" }), + ).toThrow(/no input array/); + }); + + test("a duplicate function_call_output throws", () => { + const body = responsesBody(); + const input = body["input"]; + if (!Array.isArray(input)) throw new Error("expected input array"); + input.push({ + type: "function_call_output", + call_id: "call_test", + output: "again", + }); + expect(() => extractDispatches("openai-responses", body)).toThrow( + /duplicate tool result/, + ); + }); + + test("an unpaired call throws", () => { + const body = responsesBody(); + const input = body["input"]; + if (!Array.isArray(input)) throw new Error("expected input array"); + input.pop(); + expect(() => extractDispatches("openai-responses", body)).toThrow( + /has no matching tool_result/, + ); + }); +}); diff --git a/packages/inference-discovery/src/dispatch-reconstruction.ts b/packages/inference-discovery/src/dispatch-reconstruction.ts index bfdfff9aa..52dd7a9b4 100644 --- a/packages/inference-discovery/src/dispatch-reconstruction.ts +++ b/packages/inference-discovery/src/dispatch-reconstruction.ts @@ -87,6 +87,42 @@ function requireMessages(body: Record): unknown[] { return messages; } +function requireResponsesInput(body: Record): unknown[] { + const input = body.input; + if (!Array.isArray(input)) { + throw new Error("dispatch reconstruction: request body has no input array"); + } + return input; +} + +function extractResponsesDispatches( + body: Record, +): ReconstructedDispatch[] { + const calls: { id: string; name: string; args: unknown }[] = []; + const results = new Map(); + for (const item of requireResponsesInput(body)) { + if (!isRecord(item)) continue; + if (item.type === "function_call") { + calls.push({ + id: String(item.call_id), + name: String(item.name), + args: JSON.parse(String(item.arguments)), + }); + } else if (item.type === "function_call_output") { + const id = String(item.call_id); + if (results.has(id)) { + throw new Error( + `dispatch reconstruction: Responses duplicate tool result for ${JSON.stringify(id)}`, + ); + } + // The output is the verbatim string the client fed back; storing it + // unparsed reproduces it exactly when the adapter re-emits it. + results.set(id, item.output); + } + } + return pairById(calls, results, "openai-responses"); +} + function extractAnthropicDispatches( body: Record, ): ReconstructedDispatch[] { @@ -211,7 +247,8 @@ function extractGoogleDispatches( // `adapterProvider` is the adapter-registry key the replay harness drives // runInference against, so the extractor keys off the same name. The catalog // providers `openai` and `opencode-zen` both speak the OpenAI protocol and -// resolve to the one `openai-compatible` adapter. +// resolve to the one `openai-compatible` adapter, while `openai-responses` +// speaks the Responses protocol and resolves to `openai-responses`. export function extractDispatches( adapterProvider: string, body: Record, @@ -221,6 +258,8 @@ export function extractDispatches( return extractAnthropicDispatches(body); case "openai-compatible": return extractOpenAIDispatches(body); + case "openai-responses": + return extractResponsesDispatches(body); case "google-genai": return extractGoogleDispatches(body); default: From 39cad13644ca09ef6264123b6453dd9b04829975 Mon Sep 17 00:00:00 2001 From: Sawyer Date: Fri, 30 Oct 2026 15:57:59 -0700 Subject: [PATCH 5/7] Ground catalog offerings in Responses evidence Add the OpenAI Responses provider with ten offerings baked from fixture-backed matrix rows, plus the credential and price fixtures the seed coverage gate requires. --- bin/lib/catalog-dev-fixtures.ts | 16 +++ .../inference-catalog/src/catalog.test.ts | 22 ++++ packages/inference-catalog/src/models.ts | 5 + packages/inference-catalog/src/providers.ts | 123 ++++++++++++++++++ packages/inference-catalog/src/quirks.ts | 19 +++ 5 files changed, 185 insertions(+) diff --git a/bin/lib/catalog-dev-fixtures.ts b/bin/lib/catalog-dev-fixtures.ts index 1d15fe7b1..efb9e1e8f 100644 --- a/bin/lib/catalog-dev-fixtures.ts +++ b/bin/lib/catalog-dev-fixtures.ts @@ -47,6 +47,10 @@ export const credentialFixtures: Record = { credentialName: "xAI Direct Key", credentialSecret: "xai-fake-key-for-seed-data", }, + "OpenAI Responses": { + credentialName: "OpenAI Responses Key", + credentialSecret: "sk-responses-fake-key-for-seed-data", + }, }; // Dev pricing as decimal strings, matching the API's string money fields. @@ -88,6 +92,18 @@ export const priceFixtures: Record> = { "grok-4.5": { input: "0.000002", output: "0.000006" }, "grok-4.6": { input: "0.000002", output: "0.000006" }, }, + "OpenAI Responses": { + "gpt-6-astra": { input: "0.00001", output: "0.00005" }, + "gpt-6.1-sol": { input: "0.000002", output: "0.00001" }, + "gpt-6.1-terra": { input: "0.000001", output: "0.000005" }, + "gpt-6-luna": { input: "0.0000001", output: "0.0000005" }, + "gpt-6-sol": { input: "0.000002", output: "0.00001" }, + "gpt-5.6-sol": { input: "0.000004", output: "0.00002" }, + "gpt-5.6-terra": { input: "0.000002", output: "0.000012" }, + "gpt-5.6-luna": { input: "0.0000002", output: "0.0000012" }, + "gpt-5.5": { input: "0.000005", output: "0.00003" }, + "gpt-5-mini": { input: "0.00000025", output: "0.000002" }, + }, }; // Offerings intentionally seeded without pricing, keyed by provider name to the diff --git a/packages/inference-catalog/src/catalog.test.ts b/packages/inference-catalog/src/catalog.test.ts index 98b3d4e45..4f8b44c90 100644 --- a/packages/inference-catalog/src/catalog.test.ts +++ b/packages/inference-catalog/src/catalog.test.ts @@ -8,6 +8,7 @@ import { AnthropicQuirks, GoogleGenAIQuirks, OpenAIQuirks, + ResponsesQuirks, } from "@intx/inference/providers"; import { baseURLForCatalogProvider, @@ -26,6 +27,7 @@ const quirkValidatorByPlugin: Record = { anthropic: AnthropicQuirks, openai: OpenAIQuirks, "openai-compatible": OpenAIQuirks, + "openai-responses": ResponsesQuirks, "google-genai": GoogleGenAIQuirks, }; @@ -71,6 +73,26 @@ describe("first-party OpenAI maxEffort", () => { } }); +describe("OpenAI Responses reasoning", () => { + // Same maxEffort contract as above, read from the Responses adapter's + // nested key, plus the summary every Responses offering requests. + // Exact equality, so a removed or swapped field fails the build the + // same as for Direct. + const expected: Record = { + "gpt-5.5": { maxEffort: "xhigh", summary: "detailed" }, + "gpt-5.6-sol": { maxEffort: "max", summary: "detailed" }, + }; + const responses = catalogProviders.find((p) => p.name === "OpenAI Responses"); + if (responses === undefined) throw new Error("OpenAI Responses is missing"); + for (const offering of responses.offerings) { + test(`${offering.model} carries the expected reasoning quirks`, () => { + expect(offering.quirks["reasoning"]).toEqual( + expected[offering.model] ?? { summary: "detailed" }, + ); + }); + } +}); + describe("catalog offering capabilities", () => { for (const provider of catalogProviders) { for (const offering of provider.offerings) { diff --git a/packages/inference-catalog/src/models.ts b/packages/inference-catalog/src/models.ts index 4fd058fbb..ab31c2705 100644 --- a/packages/inference-catalog/src/models.ts +++ b/packages/inference-catalog/src/models.ts @@ -102,4 +102,9 @@ export const catalogModels: CatalogModelSpec[] = [ { canonicalName: "grok-4.5", displayName: "Grok 4.5" }, { canonicalName: "grok-4.6", displayName: "Grok 4.6" }, { canonicalName: "grok-build-0.1", displayName: "Grok Build 0.1" }, + { canonicalName: "gpt-6-astra", displayName: "GPT-6 Astra" }, + { canonicalName: "gpt-6.1-sol", displayName: "GPT-6.1 Sol" }, + { canonicalName: "gpt-6.1-terra", displayName: "GPT-6.1 Terra" }, + { canonicalName: "gpt-6-luna", displayName: "GPT-6 Luna" }, + { canonicalName: "gpt-6-sol", displayName: "GPT-6 Sol" }, ]; diff --git a/packages/inference-catalog/src/providers.ts b/packages/inference-catalog/src/providers.ts index 9d4c78bf1..474a9021a 100644 --- a/packages/inference-catalog/src/providers.ts +++ b/packages/inference-catalog/src/providers.ts @@ -4,12 +4,16 @@ import { OPENAI_FIRSTPARTY_QUIRKS, OPENAI_FIRSTPARTY_XHIGH_QUIRKS, OPENAI_REASONING_QUIRKS, + OPENAI_RESPONSES_MAX_QUIRKS, + OPENAI_RESPONSES_REASONING_QUIRKS, + OPENAI_RESPONSES_XHIGH_QUIRKS, } from "./quirks"; export type CatalogPlugin = | "anthropic" | "openai" | "openai-compatible" + | "openai-responses" | "google-genai"; export type DiscoverySource = { @@ -109,6 +113,29 @@ const OPENAI_REASONING_NO_VISION_CAPABILITIES: Capability[] = [ "structured-output-streaming", ]; +// The Responses-wire sets proven by the openai-responses matrix rows: +// gpt-5-mini carries the full builder surface; every other offering carries +// the representative streaming, buffered, tool follow-up, and reasoning +// subset. The guard test re-bakes each offering from its provenance tuple. +const OPENAI_RESPONSES_FULL_OFFERING_CAPABILITIES: Capability[] = [ + "plain-text", + "plain-text-streaming", + "function-calling", + "function-calling-multi-turn", + "function-calling-multi-turn-streaming", + "vision-input", + "document-input", + "reasoning-content", + "reasoning-content-streaming", +]; + +const OPENAI_RESPONSES_REPRESENTATIVE_OFFERING_CAPABILITIES: Capability[] = [ + "plain-text", + "plain-text-streaming", + "function-calling-multi-turn", + "reasoning-content", +]; + // Plain-text + reasoning only (no vision, no structured output): glm-5, glm-5.1, // deepseek-v4-pro, deepseek-v4-flash. const OPENAI_REASONING_TEXT_CAPABILITIES: Capability[] = [ @@ -510,6 +537,102 @@ export const catalogProviders: CatalogProviderSpec[] = [ }, ], }, + { + name: "OpenAI Responses", + plugin: "openai-responses", + baseURL: "https://api.openai.com/v1", + offerings: [ + { + model: "gpt-6-astra", + priority: 0, + discoverySource: { provider: "openai-responses", model: "gpt-6-astra" }, + curatedCapabilities: [], + capabilities: OPENAI_RESPONSES_REPRESENTATIVE_OFFERING_CAPABILITIES, + quirks: OPENAI_RESPONSES_REASONING_QUIRKS, + }, + { + model: "gpt-6.1-sol", + priority: 5, + discoverySource: { provider: "openai-responses", model: "gpt-6.1-sol" }, + curatedCapabilities: [], + capabilities: OPENAI_RESPONSES_REPRESENTATIVE_OFFERING_CAPABILITIES, + quirks: OPENAI_RESPONSES_REASONING_QUIRKS, + }, + { + model: "gpt-6.1-terra", + priority: 10, + discoverySource: { + provider: "openai-responses", + model: "gpt-6.1-terra", + }, + curatedCapabilities: [], + capabilities: OPENAI_RESPONSES_REPRESENTATIVE_OFFERING_CAPABILITIES, + quirks: OPENAI_RESPONSES_REASONING_QUIRKS, + }, + { + model: "gpt-6-luna", + priority: 15, + discoverySource: { provider: "openai-responses", model: "gpt-6-luna" }, + curatedCapabilities: [], + capabilities: OPENAI_RESPONSES_REPRESENTATIVE_OFFERING_CAPABILITIES, + quirks: OPENAI_RESPONSES_REASONING_QUIRKS, + }, + { + model: "gpt-6-sol", + priority: 20, + discoverySource: { provider: "openai-responses", model: "gpt-6-sol" }, + curatedCapabilities: [], + capabilities: OPENAI_RESPONSES_REPRESENTATIVE_OFFERING_CAPABILITIES, + quirks: OPENAI_RESPONSES_REASONING_QUIRKS, + }, + { + model: "gpt-5.6-sol", + priority: 25, + discoverySource: { provider: "openai-responses", model: "gpt-5.6-sol" }, + curatedCapabilities: [], + capabilities: OPENAI_RESPONSES_REPRESENTATIVE_OFFERING_CAPABILITIES, + quirks: OPENAI_RESPONSES_MAX_QUIRKS, + }, + { + model: "gpt-5.6-terra", + priority: 30, + discoverySource: { + provider: "openai-responses", + model: "gpt-5.6-terra", + }, + curatedCapabilities: [], + capabilities: OPENAI_RESPONSES_REPRESENTATIVE_OFFERING_CAPABILITIES, + quirks: OPENAI_RESPONSES_REASONING_QUIRKS, + }, + { + model: "gpt-5.6-luna", + priority: 35, + discoverySource: { + provider: "openai-responses", + model: "gpt-5.6-luna", + }, + curatedCapabilities: [], + capabilities: OPENAI_RESPONSES_REPRESENTATIVE_OFFERING_CAPABILITIES, + quirks: OPENAI_RESPONSES_REASONING_QUIRKS, + }, + { + model: "gpt-5.5", + priority: 40, + discoverySource: { provider: "openai-responses", model: "gpt-5.5" }, + curatedCapabilities: [], + capabilities: OPENAI_RESPONSES_REPRESENTATIVE_OFFERING_CAPABILITIES, + quirks: OPENAI_RESPONSES_XHIGH_QUIRKS, + }, + { + model: "gpt-5-mini", + priority: 45, + discoverySource: { provider: "openai-responses", model: "gpt-5-mini" }, + curatedCapabilities: [], + capabilities: OPENAI_RESPONSES_FULL_OFFERING_CAPABILITIES, + quirks: OPENAI_RESPONSES_REASONING_QUIRKS, + }, + ], + }, { name: "Gemini Direct", plugin: "google-genai", diff --git a/packages/inference-catalog/src/quirks.ts b/packages/inference-catalog/src/quirks.ts index f4a047dfd..4d69ca44d 100644 --- a/packages/inference-catalog/src/quirks.ts +++ b/packages/inference-catalog/src/quirks.ts @@ -28,6 +28,25 @@ export const OPENAI_FIRSTPARTY_MAX_QUIRKS: Record = { maxEffort: "max", }; +// Responses-wire counterparts of the maxEffort quirks above: the Responses +// adapter reads the value from `reasoning.maxEffort`, not the top level, and +// rejects the Chat keys. The values are carried from the Chat entries for +// the same models — no Responses-side capture has yet sent `xhigh` or `max` +// on this wire (INTR-720 tracks per-capture rig options to prove them). +// Every Responses offering also requests a `detailed` reasoning summary: +// the fixtures prove the server returns summary text when asked, and the +// adapter only forwards `summary` when this quirk is set — without it, +// `reasoning-content` calls would yield empty thinking blocks. +export const OPENAI_RESPONSES_REASONING_QUIRKS: Record = { + reasoning: { summary: "detailed" }, +}; +export const OPENAI_RESPONSES_XHIGH_QUIRKS: Record = { + reasoning: { maxEffort: "xhigh", summary: "detailed" }, +}; +export const OPENAI_RESPONSES_MAX_QUIRKS: Record = { + reasoning: { maxEffort: "max", summary: "detailed" }, +}; + // The reasoning-bearing opencode-zen relay offerings — the kimi models plus // qwen, deepseek, glm, and mimo — advertise reasoning_content on the wire. The // OpenAI adapter no longer forces reasoning content by default, so From a1a663e7030e0b9cd2ded683a3ddb684035efe13 Mon Sep 17 00:00:00 2001 From: Sawyer Date: Fri, 30 Oct 2026 15:58:32 -0700 Subject: [PATCH 6/7] Match Chat wire encoding for tool errors Join multi-part tool results with newlines and wrap failures in error tags, since the wire schema has no field for error status. --- .../src/providers/openai-responses.test.ts | 192 ++++++++++- .../src/providers/openai-responses.ts | 321 +++++++++++++++++- 2 files changed, 494 insertions(+), 19 deletions(-) diff --git a/packages/inference/src/providers/openai-responses.test.ts b/packages/inference/src/providers/openai-responses.test.ts index d6b32aeb7..314492dfb 100644 --- a/packages/inference/src/providers/openai-responses.test.ts +++ b/packages/inference/src/providers/openai-responses.test.ts @@ -355,6 +355,36 @@ describe("openai-responses buildRequest", () => { ).toBe(false); }); + test("error tool results use the shared Chat wire encoding", () => { + const body = requestBodyOf( + [ + { + role: "user", + content: [ + { + type: "tool_result", + callId: "call-1", + content: [ + { type: "text", text: "first" }, + { type: "text", text: "second" }, + ], + isError: true, + }, + ], + timestamp: 2, + }, + ], + "gpt-5-mini", + {}, + ); + const input = requestInput(body); + expect(input).toContainEqual({ + type: "function_call_output", + call_id: "call-1", + output: "\nfirst\nsecond\n", + }); + }); + test("untagged signatures are never replayed", () => { const body = requestBodyOf( [ @@ -590,6 +620,77 @@ describe("openai-responses parseResponse", () => { ]); }); + test("code interpreter deltas accumulate before the done result", () => { + const events = parse([ + { + type: "response.code_interpreter_call_code.delta", + item_id: "ci-1", + delta: "print(", + }, + { + type: "response.code_interpreter_call_code.delta", + item_id: "ci-1", + delta: "1)", + }, + { + type: "response.output_item.done", + item: { + type: "code_interpreter_call", + id: "ci-1", + status: "completed", + code: "print(1)", + outputs: null, + }, + }, + ]); + expect(events.map((e) => e.type)).toEqual([ + "inference.code_execution.start", + "inference.code_execution.delta", + "inference.code_execution.delta", + "inference.code_execution.result", + ]); + const result = events.find( + (e) => e.type === "inference.code_execution.result", + ); + if (result?.type !== "inference.code_execution.result") { + throw new Error("expected a code execution result"); + } + expect(result.data.result).toMatchObject({ + requestId: "ci-1", + status: "ok", + }); + }); + + test("content_part.done emits citations without duplicating text", () => { + const events = parse([ + { + type: "response.output_text.delta", + item_id: "m1", + delta: "hello world", + }, + { + type: "response.content_part.done", + item_id: "m1", + part: { + type: "output_text", + text: "hello world", + annotations: [ + { + type: "url_citation", + start_index: 0, + end_index: 5, + url: "https://example.com", + }, + ], + }, + }, + ]); + expect(events.map((e) => e.type)).toEqual([ + "inference.text.delta", + "inference.citation", + ]); + }); + test("orphan argument delta throws protocol mismatch", () => { const adapter = createOpenAIResponsesAdapter(createSource()); expect(() => @@ -789,10 +890,23 @@ describe("openai-responses parseJSONResponse", () => { expect(usage.data.usage).toMatchObject({ input: 10, output: 5 }); }); - test("failed status throws instead of decoding an empty turn", () => { - expect(() => - parseJson({ status: "failed", output: [], error: { message: "nope" } }), - ).toThrow(/status is "failed"/); + test("explicit null error and incomplete_details decode", () => { + const events = parseJson({ + status: "completed", + output: [ + { + type: "message", + content: [{ type: "output_text", text: "hello" }], + }, + ], + error: null, + incomplete_details: null, + usage: { input_tokens: 1, output_tokens: 1 }, + }); + expect(events.map((e) => e.type)).toEqual([ + "inference.text.delta", + "inference.usage", + ]); }); test("buffered incomplete with a content_filter reason emits a safety rating", () => { @@ -814,6 +928,76 @@ describe("openai-responses parseJSONResponse", () => { ]); }); + test("url_citation annotations emit anchored citations", () => { + const events = parseJson({ + output: [ + { + type: "message", + content: [ + { + type: "output_text", + text: "hello world", + annotations: [ + { + type: "url_citation", + start_index: 0, + end_index: 5, + url: "https://example.com", + title: "Example", + }, + ], + }, + ], + }, + ], + }); + const citation = events.find((e) => e.type === "inference.citation"); + if (citation?.type !== "inference.citation") { + throw new Error("expected a citation event"); + } + expect(citation.data.citation).toMatchObject({ + citedText: "hello", + source: { uri: "https://example.com", title: "Example" }, + textOffset: { start: 0, end: 5 }, + }); + }); + + test("code_interpreter_call emits code execution request and result", () => { + const events = parseJson({ + output: [ + { + type: "code_interpreter_call", + id: "ci-1", + status: "completed", + code: "print(1)", + outputs: null, + }, + ], + }); + expect(events.map((e) => e.type)).toEqual([ + "inference.code_execution.start", + "inference.code_execution.result", + "inference.usage", + ]); + const result = events.find( + (e) => e.type === "inference.code_execution.result", + ); + if (result?.type !== "inference.code_execution.result") { + throw new Error("expected a code execution result"); + } + expect(result.data.result).toMatchObject({ + requestId: "ci-1", + status: "ok", + providerOutcome: "completed", + }); + }); + + test("failed status throws instead of decoding an empty turn", () => { + expect(() => + parseJson({ status: "failed", output: [], error: { message: "nope" } }), + ).toThrow(/status is "failed"/); + }); + test("malformed body throws protocol mismatch", () => { const adapter = createOpenAIResponsesAdapter(createSource()); expect(() => adapter.parseJSONResponse("{bad")).toThrow( diff --git a/packages/inference/src/providers/openai-responses.ts b/packages/inference/src/providers/openai-responses.ts index 1a39ee99a..b58dd0c5a 100644 --- a/packages/inference/src/providers/openai-responses.ts +++ b/packages/inference/src/providers/openai-responses.ts @@ -207,18 +207,8 @@ function toolResultText( if (c.type === "text") parts.push(c.text); else parts.push(`[unsupported ${c.type} content omitted]`); } - return parts.join(""); -} - -// Grounded on the OpenAI Responses API document input shape: a base64 -// document synthesizes a deterministic filename from its mimeType, since -// MediaSource carries no filename field of its own. Only PDF is supported -// today, matching the Chat Completions adapter's own document support. -function filenameForDocumentMime(mimeType: string): string { - if (mimeType === "application/pdf") return "document.pdf"; - throw new Error( - `openai-responses adapter: document input currently supports application/pdf only; received mimeType: ${mimeType}`, - ); + const text = parts.join("\n"); + return block.isError ? `\n${text}\n` : text; } // Converts one content block to zero or one Responses content part. Blocks @@ -623,6 +613,24 @@ const OutputItemDoneEvent = type({ "encrypted_content?": "string", }, }); +const CodeInterpreterDoneEvent = type({ + item: { + type: "'code_interpreter_call'", + id: "string", + status: "'completed' | 'failed'", + code: "string", + "container_id?": "string", + "outputs?": "unknown", + }, +}); +const CodeInterpreterCodeDeltaEvent = type({ + item_id: "string > 0", + delta: "string", +}); +const ContentPartDoneEvent = type({ + item_id: "string > 0", + part: type({ type: "string" }), +}); const ResponsesUsage = type({ "input_tokens?": "number", "output_tokens?": "number", @@ -964,8 +972,152 @@ export function parseResponse( }); } } + if (item.type === "code_interpreter_call") { + const call = CodeInterpreterDoneEvent(parsed); + if (call instanceof type.errors) { + throw protocolMismatch( + provider, + `output_item.done failed schema validation: ${call.summary}`, + parsed, + ); + } + const callItem = call.item; + if (callItem.outputs !== undefined && callItem.outputs !== null) { + throw protocolMismatch( + provider, + "output_item.done code_interpreter_call carries outputs the neutral code-execution result does not model", + parsed, + ); + } + if (!indexer.items.has(callItem.id)) { + events.push({ + type: "inference.code_execution.start", + seq, + data: { + request: { + type: "code_execution_request", + id: callItem.id, + code: callItem.code, + }, + index: getOrAssignBlockIndex( + indexer, + callItem.id, + "code_execution_request", + ), + }, + }); + } + events.push({ + type: "inference.code_execution.result", + seq, + data: { + result: { + type: "code_execution_result", + requestId: callItem.id, + status: callItem.status === "completed" ? "ok" : "error", + providerOutcome: callItem.status, + }, + index: getOrAssignBlockIndex( + indexer, + `${callItem.id}#result`, + "code_execution_result", + ), + }, + }); + } + return events; + } + case "response.code_interpreter_call_code.delta": { + const validated = CodeInterpreterCodeDeltaEvent(parsed); + if (validated instanceof type.errors) { + throw protocolMismatch( + provider, + `code_interpreter_call_code.delta failed schema validation: ${validated.summary}`, + parsed, + ); + } + const itemId = validated.item_id; + const existing = indexer.items.get(itemId); + if ( + existing !== undefined && + existing.kind !== "code_execution_request" + ) { + throw protocolMismatch( + provider, + `code_interpreter_call_code.delta for item_id ${itemId} routed to a ${existing.kind} block`, + parsed, + ); + } + const blockIndex = + existing === undefined + ? getOrAssignBlockIndex(indexer, itemId, "code_execution_request") + : existing.index; + if (existing === undefined) { + events.push({ + type: "inference.code_execution.start", + seq, + data: { + request: { type: "code_execution_request", id: itemId, code: "" }, + index: blockIndex, + }, + }); + } + if (validated.delta.length > 0) { + events.push({ + type: "inference.code_execution.delta", + seq, + data: { + requestId: itemId, + codeFragment: validated.delta, + index: blockIndex, + }, + }); + } + return events; + } + case "response.content_part.done": { + const validated = ContentPartDoneEvent(parsed); + if (validated instanceof type.errors) { + throw protocolMismatch( + provider, + `content_part.done failed schema validation: ${validated.summary}`, + parsed, + ); + } + if (validated.part.type !== "output_text") return events; + const part = OutputTextPart(validated.part); + if (part instanceof type.errors) { + throw protocolMismatch( + provider, + `content_part.done output_text part failed schema validation: ${part.summary}`, + parsed, + ); + } + const annotations = part.annotations ?? []; + if (annotations.length === 0) return events; + if (part.text.length === 0) { + throw protocolMismatch( + provider, + "content_part.done output_text part carries annotations but no text to anchor them against", + parsed, + ); + } + const index = getOrAssignBlockIndex(indexer, validated.item_id, "text"); + for (const annotation of annotations) { + events.push( + urlCitationEvent(provider, part.text, annotation, index, seq, parsed), + ); + } return events; } + case "response.web_search_call.in_progress": + case "response.web_search_call.searching": + case "response.web_search_call.completed": + case "response.code_interpreter_call.in_progress": + case "response.code_interpreter_call.interpreting": + case "response.code_interpreter_call.completed": + case "response.code_interpreter_call.done": + return events; case "response.function_call_arguments.delta": { const validated = FunctionCallArgsDeltaEvent(parsed); if (validated instanceof type.errors) { @@ -1135,8 +1287,33 @@ export function isResponsesStreamTerminal(sseData: string): boolean { // them on first observation. // --------------------------------------------------------------------------- -const OutputTextPart = type({ type: "'output_text'", text: "string" }); +const UrlCitationAnnotation = type({ + type: "'url_citation'", + start_index: "number", + end_index: "number", + url: "string", + "title?": "string", +}); +const OutputTextPart = type({ + type: "'output_text'", + text: "string", + "annotations?": UrlCitationAnnotation.array(), +}); const RefusalPart = type({ type: "'refusal'", refusal: "string" }); +const WebSearchCallItem = type({ + type: "'web_search_call'", + id: "string", + "status?": "string", + "action?": "unknown", +}); +const CodeInterpreterCallItem = type({ + type: "'code_interpreter_call'", + id: "string", + status: "'completed' | 'failed'", + code: "string", + "container_id?": "string", + "outputs?": "unknown", +}); // Content parts are validated individually by kind, same rationale as // output items below: an "unknown kind, ignore it" fallback branch defeats // narrowing on the known branches. @@ -1170,10 +1347,51 @@ const CompleteResponse = type({ "usage?": ResponsesUsage, "status?": "'completed' | 'failed' | 'incomplete' | 'in_progress' | 'cancelled' | 'queued'", - "error?": { "message?": "string" }, - "incomplete_details?": { "reason?": "string" }, + "error?": type({ "message?": "string" }).or("null"), + "incomplete_details?": type({ "reason?": "string" }).or("null"), }); +function urlCitationEvent( + provider: string, + text: string, + annotation: typeof UrlCitationAnnotation.infer, + index: number, + seq: number, + raw: unknown, +): InferenceEvent { + const start = annotation.start_index; + const end = annotation.end_index; + if ( + !Number.isInteger(start) || + !Number.isInteger(end) || + start < 0 || + end <= start || + end > text.length + ) { + throw new ProtocolMismatchError( + `${provider} parseJSONResponse: url_citation annotation has an invalid span: ${JSON.stringify({ start_index: start, end_index: end, textLength: text.length })}`, + raw, + ); + } + const source = + annotation.title === undefined + ? { uri: annotation.url } + : { uri: annotation.url, title: annotation.title }; + return { + type: "inference.citation", + seq, + data: { + citation: { + type: "citation", + citedText: text.slice(start, end), + source, + textOffset: { start, end }, + }, + index, + }, + }; +} + export function parseJSONResponse( body: string, source: LastCycleSource, @@ -1232,6 +1450,13 @@ export function parseJSONResponse( rawPart, ); } + const annotations = part.annotations ?? []; + if (annotations.length > 0 && part.text.length === 0) { + throw new ProtocolMismatchError( + `${provider} parseJSONResponse: output_text part carries annotations but no text to anchor them against`, + rawPart, + ); + } if (part.text.length > 0) { events.push({ type: "inference.text.delta", @@ -1242,6 +1467,18 @@ export function parseJSONResponse( index: nextIndex, }, }); + for (const annotation of annotations) { + events.push( + urlCitationEvent( + provider, + part.text, + annotation, + nextIndex, + seq, + rawPart, + ), + ); + } nextIndex += 1; } } else if (rawPart.type === "refusal") { @@ -1326,6 +1563,60 @@ export function parseJSONResponse( }, }); } + } else if (rawItem.type === "web_search_call") { + const item = WebSearchCallItem(rawItem); + if (item instanceof type.errors) { + throw new ProtocolMismatchError( + `${provider} parseJSONResponse: web_search_call output item failed schema validation: ${item.summary}`, + rawItem, + ); + } + // A web_search_call is provider-executed: the model-visible evidence is + // the url_citation annotations on the message text, parsed above. The + // call item itself carries no neutral block, so it contributes no event. + } else if (rawItem.type === "code_interpreter_call") { + const item = CodeInterpreterCallItem(rawItem); + if (item instanceof type.errors) { + throw new ProtocolMismatchError( + `${provider} parseJSONResponse: code_interpreter_call output item failed schema validation: ${item.summary}`, + rawItem, + ); + } + if (item.outputs !== undefined && item.outputs !== null) { + throw new ProtocolMismatchError( + `${provider} parseJSONResponse: code_interpreter_call carries outputs the neutral code-execution result does not model`, + rawItem, + ); + } + const requestIndex = nextIndex; + nextIndex += 1; + const resultIndex = nextIndex; + nextIndex += 1; + events.push({ + type: "inference.code_execution.start", + seq, + data: { + request: { + type: "code_execution_request", + id: item.id, + code: item.code, + }, + index: requestIndex, + }, + }); + events.push({ + type: "inference.code_execution.result", + seq, + data: { + result: { + type: "code_execution_result", + requestId: item.id, + status: item.status === "completed" ? "ok" : "error", + providerOutcome: item.status, + }, + index: resultIndex, + }, + }); } // Unknown output item kinds are protocol-legal extensions this adapter // has nothing to do with; ignored, mirroring the SSE default case. From 32c396e0852f4626a5f8b913fed4285c241b2298 Mon Sep 17 00:00:00 2001 From: Sawyer Date: Fri, 30 Oct 2026 16:00:49 -0700 Subject: [PATCH 7/7] Add Responses web search and code execution Probe-built web_search and code_interpreter tools on gpt-5-mini. Parse citations and code execution events in both JSON and SSE. Ground catalog offerings in the new fixtures. --- packages/inference-catalog/src/providers.ts | 4 + packages/inference-discovery-openai/README.md | 13 +- .../exchanges/0/request-headers.json | 4 + .../exchanges/0/request.json | 20 ++ .../exchanges/0/response-headers.json | 25 ++ .../exchanges/0/response.sse | 306 ++++++++++++++++++ .../code-execution-streaming/session.json | 11 + .../exchanges/0/request-headers.json | 4 + .../code-execution/exchanges/0/request.json | 19 ++ .../exchanges/0/response-headers.json | 26 ++ .../code-execution/exchanges/0/response.json | 131 ++++++++ .../gpt-5-mini/code-execution/session.json | 11 + .../exchanges/0/request-headers.json | 4 + .../exchanges/0/request.json | 16 + .../exchanges/0/response-headers.json | 25 ++ .../exchanges/0/response.sse | 126 ++++++++ .../grounding-streaming/session.json | 11 + .../exchanges/0/request-headers.json | 4 + .../grounding/exchanges/0/request.json | 15 + .../exchanges/0/response-headers.json | 26 ++ .../grounding/exchanges/0/response.json | 163 ++++++++++ .../gpt-5-mini/grounding/session.json | 11 + .../src/openai-responses.plugin.test.ts | 70 +++- .../src/protocol/responses-body.ts | 33 ++ .../src/catalog/support-matrix.ts | 12 +- 25 files changed, 1078 insertions(+), 12 deletions(-) create mode 100644 packages/inference-discovery-openai/sessions/openai-responses/gpt-5-mini/code-execution-streaming/exchanges/0/request-headers.json create mode 100644 packages/inference-discovery-openai/sessions/openai-responses/gpt-5-mini/code-execution-streaming/exchanges/0/request.json create mode 100644 packages/inference-discovery-openai/sessions/openai-responses/gpt-5-mini/code-execution-streaming/exchanges/0/response-headers.json create mode 100644 packages/inference-discovery-openai/sessions/openai-responses/gpt-5-mini/code-execution-streaming/exchanges/0/response.sse create mode 100644 packages/inference-discovery-openai/sessions/openai-responses/gpt-5-mini/code-execution-streaming/session.json create mode 100644 packages/inference-discovery-openai/sessions/openai-responses/gpt-5-mini/code-execution/exchanges/0/request-headers.json create mode 100644 packages/inference-discovery-openai/sessions/openai-responses/gpt-5-mini/code-execution/exchanges/0/request.json create mode 100644 packages/inference-discovery-openai/sessions/openai-responses/gpt-5-mini/code-execution/exchanges/0/response-headers.json create mode 100644 packages/inference-discovery-openai/sessions/openai-responses/gpt-5-mini/code-execution/exchanges/0/response.json create mode 100644 packages/inference-discovery-openai/sessions/openai-responses/gpt-5-mini/code-execution/session.json create mode 100644 packages/inference-discovery-openai/sessions/openai-responses/gpt-5-mini/grounding-streaming/exchanges/0/request-headers.json create mode 100644 packages/inference-discovery-openai/sessions/openai-responses/gpt-5-mini/grounding-streaming/exchanges/0/request.json create mode 100644 packages/inference-discovery-openai/sessions/openai-responses/gpt-5-mini/grounding-streaming/exchanges/0/response-headers.json create mode 100644 packages/inference-discovery-openai/sessions/openai-responses/gpt-5-mini/grounding-streaming/exchanges/0/response.sse create mode 100644 packages/inference-discovery-openai/sessions/openai-responses/gpt-5-mini/grounding-streaming/session.json create mode 100644 packages/inference-discovery-openai/sessions/openai-responses/gpt-5-mini/grounding/exchanges/0/request-headers.json create mode 100644 packages/inference-discovery-openai/sessions/openai-responses/gpt-5-mini/grounding/exchanges/0/request.json create mode 100644 packages/inference-discovery-openai/sessions/openai-responses/gpt-5-mini/grounding/exchanges/0/response-headers.json create mode 100644 packages/inference-discovery-openai/sessions/openai-responses/gpt-5-mini/grounding/exchanges/0/response.json create mode 100644 packages/inference-discovery-openai/sessions/openai-responses/gpt-5-mini/grounding/session.json diff --git a/packages/inference-catalog/src/providers.ts b/packages/inference-catalog/src/providers.ts index 474a9021a..c34ecf604 100644 --- a/packages/inference-catalog/src/providers.ts +++ b/packages/inference-catalog/src/providers.ts @@ -125,8 +125,12 @@ const OPENAI_RESPONSES_FULL_OFFERING_CAPABILITIES: Capability[] = [ "function-calling-multi-turn-streaming", "vision-input", "document-input", + "code-execution", + "code-execution-streaming", "reasoning-content", "reasoning-content-streaming", + "grounding", + "grounding-streaming", ]; const OPENAI_RESPONSES_REPRESENTATIVE_OFFERING_CAPABILITIES: Capability[] = [ diff --git a/packages/inference-discovery-openai/README.md b/packages/inference-discovery-openai/README.md index e2e94a182..41b6a01a7 100644 --- a/packages/inference-discovery-openai/README.md +++ b/packages/inference-discovery-openai/README.md @@ -115,12 +115,13 @@ excluded pending verification that those models serve `/responses`. The Responses body builder emits `plain-text`, `plain-text-streaming`, `function-calling`, `function-calling-multi-turn`, `reasoning-content`, -`reasoning-content-streaming`, `vision-input`, and `document-input`. -Structured output and URL-form file input are out of scope until the -runtime adapter supports them and discovery verifies them; audio, video, -image-output, code execution, and grounding are not built. Refresh the -fixtures with a live capture run (`bin/discover --provider -openai-responses --all` against a funded account). +`reasoning-content-streaming`, `vision-input`, `document-input`, +`code-execution`, `code-execution-streaming`, `grounding`, and +`grounding-streaming`. Structured output and URL-form file input are out of +scope until the runtime adapter supports them and discovery verifies them; +audio, video, and image-output are not built. Refresh the fixtures with a +live capture run (`bin/discover --provider openai-responses --all` against +a funded account). ### Environment diff --git a/packages/inference-discovery-openai/sessions/openai-responses/gpt-5-mini/code-execution-streaming/exchanges/0/request-headers.json b/packages/inference-discovery-openai/sessions/openai-responses/gpt-5-mini/code-execution-streaming/exchanges/0/request-headers.json new file mode 100644 index 000000000..28c14bb85 --- /dev/null +++ b/packages/inference-discovery-openai/sessions/openai-responses/gpt-5-mini/code-execution-streaming/exchanges/0/request-headers.json @@ -0,0 +1,4 @@ +{ + "Content-Type": "application/json", + "Authorization": "" +} diff --git a/packages/inference-discovery-openai/sessions/openai-responses/gpt-5-mini/code-execution-streaming/exchanges/0/request.json b/packages/inference-discovery-openai/sessions/openai-responses/gpt-5-mini/code-execution-streaming/exchanges/0/request.json new file mode 100644 index 000000000..3a9af1744 --- /dev/null +++ b/packages/inference-discovery-openai/sessions/openai-responses/gpt-5-mini/code-execution-streaming/exchanges/0/request.json @@ -0,0 +1,20 @@ +{ + "model": "gpt-5-mini", + "input": [ + { + "type": "message", + "role": "user", + "content": "Compute the 12th Fibonacci number by running code." + } + ], + "tools": [ + { + "type": "code_interpreter", + "container": { + "type": "auto", + "memory_limit": "4g" + } + } + ], + "stream": true +} diff --git a/packages/inference-discovery-openai/sessions/openai-responses/gpt-5-mini/code-execution-streaming/exchanges/0/response-headers.json b/packages/inference-discovery-openai/sessions/openai-responses/gpt-5-mini/code-execution-streaming/exchanges/0/response-headers.json new file mode 100644 index 000000000..8f33a1913 --- /dev/null +++ b/packages/inference-discovery-openai/sessions/openai-responses/gpt-5-mini/code-execution-streaming/exchanges/0/response-headers.json @@ -0,0 +1,25 @@ +{ + "access-control-expose-headers": "X-Request-ID, Server-Timing-Total, CF-Ray, CF-Ray", + "alt-svc": "h3=\":443\"; ma=86400", + "cf-cache-status": "DYNAMIC", + "cf-ray": "a528a3c08cf32a8e-LAX", + "connection": "keep-alive", + "content-type": "text/event-stream; charset=utf-8", + "date": "Fri, 30 Oct 2026 07:17:20 GMT", + "openai-organization": "", + "openai-processing-ms": "778", + "openai-project": "", + "openai-version": "2020-10-01", + "server": "cloudflare", + "strict-transport-security": "max-age=31536000; includeSubDomains; preload", + "transfer-encoding": "chunked", + "x-content-type-options": "nosniff", + "x-ratelimit-limit-requests": "5000", + "x-ratelimit-limit-tokens": "2000000", + "x-ratelimit-remaining-requests": "4999", + "x-ratelimit-remaining-tokens": "1999114", + "x-ratelimit-reset-requests": "12ms", + "x-ratelimit-reset-tokens": "26ms", + "x-request-id": "", + "set-cookie": "" +} diff --git a/packages/inference-discovery-openai/sessions/openai-responses/gpt-5-mini/code-execution-streaming/exchanges/0/response.sse b/packages/inference-discovery-openai/sessions/openai-responses/gpt-5-mini/code-execution-streaming/exchanges/0/response.sse new file mode 100644 index 000000000..1606f306f --- /dev/null +++ b/packages/inference-discovery-openai/sessions/openai-responses/gpt-5-mini/code-execution-streaming/exchanges/0/response.sse @@ -0,0 +1,306 @@ +event: response.created +data: {"type":"response.created","response":{"id":"resp_0e31e323da9c6f51006ae4448032dc87d09b4ed03459fa2d4d","object":"response","created_at":1793344640,"status":"in_progress","access_programs":null,"background":false,"completed_at":null,"error":null,"frequency_penalty":0.0,"incomplete_details":null,"instructions":null,"max_output_tokens":null,"max_tool_calls":null,"model":"gpt-5-mini-2025-08-07","moderation":null,"output":[],"parallel_tool_calls":true,"presence_penalty":0.0,"previous_response_id":null,"prompt_cache_key":null,"prompt_cache_retention":"in_memory","reasoning":{"context":"current_turn","effort":"medium","mode":"standard","summary":null},"safety_identifier":null,"service_tier":"auto","store":true,"temperature":1.0,"text":{"format":{"type":"text"},"verbosity":"medium"},"tool_choice":"auto","tool_usage":{"image_gen":{"input_tokens":0,"input_tokens_details":{"image_tokens":0,"text_tokens":0},"output_tokens":0,"output_tokens_details":{"image_tokens":0,"text_tokens":0},"total_tokens":0},"web_search":{"num_requests":0}},"tools":[{"type":"code_interpreter","container":{"type":"auto"}}],"top_logprobs":0,"top_p":1.0,"truncation":"disabled","usage":null,"user":null,"metadata":{}},"sequence_number":0} + +event: response.in_progress +data: {"type":"response.in_progress","response":{"id":"resp_0e31e323da9c6f51006ae4448032dc87d09b4ed03459fa2d4d","object":"response","created_at":1793344640,"status":"in_progress","access_programs":null,"background":false,"completed_at":null,"error":null,"frequency_penalty":0.0,"incomplete_details":null,"instructions":null,"max_output_tokens":null,"max_tool_calls":null,"model":"gpt-5-mini-2025-08-07","moderation":null,"output":[],"parallel_tool_calls":true,"presence_penalty":0.0,"previous_response_id":null,"prompt_cache_key":null,"prompt_cache_retention":"in_memory","reasoning":{"context":"current_turn","effort":"medium","mode":"standard","summary":null},"safety_identifier":null,"service_tier":"auto","store":true,"temperature":1.0,"text":{"format":{"type":"text"},"verbosity":"medium"},"tool_choice":"auto","tool_usage":{"image_gen":{"input_tokens":0,"input_tokens_details":{"image_tokens":0,"text_tokens":0},"output_tokens":0,"output_tokens_details":{"image_tokens":0,"text_tokens":0},"total_tokens":0},"web_search":{"num_requests":0}},"tools":[{"type":"code_interpreter","container":{"type":"auto"}}],"top_logprobs":0,"top_p":1.0,"truncation":"disabled","usage":null,"user":null,"metadata":{}},"sequence_number":1} + +event: response.output_item.added +data: {"type":"response.output_item.added","item":{"id":"rs_0e31e323da9c6f51006ae444811c6087d0a74ac9a827f3a465","type":"reasoning","content":[],"encrypted_content":"gAAAAABq5ESBVfJBF2URgt6iAt3L4Y2Sr8B45owBCO20p801tgcJHn0FLKnKRBtq0ORVMDXwv83NqKA8VQmI_gUolYgDTj8SKM1czVX2B797D8SeDAlkBySGMAz6TRcXneezCT7V7hsUPQ4Vww1BKh2UADg1wtVe-s-msdohiEIz9R12557zJy7DDsy_ZkdLMlhFA7aWLoBXWu06c0XvNlxRVWHqXZEhGqxFJyOvu31RvZjsoUrhUH9tBEfjrdT7Z3WpQVGEy-dRbT2pus3jqyCSD-kaRKVjCW1_k29WfC05P4XwCG4_ZQMHCC3jOwzwIPhbA6zGuzafxbt-qmVOsC0EdWq1sTD01P8jTfVePwL88dgY-0tVJGHXB0pyoMId0NOC2qNHE9Ad_WkU0Hu4zlXuQZI-s0MTKSCgNabTldU7LOJWkFO8x_t7UtLfV7uKD2laBA2e4TpX087vGNWzVkdPlu2GCLmOz4lSl6QLqlu7k10z5tH5f0nG0kIuVr2apVPK72tGZ12lovo-pRPYocN3YF0OGSIqNkEOt69MrqSMjNh9z56UzbiHAsIgp0AZDerZy1Wo2oqQmoXjnTR9gkmAAzCDIVVwjW2Fb_8fGMnEOm1af-m3e9ZJcTsn4F7Dbuu75Ug9U2jUUqwEFXQvrZQJUbvynvbW19ivN-BP3Krsd37D1HbojJo7XjWqKb1MEEfKDdQvflpeAge4Qp9ihsM_GvVXC6ltJXyQGHq1R4C_tdfz3e-88_q6ojZPVLeh0R-5ZkXBVW7Qu_8YebP3lqTRzVP2w86kOic7A6hiFOPMdFLUvz85ZQacySR7k7Tn1q5zrBh0hrNzwn9O3KfZYV5ePzfAETXX1X7OfFy3_P4Aamz806lMzZ2nrKLYh4NeSDEtUh9ZAO9V7O-ZqGNKQXANj_CLnEZl_RRQRnAn3B5CVVyst_s5PTPCAXTLkllr7DA5e8ETkI5UIupgl7X4VrbuMXggqUwI61FFes8ewe0ev2yJVDQQxda0RGJHEIESRQzf2yiouJI1hcfakkBNjsB-7DWL6XbTmbgJ0LQMgmzV0GCoznqbJJw-ymcWRqZzwIbWIZpf1Ns20TUPkLHqGPJA58dTE9euzpHeNsdJ3j7q3Sa7XRRdjFqScPsH6bkineZcc1eZ1uRRRwDclRBEudjaWRWEbDY4Slzn85PK3bSX73IIWyTl6ebwA6sQWhSgpFcq7bNdySjjunRt_n_RA97mo_IcfBemOw==","summary":[]},"output_index":0,"sequence_number":2} + +event: response.output_item.done +data: {"type":"response.output_item.done","item":{"id":"rs_0e31e323da9c6f51006ae444811c6087d0a74ac9a827f3a465","type":"reasoning","content":[],"encrypted_content":"gAAAAABq5ESHHuYMNdw2QbhDd5TUkyIy-rM8irHuxGbLGP1OVYzzoSRTdO2k2N64YAE2FXcft-jweWb7XaBdDw_AzPXRqvuUscGcbjl4-FX5kwHtO6e0-QbCtR7Q94EHB9h1CB5LlbcAWvyUBBhP-qsefi6Z_lozxSg8_h_0VJJy2h759Oofan-oMgUW3m2XJ8ZwpSPprGwc7w05Ur9udsXDqi2PBIPu8XKsc2oy8szlkEGWzggAbybyp6lTEpM9OqU2h0Ln9WdByqP0Z1UPae5S-Jz9E7IAW41UvVYrCXPOn00_JUvSGOX5OWCKrJnmJk9lKz9jTDkrnTWmqn_vZbqQlq2zKoX88Uj063GBQqWzwIjeMGrq0nGw12W525Whb500Qrt_Eibz-GgUNIAW0m8MwbN8j7NcNJIEGcPc7l8h3ZCa8xQn71_ssisLNF3L3h-TOrHfQfjrRDPpU8_-iUg6eUIHb6whV7WIAHuWrNS5pQaDf8sgHXVwUAy70RrM3XGALn5J78X0WOlb9TnY1G6RPcJS3oMXQHGY-N84mIw0uqNDxNdJPzbcWaiGVvbadM6L_ToT9rWQ4usBeZcfu5SqkIJqiNWpVa28qj2DNGTLpdzXysb2NjsVSGNCH2NQ0a9YPlSMucFoxnsULqF4hQ_3b880uMvktM7eoxeqo_TK3cGxv42VLJjut0iwbE9bnoFFUv2RXIVAaD_BDQild1tXLctCzEyN0SkgsOO08FRMXFuWDCyGQuzSnaPBOm0oxrhzeFMGpQQ9VzbmU5jiYNwEj5hOSfov0Ptq5HVMD45wE2ALPUaquuIt2rQ4RaKp2PyfmaLwqPkiTUmfTCpqir0rvmTe9cuUZUaUJ19mm6TvOEK-f_MMPx0o_0uVD7dsxcVGVhqtirsNf2SFDQ1prANp3Qq1eGKfCeX-BdtHuxBm-Ga1dTIyY798dbenOXQ0yeFcSkCAN0-wc_cMB6Y1c46q8GxxTOWrg5ZIzDgpHKxXbtjnOqVwu7VyVWNROLNxC1XdxZqrtAtW-HRL08ZbInkf1DDDJdOdtvWhCMjP-1pIpTM2lYL3qRoeMvvesuoyVWALAC1uyKUNgI0v_yKxuImh5reyIytuVSqyS2O31hqSeKjgEJi4VLmgwF3P0IEVxy07Y5eQEEXFoq1Cx0c3Vs2Alu3DxR2ioC5ae4jHKzwr1DbNLA8BMuf90PjB5XmaDHlAM_xYejnU3LazdVNayDGej5O5KZ1o8DQzokS7SfX3Dzycnu0VGLOYT3uOAcPTIt1F6FAxmO5qY8n3q8cvWpPj0X7DFSJs8-jhbjXGNzktPee78tb3soNU86OWr9t9OSxYiatLFl0yGDU1sTt6zLp1zSbGmr6HYTSphRW9rFPwraxWwKbc6e2wS1QQ8f9z_zXKrq607pTnbs8RJlYdxEZIQRk9b7uBzNaxZCGtYh9zSdmrsPFptfziGz8NJCfhi_Ur1oNaxAjh1r-fnA7fmr3v-Irk8hl7OlIRRe2i5Dywu3ujjazpE_pnQqGMpS8lM2GzTGHLvcgyHsSIYzBOq8M6wpvK0J9qUqwzU6rVsoVbfzzt6ct13nAAwqfXlPtDlXFezNpSLF-_peelrmYdo6FZFLKZlM6UmmxYRRIlUm3paftCSR81Gbs3TCwzSSq6-77wKwCzukO9GEi7iPbXpeGeYuFAtuV0ot9K4FJvNwA1hAOaDPvw5F-787BXU320ZA9pUdDu582fjFk_9-jDatzXI-ZLKPaGW_GolBvqS3PmP_eGbxGDIqaaGpCQZebxP2IWnNK8BkklCRvcCHu3LKFjdfNYtJE7SpwEtw1dOcElwrXZ80gh6xJrE9QCyAt8K2iD_B-g7zUmKWXeHiIvA9mO7dzRVQ0IcJR_8IrDgBlkBTW2xNoMaIxg7oeJfkePTRpAJqLl6t37c3yJrs7wmw5P3npIKq7NsBvtYtNWjwVc3sDJl9qInlgWwgb9jwM6qNu1FQTLJNjLZc9T9yvxFeHanDbc9RNNhcUwwJexK8M-MlFDEb_5cN3AtC6PCzcWtAbNcxfzH0nX53fx7FU9bxCVPm2IqbItm9ZLyfwSWnxqkzrUY6l2VyvY_nbcc7Ws595sOftn3ACmPkTL5fRv_pGT3DwvXuPgI2S98Smm9Qeq_xMU0Q07BTkCdC0FASOLet4X4H9O-XT9LnUT8yxlS0UGoiggzuV-aeDd-jPjW4LljlwHfpzGY_wFq6NYy05uJoLkER-9AyaBD0hfaf2z8g7FBXkGOAEEObbncM7PBOUhHD51Bx1UhVZq1uu1fcgNNbgJPrD-nLF1XKc6Ei43e5Ow-M9a_6abzCT56zx6_rc0dFNkRy6v4-V69NGT76SkUqIfssk9Z0lNWDNtcc-Lj2zRIYXwe7kCCyheoKroZJxq0xIXB2CEIwltTaRdYBo1GSKXt0W25Katw4-nG5h7JakXDsCwjZdOFgT4bgrX_k9epY2nALy0BIeH0eZAZhj27O94uorsddvmN5CnOapF0pLsojyJ416lUyBVpVZr67MvdXc2WzVn-TcZPQjUMamEVN_DI9n6enVZ1TXkJe0l-xZZ3dHJ8yWD1aeF5l2LuRaybJ2QUA9sTrAO_DmKCLzyfb2dNtUZdFY7bNgK1k8_JS4vKCJ0BMwtS02F3WRg8y_wcDTgpkZCpaHzhsHoEywXukAHZi67323GLDcLXURs8XnywEptgtZrUSfZWDP9ePKL5LZ3GTR7lYJQWDH0uZbz01VUvDyC7jHZSVeON5zLeEluFr8QFVU7TTCf6TSYH_W4gsVF3pEnoEvFhfFTEUD7cQIeAUGr22YSbcslhPPs5MtTvBsX9A_Jjeb9SpJE-b7l0XPCCkjtncgiH3wwKTP1LoyouZJflbxH0hoe47I25Xib5kjkWyUKPK7iB22zTteDrp9cKhDNsURcVFZDqZJNmePx8w18n4E9qamoMdZwsnzhosVUc2obmvb4_s27AMA7-mRYW55snyK7xOpMOsZkllH8i7Fd5hkGz3JoT88yZBVHZbzJK139xMXcWk5-2fxT5B4tjBwHIIc5vbiLcoXM8dL1JotXIlykytW1tNcoNt8PkhFkupkoAX0SMaDBg_tSgiuqZ93KMSlFYo-DE_T5h9dizYDnXS7xygJsUK5g_wrKeRh_oQ00EacdOW34yQscQ03uRE0RdBefZA3PGfJ9q82ofw9-AVpQW49aox1f_Ko-9Hd3ETgrJy55zhG97yvpJK_Qmzu2xzV2oPCi2kvLUZK4z2MBSmmmGHpvt-dF-tGS7BfCJJFbZfq1CAO4TRFbOPljwLsIwBRkAUxkOw7i1zXsE7MNjyNsLF9AOdjnK5uMpDVRiWfO0GwEGsXU7eXGJduYXm8o2qFyfJ6ew9IuXXXiZ2wvymNcoLPt3zPLCpOoxODftz3-nDQN5JqbMOBLZN-Q1RppxFU_FXJDwrUVhpn15q9fWPkUIQiJ47C3YUyswRRvsG9JLazg0FAWPamGrhE9t5weNBRMGjVJmPn7qYniTrqxCp3pil6qO-u6xK1Y8KN6d2MoWV6ZRqn2br5zcazlscUkYAZL9GqWRHRF2_NzCNHDFlnUoMmqhkAhgJKb6BtesO3NuGZOYHj7uwoAqTgdV1hvty0fn3ASgmC9c54oQhsER7o3caXNB7jW445WjtSpRCGoWaz3kjFyyGsaZxe03enfBCH_knoitU1jbPGa87JUfJiUXByOHrraYdWU73eyv1Ngr6mFhJeLiecJeCY0tB0J5SSilW98Oo0fCsvJdMR_EcxebN5G9zb50hTSZSR0q0btY4zLkW6jc2vBJDsMpvf1N9OqfEeJx7emfxqG90vNZZLPXD0-deC4daj4VRaRM0OIJamZOws3Bk-LczvbhtF8HOhLxatw77cvarjwRvQmUpwIcm-y8WjTzD0GrrTuAHzF0v9jgyLUEfNQx4Ux20RswJdmiCb5B7HbKicrKGOjCHg0Dn-yt71iQdWZppddluEOgKoGKK_pQo3kI1WyPhqpxCuh2pd6URDSZXteGtjQ8ed57bb9IRXH69MWORWlIiSJ0CnjX4QU_joEPVPT9zD15SOESXjuTNLRfKR9AgaFPLWYUtG3Tc8p1g4J2xgz81K6lxqqlJhuBkXcvxB6K5ohV_UcT6YP3zPAzWuNxoLYUIJAiaojfAiy3C52DKsQWcfApUfovXrg7DGCpibdxOIAv-apaeULsnxLj4r7wE1rocNgzGenJP91Pwpgb9SnK7BExlhl-3VBkOUJYiABQ2Z6ASB8_NQq9PIBiABkHYaNrUhEbf210uOSQ_w1ne5L9ziY0dfE0Xsa6tgU4KSikpTRoIvtFp4fkoZW5LPC-sctZjBtQtVTQW99wbvZNWVrquBiQWpc0M_aRV1aCIoAFYvmY9872d792HMD4j_fiXtaQkuUgMkmRxi8PmyinboJ9NgWU2DJrzpKrX-UCO2hEFBZAohtRStdbnAqz9PuMm_kMBNGWW1pFz1TOpF2krsy9uh6STdjcPRwNCghjOyZicLxn-ikohHciMlFIy8j4vcbmfbZ4r836LAA2NAg59dhYHsRi7-LGncWIYxQQf_ZT_C7nwaM5mWW_bk8hSuzSiTkwwv1XbkjEuKhrLyKSp2NE-DlGWqe5KkLr1C6-T9_8dVsdmsx103ZGXrbNDxWPt_aujehCwK_N4yB6PRcpYF6WzYPVsZF8D1Za0h5_6oDPIKqaiLGr_ZrGA1sQoLgTrJwOV8tZj5QuuYksJS_Cd1H03xg2qaMj8fSawgoGIVOlhtEFAni-7K7fV9MeYMkLJh3qHVPlppFkJ0RzpPOjXeEm7C7cyb1qzpBATlJ58aRiSu7G13DU8Yyvu8lZEerzbTLldnU7zZiz91lGutUzH_JkAsCdsk6_V2Omms2Y21tOJJHZdvJf6C6m3keQuWBW3swYJxkceS1JnFOZ-_hLicX1qdqBVIobv1_YYD7-VEooOWWTV8cGiJSkz_gsrOaVJSSFlhvnyi64yWSXisCzUE7QGY-CnwRR6McItvg_yJFR6DlTFFFG8RKfq-Or6H4hDv0MnlN1OY9ZyQxmYYER567LWdvKY_jXH0cptdOS9nJSLK5M3-PD5VZaWupaYX5wJt5M6GeqYzSg4USdRCv2XL_2kmVwWHNSuWRTiCFcd-EFXqP7Eol7S7w3hK8vJbiTwsCGAoAaXQm2M92ocpwif8sev4o3DlY37TUCoxaBW_jucB01TD0W0g3VAWnVhxh6rhDuutndMIg8euL8afi5tzYLfMr1abbJQs_9mmT7Xp-Py842AN6UGhZVCqON6YuVWNgd_UefxK9XOfjfpyRAs2a8XF3RcuI1LsT0VKHwau2P0r54rvG-sJsKnGm7zeBGz4QB-Xitl_6tZiw8aK5ZNItUdi4eBu6JX8fXDnNvqOBBvQ-LdA4KORXXEGpoqhbKOCOYK1rq3_nhakOyfKHKk9g58TV0t4Bm8wbBn1VMr4iGnvRy-dpU2d093LdqS7EcemJS9cpWZG3E6yEewX53AC-xyD2hpTn9P2nG_NafN9oZ--DCvfnZfYrdNLEAf7mWPgBtI9NyYFV07d6pbT8W0hDy6yHERZ45HcC04l3nnWPMQ6SmjjYKjWpmE0mF3pHZbklEwJKQWUWi7nIW6UISovHRNXEhr5iGdpqFATYxNWQIoLL0xrXO2RCohf4gb9TycDN4vvYYY7PpmDSV9UCfTUAxiRkd05GdcjyKvfLbDfmZXs9yN11oLouVfssRloyjMA3ULEX458R34sNGGUbQqwHlCQyJwRG1FYCyNAk19SbdyugNfQT_PqMkWuY9XnBt35rpDWXJToB1J9-84JE6z452SL-kWXwrEi2KlVWp_vyveXo6Lgk0ojM3HrksVcVxB8AqGL5U-2gDReMCXCOW-um2_sF8g9N3tvGYtxH9jKXbv8RAjLfLFRYcL6zE2QLeukYUft1AMt_K3_iCYaT1w2DPtU6daqucXj2MyMtNbx9NtzC1TfnNb9imhkrXMx2rDJxtIKBVIguzOrgCHMoBBgR1ZO0zxdjSCnkprMnizE4giijFyhtANJAF9Y8P3B3nVYo7_WUlChJ_vUd2vLt-pmEmk4dFMbPnEzgVgtx-NHQC4mYnDvOe-IP5OgqtdAFP5Cl97jU7LR0PGoP02DQ5AbKpORihyBRSkMfmfExzpd5NqkZy4bL0uDDq0im8R6FBzhNRr0-X12f9kvzgmvUARsTw2gjOWHWuV0IfjaqgPnLoTeWCVsgXkxQKggTTAG-0vmgHgF0jEa_iVjMJiVu6Zt-yDXAxDlDXM5NdiucaTftHC2Fb-HMcGb8CAv-tOtN9iaCDLgsDEsIwmUJ8CdWMOgUa9MJD0HqZdo0TsBGwFNEL7ZPrayOFiFCItYxdy_91HT1VoLyb5O5sWfoiwHIO1dusV-phQePJF8vOoFwq-35fzPvl3cHSIetfkF98OI8yLJ1KxEpQpLvmpxPUwjARPpb8YVQMwDeO_1POvAxjWMCN6dRxyU9ZNE-1xAIDAsyA3LkZJa0bdOjTsDGSowVv5w3tJ0FWu9IhLr9Nskpqi0ScFEHzjqpWMjtnBR5LUuzcXnkn1EVVvg3z9RlWsTeNtTl5oX9Pao9YrbAQTubRtEXBv1lOFzrqELLjmGiAf6UMPKvDbekUcatAGf6RmUKgUXwS1shnNI3n9rnU17JnxOVAfnouSvRF4A101S2Baeqers7Wmb7FxIHHsT7wMdeUtzVB-wrEpNS2VvZAVVKVI5UjRgea5wdT6FoGLPIV2OoQkXHi9gE_3If7CTZmXHVCe7qnAcHbsQm0EbCniKhEIuj5GyYGcEgzZP-PWs-crBJfV1DBaisP4Sh9iZgYVczpxyd4oHpGPdr7pX69ZR0gjHUxyBpwbvpO6u3A246coDIn5DvxK6idHgHPsAfjdmpeXOZyRlLQLPZPsocJIP4OLRWzyMvzcQ8McM95upaeYX6gNX_TLBIGQr4rJX-l3r93udZNGCx8OvB3Ne_sKkvGA0zvtKIrUWY4Zq2CRVLxpjvpPE9Q11L3FdTp-RvC2NnXu6726dzPDGILJ1YED_d7NH41RU3ebBoI08ai7AT_EOnEO_JX7l0bjOpM-x7_eJCoEb94Pr4SbHn2pTZ0clEkKDPlcO7gGU9hPKFNI3gmsdsONLOPpPkQNc7HBvi1kEtKJSDuQdaFvzI1HZxc_OsOLN4xt6Z2VdYwyLqalw5T3sDrDnmLZuEfdWqSUMuLCFPR5_Ne6sy-rU_5rPxZ4mV11krWl5W4ucrQh03znm9kMCyOSM7fbsOmAwgCcfXldJI2MkwvZ5v6FI7ECJrd8gOV5p9MkcJs1Ae8LPlWI-VJL22qgy0YdcC2ljZSNn2IT28tdSpaSqIqF4uV3DFzj3OJRvdh9doqVNXcBgZWTI53rfN3Z--xFQgEagCJJ622qTZa7xN_7243-QlmSYUzHf6BObRRWRx1xht9XZJPELy8WI5jpRfCjRgMVdzr1zmtdnCBD2muIRKVALBSYeSiiJKts3IpVDdBFDdDhwQJyd5-OFHw7MEJuxg5AJyz-tM6YDgbzflPamvwgezJoRjHz2kd_s11lhtltZDm8uU8T35l7p9KOnc6ZBiSRsjNbDdww0IO8Sq3uaOd1BekJT30K2HQcjGkeVR9fhJs9e8pW2rcka8vLv0M5IXi1if_ddF8PIKHFS3XmyFsaGFC-NemN-zB0rwlEOM5COdh54X_c6D6v2QJStjc9n8AudCTb5V9UZnTkIlf7CzS-wdg7s0j9bgMr48b1tCxcJQFrK-DO7BXJAEZiHfeBxJTVqd51WX7u4Fxa1hIm1aMv0BPgHF_MJmfgwVUIOF72gCug1BCSjxURPUb9QWPIsPt26Ywo0vKXNanCzyGLk0VNCdg93Jo0WyqqXoXpGbsbKdbttEsFlpcZp0RMmwjwYMkoItH_R_pjQU7AI-a7XHdVtQ0v7nd8VuaTjCBj2xV3rQZKeamS_zG94cg5ZHKc68fb3htSoJwNyXKRWyOidj0Dq0Yyh6hpTXeOFedCM2ABCD88ssIRTzYgMPJyoVIdOCwLV3kmSNtYoDZagCwbe4bqv01d9hxqMd5HZfvWLOjoePKPDtrGIc_vKNidAaqUrtg-BzJBCwGCy1VRjWla3GI1dhPXBTEJmzQNGHs7-FioeG7jK2U75VXLAxUVFsFTRFqFi9DWdmAMMN9DCI8Tl9NJW5NKUNmo3mpw5ppEUwrO-RLy4ZFywroenAUJ4M1q1srMl677ny1vAK5HN1rbugdJLLC9DnpSWzf__AyuPZYUD9f4DqL-lnTvhtkhBfznGkLEQat5kGm7Yhkwd0KArzN4CJ54INTwhyx58rzrfYH91s5UyVGSqm2697pQuNAfZe6K8JePOmmdP2aRPJpLZbqfA2XaXhC6FRdaiJlm7PiU8=","summary":[]},"output_index":0,"sequence_number":3} + +event: response.output_item.added +data: {"type":"response.output_item.added","item":{"id":"ci_0e31e323da9c6f51006ae444874be887d0b5bdd68e0e3af193","type":"code_interpreter_call","status":"in_progress","code":"","container_id":"cntr_6ae4448078408198b543bf14e05fa9aa0d582355793fb4d9","outputs":null},"output_index":1,"sequence_number":4} + +event: response.code_interpreter_call.in_progress +data: {"type":"response.code_interpreter_call.in_progress","item_id":"ci_0e31e323da9c6f51006ae444874be887d0b5bdd68e0e3af193","output_index":1,"sequence_number":5} + +event: response.code_interpreter_call_code.delta +data: {"type":"response.code_interpreter_call_code.delta","delta":"#","item_id":"ci_0e31e323da9c6f51006ae444874be887d0b5bdd68e0e3af193","obfuscation":"18yHEeiZiIijgpt","output_index":1,"sequence_number":6} + +event: response.code_interpreter_call_code.delta +data: {"type":"response.code_interpreter_call_code.delta","delta":" Compute","item_id":"ci_0e31e323da9c6f51006ae444874be887d0b5bdd68e0e3af193","obfuscation":"dNGzFnU2","output_index":1,"sequence_number":7} + +event: response.code_interpreter_call_code.delta +data: {"type":"response.code_interpreter_call_code.delta","delta":" the","item_id":"ci_0e31e323da9c6f51006ae444874be887d0b5bdd68e0e3af193","obfuscation":"JO4PgcGMPFS0","output_index":1,"sequence_number":8} + +event: response.code_interpreter_call_code.delta +data: {"type":"response.code_interpreter_call_code.delta","delta":" ","item_id":"ci_0e31e323da9c6f51006ae444874be887d0b5bdd68e0e3af193","obfuscation":"mgKLzu8mJvaspjq","output_index":1,"sequence_number":9} + +event: response.code_interpreter_call_code.delta +data: {"type":"response.code_interpreter_call_code.delta","delta":"12","item_id":"ci_0e31e323da9c6f51006ae444874be887d0b5bdd68e0e3af193","obfuscation":"St4lbKm8Tuu01S","output_index":1,"sequence_number":10} + +event: response.code_interpreter_call_code.delta +data: {"type":"response.code_interpreter_call_code.delta","delta":"th","item_id":"ci_0e31e323da9c6f51006ae444874be887d0b5bdd68e0e3af193","obfuscation":"pXHU8W3yHhiKDx","output_index":1,"sequence_number":11} + +event: response.code_interpreter_call_code.delta +data: {"type":"response.code_interpreter_call_code.delta","delta":" Fibonacci","item_id":"ci_0e31e323da9c6f51006ae444874be887d0b5bdd68e0e3af193","obfuscation":"oDJzfD","output_index":1,"sequence_number":12} + +event: response.code_interpreter_call_code.delta +data: {"type":"response.code_interpreter_call_code.delta","delta":" number","item_id":"ci_0e31e323da9c6f51006ae444874be887d0b5bdd68e0e3af193","obfuscation":"ltmExrjXF","output_index":1,"sequence_number":13} + +event: response.code_interpreter_call_code.delta +data: {"type":"response.code_interpreter_call_code.delta","delta":" and","item_id":"ci_0e31e323da9c6f51006ae444874be887d0b5bdd68e0e3af193","obfuscation":"Lt8SNwicnAy1","output_index":1,"sequence_number":14} + +event: response.code_interpreter_call_code.delta +data: {"type":"response.code_interpreter_call_code.delta","delta":" print","item_id":"ci_0e31e323da9c6f51006ae444874be887d0b5bdd68e0e3af193","obfuscation":"71yz4k0oQP","output_index":1,"sequence_number":15} + +event: response.code_interpreter_call_code.delta +data: {"type":"response.code_interpreter_call_code.delta","delta":" it","item_id":"ci_0e31e323da9c6f51006ae444874be887d0b5bdd68e0e3af193","obfuscation":"gHkwyiYQ4HIvW","output_index":1,"sequence_number":16} + +event: response.code_interpreter_call_code.delta +data: {"type":"response.code_interpreter_call_code.delta","delta":".\r\n","item_id":"ci_0e31e323da9c6f51006ae444874be887d0b5bdd68e0e3af193","obfuscation":"5S4mDA7vucla3","output_index":1,"sequence_number":17} + +event: response.code_interpreter_call_code.delta +data: {"type":"response.code_interpreter_call_code.delta","delta":"#","item_id":"ci_0e31e323da9c6f51006ae444874be887d0b5bdd68e0e3af193","obfuscation":"A6YPexJEmMhJlhN","output_index":1,"sequence_number":18} + +event: response.code_interpreter_call_code.delta +data: {"type":"response.code_interpreter_call_code.delta","delta":" Using","item_id":"ci_0e31e323da9c6f51006ae444874be887d0b5bdd68e0e3af193","obfuscation":"KU7svjJDEY","output_index":1,"sequence_number":19} + +event: response.code_interpreter_call_code.delta +data: {"type":"response.code_interpreter_call_code.delta","delta":" the","item_id":"ci_0e31e323da9c6f51006ae444874be887d0b5bdd68e0e3af193","obfuscation":"jYKLSEsUoHbt","output_index":1,"sequence_number":20} + +event: response.code_interpreter_call_code.delta +data: {"type":"response.code_interpreter_call_code.delta","delta":" convention","item_id":"ci_0e31e323da9c6f51006ae444874be887d0b5bdd68e0e3af193","obfuscation":"LB0mg","output_index":1,"sequence_number":21} + +event: response.code_interpreter_call_code.delta +data: {"type":"response.code_interpreter_call_code.delta","delta":" F","item_id":"ci_0e31e323da9c6f51006ae444874be887d0b5bdd68e0e3af193","obfuscation":"NinaHmdQ9XSYz1","output_index":1,"sequence_number":22} + +event: response.code_interpreter_call_code.delta +data: {"type":"response.code_interpreter_call_code.delta","delta":"0","item_id":"ci_0e31e323da9c6f51006ae444874be887d0b5bdd68e0e3af193","obfuscation":"ZN9iEfuhGa3XrL6","output_index":1,"sequence_number":23} + +event: response.code_interpreter_call_code.delta +data: {"type":"response.code_interpreter_call_code.delta","delta":" =","item_id":"ci_0e31e323da9c6f51006ae444874be887d0b5bdd68e0e3af193","obfuscation":"HTfQewaOvv5kfV","output_index":1,"sequence_number":24} + +event: response.code_interpreter_call_code.delta +data: {"type":"response.code_interpreter_call_code.delta","delta":" ","item_id":"ci_0e31e323da9c6f51006ae444874be887d0b5bdd68e0e3af193","obfuscation":"mvLu0Muabk6UdkV","output_index":1,"sequence_number":25} + +event: response.code_interpreter_call_code.delta +data: {"type":"response.code_interpreter_call_code.delta","delta":"0","item_id":"ci_0e31e323da9c6f51006ae444874be887d0b5bdd68e0e3af193","obfuscation":"vf0KWfHc6pzSUm7","output_index":1,"sequence_number":26} + +event: response.code_interpreter_call_code.delta +data: {"type":"response.code_interpreter_call_code.delta","delta":",","item_id":"ci_0e31e323da9c6f51006ae444874be887d0b5bdd68e0e3af193","obfuscation":"xrcfSV4YVEuc3fu","output_index":1,"sequence_number":27} + +event: response.code_interpreter_call_code.delta +data: {"type":"response.code_interpreter_call_code.delta","delta":" F","item_id":"ci_0e31e323da9c6f51006ae444874be887d0b5bdd68e0e3af193","obfuscation":"c2XKVqEGwtO8Cr","output_index":1,"sequence_number":28} + +event: response.code_interpreter_call_code.delta +data: {"type":"response.code_interpreter_call_code.delta","delta":"1","item_id":"ci_0e31e323da9c6f51006ae444874be887d0b5bdd68e0e3af193","obfuscation":"1fNBixtf1iEyzV0","output_index":1,"sequence_number":29} + +event: response.code_interpreter_call_code.delta +data: {"type":"response.code_interpreter_call_code.delta","delta":" =","item_id":"ci_0e31e323da9c6f51006ae444874be887d0b5bdd68e0e3af193","obfuscation":"IEaOMRPGnc1TCo","output_index":1,"sequence_number":30} + +event: response.code_interpreter_call_code.delta +data: {"type":"response.code_interpreter_call_code.delta","delta":" ","item_id":"ci_0e31e323da9c6f51006ae444874be887d0b5bdd68e0e3af193","obfuscation":"5MWxBX71FRWLuFA","output_index":1,"sequence_number":31} + +event: response.code_interpreter_call_code.delta +data: {"type":"response.code_interpreter_call_code.delta","delta":"1","item_id":"ci_0e31e323da9c6f51006ae444874be887d0b5bdd68e0e3af193","obfuscation":"Xvk3nAaME8ECdDr","output_index":1,"sequence_number":32} + +event: response.code_interpreter_call_code.delta +data: {"type":"response.code_interpreter_call_code.delta","delta":" (","item_id":"ci_0e31e323da9c6f51006ae444874be887d0b5bdd68e0e3af193","obfuscation":"WMHNtS7KocuZcm","output_index":1,"sequence_number":33} + +event: response.code_interpreter_call_code.delta +data: {"type":"response.code_interpreter_call_code.delta","delta":"so","item_id":"ci_0e31e323da9c6f51006ae444874be887d0b5bdd68e0e3af193","obfuscation":"l3xw4fIuE3nMJR","output_index":1,"sequence_number":34} + +event: response.code_interpreter_call_code.delta +data: {"type":"response.code_interpreter_call_code.delta","delta":" F","item_id":"ci_0e31e323da9c6f51006ae444874be887d0b5bdd68e0e3af193","obfuscation":"R13yyhhLJqphBU","output_index":1,"sequence_number":35} + +event: response.code_interpreter_call_code.delta +data: {"type":"response.code_interpreter_call_code.delta","delta":"12","item_id":"ci_0e31e323da9c6f51006ae444874be887d0b5bdd68e0e3af193","obfuscation":"0unhA2yAAWeGYf","output_index":1,"sequence_number":36} + +event: response.code_interpreter_call_code.delta +data: {"type":"response.code_interpreter_call_code.delta","delta":" =","item_id":"ci_0e31e323da9c6f51006ae444874be887d0b5bdd68e0e3af193","obfuscation":"1yx4vrpeJsx3Ax","output_index":1,"sequence_number":37} + +event: response.code_interpreter_call_code.delta +data: {"type":"response.code_interpreter_call_code.delta","delta":" ","item_id":"ci_0e31e323da9c6f51006ae444874be887d0b5bdd68e0e3af193","obfuscation":"k02UFSqQp0G3ZWo","output_index":1,"sequence_number":38} + +event: response.code_interpreter_call_code.delta +data: {"type":"response.code_interpreter_call_code.delta","delta":"144","item_id":"ci_0e31e323da9c6f51006ae444874be887d0b5bdd68e0e3af193","obfuscation":"FyAyDudQm0Q8m","output_index":1,"sequence_number":39} + +event: response.code_interpreter_call_code.delta +data: {"type":"response.code_interpreter_call_code.delta","delta":").\r\n","item_id":"ci_0e31e323da9c6f51006ae444874be887d0b5bdd68e0e3af193","obfuscation":"Ku9veWDrfsYQ","output_index":1,"sequence_number":40} + +event: response.code_interpreter_call_code.delta +data: {"type":"response.code_interpreter_call_code.delta","delta":"def","item_id":"ci_0e31e323da9c6f51006ae444874be887d0b5bdd68e0e3af193","obfuscation":"vM77WfodSSgaR","output_index":1,"sequence_number":41} + +event: response.code_interpreter_call_code.delta +data: {"type":"response.code_interpreter_call_code.delta","delta":" fib","item_id":"ci_0e31e323da9c6f51006ae444874be887d0b5bdd68e0e3af193","obfuscation":"AcrcLy55ZBFn","output_index":1,"sequence_number":42} + +event: response.code_interpreter_call_code.delta +data: {"type":"response.code_interpreter_call_code.delta","delta":"(n","item_id":"ci_0e31e323da9c6f51006ae444874be887d0b5bdd68e0e3af193","obfuscation":"1McN70PRbX8evW","output_index":1,"sequence_number":43} + +event: response.code_interpreter_call_code.delta +data: {"type":"response.code_interpreter_call_code.delta","delta":"):\r\n","item_id":"ci_0e31e323da9c6f51006ae444874be887d0b5bdd68e0e3af193","obfuscation":"aSfOMy6W3VTd","output_index":1,"sequence_number":44} + +event: response.code_interpreter_call_code.delta +data: {"type":"response.code_interpreter_call_code.delta","delta":" ","item_id":"ci_0e31e323da9c6f51006ae444874be887d0b5bdd68e0e3af193","obfuscation":"XwgiAOkIeL0Wh","output_index":1,"sequence_number":45} + +event: response.code_interpreter_call_code.delta +data: {"type":"response.code_interpreter_call_code.delta","delta":" a","item_id":"ci_0e31e323da9c6f51006ae444874be887d0b5bdd68e0e3af193","obfuscation":"W2cwDj2bWsjBE2","output_index":1,"sequence_number":46} + +event: response.code_interpreter_call_code.delta +data: {"type":"response.code_interpreter_call_code.delta","delta":",","item_id":"ci_0e31e323da9c6f51006ae444874be887d0b5bdd68e0e3af193","obfuscation":"xYHKrl1u0sG4JPn","output_index":1,"sequence_number":47} + +event: response.code_interpreter_call_code.delta +data: {"type":"response.code_interpreter_call_code.delta","delta":" b","item_id":"ci_0e31e323da9c6f51006ae444874be887d0b5bdd68e0e3af193","obfuscation":"TzdVmBheh38oHN","output_index":1,"sequence_number":48} + +event: response.code_interpreter_call_code.delta +data: {"type":"response.code_interpreter_call_code.delta","delta":" =","item_id":"ci_0e31e323da9c6f51006ae444874be887d0b5bdd68e0e3af193","obfuscation":"z2QXp947b4Qhc9","output_index":1,"sequence_number":49} + +event: response.code_interpreter_call_code.delta +data: {"type":"response.code_interpreter_call_code.delta","delta":" ","item_id":"ci_0e31e323da9c6f51006ae444874be887d0b5bdd68e0e3af193","obfuscation":"fcPyXCBKD9iakYR","output_index":1,"sequence_number":50} + +event: response.code_interpreter_call_code.delta +data: {"type":"response.code_interpreter_call_code.delta","delta":"0","item_id":"ci_0e31e323da9c6f51006ae444874be887d0b5bdd68e0e3af193","obfuscation":"OZS6Y2t86vf7x7s","output_index":1,"sequence_number":51} + +event: response.code_interpreter_call_code.delta +data: {"type":"response.code_interpreter_call_code.delta","delta":",","item_id":"ci_0e31e323da9c6f51006ae444874be887d0b5bdd68e0e3af193","obfuscation":"mrzAUvGpnKiXwn3","output_index":1,"sequence_number":52} + +event: response.code_interpreter_call_code.delta +data: {"type":"response.code_interpreter_call_code.delta","delta":" ","item_id":"ci_0e31e323da9c6f51006ae444874be887d0b5bdd68e0e3af193","obfuscation":"of5Y4DySZvPYIyp","output_index":1,"sequence_number":53} + +event: response.code_interpreter_call_code.delta +data: {"type":"response.code_interpreter_call_code.delta","delta":"1","item_id":"ci_0e31e323da9c6f51006ae444874be887d0b5bdd68e0e3af193","obfuscation":"QLTvE1wUxUo5nev","output_index":1,"sequence_number":54} + +event: response.code_interpreter_call_code.delta +data: {"type":"response.code_interpreter_call_code.delta","delta":"\r\n","item_id":"ci_0e31e323da9c6f51006ae444874be887d0b5bdd68e0e3af193","obfuscation":"DTsyzInHsBpGqv","output_index":1,"sequence_number":55} + +event: response.code_interpreter_call_code.delta +data: {"type":"response.code_interpreter_call_code.delta","delta":" ","item_id":"ci_0e31e323da9c6f51006ae444874be887d0b5bdd68e0e3af193","obfuscation":"T6yi6VLu0LlC3","output_index":1,"sequence_number":56} + +event: response.code_interpreter_call_code.delta +data: {"type":"response.code_interpreter_call_code.delta","delta":" for","item_id":"ci_0e31e323da9c6f51006ae444874be887d0b5bdd68e0e3af193","obfuscation":"tYEwsByfRrlf","output_index":1,"sequence_number":57} + +event: response.code_interpreter_call_code.delta +data: {"type":"response.code_interpreter_call_code.delta","delta":" _","item_id":"ci_0e31e323da9c6f51006ae444874be887d0b5bdd68e0e3af193","obfuscation":"raqI1MQOE9Bg3y","output_index":1,"sequence_number":58} + +event: response.code_interpreter_call_code.delta +data: {"type":"response.code_interpreter_call_code.delta","delta":" in","item_id":"ci_0e31e323da9c6f51006ae444874be887d0b5bdd68e0e3af193","obfuscation":"VTLQCuycUZvoT","output_index":1,"sequence_number":59} + +event: response.code_interpreter_call_code.delta +data: {"type":"response.code_interpreter_call_code.delta","delta":" range","item_id":"ci_0e31e323da9c6f51006ae444874be887d0b5bdd68e0e3af193","obfuscation":"3lqSGLWio9","output_index":1,"sequence_number":60} + +event: response.code_interpreter_call_code.delta +data: {"type":"response.code_interpreter_call_code.delta","delta":"(n","item_id":"ci_0e31e323da9c6f51006ae444874be887d0b5bdd68e0e3af193","obfuscation":"m4NHT4INI6QkJK","output_index":1,"sequence_number":61} + +event: response.code_interpreter_call_code.delta +data: {"type":"response.code_interpreter_call_code.delta","delta":"):\r\n","item_id":"ci_0e31e323da9c6f51006ae444874be887d0b5bdd68e0e3af193","obfuscation":"Gn59MVUly86f","output_index":1,"sequence_number":62} + +event: response.code_interpreter_call_code.delta +data: {"type":"response.code_interpreter_call_code.delta","delta":" ","item_id":"ci_0e31e323da9c6f51006ae444874be887d0b5bdd68e0e3af193","obfuscation":"kXKCwZjui","output_index":1,"sequence_number":63} + +event: response.code_interpreter_call_code.delta +data: {"type":"response.code_interpreter_call_code.delta","delta":" a","item_id":"ci_0e31e323da9c6f51006ae444874be887d0b5bdd68e0e3af193","obfuscation":"lymRdRcESpfDDJ","output_index":1,"sequence_number":64} + +event: response.code_interpreter_call_code.delta +data: {"type":"response.code_interpreter_call_code.delta","delta":",","item_id":"ci_0e31e323da9c6f51006ae444874be887d0b5bdd68e0e3af193","obfuscation":"LJlBEAZfHdkAccb","output_index":1,"sequence_number":65} + +event: response.code_interpreter_call_code.delta +data: {"type":"response.code_interpreter_call_code.delta","delta":" b","item_id":"ci_0e31e323da9c6f51006ae444874be887d0b5bdd68e0e3af193","obfuscation":"sfawvZzFMzfKz1","output_index":1,"sequence_number":66} + +event: response.code_interpreter_call_code.delta +data: {"type":"response.code_interpreter_call_code.delta","delta":" =","item_id":"ci_0e31e323da9c6f51006ae444874be887d0b5bdd68e0e3af193","obfuscation":"kmPcSuTDCVIAi3","output_index":1,"sequence_number":67} + +event: response.code_interpreter_call_code.delta +data: {"type":"response.code_interpreter_call_code.delta","delta":" b","item_id":"ci_0e31e323da9c6f51006ae444874be887d0b5bdd68e0e3af193","obfuscation":"UumC7JVDKngs8d","output_index":1,"sequence_number":68} + +event: response.code_interpreter_call_code.delta +data: {"type":"response.code_interpreter_call_code.delta","delta":",","item_id":"ci_0e31e323da9c6f51006ae444874be887d0b5bdd68e0e3af193","obfuscation":"cdG6cQIW7doFfSF","output_index":1,"sequence_number":69} + +event: response.code_interpreter_call_code.delta +data: {"type":"response.code_interpreter_call_code.delta","delta":" a","item_id":"ci_0e31e323da9c6f51006ae444874be887d0b5bdd68e0e3af193","obfuscation":"kmotdZbv6a9kew","output_index":1,"sequence_number":70} + +event: response.code_interpreter_call_code.delta +data: {"type":"response.code_interpreter_call_code.delta","delta":" +","item_id":"ci_0e31e323da9c6f51006ae444874be887d0b5bdd68e0e3af193","obfuscation":"hkiH2WznBdjrSt","output_index":1,"sequence_number":71} + +event: response.code_interpreter_call_code.delta +data: {"type":"response.code_interpreter_call_code.delta","delta":" b","item_id":"ci_0e31e323da9c6f51006ae444874be887d0b5bdd68e0e3af193","obfuscation":"TrMwkEyDzxHXLS","output_index":1,"sequence_number":72} + +event: response.code_interpreter_call_code.delta +data: {"type":"response.code_interpreter_call_code.delta","delta":"\r\n","item_id":"ci_0e31e323da9c6f51006ae444874be887d0b5bdd68e0e3af193","obfuscation":"WtfJoFvCVPf9MR","output_index":1,"sequence_number":73} + +event: response.code_interpreter_call_code.delta +data: {"type":"response.code_interpreter_call_code.delta","delta":" ","item_id":"ci_0e31e323da9c6f51006ae444874be887d0b5bdd68e0e3af193","obfuscation":"eSTlU7lLX0HGU","output_index":1,"sequence_number":74} + +event: response.code_interpreter_call_code.delta +data: {"type":"response.code_interpreter_call_code.delta","delta":" return","item_id":"ci_0e31e323da9c6f51006ae444874be887d0b5bdd68e0e3af193","obfuscation":"ZyAtR28Sr","output_index":1,"sequence_number":75} + +event: response.code_interpreter_call_code.delta +data: {"type":"response.code_interpreter_call_code.delta","delta":" a","item_id":"ci_0e31e323da9c6f51006ae444874be887d0b5bdd68e0e3af193","obfuscation":"GPatSpeJln7o44","output_index":1,"sequence_number":76} + +event: response.code_interpreter_call_code.delta +data: {"type":"response.code_interpreter_call_code.delta","delta":"\r\n\r\n","item_id":"ci_0e31e323da9c6f51006ae444874be887d0b5bdd68e0e3af193","obfuscation":"h6AyWS9v5GcS","output_index":1,"sequence_number":77} + +event: response.code_interpreter_call_code.delta +data: {"type":"response.code_interpreter_call_code.delta","delta":"n","item_id":"ci_0e31e323da9c6f51006ae444874be887d0b5bdd68e0e3af193","obfuscation":"gO6GhqAbCKi1lkj","output_index":1,"sequence_number":78} + +event: response.code_interpreter_call_code.delta +data: {"type":"response.code_interpreter_call_code.delta","delta":" =","item_id":"ci_0e31e323da9c6f51006ae444874be887d0b5bdd68e0e3af193","obfuscation":"aWzl6fT0MeGmWX","output_index":1,"sequence_number":79} + +event: response.code_interpreter_call_code.delta +data: {"type":"response.code_interpreter_call_code.delta","delta":" ","item_id":"ci_0e31e323da9c6f51006ae444874be887d0b5bdd68e0e3af193","obfuscation":"xcbgTn83rZyEKbG","output_index":1,"sequence_number":80} + +event: response.code_interpreter_call_code.delta +data: {"type":"response.code_interpreter_call_code.delta","delta":"12","item_id":"ci_0e31e323da9c6f51006ae444874be887d0b5bdd68e0e3af193","obfuscation":"HFk5AFFYG77RoR","output_index":1,"sequence_number":81} + +event: response.code_interpreter_call_code.delta +data: {"type":"response.code_interpreter_call_code.delta","delta":"\r\n","item_id":"ci_0e31e323da9c6f51006ae444874be887d0b5bdd68e0e3af193","obfuscation":"8mMuZciywhB9qF","output_index":1,"sequence_number":82} + +event: response.code_interpreter_call_code.delta +data: {"type":"response.code_interpreter_call_code.delta","delta":"result","item_id":"ci_0e31e323da9c6f51006ae444874be887d0b5bdd68e0e3af193","obfuscation":"3pTvo66gjc","output_index":1,"sequence_number":83} + +event: response.code_interpreter_call_code.delta +data: {"type":"response.code_interpreter_call_code.delta","delta":" =","item_id":"ci_0e31e323da9c6f51006ae444874be887d0b5bdd68e0e3af193","obfuscation":"8drJmQOcOQVG0c","output_index":1,"sequence_number":84} + +event: response.code_interpreter_call_code.delta +data: {"type":"response.code_interpreter_call_code.delta","delta":" fib","item_id":"ci_0e31e323da9c6f51006ae444874be887d0b5bdd68e0e3af193","obfuscation":"jqfz39lFsHh3","output_index":1,"sequence_number":85} + +event: response.code_interpreter_call_code.delta +data: {"type":"response.code_interpreter_call_code.delta","delta":"(n","item_id":"ci_0e31e323da9c6f51006ae444874be887d0b5bdd68e0e3af193","obfuscation":"Vnx8QmUOHJ4RJ9","output_index":1,"sequence_number":86} + +event: response.code_interpreter_call_code.delta +data: {"type":"response.code_interpreter_call_code.delta","delta":")\r\n","item_id":"ci_0e31e323da9c6f51006ae444874be887d0b5bdd68e0e3af193","obfuscation":"6hiP20L7SXfmf","output_index":1,"sequence_number":87} + +event: response.code_interpreter_call_code.delta +data: {"type":"response.code_interpreter_call_code.delta","delta":"print","item_id":"ci_0e31e323da9c6f51006ae444874be887d0b5bdd68e0e3af193","obfuscation":"xWZTjsPc6EH","output_index":1,"sequence_number":88} + +event: response.code_interpreter_call_code.delta +data: {"type":"response.code_interpreter_call_code.delta","delta":"(result","item_id":"ci_0e31e323da9c6f51006ae444874be887d0b5bdd68e0e3af193","obfuscation":"aamypPnnO","output_index":1,"sequence_number":89} + +event: response.code_interpreter_call_code.delta +data: {"type":"response.code_interpreter_call_code.delta","delta":")","item_id":"ci_0e31e323da9c6f51006ae444874be887d0b5bdd68e0e3af193","obfuscation":"uNTcCBtnLY5D7A1","output_index":1,"sequence_number":90} + +event: response.code_interpreter_call_code.done +data: {"type":"response.code_interpreter_call_code.done","code":"# Compute the 12th Fibonacci number and print it.\r\n# Using the convention F0 = 0, F1 = 1 (so F12 = 144).\r\ndef fib(n):\r\n a, b = 0, 1\r\n for _ in range(n):\r\n a, b = b, a + b\r\n return a\r\n\r\nn = 12\r\nresult = fib(n)\r\nprint(result)","item_id":"ci_0e31e323da9c6f51006ae444874be887d0b5bdd68e0e3af193","output_index":1,"sequence_number":91} + +event: response.code_interpreter_call.interpreting +data: {"type":"response.code_interpreter_call.interpreting","item_id":"ci_0e31e323da9c6f51006ae444874be887d0b5bdd68e0e3af193","output_index":1,"sequence_number":92} + +event: response.code_interpreter_call.completed +data: {"type":"response.code_interpreter_call.completed","item_id":"ci_0e31e323da9c6f51006ae444874be887d0b5bdd68e0e3af193","output_index":1,"sequence_number":93} + +event: response.output_item.done +data: {"type":"response.output_item.done","item":{"id":"ci_0e31e323da9c6f51006ae444874be887d0b5bdd68e0e3af193","type":"code_interpreter_call","status":"completed","code":"# Compute the 12th Fibonacci number and print it.\r\n# Using the convention F0 = 0, F1 = 1 (so F12 = 144).\r\ndef fib(n):\r\n a, b = 0, 1\r\n for _ in range(n):\r\n a, b = b, a + b\r\n return a\r\n\r\nn = 12\r\nresult = fib(n)\r\nprint(result)","container_id":"cntr_6ae4448078408198b543bf14e05fa9aa0d582355793fb4d9","outputs":null},"output_index":1,"sequence_number":94} + +event: response.output_item.added +data: {"type":"response.output_item.added","item":{"id":"msg_0e31e323da9c6f51006ae444899ef087d0b482a46ecc14c45d","type":"message","status":"in_progress","content":[],"role":"assistant"},"output_index":2,"sequence_number":95} + +event: response.content_part.added +data: {"type":"response.content_part.added","content_index":0,"item_id":"msg_0e31e323da9c6f51006ae444899ef087d0b482a46ecc14c45d","output_index":2,"part":{"type":"output_text","annotations":[],"logprobs":[],"text":""},"sequence_number":96} + +event: response.output_text.delta +data: {"type":"response.output_text.delta","content_index":0,"delta":"144","item_id":"msg_0e31e323da9c6f51006ae444899ef087d0b482a46ecc14c45d","logprobs":[],"obfuscation":"gbSqEtNvQKSxh","output_index":2,"sequence_number":97} + +event: response.output_text.done +data: {"type":"response.output_text.done","content_index":0,"item_id":"msg_0e31e323da9c6f51006ae444899ef087d0b482a46ecc14c45d","logprobs":[],"output_index":2,"sequence_number":98,"text":"144"} + +event: response.content_part.done +data: {"type":"response.content_part.done","content_index":0,"item_id":"msg_0e31e323da9c6f51006ae444899ef087d0b482a46ecc14c45d","output_index":2,"part":{"type":"output_text","annotations":[],"logprobs":[],"text":"144"},"sequence_number":99} + +event: response.output_item.done +data: {"type":"response.output_item.done","item":{"id":"msg_0e31e323da9c6f51006ae444899ef087d0b482a46ecc14c45d","type":"message","status":"completed","content":[{"type":"output_text","annotations":[],"logprobs":[],"text":"144"}],"role":"assistant"},"output_index":2,"sequence_number":100} + +event: response.completed +data: {"type":"response.completed","response":{"id":"resp_0e31e323da9c6f51006ae4448032dc87d09b4ed03459fa2d4d","object":"response","created_at":1793344640,"status":"completed","access_programs":null,"background":false,"completed_at":1793344650,"error":null,"frequency_penalty":0.0,"incomplete_details":null,"instructions":null,"max_output_tokens":null,"max_tool_calls":null,"model":"gpt-5-mini-2025-08-07","moderation":null,"output":[{"id":"rs_0e31e323da9c6f51006ae444811c6087d0a74ac9a827f3a465","type":"reasoning","content":[],"encrypted_content":"gAAAAABq5ESK7mQfVHzlDtR1OU5x_ZRNcJVPnzb1bk053a61vncONnMAO62NlJ7_ZrFOQooMgCOnFiC2CbgT0UHEIFZO6Wl0n_npI5JKiCPaCT2SYoRP-ETxZX7w9DpU2RdtsARkwUc8I_rvynwhXr_pRq5KIvCkT7vRVXXjT46gXs-8B1JwGK7jW8xv0f3wMto_BFCEUfRWmuJ3JBgDZ7e6Hh0PXq43f7NOWyXrKPYRdGs0eyPPh1V1ExFHO5DJOUUlnXSGrSicN5Jhn8CjryKmAKdp8bCnk36ElqI5_E_-YrHizivFlVP1L1rI80mdG17H78SPdcyw5MsZlsbh0h6gnGzjOKWkgSPZMaI2W66UxeUQC-wSTEGPwatexGar012anmdDGDJlNSfuYR-buE__mHuzI_uYpHWRYEoNEQZcIpuwZoR_Phs34VXwnuSB42qDy_T5FECnllCF-_1UlPZgFfbOFDSjJ9ZcXRPMAb7w0MGBy-ZiWJFiZ9lH0fMTBAQXWXMybPVp-6xY0q7j8GOIzsQu3PxOufq61bkr3bFzQ9qXbsPVaSmEGexKiXLUmOTU8t5DDRp8ihKG4OIKjQo4VktqBip_9-G1BhRM3vwg5KTtLi27FJWs2O245Z5ifN6-3xMz3rczrvQQLpeNZSDhHWffR3BNdq6YYZEXbvtOI4Xmu1iK4ym9EGyDfptvxut-MdpyMGWfHgL0DtVc57GqJIwUJ7Swyo-wQxNzIdZ42fyNwuYJuZLrYO_8rsyWtHrbHzVuMWnDs45em568X3AQUq9JUoMAwA12ZQzMlbchULC3L4RT4zoZYuLiAd_BOleoLM0EArYsR6WCypPM4LYd08jK0bxIgQ7r1xrXyqoaQJG6r62esWaKw4Zo_BC8s8efJF6W0jX1puI7VsBb7f3zKjkdT9zWv9iuaw2-zDLFh8ILqRtQLgk3DM0pzr8UpDq5hShRYR8ZjavKFuucBuQCGlEKo6NKUXoHER1RmAulvxZ21P5Xl-MCFWlGJK7ll2TDQwQLO5Cw4ABjpJhJMdDcjpfax-CeW0OnFQf5VTOqezXSr4DhvE9a4V-OV_8bvqbZ3D4pqmn-XCwX6ilyh1s0agrus1EnccSyjLhyYB_rH1jNZlqU5Xmt2tO0fsxcPOB22r_U2T2j4t8FZHkZKXGJDDFIDqaJEz2mREvqiCNnz85W8DNpG9_xNyuDHhOmCSv-e4WqtfycjVhIeA7EK85Sie_ZAJAOnLghxg9XYDQ2Qz78feK7j0vpbvFG6SvXHjFBF38EERlxh9pUxRhHXpLk27goPfRdFizjsc9EudkXlq5Q8pPgwUkHfitcPYqosZWS2aRD5q_1xNoS9grNJGnkJiYve5UikDjri6ro9RWJToXlbFTv1_im19MVhMULEh1E72HFyJZ7lZhwiK6LSBkr2KctLZAccdtjFOHaK0t9S2QmeksegJ05Mhuj1izFXTiiyXjIG9CUbWWAFxwcgvR7p3Y1yMHwmRlT7twWjfkG8pxGo_Yb974niNBshxqY8UZKl4aC2up0fbMO2e6H78U1gZ47-ipcTqIpNclvgarO44uyllY9pHbV0aP_EDBfHvw8V2Ayg8IaxQTKq6869OYv04i8StAGJEZrvuZAUkceuS7f0GsLPRpZACgc0PYdovt8bE8o9fR_X-3RMMt9xo7COvSB81lrvcyqG_O078DRs3kUkLQQqGu_xJ_CF149i12Sh2gsupaZFFx-5CyarhV4mgEVY10gGz3UDsVXa-0hmjFOE_8YV6hb7w45ruXIuk8ViS_O7pBLjVDe1_uQGBvTNYivCmIbVVtcieWBh1LBISJ7SM3uWFiTfPmhiuVcp3XKSA2cImlxhYrX80FlFGSdrTzIwwZ82Iy_qm0AqlUuNOlCTBGMLVKUgAG-AL0BxTkF-ono8VIl7qxtiL5h4aTSJKeYtvzgT0uXqHhqaSnT4zHbWICscBlTClNVvTUlC5kLjaxLpFWVJYok01BqRVsHso3Cf-ltPmy9yJGb2ysXLvBAP_8pnWv3e4Eg0NHRdLos1aEpbjXO0jM_F1U7ViHz5OdE4Ec4IvHHaGRYdAt5w9qvdzna4NMosxJ8L3GgFYPFW6K7trE5HAm8QqvRaJljuptkiY3UYJtKH18TxvHCWwlJ1hS0S74PDc8fIBWua2nDw_holeNJgG6K1Rgj8eOmQPMfmeB1ChGnyJExxKS5Mr6I8Flj1qKUlOhvFNmcISOv0FM6IT9UsQgsQJULHudqlNoFD72BQYvU8u57_gDR0lBWqgLExlb1vPhAwvXtUNjXNO63OTBcW7shA4Qk-ygoKTh7IVyKCbxp1zJQuL_t30S3rfnrUZx2r7l7rXDdWXdG4dN-9pL2rcuXcYppHK1AMhBdO4fUuJ05P53IM634TsCTxk8IvAVeOQjPorSp5XNjUQ69KKb8UoTV1gK1kyfarZp7_8Dn7qkYvGzm0h2YaXnkvEicPZtFQ71kpiGykwLEgztvsjWqLq3r3wx1mWuwaol5IRA5_G8xHCIrzeqImyHf0Xwr8orQp0dK0Y6HIcna0qMp6hOCZNHnyK2gF8s2M_IaEecUUAOJOenCp5trVt0XHPKPfMBtD7CJwj3yXbgqyRKloIJCOfobN6c7I-bobyEDFGu_vcBoW7eO8-jUNin0wY4eq0jBy-uYmH73JahB8SS4QY75usEM9b2q1q_TUaiFMZreR2itLMPasVKboJYChrMf7ivh2FrsJHp70BZJfMQEtDmuDDPNfopjtQ_DgMuPZde8kROuuIJeyDF0tMIuFYerDm1HfGYo1u4XOyD-RsNBLPhcUsYUlTaUwrCTQg9-T5jOe4rTTkPo4OyFWKkmB0Gqv16_d7poADIm2-CM_7s9XlaMnJIBurbR-S4ahdtkU9ilMntFoPD8wI_1keSh8UCbXBSgjrCYZp2wWQRHWnnahAdQxoDPCRVFy7Ed1mbiNt-stRSXmAbvFA3Sv_SMglCqexjAaOLyAd6u_WtaVvBB2cYdKbYrCXuuuB5UYCYGeHqsIt0XFy_FHku2_zseYZrhUumAtfXZ6vfarsNYUB_2VDhosR7QgMWQY_Wjd3GSvHzWXHaQTAjmrT0xPmzFkHD1qyK2vdBMZxQKtG1K67dvNMjdvaGvu0GWYoQWLK02i7EiXJ4Qo77BNeyfIjNpZINi0iriBG2_BT5NSmuBQzYf5XEBagOejzLnH5R1sMnkSAHQjKaR8v8wGPVTrc5UI1pMoeR0lPBAIRnTy55EYekkGulBvaWA11dQzTeoYuBterHwOYtKRVmqH6Np170YY2-MBCMMmQwa9sCMjdPge3NYQG7c9hT2bJE94tJCekcGDyAbC_CEfgtnipp3B97WjEDF386_iZSC4U-4og_5qVk5AZgG3ChhCD4gHzSHxCFVClzJDdulgNc3GfJETT_2AfcH-0RGejqHjuIVoCelRVWXn6lvKHAAfw5rOoYf-THRaDLDX1-WuJrqCq55mPyocvsArsy-KfgWAMl8VWau8SguYGX54_xNgJml9SFtWtrcQBA3y5tcui4lxebMUPKUar1Xb8Dx5EflkEDt1j6trGvW-2NjNDh3qu_JE3U4R4q9F4T6f9ns_z1iX1GzMkSCwKu2yCdk71FYqjAgVw_icHEX6ebE9fz-w9H0YUrcNiS_KBIRa_w9XbMen29kWv2y_OZ5l65Stqh_zi6Mj6V6WmCaNGpsuX5ZC6gVOdyvNOFYx4SJ0mT86wBkcx5GKeP4SfpJeAvsB9D2kVB0ezE5su34VP7FoQJqVQnjN5tf4hC63IJII_DeVZFnsgv41Vw-FMyZAX-hewAdv2ppTIMEPSmU09dY7_g2kQJIboKW5wf8UrZ818HQDx3ypUOrYsO3Hu5XeatSROClCcdRU40ueYlryjyMPjJoUhHiBpyxJ69I9Nr-weFOle6c6zY3sMlu8sF5zoalIcc7AB9aja4aZEJdTn5WnlB00ETOYJGZdj5wLrF_a2lqryDg6SZOOTo-TaEN7SQMUm6FXrXkPpKQespxEJLgnOhfxhSaPhZFTmTkvb9BN3Lbdx1-ezcMofhcy0iOlsPFozw6Ng7pudoMEvMFXq5Kr9Wg1AUwioZgBwsmNtoG7mgLN_kYF2TywD_WbZRBnfC7LQ7a4EwzWBP-4ZfUudFZsESvKUCbUVlyjGLyD-1OrmrMhk3N4wUiXLPek9TbOToCvcv9XOCVAOlq_YDP0zMcRIcHj9tRc8bH396e7JQtOsTkJzyT6t9eFcS8Z583qt9JsH9jfhryyvID6dfywcBF8h5M10Bg5MsC6f3C8FmhgVyEIFAaD3PYwywlTIQ625JO6ewKhSInJ3TLGtFE0E6k-YhSDl2oNqLBkJNCV_4ulzw3bDQUm0CMDUm68CMY_8OowPl7M1uRToGxfULF1DFN0npHNMPrlPojl3An2leQVVCmExBGcGGcvVnWS1FfcCChxB9MGAM0Du1QyeAEHJRrjbsBI37aHNEbMgUXEgqxxx5KU6Kqa6SF6LdqhBEhmJq2uQa9DUpmNOACVSpRpISwGc5w_kMmKVy7hp8Y5EdNxupqmfqwnhKqiLZmZSZUewD7g0RQkOhxKbN9NLExBE-aFmMe3NhswhAzFzZdpnaSlZ4ZWV7ih3NbX_9o40MDZSH-6RsUeZF5ut6k9h80gdAmqbZKPRVVrtVenggqoQ0qRx2O1MckCqaoM7UJoD8EgIBfU0DSnDgXDPLh0lg4qc2ZGRgtPB1lHMKGUveNT1ixkuhwIm1HVttEA69bcii-URXiZCra79SyakA5SFflv2Hl0tZaCyC6EdL7M6wdElXpy-b5Rx56S4EVwgC_7ZmhQAkMyk_d0MRB6mK1GSGda2BcBAKPhHOQRxn_OvwCWYA43l2MtHEysK0vB76FfdjtIfHEFc3pJNheoV7YUMKSvIcr0zDpo8Y7nUEXOQVcIpPBB0aZEKwueqfLrCQSOqwupbABtzyd2B1TcuZIITKXyxwSPBUbsCB66uIPPWMByjK70Zn9btlwoioWHqsaeLz4tZ2oXPQDAuhrdQdKo-Tg0sbRWORDvePeBScvMWjkCmkE0vlBx5JAN-IP__xrVPH38lVTdjRfutpQbVuDZlxrPl8-adv1S3nXqY8PWRNmJI_A-9wJyed75aQZReV1NRWoJE8b9R632mVUt5a1xj5qEtj1DswkTqZ0Bv5Lws_xGorSr8ZLLap4mGcGydx0JL1NZnE6hDzD6yo1gxROY9RzfIQsQKRmTPMY-OQfxecbtrxCeFUoD8XxCA5QKlhIQ6FPoqYks0gm5VKEtubWiHvawWOzvM_Y6C57Ok9UQ3uCI0I0-_y33exdLTm_01rEAVUYbGnU_LtVGJHFPVbEnIDcioKLHns14ugxmNn5cb-eayJjtqO67-BGO6daRyeSs21ZB6YQtPy-LzRouISSXV_Fg-jaABZ47G2BK5Oh1GFwpYIZNdPVozpLNGB7kgyZhvaGrtVVmT2b0ecWTdPc6JQJPfGqI4YmDonRc5wNaQNu1XaDJZFFbeNG5A5lETSTQM8SnnDa4ng5uz001y4EslZ0kkTjxNAa0S-GPlhiLmIIhcBGhH8nHm5C4Wja_j6XgzQBgr5JgnZZUvAnS7TQnakf7Wr94VXj0yv3XoICOx-W4F3-LBTF9C6QCZnji-X09vzjGnW5p9qEP22DbqkPWnYNtJVe3mdyNrdT4d82QCavR8odtjhhuweMx5cSS9xe7ZW37R9kWXVI3zmR1ymMQ9yr_kQ0l2DfDaZlQ6RcLuJl8epE6dNL4R5kSN1PKkNsCmuGAwA9q4Q8r7HU98AffSFbwy_arEx_6N09PVkfum40LVWnYgYpRgXYaOowMgFjcI7OgSQ4m31Lw0eGlyfriNazqlcKl2IwU9TEMZf9NSF5D-L862zWbMKgOThNeMMHgsGGOTvbIikOcAVQXvFVtmepX7izaVHjvtixkO_9LxJb732JaxkSaVTgzCF89XsmvxNHk-6DYXR8-WrhjQAYpWpJAP3seNFIxAY9BLvt6bvFMx_kIjHUZCiot26j6-t6ZhX8PxaHsmOiH8E3t8gBxIIfwoSp4uWCeu8jfwKjToXyO3hAgtLcoKADVAyfIk_v1oyn6Y4Gdr5pavFRvNBf_hr2rg8PQ5wIM6stqL7_CBE0sOwBulhVEN4EvZpLIp-3_NNIwrPfQPll4OsOM_TIRElnWK3wiXxgZH_pgjIZPV7u2HHtB-aKs_8fRGyXcyZfiKk_m2zmUmntlNBcUg2r6awpmaDimdto3BUOymqyhlvVEduFJGBr72XbuzlVLJPTK-eZJDppTvkDJa7fOhTxN2mvzJNSnlPcgGh7_87U58Dzb2Ngob_EUBOTLBiLU9zCiwAFiRe5LSrpKhCzKqc4Kd_HQ9NGJ1SBUp93Gjan8to5-oh2TE0WRY5oM6dUcOjJPQstZPRBghU4ij9kQ1yTKl4f2_Rw_GVq99UzeCShWzyTnJv4dZMW4ta4i2ZRq1ARDSK_pwAVgGcSDLhegs7xM5nVvLc7dFObrgJcwOX-sOlqIu4JxbEctM04i9ogamwHe064AdgjyqKOaj2f9poE9EkaRMSwA9aiiFhmBHL-hDGuHVX3p_lRNoKvK3gaFga3ZX7NsGZAe-8_Kuvkvo3nS1B2uZKyjGXTlPwGXiMJ16m8BSa-nhIBoxE8-AuuLljYHpfWfccH0Lm_0uAfpSB8CiFLRxYDcIVdQyd7GLvdxrl4HGLz0KOqHXInl3HBXP1HKnRQit18mP5tc87NQ2k7g1fbUt-uKF7q0o3NQLYvt-nwhWvjCskWXCBMf4RxY1hVsrBSzNtV1jfbIo3EjkJbIyz2wqtI0VPUYBZMJmF8-SyZq6GVSUID5YHvb9DaXzYiwXa6tz7VbTTcKwjolaFHbLq-WnbZ00DOB8ROGSJz3sdaHPnoBLVzlfFAwYQ16MeGbyNNJTPYKP_b23n2nl1ZnER_B8h6ErFUwl1UCEajhMtnXWJSobWmCUyn7H5PxtCIGVg1NgFLVuk-phaak4iWoVG6f2pIhYTkDkDHnt_l03Yeb38u2muDL2MOBoR1-vVXdlBWIBMnAfxV8uLzaKTzEVJGCfh_irjL8MiOSr9dy-lXMJO0ARlcmfm0GUNTEs7BTOexek5PHzdbuGBWQzmUWSrMR3Pyljo6ICUvqsxv8Qq9lF2EYljCAWFtQDU5Ownah21KCsDut3jyNiP7PYS4eHKNe_S5twjokCHgucEnj27EuBQmYZJ5TiTKMlmPAOc99BUIHsy4sis9uaFZg_FE73B_OoGZr77mxypNEQfnuToKMAXSmhcTIhri4vyZvvAEtx5RAdTCc9aIZ14x0t74GPfAj_hiRl2OVkEcdJAhPnQlMloi19o8RmVbFvg6h7_cEk0KCdsechCB0xOYZwKCOhC9BFWW8zLS4STnzBZ_C8SQ8_xOK-VtCeV11BSAvuZQirlueeBQ-PeDgdLaLHxW7b0-n0O3Z_nsRmKtAEa2EU5cwMCB54ENRbPtkqH8eQrMHEBYavBJMzMq9BxNTNDa3Cwqz77BMX8LzPfSucCTQl0XtdK8mBYybHRP3oA4PxgQlXjgv_wQ8jcmwd5BxuQGBmA90-KzXF7lAVlAShS8EGI-jqz5ShJ4aPoOw9n5J8O13gPIZyvXPVRV5L_3rVl6t7CkbH_M2ored31bVI5-qKCh9MPruuCyqdTaSgMGgI7hB18fjBRlYHQ6aEr-3--04Msvd7H9IHjZ-0KymWiA6NGlzyzdcF9c-Lf_2L9ep4cqTFOq7_ROxQ5w_HaVV-B6hmpUfsofNytxOR0ZkSpeASpqc-vm8lWv4ESTI1u6WjtAhlxggiiqI3VHQvtQkTTw6Sw9f-vpNQQZuZqDF7HcOjlvWzstQbJ8Uv0OdSl7KrXaL-V0lt3cE98r8c2m30Pcij1ZP7BiXm5KwOgx-qx4nEtRrRYURoa77a5_pGryQo24YREBSWocKvV71lwDbK7rqqpnMZoA1TGMjyvsmSVyuDw1MwiPSZ8HY1HPFHuCLemJl5toLxso6exCXykU3cMMgeuhK9VdU_er45EuvSE9tHqf97OyeKHIqOf-ksQ2eoXDfX_kgARMpWK_CV55BuN0u_lUF_lZx9gvrkL27jWE_KGmUIX-T4mvw55iovc7UNjyDAF9w3kA1l-OTP0c_Y1-QRSlVfLFN4padxPmuA9hZq2xF6mgzxXG1bJeK8WtG_TtbkGC2rWq4BnsLSG2_eaeKNuRCf_WXyMwljGt7K2lvGeWe1z4GIp19slWFHzPeOm_Lsp1efsNVbSnJsH7MVm7ziBIpzTTLL78aGPfBicR4WBjFP0sSsI1QpM3QN5kqSNmInnls2Zk0IFj8XZHLSa_y4tnNV3p0WVCl_w6Ci2a9fs-PfesTc6atILW0tB-X7oo_TSXJy4=","summary":[]},{"id":"ci_0e31e323da9c6f51006ae444874be887d0b5bdd68e0e3af193","type":"code_interpreter_call","status":"completed","code":"# Compute the 12th Fibonacci number and print it.\r\n# Using the convention F0 = 0, F1 = 1 (so F12 = 144).\r\ndef fib(n):\r\n a, b = 0, 1\r\n for _ in range(n):\r\n a, b = b, a + b\r\n return a\r\n\r\nn = 12\r\nresult = fib(n)\r\nprint(result)","container_id":"cntr_6ae4448078408198b543bf14e05fa9aa0d582355793fb4d9","outputs":null},{"id":"msg_0e31e323da9c6f51006ae444899ef087d0b482a46ecc14c45d","type":"message","status":"completed","content":[{"type":"output_text","annotations":[],"logprobs":[],"text":"144"}],"role":"assistant"}],"parallel_tool_calls":true,"presence_penalty":0.0,"previous_response_id":null,"prompt_cache_key":null,"prompt_cache_retention":"in_memory","reasoning":{"context":"current_turn","effort":"medium","mode":"standard","summary":null},"safety_identifier":null,"service_tier":"default","store":true,"temperature":1.0,"text":{"format":{"type":"text"},"verbosity":"medium"},"tool_choice":"auto","tool_usage":{"image_gen":{"input_tokens":0,"input_tokens_details":{"image_tokens":0,"text_tokens":0},"output_tokens":0,"output_tokens_details":{"image_tokens":0,"text_tokens":0},"total_tokens":0},"web_search":{"num_requests":0}},"tools":[{"type":"code_interpreter","container":{"type":"auto"}}],"top_logprobs":0,"top_p":1.0,"truncation":"disabled","usage":{"input_tokens":1456,"input_tokens_details":{"cache_write_tokens":0,"cached_tokens":0},"output_tokens":777,"output_tokens_details":{"reasoning_tokens":640},"total_tokens":2233},"user":null,"metadata":{}},"sequence_number":101} + diff --git a/packages/inference-discovery-openai/sessions/openai-responses/gpt-5-mini/code-execution-streaming/session.json b/packages/inference-discovery-openai/sessions/openai-responses/gpt-5-mini/code-execution-streaming/session.json new file mode 100644 index 000000000..e5077e689 --- /dev/null +++ b/packages/inference-discovery-openai/sessions/openai-responses/gpt-5-mini/code-execution-streaming/session.json @@ -0,0 +1,11 @@ +{ + "schemaVersion": "2", + "source": { + "provider": "openai-responses", + "model": "gpt-5-mini", + "baseURL": "https://api.openai.com/v1" + }, + "origin": "live", + "capturedAt": "2026-10-30T07:17:30.305Z", + "capability": "code-execution-streaming" +} diff --git a/packages/inference-discovery-openai/sessions/openai-responses/gpt-5-mini/code-execution/exchanges/0/request-headers.json b/packages/inference-discovery-openai/sessions/openai-responses/gpt-5-mini/code-execution/exchanges/0/request-headers.json new file mode 100644 index 000000000..28c14bb85 --- /dev/null +++ b/packages/inference-discovery-openai/sessions/openai-responses/gpt-5-mini/code-execution/exchanges/0/request-headers.json @@ -0,0 +1,4 @@ +{ + "Content-Type": "application/json", + "Authorization": "" +} diff --git a/packages/inference-discovery-openai/sessions/openai-responses/gpt-5-mini/code-execution/exchanges/0/request.json b/packages/inference-discovery-openai/sessions/openai-responses/gpt-5-mini/code-execution/exchanges/0/request.json new file mode 100644 index 000000000..dfaedb656 --- /dev/null +++ b/packages/inference-discovery-openai/sessions/openai-responses/gpt-5-mini/code-execution/exchanges/0/request.json @@ -0,0 +1,19 @@ +{ + "model": "gpt-5-mini", + "input": [ + { + "type": "message", + "role": "user", + "content": "Compute the 12th Fibonacci number by running code." + } + ], + "tools": [ + { + "type": "code_interpreter", + "container": { + "type": "auto", + "memory_limit": "4g" + } + } + ] +} diff --git a/packages/inference-discovery-openai/sessions/openai-responses/gpt-5-mini/code-execution/exchanges/0/response-headers.json b/packages/inference-discovery-openai/sessions/openai-responses/gpt-5-mini/code-execution/exchanges/0/response-headers.json new file mode 100644 index 000000000..6372b86c7 --- /dev/null +++ b/packages/inference-discovery-openai/sessions/openai-responses/gpt-5-mini/code-execution/exchanges/0/response-headers.json @@ -0,0 +1,26 @@ +{ + "access-control-expose-headers": "X-Request-ID, Server-Timing-Total, CF-Ray, CF-Ray", + "alt-svc": "h3=\":443\"; ma=86400", + "cf-cache-status": "DYNAMIC", + "cf-ray": "a5289b8c3f40ed79-LAX", + "connection": "keep-alive", + "content-encoding": "br", + "content-type": "application/json", + "date": "Fri, 30 Oct 2026 07:11:59 GMT", + "openai-organization": "", + "openai-processing-ms": "15690", + "openai-project": "", + "openai-version": "2020-10-01", + "server": "cloudflare", + "strict-transport-security": "max-age=31536000; includeSubDomains; preload", + "transfer-encoding": "chunked", + "x-content-type-options": "nosniff", + "x-ratelimit-limit-requests": "5000", + "x-ratelimit-limit-tokens": "2000000", + "x-ratelimit-remaining-requests": "4999", + "x-ratelimit-remaining-tokens": "1998064", + "x-ratelimit-reset-requests": "12ms", + "x-ratelimit-reset-tokens": "58ms", + "x-request-id": "", + "set-cookie": "" +} diff --git a/packages/inference-discovery-openai/sessions/openai-responses/gpt-5-mini/code-execution/exchanges/0/response.json b/packages/inference-discovery-openai/sessions/openai-responses/gpt-5-mini/code-execution/exchanges/0/response.json new file mode 100644 index 000000000..bb3c6c0fe --- /dev/null +++ b/packages/inference-discovery-openai/sessions/openai-responses/gpt-5-mini/code-execution/exchanges/0/response.json @@ -0,0 +1,131 @@ +{ + "id": "resp_023aca0419c09a81006ae443301db087d0b91cdc7bfd6d132d", + "object": "response", + "created_at": 1793344304, + "status": "completed", + "access_programs": null, + "background": false, + "billing": { + "payer": "developer" + }, + "completed_at": 1793344319, + "error": null, + "frequency_penalty": 0.0, + "incomplete_details": null, + "instructions": null, + "max_output_tokens": null, + "max_tool_calls": null, + "model": "gpt-5-mini-2025-08-07", + "moderation": null, + "output": [ + { + "id": "rs_023aca0419c09a81006ae44330ebbc87d08cacb864acc96aa9", + "type": "reasoning", + "content": [], + "encrypted_content": "gAAAAABq5EM_k55ZCeq71nEWJni7bQoy2MqEHMzxylxXhkm0Ar3kTxcdESEajVRkllM0XuTIxNBmx7cTAwi3lGGQa0nXBH8HkEnTmV_5t_WFZdnePMiBZN0aUuEFNw8Q3_Pi-g9NTBSdgezcJrz6tVNqvetf-iXT1_RqnIEuW2OFeo-4WY93pgSiVgzkya0WAKJ5h2IH2unn5jkNhD9UChe1DuDHmNO6mf6PBxbz2mhJy89Tv4PtyLXbgIbEtJTLoxP0gIeuf273PprirtYnOA34FpofqqlRcAT6eixiTLvFm8VDjTk_Z0WOUDf2NmOsdXJnCmTGDEhQdibf5JLqBR3H6ZYYtg-z8t6dr66y743P63D3Pz5RVmj1CRFBXW8kA_uotBrid77aqIBhvqSuMCwgEXUuRRmbXRT5OSEH7rmrgISUAxkw3bJGopmsZAlzUHBRN2iTiF7REpGVATGQfBHJPlvCD12BwKJn-p8zfb1tFltQaxwzIxh4O6ZXJ0IBJYaKv52u6sSM2JHA1G9KiBGvNe9yIBAqfjWnRiginEetnXbeUafFrzB6fYFyR9k2SZNCR3tvToWvP0DDojhtTCqPHCRfkrJuzNd7CDo3z_9R1e5udThAdlhcA7jjH-MdOOslIcZCT9FTspdeLX8-ktHM2dZA2yCB2AJVsWgjb5Jepq-4yKKB6ZKqfuJh_EunjFwpndtDCc-jJXC4kbfXGIYBpPi_bA9Y-wokl_5FUDKipDatyBsCPsyL3RcwOMC8rveuAPvJJ3Yi0I7cpd-aCZRBb258Y-bjSlEK5Xi_oYtFEJGuCpXwOIzwZhhvQ1gVKLy4Nm-sBOJcRzT_i780nTm_hM_Rl4MtFt8NgGtnnsO2RWWvlQFCZeLcTqOWvYaS8rnArXMS0OYgbakiSsFvBZnV-mUvwzAXdCvNgYMKg2P598klL5aHg4ww1aw5_X3PQz3E0Y0biaUBJzvoczLQiEKxaWf8fQf5o1m6hacPPJor9yDJ6G4BG3HNMdW79SdZPjWsjffxjw8d66uyy8odpnj3gJrkNoF_tQcnr8lDAU1y2AJPcmNwvp6_r-0SigPd2PahAu8DhYAd29yJSa1n-a4spU3O0-tV6A6NVkuoGE-f3SsEjxXz4pY12GSmm45ybi_6H9qZRfCjXfioKeYgHpjXqIxsMUPvwm0LsN5X3ah6s12FJzMlzmYIIXlAUvVTOoVPuL5lT2AJgHdjpG9BGjU0F4_LAWk1QJHN7wHTbiMfm-CuMVvvOukKwHcrN_QZ7DD0B9uTQPUb_jRxQVfp80-GVmVNLx62NBPxQzf-uqeMHYZY6g2txvtCjld9QbtN8Y1-ZKlubvuaBwl2jq-7jwne3Q3XxZWmmIGvpR8NNewUOD1ol7i78snQdaSf4P7ehNTy6X50UYC0RtgYuhv4ihOrm3mF94L-9bS_Gu7GkljxRqMTH1e7yHCeVN2rduIxiRC9xJsQEJQGqXYAXpZb6EqLGRq-SWnU3tJenbOJvMmxll_KSWjo7moUnIR6cUvyuZMlVZvBlC2VZ0zh_LIe8XP_kD_iNZzG7IBM8VxvxvBxrJe8dT6jDS8U8SXCIse7pNxMTy11grjhyOFdITti84QPni_N4p-k2E7OkTidSJN4jkzP2E-lPrQMEt5vaOYXUldH-8Owy2_87o3XxVkK2HgxvC4SuGgGSVxqyxpDFmYnAyY81e96oCk0qXJpnyNaxYfRLnp9QWCG8TKC83ajwa73A3DBkJqTOcfwEKaqC8gJY001DhESg_ViSV5QCIXMMOTr9SPLRGayMmXN2lG8pWbrvooG3gQjmz41xjZ3Ze5yXWDRbIinqD_jB-gzBg_VXDVVtRCSa1-7CHY98eTEhXRQSmjoJTSub4TxPJbaP78xL0BMVBCxPx7sJUIse23e5mfGN9xQsD5FYS-pPrvWCpdBjgpHl8DJ4oUodwuCAwe4TiVkOeeYJGp42vVbUBnpsLUCh4_kGKTBFcz27PK_m6CowvjY6yQk9jt4OFMh-G8tNJKOHu7dUwocGBh8s8Em6thV_brVLYso89N-0omCAaNA98W4JWaYeKUuObCV_XCaQ1kNq8m_-F9SxP-MksC3a3yCCnGdpW9hiJPyJxTm0Tk_KQahF6ahyy7tRvDf3uFQAV99Qczp8pq2BiesHd6Tw-p4Uuw05_-3wKo3i587SV_Whpk9s8IngYNMzKtoEiFY7PlxgJwNqk7RpLjy3QI8pR2tGaxjOQH-YPbNjZIISq7khvrccgASrCNLkBf527nnljrZnu4fxw5T6MPrQ-akv-5D_hbIYi6H8idDRTQ29YZeVdvq_R9zn2sfj_Gn9A7_GG7DFZNgpjs3w2Q4WYv2vCMg6RJqZcXtL4XcMbyFntPa7LNeOlp-QpB60nhEe4QKrecsCGXqcfQwxKH5_tK3HTH6q0I92c4G0ruSu3268_dKcvy3SbUc5L4TzoLwN3SR4_fXbMqsoyETs-PpnAKZvw6hA8wmmsYRKfd0QY0Jhl4p7EhIbkgKRlsFrlFJAz4DEvEHnpZjmAOCduAVLEKyNs4lygey4V0dwo8TZGci_usLLQrnkakGMGcJPjnaSZtbxlehyr7yul1oW6_HWMSrjEPJKfaVNL6v4nO53_IEt2FUTr14c0hxrmugi2Fk7ppngtPtvZPLrp86ipkuG8VgykelcsV0TKUzsj5qpAlA7QO8lLy1xUiZrW8b60BkjhZM5-fpi_Ho9rz2YI8vbi1eJ3rxKed7UO6vELMrwOnhUDt9aK46JIOk59U_udSRtOlcH3rZ8L2Zu_ntFrAiWr6-p4l6FpvxbG_2DKN5GPLPMBl3J8XF_2Hc5XxZzIgXuiRm7z5kBbjWrm3lI_YzaKHnmcoaPRhWEbmJ1pR7FhlorkBvZ8vh3kR70uQG5qf61SxFTqEuxfKwcEcJFg49S03H8lv-w1rJ9e-bhQ3RSTIT0z_gQotN1-SEttFOnpOcKc3ldih4YtjY1a-UASCu7CEA-kqsgWcwbF4x2abdQIcokVYE-ZH7DKFBpbXL66mtCQTYBlIu9ilMYpLwJ84YxJX9xAK3fkh0_pLrPS56ibN2342jqSoJlyERFsVvBIn3ZMwH7te4P9ajPj0Cpl5a0FBLadr6G3bcVXPGoyEQ3XBA45zESEb74lk4GSetPHa84ogSO5VozCdrwJc6Js5zsWa_3I6ePJ0IsF4uLrzZ2cguomfeSFtxKxxdcWVudFOJyi79jvWSBsqbTdWhPRl2jHoNhYmAGjIzWcn3nZkxPW6rz7qFaTPi0dc9HOHDGqRS3y3w6QyRsvisyDMwmxub_vgL972fkYp-OcTF3feTkAHCIce2Q3rSElO7xoWKincDae9sWzkNgrWl0_8OhjPi6ZBCnoLBUG0rR2FFtj-zW9jW2WjFQTTb9IoM0DQCdsqz1A0LN4o1FvHrPhXzlLQatTXc0GhdrbRkN1eWToDbATFkoiip5jXxB8Yu1-UPDIjXv5cfBWpmetvwRbBamsTTR1fqwqaKjQEl6Pp2-IymagCgduCTFXJq7rmXb4LtkHI_BHVaZ4tA6Tz8ZEQZLf3Zn_jYJyBfP-1DF9OO7louUdFZtbNkgLksScHVWDDAIpFE9Qrh3j_Xh25tMIwFz5zRsztPSTc9dy54M2HFHHjjWbZ1GtnthIXLtA8lR_yMqRCSXf_U8EHcmMqrnAYc8tjCakOAWqQYcf3vyhmKkVQJqpCEADDTG6KSnhpLRzed554E3l1IwVmgDYLZzMlLj519pSWWiX-4-nXCnMPUqicUHyKPmcOSDnYtX3ERLojvz7BEIWHEm1H6iDL_CBj5mjI-m2LPHq8lZdTPtVrgVfvcbX3NFLTXlmOzrDXRfgzftGfxyPnb4Xdbv-p6_FD4_IDFeQSsfQLFdVpx0Vuo2AX3FOf_ILgeo0mGdvIWGKTQ8FU_wE_VvillhEqcu5nMBArJ3sJh8YrU_VSSn6s5oWUZhMG0eYNAzBvBxjPiDiGJswnslprC6y94xfPP6rXzqi1nzyK4xwwgc-1OcAG8bYbGufgc2QbZuvxrOC9RZXml3MiSkPjM_gu64YQEjWeLsNujoMI6iRVyBIVC6YhfKEXi-AFOJ7b0vp_kLws-pcPVO60gBv-pc3x8e06nOn0JJee0hHmXa3wcHk4fEGRd1gIMFrJ1I-W3UclUShsuNjyB6E6rB1KylNTqsYljTc6rQO-FyIImI-sOUYsaIx_w9f1EYUommx2a5AniIcLbqxaUDWKC5_QD5UVCSkH1P5K9BrB6PUCFQH5RUnut9fYFZzxrXec8z5UAlrYr8U6JR5BhZkv_xx3NoTAEzPsj2yoT6Ds1WEZfRrG9LlR2tLmUASir2xsArC3MsRJi36s634z_MEk8ec4_ria2O78r-okf7yU3fZ8WeG19EB10J_DQycrz8dbWfhj0tmCByRag77VPacRaqS5vhPEwVKLbIpGpAuwnOwgwXRxcrgpaiSiQF769dq4BkI915U4A_RNNQWA_aQWcpCZUlHtsV3IXPXfiwJPF3-tcZA-MFftNAsSYXIctP798C-vh3eNENl5PaGuLkZgXT4JaF0bAqfWywWPbpKqUB8GJCrIPQNr40Nc0TRl0400XKaiFtc0l8npFN1t8e9yD-lX6uFctgjDxewj_nnuzf8YFJoFu31N0S1ImFslWvoQJTRuvPHvFNVXM3TnsQfYKcsta1WXP5Mdggfskj8rlDWdb2pekLrRK53xG1e__mG43_aMb6sAqr9Ba6JW08LHVr-fPSKAoKxkBNHVYXPz6q7GfpF_Fo0SuxF59xMG4MLPigmWYbiD1LGlYC0tpkR6MkUh36nxIDl60DwGlYahI8bb_dHsj61qDSMXExsWvfUcGTyzDPpx4HNC9mBUYK3lkpIwHF1NzDI9HDWi3P3624WI7B1k5EHxnvfWsYdSnf0GUqm7uJItvkJCbBwxrYy9CPByLhu07IvIMtxCoDvnIqw_Gkds9ofV6ryezjLHLusXJztBZleFQ0TuskTrXz1Nr_7sKullM0eDcwiOqxj8PD2g5J148TDHgEuBanqHLg5A5vpS_aGzm-O2sldeBJZFrkKXDutqHV_iDu-VDzFXuVhZWuo9Ps7sroSi03P5BXx3bqGKTaZseSCj4e64u_kbyJJBAwUJADHV8Ez9eQ45hXd-AfTGYJaPVrisOiNbH_WPXItaKZwpF7UCU-_eWnLLJnEZSS6a337UMypysXHedzCk9Zbmur7D5iIQLbr6OB3a-hk82FIBaEdIvog==", + "summary": [] + }, + { + "id": "ci_023aca0419c09a81006ae44334710887d0a721680ecb178bd8", + "type": "code_interpreter_call", + "status": "completed", + "code": "# Compute the 12th Fibonacci number (with F1 = 1, F2 = 1)\r\ndef fib(n):\r\n if n <= 0:\r\n return 0\r\n a, b = 1, 1\r\n if n == 1:\r\n return a\r\n for _ in range(2, n+1):\r\n a, b = b, a + b\r\n return b\r\n\r\nn = 12\r\nresult = fib(n)\r\nprint(f\"The {n}th Fibonacci number (with F1=1, F2=1) is: {result}\")", + "container_id": "cntr_6ae4433089cc8198be33ad123077d03d058c8c33406196a0", + "outputs": null + }, + { + "id": "rs_023aca0419c09a81006ae44336679087d08a04363f03e1bcd1", + "type": "reasoning", + "content": [], + "encrypted_content": "gAAAAABq5EM_Mtf5yAJvB108Its3rO4jTrG-PsIFdWuKGcADFXgXzXirnIh6_fvmwSQbeLZK-alWTDEwDT_p5LEA-4SYGi67n-aPjypqe7AK50nNtUUaAraGDkNBzu7D9gbPWRlUj_baMMTIh-MA7BkNzxxrSwsbV7v-p4jVvBLXS4rhIPzsOxPPTbGSNMrW49cJZwNPNHyvtOtPTWxFJ3SswkR_HGod2c7d3lbsHcj2b-eyVRf582LocDrBk2VKFdeVVV4WvnzblREkhV13gX933z21DFxvv315OsgtcnkYGMQOEbdWOVQDRYPPhAc7boCMqUu5JLB_EfcKMg1p4ph3K9U-K0cfrwTmTjgVSBY_1uEULAgUnMy_mpYsYJkKALUF9CCJ2ujxtrcuaNr4Z6sidsETiupvx3uLptcMDA-EaiUnwoUCK5YhLGXcO9d5NxbUrtdWZz69zCgV8rR_WUnQ3FCGZdU34lWj5CHwHaPPJlgxnF9eFMwqItfRl0NKIRb70Q8A6bMS_mFllF3K3BIDS3TDA6bUP-fNbzDt5TqLxD1NwuBVx49TrwPDnaOuqvqHtiowjXW4E34Rmyi0y7DvQAqAT2mfS5wwkD3FjsRct0SfK7yDdK_JVsC71fSV0tmqv23IDhAF8aoI_-uk_zdhxndTx34zL7TYKIVoRNszbZ_TX3LsydKNTbfqW1NNTAT3zyP8QC8pIfSMi2K0Qijya_sV2spNqQx2EzpBAVMfnzO01U33HS4n0YsaYPulgTwpEtWlc9YeCXE9juuOU51BiJ79rzRKF8n0HxGXFEG0yWz-q-CuSCLQ7w2Vd8YjRjVx92jUNCyGbFBb80KFfFNhMVAFHPG2dd1tAFEsSrQnEMy4B7LK4MVb6spQVwbTi3xOil90r_PCpIMfcQ1lgNqZSXnD-2aUp-qov7UeQOG1ywYDUI_W9a6JNMsClChc1znk_rM9NWpBHX4IWAzsR65yMG_-9aDOHxeBv7SjKLCEmlCkv_Zh4SSKfSSEjXHRVglb3vqLD-LovYhvS4PwFEdIhlrniVsCUsqXH_aKaIBm4dnNQqTawjp-VSKcDpcdRvh2MSy8gXTAdddKDFmyclyRAi3NfM-aUWhzsSy7M7CNfFGKjSPknIVXThCHcm3kbCC3snsuQ-rrpf5ecEqR3RtpZFOZrMTGOyUmHmKHUNB0IhDU9w2R3tAISO70sRSU_kdTbPxE7dlHsl1yuPYlSK3bka_Hbs0Wgy-j9TL4U990zvQT1ppiKdmxxmPt-BW0RxhXANCmlDyVMLua6cauyB9o8Mvc4ktiR4noyAqQg2V0zavLbm3lGWTlmEbn0cNfKDhtWY3x7rfy2Is22OBXo8OyDnAGaD2Im17-56fB-tZ51jicYhIha6k_C9ddb3A3FUw2ZELg1Z1kTO2yssB4veCONE4UEBtvLyvXbY797McimKJZaIW2X6-RhamQuX1QHLGUjhVkHFCM2S7mEvHwQDh3FP-ehFIbLGlg0965i9rTlkwgYRZWPmGwLVk8vKrDeNm_ztIciTQYObyjLHBTislYQ4qfrPU46ekBUJYiiRGfDhAtn478-joUPZZL9GIxOXzJfyZXrfK63qBe-5wZxck39PIDorKF6ul_D84Lv_zUE_KRoC2PLWhpeTHqDG1OsgQeM3yBgnutRECohl23rEeBhUDAYW_ahrE9DQG-AEzhQHDp00o4gL2tHAH-AhlAM3Aiuve1fIkAtyEvhkMxIeH_QtO0QLP_B18Ln-utje5QFj-1-xTeu_zV99-2GfN5YfWyvbCcRK71ieJicBpH8q-xFNEIYrBCro1xyzn723UQ4x1LTY9iblWW_ONVpa0ZqvOEQWsbiYjmkMqG_YtLIWQFJIPAthLP0dd49I5sfbMfr0t6MRUbliRQDSscU2XzNi2SzKWv-GaGL4YMTshRKUDM-JnwSr2g2kI2pPGxhms4IHhzzJ6avFCLPPzlqP7nWbUNq5UM_bJZWvxEtqLHiG5lXTXYb2WwTMFMAFkpvrzRSgYgARmR6RZlqTDSk2AiqXeetjGhdAoXEjXnYp2Ml5wIBNs0xTIdSMhVwtpxU9X2Adz7riQM7D-3EQTPSONSZ-AEAf-gj8J8Gq6bIx_KzJ-ON8O5cFn4ChB6npmRlbTsrunFfbsKv3dQMfm1lg43KtNgWTgYVtGrDvVHxCzRPcvT8Xkva2PCgteh-ql3lEEXZ4lVipy4VDlgA0ovfmLhr70owo7EZjC1S8U8eAdvihnImzv9I0ARhUem_NJYHRYDZIXtc8buD6BQpunxK4fWGSg-2apOz5MUi9_lyLoxFhzX3a5vV8EbAvgqcBIuv6Ew5w1CczzpjvV44-8thy_aqTX_LIkgf1vO4Rbyg1iBjQeZvHTdDv4UZZrRTA30YPMe79ipebfb0rHDPW-wVmvuhJ9-qDCKacBMdT4JjpzV6fQbKKIP3x4LeskJCKetoydHSR-ES_YasKvLDqEztWnkH1PdHjkF12kCd5wV9fl6Xo19PXNtzzmKoSSEXQnR1IoGvxNE6XMCW8x6L5V9w8n4c1jyZ1a5qSFMvQIsZp6Ipt_BBa8aAavXHt4q6f6QScD-FLXrMK-xh_PQc7OF1p77ibVd5L3qX8IwXGc17GQfmBPKaMxMiK3xMMsR0Vh3NgYb4cZ3-YFeOu4OG3P8uFEL93zOzHjfIH0P1YqGhCXSCXIi1fGqanAdvKRFFKBgHBOQRSqLLFtbw7Vhugbrai-KQpBqzJZpvN2e87EjmNhLchMAyR2thg6MJoUUBmMBFXHpPps9fxtKaqyPGxf1tF0ui_rI0Zk5WGAJzmBqHh7Rk8LZdSPl8NtXopF21ucA9AOEE37DaCI1EzrSu6iWxtHksfKi4f-hPSWrSPK5yrdJ5H3R-T4eUyNIYtOb41RloxyUJ1TDyTCOyzDdVPo27JAF9r2_edCuZjVGThjCKkZqAfk3Hzzyk8COjTuV3rYF-vZ405-nb8lNcLaZLD9Moq6OyQVnPvI11HbyaKuCboWH4oozcwVK0NtuXXNoxYg1rfQATChSb9bxm0T7ffgldcwADfjJgOlap_q8PC-Vwpgl7u0rhi3vMySKcqcHBedHeobWMNyylQ1iewc0Nq6kfCkCdcgF1hmb2xZGfJHJkc_TXyVsUd7s6RuJQ-k3YPOyQe5-DxqwOsm8GjWr8a7Q2D01IHnsG9L2v8ghhvpy90kaUb6QzFRP0dQqQADb2H1zUkt-iB32ByoWBnQsVLnv64oqQL3Xoo-9ulpQkulrF_nNGI59IjFOK38nKU9lmwIqadfj1Hm0gqsjBfDIH1BcBbx1bcgC93dvOm1bToG8kkI5M6rSRg9riU4CJvkkaVPzHUXWdlBexgCAQKKQuuZfapNyFcVhhd2l5Q7a6yLWiH6ZJrIoFTeDdKzxq4asERRzmMPDtgzhueb0bhWHNmc12rWESDLVQQJ_OTnEwKhuA9c887C8cALb6OBaII0VlsIyfiyk0_e_uM2Wl6P_NyMnQT2TLVmzxWVwCX3vSLoib00S5HDEZ46kgeoxpCJDiRtYmyCi7j1s0lq23X-MH_aZaY5eUq767XycGyANYtq3OMaF7P2Q3PtFUfdgd3MXjjJp2Hrl7ZvGtdL0-oeZRuE1DARFOYkE29T54Go9U5CGnIwTy28zvE0FHSLaEUx1DDx2zOINKNdmMRYSofVH2z7ieNrXUGjbrp2RCIPr0EzTve1pTPbfIo1ynSCzXEFirizl3PEQdiuuL8JIrE3BtoKMuqeMfvPh7-0zYfqd-byyXFDGhchdActRqhhKXJCYZ8T9v0-bYYODGk9VFMp2jnxnKepsrnd-Ulnw3wBI13B_7dT25n5o8Je9Hh_zEMCK8W_--RcxRGASrxBp-An9epOdnbQHmQo7P2r--Y33kCGwud1A_lLNlrAywOG4ZwP8hjKkfEiw8jRA0q8bwsMAWSZhas1mtHiWn5xtNPpZEJf9nlOn1F9DCSnfHSi5l0D5lzVYNFwJk5zkCL7ZpimECuQmGYwWMPeP7nhwOruRGI5Uwu9S3djh7DShpJMJH3HdnKfsbcqU-569x4girbJ6whiIKgusi6ZI8AUcK4yxxAEebKeuHb_yNQjlel0oHiB6h3o-p9SvI0c__QNoEzDSSETZff5V7TTDsXIeinqtGC3Il5jcxKRLASu_JYST-Yj14b7vOwY-2ok3deuYpXIYi0VVgo12wp732vGZOrr5TY2g16BdqZhZr3BKktq3pG8mQ8EzEYPugEx3YZDYKOyYOevdQLN870QoulmZkSLRTLfdbhOJUaEH3qUorv43nBSX6qRB0gs_OIlylYWefWOUv02vZ81m2ryPzGI4Eq5AS8SVg_9JeiMf5TTcG4rGLjZ3WfxmR0sqASI2H0o5tMWm6xcHp-x4hWGpnC7OUPb0C4PxuBdxGCr86Siwx0IXHmoR8Ma4b0J2hEPLOrLLAEYRPdq66Oi6zs8_fNcpkoQiShQxE1Wdz1nnNQQ0U61-D8r_VZqkc_pc55k6FnEBsvioXUfkfK96NMaldaj94icr8La0YS0gI4ECvi62ICMx7AbNx7Gh3UOzK8Lo0eF6B-GceXIs6Hg9ELZXrDR3GkdpEH-3l0vFtu8fV53CXb3AQmO7RDnVww1uFsP5VH-hzH7L_2Xkv4dyToLmuCBufSEt9dqfLrykvJVLOy6ZWbwrED7qs94OzjZplH39SrxS8zMk4qlgLg0p-HuLLcF-a21QCpbyhbZMPxPUdd0PcL_XdnWtWEERbIwg1VGtA6T6ayYf-Zn0YF8wpkoGGnC32D8CJvl6X8qgpirVpZB1pB7rXk3e51qALoTHAx44CYwPW8Jle-sSAj-qGp56rkJULg5EUcub528B6KHmaZXlBHdlQQHeqwvJ0ycg65k77DlSunWAjvHWWPOF-YaagSTl7Uoh_Alm8NJVRhWSGRXfZ876n0wSKQxXTDUPft1WHDkv0QONE0TiPl_RDXrG7zU8qw8pHYpR8Xdk55V3ub-PsCt-yiTKMhKdMuZeSmuelLR_Anaz2_AFnq0ZJUD81pXyJJK6z5ov4gKCwAP9DKY4hofU9m4TGNrq3Zq2F03WxG9ZGNLssN7wTYped15O2pDmxC-2quYuhRIwb9fSLkMq84nEcdP0nyBKOXEz7cEZq5BE2FHt1o9sdgOcVf89v1Wsy89EO--TZ8gmretTJ051f2t5PJDnfgAOraemwbVIk9Jp3KE98voA0F0HZ9BIIlUWuXUiVKEBOfCP91XOhYEB1Tp1DejkUGhjcjsufqMtiwSoZvHaSeqUb5GdWI8y4ojVzMqLnCiR9abwKqsJ_qXAdYm_Lag8ZGYMYjCoArfCzlLNF6sajfvI_BGlGdIg0sfN4SBSh_72fE-NnBIC0LzCZHU3K5X6BzNPY9L1ZP_aphkwifNXPg-kYdrkFVp5Dms1GnuzuEDlGzgY_0kbindDqxq7DpBl8akuLMFn7M3dK-Lb5rwnF9AGMuO2tmZPkUoh0yS_Jj0UoNcHyfwo9_CK0ALnIwWqt27ImKYu2Jg242pv8dDHlDQQwr6R__54a5eECTxegPA6CUEe6pdROKn7OiYbHQ8DU5oNARJKBSsFiP2_YnuhQm0HxCuZioaokIQg-kQUNK1Iss6B6XHsfqelKFeOWAtnUQ_nzdlV8tfwF6Kk24lEAsp2i41up8OFrLDkE8Kdh6IF7qYY0p5Ssk5xf0DspBPpWQkQjeXCI7tCkyXfVH98pZH8U2PJl4z_dg5ZRyWwS-Qw8TOBWviutIA2GxoFU1m-M4fsgpnzKb3wzXFFFVtZVKFh-0x_FcMuBYTrafmmjvar-qWYUe8NYRlnZinTFhulGIfCsWuaaa35mO0yIEaj5BvadD-ARcIZ4mFKmsH7mGmjNl3ZqY_5sUs3_nuh3dUT_POmgfbPXE8FJ-Nk7JibMN43X5XrY2tY1zrik0iuk7fIbNhLA8DfDtcYErx8IHNRYCVL6x2bH2l8tPAFo5_tJw5RCntxSMoZ7R-X5IHfYBlkatrPJ8VZq_yVXuskDmKbqS8KML_uZYRZwNYeENPzeWpb_KnUGuzcdZ8RH3w6BwVhAtQ1JF7Fe2ggcJrfxkAUKHoGrJdA4s_FZFsTmr707udBZt3c-0CIpVXhueca0qSMYBiOGvgAPjCX7DRzH0DxGMsIRnvu3dN_DFyyUvqm-3rKki2GN-bv9ESffs8XptaEXnoDb1LyXfhEDycN0DKtC0r1d8gD469j-NXK1cV-ba4vaPbQrM6dnNNyYX-EMiVlTqHv8IH96Tr59z6Tm7B0UsmTDDYZRRmr9Pww0_xd9Phaq80LZrKOgt5RUhuerijC8SX7eswfh-0sokR0_gsxDwXzEJqMgtjq6y5VppQur6b9ENwGWpCYPXuYMtjC5XoQiX1zea_tSxqQE_vvwt4mPpWiUhpeHiBJYfLGR7XnCpkLDlDMHgPjAjxxkreYc8KOkq5JculxHmvwQ6TQkdNif3Bsav1u4G2E-zfm82n0YlBNGgFSQPbaKwHmjQnwkYU6fMJQ1lql-8uiAo4bBQ-dfHR32Gp8420pA0zZ3ynGQIWijJ0wxwtbv82vL_G1JQe3UDIsPGv0KnLQ_QR0Ts_rgX6f2g6w1zmXx-VNV9rilgUEzfFcQmayde_fl7wo9_3os_HorRNks52NZ2e_81UP3Vj8Rzw0Iah-3EjS0bCXSBh08CMnAZFVmnDvBFIk8kpFZMW1KsVEOQighrJQuFiZZWamro5JYm5JZbc-bhGFijdDAUdIZROBEU9taxslOPA76Erhnej4fKpJ94UFESxPH1PlsViDcDo0cvnxw528w7Tv8QCGUsQGJNjrXXigXK1SmyAcQXqjcpEiHDAe6gNfb_FpRT-itrHuK731vC7RkmbwFCfjHv5JsVLygJ2iKhT4vwMBSj2VGITMjdv-5CEH1rgtw27uBz-2_73i30yrY-rA-pJcUQ7WsDGlikVoQVl5E8DksTnfTb3AZJ0i4x1c1HlWQrrWTxU2-RFRCzymYNkl4fPNT01-D3Ig-JewPp_4N1OqIq-kLVnCNctgi5wPGDJQ1jt7sgruG2TOcE1b1eA5htgdE0JCfSHKPycOTpqb7XydULWHZmS6leQ3QTuaWRvnK02nBkBhTPx_l3I4UCUegXXmCM1CpVsNM5606Z7p3aCK6RJGVBxbrqGf1NsZUlIhvGjV4LOiTUZazYU5GZzmIJEoMCKoZ3wkfuNqnG_maS-2NUDvcmp-jIEOvd5i7TTzAr1Kd_67kRyn42NPnKv0jMbcJ49sCFiHLEAzeicINX2i4KlbpCupANQ-H2NKmsNoHqzQ-MpnN0bMJGxn628H2bFwDLefCC-R5_UIHI9_Juk-CsEigvnWRBjWpcWE3sfjgs15t3ctPb4QM3dS8YPQO8r31dHeWXU6noDtzRbkPu1NBmBDdBcLyoeonHnV5izg7DO5vsMe-tbh7YcCjN9qM1KDlwWIERWJorG2oBljCqdNOlHKKvlM-UkIb7o-2piSoiIWJgl-hlz_bSKQULc5EzpevPAVih-9m830DLx8MHG8jNbHYapF59G-VPxf0fBmPogyary67HZ5As5uT6Pay-sVEm-M-hEw2pCbpcNPJksxXg8vfaKJNO-6J_gmJe2Gr6auQsovzewXbyQ=", + "summary": [] + }, + { + "id": "ci_023aca0419c09a81006ae4433c5e7c87d0ba45ae85af5aa29b", + "type": "code_interpreter_call", + "status": "completed", + "code": "# Correct computation of the 12th Fibonacci number (showing both common index conventions)\r\n\r\ndef fib_zero_indexed(n):\r\n # F0 = 0, F1 = 1\r\n a, b = 0, 1\r\n for _ in range(n):\r\n a, b = b, a + b\r\n return a # after n steps, 'a' is F_n (zero-indexed)\r\n\r\ndef fib_one_indexed(n):\r\n # F1 = 1, F2 = 1\r\n # This is the same as zero-indexed F_n for n >= 1\r\n return fib_zero_indexed(n)\r\n\r\nn = 12\r\nprint(f\"Using zero-indexed (F0=0): F_{n} = {fib_zero_indexed(n)}\")\r\nprint(f\"Using one-indexed (F1=1): F_{n} = {fib_one_indexed(n)}\")", + "container_id": "cntr_6ae4433089cc8198be33ad123077d03d058c8c33406196a0", + "outputs": null + }, + { + "id": "msg_023aca0419c09a81006ae4433ef09c87d0a799f1a0db522528", + "type": "message", + "status": "completed", + "content": [ + { + "type": "output_text", + "annotations": [], + "logprobs": [], + "text": "The 12th Fibonacci number is 144." + } + ], + "role": "assistant" + } + ], + "parallel_tool_calls": true, + "presence_penalty": 0.0, + "previous_response_id": null, + "prompt_cache_key": null, + "prompt_cache_retention": "in_memory", + "reasoning": { + "context": "current_turn", + "effort": "medium", + "mode": "standard", + "summary": null + }, + "safety_identifier": null, + "service_tier": "default", + "store": true, + "temperature": 1.0, + "text": { + "format": { + "type": "text" + }, + "verbosity": "medium" + }, + "tool_choice": "auto", + "tool_usage": { + "image_gen": { + "input_tokens": 0, + "input_tokens_details": { + "image_tokens": 0, + "text_tokens": 0 + }, + "output_tokens": 0, + "output_tokens_details": { + "image_tokens": 0, + "text_tokens": 0 + }, + "total_tokens": 0 + }, + "web_search": { + "num_requests": 0 + } + }, + "tools": [ + { + "type": "code_interpreter", + "container": { + "type": "auto" + } + } + ], + "top_logprobs": 0, + "top_p": 1.0, + "truncation": "disabled", + "usage": { + "input_tokens": 2036, + "input_tokens_details": { + "cache_write_tokens": 0, + "cached_tokens": 0 + }, + "output_tokens": 1298, + "output_tokens_details": { + "reasoning_tokens": 896 + }, + "total_tokens": 3334 + }, + "user": null, + "metadata": {} +} \ No newline at end of file diff --git a/packages/inference-discovery-openai/sessions/openai-responses/gpt-5-mini/code-execution/session.json b/packages/inference-discovery-openai/sessions/openai-responses/gpt-5-mini/code-execution/session.json new file mode 100644 index 000000000..723837f2d --- /dev/null +++ b/packages/inference-discovery-openai/sessions/openai-responses/gpt-5-mini/code-execution/session.json @@ -0,0 +1,11 @@ +{ + "schemaVersion": "2", + "source": { + "provider": "openai-responses", + "model": "gpt-5-mini", + "baseURL": "https://api.openai.com/v1" + }, + "origin": "live", + "capturedAt": "2026-10-30T07:12:00.071Z", + "capability": "code-execution" +} diff --git a/packages/inference-discovery-openai/sessions/openai-responses/gpt-5-mini/grounding-streaming/exchanges/0/request-headers.json b/packages/inference-discovery-openai/sessions/openai-responses/gpt-5-mini/grounding-streaming/exchanges/0/request-headers.json new file mode 100644 index 000000000..28c14bb85 --- /dev/null +++ b/packages/inference-discovery-openai/sessions/openai-responses/gpt-5-mini/grounding-streaming/exchanges/0/request-headers.json @@ -0,0 +1,4 @@ +{ + "Content-Type": "application/json", + "Authorization": "" +} diff --git a/packages/inference-discovery-openai/sessions/openai-responses/gpt-5-mini/grounding-streaming/exchanges/0/request.json b/packages/inference-discovery-openai/sessions/openai-responses/gpt-5-mini/grounding-streaming/exchanges/0/request.json new file mode 100644 index 000000000..b6eb5b2c5 --- /dev/null +++ b/packages/inference-discovery-openai/sessions/openai-responses/gpt-5-mini/grounding-streaming/exchanges/0/request.json @@ -0,0 +1,16 @@ +{ + "model": "gpt-5-mini", + "input": [ + { + "type": "message", + "role": "user", + "content": "What is today's top news headline? Cite a web source." + } + ], + "tools": [ + { + "type": "web_search" + } + ], + "stream": true +} diff --git a/packages/inference-discovery-openai/sessions/openai-responses/gpt-5-mini/grounding-streaming/exchanges/0/response-headers.json b/packages/inference-discovery-openai/sessions/openai-responses/gpt-5-mini/grounding-streaming/exchanges/0/response-headers.json new file mode 100644 index 000000000..3d2b4c103 --- /dev/null +++ b/packages/inference-discovery-openai/sessions/openai-responses/gpt-5-mini/grounding-streaming/exchanges/0/response-headers.json @@ -0,0 +1,25 @@ +{ + "access-control-expose-headers": "X-Request-ID, Server-Timing-Total, CF-Ray, CF-Ray", + "alt-svc": "h3=\":443\"; ma=86400", + "cf-cache-status": "DYNAMIC", + "cf-ray": "a528a354dc952a8e-LAX", + "connection": "keep-alive", + "content-type": "text/event-stream; charset=utf-8", + "date": "Fri, 30 Oct 2026 07:17:03 GMT", + "openai-organization": "", + "openai-processing-ms": "896", + "openai-project": "", + "openai-version": "2020-10-01", + "server": "cloudflare", + "strict-transport-security": "max-age=31536000; includeSubDomains; preload", + "transfer-encoding": "chunked", + "x-content-type-options": "nosniff", + "x-ratelimit-limit-requests": "5000", + "x-ratelimit-limit-tokens": "2000000", + "x-ratelimit-remaining-requests": "4999", + "x-ratelimit-remaining-tokens": "1995136", + "x-ratelimit-reset-requests": "12ms", + "x-ratelimit-reset-tokens": "145ms", + "x-request-id": "", + "set-cookie": "" +} diff --git a/packages/inference-discovery-openai/sessions/openai-responses/gpt-5-mini/grounding-streaming/exchanges/0/response.sse b/packages/inference-discovery-openai/sessions/openai-responses/gpt-5-mini/grounding-streaming/exchanges/0/response.sse new file mode 100644 index 000000000..f59a0482b --- /dev/null +++ b/packages/inference-discovery-openai/sessions/openai-responses/gpt-5-mini/grounding-streaming/exchanges/0/response.sse @@ -0,0 +1,126 @@ +event: response.created +data: {"type":"response.created","response":{"id":"resp_0c5c51d167d5c241006ae4446f0f1887d0a76d388a78eeff0e","object":"response","created_at":1793344623,"status":"in_progress","access_programs":null,"background":false,"completed_at":null,"error":null,"frequency_penalty":0.0,"incomplete_details":null,"instructions":null,"max_output_tokens":null,"max_tool_calls":null,"model":"gpt-5-mini-2025-08-07","moderation":null,"output":[],"parallel_tool_calls":true,"presence_penalty":0.0,"previous_response_id":null,"prompt_cache_key":null,"prompt_cache_retention":"in_memory","reasoning":{"context":"current_turn","effort":"medium","mode":"standard","summary":null},"safety_identifier":null,"service_tier":"auto","store":true,"temperature":1.0,"text":{"format":{"type":"text"},"verbosity":"medium"},"tool_choice":"auto","tool_usage":{"image_gen":{"input_tokens":0,"input_tokens_details":{"image_tokens":0,"text_tokens":0},"output_tokens":0,"output_tokens_details":{"image_tokens":0,"text_tokens":0},"total_tokens":0},"web_search":{"num_requests":0}},"tools":[{"type":"web_search","return_token_budget":"default","search_content_types":["text"],"search_context_size":"medium","user_location":{"type":"approximate","city":null,"country":"US","region":null,"timezone":null}}],"top_logprobs":0,"top_p":1.0,"truncation":"disabled","usage":null,"user":null,"metadata":{}},"sequence_number":0} + +event: response.in_progress +data: {"type":"response.in_progress","response":{"id":"resp_0c5c51d167d5c241006ae4446f0f1887d0a76d388a78eeff0e","object":"response","created_at":1793344623,"status":"in_progress","access_programs":null,"background":false,"completed_at":null,"error":null,"frequency_penalty":0.0,"incomplete_details":null,"instructions":null,"max_output_tokens":null,"max_tool_calls":null,"model":"gpt-5-mini-2025-08-07","moderation":null,"output":[],"parallel_tool_calls":true,"presence_penalty":0.0,"previous_response_id":null,"prompt_cache_key":null,"prompt_cache_retention":"in_memory","reasoning":{"context":"current_turn","effort":"medium","mode":"standard","summary":null},"safety_identifier":null,"service_tier":"auto","store":true,"temperature":1.0,"text":{"format":{"type":"text"},"verbosity":"medium"},"tool_choice":"auto","tool_usage":{"image_gen":{"input_tokens":0,"input_tokens_details":{"image_tokens":0,"text_tokens":0},"output_tokens":0,"output_tokens_details":{"image_tokens":0,"text_tokens":0},"total_tokens":0},"web_search":{"num_requests":0}},"tools":[{"type":"web_search","return_token_budget":"default","search_content_types":["text"],"search_context_size":"medium","user_location":{"type":"approximate","city":null,"country":"US","region":null,"timezone":null}}],"top_logprobs":0,"top_p":1.0,"truncation":"disabled","usage":null,"user":null,"metadata":{}},"sequence_number":1} + +event: response.output_item.added +data: {"type":"response.output_item.added","item":{"id":"rs_0c5c51d167d5c241006ae44470251887d08301a5267be92ecd","type":"reasoning","content":[],"encrypted_content":"gAAAAABq5ERwaHx0Y499GNpckxHgZ_fjbFpibRSnYUspIgxi6zbIJOY7vRsS4I_g-Bc54HMIOGxUXZAIhweuFPOdIgEUh47AqnEuXEvAAZ_uwJj7SL-DkyuyPf0IeT68KRqRvsmaHtTVhLF05kogQjnBSo84K4utldEWFQBojNUeanIwyKFZkWhr7rvF67KRk8sdYhE805pTjnMyUQQnj9KeEtjG0uqKTghVJ98KhahTBLOicFYA9_LBSlIm2HLCXTg9YIrdnQHpR8Zlou3eSC9BDu-J5hLNwVXaBRLMtKrhR4AN8OVSdum-I-352ifjpYqvdOzdZNXBNzUl3IUo9Lvint6jTTwcNbolCB67KTMEFgahMqeIMaLqn_Dd2oTFYMpfBcYZohZIXaS3b7tr_TkCAeiJKANLa2Igjm0ljb5REazX6Jric3MCWTI_0mumojmNaxGXhq9pb3UnJWXvOupw1JHnTbjKZFqcTbBQSE0G2m0b8umhDtCFrdi1oisJ37UsShh4XZbapNrBSWTzO6_nwPGnh_JhfflL2e9sSTd9guaqZeJHO6nkVlo3fdUJDlffJeh4-g5cUF3XJpe7RQ93QiXhxT9k-nMVVeEnUXiCHtk7a646YaK_7qHPJdFK3-614EIXEAe41qD8IPYOy7Jkk0kDWyuSu8OyTJzedI4bbanAYKz1MVmFIaLEiDLQmsyWuxiXNzYUc9Kantg_26xraB0lNWIsSqTzQccJkUKZcNmxQk6biNHTqxrb3bP3ufPA68n_vrTEeWTUqY0fsAun5WUcmrZEVrQ41sdW-vDU5ob6T1hYcLaW2SZU4SxlQ3sCnSpeIDFNau9jcIaw-fXk0zAGN3wMokDRVRNRnRG2qCUK5ORshW6MEU4iK2VvWMtfLISL3ZTMCPqeNNQSaIB0_97svqOK6XQk8ZQZcgDhsj1Hnorn0EOh-sln2aHymQc6bwp17lzwY6nFahJxIbnEwmgW5FMzBVUCfALXCPLSf8vaNmtHyD-8vmR_90wF4JDMDj55vW3FOCKXClCYL2ui6ZC9w43fAYvXAGJ9M94XS5yuSjnquSGyJxIjZX6eYOf9F6TxEjlYF5Nq_4gqcWlX0JAhpgYAk_89Xfyt019uFWyhmJ9YW8JA3aucsh8UXjeJVdZi-RFdZxDR2jVFggJiCa28EORWJotLahOvAICqc2Ug7M_AFlPh-04sjIYT_Z5YEubdKrUY0T_BDzT4ILpPrOBnaq6Q3Q==","summary":[]},"output_index":0,"sequence_number":2} + +event: response.output_item.done +data: {"type":"response.output_item.done","item":{"id":"rs_0c5c51d167d5c241006ae44470251887d08301a5267be92ecd","type":"reasoning","content":[],"encrypted_content":"gAAAAABq5ERyJTBHy8WdP4o4BaZf792l4Q4DY-t12tkXpk0ApzgF2zPBYoPCobISUutNzKgyB4PD4upvWi4T3VliCxK6T53PT6ZnDabmXjiQfGWEonw9Yg6G2gGyc4YC4wSHKM56smbZnj0lu6OZe79HBRd897VMPuhBrqepeVXQQTKqkvDqzqtQIyLeI0b-eDvqL7hCDB1omXdA_CctGqKCpNGTUfMwpllmaSRUPsgNcaGohIh6IQtLnrO8XviLReATfZyEUEVySjQxKN9P3BP7fvpiARg69M2zHijAhw8S8Ttvgu91QbtEaFiZfRfiguvAwO1_n6zapy0sVAspyDIvxKb6y6R7H2vACGd7zJG_Au1car5nv5dSaRkjmaW3OzFH7lLGoaozw35TUj5wxJ97WXFRa6IxKd9x4HMiBToGPW9To7IQbkL1__bPUxUbYrPjo_p1-rG6LaHP_7ZjT841WFEufn8i-pvaei0Xp0RMaPl4ptEJqoPsr-agF3U6kZXK96sH2ECboo2a3FkqSqokFOvZvtQ7FoMb9nPvNxupbXtOi4pNf1zOwcGmGptoZLgmzMhuK5FYeDa1y8rA3PqAc6O4AC-VdvemGhdvZz0snqzReUh9qABrD06wnPV8OdTGWfBZ76q0Apkgwq_Yu-Wdjc1W3gHQLzbLnNf2fCDCGOuUlq7LRAWTfqWEd0a7xwqU_jq7h8vd1xNGnNWZC6Tc_O_NFATsGPATtGGhFctapqEQdb9q3a66eLfD_iUmo07Z4zsNHIzzwijYy9_1yHY8H4AWm3Bpf5VfUH1pw8Wrv55WVfFJs_AK5qwjLcAPyuQskVZYrg8hkedY1KR5LhwqeixJoTPG44dAm9z-1KBer5TFQPPFbJbeneYguKJEPrgo-fPzOGoC_Weo7MP_xs5Kx_6FVl50sehqHOPdCiYLCe6ktlL_YFYBVAHgGNz47tXsdrV6I5h_o11sqX7Cd14kUkXuKVEnmi8nz_yvWseiX0SQs061od8uff2LKearuQHGTcO-5eMZlyKu34-h0HcshwRjOslhELOOK65l3lnfEppHXpQuK65IQqFBBgwWlfy8mk07LDzdyAYcnNdEJgq4otOnHxcXkqV--dsOUMTkoFuSj6rpCL8socS6XbWNvC57LvIAdqIndPMCMNbmhEGX8LFipUFecmgcYnDtST5i2m23HF1uxtcHsGVXXkMOm5V3eo9tROr-vpzW6Zd6GclvkgCoQjVaUMD-K6LWEFli-W-T_aXoUwyo1Y-_HNKHu7VJrnCXkoI-0V_3Q2noVXsp-o06BlXfpN0onDmBP4ByyzhzcuqdHJNVtuKZk7tPVNqR1uWKaaH1AshJHyRel_7SQZ_HJSv89cKdQ1uoeT7GaGleaQYR1mp4siT9hkkW4GqHheQYnas1v0Z5mw7raWuAn_nt-jAlK4m3dzuhrZeVF47Tedt3-eGwPjpdTsfqQKMMho81nJwLqeZv6eJu1G8x-sB6McqORSZ9feueR94cjK31Jqa5VU3P4ulmnVijFLZt6oVwkTmkX0RESk6sEsaXrrxm94KOPm9ctkv-5vDlTVCWAipqN7LtvXdxxq6bDQDZId_M-65lYsfyxf7P2wB2mZPwzFJPKwa6LUt_vxSx3tf984Kvoikd1uQnB5PoVicEi1YP6Vz5zKb3UAWnfPs8UAQFjzu3-h2EXDHM1KB6EcpP4OlFF6BY9LFxYp7A_q-i4zUSDrQUfNp4tYEfBqehLdpgA7hDh1Wtq2FKDIEo4OumQkazMiR88sdL9VDjSFa1iD_0CLjqVkLXqRvr1Lm0GGZNOwFyvwdR5MKmf9BcuvTLTg-LdMPB97VPZNL2Q7u3gZlDCvqSzRKxpWKjHCvSA3QQgjQmyDflDsZGFg6WeGmHUxhdH0FFjztHbjZ7wg20XYdrsMl843tfpIRgiK3ir4P_Yv5Fot2N0_i_gFo2KGUOKwYYhLTNbmr_5J84JuKBIgkK7lAG0qF-ySpfVVe0eiIOz-rqKk7LjxcyuYqqMBg0SRMGfefLSz0vPev9oc41r5GMpI-zD_cbC6MV5AFPNHeft-dumn4YBpnXJdkLnHjiIkr7S4ct3Snc7Y_0K-ts_PUz0nFdlR72SJSlMZThHWRVolnzgDn4uj9haa1Kzo8wFl551v3DXi3SDVFGVEt5IeJZDvRTx7cWVInpVktGpC2VZT6NwDXtYv8zzRntGAL6pqoDjzAsvzrBz1eRel3V2vsuUKWKC4jx3rEgvvhKpreas35B6FxaOB_Ok1Cphc66QehBhthiJ6SiND276Ljh8Rl9KVWLzPDLNYPBuYYLYrZ6A_8tuhzgnWuAG1U8Ptu-vEbOBNz_yKliLYWvfBHUC7vLtVGyEUBx3qj_M2smTs6BTExNXv27vWPbYDfnjQuwALzrugmBNKcYtIdt7YVnWnTi-vGCXVZdj3R1yqTLyvgOUjLJI_g49CPJZHRhFgFQhhiQgJTDYM3nALFhUL-HHzNoYzGp1-okof5HyLoPVWXoKXKw38Ba1t1XeTPdZm2z1Nrv1c0svP9KJgLvvFSPneZ6_icVeJ1iAlRcWoEFzocFLWsJ0eD-DXCXrE8mjQa7NarSmpdGzUBw9HOannzVMsefCzYxDvxg4KvghTp3-r4hnZAbUtXc9KS-ThHyBxeoc4SoZgEgitQv-mgDWI-EYRAVhzAktheck-cc61LIwdI88eYTddlvjYrZtbxwvkwqA0MTtmfMfoUs3JtBiQLfW-nm_savW07TRUcIOx-2WKEX7uFWeKCP8wIi1dASAYAY36wG5IPUE1eEWM4cHkJ8p37MUb88yumDecz-0ZWKR7-RLxCnUsfXwg9MGQq9yetvzEi8gYbxk_Abh_XqNhySIJN61mgXml9Ni6sg7AoEvBrabFRbLKviE3asIHk67okHpVJNj_Ak436QZ-htPyZKo6zed7JOZ7Rw6fhdv-PbZmk5k0d-S1tX3BmFt7OupQ-vd8WDSv82U30PHN04zis0ovrGzWACpqEBBDHGZ8xjxF5L392qJuDPUUmtTV29SCPxSvlvpBFNVxTZlSJbyouXqBny1K_8ooY8ktbaCj9Bqqv23zXMms6kvJoLBLSxLZPnI_q1l0iICAxpKsxn88kf4glHj1qwnKfT7IQqcpAGOPKbXmsmOjnvAhBRrWDCDx4e07PTwpUj4MTijbhlejQWHobMwPHBO03Ib3s8LO4fyGsxAC8SfiicOhrzTMPmPWtARaTLyGPTgtA8nwGmdmMwHwWyWCbBCzIo0yV1z0uSwKHaMcN6AQ29o4izNQWt3_yFBmQKzeXoBHCCVbEG7aLsMWQejg_Vop-bBIly2N2u0VG2uhpghTzomOand_YkKqELbLut_W2AuvqEYD3YejlqW8HfSILyR6l5ld-InQr6HKzSmxvklDxu2NhUv18J02ovD2rHDkA1SWuWsrsPWnxsX9GSjMKvvgBcaN4fHBDE7UZTpsv7snXHaPUB3ioslUIBo2Gy7KE3ICtCyWftUiGqGdv5pz10YhrM-j2ZzOEdxpkri3KUrHeYQ3G_8JDhdb0tlBcCH6SWdwuX6T7VWWNIudPYyItmWFkBRo47xIBVHd6COFVsfSwuGWdijqc5eMWb2ZsUo0-L-_ILKIAtXrG6jAbZRyxIMnHbHK9at5e_MTfgvSNu9FRcmQOXdxHz5gYf18jciMbSjAFAtQuuX_KDPauR_Gba6dX7U2onPm0ceJ0RFBpK2TcbBVMGiw6gbuQFk6v9sVkocRgm2_aKvrsT3CGBBehyUPkpQAcc_KhFFpiEuwOhEK-n202f0PfG0q4aljxIjRCc02utH_nwZIt61bGUQjbXa-FHupA-WG-vUXe3TDOhu81lW37SOv_5eUlukD1U0AGaFFj79JiGHZIqemrmmcNEkNuma9t8ZO-IisRAHqYOlsvpWUs-iCEmKzSxDd4YnO_TRlfN6GsAJtY9rtxGAVsf-89AeFehO_XhbzjLkYRXKpNsgPxV32NhxIEtBD-sKQH096Gpk2ow1TpqbSKggLuMeZJ_6FEfw69pgRFH2CKURJlDn6RYD2NRIQR418NajsZbWZ70iyXPE3y2y-CRVL4zbfovwv7Td3KIe2SvKLkBMYuFU2Mg9TPCbmoYUmFA6aQbVLvAEyNYoXd7ds4I9qPCrv8jF2FhE7JSlOaAvE8s1XJPt_STR51VqyNhctzvxI52lAwXrxBAPZ4ovuJQ8T2B7sYj3q4GP06_pjR4mAteZm4iQGzdoUQvuqqNuIr2e4zMLqwDDl4JRIJ-tM5nsjuqWEcOn3f0Z-ClZajkzzhql2wrlYs0TvqctRasq0Yrc0dah7wmzHi0z1yAsbRQA4oYx6A4F7ljx9RcqQd49isAXS9PbJTEPgYW8UUJXeuJiliXS-XCzIm8JprxsgqP-oJ7gLGBWE-3v03k_gbHU1R0SkNGI-pC4VgRwQkB_0fQ7nnn5PhXSHVszlh2dmOSQAznwpJxO5HLFBNpE4TyJxE0GdIciGu73oJGqL83Nv9qy9J-eD9mXZZ0SH_gQ5wtA11650m5ZYFzgOWKcnp_5M8IyuydWzGN0Lh3j-gZmS1EoTO5rjwS9wTt1q2N7GI-_kysf4h6R3Dlpnyxg-1LEtLW4OMIBV50BNJ9at88GwSqYhhisbNcjZ4LHy9ygBH8R-sR3eCB89rcBdomasNNwvunBn2KvLxhu1PzIT3sYxnQm4yEiRbg6Ys2PD0eny_7ynPfpRni3oAZyiAXNrLZzi8XOQ==","summary":[]},"output_index":0,"sequence_number":3} + +event: response.output_item.added +data: {"type":"response.output_item.added","item":{"id":"ws_0c5c51d167d5c241006ae44472fc4887d0a8a45fd5eefdcdf9","type":"web_search_call","status":"in_progress"},"output_index":1,"sequence_number":4} + +event: response.web_search_call.in_progress +data: {"type":"response.web_search_call.in_progress","item_id":"ws_0c5c51d167d5c241006ae44472fc4887d0a8a45fd5eefdcdf9","output_index":1,"sequence_number":5} + +event: response.web_search_call.searching +data: {"type":"response.web_search_call.searching","item_id":"ws_0c5c51d167d5c241006ae44472fc4887d0a8a45fd5eefdcdf9","output_index":1,"sequence_number":6} + +event: response.web_search_call.completed +data: {"type":"response.web_search_call.completed","item_id":"ws_0c5c51d167d5c241006ae44472fc4887d0a8a45fd5eefdcdf9","output_index":1,"sequence_number":7} + +event: response.output_item.done +data: {"type":"response.output_item.done","item":{"id":"ws_0c5c51d167d5c241006ae44472fc4887d0a8a45fd5eefdcdf9","type":"web_search_call","status":"completed","action":{"type":"search","queries":["October 30 2026 top news headlines","Breaking news October 30 2026 Reuters","Top story October 30 2026 BBC News","Top story October 30 2026 New York Times"],"query":"October 30 2026 top news headlines"}},"output_index":1,"sequence_number":8} + +event: response.output_item.added +data: {"type":"response.output_item.added","item":{"id":"rs_0c5c51d167d5c241006ae444759eb887d09ad0d811191022c9","type":"reasoning","content":[],"encrypted_content":"gAAAAABq5ER1QTdEQlkJXXnxsPEpw4aKrgX07NA1C_naQEH61nWcfjnLafWpBDoTCK5h_L95rvGLx_bOPO-tPmZ8UjD_Lyn2Gnd7mJPhWdMLypWyiUYMMcDRjCH1IIrqhGlLrJb4eC4FlCC5ojQ_62SnaWsWiJb0lfZagKUF8p1DMlS4neqZewUL4SmubE39bhbJNRIsiy4xHMf4nbj9fiOhKPf8TzMXT4Gs_a4Lrcub1ukw3Nrvl1M8BAHiYK49z9pzCbuwZOzlB6-ZOcwjQrF99fnYp2eYpWou1B89S9Jc8paLEjinGsD8UD_IEDed-SqGdM7RJ9X6ZbaghSTrzG7UTmmJNMZFTFigV362fN2owuuBGpNPqaymYg45EsB2gdeGE5kcY7jQRBCerHfZksEEn72YUOxkwFKHsK272gHOqsNHPtHJLrB-H18x2k_EGYNxguvKXHbbh3M2PkjItGkzW7sY0_xaACOBMhj7FlWvYlsUNIhbb1BLIaaXszcGYrUw6X8D4bTXsk7Dv4l_Bykop1jYw2JQ7S_K-jEaHrR-E-TA2_iLo8BNixVM5iUdGY1x4rw7MwgJofoL6xk20NO9i1bJlgKS-JIVr7HEsTuUV6gXDldJG8bNlzd-DyJqzcaUJQn3j2aiWHjbtz8EVX8pwX7aUmPrFowrvhnUN7KKojcJmxgVphvqKJuRirtD0Il3in2oy25FOhzizyjeUlw39bdcZwMCVarOxctHRps8pnCxadFvXu-l3F5Ddc8tDRuzs4mc89JCOMJFo5S3uUBANfe-xld8Oe9w-mAPJt-OPQEU5DqoY8Q5R-hLTjm-Ixn4c-cLa_ZUWAHKMxaaKj8XYnPZXP8EVUX4-y3_EI3X30KYSnpVMTsZVx-uJyx8vBzz4G--J9j765nOSmaCIRYpp-vcdKOREtwuucLFcHqktROXxxbDxbDt4EcfhSFiJmHrZk3SjY-nAQS1148A0z1zlspMoYy-lnPY0wyEbG3AUaBS2EP61JQSWYwHVxSjIGeCBB2RtFvvk3Mpv0wfDFRCffXImIA4e6lLQMOAhELQF8LFsy_pubQcITxa7zZoNIk6vGsL5BTp2BXJ9nekgulYHzm7JJMVnmR1bQGZmmmF0gaP7t0VWyXKkGYd14TDgOtYmmyQ76fmx6l-3g7Js-np45eyOHHxS7IrIx22OUlV8PxGcM7oInHiyi2SCPjBcq8EUBRPL1kxmS_Ycak5h9CBfrcaml0e2w==","summary":[]},"output_index":2,"sequence_number":9} + +event: response.output_item.done +data: {"type":"response.output_item.done","item":{"id":"rs_0c5c51d167d5c241006ae444759eb887d09ad0d811191022c9","type":"reasoning","content":[],"encrypted_content":"gAAAAABq5ER2NEZn30PFKW4ooycSWipBY9VqQG5QyFJ3rQdv2XAFdsmbrii8fOP2QgrPbfYspVVkT-rCVJpBLQ0Dskc28SzfYqUMiiqeRmzGQE4vOShWREG-Z-ElPpPaNCaZ7yqNjyNzwiGFzM3i2M9v6aNFPmA6Tzepyw9bHeVsGgYvRBeQZtC-uFh_umnJN_wKkgrT0S5HiqxGyny3BIwncQ69-kp5eXk0jfHNht4AEbFX8ABV5zbPgoSBeuMRB029sMPSTOd9HSDJhiEcabMmPOTz-Tm_2T4a01hV1fEvcz6NuZ3NrXBqT6P2haOWYkzbsiQqt5rR24ZKBO9SrmlazN5i2-oeDVDEjpZcLJ3UHFUkB-UUD1J8p8FsyWpsfGupoDsP47wkPLWoMxJMpf0gtl570iLQCWyBEV-AlUJkOwzNST12v8_2nYkGGuzgsQOoI8p8CnfJM2nWJpSf7f18SvnPbNsMI6-uEs5CYRT2xRWV4TfKYMlQnBezb1H9rsuphp5s5mRUvs-xVJrdMk8sKa7LwzYKzr0t_LApTdDjHZKByO9vobgV5Y3-EKnk2S2HufSR_-xXziufjlEeORugU2TG2TKpvGo6ADJugNDS0DEAHIoOyNJHzKEM46CNeYJo68p_jlVYmepiVmzIt4EqoClFq9zxxelDm_3P1Y23bg8V_1VWsnAfqcJYRWOd4qQnIM5v7jwBHIyum6noZhFYfeFEbeIypINtNMs7KId864SfNqmPQUSkkn28X1JZFqUYr399eOBSA1GbhX_NFjZldr52iS4BLp0JKg6U6CDDi5Us1ZE0ikhebQMD1zQUM1E8MDoU57Oph5xQ48Wua_s7lhVsSDDsDMhKlkW5VPwdeqn6x3jiofd3s31K23yuH305WDAEP6I0UaU0vBqTe8_ElzlylYmBd7MCOlxAzBqnE4ZfXVOmQ5PVa0dSGdcxoPQ71DQYjQdn7NJwUr8R4Fx_6ZyHQ6KHiTrAl_yjlwyEdYeO4GjcURl_tJ1rAEE0Lj3wviYPj5N6TQ4juFtFZDJzHU2Vl58e6E0vb88Z4PIchxDhbZ-VE6vzlndXCghAkfS-sDXiM6kbCN6UwfVom7KG7_kSsb-VpeX1GPFI7WKmju3_Z40mtbDuRvLhddGSFqR5eaaQGm8-MBIftyyKaaqBXvvCG0Y-CkH-XeuTxvfTEvHBaUSpYPRh5BwtlpfKgRy8qPt-PvfETKPG2WFlP-hLsREF1WDBdVqVWCR0cG4CDcXUtEavncwGJ6zeWEyYaB3O469f6K0bcBUmqL0vXrs8GymZS55UxttSmEcbYLzWwwVlywLsO9J1oCUYt8eD3NFH3w1E0_alBQHa_wDXqa14a3cbx2sW4sVocqUVTKprkhnabZyl_pNV7SwvPmEzlNMjkjOXHdbOyiMtsaFIL059bcXqgj58imNhp_qZkfDR68_dxILSyRxWLwylVfWlI12pEB9A2VztWNf3PLEoL8rIc35Se0STdflG0-YM0cvmXYFeBZoUL6txoQ0nHqB5qbaeMlr9SIhJhzOJgO14meQozxElwrN5TMW7yC_iwrQLJOPsa2f_LgkN9b1JHsQKO10Yl7S0q-UTYGgSxlXXPl6VX79IZJEsA97K5Ayn4PccfjrwRkwTCyN4yO7buIv8hBPLJNBEm2bRo1TVZZIeyKGRnLUNKSbmqaMdROQqNiQo9-eXfyZrV5BgE4rxdQauNs0Qn-6IPtNalkyO1ci8Dwn9bkFO49NyYelffVpC6f7waodQhj0tz9Z9v0QxHL07G5hPSkRCwebjPnHvBN9mmLcqz3wbHw781IWkZMdpKBQCV8QDTy49HCbk2CfHiuW4ZVQHUUQjgBIpEKi_rESNpsDacJWLf802uC4eKC9Vx_NaI9KadCMbHqTWlawmUkXOhN0vHAIgbMIlVDTHG6F8HkhuCW8f2KGcCDpIo1F4mLM9Npkv1PF_p2oPhBPwLnfePFCySjzCUeYHvrQP24TULALK3lvWctu3W54EkPWUx8NqJxUBNBU_DI7RP4RkSvgRVKGHtHwpMBvWse7AHGCHNRnraXLiw2Dq4KHNWU7PLFMR1tkZy8mLQOagKa8S4zptpAJ_LBgU7ajwRLacE9NtkkQfspyo_0GZyInx-2HJvkkbtNO5vZFgVLL1LENYsIKCZD5ajVreNyaLg2XCtQq_g3Kg8CQ7g-poxPmsqJzfboEsLOLjVOT8r7Oso2JUyacsdsRkDF6uEY5dgqqLU2ROoN_W73HzGoZydQFP4e500eGPvRFfNrjK3ckSDkFQP0Zi_NKb-NmDPpzFvFiMRuaINoAWH8CQ71n80Sv6bzILnLBLnuUvsLwFRnSBwgKefwKBiSyAf1oPzrTphkpvcGpZHMHzMYm3wohGggqEgdcBzJAplSAv9F6qQECjihLpB22QfhqujGRSaFQob7hW6lqoeQD0_mF_RpFrsQWqcX8kLAG0uKXdEKZ1Fh4chWURTWHPY_UHSujuBLf7Cn1wgCA4enVizEZUDBbSpMlvepPC4bJBPrk4M009_1t099FeI38e3TiaR3wzZ32Wnu4zWiK20Dv6zQj_4Z5ra7tKZJe3o2dMJRcZyHV_zQH44pqRJ28_wDbtWfdAAXLQLM7jfE56UxLeCX-Z_7J2UI0xNXp_eVQaKWfnSPanNiyiilQyT-5yKIcdJJtFaqMGDgcMpZ8-_aS-P6a-45U4pyNvKHAClZUru-ZrfkU9kVi_oFzK-pxrAKTtKncQNlnotBw76Dr065Xvz4SbA53t6K07IuEL8AmegBFdQc9IBMyAmsZgrFb8uYdtmvOsEGg3LGSlaC_0zk0d7O9_8ByHSGe8g483AbG-1j4mZGVC0qc2jYLREuJnMyl7rap9d6IYq19PEYFBb3JZx_g6IsY3wcq9f0d7Ou2CcVjJIYD9NXTDAmQBqtwdw1d3Lei-OnwGg-s_KP_Pm6IaDVpseAP7hIb13LQmxKzjOdJw9seIDpJdEv4op9rMfQ12vjHjgLFbwhqO8f3MKpPf1uzWB0-sxFr7ipsgbdLZiuyf--2txCJxHlrqxd8aIkgwo9fuxytlhDlnDOwM02a3-hFYfFhKVE46crxf6tsNZ8TI_oFwhtC6RI2p1shXw9TSjjikpllx8KKLjrOLPLeL4mp3yLReB-q_fHz0ufXBi-coHJ2AljPSx4JeI_hs6Ftpe9jsCZWI5mhhoV9UyXtCauza1aj8W62lOQtYsiK7od1jOuQ8BIu4HCzl_sHaThZGeEeefTR7","summary":[]},"output_index":2,"sequence_number":10} + +event: response.output_item.added +data: {"type":"response.output_item.added","item":{"id":"ws_0c5c51d167d5c241006ae44476ebd487d08fa677f3b958340a","type":"web_search_call","status":"in_progress"},"output_index":3,"sequence_number":11} + +event: response.web_search_call.in_progress +data: {"type":"response.web_search_call.in_progress","item_id":"ws_0c5c51d167d5c241006ae44476ebd487d08fa677f3b958340a","output_index":3,"sequence_number":12} + +event: response.web_search_call.searching +data: {"type":"response.web_search_call.searching","item_id":"ws_0c5c51d167d5c241006ae44476ebd487d08fa677f3b958340a","output_index":3,"sequence_number":13} + +event: response.web_search_call.completed +data: {"type":"response.web_search_call.completed","item_id":"ws_0c5c51d167d5c241006ae44476ebd487d08fa677f3b958340a","output_index":3,"sequence_number":14} + +event: response.output_item.done +data: {"type":"response.output_item.done","item":{"id":"ws_0c5c51d167d5c241006ae44476ebd487d08fa677f3b958340a","type":"web_search_call","status":"completed","action":{"type":"search","queries":["Reuters top news October 30 2026 site:reuters.com","BBC top story October 30 2026 site:bbc.com","New York Times front page October 30 2026 site:nytimes.com"],"query":"Reuters top news October 30 2026 site:reuters.com"}},"output_index":3,"sequence_number":15} + +event: response.output_item.added +data: {"type":"response.output_item.added","item":{"id":"rs_0c5c51d167d5c241006ae44478c27c87d096983ffa03f96839","type":"reasoning","content":[],"encrypted_content":"gAAAAABq5ER4vCT1LfNn_48cn327wTi5MXBeZ2fU6a2bAHhabtIA-1vgfm6mRNX61St9zgiQLBgQz3Ef3vXqdnlChYfSxL-Wfud3pav8G5vTdezJJegRgP2iIXwUQcT42lmwDO7BpYy1IMCDR7rVk_EcP5ajFo4ienZrNflIi_awMdxVxWXe65AUCf3MDnyAhVmOCIZkQooQ7LWyAPyktnwQ5FyXKflW52-28sN0wZVjfb9-1Qqi5mbD7oklpLapJYO6EH1YO0HiG62xy0vzfiIKMSDq8A1JBBL9-uj7wqGYdy6cEyFGrw77wvoXAdYQkAQ12cx0hOJ5_puUM4gJqqfBMjIjyZQqQAW7ylGhAGEQKjVCuFk1yvE6xPYkip3-DW8DvbWGLka5YZHj1ybnisINValFGchPpnwy_H5iLhI88dJrhimp99JCrgGgG5OS6c_4R-ojJL3arHRv_P6bvQaNyzSnvLW5yYri-tOSX0n8xvHOVwqjtKrlUMapq866wd-te-ibIe3rip3nBIya-jA_M16xW1FB-v0r-3a4EiSzl31-1fhisAX-uUx7uLr0ck6MNVcQaEcOGaxMX7CdbFYBaYkJkMKfto7U0RF5CohjOC2203TVSY3CNxdMW0PKxjJrzCMKc-06PQ5ExY3Yq2hSqlQLQWKmwrq0rgEi9C-cfz6arLrFVkPRGd0vHjD0_VnUI-8dkwCwtIrje1wrSCppAu9EF1KUOnksAaYBvT_5QFzVk-ku7MfaKTISaFkNNLUZD8EqoumArvA-r1ubhoh7gX9D-CwZjsM539H8CJFzjQGV4XFxVLKjzL7cT-amLAupGDqM7XAYgq4xcevaAiSxLrDht-sDm9k-J3IjoMLVDIGbT5g1GkOAV5nOwE6dxGTP9qvmGSyRtTTyONlyzoNgeuoEswbT376kFrubkXkiNJL2P6ojAUmDWilKPgPT10XKcnLgH2JtowRdlwfpQbYrTD1L1VoII3jrCRfh6yuXNY8CtELim6KKHYol9kT0Vq4NdFP7aKeRmBpGyYKdfgVR4ZjzgCP4pLFMdbs3nYEzWLzGZqFbSB40_bkzKlKFt-9bDZXGQReW8TVOSgVlwkxIVISDeqdNCqROqZMx4AmHP69NUsZPSia9nuo38m-SSSenWbPOhOhA3nXBRWEY93fxVveq4HX6ocy9HUcov6hyJyWEIJcLQiB-dod7WZHyw2qwdxjHHPj9b2uHkNAgOX4DDw1KRlc25g==","summary":[]},"output_index":4,"sequence_number":16} + +event: response.output_item.done +data: {"type":"response.output_item.done","item":{"id":"rs_0c5c51d167d5c241006ae44478c27c87d096983ffa03f96839","type":"reasoning","content":[],"encrypted_content":"gAAAAABq5ER5XbXvirOU8K-LrMRXifLEfETB97Eb5TQ4X1TJOy8ybISaB2CE5abhVDEnVotkMNCzZgk9AjyLEur2XwIJgih00R0uLv-PZJQNl7XOV33pt1BTcDU-uSBX-3XH6zh2am_AqLmHE8LLqV_b3aSd8pzeUE3IlqeTw7szShTP0vcUXB7j_q7Z_PMsG4MTWC4cPZortpu752FyttWmAB5ZDutuvyAfzp0PwV6v_ZK5dQjFQ9cTmttEQO9MrJdkmDB02g3r6cCKcKLCN0nqIy1bE2eAv3gaISJG2Tu7MSLy4xd5TrcIr1A_Cv81bM1l0mEIvF9VxkckicZGX8b0XwXIwV1EINQZupxg-1p_rq5y8nU3R8l87-HofqrB8W7KCaMPHRDbl258BbbwHQZ9Riwc_t2aL6vQI9KM0cqQCC-yrDksFSM-GMNlMKGIjXmK-1v7nN7oGNKw-FN05aphS2aTb-0QbrdVbJdk0-t4GOJQAdo_iVx0YYnI9FT9hIsNKdB7GPybUY8QcYQ6BqHEjfkQWptV4kVzMEYcx0pqhSYDFyMbZdjaybbUrUMb5q3Nja5AxeGnPHZvj-WMAGyKEFmfzrYFb0XoY3HSxNILw_ZrD3xWH4fRRUxSAUd1Uqa4HBpJmIIe3vQtjdWf0lGRVEjvSUCrfp3RV8jUas9LYBAFSO-VcTJAtc8pqHeITmAltd7y-5_OP3vBEp2cWH1NEdgZMm1MyGk7oTMvn-3z4j2gTIlRAT7wmWuZQXkLPktdm5FBr6AQilc5aAgLsYlaie4fGGeCDFze41zfvYelxprkCwh78dy948IZXJuL6AfHaAiTxkp_zeoovkt7nmKkNiZ2KVey0c5xL3fCRPsPfZxI-Xhx_jFoROzdFXnLxWT8ouCky-3GkeZZh2jKS9mIIX24ykudnadQmt9pDiESxtoX8VQGpA6ywbJJOSPTFiRiCMFtDhZibmlkmKuZcsyLXc-pfPlKcX6vLzed8Zf8JjKkE2ZX1V-70pC5KzX2sE-rUVTvft24JD3Wiori0Mg_kr_BCPohfqRtRD8BtPq8TFcAs5LPcix5o2fT8JivarqMUmmlxWRfUbbmI9OxaMJkJ_QRVVGE0qAo6SvEHNWjT3Lv6gZ3zSlWJHPlafIXI31orXKcUZ7udu8GBBNaEdNK0fgOROLRIFDEhEiGrdLwc28BuVGoHBz7np6JC0cDC-1lpTEkH2D4aVyczN_xhB-wgbaE_cwdnq0bPmH6RaszoQtMOPoYuTLymwxDbYKPd01xEgZVO8IB1_qPaP8Gt5T3tPMz6VUk6I8KbO_P_OCIrUtV3TBopdLTz0PTBrBskMN72sFk_3A1tOqHHzoyiqD9kK2b5oofi0IDEXCIk_OvsA2cxWjrQt-41GiD2o8kq7mhppyooTaOPaCslnd1g7VkgnrUexbTzulDhRgDJk_WWRUK3zW6EN-rT5JLiE3rZHO46hZYkpKqk5I_vavF_CTAhaPENBCEoOCALGekWXhho9PYG4CvMM8cE6mPJCiGCH84J61Kjl3UEiSQ4_LVkRL4DH0mSAg7tn2kgQw2pLlCiKn8b6RPImCrt04bddlNZOGkF2He8WCrNBilP0jFR_Ki3f2j0YcWLkfJDzJqEj2V9AkmeaGdxA9C0O9fHKj7VLmPOtQoMeVtOglSqLj6-Tndi5X9RTIjIrTwFie_b683u4vLdDWVagB2HcIiaT4MM8bwEIptqCvi9iorh6tqwqiQS9ur6zhP9HxofPI49uhxWVPfCj6N7xqKmTaajJxsUgoImoJH-X0lrZTzWEgtNDKovwOeD7QdnwhcV4KZO7MB1qSmESwfrKAsSfzlbtF80TO-swdxYoCdFBsoC9HOKx-aI9L3EmOf3ffXLe8XU4iJM9sgSG5cOH0jFzCI5WEUlwr1C3TXvZNBNungtL6z_d1rhCOxcLTWC051lblOUmdjB8HAEGp4FvSGES8f7xbMGS1M8FdrF88wRecKQt3gycSC2rHZkUGnabSDpsLcVmNqouMCZFmaa9Yii4gKdrd5JF8F8XQa2SzUBF0IH2VQX5ldHuaGy37cWADf49Zng3lbwIArEwtOsxngB6QqnYY1LMVYDHbIK6Pux6aNS3wSqvSTZdbQyf0o0oTLiyDg09QQfII7pBogHD9aUZUSiWsK4vbEngh5ZHxv3K4bqnCAZdNz5KdKG-cgKXJbshzOiQrA8CZ_3hpX4tN8z9EDFL9SdPEahjoL-sm_aBlvdIbtC1O8syClwmAB1ZKg9iMYNEUeLA8hdkdOuYVFloymDLP1_FJedXNaeN3vvYOlARALbRMCXxel_i0peDD_ixz7ZGLjWR9W5b1G2Y8pZgfbrlphIYTWySDJVBEvK4Irr40vCR3aQvH_XUV_Rm5Y2T2akHD91c-rRsfOjEJqy3fmv0qFXO1PHqxHikMbDoKHCD8s-7MY8petQVg0bH4PofwTwlXAJGL3ZVZoBNajjllNnZEs5UImcREsMqHyAErzcXBRuoWCGEx2RP-Q5SE19DU-r482hsOZYffWMKCKNLECVM19O93p4wYjDXt3RDQn6ZpD3brmjO2EHcYWTPpbt6OWa_CtwctQJ_6N7Xfw-nx1uAia6-rxMYSlU1CT","summary":[]},"output_index":4,"sequence_number":17} + +event: response.output_item.added +data: {"type":"response.output_item.added","item":{"id":"ws_0c5c51d167d5c241006ae44479b09887d0a910302a1dbd053c","type":"web_search_call","status":"in_progress"},"output_index":5,"sequence_number":18} + +event: response.web_search_call.in_progress +data: {"type":"response.web_search_call.in_progress","item_id":"ws_0c5c51d167d5c241006ae44479b09887d0a910302a1dbd053c","output_index":5,"sequence_number":19} + +event: response.web_search_call.searching +data: {"type":"response.web_search_call.searching","item_id":"ws_0c5c51d167d5c241006ae44479b09887d0a910302a1dbd053c","output_index":5,"sequence_number":20} + +event: response.web_search_call.completed +data: {"type":"response.web_search_call.completed","item_id":"ws_0c5c51d167d5c241006ae44479b09887d0a910302a1dbd053c","output_index":5,"sequence_number":21} + +event: response.output_item.done +data: {"type":"response.output_item.done","item":{"id":"ws_0c5c51d167d5c241006ae44479b09887d0a910302a1dbd053c","type":"web_search_call","status":"completed","action":{"type":"open_page","url":"https://www.theguardian.com/world/2026/oct/30/all"}},"output_index":5,"sequence_number":22} + +event: response.output_item.added +data: {"type":"response.output_item.added","item":{"id":"rs_0c5c51d167d5c241006ae4447a8f0c87d08065b4dfb049bd12","type":"reasoning","content":[],"encrypted_content":"gAAAAABq5ER6WMhQekPp64mtZMvtAhyB_1jWbb-W0izaxVQpfDKJX4O4N4IO6IGxpaFy4AnTWCj8LGQzA11eIFrd6mSiWPmPIihW95SRHqdupQ_j87pOC6eveIIYYfsPRFWRvbZPpmzc0G3SviXsMqDacjxgN3UPmc63lmyGCde11qiHlRhrfQfxITJ4iWrs7OrFw6Lc8qc1my1opsGVUKaLDxFglb3m4uKxpwp-FykMDkoVKbIY2koG69UmNBXEB5AtBvq-btB4-cQCCFde7FQUKKWccIJlphCgWJ_1HIYADppYNDGv5YNJWOu5gc0HygGAXP-D8Mt-BjrceuZj5ZYR-mGvYitQl6iKEPcutbAkfLBlGacYAEPzt7mDoQOVBNmt2lpiKGeb08ro0uXN-f8jnBHxGZ4QlHL25rVsBOQvm8ZxgCEyPPz1CekZoemuvq0e8S3j2OWa8-grh2VK9CzA7mpK0XOv0__NMDfwXemmrFJQk6PyfI7f48x40omemvMz_qB4x8r-XZnsBuEhqhbHHMJHN1hUq1q3uoHrlWIePV6LmRav2pnia26Vn9z_Tjl8sUkHfsjQUcVB7N0zy0qZagtDk8I86EuvJGtz781z6aUYs02Y0YEaQkdI3rS21ch2tGyCRfRMMLxE4vhb0ZJH0iYwyAexPTx_Nk1sMpnhszg65JQF8_a_zG1NpYBvIZyUO_KnuYrwGlfRTzTrhfZVAce116RL9kpaQyp_lQxZFyBz_8e-QAxrU3y35RaTYf_x-342FBKrhJeOtF6tKgmdR2ItDEWsKsghGbJL4Y7cdIuLyZJB9lNRSlZ6YPU6ZCvmnyk0kemhKCylAyOlucW9vkol_AZDAYTl1GQh7cnSHiqDvOmWN7MWQNkoUmXxyiw9aLw0Xk4EH9VroAtxa6hY5AlMhlnweM2eClB5-nylKPLpEsS5FZ2NAgQ56DnOiWoaTwU4-0o_cMx87KT9VImW2V2loR8LzGW1Xkwv899e09S6-MbsiApQrCv05E0-D5O3OiyxvR978NQjWDtxfXxcUMtWej7uKJwcYW6WohiPHMDpdNQReJKe3ptIRBVhKUfSSVYbpKvuNzq7HMF8g2EJQf_EfBGn-EbbJl78CsUEZZNWrOKg7b1fov5EYZ2JdEVYIPoK3mKnJAKi5DIYGfSnHs9gOKpbQgEA04CT9rsCrt5V4-m-5WVMqoI875fF81UD7KB0JnSfdjVrfqgp_D281gy8G_16Jg==","summary":[]},"output_index":6,"sequence_number":23} + +event: response.output_item.done +data: {"type":"response.output_item.done","item":{"id":"rs_0c5c51d167d5c241006ae4447a8f0c87d08065b4dfb049bd12","type":"reasoning","content":[],"encrypted_content":"gAAAAABq5ER-nQ6jDbPhZ4FjZ4RYVlY-pEdu1xhvd-HeuvltgvS2O6KAmw5AzWmVPn09BxCAzSRWYLT18WRYx-rrcIMZkzuSJiPwNW97WusssyniZBi_41fdpzKW-5dRzOovVkpDMQLXGljivknRHsmh-zT3OqjUHUFmpJKzFlbTclfGZLBkZfmJEVvVzUsOSa0TAt-7AKEg0K1Kv0WnY8U3KUQamdewJ2TPV5KGmg2NkFrVrjhxoiKlEtmQr6hi-UeevpJZmS-_s-3qYgsGiKV9JlnPq3THZtUxah4i8wLX7-ltBqpozl9DW2UiTZbmzI3TPcMTu1iTD0S3K3WDKgqnQrz3nAyG74MLa4M7Vy4ybvB4VYPL-oUDPBSJfDnTIAdHhkX464h38ZpaVb5dpMsW1eaiCybX2Fcc5qRb1tws-LkF_fE5Zo6-m1CRCo1D2E-Oag4J7v1oD2DN8rGRgoFaCOglPVXHnghR9-SdTCbW4D8fEiqrtY8k6zyLX_iOCOs9Z20-wiyBUX3fqZIGrQWOBZgOzjpSsYkLst8ab7B7yQQhYAH7vfxDx0_ErcdnYZuTkjh8pVW1vWXI75vPmKp4aoVy_2Ado5K2W4gf526TAqkWUkn4IjLy9QwUxa92OgXmQW_vPyzQYcFC-phgmpNjzY8SEO17KF0CePb36BaSkps2KmEvyD8YluD-9Hksl3zpgk_a4AaXHvRc7E5ZdO4ZOUlbSnZ7E6IR5xY4vxKDobxTdLzPFqtrGuuwNhSMT2-OVyxXjCyUZhXMKPjhuuwkfJIRNX-wFLUkzZ0Fti9DUNBd0uMTHKhbDMgB_GToQ-TTll0LOm-sZdxQyTTK3t_WtIKlQe6qnvuDo7itocMcD-yOGdJ1VEa4L6GRVuQP1GuJp6XCuPRXvpFakjgyQm0vU9xGqMEdLKNxHM_2L2KSoPpUH1Y6w86XKtbSc8j3G6XBMsMaRxasyad7O6VrCQqM0QB1hcXmLOBGXIsJhw8sU4jLDsPhehjS3UGgSiGhO6wTYB-lPHOjf5S7savl7vopexu5QiKiU0PA3hC1ZkKCYE3uD29-NcrUPmxECJR5LVtY0DspumVJWecpDkW65LApocAgJyXX3014rSiL1tYkrtwkATJ9CuWJ-9WrIzITXWPiGInCgP-RIvV-jgEfeI88zlseW4AmiJKlR0DZrtR1nA8PEYuhXllIQo-4JmzmYR0LdvPSxvENCvvIJWH--y-wj4Vltib-BoPYUfa47idkBybDWRJs3P8slcbTM2ik5iVXDyFf4xL1WyYpYOrvh7mAW8HwaTjreHOdORUo_gF_h26K9KwQFNDWJJfbUt-OOjAhw5LZvAwnqtA9SMKPuhfrSo-9xfISHt_fWiGnocTJHzmtnk5_Fnjam3BNH9IvAQyCIeWk63eR4F6oINlwDCnMLtlNkr3Vf-HvNlCag_kse5yK98mPFlWhQ-0eVSteS0CGyw0yPDCUoruYgu50RSwaNMjM8ceRbXDwjV7IiYb7h8-3b3fCTQfR-57S7_7iYk7rI9TRC0-QjyMyHXTgblhmtFkWjEHkS3TDeoP_bz4NUV9yMzZX4ylKm-HUQctd6G39LM_-B-I4Gx-jwdI08qIU3mLyfz9wtxH89dpRsbL2Z3qDwrB0eE6GuLtHZEYZKkchXiHSs_KfproEGMFc26BJrtVKmodprf-e__CSrr7H_5tHNw_0vuAnAFUjH63vbF34V6oeVLjRjzM7JZvNtt8mFMTF_wOJHHfiZps9QbdGPx_YrtbFDrABo8mT-ewExEIxKio5xN-mW2XyJjOhuHTPFGj7jXVhEfUsGoe8XbFhlUPV9rX9kVL8nIJLsT2irkWpRI5vx8q4sZHNe0LKdRTPdXOvaCkr2UspjwZnj79IINa1mdiLnRZVCayVgEBhd51xuRohNl_8RMgz6LKhIWM84nfrF--ABZllQHWHu3TcrkU50iht-jv-T8pbiWpTvspgRTlMizyMz-X1_YWS7SH4lJs2lx1CG_Nh16vyhzaTXMG8ZgOFX8gceIGtfg_7l-wqwwNWzeyRtmBi2Fuy1RS-sT98SLiWkLWI26qlhzgtUdvD57WFyjd80Gy6aH3APRxtK_i6k8ChS6BvUSu9ouR88ux1I-oto12K3YSkrXN4avt65roSZJUaSJftlRx31bxD09Gv4o26rB-912cnycu3wG9Ivs_1gOv3M9Lyzw5JjEMUWgwHNXOHaWu07XCRSp4jbxGKzelc-eFUPUEQHvbuHANYeptE3fSgAHmwUjhEFK5z2HgLpvPRwLFmWgjApylUiNX39m_CMmBfMeosjm6fn2f7r5Oy3o8pVhZ30PgBKu-bzf7ReGmMkKlW8Mjj9bGggYycqm-s4mrMstZD-6ZGh0C9JCgboog6dqLRrGJJayvqVSV--bG2y-kvgL5TSh9MdLG8blVKlSnuHBL73lZ7bmELfEdMcO4jx9CeUYOhDWeKeh-dWH_HhofCZRZnLugMo8KNrHfHLCGUCbYibLICNJmsOhzeTKfFBjqrkzKWbs8ZaaOvHg8u_gpxp2sIGetmyP4izOlmzu0MILnMfQ87fyE28pp_G2su8B6nxPNTWpdBZM1sGhVLBcG1VCJEujFjCJmYPNSuGe-MTf6phhlUl5ICqM63ELJouSjRIVxHCDCquS3JkDow1cHWMHlSBSpCGpGEEDdbsdv8AN95JMpASo3A23RgeIUF-57nCCQXzxlH7pjKpCc7NLIO22xQs5qjXHCfqd69311E5aqmYCsOcikM65qf0XpU3LLwZGasHmHWGREKc9ihWU0UJe_m7TdUn7uczsJQ3pWfRBBiy_HYQWHlVUydzinW95unCi6PinOg0QH8DLH6Q6m_Y2b52GF4QJG9kJ0nm5hYV2JZUjOGAtHnz-fS6or1k5cAvEXn4hDQRDTQov1WhAcmm7L9LbiTdUimbxlS2KQoRF2-YgNdJF2V_tTS580NtG8L_OWaEGfLkpfqwFGLzczAtYCV2QXK98fcL_0SRmo4ZL9ks8KBn6OjZEfXPfVLC9AhTY0FHs_yzT3mDEbQE_9iOiAOQuSi1a7dCguseYav0lmdCF5BD5sF0IG16qK8NddBZcZI6qd1_aPCKqUw0FNQWeHHQzYSH6m9l36QYXb_uInQrPCECMhj7WNHSiAq1xn-HhdpkWMxoH_4WUZa_zd0Un3P9STPiHruKlgP3ei0FgWSycDcsuLyNshy6IbmObA3eR3hupjF_LX8x8UWHS1Nmh3e3MKbJgCM3br23cvoNFd5jxFISufhwBI7STD-wz_CgGP-A0o4y_nTebHZdsdtbk9KYs0gBVfwP_hrp4vTkH_4GAa2DEaxZC8eWx_he4BPZR9nuYMRgua3_Z9nUTkP3nZg1GkfgEtsn8bdDwZNAM_bZz2klCmybIM9gqHS62W3LWM6TwKdNwqaqywlPJu68Ve6aPtTxJrEVvTcDCNxD8YzdjG7c5rcymO9Z0Q83PBf-uzLWKIirG6npZuLUcWWXrhYI8k-cshe_rfKnoXBzPDy_USzGZH7-13H22tltkeopieQ3hIifjsQbudCE8zyNs81UTLKUHbO-jre4sOpLG-TbRB6pVjhONJUANsDGUf1JlCRXBxBQltvlfetr133yGie_FliKopfMUpaDxJxfN7RVu-lBeoVkvnnsaveb0frcs40XQoT-mlpttRNCUbllzIxt2pazGMXVNiNLx10R1vIFZnM48rF_xF0eLFaLucTmnlOFYWJ6fwy5KPBV7xkc3zd_PPSYBLAVsbJfcKbr3KkM_twEogPbNCQ2N8H5O4I_d9tu51vmQeADdHmRj7ZvB1wzKN2ULeOkVINFtcujFqYw-BiMv2sZvp6mZjluP4xOmqKxEb-IIAehIgrGu8i-m5-iKc3slEOWP7f_icy5mKcErkviJr2J-0zQZIx1sqQyKhEyTR0RUBXRSZmsRzSmq-5sqZ6MBhv64zpktFYqYixuXai1w0qQwYUaMnPbylLUwDZZ-qsPnmkBH3VQBd6DSDm-tSmQQRoKGciS5qdP0E_9sxjjm2gznKKGl0lAPbhCtT7NDSzNGA3hNIEPy1SXHzTggWE97ba43qWMPCDWWZxSHilfnWUCmdXr6bOqdiUhqhgKjIreVYuzG47jfhcMw3aRNAayjemteF6l-aVCdtkps2FpayN1s7C4JM7A0jzkcNy1P4mKmc-ZlXCeLHJEXGFp-OZO7XuuRRRjbZ6eerO4hYWG59RnMNY1n2x51fsDH1TgXRmcyEmwps2C8KqZxSVZItEmHm8643yOmhh2_KIF4ntVCGc1_N8yupyGsK5r6Oxonxqf2fTYyaS5WC3EK26_e6MaUXoawKxnQP_IRuvM3lu8MPoftVx_rOTSsHziCwTAOLcATN9OBqeOFD-Yqx31A9-QLlLLJEj_KtFEANseK51Ll4JLbzzlPHAkw4Q716M35zDoMnYrrSxf0wy8aj7LNkzqzYAM46ocJP6JWAvJvpjNK_vhbInq01MhELvJL3h5KvJr5SCrVSHdm5o8DsSa55AtldcB_XMZxCRrmhwnZvmoVNzM4HugbU0OifZXTxX1EMwSTTzqXO3cts9iFx3AAY3Pr25yd5pFpy2p6xyjFRj0vViHiAB34LMoIOY5qxEIDMEe5GdvHjhQZGBnjrINAzhoKoAlTOlm_uIzGpAc2WHnEnBahiesVVDQj1BRwxcE0Fn6PtOMm9Wu9dV8hACWWmWITHsJ9syjFwEwubrTUwDbBvbAAKQAgQget1HrkgKGQJK-e8jgBKJr8ttSZBus2hBbJunZ5NWOY9ufPrlQri0NxaXSbOyClO1uYkR6Uig2LQ3TJcBsqVlolJC1zZFN45j0ktyz2CXh7R4nLFHGhCRHY9kue2wWppwW1--pZ5BWMeS43ifkoC-zgFkXngPu5YjCw5pzuKFNMIOq-GboHuFoKcFybwlbYrdSfTPMOIF3cBNGqW_0VRuzi72Np4H8RYWc37zqxhCYWKdbbLAiAywC-MU3Dl4WPH0d9MoxI9MxMgOVVL6ktjl1D6d8s3u_pJywcaOYi6f8tGL1tGn_NyGyr05DUPmngJWW4xA5ujKE-C4RgCJ1Kj1-HYOMcrhTX1gcBwHoQIS20RSpRNnH18_xDyK4kA0lhOMENXeSwPsoytKpz4hdFouh8w5ntXNwEF7tVqECN7o6E9BtFflCzzWG_nOmQREbV-ZYNeBOkZ1Z-xeZZ7VBA6X09-cQneZzcD1RJ1ugvrtc68Md9bXIACGAxcEvnWUZ_03moW-d9CusXsjM4trjCuJArCA5XFE3B9g2wgglV3zGJRqAjCC-iC_ugWMSo5YvrEvDG5M_tz0XGYElXBBZFi0pxPhrzpJBpa8lTiLF7_zcSA5qLBZw7XOZjA_FUnCk9ckQrp6XqD0YPj_psQuA81AKMc771YT3LHShpYR7JRzHxPX4yViPeizli7kd2rX8eqUEZedllfi0Mm5uDrpjvH3dzRz8GVLkUUyMkFBGO2rQe74sQlyWuC-N1_c3sc-HVsQdeybPj62K82F22xkXeFujHfNwRN0srSQyt2inW5WqrC_mS3oWIj348JNuZ4Bkyr2HDIRP3hWcNuQCo27Nuxq46lqufxzelmMF0wVOGLfGq7KCYNbtLTeZn0l1-LUHjzbFalflDT4C-4dfGNyfIClUq0OhunIfVAcm9tmw0RzZyNGRM20ySc0Zl6U3sBmz5ncZ2KadG-xdfc1xqCBz6ayFWV_BHyV1BE-kLkBKs7nZcupaiVtmsG79jb5RYF_gGCUa2dxllbf3y_1mtbPY5A1tAjBKrvRb-xx2McRm5w_eQz2SgL9q4NWcsB4xNNW5fmuNqwqZ4v-gYRiKO9e035TYGgZl525QtTAfQQTX-UjrjRLaHqrUEii_UL1MuhceXXalw3hPKgCjgmkVEnTaOIvvbt4dZn1h5wupLxanDhP-jH0jQgGCpoygjyxj9_gHUarCjpNm_XM2nA6bVbi4N89yBzvPA7iuijWq3Xxiga4Pd2EB4wHRDu2yI5HccwT6L2j9UYgck9PdeCfMSy6HAl2VZpo1OKcCjG0b80N0y2LkUF_0AYxjc-Z2BuIJtV5i5Ie2oBo6KJ-X-ZuwxdjKd6Td_c66nj1OiVHn7xg5Eh8SUPpBDVzZ0irwoqM2_6fh9Aaku6qSnaIM6rqxkbRFB_OPpU-nZjXmrbr_ytZ9QGyWe8CW77Zzo0JNWCNqiYZZ604WX_4x-UV1UtsuZt6pZDnTshkxnloyGNGDAGTavXJ9r-5a5ZvggR8ryVp5oG-VTerWikQdXSqLo5g4hFE0-DVRj7uVGh1yUt6fXjjxN50Lpbw_q71jfT3NNM8PtAM-2zsc61cG874RitUnPxMcN-m35ikn2kDKa8CjEKxRf2vpTJlmhZ91d9eX8M_YM5wMbCrMMBBXN7lPpGL6YVoIG_npo152Q0LD2iw87qATSVMYiYh0HVRJhMTYLz5aBmCFXukwqDsZgphqFmC2l0Io43biA0ntZ8cA1iyjsQyMGiILd1NDb_3d9D0oTzhJihjNRRWzwIx_6I0iXTGy71OTvQ52lEuR6DfqtbDZLAr0e-1IjpQ315Z1dBMCHzdVurLC2QzGEgR7Qlkx0QxJUJf-PM-opE-HHOHGhJopKg24kl-olLDlSnnJZKixoMalFcQe7Cpfkx_Bh2XaUnq0FQXVmMv1D1IMdpganrL4vsr_REA8QAWeZ7UHl17LmKEypq-1uMyYl0JP1iicRDJi5rg10mZ5onmOhPvwjmXv6_8oHF_7IE5yWjVwwIdFeobRoxwP8a3DaAP0DBmY0ZrExpnsThS5ndawWeqj0F7xdqacVmyJa9-ZtdQaMoYQ4DuiW6I0LCrHAmRLUHXwvnR1sQVvODfVP-2-8YmdUE-ZuaDU_8dIMEkJs49r-a9VfPkZt2aVQvBrF0LDIfdQBlDd2UuJwzkWLD4ZHTC7fIMykSBY6dybf8fzPDPW9ZzhIvAOPhEY324tZa28G8Pm2CjgXvKDf0OLSAg2kNvp0Vt6u1mv83J4ynFJjk4b953U3rgE_x2hLKDpoFiijooL7W1x3if0DTnDMy0V7f-ytbqIacQ6fXi9hAQlDDaWr5xCf4ZCTAeV3AlqBRBdV-CFUk0aiwKLtTh5Zu01xQHrUPwze6NvPN_4cUbQBP9joH_xnR8cjYpDMBfSypw8qEqBxBldChg5ijlNwcQAAey2jkOpcCFqqULM205KIr1D_I4HRiI5v836w==","summary":[]},"output_index":6,"sequence_number":24} + +event: response.output_item.added +data: {"type":"response.output_item.added","item":{"id":"msg_0c5c51d167d5c241006ae4447eeb5087d084518a07d29b20e4","type":"message","status":"in_progress","content":[],"role":"assistant"},"output_index":7,"sequence_number":25} + +event: response.content_part.added +data: {"type":"response.content_part.added","content_index":0,"item_id":"msg_0c5c51d167d5c241006ae4447eeb5087d084518a07d29b20e4","output_index":7,"part":{"type":"output_text","annotations":[],"logprobs":[],"text":""},"sequence_number":26} + +event: response.output_text.delta +data: {"type":"response.output_text.delta","content_index":0,"delta":"Today is October 30, 202","item_id":"msg_0c5c51d167d5c241006ae4447eeb5087d084518a07d29b20e4","logprobs":[],"obfuscation":"Pb4UdIbj","output_index":7,"sequence_number":27} + +event: response.output_text.delta +data: {"type":"response.output_text.delta","content_index":0,"delta":"6. A prominent top","item_id":"msg_0c5c51d167d5c241006ae4447eeb5087d084518a07d29b20e4","logprobs":[],"obfuscation":"q8duOvH9qW0LEJ","output_index":7,"sequence_number":28} + +event: response.output_text.delta +data: {"type":"response.output_text.delta","content_index":0,"delta":" headline (The Guardian) is: \"","item_id":"msg_0c5c51d167d5c241006ae4447eeb5087d084518a07d29b20e4","logprobs":[],"obfuscation":"EH","output_index":7,"sequence_number":29} + +event: response.output_text.delta +data: {"type":"response.output_text.delta","content_index":0,"delta":"Friday briefing: Israel has a dilemma","item_id":"msg_0c5c51d167d5c241006ae4447eeb5087d084518a07d29b20e4","logprobs":[],"obfuscation":"6w2btD0Mrwf","output_index":7,"sequence_number":30} + +event: response.output_text.delta +data: {"type":"response.output_text.delta","content_index":0,"delta":" - can its opposition govern with Palestinian","item_id":"msg_0c5c51d167d5c241006ae4447eeb5087d084518a07d29b20e4","logprobs":[],"obfuscation":"oFD","output_index":7,"sequence_number":31} + +event: response.output_text.delta +data: {"type":"response.output_text.delta","content_index":0,"delta":" parties?\" ","item_id":"msg_0c5c51d167d5c241006ae4447eeb5087d084518a07d29b20e4","logprobs":[],"obfuscation":"gc1IU","output_index":7,"sequence_number":32} + +event: response.output_text.delta +data: {"type":"response.output_text.delta","content_index":0,"delta":"([theguardian.com](https://www.theguardian.com/world/2026/oct/30/all))\n\nWould you like the","item_id":"msg_0c5c51d167d5c241006ae4447eeb5087d084518a07d29b20e4","logprobs":[],"obfuscation":"yIEFgk","output_index":7,"sequence_number":33} + +event: response.output_text.annotation.added +data: {"type":"response.output_text.annotation.added","annotation":{"type":"url_citation","end_index":235,"start_index":165,"title":"World news | World | The Guardian","url":"https://www.theguardian.com/world/2026/oct/30/all"},"annotation_index":0,"content_index":0,"item_id":"msg_0c5c51d167d5c241006ae4447eeb5087d084518a07d29b20e4","output_index":7,"sequence_number":34} + +event: response.output_text.delta +data: {"type":"response.output_text.delta","content_index":0,"delta":" top headline from a different outlet (Reuters","item_id":"msg_0c5c51d167d5c241006ae4447eeb5087d084518a07d29b20e4","logprobs":[],"obfuscation":"u8","output_index":7,"sequence_number":35} + +event: response.output_text.delta +data: {"type":"response.output_text.delta","content_index":0,"delta":", AP, NYT,","item_id":"msg_0c5c51d167d5c241006ae4447eeb5087d084518a07d29b20e4","logprobs":[],"obfuscation":"w9imGS","output_index":7,"sequence_number":36} + +event: response.output_text.delta +data: {"type":"response.output_text.delta","content_index":0,"delta":" Washington Post)?","item_id":"msg_0c5c51d167d5c241006ae4447eeb5087d084518a07d29b20e4","logprobs":[],"obfuscation":"Yoi8Aaab4Imjh8","output_index":7,"sequence_number":37} + +event: response.output_text.done +data: {"type":"response.output_text.done","content_index":0,"item_id":"msg_0c5c51d167d5c241006ae4447eeb5087d084518a07d29b20e4","logprobs":[],"output_index":7,"sequence_number":38,"text":"Today is October 30, 2026. A prominent top headline (The Guardian) is: \"Friday briefing: Israel has a dilemma - can its opposition govern with Palestinian parties?\" ([theguardian.com](https://www.theguardian.com/world/2026/oct/30/all))\n\nWould you like the top headline from a different outlet (Reuters, AP, NYT, Washington Post)?"} + +event: response.content_part.done +data: {"type":"response.content_part.done","content_index":0,"item_id":"msg_0c5c51d167d5c241006ae4447eeb5087d084518a07d29b20e4","output_index":7,"part":{"type":"output_text","annotations":[{"type":"url_citation","end_index":235,"start_index":165,"title":"World news | World | The Guardian","url":"https://www.theguardian.com/world/2026/oct/30/all"}],"logprobs":[],"text":"Today is October 30, 2026. A prominent top headline (The Guardian) is: \"Friday briefing: Israel has a dilemma - can its opposition govern with Palestinian parties?\" ([theguardian.com](https://www.theguardian.com/world/2026/oct/30/all))\n\nWould you like the top headline from a different outlet (Reuters, AP, NYT, Washington Post)?"},"sequence_number":39} + +event: response.output_item.done +data: {"type":"response.output_item.done","item":{"id":"msg_0c5c51d167d5c241006ae4447eeb5087d084518a07d29b20e4","type":"message","status":"completed","content":[{"type":"output_text","annotations":[{"type":"url_citation","end_index":235,"start_index":165,"title":"World news | World | The Guardian","url":"https://www.theguardian.com/world/2026/oct/30/all"}],"logprobs":[],"text":"Today is October 30, 2026. A prominent top headline (The Guardian) is: \"Friday briefing: Israel has a dilemma - can its opposition govern with Palestinian parties?\" ([theguardian.com](https://www.theguardian.com/world/2026/oct/30/all))\n\nWould you like the top headline from a different outlet (Reuters, AP, NYT, Washington Post)?"}],"role":"assistant"},"output_index":7,"sequence_number":40} + +event: response.completed +data: {"type":"response.completed","response":{"id":"resp_0c5c51d167d5c241006ae4446f0f1887d0a76d388a78eeff0e","object":"response","created_at":1793344623,"status":"completed","access_programs":null,"background":false,"completed_at":1793344639,"error":null,"frequency_penalty":0.0,"incomplete_details":null,"instructions":null,"max_output_tokens":null,"max_tool_calls":null,"model":"gpt-5-mini-2025-08-07","moderation":null,"output":[{"id":"rs_0c5c51d167d5c241006ae44470251887d08301a5267be92ecd","type":"reasoning","content":[],"encrypted_content":"gAAAAABq5ER_rfJhYxOLPK2OHmD1_deXwVXy567946be4Uje8YmqJUpVgufVsgt9YFItiAio8bpVFlU4UTBjOclp_yvgPrmvDl7Sv8F3LQu7ssU7vgyluv0UD7BJCKf7el3a0QAo6CL5DfXJ1mXiq-5T3n63cyXwRJM4bNDst--xke8rIN7cFbftD0scobc3E3ijbS08KLMuLxstJ13X3yB3HnIBZcE-7usEkdF8xo-nG1z1wG2N3uYHlk1Yr5ix9bJq7B4Z_xuZobp4P2o7bfE0qiL7hrehyat5SSY7M_dCvdbH2TvACzdtHPZVqlfjkM0humwv5sEcySZPROicbKSKTdMGeznvS1gm48cPabFmBpdo7jefjFO_8SpvknV_NORj9k9VAJRePQud7HZRBgNDxaLm-9aCpqSs2E_FZQhqXWenv1J0CCKIXAT-AFEpbhk65bc0he8a8wPe8VEIKEQOb4jHI2Aeh_4piJ4ffSPSRfHR2uhNbxgOjIK7zKzgukAgCAG6b7eQ3N0aL0NcWUIu8GaJXcelnESYy42RHuyMGx3kSDYBl2BVFzwyikUk1g1VRpUqRwgiOU-piQ9MWgOENGSOX_o3x3b0KEMvgHu0SzhQDXBkQ1RSC7RzFRPir99hudoZt92YD6FbX0kP6PSwCEBtlSUN2ANVUkHyIHfCSY7_L4Oq3WLG5oBCecuujE9JKzr6hUElVzFmYF2KkybxYlr5KEYKN5xp5Bqei5CUSBzh5B5TMnBhVjcXFhlszDbmgrxmqE1JnYa53TujhZCw6YSChfsntdqQ1tQG50DCvZnKh8MGA0jdpBugRKm4PcG43rGJ4jJeiMMLURlwFxXw-DMa7N-iZv2OYJuG7xVDZNVuJMGGKoMkvcRGByTFExbPw60hu0FMnV_VJDunE39tOzMhasIRE7a4Tns1aMEVMvqkWtYJ92_TeBk38kbXL2G3-VnssnJLR23Ytsu4KV3VBle713LA2slQUCU9yWusLIe8ogyf35s6YUlOanSBUeODZ9gNf8-wncp1fVM5hiZBK7Axh8OcqinvJTnpT6hAc-ktaPsJH5gH45fGJelq1kSKFzPhFgLlMcSg6RO7SC653ZWOXXWn3NYSF828mnYduVyjO38Lvx9DIdGIR8yD261p4Ea2QL8ei5JmA68GqgSqsQHXFw4t9a-9XTD-9M6Lb3d7Nd8BIXaHjrDPHjEo1OlaodnihOb0W31O23IdELoEsOLkmNBmUOE3veghzXIxlxgu-_rRA5rkwn7uQK6SPvNdRUWcRzKTNMsfFVSZfPU3jaFhHnFWoR-RdtS_cAi7zJwhtuLDjwfAEKPJmRfl9fSFvRAjgEAJYZa3lmNs4SmzsbjMFYba-kCT5X7VLIMxGSSF0uEhNBXhKcJNs90Sljgf8pAFmKTBB6UzZIJ_gYPgcHNTFbWA7kanQBnS4SSPx8BcxKRQ0PGtKE6goeunp89HlcHJzPHXn1nWSEcexIgJ0nD8JuhRoMjaCLyP-B8Ioqu4BD408UsMnmRmIGaHgQE86Sdr19FNk99QjRJvGdwpbb8ajRdWjMo5jvOSTJpnG_UjIzFoL4PFkDp9uDdbyvV7-KIwwDOpWcCgkmC89-dEIm8FoesNI2mCO1wJ32v9I_R3Q4_6byfxGQfj1mP-jONGBN6vRRK85Jyc3nHQ6z0_bLLlc4GFnIGxgpYubqkAPDLfC-9sA7ITt1UYExddHiRvBN2MJL1j5K4EHNDm6a6YsFKKAtGgBgGLN7gRZzq_KcW-9dMkL0Z6hlXk70qOoVNXo5byiNfb3BNZMfrcjxWmKf2F-YLI8mjywdXrwZMYR7PEgehuF9qaImob7wtN-siJF9w_bCO41vtf7Z4wm0E6-QIcNAObPES_KMlNyjvnchkBDRVAjkOm26O1PVLIGGdkUDWAo0PvxD_FAnnBqqwuw01_3etRynwW1LCUhsyFMJwXGOTug6E062kdWLjh5Bi_hwg1kabZZC_G46Po7vWITaMu-WzXUDhQMUeZ3EiFu4v54gZDYUhL-vz4257hSzybrVEaLxkbFW17ZSi8KL46yTepD79Opexn4njLHQZNNiqtqhMA5mzx8z7hcV1DytIMn82mW7dzmyBPG67MPLhfLnGQBb-GE7XYZBEAlos5_DO-Rq7WFdbLFh5OZ3Na5G7Ox3s6OhCcI0Pm5vufpIGK24YPx6Kf8KC2tUqEc-7osWMvEmjo38cFP8b2PbHB1nn1bdviO05jb5sygcWWCwS38Zbwsn5HjqJvuwZRMAsXvl9pMi59lqVJMy5qtGCz0LTNVT1sAp9gbpWiY7exMipeUb1lpMyMCFa-l-a_4ZRpp6aB9U_41bt4foNXjB_8rIDS39FwIb__v_Msw2Z-SAY9XzZml5LZ3rbgB8Fre5SWvQkWSGHsdCqL5hbr-20ZbxASj0rbccWCrhW4oBfb5ezSiuPy_3al1zRxwU9fuvy2J83icwL5tUkE991GbP6M9etqPC4VrzzvAvlbd2xGDFrTNqML6n9fQz7HqzqbDylextOdfOXnH2MyavMzx9j9iDaNMOo3bekMy3S6SIdL5_nTmfHQxNVTAjVFC7ub0me8FQKrP8agpH_xT0e-W_fh3SL8HDLRqnsuSZFfpyO5aBcyWplpfNYKTIVe9Sc6fN0F65NZXovoCMimN8yE7vP1B6QZHp9d_JUzUnxzp2uPHcCf26a6UkcUuUnd6Wy1lSDMYwyFhVExJoUE-MAdRJKSiBGasAzrKI8Nebj9BcADENPLhK3bcax5So837nNjbPkQ048VngloKnRLbcrltg-SjVCErlOX82Svhomke0iZe5XlV9VFb3TffZoGbFEr2txi8ihqVtiPWEmnnyGzkqSWhXnw3pKtZaj1getFRfhxQCCIDO1Brsp5OdyF8wOfZitvOjFrUJE7bECO_EJen2Sst8hRjZgN0jZqSZKOzKejpHZ6JDk2QG1a5i09ubeadYTCLSb5S_P6Osk_Kg2Ed_Lfzr7CtQLFVtbIIefo7224Htz-IKJGDq5V9FvtpG0aZ54MUiJ4BpmjvU_FazXC6E0epPzPBnk9e3G2igHNT4ElHcf3uCQT6SOer-__SqiUdlgntvhUMs7vYyM0TeU9W_6jhLnJCwsg4w8OzejmxQQ4b1AWqTbBN-k39ezrMnRyKFN9X7IKif7RK6t21QbJsMUBCmFhOFhyuu29Cw2lr9MJPKqkMeY5DRYcj2D2Rhc6Jckps2DXnLtyn4wM88EXu0Qfj5kYULptpL7IpbmmrPCA9rOMkIAkZuv55GyyEJfpnGMo7xN-lUEBTZ7a-12JqJRb42XdapaxigkbTFK67nBX9HyGtWCJnt6q8p5mzOiWWG5bTjA-8SRLCssOl2bvMGfseRiNGa835VrCjcOSflsQBjnGvHhxLbQFryGXb_8Y9cmelSKb2QDWercnmiWQ2TcWA1306Pyszvv-vfngJnFfBSnlifdLB8pD62-_BGkoGj0I7m_aItn9OCCskBeasergNgdhmQdPH4am05O_kbFKhf1HvnJAIPi4Ami1Sn-y7vLwxAAqDlFotbha4knFckNLFNg1N-Wy6Khl9xRnBDIA5dtfCHqfLALRwYUbkr0Crn4BNCprWmwyj27De7ffnVDRriyV_lrrDf-9KPhvIvIb05pbwSad_iamUoGB4Hz9N2yfewmSpxAVOgxDv_HGJTYB0cpaPgx-HAtKzpag9IYIqodgsxbxr-cIF40feahh2uypoyBJEsr4iFxMMnjwoZrWsk-Ro-fRQuSeRyvS8ljUt_zmlNYtw8SzH_2MOEY_S3bwZvK4mGZ3BN10OgQ-nShoMajh2u5D6EjVpPxratXAg9Idv1Q0XHlsYyB2eOx_Zcm5Ae8drNwFGQQA0IO95g_7shzNoOYuwoshaR8tN9X0u6BTWv_7xsRviL6B1V7dymTNVvDpNyXIF1C_hh0MXfpElqWfchKsRPSQbFEFL0OJcFgDrfbfAU4oTrUaQGsXjGAILIVTvNv1E6bFR8IEFhiIecYhqylyegEZ34E4pHMFdoqBZfkL4aCKcrGY3t5kj6JFszJ1djASJclQ66YP9gNrMd0r4UDdi83MA8UAwgB5JjecVkufv7d3f3-4t0M5Q-DQPZUKWNtXQRx-A4J5bMDPsk48pfBWy-jU-pCjxd3BDf5v3kAYoLMlN6CozR3703SFmkpY3MvVPCOvQM3QS37p9MDiWB4yNCKsRG3n7xO_dVnKJcAGFOEuzGi58NZzguKA5wCpgGvbEwGGEEIKlCGQhm-wcXTX27adno57xp1IWHQ4VR4BGj9Oeq31xn9aDROG3zesi1Ccuub8t1G1ckGxz_YfTdR8vBMhvOEKtkBvGCL63T-1IMggcuto4A1nSnx4ZNUPlP0BCx03FvXBMWcAcZ-ud3XUXlcwWLrddqNwwt1nSrDPd-fFdrEG4QLYpDgDlxsKXldufB0LmYCvGFaPVOQ0owsb7bkSra77F_cNFVqTFAZT4GvGN-cT98DEd09A_xrucm7hkr8CnUlUDQAdIKNgQdr6AslFoQp_ZvkdKQO8dwKJjdriQY4yDJEQtlyV72pcOqtTNN1ewG6BqH1brR46omTTt0qvHA7NHDbvcadOzkY2cm2NncxVgQ3gqXubdG9_a9m_h6cI3BMx3MJYHUeEZK9V6UdOJkc__o7loQWt_f8DImzV9MYomBbypa1iTM8aWz18_sq-dUcm7TyX0Dh1NWXNmeq23oj7jATe_DYXfD8DLdRpRQ==","summary":[]},{"id":"ws_0c5c51d167d5c241006ae44472fc4887d0a8a45fd5eefdcdf9","type":"web_search_call","status":"completed","action":{"type":"search","queries":["October 30 2026 top news headlines","Breaking news October 30 2026 Reuters","Top story October 30 2026 BBC News","Top story October 30 2026 New York Times"],"query":"October 30 2026 top news headlines"}},{"id":"rs_0c5c51d167d5c241006ae444759eb887d09ad0d811191022c9","type":"reasoning","content":[],"encrypted_content":"gAAAAABq5ER_obaicEa8uv54iVJ_G1k4Rvncq3IqH_FYpUDj4XTNSq0_w7oarK1_DULPs5jYkGo0d-oanjEvNL8WY3RXy-wSSH34T8pTyNzSJWPCFpO46qCFSsEpyBLtTSAtDcALv8hA-S2285U0zj_1JEE20BxSwtHV76XeeMuBXNlzgEKgA_HwH_6cumrTz50FTbQqEK45eq5zQsgNm5HY0xPn5S8QJDiy0i45kwikqWuZmetamyZNMSu-ax28urGLrHn_WVGGxYGUaBO0WmBIXKPqzAkU6K2fEKq_gq-ePK6SW7AEMXMjZFc-YOo3pWZIgJIajz11iuQJxW5iFUY01uL_yij2LAakm_2wfLr28WcL16esvYep8xxjOfiz3iFonMwwAoGz-9mrYfcHvmJK3ZHgZI6T_uU7Q67PfiPupHBo8cq4GUnPDEskCH92NX5XhP_Z0s8NCS6cZqVsZGhc2zHSaVKQgMLy0aWkYQCI7DTQnRvfagZsT4jfYGFtqWuNwryZrONDJY342zLrnsWr0NlLdSUS2SJoTmo2R4G-cDJFbd1t8NaEZXufitVs0cg_9tIidHmaRIo6OaNytbcFdrFPVFsfyp9K78m9N3cBkZm7d1cP7K9rqqMHtL-UzmNylESXuRs4bysdsyibO3sVdyRvf1XNIlBm-m5yNzt4eof3zOUVH4LFZxmwWNziKHz13c6F-OV13Dh8xx5ILPXFYiPhdB6uo-Ta0jVq0h-ymkvquNmJLz5QC0TZ6ShG_hF3lrRtN3GlLvVsLBRjKqNXPW-LLc03iwGDwlyo5ifgwuGrtI7ZQBOHXNPZyvWHhmPCOea5lUWm9ozDET_d8sh8q-eTYdpb3UDC8XCojlLjaO_v08hQcF3-VrgMUhuBxaQC7iZ4TJ2tS9n-rlPhUuE4FNQWP5Zjv2O6uX5M1VMpOEnLMJ6OfJS6tpd2SWFqkYjJlQfB4OGknjozI1Qhbyb4iCMWhNw4k4BwEACix8GUu3ZsxlrP1xVl-hQsWsgD4A3cWusxs-t5QY3xm-LkGpjehN42o6MR_OHcc3U0OxMiEcy3IL4h4UlCnStyg0qbWPf6G1XEp9_6cy_o05PMyi3wcSONzeBL3tNTNw5sRUiB2CVxbmghN-mygxm6ymojkyV_SLQa2Hxuk60G8brjaWVhyBc0JCaEZeCckcFc_CkUJs49eG-kEBhT2Jw1GeHB5QTX9Mr_b3kg6mPQ1zc0fUX-HUICTIvk19T9ntK7MiY2WpUSjTL1TDfCKMxUl9QAMrSLNnR6vsWmHIsQsfW4XHXk7267BBzBkHwUEuIWyUTCBrEt6zUrLA_2Ko7hoVAhHInwa0XETD2QUy1psK9XCfree_0o1Odb4CiqMfrKoXriEd7tXRs4t9ePnUcaKB4_2VrkipaeS8WphPerTBPtmFPhWGwOcJg9xEwrmZ2D2o4wO-pZSh2L9XJ1ZIhJc98hECXXkiy9eu2eyBz5PYeuCtCpLkRI3inHi1ZDqbqjfMv9Yfw-3wPrthC_QbupLYH0ZYcwEsayTbpsmkeCY5WY9RvOmmHv_9nThDd2Q34mT0ETao_S9J2Q3BPokJLElAB8DWEttviPFyhM5bYRVTyAguS5i1E9FPIF6uXZrzcD460UJzP8O3GE6Z44JvnuqAODCDharJsB-J9brI-XYkKbIv1smGAiHeTkpr4AY6B4bi2u5DxPo6hnkfvoszW4rojsA0u28qcos-xJrhHPUZoyAtyKROaN-3yb46KE5RIoRR5THDgY4F4HepVjRfE32U5DgfQzQO1crPCuervHYEjDTdm30u9PbhD5fKkwtjR1a868rdXTNmqBpa6mX0Q-vQkhTBphKlxKqhkGRtLVx8_Z8ZzX1BxaSNNvQL52ViYuI0mRlmvRY8Tb_YVh9oBXIv6zjXmk-5jneFl6-hWH7ldBHPT51y49gUScKVZGdUQavLOdN6HMg9P8XeMotf_Ow0qM8wuiq9735alwnfW9UcQ5vZ1ASDZX9RSEpYkdY3a4-CuuDcP2HUqlUW5AM3nbWZzso_ekE9BCSfpF5rl0g4q25a4y7hWYiXa1wNQi50c_OP9sD9aNPD3IZCyII-rN80EuFSdMKJqzYUK0m0nJ3NkNy8aTcVmrda02thNcMtvhmQbO2179lTBncBArr1TDFXG9Aa3dvLCL2wmn3u9OPgZp3pPGzivgUBYYl__O1OG1hUXnd8IAI64JP4kbYjw0TAOdfhWH1APHj7h9wlBecsTbqOFumsi97D4EObBvw9ZYD4ubN8xgFoFwxlkJAdQbSEmx-0xAbr1qJgRflKxZhJMiAK47JYa5wKdTAYcYvi-3UEHGk171V34rX6Yav1eYaEsy_QRPqL4WMB0bfc3gNv_4EGPXvtfLSy8YJ7bTlURciPFdn2qjxuwX2N7dFsyCeUvcGmvoKq4BYa452d_Wa5ETPX_2CW2Lw_C9eEmQu8HgW6RsMXYmj1LMvIlvNQlbzgSvgWHG6vbhrk2925VV3NRpcsLUyhxmsuqzFBY-9-7Ai0y7SxXgqLLykue9-EN7TF54XrPA0AIzbYFmXZw2j9m0UtS6TyCjdPKzqXMKJ33A-zGbSS_ZmeiwmG7V54LxxWoyB9qkUq1zql2f4gp7hnf1xVicmvdbO8bNuf8IwJU5nUMljY_2oma5qSUv0eDFoGtQl-OeVD3xMFz04HrUGedOj8GJw7jbhwaFopBW_NyIjP2gtJg1Shn6fHs3hvnFtdHClCMbwVq0u7RnEIA-61XZTmtq1y9AIrQ2icFkMSz8zXCr-3yLruic2Q9hwxwd36leL-Bd6c79Q1j22xaE3_GOcQnZz2jqXnIKNM52OBOw3LyE-1MdvadVM7wxN62BeGlwn6Yt5IO1Ch8mBMQhnMMq3W2VKRcMwmqUuNNsj8vkhJBJnTJj-9QpW-STaauGEzaoat7KqrUfR5mOzUNqPsyAgYwHiLqVb666Wrb70g12VjIAmnIpZAenCxBHFG4NGITYOKhYDZeyBoP0O2dp5ff4z5PbsuVt5il4HMP3bz-4B47-h1wV_wwhSme2a4jkyS73loYdiIzYZt9j6tDAgdOiam0Oc4En3nyE2u3WM47TxWVE644ElZQagysfPQXu7uLjlMwLrCXuq37sZa4dBu0mkpURWd9Zd4dGW49AcS_ZEpLWoRw3iqdh_PS5rTr5t4K5x0CUSg46Rm7QeffIQA7JSp-2MsDCEqvKqfgfGHPwnflZy_xWyVO4t3tb7QitzVEQ-3l7ZUizm4rj","summary":[]},{"id":"ws_0c5c51d167d5c241006ae44476ebd487d08fa677f3b958340a","type":"web_search_call","status":"completed","action":{"type":"search","queries":["Reuters top news October 30 2026 site:reuters.com","BBC top story October 30 2026 site:bbc.com","New York Times front page October 30 2026 site:nytimes.com"],"query":"Reuters top news October 30 2026 site:reuters.com"}},{"id":"rs_0c5c51d167d5c241006ae44478c27c87d096983ffa03f96839","type":"reasoning","content":[],"encrypted_content":"gAAAAABq5ER_eVQrp6dLRA2aQMi9TaUy8DdgCkSgLtjZtwn7tP2iAsrOrHodRHByKbi5QYOyAOv368yFkCadCCbkblwg7vifZMvA6xz1eigm7iJad_bqFK3L60LXbayAzMGORiFtmBPwrm-dlvqHkuC63C6p3qxUZt-4ST8_hyFFyu4lI5cx3exorLaJnWBKbUKEdXwHAzB9JcbDW-H1k5n_c3qEMmv4NifwbVKGnLvKhuvwQ-wEw3gE1rSvd_wszMm0KiZHVDW6Tcip6_sG8PX_bcHVIgVysOQ1X4Z-DmtuTKzi8r31iud8ht6lLEFPafePAKgJ4hPdhQI3wv-ThBaHFJoWsAb0SmcASTaPNnF3BKTibCjVQsLMq8EyU0CmzKAYZeDo1ZUHUnflD1zyyvH42fEcbrCbm4e_OLKTlHfR2CIA0cqOdZw2W4AK3J8-KkwH2_5glL5cybjFpE8P_hRqLU4a1D75J4vZhe94MOVnnxtDja8XpJdHXE5mKlkPFvkpvOHE51mda4ZMpanENpXV1apS3VJVSwFOj1v87fZ5ra8A9DHIaxEWef2UIGyKJnNb2KwhEWqD4OAPbM8WMc58cRzjgNLfub--bkbCWE84Gul_7DqIEwJUweNG4apM2CRZRFXtfmjEa2etfrP9t6-klyMgAWg5MHTuZVIuSDslC0cDvSxyGGpFIhuL0zPSjNlvhUqregrfy0odBQCK0Hy7uPtwxp8WLCWO3-spndn2v-z1eiObEIEvKVThpKWfdJpidL1WPpcFOVug6Pc1Uvp-NDI9piYBHWJNOpZMpCsSOXwBpwf0ayGXGvErl-Ce8N22ZUn-o3fyZNZBN7vhbZxHd9KdedpNrtub5qD5dtlHvykIP3VAJ9pU2_gztUqTQBhho-23v2QZZ-4mBFQUV5XRgjgivw2ZJ1dspo286QB8BT-Bryjm8tU0UpxxyO0EXuugi2MFIaAIib02UNEhgHD5UTyPZIITvBJuccOlwfm9wkyOXZRZTftf5LNJZvrJnTQpmN54jFSA-I3uk0Ib-Fa32oYCrVk4I5EhOa5xqlzwAdE3Uhacc5snyOOnp3SGcAW0a2m87jMODD_ATtTSUDu96V_sZGXgjEiOqBYhg7z9wcLTqI31sSxeeQBC0MyfwMCdmq4vuNafkkZfuo1kDyzQlQelLOYwvuDcsVUaZKJ3xN478UWEhvLOaFh8Iljav7FqCPgU1_Kb-CWXLeezECiyqRQGdwLhxMTtlzOKJyaqU3D4LlA7g31ETQAlpJQBag-6xg5iY7UYqndU8r21Ia8rCEFtbm6ZL8gZIX4FwlljXZtytQi6i8ahWwlsdTvfTUSTMppeUDefCJdeRu7dsktHCmy2_ehwddMjQEinuAl-IiemhXcsCsa1dMbNdbvbMcXfWVBpNQguXrAYXCxyt-SfSYiyF1YAS50BWH9hiFGfwiS1C1lD7OMDb_kcnm-N490wp-skJadeaLq99ZKsq-8wWMXaNc8HjPQggEQxot_hceamuaaU7-NpjT-PiVy8JUFNwJihIi2u6cpbFXwHZkI3jg6wK-u6xmH0c-GhcoYew953UgSSo74zU61FKSr8CtF7AOypX-4YggmUz1CJPHvwN3JI-6HeZOVyylvrDLZR-q8FydHTKg6LHLEsVDMfhtd8NUud9XgVUjV6gFDezunHwsG0dTVo07lZBAs72TaueCnol9utoWA_DmVnYmS6qBR9o2rM78qMd90XeLK146nzfawcUhrM2U2dKdC7ZvsK0T4NgA5ROuf5zNWdIiyoGM-Q9dskMKnkkt6YGLoqiDfAnY5VN05dkA1ZS4vDw2UM59TdgWeHkECNwZbPoiFH1t0dxSau5hWxbS2FeiTtdtWguS5ko06IVus9a5ZruCf8pl_cbpjfwYjfc-WsKwGlYcWKXQt3w4j3Z8yOJFsa6RUB0HlufsFIyVV-0XyilYvZ0ral4epMpyFqAASiPMavN5sv55rRrQe3jco-uBoG2yu5Dmc5ShkIrxqHJNb-d0EPLH6BftKS4u-7gb3fI95uXkfBG1bj7dJ-CIQB6DsAKOIbbDzfw7MwrkDG8AJj0PUjM-ndxpOti15dalaTYI4Hs5vZ6jbSfd2vFEYPLFQ6VVVOsmSBZlX-G7uyuD8AZFv-8sktTW475rLzo7w55HBpt9yyTonH_YOUPmhrwWTPzSRNepRcM4klh68wBCtH_QtgF7rtWKLKodQggRcw9hKhGTJWlEsjJqM-Q9nrs2vkacl8R5Tt08na9Uh_KK5RuYHyurNZ7ahXlx7KOE31LVIKpdrUke2SzajZxNJCqZZ_GqePZ3GsatKdVwx7XCZPHh0Rorjn4AW9B5N44MNTAzPGMjshKtC79L7HcitsNKXiOVX7WRWBhWWAI8dcURWex8IDR2xUC6k0MlSwlc9UGD9s7BYtoVYveP0ytPVRzaTr6Uogr-ipTFw7QWjmDbQMsNRM_PO6Z6-0mwEAe9CmbS353QYNaZQ0dM-SF6cFe1jtzVzqI7mK-59b6bMuYmrW2Ff5k31VQQCy32Rdqj0aiXXzHFpqD9VxFIO5V3aa18ZmSd7_QNgAyljdj3omUntjF8-kDNBlg7RC4SV_904g3qgNm1P6yeX1dOGw","summary":[]},{"id":"ws_0c5c51d167d5c241006ae44479b09887d0a910302a1dbd053c","type":"web_search_call","status":"completed","action":{"type":"open_page","url":"https://www.theguardian.com/world/2026/oct/30/all"}},{"id":"rs_0c5c51d167d5c241006ae4447a8f0c87d08065b4dfb049bd12","type":"reasoning","content":[],"encrypted_content":"gAAAAABq5ER_aJWs1dcZKlx3ME8m_QoCceAu1X6ua2ISTGRBw9DS5GetshVUE0Dg5pSU32CmkZzLBadv_o8yjjfZDBm_eYdANPf0rfMC61MPmmgiwIlVWtd9-l0QNipjNGlTwo24sHw5Bcvv5mfiRjopr1Z-IQDxdIfJkpVhJhGuQ5Zq6UcpCPrjjxQPNTlgrwPAvLbreHMHk9z0Aw03vi8i-vJxGbO2tq4iVb_PifpKf3w1keszjKAEo-pn1sYp1zpQWmi4D2WpUw7eWWcdYhKqqcXOuZO428efbXGSIPRZ2wu6gTqJTi_W8Kg7PVtW-T-JuhTRvV7ZCDVJmGBb2EMcRZWnF2mGCLLICbQmMKdW_471BRLDaZhKCHoh8EEZx7I7LgwQ2OnHC0_UX1ijmbqqWRzUp8bi-qMIWloavZJE5_KAbUxc_LEr6wzvFCuVr6sRnA3Rr1xfR2eOsNx6MG8aKCZxneHlrI9bKrRVaRoCzG6zQJ8omkR0DWJlsMmlxgpwGicZXWdOWZeAA0uX_gTj80NJkVcg67eNCu_pozyjTJtGsOFswYMXoiJ2xBcrCigZIi9YyENCd3Wm9t3Pf5PjnBEnZVwWaPyBE7N5Uxng0NwM_YCuEJ_bwN5WaF6qpFAPZkbJvUhbrlsMPXQY5os5Jsq9rNLcbJ0o6IgUatLnNQ9U886-eqw1FV8nMMl4iCgCF7JFAMCYao9fpL7a8J_tSOlziL99cf3TLbNIiVe3JEJNj80ct70mv032b6ZhqTfwLSHJ-F4pXS1pxIrR0JLBoL1Nh51uNfpJREuxhsWvox2-IK210QI0klFO1w5laP8PkxEWM1M6YsoDk5A4c_zY_G_hzS-kJFkPbRBH2QWCw0BS2NiZXrWuTZv0bTDQCySx_DloSRJM9SFdj-GVkALEoQLfnIAchv9SjPeyLAvEAVjaJ7OHYhDFOW166uDCNFJf4IXWkLak5LPCv5fZc3L-XXCXNIjtURXHLLdXI_G1Xgkw6JIgnEAEMaL_-SUbTtJCubONqbOcmGIFs1U9tCWJSo150qw7f361Vj1U8qdYBrUMIrRpw4d6X2L_jp9xfhqDSezMvfalDPGNOrwTniDwI-i8Tq-_mjJgaUWnUfoqmBQC6y7qCi1UnEivaxiOmfuwovIbtv0tNyGsp8F5LET-NOn_1F102jBbkjp82PdN_0cKInHsHzMsDQDmlpMcil0kPkQ9EULY7DWFFE1Xe2fQzT2aBZif68J8Eov1veOHSKt4dQUL4ZqCu4nB5WO4L0yKR4YRMRrGAq-5rCAnm7MvZhe4U6WbEzqsRO0HoGhbhoEkOgWyiQxHgPjBH9Ou9yCa-NOTCWbCZi2PqX8iSSFm5CbButXQz1pDunBQJGGG1NFoCKPgC2uuJQ6J3bxmaKeCXxCrpi16RRm9NwTEL9oo2dxv2GoMBG2AufCLMFhXoIoCGvN1_sm7yrEjYkjyumghkVn1bbI3YVrU5P8RabSCFwlWlvcbt0wxVYqfIT0Cw5LFuPgU738yYmtmXw1iLnnhdMiAyAqLQ8fQkgdyrRsFMqWK-m9kydU1vdECvMhh0T9DKsIoKJw7OzI_e5WpJfdKfipBigKeuF10sCHjRIMb2v3bRBM-BuizIrnWeegkcEHYsiZfDHNTXmU-N1JryzgbEqtUE-wvPzlpYq8duOKPh8dCefC4QSQeyi2WtALUF4vhGfpBHRITqxPsk9mYwlNx7SDYmvx9mtK1kaynocM52z3wkktqwX-m3Rbg7fyQlM3ieher2mx3HgYHC8kdf4IafCiqusvNDATOYJ3-vAvUHp6BDqrXXeB07jWlB3EWr-38utXGjsTOQRD0zlnWnrt7vPiQm6xl93GG5bw8BnfxaHLqo7XiCXm3dfSE6TFyWBrRLhCqiqPWcWX3WBmFNNjpVYwqqy7lA-NJ-nTLRvedSXTwwrJXaEJgm75QYwq1XFXGFHAgP97WW-0Lo6azMaSJJb27gLIctXaI37_c1mbESUbenIU8y90UasUs_epRfB8hubNq1HdywVG7MtdBlBs56T08IHncS-d3VdF8ovtAzKhGwVnk09paRBGZqpfcMcnTSYRQPpnvnEnoORwW8p4_OcB4m9qAvxuKDXBZhNJou_g0YTgpvtm-q0GFk8UCeZxwrjwnpDjW6q5uUpkKvqKB8_ER6viaoOPrMZFFzoKuvplz1lXiED0eFzDhWXt_IZSI4YKeirGbhduwaBGfGl8fpBGsERWMSYmudnssANEeLtAms8deHroLte2aTm41C3DCNi7Wit8a1VP5Vqar15pi4omwEvgjkQos_58fUMXmPEvpaLh8TcDd3LiCRw7UzvkK6OTsoJXW8Y5KbZK1EedfkxXD3KzKhke_fSBq-EBVvdUPRzXFvIJUJO9sgWf_MPHG1WYcmn4kYzSdoOW4-Fn0iQsU6Q1akOSJlr4LQRj5pWmykMviC3hpHhjDTqS0I3-mLxpju007FRjDi324e5iadgxlLQP1uKur7G-OcTm33tTtJe7jKgHPb3DUFWOJegkLBgju77nGfOm5XdUMMXFB19lZqGbOhm0Pua4hni7LX97oj1h01ocdnEuj6Msu10znHN9xfJ_VRdVvDMg7wKBRyVLaQyP9u2glKtzzw60T3lNvWxcq5ICnXQnJQ1nYsO_dMLRQgiR2-ZFXv_iJPQp_chNXj0z_tdON1JPCVzHmqI9Wv0WnYHaPphQLvPvkQRlQQdtgwBXCThfH1g4N91s1AYAfW23-Km7J1TvdHyl38kFpydllyza2oKPN4bj3_Ze-LGe5b3jHrC0KvRxJiwqQLx6zRE2s7QqcdpCqnb5KWE4TZXun0n1ix2HyumvkUUL8epK3rlCuukGWUAx24AK1QuEMxwGi9FU2DOosSdl9IoYSmb0w0fLuJn1XBkhoGTJeocS9KvDoDkcxDSbu1akcRk4y1rQav3aWfAT5nDxF0MR2nuWWaWYDzIW6Npo4VsgIIGwBWCaBq65oYweoDtv1p4qaAc0HRwBlF5Ij48cPnJNy0UC7oXyitIjtfajBKEEZJdmcNPdraf_SG5LQ0CeIb45GMw8HQMmNfXgVDmF6EeyLciDBQ2FieAos5HSzoyCkIbHbywCf4iiYAMck4l91PyuRxGorp0XkciUBPDnm5H4xl3v97e5daOwsQfdrwgGUgRYqEksB3UtBY5t1nSzc4iypjOAcwPjtfY6KLXEXUByN82vGBdhpoY_bXtstyCTgsCxxmt7KZxFRBQ-KgBNVFuccyC8tMqo9EpPk8GjiJmUrSiJ6VjGalFL-cy6DXpehylQ4Q9NxrCF1zLecOhgOQXcewBdgxFpAJzlRG7o6PS5l_87p82u-V3NOUyZEbpvYu6bQoN2bw3pwPaWaI_GhU_t4QZLaYEL5L5JipNdBr1hc_GLyQFNH-AEuYKL0UFG_coaOwgK13AVkTcibP2XI37ghjoREP1Yii8ERcuPa0jaO9moXxn4R9J_Zy8t1nd4jyz696z1CqklK2AkdsGydm8grW2dODxU8u6YX74MrjYKg1Oi3LaYSerlNOuKe3_A35OVjdsAAblx7lnqvNq7td1fPNX7u1yIRg8xJJWQ82MMCnZuO6t9hFM9gVSk3TIMG6_UQ0FtY1ZqcYEdAHmH65ju5AUYOj9rSfsrkR5vRft8Jt0MpsMYMYmqp207QEEe7F_4nwUN2Gft0qK_i-5yPcTmLe9C4YKgrE-YLT2VG5uir_PguHuReMOKHh47PQzvSuMQZje9Tgn33tB1Kv-xvcdQZ2ijX3bCwK7h3e8ipku5RdOU8cQGhN3fxWWFmjrJZRC16XBL8pGjVf9qePKXMcJ1HaxdoUn6Jr6c7E4CUFJ6agaBhVNNbCvqqf2yrVDWYOu6Qo0WdLrDMRWgJqA9N-yBEHgrl6fBPfamKm-QmJHAQgq5HJoSxhJz2-h_SEFORAY7Ly-eyECadivunLeDCBdS_T3uurmWok4Sy3ToW9mXjdu6UwknF5yFgm7-GURS4-0et3X8S7joEeOTwnaSOooiNMT-sJ-pZnXWtsWcPznmNiJh3yk73l5jVyuI8N_zQvtEq5VIQbAOSMFd_SQdnd7RMviAEmF2XNYthh5B5HeXWGh-Q3xG8hXMbaxca2HQ6qXM4dIS22YKUzNNpzFtWtTm7Fr_KvNJa9w11TQR6e3eh-3s8QLTxXaOJl927Mjnifq7GKRtaZ81EoNZX7xxoUZkcoNbsUqfViW0PAqbaqfuqreHZPYooZ2SEVwH1Uw2AQ7h_dl64Bn9it-Msu6_kJ6Jc5LuoVI5TXBkpNJychlyluLGuNlGWwRdx11HM14aB87kqdI3b7S5th3_V1TsIZm6dYg83LGMgcvVaGPuqUT-LgBd_OZbS40Eb9r8OeYmWQg-97-np4EnUjPuGOx6HX5GNX8L76N3oyaeBFSDyKgOb_b_PAFDpe1Ws8Ej_Z6TpokJoIV7wjS0j6OCzwSQBqUIELgfDeg_lxZh9vwB0XQ6S9CRhzK3-Z0Qn0C983oV-IaHr4X2ahGW_diJWi1l8Bbxpu6a5vdKAhDQnm0zax0xBWtl7nXqGDg3RM8py9Exen0tOsovCknh1jGb5IUJKkDjcTQcpl5Fx7UOOnhPFcB9cyoDp6T1G23knKxdJ4aqogyx3FsmGv5o6MmjtA6qGSLNWm5szc0TDwXvUceglkDvAU4NaQpSv6cuYYOl14FxFzcy27z2rLBF3oOgP67anc2_B5shApiuO6SZhB3AtH2o8AF_LZ72WHhx_exnv6fBq5orY_EVy29r5wolGFNK04CRgmunIgZ1XIuEBMp1KTPFBcBveg4u1mX7Z057WZO_awA_yCLX5vtjN-cNPa9l7v9XTF4WxAGmrOmImswt4QexVYhDcrZskpm4CpdIBPMnpqutrmzhHGZHPVD69BULWWcAIpXhvJFNodaKUbkVI-c1B12rWfH8gNomoEL-XhVRsbaox2bSHzqu0IEv9c_7VhVtv6aECcIhwXlh1bTlnb8_S9QimVHiQa8KIWV-K_QjlHVnaqufvmet3rocMt-20bS5S2f9wddWrjySKJBB2AXKhkZf01rmMOUmvaz_bcv6FN8KkJ2Hldu9xbFIDB4u_LKp76nJBTKizWTqAn0UiPkNBy69FCda5nERl31kxJJrgum_nX4hmsZXMk4zDLRZoQgITOunYT5IigG7QwWMgUnrgDrZnPE8fYuE5FgXwPOMc-QhL9PSJQcNm4VjgjPBU7FiOM8Kvslix4J-265riqkTqFpTZQZ_yettMExtPnf6-HvnW5Q-KNIIB4-Lo8ofv0Ldfggt01b5muXDn0UGqp2GnSLOkTmIahlpAKDNX9zc0GwmQDk41VcT7sr3mKK1QCntQVnBKMkZWdsDP9ZKH39DYOao-MvfQ-wXKVVPQXHu4UZ-EQrq5UBrYQA71eJt_cKmsh30RbEli8_96CwXHDfj9OKZC9e5KKbwxX_5uCoQMYS_RTjS9D-axIkdCv81OGsBXNXqaC3Y2tEPtQePV_lwGR0CGxit74Rr0e4gqYNXZV0Qe64AaPOLfJchTZuokAQJWdP9UFnjsW6qFoo8ggSz-6uB1KiObZSEmDUUl5qjqe5HugbWgfejKE2ve3MK-YalzW3q5eUpLArb1m5w1kYPk03Cc5SusLS-anJ8yT74zuiQWSDBCeTJNjQirtHzFJq_EFkMnFVbbqPsPhyMji-ReqoqgNqPxzdUHepaJOkNuCcJTonPRZHbSQIvDgHzLXXf7MbMTK-3YEYxhYC9mggk6qvLDGELCn251hgCRugsjA9VYaLrU8ICGtjs-2dJHuierb0b4Im_VR490QaWF1qL8SWb-3YbYMAKKMlqsSVhpXovePCZHZUbsiGRsQ2c8YrT2Fw1J2ki-5z6IrHwJLQ3AHbgYbyNnY-v6o4WEF22W0iQOeBeLr9YAB8IrrZKjuPN9GDD9HULCZSoM7qmH7R9H75j9GMw8o4SMy_3eSgEQobpZSK-haItSQ07IMmOYmdphPCPYmmmvP2hWfgAghumhPdpSuyK4IAp9A1rTJ38BpjydE4z2-CgnDPiRwvNwId8x9Afe3EvY-0qbwBN5zIB9_hgjioXVEp5wK7fNOltx28ZB0prJPHxjxaUq2TpQGdU3zgxC1NarnfbnzqJ0z2pzJx7ySkv70YnUp9rd4ih11pnrg3mjTVxi5LjSPyeFohKUXC567PXurASRv79vjSUOx0zkhFEQ4aBgNhzH_PCPUDWMYh_EUpyFMi_-TIexQmUjEuhFO7mz0pbZTK52GeGXAjsyS26hAHtfzWc00N8cdsO0ekSrWQVXTUZ3EO0xWrLFjwP2XmhOZtP7WmfYuCkTEh3uhoel1suwCBq9WGQqZQwTMpQtj3s_9m8Th8qFa0jx6q8pA9UnN3rGiuP6iQ4I-fQuE-gptaruMVx8ReHn11XJCRzPBD50IRpk561Cv5jtWtlBBbyFoZCtoGbc46XHhbNxbf75Y0BnE9-WYMOabii47vqFDrrmTcBYAu3nA7Ox08iD4TB2QPTEL_axKAxnD_W060IP0T-kXNBXXJISEuj5b5vvppiPF94kafj3pWsD9y027XtLr1RZFOX7e51TQVzsE3InFvkp2U9UDOi8Y_nkVwdEHXKToQDahevjgE9xH1cpxEEj2NLLuIU5JNbHGAMATsoaAP8ajD1p5IQbsDQ9QnmGUL-NF19X9Chvb1t68Qz_GCzSyznQNhwn5Y15PyeNyXefmLrQBoANW4g_7b8Pr0bdOnEgZznQVKKAuj9Hd1czD5pZmXUMBYhbT9i7lmsVZyNZ_m59yHKWAY4bM1cG5vSInik1OHfKk4If7c5AVJprZ-IelzYnX75IkN66RwZV-E8xEDr2lQ7po9h7K6VeouS4-U7ny_rGww5H0b39lNZKbjbIYuIT0sLTFL7YCXtwf4Do-FiGVHIh2zoZ9YTF2Qoy-XmsAg20rv4f0sKuZrcQN4WIcPkD9Lnf8iTCD_PmHr7JLz3wTSterj9-1NDmFBDeI3KORJ-BAAWUyG32j-StnYeuAhWRjk6euNs5gPBU6uIhln40qwTyD-diFs7x2fiP_vxXvFBuuwtE660FuCfUS9FHbSZbFqgY17cNv_VoUDbQX7bMxcolhkq5RLbZl1TYW1RD22p2LLiQUnvIknl9A9gP-UN4apTKRypCHs5z-eMCTavT14MFoEEkZ5xOjSZxfxVTN3bw0YZqiRjxre_axCN2FX5-qpgOoyn6ZekbcA==","summary":[]},{"id":"msg_0c5c51d167d5c241006ae4447eeb5087d084518a07d29b20e4","type":"message","status":"completed","content":[{"type":"output_text","annotations":[{"type":"url_citation","end_index":235,"start_index":165,"title":"World news | World | The Guardian","url":"https://www.theguardian.com/world/2026/oct/30/all"}],"logprobs":[],"text":"Today is October 30, 2026. A prominent top headline (The Guardian) is: \"Friday briefing: Israel has a dilemma - can its opposition govern with Palestinian parties?\" ([theguardian.com](https://www.theguardian.com/world/2026/oct/30/all))\n\nWould you like the top headline from a different outlet (Reuters, AP, NYT, Washington Post)?"}],"role":"assistant"}],"parallel_tool_calls":true,"presence_penalty":0.0,"previous_response_id":null,"prompt_cache_key":null,"prompt_cache_retention":"in_memory","reasoning":{"context":"current_turn","effort":"medium","mode":"standard","summary":null},"safety_identifier":null,"service_tier":"default","store":true,"temperature":1.0,"text":{"format":{"type":"text"},"verbosity":"medium"},"tool_choice":"auto","tool_usage":{"image_gen":{"input_tokens":0,"input_tokens_details":{"image_tokens":0,"text_tokens":0},"output_tokens":0,"output_tokens_details":{"image_tokens":0,"text_tokens":0},"total_tokens":0},"web_search":{"num_requests":2}},"tools":[{"type":"web_search","return_token_budget":"default","search_content_types":["text"],"search_context_size":"medium","user_location":{"type":"approximate","city":null,"country":"US","region":null,"timezone":null}}],"top_logprobs":0,"top_p":1.0,"truncation":"disabled","usage":{"input_tokens":14440,"input_tokens_details":{"cache_write_tokens":0,"cached_tokens":0},"output_tokens":1162,"output_tokens_details":{"reasoning_tokens":1024},"total_tokens":15602},"user":null,"metadata":{}},"sequence_number":41} + diff --git a/packages/inference-discovery-openai/sessions/openai-responses/gpt-5-mini/grounding-streaming/session.json b/packages/inference-discovery-openai/sessions/openai-responses/gpt-5-mini/grounding-streaming/session.json new file mode 100644 index 000000000..2388d0846 --- /dev/null +++ b/packages/inference-discovery-openai/sessions/openai-responses/gpt-5-mini/grounding-streaming/session.json @@ -0,0 +1,11 @@ +{ + "schemaVersion": "2", + "source": { + "provider": "openai-responses", + "model": "gpt-5-mini", + "baseURL": "https://api.openai.com/v1" + }, + "origin": "live", + "capturedAt": "2026-10-30T07:17:20.075Z", + "capability": "grounding-streaming" +} diff --git a/packages/inference-discovery-openai/sessions/openai-responses/gpt-5-mini/grounding/exchanges/0/request-headers.json b/packages/inference-discovery-openai/sessions/openai-responses/gpt-5-mini/grounding/exchanges/0/request-headers.json new file mode 100644 index 000000000..28c14bb85 --- /dev/null +++ b/packages/inference-discovery-openai/sessions/openai-responses/gpt-5-mini/grounding/exchanges/0/request-headers.json @@ -0,0 +1,4 @@ +{ + "Content-Type": "application/json", + "Authorization": "" +} diff --git a/packages/inference-discovery-openai/sessions/openai-responses/gpt-5-mini/grounding/exchanges/0/request.json b/packages/inference-discovery-openai/sessions/openai-responses/gpt-5-mini/grounding/exchanges/0/request.json new file mode 100644 index 000000000..496a16dc8 --- /dev/null +++ b/packages/inference-discovery-openai/sessions/openai-responses/gpt-5-mini/grounding/exchanges/0/request.json @@ -0,0 +1,15 @@ +{ + "model": "gpt-5-mini", + "input": [ + { + "type": "message", + "role": "user", + "content": "What is today's top news headline? Cite a web source." + } + ], + "tools": [ + { + "type": "web_search" + } + ] +} diff --git a/packages/inference-discovery-openai/sessions/openai-responses/gpt-5-mini/grounding/exchanges/0/response-headers.json b/packages/inference-discovery-openai/sessions/openai-responses/gpt-5-mini/grounding/exchanges/0/response-headers.json new file mode 100644 index 000000000..f66807b61 --- /dev/null +++ b/packages/inference-discovery-openai/sessions/openai-responses/gpt-5-mini/grounding/exchanges/0/response-headers.json @@ -0,0 +1,26 @@ +{ + "access-control-expose-headers": "X-Request-ID, Server-Timing-Total, CF-Ray, CF-Ray", + "alt-svc": "h3=\":443\"; ma=86400", + "cf-cache-status": "DYNAMIC", + "cf-ray": "a5289b301e9aed79-LAX", + "connection": "keep-alive", + "content-encoding": "br", + "content-type": "application/json", + "date": "Fri, 30 Oct 2026 07:11:44 GMT", + "openai-organization": "", + "openai-processing-ms": "14114", + "openai-project": "", + "openai-version": "2020-10-01", + "server": "cloudflare", + "strict-transport-security": "max-age=31536000; includeSubDomains; preload", + "transfer-encoding": "chunked", + "x-content-type-options": "nosniff", + "x-ratelimit-limit-requests": "5000", + "x-ratelimit-limit-tokens": "2000000", + "x-ratelimit-remaining-requests": "4999", + "x-ratelimit-remaining-tokens": "1995223", + "x-ratelimit-reset-requests": "12ms", + "x-ratelimit-reset-tokens": "143ms", + "x-request-id": "", + "set-cookie": "" +} diff --git a/packages/inference-discovery-openai/sessions/openai-responses/gpt-5-mini/grounding/exchanges/0/response.json b/packages/inference-discovery-openai/sessions/openai-responses/gpt-5-mini/grounding/exchanges/0/response.json new file mode 100644 index 000000000..1924fdd35 --- /dev/null +++ b/packages/inference-discovery-openai/sessions/openai-responses/gpt-5-mini/grounding/exchanges/0/response.json @@ -0,0 +1,163 @@ +{ + "id": "resp_055961e87f906de8006ae44321db1487d0b83ad2631ba8516a", + "object": "response", + "created_at": 1793344290, + "status": "completed", + "access_programs": null, + "background": false, + "billing": { + "payer": "developer" + }, + "completed_at": 1793344303, + "error": null, + "frequency_penalty": 0.0, + "incomplete_details": null, + "instructions": null, + "max_output_tokens": null, + "max_tool_calls": null, + "model": "gpt-5-mini-2025-08-07", + "moderation": null, + "output": [ + { + "id": "rs_055961e87f906de8006ae44322f8cc87d0a89362dd41852129", + "type": "reasoning", + "content": [], + "encrypted_content": "gAAAAABq5EMv-WR9g34LV_fgjOhXg_ymyuQgOr2ZA3sz_-uljFZRfabhBdnaiISq0iy_4nuPcyKoByjpZqyUSTYY6qJbE-PkCSAngoWouTFqfv8HgvKE5HfpymzGZ-AWU3QhIw6jeh0XbwJkHYZSVsT1hExx3_qkUnSvsWv0D6pWdimZNlTH-u4T56xq7YCr8i9UC2WbjVAN7-F61OkU-M_eDE57XZZAwCOtNtbk7QBdDR4-JZqn-WAdEHixcXfsbQFJLMZjbgHHS2nO5H10jnVaqVJvwZU4kcWT5pGcm9mLCKhlismzql0PCDkj5z82qd9FIEiN6st7RValoHyl21GouQOKm8LKQmIQ7Pkx2hzL5MsTIy9KXyrnxH9EMwjHUFo8gFv4Vmk6rAPwnCnF9U5PG-skqWehxDFTKTkS0zNm7MmcawW06lljRsVnDygYyMG2fO8wChOHzEfJXjuQdPP2cf13506XgRUxIE53_YuEeJ2RH8xa5MEOYMAzGwrwv2MabFxICLbvptv8KxJs3-1YYKuQMTECum_RDMMssC_iXv8JUFWokLVR2czYbu9dMQh5Wa2EDnY_Vz6NtPsvDNjG8zMgmkkGAG_obZApFbR46uThc7agKvdXi2hp2FtsGxPN3FD8pHxBBzPdqE5XIHMqNj-4aU2u_-rgqRjvz6c47unlUbs75wjl5LGDXnVvbLaBBh6SCYY1B91rH3KDEoww0GF5Sj2mcjslj26JRnpFhqdMSsDg0ambm21QN4li8JZ9ny2ZkpNI0R8suJVP01NbQ4OPDYJh_u3iQL7zs43bGR5IRSTVj1A4lj-EWKlkKvQaw9l_D_Qh00oKYhdcbf6oDu_eTFxiRhwAXTOs1zqFX_maNaSbxYYOHuLprDqVuO-eTOVBpoVhZIv0yXlsbniao4GIyg4gvOy4NdI4TEuiofibybajmtTL604qHdmW4MTPg5tWDBEyPeGTffTgRbhIBZMOlIdL-Oi8g9U7h2o_Ip27dedpU6wmcEG6jiiNAqW3kBQKFoHgvWlg3twTbvH3SY-LB3CeWABd9X1Oe9f953L2u-T0AuCcGudznzrwztJd8ehIy9e8T9rSV6RSo6HelKv099yYOR-Pi4isTBbFg-v6h9kmNXRLHZghdhszTgI3ELBw-HdcdJ3TYU2J7kws59qVgeU6i8OLlBw34xhEPEAsKjudO37EB49CW7on91G8NOuwXZ2SYCWvM6khwVORPq4HIeSRBVCcWqWOrO3wO2V4rYpnjjpWYDlXkON_RNfEPKgHlcpAQwIxPX-Zq9FZEnhfe0u4UEoRTeBP-CEUrowfkYgSOSRCBXUrJBWZE5-lvNaki51RL-l35mVMlSjZPBu6kBBJvlEUZalEYWEg4Tb9LwaDPk003xTvk_Vc6yR3oXnoFFn06BoJoqEfIEGc1XqC2cdK_9R5TIQ5AZUFrXzCtRpCo8htA9iCfd-wWP4-b1ZN-XT2p1BENsziDlytQ83ZtHCrVSQNAv32wUtA0EEFumhHaFJus_ajFjwWgG7orLtQIRS09bzLWec1vlxWBfc8plDFZh3lzKMWQPhVv6MJDOPecBZosbIyZ9ek3ACjEluoc3DV1JiEgSopeycgLYo__B4uTxU4tLKO8lqbsf0zxhtCtGFPe3na8uWSz1PcusjmtDGGuDUneoll6s5pc0P3wTt-pDlKEDPd9A5eB4NJxWqFMFHQJZuVSyuAB23F70XV1IhFQ--0jQWGwb-YkP8G_jQd_C8Ma_dEv4laep6d53V0HApX__8eFo77oB7pD31KlXxW5nSy1OyRW1Ur0KWgYht8QVIMqMYd5XmRox6nOijQU8W3xvzTq2FLnpPtur9mvsEye5lM2-4_mFXcn1UCwqgRRl1hSlOfwL239v9UGRsVbUA2NZkXyIlPEE2NeW4NzBszQ3j9UFXsxv5ZgKfH-ATfoJVJCQkXuWtzarHxh40WDxOOH1gQG4us4UHXw7FQQIGJy2M91Ew80LwB2z6sD6GqKyF4VjNmL5mCky9uuO-JidRr7XIkvjq5S3EJBXd9ZW9tlCesbryPM5Zn0Eg72mZZav3nmBPgSGJerlAMuoO5VEHxF75p4qwWtTa4SmLfDR_g5Xcg0vzDUfPrxLn0-xOKUtidZNQOLSGp7waLgT47V5fmKCecyYm-HIWant-6jXTZV6KSDg9sM_N86Lsj9yz9uDzGRR541WLcrysdZXmXj-pEHW-KcAwOpenNYL2L-FWM5KwJsyIfc_xr41tnDpcI9fkhf966PxVy_j6xUp-TqHaSA3hyzzppyz2q0nlTYigxokuKXR2Avq05tFhQPhRzdtr83xZj67M_fE4wL336X8fdbTOoXV6wYeiay3XolkBVsLTU7AspDWd_FWHXbAZDLbuv2kFctJehZ6tLOXL87ASvlHoq0foj48LAVEwkHZppiqmhBrFaUJT0b9PcyL7qaER56KgQxbeb9jchWy78knyzAx5a1UZ5Fjr-4WLwcK2ZU7GqRl-_R-B1zyx37ytIDOf8RG9xn-C0BDCsMsl5jfvpGb7Q92Q-UbvRVvWy_tzLhERSnX5zRSY9s8EEdQNpPT0cio4hR3V1YClcVDeL5BzcoJuZ7nt-3cCyvzjE2b9I31lutxdij-rAWpIjPobUjI5CeMQkNKlEVusquxKb-YwSRCUCr7dhoN3-mK9r2Qreut3dKUvI8qoEkBwE-7G1zKjafgqVFCvV483L6di0Va7xoYR1VjHWlWhFtq6uPKzD7uIzQRXXAboffvv4yJT4sh-fHapkw4Y7wlFY_T5sMBGkfHxXO7eCmbSj44eKr_xMQDLKk5UYqzdnjFSQIt3lYynlbZbn9TC15uJQp56y5HzR5hbV73PAId3iYEDr1z7_ow4gGlbJFYYT6vHm7LVvTZdAlj0YZXVAZI5ws3_T2tyast29eGPSTPHnNb_HEMXz5-2F0gb_OUpuP-BxTkX4h5jY7jpI547w8HDjrOlNarHnaIsBIAvduCt3b5KeQO5WeAarf-7Matwc6rA4HANIoZ9_wd9fi35Y6EArVHveWq2fM0N0lJYIimt9lTg10Tme4Omq7QPhRaI5hbGUh0LwKIkKVFiZbCA-Ss2Ff1PvMQ4tvmCF_HIK547r2TK80_ABTv3z1-hakTpVllrPpGB2oB3fBJuxaIW_Ca4wQCx5pZhsawkFzMi2yDQ8dSL3eh1opBKl99-cv373xw-W9oL68jH8I2NB80JhBnqOKI6U2_i63P83CRg8V7ra8CgANuorgLZqk3LkJAdu0otPXwkfz951woNF3OBNiG0cFTvH5smbNmqSQivGQcSpB3PoVvA1JPY19_NEdI0Qy0vvt0TtSKK0E6cASdDtG5x9pJVZBdOisJCCvjhbErDZpPNdm-TAm5QcBlhiVsESI6Bbd9cxHTrJnbUQs4XLdfVXnVWCuVH95qs5WgFWGSr0tlxRUpp_d6acwyIQJSXNPYvLNbTfxM8_mtTlP4zPMt-zPNXBQ-AIXzzqZ-9YmKMTWv3-c3mUzAvqQloY7F-Rx_anVcv8c05fLv5shUf2MaUJ92APvUwrtmg5BWauX6TAUttIykvonDrAYOFarluW3t93rOFkVH73VlXOkRegHRLC1svi7urmWJ3R1IrkOGdrGWSGWr_Pp2RJRBZRpxPWgu21HWr2j0qAthKL_QdcWo-olJ8kIw5q8TgUrkr-yp45WIybouAVDGZ09VeCHnxrhfjbxfUxM3YKt_3ZyBV392VcA0IXUV5ivniJq6fAUoDXBF34Vvo79K-Ca8W531hSdf6tGLYlWfahyghKMfGYzVNYrQ9sbsM8WwzpAeH9Mtd1w5s73YKZwgzPxxaDCZa9jpnky7X1jPiDpQOcEQbrVcTLz4bj0umQqQVrO3h8r2L4gQCiJ5GSYOklGai7yop3RwTiQk3g7riRRPSYARihIuudM_76K9vS2H_0ICeTlT1So00siFv_FCDP2U_e2U2LYlGQkwOf-PZl2jrwQ79XM2_nx_Y8nZbgOO0Fl8wOB6vBvWJtOG64crpv7na0C29G4PkdDGA_FQgt2Aj1lIBl_Nbh5waxN2I=", + "summary": [] + }, + { + "id": "ws_055961e87f906de8006ae443257bbc87d0bd106872ecf0a133", + "type": "web_search_call", + "status": "completed", + "action": { + "type": "search", + "queries": [ + "top news headlines October 30 2026 Reuters", + "AP top story October 30 2026", + "BBC News front page October 30 2026", + "today's top news October 30 2026 'top story' 'October 30, 2026'" + ], + "query": "top news headlines October 30 2026 Reuters" + } + }, + { + "id": "rs_055961e87f906de8006ae443288bb087d0b331d294e2c00596", + "type": "reasoning", + "content": [], + "encrypted_content": "gAAAAABq5EMvVrifrERnQ5YBIgiQdUBoUN-8wy8kXGzEg36esYKuo0OvZpsnf1a7aUKwTeF61KwRTnBkn6aFSVEZnM1RTOXPL0dF-ZPygsws7pNYxzam_q_E2zGy6kVxwQeSWu-BYmYT3q_lONDjU8RB6UQTK_Hq0po3R6CkcBIQT7L8HzhlNFvRWcaU0x8IHX4jW2n9kagX60sBrDAR77kZpTG24TE9A1Y3Zt-af49QyQGpdCqwkrY02Imcqe1iQAkvy0xtwXy93dm4VyKG-sg0hAfA3Ha1UM2Kl7h-X1aaf8Rk9azk25XjdvXheTL_zkhFrps-fwgu9B10KtaG3oT617_WeFsl7slXsq7L4WBAa35C_rZr2sPo3VrwzUGJPWtRH604hzl5Qe1gtG3UxsjfXntGPPIkzB-3sUlcyDpcby1aLtqwz5VCBE05LMaSbA_oIyldliD3deKT26tUdxwk0CQCJzrV6YJ-Hzj9XAFEOem0CV3BF7dnHs-gp5GaOOxDRji8DxCjTvj_NB9h8niCBu9U3Y_l2ARPq_owNw5exi3CZexrT9tsff60HJrZgcJ4ldAD5iXmL5f7Ol8AwFKUWQqtlURkwTyTTGsDXBIj7nSL2f6d5l6QMhjqpXXR_3-X3-mfuWbAkJb_-RRMad_gJHfJj_Lh6T0L4gP9qy8SDS4CxTMzS3IJsmb2pRKpFaLbjItMIxtDHRmVGXQi93dA1XZ4xmTeikvbr9ofnBlvecFzunrKyuYb6Js6ffHFv05SED9RTxqCXpwt8Qtzqojq4-QOIenb4foRvXFFE-C83hAfA_M5EuJFVGz6jk-ZF89HODI22b8vWUnnU1UigTf-ap8D89xxIitalKt-WQb3DYZ0doA2M8-TAWA7ePgFiAPSHJUT2Qjk5NvYKyKotXC8L-j7ICgFI4bSkcWFNY93NKzftfK-HTWH6F0pLxvHJ9K4vVkESGW2qgCFRKvV0mfzBT_Z46wTPPN4RihezYqWl60Skp5wLQd3dW6vYHEw7IAJZSV7JTDb6TBvVQ8y4yYAcl44bLK0-h8PgbXsL5LdxWH6oLEhTSwPjGgsHhJKlXYru8nbCx_nuaT0pclcwPcyBU0KqjE_Ua-olqnsTaN3Pvns7rhM5w2Of-evUrWX3_eapYzE03Aes0kcaLCTAg7eFLQXmGc5yXFesywIa0lWP1nW5PyV0qHe13UaKXrf25BN44vFJ3bYRP5n_gn95w70NG6SwNovnLooc8390mJ0HezSTzi5WTUIqlBy28m3vL1FzLdA9c7sLXPugCpvqyzb0qnjUp-pjNVq-WAerJiJspUcUx_T8WNrsC_60sFWFNiKl4M8yfrK_tXp2T2FAxzZ_MKgyLR4SzSnOwe5nuKkFLe_N0XAklTiSmEfRcoR9oW7C3vnzP5rwFdroxZ20rrDcd5e0tTNs4jTCCMPcCcgSHKqB_YwmalE0gZBSixYzT6e0iKZhRP4PS0yZK5eUPgEMBP_vHZJqiCJsIcsAWAbUmzwKNJxnW07w73TELKska0yvH1ViAkRUZWC7Xi1NRYG-hCVlnq94ARRt5e2wC27eKM0v8NRoz9La9dPP_zNF9UzscIzZAKolF_d3MsOHvyakUqfEKwCd2_-z8Vhpmps28d3h7fPHCFre0ni_BpISQ8APHb-WmWrX_wNePVO7UcAMVDlotvOBFFpkiTbdTbufG6GlO9hqbrl8Clnf0XOTho278BFgx0pK3NGWuk5ZDr6OCvrxWfT5NwUqw_ujRdB7aDUiPqhfLiRTacagP9oi5wW4AQyXAgxYrCgu6KuWRcRdUasC4i5ApgjnBULIj0lrryLK0Hw_qtW4FeGNIrmz7gPBCPw2J9YfiufLLuQYwIlsmWvhFnAUaZMMd7ElTKsDlxBjvkbIbatp3C-SvYQpFU-x2U54KkC7O2n3vaXBBNmezeBq2Wtvvcq4fbkgcjhZYKn8221Ti3A3vfvKQ-LflFF3Acgs0ZbSbxUA3mtuUMgJK_B4FvvoIK_RxAZdJnE8-zqM_wmI8CRUWOGvcD89yQoy3GQKM5gFefXVBpP42EyYY9thOClHtUwoJwMB5ay8MaiD_g_i2tx5hgnwTRPNtdxLUn4nYzsBX3GUTjIe6Ofxd9AcqpcbQGae2pPRK31H1M0X0ZuV-55MpqhR6DxuCZ8B13C2D4VxKmLdF8Zjcs7O9W2-9z_0MDYY_cPkiFH9tfKyhskDZcleRvSuolmSTUyX5t11P4llNxfv7VBSey3iFy_XAKL0TjDZzTARZDLA8XpBzEghouQwLreTmUlC2a7kg_gkdRXbRgACayRDC95KI1P0vkJhMW6qbIo6rBwBK3ces9CU1xef_mMBuxdaCuJNzd9160ttmGTX0K7kJMZQNaJJmrsnUGFW4ANQMKMs8iQPaXS2W5Bf2R8T_e6uO9xDki6ISWfWMdyue0GLB6Fj6BaGuRXjtWvrluXXfws89N_tfQYGmJOmTBsNsDZBrPcWtOP_DN3LXuU5TZRSfwrek76YfpR1nzYJeKqK3SB86OUmyVAkcEn4Oe6aShqAMKToTNtvM0PM7AHbC6zR1VN2gY5wn12HUvtA9fTHpckwIabLhcMUvX9Ad8UscuG8AjQtjquUvWiCodSbJVe9tU2A3x_nlCNBRS56h40mGB7THJcy2JTsTMDDDr9H8Gx8fqZbnoRjeWl8EuRMeHv4i-szHmeRLQS6nhOsGXs2EPK4MddE3jxEdYynHUfBgZmQ8ZV0kISCLYp6lcyh1Xk71poQbLeIn_QG1uWOobg3pGykHIANJQgukbhcxGDzpbhLpkMKGcPpODCpjrr-ii40n_RiaYw4PbE4dMgXpQx0syyikVoniH_wlheztzgG6TDMLhzCL2E-MCLSkezLG4lsOJag32oTsNQhs1rrlFpyjlFLTBKoLhmiskGP7XmwOzj1qxWruGzM9V0Enob82ZMgJK1KCPcXhLpIkoX5iyxdRU5auFKMVu4h2ApgkosN8G8YVpWoOTgiRz_O84n6ozjxMR5lyxOSQyIKFPiMCQlmXrk4_iJgsFbYH-C-ovsouvBRo9h2Q_36olehF9AcgjA9IzLOAs4vD7Prug7Ny1_AuT6fADUw5iKUIxsNiHXffXOjFNzVVTN9vP-yq8OePh-iEV8OKXSLctAJJNV6RA_yrtXUlOLGHO-UqFOw1TCSdjFL6DlfMcsgd8HpbSJVC8BTzgtEsaSRp3KYqiaU7nLdkkswqzbdKPYEtTcMFUny6wX6A1jrgID1ft4Xsz8Dh7-rEEGxujCVfVsdw==", + "summary": [] + }, + { + "id": "ws_055961e87f906de8006ae44329fe4087d0b12f1832c1a62ecb", + "type": "web_search_call", + "status": "completed", + "action": { + "type": "open_page", + "url": "https://apnews.com/" + } + }, + { + "id": "rs_055961e87f906de8006ae4432b06c487d094d0b26ae9c7bc5c", + "type": "reasoning", + "content": [], + "encrypted_content": "gAAAAABq5EMvddhQRItVX_ZvxNejeTZl4aFQdUcyNbBd3CUN19DNpLe3WyE-nUCVVNqv6tR9ewr0vGg35XWN5FxpYzBD1z3QvmE_Paajy0Lg3PpQDo-VcSLBiV-hzD-II_HCyZYDg5Se5QQs3Ejyy_i2WKqqdeyBzCUD-NrGs0RhXPm6puaAjgq3U4MoSMroGwTPqYBqiVWgmbYsyyuMAETBKwQEXkyXcfNauAjz3yRUsgMPNKO9R87ADsHLia9yxe2hwZCdMIh2SxpC8ZzD4uzjH89xAXH4IN-QZY9Tb88uzf8C3I9_3PsjQs6WVdTC1h4Q-0p5xA32d0HvRAkyPwJNc_M93UiX_QuZKC3JAaBNRYCIwIxzrg9nkmAVwFvfnpjes-9vHwY5S2TmsMs1ucmAcF0phnek5vlcgj2DR2Rb7Bqaki7GdZnvoyJsFVQ4bIwyMZBk10olm9Nb3gfHTCCpMKIWbZklcgv7aold5uRoeqCPp-eFNgIgkQJg2uPnA8GTz0mrhA1kTiBkWmHfQWY8_zeM4JOGQ1mRgkQtvvxlgiA5EohaWZFb6BPqIytJOGpcqv0urUIEyPOUXhPtqhs-83z9n57fyNLZZICa3KpHxdZPgDXjsb_Ak3AKsQdwW9kFnQTrSp30CMNZTScxia7_VU7P6aG-nuy1gQTdrxDN_ByIUAf0rUvV3aapfhddcly8xRJY3GnY0fZyRa2hOTZ4xfwuBQqsbDG1DNMxvWzRIfXeHa9bXe_UsPJ5JfTrGUuTbp_eWJqz8449-PCRfXhZrX7wZWeqCSpMvsACUAXONskglQDCXoHoQOVqIlaQsCRSU1S6VzYJquTgk3B9_ywR9am20K492d6PsUUQ3X7hvjcKQWYUlRo8wki5NcAjDHLEcHTYj01v5es626qBP5M-IdRDprJTXYUu3a-52R444BFTLIluhLD7fFgQMIzvDwP6ATwmJbzzTdzoZGF1RFkJ6uZaXIikMcasT2BgZhNYTwKFbmZJx7FMS8aOQiSvl81nu4IUPFFh1f9oUZfSzaa3D4HqoeGUX5-X4ipIydr7eTzJTGimiIxUgO0JXWc07SilcgewHT3XKR0l5dP7o63Twv_a72qul2Evp3V7yapeaM1Gx1dM2RCbXNOGVwp3vZQDC6HEaW1v6xU8qcbPzN5ysZEyFgV3xhz1ZOLF81UJ0f9mG_5V9lBuVCFmhiS1OdI28fNy7YdQZCyfJ4dWPHlbj9oLZBlmStJqZ3TqgAe-axfuEbdjsFogstPGCHphtWLFlW5gDCC9WDK40zTzTaabxiDsFytj0ZQhPgdvMH33tPKUqy4YxXbz1b_WX584AQDtA14JmgGAwATz2u_nqhexv8w91lvuu9pQvySJLAfIgsRcQyvUs36n09bHagdJ_vLv-xHeiShHGoi54d8q19g3iPOPfgbvdVja48UYYjD_zRG6RAZmwaiVpPbk7-c1rVNwlf8rDnyXvnuu1_TUuFM4-TJFpVerp6es7vzkqnfV1S20rUPMXrVhQcEYqnEE9Ri9FdUSZ0NePiF3IgSCxD1k-AsjlojhooQAkf8-yF-uoEJ8LIr2DaKVBD2U2KYxNhy3HgjdnQ3p5St7qgt3bC36WIzJZLGhsRI5oyjl08O8rRKt8bmL2W42p1QRwAPtmccs5kXfeN-teUcPsaG7bkQbgApLFU1VEhgd-OxC6i1UEtoF2KvrNNMoBb8P_bX6ViYxmXXCrN6AWS2ml5MtwZDlBmzeRJ90z6rptAjepgz82BmdxF4_09I-47-kgUKbxjIS0KbLVeRergtW-PCID7lvsYkpzIiq97Fw460KHuQNGL3TK0beODNAFFWUa7qmp7o3WkTF6pw82lnuJk1m3To403TMjgyl1Dqep_D-w_M2023LU2X281OFYUi3AupqgpKFedDebpuXaXwI9p_a_dEt259ECLiG5EtOKyill_vu7gJp3Ps2R4OFzuTyNBaczPA8JRZVOLKWVh06HEdmCKdEEtVBCz-IwnKHEIbvzDGU9WQF5mE3ijGmcW27cn8L5UQdwI5nNeFOFJay6FZhXJRDTt05JJV0X-5QlAsoh7hyk4_ODwTzwBVIR-dIZvCp64e0L6po2EjPb6SWBnrh4TP4p3_3yKafmgABnq-SXNWvy5Q3gxcnw1xUnFge0Yulpiukx1Wqcm099isa9woa2AuwxSRyRS7VGCyw7hW2zXCxDP-D3W-5Hulyzk8FhDvJCqg0fBDcwbeYUltegVC6ZaZk2OlLS6dfRa_ySFotUpn59lT_jMdklofi9q9iUoS6RbdUVSWKfJilft5ber0kwpbWLSmQ7xfhyjMU0A9NqMiksBGtAuxjnoocgFLqdRPRyptKYQDPUj4FY9EHIIthGsdn2p3SclCLetKysUeTS4VxWCAT6AC6hFNKSpiz4FR09abk8w_nJUx6zLFpXB6Bha1_B8IeYUKYtkhTAzXLEIApaBuje1jQhD5jkpWzGh4gq4aYBJB_ZLQtC0_-y8AWjAESqJ-93OimYY5CsP5FqheXXz6CswPPQIVKz6LnmxrFNTKn5Yy9B1VAmihObdgmyIQ-kx-KDW9BYyjkiXj0RTgbUR3jXKSMnqAKBrqIjKT20cE98stCCezQOFfXWNYAIc7Jnk4u4MPDmqRmTlwu9KAXOra0GAnF6kbSV6dWilJWHSkeeql-Ee8WJEb-8vlTbhHMzFnRz1WOyc-4-BCHef7Tk0g1Z-0zeaORBOmdoSSVBHhJwh5EKsBNzI6UjA-AicOZ949arLYWeCG6u_NzlHhJeNLNCo0NCfVXhHQvoRGPtK0Xumc7zvLxgv7aWot6s5mnKh9gyagB-d_UlHPPZA_Rnz4wBJRDR8PrCFEQH9nfFZe980Kc3xY9F0WYcd0Z6ug1MEeorba_gJPb1Q2sR7A6TTnt5yEPHJJRle4v300oURBxWArWRfudTtO2HW7mbhyoMg8PMCyS-yvwHec6AK3Sq1KHsszHZTLfZPeXYtmTQXuCrIlqkdm8w4vqFUwtXBqX-cb72CqlQyMqOLuGztRu6_eMznQq4dlj0OCa3uTZiAyug0kWQDf37me0fgHyAVbAX_A05cTeXbPlr-n-NmvNfaOLlKBFYqUeanju7A3JW0dEXXUk0fHxgCk1WVHcLZT8x5zQQnE9Tj9C3qHfB2Ne8ABs3-TK0yt4sBlsMfR6EnjmbdE_q7tCUjgfcXhQfamxGJrXZqx_l2h6U2iigaXxWaD1AnCfSH8Yv_ydEQlUslPt8649H1qEPRASK7xYFPCJ5gYoQRrNxLRuBPwIo4zL9LYfyDZmnpaVGCDcs6Mbb76uezhCzxABgeSJzcP1pXn_mUMErgM3IG4b3Y7jehH8lhLb72gYdAfH5tdJUU-8bAP_DFK8F-O-dgHiXv-NKiZ8YIVF04nHmDgy1FfVF48aVBkOACksEZ35wbsRa2EHncixhh3e08YtTGUKQR_rj5yLWj1Hm20AZBJkykNi8taj18pAc9ibMnMcWFx2RRn39FclHiTXGkYWKmckDHkLEZ3y18uz_j3WNQL8pAGzjleBudDe0ZTqgHKbKigWWNm3Fl2Dj_D3C0gyyB4WXmKXQfpy6yThg9i_dfyE8Cvwo7_Zz_oXY3wSVoJ1bwXtcnU8CHRwZ9NwNbl9xbEUYs1-QpM7jzst5PbiRI0TRCb9UyTeeTvfJLM8nZ8YmJGCuAmFcHOS0A0s0waBj6J3JdEVzLVCKXhDEiiDoZrBZCipwmlgYDtPEwnwo867041JqpJxM1fPJlEA19Ecy4Abm0M1GqCRLyAMgY19Bp34Pnw0Kr2IjsI5zSw3T59HeG1Ez7H-1NzaTXcoCNA3ZCC_qT2NmpHxG9ozhYmmFzJTycGmHivKxcq1h_H9sZNQ_-gT7rFuqilVTycPNtIJ_kM1Oei2oThF5TzuQpSFBU_74tsTM8wnXrFia0VzwrqLIzLnaar64NB3CwduwYG9DtgaG8nYKrncGXk4M_j_3xhsJI6Ss8UX0TXWLSHxuGCpNsu8U4IzyRwe-tDB4l3EZikAIaSNLv4mQx_yK4xSRXJ3tF_2OBqmEAzZ7ZGgYGPr5m_4II9bELCgXSueXUaO6MLM-LeOluMBPWQ-epDHNL7rzCSI6JB24GY_ECTBlbUbKSgufwQrjfFUgXLCgRhBXY-1y3JLwwepy96gsmT5ds5wjpYYArcdXbqhyv_4vyxKh0xD6KG33HyapXkCf7FBKh4Zywj0DvWm0nOFtUKACoDWfo0n9sNsJIM9fMzoMC2zDRzZm7jyn-eXAFjLG_ZHXlM4fzfrayZXauHvkJNt0fsgSRJHMZb1MJzTUpusDCkbZUarEz7IeTkon2xFULLBOy177UQ3ZelvtyAxZGNsJYuHeoy-KH2BncRzgLT1593gbDZMrz6pfVyjF0hrlsXKdmV2CRGHHmQNKtKFEm6rNcR9osHFTZslYjiLF_D6dEvU2g4WnXxiRzVdkustAtUXZuy6Us6ozKvEJ0NdMLnW_ZDnxKJgNliOvWWGD-1cs0dbmrNPLT32FtOGfLfmRxvIrnWKrvTuVsvcb8cdwM09R-dCZqy01fmYWr6ywHxsrfGdedw2RGGD5MHuYQW9X8mcEwFreiHJWBGfP-H64p-qjrodqtVZdG4SzS44pczLe-VdiUUKmyZtM-hmoEtxgk88jdCLtRd0m6_RDPeqLttjlXPrxmO_U163gDS2p1i650IRU1Kq9feSbOcE7GLKi01sP0bQU7qja3leu7AFHTl4Ty2YXgpiytpqukOxzAY_rd5Gv5q3W4qdKY2kxRbllw0KNfCjktN806dx5JtD2A1PaX5Y2jDeY1qtghRMfipK_dIBvrqA1BQnt_NFw_-wiG44F9RnYR3Kjot57Y5WrA8DYU9cnPDaN5EWTn15Uky6ToW6ecAG4n5KE-DvkRY0T8n94-rzEmsbP16ZGlAN7U6fUW88sc4VK5eG_3eUlrMoTgDHdaN6Jp-PAuVBWnF_L4re_x9hPqHvbZOTTIJKFm6HpA1BSbVWHsJQKtUY0lFsAnhIJJBRI6ipJJb-wXp5Cf5QlglyaYRzP_pbQ_OIbi446uCn1lw84ID2S9igeEUS1SRA9FjTfZS5w4JjaxN79wdrszX2uLGcNMmRm2wxbTn38H-L4x9u4bTj101hfaeMtrXreXcGmDC04IKYCzHY5DzmvXL8T3_bHpj9v1D2On5_XnDSsH32yNjHh7lqpID2C8hhrbehBVSI3lXVy9pGY4zlH1R0D6Mb-hz2RCyRS8pOGyA7podfo6YAbTfdYpO1VD1W9onfR4H-xLJBMNYkyv3951v5iKCHd-IDqyCpfkNV7ywMMDQbjMjm7HoY_LPUku31ur3jM6pnq3pBbCW8DwZW7VRbL1BCLRe3wZweuuIMiCdIVBwjOS5mni6WyukwUU9FYhf5cpSFaTspc2icgKY_nwHRA5tVQK5JCLU7ea6xEMmfYPRwwe_HuPvSUuDpT0Yx8SyytkGCOKZU-7x1HCjH1MePlCuRrPkBFhS74qCLPCH-n4i0WA3YgQHCmP5CYA1Ry2okGavD_ZaqqrOtVJeyZatev-LJZh1ro1_wI4WU1m9hVR08oNDD1m5qRYbEgA2fNmXc9DUS1B-sBW6MDD4V2R9wU7fGLI6Chs5WiAwbFUT-wuXRcAROTj4CCWOMquKqPoWSwZ4tBxRG5YTLb8UEgUNLtlVgVTG35xmW9a3Eh-r2wbLyPakYTtqTJ4Tz7kdGIoxSQeaFAkpBaoxNP_OL2is6XJIcJIRJuSGRk6Jl9i9QC4YAZf8tIiiWbaHJOm2P4eKtbJErGn598wygEBgQCHsWXdE6BrZ3U7kquOqzJWhZgTVC_nXSmyzzwU7Kxf4gVBV33Y1j5LvF4ICa4iiS96mROQK0KFrHxsD25oomzRLZ4p7SprhsqBlWJkJUU8RT0d-MnXnktUyzxo9pHMEEOugUBbZPyjG4jcTPmKtAJze-d36Ua2JLOSNzcGLnDRiVPshk3MzCErScyrgCqCAKYHoMpU1sR0t8Whi9Y-OtUzjulNPIH1RC7AZ3OtxUjtyR53adCP7j8uBciO5x5hqeB_4-UcS9XpugJngm-eHrn3M6-IXzT99aB24XUtn-ACYP8RLfuHHuwlA-CpeuZxB-uU8s2rYLC53PoVA8EUIe2rFEvLGABn0m7_pkvDfkePcmUVz1fclU593sgF8FfIziNOZUX6kR-Oj78378Qtf7X_QGgUqR9ZduZZPGYRn77A17-55y2he2siAYZI-Sv9-0F2Gj7yyxlDh6hpQB1jZ2EE-uVGyyZUaIdRh3H_kdSBY=", + "summary": [] + }, + { + "id": "msg_055961e87f906de8006ae4432ee04c87d0ba8e04dddd9e3487", + "type": "message", + "status": "completed", + "content": [ + { + "type": "output_text", + "annotations": [ + { + "type": "url_citation", + "end_index": 167, + "start_index": 132, + "title": "Associated Press News: Breaking News, Latest Headlines and Videos | AP News", + "url": "https://apnews.com/" + } + ], + "logprobs": [], + "text": "Today (October 30, 2026) \u2014 AP's top headline: \"Binance flags 'potential security issue,' says approximately $6.3 billion impacted.\" ([apnews.com](https://apnews.com/))\n\nWould you like the same headline from Reuters, BBC, or another outlet?" + } + ], + "role": "assistant" + } + ], + "parallel_tool_calls": true, + "presence_penalty": 0.0, + "previous_response_id": null, + "prompt_cache_key": null, + "prompt_cache_retention": "in_memory", + "reasoning": { + "context": "current_turn", + "effort": "medium", + "mode": "standard", + "summary": null + }, + "safety_identifier": null, + "service_tier": "default", + "store": true, + "temperature": 1.0, + "text": { + "format": { + "type": "text" + }, + "verbosity": "medium" + }, + "tool_choice": "auto", + "tool_usage": { + "image_gen": { + "input_tokens": 0, + "input_tokens_details": { + "image_tokens": 0, + "text_tokens": 0 + }, + "output_tokens": 0, + "output_tokens_details": { + "image_tokens": 0, + "text_tokens": 0 + }, + "total_tokens": 0 + }, + "web_search": { + "num_requests": 1 + } + }, + "tools": [ + { + "type": "web_search", + "return_token_budget": "default", + "search_content_types": [ + "text" + ], + "search_context_size": "medium", + "user_location": { + "type": "approximate", + "city": null, + "country": "US", + "region": null, + "timezone": null + } + } + ], + "top_logprobs": 0, + "top_p": 1.0, + "truncation": "disabled", + "usage": { + "input_tokens": 13364, + "input_tokens_details": { + "cache_write_tokens": 0, + "cached_tokens": 0 + }, + "output_tokens": 877, + "output_tokens_details": { + "reasoning_tokens": 768 + }, + "total_tokens": 14241 + }, + "user": null, + "metadata": {} +} \ No newline at end of file diff --git a/packages/inference-discovery-openai/sessions/openai-responses/gpt-5-mini/grounding/session.json b/packages/inference-discovery-openai/sessions/openai-responses/gpt-5-mini/grounding/session.json new file mode 100644 index 000000000..a9dcc66ee --- /dev/null +++ b/packages/inference-discovery-openai/sessions/openai-responses/gpt-5-mini/grounding/session.json @@ -0,0 +1,11 @@ +{ + "schemaVersion": "2", + "source": { + "provider": "openai-responses", + "model": "gpt-5-mini", + "baseURL": "https://api.openai.com/v1" + }, + "origin": "live", + "capturedAt": "2026-10-30T07:11:44.020Z", + "capability": "grounding" +} diff --git a/packages/inference-discovery-openai/src/openai-responses.plugin.test.ts b/packages/inference-discovery-openai/src/openai-responses.plugin.test.ts index 5ee0159bf..551792f01 100644 --- a/packages/inference-discovery-openai/src/openai-responses.plugin.test.ts +++ b/packages/inference-discovery-openai/src/openai-responses.plugin.test.ts @@ -258,6 +258,74 @@ describe("buildResponsesRequestBody capability dispatch", () => { ).toBe(true); }); + test("grounding declares the web_search server tool", () => { + const body = buildResponsesRequestBody({ + model: "gpt-5-mini", + capability: "grounding", + intent: INTENTS["grounding"], + }); + expect(body).toEqual({ + model: "gpt-5-mini", + input: [ + { + type: "message", + role: "user", + content: INTENTS["grounding"].prompt, + }, + ], + tools: [{ type: "web_search" }], + }); + }); + + test("code-execution declares the code_interpreter server tool", () => { + const body = buildResponsesRequestBody({ + model: "gpt-5-mini", + capability: "code-execution", + intent: INTENTS["code-execution"], + }); + expect(body).toEqual({ + model: "gpt-5-mini", + input: [ + { + type: "message", + role: "user", + content: INTENTS["code-execution"].prompt, + }, + ], + tools: [ + { + type: "code_interpreter", + container: { type: "auto", memory_limit: "4g" }, + }, + ], + }); + }); + + test("streaming server-tool variants set stream without changing tools", () => { + const grounding = buildResponsesRequestBody({ + model: "gpt-5-mini", + capability: "grounding-streaming", + intent: INTENTS["grounding-streaming"], + }); + if (!isRecord(grounding)) throw new Error("expected record body"); + expect(grounding["stream"]).toBe(true); + expect(grounding["tools"]).toEqual([{ type: "web_search" }]); + + const execution = buildResponsesRequestBody({ + model: "gpt-5-mini", + capability: "code-execution-streaming", + intent: INTENTS["code-execution-streaming"], + }); + if (!isRecord(execution)) throw new Error("expected record body"); + expect(execution["stream"]).toBe(true); + expect(execution["tools"]).toEqual([ + { + type: "code_interpreter", + container: { type: "auto", memory_limit: "4g" }, + }, + ]); + }); + test("unsupported capabilities throw CapabilityNotBuildableError", () => { for (const capability of [ "audio-input", @@ -265,8 +333,6 @@ describe("buildResponsesRequestBody capability dispatch", () => { "structured-output", "structured-output-streaming", "image-output", - "code-execution", - "grounding", ] as const) { expect(() => buildResponsesRequestBody({ diff --git a/packages/inference-discovery-openai/src/protocol/responses-body.ts b/packages/inference-discovery-openai/src/protocol/responses-body.ts index f708a96ab..94f7aeb8b 100644 --- a/packages/inference-discovery-openai/src/protocol/responses-body.ts +++ b/packages/inference-discovery-openai/src/protocol/responses-body.ts @@ -161,6 +161,21 @@ export function buildResponsesMultiTurnTurn2Body(opts: { return body; } +function buildServerToolBody( + model: string, + intent: CapabilityIntent, + stream: boolean, + tool: unknown, +): ResponsesRequest { + const body: ResponsesRequest = { + model, + input: buildTextInput(intent), + tools: [tool], + }; + if (stream) body.stream = true; + return body; +} + function buildReasoningBody( model: string, intent: CapabilityIntent, @@ -254,6 +269,24 @@ export function buildResponsesRequestBody( return buildReasoningBody(model, intent, false); case "reasoning-content-streaming": return buildReasoningBody(model, intent, true); + case "code-execution": + return buildServerToolBody(model, intent, false, { + type: "code_interpreter", + container: { type: "auto", memory_limit: "4g" }, + }); + case "code-execution-streaming": + return buildServerToolBody(model, intent, true, { + type: "code_interpreter", + container: { type: "auto", memory_limit: "4g" }, + }); + case "grounding": + return buildServerToolBody(model, intent, false, { + type: "web_search", + }); + case "grounding-streaming": + return buildServerToolBody(model, intent, true, { + type: "web_search", + }); case "vision-input": return buildMediaInputBody( model, diff --git a/packages/inference-discovery/src/catalog/support-matrix.ts b/packages/inference-discovery/src/catalog/support-matrix.ts index 45f13e32b..ba59f2299 100644 --- a/packages/inference-discovery/src/catalog/support-matrix.ts +++ b/packages/inference-discovery/src/catalog/support-matrix.ts @@ -240,10 +240,10 @@ const OPENAI_RESPONSES_PROVIDER = "openai-responses"; // First-party OpenAI on the Responses wire (`/v1/responses`), probed by the // openai-responses plug-in. gpt-5-mini carries the full surface the Responses -// body builder builds; gpt-5.5 carries the representative streaming, -// buffered, reasoning, and tool follow-up subset. Structured output and -// URL-form file input stay out until the runtime adapter supports them and -// discovery verifies them. +// body builder builds, including the code-execution and grounding server +// tools; gpt-5.5 carries the representative streaming, buffered, reasoning, +// and tool follow-up subset. Structured output and URL-form file input stay +// out until the runtime adapter supports them and discovery verifies them. const OPENAI_RESPONSES_FULL_CAPABILITIES = [ "plain-text", "plain-text-streaming", @@ -254,6 +254,10 @@ const OPENAI_RESPONSES_FULL_CAPABILITIES = [ "reasoning-content-streaming", "vision-input", "document-input", + "code-execution", + "code-execution-streaming", + "grounding", + "grounding-streaming", ] as const satisfies readonly SupportEntry["capability"][]; const OPENAI_RESPONSES_REPRESENTATIVE_CAPABILITIES = [