@mupt-ai/dari-router 0.1.0 → 0.2.1

package/src/pi_output.ts

@@ -1,387 +0,0 @@
-import type {
-  AssistantMessage,
-  AssistantMessageEvent,
-  ThinkingContent,
-  ToolCall,
-} from "@mupt-ai/pi-ai";
-
-import { RouterFrameworkError } from "./framework_error.js";
-import { decodeOpenAIReasoningSignature } from "./pi_reasoning_signature.js";
-import { isRecord } from "./types.js";
-import {
-  isOpenAIResponsesApi,
-  type ProviderContinuationState,
-  type ProviderIdentity,
-} from "./continuation_state.js";
-import {
-  isRouterHostedToolCallStatus,
-  type RouterCompletion,
-  type RouterOutputHostedToolCall,
-  type RouterOutputReasoning,
-  type RouterStreamEvent,
-} from "./framework_types.js";
-
-export function routerCompletion(
-  message: AssistantMessage,
-  signal: AbortSignal,
-): RouterCompletion {
-  assertPiSuccess(message, signal);
-  const content: RouterCompletion["content"] = [];
-  const source = providerIdentity(message);
-  for (const part of message.content) {
-    if (part.type === "text") content.push({ type: "text", text: part.text });
-    if (part.type === "thinking") content.push(routerReasoning(part, source));
-    if (part.type === "toolCall") {
-      content.push({
-        type: "tool_call",
-        id: part.id,
-        name: part.name,
-        arguments: part.arguments,
-      });
-    }
-    const hostedItem = providerItemRecord(part);
-    if (hostedItem !== null) content.push(hostedToolCall(hostedItem, source));
-  }
-  return {
-    ...(message.responseId === undefined ? {} : { id: message.responseId }),
-    createdAtMs: message.timestamp,
-    content,
-    finishReason: routerFinishReason(message.stopReason),
-    usage: routerUsage(message),
-  };
-}
-
-export async function* routerEvents(
-  events: AsyncIterable<AssistantMessageEvent>,
-  signal: AbortSignal,
-): AsyncIterable<RouterStreamEvent> {
-  const text = new Map<number, string>();
-  const thinking = new Map<number, string>();
-  const endedThinking = new Set<number>();
-  const openTools = new Map<number, { receivedDelta: boolean }>();
-  const completedTools = new Map<number, Pick<ToolCall, "id" | "name">>();
-  for await (const event of events) {
-    if (event.type === "text_start") {
-      text.set(event.contentIndex, text.get(event.contentIndex) ?? "");
-      continue;
-    }
-    if (event.type === "text_delta") {
-      if (event.delta.length > 0) {
-        text.set(event.contentIndex, (text.get(event.contentIndex) ?? "") + event.delta);
-        yield { type: "text_delta", index: event.contentIndex, delta: event.delta };
-      }
-      continue;
-    }
-    if (event.type === "text_end") {
-      const suffix = remainingText(text.get(event.contentIndex) ?? "", event.content);
-      if (suffix.length > 0) yield { type: "text_delta", index: event.contentIndex, delta: suffix };
-      text.set(event.contentIndex, event.content);
-      continue;
-    }
-    if (event.type === "thinking_start") {
-      thinking.set(event.contentIndex, "");
-      continue;
-    }
-    if (event.type === "thinking_delta") {
-      if (event.delta.length > 0) {
-        thinking.set(event.contentIndex, (thinking.get(event.contentIndex) ?? "") + event.delta);
-        yield { type: "reasoning_delta", index: event.contentIndex, delta: event.delta };
-      }
-      continue;
-    }
-    if (event.type === "thinking_end") {
-      const streamed = thinking.get(event.contentIndex) ?? "";
-      const suffix = remainingText(streamed, event.content);
-      if (suffix.length > 0) yield { type: "reasoning_delta", index: event.contentIndex, delta: suffix };
-      thinking.set(event.contentIndex, event.content);
-      endedThinking.add(event.contentIndex);
-      const part = event.partial.content[event.contentIndex];
-      const source = providerIdentity(event.partial);
-      if (part?.type === "thinking") {
-        const reasoning = routerReasoning(part, source);
-        yield {
-          type: "reasoning_end",
-          index: event.contentIndex,
-          ...(part.redacted === true ? { redacted: true } : {}),
-          source,
-          ...(reasoning.continuation ? { continuation: reasoning.continuation } : {}),
-        };
-      } else {
-        yield { type: "reasoning_end", index: event.contentIndex, source };
-      }
-      continue;
-    }
-    if (event.type === "toolcall_start") {
-      const call = event.partial.content[event.contentIndex];
-      if (call?.type !== "toolCall") throw invalidPiStream("tool-call start is missing its tool call.");
-      openTools.set(event.contentIndex, { receivedDelta: false });
-      yield {
-        type: "tool_call_start",
-        index: event.contentIndex,
-        id: call.id,
-        name: call.name,
-      };
-      continue;
-    }
-    if (event.type === "toolcall_delta") {
-      const state = openTools.get(event.contentIndex);
-      if (state === undefined) throw invalidPiStream("tool-call delta arrived before its start.");
-      if (event.delta.length > 0) {
-        state.receivedDelta = true;
-        yield { type: "tool_call_delta", index: event.contentIndex, delta: event.delta };
-      }
-      continue;
-    }
-    if (event.type === "toolcall_end") {
-      const state = openTools.get(event.contentIndex);
-      if (state === undefined) {
-        yield* completeToolCall(event.contentIndex, event.toolCall);
-        completedTools.set(event.contentIndex, event.toolCall);
-        continue;
-      }
-      if (!state.receivedDelta) {
-        yield {
-          type: "tool_call_delta",
-          index: event.contentIndex,
-          delta: JSON.stringify(event.toolCall.arguments),
-        };
-      }
-      openTools.delete(event.contentIndex);
-      completedTools.set(event.contentIndex, event.toolCall);
-      yield { type: "tool_call_end", index: event.contentIndex };
-      continue;
-    }
-    if (event.type === "done") {
-      assertPiSuccess(event.message, signal);
-      if (event.reason !== "stop" && event.reason !== "length" && event.reason !== "toolUse") {
-        throw invalidPiStream(`stream ended with invalid reason '${String(event.reason)}'.`);
-      }
-      if (openTools.size > 0) throw invalidPiStream("stream finished with open tool calls.");
-      yield* reconcileTerminalOutput(event.message, text, thinking, endedThinking, completedTools);
-      yield {
-        type: "finish",
-        finishReason: routerFinishReason(event.reason),
-        usage: routerUsage(event.message),
-      };
-      return;
-    }
-    if (event.type === "error") {
-      if (event.reason === "aborted") throw piCancellation(event.error, signal);
-      throw piProviderError(event.error.errorMessage ?? "Pi provider execution failed.");
-    }
-  }
-  throw invalidPiStream("stream ended without a terminal event.");
-}
-
-function* reconcileTerminalOutput(
-  message: AssistantMessage,
-  text: ReadonlyMap<number, string>,
-  thinking: ReadonlyMap<number, string>,
-  endedThinking: ReadonlySet<number>,
-  completedTools: ReadonlyMap<number, Pick<ToolCall, "id" | "name">>,
-): Iterable<RouterStreamEvent> {
-  for (const index of text.keys()) {
-    if (message.content[index]?.type !== "text") {
-      throw invalidPiStream(`terminal output changed text block ${index}.`);
-    }
-  }
-  for (const index of thinking.keys()) {
-    if (message.content[index]?.type !== "thinking") {
-      throw invalidPiStream(`terminal output changed thinking block ${index}.`);
-    }
-  }
-  for (const [index, streamed] of completedTools) {
-    const terminal = message.content[index];
-    if (terminal?.type !== "toolCall" || terminal.id !== streamed.id || terminal.name !== streamed.name) {
-      throw invalidPiStream(`terminal output changed tool call ${index}.`);
-    }
-  }
-
-  for (const [index, part] of message.content.entries()) {
-    if (part.type === "text") {
-      const suffix = remainingText(text.get(index) ?? "", part.text);
-      if (suffix.length > 0) yield { type: "text_delta", index, delta: suffix };
-      continue;
-    }
-    if (part.type === "thinking") {
-      // Started-but-unended thinking blocks reconcile like unended text:
-      // emit the remaining delta, then the proper reasoning_end.
-      if (!endedThinking.has(index)) {
-        yield* completeReasoning(index, part, providerIdentity(message), thinking.get(index) ?? "");
-      }
-      continue;
-    }
-    if (part.type === "toolCall") {
-      if (!completedTools.has(index)) yield* completeToolCall(index, part);
-      continue;
-    }
-    const hostedItem = providerItemRecord(part);
-    if (hostedItem !== null) {
-      yield { ...hostedToolCall(hostedItem, providerIdentity(message)), index };
-    }
-  }
-}
-
-function* completeToolCall(index: number, call: ToolCall): Iterable<RouterStreamEvent> {
-  yield { type: "tool_call_start", index, id: call.id, name: call.name };
-  yield { type: "tool_call_delta", index, delta: JSON.stringify(call.arguments) };
-  yield { type: "tool_call_end", index };
-}
-
-function* completeReasoning(
-  index: number,
-  part: ThinkingContent,
-  source: ProviderIdentity,
-  streamed = "",
-): Iterable<RouterStreamEvent> {
-  const suffix = remainingText(streamed, part.thinking);
-  if (suffix.length > 0) {
-    yield { type: "reasoning_delta", index, delta: suffix };
-  }
-  const reasoning = routerReasoning(part, source);
-  yield {
-    type: "reasoning_end",
-    index,
-    ...(part.redacted === true ? { redacted: true } : {}),
-    source,
-    ...(reasoning.continuation ? { continuation: reasoning.continuation } : {}),
-  };
-}
-
-function providerItemRecord(part: unknown): Record<string, unknown> | null {
-  if (!isRecord(part) || part.type !== "providerItem") return null;
-  if (!isRecord(part.item)) {
-    throw unsupportedHostedTool("the provider item has no payload record");
-  }
-  return part.item;
-}
-
-function hostedToolCall(
-  item: Record<string, unknown>,
-  source: ProviderIdentity,
-): RouterOutputHostedToolCall {
-  if (item.type !== "web_search_call") {
-    throw unsupportedHostedTool(
-      `only web_search_call items are replayable, got '${String(item.type)}'`,
-    );
-  }
-  if (typeof item.id !== "string" || item.id.length === 0) {
-    throw unsupportedHostedTool("the web_search_call item has no id");
-  }
-  const status = hostedToolCallStatus(item.status);
-  return {
-    type: "hosted_tool_call",
-    id: item.id,
-    tool: "web_search",
-    providerType: "web_search_call",
-    ...(status === undefined ? {} : { status }),
-    payload: item,
-    source,
-  };
-}
-
-function hostedToolCallStatus(value: unknown): RouterOutputHostedToolCall["status"] {
-  if (value === undefined || isRouterHostedToolCallStatus(value)) return value;
-  throw unsupportedHostedTool(`web_search_call status '${String(value)}' is not replayable`);
-}
-
-function unsupportedHostedTool(detail: string): RouterFrameworkError {
-  return new RouterFrameworkError(
-    "executor",
-    `Pi returned a hosted tool item the router cannot replay: ${detail}.`,
-    "pi_hosted_tool_unsupported",
-  );
-}
-
-function remainingText(streamed: string, terminal: string): string {
-  if (!terminal.startsWith(streamed)) {
-    throw invalidPiStream("terminal text does not extend the streamed text.");
-  }
-  return terminal.slice(streamed.length);
-}
-
-function providerIdentity(
-  message: Pick<AssistantMessage, "provider" | "api" | "model">,
-): ProviderIdentity {
-  return { provider: message.provider, api: message.api, model: message.model };
-}
-
-function routerReasoning(
-  part: ThinkingContent,
-  source: ProviderIdentity,
-): RouterOutputReasoning {
-  const signature = typeof part.thinkingSignature === "string" && part.thinkingSignature.length > 0
-    ? part.thinkingSignature
-    : undefined;
-  let continuation: ProviderContinuationState | undefined;
-  if (isOpenAIResponsesApi(source.api) && signature) {
-    const native = decodeOpenAIReasoningSignature(signature);
-    if (native?.encryptedContent) {
-      continuation = {
-        kind: "openai_reasoning",
-        source,
-        encryptedContent: native.encryptedContent,
-        ...(native.id ? { providerItemId: native.id } : {}),
-      };
-    }
-  } else if (source.api === "anthropic-messages" && signature) {
-    continuation = part.redacted === true
-      ? { kind: "anthropic_redacted_thinking", source, data: signature }
-      : { kind: "anthropic_thinking", source, thinking: part.thinking, signature };
-  }
-  return {
-    type: "reasoning",
-    text: part.thinking,
-    ...(part.redacted === true ? { redacted: true } : {}),
-    source,
-    ...(continuation ? { continuation } : {}),
-  };
-}
-
-function assertPiSuccess(message: AssistantMessage, signal: AbortSignal): void {
-  if (message.stopReason === "error") {
-    throw piProviderError(message.errorMessage ?? "Pi provider execution failed.");
-  }
-  if (message.stopReason === "aborted") throw piCancellation(message, signal);
-}
-
-function routerFinishReason(
-  reason: "stop" | "length" | "toolUse" | AssistantMessage["stopReason"],
-): RouterCompletion["finishReason"] {
-  if (reason === "length") return "length";
-  if (reason === "toolUse") return "tool_calls";
-  return "stop";
-}
-
-function routerUsage(
-  message: Pick<AssistantMessage, "usage">,
-): NonNullable<RouterCompletion["usage"]> {
-  return {
-    inputTokens: message.usage.input,
-    outputTokens: message.usage.output,
-    cacheReadTokens: message.usage.cacheRead,
-    cacheWriteTokens: message.usage.cacheWrite,
-    totalTokens: message.usage.totalTokens,
-  };
-}
-
-function piCancellation(
-  message: Pick<AssistantMessage, "errorMessage">,
-  signal: AbortSignal,
-): RouterFrameworkError {
-  return new RouterFrameworkError(
-    "cancelled",
-    typeof signal.reason === "string"
-      ? signal.reason
-      : message.errorMessage ?? "Request cancelled.",
-    "request_cancelled",
-  );
-}
-
-function piProviderError(message: string): RouterFrameworkError {
-  return new RouterFrameworkError("executor", message, "pi_provider_error");
-}
-
-function invalidPiStream(message: string): RouterFrameworkError {
-  return new RouterFrameworkError("executor", `Pi ${message}`, "pi_stream_invalid");
-}

package/src/pi_reasoning_signature.ts

@@ -1,41 +0,0 @@
-import { isRecord } from "./types.js";
-
-// Wire codec for the JSON blob Pi carries in thinkingSignature on
-// openai-responses APIs: a serialized Responses reasoning item whose
-// encrypted_content holds the replayable state.
-
-export function encodeOpenAIReasoningSignature(state: {
-  id?: string;
-  summary: string[];
-  content: string[];
-  encryptedContent: string;
-}): string {
-  return JSON.stringify({
-    type: "reasoning",
-    ...(state.id ? { id: state.id } : {}),
-    summary: state.summary.map((text) => ({ type: "summary_text", text })),
-    ...(state.content.length
-      ? { content: state.content.map((text) => ({ type: "reasoning_text", text })) }
-      : {}),
-    encrypted_content: state.encryptedContent,
-  });
-}
-
-export function decodeOpenAIReasoningSignature(value: string): {
-  id?: string;
-  encryptedContent?: string;
-} | null {
-  let parsed: unknown;
-  try {
-    parsed = JSON.parse(value);
-  } catch {
-    return null;
-  }
-  if (!isRecord(parsed) || parsed.type !== "reasoning") return null;
-  return {
-    ...(typeof parsed.id === "string" && parsed.id.length > 0 ? { id: parsed.id } : {}),
-    ...(typeof parsed.encrypted_content === "string" && parsed.encrypted_content.length > 0
-      ? { encryptedContent: parsed.encrypted_content }
-      : {}),
-  };
-}

package/src/pi_runtime.ts

@@ -1,238 +0,0 @@
-import { RouterFrameworkError } from "./framework_error.js";
-import { nativeModelId, providerForModel } from "./model_ids.js";
-import { piContext } from "./pi_context.js";
-import { piOptions } from "./pi_options.js";
-import { routerCompletion, routerEvents } from "./pi_output.js";
-import { openAIChatRequest } from "./protocol_openai_chat.js";
-import type { ReasoningEffort } from "./types.js";
-import type {
-  RouterExecutorResult,
-  RouterModel,
-  RouterRequest,
-} from "./framework_types.js";
-import type {
-  CreatePiRuntimeOptions,
-  PiExecution,
-  PiModel,
-  PiModelRegistry,
-  PiRouterModelOptions,
-  PiRuntime,
-} from "./pi_types.js";
-
-export type {
-  CreatePiRuntimeOptions,
-  PiApiKey,
-  PiCredentialInput,
-  PiModelRegistry,
-  PiRouterModelOptions,
-  PiRuntime,
-} from "./pi_types.js";
-
-type PiRuntimeDependencies = {
-  registry: PiModelRegistry;
-  supportedThinkingLevels(model: PiModel): ReasoningEffort[];
-};
-
-const STRUCTURED_OUTPUT_APIS = new Set([
-  "anthropic-messages",
-  "azure-openai-responses",
-  "google-generative-ai",
-  "google-vertex",
-  "mistral-conversations",
-  "openai-completions",
-  "openai-responses",
-]);
-
-export async function createPiRuntime(
-  options: CreatePiRuntimeOptions,
-): Promise<PiRuntime> {
-  validateRuntimeOptions(options);
-  const dependencies = await piDependencies(options.registry);
-
-  const model = <Metadata = unknown>(
-    id: string,
-    overrides: Partial<PiRouterModelOptions<Metadata>> = {},
-  ): RouterModel<Metadata> => {
-    const provider = modelProvider(id);
-    const registered = registeredModel(dependencies.registry, provider, id);
-    const reasoningEfforts = overrides.reasoningEfforts === undefined
-      ? dependencies.supportedThinkingLevels(registered)
-      : [...overrides.reasoningEfforts];
-    const defaultReasoningEffort = overrides.defaultReasoningEffort
-      ?? (reasoningEfforts.includes("off") ? "off" : reasoningEfforts[0]);
-    return {
-      id,
-      executor: "pi",
-      provider,
-      api: registered.api,
-      reasoningEfforts,
-      ...(defaultReasoningEffort === undefined ? {} : { defaultReasoningEffort }),
-      capabilities: {
-        imageInput: registered.input.includes("image"),
-        toolUse: true,
-        structuredOutput: STRUCTURED_OUTPUT_APIS.has(registered.api),
-        streaming: true,
-        ...overrides.capabilities,
-      },
-      ...(overrides.metadata === undefined ? {} : { metadata: overrides.metadata }),
-    };
-  };
-
-  const run = async (execution: PiExecution): Promise<RouterExecutorResult> => {
-    const registered = registeredModel(
-      dependencies.registry,
-      execution.candidate.provider,
-      execution.candidate.id,
-    );
-    if (registered.api !== execution.candidate.api) {
-      throw new RouterFrameworkError(
-        "configuration",
-        `Model '${execution.candidate.id}' declares API '${execution.candidate.api}' but Pi uses '${registered.api}'.`,
-        "pi_model_api_mismatch",
-      );
-    }
-    const context = piContext(execution.request, registered);
-    const streamOptions = await piOptions(options, execution, registered);
-    if (execution.request.stream) {
-      const events = dependencies.registry.streamSimple(registered, context, streamOptions);
-      return { type: "stream", events: routerEvents(events, execution.signal) };
-    }
-    const message = await dependencies.registry.completeSimple(registered, context, streamOptions);
-    return { type: "complete", output: routerCompletion(message, execution.signal) };
-  };
-
-  return {
-    model,
-    execute: async (input) => run({
-      request: input.request,
-      candidate: input.model,
-      reasoningEffort: input.decision.reasoningEffort,
-      signal: input.signal,
-      purpose: "execution",
-    }),
-    select: async (request, signal = new AbortController().signal) => {
-      let normalized: RouterRequest;
-      try {
-        normalized = openAIChatRequest(request);
-      } catch (error) {
-        // The selector request is constructed internally; an invalid request
-        // here is a router bug, not the end user's fault.
-        if (error instanceof RouterFrameworkError && error.kind === "invalid_request") {
-          throw new RouterFrameworkError(
-            "configuration",
-            error.message,
-            "pi_selector_request_invalid",
-            error.param,
-            { cause: error },
-          );
-        }
-        throw error;
-      }
-      const selectorModel = requiredSelectorModel(request.model);
-      const candidate = model(selectorModel);
-      const result = await run({
-        request: { ...normalized, stream: false },
-        candidate: {
-          id: candidate.id,
-          provider: candidate.provider!,
-          api: candidate.api!,
-        },
-        reasoningEffort: normalized.reasoning?.effort ?? candidate.defaultReasoningEffort ?? "off",
-        signal,
-        purpose: "selector",
-      });
-      if (result.type !== "complete") {
-        throw new RouterFrameworkError(
-          "configuration",
-          "Pi returned a stream for a non-streaming selector request.",
-          "pi_selector_mode_mismatch",
-        );
-      }
-      return result.output.content
-        .filter((item) => item.type === "text")
-        .map((item) => item.text)
-        .join("");
-    },
-  };
-}
-
-async function piDependencies(registry: PiModelRegistry | undefined): Promise<PiRuntimeDependencies> {
-  const pi = await import("@mupt-ai/pi-ai");
-  const resolvedRegistry = registry ?? (await import("@mupt-ai/pi-ai/providers/all")).builtinModels();
-  return {
-    registry: resolvedRegistry,
-    supportedThinkingLevels: (model) => pi.getSupportedThinkingLevels(model) as ReasoningEffort[],
-  };
-}
-
-function validateRuntimeOptions(options: CreatePiRuntimeOptions): void {
-  if (!options || (typeof options.apiKey !== "string" && typeof options.apiKey !== "function")) {
-    throw new RouterFrameworkError(
-      "configuration",
-      "createPiRuntime requires an API key or API-key resolver.",
-      "pi_api_key_missing",
-    );
-  }
-  if (typeof options.apiKey === "string" && !options.apiKey.trim()) {
-    throw new RouterFrameworkError(
-      "configuration",
-      "createPiRuntime API keys must be non-empty strings.",
-      "pi_api_key_missing",
-    );
-  }
-  for (const [name, value] of [
-    ["timeoutMs", options.timeoutMs],
-    ["maxRetries", options.maxRetries],
-  ] as const) {
-    if (value !== undefined && (!Number.isSafeInteger(value) || value < 0)) {
-      throw new RouterFrameworkError(
-        "configuration",
-        `createPiRuntime ${name} must be a non-negative integer.`,
-        "pi_options_invalid",
-      );
-    }
-  }
-}
-
-function modelProvider(id: string): string {
-  try {
-    return providerForModel(id);
-  } catch (error) {
-    throw new RouterFrameworkError(
-      "configuration",
-      `Pi model '${id}' must include a provider prefix.`,
-      "pi_model_provider_missing",
-      undefined,
-      { cause: error },
-    );
-  }
-}
-
-function registeredModel(registry: PiModelRegistry, provider: string, id: string): PiModel {
-  let nativeId: string;
-  try {
-    nativeId = nativeModelId(id);
-  } catch {
-    nativeId = id;
-  }
-  const registered = registry.getModel(provider, nativeId) ?? registry.getModel(provider, id);
-  if (registered === undefined) {
-    throw new RouterFrameworkError(
-      "configuration",
-      `Pi does not know model '${id}' for provider '${provider}'.`,
-      "pi_model_not_found",
-    );
-  }
-  return registered;
-}
-
-function requiredSelectorModel(value: unknown): string {
-  if (typeof value !== "string" || !value.trim()) {
-    throw new RouterFrameworkError(
-      "configuration",
-      "The Pi selector request requires a model.",
-      "pi_selector_model_missing",
-    );
-  }
-  return value;
-}