@mupt-ai/dari-router 0.1.0

package/src/model_ids.ts

@@ -0,0 +1,29 @@
+import { RouterCoreError } from "./errors.js";
+import type { Provider } from "./types.js";
+
+const PROVIDER_PATTERN = /^[a-z][a-z0-9_.-]{0,119}$/;
+
+export function providerForModel(model: string): Provider {
+  const slash = model.indexOf("/");
+  if (slash <= 0) {
+    throw new RouterCoreError("invalid_request", `Unsupported model provider for ${model}`, "unsupported_model", "model");
+  }
+  const provider = model.slice(0, slash).toLowerCase();
+  if (!PROVIDER_PATTERN.test(provider)) {
+    throw new RouterCoreError("invalid_request", `Unsupported model provider for ${model}`, "unsupported_model", "model");
+  }
+  return provider;
+}
+
+export function nativeModelId(model: string): string {
+  return model.slice(`${providerForModel(model)}/`.length);
+}
+
+// providerForModel() lowercases the provider prefix, so lookups keyed on
+// model ids must use the same canonical spelling; the model segment stays
+// case-sensitive (native ids can be), matching providerForModel semantics.
+export function canonicalModelId(modelId: string): string {
+  const slash = modelId.indexOf("/");
+  if (slash <= 0) return modelId;
+  return modelId.slice(0, slash).toLowerCase() + modelId.slice(slash);
+}

package/src/pi_context.ts

@@ -0,0 +1,251 @@
+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

@@ -0,0 +1,295 @@
+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,
+    },
+  };
+}