@bunny-agent/sdk 0.9.63-beta.2 → 0.10.0-beta.3

package/dist/index.js

@@ -1,3 +1,9 @@
+import {
+  isSafeHttpUrl,
+  isSearchContractCapabilities,
+  isValidCitationContractMetadata
+} from "./chunk-WQI667GT.js";
+
 // src/index.ts
 import {
   buildRunnerEnv,
@@ -40,6 +46,203 @@ function getProviderLogger(settings) {
   };
 }
 
+// src/provider/search-contract-ai-sdk.ts
+import { createRequire } from "module";
+var SEARCH_CONTRACT_AI_SDK_MINIMUM = "6.0.264";
+function supportsSearchContractUiMetadata(version) {
+  const match = /^6\.(\d+)\.(\d+)(?:\+[\w.-]+)?$/.exec(version);
+  return !!match && (Number(match[1]) > 0 || Number(match[2]) >= 264);
+}
+async function assertSearchContractAiSdkSupport() {
+  let version;
+  try {
+    const packageInfo = createRequire(import.meta.url)("ai/package.json");
+    version = packageInfo.version;
+  } catch {
+    throw new Error(
+      "Cannot verify the AI SDK peer required by searchContractVersion: 1."
+    );
+  }
+  if (typeof version !== "string" || !supportsSearchContractUiMetadata(version)) {
+    throw new Error(
+      `searchContractVersion: 1 requires ai >=${SEARCH_CONTRACT_AI_SDK_MINIMUM} <7.0.0 to preserve structured tool-result metadata; found ai@${String(version)}.`
+    );
+  }
+}
+
+// src/provider/search-contract-discovery.ts
+var CACHE_TTL_MS = 3e4;
+var PROBE_TIMEOUT_MS = 4e3;
+var MAX_ENDPOINTS_PER_HANDLE = 16;
+var MAX_RESPONSE_BYTES = 16384;
+var cache = /* @__PURE__ */ new WeakMap();
+function abortError() {
+  return new DOMException("Search capability discovery aborted.", "AbortError");
+}
+function waitForSearchDiscovery(promise, signal) {
+  if (signal?.aborted) return Promise.reject(abortError());
+  if (!signal) return promise;
+  return new Promise((resolve, reject) => {
+    const onAbort = () => reject(abortError());
+    signal.addEventListener("abort", onAbort, { once: true });
+    promise.then(resolve, reject).finally(() => {
+      signal.removeEventListener("abort", onAbort);
+    });
+  });
+}
+function object(value) {
+  return value !== null && typeof value === "object" && !Array.isArray(value) ? value : void 0;
+}
+function parseHealth(text) {
+  const status = /\n(\d{3})$/.exec(text);
+  if (!status || status[1] !== "200") {
+    throw new Error(
+      `Search capability discovery failed (HTTP ${status?.[1] ?? "unknown"}).`
+    );
+  }
+  let health;
+  try {
+    health = JSON.parse(text.slice(0, status.index));
+  } catch {
+    throw new Error("Invalid daemon health response during search discovery.");
+  }
+  const envelope = object(health);
+  const data = object(envelope?.data);
+  if (envelope?.ok !== true || data?.status !== "ok") {
+    throw new Error("Invalid daemon health response during search discovery.");
+  }
+  if (data.capabilities === void 0) return void 0;
+  const capabilities = object(data.capabilities);
+  if (!capabilities)
+    throw new Error("Invalid daemon capability advertisement.");
+  if (capabilities.searchContracts === void 0) return void 0;
+  const contracts = object(capabilities.searchContracts);
+  if (!contracts)
+    throw new Error("Invalid daemon search capability advertisement.");
+  if (contracts.pi === void 0) return void 0;
+  if (!isSearchContractCapabilities(contracts.pi)) {
+    throw new Error("Invalid Pi search capability advertisement.");
+  }
+  return contracts.pi.structured_retrieval && contracts.pi.explicit_source_marker_annotations ? 1 : void 0;
+}
+async function probe(handle, url, opts) {
+  const decoder = new TextDecoder();
+  let text = "";
+  let bytes = 0;
+  try {
+    for await (const chunk of handle.exec(
+      [
+        "curl",
+        "-sS",
+        "--connect-timeout",
+        "2",
+        "--max-time",
+        "4",
+        "--write-out",
+        "\n%{http_code}",
+        "--url",
+        url
+      ],
+      opts
+    )) {
+      bytes += chunk.byteLength;
+      if (bytes > MAX_RESPONSE_BYTES) {
+        throw new Error("Daemon capability response exceeds its size limit.");
+      }
+      text += decoder.decode(chunk, { stream: true });
+    }
+  } catch {
+    if (opts.signal?.aborted) throw opts.signal.reason ?? abortError();
+    throw new Error("Search capability discovery transport failed.");
+  }
+  text += decoder.decode();
+  return parseHealth(text.trimEnd());
+}
+async function join(flight, signal) {
+  flight.waiters += 1;
+  try {
+    return await waitForSearchDiscovery(flight.promise, signal);
+  } finally {
+    flight.waiters -= 1;
+    if (flight.waiters === 0 && !flight.settled) {
+      flight.controller.abort(abortError());
+    }
+  }
+}
+async function discoverPiSearchContract(handle, daemonUrl, opts = {}) {
+  if (opts.signal?.aborted) throw abortError();
+  const parsed = new URL(daemonUrl);
+  if (!["http:", "https:"].includes(parsed.protocol) || parsed.username || parsed.password || parsed.search || parsed.hash) {
+    throw new Error("Invalid daemon URL for search capability discovery.");
+  }
+  parsed.pathname = `${parsed.pathname.replace(/\/$/, "").replace(/\/healthz$/, "")}/healthz`;
+  const url = parsed.href;
+  const key = JSON.stringify([handle.getSandboxId(), url]);
+  let entries = cache.get(handle);
+  if (!entries) {
+    entries = /* @__PURE__ */ new Map();
+    cache.set(handle, entries);
+  }
+  const previous = entries.get(key);
+  if (previous?.flight) return join(previous.flight, opts.signal);
+  if (previous && previous.expiresAt > Date.now()) return previous.version;
+  entries.delete(key);
+  for (const [entryKey, entry2] of entries) {
+    if (!entry2.flight && entry2.expiresAt <= Date.now())
+      entries.delete(entryKey);
+  }
+  if (entries.size >= MAX_ENDPOINTS_PER_HANDLE) {
+    const evictable = [...entries].find(([, entry2]) => !entry2.flight);
+    if (!evictable)
+      throw new Error("Too many pending daemon capability probes.");
+    entries.delete(evictable[0]);
+  }
+  const controller = new AbortController();
+  const entry = { expiresAt: 0 };
+  const flight = {
+    controller,
+    promise: Promise.resolve(void 0),
+    waiters: 0,
+    settled: false
+  };
+  entry.flight = flight;
+  entries.set(key, entry);
+  const timer = setTimeout(() => {
+    controller.abort(
+      new DOMException(
+        "Search capability discovery timed out.",
+        "TimeoutError"
+      )
+    );
+  }, PROBE_TIMEOUT_MS);
+  const operation = probe(handle, url, {
+    cwd: opts.cwd ?? handle.getWorkdir(),
+    timeout: PROBE_TIMEOUT_MS,
+    signal: controller.signal
+  });
+  operation.then(
+    (version) => {
+      flight.settled = true;
+      clearTimeout(timer);
+      if (controller.signal.aborted) entries.delete(key);
+      else entries.set(key, { version, expiresAt: Date.now() + CACHE_TTL_MS });
+    },
+    () => {
+      flight.settled = true;
+      clearTimeout(timer);
+      entries.delete(key);
+    }
+  );
+  flight.promise = new Promise((resolve, reject) => {
+    const onAbort = () => reject(controller.signal.reason ?? abortError());
+    controller.signal.addEventListener("abort", onAbort, { once: true });
+    operation.then(resolve, reject).finally(() => {
+      controller.signal.removeEventListener("abort", onAbort);
+    });
+  });
+  return join(flight, opts.signal);
+}
+
 // src/provider/tool-refs.ts
 var BUNNY_PROVIDER_OPTIONS_KEY = "bunny-agent";
 function bunnyHttpTool(input) {
@@ -361,7 +564,14 @@ function readToolDynamicFlag(parsed) {
   }
   return parsed.providerExecuted === true;
 }
-var BunnyAgentLanguageModel = class {
+function mergeProviderMetadata(previous, next) {
+  const merged = { ...previous };
+  for (const [provider, fields] of Object.entries(next ?? {})) {
+    merged[provider] = { ...merged[provider], ...fields };
+  }
+  return merged;
+}
+var BunnyAgentLanguageModel = class _BunnyAgentLanguageModel {
   specificationVersion = "v3";
   provider;
   modelId;
@@ -376,6 +586,68 @@ var BunnyAgentLanguageModel = class {
   legacyTextPartCounter = 0;
   receivedFinish = false;
   activeReasoningPartId;
+  acknowledgedSearchContract;
+  /** Defense in depth: the runner already dedupes per emitted source, but a
+   * duplicate `source-url` event must never reach the UI as two source parts. */
+  emittedSourceIds = /* @__PURE__ */ new Set();
+  completedTextIds = /* @__PURE__ */ new Set();
+  completedToolIds = /* @__PURE__ */ new Set();
+  textById = /* @__PURE__ */ new Map();
+  textMetadata = /* @__PURE__ */ new Map();
+  toolMetadata = /* @__PURE__ */ new Map();
+  pendingSources = /* @__PURE__ */ new Map();
+  citedSources = /* @__PURE__ */ new Map();
+  messageMetadata = {};
+  seenMessageMetadata = /* @__PURE__ */ new Set();
+  seenStreamErrors = /* @__PURE__ */ new Set();
+  /** Merge every provider namespace while retaining negotiated request facts. */
+  partMetadata(raw, textPartId) {
+    const metadata = mergeProviderMetadata(
+      textPartId === void 0 ? void 0 : this.textMetadata.get(textPartId),
+      raw && typeof raw === "object" ? raw : void 0
+    );
+    const { searchContract: _untrustedAcknowledgement, ...bunnyMetadata } = metadata["bunny-agent"] ?? {};
+    const result = {
+      ...metadata,
+      "bunny-agent": {
+        ...this.messageMetadata,
+        ...bunnyMetadata,
+        ...this.sessionId ? { sessionId: this.sessionId } : {},
+        ...textPartId !== void 0 ? { textPartId } : {},
+        ...this.acknowledgedSearchContract ? {
+          searchContract: this.acknowledgedSearchContract
+        } : {}
+      }
+    };
+    if (textPartId !== void 0) this.textMetadata.set(textPartId, result);
+    return result;
+  }
+  toolPartMetadata(parsed) {
+    const id = parsed.toolCallId;
+    const metadata = mergeProviderMetadata(
+      this.toolMetadata.get(id),
+      this.partMetadata(parsed.providerMetadata)
+    );
+    this.toolMetadata.set(id, metadata);
+    return metadata;
+  }
+  emitCitedSource(sourceId) {
+    const source = this.pendingSources.get(sourceId);
+    const cited = this.citedSources.get(sourceId);
+    if (!source || !cited || this.emittedSourceIds.has(sourceId) || typeof source.url !== "string" || !isSafeHttpUrl(source.url) || new URL(source.url).href !== new URL(cited.url).href)
+      return [];
+    this.emittedSourceIds.add(sourceId);
+    return [
+      {
+        type: "source",
+        sourceType: "url",
+        id: sourceId,
+        url: source.url,
+        title: cited.title,
+        ...source.providerMetadata ? { providerMetadata: this.partMetadata(source.providerMetadata) } : {}
+      }
+    ];
+  }
   logUnparsedStreamLine(candidate, error) {
     const trimmed = candidate.trim();
     if (!trimmed) return;
@@ -421,13 +693,20 @@ var BunnyAgentLanguageModel = class {
         if (done) break;
         switch (value.type) {
           case "text-start": {
-            textParts.set(value.id, { text: "" });
+            textParts.set(value.id, {
+              text: "",
+              providerMetadata: value.providerMetadata
+            });
             break;
           }
           case "text-delta": {
             const part = textParts.get(value.id);
             if (part) {
               part.text += value.delta;
+              part.providerMetadata = mergeProviderMetadata(
+                part.providerMetadata,
+                value.providerMetadata
+              );
             }
             break;
           }
@@ -436,8 +715,13 @@ var BunnyAgentLanguageModel = class {
             if (part) {
               content.push({
                 type: "text",
-                text: part.text
+                text: part.text,
+                providerMetadata: mergeProviderMetadata(
+                  part.providerMetadata,
+                  value.providerMetadata
+                )
               });
+              textParts.delete(value.id);
             }
             break;
           }
@@ -477,13 +761,15 @@ var BunnyAgentLanguageModel = class {
             break;
           }
           case "tool-call": {
-            content.push({
-              type: "tool-call",
-              toolCallId: value.toolCallId,
-              toolName: value.toolName,
-              input: value.input,
-              providerExecuted: value.providerExecuted
-            });
+            content.push(value);
+            break;
+          }
+          case "tool-result": {
+            content.push(value);
+            break;
+          }
+          case "source": {
+            content.push(value);
             break;
           }
           case "stream-start": {
@@ -517,9 +803,52 @@ var BunnyAgentLanguageModel = class {
     };
   }
   async doStream(options) {
+    let invocationOptions = this.options;
+    let discoveredHandle;
+    if (this.options.searchContractVersion === "auto") {
+      if (!this.options.sandbox) {
+        throw new Error(
+          "BunnyAgent language model requires a sandbox adapter (set `sandbox` on the provider)."
+        );
+      }
+      if (options.abortSignal?.aborted) {
+        throw new DOMException(
+          "Search capability discovery aborted.",
+          "AbortError"
+        );
+      }
+      let version;
+      if (this.options.runner.runnerType === "pi" && this.options.daemonUrl) {
+        discoveredHandle = await waitForSearchDiscovery(
+          this.options.sandbox.attach(),
+          options.abortSignal
+        );
+        version = await discoverPiSearchContract(
+          discoveredHandle,
+          this.options.daemonUrl,
+          {
+            cwd: this.options.cwd,
+            signal: options.abortSignal
+          }
+        );
+      }
+      invocationOptions = {
+        ...this.options,
+        runner: { ...this.options.runner, searchContractVersion: version }
+      };
+    }
+    const invocation = new _BunnyAgentLanguageModel({
+      id: this.modelId,
+      options: invocationOptions
+    });
+    return invocation.doStreamInvocation(options, discoveredHandle);
+  }
+  async doStreamInvocation(options, discoveredHandle) {
+    if (this.requestedSearchContractVersion === 1) {
+      await assertSearchContractAiSdkSupport();
+    }
     const { prompt, abortSignal } = options;
     const messages = this.convertPromptToMessages(prompt);
-    this.resetStreamState();
     this.logger.debug(
       `[bunny-agent] Starting stream with ${messages.length} messages`
     );
@@ -533,7 +862,7 @@ var BunnyAgentLanguageModel = class {
     const toolRefs = mergeToolRefs(this.options.toolRefs, callToolRefs);
     const daemonUrl = this.options.daemonUrl;
     if (daemonUrl) {
-      const handle = await sandbox.attach();
+      const handle = discoveredHandle ?? await sandbox.attach();
       const sandboxEnv2 = sandbox.getEnv?.() ?? {};
       const runnerEnv = { ...sandboxEnv2, ...this.options.env };
       const body = {
@@ -606,12 +935,36 @@ var BunnyAgentLanguageModel = class {
       throw error;
     }
   }
-  resetStreamState() {
-    this.sessionId = void 0;
-    this.toolNameMap = /* @__PURE__ */ new Map();
-    this.legacyTextPartCounter = 0;
-    this.receivedFinish = false;
-    this.activeReasoningPartId = void 0;
+  /** The `searchContractVersion` explicitly requested for this turn, if any (never a process-global default). */
+  get requestedSearchContractVersion() {
+    return this.options.runner.searchContractVersion === 1 ? 1 : void 0;
+  }
+  /**
+   * When an explicit v1 selection was requested but the stream reached a
+   * normal finish without ever delivering a `searchContract` acknowledgement
+   * (e.g. an older daemon/CLI peer that silently ignores the field), surface
+   * a clear error instead of letting the caller believe v1 behavior is
+   * active. Never retried automatically — the caller decides whether to
+   * retry without the contract.
+   */
+  buildMissingAcknowledgementErrorParts() {
+    return [
+      {
+        type: "error",
+        error: new Error(
+          "searchContractVersion: 1 was explicitly requested but the runner/daemon never acknowledged support for it (no searchContract capability message received). The peer may be running an older release that silently ignores this option."
+        )
+      },
+      {
+        type: "finish",
+        finishReason: {
+          unified: "error",
+          raw: "search-contract-unacknowledged"
+        },
+        usage: createEmptyUsage(),
+        providerMetadata: this.partMetadata(void 0)
+      }
+    ];
   }
   /** Close the open reasoning part, if any (returns the end part to emit). */
   closeReasoningPart() {
@@ -622,6 +975,9 @@ var BunnyAgentLanguageModel = class {
   }
   /** Synthesize a terminal error+finish pair for streams that end (EOF or `[DONE]`) without ever emitting a "finish" part, so the UI shows an error instead of silently stalling. */
   buildUnexpectedEndParts() {
+    if (this.requestedSearchContractVersion === 1 && this.acknowledgedSearchContract === void 0) {
+      return this.buildMissingAcknowledgementErrorParts();
+    }
     return [
       {
         type: "error",
@@ -633,11 +989,7 @@ var BunnyAgentLanguageModel = class {
         type: "finish",
         finishReason: { unified: "error", raw: "unexpected-stream-end" },
         usage: createEmptyUsage(),
-        providerMetadata: {
-          "bunny-agent": {
-            sessionId: this.sessionId
-          }
-        }
+        providerMetadata: this.partMetadata(void 0)
       }
     ];
   }
@@ -668,7 +1020,8 @@ var BunnyAgentLanguageModel = class {
       yolo: this.options.yolo ?? (runner.runnerType === "pi" ? true : void 0),
       ...toolRefs && toolRefs.length > 0 ? { toolRefs } : {},
       ...this.options.mcpConfig ? { mcpConfig: this.options.mcpConfig } : {},
-      ...this.options.effort ? { effort: this.options.effort } : {}
+      ...this.options.effort ? { effort: this.options.effort } : {},
+      ...runner.searchContractVersion !== void 0 ? { searchContractVersion: runner.searchContractVersion } : {}
     };
   }
   buildStreamResult(bytesStream, messages, signal) {
@@ -798,8 +1151,11 @@ var BunnyAgentLanguageModel = class {
     const parts = [];
     const parsed = JSON.parse(data);
     const parsedType = typeof parsed.type === "string" ? parsed.type : void 0;
+    if (this.receivedFinish && parsedType !== "error" && !(!parsedType && typeof parsed.error === "string"))
+      return parts;
     if (!parsedType && typeof parsed.error === "string") {
-      this.receivedFinish = true;
+      if (this.seenStreamErrors.has(parsed.error)) return parts;
+      this.seenStreamErrors.add(parsed.error);
       return [
         {
           type: "error",
@@ -820,21 +1176,31 @@ var BunnyAgentLanguageModel = class {
             {
               type: "text-start",
               id,
-              providerMetadata: {
-                "bunny-agent": {
-                  sessionId: this.sessionId
-                }
-              }
+              providerMetadata: this.partMetadata(parsed.providerMetadata, id)
             },
             { type: "text-delta", id, delta: text },
-            { type: "text-end", id }
+            {
+              type: "text-end",
+              id,
+              providerMetadata: this.partMetadata(parsed.providerMetadata, id)
+            }
           );
         }
         break;
       }
       case "message-metadata": {
         const metadata = parsed.messageMetadata;
-        if (metadata?.sessionId && typeof metadata.sessionId === "string") {
+        const key = JSON.stringify(metadata);
+        if (this.seenMessageMetadata.has(key)) break;
+        this.seenMessageMetadata.add(key);
+        if (metadata && typeof metadata === "object") {
+          const { searchContract: _acknowledgement, ...fields } = metadata;
+          this.messageMetadata = {
+            ...this.messageMetadata,
+            ...fields
+          };
+        }
+        if (metadata?.sessionId && typeof metadata.sessionId === "string" && this.sessionId !== metadata.sessionId) {
           this.sessionId = metadata.sessionId;
           this.logger.debug(
             `[bunny-agent] Session ID extracted: ${this.sessionId}`
@@ -844,6 +1210,12 @@ var BunnyAgentLanguageModel = class {
             rawValue: this.sessionId
           });
         }
+        if (this.requestedSearchContractVersion === 1 && isSearchContractCapabilities(metadata?.searchContract) && this.acknowledgedSearchContract === void 0) {
+          this.acknowledgedSearchContract = metadata.searchContract;
+          this.logger.debug(
+            `[bunny-agent] Search contract acknowledged: ${JSON.stringify(this.acknowledgedSearchContract)}`
+          );
+        }
         break;
       }
       // Context compaction progress. Delivered out-of-band via the
@@ -883,30 +1255,83 @@ var BunnyAgentLanguageModel = class {
         break;
       }
       case "text-start": {
+        const id = parsed.id;
+        if (this.textById.has(id) || this.completedTextIds.has(id)) break;
+        this.textById.set(id, "");
         parts.push(...this.closeReasoningPart());
         parts.push({
           type: "text-start",
           id: parsed.id,
-          providerMetadata: {
-            "bunny-agent": {
-              sessionId: this.sessionId
-            }
-          }
+          providerMetadata: this.partMetadata(parsed.providerMetadata, id)
         });
         break;
       }
       case "text-delta": {
+        const id = parsed.id;
+        if (this.completedTextIds.has(id)) break;
+        this.textById.set(
+          id,
+          (this.textById.get(id) ?? "") + parsed.delta
+        );
         parts.push({
           type: "text-delta",
           id: parsed.id,
-          delta: parsed.delta
+          delta: parsed.delta,
+          ...parsed.providerMetadata ? {
+            providerMetadata: this.partMetadata(
+              parsed.providerMetadata,
+              id
+            )
+          } : {}
         });
         break;
       }
       case "text-end": {
+        const id = parsed.id;
+        if (this.completedTextIds.has(id)) break;
+        this.completedTextIds.add(id);
+        const rawMetadata = parsed.providerMetadata;
+        const bunnyMetadata = rawMetadata?.["bunny-agent"];
+        const contract = bunnyMetadata?.citation_contract;
+        if (this.acknowledgedSearchContract && isValidCitationContractMetadata(contract, {
+          text: this.textById.get(id) ?? ""
+        })) {
+          for (const binding of contract.bindings) {
+            const annotation = contract.annotations[binding.annotation_index];
+            this.citedSources.set(binding.source_id, {
+              url: annotation.url,
+              title: annotation.title
+            });
+            parts.push(...this.emitCitedSource(binding.source_id));
+          }
+        }
         parts.push({
           type: "text-end",
-          id: parsed.id
+          id: parsed.id,
+          providerMetadata: this.partMetadata(rawMetadata, id)
+        });
+        break;
+      }
+      // Terminal per-text citation marker bridge: one `source-url` chunk per
+      // actually cited source (never per retrieved-but-uncited result).
+      case "source-url": {
+        const sourceId = parsed.sourceId;
+        if (typeof sourceId !== "string" || typeof parsed.url !== "string" || !isSafeHttpUrl(parsed.url))
+          break;
+        if (this.requestedSearchContractVersion === 1) {
+          if (!this.pendingSources.has(sourceId))
+            this.pendingSources.set(sourceId, parsed);
+          parts.push(...this.emitCitedSource(sourceId));
+          break;
+        }
+        if (this.emittedSourceIds.has(sourceId)) break;
+        this.emittedSourceIds.add(sourceId);
+        parts.push({
+          type: "source",
+          sourceType: "url",
+          id: sourceId,
+          url: parsed.url,
+          ...typeof parsed.title === "string" ? { title: parsed.title } : {}
         });
         break;
       }
@@ -917,7 +1342,8 @@ var BunnyAgentLanguageModel = class {
           id: parsed.toolCallId,
           toolName: parsed.toolName,
           dynamic: readToolDynamicFlag(parsed),
-          providerExecuted: parsed.providerExecuted
+          providerExecuted: parsed.providerExecuted,
+          providerMetadata: this.toolPartMetadata(parsed)
         });
         break;
       }
@@ -925,7 +1351,16 @@ var BunnyAgentLanguageModel = class {
         parts.push({
           type: "tool-input-delta",
           id: parsed.toolCallId,
-          delta: parsed.inputTextDelta
+          delta: parsed.inputTextDelta,
+          providerMetadata: this.toolPartMetadata(parsed)
+        });
+        break;
+      }
+      case "tool-input-end": {
+        parts.push({
+          type: "tool-input-end",
+          id: parsed.toolCallId,
+          providerMetadata: this.toolPartMetadata(parsed)
         });
         break;
       }
@@ -940,11 +1375,14 @@ var BunnyAgentLanguageModel = class {
           toolName,
           input: JSON.stringify(input),
           dynamic: readToolDynamicFlag(parsed),
-          providerExecuted: parsed.providerExecuted
+          providerExecuted: parsed.providerExecuted,
+          providerMetadata: this.toolPartMetadata(parsed)
         });
         break;
       }
       case "tool-output-available": {
+        if (this.completedToolIds.has(parsed.toolCallId)) break;
+        this.completedToolIds.add(parsed.toolCallId);
         const toolName = this.toolNameMap.get(parsed.toolCallId);
         parts.push({
           type: "tool-result",
@@ -952,11 +1390,14 @@ var BunnyAgentLanguageModel = class {
           toolName: toolName ?? "",
           result: parsed.output,
           isError: parsed.isError,
-          dynamic: readToolDynamicFlag(parsed)
+          dynamic: readToolDynamicFlag(parsed),
+          providerMetadata: this.toolPartMetadata(parsed)
         });
         break;
       }
       case "tool-output-error": {
+        if (this.completedToolIds.has(parsed.toolCallId)) break;
+        this.completedToolIds.add(parsed.toolCallId);
         const toolName = this.toolNameMap.get(parsed.toolCallId);
         parts.push({
           type: "tool-result",
@@ -964,17 +1405,18 @@ var BunnyAgentLanguageModel = class {
           toolName: toolName ?? "",
           result: parsed.errorText ?? "Tool execution failed",
           isError: true,
-          dynamic: readToolDynamicFlag(parsed)
+          dynamic: readToolDynamicFlag(parsed),
+          providerMetadata: this.toolPartMetadata(parsed)
         });
         break;
       }
       case "error": {
-        this.receivedFinish = true;
+        const message = parsed.errorText || parsed.error || "Unknown stream error";
+        if (this.seenStreamErrors.has(message)) break;
+        this.seenStreamErrors.add(message);
         parts.push({
           type: "error",
-          error: new Error(
-            parsed.errorText || parsed.error || "Unknown stream error"
-          )
+          error: new Error(message)
         });
         break;
       }
@@ -988,6 +1430,10 @@ var BunnyAgentLanguageModel = class {
         } else {
           finishReason = this.mapFinishReason(rawFinishReason);
         }
+        if (this.requestedSearchContractVersion === 1 && this.acknowledgedSearchContract === void 0 && finishReason.unified !== "error") {
+          parts.push(...this.buildMissingAcknowledgementErrorParts());
+          break;
+        }
         const usage = normalizeBunnyAgentUsage(
           parsed.messageMetadata ?? void 0
         ) ?? createEmptyUsage();
@@ -995,12 +1441,14 @@ var BunnyAgentLanguageModel = class {
           type: "finish",
           finishReason,
           usage,
-          providerMetadata: {
-            "bunny-agent": {
-              ...parsed.messageMetadata ?? {},
-              sessionId: this.sessionId
-            }
-          }
+          providerMetadata: this.partMetadata(
+            mergeProviderMetadata(
+              parsed.providerMetadata,
+              {
+                "bunny-agent": parsed.messageMetadata ?? {}
+              }
+            )
+          )
         });
         break;
       }
@@ -1096,27 +1544,31 @@ function createBunnyAgent(defaultOptions) {
   const logger = getProviderLogger(defaultOptions);
   if (!defaultOptions.sandbox) {
     throw new Error(
-      "Provide a `sandbox` adapter (e.g. E2BSandbox, LocalMachine). Optional `daemonUrl` uses in-sandbox HTTP to bunny-agent-daemon (no automatic `/healthz` probe). Use `isBunnyAgentDaemonHealthy` from `@bunny-agent/sdk` if you want to probe and omit `daemonUrl` for CLI fallback. Omit `daemonUrl` to always use CLI."
+      "Provide a `sandbox` adapter (e.g. E2BSandbox, LocalMachine). Optional `daemonUrl` uses in-sandbox HTTP to bunny-agent-daemon (no automatic `/healthz` probe unless searchContractVersion is `auto`). Use `isBunnyAgentDaemonHealthy` from `@bunny-agent/sdk` if you want to probe and omit `daemonUrl` for CLI fallback. Omit `daemonUrl` to always use CLI."
     );
   }
   const createModel = (modelId, options = {}) => {
     const mergedSkillPaths = options.skillPaths !== void 0 ? options.skillPaths : defaultOptions.skillPaths;
     const mergedAllowedTools = options.allowedTools !== void 0 ? options.allowedTools : defaultOptions.allowedTools;
+    const searchContractVersion = options.searchContractVersion ?? defaultOptions.searchContractVersion;
     const runner = {
       model: modelId,
       runnerType: options.runnerType ?? defaultOptions.runnerType,
       outputFormat: "stream",
       maxTurns: options.maxTurns ?? defaultOptions.maxTurns,
+      ...(options.yolo ?? defaultOptions.yolo) !== void 0 ? { yolo: options.yolo ?? defaultOptions.yolo } : {},
       ...options.systemPrompt ?? defaultOptions.systemPrompt ? { systemPrompt: options.systemPrompt ?? defaultOptions.systemPrompt } : {},
       ...mergedSkillPaths && mergedSkillPaths.length > 0 ? { skillPaths: mergedSkillPaths } : {},
       ...mergedAllowedTools !== void 0 ? { allowedTools: mergedAllowedTools } : {},
       ...options.effort ?? defaultOptions.effort ? {
         effort: options.effort ?? defaultOptions.effort
-      } : {}
+      } : {},
+      ...searchContractVersion === 1 ? { searchContractVersion: 1 } : {}
     };
     const mergedOptions = {
       ...defaultOptions,
       ...options,
+      searchContractVersion,
       runner,
       env: {
         ...defaultOptions.env,