apple-llm 0.1.0 → 0.2.0

package/dist/client-CXewzZTj.d.ts

@@ -0,0 +1,1160 @@
+import { ChildProcess } from 'node:child_process';
+
+interface Progress {
+    status: string;
+    percent?: number;
+}
+type OnProgress = (p: Progress) => void;
+/**
+ * Where the compiled helper is cached.
+ *
+ * Deliberately not namespaced per language binding: the npm and the pip package
+ * embed byte-identical Swift, so they derive the same fingerprint and share one
+ * compiled binary. Installing both costs one compile, not two.
+ */
+declare function cacheDir(): string;
+/**
+ * The cache key: sha256 over the Swift source, a newline, and the target triple,
+ * truncated to 12 hex characters.
+ *
+ * The exact recipe is load-bearing — the Python package computes the same string
+ * and must agree byte for byte, or the two would each compile their own copy.
+ * A helper edit or an OS upgrade changes it, so both rebuild automatically.
+ */
+declare function fingerprint(source: string, triple: string): string;
+/** The embedded Swift source, shipped as package data beside the built output. */
+declare function helperSource(): Promise<string>;
+/**
+ * Compile the helper on first use and cache it. Never called at install time —
+ * importing this package on Linux, an Intel Mac or macOS 25 must not fail.
+ *
+ * `force` bypasses the in-process memo, so a caller can rebuild after the cached
+ * binary is removed or found corrupt without restarting the program.
+ *
+ * The memo is fingerprint-aware: a helper edit or OS upgrade changes the
+ * fingerprint, so a stale in-process memo is discarded rather than reused.
+ */
+declare function ensureBinary(onProgress?: OnProgress, options?: {
+    force?: boolean;
+}): Promise<string>;
+
+/**
+ * Apple's `GenerationSchema` is `Decodable` from JSON Schema, but only accepts a
+ * restricted dialect. These rules were established empirically, by decoding
+ * real schemas against macOS 26 and 27 until they were accepted:
+ *
+ *  1. Union types are rejected — `type: ['string','null']` fails with
+ *     "Expected value of type String". Nullability is expressed by leaving the
+ *     property out of `required` instead.
+ *  2. Every object schema requires an `x-order` array naming its properties in
+ *     generation order. Omitting it fails with "Key 'x-order' not found".
+ *  3. `enum` is not recognized. A node may only carry `type`, `const`, `$ref` or
+ *     `anyOf`, so enums become `anyOf` of `const` branches.
+ *  4. Every object schema *and* every `anyOf` schema requires a `title`, and
+ *     `$ref` resolves by that title rather than by JSON pointer — so a
+ *     definition's title must equal the key it is referenced by.
+ *  5. Every object schema must state `additionalProperties`; omitting it fails
+ *     with "Key 'additionalProperties' not found". macOS 26's decoder tolerated
+ *     its absence, so this one only surfaced on macOS 27.
+ *
+ *  6. `const` is decoded as a String, always. A numeric member (`const: 200`)
+ *     fails with "Expected value of type String". Stringifying it is accepted
+ *     but changes the output type — the model then emits `"200"` rather than
+ *     `200` — so a numeric enum is converted to its underlying type instead and
+ *     the literal constraint is dropped. A string-typed status-code union once
+ *     produced junk like `": 201"`; a plain `integer` is what works.
+ *  7. An object with no properties still needs an explicit `properties: {}`.
+ *     Without it Apple reads `additionalProperties` in its other JSON Schema
+ *     sense — a schema for the values — and fails with "Expected value of type
+ *     Dictionary<String, Any>". Supplying a dictionary there is accepted but
+ *     turns the field into a free-form map the model fills with invented keys.
+ *
+ *  8. A `title` on a `type: "string"` node is rejected: Apple reads it as a
+ *     "named string type" and fails with "Named string types must have a
+ *     non-empty enum field". Other primitives (integer, number, boolean) and
+ *     arrays accept a title happily. Titles are therefore stripped from plain
+ *     strings. This matters most for pydantic, whose `model_json_schema()`
+ *     titles every single property.
+ *
+ *  9. `pattern` is rejected at generation time with "UnsupportedGuide", for any
+ *     regex — even `^[A-Z]{3}$`. It is stripped, and checked on the reply
+ *     instead. (Found on macOS 27.2 through Zod, which puts a pattern on
+ *     `.email()`, `.uuid()` and `.datetime()`.)
+ *
+ * Rules 6, 7 and 8 were found by decoding this package's own fixture corpus
+ * against macOS 27: they only show up with numeric enums, empty objects, and
+ * machine-generated schemas that title every string.
+ *
+ * macOS 27.2 relaxed rules 2, 4 and 5 for objects: an object without a title,
+ * x-order or additionalProperties now decodes. They are still applied, since
+ * macOS 26 and 27.0–27.1 require them and they cost nothing where not needed.
+ *
+ * `$ref` / `$defs` are otherwise supported and pass through untouched.
+ *
+ * Why this matters more than it looks: constrained decoding makes a schema
+ * mistake invisible but total. Collapsing a `["number","string"]` union to
+ * `"string"` made it physically impossible for the model to emit a status code —
+ * it wrote `": 201"` and the literal `"default"` instead. Never collapse a
+ * multi-type union to one branch; convert it to `anyOf`.
+ */
+type JsonSchema = Record<string, unknown>;
+/**
+ * Translate a standard JSON Schema into the dialect Apple's `GenerationSchema`
+ * accepts. Constrained decoding then makes the shape of the reply a guarantee
+ * rather than a request.
+ */
+declare function toAppleSchema(schema: JsonSchema, rootName?: string): JsonSchema;
+
+/**
+ * OpenAI-style message lists, mapped onto what Apple's model actually has.
+ *
+ * Apple has one instructions slot, a native transcript of prompt / response /
+ * tool-call / tool-output entries, and one new prompt per call. So: every
+ * system message joins the instructions, the last user message is the prompt,
+ * and everything before it becomes a native transcript — not a text preamble,
+ * which the model would read as part of the question.
+ *
+ * Messages *after* the last user message are a tool exchange in progress: the
+ * model asked for tool calls, the caller ran them, and the results are here.
+ * Apple cannot resume generation from a tool output without a new prompt, so
+ * the exchange is replayed instead: the same prompt runs again, and when the
+ * model makes the same call its recorded result is returned immediately rather
+ * than executed twice.
+ */
+
+interface ChatToolCall {
+    id: string;
+    name: string;
+    arguments: unknown;
+}
+type ChatMessage = {
+    role: 'system';
+    content: string;
+} | {
+    role: 'user';
+    content: string;
+    images?: ImageAttachment[];
+} | {
+    role: 'assistant';
+    content?: string | null;
+    toolCalls?: ChatToolCall[];
+} | {
+    role: 'tool';
+    toolCallId: string;
+    name?: string;
+    content: string;
+};
+/** The helper's wire form of one history entry. */
+type HistoryEntry = {
+    role: 'user';
+    content: string;
+} | {
+    role: 'assistant';
+    content: string;
+    toolCalls?: ChatToolCall[];
+} | {
+    role: 'tool';
+    toolCallId: string;
+    name: string;
+    content: string;
+};
+/** A tool result recorded by the caller, to be handed back if the model repeats the call. */
+interface ReplayedResult {
+    name: string;
+    arguments: unknown;
+    output: string;
+}
+interface SplitMessages {
+    system?: string;
+    history: HistoryEntry[];
+    prompt: string;
+    /** Images on the last user message, which the model sees. */
+    images: ImageAttachment[];
+    replay: ReplayedResult[];
+}
+/** Map message lists onto instructions + history + prompt (+ replayed tool results). */
+declare function splitMessages(messages: ReadonlyArray<ChatMessage>): SplitMessages;
+/**
+ * Hands recorded results back to repeated calls: an exact (name, arguments)
+ * match first, then the next unused result for that tool name — the model's
+ * second attempt at "Paris, France" should still get the Paris weather.
+ */
+declare class ReplayBook {
+    private readonly unused;
+    constructor(results: ReadonlyArray<ReplayedResult>);
+    take(name: string, args: unknown): string | undefined;
+}
+
+/** How a child is created. Injectable so tests can script stdout without Apple hardware. */
+type Spawner = (binary: string, args: string[]) => ChildProcess;
+interface HelperServerOptions {
+    timeoutMs?: number;
+    spawner?: Spawner;
+}
+/** A line the helper sent before a request's final line (`"done": false`). */
+type HelperEvent = Record<string, unknown> & {
+    done: false;
+};
+interface RequestHooks {
+    /** Called for every event line; `write` sends a control line for this request. */
+    onEvent?: (event: HelperEvent, write: (control: Record<string, unknown>) => void) => void;
+    /** Cancels the request: a queued one is never sent, a running one is cancelled in the helper. */
+    signal?: AbortSignal;
+    /** Request id, the target of a cancel line. Needed to cancel mid-flight. */
+    id?: string;
+}
+/**
+ * A long-lived helper process speaking newline-delimited JSON.
+ *
+ * This is the single most important piece of the on-device path. Spawning a
+ * helper per request measured ~17s per call against ~1.5s once the model was
+ * resident, with identical prompts and identically short outputs — so keeping
+ * one process alive is worth roughly an order of magnitude. Both failure modes
+ * it guards against are silent: they produce correct output, just 10-20x
+ * slower.
+ *
+ * Requests are serialised, and that costs nothing: Apple's framework serialises
+ * inference anyway. Four concurrent requests measured 29.19s against 29.45s
+ * sequentially, so concurrency > 1 buys precisely nothing. A request owns the
+ * head of the queue from the moment it is written until its final line; the
+ * lines in between (`"done": false`) are its events — stream deltas, partial
+ * objects, tool calls — and nothing else is written meanwhile except control
+ * lines for that same request.
+ *
+ * The child is unref'd whenever nothing is in flight, so a script that forgets
+ * `close()` still exits instead of hanging on an idle helper.
+ */
+declare class HelperServer {
+    private readonly binary;
+    private child;
+    private buffer;
+    private queue;
+    /** Serialises callers so one request's reply cannot be handed to another. */
+    private chain;
+    private inFlight;
+    /** The helper's recent stderr, quoted when it dies. Always drained: an unread pipe blocks the writer. */
+    private stderrTail;
+    private readonly timeoutMs;
+    private readonly spawner;
+    constructor(binary: string, options?: HelperServerOptions);
+    private start;
+    /** Keep the event loop alive only while a request is in flight. */
+    private setRef;
+    /** Route one line: an event to the head's hooks, anything else completes the head. */
+    private dispatch;
+    /**
+     * (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.
+     */
+    private arm;
+    /**
+     * 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(): void;
+    /** Resume the wedge timer paused by `pause()`. */
+    resume(): void;
+    private timeOut;
+    /** Write a control line (cancel, toolResult) for the request in flight. */
+    write(control: Record<string, unknown>): void;
+    /**
+     * One request. Resolves with its final line; events go to `hooks.onEvent`.
+     * Serialised against every other request through one chain.
+     */
+    request(payload: string, hooks?: RequestHooks): Promise<string>;
+    /** Version-1 shape: one request, one line. */
+    send(payload: string, hooks?: RequestHooks): Promise<string>;
+    /**
+     * Streaming request, kept for callers of the version-1 API: deltas go to
+     * `onDelta` and the promise resolves with the final line.
+     */
+    stream(payload: string, onDelta: (delta: string) => void, hooks?: RequestHooks): Promise<string>;
+    stop(): void;
+}
+
+/**
+ * Schema interop without a dependency.
+ *
+ * Any library implementing Standard Schema (https://standardschema.dev) *and*
+ * Standard JSON Schema — Zod 4.2+, ArkType 2.1+, Valibot through
+ * `toStandardJsonSchema()` — can be passed wherever a JSON Schema is accepted.
+ * The JSON Schema goes to Apple's decoder; the library's own `validate` runs on
+ * the reply, so refinements the decoder cannot enforce (`.email()`, `.min(3)`,
+ * transforms, defaults) still apply, and the result is typed by the library.
+ *
+ * The interfaces below are copied from the spec rather than imported: the spec
+ * is designed to be vendored, and the package stays at zero dependencies.
+ */
+
+interface StandardSchemaV1<Input = unknown, Output = Input> {
+    readonly '~standard': StandardSchemaV1.Props<Input, Output>;
+}
+declare namespace StandardSchemaV1 {
+    interface Props<Input = unknown, Output = Input> {
+        readonly version: 1;
+        readonly vendor: string;
+        readonly validate: (value: unknown) => Result<Output> | Promise<Result<Output>>;
+        readonly types?: Types<Input, Output> | undefined;
+    }
+    type Result<Output> = SuccessResult<Output> | FailureResult;
+    interface SuccessResult<Output> {
+        readonly value: Output;
+        readonly issues?: undefined;
+    }
+    interface FailureResult {
+        readonly issues: ReadonlyArray<Issue>;
+    }
+    interface Issue {
+        readonly message: string;
+        readonly path?: ReadonlyArray<PropertyKey | {
+            readonly key: PropertyKey;
+        }> | undefined;
+    }
+    interface Types<Input = unknown, Output = Input> {
+        readonly input: Input;
+        readonly output: Output;
+    }
+}
+/** The Standard JSON Schema extension: a schema that can describe itself. */
+interface StandardJSONSchemaV1 {
+    readonly '~standard': {
+        readonly jsonSchema: {
+            readonly input: (options: {
+                target: string;
+            }) => Record<string, unknown>;
+            readonly output: (options: {
+                target: string;
+            }) => Record<string, unknown>;
+        };
+    };
+}
+/** Anything `json()`, `streamJson()` and `tool()` accept as a schema. */
+type SchemaLike = JsonSchema | StandardSchemaV1;
+/** The parsed type a schema produces: inferred for Standard Schemas, `unknown` for plain JSON Schema. */
+type InferSchema<S> = S extends StandardSchemaV1<any, infer Output> ? Output : unknown;
+declare function isStandardSchema(value: unknown): value is StandardSchemaV1;
+/** A schema reduced to the two things this package needs from it. */
+interface ResolvedSchema {
+    /** Plain JSON Schema, before the Apple-dialect rewrite. */
+    json: JsonSchema;
+    /** The library's validator, when there is one. */
+    validate?: (value: unknown) => Promise<StandardSchemaV1.Result<unknown>>;
+}
+declare function resolveSchema(schema: SchemaLike): ResolvedSchema;
+/**
+ * Put back the `null`s Apple's dialect took away.
+ *
+ * Apple has no union types, so a property that is required-but-nullable is
+ * rewritten as simply not required, and the model then omits it rather than
+ * writing `null`. Your schema still says the key must be present, so a
+ * validator (or plain code reading `obj.key === null`) would reject or
+ * misread the reply. This walks the *original* schema and fills each such
+ * missing key with `null`. Never overwrites a value the model produced.
+ */
+declare function restoreNulls(value: unknown, schema: JsonSchema, root?: JsonSchema, depth?: number): unknown;
+
+/** Apple's built-in on-device tools (all macOS 27+, all local). */
+type BuiltInTool = 'ocr' | 'barcode' | 'spotlight';
+interface ToolExecutionContext {
+    /** The id of this call, as it will appear in `toolCalls`. */
+    toolCallId: string;
+    /** Fires when the request is aborted; long-running tools should honour it. */
+    signal?: AbortSignal;
+}
+interface FunctionTool<Args = any, Result = unknown> {
+    /** What the model calls it. Letters, digits, `_` and `-`; must start with a letter or `_`. */
+    name: string;
+    /** When to use it. The model reads this, so write it for the model. */
+    description?: string;
+    /** JSON Schema or a Standard Schema (Zod, ArkType, …). Omit for a tool that takes no arguments. */
+    parameters?: SchemaLike;
+    /**
+     * Runs the tool. Return a string, or anything JSON-serialisable. Omit it for
+     * a client-driven tool that stops generation instead (see above).
+     * A thrown error ends the request with a ToolExecutionError whose `cause` is
+     * your error; return an error *message* instead if the model should see it
+     * and recover.
+     */
+    execute?: (args: Args, context: ToolExecutionContext) => Result | Promise<Result>;
+}
+/**
+ * Define a function tool, with the argument type inferred from a Standard
+ * Schema.
+ *
+ *   const weather = tool({
+ *     name: 'getWeather',
+ *     description: 'Current weather for a city',
+ *     parameters: z.object({ city: z.string() }),
+ *     execute: async ({ city }) => fetchWeather(city),   // city: string
+ *   });
+ */
+declare function tool<S extends SchemaLike, Result = unknown>(definition: {
+    name: string;
+    description?: string;
+    parameters?: S;
+    execute?: (args: InferSchema<S>, context: ToolExecutionContext) => Result | Promise<Result>;
+}): FunctionTool<InferSchema<S>, Result>;
+/** Everything `tools` accepts: built-in names, function tools, or a record of function tools keyed by name. */
+type ToolSet = ReadonlyArray<BuiltInTool | FunctionTool> | Readonly<Record<string, Omit<FunctionTool, 'name'> & {
+    name?: string;
+}>>;
+interface NormalizedTools {
+    builtIn: BuiltInTool[];
+    functions: Array<FunctionTool & {
+        resolved?: ResolvedSchema;
+        json: JsonSchema;
+    }>;
+}
+/** Split and check a tool set. Throws before any model call on a bad definition. */
+declare function normalizeTools(tools: ToolSet | undefined): NormalizedTools;
+/** Tool output as the model will read it. */
+declare function toolOutputText(value: unknown): string;
+
+/**
+ * Sampling temperature. Not zero on purpose.
+ *
+ * Constrained decoding already guarantees the schema, so greedy decoding buys
+ * nothing and reliably degenerates: at 0 the model padded an unbounded array
+ * forever, then ran away *inside a single string*, emitting 2.7KB of
+ * "tasks-tasks-tasks-…". A 2s call became 20s. Apple honours `maxItems` but
+ * ignores `maxLength`, so bounding strings is not available as a fix — a little
+ * sampling is. Nothing about this is a quality/creativity tradeoff.
+ */
+declare const DEFAULT_TEMPERATURE = 0.4;
+/**
+ * Cap on generated tokens. Left uncapped, the model occasionally runs away and
+ * only stops when it exhausts the context window — one observed run burned
+ * ~206s before failing. This bounds that to well under a minute while leaving
+ * room for a few paragraphs of prose.
+ */
+declare const DEFAULT_MAX_TOKENS = 2048;
+/**
+ * Tool calls allowed in one request before the model is told to stop calling
+ * and answer. A small model can loop on a tool whose output it misreads.
+ */
+declare const DEFAULT_MAX_TOOL_CALLS = 8;
+/** What the model can actually do, as reported by the framework (macOS 27+). */
+interface ModelCapabilities {
+    vision: boolean;
+    guidedGeneration: boolean;
+    reasoning: boolean;
+    toolCalling: boolean;
+}
+/** Feature flags reported by --probe (absent on older helpers). */
+interface HelperFeatures {
+    protocol?: number;
+    streaming: boolean;
+    structuredStreaming?: boolean;
+    sessions: boolean;
+    history: boolean;
+    transcripts?: boolean;
+    labelledAttachments: boolean;
+    functionTools?: boolean;
+    cancellation?: boolean;
+    builtInTools: string[];
+}
+/** An image attachment: a bare path, or a path with a Siri-style label. */
+type ImageAttachment = string | {
+    path: string;
+    label?: string;
+};
+/** A history turn mirrored by the helper for a named session. */
+interface HistoryTurn {
+    role: string;
+    content: string;
+}
+/**
+ * Private Cloud Compute quota, read from the framework without calling it.
+ *
+ * PCC *inference* needs an entitlement no installable package can ship, which is
+ * why the cloud tier goes through Shortcuts — but `quotaUsage` is readable from
+ * an unentitled process, so this is real first-party quota state rather than a
+ * guess parsed out of an error message.
+ */
+interface CloudQuota {
+    isAvailable: boolean;
+    status: 'belowLimit' | 'limitReached' | 'unknown';
+    approachingLimit?: boolean;
+    resetDate?: string;
+}
+/**
+ * The Private Cloud Compute model as the framework describes it (macOS 27+):
+ * quota, capabilities and context size, all readable without the entitlement
+ * that blocks calling it directly.
+ */
+interface CloudModelInfo extends CloudQuota {
+    capabilities?: ModelCapabilities;
+    contextSize?: number;
+}
+interface DeviceProbe {
+    available: boolean;
+    reason?: string;
+    contextSize?: number;
+    variant?: string;
+    /** macOS 27+ only; absent on macOS 26. */
+    capabilities?: ModelCapabilities;
+    useCases?: string[];
+    /** Helper feature flags; absent when the cached binary predates them. */
+    features?: HelperFeatures;
+    /** PCC quota and model info, surfaced here because the on-device helper is what can read them. */
+    cloud?: CloudModelInfo;
+}
+/**
+ * How tokens are chosen.
+ *
+ * `greedy` is deterministic but degenerates under guided generation — it is the
+ * `temperature: 0` trap by another name. The seeded modes give the same
+ * reproducibility *without* that failure: `{ mode: 'topK', k: 50, seed: 42 }`
+ * returned byte-identical output across three runs here. Determinism relies on
+ * a fresh session per request, which is the default.
+ */
+type SamplingMode = {
+    mode: 'greedy';
+} | {
+    mode: 'topK';
+    k?: number;
+    seed?: number;
+} | {
+    mode: 'threshold';
+    p?: number;
+    seed?: number;
+};
+/** Apple ships a use case specialised for tagging and topic extraction. */
+type UseCase = 'general' | 'contentTagging';
+/**
+ * `permissive` selects `permissiveContentTransformations`, which relaxes the
+ * guardrails for content *transformation* — rewriting or summarising text the
+ * default guardrails would refuse to touch.
+ */
+type Guardrails = 'default' | 'permissive';
+/** Token accounting for one generation (macOS 27+). */
+interface Usage {
+    inputTokens: number;
+    outputTokens: number;
+    totalTokens: number;
+    /** Prompt tokens served from the session's cache — a conversation's earlier turns. */
+    cachedInputTokens?: number;
+}
+/** Why generation ended. `length` means `maxTokens` cut it off; `tool-calls` means a client-driven tool is waiting. */
+type FinishReason = 'stop' | 'length' | 'tool-calls';
+/** One tool call the model made while producing a reply. */
+interface ToolCallRecord {
+    id: string;
+    name: string;
+    arguments: unknown;
+    /** What the tool returned to the model. Absent for a client-driven call not yet run. */
+    output?: string;
+}
+interface DeviceRequest {
+    system?: string;
+    prompt: string;
+    schema?: JsonSchema | null;
+    temperature?: number;
+    maxTokens?: number;
+    /** Image attachments. Entries may carry a label for follow-up turns. */
+    images?: ImageAttachment[];
+    /** Text documents inlined into the prompt client-side (see withDocuments). */
+    documents?: string[];
+    /** Named multi-turn conversation; the helper keeps the native transcript. */
+    sessionId?: string;
+    /** Earlier turns, sent as a native transcript (stateless multi-turn). */
+    history?: HistoryEntry[];
+    /** Drop the oldest history turns rather than fail when they do not fit. */
+    trimHistory?: boolean;
+    /** Built-in Apple tools: on-device OCR, barcode reading, Spotlight RAG. */
+    tools?: BuiltInTool[];
+    /** Function tools, already normalised (see normalizeTools). */
+    functions?: NormalizedTools['functions'];
+    useCase?: UseCase;
+    guardrails?: Guardrails;
+    sampling?: SamplingMode;
+    /** Send the schema in the prompt as well as to the decoder. See helper.swift. */
+    includeSchemaInPrompt?: boolean;
+    /**
+     * Reuse one session across calls. Off by default: it makes unrelated calls
+     * share a transcript. See the note in helper.swift.
+     * Prefer sessionId for conversations; this flag is the legacy single slot.
+     */
+    reuseSession?: boolean;
+}
+/** Per-call hooks for `run`. */
+interface RunHooks {
+    signal?: AbortSignal;
+    onDelta?: (delta: string) => void;
+    /** Each partial JSON document while streaming with a schema. */
+    onPartial?: (json: string) => void;
+    /** Every tool call, as the model makes it. */
+    onToolCall?: (call: ToolCallRecord) => void;
+    /** Results the caller already has for calls the model may repeat. */
+    replay?: ReplayBook;
+    maxToolCalls?: number;
+}
+/** What one generation produced. */
+interface DeviceOutcome {
+    content: string;
+    finishReason: FinishReason;
+    usage?: Usage;
+    toolCalls: ToolCallRecord[];
+    trimmedTurns: number;
+}
+/** Assert every requested tool is one the helper knows, before spending a call. */
+declare function assertTools(tools: BuiltInTool[] | undefined): void;
+/** Probe the on-device model without constructing a client. */
+declare function probeDevice(onProgress?: OnProgress): Promise<DeviceProbe>;
+/**
+ * The on-device tier: Apple's `FoundationModels` framework, reached through a
+ * self-compiled Swift helper. Nothing leaves the machine.
+ */
+interface DeviceClientOptions {
+    useCase?: UseCase;
+    guardrails?: Guardrails;
+    /**
+     * A ready helper to use instead of probing and compiling one. For tests,
+     * which script a fake helper; not needed in normal use.
+     */
+    server?: HelperServer;
+}
+declare class DeviceClient {
+    private readonly options;
+    private binary?;
+    private probeResult?;
+    private server?;
+    private readying?;
+    constructor(options?: DeviceClientOptions);
+    get label(): string;
+    get contextSize(): number | undefined;
+    /** Probe and build once; concurrent first calls share the one attempt. */
+    ensureReady(onProgress?: OnProgress): Promise<void>;
+    getProbe(): DeviceProbe | undefined;
+    private helper;
+    /** Send one single-line envelope and return the parsed reply, raising a typed error on failure. */
+    private exchange;
+    /** The request envelope, shared by every generation path. */
+    private envelopeFor;
+    /**
+     * One generation, with every event handled: text deltas, partial objects,
+     * and function tool calls, which run here and answer the helper.
+     */
+    run(request: DeviceRequest, op?: 'generate' | 'stream', hooks?: RunHooks): Promise<DeviceOutcome>;
+    /** One request. Returns the helper's `content` string, unparsed. */
+    complete(request: DeviceRequest, hooks?: RunHooks): Promise<string>;
+    /**
+     * Streaming text. Deltas arrive via onDelta as the model generates; the
+     * promise resolves with the full text.
+     */
+    stream(prompt: string, options?: Omit<DeviceRequest, 'prompt' | 'schema'> & {
+        onDelta?: (delta: string) => void;
+        signal?: AbortSignal;
+    }): Promise<string>;
+    /**
+     * 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.
+     */
+    history(sessionId: string): Promise<{
+        instructions: string;
+        history: HistoryTurn[];
+    }>;
+    /** Drop a named session (and its persisted history), or all of them. */
+    resetSession(sessionId?: string): Promise<void>;
+    /**
+     * 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.
+     */
+    countTokens(prompt: string, options?: {
+        system?: string;
+        images?: ImageAttachment[];
+        tools?: BuiltInTool[];
+        documents?: string[];
+        history?: HistoryEntry[];
+        schema?: JsonSchema;
+        functions?: NormalizedTools['functions'];
+        signal?: AbortSignal;
+    }): Promise<{
+        tokens: number;
+        contextSize: number;
+    }>;
+    /**
+     * 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.
+     */
+    prewarm(system?: string): Promise<void>;
+    text(prompt: string, options?: Omit<DeviceRequest, 'prompt' | 'schema'>): Promise<string>;
+    json(prompt: string, options: Omit<DeviceRequest, 'prompt'> & {
+        schema: JsonSchema;
+    }): Promise<unknown>;
+    /** Shut the helper process down. Safe to call more than once. */
+    close(): void;
+}
+/**
+ * Inline text documents into the prompt client-side.
+ *
+ * The helper's vision path handles images; plain-text sources (.txt/.md/.json
+ * and friends) are cheaper to splice here than to teach the Swift side about.
+ * Binary files are refused loudly — silently skipping a document the caller
+ * asked about would be the vision-drop trap by another name.
+ */
+declare function withDocuments(prompt: string, documents: string[] | undefined): Promise<string>;
+/** Parse a CLI --image value: "path" or "path::label". */
+declare function parseImageFlag(value: string): ImageAttachment;
+
+/**
+ * Apple's Private Cloud Compute model, reached through the Shortcuts action
+ * `is.workflow.actions.askllm`.
+ *
+ * Why this route rather than the framework: macOS 27 exposes
+ * `FoundationModels.PrivateCloudComputeLanguageModel` as public API and it even
+ * reports `isAvailable: true`, but every call fails with `ModelManagerError
+ * 1046` unless the process carries `com.apple.developer.private-cloud-compute`.
+ * That entitlement is AMFI-restricted — an ad-hoc-signed binary carrying it is
+ * SIGKILLed (exit 137), and wrapping it in a signed .app with a real bundle ID
+ * does not help. It needs a paid Developer Program provisioning profile, which
+ * no installable package can ship. Shortcuts.app already holds the entitlement
+ * and `/usr/bin/shortcuts` is public, so a generated shortcut is the only route
+ * that works. Do not spend time re-confirming this.
+ *
+ * This tier sends your prompt off the machine. It is not local.
+ *
+ * Measured on an M4 Air: ~2s typical, ~11s at 14k tokens.
+ */
+/** Distinctive, so `shortcuts run` cannot match a shortcut the user wrote. */
+declare const CLOUD_SHORTCUT_NAME = "Apple LLM Cloud";
+/** Web search is fixed in the shortcut at install time, so it needs its own copy. */
+declare const CLOUD_SHORTCUT_NAME_WEB = "Apple LLM Cloud Web";
+/** Context window, measured empirically: 14.4k succeeds, ~33.5k is refused. */
+declare const CLOUD_CONTEXT_TOKENS = 32768;
+interface CloudProbe {
+    available: boolean;
+    reason?: string;
+    installed?: boolean;
+    contextSize?: number;
+    /**
+     * Real quota state, read from `PrivateCloudComputeLanguageModel.quotaUsage`
+     * by the on-device helper. Absent when the helper could not run (macOS 26, or
+     * no on-device model), since that is the only thing that can read it.
+     */
+    quota?: CloudQuota;
+    /**
+     * What the server model can do, from the framework (macOS 27+). On Golden
+     * Gate: reasoning, vision, tool calling and guided generation. Tools and
+     * guided generation are not reachable through Shortcuts; vision is.
+     */
+    capabilities?: ModelCapabilities;
+}
+/**
+ * The shortcut definition, as plain JSON.
+ *
+ * Every key here was confirmed against a shortcut built in the Shortcuts GUI and
+ * exported, rather than guessed — the difference matters because a wrong
+ * parameter name does not fail loudly. Shortcuts imports the action, silently
+ * discards the unrecognised parameter, and the action then blocks on its
+ * interactive prompt at run time, forever. This is the single most expensive
+ * mistake available on this path.
+ *
+ * In particular the prompt key is `WFLLMPrompt`, *not* the `WFInput` that the
+ * action's own localised strings suggest.
+ *
+ * The model key is deliberately absent: with no model key the action uses its
+ * default, which is the Cloud (Private Cloud Compute) tier.
+ */
+declare function shortcutDefinition(webSearch?: boolean): Record<string, unknown>;
+declare function cloudSetupHint(): string;
+/**
+ * Generate, sign and install the shortcut. Idempotent unless `force` is set.
+ *
+ * Signing needs no developer account and no signing identity: `shortcuts sign -m
+ * anyone` issues a per-signature certificate that chains to Apple Root CA - G3
+ * on the device. Every user signs their own copy, so nothing has to be
+ * pre-signed, hosted, or shipped in the package.
+ */
+declare function installCloudShortcut(onProgress?: OnProgress, options?: {
+    force?: boolean;
+    webSearch?: boolean;
+}): Promise<void>;
+/** Probe the cloud tier without constructing a client. */
+declare function probeCloud(): Promise<CloudProbe>;
+interface CloudRequest {
+    system?: string;
+    prompt: string;
+    /** Run with "Use Broad World Knowledge" — needs the web shortcut installed. */
+    webSearch?: boolean;
+    /** Kills the `shortcuts run` process. The quota spent so far is not refunded. */
+    signal?: AbortSignal;
+    /**
+     * Images for the server model to look at, passed to the shortcut as extra
+     * inputs. Needs a server model that reports vision (macOS 27 Golden Gate).
+     */
+    images?: ImageAttachment[];
+}
+/**
+ * The Private Cloud Compute tier. Free but quota'd, and text-out only: there is
+ * no constrained decoding here, so `json()` asks for JSON in the prompt and
+ * recovers it from prose rather than guaranteeing it.
+ */
+declare class CloudClient {
+    private ready;
+    /** Last known quota, set by `probe()` so a call can fail fast. */
+    private quota?;
+    /** What the framework says the server model can do, when it could be read. */
+    private model?;
+    /**
+     * 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: CloudModelInfo | undefined): void;
+    /** Whether the server model is known to read images. False when it could not be read (macOS 26). */
+    get supportsImages(): boolean;
+    private assertQuota;
+    get label(): string;
+    get contextSize(): number;
+    ensureReady(onProgress?: OnProgress): Promise<void>;
+    text(request: CloudRequest): Promise<string>;
+    /**
+     * 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.
+     */
+    json(request: CloudRequest & {
+        schema: JsonSchema;
+    }): Promise<unknown>;
+    close(): void;
+}
+
+/**
+ * Streams that are both `for await`-able and awaitable.
+ *
+ *   for await (const delta of llm.stream(prompt)) process.stdout.write(delta);
+ *   const text = await llm.stream(prompt);          // the whole reply
+ *   const { usage } = await llm.stream(prompt).result;
+ *
+ * The request starts immediately, whichever way it is consumed. Breaking out
+ * of a `for await` loop cancels it — nothing keeps generating for a reader who
+ * has gone. An error surfaces through whichever of the two you use; a stream
+ * nobody consumes never raises an unhandled rejection.
+ */
+/**
+ * The shared shape: `Chunk`s arrive through the iterator, the promise
+ * resolves with `Final`, and `result` carries the full result object.
+ */
+declare class ResultStream<Chunk, Final, Result> implements AsyncIterable<Chunk>, PromiseLike<Final> {
+    /** Everything about the finished generation: text, usage, tool calls, finish reason. */
+    readonly result: Promise<Result>;
+    private readonly channel;
+    private readonly controller;
+    private readonly final;
+    private iterated;
+    private finished;
+    constructor(run: (emit: (chunk: Chunk) => void, signal: AbortSignal) => Promise<Result>, pick: (result: Result) => Final);
+    /** Stop generating. The promise and the iterator both reject with an AbortError. */
+    abort(reason?: unknown): void;
+    then<A = Final, B = never>(onfulfilled?: ((value: Final) => A | PromiseLike<A>) | null, onrejected?: ((reason: unknown) => B | PromiseLike<B>) | null): Promise<A | B>;
+    catch<B = never>(onrejected?: ((reason: unknown) => B | PromiseLike<B>) | null): Promise<Final | B>;
+    finally(onfinally?: (() => void) | null): Promise<Final>;
+    [Symbol.asyncIterator](): AsyncIterator<Chunk>;
+}
+
+/**
+ * The public client: one API over both tiers.
+ *
+ * Every generation method takes either a prompt string or a message list, and
+ * funnels into one private `execute`, so a feature added there reaches `text`,
+ * `json`, `generate` and both streams at once.
+ */
+
+type Tier = 'device' | 'cloud' | 'auto';
+interface ProbeResult {
+    device: DeviceProbe;
+    cloud: CloudProbe;
+}
+/**
+ * What this machine can actually do. Never throws: on Linux, an Intel Mac or
+ * macOS 25 it returns `available: false` with a reason naming the fix.
+ */
+declare function probe(onProgress?: OnProgress): Promise<ProbeResult>;
+interface AppleLLMOptions {
+    tier?: Tier;
+    /** Default instructions for every call; a per-call `system` replaces it. */
+    system?: string;
+    /** Default sampling temperature. See DEFAULT_TEMPERATURE — do not set 0. */
+    temperature?: number;
+    maxTokens?: number;
+    /** Default per-call deadline in milliseconds. Aborts the call with a TimeoutError. */
+    timeoutMs?: number;
+    /** Called for the one-time compile and the shortcut install; both take seconds. */
+    onProgress?: OnProgress;
+    /** `contentTagging` selects Apple's tagging-specialised model. Device tier only. */
+    useCase?: UseCase;
+    /** `permissive` relaxes guardrails for rewriting tasks. Device tier only. */
+    guardrails?: Guardrails;
+    /** Default sampling mode; a seeded one makes output reproducible. */
+    sampling?: SamplingMode;
+}
+/** A prompt, or a whole conversation in OpenAI-style messages. */
+type Input = string | ReadonlyArray<ChatMessage>;
+interface TextOptions {
+    system?: string;
+    temperature?: number;
+    maxTokens?: number;
+    /** Cloud tier only: run with "Use Broad World Knowledge". */
+    webSearch?: boolean;
+    /** Image attachments; entries may carry a label for follow-up turns. */
+    images?: ImageAttachment[];
+    /** Text files inlined into the prompt. */
+    documents?: string[];
+    /** Named multi-turn conversation kept by the helper (device tier). */
+    sessionId?: string;
+    /**
+     * Tools the model may call: Apple's built-ins (`'ocr'`, `'barcode'`,
+     * `'spotlight'`) and your own function tools (see `tool()`), as an array or
+     * a record keyed by name. Device tier.
+     */
+    tools?: ToolSet;
+    /** Tool calls allowed per request before the model is told to answer. Default 8. */
+    maxToolCalls?: number;
+    useCase?: UseCase;
+    guardrails?: Guardrails;
+    sampling?: SamplingMode;
+    /** Cancels the call. Rejects with an AbortError (a TimeoutError for `AbortSignal.timeout`). */
+    signal?: AbortSignal;
+    /** Deadline for this call in milliseconds. */
+    timeoutMs?: number;
+    /**
+     * For message-list input: drop the oldest turns when the conversation no
+     * longer fits the context window, instead of failing. Default true; the
+     * result's `trimmedTurns` says how many went.
+     */
+    trimHistory?: boolean;
+}
+interface StreamOptions extends TextOptions {
+    /** Called with each delta; the returned stream can be iterated as well. */
+    onDelta?: (delta: string) => void;
+}
+interface JsonOptions<S extends SchemaLike = SchemaLike> extends TextOptions {
+    /** JSON Schema, or a Standard Schema (Zod 4, ArkType, Valibot via toStandardJsonSchema). */
+    schema: S;
+}
+interface GenerateResult<T = undefined> {
+    /** The reply text; for a schema, the JSON as the model wrote it. */
+    text: string;
+    /** The parsed and validated reply; `undefined` without a schema. */
+    object: T;
+    finishReason: FinishReason;
+    /** Token accounting — device tier on macOS 27+. */
+    usage?: Usage;
+    /** Every tool call made along the way, with what each returned. */
+    toolCalls: ToolCallRecord[];
+    /** Oldest conversation turns dropped to fit the context window. 0 almost always. */
+    trimmedTurns: number;
+    tier: 'device' | 'cloud';
+    durationMs: number;
+    /** The assistant turn, ready to append to a message list for the next call. */
+    message: Extract<ChatMessage, {
+        role: 'assistant';
+    }>;
+}
+/** Recursively optional — the shape of an object that is still being generated. */
+type DeepPartial<T> = T extends ReadonlyArray<infer U> ? Array<DeepPartial<U>> : T extends object ? {
+    [K in keyof T]?: DeepPartial<T[K]>;
+} : T;
+/** `for await` the deltas, or `await` the whole text. `.result` has usage and the rest. */
+type TextStream = ResultStream<string, string, GenerateResult<undefined>>;
+/** `for await` partial objects as they fill in, or `await` the final validated object. */
+type ObjectStream<T> = ResultStream<DeepPartial<T>, T, GenerateResult<T>>;
+/**
+ * The main entry point.
+ *
+ *   const llm = new AppleLLM();
+ *   await llm.text('Summarize this');
+ *   await llm.json('Extract the fields', { schema });
+ *   for await (const d of llm.stream('Tell me a story')) process.stdout.write(d);
+ *
+ * One instance keeps one helper process warm. It is unref'd between calls, so
+ * a script exits on its own; `close()` (or `await using`) releases it early.
+ */
+declare class AppleLLM {
+    private device?;
+    private cloud?;
+    /** Which tier `auto` settled on, once resolved. */
+    private resolved?;
+    private readying?;
+    private readonly options;
+    constructor(options?: AppleLLMOptions);
+    get tier(): Tier;
+    /** Human-readable name of the tier in use, for logs. */
+    get label(): string;
+    /** Context window of the resolved tier, in tokens. */
+    get contextSize(): number | undefined;
+    /**
+     * 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.
+     */
+    ensureReady(onProgress?: OnProgress): Promise<void>;
+    private newDevice;
+    private readyCloud;
+    private resolve;
+    /** Free text. */
+    text(input: Input, options?: TextOptions): Promise<string>;
+    /**
+     * Everything about one generation: text, parsed object (with a schema),
+     * usage, tool calls, finish reason, and the assistant `message` to append.
+     */
+    generate<S extends SchemaLike>(input: Input, options: TextOptions & {
+        schema: S;
+    }): Promise<GenerateResult<InferSchema<S>>>;
+    generate(input: Input, options?: TextOptions & {
+        schema?: undefined;
+    }): Promise<GenerateResult<undefined>>;
+    /**
+     * 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.
+     */
+    json<S extends SchemaLike>(input: Input, options: JsonOptions<S>): Promise<InferSchema<S>>;
+    /**
+     * 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: Input, options?: StreamOptions): TextStream;
+    /**
+     * 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<S extends SchemaLike>(input: Input, options: JsonOptions<S>): ObjectStream<InferSchema<S>>;
+    /** The one path every generation takes. */
+    private execute;
+    /** Parse, restore nulls, validate. Throws SchemaValidationError for anything the schema rejects. */
+    private parseObject;
+    private assertCloudCompatible;
+    /** Conversation history for a named session (device tier only). */
+    history(sessionId: string): Promise<{
+        instructions: string;
+        history: HistoryTurn[];
+    }>;
+    /** Drop a named session, or all sessions when omitted (device tier only). */
+    resetSession(sessionId?: string): Promise<void>;
+    /**
+     * 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: string, options?: {
+        system?: string;
+    }): Conversation;
+    /**
+     * 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.
+     */
+    rewrite(text: string, options?: {
+        instruction?: string;
+    } & TextOptions): Promise<string>;
+    proofread(text: string, options?: TextOptions): Promise<string>;
+    /**
+     * 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.
+     */
+    summarize(text: string, options?: {
+        length?: string;
+    } & TextOptions): Promise<string>;
+    /** Split text into pieces that each fit one call, on paragraph boundaries where possible. */
+    private chunksFor;
+    draft(topic: string, options?: {
+        kind?: string;
+    } & TextOptions): Promise<string>;
+    tone(text: string, tone: string, options?: TextOptions): Promise<string>;
+    /**
+     * 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+.
+     */
+    askScreen(question: string, options?: {
+        mode?: 'interactive' | 'window' | 'fullscreen';
+    } & TextOptions): Promise<string>;
+    /**
+     * `json()` in the `(system, user, schema)` shape many LLM clients use, for
+     * dropping this in behind an existing interface.
+     */
+    completeJson(system: string, user: string, schema: JsonSchema): Promise<unknown>;
+    /**
+     * 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.
+     */
+    countTokens(input: Input, options?: Pick<TextOptions, 'system' | 'images' | 'tools' | 'documents' | 'signal'> & {
+        schema?: SchemaLike;
+    }): Promise<{
+        tokens: number;
+        contextSize: number;
+    }>;
+    /**
+     * 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).
+     */
+    prewarm(system?: string): Promise<void>;
+    /** Release the long-lived helper process. Safe to call more than once. */
+    close(): void;
+    /** `using llm = new AppleLLM()` closes it at the end of the block. */
+    [Symbol.dispose](): void;
+    /** `await using llm = new AppleLLM()` closes it at the end of the block. */
+    [Symbol.asyncDispose](): Promise<void>;
+}
+/**
+ * One thread in the Siri-app sense: every call carries the same sessionId,
+ * so the helper's native transcript accumulates across turns.
+ */
+declare class Conversation {
+    private readonly llm;
+    readonly sessionId: string;
+    private readonly defaults;
+    constructor(llm: AppleLLM, sessionId: string, defaults?: {
+        system?: string;
+    });
+    private with;
+    text(prompt: string, options?: TextOptions): Promise<string>;
+    stream(prompt: string, options?: StreamOptions): TextStream;
+    generate(prompt: string, options?: TextOptions): Promise<GenerateResult<undefined>>;
+    json<S extends SchemaLike>(prompt: string, options: JsonOptions<S>): Promise<InferSchema<S>>;
+    history(): Promise<{
+        instructions: string;
+        history: HistoryTurn[];
+    }>;
+    reset(): Promise<void>;
+}
+/**
+ * Capture a screenshot to a temp file. Interactive selection mirrors the
+ * Visual Intelligence entry point (Cmd+Shift+Space): drag to select, and the
+ * path comes back ready to pass as an image attachment.
+ */
+declare function captureScreenshot(mode?: 'interactive' | 'window' | 'fullscreen'): Promise<string>;
+
+export { type ToolExecutionContext as $, type AppleLLMOptions as A, type BuiltInTool as B, CLOUD_CONTEXT_TOKENS as C, DEFAULT_MAX_TOKENS as D, type OnProgress as E, type FinishReason as F, type Guardrails as G, type HelperFeatures as H, type ImageAttachment as I, type JsonOptions as J, type Progress as K, ResultStream as L, type ModelCapabilities as M, type RunHooks as N, type ObjectStream as O, type ProbeResult as P, type SchemaLike as Q, ReplayBook as R, type SamplingMode as S, type StandardJSONSchemaV1 as T, type UseCase as U, StandardSchemaV1 as V, type StreamOptions as W, type TextOptions as X, type TextStream as Y, type Tier as Z, type ToolCallRecord as _, AppleLLM as a, type ToolSet as a0, type Usage as a1, assertTools as a2, cacheDir as a3, captureScreenshot as a4, cloudSetupHint as a5, ensureBinary as a6, fingerprint as a7, helperSource as a8, installCloudShortcut as a9, isStandardSchema as aa, normalizeTools as ab, parseImageFlag as ac, probe as ad, probeCloud as ae, probeDevice as af, resolveSchema as ag, restoreNulls as ah, shortcutDefinition as ai, splitMessages as aj, toAppleSchema as ak, tool as al, toolOutputText as am, withDocuments as an, CLOUD_SHORTCUT_NAME as b, CLOUD_SHORTCUT_NAME_WEB as c, type ChatMessage as d, type ChatToolCall as e, CloudClient as f, type CloudModelInfo as g, type CloudProbe as h, type CloudQuota as i, type CloudRequest as j, Conversation as k, DEFAULT_MAX_TOOL_CALLS as l, DEFAULT_TEMPERATURE as m, type DeepPartial as n, DeviceClient as o, type DeviceClientOptions as p, type DeviceOutcome as q, type DeviceProbe as r, type DeviceRequest as s, type FunctionTool as t, type GenerateResult as u, type HistoryEntry as v, type HistoryTurn as w, type InferSchema as x, type Input as y, type JsonSchema as z };