@brianmichel/pi-noodle 0.1.0

package/src/config.ts

@@ -0,0 +1,159 @@
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
+import { homedir } from "node:os";
+import { join } from "node:path";
+import type { NoodleConfig, NoodleConfigPartial, NoodleExtractorMode } from "./types.ts";
+
+// ---------------------------------------------------------------------------
+// Paths — user-level, not project-level (memories travel with the user)
+// ---------------------------------------------------------------------------
+
+const NOODLE_DIR = join(homedir(), ".pi", "noodle");
+
+export function resolveConfigPath(): string {
+  return process.env["NOODLE_CONFIG_PATH"] ?? join(NOODLE_DIR, "config.json");
+}
+
+// ---------------------------------------------------------------------------
+// Defaults
+// ---------------------------------------------------------------------------
+
+export const DEFAULT_EXTRACTOR_MODE: NoodleExtractorMode = "balanced";
+export const DISABLED_EXTRACTOR_MODE: NoodleExtractorMode = "off";
+
+export function defaultExtractorTriggerEvery(mode: NoodleExtractorMode = DEFAULT_EXTRACTOR_MODE): number {
+  switch (mode) {
+    case "conservative":
+      return 20;
+    case "proactive":
+      return 5;
+    case "off":
+    case "balanced":
+    default:
+      return 10;
+  }
+}
+
+const DEFAULTS: NoodleConfig = {
+  db: {
+    mode: "local",
+    path: join(NOODLE_DIR, "memories.db"),
+  },
+  embedding: {
+    provider: "openai",
+    apiKey: "",
+    baseUrl: "https://api.openai.com/v1",
+    model: "text-embedding-3-small",
+  },
+  extractor: {
+    mode: DISABLED_EXTRACTOR_MODE,
+    triggerEvery: defaultExtractorTriggerEvery(DEFAULT_EXTRACTOR_MODE),
+    debug: false,
+  },
+};
+
+// ---------------------------------------------------------------------------
+// Read
+// ---------------------------------------------------------------------------
+
+export function resolveConfig(): NoodleConfig {
+  const config = structuredClone(DEFAULTS);
+
+  // File overlays defaults
+  const filePath = resolveConfigPath();
+  if (existsSync(filePath)) {
+    try {
+      mergeInto(config, JSON.parse(readFileSync(filePath, "utf-8")));
+    } catch {
+      // corrupt file — skip to env
+    }
+  }
+
+  // Environment variables take highest priority
+  const env = process.env;
+  if (env["NOODLE_DB_PATH"]) config.db.path = env["NOODLE_DB_PATH"];
+  if (env["NOODLE_DB_URL"]) {
+    config.db.url = env["NOODLE_DB_URL"];
+    config.db.mode = "cloud";
+  }
+  if (env["NOODLE_DB_TOKEN"]) config.db.authToken = env["NOODLE_DB_TOKEN"];
+  if (env["OPENAI_API_KEY"]) config.embedding.apiKey = env["OPENAI_API_KEY"];
+  if (env["EMBEDDING_BASE_URL"]) config.embedding.baseUrl = env["EMBEDDING_BASE_URL"];
+  if (env["EMBEDDING_MODEL"]) config.embedding.model = env["EMBEDDING_MODEL"];
+  if (env["EMBEDDING_DIMENSIONS"]) {
+    const n = parseInt(env["EMBEDDING_DIMENSIONS"], 10);
+    if (!isNaN(n) && n > 0) config.embedding.dimensions = n;
+  }
+
+  // Extractor env overrides
+  if (env["NOODLE_EXTRACTOR_MODE"]) {
+    const mode = env["NOODLE_EXTRACTOR_MODE"];
+    if (mode === "off" || mode === "conservative" || mode === "balanced" || mode === "proactive") {
+      if (!config.extractor) config.extractor = {};
+      config.extractor.mode = mode;
+      if (!config.extractor.triggerEvery || config.extractor.triggerEvery < 1) {
+        config.extractor.triggerEvery = defaultExtractorTriggerEvery(mode === "off" ? DEFAULT_EXTRACTOR_MODE : mode);
+      }
+    }
+  }
+  if (env["NOODLE_EXTRACTOR_MODEL"]) {
+    if (!config.extractor) config.extractor = {};
+    config.extractor.model = env["NOODLE_EXTRACTOR_MODEL"];
+    config.extractor.mode ??= DEFAULT_EXTRACTOR_MODE;
+  }
+  if (env["NOODLE_EXTRACTOR_TRIGGER_EVERY"]) {
+    const n = parseInt(env["NOODLE_EXTRACTOR_TRIGGER_EVERY"], 10);
+    if (!isNaN(n) && n > 0) {
+      if (!config.extractor) config.extractor = {};
+      config.extractor.triggerEvery = n;
+    }
+  }
+  if (env["NOODLE_EXTRACTOR_DEBUG"]) {
+    if (!config.extractor) config.extractor = {};
+    config.extractor.debug = ["1", "true", "yes", "on"].includes(env["NOODLE_EXTRACTOR_DEBUG"].toLowerCase());
+  }
+
+  if (config.extractor) {
+    config.extractor.mode ??= DISABLED_EXTRACTOR_MODE;
+    config.extractor.triggerEvery = config.extractor.triggerEvery && config.extractor.triggerEvery > 0
+      ? config.extractor.triggerEvery
+      : defaultExtractorTriggerEvery(config.extractor.mode === "off" ? DEFAULT_EXTRACTOR_MODE : config.extractor.mode);
+    config.extractor.debug ??= false;
+  }
+
+  return config;
+}
+
+// ---------------------------------------------------------------------------
+// Write
+// ---------------------------------------------------------------------------
+
+export function writeConfig(partial: NoodleConfigPartial): void {
+  const config = resolveConfig();
+  mergeInto(config, partial);
+
+  const filePath = resolveConfigPath();
+  mkdirSync(NOODLE_DIR, { recursive: true });
+  writeFileSync(filePath, JSON.stringify(config, null, 2) + "\n", "utf-8");
+}
+
+// ---------------------------------------------------------------------------
+// Internal helpers
+// ---------------------------------------------------------------------------
+
+type PlainObject = Record<string, unknown>;
+
+function isPlainObject(value: unknown): value is PlainObject {
+  return value !== null && typeof value === "object" && !Array.isArray(value);
+}
+
+function mergeInto(target: PlainObject, source: PlainObject): void {
+  for (const key of Object.keys(source)) {
+    const src = source[key];
+    const dst = target[key];
+    if (isPlainObject(src) && isPlainObject(dst)) {
+      mergeInto(dst, src);
+    } else {
+      target[key] = src;
+    }
+  }
+}

package/src/constants.ts

@@ -0,0 +1 @@
+export const DEFAULT_AGENT_ID = "pi";

package/src/debug-overlay.ts

@@ -0,0 +1,230 @@
+import type { ExtensionContext } from "@earendil-works/pi-coding-agent";
+
+type DebugRunStatus = "queued" | "running" | "success" | "error" | "skipped";
+
+type DebugRunSummary = {
+  startedAt: number;
+  finishedAt?: number;
+  status: DebugRunStatus;
+  reason: string;
+  model?: string;
+  candidateTexts: string[];
+  savedCount: number;
+  error?: string;
+};
+
+type DebugState = {
+  enabled: boolean;
+  mode: string;
+  triggerEvery: number;
+  sessionTurnCount: number;
+  turnsUntilNextRun: number;
+  isRunning: boolean;
+  lastRun?: DebugRunSummary;
+};
+
+const state: DebugState = {
+  enabled: false,
+  mode: "off",
+  triggerEvery: 10,
+  sessionTurnCount: 0,
+  turnsUntilNextRun: 10,
+  isRunning: false,
+};
+
+const sessions = new Set<ExtensionContext>();
+const WIDGET_KEY = "noodle-extractor-debug-widget";
+const SPINNER_FRAMES = ["⠋", "⠙", "⠹", "⠸", "⠼", "⠴", "⠦", "⠧", "⠇", "⠏"];
+const MIN_RUNNING_MS = 900;
+
+let spinnerIndex = 0;
+let spinnerTimer: ReturnType<typeof setInterval> | null = null;
+
+function emit(): void {
+  for (const ctx of sessions) {
+    ctx.ui.setWidget(WIDGET_KEY, renderWidget(ctx));
+  }
+}
+
+function formatAge(timestamp?: number): string {
+  if (!timestamp) return "—";
+  const seconds = Math.max(0, Math.floor((Date.now() - timestamp) / 1000));
+  if (seconds < 60) return `${seconds}s`;
+  const minutes = Math.floor(seconds / 60);
+  return `${minutes}m${seconds % 60}s`;
+}
+
+function startSpinner(): void {
+  if (spinnerTimer) return;
+  spinnerTimer = setInterval(() => {
+    spinnerIndex = (spinnerIndex + 1) % SPINNER_FRAMES.length;
+    emit();
+  }, 90);
+}
+
+function stopSpinner(): void {
+  if (!spinnerTimer) return;
+  clearInterval(spinnerTimer);
+  spinnerTimer = null;
+}
+
+function renderStateLabel(ctx: ExtensionContext): string {
+  const theme = ctx.ui.theme;
+  if (state.isRunning) {
+    return `${theme.fg("accent", SPINNER_FRAMES[spinnerIndex] ?? "⠋")} ${theme.fg("accent", "running")}`;
+  }
+  switch (state.lastRun?.status) {
+    case "queued":
+      return `${theme.fg("warning", "…")} ${theme.fg("warning", "queued")}`;
+    case "error":
+      return theme.fg("error", "error");
+    case "skipped":
+      return theme.fg("warning", "skipped");
+    case "success":
+      return theme.fg("success", "ready");
+    default:
+      return theme.fg("dim", "idle");
+  }
+}
+
+function summarizeReason(reason: string): string {
+  if (reason.startsWith("shutdown:")) return `shutdown (${reason.slice("shutdown:".length)})`;
+  return reason === "scheduled" ? "scheduled cadence" : reason;
+}
+
+function renderWidget(ctx: ExtensionContext): string[] | undefined {
+  if (!state.enabled) return undefined;
+
+  const theme = ctx.ui.theme;
+  const title = theme.bold?.("Noodle extractor") ?? "Noodle extractor";
+  const nextRun = state.turnsUntilNextRun === 0
+    ? "this turn"
+    : `in ${state.turnsUntilNextRun} turn${state.turnsUntilNextRun === 1 ? "" : "s"}`;
+
+  const lines = [
+    title,
+    theme.fg("dim", `mode ${state.mode} • every ${state.triggerEvery} turns • next ${nextRun}`),
+    renderStateLabel(ctx),
+  ];
+
+  if (!state.lastRun) return lines;
+
+  lines.push(theme.fg("dim", `last run ${formatAge(state.lastRun.finishedAt ?? state.lastRun.startedAt)} ago • ${summarizeReason(state.lastRun.reason)}`));
+  if (state.lastRun.model) lines.push(theme.fg("dim", `model ${state.lastRun.model}`));
+
+  if (state.lastRun.status === "success") {
+    lines.push(theme.fg("dim", `pulled ${state.lastRun.candidateTexts.length} candidate${state.lastRun.candidateTexts.length === 1 ? "" : "s"} • saved ${state.lastRun.savedCount}`));
+    if (state.lastRun.candidateTexts.length > 0) {
+      lines.push(...state.lastRun.candidateTexts.slice(0, 2).map((text) => theme.fg("dim", `• ${text}`)));
+    } else {
+      lines.push(theme.fg("dim", "• nothing durable found"));
+    }
+  } else if (state.lastRun.status === "skipped") {
+    lines.push(theme.fg("dim", `• ${state.lastRun.reason}`));
+  } else if (state.lastRun.status === "error" && state.lastRun.error) {
+    lines.push(theme.fg("dim", `• ${state.lastRun.error}`));
+  }
+
+  return lines;
+}
+
+function finalizeRun(
+  status: Extract<DebugRunStatus, "success" | "error">,
+  options: { candidateTexts?: string[]; savedCount?: number; error?: string },
+): void {
+  const apply = () => {
+    state.isRunning = false;
+    stopSpinner();
+    state.lastRun = {
+      startedAt: state.lastRun?.startedAt ?? Date.now(),
+      finishedAt: Date.now(),
+      status,
+      reason: state.lastRun?.reason ?? "scheduled",
+      ...(state.lastRun?.model ? { model: state.lastRun.model } : {}),
+      candidateTexts: options.candidateTexts?.slice(0, 3) ?? state.lastRun?.candidateTexts ?? [],
+      savedCount: options.savedCount ?? state.lastRun?.savedCount ?? 0,
+      ...(options.error ? { error: options.error } : {}),
+    };
+    emit();
+  };
+
+  const startedAt = state.lastRun?.startedAt ?? Date.now();
+  const remaining = Math.max(0, MIN_RUNNING_MS - (Date.now() - startedAt));
+  if (remaining > 0) {
+    setTimeout(apply, remaining);
+  } else {
+    apply();
+  }
+}
+
+export function configureExtractorDebug(enabled: boolean, mode: string, triggerEvery: number): void {
+  state.enabled = enabled && mode !== "off";
+  state.mode = mode;
+  state.triggerEvery = Math.max(1, triggerEvery);
+  state.turnsUntilNextRun = state.enabled
+    ? state.triggerEvery - (state.sessionTurnCount % state.triggerEvery || 0)
+    : 0;
+  emit();
+}
+
+export function noteUserTurnForExtractorDebug(): void {
+  state.sessionTurnCount += 1;
+  if (!state.enabled) {
+    emit();
+    return;
+  }
+
+  const remainder = state.sessionTurnCount % state.triggerEvery;
+  state.turnsUntilNextRun = remainder === 0 ? 0 : state.triggerEvery - remainder;
+  emit();
+}
+
+export function noteExtractorSkipped(reason: string): void {
+  state.isRunning = false;
+  state.lastRun = {
+    startedAt: Date.now(),
+    finishedAt: Date.now(),
+    status: "skipped",
+    reason,
+    candidateTexts: [],
+    savedCount: 0,
+  };
+  emit();
+}
+
+export function noteExtractorQueued(reason: string, model?: string): void {
+  state.isRunning = false;
+  state.lastRun = {
+    startedAt: Date.now(),
+    status: "queued",
+    reason,
+    ...(model ? { model } : {}),
+    candidateTexts: [],
+    savedCount: 0,
+  };
+  emit();
+}
+
+export function noteExtractorRunStarted(): void {
+  state.isRunning = true;
+  startSpinner();
+  if (state.lastRun) {
+    state.lastRun.status = "running";
+    state.lastRun.startedAt = Date.now();
+  }
+  emit();
+}
+
+export function noteExtractorRunFinished(candidateTexts: string[], savedCount: number): void {
+  finalizeRun("success", { candidateTexts, savedCount });
+}
+
+export function noteExtractorRunFailed(error: string): void {
+  finalizeRun("error", { error });
+}
+
+export function maybeStartExtractorDebugOverlay(ctx: ExtensionContext): void {
+  if (!ctx.hasUI) return;
+  sessions.add(ctx);
+  ctx.ui.setWidget(WIDGET_KEY, renderWidget(ctx));
+}

package/src/extension.ts

@@ -0,0 +1,166 @@
+import type { Api, Model } from "@earendil-works/pi-ai";
+import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
+
+import { registerCommands as registerCommandsRuntime } from "./commands.ts";
+import {
+  configureExtractorDebug,
+  maybeStartExtractorDebugOverlay,
+  noteUserTurnForExtractorDebug,
+} from "./debug-overlay.ts";
+import {
+  extractorDebug as runtimeExtractorDebug,
+  extractorMode as runtimeExtractorMode,
+  extractorModelId as runtimeExtractorModelId,
+  extractorTriggerEvery as runtimeExtractorTriggerEvery,
+  memoryService as runtimeMemoryService,
+} from "./memory/runtime.ts";
+import type { MemoryCaptureEvent, MemoryCaptureResult, MemoryExtractorResolution, MemoryRecord } from "./memory/types.ts";
+import { flushPendingWrites as flushPendingWritesRuntime } from "./session.ts";
+import { memoryTools as runtimeMemoryTools } from "./tools.ts";
+import type { NoodleExtractorMode } from "./types.ts";
+
+type RegisteredTool = Parameters<ExtensionAPI["registerTool"]>[0];
+
+type MemoryServiceLike = {
+  capture: (event: MemoryCaptureEvent) => Promise<MemoryCaptureResult>;
+  findRelevantMemories: (prompt: string, limit?: number) => Promise<MemoryRecord[]>;
+};
+
+export type MemoryExtensionDeps = {
+  memoryService: MemoryServiceLike;
+  extractorMode: NoodleExtractorMode;
+  extractorModelId?: string;
+  extractorTriggerEvery: number;
+  extractorDebug?: boolean;
+  flushPendingWrites: () => Promise<void>;
+  memoryTools: readonly RegisteredTool[];
+  registerCommands: (pi: ExtensionAPI) => void;
+};
+
+type ExtractorModelRegistry = {
+  getAll(): Model<Api>[];
+  getApiKeyAndHeaders(model: Model<Api>): Promise<{ ok: boolean; apiKey?: string; headers?: Record<string, string>; error?: string }>;
+};
+
+type ExtractorContext = {
+  modelRegistry: ExtractorModelRegistry;
+};
+
+const runtimeDeps: MemoryExtensionDeps = {
+  memoryService: runtimeMemoryService,
+  extractorMode: runtimeExtractorMode,
+  ...(runtimeExtractorModelId ? { extractorModelId: runtimeExtractorModelId } : {}),
+  extractorTriggerEvery: runtimeExtractorTriggerEvery,
+  extractorDebug: runtimeExtractorDebug,
+  flushPendingWrites: flushPendingWritesRuntime,
+  memoryTools: runtimeMemoryTools,
+  registerCommands: registerCommandsRuntime,
+};
+
+export function createMemoryExtension(deps: MemoryExtensionDeps = runtimeDeps) {
+  return function memoryExtension(pi: ExtensionAPI) {
+    configureExtractorDebug(deps.extractorDebug ?? false, deps.extractorMode, deps.extractorTriggerEvery);
+
+    const buildExtractor = (ctx: ExtractorContext): MemoryCaptureEvent["extractor"] | undefined => {
+      if (deps.extractorMode === "off") return undefined;
+      return {
+        resolve: () => resolveExtractorModel(deps.extractorModelId, ctx.modelRegistry),
+      };
+    };
+
+    pi.on("session_start", async (_event, ctx) => {
+      maybeStartExtractorDebugOverlay(ctx);
+    });
+
+    pi.on("input", async (event, ctx) => {
+      if (event.source === "extension") return { action: "continue" };
+
+      noteUserTurnForExtractorDebug();
+      const extractor = buildExtractor(ctx);
+      await deps.memoryService.capture({
+        type: "user_input",
+        text: event.text,
+        sessionManager: ctx.sessionManager,
+        target: ctx,
+        ...(extractor ? { extractor } : {}),
+      });
+
+      return { action: "continue" };
+    });
+
+    pi.on("before_agent_start", async (event) => {
+      try {
+        const memories = await deps.memoryService.findRelevantMemories(event.prompt, 3);
+        if (memories.length === 0) return;
+
+        return {
+          systemPrompt: `${event.systemPrompt}\n\nRelevant user memory:\n${memories.map((memory) => `- ${memory.text}`).join("\n")}`,
+        };
+      } catch {
+        return;
+      }
+    });
+
+    pi.on("session_before_compact", async (_event, ctx) => {
+      const extractor = buildExtractor(ctx);
+      await deps.memoryService.capture({
+        type: "session_before_compact",
+        sessionManager: ctx.sessionManager,
+        target: ctx,
+        ...(extractor ? { extractor } : {}),
+      });
+    });
+
+    pi.on("session_before_switch", async (event, ctx) => {
+      const extractor = buildExtractor(ctx);
+      await deps.memoryService.capture({
+        type: "session_before_switch",
+        reason: event.reason,
+        sessionManager: ctx.sessionManager,
+        target: ctx,
+        ...(extractor ? { extractor } : {}),
+      });
+    });
+
+    pi.on("session_shutdown", async (event, ctx) => {
+      const extractor = buildExtractor(ctx);
+      await deps.memoryService.capture({
+        type: "session_shutdown",
+        reason: event.reason,
+        sessionManager: ctx.sessionManager,
+        ...(extractor ? { extractor } : {}),
+      });
+
+      await deps.flushPendingWrites();
+    });
+
+    for (const tool of deps.memoryTools) {
+      pi.registerTool(tool);
+    }
+
+    deps.registerCommands(pi);
+  };
+}
+
+async function resolveExtractorModel(
+  extractorModelId: string | undefined,
+  modelRegistry: ExtractorModelRegistry,
+): Promise<MemoryExtractorResolution | null> {
+  if (!extractorModelId) return null;
+
+  const model = modelRegistry.getAll().find((candidate) => candidate.id === extractorModelId);
+  if (!model) {
+    return null;
+  }
+
+  const auth = await modelRegistry.getApiKeyAndHeaders(model);
+  if (!auth?.ok || !auth.apiKey) return null;
+
+  return {
+    model,
+    apiKey: auth.apiKey,
+    ...(auth.headers ? { headers: auth.headers } : {}),
+  };
+}
+
+export default createMemoryExtension();

package/src/index.ts

@@ -0,0 +1 @@
+export { default } from "./extension.ts";

package/src/memory/backend.ts

@@ -0,0 +1,22 @@
+import type {
+  AddMemoryInput,
+  ConsolidationReport,
+  ConversationCaptureInput,
+  MemoryListInput,
+  MemoryRecord,
+  MemorySearchInput,
+  UpdateMemoryInput,
+} from "./types.ts";
+
+export interface MemoryBackend {
+  add(input: AddMemoryInput): Promise<void>;
+  search(input: MemorySearchInput): Promise<MemoryRecord[]>;
+  list(input?: MemoryListInput): Promise<MemoryRecord[]>;
+  get(id: string): Promise<MemoryRecord | null>;
+  update(id: string, input: UpdateMemoryInput): Promise<void>;
+  delete(id: string): Promise<void>;
+  /** Bump retrieval stats when memories are injected into a prompt. */
+  recordRetrievals?(ids: string[]): Promise<void>;
+  captureConversation?(input: ConversationCaptureInput): Promise<void>;
+  consolidate?(): Promise<ConsolidationReport>;
+}

package/src/memory/embedder.ts

@@ -0,0 +1,7 @@
+/** Injectable embedding function. */
+export type Embedder = {
+  /** Produce a floating-point embedding vector for `text`. */
+  embed(text: string): Promise<Float32Array>;
+  /** Optional expected dimensionality of the vectors returned by `embed`. */
+  dimensions?: number;
+};

package/src/memory/embedders/lm-studio.ts

@@ -0,0 +1,25 @@
+import type { Embedder } from "../embedder.ts";
+import { createOpenAIEmbedder } from "./openai.ts";
+import type { OpenAIEmbedderOptions } from "./openai.ts";
+
+export type LMStudioEmbedderOptions = {
+  baseUrl: string;
+  model?: string;
+};
+
+/**
+ * LM Studio exposes an OpenAI-compatible `/v1/embeddings` endpoint — this is a
+ * thin convenience wrapper.
+ */
+export function createLMStudioEmbedder(
+  options: LMStudioEmbedderOptions,
+): Embedder {
+  const opts: Record<string, unknown> = {
+    apiKey: "lm-studio",
+    baseUrl: options.baseUrl,
+  };
+  if (options.model) opts.model = options.model;
+  return createOpenAIEmbedder(
+    opts as unknown as OpenAIEmbedderOptions,
+  );
+}

package/src/memory/embedders/openai.ts

@@ -0,0 +1,66 @@
+import type { Embedder } from "../embedder.ts";
+
+export type OpenAIEmbedderOptions = {
+  apiKey: string;
+  model?: string;
+  baseUrl?: string;
+  dimensions?: number;
+};
+
+/**
+ * Creates an embedder that calls an OpenAI-compatible `/v1/embeddings` endpoint.
+ * Works with OpenAI, LM Studio, Ollama, vLLM, etc. — anything that exposes the
+ * OpenAI embeddings API shape.
+ */
+export function createOpenAIEmbedder(options: OpenAIEmbedderOptions): Embedder {
+  const model = options.model ?? "text-embedding-3-small";
+  const baseUrl = (options.baseUrl ?? "https://api.openai.com/v1").replace(
+    /\/$/,
+    "",
+  );
+  const knownDimensions: Record<string, number> = {
+    "text-embedding-3-small": 1536,
+    "text-embedding-3-large": 3072,
+    "text-embedding-ada-002": 1536,
+  };
+  const expectedDimensions = options.dimensions ?? knownDimensions[model];
+
+  return {
+    ...(expectedDimensions ? { dimensions: expectedDimensions } : {}),
+    embed: async (text: string): Promise<Float32Array> => {
+      const response = await fetch(`${baseUrl}/embeddings`, {
+        method: "POST",
+        headers: {
+          Authorization: `Bearer ${options.apiKey}`,
+          "Content-Type": "application/json",
+        },
+        body: JSON.stringify({ model, input: text }),
+      });
+
+      if (!response.ok) {
+        const body = await response.text().catch(() => "(no body)");
+        throw new Error(
+          `OpenAI embeddings request failed: ${response.status} ${body}`,
+        );
+      }
+
+      const json = (await response.json()) as {
+        data: Array<{ embedding: number[] }>;
+      };
+
+      const embedding = json.data[0];
+      if (!embedding?.embedding) {
+        throw new Error("OpenAI returned no embeddings");
+      }
+
+      const vector = new Float32Array(embedding.embedding);
+      if (expectedDimensions && vector.length !== expectedDimensions) {
+        throw new Error(
+          `Embedding dimension mismatch for model ${model}: expected ${expectedDimensions}, got ${vector.length}. Update noodle embedding.dimensions or switch to a matching model/provider.`,
+        );
+      }
+
+      return vector;
+    },
+  };
+}