apple-llm 0.1.0 → 0.2.0

package/dist/chunk-NRDZIP5G.cjs

@@ -0,0 +1,2588 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true}); function _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj; } else { var newObj = {}; if (obj != null) { for (var key in obj) { if (Object.prototype.hasOwnProperty.call(obj, key)) { newObj[key] = obj[key]; } } } newObj.default = obj; return newObj; } } function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; } function _nullishCoalesce(lhs, rhsFn) { if (lhs != null) { return lhs; } else { return rhsFn(); } } async function _asyncNullishCoalesce(lhs, rhsFn) { if (lhs != null) { return lhs; } else { return await rhsFn(); } } function _optionalChain(ops) { let lastAccessLHS = undefined; let value = ops[0]; let i = 1; while (i < ops.length) { const op = ops[i]; const fn = ops[i + 1]; i += 2; if ((op === 'optionalAccess' || op === 'optionalCall') && value == null) { return undefined; } if (op === 'access' || op === 'optionalAccess') { lastAccessLHS = value; value = fn(value); } else if (op === 'call' || op === 'optionalCall') { value = fn((...args) => value.call(lastAccessLHS, ...args)); lastAccessLHS = undefined; } } return value; } async function _asyncOptionalChain(ops) { let lastAccessLHS = undefined; let value = ops[0]; let i = 1; while (i < ops.length) { const op = ops[i]; const fn = ops[i + 1]; i += 2; if ((op === 'optionalAccess' || op === 'optionalCall') && value == null) { return undefined; } if (op === 'access' || op === 'optionalAccess') { lastAccessLHS = value; value = await fn(value); } else if (op === 'call' || op === 'optionalCall') { value = await fn((...args) => value.call(lastAccessLHS, ...args)); lastAccessLHS = undefined; } } return value; } var _class; var _class2; var _class3; var _class4; var _class5; var _class6; var _class7; var _class8; var _class9; var _class10; var _class11; var _class12; var _class13; var _class14; var _class15; var _class16; var _class17;// node_modules/tsup/assets/cjs_shims.js
+var getImportMetaUrl = () => typeof document === "undefined" ? new URL(`file:${__filename}`).href : document.currentScript && document.currentScript.tagName.toUpperCase() === "SCRIPT" ? document.currentScript.src : new URL("main.js", document.baseURI).href;
+var importMetaUrl = /* @__PURE__ */ getImportMetaUrl();
+
+// src/errors.ts
+var AppleLLMError = (_class = class extends Error {
+  constructor(message, tier, options) {
+    super(message, _optionalChain([options, 'optionalAccess', _ => _.cause]) === void 0 ? void 0 : { cause: options.cause });_class.prototype.__init.call(this);;
+    this.tier = tier;
+    this.name = new.target.name;
+  }
+  
+  __init() {this.code = "APPLE_LLM_ERROR"}
+}, _class);
+var ModelUnavailableError = (_class2 = class extends AppleLLMError {
+  constructor(message, reason, tier, options) {
+    super(message, tier, options);_class2.prototype.__init2.call(this);;
+    this.reason = reason;
+  }
+  
+  __init2() {this.code = "MODEL_UNAVAILABLE"}
+}, _class2);
+var SchemaRejectedError = (_class3 = class extends AppleLLMError {constructor(...args2) { super(...args2); _class3.prototype.__init3.call(this); }
+  __init3() {this.code = "SCHEMA_REJECTED"}
+}, _class3);
+var SchemaValidationError = (_class4 = class extends AppleLLMError {
+  constructor(message, issues, text, tier) {
+    super(message, tier);_class4.prototype.__init4.call(this);;
+    this.issues = issues;
+    this.text = text;
+  }
+  
+  
+  __init4() {this.code = "SCHEMA_VALIDATION"}
+}, _class4);
+var ContextLengthError = (_class5 = class extends AppleLLMError {
+  constructor(message, tier, contextSize, tokenCount) {
+    super(message, tier);_class5.prototype.__init5.call(this);;
+    this.contextSize = contextSize;
+    this.tokenCount = tokenCount;
+  }
+  
+  
+  __init5() {this.code = "CONTEXT_LENGTH"}
+}, _class5);
+var QuotaError = (_class6 = class extends AppleLLMError {
+  constructor(message, tier, resetDate) {
+    super(message, tier);_class6.prototype.__init6.call(this);;
+    this.resetDate = resetDate;
+  }
+  
+  __init6() {this.code = "QUOTA"}
+}, _class6);
+var TimeoutError = (_class7 = class extends AppleLLMError {constructor(...args3) { super(...args3); _class7.prototype.__init7.call(this); }
+  __init7() {this.code = "TIMEOUT"}
+}, _class7);
+var AbortError = (_class8 = class extends AppleLLMError {constructor(...args4) { super(...args4); _class8.prototype.__init8.call(this); }
+  __init8() {this.code = "ABORTED"}
+}, _class8);
+var SetupRequiredError = (_class9 = class extends AppleLLMError {
+  constructor(message, step, tier) {
+    super(message, tier);_class9.prototype.__init9.call(this);;
+    this.step = step;
+  }
+  
+  __init9() {this.code = "SETUP_REQUIRED"}
+}, _class9);
+var RefusalError = (_class10 = class extends AppleLLMError {constructor(...args5) { super(...args5); _class10.prototype.__init10.call(this); }
+  __init10() {this.code = "REFUSAL"}
+}, _class10);
+var ToolExecutionError = (_class11 = class extends AppleLLMError {
+  constructor(message, toolName, options) {
+    super(message, "device", options);_class11.prototype.__init11.call(this);;
+    this.toolName = toolName;
+  }
+  
+  __init11() {this.code = "TOOL_EXECUTION"}
+}, _class11);
+var ModelBusyError = (_class12 = class extends AppleLLMError {constructor(...args6) { super(...args6); _class12.prototype.__init12.call(this); }
+  __init12() {this.code = "MODEL_BUSY"}
+}, _class12);
+var UnsupportedError = (_class13 = class extends AppleLLMError {constructor(...args7) { super(...args7); _class13.prototype.__init13.call(this); }
+  __init13() {this.code = "UNSUPPORTED"}
+}, _class13);
+function unavailableMessage(reason) {
+  const base = "Apple\u2019s on-device model is not available";
+  if (_optionalChain([reason, 'optionalAccess', _2 => _2.includes, 'call', _3 => _3("appleIntelligenceNotEnabled")])) {
+    return `${base}: Apple Intelligence is turned off.
+Enable it in System Settings \u203A Apple Intelligence & Siri, then try again.`;
+  }
+  if (_optionalChain([reason, 'optionalAccess', _4 => _4.includes, 'call', _5 => _5("modelNotReady")])) {
+    return `${base}: the model is still downloading.
+Leave the Mac online and plugged in for a few minutes, then try again.`;
+  }
+  if (_optionalChain([reason, 'optionalAccess', _6 => _6.includes, 'call', _7 => _7("deviceNotEligible")])) {
+    return `${base}: this Mac is not eligible for Apple Intelligence.`;
+  }
+  if (_optionalChain([reason, 'optionalAccess', _8 => _8.includes, 'call', _9 => _9("unsupportedPlatform")])) {
+    return `${base}: this platform is not supported (macOS on Apple Silicon only).`;
+  }
+  if (_optionalChain([reason, 'optionalAccess', _10 => _10.includes, 'call', _11 => _11("unsupportedOSVersion")])) {
+    return `${base}: needs macOS 26 or later.`;
+  }
+  if (_optionalChain([reason, 'optionalAccess', _12 => _12.includes, 'call', _13 => _13("noSwiftCompiler")])) {
+    return `${base}: no Swift compiler found.
+Install the Xcode command line tools with \`xcode-select --install\`, then try again.`;
+  }
+  return `${base}${reason ? `: ${reason}` : "."}`;
+}
+function toUnavailableReason(reason) {
+  if (_optionalChain([reason, 'optionalAccess', _14 => _14.includes, 'call', _15 => _15("appleIntelligenceNotEnabled")])) return "appleIntelligenceNotEnabled";
+  if (_optionalChain([reason, 'optionalAccess', _16 => _16.includes, 'call', _17 => _17("modelNotReady")])) return "modelNotReady";
+  if (_optionalChain([reason, 'optionalAccess', _18 => _18.includes, 'call', _19 => _19("deviceNotEligible")])) return "deviceNotEligible";
+  if (_optionalChain([reason, 'optionalAccess', _20 => _20.includes, 'call', _21 => _21("unsupportedPlatform")])) return "unsupportedPlatform";
+  if (_optionalChain([reason, 'optionalAccess', _22 => _22.includes, 'call', _23 => _23("unsupportedOSVersion")])) return "unsupportedOSVersion";
+  if (_optionalChain([reason, 'optionalAccess', _24 => _24.includes, 'call', _25 => _25("noSwiftCompiler")])) return "noSwiftCompiler";
+  return "unknown";
+}
+
+// src/json-recovery.ts
+function stripCodeFences(text) {
+  const trimmed = text.trim();
+  const fenced = /```(?:json)?\s*\n?([\s\S]*?)```/i.exec(trimmed);
+  if (_optionalChain([fenced, 'optionalAccess', _26 => _26[1]]) !== void 0) return fenced[1].trim();
+  if (trimmed.startsWith("```")) {
+    return trimmed.replace(/^```(?:json)?\s*/i, "").replace(/```\s*$/, "").trim();
+  }
+  return trimmed;
+}
+function extractJsonSpan(text) {
+  for (let start = 0; start < text.length; start += 1) {
+    const open = text[start];
+    if (open !== "{" && open !== "[") continue;
+    const close = open === "{" ? "}" : "]";
+    let depth = 0;
+    let inString = false;
+    let escaped = false;
+    for (let i = start; i < text.length; i += 1) {
+      const ch = text[i];
+      if (escaped) {
+        escaped = false;
+        continue;
+      }
+      if (ch === "\\") {
+        if (inString) escaped = true;
+        continue;
+      }
+      if (ch === '"') {
+        inString = !inString;
+        continue;
+      }
+      if (inString) continue;
+      if (ch === open) depth += 1;
+      else if (ch === close) {
+        depth -= 1;
+        if (depth === 0) return text.slice(start, i + 1);
+      }
+    }
+  }
+  return null;
+}
+function parseLlmJson(raw) {
+  const text = stripCodeFences(raw);
+  try {
+    return JSON.parse(text);
+  } catch (e) {
+  }
+  let offset = 0;
+  while (offset < text.length) {
+    const span = extractJsonSpan(text.slice(offset));
+    if (span === null) break;
+    try {
+      return JSON.parse(span);
+    } catch (e2) {
+    }
+    const idx = text.indexOf(span, offset);
+    offset = (idx === -1 ? offset : idx) + 1;
+  }
+  throw new Error(`Model returned invalid JSON: ${raw.slice(0, 200)}`);
+}
+
+// src/target.ts
+var _child_process = require('child_process');
+var _util = require('util');
+var execFileAsync = _util.promisify.call(void 0, _child_process.execFile);
+function isAppleSiliconMac() {
+  return process.platform === "darwin" && process.arch === "arm64";
+}
+function targetTripleFrom(versionOutput, arch = process.arch) {
+  const [major, minor = "0"] = versionOutput.trim().split(".");
+  if (!major || !/^\d+$/.test(major)) return null;
+  if (minor !== void 0 && !/^\d+$/.test(minor)) return null;
+  const cpu = arch === "x64" || arch === "x86_64" ? "x86_64" : "arm64";
+  return `${cpu}-apple-macos${major}.${minor}`;
+}
+async function macosMajor() {
+  try {
+    const { stdout } = await execFileAsync("sw_vers", ["-productVersion"]);
+    const major = Number.parseInt(_nullishCoalesce(stdout.trim().split(".")[0], () => ( "")), 10);
+    return Number.isFinite(major) ? major : null;
+  } catch (e3) {
+    return null;
+  }
+}
+async function hostTarget() {
+  for (const [cmd, args] of [
+    ["xcrun", ["--show-sdk-version"]],
+    ["sw_vers", ["-productVersion"]]
+  ]) {
+    try {
+      const { stdout } = await execFileAsync(cmd, args);
+      const triple = targetTripleFrom(stdout);
+      if (triple !== null) return triple;
+    } catch (e4) {
+    }
+  }
+  return null;
+}
+async function findSwiftc() {
+  try {
+    await execFileAsync("xcrun", ["-f", "swiftc"]);
+    return { command: "xcrun", prefixArgs: ["swiftc"] };
+  } catch (e5) {
+  }
+  const { stat: stat3 } = await Promise.resolve().then(() => _interopRequireWildcard(require("fs/promises")));
+  try {
+    await stat3("/usr/bin/swiftc");
+    return { command: "/usr/bin/swiftc", prefixArgs: [] };
+  } catch (e6) {
+    return null;
+  }
+}
+
+// src/cloud.ts
+
+var _promises = require('fs/promises');
+var _os = require('os'); var _os2 = _interopRequireDefault(_os);
+var _path = require('path'); var _path2 = _interopRequireDefault(_path);
+
+var execFileAsync2 = _util.promisify.call(void 0, _child_process.execFile);
+var CLOUD_SHORTCUT_NAME = "Apple LLM Cloud";
+var CLOUD_SHORTCUT_NAME_WEB = "Apple LLM Cloud Web";
+var CALL_TIMEOUT_MS = 12e4;
+var CLOUD_CONTEXT_TOKENS = 32768;
+var IMPORT_TIMEOUT_MS = 9e4;
+var IMPORT_POLL_MS = 2e3;
+function shortcutDefinition(webSearch = false) {
+  const parameters = {
+    // Stable UUID: re-running setup re-imports the same action rather than
+    // accumulating variants.
+    UUID: webSearch ? "B47F1A90-2D5E-4C83-A6F1-9E0C7B34D215" : "3827CFFE-3A65-4456-BFA0-49EF061ACEE3",
+    // Plain text out. "Automatic" reshapes the result to suit whatever action
+    // comes next, and nothing comes next here.
+    WFGenerativeResultType: "Text",
+    // The shortcut's own input, spliced in as a variable. U+FFFC is the
+    // object-replacement character marking the attachment's position.
+    WFLLMPrompt: {
+      Value: {
+        string: "\uFFFC",
+        attachmentsByRange: { "{0, 1}": { Type: "ExtensionInput" } }
+      },
+      WFSerializationType: "WFTextTokenString"
+    }
+  };
+  if (webSearch) parameters.WFAllowWebSearch = true;
+  return {
+    WFWorkflowMinimumClientVersionString: "900",
+    WFWorkflowMinimumClientVersion: 900,
+    WFWorkflowClientVersion: "5037.0.17",
+    WFWorkflowIcon: {
+      WFWorkflowIconStartColor: 431817727,
+      WFWorkflowIconGlyphNumber: 61440
+    },
+    WFWorkflowOutputContentItemClasses: [],
+    WFWorkflowHasOutputFallback: false,
+    WFWorkflowActions: [
+      {
+        WFWorkflowActionIdentifier: "is.workflow.actions.askllm",
+        WFWorkflowActionParameters: parameters
+      }
+    ],
+    WFWorkflowInputContentItemClasses: ["WFStringContentItem", "WFRichTextContentItem"],
+    WFWorkflowImportQuestions: [],
+    WFQuickActionSurfaces: [],
+    WFWorkflowTypes: ["WFWorkflowTypeShowInSearch"],
+    WFWorkflowHasShortcutInputVariables: true
+  };
+}
+async function listShortcuts() {
+  try {
+    const { stdout } = await execFileAsync2("shortcuts", ["list"], { timeout: 2e4 });
+    return stdout.split("\n").map((l) => l.trim()).filter((l) => l !== "");
+  } catch (e7) {
+    return [];
+  }
+}
+async function installCount(name = CLOUD_SHORTCUT_NAME) {
+  return (await listShortcuts()).filter((l) => l === name).length;
+}
+function cloudSetupHint() {
+  return "The cloud tier needs a one-time shortcut installed.\nRun:  apple-llm setup-cloud\nIt generates and signs the shortcut on this machine \u2014 no account, no API key, nothing uploaded.";
+}
+function duplicateMessage(count, name) {
+  return `${count} shortcuts are named "${name}"; \`shortcuts run\` cannot tell them apart and fails with "Couldn't find shortcut".
+Delete the duplicates in the Shortcuts app, then try again.`;
+}
+async function installCloudShortcut(onProgress, options = {}) {
+  const name = options.webSearch === true ? CLOUD_SHORTCUT_NAME_WEB : CLOUD_SHORTCUT_NAME;
+  const existing = await installCount(name);
+  if (existing > 1) throw new AppleLLMError(duplicateMessage(existing, name), "cloud");
+  if (existing === 1 && options.force !== true) {
+    _optionalChain([onProgress, 'optionalCall', _27 => _27({ status: `"${name}" is already installed` })]);
+    return;
+  }
+  const dir = await _promises.mkdtemp.call(void 0, _path2.default.join(_os2.default.tmpdir(), "apple-llm-shortcut-"));
+  try {
+    const jsonPath = _path2.default.join(dir, "definition.json");
+    const unsignedPath = _path2.default.join(dir, "unsigned.shortcut");
+    const signedPath = _path2.default.join(dir, `${name}.shortcut`);
+    await _promises.writeFile.call(void 0, jsonPath, JSON.stringify(shortcutDefinition(options.webSearch)), "utf8");
+    await execFileAsync2("plutil", ["-convert", "binary1", "-o", unsignedPath, jsonPath]);
+    _optionalChain([onProgress, 'optionalCall', _28 => _28({ status: "signing the shortcut locally" })]);
+    await execFileAsync2("shortcuts", ["sign", "-m", "anyone", "-i", unsignedPath, "-o", signedPath]);
+    _optionalChain([onProgress, 'optionalCall', _29 => _29({ status: `installing "${name}" (Shortcuts imports asynchronously)` })]);
+    await execFileAsync2("open", [signedPath]);
+    const deadline = Date.now() + IMPORT_TIMEOUT_MS;
+    for (; ; ) {
+      if (await installCount(name) >= 1) break;
+      if (Date.now() > deadline) {
+        throw new SetupRequiredError(
+          `Shortcuts did not import "${name}" within ${IMPORT_TIMEOUT_MS / 1e3}s.
+If a confirmation panel is open in the Shortcuts app, accept it and run setup again.`,
+          "setup-cloud",
+          "cloud"
+        );
+      }
+      await new Promise((resolve) => setTimeout(resolve, IMPORT_POLL_MS));
+    }
+    _optionalChain([onProgress, 'optionalCall', _30 => _30({ status: `"${name}" installed` })]);
+  } finally {
+    await _promises.rm.call(void 0, dir, { recursive: true, force: true });
+  }
+}
+async function probeCloud() {
+  if (process.platform !== "darwin") {
+    return { available: false, installed: false, reason: `unsupportedPlatform: this machine reports "${process.platform}"` };
+  }
+  if (!isAppleSiliconMac()) {
+    return { available: false, installed: false, reason: "deviceNotEligible: Apple Intelligence needs Apple Silicon" };
+  }
+  try {
+    await execFileAsync2("shortcuts", ["list"], { timeout: 2e4 });
+  } catch (e8) {
+    return { available: false, installed: false, reason: "this system does not provide /usr/bin/shortcuts" };
+  }
+  const count = await installCount();
+  if (count === 0) {
+    return { available: false, installed: false, reason: cloudSetupHint() };
+  }
+  if (count > 1) {
+    return { available: false, installed: true, reason: duplicateMessage(count, CLOUD_SHORTCUT_NAME) };
+  }
+  return { available: true, installed: true, contextSize: CLOUD_CONTEXT_TOKENS };
+}
+var CloudClient = (_class14 = class {constructor() { _class14.prototype.__init14.call(this); }
+  __init14() {this.ready = false}
+  /** Last known quota, set by `probe()` so a call can fail fast. */
+  
+  /** What the framework says the server model can do, when it could be read. */
+  
+  /**
+   * Tell the client what the framework reported about the quota.
+   *
+   * Worth doing because a `shortcuts run` against an exhausted quota costs a
+   * full round trip to find out; this turns that into an immediate typed error.
+   */
+  setQuota(quota) {
+    this.quota = quota;
+    this.model = quota;
+  }
+  /** Whether the server model is known to read images. False when it could not be read (macOS 26). */
+  get supportsImages() {
+    return _optionalChain([this, 'access', _31 => _31.model, 'optionalAccess', _32 => _32.capabilities, 'optionalAccess', _33 => _33.vision]) === true;
+  }
+  assertQuota() {
+    if (_optionalChain([this, 'access', _34 => _34.quota, 'optionalAccess', _35 => _35.status]) !== "limitReached") return;
+    throw new QuotaError(
+      "Apple Private Cloud Compute quota is exhausted (reported by the framework before the call was made).\nFall back to the on-device tier, or try again later.",
+      "cloud",
+      this.quota.resetDate === void 0 ? void 0 : new Date(this.quota.resetDate)
+    );
+  }
+  get label() {
+    return "apple private cloud compute";
+  }
+  get contextSize() {
+    return _nullishCoalesce(_optionalChain([this, 'access', _36 => _36.model, 'optionalAccess', _37 => _37.contextSize]), () => ( CLOUD_CONTEXT_TOKENS));
+  }
+  async ensureReady(onProgress) {
+    if (this.ready) return;
+    const probe2 = await probeCloud();
+    if (!probe2.available) {
+      if (probe2.installed !== true) {
+        throw new SetupRequiredError(_nullishCoalesce(probe2.reason, () => ( cloudSetupHint())), "setup-cloud", "cloud");
+      }
+      throw new AppleLLMError(_nullishCoalesce(probe2.reason, () => ( "the cloud tier is unavailable")), "cloud");
+    }
+    this.ready = true;
+    _optionalChain([onProgress, 'optionalCall', _38 => _38({ status: `apple private cloud compute ready (${CLOUD_CONTEXT_TOKENS} token context)` })]);
+  }
+  async text(request) {
+    await this.ensureReady();
+    this.assertQuota();
+    const name = request.webSearch === true ? CLOUD_SHORTCUT_NAME_WEB : CLOUD_SHORTCUT_NAME;
+    if (request.webSearch === true && await installCount(name) !== 1) {
+      throw new SetupRequiredError(
+        `webSearch needs the "${name}" shortcut.
+Run:  apple-llm setup-cloud --web-search`,
+        "setup-cloud --web-search",
+        "cloud"
+      );
+    }
+    const images = await imageInputs(request.images);
+    let prompt = request.system ? `${request.system}
+
+${request.prompt}` : request.prompt;
+    const labels = images.map((image, i) => image.label === void 0 ? void 0 : `${i + 1}: ${image.label}`);
+    if (labels.some((label) => label !== void 0)) {
+      prompt = `${prompt}
+
+Attached images, in order \u2014 ${labels.map((l, i) => _nullishCoalesce(l, () => ( `${i + 1}`))).join(", ")}.`;
+    }
+    const dir = await _promises.mkdtemp.call(void 0, _path2.default.join(_os2.default.tmpdir(), "apple-llm-cloud-"));
+    try {
+      const inPath = _path2.default.join(dir, "prompt.txt");
+      const outPath = _path2.default.join(dir, "reply.txt");
+      await _promises.writeFile.call(void 0, inPath, prompt, "utf8");
+      const inputs = [inPath, ...images.map((image) => image.path)].flatMap((p) => ["-i", p]);
+      try {
+        await execFileAsync2("shortcuts", ["run", name, ...inputs, "-o", outPath], {
+          timeout: CALL_TIMEOUT_MS,
+          killSignal: "SIGKILL",
+          signal: request.signal
+        });
+      } catch (error) {
+        if (_optionalChain([request, 'access', _39 => _39.signal, 'optionalAccess', _40 => _40.aborted]) === true) {
+          throw new AbortError("The request was aborted.", "cloud", { cause: request.signal.reason });
+        }
+        throw describeRunFailure(error, name);
+      }
+      let reply;
+      try {
+        reply = await _promises.readFile.call(void 0, outPath, "utf8");
+      } catch (e9) {
+        throw new AppleLLMError("Apple cloud generation produced no output.", "cloud");
+      }
+      if (reply.trim() === "") {
+        throw new AppleLLMError("Apple cloud generation returned an empty reply.", "cloud");
+      }
+      return reply;
+    } finally {
+      await _promises.rm.call(void 0, dir, { recursive: true, force: true });
+    }
+  }
+  /**
+   * There is no constrained decoding on this tier, so the schema is spelled out
+   * in the prompt and the reply is mined for JSON. The shape is a request here,
+   * not a guarantee — unlike on device.
+   */
+  async json(request) {
+    const instruction = `Reply with a single JSON value matching this JSON Schema. Output only the JSON, with no commentary and no code fence.
+
+${JSON.stringify(request.schema, null, 2)}`;
+    const system = request.system ? `${request.system}
+
+${instruction}` : instruction;
+    return parseLlmJson(await this.text({ ...request, system }));
+  }
+  // eslint-disable-next-line class-methods-use-this
+  close() {
+  }
+}, _class14);
+async function imageInputs(images) {
+  const out = [];
+  for (const image of _nullishCoalesce(images, () => ( []))) {
+    const entry = typeof image === "string" ? { path: image } : image;
+    const absolute = _path2.default.resolve(entry.path);
+    try {
+      await _promises.stat.call(void 0, absolute);
+    } catch (e10) {
+      throw new AppleLLMError(`Image not found: ${entry.path}`, "cloud");
+    }
+    out.push({ path: absolute, ...entry.label === void 0 ? {} : { label: entry.label } });
+  }
+  return out;
+}
+function describeRunFailure(error, name = CLOUD_SHORTCUT_NAME) {
+  const err = error;
+  if (err.killed === true) {
+    return new TimeoutError(
+      `Apple cloud generation got no response within ${CALL_TIMEOUT_MS / 1e3}s. Open "${name}" in the Shortcuts app and check that Request is bound to the Shortcut Input variable \u2014 an unbound Request makes the action wait for a human.`,
+      "cloud"
+    );
+  }
+  const stderr = _nullishCoalesce(_optionalChain([err, 'access', _41 => _41.stderr, 'optionalAccess', _42 => _42.trim, 'call', _43 => _43()]), () => ( ""));
+  if (/maximum allowed length/i.test(stderr)) {
+    return new ContextLengthError(
+      `The prompt exceeded the cloud model's ~${CLOUD_CONTEXT_TOKENS}-token context window.`,
+      "cloud"
+    );
+  }
+  if (/QuotaLimitReached|quota/i.test(stderr)) {
+    const match = /(\d{4}-\d{2}-\d{2}[T ][\d:]+)/.exec(stderr);
+    const resetDate = match ? new Date(match[1].replace(" ", "T")) : void 0;
+    return new QuotaError(
+      `Apple Private Cloud Compute quota reached.${resetDate ? ` Resets ${resetDate.toISOString()}.` : ""}
+Fall back to the on-device tier, or try again later.`,
+      "cloud",
+      resetDate !== void 0 && !Number.isNaN(resetDate.getTime()) ? resetDate : void 0
+    );
+  }
+  if (/Couldn.t find shortcut/i.test(stderr)) {
+    return new SetupRequiredError(
+      `Shortcuts could not find "${name}".
+${cloudSetupHint()}`,
+      "setup-cloud",
+      "cloud"
+    );
+  }
+  return new AppleLLMError(
+    `Apple cloud generation failed: ${stderr !== "" ? stderr : _nullishCoalesce(err.message, () => ( String(error)))}`,
+    "cloud"
+  );
+}
+
+// src/compile.ts
+
+
+var _crypto = require('crypto');
+
+
+var _url = require('url');
+
+var execFileAsync3 = _util.promisify.call(void 0, _child_process.execFile);
+function cacheDir() {
+  return _path2.default.join(_os2.default.homedir(), "Library", "Caches", "apple-llm", "bin");
+}
+function fingerprint(source, triple) {
+  return _crypto.createHash.call(void 0, "sha256").update(`${source}
+${triple}`, "utf8").digest("hex").slice(0, 12);
+}
+var cachedSource;
+async function helperSource() {
+  if (cachedSource !== void 0) return cachedSource;
+  const here = _path2.default.dirname(_url.fileURLToPath.call(void 0, importMetaUrl));
+  const candidates = [
+    _path2.default.join(here, "..", "swift", "helper.swift"),
+    _path2.default.join(here, "swift", "helper.swift")
+  ];
+  for (const candidate of candidates) {
+    try {
+      cachedSource = await _promises.readFile.call(void 0, candidate, "utf8");
+      return cachedSource;
+    } catch (e11) {
+    }
+  }
+  throw new Error(
+    `apple-llm could not find its embedded helper.swift (looked in ${candidates.join(", ")}).`
+  );
+}
+async function fileExists(p) {
+  try {
+    await _promises.stat.call(void 0, p);
+    return true;
+  } catch (e12) {
+    return false;
+  }
+}
+var inFlight;
+var cachedKey;
+async function ensureBinary(onProgress, options = {}) {
+  if (options.force === true) {
+    inFlight = void 0;
+    cachedKey = void 0;
+  } else if (inFlight !== void 0 && cachedKey !== void 0) {
+    const pending = inFlight;
+    try {
+      const source = await helperSource();
+      const triple = await _asyncNullishCoalesce(await hostTarget(), async () => ( process.arch));
+      if (fingerprint(source, triple) === cachedKey) return pending;
+      inFlight = void 0;
+      cachedKey = void 0;
+    } catch (e13) {
+      return pending;
+    }
+  }
+  if (inFlight === void 0) {
+    try {
+      const source = await helperSource();
+      const triple = await _asyncNullishCoalesce(await hostTarget(), async () => ( process.arch));
+      cachedKey = fingerprint(source, triple);
+    } catch (e14) {
+    }
+    inFlight = build(onProgress).catch((err) => {
+      inFlight = void 0;
+      cachedKey = void 0;
+      throw err;
+    });
+  }
+  return inFlight;
+}
+async function build(onProgress) {
+  const source = await helperSource();
+  const triple = await _asyncNullishCoalesce(await hostTarget(), async () => ( process.arch));
+  const dir = cacheDir();
+  const target = _path2.default.join(dir, `fm-helper-${fingerprint(source, triple)}`);
+  if (await fileExists(target)) return target;
+  const swiftc = await findSwiftc();
+  if (swiftc === null) {
+    throw new ModelUnavailableError(
+      "apple-llm needs a Swift compiler to build its on-device helper, but none was found.\nInstall the Xcode command line tools with `xcode-select --install`, then try again.",
+      "noSwiftCompiler",
+      "device"
+    );
+  }
+  _optionalChain([onProgress, 'optionalCall', _44 => _44({ status: "building the Apple on-device helper (one time, a few seconds)" })]);
+  await _promises.mkdir.call(void 0, dir, { recursive: true });
+  const unique = `${process.pid}.${Math.random().toString(36).slice(2)}`;
+  const sourcePath = `${target}.${unique}.swift`;
+  const staging = `${target}.${unique}.tmp`;
+  const { writeFile: writeFile2 } = await Promise.resolve().then(() => _interopRequireWildcard(require("fs/promises")));
+  await writeFile2(sourcePath, source, "utf8");
+  try {
+    const targetArgs = triple.includes("-apple-") ? ["-target", triple] : [];
+    await execFileAsync3(swiftc.command, [
+      ...swiftc.prefixArgs,
+      ...targetArgs,
+      "-parse-as-library",
+      "-O",
+      sourcePath,
+      "-o",
+      staging
+    ]);
+    await _promises.chmod.call(void 0, staging, 493);
+    await _promises.rename.call(void 0, staging, target);
+  } catch (err) {
+    await _promises.rm.call(void 0, staging, { force: true });
+    if (await fileExists(target)) return target;
+    const reason = err instanceof Error ? err.message : String(err);
+    throw new ModelUnavailableError(
+      `Failed to build the Apple on-device helper with ${swiftc.command}.
+${reason.slice(0, 400)}
+This usually means the macOS SDK predates the Foundation Models framework (macOS 26+).`,
+      "unsupportedOSVersion",
+      "device"
+    );
+  } finally {
+    await _promises.rm.call(void 0, sourcePath, { force: true });
+  }
+  _optionalChain([onProgress, 'optionalCall', _45 => _45({ status: "helper built" })]);
+  return target;
+}
+
+// src/messages.ts
+function splitMessages(messages) {
+  const systems = [];
+  const rest = [];
+  for (const message of messages) {
+    if (message.role === "system") systems.push(message.content);
+    else rest.push(message);
+  }
+  let lastUser = -1;
+  for (let i = rest.length - 1; i >= 0; i -= 1) {
+    if (rest[i].role === "user") {
+      lastUser = i;
+      break;
+    }
+  }
+  if (lastUser === -1) {
+    throw new AppleLLMError("A message list needs at least one user message.");
+  }
+  const tail = rest.slice(lastUser + 1);
+  const final = tail[tail.length - 1];
+  if (final !== void 0 && final.role !== "tool") {
+    throw new AppleLLMError(
+      "The last message must be from the user, or a tool result answering the assistant\u2019s tool call."
+    );
+  }
+  const callNames = /* @__PURE__ */ new Map();
+  for (const message of rest) {
+    if (message.role === "assistant") for (const call of _nullishCoalesce(message.toolCalls, () => ( []))) callNames.set(call.id, call);
+  }
+  const history = [];
+  for (const message of rest.slice(0, lastUser)) {
+    const entry = toHistory(message, callNames);
+    if (entry !== void 0) history.push(entry);
+  }
+  const replay = [];
+  for (const message of tail) {
+    if (message.role !== "tool") continue;
+    const call = callNames.get(message.toolCallId);
+    replay.push({
+      name: _nullishCoalesce(_nullishCoalesce(message.name, () => ( _optionalChain([call, 'optionalAccess', _46 => _46.name]))), () => ( "")),
+      arguments: _nullishCoalesce(_optionalChain([call, 'optionalAccess', _47 => _47.arguments]), () => ( {})),
+      output: message.content
+    });
+  }
+  const last = rest[lastUser];
+  return {
+    system: systems.length > 0 ? systems.join("\n\n") : void 0,
+    history,
+    prompt: last.content,
+    images: _nullishCoalesce(last.images, () => ( [])),
+    replay
+  };
+}
+function toHistory(message, calls) {
+  switch (message.role) {
+    case "user": {
+      const images = _nullishCoalesce(_optionalChain([message, 'access', _48 => _48.images, 'optionalAccess', _49 => _49.length]), () => ( 0));
+      const note = images === 0 ? "" : ` [${images === 1 ? "an image was" : `${images} images were`} attached here]`;
+      return { role: "user", content: `${message.content}${note}` };
+    }
+    case "assistant":
+      return {
+        role: "assistant",
+        content: _nullishCoalesce(message.content, () => ( "")),
+        ...message.toolCalls !== void 0 && message.toolCalls.length > 0 ? { toolCalls: message.toolCalls } : {}
+      };
+    case "tool":
+      return {
+        role: "tool",
+        toolCallId: message.toolCallId,
+        name: _nullishCoalesce(_nullishCoalesce(message.name, () => ( _optionalChain([calls, 'access', _50 => _50.get, 'call', _51 => _51(message.toolCallId), 'optionalAccess', _52 => _52.name]))), () => ( "tool")),
+        content: message.content
+      };
+    default:
+      return void 0;
+  }
+}
+function renderHistory(history) {
+  return history.map((entry) => {
+    if (entry.role === "user") return `User: ${entry.content}`;
+    if (entry.role === "tool") return `Tool ${entry.name} returned: ${entry.content}`;
+    const calls = (_nullishCoalesce(entry.toolCalls, () => ( []))).map((c) => `[called ${c.name}(${JSON.stringify(c.arguments)})]`);
+    return `Assistant: ${[entry.content, ...calls].filter((s) => s !== "").join(" ")}`;
+  }).join("\n");
+}
+function canonicalJson(value) {
+  if (Array.isArray(value)) return `[${value.map(canonicalJson).join(",")}]`;
+  if (value !== null && typeof value === "object") {
+    const keys = Object.keys(value).sort();
+    return `{${keys.map((k) => `${JSON.stringify(k)}:${canonicalJson(value[k])}`).join(",")}}`;
+  }
+  return _nullishCoalesce(JSON.stringify(value), () => ( "null"));
+}
+var ReplayBook = class {
+  
+  constructor(results) {
+    this.unused = [...results];
+  }
+  take(name, args) {
+    const key = canonicalJson(args);
+    let index = this.unused.findIndex((r) => r.name === name && canonicalJson(r.arguments) === key);
+    if (index < 0) index = this.unused.findIndex((r) => r.name === name);
+    if (index < 0) return void 0;
+    const [hit] = this.unused.splice(index, 1);
+    return hit.output;
+  }
+};
+
+// src/schema.ts
+var SCHEMA_MAP_KEYS = ["properties", "$defs", "definitions"];
+var SCHEMA_LIST_KEYS = ["anyOf", "oneOf", "allOf"];
+var SCHEMA_KEYS = ["items", "not", "additionalItems"];
+function isPlainObject(value) {
+  return value !== null && typeof value === "object" && !Array.isArray(value);
+}
+function sanitize(name, counter) {
+  const cleaned = name.replace(/[^A-Za-z0-9_]/g, "");
+  if (cleaned.length === 0 || /^[0-9]/.test(cleaned)) {
+    counter.n += 1;
+    return `Schema${counter.n}`;
+  }
+  return cleaned;
+}
+function titleFrom(name, ctx) {
+  const base = sanitize(name, ctx.counter);
+  if (!ctx.used.has(base)) {
+    ctx.used.add(base);
+    return base;
+  }
+  for (let i = 2; ; i += 1) {
+    const candidate = `${base}${i}`;
+    if (!ctx.used.has(candidate)) {
+      ctx.used.add(candidate);
+      return candidate;
+    }
+  }
+}
+function memberType(value) {
+  if (typeof value === "number") return Number.isInteger(value) ? "integer" : "number";
+  if (typeof value === "boolean") return "boolean";
+  return "string";
+}
+function rewriteRef(ref, ctx) {
+  const slash = ref.lastIndexOf("/");
+  if (slash === -1) return ref;
+  const name = ref.slice(slash + 1);
+  const title = ctx.defTitles.get(name);
+  return title === void 0 || title === name ? ref : `${ref.slice(0, slash + 1)}${title}`;
+}
+function convertNode(node, name, ctx) {
+  const out = {};
+  let nullable = false;
+  const converted = /* @__PURE__ */ new Map();
+  const properties = node.properties;
+  if (isPlainObject(properties)) {
+    for (const [key, value] of Object.entries(properties)) {
+      converted.set(
+        key,
+        isPlainObject(value) ? convertNode(value, key, ctx) : { schema: value, nullable: false }
+      );
+    }
+  }
+  for (const [key, value] of Object.entries(node)) {
+    if (key === "type" || key === "enum" || key === "required" || key === "properties") continue;
+    if (key === "$ref" && typeof value === "string") {
+      out.$ref = rewriteRef(value, ctx);
+    } else if (SCHEMA_MAP_KEYS.includes(key) && isPlainObject(value)) {
+      const isDefs = key === "$defs" || key === "definitions";
+      const mapped = {};
+      for (const [childName, childValue] of Object.entries(value)) {
+        if (!isPlainObject(childValue)) {
+          mapped[childName] = childValue;
+          continue;
+        }
+        const child = convertNode(childValue, childName, ctx).schema;
+        const reserved = isDefs ? ctx.defTitles.get(childName) : void 0;
+        if (reserved !== void 0) child.title = reserved;
+        mapped[childName] = child;
+      }
+      out[key] = mapped;
+    } else if (SCHEMA_LIST_KEYS.includes(key) && Array.isArray(value)) {
+      if (key === "allOf") {
+        const allOfConverted = value.map(
+          (entry) => isPlainObject(entry) ? convertNode(entry, name, ctx).schema : entry
+        );
+        if (allOfConverted.length === 1 && isPlainObject(allOfConverted[0])) {
+          for (const [k, v] of Object.entries(allOfConverted[0])) {
+            if (out[k] === void 0) out[k] = v;
+          }
+        } else {
+          out.allOf = allOfConverted;
+        }
+      } else {
+        const branches = value.filter((entry) => !(isPlainObject(entry) && entry.type === "null"));
+        if (branches.length !== value.length) nullable = true;
+        const convertedBranches = branches.map(
+          (entry) => isPlainObject(entry) ? convertNode(entry, name, ctx) : { schema: entry, nullable: false }
+        );
+        if (convertedBranches.some((b) => b.nullable)) nullable = true;
+        if (convertedBranches.length === 1 && isPlainObject(convertedBranches[0].schema)) {
+          for (const [k, v] of Object.entries(convertedBranches[0].schema)) {
+            if (out[k] === void 0) out[k] = v;
+          }
+        } else if (convertedBranches.length > 0) {
+          out.anyOf = convertedBranches.map((b) => b.schema);
+        }
+      }
+    } else if (SCHEMA_KEYS.includes(key) && isPlainObject(value)) {
+      out[key] = convertNode(value, name, ctx).schema;
+    } else {
+      out[key] = value;
+    }
+  }
+  const rawType = node.type;
+  if (Array.isArray(rawType)) {
+    const nonNull = rawType.filter((t) => t !== "null");
+    if (nonNull.length !== rawType.length) nullable = true;
+    if (nonNull.length > 1) {
+      out.anyOf = nonNull.map((t) => ({ type: t }));
+    } else {
+      out.type = _nullishCoalesce(nonNull[0], () => ( "string"));
+    }
+  } else if (rawType !== void 0) {
+    out.type = rawType;
+  }
+  const rawEnum = node.enum;
+  if (Array.isArray(rawEnum) && rawEnum.length > 0) {
+    const members = rawEnum.filter((v) => v !== null);
+    if (members.length !== rawEnum.length) nullable = true;
+    if (members.length > 0) {
+      delete out.type;
+      if (members.every((v) => typeof v === "string")) {
+        out.anyOf = members.map((value) => ({ type: "string", const: value }));
+      } else {
+        const types = [...new Set(members.map(memberType))];
+        if (types.length === 1) out.type = types[0];
+        else out.anyOf = types.map((t) => ({ type: t }));
+      }
+    }
+  }
+  const merged = converted.size === 0 && isPlainObject(out.properties);
+  const isObject2 = !merged && (out.type === "object" || converted.size > 0);
+  if (isObject2) {
+    const props = {};
+    for (const [key, child] of converted) props[key] = child.schema;
+    out.properties = props;
+    const originalRequired = Array.isArray(node.required) ? node.required : [];
+    out.required = originalRequired.filter((key) => !_optionalChain([converted, 'access', _53 => _53.get, 'call', _54 => _54(key), 'optionalAccess', _55 => _55.nullable]));
+    const keys = Object.keys(props);
+    const declaredOrder = Array.isArray(node["x-order"]) ? node["x-order"].filter((k) => typeof k === "string" && keys.includes(k)) : [];
+    out["x-order"] = [...declaredOrder, ...keys.filter((k) => !declaredOrder.includes(k))];
+    if (typeof out.title === "string") ctx.used.add(out.title);
+    else out.title = titleFrom(name, ctx);
+    if (out.additionalProperties === void 0) out.additionalProperties = false;
+  } else if (Array.isArray(node.required)) {
+    out.required = node.required;
+  }
+  if ((Array.isArray(out.anyOf) || Array.isArray(out.allOf)) && typeof out.title !== "string") {
+    out.title = titleFrom(name, ctx);
+  }
+  if (out.type === "string" && out.anyOf === void 0 && out.allOf === void 0)
+    delete out.title;
+  delete out.pattern;
+  return { schema: out, nullable };
+}
+function reserveDefTitles(schema, ctx) {
+  for (const key of ["$defs", "definitions"]) {
+    const defs = schema[key];
+    if (!isPlainObject(defs)) continue;
+    for (const [name, value] of Object.entries(defs)) {
+      const declared = isPlainObject(value) && typeof value.title === "string" ? value.title : null;
+      const title = _nullishCoalesce(declared, () => ( sanitize(name, ctx.counter)));
+      ctx.defTitles.set(name, title);
+      ctx.used.add(title);
+    }
+  }
+}
+function toAppleSchema(schema, rootName = "Response") {
+  const ctx = { counter: { n: 0 }, defTitles: /* @__PURE__ */ new Map(), used: /* @__PURE__ */ new Set() };
+  reserveDefTitles(schema, ctx);
+  const { $schema: _draft, ...rest } = schema;
+  return convertNode(rest, rootName, ctx).schema;
+}
+
+// src/standard-schema.ts
+function isStandardSchema(value) {
+  if (value === null || typeof value !== "object" && typeof value !== "function") return false;
+  const props = value["~standard"];
+  return props !== null && typeof props === "object" && typeof props.validate === "function";
+}
+function resolveSchema(schema) {
+  if (!isStandardSchema(schema)) return { json: schema };
+  const props = schema["~standard"];
+  const describe = props.jsonSchema;
+  if (describe === void 0 || typeof describe.input !== "function") {
+    throw new UnsupportedError(
+      `This ${props.vendor} schema cannot describe itself as JSON Schema, which Apple's decoder needs.
+` + (props.vendor === "valibot" ? "Wrap it: `toStandardJsonSchema(schema)` from @valibot/to-json-schema." : "Use a version that implements Standard JSON Schema (zod >= 4.2, arktype >= 2.1), or pass a JSON Schema.")
+    );
+  }
+  let json;
+  try {
+    json = describe.input({ target: "draft-2020-12" });
+  } catch (e15) {
+    json = describe.input({ target: "draft-07" });
+  }
+  return { json, validate: async (value) => props.validate(value) };
+}
+function formatPath(path3) {
+  if (path3 === void 0 || path3.length === 0) return "";
+  return path3.map((segment) => typeof segment === "object" && segment !== null ? segment.key : segment).map((key) => String(key)).join(".");
+}
+function describeIssues(issues) {
+  return issues.slice(0, 8).map((issue) => {
+    const at = formatPath(issue.path);
+    return at === "" ? issue.message : `${at}: ${issue.message}`;
+  }).join("; ");
+}
+async function validateWith(resolved, value, text, tier) {
+  if (resolved.validate === void 0) {
+    const issues = checkPatterns(value, resolved.json);
+    if (issues.length === 0) return value;
+    throw new SchemaValidationError(
+      `The model's reply did not satisfy the schema: ${describeIssues(issues)}`,
+      issues.map((issue) => ({ message: issue.message, path: issue.path })),
+      text,
+      tier
+    );
+  }
+  const result = await resolved.validate(value);
+  if (result.issues !== void 0) {
+    throw new SchemaValidationError(
+      `The model's reply did not satisfy the schema: ${describeIssues(result.issues)}`,
+      result.issues.map((issue) => ({ message: issue.message, path: issue.path })),
+      text,
+      tier
+    );
+  }
+  return result.value;
+}
+function isObject(value) {
+  return value !== null && typeof value === "object" && !Array.isArray(value);
+}
+function allowsNull(schema) {
+  if (!isObject(schema)) return false;
+  if (schema.type === "null" || schema.nullable === true) return true;
+  if (Array.isArray(schema.type) && schema.type.includes("null")) return true;
+  if (Array.isArray(schema.enum) && schema.enum.includes(null)) return true;
+  for (const key of ["anyOf", "oneOf"]) {
+    const branches = schema[key];
+    if (Array.isArray(branches) && branches.some(allowsNull)) return true;
+  }
+  return false;
+}
+function restoreNulls(value, schema, root = schema, depth = 0) {
+  if (depth > 32 || !isObject(schema)) return value;
+  const ref = schema.$ref;
+  if (typeof ref === "string") {
+    const target = resolveRef(ref, root);
+    return target === void 0 ? value : restoreNulls(value, target, root, depth + 1);
+  }
+  for (const key of ["anyOf", "oneOf"]) {
+    const branches = schema[key];
+    if (Array.isArray(branches)) {
+      const nonNull = branches.filter((b) => !(isObject(b) && b.type === "null"));
+      if (nonNull.length === 1 && isObject(nonNull[0])) {
+        return restoreNulls(value, nonNull[0], root, depth + 1);
+      }
+      return value;
+    }
+  }
+  if (Array.isArray(schema.allOf) && schema.allOf.length === 1 && isObject(schema.allOf[0])) {
+    return restoreNulls(value, schema.allOf[0], root, depth + 1);
+  }
+  if (Array.isArray(value)) {
+    return isObject(schema.items) ? value.map((item) => restoreNulls(item, schema.items, root, depth + 1)) : value;
+  }
+  if (!isObject(value) || !isObject(schema.properties)) return value;
+  const properties = schema.properties;
+  const required = Array.isArray(schema.required) ? schema.required : [];
+  const out = { ...value };
+  for (const [key, child] of Object.entries(properties)) {
+    if (out[key] === void 0) {
+      if (required.includes(key) && allowsNull(child)) out[key] = null;
+      continue;
+    }
+    if (isObject(child)) out[key] = restoreNulls(out[key], child, root, depth + 1);
+  }
+  return out;
+}
+function resolveRef(ref, root) {
+  const match = /^#\/(\$defs|definitions)\/(.+)$/.exec(ref);
+  if (match === null) return ref === "#" ? root : void 0;
+  const defs = root[match[1]];
+  const target = isObject(defs) ? defs[decodeURIComponent(match[2])] : void 0;
+  return isObject(target) ? target : void 0;
+}
+function checkPatterns(value, schema, root = schema, path3 = [], depth = 0) {
+  if (depth > 32 || !isObject(schema)) return [];
+  if (typeof schema.$ref === "string") {
+    const target = resolveRef(schema.$ref, root);
+    return target === void 0 ? [] : checkPatterns(value, target, root, path3, depth + 1);
+  }
+  if (Array.isArray(schema.allOf) && schema.allOf.length === 1 && isObject(schema.allOf[0])) {
+    return checkPatterns(value, schema.allOf[0], root, path3, depth + 1);
+  }
+  for (const key of ["anyOf", "oneOf"]) {
+    const branches = schema[key];
+    if (!Array.isArray(branches)) continue;
+    const nonNull = branches.filter((b) => !(isObject(b) && b.type === "null"));
+    return nonNull.length === 1 && isObject(nonNull[0]) && value !== null ? checkPatterns(value, nonNull[0], root, path3, depth + 1) : [];
+  }
+  if (typeof value === "string" && typeof schema.pattern === "string") {
+    let regex;
+    try {
+      regex = new RegExp(schema.pattern, "u");
+    } catch (e16) {
+      regex = void 0;
+    }
+    return regex === void 0 || regex.test(value) ? [] : [{ message: `must match the pattern ${schema.pattern}`, path: path3 }];
+  }
+  if (Array.isArray(value) && isObject(schema.items)) {
+    return value.flatMap((item, i) => checkPatterns(item, schema.items, root, [...path3, i], depth + 1));
+  }
+  if (isObject(value) && isObject(schema.properties)) {
+    return Object.entries(schema.properties).flatMap(
+      ([key, child]) => value[key] === void 0 || !isObject(child) ? [] : checkPatterns(value[key], child, root, [...path3, key], depth + 1)
+    );
+  }
+  return [];
+}
+
+// src/tools.ts
+var BUILT_IN_TOOLS = /* @__PURE__ */ new Set(["ocr", "barcode", "spotlight"]);
+function tool(definition) {
+  return definition;
+}
+var TOOL_NAME = /^[A-Za-z_][A-Za-z0-9_-]{0,63}$/;
+var EMPTY_PARAMETERS = { type: "object", properties: {}, required: [] };
+function normalizeTools(tools) {
+  const out = { builtIn: [], functions: [] };
+  if (tools === void 0) return out;
+  const entries = Array.isArray(tools) ? [...tools] : Object.entries(tools).map(([name, def]) => ({ ...def, name: _nullishCoalesce(def.name, () => ( name)) }));
+  const seen = /* @__PURE__ */ new Set();
+  for (const entry of entries) {
+    if (typeof entry === "string") {
+      if (!BUILT_IN_TOOLS.has(entry)) {
+        throw new AppleLLMError(`Unknown tool "${entry}" (want ${[...BUILT_IN_TOOLS].join(", ")}).`, "device");
+      }
+      if (!out.builtIn.includes(entry)) out.builtIn.push(entry);
+      continue;
+    }
+    if (entry === null || typeof entry !== "object" || typeof entry.name !== "string") {
+      throw new AppleLLMError("A function tool needs a name.", "device");
+    }
+    if (!TOOL_NAME.test(entry.name)) {
+      throw new AppleLLMError(
+        `Tool name "${entry.name}" is invalid: use letters, digits, "_" or "-", starting with a letter or "_".`,
+        "device"
+      );
+    }
+    if (seen.has(entry.name) || BUILT_IN_TOOLS.has(entry.name)) {
+      throw new AppleLLMError(`Tool name "${entry.name}" is used twice.`, "device");
+    }
+    seen.add(entry.name);
+    const resolved = entry.parameters === void 0 ? void 0 : resolveSchema(entry.parameters);
+    out.functions.push({ ...entry, resolved, json: _nullishCoalesce(_optionalChain([resolved, 'optionalAccess', _56 => _56.json]), () => ( EMPTY_PARAMETERS)) });
+  }
+  return out;
+}
+function toolOutputText(value) {
+  if (typeof value === "string") return value;
+  if (value === void 0) return "";
+  try {
+    return JSON.stringify(value);
+  } catch (e17) {
+    return String(value);
+  }
+}
+
+// src/device.ts
+
+
+
+
+// src/protocol.ts
+
+var defaultSpawner = (binary, args) => _child_process.spawn.call(void 0, binary, args, { stdio: ["pipe", "pipe", "pipe"] });
+function abortErrorFrom(signal) {
+  const reason = signal.reason;
+  if (reason instanceof AppleLLMError) return reason;
+  if (reason instanceof Error && reason.name === "TimeoutError") {
+    return new TimeoutError(`Apple generation timed out: ${reason.message}`, "device", { cause: reason });
+  }
+  return new AbortError("The request was aborted.", void 0, { cause: reason });
+}
+var HelperServer = (_class15 = class {
+  constructor(binary, options = {}) {;_class15.prototype.__init15.call(this);_class15.prototype.__init16.call(this);_class15.prototype.__init17.call(this);_class15.prototype.__init18.call(this);_class15.prototype.__init19.call(this);
+    this.binary = binary;
+    this.timeoutMs = _nullishCoalesce(options.timeoutMs, () => ( 12e4));
+    this.spawner = _nullishCoalesce(options.spawner, () => ( defaultSpawner));
+  }
+  
+  
+  __init15() {this.buffer = ""}
+  __init16() {this.queue = []}
+  /** Serialises callers so one request's reply cannot be handed to another. */
+  __init17() {this.chain = Promise.resolve()}
+  __init18() {this.inFlight = 0}
+  /** The helper's recent stderr, quoted when it dies. Always drained: an unread pipe blocks the writer. */
+  __init19() {this.stderrTail = ""}
+  
+  
+  start() {
+    if (this.child !== void 0 && this.child.exitCode === null && !this.child.killed) {
+      return this.child;
+    }
+    const child = this.spawner(this.binary, ["--serve"]);
+    this.child = child;
+    this.buffer = "";
+    this.stderrTail = "";
+    _optionalChain([child, 'access', _57 => _57.stdout, 'optionalAccess', _58 => _58.on, 'call', _59 => _59("data", (chunk) => {
+      this.buffer += chunk.toString();
+      for (; ; ) {
+        const newline = this.buffer.indexOf("\n");
+        if (newline === -1) break;
+        const line = this.buffer.slice(0, newline).trim();
+        this.buffer = this.buffer.slice(newline + 1);
+        if (line !== "") this.dispatch(line);
+      }
+    })]);
+    _optionalChain([child, 'access', _60 => _60.stderr, 'optionalAccess', _61 => _61.on, 'call', _62 => _62("data", (chunk) => {
+      this.stderrTail = (this.stderrTail + chunk.toString()).slice(-2e3);
+    })]);
+    const fail = (err) => {
+      if (this.child === child) this.child = void 0;
+      const pending = this.queue;
+      this.queue = [];
+      for (const p of pending) {
+        clearTimeout(p.timer);
+        p.finish(void 0, err);
+      }
+    };
+    child.on("error", (err) => fail(err instanceof Error ? err : new Error(String(err))));
+    child.on("close", (code) => {
+      const tail = this.stderrTail.trim();
+      fail(new AppleLLMError(`Apple helper exited with code ${code}${tail ? `: ${tail.slice(-400)}` : ""}`, "device"));
+    });
+    _optionalChain([child, 'access', _63 => _63.stdin, 'optionalAccess', _64 => _64.on, 'call', _65 => _65("error", () => {
+    })]);
+    const killer = () => {
+      if (child.exitCode === null) child.kill();
+    };
+    process.once("exit", killer);
+    child.once("close", () => process.removeListener("exit", killer));
+    this.setRef(this.inFlight > 0);
+    return child;
+  }
+  /** Keep the event loop alive only while a request is in flight. */
+  setRef(on) {
+    const child = this.child;
+    if (child === void 0) return;
+    const handles = [child, child.stdin, child.stdout, child.stderr];
+    for (const handle of handles) {
+      if (on) _optionalChain([handle, 'optionalAccess', _66 => _66.ref, 'optionalCall', _67 => _67()]);
+      else _optionalChain([handle, 'optionalAccess', _68 => _68.unref, 'optionalCall', _69 => _69()]);
+    }
+  }
+  /** Route one line: an event to the head's hooks, anything else completes the head. */
+  dispatch(line) {
+    const head = this.queue[0];
+    if (head === void 0) return;
+    let parsed;
+    try {
+      const value = JSON.parse(line);
+      if (value !== null && typeof value === "object" && !Array.isArray(value)) {
+        parsed = value;
+      }
+    } catch (e18) {
+    }
+    if (_optionalChain([parsed, 'optionalAccess', _70 => _70.done]) === false) {
+      this.arm(head);
+      if (head.abandoned) {
+        const call = parsed.toolCall;
+        if (typeof _optionalChain([call, 'optionalAccess', _71 => _71.id]) === "string") this.write({ op: "toolResult", callId: call.id, stop: true });
+        return;
+      }
+      try {
+        _optionalChain([head, 'access', _72 => _72.hooks, 'access', _73 => _73.onEvent, 'optionalCall', _74 => _74(parsed, (control) => this.write(control))]);
+      } catch (e19) {
+      }
+      return;
+    }
+    this.queue.shift();
+    clearTimeout(head.timer);
+    head.finish(line);
+  }
+  /**
+   * (Re)start the wedge timer. It measures silence, not total time: every
+   * event resets it, so a long stream is fine while a helper that stops
+   * talking is not.
+   */
+  arm(entry) {
+    clearTimeout(entry.timer);
+    entry.timer = setTimeout(() => this.timeOut(entry), this.timeoutMs);
+  }
+  /**
+   * Pause the wedge timer while the client itself is busy — a function tool
+   * running in JS. The helper is legitimately silent then: it is waiting on us.
+   */
+  pause() {
+    const head = this.queue[0];
+    if (head !== void 0) clearTimeout(head.timer);
+  }
+  /** Resume the wedge timer paused by `pause()`. */
+  resume() {
+    const head = this.queue[0];
+    if (head !== void 0) this.arm(head);
+  }
+  timeOut(entry) {
+    const index = this.queue.indexOf(entry);
+    if (index < 0) return;
+    this.queue.splice(index, 1);
+    this.stop();
+    entry.finish(
+      void 0,
+      new TimeoutError(`Apple on-device generation timed out after ${this.timeoutMs / 1e3}s of silence.`, "device")
+    );
+  }
+  /** Write a control line (cancel, toolResult) for the request in flight. */
+  write(control) {
+    _optionalChain([this, 'access', _75 => _75.child, 'optionalAccess', _76 => _76.stdin, 'optionalAccess', _77 => _77.write, 'call', _78 => _78(`${JSON.stringify(control)}
+`)]);
+  }
+  /**
+   * One request. Resolves with its final line; events go to `hooks.onEvent`.
+   * Serialised against every other request through one chain.
+   */
+  request(payload, hooks = {}) {
+    const { signal } = hooks;
+    if (_optionalChain([signal, 'optionalAccess', _79 => _79.aborted]) === true) return Promise.reject(abortErrorFrom(signal));
+    let entry;
+    let rejectCaller = () => void 0;
+    const caller = new Promise((resolve, reject) => {
+      rejectCaller = reject;
+      const run = () => {
+        if (_optionalChain([signal, 'optionalAccess', _80 => _80.aborted]) === true) {
+          reject(abortErrorFrom(signal));
+          return Promise.resolve();
+        }
+        const child = this.start();
+        this.inFlight += 1;
+        this.setRef(true);
+        return new Promise((settle) => {
+          const pending = {
+            hooks,
+            abandoned: false,
+            finish: (line, err) => {
+              this.inFlight -= 1;
+              if (this.inFlight === 0) this.setRef(false);
+              settle();
+              if (pending.abandoned) return;
+              if (err !== void 0) reject(err);
+              else resolve(_nullishCoalesce(line, () => ( "")));
+            }
+          };
+          entry = pending;
+          this.arm(pending);
+          this.queue.push(pending);
+          _optionalChain([child, 'access', _81 => _81.stdin, 'optionalAccess', _82 => _82.write, 'call', _83 => _83(`${payload.replace(/\n/g, " ")}
+`)]);
+        });
+      };
+      const slot = this.chain.then(run, run);
+      this.chain = slot.catch(() => void 0);
+    });
+    if (signal !== void 0) {
+      const onAbort = () => {
+        if (entry !== void 0 && this.queue.includes(entry)) {
+          entry.abandoned = true;
+          if (hooks.id !== void 0) this.write({ op: "cancel", id: hooks.id });
+        }
+        rejectCaller(abortErrorFrom(signal));
+      };
+      signal.addEventListener("abort", onAbort, { once: true });
+      const detach = () => signal.removeEventListener("abort", onAbort);
+      caller.then(detach, detach);
+    }
+    return caller;
+  }
+  /** Version-1 shape: one request, one line. */
+  send(payload, hooks = {}) {
+    return this.request(payload, hooks);
+  }
+  /**
+   * Streaming request, kept for callers of the version-1 API: deltas go to
+   * `onDelta` and the promise resolves with the final line.
+   */
+  stream(payload, onDelta, hooks = {}) {
+    return this.request(payload, {
+      ...hooks,
+      onEvent: (event, write) => {
+        if (typeof event.delta === "string") onDelta(event.delta);
+        _optionalChain([hooks, 'access', _84 => _84.onEvent, 'optionalCall', _85 => _85(event, write)]);
+      }
+    });
+  }
+  stop() {
+    const child = this.child;
+    this.child = void 0;
+    if (child !== void 0 && child.exitCode === null) {
+      _optionalChain([child, 'access', _86 => _86.stdin, 'optionalAccess', _87 => _87.end, 'call', _88 => _88()]);
+      child.kill();
+    }
+  }
+}, _class15);
+
+// src/device.ts
+var execFileAsync4 = _util.promisify.call(void 0, _child_process.execFile);
+var DEFAULT_TEMPERATURE = 0.4;
+var DEFAULT_MAX_TOKENS = 2048;
+var DEFAULT_MAX_TOOL_CALLS = 8;
+var CALL_TIMEOUT_MS2 = 12e4;
+var BUSY_RETRY_DELAYS_MS = [250, 1e3, 2500];
+function assertTools(tools) {
+  if (tools === void 0) return;
+  for (const tool2 of tools) {
+    if (!BUILT_IN_TOOLS.has(tool2)) {
+      throw new AppleLLMError(
+        `Unknown tool "${tool2}" (want ${[...BUILT_IN_TOOLS].join(", ")}).`,
+        "device"
+      );
+    }
+  }
+}
+async function probeDevice(onProgress) {
+  if (process.platform !== "darwin") {
+    return { available: false, reason: `unsupportedPlatform: this machine reports "${process.platform}"` };
+  }
+  if (!isAppleSiliconMac()) {
+    return { available: false, reason: "deviceNotEligible: Apple Intelligence needs Apple Silicon" };
+  }
+  const major = await macosMajor();
+  if (major !== null && major < 26) {
+    return { available: false, reason: `unsupportedOSVersion: needs macOS 26 or later, this is ${major}` };
+  }
+  let binary;
+  try {
+    binary = await ensureBinary(onProgress);
+  } catch (err) {
+    return { available: false, reason: err instanceof Error ? err.message : String(err) };
+  }
+  try {
+    const { stdout } = await execFileAsync4(binary, ["--probe"], { timeout: 2e4 });
+    return JSON.parse(stdout.trim());
+  } catch (err) {
+    const reason = err instanceof Error ? err.message : String(err);
+    return { available: false, reason: `the helper could not be run: ${reason.slice(0, 300)}` };
+  }
+}
+function raiseFor(response, raw, toolFailure) {
+  const detail = _nullishCoalesce(response.error, () => ( raw.slice(0, 200)));
+  switch (response.kind) {
+    case "availability":
+      throw new ModelUnavailableError(
+        unavailableMessage(detail),
+        toUnavailableReason(detail),
+        "device"
+      );
+    case "schema":
+      throw new SchemaRejectedError(
+        `Apple rejected the response schema: ${detail}
+Every object needs a title, an x-order and additionalProperties; enums must be anyOf/const; unions cannot include null.`,
+        "device"
+      );
+    case "context":
+      throw new ContextLengthError(
+        `The prompt exceeded the on-device context window: ${detail}`,
+        "device",
+        response.contextSize,
+        response.tokenCount
+      );
+    case "quota": {
+      const parsed = response.resetDate === void 0 ? void 0 : new Date(response.resetDate);
+      const resetDate = parsed !== void 0 && !Number.isNaN(parsed.getTime()) ? parsed : void 0;
+      throw new QuotaError(
+        `Apple rate limited the on-device model: ${detail}`,
+        "device",
+        resetDate
+      );
+    }
+    case "guardrail":
+      throw new RefusalError(`The on-device model declined to answer: ${detail}`, "device");
+    case "timeout":
+      throw new TimeoutError(`Apple on-device generation timed out: ${detail}`, "device");
+    case "cancelled":
+      throw new AbortError("The request was cancelled.", "device");
+    case "tool": {
+      const name = _nullishCoalesce(_nullishCoalesce(_optionalChain([toolFailure, 'optionalAccess', _89 => _89.name]), () => ( response.tool)), () => ( "unknown"));
+      const cause = _optionalChain([toolFailure, 'optionalAccess', _90 => _90.error]);
+      const why = cause instanceof Error ? cause.message : cause === void 0 ? detail : String(cause);
+      throw new ToolExecutionError(`Tool "${name}" failed: ${why}`, name, { cause });
+    }
+    case "unsupported":
+      throw new UnsupportedError(`Apple on-device generation failed: ${detail}`, "device");
+    case "busy":
+      throw new ModelBusyError(
+        "Apple\u2019s on-device model is busy serving other processes and turned the request away (ModelManagerError 1042), even after retrying. Try again shortly.",
+        "device"
+      );
+    default:
+      throw new AppleLLMError(`Apple on-device generation failed: ${detail}`, "device");
+  }
+}
+function usageFrom(raw) {
+  if (raw === void 0 || typeof raw.inputTokens !== "number" || typeof raw.outputTokens !== "number") {
+    return void 0;
+  }
+  return {
+    inputTokens: raw.inputTokens,
+    outputTokens: raw.outputTokens,
+    totalTokens: raw.inputTokens + raw.outputTokens,
+    ...typeof raw.cachedInputTokens === "number" ? { cachedInputTokens: raw.cachedInputTokens } : {}
+  };
+}
+function finishFrom(raw) {
+  if (raw === "length") return "length";
+  if (raw === "toolCalls") return "tool-calls";
+  return "stop";
+}
+var DeviceClient = class {
+  constructor(options = {}) {
+    this.options = options;
+    this.server = options.server;
+  }
+  
+  
+  
+  
+  
+  get label() {
+    const variant = _optionalChain([this, 'access', _91 => _91.probeResult, 'optionalAccess', _92 => _92.variant]);
+    return variant ? `apple on-device (${variant})` : "apple on-device";
+  }
+  get contextSize() {
+    return _optionalChain([this, 'access', _93 => _93.probeResult, 'optionalAccess', _94 => _94.contextSize]);
+  }
+  /** Probe and build once; concurrent first calls share the one attempt. */
+  async ensureReady(onProgress) {
+    if (_optionalChain([this, 'access', _95 => _95.probeResult, 'optionalAccess', _96 => _96.available]) === true && this.binary !== void 0) return;
+    this.readying ??= (async () => {
+      const probe2 = await probeDevice(onProgress);
+      this.probeResult = probe2;
+      if (!probe2.available) {
+        throw new ModelUnavailableError(
+          unavailableMessage(probe2.reason),
+          toUnavailableReason(probe2.reason),
+          "device"
+        );
+      }
+      this.binary = await ensureBinary(onProgress);
+      _optionalChain([onProgress, 'optionalCall', _97 => _97({
+        status: `apple on-device model ready${probe2.variant ? ` (${probe2.variant}, ${probe2.contextSize} token context)` : ""}`
+      })]);
+    })().finally(() => {
+      this.readying = void 0;
+    });
+    return this.readying;
+  }
+  getProbe() {
+    return this.probeResult;
+  }
+  async helper() {
+    if (this.options.server !== void 0) return this.options.server;
+    await this.ensureReady();
+    const binary = await _asyncNullishCoalesce(this.binary, async () => ( await ensureBinary()));
+    this.server ??= new HelperServer(binary, { timeoutMs: CALL_TIMEOUT_MS2 });
+    return this.server;
+  }
+  /** Send one single-line envelope and return the parsed reply, raising a typed error on failure. */
+  async exchange(envelope, signal) {
+    const server = await this.helper();
+    const id = _crypto.randomUUID.call(void 0, );
+    const raw = await server.request(JSON.stringify({ ...envelope, id }), { signal, id });
+    const response = parse(raw);
+    if (response.ok !== true) raiseFor(response, raw);
+    return response;
+  }
+  /** The request envelope, shared by every generation path. */
+  async envelopeFor(request, op) {
+    assertTools(request.tools);
+    return {
+      op,
+      instructions: _nullishCoalesce(request.system, () => ( "")),
+      prompt: await withDocuments(request.prompt, request.documents),
+      schema: _nullishCoalesce(request.schema, () => ( null)),
+      temperature: _nullishCoalesce(request.temperature, () => ( DEFAULT_TEMPERATURE)),
+      maxTokens: _nullishCoalesce(request.maxTokens, () => ( DEFAULT_MAX_TOKENS)),
+      includeSchemaInPrompt: request.includeSchemaInPrompt,
+      reuseSession: _nullishCoalesce(request.reuseSession, () => ( false)),
+      sessionId: request.sessionId,
+      history: request.history !== void 0 && request.history.length > 0 ? request.history : void 0,
+      trimHistory: request.trimHistory,
+      tools: request.tools !== void 0 && request.tools.length > 0 ? request.tools : void 0,
+      functions: request.functions !== void 0 && request.functions.length > 0 ? request.functions.map((fn) => ({
+        name: fn.name,
+        description: _nullishCoalesce(fn.description, () => ( "")),
+        parameters: toAppleSchema(fn.json, `${fn.name}Arguments`)
+      })) : void 0,
+      images: request.images,
+      useCase: _nullishCoalesce(request.useCase, () => ( this.options.useCase)),
+      guardrails: _nullishCoalesce(request.guardrails, () => ( this.options.guardrails)),
+      sampling: request.sampling
+    };
+  }
+  /**
+   * One generation, with every event handled: text deltas, partial objects,
+   * and function tool calls, which run here and answer the helper.
+   */
+  async run(request, op = "generate", hooks = {}) {
+    const envelope = await this.envelopeFor(request, op);
+    const server = await this.helper();
+    const functions = new Map((_nullishCoalesce(request.functions, () => ( []))).map((fn) => [fn.name, fn]));
+    const maxToolCalls = _nullishCoalesce(hooks.maxToolCalls, () => ( DEFAULT_MAX_TOOL_CALLS));
+    const calls = [];
+    let toolFailure;
+    const answerToolCall = async (call, write) => {
+      const reply = (fields) => write({ op: "toolResult", callId: call.id, ...fields });
+      const fn = functions.get(call.name);
+      if (fn === void 0) {
+        reply({ output: `There is no tool named "${call.name}".`, isError: true });
+        return;
+      }
+      if (calls.length > maxToolCalls) {
+        call.output = "Tool call limit reached. Answer with the information you already have.";
+        reply({ output: call.output });
+        return;
+      }
+      const replayed = _optionalChain([hooks, 'access', _98 => _98.replay, 'optionalAccess', _99 => _99.take, 'call', _100 => _100(call.name, call.arguments)]);
+      if (replayed !== void 0) {
+        call.output = replayed;
+        reply({ output: replayed });
+        return;
+      }
+      if (fn.execute === void 0) {
+        reply({ stop: true });
+        return;
+      }
+      let args = restoreNulls(call.arguments, fn.json);
+      if (_optionalChain([fn, 'access', _101 => _101.resolved, 'optionalAccess', _102 => _102.validate]) !== void 0) {
+        const checked = await fn.resolved.validate(args);
+        if (checked.issues !== void 0) {
+          call.output = `Invalid arguments: ${describeIssues(checked.issues)}`;
+          reply({ output: call.output });
+          return;
+        }
+        args = checked.value;
+      }
+      server.pause();
+      try {
+        const result = await fn.execute(args, { toolCallId: call.id, signal: hooks.signal });
+        call.output = toolOutputText(result);
+        reply({ output: call.output });
+      } catch (error) {
+        toolFailure = { name: call.name, error };
+        reply({ output: error instanceof Error ? error.message : String(error), isError: true });
+      } finally {
+        server.resume();
+      }
+    };
+    let delivered = false;
+    const attempt = (id = _crypto.randomUUID.call(void 0, )) => server.request(JSON.stringify({ ...envelope, id }), {
+      id,
+      signal: hooks.signal,
+      onEvent: (event, write) => {
+        delivered = true;
+        if (typeof event.delta === "string") {
+          if (event.delta !== "") _optionalChain([hooks, 'access', _103 => _103.onDelta, 'optionalCall', _104 => _104(event.delta)]);
+        } else if (typeof event.partial === "string") {
+          _optionalChain([hooks, 'access', _105 => _105.onPartial, 'optionalCall', _106 => _106(event.partial)]);
+        } else if (event.toolCall !== null && typeof event.toolCall === "object") {
+          const toolCall = event.toolCall;
+          const call = {
+            id: String(_nullishCoalesce(toolCall.id, () => ( _crypto.randomUUID.call(void 0, )))),
+            name: String(_nullishCoalesce(toolCall.name, () => ( ""))),
+            arguments: _nullishCoalesce(toolCall.arguments, () => ( {}))
+          };
+          calls.push(call);
+          try {
+            _optionalChain([hooks, 'access', _107 => _107.onToolCall, 'optionalCall', _108 => _108(call)]);
+          } catch (e20) {
+          }
+          void answerToolCall(call, write).catch((error) => {
+            toolFailure ??= { name: call.name, error };
+            write({ op: "toolResult", callId: call.id, output: String(error), isError: true });
+          });
+        }
+      }
+    });
+    let raw = await attempt();
+    let response = parse(raw);
+    for (const delay of BUSY_RETRY_DELAYS_MS) {
+      if (response.ok === true || response.kind !== "busy" || delivered) break;
+      await sleep(delay, hooks.signal);
+      raw = await attempt();
+      response = parse(raw);
+    }
+    if (response.ok !== true) raiseFor(response, raw, toolFailure);
+    if (typeof response.content !== "string") {
+      throw new AppleLLMError("Apple helper returned no content.", "device");
+    }
+    const builtIn = (_nullishCoalesce(response.toolCalls, () => ( []))).filter((c) => typeof c.name === "string" && !functions.has(c.name)).map((c) => ({
+      id: String(_nullishCoalesce(c.id, () => ( ""))),
+      name: String(c.name),
+      arguments: _nullishCoalesce(c.arguments, () => ( {})),
+      ...typeof c.output === "string" ? { output: c.output } : {}
+    }));
+    return {
+      content: response.content,
+      finishReason: finishFrom(response.finishReason),
+      usage: usageFrom(response.usage),
+      toolCalls: [...calls, ...builtIn],
+      trimmedTurns: typeof response.trimmedTurns === "number" ? response.trimmedTurns : 0
+    };
+  }
+  /** One request. Returns the helper's `content` string, unparsed. */
+  async complete(request, hooks = {}) {
+    return (await this.run(request, "generate", hooks)).content;
+  }
+  /**
+   * Streaming text. Deltas arrive via onDelta as the model generates; the
+   * promise resolves with the full text.
+   */
+  async stream(prompt, options = {}) {
+    const { onDelta, signal, ...rest } = options;
+    return (await this.run({ ...rest, prompt, schema: null }, "stream", { onDelta, signal })).content;
+  }
+  /**
+   * Conversation history for a named session: the mirrored turns the helper
+   * persisted, oldest first. Survives helper restarts, and the next call
+   * rebuilds the native transcript from it.
+   */
+  async history(sessionId) {
+    const response = await this.exchange({ op: "history", sessionId, instructions: "" });
+    return {
+      instructions: typeof response.instructions === "string" ? response.instructions : "",
+      history: Array.isArray(response.history) ? response.history : []
+    };
+  }
+  /** Drop a named session (and its persisted history), or all of them. */
+  async resetSession(sessionId) {
+    await this.exchange({ op: "reset", sessionId: _nullishCoalesce(sessionId, () => ( "")), instructions: "" });
+  }
+  /**
+   * How many tokens a request costs, before sending it.
+   *
+   * The point is to turn a ContextLengthError into an arithmetic check: compare
+   * against `contextSize` and trim, rather than discovering the ceiling by
+   * hitting it. Counts everything that shares the window: instructions,
+   * history, tools, schema, images and inlined documents.
+   */
+  async countTokens(prompt, options = {}) {
+    const envelope = await this.envelopeFor(
+      {
+        prompt,
+        system: options.system,
+        images: options.images,
+        tools: options.tools,
+        documents: options.documents,
+        history: options.history,
+        schema: options.schema === void 0 ? null : toAppleSchema(options.schema),
+        functions: options.functions
+      },
+      "generate"
+    );
+    const response = await this.exchange({ ...envelope, op: "countTokens" }, options.signal);
+    if (typeof response.tokens !== "number" || typeof response.contextSize !== "number") {
+      throw new AppleLLMError("Apple helper returned an unreadable token count.", "device");
+    }
+    return { tokens: response.tokens, contextSize: response.contextSize };
+  }
+  /**
+   * Load the model assets now so the first real call does not pay for it.
+   *
+   * Cheap and idempotent, but do not expect much on a warm machine: with the
+   * assets already resident this measured 0.31s against 0.36s for an
+   * unprewarmed first call — inside the noise. The win is on a genuinely cold
+   * system, where the very first call to the framework here took 7.8s. Worth
+   * calling at startup when you know a request is coming; not worth building
+   * around.
+   */
+  async prewarm(system) {
+    await this.exchange({ op: "prewarm", instructions: _nullishCoalesce(system, () => ( "")) });
+  }
+  async text(prompt, options = {}) {
+    return this.complete({ ...options, prompt, schema: null });
+  }
+  async json(prompt, options) {
+    const content = await this.complete({ ...options, prompt, schema: toAppleSchema(options.schema) });
+    try {
+      return restoreNulls(JSON.parse(content), options.schema);
+    } catch (e21) {
+      throw new AppleLLMError(
+        `Apple on-device model returned invalid JSON: ${content.slice(0, 200)}`,
+        "device"
+      );
+    }
+  }
+  /** Shut the helper process down. Safe to call more than once. */
+  close() {
+    _optionalChain([this, 'access', _109 => _109.server, 'optionalAccess', _110 => _110.stop, 'call', _111 => _111()]);
+    this.server = void 0;
+  }
+};
+function sleep(ms, signal) {
+  return new Promise((resolve, reject) => {
+    if (_optionalChain([signal, 'optionalAccess', _112 => _112.aborted]) === true) {
+      reject(abortErrorFrom(signal));
+      return;
+    }
+    const timer = setTimeout(() => {
+      _optionalChain([signal, 'optionalAccess', _113 => _113.removeEventListener, 'call', _114 => _114("abort", onAbort)]);
+      resolve();
+    }, ms);
+    const onAbort = () => {
+      clearTimeout(timer);
+      reject(abortErrorFrom(signal));
+    };
+    _optionalChain([signal, 'optionalAccess', _115 => _115.addEventListener, 'call', _116 => _116("abort", onAbort, { once: true })]);
+  });
+}
+function parse(raw) {
+  try {
+    return JSON.parse(raw);
+  } catch (e22) {
+    throw new AppleLLMError(`Apple helper returned an unreadable envelope: ${raw.slice(0, 200)}`, "device");
+  }
+}
+async function withDocuments(prompt, documents) {
+  if (documents === void 0 || documents.length === 0) return prompt;
+  const { readFile: readFile3, stat: stat3 } = await Promise.resolve().then(() => _interopRequireWildcard(require("fs/promises")));
+  const parts = [prompt];
+  for (const doc of documents) {
+    let size = 0;
+    try {
+      size = (await stat3(doc)).size;
+    } catch (e23) {
+      throw new AppleLLMError(`Document not found: ${doc}`);
+    }
+    if (size > 512e3) {
+      throw new AppleLLMError(`Document too large to inline (>${512e3} bytes): ${doc}`);
+    }
+    let text;
+    try {
+      text = await readFile3(doc, "utf8");
+    } catch (e24) {
+      throw new AppleLLMError(`Document is not readable text: ${doc}`);
+    }
+    if (text.includes("\uFFFD")) {
+      throw new AppleLLMError(`Document is not readable text: ${doc}`);
+    }
+    parts.push(`
+
+--- Document: ${doc} ---
+${text}`);
+  }
+  return parts.join("");
+}
+function parseImageFlag(value) {
+  const sep = value.lastIndexOf("::");
+  if (sep > 0) {
+    const path3 = value.slice(0, sep);
+    const label = value.slice(sep + 2).trim();
+    if (path3 !== "" && label !== "") return { path: path3, label };
+  }
+  return value;
+}
+
+// src/stream.ts
+var Channel = (_class16 = class {constructor() { _class16.prototype.__init20.call(this);_class16.prototype.__init21.call(this); }
+  __init20() {this.items = []}
+  
+  __init21() {this.closed = false}
+  push(value) {
+    this.offer({ value });
+  }
+  end() {
+    this.offer({ done: true });
+  }
+  fail(error) {
+    this.offer({ error });
+  }
+  offer(item) {
+    if (this.closed) return;
+    if (!("value" in item)) this.closed = true;
+    const waiter = this.waiter;
+    if (waiter !== void 0) {
+      this.waiter = void 0;
+      waiter(item);
+    } else {
+      this.items.push(item);
+    }
+  }
+  next() {
+    const item = this.items.shift();
+    if (item !== void 0) return Promise.resolve(item);
+    return new Promise((resolve) => {
+      this.waiter = resolve;
+    });
+  }
+}, _class16);
+var ResultStream = (_class17 = class {
+  /** Everything about the finished generation: text, usage, tool calls, finish reason. */
+  
+  __init22() {this.channel = new Channel()}
+  __init23() {this.controller = new AbortController()}
+  
+  __init24() {this.iterated = false}
+  __init25() {this.finished = false}
+  constructor(run, pick) {;_class17.prototype.__init22.call(this);_class17.prototype.__init23.call(this);_class17.prototype.__init24.call(this);_class17.prototype.__init25.call(this);
+    this.result = run((chunk) => this.channel.push(chunk), this.controller.signal).then(
+      (result) => {
+        this.finished = true;
+        this.channel.end();
+        return result;
+      },
+      (error) => {
+        this.finished = true;
+        this.channel.fail(error);
+        throw error;
+      }
+    );
+    this.final = this.result.then(pick);
+    this.result.catch(() => void 0);
+    this.final.catch(() => void 0);
+  }
+  /** Stop generating. The promise and the iterator both reject with an AbortError. */
+  abort(reason) {
+    this.controller.abort(reason);
+  }
+  then(onfulfilled, onrejected) {
+    return this.final.then(onfulfilled, onrejected);
+  }
+  catch(onrejected) {
+    return this.final.catch(onrejected);
+  }
+  finally(onfinally) {
+    return this.final.finally(onfinally);
+  }
+  [Symbol.asyncIterator]() {
+    if (this.iterated) throw new Error("A stream can only be iterated once.");
+    this.iterated = true;
+    return {
+      next: async () => {
+        const item = await this.channel.next();
+        if ("value" in item) return { value: item.value, done: false };
+        if ("error" in item) throw item.error;
+        return { value: void 0, done: true };
+      },
+      return: async () => {
+        if (!this.finished) this.abort();
+        return { value: void 0, done: true };
+      }
+    };
+  }
+}, _class17);
+
+// src/client.ts
+async function probe(onProgress) {
+  const [device, cloud] = await Promise.all([probeDevice(onProgress), probeCloud()]);
+  if (device.cloud !== void 0) {
+    const { capabilities, contextSize, ...quota } = device.cloud;
+    cloud.quota = quota;
+    if (capabilities !== void 0) cloud.capabilities = capabilities;
+    if (contextSize !== void 0 && cloud.contextSize !== void 0) cloud.contextSize = contextSize;
+  }
+  return { device, cloud };
+}
+function anySignal(signals) {
+  const list = signals.filter((s) => s !== void 0);
+  if (list.length <= 1) return list[0];
+  const any = AbortSignal.any;
+  if (typeof any === "function") return any(list);
+  const controller = new AbortController();
+  for (const signal of list) {
+    if (signal.aborted) {
+      controller.abort(signal.reason);
+      break;
+    }
+    signal.addEventListener("abort", () => controller.abort(signal.reason), { once: true });
+  }
+  return controller.signal;
+}
+var AppleLLM = class {
+  
+  
+  /** Which tier `auto` settled on, once resolved. */
+  
+  
+  
+  constructor(options = {}) {
+    this.options = options;
+  }
+  get tier() {
+    return _nullishCoalesce(this.options.tier, () => ( "auto"));
+  }
+  /** Human-readable name of the tier in use, for logs. */
+  get label() {
+    if (this.resolved === "cloud") return _nullishCoalesce(_optionalChain([this, 'access', _117 => _117.cloud, 'optionalAccess', _118 => _118.label]), () => ( "apple private cloud compute"));
+    if (this.resolved === "device") return _nullishCoalesce(_optionalChain([this, 'access', _119 => _119.device, 'optionalAccess', _120 => _120.label]), () => ( "apple on-device"));
+    return `apple (${this.tier})`;
+  }
+  /** Context window of the resolved tier, in tokens. */
+  get contextSize() {
+    if (this.resolved === "cloud") return _nullishCoalesce(_optionalChain([this, 'access', _121 => _121.cloud, 'optionalAccess', _122 => _122.contextSize]), () => ( CLOUD_CONTEXT_TOKENS));
+    return _optionalChain([this, 'access', _123 => _123.device, 'optionalAccess', _124 => _124.contextSize]);
+  }
+  /**
+   * Resolve the tier and do any one-time setup. Called automatically, but
+   * exposed so a caller can pay the compile cost up front with a progress bar.
+   * Concurrent first calls share one attempt.
+   */
+  async ensureReady(onProgress) {
+    if (this.resolved !== void 0) return;
+    this.readying ??= this.resolve(_nullishCoalesce(onProgress, () => ( this.options.onProgress))).finally(() => {
+      this.readying = void 0;
+    });
+    return this.readying;
+  }
+  newDevice() {
+    return new DeviceClient({ useCase: this.options.useCase, guardrails: this.options.guardrails });
+  }
+  async readyCloud(progress) {
+    this.cloud ??= new CloudClient();
+    await this.cloud.ensureReady(progress);
+    this.cloud.setQuota(await _asyncOptionalChain([(await probeDevice().catch(() => void 0)), 'optionalAccess', async _125 => _125.cloud]));
+    this.resolved = "cloud";
+  }
+  async resolve(progress) {
+    if (this.tier === "device") {
+      this.device ??= this.newDevice();
+      await this.device.ensureReady(progress);
+      this.resolved = "device";
+      return;
+    }
+    if (this.tier === "cloud") {
+      await this.readyCloud(progress);
+      return;
+    }
+    this.device ??= this.newDevice();
+    try {
+      await this.device.ensureReady(progress);
+      this.resolved = "device";
+    } catch (deviceError) {
+      try {
+        await this.readyCloud(progress);
+      } catch (cloudError) {
+        const deviceReason = deviceError instanceof Error ? deviceError.message : String(deviceError);
+        const cloudReason = cloudError instanceof Error ? cloudError.message : String(cloudError);
+        throw new ModelUnavailableError(
+          `No Apple model is available.
+
+On-device: ${deviceReason}
+
+Cloud: ${cloudReason}`,
+          deviceError instanceof ModelUnavailableError ? deviceError.reason : "unknown"
+        );
+      }
+    }
+  }
+  /** Free text. */
+  async text(input, options = {}) {
+    return (await this.execute(input, options, {})).text;
+  }
+  async generate(input, options = {}) {
+    const { schema, ...rest } = options;
+    return this.execute(input, rest, { schema: schema === void 0 ? void 0 : resolveSchema(schema) });
+  }
+  /**
+   * Ask for JSON. On device the *shape* is guaranteed by constrained decoding;
+   * a Standard Schema's own validation (refinements, transforms) then runs on
+   * top, and the result is typed by it. On cloud the shape is requested in the
+   * prompt and recovered from the reply. Either way, a reply that fails
+   * validation is retried once with the problems pointed out, then raised as a
+   * SchemaValidationError.
+   */
+  async json(input, options) {
+    const { schema, ...rest } = options;
+    const result = await this.execute(input, rest, { schema: resolveSchema(schema) });
+    return result.object;
+  }
+  /**
+   * Streaming text. Iterate it for deltas, or await it for the whole reply:
+   *
+   *   for await (const delta of llm.stream(prompt)) process.stdout.write(delta);
+   *   const text = await llm.stream(prompt, { onDelta });
+   *
+   * On the cloud tier the reply arrives as one chunk: Shortcuts is not
+   * incremental.
+   */
+  stream(input, options = {}) {
+    const { onDelta, ...rest } = options;
+    return new ResultStream(
+      (emit, signal) => this.execute(input, rest, {
+        streaming: true,
+        signal,
+        onDelta: (delta) => {
+          _optionalChain([onDelta, 'optionalCall', _126 => _126(delta)]);
+          emit(delta);
+        }
+      }),
+      (result) => result.text
+    );
+  }
+  /**
+   * Streaming JSON: partial objects as the model fills them in — render a form
+   * or a card while it is still being written — and the final object, parsed
+   * and validated, as the awaited value.
+   *
+   *   for await (const partial of llm.streamJson(prompt, { schema })) render(partial);
+   */
+  streamJson(input, options) {
+    const { schema, ...rest } = options;
+    const resolved = resolveSchema(schema);
+    return new ResultStream(
+      (emit, signal) => this.execute(input, rest, {
+        schema: resolved,
+        streaming: true,
+        signal,
+        onPartial: (json) => {
+          try {
+            emit(JSON.parse(json));
+          } catch (e25) {
+          }
+        }
+      }),
+      (result) => result.object
+    );
+  }
+  /** The one path every generation takes. */
+  async execute(input, options, mode) {
+    const started = Date.now();
+    await this.ensureReady();
+    let prompt;
+    let history = [];
+    let replay;
+    let system = _nullishCoalesce(options.system, () => ( this.options.system));
+    let trimHistory;
+    let images = options.images;
+    if (typeof input === "string") {
+      prompt = input;
+    } else {
+      if (options.sessionId !== void 0) {
+        throw new AppleLLMError(
+          "Pass either a message list or a sessionId, not both: a named session keeps its own history."
+        );
+      }
+      const split = splitMessages(input);
+      prompt = split.prompt;
+      history = split.history;
+      replay = split.replay.length > 0 ? new ReplayBook(split.replay) : void 0;
+      if (split.system !== void 0) system = system === void 0 ? split.system : `${system}
+
+${split.system}`;
+      trimHistory = _nullishCoalesce(options.trimHistory, () => ( true));
+      if (split.images.length > 0) images = [..._nullishCoalesce(images, () => ( [])), ...split.images];
+    }
+    const tools = normalizeTools(options.tools);
+    const timeoutMs = _nullishCoalesce(options.timeoutMs, () => ( this.options.timeoutMs));
+    const signal = anySignal([
+      options.signal,
+      mode.signal,
+      timeoutMs === void 0 ? void 0 : AbortSignal.timeout(timeoutMs)
+    ]);
+    if (_optionalChain([signal, 'optionalAccess', _127 => _127.aborted]) === true) throw abortErrorFrom(signal);
+    const attempt = async (feedback) => {
+      const promptText = feedback === void 0 ? prompt : `${prompt}
+
+${feedback}`;
+      let text;
+      let finishReason = "stop";
+      let usage;
+      let toolCalls = [];
+      let trimmedTurns = 0;
+      if (this.resolved === "cloud") {
+        this.assertCloudCompatible({ ...options, images }, tools.builtIn.length + tools.functions.length > 0);
+        let cloudPrompt = await withDocuments(promptText, options.documents);
+        if (history.length > 0) {
+          cloudPrompt = `Conversation so far:
+${renderHistory(history)}
+
+New message from the user:
+${cloudPrompt}`;
+        }
+        let cloudSystem = system;
+        if (mode.schema !== void 0) {
+          const instruction = "Reply with a single JSON value matching this JSON Schema. Output only the JSON, with no commentary and no code fence.\n\n" + JSON.stringify(mode.schema.json, null, 2);
+          cloudSystem = cloudSystem ? `${cloudSystem}
+
+${instruction}` : instruction;
+        }
+        text = await this.cloud.text({
+          system: cloudSystem,
+          prompt: cloudPrompt,
+          webSearch: options.webSearch,
+          signal,
+          images: images !== void 0 && images.length > 0 ? images : void 0
+        });
+        if (mode.schema === void 0) _optionalChain([mode, 'access', _128 => _128.onDelta, 'optionalCall', _129 => _129(text)]);
+      } else {
+        const outcome = await this.device.run(
+          {
+            system,
+            prompt: promptText,
+            schema: mode.schema === void 0 ? null : toAppleSchema(mode.schema.json),
+            temperature: _nullishCoalesce(options.temperature, () => ( this.options.temperature)),
+            maxTokens: _nullishCoalesce(options.maxTokens, () => ( this.options.maxTokens)),
+            images,
+            documents: options.documents,
+            sessionId: options.sessionId,
+            history: history.length > 0 ? history : void 0,
+            trimHistory,
+            tools: tools.builtIn.length > 0 ? tools.builtIn : void 0,
+            functions: tools.functions.length > 0 ? tools.functions : void 0,
+            useCase: _nullishCoalesce(options.useCase, () => ( this.options.useCase)),
+            guardrails: _nullishCoalesce(options.guardrails, () => ( this.options.guardrails)),
+            sampling: _nullishCoalesce(options.sampling, () => ( this.options.sampling))
+          },
+          mode.streaming === true ? "stream" : "generate",
+          {
+            signal,
+            onDelta: mode.onDelta,
+            onPartial: mode.onPartial,
+            replay,
+            maxToolCalls: options.maxToolCalls
+          }
+        );
+        text = outcome.content;
+        finishReason = outcome.finishReason;
+        usage = outcome.usage;
+        toolCalls = outcome.toolCalls;
+        trimmedTurns = outcome.trimmedTurns;
+      }
+      let object;
+      if (mode.schema !== void 0 && finishReason !== "tool-calls") {
+        object = await this.parseObject(text, mode.schema);
+        if (this.resolved === "cloud") _optionalChain([mode, 'access', _130 => _130.onPartial, 'optionalCall', _131 => _131(JSON.stringify(object))]);
+      }
+      return {
+        text,
+        object,
+        finishReason,
+        usage,
+        toolCalls,
+        trimmedTurns,
+        tier: this.resolved === "cloud" ? "cloud" : "device",
+        durationMs: Date.now() - started,
+        message: {
+          role: "assistant",
+          content: finishReason === "tool-calls" ? null : text,
+          ...toolCalls.length > 0 ? { toolCalls: toolCalls.map(({ id, name, arguments: args }) => ({ id, name, arguments: args })) } : {}
+        }
+      };
+    };
+    try {
+      return await attempt();
+    } catch (error) {
+      if (!(error instanceof SchemaValidationError) || mode.streaming === true) throw error;
+      return attempt(
+        `Your previous answer was rejected: ${error.message.replace(/^The model's reply did not satisfy the schema: /, "")}. Answer again, fixing those problems.`
+      );
+    }
+  }
+  /** Parse, restore nulls, validate. Throws SchemaValidationError for anything the schema rejects. */
+  async parseObject(text, schema) {
+    const tier = this.resolved === "cloud" ? "cloud" : "device";
+    let value;
+    try {
+      value = tier === "cloud" ? parseLlmJson(text) : JSON.parse(text);
+    } catch (e26) {
+      throw new SchemaValidationError("The model did not reply with valid JSON.", [{ message: "invalid JSON" }], text, tier);
+    }
+    return validateWith(schema, restoreNulls(value, schema.json), text, tier);
+  }
+  assertCloudCompatible(options, hasTools) {
+    const refuse = (what) => {
+      throw new UnsupportedError(`${what} needs the on-device tier.`, "cloud");
+    };
+    if (options.images !== void 0 && options.images.length > 0 && _optionalChain([this, 'access', _132 => _132.cloud, 'optionalAccess', _133 => _133.supportsImages]) !== true) {
+      throw new UnsupportedError(
+        "images on the cloud tier need a server model that reads them \u2014 macOS 27 (Golden Gate) or later, where the helper can confirm it. Use the on-device tier for images here.",
+        "cloud"
+      );
+    }
+    if (options.sessionId !== void 0) refuse("sessionId");
+    if (hasTools) refuse("tools");
+  }
+  /** Conversation history for a named session (device tier only). */
+  async history(sessionId) {
+    await this.ensureReady();
+    if (this.resolved !== "device") {
+      throw new UnsupportedError("history needs the on-device tier.", "cloud");
+    }
+    return this.device.history(sessionId);
+  }
+  /** Drop a named session, or all sessions when omitted (device tier only). */
+  async resetSession(sessionId) {
+    await this.ensureReady();
+    if (this.resolved === "device") await this.device.resetSession(sessionId);
+  }
+  /**
+   * A named conversation: calls sharing one native transcript, like one thread
+   * in the Siri app. History persists across helper restarts, and the
+   * transcript is rebuilt from it — trimmed to fit when it outgrows the window.
+   */
+  conversation(sessionId, options = {}) {
+    return new Conversation(this, sessionId, options);
+  }
+  /**
+   * Write with Siri, anywhere you type: drafting, rewriting and feedback
+   * built on the permissive-content-transformation guardrails. Device tier
+   * only — these are transformation tasks the default guardrails refuse.
+   */
+  async rewrite(text, options = {}) {
+    const { instruction, ...rest } = options;
+    return this.text(`Rewrite the following text. ${_nullishCoalesce(instruction, () => ( "Keep the meaning, improve clarity."))}
+
+---
+${text}`, {
+      ...rest,
+      guardrails: _nullishCoalesce(rest.guardrails, () => ( "permissive")),
+      system: _nullishCoalesce(rest.system, () => ( "You rewrite text. Reply with only the rewritten text, no commentary."))
+    });
+  }
+  async proofread(text, options = {}) {
+    return this.text(`Fix spelling, grammar and punctuation in the following text. Preserve the meaning and tone.
+
+---
+${text}`, {
+      ...options,
+      guardrails: _nullishCoalesce(options.guardrails, () => ( "permissive")),
+      system: _nullishCoalesce(options.system, () => ( "You proofread text. Reply with only the corrected text, no commentary."))
+    });
+  }
+  /**
+   * Summarise text of any length. Text that does not fit the context window
+   * is summarised in parts, then the parts are summarised together — so a
+   * long report works on an 8k-token model instead of failing.
+   */
+  async summarize(text, options = {}) {
+    const { length, ...rest } = options;
+    const once = (body, what, size) => this.text(`Summarize ${what} in ${size}.
+
+---
+${body}`, {
+      ...rest,
+      guardrails: _nullishCoalesce(rest.guardrails, () => ( "permissive")),
+      system: _nullishCoalesce(rest.system, () => ( "You summarize text tersely."))
+    });
+    let current = text;
+    for (let round = 0; round < 4; round += 1) {
+      const chunks = await this.chunksFor(current, rest.maxTokens);
+      if (chunks.length <= 1) break;
+      const parts = [];
+      for (const chunk of chunks) {
+        parts.push(await once(chunk, "this part of a longer document", "a few sentences, keeping names, numbers and decisions"));
+      }
+      current = parts.join("\n\n");
+    }
+    return once(current, current === text ? "the following text" : "these notes on a longer document", _nullishCoalesce(length, () => ( "one short paragraph")));
+  }
+  /** Split text into pieces that each fit one call, on paragraph boundaries where possible. */
+  async chunksFor(text, maxTokens) {
+    await this.ensureReady();
+    const window = _nullishCoalesce(this.contextSize, () => ( 4096));
+    const budget = Math.max(512, window - (_nullishCoalesce(_nullishCoalesce(maxTokens, () => ( this.options.maxTokens)), () => ( 1024))) - 256);
+    let tokens;
+    if (this.resolved === "device") {
+      try {
+        tokens = (await this.device.countTokens(text)).tokens;
+      } catch (e27) {
+        tokens = Math.ceil(text.length / 3);
+      }
+    } else {
+      tokens = Math.ceil(text.length / 3);
+    }
+    if (tokens <= budget) return [text];
+    const maxChars = Math.floor(text.length / tokens * budget * 0.85);
+    const chunks = [];
+    let current = "";
+    for (const paragraph of text.split(/\n\s*\n/)) {
+      const pieces = paragraph.length > maxChars ? _nullishCoalesce(paragraph.match(new RegExp(`[\\s\\S]{1,${maxChars}}`, "g")), () => ( [])) : [paragraph];
+      for (const piece of pieces) {
+        if (current.length + piece.length + 2 > maxChars && current !== "") {
+          chunks.push(current);
+          current = "";
+        }
+        current = current === "" ? piece : `${current}
+
+${piece}`;
+      }
+    }
+    if (current !== "") chunks.push(current);
+    return chunks;
+  }
+  async draft(topic, options = {}) {
+    const { kind, ...rest } = options;
+    return this.text(`Write a ${_nullishCoalesce(kind, () => ( "short draft"))} about the following topic.
+
+---
+${topic}`, {
+      ...rest,
+      system: _nullishCoalesce(rest.system, () => ( "You are a helpful writing assistant."))
+    });
+  }
+  async tone(text, tone, options = {}) {
+    return this.text(`Rewrite the following text to sound more ${tone}.
+
+---
+${text}`, {
+      ...options,
+      guardrails: _nullishCoalesce(options.guardrails, () => ( "permissive")),
+      system: _nullishCoalesce(options.system, () => ( "You rewrite text. Reply with only the rewritten text, no commentary."))
+    });
+  }
+  /**
+   * Ask about what's on screen: captures a screenshot (interactive selection
+   * by default, like Cmd+Shift+Space Visual Intelligence) and asks the model
+   * about it with vision. Device tier, macOS 27+.
+   */
+  async askScreen(question, options = {}) {
+    await this.ensureReady();
+    if (this.resolved !== "device") {
+      throw new UnsupportedError("askScreen needs the on-device tier.", "cloud");
+    }
+    const { mode, ...rest } = options;
+    const shot = await captureScreenshot(_nullishCoalesce(mode, () => ( "interactive")));
+    try {
+      return await this.text(question, { ...rest, images: [..._nullishCoalesce(rest.images, () => ( [])), shot] });
+    } finally {
+      const { rm: rm3 } = await Promise.resolve().then(() => _interopRequireWildcard(require("fs/promises")));
+      await rm3(shot, { force: true }).catch(() => void 0);
+    }
+  }
+  /**
+   * `json()` in the `(system, user, schema)` shape many LLM clients use, for
+   * dropping this in behind an existing interface.
+   */
+  async completeJson(system, user, schema) {
+    return this.json(user, { system, schema });
+  }
+  /**
+   * How many tokens a request costs, before sending it. Device tier only.
+   *
+   * Turns a ContextLengthError into arithmetic: compare against `contextSize`
+   * and trim, rather than finding the ceiling by hitting it. Counts
+   * everything that shares the window — instructions, message history, tools,
+   * schema, images and documents.
+   */
+  async countTokens(input, options = {}) {
+    await this.ensureReady();
+    if (this.resolved !== "device") {
+      throw new UnsupportedError("countTokens needs the on-device tier.", "cloud");
+    }
+    let prompt;
+    let history;
+    let system = _nullishCoalesce(options.system, () => ( this.options.system));
+    if (typeof input === "string") {
+      prompt = input;
+    } else {
+      const split = splitMessages(input);
+      prompt = split.prompt;
+      history = split.history;
+      if (split.system !== void 0) system = system === void 0 ? split.system : `${system}
+
+${split.system}`;
+    }
+    const tools = normalizeTools(options.tools);
+    return this.device.countTokens(prompt, {
+      system,
+      images: options.images,
+      documents: options.documents,
+      history,
+      tools: tools.builtIn.length > 0 ? tools.builtIn : void 0,
+      functions: tools.functions.length > 0 ? tools.functions : void 0,
+      schema: options.schema === void 0 ? void 0 : resolveSchema(options.schema).json,
+      signal: options.signal
+    });
+  }
+  /**
+   * Load the model assets now so the first real call does not pay for it.
+   * Device tier only; a no-op elsewhere. See `DeviceClient.prewarm` for what it
+   * is actually worth (little, on a warm machine).
+   */
+  async prewarm(system) {
+    await this.ensureReady();
+    if (this.resolved === "device") await this.device.prewarm(_nullishCoalesce(system, () => ( this.options.system)));
+  }
+  /** Release the long-lived helper process. Safe to call more than once. */
+  close() {
+    _optionalChain([this, 'access', _134 => _134.device, 'optionalAccess', _135 => _135.close, 'call', _136 => _136()]);
+    _optionalChain([this, 'access', _137 => _137.cloud, 'optionalAccess', _138 => _138.close, 'call', _139 => _139()]);
+  }
+  /** `using llm = new AppleLLM()` closes it at the end of the block. */
+  [Symbol.dispose]() {
+    this.close();
+  }
+  /** `await using llm = new AppleLLM()` closes it at the end of the block. */
+  async [Symbol.asyncDispose]() {
+    this.close();
+  }
+};
+var Conversation = class {
+  constructor(llm, sessionId, defaults = {}) {
+    this.llm = llm;
+    this.sessionId = sessionId;
+    this.defaults = defaults;
+  }
+  
+  
+  
+  with(options) {
+    return { ...options, system: _nullishCoalesce(options.system, () => ( this.defaults.system)), sessionId: this.sessionId };
+  }
+  async text(prompt, options = {}) {
+    return this.llm.text(prompt, this.with(options));
+  }
+  stream(prompt, options = {}) {
+    return this.llm.stream(prompt, this.with(options));
+  }
+  async generate(prompt, options = {}) {
+    return this.llm.generate(prompt, this.with(options));
+  }
+  async json(prompt, options) {
+    return this.llm.json(prompt, this.with(options));
+  }
+  async history() {
+    return this.llm.history(this.sessionId);
+  }
+  async reset() {
+    await this.llm.resetSession(this.sessionId);
+  }
+};
+async function captureScreenshot(mode = "interactive") {
+  const { execFile: execFile5 } = await Promise.resolve().then(() => _interopRequireWildcard(require("child_process")));
+  const { promisify: promisify5 } = await Promise.resolve().then(() => _interopRequireWildcard(require("util")));
+  const { mkdtemp: mkdtemp2, stat: stat3 } = await Promise.resolve().then(() => _interopRequireWildcard(require("fs/promises")));
+  const os3 = await Promise.resolve().then(() => _interopRequireWildcard(require("os")));
+  const path3 = await Promise.resolve().then(() => _interopRequireWildcard(require("path")));
+  const execFileAsync5 = promisify5(execFile5);
+  const dir = await mkdtemp2(path3.join(os3.tmpdir(), "apple-llm-screen-"));
+  const out = path3.join(dir, "screen.png");
+  const args = mode === "interactive" ? ["-i", "-x", out] : mode === "window" ? ["-w", "-x", out] : ["-x", out];
+  try {
+    await execFileAsync5("screencapture", args, { timeout: 12e4 });
+  } catch (err) {
+    throw new AppleLLMError(
+      `Could not capture a screenshot (screencapture failed): ${err instanceof Error ? err.message : String(err)}`,
+      "device"
+    );
+  }
+  try {
+    const st = await stat3(out);
+    if (st.size === 0) throw new Error("empty capture");
+  } catch (e28) {
+    throw new AppleLLMError("Screenshot capture was cancelled or produced no image.", "device");
+  }
+  return out;
+}
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+exports.AppleLLMError = AppleLLMError; exports.ModelUnavailableError = ModelUnavailableError; exports.SchemaRejectedError = SchemaRejectedError; exports.SchemaValidationError = SchemaValidationError; exports.ContextLengthError = ContextLengthError; exports.QuotaError = QuotaError; exports.TimeoutError = TimeoutError; exports.AbortError = AbortError; exports.SetupRequiredError = SetupRequiredError; exports.RefusalError = RefusalError; exports.ToolExecutionError = ToolExecutionError; exports.ModelBusyError = ModelBusyError; exports.UnsupportedError = UnsupportedError; exports.stripCodeFences = stripCodeFences; exports.extractJsonSpan = extractJsonSpan; exports.parseLlmJson = parseLlmJson; exports.isAppleSiliconMac = isAppleSiliconMac; exports.targetTripleFrom = targetTripleFrom; exports.hostTarget = hostTarget; exports.CLOUD_SHORTCUT_NAME = CLOUD_SHORTCUT_NAME; exports.CLOUD_SHORTCUT_NAME_WEB = CLOUD_SHORTCUT_NAME_WEB; exports.CLOUD_CONTEXT_TOKENS = CLOUD_CONTEXT_TOKENS; exports.shortcutDefinition = shortcutDefinition; exports.cloudSetupHint = cloudSetupHint; exports.installCloudShortcut = installCloudShortcut; exports.probeCloud = probeCloud; exports.CloudClient = CloudClient; exports.cacheDir = cacheDir; exports.fingerprint = fingerprint; exports.helperSource = helperSource; exports.ensureBinary = ensureBinary; exports.splitMessages = splitMessages; exports.ReplayBook = ReplayBook; exports.toAppleSchema = toAppleSchema; exports.isStandardSchema = isStandardSchema; exports.resolveSchema = resolveSchema; exports.restoreNulls = restoreNulls; exports.tool = tool; exports.normalizeTools = normalizeTools; exports.toolOutputText = toolOutputText; exports.DEFAULT_TEMPERATURE = DEFAULT_TEMPERATURE; exports.DEFAULT_MAX_TOKENS = DEFAULT_MAX_TOKENS; exports.DEFAULT_MAX_TOOL_CALLS = DEFAULT_MAX_TOOL_CALLS; exports.assertTools = assertTools; exports.probeDevice = probeDevice; exports.DeviceClient = DeviceClient; exports.withDocuments = withDocuments; exports.parseImageFlag = parseImageFlag; exports.ResultStream = ResultStream; exports.probe = probe; exports.AppleLLM = AppleLLM; exports.Conversation = Conversation; exports.captureScreenshot = captureScreenshot;