@rendkit/copilotkit 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Rendkit
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,51 @@
+# @rendkit/copilotkit
+
+The [CopilotKit v2](https://copilotkit.ai) adapter for the
+[Rendkit](https://github.com/rendkit-ui/rendkit) agentic component catalog.
+
+CopilotKit ships the sockets (`useFrontendTool`, `useHumanInTheLoop`); Rendkit is
+the components you bring. This package binds a Rendkit catalog to CopilotKit and
+exposes only that value-add — it never re-exports CopilotKit's own runtime or
+client primitives, so your host owns the `@copilotkit/*` version directly.
+
+- `RegisterCatalog` — mount one registration wrapper per catalog def; display
+  defs register via `useFrontendTool`, interactive defs via `useHumanInTheLoop`.
+- Every render path runs `schema.safeParse` and degrades to a `FallbackCard` on
+  invalid args (CopilotKit does no runtime validation of tool args).
+- `checkSchemaBudget` / `checkSchemaPortability` — advertised-schema byte budget
+  and the portable tool-schema subset check, for tests and `/debug` surfaces.
+
+## Install
+
+```bash
+npm install @rendkit/copilotkit @rendkit/core
+# peers you already own as a CopilotKit v2 host:
+npm install @copilotkit/react-core@1.62.3 react zod
+```
+
+## Usage
+
+```tsx
+"use client";
+
+import { RegisterCatalog } from "@rendkit/copilotkit";
+import "@rendkit/copilotkit/styles.css";
+import { createCatalogRegistry } from "./catalog"; // your copied catalog
+
+const registry = createCatalogRegistry();
+
+export function Chat() {
+  return <RegisterCatalog registry={registry} />;
+}
+```
+
+The package is **ESM-only** — any CopilotKit v2 host is ESM-capable by
+construction (the upstream runtime is ESM-only). Client components ship with the
+`"use client"` directive preserved, so they import cleanly in Next.js App Router
+without `transpilePackages`.
+
+Subpath exports: `.`, `./fallback-card`, `./schema`, `./styles.css`.
+
+## License
+
+MIT

package/dist/display-tool.d.ts

@@ -0,0 +1,16 @@
+import { ComponentType } from 'react';
+import { ComponentDef } from '@rendkit/core';
+import { RndDebugEvent } from './tool-bridge.js';
+import { FallbackProps } from './fallback-card.js';
+import './upstream.js';
+import 'zod';
+import '@copilotkit/react-core/v2';
+
+type DisplayToolProps = {
+    def: ComponentDef;
+    fallback?: ComponentType<FallbackProps>;
+    onEvent?: (event: RndDebugEvent) => void;
+};
+declare const DisplayTool: ({ def, fallback, onEvent }: DisplayToolProps) => null;
+
+export { DisplayTool };

package/dist/display-tool.js

@@ -0,0 +1,17 @@
+"use client";
+import { jsx } from "react/jsx-runtime";
+import { useFrontendTool } from "./upstream";
+import { ToolBridge } from "./tool-bridge";
+const DisplayTool = ({ def, fallback, onEvent }) => {
+  useFrontendTool({
+    name: def.name,
+    description: def.description,
+    parameters: def.parameters,
+    handler: async () => ({ displayed: true }),
+    render: (props) => /* @__PURE__ */ jsx(ToolBridge, { def, upstream: props, fallback, onEvent })
+  });
+  return null;
+};
+export {
+  DisplayTool
+};

package/dist/fallback-card.d.ts

@@ -0,0 +1,9 @@
+import * as react from 'react';
+
+type FallbackProps = {
+    toolName: string;
+    args: unknown;
+};
+declare const FallbackCard: ({ toolName, args }: FallbackProps) => react.JSX.Element;
+
+export { FallbackCard, type FallbackProps };

package/dist/fallback-card.js

@@ -0,0 +1,45 @@
+import { jsx, jsxs } from "react/jsx-runtime";
+const cardStyle = {
+  background: "var(--gk-card, var(--card, transparent))",
+  color: "var(--gk-card-foreground, var(--card-foreground, inherit))",
+  border: "1px solid var(--gk-border, var(--border, currentColor))",
+  borderRadius: "var(--gk-radius, var(--radius, 0.5rem))",
+  padding: "12px 16px",
+  fontSize: "0.875rem",
+  lineHeight: 1.5
+};
+const summaryStyle = {
+  cursor: "pointer",
+  color: "var(--gk-muted-foreground, var(--muted-foreground, inherit))",
+  fontSize: "0.75rem"
+};
+const argsStyle = {
+  margin: "8px 0 0",
+  padding: 8,
+  maxHeight: 240,
+  overflow: "auto",
+  // chat clips at 768px with no horizontal scroll — scroll internally
+  fontSize: "0.75rem",
+  background: "var(--gk-muted, var(--muted, transparent))",
+  borderRadius: "var(--gk-radius, var(--radius, 0.5rem))"
+};
+function safeStringify(value) {
+  try {
+    return JSON.stringify(value, null, 2) ?? String(value);
+  } catch {
+    return String(value);
+  }
+}
+const FallbackCard = ({ toolName, args }) => /* @__PURE__ */ jsxs("div", { role: "status", style: cardStyle, children: [
+  /* @__PURE__ */ jsxs("p", { style: { margin: 0 }, children: [
+    /* @__PURE__ */ jsx("strong", { children: toolName }),
+    " couldn't render this response."
+  ] }),
+  /* @__PURE__ */ jsxs("details", { style: { marginTop: 8 }, children: [
+    /* @__PURE__ */ jsx("summary", { style: summaryStyle, children: "Raw arguments" }),
+    /* @__PURE__ */ jsx("pre", { style: argsStyle, children: safeStringify(args) })
+  ] })
+] });
+export {
+  FallbackCard
+};

package/dist/index.d.ts

@@ -0,0 +1,12 @@
+export { RegisterCatalog } from './register-catalog.js';
+export { DisplayTool } from './display-tool.js';
+export { InteractiveTool } from './interactive-tool.js';
+export { RndDebugEvent, ToolBridge } from './tool-bridge.js';
+export { FallbackCard, FallbackProps } from './fallback-card.js';
+export { MAX_DEF_SCHEMA_BYTES, MAX_REGISTRY_SCHEMA_BYTES, SchemaBudgetReport, checkSchemaBudget, serializeAdvertisedTool, serializedToolSchemaBytes } from './schema-budget.js';
+export { SchemaPortabilityReport, checkSchemaPortability } from './schema-portability.js';
+import 'react';
+import '@rendkit/core';
+import './upstream.js';
+import 'zod';
+import '@copilotkit/react-core/v2';

package/dist/index.js

@@ -0,0 +1,28 @@
+import { RegisterCatalog } from "./register-catalog";
+import { DisplayTool } from "./display-tool";
+import { InteractiveTool } from "./interactive-tool";
+import { ToolBridge } from "./tool-bridge";
+import { FallbackCard } from "./fallback-card";
+import {
+  MAX_DEF_SCHEMA_BYTES,
+  MAX_REGISTRY_SCHEMA_BYTES,
+  checkSchemaBudget,
+  serializeAdvertisedTool,
+  serializedToolSchemaBytes
+} from "./schema-budget";
+import {
+  checkSchemaPortability
+} from "./schema-portability";
+export {
+  DisplayTool,
+  FallbackCard,
+  InteractiveTool,
+  MAX_DEF_SCHEMA_BYTES,
+  MAX_REGISTRY_SCHEMA_BYTES,
+  RegisterCatalog,
+  ToolBridge,
+  checkSchemaBudget,
+  checkSchemaPortability,
+  serializeAdvertisedTool,
+  serializedToolSchemaBytes
+};

package/dist/interactive-tool.d.ts

@@ -0,0 +1,16 @@
+import { ComponentType } from 'react';
+import { ComponentDef } from '@rendkit/core';
+import { RndDebugEvent } from './tool-bridge.js';
+import { FallbackProps } from './fallback-card.js';
+import './upstream.js';
+import 'zod';
+import '@copilotkit/react-core/v2';
+
+type InteractiveToolProps = {
+    def: ComponentDef;
+    fallback?: ComponentType<FallbackProps>;
+    onEvent?: (event: RndDebugEvent) => void;
+};
+declare const InteractiveTool: ({ def, fallback, onEvent }: InteractiveToolProps) => null;
+
+export { InteractiveTool };

package/dist/interactive-tool.js

@@ -0,0 +1,16 @@
+"use client";
+import { jsx } from "react/jsx-runtime";
+import { useHumanInTheLoop } from "./upstream";
+import { ToolBridge } from "./tool-bridge";
+const InteractiveTool = ({ def, fallback, onEvent }) => {
+  useHumanInTheLoop({
+    name: def.name,
+    description: def.description,
+    parameters: def.parameters,
+    render: (props) => /* @__PURE__ */ jsx(ToolBridge, { def, upstream: props, fallback, onEvent })
+  });
+  return null;
+};
+export {
+  InteractiveTool
+};

package/dist/register-catalog.d.ts

@@ -0,0 +1,17 @@
+import * as react from 'react';
+import { ComponentType } from 'react';
+import { ComponentRegistry } from '@rendkit/core';
+import { FallbackProps } from './fallback-card.js';
+import { RndDebugEvent } from './tool-bridge.js';
+import './upstream.js';
+import 'zod';
+import '@copilotkit/react-core/v2';
+
+type RegisterCatalogProps = {
+    registry: ComponentRegistry;
+    fallback?: ComponentType<FallbackProps>;
+    onEvent?: (event: RndDebugEvent) => void;
+};
+declare const RegisterCatalog: ({ registry, fallback, onEvent }: RegisterCatalogProps) => react.JSX.Element;
+
+export { RegisterCatalog };

package/dist/register-catalog.js

@@ -0,0 +1,10 @@
+"use client";
+import { Fragment, jsx } from "react/jsx-runtime";
+import { DisplayTool } from "./display-tool";
+import { InteractiveTool } from "./interactive-tool";
+const RegisterCatalog = ({ registry, fallback, onEvent }) => /* @__PURE__ */ jsx(Fragment, { children: registry.defs.map(
+  (def) => def.kind === "display" ? /* @__PURE__ */ jsx(DisplayTool, { def, fallback, onEvent }, def.name) : /* @__PURE__ */ jsx(InteractiveTool, { def, fallback, onEvent }, def.name)
+) });
+export {
+  RegisterCatalog
+};

package/dist/respond.d.ts

@@ -0,0 +1,11 @@
+import { RndEvent } from '@rendkit/core';
+
+type CreateRespondParams = {
+    tool: string;
+    toolCallId: string;
+    events: readonly string[];
+    send: (envelope: RndEvent) => Promise<void>;
+};
+declare function createRespond({ tool, toolCallId, events, send, }: CreateRespondParams): (action: string, payload?: unknown) => Promise<void>;
+
+export { type CreateRespondParams, createRespond };

package/dist/respond.js

@@ -0,0 +1,22 @@
+function createRespond({
+  tool,
+  toolCallId,
+  events,
+  send
+}) {
+  let consumed = false;
+  return async (action, payload) => {
+    if (!events.includes(action)) {
+      throw new Error(
+        `respond: action "${action}" is not declared in events of "${tool}" (allowed: ${events.join(", ")})`
+      );
+    }
+    if (consumed) return;
+    consumed = true;
+    const envelope = { tool, toolCallId, action, payload: payload ?? null };
+    await send(envelope);
+  };
+}
+export {
+  createRespond
+};

package/dist/schema-budget.d.ts

@@ -0,0 +1,22 @@
+import { ComponentDef } from '@rendkit/core';
+export { SchemaPortabilityReport, checkSchemaPortability } from './schema-portability.js';
+
+declare const MAX_DEF_SCHEMA_BYTES = 1536;
+declare const MAX_REGISTRY_SCHEMA_BYTES: number;
+type SchemaBudgetReport = {
+    perDef: {
+        name: string;
+        bytes: number;
+    }[];
+    totalBytes: number;
+    violations: string[];
+};
+declare function serializeAdvertisedTool(def: Pick<ComponentDef, "name" | "description" | "parameters">): {
+    name: string;
+    description: string;
+    parameters: unknown;
+};
+declare function serializedToolSchemaBytes(def: Pick<ComponentDef, "name" | "description" | "parameters">): number;
+declare function checkSchemaBudget(defs: readonly ComponentDef[]): SchemaBudgetReport;
+
+export { MAX_DEF_SCHEMA_BYTES, MAX_REGISTRY_SCHEMA_BYTES, type SchemaBudgetReport, checkSchemaBudget, serializeAdvertisedTool, serializedToolSchemaBytes };

package/dist/schema-budget.js

@@ -0,0 +1,38 @@
+import { zodToJsonSchema } from "zod-to-json-schema";
+import { checkSchemaPortability } from "./schema-portability";
+const MAX_DEF_SCHEMA_BYTES = 1536;
+const MAX_REGISTRY_SCHEMA_BYTES = 25 * 1024;
+function serializeAdvertisedTool(def) {
+  return {
+    name: def.name,
+    description: def.description,
+    parameters: zodToJsonSchema(def.parameters)
+  };
+}
+function serializedToolSchemaBytes(def) {
+  return new TextEncoder().encode(JSON.stringify(serializeAdvertisedTool(def))).length;
+}
+function checkSchemaBudget(defs) {
+  const perDef = defs.map((def) => ({
+    name: def.name,
+    bytes: serializedToolSchemaBytes(def)
+  }));
+  const totalBytes = perDef.reduce((sum, entry) => sum + entry.bytes, 0);
+  const violations = perDef.filter((entry) => entry.bytes > MAX_DEF_SCHEMA_BYTES).map(
+    (entry) => `def "${entry.name}" schema is ${entry.bytes} bytes (budget ${MAX_DEF_SCHEMA_BYTES})`
+  );
+  if (totalBytes > MAX_REGISTRY_SCHEMA_BYTES) {
+    violations.push(
+      `registry total is ${totalBytes} bytes (budget ${MAX_REGISTRY_SCHEMA_BYTES})`
+    );
+  }
+  return { perDef, totalBytes, violations };
+}
+export {
+  MAX_DEF_SCHEMA_BYTES,
+  MAX_REGISTRY_SCHEMA_BYTES,
+  checkSchemaBudget,
+  checkSchemaPortability,
+  serializeAdvertisedTool,
+  serializedToolSchemaBytes
+};

package/dist/schema-portability.d.ts

@@ -0,0 +1,9 @@
+import { ComponentDef } from '@rendkit/core';
+
+type DefLike = Pick<ComponentDef, "name" | "description" | "parameters">;
+type SchemaPortabilityReport = {
+    violations: string[];
+};
+declare function checkSchemaPortability(defs: readonly DefLike[]): SchemaPortabilityReport;
+
+export { type SchemaPortabilityReport, checkSchemaPortability };

package/dist/schema-portability.js

@@ -0,0 +1,60 @@
+import { zodToJsonSchema } from "zod-to-json-schema";
+const PORTABLE_LEAF_TYPES = /* @__PURE__ */ new Set(["string", "number", "integer", "boolean"]);
+function checkSchemaPortability(defs) {
+  const violations = [];
+  for (const def of defs) {
+    walk(zodToJsonSchema(def.parameters), `${def.name}:`, violations);
+  }
+  return { violations };
+}
+function walk(node, path, violations) {
+  if (typeof node !== "object" || node === null) {
+    violations.push(`${path} unsupported non-object schema node`);
+    return;
+  }
+  const schema = node;
+  for (const combinator of ["anyOf", "oneOf", "allOf", "not"]) {
+    if (combinator in schema) {
+      violations.push(`${path} uses ${combinator} (type union/composition \u2014 not in the portable subset)`);
+      return;
+    }
+  }
+  const type = schema.type;
+  if (Array.isArray(type)) {
+    violations.push(`${path} declares a type union ${JSON.stringify(type)} (anyOf-equivalent)`);
+    return;
+  }
+  if (type === "object") {
+    const additional = schema.additionalProperties;
+    if (additional !== void 0 && additional !== false) {
+      violations.push(`${path} allows dynamic-key records via additionalProperties`);
+      return;
+    }
+    const properties = schema.properties;
+    if (typeof properties !== "object" || properties === null || Object.keys(properties).length === 0) {
+      violations.push(`${path} is an object without fixed keys (empty/free-form objects are rejected)`);
+      return;
+    }
+    for (const [key, child] of Object.entries(properties)) {
+      walk(child, `${path}.${key}`, violations);
+    }
+    return;
+  }
+  if (type === "array") {
+    if (schema.items === void 0) {
+      violations.push(`${path} is an array without an items schema`);
+      return;
+    }
+    walk(schema.items, `${path}[]`, violations);
+    return;
+  }
+  if (typeof type === "string" && PORTABLE_LEAF_TYPES.has(type)) {
+    return;
+  }
+  violations.push(
+    `${path} has unsupported type ${JSON.stringify(type ?? "(none)")} \u2014 portable leaves are string/number/integer/boolean`
+  );
+}
+export {
+  checkSchemaPortability
+};

package/dist/status.d.ts

@@ -0,0 +1,5 @@
+import { RndStatus } from '@rendkit/core';
+
+declare function toRndStatus(status: string): RndStatus;
+
+export { toRndStatus };

package/dist/status.js

@@ -0,0 +1,9 @@
+function toRndStatus(status) {
+  if (status === "inProgress" || status === "executing" || status === "complete") {
+    return status;
+  }
+  throw new Error(`Unknown upstream tool call status "${status}"`);
+}
+export {
+  toRndStatus
+};

package/dist/styles.css

@@ -0,0 +1,6 @@
+/*
+ * Chat UI stylesheet seam. Hosts import THIS file, never the upstream path
+ * directly (CLAUDE.md #9 — the boundary script does not scan CSS, but the
+ * one-file-fix discipline applies to stylesheets the same way).
+ */
+@import "@copilotkit/react-core/v2/styles.css";

package/dist/tool-bridge.d.ts

@@ -0,0 +1,23 @@
+import * as react from 'react';
+import { ComponentType } from 'react';
+import { ComponentDef } from '@rendkit/core';
+import { UpstreamRenderProps } from './upstream.js';
+import { FallbackProps } from './fallback-card.js';
+import 'zod';
+import '@copilotkit/react-core/v2';
+
+type RndDebugEvent = {
+    tool: string;
+    toolCallId: string;
+    kind: ComponentDef["kind"];
+    result: unknown;
+};
+type ToolBridgeProps = {
+    def: ComponentDef;
+    upstream: UpstreamRenderProps;
+    fallback?: ComponentType<FallbackProps>;
+    onEvent?: (event: RndDebugEvent) => void;
+};
+declare const ToolBridge: ({ def, upstream, fallback, onEvent }: ToolBridgeProps) => react.JSX.Element;
+
+export { type RndDebugEvent, ToolBridge };

package/dist/tool-bridge.js

@@ -0,0 +1,79 @@
+"use client";
+import { jsx } from "react/jsx-runtime";
+import { useEffect, useMemo } from "react";
+import { toRndStatus } from "./status";
+import { createRespond } from "./respond";
+import { FallbackCard } from "./fallback-card";
+const ToolBridge = ({ def, upstream, fallback, onEvent }) => {
+  const status = toRndStatus(upstream.status);
+  const upstreamRespond = upstream.respond;
+  const respond = useMemo(
+    () => upstreamRespond === void 0 ? void 0 : createRespond({
+      tool: def.name,
+      toolCallId: upstream.toolCallId,
+      events: def.events ?? [],
+      send: upstreamRespond
+    }),
+    [def, upstream.toolCallId, upstreamRespond]
+  );
+  const result = useMemo(() => parseUpstreamResult(upstream.result), [upstream.result]);
+  const toolCallId = upstream.toolCallId;
+  useEffect(() => {
+    if (status === "complete" && result !== void 0) {
+      onEvent?.({ tool: def.name, toolCallId, kind: def.kind, result });
+    }
+  }, [status, result, def.name, def.kind, toolCallId, onEvent]);
+  const Component = def.component;
+  if (status === "inProgress") {
+    return /* @__PURE__ */ jsx(
+      Component,
+      {
+        args: toPartialArgs(upstream.args),
+        status,
+        toolCallId: upstream.toolCallId,
+        surface: "chat"
+      }
+    );
+  }
+  const parsed = def.parameters.safeParse(upstream.args);
+  if (!parsed.success) {
+    warnInvalidArgs(def.name, upstream.toolCallId, parsed.error);
+    const Fallback = fallback ?? FallbackCard;
+    return /* @__PURE__ */ jsx(Fallback, { toolName: def.name, args: upstream.args });
+  }
+  return /* @__PURE__ */ jsx(
+    Component,
+    {
+      args: parsed.data,
+      status,
+      toolCallId: upstream.toolCallId,
+      surface: "chat",
+      respond: status === "executing" ? respond : void 0,
+      result
+    }
+  );
+};
+function toPartialArgs(value) {
+  if (typeof value === "object" && value !== null && !Array.isArray(value)) {
+    return value;
+  }
+  return {};
+}
+function parseUpstreamResult(result) {
+  if (result === void 0 || result === "") return void 0;
+  try {
+    return JSON.parse(result);
+  } catch {
+    return result;
+  }
+}
+function warnInvalidArgs(tool, toolCallId, error) {
+  console.warn("[rendkit] tool args failed schema validation; rendering FallbackCard", {
+    tool,
+    toolCallId,
+    issues: error.issues
+  });
+}
+export {
+  ToolBridge
+};

package/dist/upstream.d.ts

@@ -0,0 +1,21 @@
+import { ReactElement } from 'react';
+import { z } from 'zod';
+export { useFrontendTool, useHumanInTheLoop } from '@copilotkit/react-core/v2';
+
+type UpstreamRenderProps = {
+    name: string;
+    toolCallId: string;
+    args: unknown;
+    status: string;
+    result: string | undefined;
+    respond?: (result: unknown) => Promise<void>;
+};
+type UpstreamToolConfig = {
+    name: string;
+    description: string;
+    parameters: z.ZodTypeAny;
+    handler?: (args: unknown) => Promise<unknown>;
+    render: (props: UpstreamRenderProps) => ReactElement | null;
+};
+
+export type { UpstreamRenderProps, UpstreamToolConfig };

package/dist/upstream.js

@@ -0,0 +1,5 @@
+import { useFrontendTool, useHumanInTheLoop } from "@copilotkit/react-core/v2";
+export {
+  useFrontendTool,
+  useHumanInTheLoop
+};

package/package.json

@@ -0,0 +1,78 @@
+{
+  "name": "@rendkit/copilotkit",
+  "version": "0.1.0",
+  "description": "CopilotKit v2 adapter for the Rendkit agentic component catalog — RegisterCatalog, the display/interactive tool bridges, the schema byte budget, and the portable-schema check.",
+  "keywords": [
+    "rendkit",
+    "copilotkit",
+    "agentic",
+    "generative-ui",
+    "ai",
+    "react",
+    "human-in-the-loop",
+    "shadcn"
+  ],
+  "license": "MIT",
+  "author": "Houssem Djeghri",
+  "homepage": "https://github.com/rendkit-ui/rendkit#readme",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/rendkit-ui/rendkit.git",
+    "directory": "packages/copilotkit"
+  },
+  "type": "module",
+  "sideEffects": [
+    "**/*.css"
+  ],
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js"
+    },
+    "./fallback-card": {
+      "types": "./dist/fallback-card.d.ts",
+      "import": "./dist/fallback-card.js"
+    },
+    "./schema": {
+      "types": "./dist/schema-budget.d.ts",
+      "import": "./dist/schema-budget.js"
+    },
+    "./styles.css": "./dist/styles.css"
+  },
+  "files": [
+    "dist",
+    "LICENSE",
+    "README.md"
+  ],
+  "engines": {
+    "node": ">=18"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "dependencies": {
+    "zod-to-json-schema": "^3.25.2",
+    "@rendkit/core": "^0.1.0"
+  },
+  "peerDependencies": {
+    "@copilotkit/react-core": "1.62.3",
+    "react": "^18 || ^19",
+    "zod": "^3.25.0"
+  },
+  "devDependencies": {
+    "@copilotkit/react-core": "1.62.3",
+    "@testing-library/react": "^16.3.2",
+    "@types/react": "^19.1.0",
+    "happy-dom": "^20.10.6",
+    "react": "^19.1.0",
+    "react-dom": "^19.1.0",
+    "zod": "^3.25.76"
+  },
+  "scripts": {
+    "build": "tsup",
+    "typecheck": "tsc --noEmit",
+    "test": "vitest run"
+  },
+  "module": "./dist/index.js"
+}