@tambo-ai/react 1.0.0 → 1.0.1

package/esm/v1/utils/unstrictify.js

@@ -0,0 +1,155 @@
+/**
+ * Unstrictify tool call parameters using the original JSON Schema.
+ *
+ * When OpenAI's structured outputs mode is enabled, all optional parameters
+ * become required-and-nullable. The LLM then sends `null` for parameters the
+ * user didn't specify. This module reverses that transformation by comparing
+ * the LLM's output against the original schema and stripping nulls for
+ * parameters that were originally optional and non-nullable.
+ *
+ * Copied from packages/core/src/strictness/tool-call-strict.ts (minus the
+ * OpenAI-specific `unstrictifyToolCallRequest` wrapper).
+ */
+/**
+ * Unstrictify the parameters of a tool call request.
+ *
+ * This effectively reverses the process of strictifyToolCallParams, for a
+ * tool call request that was built from a strict JSON Schema, by returning a
+ * updated tool call request with the parameter values unstrictified.
+ */
+function unstrictifyToolCallParams(originalToolParamSchema, toolCallRequestParams) {
+    if (originalToolParamSchema.type !== "object") {
+        throw new Error(`tool call parameter schema must be an object, instead got ${originalToolParamSchema.type} / ${typeof originalToolParamSchema}`);
+    }
+    const newParams = Object.entries(toolCallRequestParams)
+        .map(([parameterName, parameterValue]) => {
+        const isRequired = originalToolParamSchema.required?.includes(parameterName);
+        // find the param in the original tool schema
+        const originalParamSchema = parameterName in (originalToolParamSchema.properties ?? {})
+            ? originalToolParamSchema.properties?.[parameterName]
+            : undefined;
+        // This should never happen, because the strict schema was derived from
+        // the original schema, so the parameter should always be present.
+        if (!originalParamSchema) {
+            throw new Error(`Tool call request parameter ${parameterName} not found in original tool`);
+        }
+        if (parameterValue === null &&
+            !canBeNull(originalParamSchema) &&
+            !isRequired) {
+            // This is the meat of this function. In the strict schema, this is
+            // "required and can be null", but in the original schema, the param was
+            // not required.
+            if (typeof originalParamSchema === "object" &&
+                "default" in originalParamSchema) {
+                return [parameterName, originalParamSchema.default];
+            }
+            return undefined;
+        }
+        // recurse into arrays
+        if (typeof originalParamSchema === "object" &&
+            originalParamSchema.type === "array") {
+            const arrayValue = parameterValue;
+            const itemSchema = originalParamSchema.items;
+            if (Array.isArray(arrayValue) &&
+                itemSchema &&
+                typeof itemSchema === "object" &&
+                !Array.isArray(itemSchema)) {
+                const newArrayValue = arrayValue.map((item) => {
+                    if (itemSchema.type === "object" &&
+                        typeof item === "object" &&
+                        item !== null) {
+                        // recurse into each object in the array
+                        return unstrictifyToolCallParams(itemSchema, item);
+                    }
+                    return item;
+                });
+                return [parameterName, newArrayValue];
+            }
+            return [parameterName, parameterValue];
+        }
+        // recurse into the parameter value, passing along the matching original schema
+        if (typeof originalParamSchema === "object" &&
+            originalParamSchema.type === "object") {
+            // If the LLM sent a JSON string instead of an object (common with z.any() schemas),
+            // try to parse it
+            let objectValue = parameterValue;
+            if (typeof parameterValue === "string") {
+                try {
+                    const parsed = JSON.parse(parameterValue);
+                    if (typeof parsed === "object" && parsed !== null) {
+                        objectValue = parsed;
+                    }
+                }
+                catch {
+                    // Not valid JSON, keep original value
+                }
+            }
+            // Only recurse if we have an actual object AND the schema has properties defined.
+            // If the schema has no properties (e.g., z.any() which produces {type: 'object', anyOf: [...]}),
+            // just return the value as-is without recursing.
+            const hasProperties = originalParamSchema.properties &&
+                Object.keys(originalParamSchema.properties).length > 0;
+            if (hasProperties &&
+                typeof objectValue === "object" &&
+                objectValue !== null &&
+                !Array.isArray(objectValue)) {
+                const newParamValue = unstrictifyToolCallParams(originalParamSchema, objectValue);
+                return [parameterName, newParamValue];
+            }
+            // Return the (possibly parsed) object value without recursing
+            return [parameterName, objectValue];
+        }
+        return [parameterName, parameterValue];
+    })
+        .filter((param) => param !== undefined);
+    return Object.fromEntries(newParams);
+}
+/**
+ * Unstrictify tool call params using the original JSON Schema.
+ *
+ * Unlike the private `unstrictifyToolCallParams` which throws on unknown params,
+ * this function separates params into schema-defined vs `_tambo_*` pass-through
+ * (server-injected params not in the original schema), unstrictifies only the
+ * schema-defined ones, and merges pass-through params back. Unknown keys that
+ * aren't in the schema and don't have the `_tambo_` prefix are dropped.
+ * @returns The params with strictification-induced nulls stripped for optional
+ * non-nullable properties, and pass-through params preserved as-is.
+ */
+export function unstrictifyToolCallParamsFromSchema(originalSchema, params) {
+    if (originalSchema.type !== "object") {
+        return params;
+    }
+    const schemaProperties = originalSchema.properties ?? {};
+    const schemaDefinedParams = {};
+    const passThroughParams = {};
+    for (const [key, value] of Object.entries(params)) {
+        if (key in schemaProperties) {
+            schemaDefinedParams[key] = value;
+        }
+        else if (key.startsWith("_tambo_")) {
+            passThroughParams[key] = value;
+        }
+        // Unknown keys not in schema and not _tambo_* are dropped —
+        // they're likely hallucinated by the model.
+    }
+    const unstrictified = unstrictifyToolCallParams(originalSchema, schemaDefinedParams);
+    return { ...unstrictified, ...passThroughParams };
+}
+/**
+ * Check if a JSON Schema definition allows null values.
+ * @param originalSchema - The schema definition to check
+ * @returns True if the schema allows null values
+ */
+export function canBeNull(originalSchema) {
+    if (typeof originalSchema !== "object") {
+        return false;
+    }
+    if (originalSchema.type === "null") {
+        return true;
+    }
+    if (originalSchema.anyOf?.some((anyOf) => canBeNull(anyOf))) {
+        return true;
+    }
+    return false;
+}
+//# sourceMappingURL=unstrictify.js.map

package/esm/v1/utils/unstrictify.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"unstrictify.js","sourceRoot":"","sources":["../../../src/v1/utils/unstrictify.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * Unstrictify tool call parameters using the original JSON Schema.\n *\n * When OpenAI's structured outputs mode is enabled, all optional parameters\n * become required-and-nullable. The LLM then sends `null` for parameters the\n * user didn't specify. This module reverses that transformation by comparing\n * the LLM's output against the original schema and stripping nulls for\n * parameters that were originally optional and non-nullable.\n *\n * Copied from packages/core/src/strictness/tool-call-strict.ts (minus the\n * OpenAI-specific `unstrictifyToolCallRequest` wrapper).\n */\n\nimport type { JSONSchema7, JSONSchema7Definition } from \"json-schema\";\n\n/**\n * Unstrictify the parameters of a tool call request.\n *\n * This effectively reverses the process of strictifyToolCallParams, for a\n * tool call request that was built from a strict JSON Schema, by returning a\n * updated tool call request with the parameter values unstrictified.\n */\nfunction unstrictifyToolCallParams(\n  originalToolParamSchema: JSONSchema7,\n  toolCallRequestParams: Record<string, unknown>,\n): Record<string, unknown> {\n  if (originalToolParamSchema.type !== \"object\") {\n    throw new Error(\n      `tool call parameter schema must be an object, instead got ${originalToolParamSchema.type} / ${typeof originalToolParamSchema}`,\n    );\n  }\n  const newParams = Object.entries(toolCallRequestParams)\n    .map(([parameterName, parameterValue]) => {\n      const isRequired =\n        originalToolParamSchema.required?.includes(parameterName);\n      // find the param in the original tool schema\n      const originalParamSchema =\n        parameterName in (originalToolParamSchema.properties ?? {})\n          ? originalToolParamSchema.properties?.[parameterName]\n          : undefined;\n\n      // This should never happen, because the strict schema was derived from\n      // the original schema, so the parameter should always be present.\n      if (!originalParamSchema) {\n        throw new Error(\n          `Tool call request parameter ${parameterName} not found in original tool`,\n        );\n      }\n\n      if (\n        parameterValue === null &&\n        !canBeNull(originalParamSchema) &&\n        !isRequired\n      ) {\n        // This is the meat of this function. In the strict schema, this is\n        // \"required and can be null\", but in the original schema, the param was\n        // not required.\n        if (\n          typeof originalParamSchema === \"object\" &&\n          \"default\" in originalParamSchema\n        ) {\n          return [parameterName, originalParamSchema.default] as const;\n        }\n        return undefined;\n      }\n\n      // recurse into arrays\n      if (\n        typeof originalParamSchema === \"object\" &&\n        originalParamSchema.type === \"array\"\n      ) {\n        const arrayValue = parameterValue as unknown[];\n        const itemSchema = originalParamSchema.items;\n        if (\n          Array.isArray(arrayValue) &&\n          itemSchema &&\n          typeof itemSchema === \"object\" &&\n          !Array.isArray(itemSchema)\n        ) {\n          const newArrayValue = arrayValue.map((item) => {\n            if (\n              itemSchema.type === \"object\" &&\n              typeof item === \"object\" &&\n              item !== null\n            ) {\n              // recurse into each object in the array\n              return unstrictifyToolCallParams(\n                itemSchema,\n                item as Record<string, unknown>,\n              );\n            }\n            return item;\n          });\n          return [parameterName, newArrayValue] as const;\n        }\n        return [parameterName, parameterValue] as const;\n      }\n\n      // recurse into the parameter value, passing along the matching original schema\n      if (\n        typeof originalParamSchema === \"object\" &&\n        originalParamSchema.type === \"object\"\n      ) {\n        // If the LLM sent a JSON string instead of an object (common with z.any() schemas),\n        // try to parse it\n        let objectValue = parameterValue;\n        if (typeof parameterValue === \"string\") {\n          try {\n            const parsed = JSON.parse(parameterValue);\n            if (typeof parsed === \"object\" && parsed !== null) {\n              objectValue = parsed;\n            }\n          } catch {\n            // Not valid JSON, keep original value\n          }\n        }\n\n        // Only recurse if we have an actual object AND the schema has properties defined.\n        // If the schema has no properties (e.g., z.any() which produces {type: 'object', anyOf: [...]}),\n        // just return the value as-is without recursing.\n        const hasProperties =\n          originalParamSchema.properties &&\n          Object.keys(originalParamSchema.properties).length > 0;\n\n        if (\n          hasProperties &&\n          typeof objectValue === \"object\" &&\n          objectValue !== null &&\n          !Array.isArray(objectValue)\n        ) {\n          const newParamValue = unstrictifyToolCallParams(\n            originalParamSchema,\n            objectValue as Record<string, unknown>,\n          );\n          return [parameterName, newParamValue] as const;\n        }\n\n        // Return the (possibly parsed) object value without recursing\n        return [parameterName, objectValue] as const;\n      }\n\n      return [parameterName, parameterValue] as const;\n    })\n    .filter((param) => param !== undefined);\n  return Object.fromEntries(newParams);\n}\n\n/**\n * Unstrictify tool call params using the original JSON Schema.\n *\n * Unlike the private `unstrictifyToolCallParams` which throws on unknown params,\n * this function separates params into schema-defined vs `_tambo_*` pass-through\n * (server-injected params not in the original schema), unstrictifies only the\n * schema-defined ones, and merges pass-through params back. Unknown keys that\n * aren't in the schema and don't have the `_tambo_` prefix are dropped.\n * @returns The params with strictification-induced nulls stripped for optional\n * non-nullable properties, and pass-through params preserved as-is.\n */\nexport function unstrictifyToolCallParamsFromSchema(\n  originalSchema: JSONSchema7,\n  params: Record<string, unknown>,\n): Record<string, unknown> {\n  if (originalSchema.type !== \"object\") {\n    return params;\n  }\n\n  const schemaProperties = originalSchema.properties ?? {};\n  const schemaDefinedParams: Record<string, unknown> = {};\n  const passThroughParams: Record<string, unknown> = {};\n\n  for (const [key, value] of Object.entries(params)) {\n    if (key in schemaProperties) {\n      schemaDefinedParams[key] = value;\n    } else if (key.startsWith(\"_tambo_\")) {\n      passThroughParams[key] = value;\n    }\n    // Unknown keys not in schema and not _tambo_* are dropped —\n    // they're likely hallucinated by the model.\n  }\n\n  const unstrictified = unstrictifyToolCallParams(\n    originalSchema,\n    schemaDefinedParams,\n  );\n\n  return { ...unstrictified, ...passThroughParams };\n}\n\n/**\n * Check if a JSON Schema definition allows null values.\n * @param originalSchema - The schema definition to check\n * @returns True if the schema allows null values\n */\nexport function canBeNull(originalSchema: JSONSchema7Definition): boolean {\n  if (typeof originalSchema !== \"object\") {\n    return false;\n  }\n\n  if (originalSchema.type === \"null\") {\n    return true;\n  }\n\n  if (originalSchema.anyOf?.some((anyOf) => canBeNull(anyOf))) {\n    return true;\n  }\n  return false;\n}\n"]}

package/esm/v1/utils/unstrictify.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=unstrictify.test.d.ts.map

package/esm/v1/utils/unstrictify.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"unstrictify.test.d.ts","sourceRoot":"","sources":["../../../src/v1/utils/unstrictify.test.ts"],"names":[],"mappings":""}

package/esm/v1/utils/unstrictify.test.js

@@ -0,0 +1,185 @@
+import { canBeNull, unstrictifyToolCallParamsFromSchema } from "./unstrictify.js";
+describe("canBeNull", () => {
+    it("should return true for schema with type null", () => {
+        const schema = { type: "null" };
+        expect(canBeNull(schema)).toBe(true);
+    });
+    it("should return true for schema with anyOf containing type null", () => {
+        const schema = {
+            anyOf: [{ type: "string" }, { type: "null" }],
+        };
+        expect(canBeNull(schema)).toBe(true);
+    });
+    it("should return true for deeply nested anyOf containing type null", () => {
+        const schema = {
+            anyOf: [
+                { type: "string" },
+                {
+                    anyOf: [{ type: "number" }, { type: "null" }],
+                },
+            ],
+        };
+        expect(canBeNull(schema)).toBe(true);
+    });
+    it("should return false for non-object schema", () => {
+        expect(canBeNull(true)).toBe(false);
+        expect(canBeNull("string")).toBe(false);
+    });
+    it("should return false for schema without null type", () => {
+        const schema = { type: "string" };
+        expect(canBeNull(schema)).toBe(false);
+    });
+    it("should return false for schema with anyOf not containing null type", () => {
+        const schema = {
+            anyOf: [{ type: "string" }, { type: "number" }],
+        };
+        expect(canBeNull(schema)).toBe(false);
+    });
+});
+describe("unstrictifyToolCallParamsFromSchema", () => {
+    it("should strip null values for optional non-nullable params", () => {
+        const schema = {
+            type: "object",
+            properties: {
+                name: { type: "string" },
+                age: { type: "number" },
+            },
+            required: ["name"],
+        };
+        const result = unstrictifyToolCallParamsFromSchema(schema, {
+            name: "John",
+            age: null,
+        });
+        expect(result).toEqual({ name: "John" });
+    });
+    it("should preserve pass-through params not in original schema", () => {
+        const schema = {
+            type: "object",
+            properties: {
+                name: { type: "string" },
+            },
+            required: ["name"],
+        };
+        const result = unstrictifyToolCallParamsFromSchema(schema, {
+            name: "John",
+            _tambo_statusMessage: "Processing...",
+            _tambo_displayMessage: "Hello",
+        });
+        expect(result).toEqual({
+            name: "John",
+            _tambo_statusMessage: "Processing...",
+            _tambo_displayMessage: "Hello",
+        });
+    });
+    it("should handle nested object unstrictification with pass-through params", () => {
+        const schema = {
+            type: "object",
+            properties: {
+                user: {
+                    type: "object",
+                    properties: {
+                        name: { type: "string" },
+                        email: { type: "string" },
+                    },
+                    required: ["name"],
+                },
+            },
+            required: ["user"],
+        };
+        const result = unstrictifyToolCallParamsFromSchema(schema, {
+            user: { name: "John", email: null },
+            _tambo_statusMessage: "Updating user",
+        });
+        expect(result).toEqual({
+            user: { name: "John" },
+            _tambo_statusMessage: "Updating user",
+        });
+    });
+    it("should return params as-is for non-object schemas", () => {
+        const schema = { type: "string" };
+        const params = { name: "John", _tambo_foo: "bar" };
+        const result = unstrictifyToolCallParamsFromSchema(schema, params);
+        expect(result).toEqual(params);
+    });
+    it("should handle empty params", () => {
+        const schema = {
+            type: "object",
+            properties: {
+                name: { type: "string" },
+            },
+            required: [],
+        };
+        const result = unstrictifyToolCallParamsFromSchema(schema, {});
+        expect(result).toEqual({});
+    });
+    it("should handle schema with no properties defined", () => {
+        const schema = {
+            type: "object",
+        };
+        const result = unstrictifyToolCallParamsFromSchema(schema, {
+            anything: "value",
+            _tambo_status: "ok",
+        });
+        // Only _tambo_* keys pass through; unknown keys are dropped
+        expect(result).toEqual({
+            _tambo_status: "ok",
+        });
+    });
+    it("should drop hallucinated keys not in schema or _tambo_* prefix", () => {
+        const schema = {
+            type: "object",
+            properties: {
+                city: { type: "string" },
+            },
+            required: ["city"],
+        };
+        const result = unstrictifyToolCallParamsFromSchema(schema, {
+            city: "NYC",
+            temperatur: "celsius",
+            _tambo_statusMessage: "Fetching",
+        });
+        expect(result).toEqual({
+            city: "NYC",
+            _tambo_statusMessage: "Fetching",
+        });
+    });
+    it("should handle arrays with nested objects", () => {
+        const schema = {
+            type: "object",
+            properties: {
+                targets: {
+                    type: "array",
+                    items: {
+                        type: "object",
+                        properties: {
+                            range: { type: "string" },
+                            style: {
+                                type: "object",
+                                properties: {
+                                    bold: { type: "boolean" },
+                                    fontFamily: { type: "string" },
+                                },
+                                required: [],
+                            },
+                        },
+                        required: ["style"],
+                    },
+                },
+            },
+            required: ["targets"],
+        };
+        const result = unstrictifyToolCallParamsFromSchema(schema, {
+            targets: [
+                { range: "A1:B1", style: { bold: true, fontFamily: null } },
+                { range: "A2:A6", style: { bold: false, fontFamily: null } },
+            ],
+        });
+        expect(result).toEqual({
+            targets: [
+                { range: "A1:B1", style: { bold: true } },
+                { range: "A2:A6", style: { bold: false } },
+            ],
+        });
+    });
+});
+//# sourceMappingURL=unstrictify.test.js.map

package/esm/v1/utils/unstrictify.test.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"unstrictify.test.js","sourceRoot":"","sources":["../../../src/v1/utils/unstrictify.test.ts"],"names":[],"mappings":"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","sourcesContent":["import type { JSONSchema7, JSONSchema7Definition } from \"json-schema\";\nimport { canBeNull, unstrictifyToolCallParamsFromSchema } from \"./unstrictify\";\n\ndescribe(\"canBeNull\", () => {\n  it(\"should return true for schema with type null\", () => {\n    const schema: JSONSchema7 = { type: \"null\" };\n    expect(canBeNull(schema)).toBe(true);\n  });\n\n  it(\"should return true for schema with anyOf containing type null\", () => {\n    const schema: JSONSchema7 = {\n      anyOf: [{ type: \"string\" }, { type: \"null\" }],\n    };\n    expect(canBeNull(schema)).toBe(true);\n  });\n\n  it(\"should return true for deeply nested anyOf containing type null\", () => {\n    const schema: JSONSchema7 = {\n      anyOf: [\n        { type: \"string\" },\n        {\n          anyOf: [{ type: \"number\" }, { type: \"null\" }],\n        },\n      ],\n    };\n    expect(canBeNull(schema)).toBe(true);\n  });\n\n  it(\"should return false for non-object schema\", () => {\n    expect(canBeNull(true)).toBe(false);\n    expect(canBeNull(\"string\" as JSONSchema7Definition)).toBe(false);\n  });\n\n  it(\"should return false for schema without null type\", () => {\n    const schema: JSONSchema7 = { type: \"string\" };\n    expect(canBeNull(schema)).toBe(false);\n  });\n\n  it(\"should return false for schema with anyOf not containing null type\", () => {\n    const schema: JSONSchema7 = {\n      anyOf: [{ type: \"string\" }, { type: \"number\" }],\n    };\n    expect(canBeNull(schema)).toBe(false);\n  });\n});\n\ndescribe(\"unstrictifyToolCallParamsFromSchema\", () => {\n  it(\"should strip null values for optional non-nullable params\", () => {\n    const schema: JSONSchema7 = {\n      type: \"object\",\n      properties: {\n        name: { type: \"string\" },\n        age: { type: \"number\" },\n      },\n      required: [\"name\"],\n    };\n\n    const result = unstrictifyToolCallParamsFromSchema(schema, {\n      name: \"John\",\n      age: null,\n    });\n\n    expect(result).toEqual({ name: \"John\" });\n  });\n\n  it(\"should preserve pass-through params not in original schema\", () => {\n    const schema: JSONSchema7 = {\n      type: \"object\",\n      properties: {\n        name: { type: \"string\" },\n      },\n      required: [\"name\"],\n    };\n\n    const result = unstrictifyToolCallParamsFromSchema(schema, {\n      name: \"John\",\n      _tambo_statusMessage: \"Processing...\",\n      _tambo_displayMessage: \"Hello\",\n    });\n\n    expect(result).toEqual({\n      name: \"John\",\n      _tambo_statusMessage: \"Processing...\",\n      _tambo_displayMessage: \"Hello\",\n    });\n  });\n\n  it(\"should handle nested object unstrictification with pass-through params\", () => {\n    const schema: JSONSchema7 = {\n      type: \"object\",\n      properties: {\n        user: {\n          type: \"object\",\n          properties: {\n            name: { type: \"string\" },\n            email: { type: \"string\" },\n          },\n          required: [\"name\"],\n        },\n      },\n      required: [\"user\"],\n    };\n\n    const result = unstrictifyToolCallParamsFromSchema(schema, {\n      user: { name: \"John\", email: null },\n      _tambo_statusMessage: \"Updating user\",\n    });\n\n    expect(result).toEqual({\n      user: { name: \"John\" },\n      _tambo_statusMessage: \"Updating user\",\n    });\n  });\n\n  it(\"should return params as-is for non-object schemas\", () => {\n    const schema: JSONSchema7 = { type: \"string\" };\n    const params = { name: \"John\", _tambo_foo: \"bar\" };\n\n    const result = unstrictifyToolCallParamsFromSchema(schema, params);\n\n    expect(result).toEqual(params);\n  });\n\n  it(\"should handle empty params\", () => {\n    const schema: JSONSchema7 = {\n      type: \"object\",\n      properties: {\n        name: { type: \"string\" },\n      },\n      required: [],\n    };\n\n    const result = unstrictifyToolCallParamsFromSchema(schema, {});\n\n    expect(result).toEqual({});\n  });\n\n  it(\"should handle schema with no properties defined\", () => {\n    const schema: JSONSchema7 = {\n      type: \"object\",\n    };\n\n    const result = unstrictifyToolCallParamsFromSchema(schema, {\n      anything: \"value\",\n      _tambo_status: \"ok\",\n    });\n\n    // Only _tambo_* keys pass through; unknown keys are dropped\n    expect(result).toEqual({\n      _tambo_status: \"ok\",\n    });\n  });\n\n  it(\"should drop hallucinated keys not in schema or _tambo_* prefix\", () => {\n    const schema: JSONSchema7 = {\n      type: \"object\",\n      properties: {\n        city: { type: \"string\" },\n      },\n      required: [\"city\"],\n    };\n\n    const result = unstrictifyToolCallParamsFromSchema(schema, {\n      city: \"NYC\",\n      temperatur: \"celsius\",\n      _tambo_statusMessage: \"Fetching\",\n    });\n\n    expect(result).toEqual({\n      city: \"NYC\",\n      _tambo_statusMessage: \"Fetching\",\n    });\n  });\n\n  it(\"should handle arrays with nested objects\", () => {\n    const schema: JSONSchema7 = {\n      type: \"object\",\n      properties: {\n        targets: {\n          type: \"array\",\n          items: {\n            type: \"object\",\n            properties: {\n              range: { type: \"string\" },\n              style: {\n                type: \"object\",\n                properties: {\n                  bold: { type: \"boolean\" },\n                  fontFamily: { type: \"string\" },\n                },\n                required: [],\n              },\n            },\n            required: [\"style\"],\n          },\n        },\n      },\n      required: [\"targets\"],\n    };\n\n    const result = unstrictifyToolCallParamsFromSchema(schema, {\n      targets: [\n        { range: \"A1:B1\", style: { bold: true, fontFamily: null } },\n        { range: \"A2:A6\", style: { bold: false, fontFamily: null } },\n      ],\n    });\n\n    expect(result).toEqual({\n      targets: [\n        { range: \"A1:B1\", style: { bold: true } },\n        { range: \"A2:A6\", style: { bold: false } },\n      ],\n    });\n  });\n});\n"]}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tambo-ai/react",
-  "version": "1.0.0",
+  "version": "1.0.1",
   "description": "React client package for Tambo AI!",
   "license": "MIT",
   "repository": {