@extentos/mcp-server 0.0.94 → 0.1.2

package/dist/tools/data/capabilityPatterns.js

@@ -16,11 +16,11 @@ import com.extentos.glasses.core.Photos
 import com.extentos.glasses.core.Resolution
 import com.extentos.glasses.core.valueOrNull
 
-// F-R3-9: Photos helpers (in com.extentos.glasses.core.Photos) — pass
-// photo.uri to bridge data: and file: URI schemes uniformly. All four
-// return nullable (null on unreadable URI, unrecognized scheme, decode
-// failure, or OOM — never throw). Three are \`suspend\` (decode runs on
-// Dispatchers.IO under the hood); mediaTypeFromUri is synchronous.
+// F-R3-9 + iter4: Photos helpers (in com.extentos.glasses.core.Photos) —
+// pass photo.uri to bridge data: and file: URI schemes uniformly. All
+// return nullable / Boolean (null on unreadable URI, unrecognized scheme,
+// decode failure, or OOM — never throw). Most are \`suspend\` (decode +
+// stream-copy run on Dispatchers.IO); mediaTypeFromUri is synchronous.
 //   suspend fun Photos.loadBase64(uri: String): String?
 //       — base64 of the photo bytes (NO "data:image/...;base64," prefix).
 //         Fast path on data: URIs: returns the substring after the comma
@@ -29,6 +29,14 @@ import com.extentos.glasses.core.valueOrNull
 //       — raw bytes (for ML pipelines that want the unencoded source).
 //   suspend fun Photos.loadBitmap(uri: String): android.graphics.Bitmap?
 //       — decoded Bitmap (for Compose: \`bitmap?.asImageBitmap()\`).
+//   suspend fun Photos.copyToFile(uri: String, dst: File): Boolean
+//       — persist the photo to a stable file path. Mirrors
+//         Videos.copyToFile. Handles data: / file:// / absolute path
+//         uniformly; creates parent dirs; overwrites existing dst.
+//         Returns false on any failure. Use this — NOT manual loadBytes +
+//         writeBytes — when saving a captured photo into your app's
+//         library / gallery directory (the canonical "save_photo" tool
+//         pattern; see getCapabilityGuide(feature:"assistant_vision")).
 //   fun Photos.mediaTypeFromUri(uri: String): String?
 //       — "image/jpeg" / "image/png" / "image/webp" / "image/gif" /
 //         "image/heic". For data: URIs: parses the embedded MIME directly.
@@ -781,6 +789,483 @@ _ = glasses.conversation?.onWake(phrase: "hey assistant") { ctx in
     ],
     relatedExamples: ["conversation_agent_loop"],
 };
+// ── Phase 4 assistant runtime guides ──────────────────────────────────
+const ASSISTANT_RUNTIME = {
+    feature: "assistant_runtime",
+    summary: "Phase 4 — umbrella entry for the `glasses.assistant` API. End-to-end voice provider abstraction: customer code is `glasses.assistant.start(provider) { tool(name, description) { body -> ToolResult } }`. The model owns wake / turn-taking / intent / confirmation; the customer writes tool bodies that act on app state. v1 ships OpenAI Realtime (`gpt-realtime` over WebSocket); Gemini Live in v1.5+. **Canonical replacement for the Phase 3 conversation runtime, which deprecates in v1.4.0 and removes in v2.0.0.** See per-feature entries (assistant_start, assistant_tool, assistant_provider_openai) for call-shape detail. Full composition example: `getCodeExample(pattern: \"assistant_agent_loop\")`. Conceptual guide: `searchDocs(topic: \"assistant_runtime\")`.",
+    kotlin: `// The whole runtime in one start block:
+glasses.assistant.setOpenaiApiKey(BuildConfig.OPENAI_API_KEY)
+glasses.assistant.start(
+    provider = AssistantProvider.OpenAi(model = "gpt-realtime", voice = "alloy"),
+) {
+    instructions = "You are a helpful assistant on smart glasses. Speak briefly."
+    tool("take_picture", "Take a photo with the glasses camera.") {
+        val photo = glasses.camera.capturePhoto().valueOrNull()
+            ?: return@tool ToolResult.Err("camera failed")
+        library.addPhoto(photo)
+        ToolResult.Ok("photo saved")
+    }
+}`,
+    swift: `// The whole runtime in one start closure:
+glasses.assistant.setOpenAiApiKey(Secrets.openAiKey)
+_ = try await glasses.assistant.start(
+    provider: .openAI(model: "gpt-realtime", voice: "alloy")
+) { config in
+    config.instructions = "You are a helpful assistant on smart glasses. Speak briefly."
+    config.tool("take_picture", description: "Take a photo with the glasses camera.") {
+        // capturePhoto returns ExtentosResult<Photo, CaptureError> async
+        // (not throwing); extract the success branch via the .success
+        // accessor on ExtentosResult (Errors.swift).
+        guard let photo = (await glasses.camera.capturePhoto()).success else {
+            return .err("camera failed")
+        }
+        library.add(photo)
+        return .ok("photo saved")
+    }
+}`,
+    gotchas: [
+        "**glasses.assistant is always-on — no opt-in.** Unlike Phase 3's nullable `glasses.conversation` (gated on conversationOptions in ExtentosConfig), Phase 4 ships zero on-device ML so there's no cost to always exposing the surface. No ConversationModels.ensureExtracted, no ONNX file paths, no cascaded options to wire.",
+        "**Singleton-active per ExtentosGlasses (synthesis #13).** At most one assistant.start() at a time. A second start while active throws AssistantException(AlreadyActive). Call `glasses.assistant.stop()` (or `session.stop()`) before starting a new one. v1 simplicity; can relax in v1.x if customer demand surfaces.",
+        "**Eight `assistant.*` lifecycle events emitted automatically (synthesis #15):** session_started / session_ended / user_spoke / assistant_spoke / tool_called / tool_result / reconnected / error. Visible via `glasses.runtime.events.filterIsInstance<RuntimeEvent.Assistant>()`, the simulator's right-rail AssistantPanel, and `getEventLog(filter: \"voice\")`. assistant.error climbs to filter:\"errors\" automatically.",
+        "**PII boundary differs from Phase 3.** Assistant events DO carry verbatim transcripts in user_spoke / assistant_spoke. Phase 3 conversation.* stripped text (only textLen) because the cascaded path routed transcripts through Extentos backend. Phase 4 BYOK contract sends transcripts device → openai.com directly without touching Extentos backend, so the platform-side PII enforcement doesn't apply. Customer apps own their data retention story.",
+        "**Library-owned transparent reconnection (synthesis #23).** OpenAI Realtime hard-caps sessions at 60 min; library proactively reconnects every ~50 min + on WS onFailure / onClosed. Customer code doesn't see the swap. `assistant.reconnected` event fires for observability. Conversation history (recent 40 turns) replays on each reconnect.",
+        "**BYOK key flows direct to OpenAI (synthesis #12).** `setOpenaiApiKey(key)` stores the key in the AssistantClient; when start() opens the WebSocket, the key goes into `Authorization: Bearer ...` for the wss://api.openai.com/v1/realtime connection. Extentos backend never sees the key. See `getCredentialGuide(service: \"openai\")` for the local.properties + resValue / Info.plist plumbing.",
+        "**What Extentos manages by default vs. what's yours.** The assistant runtime composes several layers of model behavior, and knowing the boundary helps you customize without fighting the SDK:\\n\\n  • **Wire plumbing (SDK-owned, no opt-out)** — WebSocket lifecycle, PCMU audio codec, 50-minute proactive reconnect, session-update handshake. You don't touch these.\\n  • **Provider defaults (SDK-owned, override on `AssistantProvider.OpenAi(...)`)** — model (`gpt-realtime-2`), voice (`alloy`), `turn_detection` (`server_vad`), `reasoningEffort` (`Low`). Override via the provider constructor when you need different behavior.\\n  • **Tools you didn't write (SDK-owned, opt-out via `AssistantConfig` flag)** — `end_conversation` tool injected when `endOnIntent = true` (default). Customize *when* via your `instructions`; opt out via `endOnIntent = false`.\\n  • **Conversation history (SDK-managed buffer; tunable + customizable via iter5.1 surface)** — local replay buffer capped at `AssistantConfig.historyCap` (default 100 turns), preserved across wake/sleep, replayed on reconnect. When the buffer approaches the cap, `AssistantConfig.historyCompaction` runs — default `Auto` summarizes oldest ~50% via gpt-4o-mini under the BYOK key (~$0.001 / compaction). Customer overrides: `Custom { turns -> ... }` for their own strategy, `DropOldest` for free/lossy, `None` for fully manual via `clearHistory` / `appendHistory` / `replaceHistory`.\\n  • **`instructions` text (100% yours)** — Extentos does not modify your prompt. Whatever you write is what the model sees.\\n  • **Mid-session primitives (you call them when you want)** — `session.setReasoningEffort(level)`, `session.updateInstructions(text)`, `session.cancelSpeak()`, `session.includeImage(uri, prompt)`, `session.conversationHistory(limit)`, plus iter5.1's `session.clearHistory()` / `appendHistory(turn)` / `replaceHistory(turns)`. Composable building blocks for escalation, persona swaps, interrupts, vision, forwarding context to stronger models, fresh-each-wake patterns, TTL resets, app-restart restoration. The SDK provides them; you decide which flows to build with them.\\n\\n**Principle for future SDK contributions:** universal-issue patches (things every voice assistant on glasses needs) sit on the SDK side with a documented opt-out. App-specific choices (personality, domain tools, language pinning, persona, custom compaction strategy) sit on the developer side. When in conflict, your `instructions` win on recency. To see what's actually being sent to OpenAI, enable debug-level logging on `OpenAiAssistantProvider` — the effective `session.update` payload (API key not included; it rides in the WS Authorization header) is logged on open + on every partial update + every reconnect.",
+    ],
+    relatedExamples: ["assistant_agent_loop", "agent_driven_e2e_full_loop"],
+};
+const ASSISTANT_START = {
+    feature: "assistant_start",
+    summary: "Open an assistant session. Two equivalent forms: sugar `start(provider) { tool(...) { ... } }` (trailing-lambda builder) and raw `createSession(AssistantConfig(...))` + `session.start()`. Sugar is idiomatic for the common case; raw is the customer-can-skip-it primitive for programmatic tool registration. Both return an `AssistantSession`. Singleton-active per synthesis #13.",
+    kotlin: `// Sugar form
+val session = glasses.assistant.start(
+    provider = AssistantProvider.OpenAi(model = "gpt-realtime", voice = "alloy"),
+) {
+    instructions = "..."
+    tool("take_picture", "Take a photo.") { ToolResult.Ok("photo saved") }
+}
+
+// Raw form — equivalent
+val session = glasses.assistant.createSession(AssistantConfig(
+    provider = AssistantProvider.OpenAi(...),
+    instructions = "...",
+    tools = listOf(
+        ToolDefinition("take_picture", "Take a photo.") { _ -> ToolResult.Ok("photo saved") },
+    ),
+))
+session.start()
+
+// Observe lifecycle:
+session.state.collect { state -> /* Idle, Starting, Active, Reconnecting, Stopping, Ended */ }
+
+// Stop when done:
+session.stop()   // or glasses.assistant.stop() — equivalent`,
+    swift: `// Sugar form
+let session = try await glasses.assistant.start(
+    provider: .openAI(model: "gpt-realtime", voice: "alloy")
+) { config in
+    config.instructions = "..."
+    config.tool("take_picture", description: "Take a photo.") { .ok("photo saved") }
+}
+
+// Raw form — equivalent
+let session = glasses.assistant.createSession(config: AssistantConfig(
+    provider: .openAI(model: "gpt-realtime", voice: "alloy"),
+    instructions: "...",
+    tools: [ToolDefinition(name: "take_picture", description: "Take a photo.") { _ in .ok("photo saved") }]
+))
+try await session.start()
+
+// Observe lifecycle (StateFlow-style — replays current on subscribe):
+for await state in session.state.stream { /* idle, starting, active, reconnecting, stopping, ended */ }
+
+// Stop when done (async, NOT throwing on iOS):
+await session.stop()   // or await glasses.assistant.stop() — equivalent`,
+    gotchas: [
+        "**`start()` is suspend / async throws — call from a coroutine / Task.** Opens the WebSocket, sends session.update, awaits session.updated handshake (~1-2s typical). Throws AssistantException(NoApiKey) if you haven't called setOpenaiApiKey; AssistantException(AlreadyActive) if another session is active; AssistantException(NetworkError) on WS open failure.",
+        "**Sugar form auto-starts the session; raw form does not.** `assistant.start(provider) { ... }` returns an already-Active session. `assistant.createSession(config)` returns an Idle session — you call `session.start()` to activate. The sugar is shorthand for `createSession + start`.",
+        "**Customer-can-skip-it (synthesis #7).** The raw form is the primitive; the sugar reduces to it. Every customer can replace `start { tool(...) { ... } }` with `createSession(AssistantConfig(tools = listOf(ToolDefinition(...), ...)))` + `start()` and get identical behavior. Useful for programmatic tool registration (loaded from config, conditional, etc.).",
+        "**`stop()` is idempotent.** Calling stop() on an Ended session is a no-op. Calling start() on an Ended session throws AssistantException(SessionEnded) — create a new session via createSession() to start fresh.",
+    ],
+    relatedExamples: ["assistant_agent_loop", "agent_driven_e2e_full_loop"],
+};
+const ASSISTANT_TOOL = {
+    feature: "assistant_tool",
+    summary: "Register a tool the assistant may call. Three overloads on the `AssistantConfigBuilder` receiver inside `start { ... }`: (1) no-arg `tool(name, description) { -> ToolResult }`, (2) typed-args `tool<Args>(name, description) { args -> ToolResult }` where Args is `@Serializable` (Kotlin) / `Codable` (Swift), (3) explicit-schema escape hatch `tool(name, description, schema = JsonObject(...)) { args -> ToolResult }`. **Cross-platform asymmetry (Q3, intentional):** Kotlin infers the schema from Args's SerialDescriptor at runtime; Swift requires explicit `schema:` parameter on the typed overload (no Mirror walk on types — see synthesis #8). JSON Schema sent to OpenAI is identical regardless of source platform.",
+    kotlin: `// No-arg tool (most common — camera, status, simple actions)
+tool("take_picture", "Take a photo when the user asks to capture a moment.") {
+    ToolResult.Ok("photo saved")
+}
+
+// Typed-args tool — Args inferred from @Serializable type
+@kotlinx.serialization.Serializable
+data class SetReminderArgs(val text: String, val minutesFromNow: Int)
+
+tool<SetReminderArgs>("set_reminder", "Set a timed reminder.") { args ->
+    reminders.add(args.text, delay = args.minutesFromNow.minutes)
+    ToolResult.Ok("reminder set for \${args.minutesFromNow} min")
+}
+
+// Explicit-schema escape hatch — for polymorphic types or format constraints
+tool("set_filter", "Apply an image filter.", schema = buildJsonObject {
+    put("type", "object")
+    put("properties", buildJsonObject {
+        put("name", buildJsonObject { put("type", "string"); put("enum", buildJsonArray { add("sepia"); add("noir") }) })
+    })
+    put("required", buildJsonArray { add("name") })
+}) { args ->
+    val filterName = args["name"]?.jsonPrimitive?.contentOrNull
+    ToolResult.Ok("filter applied: \$filterName")
+}
+
+// Per-tool blocking opt-out (synthesis #9 — default is non-blocking)
+tool("get_battery", "Current battery percentage.", blocking = true) {
+    ToolResult.Ok("\${battery.percent()}%")
+}`,
+    swift: `// No-arg tool
+config.tool("take_picture", description: "Take a photo when the user asks to capture a moment.") {
+    .ok("photo saved")
+}
+
+// Typed-args tool — EXPLICIT schema required on Swift (Q3 asymmetry).
+// v1 has no \`JSONSchema\` builder helper; the customer constructs the
+// schema directly via \`JSONValue\` (Codable + Sendable). Args type
+// is inferred from the closure parameter annotation, not a separate
+// \`args:\` parameter — see Tool.swift's typed-overload signature.
+struct SetReminderArgs: Codable, Sendable {
+    let text: String
+    let minutesFromNow: Int
+}
+
+let reminderSchema: JSONValue = .object([
+    "type": .string("object"),
+    "properties": .object([
+        "text": .object(["type": .string("string")]),
+        "minutesFromNow": .object(["type": .string("integer")]),
+    ]),
+    "required": .array([.string("text"), .string("minutesFromNow")]),
+])
+
+config.tool(
+    "set_reminder",
+    description: "Set a timed reminder.",
+    schema: reminderSchema
+) { (args: SetReminderArgs) in
+    await reminders.add(args.text, delaySeconds: args.minutesFromNow * 60)
+    return .ok("reminder set for \\(args.minutesFromNow) min")
+}
+
+// Per-tool blocking opt-out (synthesis #9 — default is non-blocking)
+config.tool("get_battery", description: "Current battery percentage.", blocking: true) {
+    .ok("\\(battery.percent())%")
+}`,
+    gotchas: [
+        "**Tool descriptions matter — write them for the AI, not the engineer.** The model reads the description verbatim when deciding which tool to call. Use \"Take a photo when the user asks to capture a moment\" (describes WHEN to call) not \"Captures imagery via the camera SDK\" (describes implementation). Mock provider's word-overlap matcher also benefits from descriptions that contain keywords from likely user utterances.",
+        "**Tool body runs on Dispatchers.IO (Kotlin) / Swift Task (Swift).** Suspending camera / storage / HTTP calls are fine; CPU-heavy work won't block the main thread. Per-tool blocking opt-out via `blocking = true` parameter (synthesis #9) — true means the model waits silently for the result before speaking. Default false means the model says \"let me check...\" while the tool runs.",
+        "**`ToolResult.Ok(text)` vs `ToolResult.Err(message)`.** The `text` for Ok is what the model reads aloud / weaves into its reply. Keep it short + factual: \"photo saved\" not \"Image successfully persisted to local storage at /...\". For structured data the model needs to reason about, return it as a JSON string: `ToolResult.Ok(\"\"\"{\"km\": 12.4}\"\"\")`. Err is the user-facing failure message; the model surfaces it (\"sorry, the camera failed\").",
+        "**Customer-can-skip-it (synthesis #8) — the builder is sugar over `ToolDefinition`.** Every tool() call constructs a `ToolDefinition(name, description, schema, blocking, body)` and appends to the builder's list. Customers can skip the builder entirely and pass `tools = listOf(ToolDefinition(...))` to `AssistantConfig` directly for programmatic registration.",
+        "**Tools have full access to glasses.* + app state (synthesis #14).** No sandbox in v1. Tool body is regular customer-app code — it sees `glasses.camera`, `glasses.audio`, the app's DBs, view models, repositories, third-party SDKs. Security boundary stays at the app/OS level (Android permissions, iOS Info.plist) — not the SDK level. Per the indie/hobbyist target audience + BYOK provider model.",
+    ],
+    relatedExamples: ["assistant_agent_loop", "agent_driven_e2e_full_loop"],
+};
+const ASSISTANT_PROVIDER_OPENAI = {
+    feature: "assistant_provider_openai",
+    summary: "OpenAI Realtime provider configuration. `AssistantProvider.OpenAi(model, voice, turnDetection, reasoningEffort)` — model defaults to `gpt-realtime-2` (released 2026-05-08, strictly better at tool calling, parallel tool calls, 128k context, GPT-5-class reasoning); voice from OpenAI's catalog (`alloy`, `echo`, `shimmer`, `marin`); turnDetection defaults to `ServerVad(threshold = 0.5, prefixPaddingMs = 300, silenceDurationMs = 500)` per synthesis #10; reasoningEffort defaults to `Low` (OpenAI's own recommended default for voice agents — anything higher noticeably adds latency). BYOK key set out-of-band via `setOpenaiApiKey`. WebSocket transport in v1 (WebRTC v1.1+). GA wire format `audio/pcmu` (no rate field; G.711 intrinsic 8 kHz) per synthesis #6.",
+    kotlin: `// Default — gpt-realtime-2 + alloy + ServerVad + reasoning Low
+val provider = AssistantProvider.OpenAi(
+    model = "gpt-realtime-2",
+    voice = "alloy",
+)
+
+// Custom VAD tuning — more aggressive turn-end detection
+val provider = AssistantProvider.OpenAi(
+    model = "gpt-realtime-2",
+    voice = "marin",
+    turnDetection = TurnDetection.ServerVad(
+        threshold = 0.6,
+        prefixPaddingMs = 200,
+        silenceDurationMs = 350,
+    ),
+)
+
+// Semantic VAD — slower but smarter turn detection (model uses context
+// to decide whether the user actually finished, vs paused mid-sentence)
+val provider = AssistantProvider.OpenAi(
+    model = "gpt-realtime-2",
+    voice = "alloy",
+    turnDetection = TurnDetection.SemanticVad,
+)
+
+// Higher reasoning baseline for an analytical assistant. Users will
+// notice extra 2-5s on every reply; pick Low for casual chat, Medium
+// for advisory, High/Xhigh only when the product really benefits.
+val provider = AssistantProvider.OpenAi(
+    model = "gpt-realtime-2",
+    voice = "alloy",
+    reasoningEffort = ReasoningEffort.Medium,
+)
+
+// BYOK key — set ONCE at bootstrap; reused on every session.start() +
+// every reconnect within a session.
+glasses.assistant.setOpenaiApiKey(BuildConfig.OPENAI_API_KEY)`,
+    swift: `// Default — gpt-realtime-2 + alloy + ServerVad + reasoning Low
+let provider: AssistantProvider = .openAI(model: "gpt-realtime-2", voice: "alloy")
+
+// Custom VAD tuning
+let provider: AssistantProvider = .openAI(
+    model: "gpt-realtime-2",
+    voice: "marin",
+    turnDetection: .serverVad(
+        threshold: 0.6,
+        prefixPaddingMs: 200,
+        silenceDurationMs: 350
+    )
+)
+
+// Semantic VAD
+let provider: AssistantProvider = .openAI(
+    model: "gpt-realtime-2",
+    voice: "alloy",
+    turnDetection: .semanticVad
+)
+
+// Higher reasoning baseline (iOS parity for reasoningEffort lands with
+// the next Mac VPS handoff)
+// let provider: AssistantProvider = .openAI(
+//     model: "gpt-realtime-2",
+//     voice: "alloy",
+//     reasoningEffort: .medium
+// )
+
+// BYOK key
+glasses.assistant.setOpenAiApiKey(Secrets.openAiKey)`,
+    gotchas: [
+        "**Reasoning effort — four customization patterns.** The two SDK knobs (\`reasoningEffort\` on \`AssistantProvider.OpenAi\` + \`session.setReasoningEffort(level)\` mid-session) enable: (1) **Static default** — set it once on the provider, never change. 80% of apps live here. (2) **Model self-routes** — register a \`think_harder\` tool the model calls when it senses complexity; tool body calls \`session.setReasoningEffort(High)\`. (3) **User-explicit trigger** — same tool pattern with a description that says \"only call when the user explicitly asks to think more carefully.\" (4) **App UI toggle** — wire a \"deep thinking\" switch in your UI to \`session.setReasoningEffort\` directly. Don't bake auto-routing heuristics into your tool body — let the model decide via descriptions, that's what tool descriptions are for.",
+        "**Reasoning levels: `Minimal | Low | Medium | High | Xhigh`.** OpenAI's spelling — wire value `xhigh`, not `very_high` (several community articles got this wrong). Each step up adds 1-5s of latency on the next response; Xhigh can hit 10s+ on hard prompts. Voice agents on glasses are latency-sensitive — keep the session baseline at Low and bump via the runtime setter for individual turns that warrant it.",
+        "**Voice CAN be swapped mid-session on `gpt-realtime-2`** (unlike the original `gpt-realtime` where voice was locked once the model first spoke). The v1.4 SDK doesn't expose a runtime voice setter — stop + start a new session is the workaround. If a customer wants mid-session voice swap as a primitive, file a request; it's a thin shim over `session.update`.",
+        "**Wire format is `audio/pcmu` with NO rate field (synthesis #6).** G.711 mulaw is intrinsically 8 kHz; the GA spec encodes that via the format type alone. Library handles the PCM↔mulaw codec internally — customer never sees raw bytes. Validated via Twilio's production GA integration. Fallback to `audio/pcm rate=24000` documented but unlikely needed.",
+        "**60-min hard ceiling on OpenAI Realtime sessions.** Library proactively reconnects every ~50 min ahead of the ceiling; on WS onFailure / onClosed mid-session, coalesced reconnect via lifecycle mutex; recent 40 conversation turns replayed on each reconnect; customer never sees the swap. `assistant.reconnected` event fires for observability. Synthesis #23.",
+        "**Parallel tool calls (new in `gpt-realtime-2`).** The model can fire multiple tool calls in one response — e.g. \"check my calendar AND get the weather\" → both tools dispatch in parallel. SDK already handles this via per-call_id state in OpenAiAssistantProvider (synthesis #9 non-blocking dispatch was already the design). No customer-side change needed; just write the tools and let the model batch them when it wants.",
+        "**No Anthropic provider in v1 or v2 (synthesis #17).** Anthropic hasn't shipped a Realtime API. v2.0.0 ships OpenAI only; Gemini Live in v1.5+. Revisit Claude when Anthropic ships their equivalent.",
+        "**Test with `AssistantProvider.Mock()` first (synthesis #16).** Mock is deterministic, sub-millisecond, $0; matches injected utterances against tool descriptions for deterministic CI. Save the OpenAi provider for end-to-end smoke + production.",
+    ],
+    relatedExamples: ["assistant_agent_loop", "agent_driven_e2e_full_loop"],
+};
+const ASSISTANT_VISION = {
+    feature: "assistant_vision",
+    summary: "Phase 4 v1.4 addition — `session.includeImage(uri, prompt = null)`. Add an image to the assistant's conversation context and auto-trigger a response: the model sees the image, speaks about it in its configured voice, and remembers it for follow-up questions in the same session. Canonical 'glasses analyze what I'm looking at' surface — pair with `glasses.camera.capturePhoto()` inside a tool body. URI accepts `data:` (sim's capturePhoto default), `http(s)://` (provider fetches), or `file://` / `content://` / bare absolute path (library reads + base64-encodes). Active-only — throws `AssistantException(NotReady)` otherwise. Mock provider stubs with a deterministic AssistantSpoke event for the agent-test loop. v1 ships against OpenAI Realtime's `conversation.item.create` with `input_image` content block.",
+    kotlin: `// Canonical pattern — capturePhoto + includeImage inside a tool body.
+// The session is guaranteed Active here (the model only calls a tool
+// while Active), so the NotReady throw won't fire in practice.
+tool("describe_scene", "Describe what the user is currently looking at — call when the user asks 'what do you see' or 'describe this'.") {
+    val photo = glasses.camera.capturePhoto().valueOrNull()
+        ?: return@tool ToolResult.Err("camera failed")
+    val uri = photo.uri
+        ?: return@tool ToolResult.Err("photo had no uri")
+    session.includeImage(uri)
+    ToolResult.Ok("looking")
+}
+
+// With a directed prompt — combine "look at this" with a specific
+// question. The prompt is sent as a user text alongside the image.
+tool("read_sign", "Read what's written on a sign in front of the user.") {
+    val photo = glasses.camera.capturePhoto().valueOrNull()
+        ?: return@tool ToolResult.Err("camera failed")
+    val uri = photo.uri
+        ?: return@tool ToolResult.Err("photo had no uri")
+    session.includeImage(uri, prompt = "What does this sign say? Read it back verbatim.")
+    ToolResult.Ok("reading")
+}
+
+// Persistence sibling — save_photo. Use a DISTINCT tool from describe_scene
+// for the "save this picture" intent: the model picks based on user intent
+// ("save / capture / remember" → save_photo; "what / describe / tell me" →
+// describe_scene). DON'T fold both responsibilities into one tool: the
+// model can compose two tools when the user wants both (e.g. "save this
+// and tell me what it is" → save_photo + describe_scene back-to-back).
+//
+// SDK pairing: Photos.copyToFile mirrors Videos.copyToFile — one stream
+// copy that handles data:/file:// uniformly, creates parent dirs, returns
+// Boolean. Use it; don't hand-roll loadBytes + writeBytes.
+tool("save_photo", "Save a photo to the user's library WITHOUT describing it. Call for 'save this', 'capture this', 'take a picture', 'remember this view'.") {
+    val photo = glasses.camera.capturePhoto().valueOrNull()
+        ?: return@tool ToolResult.Err("camera failed")
+    val uri = photo.uri
+        ?: return@tool ToolResult.Err("photo had no uri")
+    val ext = when (Photos.mediaTypeFromUri(uri)) {
+        "image/png" -> "png"
+        "image/webp" -> "webp"
+        else -> "jpg"
+    }
+    val dst = File(library.photosDir, "photo-\${System.currentTimeMillis()}.\$ext")
+    if (!Photos.copyToFile(uri, dst)) return@tool ToolResult.Err("could not save photo")
+    library.addPhoto(dst.absolutePath, photo.width, photo.height)
+    ToolResult.Ok("photo saved")
+}
+
+// From a file path (real hardware case — content:// / file:// URI from
+// the platform camera intent). Same call shape — library handles the
+// read + base64 encode internally.
+session.includeImage("content://media/external/images/media/12345")`,
+    swift: `// iOS port lands after Android stabilizes (see real-hardware-validation-backlog.md).
+// The Swift surface will mirror Kotlin's includeImage(uri:prompt:) signature.
+config.tool("describe_scene", description: "Describe what the user is currently looking at.") {
+    guard let photo = (await self.glasses.camera.capturePhoto()).success else {
+        return .err("camera failed")
+    }
+    guard let uri = photo.uri else { return .err("photo had no uri") }
+    try await self.session?.includeImage(uri: uri)
+    return .ok("looking")
+}`,
+    gotchas: [
+        "**Auto-triggers a response — that's the point.** `includeImage` is a one-call API: image goes in, the model speaks. If you want to stage an image without an immediate response (rare — e.g. accumulating multiple images then asking one question), drop down to the raw OpenAI provider primitive (not exposed in v1; file a request if you need it).",
+        "**URI types map to wire format:** `data:image/...;base64,...` passes through verbatim (sim's capturePhoto returns this shape). `http(s)://...` passes through verbatim — OpenAI Realtime fetches the URL server-side; provider may reject for size / auth reasons, so prefer data: or base64 in production. `file://` / `content://` / bare path → library reads bytes via `Photos.loadBase64` + wraps with `mediaTypeFromUri` inferred MIME. Permission-gated like any other on-device read.",
+        "**Active-only.** Same precondition as `session.say()` — throws `AssistantException(NotReady)` outside Active. Inside a tool body the state IS Active (the model only dispatches a tool while Active), so the typical usage is always safe. Don't call from `onWake { }` either — onWake fires fire-and-forget on a separate coroutine that may race with the Active transition; use a brief `delay` or call from the FIRST tool dispatch instead.",
+        "**Image persists in conversation history at the provider.** Follow-up questions in the same session (\"what about the colors?\", \"is there text?\") work without re-sending. The library does NOT replay images on reconnect in v1 (the recent-40-turns replay covers text-only entries) — if a reconnect lands mid-image-conversation, the model loses raw visual access but keeps the conversation thread via the AssistantSpoke transcript.",
+        "**Don't pass the photo bytes around manually.** The customer URI surface IS the API contract. Library handles base64 encoding, MIME detection, and the `conversation.item.create` wire shape. Manual base64-encoding inside a tool body is wasted code — just pass `photo.uri` and let the library figure out the rest.",
+        "**Mock provider emits a deterministic stub event.** `MockAssistantProvider.includeImage` synthesizes an `AssistantSpoke(\"I see an image (uri=…)\")` so agent-driven tests can `assertEvent({ type: \"assistant.assistant_spoke\", contains: \"I see an image\" })` without a real vision model. For real vision behavior in CI you need the OpenAi provider — wire it via a build flavor (see assistant_agent_loop example for the BuildConfig pattern).",
+        "**OpenAI Realtime image format (verified May 2026):** `conversation.item.create` → `item.type=\"message\"`, `role=\"user\"`, `content=[ {type:\"input_text\",text:...}, {type:\"input_image\",image_url:\"data:image/jpeg;base64,...\"} ]`. The text + image blocks can coexist; ordering is text-first so the prompt frames the image. After the item.create the library sends a follow-up `response.create` to trigger the model's response (same pattern as `say()`).",
+        "**Describe vs save are TWO tools, not one (iter4 pattern).** `describe_scene` calls `includeImage` (model speaks about the photo, photo NOT persisted). `save_photo` calls `Photos.copyToFile` + your library's add-photo method (photo persisted, NOT described). The model picks based on user intent (\"what / describe / tell me\" → describe; \"save / capture / take a picture / remember\" → save) and can call BOTH back-to-back when the user wants both. Don't bake both responsibilities into one tool — splitting lets the model compose intents naturally and keeps each tool's description tight enough for the matcher (Mock + real-model alike) to disambiguate.",
+        "**`Photos.copyToFile(uri, dst): Boolean` is the canonical photo-persist primitive (iter4).** Mirrors `Videos.copyToFile`: handles data: / file:// / absolute path uniformly, creates parent dirs, overwrites existing dst, returns false on any failure. Use it; don't hand-roll `Photos.loadBytes(uri)` + `File.writeBytes` — that's the same code with more lines and more failure modes to forget. Pick the file extension via `Photos.mediaTypeFromUri(uri)` (\"image/png\" → png, \"image/webp\" → webp, default jpg).",
+    ],
+    relatedExamples: ["assistant_agent_loop", "agent_driven_e2e_full_loop"],
+};
+const ASSISTANT_SESSION_RUNTIME = {
+    feature: "assistant_session_runtime",
+    summary: "Mid-session primitives on `AssistantSession` (iter5 addition). Four building blocks for runtime control: `setReasoningEffort` (change reasoning level mid-conversation), `updateInstructions` (swap the system prompt without losing context), `cancelSpeak` (programmatic barge-in — interrupt the model's in-flight utterance), `conversationHistory` (read-only snapshot of recent turns for forwarding to a stronger model). All four are Active-only (throws NotReady otherwise) except `conversationHistory` which is safe in any state. The SDK provides the primitives; you compose the flows.",
+    kotlin: `// ── setReasoningEffort: model self-routes via a tool ───────────────
+// The model calls this tool when it senses a complex question. The
+// tool body bumps reasoning effort for subsequent turns. Pair with
+// "back_to_quick_chat" if you want to revert; skip it for sticky-high.
+tool("think_harder", "Call when the user asks something complex that needs deeper reasoning. The next response will take longer but be more thorough.") {
+    session.setReasoningEffort(ReasoningEffort.High)
+    ToolResult.Ok("thinking more carefully")
+}
+
+tool("back_to_quick_chat", "Call when the user is done with the deep question and wants normal pace again.") {
+    session.setReasoningEffort(ReasoningEffort.Low)
+    ToolResult.Ok("back to quick mode")
+}
+
+// ── updateInstructions: persona swap ───────────────────────────────
+tool("switch_to_formal", "When the user says something like 'be more formal' or 'professional voice now', switch persona.") {
+    session.updateInstructions("""
+        You are a professional, concise voice assistant. Respond in
+        formal English. Keep replies brief and factual.
+    """.trimIndent())
+    ToolResult.Ok("switching to formal mode")
+}
+
+// ── cancelSpeak: tool-driven interrupt ─────────────────────────────
+tool("stop_video", "Stop the current video recording.") {
+    val clip = stopAndAwaitVideo() ?: return@tool ToolResult.Err("nothing recording")
+    library.add(clip)
+    // The model was mid-sentence about something else (maybe still
+    // narrating its own previous reply); cut it off so the next
+    // utterance comes from our tool result, not the prior context.
+    session.cancelSpeak()
+    ToolResult.Ok("video saved")
+}
+
+// ── conversationHistory: escalation to a stronger model ────────────
+tool("ask_smart_model", "Use when the user asks something complex that needs a more powerful model — deep reasoning, long analysis, multi-step problems.") { args ->
+    val question = args["question"]?.jsonPrimitive?.contentOrNull
+        ?: return@tool ToolResult.Err("no question")
+
+    // Forward the recent conversation so the strong model has context.
+    val context = session.conversationHistory(limit = 20).joinToString("\\n") {
+        when (it) {
+            is Turn.UserText -> "user: \${it.text}"
+            is Turn.AssistantText -> "assistant: \${it.text}"
+            is Turn.ToolInvocation -> "tool_call: \${it.name}(\${it.argsJson})"
+            is Turn.ToolReturn -> "tool_result: \${it.output}"
+        }
+    }
+
+    val answer = myStrongModelClient.chat(
+        model = "gpt-5",
+        systemPrompt = "Continue this voice conversation. Be thorough.",
+        userPrompt = "Recent context:\\n\\n\$context\\n\\nUser's current question: \$question",
+    )
+    ToolResult.Ok(answer)  // realtime model reads this aloud
+}
+
+// ── Conversation memory & compaction (iter5.1) ─────────────────
+//
+// **Two layers to understand:**
+//   1. OpenAI server-side session — exists only while WS is connected;
+//      recreated every reconnect; no persistence at all.
+//   2. SDK local replay buffer — preserved across wake/sleep, replayed
+//      to OpenAI on each connect. Capped at AssistantConfig.historyCap
+//      (default 100). When the buffer approaches the cap, the
+//      AssistantConfig.historyCompaction policy fires.
+//
+// **Default behavior:** Auto compaction — SDK summarizes oldest ~50%
+// via gpt-4o-mini using your BYOK key (~\$0.001 / compaction, every
+// ~30-45 min of talk), replaces them with one summary turn,
+// conversation continues indefinitely. Zero customer code required.
+
+// ── Custom compactor (your own model + strategy) ───────────────
+glasses.assistant.start(provider) {
+    instructions = "..."
+    historyCap = 150  // raise if your conversations run long
+
+    historyCompaction = HistoryCompaction.Custom { turns ->
+        // Customer-controlled. Could call a different model, write
+        // to a vector DB, etc. Return the replacement buffer.
+        val summary = myAnthropicClient.summarize(turns)
+        val keepRecent = turns.takeLast(turns.size / 2)
+        listOf(Turn.AssistantText("[summary] \$summary", System.currentTimeMillis())) + keepRecent
+    }
+
+    tool("...") { ... }
+}
+
+// ── Fresh-each-wake notetaker ──────────────────────────────────
+glasses.assistant.start(provider) {
+    onWake { session.clearHistory() }                    // wipe before each turn-on
+    historyCompaction = HistoryCompaction.DropOldest      // disable Auto (no LLM cost)
+    tool("...") { ... }
+}
+
+// ── TTL reset (forget after long idle) ─────────────────────────
+var lastSleepAtMs = 0L
+glasses.assistant.start(provider) {
+    onSleep { lastSleepAtMs = System.currentTimeMillis() }
+    onWake {
+        if (System.currentTimeMillis() - lastSleepAtMs > 5 * 60_000) {
+            session.clearHistory()
+        }
+    }
+    tool("...") { ... }
+}
+
+// ── App-restart persistence (your storage; SDK doesn't persist) ─
+val savedTurns = mySavedHistoryStore.load()  // your DataStore / Room / file
+if (savedTurns.isNotEmpty()) {
+    session.replaceHistory(savedTurns)  // SDK replays this on reconnect
+}
+// Save on each turn:
+glasses.runtime.events
+    .filterIsInstance<RuntimeEvent.Assistant>()
+    .onEach { mySavedHistoryStore.save(session.conversationHistory()) }
+    .launchIn(scope)`,
+    swift: `// iOS port for these four primitives lands with the next Mac VPS handoff.
+// Track in shared-context/real-hardware-validation-backlog.md.`,
+    gotchas: [
+        "**All four are Active-only except `conversationHistory`.** `setReasoningEffort` / `updateInstructions` / `cancelSpeak` throw `AssistantException(NotReady)` outside Active state — but tool bodies always run while Active (the model only dispatches a tool when the session is up), so the typical inside-a-tool-body usage is always safe. `conversationHistory` is safe in any state and returns an empty list pre-start or post-stop.",
+        "**`setReasoningEffort` and `updateInstructions` mutate session state.** The new value persists until changed again OR the session ends. On a reconnect (transparent ~50-min cadence), the LATEST value gets sent — not the original config — so customer-driven changes survive reconnects naturally. No special handling needed.",
+        "**`cancelSpeak` complements VAD-driven barge-in; it doesn't replace it.** The model already handles user-driven interruption when the VAD detects speech onset. This primitive is for the tool-driven / app-driven case where the developer wants to stop the model programmatically (e.g. after a tool completes and wants to deliver its result immediately, cutting off any filler the model was speaking).",
+        "**`conversationHistory` returns at most the SDK's reconnect-replay cap (`AssistantConfig.historyCap`, default 100 as of iter5.1, was 40 in iter5).** Asking for more returns what's available. Order: chronological, oldest first. App can tune via `historyCap = N` in the start block; pair larger caps with `HistoryCompaction.Auto` (default) so conversations don't degrade silently past the model's quality cliff.",
+        "**Memory compaction is automatic by default (`HistoryCompaction.Auto`, iter5.1).** When the local replay buffer crosses ~80% of `historyCap`, the SDK summarizes the oldest ~50% of turns via gpt-4o-mini using the customer's BYOK OpenAI key, replaces them with a single `[conversation summary] …` AssistantText turn, and the conversation continues indefinitely. Cost ~$0.001 per compaction (every ~30-45 min of talk). Customer can override the summarizer with `HistoryCompaction.Custom { turns -> ... }` for their own model / strategy, or disable with `HistoryCompaction.DropOldest` (free, lossy — original iter5 behavior). The summarizer makes outbound HTTP calls to api.openai.com/v1/chat/completions (NOT the Realtime endpoint); use `DropOldest` if you need to avoid that surface for compliance reasons.",
+        "**Memory primitives compose (iter5.1):** `session.clearHistory()` wipes the buffer (any state, idempotent); `session.appendHistory(turn)` injects a turn for app-context hints or restored turns; `session.replaceHistory(turns)` swaps the entire buffer atomically. None of these trigger compaction. Customer composes patterns like fresh-each-wake (`onWake { session.clearHistory() }`), TTL reset (`onWake { if (idleTooLong) clearHistory() }`), or app-restart restoration (`session.replaceHistory(savedTurns)` before first wake). The SDK does NOT persist history to disk; that's the customer's storage layer.",
+        "**`Turn.argsJson` is the serialized JSON string of tool arguments**, not a structured object. Customer code that wants typed args can re-parse with kotlinx.serialization (`Json.decodeFromString<MyArgs>(turn.argsJson)`) or pass the raw string to a downstream LLM. Kept as String to avoid leaking kotlinx.serialization types into the public surface — same precedent as how we kept `instructions` as raw String.",
+        "**Mock provider records history too** (iter5). When you test escalation flows with `AssistantProvider.Mock()` + `injectAssistantUtterance`, the Mock builds up a conversation buffer just like the OpenAi runtime does. Your `ask_smart_model` tool's `session.conversationHistory()` call returns the inject sequence + tool I/O, so you can verify your escalation logic forwards the right context without ever talking to a real model.",
+        "**`updateInstructions` does NOT change voice or model.** Those are provider-level locks (model: hard-locked at session start by OpenAI; voice: technically swappable mid-session on gpt-realtime-2 but not exposed by this primitive — file a request if you need it).",
+        "**Don't write auto-routing heuristics inside the SDK** — let the model decide via tool descriptions. *\"Call think_harder when the user asks something that needs deep reasoning\"* + *\"Call back_to_quick_chat when they're done with the deep question\"* is enough; the model handles the orchestration. Per the SDK layering principle, the SDK provides primitives, the model + tool descriptions provide the flow.",
+    ],
+    relatedExamples: ["assistant_agent_loop", "agent_driven_e2e_full_loop"],
+};
 export const CAPABILITY_GUIDES = {
     capture_photo: CAPTURE_PHOTO,
     capture_video: CAPTURE_VIDEO,
@@ -792,7 +1277,15 @@ export const CAPABILITY_GUIDES = {
     connection_state: CONNECTION_STATE,
     toggles: TOGGLES,
     voice_command: VOICE_COMMAND,
-    // Phase 3 conversation runtime primitives (see block above).
+    // Phase 4 assistant runtime primitives (canonical voice-AI surface).
+    assistant_runtime: ASSISTANT_RUNTIME,
+    assistant_start: ASSISTANT_START,
+    assistant_tool: ASSISTANT_TOOL,
+    assistant_provider_openai: ASSISTANT_PROVIDER_OPENAI,
+    assistant_vision: ASSISTANT_VISION,
+    assistant_session_runtime: ASSISTANT_SESSION_RUNTIME,
+    // Phase 3 conversation runtime primitives — DEPRECATED in v1.4.0,
+    // REMOVED in v2.0.0. Kept here for the migration window.
     conversation_runtime: CONVERSATION_RUNTIME,
     conversation_on_wake: CONVERSATION_ON_WAKE,
     conversation_listen: CONVERSATION_LISTEN,

package/dist/tools/data/capabilityPatterns.js.map

@@ -1 +1 @@
-{"version":3,"file":"capabilityPatterns.js","sourceRoot":"","sources":["../../../src/tools/data/capabilityPatterns.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"capabilityPatterns.js","sourceRoot":"","sources":["../../../src/tools/data/capabilityPatterns.ts"],"names":[],"mappings":"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"}

package/dist/tools/data/codeExamples.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"codeExamples.d.ts","sourceRoot":"","sources":["../../../src/tools/data/codeExamples.ts"],"names":[],"mappings":"AAeA,6DAA6D;AAC7D,MAAM,WAAW,iBAAiB;IAChC,kEAAkE;IAClE,aAAa,EAAE,gBAAgB,GAAG,qBAAqB,GAAG,oBAAoB,GAAG,2BAA2B,CAAC;IAC7G,0EAA0E;IAC1E,QAAQ,EAAE,MAAM,CAAC;IACjB,yCAAyC;IACzC,SAAS,EAAE,sBAAsB,CAAC;CACnC;AAED,6DAA6D;AAC7D,MAAM,WAAW,oBAAoB;IACnC,mEAAmE;IACnE,EAAE,EAAE,MAAM,CAAC;IACX,yDAAyD;IACzD,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,4CAA4C;IAC5C,SAAS,EAAE,uBAAuB,GAAG,sBAAsB,CAAC;IAC5D;4EACwE;IACxE,UAAU,CAAC,EAAE,OAAO,CAAC;IACrB,8DAA8D;IAC9D,IAAI,CAAC,EAAE,MAAM,CAAC;CACf;AAED,mEAAmE;AACnE,MAAM,WAAW,oBAAoB;IACnC,sBAAsB;IACtB,GAAG,EAAE,MAAM,CAAC;IACZ,oEAAoE;IACpE,IAAI,EAAE,MAAM,CAAC;IACb,6CAA6C;IAC7C,QAAQ,EAAE,MAAM,EAAE,CAAC;CACpB;AAED,MAAM,WAAW,WAAW;IAC1B,OAAO,EAAE,MAAM,CAAC;IAChB,KAAK,EAAE,MAAM,CAAC;IACd,WAAW,EAAE,MAAM,CAAC;IACpB,IAAI,EAAE;QACJ,MAAM,EAAE,MAAM,CAAC;QACf,KAAK,EAAE,MAAM,CAAC;KACf,CAAC;IACF,WAAW,EAAE,MAAM,CAAC;IACpB,OAAO,EAAE,MAAM,EAAE,CAAC;IAClB,eAAe,EAAE,MAAM,EAAE,CAAC;IAC1B;;;;;;OAMG;IACH,oBAAoB,CAAC,EAAE;QACrB,OAAO,CAAC,EAAE,iBAAiB,EAAE,CAAC;QAC9B,gBAAgB,CAAC,EAAE,oBAAoB,EAAE,CAAC;KAC3C,CAAC;IACF;;;;;;OAMG;IACH,eAAe,CAAC,EAAE;QAChB,OAAO,CAAC,EAAE,oBAAoB,EAAE,CAAC;KAClC,CAAC;CACH;AA63DD,eAAO,MAAM,aAAa,EAAE,MAAM,CAAC,MAAM,EAAE,WAAW,CAUrD,CAAC;AAEF,eAAO,MAAM,qBAAqB,UAAoC,CAAC"}
+{"version":3,"file":"codeExamples.d.ts","sourceRoot":"","sources":["../../../src/tools/data/codeExamples.ts"],"names":[],"mappings":"AAeA,6DAA6D;AAC7D,MAAM,WAAW,iBAAiB;IAChC,kEAAkE;IAClE,aAAa,EAAE,gBAAgB,GAAG,qBAAqB,GAAG,oBAAoB,GAAG,2BAA2B,CAAC;IAC7G,0EAA0E;IAC1E,QAAQ,EAAE,MAAM,CAAC;IACjB,yCAAyC;IACzC,SAAS,EAAE,sBAAsB,CAAC;CACnC;AAED,6DAA6D;AAC7D,MAAM,WAAW,oBAAoB;IACnC,mEAAmE;IACnE,EAAE,EAAE,MAAM,CAAC;IACX,yDAAyD;IACzD,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,4CAA4C;IAC5C,SAAS,EAAE,uBAAuB,GAAG,sBAAsB,CAAC;IAC5D;4EACwE;IACxE,UAAU,CAAC,EAAE,OAAO,CAAC;IACrB,8DAA8D;IAC9D,IAAI,CAAC,EAAE,MAAM,CAAC;CACf;AAED,mEAAmE;AACnE,MAAM,WAAW,oBAAoB;IACnC,sBAAsB;IACtB,GAAG,EAAE,MAAM,CAAC;IACZ,oEAAoE;IACpE,IAAI,EAAE,MAAM,CAAC;IACb,6CAA6C;IAC7C,QAAQ,EAAE,MAAM,EAAE,CAAC;CACpB;AAED,MAAM,WAAW,WAAW;IAC1B,OAAO,EAAE,MAAM,CAAC;IAChB,KAAK,EAAE,MAAM,CAAC;IACd,WAAW,EAAE,MAAM,CAAC;IACpB,IAAI,EAAE;QACJ,MAAM,EAAE,MAAM,CAAC;QACf,KAAK,EAAE,MAAM,CAAC;KACf,CAAC;IACF,WAAW,EAAE,MAAM,CAAC;IACpB,OAAO,EAAE,MAAM,EAAE,CAAC;IAClB,eAAe,EAAE,MAAM,EAAE,CAAC;IAC1B;;;;;;OAMG;IACH,oBAAoB,CAAC,EAAE;QACrB,OAAO,CAAC,EAAE,iBAAiB,EAAE,CAAC;QAC9B,gBAAgB,CAAC,EAAE,oBAAoB,EAAE,CAAC;KAC3C,CAAC;IACF;;;;;;OAMG;IACH,eAAe,CAAC,EAAE;QAChB,OAAO,CAAC,EAAE,oBAAoB,EAAE,CAAC;KAClC,CAAC;CACH;AAkxFD,eAAO,MAAM,aAAa,EAAE,MAAM,CAAC,MAAM,EAAE,WAAW,CAYrD,CAAC;AAEF,eAAO,MAAM,qBAAqB,UAAoC,CAAC"}