@youdotcom-oss/ai-sdk-plugin 1.0.0 → 1.0.1

package/dist/main.d.ts

@@ -137,10 +137,17 @@ export declare const youExpress: (config?: YouToolsConfig) => import("ai").Tool<
  */
 export declare const youContents: (config?: YouToolsConfig) => import("ai").Tool<{
     urls: string[];
-    format: "markdown" | "html";
+    formats?: ("markdown" | "html" | "metadata")[] | undefined;
+    format?: "markdown" | "html" | undefined;
+    crawl_timeout?: number | undefined;
 }, {
     url: string;
     title?: string | undefined;
     html?: string | undefined;
     markdown?: string | undefined;
+    metadata?: {
+        jsonld?: Record<string, unknown>[] | undefined;
+        opengraph?: Record<string, string> | undefined;
+        twitter?: Record<string, string> | undefined;
+    } | undefined;
 }[]>;

package/dist/main.js

@@ -9,7 +9,7 @@ var __export = (target, all) => {
     });
 };
 
-// ../../node_modules/.bun/zod@4.2.0/node_modules/zod/v4/core/core.js
+// ../../node_modules/.bun/zod@4.3.6/node_modules/zod/v4/core/core.js
 var NEVER = Object.freeze({
   status: "aborted"
 });
@@ -85,7 +85,7 @@ function config(newConfig) {
     Object.assign(globalConfig, newConfig);
   return globalConfig;
 }
-// ../../node_modules/.bun/zod@4.2.0/node_modules/zod/v4/core/util.js
+// ../../node_modules/.bun/zod@4.3.6/node_modules/zod/v4/core/util.js
 var exports_util = {};
 __export(exports_util, {
   unwrapMessage: () => unwrapMessage,
@@ -104,6 +104,7 @@ __export(exports_util, {
   prefixIssues: () => prefixIssues,
   pick: () => pick,
   partial: () => partial,
+  parsedType: () => parsedType,
   optionalKeys: () => optionalKeys,
   omit: () => omit,
   objectClone: () => objectClone,
@@ -461,6 +462,11 @@ var BIGINT_FORMAT_RANGES = {
 };
 function pick(schema, mask) {
   const currDef = schema._zod.def;
+  const checks = currDef.checks;
+  const hasChecks = checks && checks.length > 0;
+  if (hasChecks) {
+    throw new Error(".pick() cannot be used on object schemas containing refinements");
+  }
   const def = mergeDefs(schema._zod.def, {
     get shape() {
       const newShape = {};
@@ -481,6 +487,11 @@ function pick(schema, mask) {
 }
 function omit(schema, mask) {
   const currDef = schema._zod.def;
+  const checks = currDef.checks;
+  const hasChecks = checks && checks.length > 0;
+  if (hasChecks) {
+    throw new Error(".omit() cannot be used on object schemas containing refinements");
+  }
   const def = mergeDefs(schema._zod.def, {
     get shape() {
       const newShape = { ...schema._zod.def.shape };
@@ -506,15 +517,19 @@ function extend(schema, shape) {
   const checks = schema._zod.def.checks;
   const hasChecks = checks && checks.length > 0;
   if (hasChecks) {
-    throw new Error("Object schemas containing refinements cannot be extended. Use `.safeExtend()` instead.");
+    const existingShape = schema._zod.def.shape;
+    for (const key in shape) {
+      if (Object.getOwnPropertyDescriptor(existingShape, key) !== undefined) {
+        throw new Error("Cannot overwrite keys on object schemas containing refinements. Use `.safeExtend()` instead.");
+      }
+    }
   }
   const def = mergeDefs(schema._zod.def, {
     get shape() {
       const _shape = { ...schema._zod.def.shape, ...shape };
       assignProp(this, "shape", _shape);
       return _shape;
-    },
-    checks: []
+    }
   });
   return clone(schema, def);
 }
@@ -522,15 +537,13 @@ function safeExtend(schema, shape) {
   if (!isPlainObject(shape)) {
     throw new Error("Invalid input to safeExtend: expected a plain object");
   }
-  const def = {
-    ...schema._zod.def,
+  const def = mergeDefs(schema._zod.def, {
     get shape() {
       const _shape = { ...schema._zod.def.shape, ...shape };
       assignProp(this, "shape", _shape);
       return _shape;
-    },
-    checks: schema._zod.def.checks
-  };
+    }
+  });
   return clone(schema, def);
 }
 function merge(a, b) {
@@ -548,6 +561,12 @@ function merge(a, b) {
   return clone(a, def);
 }
 function partial(Class, schema, mask) {
+  const currDef = schema._zod.def;
+  const checks = currDef.checks;
+  const hasChecks = checks && checks.length > 0;
+  if (hasChecks) {
+    throw new Error(".partial() cannot be used on object schemas containing refinements");
+  }
   const def = mergeDefs(schema._zod.def, {
     get shape() {
       const oldShape = schema._zod.def.shape;
@@ -606,8 +625,7 @@ function required(Class, schema, mask) {
       }
       assignProp(this, "shape", shape);
       return shape;
-    },
-    checks: []
+    }
   });
   return clone(schema, def);
 }
@@ -661,6 +679,27 @@ function getLengthableOrigin(input) {
     return "string";
   return "unknown";
 }
+function parsedType(data) {
+  const t = typeof data;
+  switch (t) {
+    case "number": {
+      return Number.isNaN(data) ? "nan" : "number";
+    }
+    case "object": {
+      if (data === null) {
+        return "null";
+      }
+      if (Array.isArray(data)) {
+        return "array";
+      }
+      const obj = data;
+      if (obj && Object.getPrototypeOf(obj) !== Object.prototype && "constructor" in obj && obj.constructor) {
+        return obj.constructor.name;
+      }
+    }
+  }
+  return t;
+}
 function issue(...args) {
   const [iss, input, inst] = args;
   if (typeof iss === "string") {
@@ -720,7 +759,7 @@ class Class {
   constructor(..._args) {}
 }
 
-// ../../node_modules/.bun/zod@4.2.0/node_modules/zod/v4/core/errors.js
+// ../../node_modules/.bun/zod@4.3.6/node_modules/zod/v4/core/errors.js
 var initializer = (inst, def) => {
   inst.name = "$ZodError";
   Object.defineProperty(inst, "_zod", {
@@ -786,7 +825,7 @@ function formatError(error, mapper = (issue2) => issue2.message) {
   return fieldErrors;
 }
 
-// ../../node_modules/.bun/zod@4.2.0/node_modules/zod/v4/core/parse.js
+// ../../node_modules/.bun/zod@4.3.6/node_modules/zod/v4/core/parse.js
 var _parse = (_Err) => (schema, value, _ctx, _params) => {
   const ctx = _ctx ? Object.assign(_ctx, { async: false }) : { async: false };
   const result = schema._zod.run({ value, issues: [] }, ctx);
@@ -863,7 +902,7 @@ var _safeEncodeAsync = (_Err) => async (schema, value, _ctx) => {
 var _safeDecodeAsync = (_Err) => async (schema, value, _ctx) => {
   return _safeParseAsync(_Err)(schema, value, _ctx);
 };
-// ../../node_modules/.bun/zod@4.2.0/node_modules/zod/v4/core/regexes.js
+// ../../node_modules/.bun/zod@4.3.6/node_modules/zod/v4/core/regexes.js
 var cuid = /^[cC][^\s-]{8,}$/;
 var cuid2 = /^[0-9a-z]+$/;
 var ulid = /^[0-9A-HJKMNP-TV-Za-hjkmnp-tv-z]{26}$/;
@@ -888,7 +927,7 @@ var cidrv4 = /^((25[0-5]|2[0-4][0-9]|1[0-9][0-9]|[1-9][0-9]|[0-9])\.){3}(25[0-5]
 var cidrv6 = /^(([0-9a-fA-F]{1,4}:){7}[0-9a-fA-F]{1,4}|::|([0-9a-fA-F]{1,4})?::([0-9a-fA-F]{1,4}:?){0,6})\/(12[0-8]|1[01][0-9]|[1-9]?[0-9])$/;
 var base64 = /^$|^(?:[0-9a-zA-Z+/]{4})*(?:(?:[0-9a-zA-Z+/]{2}==)|(?:[0-9a-zA-Z+/]{3}=))?$/;
 var base64url = /^[A-Za-z0-9_-]*$/;
-var e164 = /^\+(?:[0-9]){6,14}[0-9]$/;
+var e164 = /^\+[1-9]\d{6,14}$/;
 var dateSource = `(?:(?:\\d\\d[2468][048]|\\d\\d[13579][26]|\\d\\d0[48]|[02468][048]00|[13579][26]00)-02-29|\\d{4}-(?:(?:0[13578]|1[02])-(?:0[1-9]|[12]\\d|3[01])|(?:0[469]|11)-(?:0[1-9]|[12]\\d|30)|(?:02)-(?:0[1-9]|1\\d|2[0-8])))`;
 var date = /* @__PURE__ */ new RegExp(`^${dateSource}$`);
 function timeSource(args) {
@@ -914,12 +953,12 @@ var string = (params) => {
   return new RegExp(`^${regex}$`);
 };
 var integer = /^-?\d+$/;
-var number = /^-?\d+(?:\.\d+)?/;
+var number = /^-?\d+(?:\.\d+)?$/;
 var boolean = /^(?:true|false)$/i;
 var lowercase = /^[^A-Z]*$/;
 var uppercase = /^[^a-z]*$/;
 
-// ../../node_modules/.bun/zod@4.2.0/node_modules/zod/v4/core/checks.js
+// ../../node_modules/.bun/zod@4.3.6/node_modules/zod/v4/core/checks.js
 var $ZodCheck = /* @__PURE__ */ $constructor("$ZodCheck", (inst, def) => {
   var _a;
   inst._zod ?? (inst._zod = {});
@@ -951,7 +990,7 @@ var $ZodCheckLessThan = /* @__PURE__ */ $constructor("$ZodCheckLessThan", (inst,
     payload.issues.push({
       origin,
       code: "too_big",
-      maximum: def.value,
+      maximum: typeof def.value === "object" ? def.value.getTime() : def.value,
       input: payload.value,
       inclusive: def.inclusive,
       inst,
@@ -979,7 +1018,7 @@ var $ZodCheckGreaterThan = /* @__PURE__ */ $constructor("$ZodCheckGreaterThan",
     payload.issues.push({
       origin,
       code: "too_small",
-      minimum: def.value,
+      minimum: typeof def.value === "object" ? def.value.getTime() : def.value,
       input: payload.value,
       inclusive: def.inclusive,
       inst,
@@ -1046,6 +1085,7 @@ var $ZodCheckNumberFormat = /* @__PURE__ */ $constructor("$ZodCheckNumberFormat"
             note: "Integers must be within the safe integer range.",
             inst,
             origin,
+            inclusive: true,
             continue: !def.abort
           });
         } else {
@@ -1056,6 +1096,7 @@ var $ZodCheckNumberFormat = /* @__PURE__ */ $constructor("$ZodCheckNumberFormat"
             note: "Integers must be within the safe integer range.",
             inst,
             origin,
+            inclusive: true,
             continue: !def.abort
           });
         }
@@ -1079,7 +1120,9 @@ var $ZodCheckNumberFormat = /* @__PURE__ */ $constructor("$ZodCheckNumberFormat"
         input,
         code: "too_big",
         maximum,
-        inst
+        inclusive: true,
+        inst,
+        continue: !def.abort
       });
     }
   };
@@ -1304,7 +1347,7 @@ var $ZodCheckOverwrite = /* @__PURE__ */ $constructor("$ZodCheckOverwrite", (ins
   };
 });
 
-// ../../node_modules/.bun/zod@4.2.0/node_modules/zod/v4/core/doc.js
+// ../../node_modules/.bun/zod@4.3.6/node_modules/zod/v4/core/doc.js
 class Doc {
   constructor(args = []) {
     this.content = [];
@@ -1342,14 +1385,14 @@ class Doc {
   }
 }
 
-// ../../node_modules/.bun/zod@4.2.0/node_modules/zod/v4/core/versions.js
+// ../../node_modules/.bun/zod@4.3.6/node_modules/zod/v4/core/versions.js
 var version = {
   major: 4,
-  minor: 2,
-  patch: 0
+  minor: 3,
+  patch: 6
 };
 
-// ../../node_modules/.bun/zod@4.2.0/node_modules/zod/v4/core/schemas.js
+// ../../node_modules/.bun/zod@4.3.6/node_modules/zod/v4/core/schemas.js
 var $ZodType = /* @__PURE__ */ $constructor("$ZodType", (inst, def) => {
   var _a;
   inst ?? (inst = {});
@@ -1446,7 +1489,7 @@ var $ZodType = /* @__PURE__ */ $constructor("$ZodType", (inst, def) => {
       return runChecks(result, checks, ctx);
     };
   }
-  inst["~standard"] = {
+  defineLazy(inst, "~standard", () => ({
     validate: (value) => {
       try {
         const r = safeParse(inst, value);
@@ -1457,7 +1500,7 @@ var $ZodType = /* @__PURE__ */ $constructor("$ZodType", (inst, def) => {
     },
     vendor: "zod",
     version: 1
-  };
+  }));
 });
 var $ZodString = /* @__PURE__ */ $constructor("$ZodString", (inst, def) => {
   $ZodType.init(inst, def);
@@ -1855,8 +1898,11 @@ var $ZodArray = /* @__PURE__ */ $constructor("$ZodArray", (inst, def) => {
     return payload;
   };
 });
-function handlePropertyResult(result, final, key, input) {
+function handlePropertyResult(result, final, key, input, isOptionalOut) {
   if (result.issues.length) {
+    if (isOptionalOut && !(key in input)) {
+      return;
+    }
     final.issues.push(...prefixIssues(key, result.issues));
   }
   if (result.value === undefined) {
@@ -1888,6 +1934,7 @@ function handleCatchall(proms, input, payload, ctx, def, inst) {
   const keySet = def.keySet;
   const _catchall = def.catchall._zod;
   const t = _catchall.def.type;
+  const isOptionalOut = _catchall.optout === "optional";
   for (const key in input) {
     if (keySet.has(key))
       continue;
@@ -1897,9 +1944,9 @@ function handleCatchall(proms, input, payload, ctx, def, inst) {
     }
     const r = _catchall.run({ value: input[key], issues: [] }, ctx);
     if (r instanceof Promise) {
-      proms.push(r.then((r2) => handlePropertyResult(r2, payload, key, input)));
+      proms.push(r.then((r2) => handlePropertyResult(r2, payload, key, input, isOptionalOut)));
     } else {
-      handlePropertyResult(r, payload, key, input);
+      handlePropertyResult(r, payload, key, input, isOptionalOut);
     }
   }
   if (unrecognized.length) {
@@ -1965,11 +2012,12 @@ var $ZodObject = /* @__PURE__ */ $constructor("$ZodObject", (inst, def) => {
     const shape = value.shape;
     for (const key of value.keys) {
       const el = shape[key];
+      const isOptionalOut = el._zod.optout === "optional";
       const r = el._zod.run({ value: input[key], issues: [] }, ctx);
       if (r instanceof Promise) {
-        proms.push(r.then((r2) => handlePropertyResult(r2, payload, key, input)));
+        proms.push(r.then((r2) => handlePropertyResult(r2, payload, key, input, isOptionalOut)));
       } else {
-        handlePropertyResult(r, payload, key, input);
+        handlePropertyResult(r, payload, key, input, isOptionalOut);
       }
     }
     if (!catchall) {
@@ -1999,8 +2047,31 @@ var $ZodObjectJIT = /* @__PURE__ */ $constructor("$ZodObjectJIT", (inst, def) =>
     for (const key of normalized.keys) {
       const id = ids[key];
       const k = esc(key);
+      const schema = shape[key];
+      const isOptionalOut = schema?._zod?.optout === "optional";
       doc.write(`const ${id} = ${parseStr(key)};`);
-      doc.write(`
+      if (isOptionalOut) {
+        doc.write(`
+        if (${id}.issues.length) {
+          if (${k} in input) {
+            payload.issues = payload.issues.concat(${id}.issues.map(iss => ({
+              ...iss,
+              path: iss.path ? [${k}, ...iss.path] : [${k}]
+            })));
+          }
+        }
+        
+        if (${id}.value === undefined) {
+          if (${k} in input) {
+            newResult[${k}] = undefined;
+          }
+        } else {
+          newResult[${k}] = ${id}.value;
+        }
+        
+      `);
+      } else {
+        doc.write(`
         if (${id}.issues.length) {
           payload.issues = payload.issues.concat(${id}.issues.map(iss => ({
             ...iss,
@@ -2008,7 +2079,6 @@ var $ZodObjectJIT = /* @__PURE__ */ $constructor("$ZodObjectJIT", (inst, def) =>
           })));
         }
         
-        
         if (${id}.value === undefined) {
           if (${k} in input) {
             newResult[${k}] = undefined;
@@ -2018,6 +2088,7 @@ var $ZodObjectJIT = /* @__PURE__ */ $constructor("$ZodObjectJIT", (inst, def) =>
         }
         
       `);
+      }
     }
     doc.write(`payload.value = newResult;`);
     doc.write(`return payload;`);
@@ -2180,11 +2251,34 @@ function mergeValues(a, b) {
   return { valid: false, mergeErrorPath: [] };
 }
 function handleIntersectionResults(result, left, right) {
-  if (left.issues.length) {
-    result.issues.push(...left.issues);
+  const unrecKeys = new Map;
+  let unrecIssue;
+  for (const iss of left.issues) {
+    if (iss.code === "unrecognized_keys") {
+      unrecIssue ?? (unrecIssue = iss);
+      for (const k of iss.keys) {
+        if (!unrecKeys.has(k))
+          unrecKeys.set(k, {});
+        unrecKeys.get(k).l = true;
+      }
+    } else {
+      result.issues.push(iss);
+    }
+  }
+  for (const iss of right.issues) {
+    if (iss.code === "unrecognized_keys") {
+      for (const k of iss.keys) {
+        if (!unrecKeys.has(k))
+          unrecKeys.set(k, {});
+        unrecKeys.get(k).r = true;
+      }
+    } else {
+      result.issues.push(iss);
+    }
   }
-  if (right.issues.length) {
-    result.issues.push(...right.issues);
+  const bothKeys = [...unrecKeys].filter(([, f]) => f.l && f.r).map(([k]) => k);
+  if (bothKeys.length && unrecIssue) {
+    result.issues.push({ ...unrecIssue, keys: bothKeys });
   }
   if (aborted(result))
     return result;
@@ -2195,6 +2289,114 @@ function handleIntersectionResults(result, left, right) {
   result.value = merged.data;
   return result;
 }
+var $ZodRecord = /* @__PURE__ */ $constructor("$ZodRecord", (inst, def) => {
+  $ZodType.init(inst, def);
+  inst._zod.parse = (payload, ctx) => {
+    const input = payload.value;
+    if (!isPlainObject(input)) {
+      payload.issues.push({
+        expected: "record",
+        code: "invalid_type",
+        input,
+        inst
+      });
+      return payload;
+    }
+    const proms = [];
+    const values = def.keyType._zod.values;
+    if (values) {
+      payload.value = {};
+      const recordKeys = new Set;
+      for (const key of values) {
+        if (typeof key === "string" || typeof key === "number" || typeof key === "symbol") {
+          recordKeys.add(typeof key === "number" ? key.toString() : key);
+          const result = def.valueType._zod.run({ value: input[key], issues: [] }, ctx);
+          if (result instanceof Promise) {
+            proms.push(result.then((result2) => {
+              if (result2.issues.length) {
+                payload.issues.push(...prefixIssues(key, result2.issues));
+              }
+              payload.value[key] = result2.value;
+            }));
+          } else {
+            if (result.issues.length) {
+              payload.issues.push(...prefixIssues(key, result.issues));
+            }
+            payload.value[key] = result.value;
+          }
+        }
+      }
+      let unrecognized;
+      for (const key in input) {
+        if (!recordKeys.has(key)) {
+          unrecognized = unrecognized ?? [];
+          unrecognized.push(key);
+        }
+      }
+      if (unrecognized && unrecognized.length > 0) {
+        payload.issues.push({
+          code: "unrecognized_keys",
+          input,
+          inst,
+          keys: unrecognized
+        });
+      }
+    } else {
+      payload.value = {};
+      for (const key of Reflect.ownKeys(input)) {
+        if (key === "__proto__")
+          continue;
+        let keyResult = def.keyType._zod.run({ value: key, issues: [] }, ctx);
+        if (keyResult instanceof Promise) {
+          throw new Error("Async schemas not supported in object keys currently");
+        }
+        const checkNumericKey = typeof key === "string" && number.test(key) && keyResult.issues.length;
+        if (checkNumericKey) {
+          const retryResult = def.keyType._zod.run({ value: Number(key), issues: [] }, ctx);
+          if (retryResult instanceof Promise) {
+            throw new Error("Async schemas not supported in object keys currently");
+          }
+          if (retryResult.issues.length === 0) {
+            keyResult = retryResult;
+          }
+        }
+        if (keyResult.issues.length) {
+          if (def.mode === "loose") {
+            payload.value[key] = input[key];
+          } else {
+            payload.issues.push({
+              code: "invalid_key",
+              origin: "record",
+              issues: keyResult.issues.map((iss) => finalizeIssue(iss, ctx, config())),
+              input: key,
+              path: [key],
+              inst
+            });
+          }
+          continue;
+        }
+        const result = def.valueType._zod.run({ value: input[key], issues: [] }, ctx);
+        if (result instanceof Promise) {
+          proms.push(result.then((result2) => {
+            if (result2.issues.length) {
+              payload.issues.push(...prefixIssues(key, result2.issues));
+            }
+            payload.value[keyResult.value] = result2.value;
+          }));
+        } else {
+          if (result.issues.length) {
+            payload.issues.push(...prefixIssues(key, result.issues));
+          }
+          payload.value[keyResult.value] = result.value;
+        }
+      }
+    }
+    if (proms.length) {
+      return Promise.all(proms).then(() => payload);
+    }
+    return payload;
+  };
+});
 var $ZodEnum = /* @__PURE__ */ $constructor("$ZodEnum", (inst, def) => {
   $ZodType.init(inst, def);
   const values = getEnumValues(def.entries);
@@ -2288,6 +2490,14 @@ var $ZodOptional = /* @__PURE__ */ $constructor("$ZodOptional", (inst, def) => {
     return def.innerType._zod.run(payload, ctx);
   };
 });
+var $ZodExactOptional = /* @__PURE__ */ $constructor("$ZodExactOptional", (inst, def) => {
+  $ZodOptional.init(inst, def);
+  defineLazy(inst._zod, "values", () => def.innerType._zod.values);
+  defineLazy(inst._zod, "pattern", () => def.innerType._zod.pattern);
+  inst._zod.parse = (payload, ctx) => {
+    return def.innerType._zod.run(payload, ctx);
+  };
+});
 var $ZodNullable = /* @__PURE__ */ $constructor("$ZodNullable", (inst, def) => {
   $ZodType.init(inst, def);
   defineLazy(inst._zod, "optin", () => def.innerType._zod.optin);
@@ -2488,7 +2698,7 @@ function handleRefineResult(result, payload, input, inst) {
     payload.issues.push(issue(_iss));
   }
 }
-// ../../node_modules/.bun/zod@4.2.0/node_modules/zod/v4/core/registries.js
+// ../../node_modules/.bun/zod@4.3.6/node_modules/zod/v4/core/registries.js
 var _a;
 var $output = Symbol("ZodOutput");
 var $input = Symbol("ZodInput");
@@ -2502,9 +2712,6 @@ class $ZodRegistry {
     const meta = _meta[0];
     this._map.set(schema, meta);
     if (meta && typeof meta === "object" && "id" in meta) {
-      if (this._idmap.has(meta.id)) {
-        throw new Error(`ID ${meta.id} already exists in the registry`);
-      }
       this._idmap.set(meta.id, schema);
     }
     return this;
@@ -2541,7 +2748,7 @@ function registry() {
 }
 (_a = globalThis).__zod_globalRegistry ?? (_a.__zod_globalRegistry = registry());
 var globalRegistry = globalThis.__zod_globalRegistry;
-// ../../node_modules/.bun/zod@4.2.0/node_modules/zod/v4/core/api.js
+// ../../node_modules/.bun/zod@4.3.6/node_modules/zod/v4/core/api.js
 function _string(Class2, params) {
   return new Class2({
     type: "string",
@@ -2995,7 +3202,7 @@ function _check(fn, params) {
   ch._zod.check = fn;
   return ch;
 }
-// ../../node_modules/.bun/zod@4.2.0/node_modules/zod/v4/core/to-json-schema.js
+// ../../node_modules/.bun/zod@4.3.6/node_modules/zod/v4/core/to-json-schema.js
 function initializeContext(params) {
   let target = params?.target ?? "draft-2020-12";
   if (target === "draft-4")
@@ -3039,12 +3246,7 @@ function process2(schema, ctx, _params = { path: [], schemaPath: [] }) {
       schemaPath: [..._params.schemaPath, schema],
       path: _params.path
     };
-    const parent = schema._zod.parent;
-    if (parent) {
-      result.ref = parent;
-      process2(parent, ctx, params);
-      ctx.seen.get(parent).isParent = true;
-    } else if (schema._zod.processJSONSchema) {
+    if (schema._zod.processJSONSchema) {
       schema._zod.processJSONSchema(ctx, result.schema, params);
     } else {
       const _json = result.schema;
@@ -3054,6 +3256,13 @@ function process2(schema, ctx, _params = { path: [], schemaPath: [] }) {
       }
       processor(schema, ctx, _json, params);
     }
+    const parent = schema._zod.parent;
+    if (parent) {
+      if (!result.ref)
+        result.ref = parent;
+      process2(parent, ctx, params);
+      ctx.seen.get(parent).isParent = true;
+    }
   }
   const meta = ctx.metadataRegistry.get(schema);
   if (meta)
@@ -3072,6 +3281,17 @@ function extractDefs(ctx, schema) {
   const root = ctx.seen.get(schema);
   if (!root)
     throw new Error("Unprocessed schema. This is a bug in Zod.");
+  const idToSchema = new Map;
+  for (const entry of ctx.seen.entries()) {
+    const id = ctx.metadataRegistry.get(entry[0])?.id;
+    if (id) {
+      const existing = idToSchema.get(id);
+      if (existing && existing !== entry[0]) {
+        throw new Error(`Duplicate schema id "${id}" detected during JSON Schema conversion. Two different schemas cannot share the same id when converted together.`);
+      }
+      idToSchema.set(id, entry[0]);
+    }
+  }
   const makeURI = (entry) => {
     const defsSegment = ctx.target === "draft-2020-12" ? "$defs" : "definitions";
     if (ctx.external) {
@@ -3151,30 +3371,65 @@ function finalize(ctx, schema) {
     throw new Error("Unprocessed schema. This is a bug in Zod.");
   const flattenRef = (zodSchema) => {
     const seen = ctx.seen.get(zodSchema);
+    if (seen.ref === null)
+      return;
     const schema2 = seen.def ?? seen.schema;
     const _cached = { ...schema2 };
-    if (seen.ref === null) {
-      return;
-    }
     const ref = seen.ref;
     seen.ref = null;
     if (ref) {
       flattenRef(ref);
-      const refSchema = ctx.seen.get(ref).schema;
+      const refSeen = ctx.seen.get(ref);
+      const refSchema = refSeen.schema;
       if (refSchema.$ref && (ctx.target === "draft-07" || ctx.target === "draft-04" || ctx.target === "openapi-3.0")) {
         schema2.allOf = schema2.allOf ?? [];
         schema2.allOf.push(refSchema);
       } else {
         Object.assign(schema2, refSchema);
-        Object.assign(schema2, _cached);
+      }
+      Object.assign(schema2, _cached);
+      const isParentRef = zodSchema._zod.parent === ref;
+      if (isParentRef) {
+        for (const key in schema2) {
+          if (key === "$ref" || key === "allOf")
+            continue;
+          if (!(key in _cached)) {
+            delete schema2[key];
+          }
+        }
+      }
+      if (refSchema.$ref && refSeen.def) {
+        for (const key in schema2) {
+          if (key === "$ref" || key === "allOf")
+            continue;
+          if (key in refSeen.def && JSON.stringify(schema2[key]) === JSON.stringify(refSeen.def[key])) {
+            delete schema2[key];
+          }
+        }
       }
     }
-    if (!seen.isParent)
-      ctx.override({
-        zodSchema,
-        jsonSchema: schema2,
-        path: seen.path ?? []
-      });
+    const parent = zodSchema._zod.parent;
+    if (parent && parent !== ref) {
+      flattenRef(parent);
+      const parentSeen = ctx.seen.get(parent);
+      if (parentSeen?.schema.$ref) {
+        schema2.$ref = parentSeen.schema.$ref;
+        if (parentSeen.def) {
+          for (const key in schema2) {
+            if (key === "$ref" || key === "allOf")
+              continue;
+            if (key in parentSeen.def && JSON.stringify(schema2[key]) === JSON.stringify(parentSeen.def[key])) {
+              delete schema2[key];
+            }
+          }
+        }
+      }
+    }
+    ctx.override({
+      zodSchema,
+      jsonSchema: schema2,
+      path: seen.path ?? []
+    });
   };
   for (const entry of [...ctx.seen.entries()].reverse()) {
     flattenRef(entry[0]);
@@ -3216,8 +3471,8 @@ function finalize(ctx, schema) {
       value: {
         ...schema["~standard"],
         jsonSchema: {
-          input: createStandardJSONSchemaMethod(schema, "input"),
-          output: createStandardJSONSchemaMethod(schema, "output")
+          input: createStandardJSONSchemaMethod(schema, "input", ctx.processors),
+          output: createStandardJSONSchemaMethod(schema, "output", ctx.processors)
         }
       },
       enumerable: false,
@@ -3285,14 +3540,14 @@ var createToJSONSchemaMethod = (schema, processors = {}) => (params) => {
   extractDefs(ctx, schema);
   return finalize(ctx, schema);
 };
-var createStandardJSONSchemaMethod = (schema, io) => (params) => {
+var createStandardJSONSchemaMethod = (schema, io, processors = {}) => (params) => {
   const { libraryOptions, target } = params ?? {};
-  const ctx = initializeContext({ ...libraryOptions ?? {}, target, io, processors: {} });
+  const ctx = initializeContext({ ...libraryOptions ?? {}, target, io, processors });
   process2(schema, ctx);
   extractDefs(ctx, schema);
   return finalize(ctx, schema);
 };
-// ../../node_modules/.bun/zod@4.2.0/node_modules/zod/v4/core/json-schema-processors.js
+// ../../node_modules/.bun/zod@4.3.6/node_modules/zod/v4/core/json-schema-processors.js
 var formatMap = {
   guid: "uuid",
   url: "uri",
@@ -3312,6 +3567,9 @@ var stringProcessor = (schema, ctx, _json, _params) => {
     json.format = formatMap[format] ?? format;
     if (json.format === "")
       delete json.format;
+    if (format === "time") {
+      delete json.format;
+    }
   }
   if (contentEncoding)
     json.contentEncoding = contentEncoding;
@@ -3515,6 +3773,42 @@ var intersectionProcessor = (schema, ctx, json, params) => {
   ];
   json.allOf = allOf;
 };
+var recordProcessor = (schema, ctx, _json, params) => {
+  const json = _json;
+  const def = schema._zod.def;
+  json.type = "object";
+  const keyType = def.keyType;
+  const keyBag = keyType._zod.bag;
+  const patterns = keyBag?.patterns;
+  if (def.mode === "loose" && patterns && patterns.size > 0) {
+    const valueSchema = process2(def.valueType, ctx, {
+      ...params,
+      path: [...params.path, "patternProperties", "*"]
+    });
+    json.patternProperties = {};
+    for (const pattern of patterns) {
+      json.patternProperties[pattern.source] = valueSchema;
+    }
+  } else {
+    if (ctx.target === "draft-07" || ctx.target === "draft-2020-12") {
+      json.propertyNames = process2(def.keyType, ctx, {
+        ...params,
+        path: [...params.path, "propertyNames"]
+      });
+    }
+    json.additionalProperties = process2(def.valueType, ctx, {
+      ...params,
+      path: [...params.path, "additionalProperties"]
+    });
+  }
+  const keyValues = keyType._zod.values;
+  if (keyValues) {
+    const validKeyValues = [...keyValues].filter((v) => typeof v === "string" || typeof v === "number");
+    if (validKeyValues.length > 0) {
+      json.required = validKeyValues;
+    }
+  }
+};
 var nullableProcessor = (schema, ctx, json, params) => {
   const def = schema._zod.def;
   const inner = process2(def.innerType, ctx, params);
@@ -3580,7 +3874,7 @@ var optionalProcessor = (schema, ctx, _json, params) => {
   const seen = ctx.seen.get(schema);
   seen.ref = def.innerType;
 };
-// ../../node_modules/.bun/zod@4.2.0/node_modules/zod/v4/classic/iso.js
+// ../../node_modules/.bun/zod@4.3.6/node_modules/zod/v4/classic/iso.js
 var ZodISODateTime = /* @__PURE__ */ $constructor("ZodISODateTime", (inst, def) => {
   $ZodISODateTime.init(inst, def);
   ZodStringFormat.init(inst, def);
@@ -3610,7 +3904,7 @@ function duration2(params) {
   return _isoDuration(ZodISODuration, params);
 }
 
-// ../../node_modules/.bun/zod@4.2.0/node_modules/zod/v4/classic/errors.js
+// ../../node_modules/.bun/zod@4.3.6/node_modules/zod/v4/classic/errors.js
 var initializer2 = (inst, issues) => {
   $ZodError.init(inst, issues);
   inst.name = "ZodError";
@@ -3645,7 +3939,7 @@ var ZodRealError = $constructor("ZodError", initializer2, {
   Parent: Error
 });
 
-// ../../node_modules/.bun/zod@4.2.0/node_modules/zod/v4/classic/parse.js
+// ../../node_modules/.bun/zod@4.3.6/node_modules/zod/v4/classic/parse.js
 var parse3 = /* @__PURE__ */ _parse(ZodRealError);
 var parseAsync2 = /* @__PURE__ */ _parseAsync(ZodRealError);
 var safeParse2 = /* @__PURE__ */ _safeParse(ZodRealError);
@@ -3659,7 +3953,7 @@ var safeDecode = /* @__PURE__ */ _safeDecode(ZodRealError);
 var safeEncodeAsync = /* @__PURE__ */ _safeEncodeAsync(ZodRealError);
 var safeDecodeAsync = /* @__PURE__ */ _safeDecodeAsync(ZodRealError);
 
-// ../../node_modules/.bun/zod@4.2.0/node_modules/zod/v4/classic/schemas.js
+// ../../node_modules/.bun/zod@4.3.6/node_modules/zod/v4/classic/schemas.js
 var ZodType = /* @__PURE__ */ $constructor("ZodType", (inst, def) => {
   $ZodType.init(inst, def);
   Object.assign(inst["~standard"], {
@@ -3678,8 +3972,11 @@ var ZodType = /* @__PURE__ */ $constructor("ZodType", (inst, def) => {
         ...def.checks ?? [],
         ...checks2.map((ch) => typeof ch === "function" ? { _zod: { check: ch, def: { check: "custom" }, onattach: [] } } : ch)
       ]
-    }));
+    }), {
+      parent: true
+    });
   };
+  inst.with = inst.check;
   inst.clone = (def2, params) => clone(inst, def2, params);
   inst.brand = () => inst;
   inst.register = (reg, meta2) => {
@@ -3703,6 +4000,7 @@ var ZodType = /* @__PURE__ */ $constructor("ZodType", (inst, def) => {
   inst.superRefine = (refinement) => inst.check(superRefine(refinement));
   inst.overwrite = (fn) => inst.check(_overwrite(fn));
   inst.optional = () => optional(inst);
+  inst.exactOptional = () => exactOptional(inst);
   inst.nullable = () => nullable(inst);
   inst.nullish = () => optional(nullable(inst));
   inst.nonoptional = (params) => nonoptional(inst, params);
@@ -3736,6 +4034,7 @@ var ZodType = /* @__PURE__ */ $constructor("ZodType", (inst, def) => {
   };
   inst.isOptional = () => inst.safeParse(undefined).success;
   inst.isNullable = () => inst.safeParse(null).success;
+  inst.apply = (fn) => fn(inst);
   return inst;
 });
 var _ZodString = /* @__PURE__ */ $constructor("_ZodString", (inst, def) => {
@@ -4016,6 +4315,21 @@ function intersection(left, right) {
     right
   });
 }
+var ZodRecord = /* @__PURE__ */ $constructor("ZodRecord", (inst, def) => {
+  $ZodRecord.init(inst, def);
+  ZodType.init(inst, def);
+  inst._zod.processJSONSchema = (ctx, json, params) => recordProcessor(inst, ctx, json, params);
+  inst.keyType = def.keyType;
+  inst.valueType = def.valueType;
+});
+function record(keyType, valueType, params) {
+  return new ZodRecord({
+    type: "record",
+    keyType,
+    valueType,
+    ...exports_util.normalizeParams(params)
+  });
+}
 var ZodEnum = /* @__PURE__ */ $constructor("ZodEnum", (inst, def) => {
   $ZodEnum.init(inst, def);
   ZodType.init(inst, def);
@@ -4133,6 +4447,18 @@ function optional(innerType) {
     innerType
   });
 }
+var ZodExactOptional = /* @__PURE__ */ $constructor("ZodExactOptional", (inst, def) => {
+  $ZodExactOptional.init(inst, def);
+  ZodType.init(inst, def);
+  inst._zod.processJSONSchema = (ctx, json, params) => optionalProcessor(inst, ctx, json, params);
+  inst.unwrap = () => inst._zod.def.innerType;
+});
+function exactOptional(innerType) {
+  return new ZodExactOptional({
+    type: "optional",
+    innerType
+  });
+}
 var ZodNullable = /* @__PURE__ */ $constructor("ZodNullable", (inst, def) => {
   $ZodNullable.init(inst, def);
   ZodType.init(inst, def);
@@ -4243,24 +4569,36 @@ function superRefine(fn) {
 
 // ../mcp/src/contents/contents.schemas.ts
 var ContentsQuerySchema = object({
-  urls: array(string2().url()).min(1).describe("URLs to extract content from"),
-  format: _enum(["markdown", "html"]).optional().default("markdown").describe("Output format: markdown (text) or html (layout)")
+  urls: array(string2().url()).min(1).describe('Array of webpage URLs to extract content from (e.g., ["https://example.com"])'),
+  formats: array(_enum(["markdown", "html", "metadata"])).optional().describe('Output formats: array of "markdown" (text), "html" (layout), or "metadata" (structured data)'),
+  format: _enum(["markdown", "html"]).optional().describe("(Deprecated) Output format - use formats array instead"),
+  crawl_timeout: number2().min(1).max(60).optional().describe("Optional timeout in seconds (1-60) for page crawling")
 });
 var ContentsItemSchema = object({
   url: string2().describe("URL"),
   title: string2().optional().describe("Title"),
   html: string2().optional().describe("HTML content"),
-  markdown: string2().optional().describe("Markdown content")
+  markdown: string2().optional().describe("Markdown content"),
+  metadata: object({
+    jsonld: array(record(string2(), unknown())).optional().describe("JSON-LD structured data (Schema.org)"),
+    opengraph: record(string2(), string2()).optional().describe("OpenGraph meta tags"),
+    twitter: record(string2(), string2()).optional().describe("Twitter Card metadata")
+  }).optional().describe("Structured metadata when available")
 });
 var ContentsApiResponseSchema = array(ContentsItemSchema);
 var ContentsStructuredContentSchema = object({
   count: number2().describe("URLs processed"),
-  format: string2().describe("Content format"),
+  formats: array(string2()).describe("Content formats requested"),
   items: array(object({
     url: string2().describe("URL"),
     title: string2().optional().describe("Title"),
-    content: string2().describe("Extracted content"),
-    contentLength: number2().describe("Content length")
+    markdown: string2().optional().describe("Markdown content"),
+    html: string2().optional().describe("HTML content"),
+    metadata: object({
+      jsonld: array(record(string2(), unknown())).optional(),
+      opengraph: record(string2(), string2()).optional(),
+      twitter: record(string2(), string2()).optional()
+    }).optional().describe("Structured metadata")
   })).describe("Extracted items")
 });
 // ../mcp/src/shared/api-constants.ts
@@ -4279,13 +4617,21 @@ var checkResponseForErrors = (responseData) => {
 
 // ../mcp/src/contents/contents.utils.ts
 var fetchContents = async ({
-  contentsQuery: { urls, format = "markdown" },
+  contentsQuery: { urls, formats, format, crawl_timeout },
   YDC_API_KEY = process.env.YDC_API_KEY,
   getUserAgent
 }) => {
   if (!YDC_API_KEY) {
     throw new Error("YDC_API_KEY is required for Contents API");
   }
+  const requestFormats = formats || (format ? [format] : ["markdown"]);
+  const requestBody = {
+    urls,
+    formats: requestFormats
+  };
+  if (crawl_timeout !== undefined) {
+    requestBody.crawl_timeout = crawl_timeout;
+  }
   const options = {
     method: "POST",
     headers: new Headers({
@@ -4293,10 +4639,7 @@ var fetchContents = async ({
       "Content-Type": "application/json",
       "User-Agent": getUserAgent()
     }),
-    body: JSON.stringify({
-      urls,
-      format
-    })
+    body: JSON.stringify(requestBody)
   };
   const response = await fetch(CONTENTS_API_URL, options);
   if (!response.ok) {
@@ -4548,11 +4891,13 @@ var SearchStructuredContentSchema = object({
   results: object({
     web: array(object({
       url: string2().describe("URL"),
-      title: string2().describe("Title")
+      title: string2().describe("Title"),
+      page_age: string2().optional().describe("Publication timestamp")
     })).optional().describe("Web results"),
     news: array(object({
       url: string2().describe("URL"),
-      title: string2().describe("Title")
+      title: string2().describe("Title"),
+      page_age: string2().describe("Publication timestamp")
     })).optional().describe("News results")
   }).optional().describe("Search results")
 });
@@ -4606,7 +4951,7 @@ import { tool } from "ai";
 // package.json
 var package_default = {
   name: "@youdotcom-oss/ai-sdk-plugin",
-  version: "1.0.0",
+  version: "1.0.1",
   description: "Vercel AI SDK plugin for You.com web search, AI agents, and content extraction via MCP",
   license: "MIT",
   engines: {
@@ -4641,13 +4986,10 @@ var package_default = {
     ".": {
       types: "./dist/main.d.ts",
       default: "./dist/main.js"
-    },
-    "./templates/generate-text": "./templates/generate-text.ts",
-    "./templates/streaming-text": "./templates/streaming-text.ts"
+    }
   },
   files: [
-    "dist",
-    "templates"
+    "dist"
   ],
   publishConfig: {
     access: "public"
@@ -4675,13 +5017,14 @@ var package_default = {
   },
   types: "./dist/main.d.ts",
   dependencies: {
-    "@youdotcom-oss/mcp": "1.3.10"
+    "@youdotcom-oss/mcp": "1.5.1"
   },
   peerDependencies: {
-    ai: "^5.0.0"
+    ai: "^6.0.0"
   },
   devDependencies: {
-    "@ai-sdk/anthropic": "^2.0.56"
+    "@ai-sdk/anthropic": "^3.0.14",
+    ai: "^6.0.37"
   }
 };
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@youdotcom-oss/ai-sdk-plugin",
-  "version": "1.0.0",
+  "version": "1.0.1",
   "description": "Vercel AI SDK plugin for You.com web search, AI agents, and content extraction via MCP",
   "license": "MIT",
   "engines": {
@@ -35,13 +35,10 @@
     ".": {
       "types": "./dist/main.d.ts",
       "default": "./dist/main.js"
-    },
-    "./templates/generate-text": "./templates/generate-text.ts",
-    "./templates/streaming-text": "./templates/streaming-text.ts"
+    }
   },
   "files": [
-    "dist",
-    "templates"
+    "dist"
   ],
   "publishConfig": {
     "access": "public"
@@ -69,12 +66,13 @@
   },
   "types": "./dist/main.d.ts",
   "dependencies": {
-    "@youdotcom-oss/mcp": "1.3.10"
+    "@youdotcom-oss/mcp": "1.5.1"
   },
   "peerDependencies": {
-    "ai": "^5.0.0"
+    "ai": "^6.0.0"
   },
   "devDependencies": {
-    "@ai-sdk/anthropic": "^2.0.56"
+    "@ai-sdk/anthropic": "^3.0.14",
+    "ai": "^6.0.37"
   }
 }

package/templates/generate-text.ts

@@ -1,78 +0,0 @@
-/**
- * AI SDK Integration Template - generateText()
- *
- * Shows how to integrate You.com tools with Vercel AI SDK's generateText().
- *
- * Key Integration Points:
- * 1. Import tools: youSearch(), youExpress(), youContents()
- * 2. Add to tools object
- * 3. API key: Use env variable or pass directly to each tool
- * 4. Model handles everything - you just get result.text
- */
-
-import { createAnthropic } from '@ai-sdk/anthropic';
-import { youContents, youExpress, youSearch } from '@youdotcom-oss/ai-sdk-plugin';
-import { generateText } from 'ai';
-
-// ============================================================================
-// INTEGRATION STEP 1: Environment Variables
-// ============================================================================
-// Option A: Use environment variables (recommended)
-// Set YDC_API_KEY in your .env file - tools read it automatically
-
-if (!process.env.YDC_API_KEY) {
-  throw new Error('YDC_API_KEY environment variable is required');
-}
-
-// Your AI provider key (Anthropic, OpenAI, etc.)
-if (!process.env.ANTHROPIC_API_KEY) {
-  throw new Error('ANTHROPIC_API_KEY environment variable is required');
-}
-
-// ============================================================================
-// INTEGRATION STEP 2: Add Tools to generateText
-// ============================================================================
-
-const anthropic = createAnthropic();
-
-// Single tool example
-const result = await generateText({
-  model: anthropic('claude-sonnet-4-5-20250929'),
-  tools: {
-    search: youSearch(), // Reads YDC_API_KEY from environment
-  },
-  prompt: 'Your dynamic prompt here', // Replace with your actual prompt
-});
-
-console.log(result.text); // Model-formatted response with search results
-
-// ============================================================================
-// Multiple Tools (model chooses which to use)
-// ============================================================================
-
-const multiToolResult = await generateText({
-  model: anthropic('claude-sonnet-4-5-20250929'),
-  tools: {
-    search: youSearch(),
-    agent: youExpress(),
-    extract: youContents(),
-  },
-  prompt: 'Your prompt here',
-});
-
-console.log(multiToolResult.text);
-
-// ============================================================================
-// INTEGRATION OPTION B: Pass API Key Directly
-// ============================================================================
-// Override environment variable per tool if needed
-
-const customKeyResult = await generateText({
-  model: anthropic('claude-sonnet-4-5-20250929'),
-  tools: {
-    search: youSearch({ apiKey: 'your-key-here' }),
-  },
-  prompt: 'Your prompt here',
-});
-
-console.log(customKeyResult.text);

package/templates/streaming-text.ts

@@ -1,123 +0,0 @@
-/**
- * AI SDK Integration Template - streamText()
- *
- * Shows how to integrate You.com tools with Vercel AI SDK's streamText().
- *
- * Key Integration Points:
- * 1. Import tools: youSearch(), youExpress(), youContents()
- * 2. Add to tools object
- * 3. IMPORTANT: Use stopWhen with stepCountIs(2 + number_of_tools) minimum
- * 4. Consume textStream for real-time UI updates
- * 5. Model handles formatting - you just render the stream
- */
-
-import { createAnthropic } from '@ai-sdk/anthropic';
-import { youContents, youExpress, youSearch } from '@youdotcom-oss/ai-sdk-plugin';
-import { stepCountIs, streamText } from 'ai';
-
-// ============================================================================
-// INTEGRATION STEP 1: Environment Variables
-// ============================================================================
-
-if (!process.env.YDC_API_KEY) {
-  throw new Error('YDC_API_KEY environment variable is required');
-}
-
-if (!process.env.ANTHROPIC_API_KEY) {
-  throw new Error('ANTHROPIC_API_KEY environment variable is required');
-}
-
-// ============================================================================
-// INTEGRATION STEP 2: Add Tools + Configure stopWhen
-// ============================================================================
-// Use stopWhen: stepCountIs(3) - works for any number of tools with Anthropic
-
-const anthropic = createAnthropic();
-
-const result = streamText({
-  model: anthropic('claude-sonnet-4-5-20250929'),
-  tools: {
-    search: youSearch(),
-  },
-  stopWhen: stepCountIs(3), // 3 steps works regardless of tool count (Anthropic)
-  prompt: 'Your dynamic prompt here', // Replace with actual prompt
-});
-
-// ============================================================================
-// INTEGRATION STEP 3: Consume the Stream
-// ============================================================================
-// Stream text to your UI in real-time
-
-for await (const chunk of result.textStream) {
-  process.stdout.write(chunk); // Or update your UI component
-}
-
-// ============================================================================
-// Multiple Tools Example
-// ============================================================================
-// stepCountIs(3) works with any number of tools when using Anthropic
-
-const multiToolStream = streamText({
-  model: anthropic('claude-sonnet-4-5-20250929'),
-  tools: {
-    search: youSearch(),
-    agent: youExpress(),
-    extract: youContents(),
-  },
-  stopWhen: stepCountIs(3), // 3 steps works for 1, 2, or 3+ tools (Anthropic)
-  prompt: 'Your prompt here',
-});
-
-for await (const chunk of multiToolStream.textStream) {
-  process.stdout.write(chunk);
-}
-
-// ============================================================================
-// Web Framework Integration Examples
-// ============================================================================
-
-// Next.js App Router (Route Handler)
-// export async function POST(req: Request) {
-//   const { messages } = await req.json();
-//
-//   const result = streamText({
-//     model: anthropic('claude-sonnet-4-5-20250929'),
-//     tools: { search: youSearch() },
-//     stopWhen: stepCountIs(3),
-//     messages,
-//   });
-//
-//   return result.toDataStreamResponse();
-// }
-
-// Express.js
-// app.post('/api/chat', async (req, res) => {
-//   const { prompt } = req.body;
-//
-//   const result = streamText({
-//     model: anthropic('claude-sonnet-4-5-20250929'),
-//     tools: { search: youSearch() },
-//     stopWhen: stepCountIs(3),
-//     prompt,
-//   });
-//
-//   result.pipeDataStreamToResponse(res);
-// });
-
-// React Component (using useChat hook)
-// import { useChat } from 'ai/react';
-//
-// function ChatComponent() {
-//   const { messages, input, handleInputChange, handleSubmit } = useChat({
-//     api: '/api/chat', // Your endpoint with You.com tools
-//   });
-//
-//   return (
-//     <div>
-//       {messages.map(m => <div key={m.id}>{m.content}</div>)}
-//       <form onSubmit={handleSubmit}>
-//         <input value={input} onChange={handleInputChange} />
-//       </form>
-//     </div>
-//   );
-// }