@assistant-ui/react-mcp 0.0.21 → 0.1.0

package/src/primitives/elicitation/initialElicitationDraft.test.ts

@@ -0,0 +1,34 @@
+// @vitest-environment node
+
+import { describe, expect, it } from "vitest";
+import { initialElicitationDraft } from "./initialElicitationDraft";
+
+describe("initialElicitationDraft", () => {
+  it("seeds defaults that match their declared types", () => {
+    expect(
+      initialElicitationDraft({
+        type: "object",
+        properties: {
+          enabled: { type: "boolean", default: true },
+          name: { type: "string", default: "Ada" },
+          ratio: { type: "number", default: 1.5 },
+          count: { type: "integer", default: 2 },
+        },
+      }),
+    ).toEqual({ enabled: true, name: "Ada", ratio: 1.5, count: 2 });
+  });
+
+  it("skips defaults that do not match their declared types", () => {
+    expect(
+      initialElicitationDraft({
+        type: "object",
+        properties: {
+          enabled: { type: "boolean", default: "true" },
+          name: { type: "string", default: 1 },
+          ratio: { type: "number", default: "1.5" },
+          count: { type: "integer", default: 1.5 },
+        },
+      }),
+    ).toEqual({});
+  });
+});

package/src/primitives/elicitation/initialElicitationDraft.ts

@@ -0,0 +1,39 @@
+const isRecord = (value: unknown): value is Record<string, unknown> =>
+  typeof value === "object" && value !== null && !Array.isArray(value);
+
+const getOwn = (value: Record<string, unknown>, key: string): unknown =>
+  Object.hasOwn(value, key) ? value[key] : undefined;
+
+const matchesType = (type: unknown, value: unknown): boolean => {
+  switch (type) {
+    case "string":
+      return typeof value === "string";
+    case "number":
+      return typeof value === "number";
+    case "integer":
+      return typeof value === "number" && Number.isInteger(value);
+    case "boolean":
+      return typeof value === "boolean";
+    default:
+      return false;
+  }
+};
+
+export const initialElicitationDraft = (
+  requestedSchema: unknown,
+): Record<string, unknown> => {
+  if (!isRecord(requestedSchema)) return {};
+
+  const properties = getOwn(requestedSchema, "properties");
+  if (!isRecord(properties)) return {};
+
+  return Object.fromEntries(
+    Object.keys(properties).flatMap((name) => {
+      const schema = properties[name];
+      if (!isRecord(schema) || !Object.hasOwn(schema, "default")) return [];
+
+      const value = schema.default;
+      return matchesType(getOwn(schema, "type"), value) ? [[name, value]] : [];
+    }),
+  );
+};

package/src/primitives/elicitation/prepareElicitationContent.test.ts

@@ -0,0 +1,415 @@
+// @vitest-environment node
+
+import { describe, expect, it } from "vitest";
+import { prepareElicitationContent } from "./prepareElicitationContent";
+
+describe("prepareElicitationContent", () => {
+  it("accepts parseable number and integer draft values", () => {
+    expect(
+      prepareElicitationContent(
+        {
+          type: "object",
+          properties: {
+            count: { type: "integer" },
+            ratio: { type: "number" },
+            enabled: { type: "boolean" },
+          },
+        },
+        { count: "42", ratio: "1.5", enabled: false },
+      ).content,
+    ).toEqual({ count: 42, ratio: 1.5, enabled: false });
+  });
+
+  it("flags and excludes an unparseable number value", () => {
+    expect(
+      prepareElicitationContent(
+        {
+          type: "object",
+          properties: { count: { type: "number" } },
+        },
+        { count: "not a number" },
+      ).content,
+    ).toEqual({});
+    expect(
+      prepareElicitationContent(
+        {
+          type: "object",
+          properties: { count: { type: "number" } },
+        },
+        { count: "not a number" },
+      ).invalid,
+    ).toEqual(["count"]);
+  });
+
+  it("flags and excludes a fractional integer value", () => {
+    expect(
+      prepareElicitationContent(
+        {
+          type: "object",
+          properties: { count: { type: "integer" } },
+        },
+        { count: "1.5" },
+      ).content,
+    ).toEqual({});
+    expect(
+      prepareElicitationContent(
+        {
+          type: "object",
+          properties: { count: { type: "integer" } },
+        },
+        { count: "1.5" },
+      ).invalid,
+    ).toEqual(["count"]);
+  });
+
+  it("flags enum values outside the allowed values for the Accept gate", () => {
+    expect(
+      prepareElicitationContent(
+        {
+          type: "object",
+          properties: { color: { enum: ["red", "blue"] } },
+        },
+        { color: "green" },
+      ),
+    ).toEqual({ content: {}, missingRequired: [], invalid: ["color"] });
+  });
+
+  it("does not read inherited draft values", () => {
+    expect(
+      prepareElicitationContent(
+        {
+          type: "object",
+          required: ["toString"],
+          properties: { toString: { type: "string" } },
+        },
+        {},
+      ),
+    ).toEqual({
+      content: {},
+      missingRequired: ["toString"],
+      invalid: [],
+    });
+  });
+
+  it("seeds required booleans with a true schema default", () => {
+    expect(
+      prepareElicitationContent(
+        {
+          type: "object",
+          required: ["enabled"],
+          properties: {
+            enabled: { type: "boolean", default: true },
+          },
+        },
+        {},
+      ),
+    ).toEqual({
+      content: { enabled: true },
+      missingRequired: [],
+      invalid: [],
+    });
+  });
+
+  it("seeds required booleans with a false schema default", () => {
+    expect(
+      prepareElicitationContent(
+        {
+          type: "object",
+          required: ["enabled"],
+          properties: {
+            enabled: { type: "boolean", default: false },
+          },
+        },
+        {},
+      ),
+    ).toEqual({
+      content: { enabled: false },
+      missingRequired: [],
+      invalid: [],
+    });
+  });
+
+  it("seeds required booleans without a schema default as false", () => {
+    expect(
+      prepareElicitationContent(
+        {
+          type: "object",
+          required: ["enabled"],
+          properties: { enabled: { type: "boolean" } },
+        },
+        {},
+      ),
+    ).toEqual({
+      content: { enabled: false },
+      missingRequired: [],
+      invalid: [],
+    });
+  });
+
+  it("omits absent optional booleans, including schema defaults", () => {
+    expect(
+      prepareElicitationContent(
+        {
+          type: "object",
+          properties: {
+            enabled: { type: "boolean" },
+            sendEmail: { type: "boolean", default: true },
+          },
+        },
+        {},
+      ),
+    ).toEqual({ content: {}, missingRequired: [], invalid: [] });
+  });
+
+  it("seeds required booleans with an empty draft value as false", () => {
+    expect(
+      prepareElicitationContent(
+        {
+          type: "object",
+          required: ["enabled"],
+          properties: { enabled: { type: "boolean" } },
+        },
+        { enabled: "" },
+      ),
+    ).toEqual({
+      content: { enabled: false },
+      missingRequired: [],
+      invalid: [],
+    });
+  });
+
+  it("omits an empty optional string draft", () => {
+    expect(
+      prepareElicitationContent(
+        {
+          type: "object",
+          properties: { query: { type: "string" } },
+        },
+        { query: "" },
+      ),
+    ).toEqual({ content: {}, missingRequired: [], invalid: [] });
+  });
+
+  it("treats an empty required string draft as absent", () => {
+    expect(
+      prepareElicitationContent(
+        {
+          type: "object",
+          required: ["query"],
+          properties: { query: { type: "string" } },
+        },
+        { query: "" },
+      ),
+    ).toEqual({
+      content: {},
+      missingRequired: ["query"],
+      invalid: [],
+    });
+  });
+
+  it("treats a cleared enum draft as absent instead of invalid", () => {
+    expect(
+      prepareElicitationContent(
+        {
+          type: "object",
+          properties: {
+            color: { type: "string", enum: ["red", "blue"] },
+            shade: { enum: ["light", "dark"] },
+          },
+        },
+        { color: "", shade: "" },
+      ),
+    ).toEqual({ content: {}, missingRequired: [], invalid: [] });
+  });
+
+  it("ignores empty-string defaults and enums on non-string schemas", () => {
+    expect(
+      prepareElicitationContent(
+        {
+          type: "object",
+          properties: {
+            limit: { type: "number", default: "" },
+            count: { type: "integer", enum: [1, 2, ""] },
+          },
+        },
+        { limit: "", count: "" },
+      ),
+    ).toEqual({ content: {}, missingRequired: [], invalid: [] });
+  });
+
+  it("seeds a required boolean whose schema declares an empty-string default", () => {
+    expect(
+      prepareElicitationContent(
+        {
+          type: "object",
+          required: ["enabled"],
+          properties: { enabled: { type: "boolean", default: "" } },
+        },
+        { enabled: "" },
+      ),
+    ).toEqual({
+      content: { enabled: false },
+      missingRequired: [],
+      invalid: [],
+    });
+  });
+
+  it("reports a cleared required enum draft as missing instead of invalid", () => {
+    expect(
+      prepareElicitationContent(
+        {
+          type: "object",
+          required: ["color"],
+          properties: { color: { type: "string", enum: ["red", "blue"] } },
+        },
+        { color: "" },
+      ),
+    ).toEqual({ content: {}, missingRequired: ["color"], invalid: [] });
+  });
+
+  it("keeps an empty string the enum admits", () => {
+    expect(
+      prepareElicitationContent(
+        {
+          type: "object",
+          required: ["note"],
+          properties: { note: { type: "string", enum: ["", "none"] } },
+        },
+        { note: "" },
+      ),
+    ).toEqual({ content: { note: "" }, missingRequired: [], invalid: [] });
+  });
+
+  it("ignores an empty-string default the enum does not admit", () => {
+    expect(
+      prepareElicitationContent(
+        {
+          type: "object",
+          required: ["color"],
+          properties: {
+            color: { type: "string", enum: ["red", "blue"], default: "" },
+          },
+        },
+        { color: "" },
+      ),
+    ).toEqual({ content: {}, missingRequired: ["color"], invalid: [] });
+  });
+
+  it("keeps an empty string the schema defaults to", () => {
+    expect(
+      prepareElicitationContent(
+        {
+          type: "object",
+          required: ["prefix"],
+          properties: { prefix: { type: "string", default: "" } },
+        },
+        { prefix: "" },
+      ),
+    ).toEqual({ content: { prefix: "" }, missingRequired: [], invalid: [] });
+  });
+
+  it("treats an empty optional boolean draft as absent", () => {
+    expect(
+      prepareElicitationContent(
+        {
+          type: "object",
+          properties: { enabled: { type: "boolean" } },
+        },
+        { enabled: "" },
+      ),
+    ).toEqual({ content: {}, missingRequired: [], invalid: [] });
+  });
+
+  it("treats undefined and empty optional boolean drafts as absent", () => {
+    expect(
+      prepareElicitationContent(
+        {
+          type: "object",
+          properties: {
+            enabled: { type: "boolean" },
+            sendEmail: { type: "boolean" },
+          },
+        },
+        { enabled: undefined, sendEmail: "" },
+      ),
+    ).toEqual({ content: {}, missingRequired: [], invalid: [] });
+  });
+
+  it("flags and excludes mistyped boolean draft values", () => {
+    expect(
+      prepareElicitationContent(
+        {
+          type: "object",
+          properties: { enabled: { type: "boolean" } },
+        },
+        { enabled: "true" },
+      ),
+    ).toEqual({ content: {}, missingRequired: [], invalid: ["enabled"] });
+  });
+
+  it("flags a mistyped required boolean instead of seeding false", () => {
+    expect(
+      prepareElicitationContent(
+        {
+          type: "object",
+          properties: { enabled: { type: "boolean" } },
+          required: ["enabled"],
+        },
+        { enabled: "true" },
+      ),
+    ).toEqual({ content: {}, missingRequired: [], invalid: ["enabled"] });
+  });
+
+  it("treats null drafts as absent for booleans and required fields", () => {
+    expect(
+      prepareElicitationContent(
+        {
+          type: "object",
+          properties: {
+            enabled: { type: "boolean" },
+            query: { type: "string" },
+          },
+          required: ["enabled", "query"],
+        },
+        { enabled: null, query: null },
+      ),
+    ).toEqual({
+      content: { enabled: false },
+      missingRequired: ["query"],
+      invalid: [],
+    });
+  });
+
+  it("treats a cleared numeric draft as absent instead of invalid", () => {
+    expect(
+      prepareElicitationContent(
+        {
+          type: "object",
+          properties: {
+            limit: { type: "number" },
+            count: { type: "integer" },
+          },
+          required: ["limit"],
+        },
+        { limit: "", count: "" },
+      ),
+    ).toEqual({
+      content: {},
+      missingRequired: ["limit"],
+      invalid: [],
+    });
+  });
+
+  it("reports required draft values that resolve to absent", () => {
+    expect(
+      prepareElicitationContent(
+        {
+          type: "object",
+          required: ["name", "email", "ignored"],
+          properties: {},
+        },
+        { name: "", email: "ada@example.com" },
+      ).missingRequired,
+    ).toEqual(["name", "ignored"]);
+  });
+});

package/src/primitives/elicitation/prepareElicitationContent.ts

@@ -0,0 +1,116 @@
+import { validateElicitationContent } from "../../resources/validateElicitationContent";
+
+const isRecord = (value: unknown): value is Record<string, unknown> =>
+  typeof value === "object" && value !== null && !Array.isArray(value);
+
+const coerceValue = (schema: unknown, value: unknown): unknown => {
+  if (!isRecord(schema) || typeof value !== "string") {
+    return value;
+  }
+  if (schema.type !== "number" && schema.type !== "integer") {
+    return value;
+  }
+
+  const number = Number(value);
+  if (value.trim() === "") return value;
+  if (!Number.isFinite(number)) return value;
+  if (schema.type === "integer" && !Number.isInteger(number)) {
+    return value;
+  }
+  return number;
+};
+
+const isBooleanSchema = (schema: unknown): schema is Record<string, unknown> =>
+  isRecord(schema) && schema.type === "boolean";
+
+const isNonStringTypedSchema = (schema: Record<string, unknown>): boolean =>
+  schema.type === "boolean" ||
+  schema.type === "number" ||
+  schema.type === "integer";
+
+const schemaAdmitsEmptyString = (schema: unknown): boolean => {
+  if (!isRecord(schema) || isNonStringTypedSchema(schema)) return false;
+
+  const values = Object.hasOwn(schema, "enum") ? schema.enum : undefined;
+  if (Array.isArray(values)) return values.includes("");
+
+  return Object.hasOwn(schema, "default") && schema.default === "";
+};
+
+const isAbsentDraftValue = (schema: unknown, value: unknown) =>
+  value === undefined ||
+  value === null ||
+  (value === "" && !schemaAdmitsEmptyString(schema));
+
+export const prepareElicitationContent = (
+  requestedSchema: unknown,
+  draft: Record<string, unknown>,
+): {
+  content: Record<string, unknown>;
+  missingRequired: readonly string[];
+  invalid: readonly string[];
+} => {
+  const properties =
+    isRecord(requestedSchema) && isRecord(requestedSchema.properties)
+      ? requestedSchema.properties
+      : {};
+  const candidateContent = Object.fromEntries(
+    Object.entries(draft).flatMap(([name, value]) => {
+      const schema = properties[name];
+      if (isAbsentDraftValue(schema, value)) return [];
+      return [[name, coerceValue(schema, value)]];
+    }),
+  );
+  const missingRequiredBooleans = validateElicitationContent(
+    requestedSchema,
+    candidateContent,
+  ).filter(
+    ({ property }) =>
+      isBooleanSchema(properties[property]) &&
+      !Object.hasOwn(candidateContent, property),
+  );
+  const contentWithBooleanDefaults = {
+    ...candidateContent,
+    ...Object.fromEntries(
+      missingRequiredBooleans.map(({ property }) => [
+        property,
+        typeof properties[property].default === "boolean"
+          ? properties[property].default
+          : false,
+      ]),
+    ),
+  };
+  const validationErrors = validateElicitationContent(
+    requestedSchema,
+    contentWithBooleanDefaults,
+  );
+  const missingRequired = [
+    ...new Set(
+      validationErrors
+        .filter(
+          ({ property }) =>
+            !Object.hasOwn(contentWithBooleanDefaults, property),
+        )
+        .map(({ property }) => property),
+    ),
+  ];
+  const invalid = [
+    ...new Set(
+      validationErrors
+        .filter(({ property }) =>
+          Object.hasOwn(contentWithBooleanDefaults, property),
+        )
+        .map(({ property }) => property),
+    ),
+  ];
+
+  return {
+    content: Object.fromEntries(
+      Object.entries(contentWithBooleanDefaults).filter(
+        ([property]) => !invalid.includes(property),
+      ),
+    ),
+    missingRequired,
+    invalid,
+  };
+};

package/src/primitives/elicitation.ts

@@ -0,0 +1,14 @@
+export {
+  McpElicitationPrimitiveItems as Items,
+  useMcpElicitation,
+} from "./elicitation/McpElicitationPrimitiveItems";
+export { McpElicitationPrimitiveRoot as Root } from "./elicitation/McpElicitationPrimitiveRoot";
+export { McpElicitationPrimitiveMessage as Message } from "./elicitation/McpElicitationPrimitiveMessage";
+export { McpElicitationPrimitiveError as Error } from "./elicitation/McpElicitationPrimitiveError";
+export {
+  McpElicitationPrimitiveFields as Fields,
+  useMcpElicitationField,
+} from "./elicitation/McpElicitationPrimitiveFields";
+export { McpElicitationPrimitiveAccept as Accept } from "./elicitation/McpElicitationPrimitiveAccept";
+export { McpElicitationPrimitiveDecline as Decline } from "./elicitation/McpElicitationPrimitiveDecline";
+export { McpElicitationPrimitiveCancel as Cancel } from "./elicitation/McpElicitationPrimitiveCancel";