@bojackduy/opencode-telescope 0.1.24 → 0.1.25

package/components/preview.tsx

@@ -14,6 +14,17 @@ import {
   toolLabel,
   truncate,
 } from "../ui/format.ts"
+import {
+  clippedText,
+  containsOrderedTokens,
+  conversationMatch,
+  filetype,
+  matchExcerpt,
+  parseApplyPatchFiles,
+  recordValue,
+  shortPath,
+  stringValue,
+} from "../ui/preview-utils.ts"
 
 export const PreviewHeader = (props: { item: SearchResult | undefined; query: string; theme: TuiThemeCurrent }) => (
   <box
@@ -37,7 +48,9 @@ export const PreviewHeader = (props: { item: SearchResult | undefined; query: st
           </box>
           <Show when={props.query.trim()}>
             <box width="100%" flexShrink={0}>
-              <text fg={props.theme.textMuted} wrapMode="none" overflow="hidden">match: {props.query.trim()}</text>
+              <text fg={props.theme.textMuted} wrapMode="none" overflow="hidden">
+                {item().isVectorMatch ? "~semantic: " : "match: "}{props.query.trim()}
+              </text>
             </box>
           </Show>
         </>
@@ -305,10 +318,10 @@ const DiffBlock = (props: { diff: string; filePath: string; syntax: SyntaxStyle;
 const TargetMarker = (props: { part: ConversationPreviewPart; item?: SearchResult; role: string; time: number; theme: TuiThemeCurrent }) => (
   <box flexDirection="column" flexShrink={0}>
     <text fg={props.theme.warning} wrapMode="none" overflow="hidden">
-      <span>match</span>
+      <span>{props.item?.isVectorMatch ? "~semantic" : "match"}</span>
       <span style={{ fg: props.theme.textMuted }}> · {props.role} · {compactTime(props.time)}</span>
     </text>
-    <Show when={props.item && matchExcerpt(props.part.text, props.item.match)}>
+    <Show when={props.item && !props.item.isVectorMatch && matchExcerpt(props.part.text, props.item.match)}>
       {(excerpt) => (
         <text fg={props.theme.textMuted} wrapMode="none" overflow="hidden">
           <span>{excerpt().before}</span>
@@ -317,13 +330,24 @@ const TargetMarker = (props: { part: ConversationPreviewPart; item?: SearchResul
         </text>
       )}
     </Show>
+    <Show when={props.item?.isVectorMatch && props.item}>
+      {(item) => (
+        <text fg={props.theme.textMuted} wrapMode="none" overflow="hidden">
+          {item().text.slice(0, 200)}
+        </text>
+      )}
+    </Show>
   </box>
 )
 
 const HighlightedConversationText = (props: { part: ConversationPreviewPart; item: SearchResult; theme: TuiThemeCurrent }) => {
-  const match = createMemo(() => conversationMatch(props.part, props.item))
+  const match = createMemo(() => conversationMatch(props.part.text, props.part.target, props.item.match))
   return (
-    <Show when={match()} fallback={<text fg={props.theme.text}>{props.part.text}</text>}>
+    <Show when={match()} fallback={
+      <text fg={props.item.isVectorMatch ? props.theme.textMuted : props.theme.text}>
+        {props.item.isVectorMatch ? `~ ${props.part.text}` : props.part.text}
+      </text>
+    }>
       {(hit) => (
         <text fg={props.theme.text}>
           <span>{props.part.text.slice(0, hit().start)}</span>
@@ -371,152 +395,15 @@ function searchResultPreviewPart(item: SearchResult): ConversationPreviewPart {
   }
 }
 
-function conversationMatch(part: ConversationPreviewPart, item: SearchResult) {
-  if (!part.target || !item.match) return
-  const tokens = item.match.split(/\s+/)
-  const lowerText = part.text.toLowerCase()
-  let searchPos = 0
-  let firstStart = -1
-  let lastEnd = -1
-  for (const token of tokens) {
-    const index = lowerText.indexOf(token.toLowerCase(), searchPos)
-    if (index === -1) return
-    if (firstStart === -1) firstStart = index
-    searchPos = index + token.length
-    lastEnd = searchPos
-  }
-  return { start: firstStart, end: lastEnd }
-}
-
 function conversationMarkdown(part: ConversationPreviewPart, item: SearchResult) {
-  const hit = conversationMatch(part, item)
+  const hit = conversationMatch(part.text, part.target, item.match)
   if (!hit || !item.previewHighlight) return part.text
   return markdownWithMatch(part.text.slice(0, hit.start), part.text.slice(hit.start, hit.end), part.text.slice(hit.end), true)
 }
 
-function matchExcerpt(text: string, query: string, radius = 80) {
-  const needle = query.trim()
-  if (!needle) return
-  const tokens = needle.split(/\s+/)
-  const lowerText = text.toLowerCase()
-  let searchPos = 0
-  let firstStart = -1
-  let lastEnd = -1
-  for (const token of tokens) {
-    const start = lowerText.indexOf(token.toLowerCase(), searchPos)
-    if (start === -1) return
-    if (firstStart === -1) firstStart = start
-    searchPos = start + token.length
-    lastEnd = searchPos
-  }
-  const beforeStart = Math.max(0, firstStart - radius)
-  const afterEnd = Math.min(text.length, lastEnd + radius)
-  return {
-    before: `${beforeStart > 0 ? "..." : ""}${text.slice(beforeStart, firstStart).replace(/\s+/g, " ")}`,
-    match: text.slice(firstStart, lastEnd),
-    after: `${text.slice(lastEnd, afterEnd).replace(/\s+/g, " ")}${afterEnd < text.length ? "..." : ""}`,
-  }
-}
-
-function clippedText(text: string, query: string, radiusLines: number) {
-  const lines = text.split("\n")
-  const tooLarge = text.length > 30000 || lines.length > 420
-  if (!tooLarge) return { text, clipped: false }
-
-  const matchLine = findOrderedTokenLine(lines, query)
-  if (matchLine === -1) {
-    return { text: lines.slice(0, radiusLines * 2).join("\n"), clipped: true }
-  }
-
-  const start = Math.max(0, matchLine - radiusLines)
-  const end = Math.min(lines.length, matchLine + radiusLines + 1)
-  return {
-    text: [
-      start > 0 ? `... ${start} lines omitted ...` : undefined,
-      ...lines.slice(start, end),
-      end < lines.length ? `... ${lines.length - end} lines omitted ...` : undefined,
-    ].filter(Boolean).join("\n"),
-    clipped: true,
-  }
-}
-
-function findOrderedTokenLine(lines: string[], query: string) {
-  const tokens = query.trim().split(/\s+/).filter(Boolean)
-  if (tokens.length === 0) return -1
-  for (let index = 0; index < lines.length; index++) {
-    if (containsOrderedTokens(lines[index]!, query)) return index
-  }
-  return -1
-}
-
-function containsOrderedTokens(text: string, query: string) {
-  const tokens = query.trim().split(/\s+/).filter(Boolean)
-  if (tokens.length === 0) return false
-  const lower = text.toLowerCase()
-  let searchPos = 0
-  for (const token of tokens) {
-    const index = lower.indexOf(token.toLowerCase(), searchPos)
-    if (index === -1) return false
-    searchPos = index + token.length
-  }
-  return true
-}
-
-function parseApplyPatchFiles(metadata: unknown) {
-  const files = recordValue(metadata)?.files
-  if (!Array.isArray(files)) return []
-  return files.flatMap((item) => {
-    const file = recordValue(item)
-    const filePath = stringValue(file?.filePath)
-    const relativePath = stringValue(file?.relativePath) ?? filePath
-    const patch = stringValue(file?.patch)
-    const type = stringValue(file?.type) ?? "update"
-    const deletions = numberValue(file?.deletions) ?? 0
-    if (!filePath || !relativePath || patch === undefined) return []
-    return [{ filePath, relativePath, patch, type, deletions }]
-  })
-}
-
 function patchTitle(file: { type: string; relativePath: string; filePath: string; deletions: number }) {
   if (file.type === "delete") return `# Deleted ${file.relativePath}`
   if (file.type === "add") return `# Created ${file.relativePath}`
   if (file.type === "move") return `# Moved ${shortPath(file.filePath)} -> ${file.relativePath}`
   return `← Patched ${file.relativePath}`
 }
-
-function recordValue(value: unknown): Record<string, unknown> | undefined {
-  if (!value || typeof value !== "object" || Array.isArray(value)) return
-  return value as Record<string, unknown>
-}
-
-function stringValue(value: unknown) {
-  return typeof value === "string" ? value : undefined
-}
-
-function numberValue(value: unknown) {
-  return typeof value === "number" && Number.isFinite(value) ? value : undefined
-}
-
-function shortPath(value: string) {
-  if (!value) return "file"
-  const parts = value.split(/[\\/]/)
-  return parts.slice(-3).join("/")
-}
-
-function filetype(input: string) {
-  const ext = input.split(".").at(-1)?.toLowerCase()
-  if (!ext || ext === input.toLowerCase()) return "none"
-  if (["ts", "tsx", "js", "jsx", "mts", "cts"].includes(ext)) return "typescript"
-  if (ext === "py") return "python"
-  if (ext === "go") return "go"
-  if (ext === "rs") return "rust"
-  if (ext === "rb") return "ruby"
-  if (ext === "java") return "java"
-  if (ext === "json") return "json"
-  if (ext === "md") return "markdown"
-  if (ext === "yml" || ext === "yaml") return "yaml"
-  if (ext === "sql") return "sql"
-  if (ext === "sh" || ext === "bash" || ext === "zsh") return "shellscript"
-  if (ext === "diff" || ext === "patch") return "diff"
-  return ext
-}

package/components/result-list.tsx

@@ -30,6 +30,9 @@ export const ResultRow = (props: {
       <span style={{ fg: props.active ? props.theme.accent : props.theme.text, bold: true }}>
         {truncate(props.item.sessionTitle, sessionTitleWidth(props.width))}
       </span>
+      <Show when={props.item.isVectorMatch}>
+        <span style={{ fg: props.theme.warning }}> ~</span>
+      </Show>
       <Show when={props.width >= 48}>
         <span style={{ fg: props.theme.textMuted }}>  </span>
         <span style={{ fg: roleColor(props.item.role, props.theme), bold: true }}>{roleLabel(props.item.role)}</span>
@@ -46,10 +49,12 @@ export const ResultRow = (props: {
       before={props.item.before}
       match={props.item.match}
       after={props.item.after}
+      excerpt={props.item.excerpt}
       query={props.query}
       active={props.active}
       theme={props.theme}
       maxWidth={props.width}
+      isVectorMatch={props.item.isVectorMatch}
     />
   </box>
 )
@@ -86,17 +91,28 @@ const HighlightedText = (props: {
   before: string
   match: string
   after: string
+  excerpt: string
   query: string
   active: boolean
   theme: TuiThemeCurrent
   maxWidth: number
+  isVectorMatch: boolean
 }) => {
   const textMax = Math.max(10, props.maxWidth - 2)
   const sideMax = Math.floor(textMax * 0.35)
   const matchMax = textMax - sideMax * 2
   const before = truncate(props.before, sideMax)
-  const match = truncate(props.match || props.query, matchMax)
   const after = truncate(props.after, sideMax)
+  if (props.isVectorMatch) {
+    return (
+      <text wrapMode="none" overflow="hidden">
+        <span style={{ fg: props.theme.textMuted }}>  </span>
+        <span style={{ fg: props.theme.warning }}>~ </span>
+        <span style={{ fg: props.active ? props.theme.text : props.theme.textMuted }}>{truncate(props.excerpt, textMax - 2)}</span>
+      </text>
+    )
+  }
+  const match = truncate(props.match || props.query, matchMax)
   return (
     <text wrapMode="none" overflow="hidden">
       <span style={{ fg: props.theme.textMuted }}>  </span>

package/package.json

@@ -1,7 +1,7 @@
 {
   "$schema": "https://json.schemastore.org/package.json",
   "name": "@bojackduy/opencode-telescope",
-  "version": "0.1.24",
+  "version": "0.1.25",
   "description": "OpenCode TUI plugin for fuzzy and semantic search across local conversation history, session transcripts, and AI coding chats",
   "type": "module",
   "license": "MIT",
@@ -54,6 +54,7 @@
     "tui.tsx",
     "telescope.tsx",
     "search.ts",
+    "search",
     "components",
     "ui",
     "tsconfig.json"

package/search/db-path.ts

@@ -0,0 +1,67 @@
+import { existsSync, readdirSync, statSync } from "node:fs"
+import { homedir } from "node:os"
+import path from "node:path"
+
+export function resolveDatabasePath() {
+  if (cachedDbPath) return cachedDbPath
+  if (process.env.OPENCODE_DB) {
+    if (process.env.OPENCODE_DB === ":memory:" || path.isAbsolute(process.env.OPENCODE_DB)) return cachedDbPath = process.env.OPENCODE_DB
+    return cachedDbPath = path.join(candidateDataDirs()[0] ?? defaultDataDir(), process.env.OPENCODE_DB)
+  }
+  if (process.env.OPENCODE_DISABLE_CHANNEL_DB === "1" || process.env.OPENCODE_DISABLE_CHANNEL_DB === "true") {
+    return cachedDbPath = requireExistingDatabase(["opencode.db"])
+  }
+  const stable = candidateDatabasePaths(["opencode.db"]).find(existsSync)
+  if (stable) return cachedDbPath = stable
+  if (process.env.OPENCODE_CHANNEL) {
+    const channel = process.env.OPENCODE_CHANNEL.replace(/[^a-zA-Z0-9._-]/g, "-")
+    const candidate = candidateDatabasePaths([`opencode-${channel}.db`]).find(existsSync)
+    if (candidate) return cachedDbPath = candidate
+  }
+  const fallback = candidateDatabasePaths(["opencode.db"])[0] ?? path.join(defaultDataDir(), "opencode.db")
+  try {
+    const discovered = candidateDataDirs()
+      .flatMap((dir) =>
+        readdirSync(dir, { withFileTypes: true })
+          .filter((entry) => entry.isFile() && /^opencode-.+\.db$/.test(entry.name))
+          .map((entry) => path.join(dir, entry.name)),
+      )
+      .at(0)
+    return cachedDbPath = discovered ?? fallback
+  } catch {
+    return cachedDbPath = fallback
+  }
+}
+
+export function searchIndexPath(sourcePath: string) {
+  const parsed = path.parse(sourcePath)
+  return path.join(parsed.dir, `${parsed.name}-telescope-search.db`)
+}
+
+export function candidateDataDirs() {
+  return [
+    defaultDataDir(),
+    path.join(homedir(), ".local", "share", "opencode"),
+    process.platform === "darwin" ? path.join(homedir(), "Library", "Application Support", "opencode") : undefined,
+    process.platform === "win32" ? path.join(process.env.APPDATA ?? path.join(homedir(), "AppData", "Roaming"), "opencode") : undefined,
+  ].filter((item, index, list): item is string => Boolean(item) && list.indexOf(item) === index)
+}
+
+function defaultDataDir() {
+  if (process.env.XDG_DATA_HOME) return path.join(process.env.XDG_DATA_HOME, "opencode")
+  return path.join(homedir(), ".local", "share", "opencode")
+}
+
+function candidateDatabasePaths(names: string[]) {
+  return candidateDataDirs().flatMap((dir) => names.map((name) => path.join(dir, name)))
+}
+
+function requireExistingDatabase(names: string[]) {
+  return candidateDatabasePaths(names).find(existsSync) ?? candidateDatabasePaths(names)[0]!
+}
+
+let cachedDbPath: string | undefined
+
+export function clearDbPathCache() {
+  cachedDbPath = undefined
+}

package/search/dependencies.test.ts

@@ -0,0 +1,38 @@
+import { describe, expect, test } from "bun:test"
+import { checkEmbeddingServer, checkSqliteVec, checkCustomSqlite } from "./dependencies.ts"
+
+describe("dependency checks", () => {
+  test("checkEmbeddingServer returns unavailable when fetch fails", async () => {
+    const originalFetch = globalThis.fetch
+    globalThis.fetch = (async () => { throw new Error("fetch failed") }) as unknown as typeof fetch
+    try {
+      const result = await checkEmbeddingServer("http://localhost:1")
+      expect(result.state).toBe("unavailable")
+    } finally {
+      globalThis.fetch = originalFetch
+    }
+  })
+
+  test("checkSqliteVec returns unavailable without a path", () => {
+    const result = checkSqliteVec()
+    expect(result.state).toBe("unavailable")
+    expect(result.message).toContain("sqlite-vec")
+  })
+
+  test("checkSqliteVec returns unavailable for nonexistent path", () => {
+    const result = checkSqliteVec("/nonexistent/vec.so")
+    expect(result.state).toBe("unavailable")
+    expect(result.message).toContain("/nonexistent/vec.so")
+  })
+
+  test("checkCustomSqlite returns unavailable without a path", () => {
+    const result = checkCustomSqlite()
+    expect(result.state).toBe("unavailable")
+  })
+
+  test("checkCustomSqlite returns unavailable for nonexistent path", () => {
+    const result = checkCustomSqlite("/nonexistent/libsqlite.dylib")
+    expect(result.state).toBe("unavailable")
+    expect(result.message).toContain("/nonexistent/libsqlite.dylib")
+  })
+})

package/search/dependencies.ts

@@ -0,0 +1,63 @@
+import { Database } from "bun:sqlite"
+import { existsSync } from "node:fs"
+
+export type DependencyState = "available" | "unavailable" | "disabled"
+
+export type DependencyStatus = {
+  state: DependencyState
+  message: string
+}
+
+export function checkEmbeddingServer(baseUrl: string): Promise<DependencyStatus> {
+  return checkEmbeddingServerInner(baseUrl)
+}
+
+async function checkEmbeddingServerInner(baseUrl: string): Promise<DependencyStatus> {
+  for (const endpoint of ["/health", "/v1/health"]) {
+    try {
+      const response = await fetch(new URL(endpoint, baseUrl), { signal: AbortSignal.timeout(3000) })
+      if (response.ok) return { state: "available", message: "embedding server is reachable" }
+    } catch {
+      continue
+    }
+  }
+  return { state: "unavailable", message: "embedding server did not respond on any health endpoint" }
+}
+
+export function checkSqliteVec(sqliteVecPath?: string): DependencyStatus {
+  if (sqliteVecPath || process.env.OPENCODE_TELESCOPE_SQLITE_VEC_EXT) {
+    const resolved = sqliteVecPath ?? process.env.OPENCODE_TELESCOPE_SQLITE_VEC_EXT!
+    if (!existsSync(resolved)) {
+      return { state: "unavailable", message: `vec0 extension not found at: ${resolved}` }
+    }
+    try {
+      const db = new Database(":memory:")
+      db.loadExtension(resolved)
+      db.close()
+      return { state: "available", message: `vec0 extension loaded from: ${resolved}` }
+    } catch (err) {
+      return { state: "unavailable", message: `vec0 extension failed to load: ${err instanceof Error ? err.message : String(err)}` }
+    }
+  }
+  return { state: "unavailable", message: "sqlite-vec npm package or explicit extension path required" }
+}
+
+export function checkCustomSqlite(libPath?: string): DependencyStatus {
+  const candidate = libPath
+    ?? process.env.OPENCODE_TELESCOPE_SQLITE_LIB
+    ?? (process.platform === "darwin" ? "/opt/homebrew/opt/sqlite/lib/libsqlite3.dylib" : undefined)
+  if (!candidate) {
+    return { state: "unavailable", message: "no custom SQLite library path available" }
+  }
+  if (!existsSync(candidate)) {
+    return { state: "unavailable", message: `custom SQLite library not found at: ${candidate}` }
+  }
+  try {
+    if (Database.setCustomSQLite(candidate)) {
+      return { state: "available", message: `custom SQLite set to: ${candidate}` }
+    }
+    return { state: "unavailable", message: "Database.setCustomSQLite returned false" }
+  } catch (err) {
+    return { state: "unavailable", message: `Database.setCustomSQLite failed: ${err instanceof Error ? err.message : String(err)}` }
+  }
+}

package/search/embedding.test.ts

@@ -0,0 +1,83 @@
+import { afterEach, describe, expect, test } from "bun:test"
+import { LlamaEmbeddingClient } from "./embedding.ts"
+
+const originalFetch = globalThis.fetch
+afterEach(() => {
+  globalThis.fetch = originalFetch
+})
+
+describe("LlamaEmbeddingClient", () => {
+  const client = new LlamaEmbeddingClient({
+    baseUrl: "http://localhost:9999",
+    documentPrefix: "search_document: ",
+    queryPrefix: "search_query: ",
+  })
+
+  test("health returns false for unreachable server", async () => {
+    const result = await client.health()
+    expect(result).toBe(false)
+  })
+
+  test("embedQuery prefixes with query prefix", async () => {
+    const inputs: string[] = []
+    globalThis.fetch = (async (url: RequestInfo | URL) => {
+      if (typeof url === "string" && url.includes("/v1/embeddings")) {
+        inputs.push("called")
+      }
+      return new Response(null, { status: 500 })
+    }) as unknown as typeof fetch
+
+    await expect(client.embedQuery("test query")).rejects.toThrow()
+  })
+
+  test("embedDocuments prefixes with document prefix", async () => {
+    globalThis.fetch = (async (_url: RequestInfo | URL, init?: RequestInit) => {
+      const body = JSON.parse(typeof init?.body === "string" ? init.body : "{}")
+      expect(body.input).toEqual(["search_document: doc1", "search_document: doc2"])
+      return new Response(JSON.stringify({
+        data: [
+          { index: 0, embedding: [0.1, 0.2, 0.3] },
+          { index: 1, embedding: [0.4, 0.5, 0.6] },
+        ],
+      }), { status: 200 })
+    }) as unknown as typeof fetch
+
+    const result = await client.embedDocuments(["doc1", "doc2"])
+    expect(result).toHaveLength(2)
+    expect(result[0]).toBeInstanceOf(Float32Array)
+    expect(result[0][0]).toBeCloseTo(0.1, 5)
+    expect(result[1][2]).toBeCloseTo(0.6, 5)
+  })
+
+  test("embedQuery returns single vector", async () => {
+    globalThis.fetch = (async () => {
+      return new Response(JSON.stringify({
+        data: [{ index: 0, embedding: [0.5, 0.5] }],
+      }), { status: 200 })
+    }) as unknown as typeof fetch
+
+    const result = await client.embedQuery("hello")
+    expect(result).toBeInstanceOf(Float32Array)
+    expect(result).toHaveLength(2)
+  })
+
+  test("rejects non-array embedding", async () => {
+    globalThis.fetch = (async () => {
+      return new Response(JSON.stringify({
+        data: [{ index: 0, embedding: "not-an-array" }],
+      }), { status: 200 })
+    }) as unknown as typeof fetch
+
+    await expect(client.embedQuery("test")).rejects.toThrow()
+  })
+
+  test("rejects embedding with non-finite values", async () => {
+    globalThis.fetch = (async () => {
+      return new Response(JSON.stringify({
+        data: [{ index: 0, embedding: [1, "not-a-number", 3] }],
+      }), { status: 200 })
+    }) as unknown as typeof fetch
+
+    await expect(client.embedQuery("test")).rejects.toThrow()
+  })
+})

package/search/embedding.ts

@@ -0,0 +1,67 @@
+export type EmbeddingConfig = {
+  baseUrl: string
+  model?: string
+  documentPrefix: string
+  queryPrefix: string
+}
+
+type EmbeddingResponse = {
+  data?: Array<{
+    index?: number
+    embedding?: unknown
+  }>
+  model?: string
+}
+
+export class LlamaEmbeddingClient {
+  constructor(private readonly config: EmbeddingConfig) {}
+
+  async health() {
+    for (const endpoint of ["/health", "/v1/health"]) {
+      try {
+        const response = await fetch(new URL(endpoint, this.config.baseUrl))
+        if (response.ok) return true
+      } catch {
+        continue
+      }
+    }
+    return false
+  }
+
+  async embedQuery(query: string) {
+    return this.embed([this.config.queryPrefix + query]).then((items) => items[0])
+  }
+
+  async embedDocuments(documents: string[]) {
+    return this.embed(documents.map((document) => this.config.documentPrefix + document))
+  }
+
+  private async embed(inputs: string[]) {
+    const response = await fetch(new URL("/v1/embeddings", this.config.baseUrl), {
+      method: "POST",
+      headers: { "content-type": "application/json" },
+      body: JSON.stringify({
+        model: this.config.model ?? "local-embedding",
+        input: inputs,
+        encoding_format: "float",
+      }),
+    })
+    if (!response.ok) throw new Error(`Embedding request failed: ${response.status}`)
+
+    const payload = (await response.json()) as EmbeddingResponse
+    if (!payload.data || payload.data.length !== inputs.length) {
+      throw new Error("Embedding response did not contain one vector per input")
+    }
+
+    return [...payload.data]
+      .sort((a, b) => (a.index ?? 0) - (b.index ?? 0))
+      .map((item) => {
+        if (!Array.isArray(item.embedding)) throw new Error("Embedding response contained a non-array embedding")
+        const values = item.embedding.map((value: unknown) => Number(value))
+        if (values.some((value) => !Number.isFinite(value))) {
+          throw new Error("Embedding response contained non-finite values")
+        }
+        return new Float32Array(values)
+      })
+  }
+}