@tanstack-ai-browser/apfel 0.0.1 → 0.2.0

package/src/availability.test.ts

@@ -0,0 +1,61 @@
+import assert from "node:assert/strict"
+import { afterEach, test } from "node:test"
+
+import { apfelText } from "./adapter.js"
+
+const baseURL = "http://apfel.test/v1"
+const originalFetch = globalThis.fetch
+afterEach(() => {
+  globalThis.fetch = originalFetch
+})
+
+test("available when apfel lists the model at the adapter's baseURL; create resolves to the adapter", async () => {
+  const asked: Array<{ url: string; headers: unknown }> = []
+  globalThis.fetch = (async (url: string, init: RequestInit) => {
+    asked.push({ url, headers: init.headers })
+    return Response.json({ data: [{ id: "apple-foundationmodel" }] })
+  }) as typeof fetch
+  const adapter = apfelText("apple-foundationmodel", { baseURL, defaultHeaders: { Authorization: "Bearer t" } })
+  assert.equal(await adapter.availability(), "available")
+  assert.deepEqual(asked[0], { url: `${baseURL}/models`, headers: { Authorization: "Bearer t" } })
+  assert.equal(await adapter.create(), adapter)
+})
+
+test("unavailable when apfel doesn't answer, fails, or doesn't serve the model; create rejects", async () => {
+  const adapter = apfelText("apple-foundationmodel", { baseURL })
+  globalThis.fetch = (async () => {
+    throw new TypeError("Failed to fetch")
+  }) as typeof fetch
+  assert.equal(await adapter.availability(), "unavailable")
+  await assert.rejects(adapter.create(), /didn't answer/)
+  globalThis.fetch = (async () => new Response("no", { status: 500 })) as typeof fetch
+  assert.equal(await adapter.availability(), "unavailable")
+  globalThis.fetch = (async () => Response.json({ data: [{ id: "other" }] })) as typeof fetch
+  assert.equal(await adapter.availability(), "unavailable")
+})
+
+test("create's signal: aborted before, nothing is asked; aborting during the check stops it with an AbortError", async () => {
+  let asked = 0
+  let requestSignal: AbortSignal | undefined
+  globalThis.fetch = ((_url: string, init: RequestInit) => {
+    asked++
+    requestSignal = init.signal ?? undefined
+    return new Promise<Response>((_resolve, reject) =>
+      init.signal?.addEventListener("abort", () => reject(init.signal?.reason))
+    )
+  }) as typeof fetch
+  const adapter = apfelText("apple-foundationmodel", { baseURL })
+  await assert.rejects(adapter.create({ signal: AbortSignal.abort() }), { name: "AbortError" })
+  assert.equal(asked, 0)
+  const controller = new AbortController()
+  const checking = adapter.create({ signal: controller.signal })
+  controller.abort()
+  await assert.rejects(checking, { name: "AbortError" })
+  assert.equal(requestSignal?.aborted, true, "the request was stopped")
+})
+
+test("the model is optional: Apple's by default, with or without a config; any other name apfel serves", () => {
+  assert.equal(apfelText().model, "apple-foundationmodel")
+  assert.equal(apfelText({ baseURL: "http://localhost:1/v1" }).model, "apple-foundationmodel")
+  assert.equal(apfelText("some-other-model").model, "some-other-model")
+})

package/src/index.ts

@@ -1,11 +1,8 @@
 /**
  * TanStack AI adapter for Apple's on-device Foundation Model, served by apfel.
+ * The model catalog (model-meta.ts) is exported here too.
  */
-export {
-  APFEL_BASE_URL,
-  APFEL_MODEL,
-  ApfelTextAdapter,
-  apfel,
-  isApfelAvailable
-} from "./adapter.js"
-export type { ApfelModelOptions, ApfelOptions, ApfelStats } from "./adapter.js"
+export { apfelText } from "./adapter.js"
+export type { ApfelConfig, ApfelModel, ApfelTextAdapter, ApfelTextModelOptions, Availability } from "./adapter.js"
+export { APFEL_CHAT_MODELS, APFEL_MODEL_META } from "./model-meta.js"
+export type { ApfelChatModel, ApfelModelMeta } from "./model-meta.js"

package/src/model-meta.ts

@@ -0,0 +1,37 @@
+/**
+ * The models apfel serves: Apple's on-device Foundation Model, with what it
+ * supports. It doesn't reason, so `chat()` offers no `reasoning` option for it.
+ * It reads images on macOS 27 and later; on older macOS apfel gives it only
+ * text read from the image.
+ */
+
+/** What a model apfel serves supports. */
+export type ApfelModelMeta = {
+  /** The model's id, as apfel lists it. */
+  name: string
+  supports: {
+    input: ReadonlyArray<"text" | "image">
+    output: ReadonlyArray<"text">
+    capabilities: ReadonlyArray<"tools">
+  }
+}
+
+const APPLE_FOUNDATION_MODEL = {
+  name: "apple-foundationmodel",
+  supports: {
+    input: ["text", "image"],
+    output: ["text"],
+    capabilities: ["tools"]
+  }
+} as const satisfies ApfelModelMeta
+
+/** The models apfel serves: Apple's on-device Foundation Model. */
+export const APFEL_CHAT_MODELS = [APPLE_FOUNDATION_MODEL.name] as const
+
+/** A model apfel serves. */
+export type ApfelChatModel = (typeof APFEL_CHAT_MODELS)[number]
+
+/** Each model's metadata, by name. */
+export const APFEL_MODEL_META: Readonly<Record<ApfelChatModel, ApfelModelMeta>> = {
+  [APPLE_FOUNDATION_MODEL.name]: APPLE_FOUNDATION_MODEL
+}

package/src/tool-calls.ts

@@ -1,134 +0,0 @@
-/**
- * Tool calls Apple's model writes as text. apfel turns the model's tool
- * calls into OpenAI `tool_calls`, but when it doesn't recognize one it
- * passes it on as text instead, like
- * `{"tool_calls": [{"function": "get_weather", "arguments": {…}}]}`.
- */
-
-export type ParsedToolCall = { name: string; args: Record<string, unknown> }
-
-/** Where Apple's model starts a tool call it writes as text. */
-export const JSON_TOOL_CALLS_MARKER = '{"tool_calls"'
-
-/** The `{…}` that starts at `text[start]`, braces in strings ignored. */
-function balancedObject(text: string, start: number) {
-  let depth = 0
-  let inString = false
-  for (let i = start; i < text.length; i++) {
-    const c = text[i]
-    if (inString) {
-      if (c === "\\") i++
-      else if (c === '"') inString = false
-    } else if (c === '"') inString = true
-    else if (c === "{") depth++
-    else if (c === "}" && --depth === 0) return text.slice(start, i + 1)
-  }
-  return null
-}
-
-/** JSON arguments, read leniently: stray strings without a key are dropped. */
-function parseJsonArgs(raw: string): Record<string, unknown> | null {
-  for (const candidate of [raw, raw.replace(/,\s*"[^"]*"\s*(?=[,}])/g, "")]) {
-    try {
-      const value = JSON.parse(candidate) as unknown
-      const args = typeof value === "string" ? JSON.parse(value) : value
-      if (args && typeof args === "object") {
-        return args as Record<string, unknown>
-      }
-    } catch {
-      // Try the next reading.
-    }
-  }
-  return null
-}
-
-/**
- * Tool calls Apple's model wrote as JSON text. Its JSON varies and is often
- * broken (`"function": "name"`, `"name: "name"`, stray strings in the
- * arguments), so instead of parsing the whole thing, this finds each quoted
- * name of a tool that exists and reads the `"arguments"` object after it.
- */
-export function parseJsonToolCalls(
-  text: string,
-  toolNames: Iterable<string>
-): Array<ParsedToolCall> {
-  const mentions: Array<{ name: string; at: number }> = []
-  for (const name of toolNames) {
-    const quoted = `"${name}"`
-    for (
-      let at = text.indexOf(quoted);
-      at >= 0;
-      at = text.indexOf(quoted, at + 1)
-    ) {
-      mentions.push({ name, at })
-    }
-  }
-  mentions.sort((a, b) => a.at - b.at)
-  const calls: Array<ParsedToolCall> = []
-  mentions.forEach(({ name, at }, i) => {
-    // The arguments belong to the last mention of a name before them. The
-    // model sometimes writes a broken "arguments" and then a good one: the
-    // first that reads is used.
-    const part = text.slice(at, mentions[i + 1]?.at ?? text.length)
-    for (const key of part.matchAll(/"arguments"?\s*:\s*/g)) {
-      const from = key.index + key[0].length
-      const raw =
-        part[from] === "{"
-          ? balancedObject(part, from)
-          : /^"(?:[^"\\]|\\.)*"/.exec(part.slice(from))?.[0]
-      const args = raw ? parseJsonArgs(raw) : null
-      if (args) {
-        calls.push({ name, args })
-        return
-      }
-    }
-  })
-  return calls
-}
-
-/** Length of the longest end of `text` that could start `marker`. */
-function partialMarker(text: string, marker: string) {
-  for (let n = Math.min(text.length, marker.length); n > 0; n--) {
-    if (marker.startsWith(text.slice(-n))) return n
-  }
-  return 0
-}
-
-/**
- * Splits a streaming answer into the text before the first tool call written
- * as text (passed through as it arrives) and the tool-call JSON after it
- * (held back and parsed once the reply ends).
- */
-export function createToolCallSplitter(marker = JSON_TOOL_CALLS_MARKER) {
-  let held = ""
-  let markup: string | null = null
-
-  /** Text that can be shown now. */
-  function push(text: string) {
-    if (markup !== null) {
-      markup += text
-      return ""
-    }
-    held += text
-    const at = held.indexOf(marker)
-    if (at >= 0) {
-      const before = held.slice(0, at)
-      markup = held.slice(at)
-      held = ""
-      return before
-    }
-    const keep = partialMarker(held, marker)
-    const out = held.slice(0, held.length - keep)
-    held = held.slice(out.length)
-    return out
-  }
-
-  /** The rest of the text, and the tool-call JSON if any. */
-  function flush() {
-    const rest = held
-    held = ""
-    return { text: rest, markup }
-  }
-
-  return { push, flush }
-}