offrouter-core 0.2.1 → 0.2.2

package/src/proxy/responses-mapper.ts

@@ -1,736 +0,0 @@
-/**
- * OpenAI Responses <-> OffRouter translation for the local proxy.
- *
- * Inbound: turn an OpenAI Responses request body into a RouteRequest that
- * carries only a redacted prompt preview and digest (never raw prompt text)
- * plus a DelegationRequest that carries the full prompt after policy allows.
- *
- * Outbound: turn OffRouter delegation/provider events into OpenAI Responses
- * streaming SSE chunks (response.created, response.output_text.delta,
- * response.completed) and map provider/policy errors to HTTP statuses and
- * OpenAI-style error JSON.
- *
- * Keeps HTTP and provider specifics out of the core router.
- */
-import { createHash, randomBytes } from "node:crypto";
-import {
-  DelegationRuntime,
-  type DelegationRuntimeOptions,
-} from "../delegation.js";
-import { ROUTE_PROTOCOL_VERSION } from "../protocol.js";
-import { z } from "zod";
-import type { PolicyConfig } from "../policy.js";
-import type { ProviderAdapter } from "../providers/adapter.js";
-import type { ProviderErrorCode } from "../providers/adapter.js";
-import type {
-  HarnessRef,
-  ProviderCandidate,
-  RouteDecision,
-  RouteRequest,
-  WorkspaceRef,
-} from "../types.js";
-import type {
-  DelegationMode,
-  DelegationOutput,
-  DelegationRequest,
-} from "../delegation.js";
-
-/** Max chars kept for the routing-only prompt preview. */
-export const RESPONSES_PROMPT_PREVIEW_CHARS = 120;
-
-// ---------------------------------------------------------------------------
-// Inbound parsing
-// ---------------------------------------------------------------------------
-
-export interface ParsedResponsesInput {
-  /** Full prompt text for delegation only (never used for routing). */
-  prompt: string;
-  /** Requested model id; informational, routing overrides it. */
-  model?: string;
-  maxOutputTokens?: number;
-  temperature?: number;
-  stream?: boolean;
-}
-
-// ---------------------------------------------------------------------------
-// Inbound request schemas (Zod, strict at the top level)
-// ---------------------------------------------------------------------------
-
-/**
- * Thrown when an inbound request body fails schema validation. The proxy maps
- * this to a 400 OpenAI-style error response.
- */
-export class InvalidProxyRequestError extends Error {
-  readonly issues: readonly z.ZodIssue[];
-  constructor(issues: readonly z.ZodIssue[]) {
-    super("Invalid request body.");
-    this.name = "InvalidProxyRequestError";
-    this.issues = issues;
-  }
-}
-
-// Nested input item content parts use the default (strip) mode so OpenAI part
-// extras such as "annotations" do not break prompt extraction; only the
-// top-level request object is parsed strictly.
-const ResponsesContentPartSchema = z.object({
-  type: z.string().optional(),
-  text: z.string().optional(),
-  input_text: z.string().optional(),
-  output_text: z.string().optional(),
-});
-
-const ResponsesInputItemSchema = z.object({
-  role: z.string().optional(),
-  content: z
-    .union([
-      z.string(),
-      z.array(z.union([z.string(), ResponsesContentPartSchema])),
-    ])
-    .optional(),
-});
-
-/**
- * Strict Zod schema for an OpenAI Responses inbound request body. Unknown
- * top-level keys are rejected so malformed requests surface as a 400 rather
- * than silently ignoring fields.
- */
-export const ResponsesRequestSchema = z.object({
-  model: z.string().optional(),
-  instructions: z.string().optional(),
-  input: z
-    .union([
-      z.string(),
-      z.array(z.union([z.string(), ResponsesInputItemSchema])),
-    ])
-    .optional(),
-  stream: z.boolean().optional(),
-  max_output_tokens: z.number().nonnegative().optional(),
-  temperature: z.number().optional(),
-});
-// Unknown top-level keys (tools, store, metadata, ...) are stripped, not rejected,
-// so real OpenAI-compatible clients interoperate. Structurally invalid values still 400.
-
-/**
- * Extract prompt text and tuning options from an OpenAI Responses request body.
- * Validates the body and throws {@link InvalidProxyRequestError} on any
- * schema violation. Accepts both string and structured `input` shapes.
- */
-export function extractPromptFromResponsesInput(
-  body: unknown,
-): ParsedResponsesInput {
-  const result = ResponsesRequestSchema.safeParse(body);
-  if (!result.success) {
-    throw new InvalidProxyRequestError(result.error.issues);
-  }
-  const data = result.data;
-  return {
-    prompt: joinPromptText(data.instructions, data.input),
-    model: data.model,
-    maxOutputTokens: data.max_output_tokens,
-    temperature: data.temperature,
-    stream: data.stream,
-  };
-}
-
-function joinPromptText(instructions: unknown, input: unknown): string {
-  const parts: string[] = [];
-  if (typeof instructions === "string" && instructions.length > 0) {
-    parts.push(instructions);
-  }
-  if (typeof input === "string") {
-    if (input.length > 0) parts.push(input);
-  } else if (Array.isArray(input)) {
-    for (const item of input) {
-      const text = textFromInputItem(item);
-      if (text) parts.push(text);
-    }
-  }
-  return parts.join("\n\n").trim();
-}
-
-function textFromInputItem(item: unknown): string | undefined {
-  if (typeof item === "string") {
-    return item.length > 0 ? item : undefined;
-  }
-  if (!item || typeof item !== "object") return undefined;
-  const obj = item as Record<string, unknown>;
-  const content = obj["content"];
-  if (typeof content === "string") {
-    return content.length > 0 ? content : undefined;
-  }
-  if (Array.isArray(content)) {
-    const out: string[] = [];
-    for (const part of content) {
-      if (typeof part === "string") {
-        if (part.length > 0) out.push(part);
-        continue;
-      }
-      if (part && typeof part === "object") {
-        const p = part as Record<string, unknown>;
-        const text = p["text"] ?? p["input_text"] ?? p["output_text"];
-        if (typeof text === "string" && text.length > 0) out.push(text);
-      }
-    }
-    return out.length > 0 ? out.join("") : undefined;
-  }
-  return undefined;
-}
-
-// ---------------------------------------------------------------------------
-// Digest + preview (routing never sees raw prompt text)
-// ---------------------------------------------------------------------------
-
-/** Stable sha256 digest of the full prompt text. */
-export function promptDigest(text: string): string {
-  return `sha256:${createHash("sha256").update(text, "utf8").digest("hex")}`;
-}
-
-/** Short single-line preview; collapses whitespace and truncates. */
-export function promptPreview(
-  text: string,
-  max: number = RESPONSES_PROMPT_PREVIEW_CHARS,
-): string {
-  const clean = text.replace(/\s+/g, " ").trim();
-  if (clean.length <= max) return clean;
-  // ASCII ellipsis (three dots) keeps the preview ASCII-only; reserve three
-  // characters for the marker so the result never exceeds `max`.
-  return `${clean.slice(0, Math.max(0, max - 3))}...`;
-}
-
-// ---------------------------------------------------------------------------
-// Build RouteRequest (digest/preview only) and DelegationRequest (full prompt)
-// ---------------------------------------------------------------------------
-
-export interface BuildRouteInput {
-  prompt: string;
-  harness: HarnessRef;
-  workspace: WorkspaceRef;
-  requestId?: string;
-  kind?: RouteRequest["task"]["kind"];
-  risk?: RouteRequest["task"]["risk"];
-}
-
-/**
- * Build a RouteRequest from the full prompt. The raw prompt is reduced to a
- * redacted preview and digest; the full text never appears on the route.
- */
-export function buildRouteRequest(input: BuildRouteInput): RouteRequest {
-  return {
-    protocolVersion: ROUTE_PROTOCOL_VERSION,
-    requestId: input.requestId ?? `req_proxy_${randomBytes(8).toString("hex")}`,
-    harness: input.harness,
-    task: {
-      promptPreview: promptPreview(input.prompt),
-      promptDigest: promptDigest(input.prompt),
-      kind: input.kind ?? "other",
-      risk: input.risk ?? "low",
-      requiresStreaming: true,
-    },
-    workspace: input.workspace,
-    constraints: {
-      subscriptionFirst: true,
-      allowApiKeyFallback: true,
-    },
-  };
-}
-
-export interface BuildDelegationInput {
-  prompt: string;
-  route: RouteRequest;
-  taskId?: string;
-  maxOutputTokens?: number;
-  temperature?: number;
-}
-
-/**
- * Build a DelegationRequest carrying the full prompt. Routing has already
- * cleared the selected provider; the full text reaches the adapter only here.
- */
-export function buildDelegationRequest(
-  input: BuildDelegationInput,
-): DelegationRequest {
-  return {
-    taskId: input.taskId ?? `task_proxy_${randomBytes(8).toString("hex")}`,
-    mode: "stream" as DelegationMode,
-    output: "text" as DelegationOutput,
-    prompt: input.prompt,
-    route: input.route,
-    maxOutputTokens: input.maxOutputTokens,
-    temperature: input.temperature,
-  };
-}
-
-// ---------------------------------------------------------------------------
-// Outbound SSE mapping
-// ---------------------------------------------------------------------------
-
-export interface ResponsesOutputTextPart {
-  type: "output_text";
-  text: string;
-  annotations: unknown[];
-}
-
-export interface ResponsesMessageItem {
-  id: string;
-  type: "message";
-  status: "completed";
-  role: "assistant";
-  content: ResponsesOutputTextPart[];
-}
-
-export interface ResponsesObject {
-  id: string;
-  object: "response";
-  created_at: number;
-  status: "in_progress" | "completed" | "failed";
-  model: string;
-  output: ResponsesMessageItem[];
-  output_text?: string;
-  usage?: { input_tokens: number; output_tokens: number; total_tokens: number };
-}
-
-export interface ResponsesUsageInput {
-  inputTokens?: number;
-  outputTokens?: number;
-  totalTokens?: number;
-}
-
-function newPrefixId(prefix: string): string {
-  return `${prefix}_${randomBytes(12).toString("hex")}`;
-}
-
-/**
- * Stateful builder that accumulates output text and produces the three
- * OpenAI Responses SSE event payloads the proxy emits.
- */
-export class ResponsesSseBuilder {
-  readonly responseId: string;
-  readonly messageId: string;
-  readonly createdAtMs: number;
-  private readonly now: () => Date;
-  private model: string;
-  private text = "";
-  private usage: ResponsesUsageInput | undefined;
-
-  constructor(model: string, now: () => Date = () => new Date()) {
-    this.model = model;
-    this.now = now;
-    this.responseId = newPrefixId("resp");
-    this.messageId = newPrefixId("msg");
-    this.createdAtMs = Math.floor(now().getTime() / 1000);
-  }
-
-  setModel(model: string): void {
-    this.model = model;
-  }
-
-  addText(delta: string): void {
-    this.text += delta;
-  }
-
-  setUsage(usage: ResponsesUsageInput): void {
-    this.usage = usage;
-  }
-
-  get fullText(): string {
-    return this.text;
-  }
-
-  createdEvent(): {
-    type: "response.created";
-    response: ResponsesObject;
-  } {
-    return {
-      type: "response.created",
-      response: this.baseObject("in_progress", []),
-    };
-  }
-
-  deltaEvent(delta: string): {
-    type: "response.output_text.delta";
-    item_id: string;
-    output_index: number;
-    content_index: number;
-    delta: string;
-  } {
-    return {
-      type: "response.output_text.delta",
-      item_id: this.messageId,
-      output_index: 0,
-      content_index: 0,
-      delta,
-    };
-  }
-
-  completedEvent(): {
-    type: "response.completed";
-    response: ResponsesObject;
-  } {
-    const item: ResponsesMessageItem = {
-      id: this.messageId,
-      type: "message",
-      status: "completed",
-      role: "assistant",
-      content: [{ type: "output_text", text: this.text, annotations: [] }],
-    };
-    return {
-      type: "response.completed",
-      response: this.baseObject("completed", [item], this.text),
-    };
-  }
-
-  /**
-   * Final non-streaming Responses object: merges created + completed into a
-   * single JSON body (status "completed" with output_text).
-   */
-  responseObject(): ResponsesObject {
-    return this.completedEvent().response;
-  }
-
-  private baseObject(
-    status: ResponsesObject["status"],
-    output: ResponsesMessageItem[],
-    outputText?: string,
-  ): ResponsesObject {
-    const obj: ResponsesObject = {
-      id: this.responseId,
-      object: "response",
-      created_at: this.createdAtMs,
-      status,
-      model: this.model,
-      output,
-    };
-    if (outputText !== undefined) {
-      obj.output_text = outputText;
-    }
-    if (this.usage) {
-      obj.usage = {
-        input_tokens: this.usage.inputTokens ?? 0,
-        output_tokens: this.usage.outputTokens ?? 0,
-        total_tokens: this.usage.totalTokens ?? 0,
-      };
-    }
-    return obj;
-  }
-}
-
-/** Wrap any JSON-serializable payload as an SSE `data:` line. */
-export function responsesSseData(payload: unknown): string {
-  return `data: ${JSON.stringify(payload)}\n\n`;
-}
-
-// ---------------------------------------------------------------------------
-// Chat Completions alias (input + SSE)
-// ---------------------------------------------------------------------------
-
-const ChatMessageContentPartSchema = z.object({
-  type: z.string().optional(),
-  text: z.string().optional(),
-});
-
-const ChatMessageSchema = z.object({
-  role: z.string().optional(),
-  content: z
-    .union([
-      z.string(),
-      z.array(z.union([z.string(), ChatMessageContentPartSchema])),
-    ])
-    .optional(),
-});
-
-/**
- * Strict Zod schema for an OpenAI Chat Completions inbound request body.
- * Unknown top-level keys are rejected.
- */
-export const ChatCompletionsRequestSchema = z.object({
-  model: z.string().optional(),
-  messages: z.array(ChatMessageSchema).optional(),
-  stream: z.boolean().optional(),
-  max_tokens: z.number().nonnegative().optional(),
-  temperature: z.number().optional(),
-});
-// Unknown top-level keys stripped (OpenAI-compat interop); invalid values still 400.
-
-/**
- * Extract prompt text and options from an OpenAI Chat Completions body.
- * Validates the body strictly and throws {@link InvalidProxyRequestError} on any
- * schema violation. Used by the optional /v1/chat/completions alias.
- */
-export function extractPromptFromChatCompletions(
-  body: unknown,
-): ParsedResponsesInput {
-  const result = ChatCompletionsRequestSchema.safeParse(body);
-  if (!result.success) {
-    throw new InvalidProxyRequestError(result.error.issues);
-  }
-  const data = result.data;
-  const messages = data.messages ?? [];
-  const parts: string[] = [];
-  for (const message of messages) {
-    const content = message.content;
-    if (typeof content === "string") {
-      if (content.length > 0) parts.push(content);
-    } else if (Array.isArray(content)) {
-      for (const part of content) {
-        if (typeof part === "string") {
-          if (part.length > 0) parts.push(part);
-        } else if (typeof part.text === "string" && part.text.length > 0) {
-          parts.push(part.text);
-        }
-      }
-    }
-  }
-  return {
-    prompt: parts.join("\n").trim(),
-    model: data.model,
-    maxOutputTokens: data.max_tokens,
-    temperature: data.temperature,
-    stream: data.stream,
-  };
-}
-
-export interface ChatCompletionDeltaEvent {
-  id: string;
-  object: "chat.completion.chunk";
-  created: number;
-  model: string;
-  choices: Array<{
-    index: number;
-    delta: { role?: "assistant"; content?: string };
-    finish_reason: string | null;
-  }>;
-}
-
-export interface ChatUsageInput {
-  promptTokens?: number;
-  completionTokens?: number;
-  totalTokens?: number;
-}
-
-export interface ChatCompletionObject {
-  id: string;
-  object: "chat.completion";
-  created: number;
-  model: string;
-  choices: Array<{
-    index: number;
-    message: { role: "assistant"; content: string };
-    finish_reason: string;
-  }>;
-  usage?: {
-    prompt_tokens: number;
-    completion_tokens: number;
-    total_tokens: number;
-  };
-}
-
-/** Stateful builder for Chat Completions streaming chunks. */
-export class ChatCompletionsSseBuilder {
-  readonly completionId: string;
-  readonly createdAtMs: number;
-  private model: string;
-  private text = "";
-  private usage: ChatUsageInput | undefined;
-
-  constructor(model: string, now: () => Date = () => new Date()) {
-    this.model = model;
-    this.completionId = newPrefixId("chatcmpl");
-    this.createdAtMs = Math.floor(now().getTime() / 1000);
-  }
-
-  setModel(model: string): void {
-    this.model = model;
-  }
-
-  addText(delta: string): void {
-    this.text += delta;
-  }
-
-  get fullText(): string {
-    return this.text;
-  }
-
-  setUsage(usage: ChatUsageInput): void {
-    this.usage = usage;
-  }
-
-  firstEvent(): ChatCompletionDeltaEvent {
-    return this.chunk({ delta: { role: "assistant" }, finish_reason: null });
-  }
-
-  deltaEvent(content: string): ChatCompletionDeltaEvent {
-    return this.chunk({ delta: { content }, finish_reason: null });
-  }
-
-  doneEvent(): ChatCompletionDeltaEvent {
-    return this.chunk({ delta: {}, finish_reason: "stop" });
-  }
-
-  /**
-   * Final non-streaming Chat Completions object: a single JSON body with the
-   * merged assistant message and (optional) usage.
-   */
-  completionObject(): ChatCompletionObject {
-    const obj: ChatCompletionObject = {
-      id: this.completionId,
-      object: "chat.completion",
-      created: this.createdAtMs,
-      model: this.model,
-      choices: [
-        {
-          index: 0,
-          message: { role: "assistant", content: this.text },
-          finish_reason: "stop",
-        },
-      ],
-    };
-    if (this.usage) {
-      obj.usage = {
-        prompt_tokens: this.usage.promptTokens ?? 0,
-        completion_tokens: this.usage.completionTokens ?? 0,
-        total_tokens: this.usage.totalTokens ?? 0,
-      };
-    }
-    return obj;
-  }
-
-  private chunk(input: {
-    delta: { role?: "assistant"; content?: string };
-    finish_reason: string | null;
-  }): ChatCompletionDeltaEvent {
-    return {
-      id: this.completionId,
-      object: "chat.completion.chunk",
-      created: this.createdAtMs,
-      model: this.model,
-      choices: [
-        { index: 0, delta: input.delta, finish_reason: input.finish_reason },
-      ],
-    };
-  }
-}
-
-/** Terminal SSE marker for Chat Completions streams. */
-export const CHAT_COMPLETIONS_DONE = "data: [DONE]\n\n";
-
-// ---------------------------------------------------------------------------
-// Error mapping
-// ---------------------------------------------------------------------------
-
-/** Map a canonical provider error code to an HTTP status. */
-export function providerErrorCodeToHttpStatus(code: ProviderErrorCode): number {
-  switch (code) {
-    case "auth_failed":
-      return 401;
-    case "rate_limited":
-    case "quota_exhausted":
-      return 429;
-    case "billing":
-      return 402;
-    case "model_not_found":
-      return 404;
-    case "context_window":
-      return 413;
-    case "overload":
-      return 503;
-    case "timeout":
-      return 504;
-    case "network":
-      return 502;
-    case "invalid_request":
-    case "safety_refusal":
-      return 400;
-    case "stream_interrupted":
-    case "unknown":
-    default:
-      return 500;
-  }
-}
-
-/**
- * Map a routing decision at the gate to an HTTP status.
- * needsConfiguration -> 503; otherwise blocked -> 403.
- */
-export function policyDecisionToHttpStatus(decision: RouteDecision): number {
-  if (decision.needsConfiguration) return 503;
-  return 403;
-}
-
-function openAiErrorType(status: number): string {
-  switch (status) {
-    case 401:
-      return "authentication_error";
-    case 403:
-      return "permission_denied";
-    case 402:
-      return "billing_error";
-    case 429:
-      return "rate_limit_error";
-    case 404:
-      return "not_found";
-    case 400:
-      return "invalid_request_error";
-    case 503:
-      return "service_unavailable";
-    default:
-      return "server_error";
-  }
-}
-
-export interface OpenAiErrorPayload {
-  error: {
-    message: string;
-    type: string;
-    code?: string;
-  };
-}
-
-/** Build an OpenAI-style error JSON payload. */
-export function openAiErrorPayload(
-  status: number,
-  message: string,
-  code?: string,
-): OpenAiErrorPayload {
-  const error: OpenAiErrorPayload["error"] = {
-    message,
-    type: openAiErrorType(status),
-  };
-  if (code !== undefined) {
-    error.code = code;
-  }
-  return { error };
-}
-
-// ---------------------------------------------------------------------------
-// Proxy context (same shape as the MCP context)
-// ---------------------------------------------------------------------------
-
-export interface ResponsesProxyContext {
-  policy: PolicyConfig;
-  candidates: ProviderCandidate[];
-  adapters: Record<string, ProviderAdapter>;
-  runtime: DelegationRuntime;
-}
-
-export function createResponsesProxyContext(options: {
-  policy: PolicyConfig;
-  candidates: ProviderCandidate[];
-  adapters: Record<string, ProviderAdapter>;
-  delegation?: Pick<
-    DelegationRuntimeOptions,
-    "audit" | "now" | "includePromptPreview"
-  >;
-}): ResponsesProxyContext {
-  const runtime = new DelegationRuntime({
-    adapters: options.adapters,
-    candidates: options.candidates,
-    policy: options.policy,
-    ...options.delegation,
-  });
-  return {
-    policy: options.policy,
-    candidates: [...options.candidates],
-    adapters: { ...options.adapters },
-    runtime,
-  };
-}