mlx-bun 0.4.0 → 1.0.0

package/src/serve/aux-routes.ts

@@ -1,132 +0,0 @@
-export type AuxiliaryRoute =
-  | "memory-status"
-  | "memory-list"
-  | "memory-search"
-  | "memory-article"
-  | "memory-links"
-  | "memory-history"
-  | "memory-diff"
-  | "memory-init"
-  | "memory-synthesize"
-  | "hub-local"
-  | "hub-search"
-  | "hub-download"
-  | "hub-serve"
-  | "sessions-search"
-  | "sessions-export";
-
-/** Match request-only routes that do not depend on the loaded model or
- * createServer's live generation state. */
-export function matchAuxiliaryRoute(method: string, pathname: string): AuxiliaryRoute | null {
-  switch (`${method} ${pathname}`) {
-    case "GET /api/memory/status": return "memory-status";
-    case "GET /api/memory/list": return "memory-list";
-    case "GET /api/memory/search": return "memory-search";
-    case "GET /api/memory/article": return "memory-article";
-    case "GET /api/memory/links": return "memory-links";
-    case "GET /api/memory/history": return "memory-history";
-    case "GET /api/memory/diff": return "memory-diff";
-    case "POST /api/memory/init": return "memory-init";
-    case "GET /v1/memory/synthesize": return "memory-synthesize";
-    case "GET /api/hub/local": return "hub-local";
-    case "GET /api/hub/search": return "hub-search";
-    case "POST /api/hub/download": return "hub-download";
-    case "POST /api/hub/serve": return "hub-serve";
-    case "GET /api/sessions/search": return "sessions-search";
-    case "GET /api/sessions/export": return "sessions-export";
-    default: return null;
-  }
-}
-
-export async function handleAuxiliaryRoute(
-  url: URL,
-  request: Request,
-): Promise<Response | null> {
-  switch (matchAuxiliaryRoute(request.method, url.pathname)) {
-    case "memory-status": {
-      const { handleMemoryStatus } = await import("../memory/rest");
-      return handleMemoryStatus();
-    }
-    case "memory-list": {
-      const { handleMemoryList } = await import("../memory/rest");
-      return handleMemoryList();
-    }
-    case "memory-search": {
-      const { handleMemorySearch } = await import("../memory/rest");
-      return handleMemorySearch(url);
-    }
-    case "memory-article": {
-      const { handleMemoryArticle } = await import("../memory/rest");
-      return handleMemoryArticle(url);
-    }
-    case "memory-links": {
-      const { handleMemoryLinks } = await import("../memory/rest");
-      return handleMemoryLinks(url);
-    }
-    case "memory-history": {
-      const { handleMemoryHistory } = await import("../memory/rest");
-      return handleMemoryHistory(url);
-    }
-    case "memory-diff": {
-      const { handleMemoryDiff } = await import("../memory/rest");
-      return handleMemoryDiff(url);
-    }
-    case "memory-init": {
-      const { handleMemoryInit } = await import("../memory/rest");
-      return handleMemoryInit(request);
-    }
-    case "memory-synthesize": {
-      const dryRun = url.searchParams.get("dry") === "1";
-      const { runSynthesis } = await import("../memory/pipeline");
-      const encoder = new TextEncoder();
-      const stream = new ReadableStream({
-        async start(controller) {
-          const send = (event: unknown) =>
-            controller.enqueue(encoder.encode(`data: ${JSON.stringify(event)}\n\n`));
-          try {
-            const summary = await runSynthesis({ dryRun }, (event) => send(event));
-            send({ type: "summary", ...summary });
-            controller.enqueue(encoder.encode("data: [DONE]\n\n"));
-          } catch (error) {
-            send({ type: "error", message: (error as Error).message });
-          } finally {
-            controller.close();
-          }
-        },
-      });
-      return new Response(stream, {
-        headers: {
-          "content-type": "text/event-stream",
-          "cache-control": "no-cache",
-          connection: "keep-alive",
-        },
-      });
-    }
-    case "hub-local": {
-      const { handleHubLocal } = await import("../hub-rest");
-      return handleHubLocal();
-    }
-    case "hub-search": {
-      const { handleHubSearch } = await import("../hub-rest");
-      return handleHubSearch(url);
-    }
-    case "hub-download": {
-      const { handleHubDownload } = await import("../hub-rest");
-      return handleHubDownload(request);
-    }
-    case "hub-serve": {
-      const { handleHubServe } = await import("../hub-rest");
-      return handleHubServe(request);
-    }
-    case "sessions-search": {
-      const { handleSessionsSearch } = await import("./session-search");
-      return handleSessionsSearch(url);
-    }
-    case "sessions-export": {
-      const { handleSessionsExport } = await import("./session-search");
-      return handleSessionsExport(url);
-    }
-    default:
-      return null;
-  }
-}

package/src/serve/batch-scheduler.ts

@@ -1,8 +0,0 @@
-// Compatibility import. Scheduling policy lives in engine/scheduler; MLX
-// batch state and numerical execution belong to the backend group.
-export {
-  MlxBatchExecutionGroup as BatchScheduler,
-  stepTraceReport,
-  type MlxBatchExecutionGroupOptions as BatchSchedulerOptions,
-  type BatchRequest, type BatchStats, type RowSampler, type RowPromptCache, type ExclusiveLock,
-} from "../backends/mlx/batch-group";

package/src/serve/checkpoint-identity.ts

@@ -1,64 +0,0 @@
-import type { GenerateOptions } from "../generate";
-import type { ResolvedExecution } from "../contracts/execution";
-import { createHash } from "node:crypto";
-
-/** Sort object fields only; array order is meaningful for adapter composition,
- * stop handling and quantization recipes. */
-function canonical(value: unknown): unknown {
-  if (Array.isArray(value)) return value.map(canonical);
-  if (value && typeof value === "object")
-    return Object.fromEntries(Object.entries(value).sort(([a], [b]) => a.localeCompare(b))
-      .map(([key, item]) => [key, canonical(item)]));
-  return value;
-}
-
-/** Stable identity for an exactly resumable generation. The prompt already
- * includes rendered messages and tool schemas; the remaining fields cover
- * every sampling policy that can change the continuation. */
-export function generationCheckpointKey(
-  promptIds: number[], options: GenerateOptions & { stopSequences?: readonly string[] }, cacheNs = "",
-  execution?: ResolvedExecution, bindingIdentity?: unknown,
-): string {
-  const policy = {
-    version: 4,
-    execution: execution && { method: execution.method, mechanism: execution.mechanism,
-      pagedKv: execution.pagedKv, fill: execution.fill,
-      compiledDecode: execution.compiledDecode, grammarJump: execution.grammarJump },
-    bindingIdentity,
-    stopSequences: options.stopSequences ?? [],
-    cacheNs,
-    promptIds,
-    maxTokens: options.maxTokens,
-    eosTokenIds: options.eosTokenIds,
-    temperature: options.temperature,
-    topP: options.topP,
-    topK: options.topK,
-    minP: options.minP,
-    minTokensToKeep: options.minTokensToKeep,
-    xtcProbability: options.xtcProbability,
-    xtcThreshold: options.xtcThreshold,
-    xtcSpecialTokens: options.xtcSpecialTokens,
-    // A missing client seed means "fresh randomness" for a new request, but
-    // an identical RETRY must find the durable checkpoint and restore the
-    // original random stream. Keep the generated seed out of request identity;
-    // it travels in checkpoint metadata instead. Explicit seeds remain part of
-    // the policy, so changing one cannot select an incompatible checkpoint.
-    seedMode: options.seedWasExplicit ? "explicit" : "server-default",
-    seed: options.seedWasExplicit ? options.seed : undefined,
-    hlg: options.hlg,
-    curve: options.curve,
-    logitBias: options.logitBias,
-    repetitionPenalty: options.repetitionPenalty,
-    repetitionContextSize: options.repetitionContextSize,
-    presencePenalty: options.presencePenalty,
-    presenceContextSize: options.presenceContextSize,
-    frequencyPenalty: options.frequencyPenalty,
-    frequencyContextSize: options.frequencyContextSize,
-    kvBits: options.kvBits,
-    kvGroupSize: options.kvGroupSize,
-    quantizedKvStart: options.quantizedKvStart,
-    kvConfig: options.kvConfig,
-    turboQuant: options.turboQuant,
-  };
-  return createHash("sha256").update(JSON.stringify(canonical(policy))).digest("hex");
-}