@mupt-ai/dari-router 0.1.0 → 0.2.0

package/src/pi_context.ts

@@ -1,251 +0,0 @@
-import type { AssistantMessage, Context, Tool } from "@mupt-ai/pi-ai";
-
-import { RouterFrameworkError } from "./framework_error.js";
-import { encodeOpenAIReasoningSignature } from "./pi_reasoning_signature.js";
-import { isRecord } from "./types.js";
-import type {
-  RouterContent,
-  RouterProviderIdentity,
-  RouterRequest,
-} from "./framework_types.js";
-import {
-  compatibleProviderContinuation,
-  isOpenAIResponsesApi,
-  type ProviderContinuationState,
-} from "./continuation_state.js";
-import type { PiModel } from "./pi_types.js";
-
-export function piContext(request: RouterRequest, model: PiModel): Context {
-  const system: string[] = [];
-  const messages: Context["messages"] = [];
-  const calls = new Map<string, string>();
-  const timestamp = Date.now();
-  let assistant: Extract<Context["messages"][number], { role: "assistant" }> | undefined;
-
-  const flushAssistant = () => {
-    if (assistant === undefined) return;
-    if (assistant.content.length === 0) assistant.content.push({ type: "text", text: "" });
-    assistant.stopReason = assistant.content.some((part) => part.type === "toolCall")
-      ? "toolUse"
-      : "stop";
-    messages.push(assistant);
-    assistant = undefined;
-  };
-  const currentAssistant = () => {
-    assistant ??= {
-      role: "assistant",
-      content: [],
-      api: model.api,
-      provider: model.provider,
-      model: model.id,
-      usage: zeroPiUsage(),
-      stopReason: "stop",
-      timestamp,
-    };
-    return assistant;
-  };
-
-  for (const item of request.items) {
-    if (item.type === "message" && (item.role === "system" || item.role === "developer")) {
-      flushAssistant();
-      system.push(systemText(item.content));
-      continue;
-    }
-    if (item.type === "message" && item.role === "user") {
-      flushAssistant();
-      messages.push({
-        role: "user",
-        content: piContent(item.content, "user message"),
-        timestamp,
-      });
-      continue;
-    }
-    if (item.type === "message") {
-      const pending = currentAssistant();
-      pending.content.push(...item.content.map((part) => {
-        if (part.type !== "text") {
-          throw new RouterFrameworkError(
-            "invalid_request",
-            "Pi does not support image content in assistant messages.",
-            "pi_assistant_image_unsupported",
-          );
-        }
-        return { type: "text" as const, text: part.text };
-      }));
-      continue;
-    }
-    if (item.type === "tool_call") {
-      const argumentsValue = toolArguments(item.arguments, item.id);
-      currentAssistant().content.push({
-        type: "toolCall",
-        id: item.id,
-        name: item.name,
-        arguments: argumentsValue,
-      });
-      calls.set(item.id, item.name);
-      continue;
-    }
-    if (item.type === "reasoning") {
-      const target: RouterProviderIdentity = {
-        provider: model.provider,
-        api: model.api,
-        model: model.id,
-      };
-      const continuation = compatibleProviderContinuation(item.continuation, target);
-      if (continuation) {
-        currentAssistant().content.push(thinkingContent(item, continuation));
-      } else {
-        const readable = [...(item.summary ?? []), ...item.content].join("\n");
-        if (readable) {
-          // Cross-provider: the encrypted blob is not replayable, so carry the
-          // readable reasoning as plain text instead of dropping the prior
-          // turn's chain-of-thought entirely.
-          currentAssistant().content.push({ type: "text", text: readable });
-        }
-      }
-      continue;
-    }
-    if (item.type === "hosted_tool_call") {
-      if (!isOpenAIResponsesApi(model.api)) {
-        // Dropping the item would silently lose a conversation turn.
-        throw new RouterFrameworkError(
-          "configuration",
-          `Hosted tool calls are not representable on the '${model.api}' API; route hosted-tool conversations to a Responses-API model.`,
-          "hosted_tool_call_unrepresentable",
-        );
-      }
-      (currentAssistant().content as unknown as Array<Record<string, unknown>>).push({
-        type: "providerItem",
-        item: item.payload,
-      });
-      continue;
-    }
-    flushAssistant();
-    messages.push({
-      role: "toolResult",
-      toolCallId: item.toolCallId,
-      toolName: calls.get(item.toolCallId) ?? "tool",
-      content: piContent(item.content, `tool result '${item.toolCallId}'`),
-      isError: item.isError ?? false,
-      timestamp,
-    });
-  }
-  flushAssistant();
-
-  const tools: Tool[] = request.tools.map((tool) => ({
-    name: tool.name,
-    description: tool.description ?? "",
-    parameters: tool.inputSchema as Tool["parameters"],
-  }));
-  return {
-    ...(system.length === 0 ? {} : { systemPrompt: system.join("\n\n") }),
-    messages,
-    ...(tools.length === 0 ? {} : { tools }),
-  };
-}
-
-function thinkingContent(
-  item: Extract<RouterRequest["items"][number], { type: "reasoning" }>,
-  continuation: ProviderContinuationState,
-): { type: "thinking"; thinking: string; thinkingSignature?: string; redacted?: boolean } {
-  if (continuation.kind === "openai_reasoning") {
-    const providerItemId = continuation.providerItemId ?? item.id;
-    return {
-      type: "thinking",
-      thinking: [...(item.summary ?? []), ...item.content].join("\n"),
-      thinkingSignature: encodeOpenAIReasoningSignature({
-        ...(providerItemId ? { id: providerItemId } : {}),
-        summary: item.summary ?? [],
-        content: item.content,
-        encryptedContent: continuation.encryptedContent,
-      }),
-    };
-  }
-  if (continuation.kind === "anthropic_thinking") {
-    return {
-      type: "thinking",
-      thinking: continuation.thinking,
-      thinkingSignature: continuation.signature,
-    };
-  }
-  return {
-    type: "thinking",
-    thinking: "",
-    thinkingSignature: continuation.data,
-    redacted: true,
-  };
-}
-
-function systemText(content: readonly RouterContent[]): string {
-  return content.map((part) => {
-    if (part.type !== "text") {
-      throw new RouterFrameworkError(
-        "invalid_request",
-        "Pi does not support image content in system or developer messages.",
-        "pi_system_image_unsupported",
-      );
-    }
-    return part.text;
-  }).join("");
-}
-
-function piContent(
-  content: readonly RouterContent[],
-  location: string,
-): Array<{ type: "text"; text: string } | { type: "image"; data: string; mimeType: string }> {
-  return content.map((part) => {
-    if (part.type === "text") return { type: "text", text: part.text };
-    const image = dataImage(part.url);
-    if (image === null) {
-      throw new RouterFrameworkError(
-        "invalid_request",
-        `Pi ${location} images must use base64 data URLs.`,
-        "pi_remote_image_unsupported",
-      );
-    }
-    return { type: "image", data: image.data, mimeType: image.mimeType };
-  });
-}
-
-function dataImage(url: string): { data: string; mimeType: string } | null {
-  const match = /^data:(image\/[a-z0-9.+-]+);base64,([a-z0-9+/=\s]+)$/i.exec(url);
-  if (match === null) return null;
-  return { mimeType: match[1]!, data: match[2]!.replace(/\s/g, "") };
-}
-
-function toolArguments(value: string | Record<string, unknown>, id: string): Record<string, unknown> {
-  if (typeof value !== "string") return value;
-  // Providers emit "" for zero-argument tool calls; replay it as {}.
-  if (value === "") return {};
-  let parsed: unknown;
-  try {
-    parsed = JSON.parse(value);
-  } catch (error) {
-    throw new RouterFrameworkError(
-      "invalid_request",
-      `Tool call '${id}' arguments must be valid JSON.`,
-      "pi_tool_arguments_invalid",
-      undefined,
-      { cause: error },
-    );
-  }
-  if (!isRecord(parsed)) {
-    throw new RouterFrameworkError(
-      "invalid_request",
-      `Tool call '${id}' arguments must be a JSON object.`,
-      "pi_tool_arguments_invalid",
-    );
-  }
-  return parsed;
-}
-
-function zeroPiUsage(): AssistantMessage["usage"] {
-  return {
-    input: 0,
-    output: 0,
-    cacheRead: 0,
-    cacheWrite: 0,
-    totalTokens: 0,
-    cost: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0, total: 0 },
-  };
-}

package/src/pi_options.ts

@@ -1,295 +0,0 @@
-import type { SimpleStreamOptions } from "@mupt-ai/pi-ai";
-
-import { isOpenAIResponsesApi } from "./continuation_state.js";
-import { RouterFrameworkError } from "./framework_error.js";
-import { isRecord } from "./types.js";
-import type { RouterContent, RouterRequest, RouterToolChoice } from "./framework_types.js";
-import type {
-  CreatePiRuntimeOptions,
-  PiExecution,
-  PiModel,
-} from "./pi_types.js";
-
-const PAYLOAD_PATCH_APIS = new Set([
-  "anthropic-messages",
-  "azure-openai-responses",
-  "openai-completions",
-  "openai-responses",
-]);
-
-export async function piOptions(
-  runtime: CreatePiRuntimeOptions,
-  execution: PiExecution,
-  model: PiModel,
-): Promise<SimpleStreamOptions> {
-  rejectUnsupportedOptions(execution.request, model);
-  const apiKey = typeof runtime.apiKey === "string"
-    ? runtime.apiKey
-    : await runtime.apiKey({
-        provider: model.provider,
-        model: execution.candidate.id,
-        api: model.api,
-        purpose: execution.purpose,
-      });
-  if (typeof apiKey !== "string" || !apiKey.trim()) {
-    throw new RouterFrameworkError(
-      "configuration",
-      `No API key was provided for Pi model '${execution.candidate.id}'.`,
-      "pi_api_key_missing",
-    );
-  }
-
-  const request = execution.request;
-  const options: SimpleStreamOptions = {
-    apiKey,
-    signal: execution.signal,
-    ...(runtime.timeoutMs === undefined ? {} : { timeoutMs: runtime.timeoutMs }),
-    ...(runtime.maxRetries === undefined ? {} : { maxRetries: runtime.maxRetries }),
-    ...(request.generation.temperature === undefined
-      ? {}
-      : { temperature: request.generation.temperature }),
-    ...(request.generation.topP === undefined ? {} : { topP: request.generation.topP }),
-    ...(request.generation.maxOutputTokens === undefined
-      ? {}
-      : { maxTokens: request.generation.maxOutputTokens }),
-    ...(request.generation.stop === undefined ? {} : { stop: request.generation.stop }),
-    ...(request.cacheKey === undefined ? {} : { sessionId: request.cacheKey }),
-    // Only anthropic-messages reads metadata (and only user_id); no other
-    // fork API consumes metadata fields.
-    ...(request.user !== undefined && model.api === "anthropic-messages"
-      ? { metadata: { user_id: request.user } }
-      : {}),
-    ...(execution.reasoningEffort === "off" ? {} : { reasoning: execution.reasoningEffort }),
-    ...(request.responseFormat === undefined
-      ? {}
-      : { responseFormat: piResponseFormat(request.responseFormat, model.api) }),
-    ...(request.toolChoice === undefined ? {} : { toolChoice: piToolChoice(request.toolChoice) }),
-  };
-
-  const budget = request.reasoning?.budgetTokens;
-  if (
-    budget !== undefined &&
-    execution.reasoningEffort !== "off" &&
-    execution.reasoningEffort !== "xhigh" &&
-    execution.reasoningEffort !== "max"
-  ) {
-    options.thinkingBudgets = { [execution.reasoningEffort]: budget };
-  }
-
-  const patch = payloadPatch(request, model);
-  if (patch !== undefined) options.onPayload = patch;
-  return options;
-}
-
-// The fork hard-throws for these (api, option) pairs inside streamSimple;
-// reject them up front as client errors instead of surfacing 502s.
-function rejectUnsupportedOptions(request: RouterRequest, model: PiModel): void {
-  if (request.generation.stop !== undefined && isOpenAIResponsesApi(model.api)) {
-    throw unsupportedPiOption("stop sequences", model.api);
-  }
-  if (request.generation.topP !== undefined && model.api === "anthropic-messages") {
-    throw unsupportedPiOption("top_p", model.api);
-  }
-  if (
-    typeof request.toolChoice === "object" &&
-    (model.api === "google-generative-ai" || model.api === "google-vertex")
-  ) {
-    throw unsupportedPiOption("forcing a specific tool with tool_choice", model.api);
-  }
-  if (request.responseFormat?.type === "json_object" && model.api === "bedrock-converse-stream") {
-    throw unsupportedPiOption("response_format json_object", model.api);
-  }
-}
-
-function unsupportedPiOption(option: string, api: string): RouterFrameworkError {
-  return new RouterFrameworkError(
-    "invalid_request",
-    `Pi API '${api}' does not support ${option}.`,
-    "pi_option_unsupported",
-  );
-}
-
-function piResponseFormat(
-  format: NonNullable<RouterRequest["responseFormat"]>,
-  api: string,
-): NonNullable<SimpleStreamOptions["responseFormat"]> {
-  if (format.type === "json_object" && api === "anthropic-messages") {
-    // Anthropic has no json_object mode; degrade to a permissive object
-    // schema so the request still produces JSON output.
-    return {
-      type: "json_schema",
-      jsonSchema: { name: "response", schema: { type: "object" } },
-    };
-  }
-  if (format.type !== "json_schema") return format;
-  return {
-    type: "json_schema",
-    jsonSchema: {
-      name: format.name,
-      schema: format.schema,
-      ...(format.description === undefined ? {} : { description: format.description }),
-      ...(format.strict === undefined ? {} : { strict: format.strict }),
-    },
-  };
-}
-
-function piToolChoice(choice: RouterToolChoice): NonNullable<SimpleStreamOptions["toolChoice"]> {
-  if (choice === "required") return "any";
-  if (typeof choice === "string") return choice;
-  return { type: "function", function: { name: choice.name } };
-}
-
-function payloadPatch(
-  request: RouterRequest,
-  model: PiModel,
-): SimpleStreamOptions["onPayload"] | undefined {
-  const strictTools = request.tools.some((tool) => tool.strict !== undefined);
-  const parallel = request.parallelToolCalls;
-  const imageDetails = imageDetailQueues(request);
-  const thinkingPatch = model.api === "anthropic-messages" && (
-    request.reasoning?.enabled === false || request.reasoning?.budgetTokens !== undefined
-  );
-  const imageDetailPatch = imageDetails.size > 0 &&
-    (isOpenAIResponsesApi(model.api) || model.api === "openai-completions");
-  if (
-    imageDetails.size > 0 &&
-    !imageDetailPatch &&
-    [...imageDetails.values()].some((queue) => queue.some((detail) => detail !== "auto"))
-  ) {
-    throw new RouterFrameworkError(
-      "invalid_request",
-      `Pi API '${model.api}' cannot preserve image detail controls.`,
-      "pi_image_detail_unsupported",
-    );
-  }
-  if (!strictTools && parallel === undefined && !thinkingPatch && !imageDetailPatch) {
-    return undefined;
-  }
-  if ((strictTools || parallel !== undefined) && !PAYLOAD_PATCH_APIS.has(model.api)) {
-    throw new RouterFrameworkError(
-      "invalid_request",
-      `Pi API '${model.api}' cannot preserve strict or parallel tool controls.`,
-      "pi_tool_control_unsupported",
-    );
-  }
-
-  return (value) => {
-    if (!isRecord(value)) return undefined;
-    let payload = value;
-    if (strictTools) payload = patchStrictTools(payload, request, model.api);
-    if (parallel !== undefined) payload = patchParallelTools(payload, parallel, model.api);
-    if (imageDetailPatch) payload = patchImageDetails(payload, imageDetails);
-    if (thinkingPatch) payload = patchAnthropicThinking(payload, request);
-    return payload;
-  };
-}
-
-function patchStrictTools(
-  payload: Record<string, unknown>,
-  request: RouterRequest,
-  api: string,
-): Record<string, unknown> {
-  if (!Array.isArray(payload.tools)) return payload;
-  const tools = new Map(request.tools.map((tool) => [tool.name, tool]));
-  return {
-    ...payload,
-    tools: payload.tools.map((entry) => {
-      if (!isRecord(entry)) return entry;
-      if (api === "anthropic-messages") {
-        const tool = typeof entry.name === "string" ? tools.get(entry.name) : undefined;
-        return tool?.strict === undefined ? entry : { ...entry, strict: tool.strict };
-      }
-      const definition = api === "openai-completions" && isRecord(entry.function)
-        ? entry.function
-        : entry;
-      const tool = typeof definition.name === "string" ? tools.get(definition.name) : undefined;
-      if (tool?.strict === undefined) return entry;
-      return api === "openai-completions"
-        ? { ...entry, function: { ...definition, strict: tool.strict } }
-        : { ...entry, strict: tool.strict };
-    }),
-  };
-}
-
-function patchParallelTools(
-  payload: Record<string, unknown>,
-  enabled: boolean,
-  api: string,
-): Record<string, unknown> {
-  if (api !== "anthropic-messages") return { ...payload, parallel_tool_calls: enabled };
-  if (enabled) return payload;
-  const current = isRecord(payload.tool_choice) ? payload.tool_choice : {};
-  return {
-    ...payload,
-    tool_choice: {
-      type: typeof current.type === "string" ? current.type : "auto",
-      ...current,
-      disable_parallel_tool_use: true,
-    },
-  };
-}
-
-function patchImageDetails(
-  payload: Record<string, unknown>,
-  details: Map<string, Array<"auto" | "low" | "high">>,
-): Record<string, unknown> {
-  const queues = new Map([...details].map(([url, queue]) => [url, [...queue]]));
-  const patch = (value: unknown): unknown => {
-    if (Array.isArray(value)) return value.map(patch);
-    if (!isRecord(value)) return value;
-    const mapped = Object.fromEntries(
-      Object.entries(value).map(([key, entry]) => [key, patch(entry)]),
-    );
-    const responseUrl = mapped.type === "input_image" && typeof mapped.image_url === "string"
-      ? mapped.image_url
-      : undefined;
-    const chatImage = mapped.type === "image_url" && isRecord(mapped.image_url)
-      ? mapped.image_url
-      : undefined;
-    const chatUrl = typeof chatImage?.url === "string" ? chatImage.url : undefined;
-    const detail = queues.get(responseUrl ?? chatUrl ?? "")?.shift();
-    if (detail === undefined) return mapped;
-    return responseUrl === undefined
-      ? { ...mapped, image_url: { ...chatImage, detail } }
-      : { ...mapped, detail };
-  };
-  const patched = patch(payload);
-  return isRecord(patched) ? patched : payload;
-}
-
-function imageDetailQueues(
-  request: RouterRequest,
-): Map<string, Array<"auto" | "low" | "high">> {
-  const details = new Map<string, Array<"auto" | "low" | "high">>();
-  const add = (content: readonly RouterContent[]) => {
-    for (const part of content) {
-      if (part.type !== "image" || part.detail === undefined) continue;
-      const queue = details.get(part.url) ?? [];
-      queue.push(part.detail);
-      details.set(part.url, queue);
-    }
-  };
-  for (const item of request.items) {
-    if (item.type === "message" || item.type === "tool_result") add(item.content);
-  }
-  return details;
-}
-
-function patchAnthropicThinking(
-  payload: Record<string, unknown>,
-  request: RouterRequest,
-): Record<string, unknown> {
-  if (request.reasoning?.enabled === false) {
-    return { ...payload, thinking: { type: "disabled" } };
-  }
-  const budget = request.reasoning?.budgetTokens;
-  if (budget === undefined) return payload;
-  return {
-    ...payload,
-    thinking: {
-      ...(isRecord(payload.thinking) ? payload.thinking : {}),
-      type: "enabled",
-      budget_tokens: budget,
-    },
-  };
-}