cortico 0.1.0

package/src/protocol/open-responses/context-helpers.ts

@@ -0,0 +1,27 @@
+import type { ModelSpec, ToolSchema, LLMUsage } from '../../core/types.ts';
+import type { Request, Schemas } from './index.ts';
+import type { TokenMeters } from '../../core/generation.ts';
+import { inputItem, itemText, type ContextRecord } from './context.ts';
+
+export function hasRole(entry: ContextRecord, role: string): boolean {
+  return entry.item.type === 'message' && entry.item.role === role;
+}
+export function textOf(entry: ContextRecord): string { return itemText(entry.item); }
+export function withoutPastReasoning(entries: readonly ContextRecord[]): ContextRecord[] {
+  return entries.filter(entry => entry.item.type !== 'reasoning' || entry.context.head);
+}
+export function responseRequest(spec: ModelSpec, context: readonly ContextRecord[], tools: readonly ToolSchema[] = []): Request {
+  return {
+    model: spec.model, input: context.map(inputItem), tools: tools.map(tool => ({ ...tool, type: 'function' })),
+    // effort 词表归端点(见 ModelSpec.reasoningEffort);协议枚举只覆盖 OpenAI 自己的取值。
+    reasoning: spec.thinking ? { ...(spec.reasoningEffort ? { effort: spec.reasoningEffort as Schemas['ReasoningEffortEnum'] } : {}) } : { effort: 'none' },
+    ...(spec.temperature !== undefined ? { temperature: spec.temperature } : {}),
+    ...(spec.maxTokens !== undefined ? { max_output_tokens: spec.maxTokens } : {}),
+  };
+}
+
+/** Legacy numeric dashboard totals sum only known measurements; billing retains nullable meters. */
+export function usageCounters(meters: TokenMeters): LLMUsage {
+  return { promptTokens: meters.input ?? 0, completionTokens: meters.output ?? 0,
+    cacheHitTokens: meters.cachedInput ?? 0, cacheMissTokens: meters.uncachedInput ?? 0, reasoningTokens: meters.reasoning ?? undefined };
+}

package/src/protocol/open-responses/context-log.ts

@@ -0,0 +1,59 @@
+import { appendFileSync, closeSync, existsSync, fsyncSync, mkdirSync, openSync, readFileSync, renameSync, writeFileSync } from 'node:fs';
+import { dirname } from 'node:path';
+import type { ContextRecord } from './context.ts';
+
+function freeze<T>(value: T): T {
+  if (value !== null && typeof value === 'object') {
+    for (const child of Object.values(value)) freeze(child);
+    Object.freeze(value);
+  }
+  return value;
+}
+
+/** Immutable standard Items with runtime metadata stored in a separate field. */
+export class ContextLog {
+  private entries: readonly ContextRecord[] = Object.freeze([]);
+  constructor(readonly file: string, private readonly stamp?: () => string) {
+    mkdirSync(dirname(file), { recursive: true });
+  }
+
+  get records(): readonly ContextRecord[] { return this.entries; }
+
+  load(): void {
+    if (!existsSync(this.file)) { this.entries = Object.freeze([]); return; }
+    const rows = readFileSync(this.file, 'utf8').split(/\r?\n/).filter(line => line.trim()).map((line, index) => {
+      let row: ContextRecord;
+      try { row = JSON.parse(line) as ContextRecord; }
+      catch { throw new Error(`Invalid session JSON at ${this.file}:${index + 1}`); }
+      if (!row || row.version !== 2 || !row.item || typeof row.item !== 'object' || Array.isArray(row.item)
+        || !row.context || typeof row.context !== 'object' || Array.isArray(row.context))
+        throw new Error(`Invalid context record at ${this.file}:${index + 1}`);
+      return freeze(row);
+    });
+    this.entries = Object.freeze(rows);
+  }
+
+  append(entry: ContextRecord): ContextRecord {
+    const next = structuredClone(entry);
+    if (this.stamp && next.context.ts === undefined) next.context.ts = this.stamp();
+    appendFileSync(this.file, JSON.stringify(next) + '\n');
+    this.entries = Object.freeze([...this.entries, freeze(next)]);
+    return next;
+  }
+
+  reset(records: readonly ContextRecord[]): void {
+    const next = records.map(entry => freeze(structuredClone(entry)));
+    atomicContextWrite(this.file, next);
+    this.entries = Object.freeze(next);
+  }
+}
+
+function atomicContextWrite(path: string, records: readonly ContextRecord[]): void {
+  const temporary = `${path}.${process.pid}.tmp`;
+  const fd = openSync(temporary, 'w');
+  try {
+    writeFileSync(fd, records.map(row => JSON.stringify(row)).join('\n') + (records.length ? '\n' : ''));
+    fsyncSync(fd);
+  } finally { closeSync(fd); }
+  renameSync(temporary, path);
+}

package/src/protocol/open-responses/context.ts

@@ -0,0 +1,89 @@
+import type { BlobRef, FrameEventRef } from '../../core/types.ts';
+import type { InputItem, OutputItem, Response, Schemas } from './index.ts';
+
+/** Context preserves the standard input and output item shapes without flattening responses. */
+export type Item = InputItem | OutputItem;
+export interface ItemOrigin {
+  instance: string;
+  module: string;
+  model: string;
+  compatibilityDomain: string;
+}
+export interface ContextMeta {
+  ts?: string;
+  ephemeral?: true;
+  /** 合成开头的项:不写入 session,交接时不进保留内容。 */
+  head?: true;
+  frame?: { events: FrameEventRef[] };
+  blobs?: BlobRef[];
+  responseId?: string;
+  responseStatus?: string;
+  origin?: ItemOrigin;
+}
+export interface ContextRecord {
+  version: 2;
+  item: Item;
+  context: ContextMeta;
+}
+
+export function record(item: Item, context: ContextMeta = {}): ContextRecord {
+  return { version: 2, item, context };
+}
+
+export function message(role: 'system' | 'developer' | 'user' | 'assistant', text: string, context: ContextMeta = {}): ContextRecord {
+  return record({
+    type: 'message', id: `msg_${crypto.randomUUID()}`, status: 'completed', role,
+    content: role === 'assistant' ? [{ type: 'output_text', text, annotations: [] }] : [{ type: 'input_text', text }],
+  }, context);
+}
+
+export function functionCall(callId: string, name: string, args: string, context: ContextMeta = {}): ContextRecord {
+  return record({ type: 'function_call', id: `fc_${crypto.randomUUID()}`, call_id: callId, name, arguments: args, status: 'completed' }, context);
+}
+
+export function functionResult(callId: string, text: string, context: ContextMeta = {}): ContextRecord {
+  return record({ type: 'function_call_output', id: `fco_${crypto.randomUUID()}`, call_id: callId, status: 'completed', output: text }, context);
+}
+
+function partsText(content: string | readonly unknown[] | null | undefined): string {
+  if (typeof content === 'string') return content;
+  return (content ?? []).map(part => {
+    const p = part as { text?: string; refusal?: string };
+    return p.text ?? p.refusal ?? '';
+  }).join('');
+}
+
+/** Extract readable text from the Item without changing its stored shape. */
+export function itemText(item: Item): string {
+  if (item.type === 'message') return partsText(item.content);
+  if (item.type === 'function_call_output') return partsText(item.output);
+  if (item.type === 'reasoning') return partsText(item.content) || partsText(item.summary);
+  return '';
+}
+
+export function withText(entry: ContextRecord, text: string): ContextRecord {
+  const item = entry.item;
+  if (item.type === 'function_call_output') return { ...entry, item: { ...item, output: text } };
+  if (item.type !== 'message') throw new Error(`Cannot replace text on ${item.type}`);
+  return { ...entry, item: { ...item, content: text } as InputItem };
+}
+
+export function responseRecords(response: Response, origin: ItemOrigin, context: ContextMeta = {}): ContextRecord[] {
+  return response.output.map(item => record(structuredClone(item), {
+    ...context, responseId: response.id, responseStatus: response.status, origin,
+  }));
+}
+
+/** Build a standard request Item; provider context records retain output reasoning content. */
+export function inputItem(entry: ContextRecord): InputItem {
+  const item = entry.item;
+  if (item.type === 'reasoning') {
+    const reasoning: Schemas['ReasoningItemParam'] = {
+      type: 'reasoning', summary: item.summary.filter(part => part.type === 'summary_text') as Schemas['ReasoningSummaryContentParam'][],
+    };
+    if (item.id) reasoning.id = item.id;
+    if (item.encrypted_content) reasoning.encrypted_content = item.encrypted_content;
+    return reasoning;
+  }
+  return structuredClone(item) as InputItem;
+}

package/src/protocol/open-responses/generated.ts

@@ -0,0 +1,115 @@
+// Generated by scripts/generate-open-responses.ts. Source: Open Responses (Apache-2.0).
+export const OPEN_RESPONSES_VERSION = "2026-04-24";
+export const OPEN_RESPONSES_SCHEMA_SHA256 = "d598753c3a86fd8a2434828fe39dcc8786a7a694bbe46080a0d24c9fa40e72df";
+export interface Schemas {
+  "ItemReferenceParam": { "type"?: ("item_reference" | null); "id": string; };
+  "ReasoningSummaryContentParam": { "type": "summary_text"; "text": string; };
+  "ReasoningItemParam": { "id"?: (string | null); "type": "reasoning"; "summary": Array<Schemas["ReasoningSummaryContentParam"]>; "content"?: (null); "encrypted_content"?: (string | null); };
+  "CompactionSummaryItemParam": { "id"?: (string | null); "type": "compaction"; "encrypted_content": string; };
+  "InputTextContentParam": { "type": "input_text"; "text": string; };
+  "DetailEnum": "low" | "high" | "auto";
+  "InputImageContentParamAutoParam": { "type": "input_image"; "image_url"?: (string | null); "detail"?: ((Schemas["ImageDetail"] & unknown) | null); };
+  "InputFileContentParam": { "type": "input_file"; "filename"?: (string | null); "file_data"?: (string | null); "file_url"?: (string | null); };
+  "UserMessageItemParam": { "id"?: (string | null); "type": "message"; "role": "user"; "content": (Array<(Schemas["InputTextContentParam"] | Schemas["InputImageContentParamAutoParam"] | Schemas["InputFileContentParam"])> | string); "status"?: (string | null); };
+  "SystemMessageItemParam": { "id"?: (string | null); "type": "message"; "role": "system"; "content": (Array<(Schemas["InputTextContentParam"])> | string); "status"?: (string | null); };
+  "DeveloperMessageItemParam": { "id"?: (string | null); "type": "message"; "role": "developer"; "content": (Array<(Schemas["InputTextContentParam"])> | string); "status"?: (string | null); };
+  "UrlCitationParam": { "type": "url_citation"; "start_index": number; "end_index": number; "url": string; "title": string; };
+  "OutputTextContentParam": { "type": "output_text"; "text": string; "annotations"?: (Array<Schemas["UrlCitationParam"]>); };
+  "RefusalContentParam": { "type": "refusal"; "refusal": string; };
+  "AssistantMessageItemParam": { "id"?: (string | null); "type": "message"; "role": "assistant"; "content": (Array<(Schemas["OutputTextContentParam"] | Schemas["RefusalContentParam"])> | string); "phase"?: "commentary" | "final_answer"; "status"?: (string | null); };
+  "FunctionCallItemStatus": "in_progress" | "completed" | "incomplete";
+  "FunctionCallItemParam": { "id"?: (string | null); "call_id": string; "type": "function_call"; "name": string; "arguments": string; "status"?: ((Schemas["FunctionCallStatus"] & unknown) | null); };
+  "FunctionCallOutputItemParam": { "id"?: (string | null); "call_id": string; "type": "function_call_output"; "output": (string | Array<(Schemas["InputTextContentParam"] | Schemas["InputImageContentParamAutoParam"] | Schemas["InputFileContentParam"] | Schemas["InputVideoContent"])>); "status"?: ((Schemas["FunctionCallStatus"] & unknown) | null); };
+  "ItemParam": (Schemas["ItemReferenceParam"] | Schemas["ReasoningItemParam"] | Schemas["CompactionSummaryItemParam"] | Schemas["UserMessageItemParam"] | Schemas["SystemMessageItemParam"] | Schemas["DeveloperMessageItemParam"] | Schemas["AssistantMessageItemParam"] | Schemas["FunctionCallItemParam"] | Schemas["FunctionCallOutputItemParam"]);
+  "IncludeEnum": "reasoning.encrypted_content" | "message.output_text.logprobs";
+  "EmptyModelParam": Record<string, unknown>;
+  "FunctionToolParam": { "name": string; "description"?: (string | null); "parameters"?: (Schemas["EmptyModelParam"] | null); "strict"?: boolean; "type": "function"; };
+  "ResponsesToolParam": (Schemas["FunctionToolParam"]);
+  "SpecificFunctionParam": { "type": "function"; "name": string; };
+  "SpecificToolChoiceParam": (Schemas["SpecificFunctionParam"]);
+  "ToolChoiceValueEnum": "none" | "auto" | "required";
+  "AllowedToolsParam": { "type": "allowed_tools"; "tools": Array<Schemas["SpecificToolChoiceParam"]>; "mode"?: (Schemas["ToolChoiceValueEnum"] & unknown); };
+  "ToolChoiceParam": (Schemas["SpecificToolChoiceParam"] | Schemas["ToolChoiceValueEnum"] | Schemas["AllowedToolsParam"]);
+  "MetadataParam": { [key: string]: string; };
+  "VerbosityEnum": "low" | "medium" | "high";
+  "TextParam": { "format"?: (Schemas["TextFormatParam"] | null); "verbosity"?: (Schemas["VerbosityEnum"] & unknown); };
+  "StreamOptionsParam": { "include_obfuscation"?: boolean; };
+  "ReasoningEffortEnum": "none" | "low" | "medium" | "high" | "xhigh";
+  "ReasoningSummaryEnum": "concise" | "detailed" | "auto";
+  "ReasoningParam": { "effort"?: ((Schemas["ReasoningEffortEnum"]) | null); "summary"?: ((Schemas["ReasoningSummaryEnum"] & unknown) | null); };
+  "TruncationEnum": "auto" | "disabled";
+  "ServiceTierEnum": "auto" | "default" | "flex" | "priority";
+  "CreateResponseBody": { "model"?: (string | null); "input"?: ((string | Array<Schemas["ItemParam"]>) | null); "previous_response_id"?: (string | null); "include"?: Array<Schemas["IncludeEnum"]>; "tools"?: (Array<Schemas["ResponsesToolParam"]> | null); "tool_choice"?: ((Schemas["ToolChoiceParam"] & unknown) | null); "metadata"?: ((Schemas["MetadataParam"] & unknown) | null); "text"?: ((Schemas["TextParam"] & unknown) | null); "temperature"?: (number | null); "top_p"?: (number | null); "presence_penalty"?: (number | null); "frequency_penalty"?: (number | null); "parallel_tool_calls"?: (boolean | null); "stream"?: boolean; "stream_options"?: ((Schemas["StreamOptionsParam"] & unknown) | null); "background"?: boolean; "max_output_tokens"?: (number | null); "max_tool_calls"?: (number | null); "reasoning"?: ((Schemas["ReasoningParam"] & unknown) | null); "safety_identifier"?: (string | null); "prompt_cache_key"?: (string | null); "truncation"?: (Schemas["TruncationEnum"] & unknown); "instructions"?: (string | null); "store"?: boolean; "service_tier"?: (Schemas["ServiceTierEnum"] & unknown); "top_logprobs"?: (number | null); };
+  "WebSocketResponseCreateEvent": ({ "type": "response.create"; "stream"?: string; "stream_options"?: string; "background"?: string; } & Schemas["CreateResponseBody"]);
+  "WebSocketErrorEvent": { "type": "error"; "status": number; "error": { "type"?: string; "code": string; "message": string; "param"?: (string | null); [key: string]: unknown; }; };
+  "IncompleteDetails": { "reason": string; };
+  "MessageRole": "user" | "assistant" | "system" | "developer";
+  "InputTextContent": { "type": "input_text"; "text": string; };
+  "UrlCitationBody": { "type": "url_citation"; "url": string; "start_index": number; "end_index": number; "title": string; };
+  "Annotation": (Schemas["UrlCitationBody"]);
+  "TopLogProb": { "token": string; "logprob": number; "bytes": Array<number>; };
+  "LogProb": { "token": string; "logprob": number; "bytes": Array<number>; "top_logprobs": Array<Schemas["TopLogProb"]>; };
+  "OutputTextContent": { "type": "output_text"; "text": string; "annotations": Array<Schemas["Annotation"]>; "logprobs"?: Array<Schemas["LogProb"]>; };
+  "TextContent": { "type": "text"; "text": string; };
+  "SummaryTextContent": { "type": "summary_text"; "text": string; };
+  "ReasoningTextContent": { "type": "reasoning_text"; "text": string; };
+  "RefusalContent": { "type": "refusal"; "refusal": string; };
+  "ImageDetail": "low" | "high" | "auto";
+  "InputImageContent": { "type": "input_image"; "image_url": (string | null); "detail": (Schemas["ImageDetail"] & unknown); };
+  "InputFileContent": { "type": "input_file"; "filename"?: string; "file_url"?: string; };
+  "MessageStatus": "in_progress" | "completed" | "incomplete";
+  "Message": { "type": "message"; "id": string; "status": (Schemas["MessageStatus"] & unknown); "role": (Schemas["MessageRole"] & unknown); "content": Array<(Schemas["InputTextContent"] | Schemas["OutputTextContent"] | Schemas["TextContent"] | Schemas["SummaryTextContent"] | Schemas["ReasoningTextContent"] | Schemas["RefusalContent"] | Schemas["InputImageContent"] | Schemas["InputFileContent"] | Schemas["InputVideoContent"])>; "phase"?: "commentary" | "final_answer"; };
+  "FunctionCallStatus": "in_progress" | "completed" | "incomplete";
+  "FunctionCall": { "type": "function_call"; "id": string; "call_id": string; "name": string; "arguments": string; "status": (Schemas["FunctionCallStatus"] & unknown); };
+  "FunctionCallOutputStatusEnum": "in_progress" | "completed" | "incomplete";
+  "FunctionCallOutput": { "type": "function_call_output"; "id": string; "call_id": string; "output": (string | Array<(Schemas["InputTextContent"] | Schemas["InputImageContent"] | Schemas["InputFileContent"])>); "status": (Schemas["FunctionCallOutputStatusEnum"] & unknown); };
+  "ReasoningBody": { "type": "reasoning"; "id": string; "content"?: Array<(Schemas["InputTextContent"] | Schemas["OutputTextContent"] | Schemas["TextContent"] | Schemas["SummaryTextContent"] | Schemas["ReasoningTextContent"] | Schemas["RefusalContent"] | Schemas["InputImageContent"] | Schemas["InputFileContent"])>; "summary": Array<(Schemas["InputTextContent"] | Schemas["OutputTextContent"] | Schemas["TextContent"] | Schemas["SummaryTextContent"] | Schemas["ReasoningTextContent"] | Schemas["RefusalContent"] | Schemas["InputImageContent"] | Schemas["InputFileContent"])>; "encrypted_content"?: string; };
+  "CompactionBody": { "type": "compaction"; "id": string; "encrypted_content": string; "created_by"?: string; };
+  "ItemField": (Schemas["Message"] | Schemas["FunctionCall"] | Schemas["FunctionCallOutput"] | Schemas["ReasoningBody"] | Schemas["CompactionBody"]);
+  "Error": { "code": string; "message": string; };
+  "FunctionTool": { "type": "function"; "name": string; "description": (string | null); "parameters": ({ [key: string]: unknown; } | null); "strict": (boolean | null); };
+  "Tool": (Schemas["FunctionTool"]);
+  "FunctionToolChoice": { "type": "function"; "name"?: string; };
+  "AllowedToolChoice": { "type": "allowed_tools"; "tools": Array<(Schemas["FunctionToolChoice"])>; "mode": Schemas["ToolChoiceValueEnum"]; };
+  "TextResponseFormat": { "type": "text"; };
+  "JsonObjectResponseFormat": { "type": "json_object"; };
+  "JsonSchemaResponseFormat": { "type": "json_schema"; "name": string; "description": (string | null); "schema": (null); "strict": boolean; };
+  "TextField": { "format": (Schemas["TextResponseFormat"] | Schemas["JsonObjectResponseFormat"] | Schemas["JsonSchemaResponseFormat"]); "verbosity"?: Schemas["VerbosityEnum"]; };
+  "Reasoning": { "effort": ((Schemas["ReasoningEffortEnum"]) | null); "summary": ((Schemas["ReasoningSummaryEnum"] & unknown) | null); };
+  "InputTokensDetails": { "cached_tokens": number; };
+  "OutputTokensDetails": { "reasoning_tokens": number; };
+  "Usage": { "input_tokens": number; "output_tokens": number; "total_tokens": number; "input_tokens_details": (Schemas["InputTokensDetails"] & unknown); "output_tokens_details": (Schemas["OutputTokensDetails"] & unknown); };
+  "ResponseResource": { "id": string; "object": "response"; "created_at": number; "completed_at": (number | null); "status": string; "incomplete_details": ((Schemas["IncompleteDetails"] & unknown) | null); "model": string; "previous_response_id": (string | null); "instructions": ((string) | null); "output": Array<Schemas["ItemField"]>; "error": ((Schemas["Error"] & unknown) | null); "tools": Array<Schemas["Tool"]>; "tool_choice": (Schemas["FunctionToolChoice"] | Schemas["ToolChoiceValueEnum"] | Schemas["AllowedToolChoice"]); "truncation": (Schemas["TruncationEnum"] & unknown); "parallel_tool_calls": boolean; "text": (Schemas["TextField"] & unknown); "top_p": number; "presence_penalty": number; "frequency_penalty": number; "top_logprobs": number; "temperature": number; "reasoning": ((Schemas["Reasoning"] & unknown) | null); "usage": ((Schemas["Usage"] & unknown) | null); "max_output_tokens": (number | null); "max_tool_calls": (number | null); "store": boolean; "background": boolean; "service_tier": string; "metadata": unknown; "safety_identifier": (string | null); "prompt_cache_key": (string | null); };
+  "ResponseCreatedStreamingEvent": { "type": "response.created"; "sequence_number": number; "response": (Schemas["ResponseResource"] & unknown); };
+  "ResponseQueuedStreamingEvent": { "type": "response.queued"; "sequence_number": number; "response": (Schemas["ResponseResource"] & unknown); };
+  "ResponseInProgressStreamingEvent": { "type": "response.in_progress"; "sequence_number": number; "response": (Schemas["ResponseResource"] & unknown); };
+  "ResponseCompletedStreamingEvent": { "type": "response.completed"; "sequence_number": number; "response": (Schemas["ResponseResource"] & unknown); };
+  "ResponseFailedStreamingEvent": { "type": "response.failed"; "sequence_number": number; "response": (Schemas["ResponseResource"] & unknown); };
+  "ResponseIncompleteStreamingEvent": { "type": "response.incomplete"; "sequence_number": number; "response": (Schemas["ResponseResource"] & unknown); };
+  "ResponseOutputItemAddedStreamingEvent": { "type": "response.output_item.added"; "sequence_number": number; "output_index": number; "item": ((Schemas["ItemField"] & unknown) | null); };
+  "ResponseOutputItemDoneStreamingEvent": { "type": "response.output_item.done"; "sequence_number": number; "output_index": number; "item": ((Schemas["ItemField"] & unknown) | null); };
+  "ResponseReasoningSummaryPartAddedStreamingEvent": { "type": "response.reasoning_summary_part.added"; "sequence_number": number; "item_id": string; "output_index": number; "summary_index": number; "part": (Schemas["InputTextContent"] | Schemas["OutputTextContent"] | Schemas["TextContent"] | Schemas["SummaryTextContent"] | Schemas["ReasoningTextContent"] | Schemas["RefusalContent"] | Schemas["InputImageContent"] | Schemas["InputFileContent"]); };
+  "ResponseReasoningSummaryPartDoneStreamingEvent": { "type": "response.reasoning_summary_part.done"; "sequence_number": number; "item_id": string; "output_index": number; "summary_index": number; "part": (Schemas["InputTextContent"] | Schemas["OutputTextContent"] | Schemas["TextContent"] | Schemas["SummaryTextContent"] | Schemas["ReasoningTextContent"] | Schemas["RefusalContent"] | Schemas["InputImageContent"] | Schemas["InputFileContent"]); };
+  "ResponseContentPartAddedStreamingEvent": { "type": "response.content_part.added"; "sequence_number": number; "item_id": string; "output_index": number; "content_index": number; "part": (Schemas["InputTextContent"] | Schemas["OutputTextContent"] | Schemas["TextContent"] | Schemas["SummaryTextContent"] | Schemas["ReasoningTextContent"] | Schemas["RefusalContent"] | Schemas["InputImageContent"] | Schemas["InputFileContent"]); };
+  "ResponseContentPartDoneStreamingEvent": { "type": "response.content_part.done"; "sequence_number": number; "item_id": string; "output_index": number; "content_index": number; "part": (Schemas["InputTextContent"] | Schemas["OutputTextContent"] | Schemas["TextContent"] | Schemas["SummaryTextContent"] | Schemas["ReasoningTextContent"] | Schemas["RefusalContent"] | Schemas["InputImageContent"] | Schemas["InputFileContent"]); };
+  "ResponseOutputTextDeltaStreamingEvent": { "type": "response.output_text.delta"; "sequence_number": number; "item_id": string; "output_index": number; "content_index": number; "delta": string; "logprobs"?: Array<Schemas["LogProb"]>; "obfuscation"?: string; };
+  "ResponseOutputTextDoneStreamingEvent": { "type": "response.output_text.done"; "sequence_number": number; "item_id": string; "output_index": number; "content_index": number; "text": string; "logprobs"?: Array<Schemas["LogProb"]>; };
+  "ResponseRefusalDeltaStreamingEvent": { "type": "response.refusal.delta"; "sequence_number": number; "item_id": string; "output_index": number; "content_index": number; "delta": string; };
+  "ResponseRefusalDoneStreamingEvent": { "type": "response.refusal.done"; "sequence_number": number; "item_id": string; "output_index": number; "content_index": number; "refusal": string; };
+  "ResponseReasoningDeltaStreamingEvent": { "type": "response.reasoning.delta"; "sequence_number": number; "item_id": string; "output_index": number; "content_index": number; "delta": string; "obfuscation"?: string; };
+  "ResponseReasoningDoneStreamingEvent": { "type": "response.reasoning.done"; "sequence_number": number; "item_id": string; "output_index": number; "content_index": number; "text": string; };
+  "ResponseReasoningSummaryDeltaStreamingEvent": { "type": "response.reasoning_summary_text.delta"; "sequence_number": number; "item_id": string; "output_index": number; "summary_index": number; "delta": string; "obfuscation"?: string; };
+  "ResponseReasoningSummaryDoneStreamingEvent": { "type": "response.reasoning_summary_text.done"; "sequence_number": number; "item_id": string; "output_index": number; "summary_index": number; "text": string; };
+  "ResponseOutputTextAnnotationAddedStreamingEvent": { "type": "response.output_text.annotation.added"; "sequence_number": number; "item_id": string; "output_index": number; "content_index": number; "annotation_index": number; "annotation": ((Schemas["Annotation"] & unknown) | null); };
+  "ResponseFunctionCallArgumentsDeltaStreamingEvent": { "type": "response.function_call_arguments.delta"; "sequence_number": number; "item_id": string; "output_index": number; "delta": string; "obfuscation"?: string; };
+  "ResponseFunctionCallArgumentsDoneStreamingEvent": { "type": "response.function_call_arguments.done"; "sequence_number": number; "item_id": string; "output_index": number; "arguments": string; };
+  "ErrorPayload": { "type": string; "code": (string | null); "message": string; "param": (string | null); "headers"?: { [key: string]: string; }; };
+  "ErrorStreamingEvent": { "type": "error"; "sequence_number": number; "error": (Schemas["ErrorPayload"] & unknown); };
+  "CompactResponseMethodPublicBody": { "model": string; "input"?: ((string | Array<Schemas["ItemParam"]>) | null); "previous_response_id"?: (string | null); "instructions"?: (string | null); "prompt_cache_key"?: (string | null); };
+  "CompactResource": { "id": string; "object": "response.compaction"; "output": Array<Schemas["ItemField"]>; "created_at": number; "usage": (Schemas["Usage"] & unknown); };
+  "InputVideoContent": { "type": "input_video"; "video_url": string; };
+  "JsonSchemaResponseFormatParam": { "type"?: "json_schema"; "description"?: string; "name"?: string; "schema"?: { [key: string]: unknown; }; "strict"?: (boolean | null); };
+  "TextFormatParam": (Schemas["TextResponseFormat"] | Schemas["JsonSchemaResponseFormatParam"]);
+}
+export type StreamEvent = Schemas["ResponseCreatedStreamingEvent"] | Schemas["ResponseQueuedStreamingEvent"] | Schemas["ResponseInProgressStreamingEvent"] | Schemas["ResponseCompletedStreamingEvent"] | Schemas["ResponseFailedStreamingEvent"] | Schemas["ResponseIncompleteStreamingEvent"] | Schemas["ResponseOutputItemAddedStreamingEvent"] | Schemas["ResponseOutputItemDoneStreamingEvent"] | Schemas["ResponseReasoningSummaryPartAddedStreamingEvent"] | Schemas["ResponseReasoningSummaryPartDoneStreamingEvent"] | Schemas["ResponseContentPartAddedStreamingEvent"] | Schemas["ResponseContentPartDoneStreamingEvent"] | Schemas["ResponseOutputTextDeltaStreamingEvent"] | Schemas["ResponseOutputTextDoneStreamingEvent"] | Schemas["ResponseRefusalDeltaStreamingEvent"] | Schemas["ResponseRefusalDoneStreamingEvent"] | Schemas["ResponseReasoningDeltaStreamingEvent"] | Schemas["ResponseReasoningDoneStreamingEvent"] | Schemas["ResponseReasoningSummaryDeltaStreamingEvent"] | Schemas["ResponseReasoningSummaryDoneStreamingEvent"] | Schemas["ResponseOutputTextAnnotationAddedStreamingEvent"] | Schemas["ResponseFunctionCallArgumentsDeltaStreamingEvent"] | Schemas["ResponseFunctionCallArgumentsDoneStreamingEvent"] | Schemas["ErrorStreamingEvent"];
+export const STREAM_EVENT_TYPES: ReadonlySet<string> = new Set(["response.created","response.queued","response.in_progress","response.completed","response.failed","response.incomplete","response.output_item.added","response.output_item.done","response.reasoning_summary_part.added","response.reasoning_summary_part.done","response.content_part.added","response.content_part.done","response.output_text.delta","response.output_text.done","response.refusal.delta","response.refusal.done","response.reasoning.delta","response.reasoning.done","response.reasoning_summary_text.delta","response.reasoning_summary_text.done","response.output_text.annotation.added","response.function_call_arguments.delta","response.function_call_arguments.done","error"]);

package/src/protocol/open-responses/index.ts

@@ -0,0 +1,33 @@
+import type { Schemas } from './generated.ts';
+export { OPEN_RESPONSES_VERSION, OPEN_RESPONSES_SCHEMA_SHA256 } from './generated.ts';
+export type { Schemas, StreamEvent } from './generated.ts';
+
+export type Response = Schemas['ResponseResource'];
+export type Request = Schemas['CreateResponseBody'];
+export type InputItem = Schemas['ItemParam'];
+export type OutputItem = Schemas['ItemField'];
+export type Usage = Schemas['Usage'];
+export type FunctionCall = Schemas['FunctionCall'];
+
+/** Initial response fields for adapters whose native API has no response resource. */
+export function createResponse(id: string, request: Request, now = Date.now()): Response {
+  return {
+    id, object: 'response', created_at: Math.floor(now / 1000), completed_at: null,
+    status: 'in_progress', incomplete_details: null, model: request.model ?? '',
+    previous_response_id: request.previous_response_id ?? null,
+    instructions: request.instructions ?? null, output: [], error: null,
+    tools: (request.tools ?? []) as Response['tools'],
+    tool_choice: (request.tool_choice ?? 'auto') as Response['tool_choice'],
+    truncation: request.truncation ?? 'disabled', parallel_tool_calls: request.parallel_tool_calls ?? false,
+    text: (request.text ?? { format: { type: 'text' } }) as Response['text'],
+    top_p: request.top_p ?? 1, presence_penalty: request.presence_penalty ?? 0,
+    frequency_penalty: request.frequency_penalty ?? 0, top_logprobs: request.top_logprobs ?? 0,
+    temperature: request.temperature ?? 1,
+    reasoning: request.reasoning ? { effort: request.reasoning.effort ?? null, summary: request.reasoning.summary ?? null } : null,
+    usage: null,
+    max_output_tokens: request.max_output_tokens ?? null, max_tool_calls: request.max_tool_calls ?? null,
+    store: request.store ?? false, background: request.background ?? false,
+    service_tier: request.service_tier ?? 'default', metadata: request.metadata ?? null,
+    safety_identifier: request.safety_identifier ?? null, prompt_cache_key: request.prompt_cache_key ?? null,
+  };
+}