@assistant-ui/metro 0.0.1

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 AgentbaseAI Inc.
+
+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,89 @@
+# @assistant-ui/metro
+
+Metro / Expo integration for [assistant-ui](https://www.assistant-ui.com): the
+`"use generative"` directive compiler for React Native. It lets you author tools
+with the **same** [`defineToolkit`](https://www.assistant-ui.com/docs/tools/defining-tools)
+API as on the web: one file colocating a tool's schema, its `execute`, and its
+`render`, then compiles them for the device (and any Expo Router server route).
+
+Works with **Expo** and **bare React Native** (both bundle with Metro).
+
+## Install
+
+```sh
+npm install --save-dev @assistant-ui/metro
+```
+
+## Setup
+
+Wrap your Metro config with `withAui`:
+
+```js
+// metro.config.js
+const { getDefaultConfig } = require("expo/metro-config");
+const { withAui } = require("@assistant-ui/metro");
+
+const config = getDefaultConfig(__dirname);
+
+module.exports = withAui(config);
+```
+
+Bare React Native (without Expo):
+
+```js
+// metro.config.js
+const { getDefaultConfig } = require("@react-native/metro-config");
+const { withAui } = require("@assistant-ui/metro");
+
+module.exports = withAui(getDefaultConfig(__dirname));
+```
+
+## Usage
+
+Author a `"use generative"` toolkit exactly like on the web, importing
+`defineToolkit` from `@assistant-ui/react-native`:
+
+```tsx
+// toolkit.tsx
+"use generative";
+
+import { defineToolkit } from "@assistant-ui/react-native";
+import { z } from "zod";
+import { WeatherCard } from "./WeatherCard";
+
+export default defineToolkit({
+  get_weather: {
+    description: "Get the weather for a city.",
+    parameters: z.object({ city: z.string() }),
+    execute: async ({ city }) => {
+      "use client";
+      return fetchWeather(city);
+    },
+    render: ({ args, result }) => <WeatherCard city={args.city} weather={result} />,
+  },
+});
+```
+
+Register it with `Tools({ toolkit })`, the same as on the web:
+
+```tsx
+import { Tools, useAui } from "@assistant-ui/react-native";
+import toolkit from "./toolkit";
+
+const aui = useAui({ tools: Tools({ toolkit }) });
+```
+
+## How it works
+
+`withAui` points Metro's `babelTransformerPath` at this package's transformer,
+which runs the `"use generative"` compiler and then delegates to your project's
+existing transformer (Expo's or React Native's).
+
+The build target follows Metro's environment: the device app gets the **client**
+build (schema + `render` + frontend `execute`), while an Expo Router `+api`
+route (bundled for a server environment) gets the **server** build (schema +
+backend `execute`). This mirrors [`@assistant-ui/next`](https://www.assistant-ui.com/docs/tools/defining-tools)
+and `@assistant-ui/vite`.
+
+See the [Tools docs](https://www.assistant-ui.com/docs/tools/defining-tools) for
+the full authoring API.

package/dist/index.cjs

@@ -0,0 +1,48 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+//#region src/index.ts
+const require$1 = (0, require("node:module").createRequire)(require("url").pathToFileURL(__filename).href);
+/**
+* Env var the transformer reads to delegate to the project's existing
+* (Expo / React Native) babel transformer. Metro forks its transform workers
+* after `metro.config` is evaluated, so they inherit this value.
+*/
+const UPSTREAM_TRANSFORMER_ENV = "AUI_METRO_UPSTREAM_TRANSFORMER";
+/**
+* Wraps a Metro (or Expo) config so assistant-ui `"use generative"` modules are
+* compiled. Such a file colocates a tool's schema, its `execute`, and its
+* `render` via {@link https://www.assistant-ui.com/docs/tools/defining-tools | defineToolkit}.
+*
+* It points Metro's `babelTransformerPath` at this package's transformer, which
+* runs the `"use generative"` compiler and then delegates to your project's
+* existing transformer. The device (client) build keeps each tool's `render`
+* and any frontend `execute`; a server build (an Expo Router `+api` route)
+* keeps a server `execute` instead.
+*
+* ```js
+* // metro.config.js
+* const { getDefaultConfig } = require("expo/metro-config");
+* const { withAui } = require("@assistant-ui/metro");
+*
+* module.exports = withAui(getDefaultConfig(__dirname));
+* ```
+*
+* Authoring is identical to the web: a `"use generative"` file whose default
+* export is `defineToolkit({ ... })`, registered with `Tools({ toolkit })`.
+*/
+function withAui(config) {
+	const self = require$1.resolve("@assistant-ui/metro/transformer");
+	const upstream = config.transformer?.babelTransformerPath;
+	if (upstream && upstream !== self) process.env[UPSTREAM_TRANSFORMER_ENV] = upstream;
+	return {
+		...config,
+		transformer: {
+			...config.transformer,
+			babelTransformerPath: self
+		}
+	};
+}
+//#endregion
+exports.UPSTREAM_TRANSFORMER_ENV = UPSTREAM_TRANSFORMER_ENV;
+exports.withAui = withAui;
+
+//# sourceMappingURL=index.cjs.map

package/dist/index.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.cjs","names":["require"],"sources":["../src/index.ts"],"sourcesContent":["import { createRequire } from \"node:module\";\n\nconst require = createRequire(import.meta.url);\n\n/**\n * The shape of a Metro / Expo config `withAui` accepts. Typed loosely so this\n * package needs no hard dependency on `metro` or `expo`; the input shape is\n * preserved and only `transformer.babelTransformerPath` is augmented.\n */\nexport type MetroConfigLike = {\n  transformer?:\n    | {\n        babelTransformerPath?: string | undefined;\n        [key: string]: unknown;\n      }\n    | undefined;\n  [key: string]: unknown;\n};\n\n/**\n * Env var the transformer reads to delegate to the project's existing\n * (Expo / React Native) babel transformer. Metro forks its transform workers\n * after `metro.config` is evaluated, so they inherit this value.\n */\nexport const UPSTREAM_TRANSFORMER_ENV = \"AUI_METRO_UPSTREAM_TRANSFORMER\";\n\n/**\n * Wraps a Metro (or Expo) config so assistant-ui `\"use generative\"` modules are\n * compiled. Such a file colocates a tool's schema, its `execute`, and its\n * `render` via {@link https://www.assistant-ui.com/docs/tools/defining-tools | defineToolkit}.\n *\n * It points Metro's `babelTransformerPath` at this package's transformer, which\n * runs the `\"use generative\"` compiler and then delegates to your project's\n * existing transformer. The device (client) build keeps each tool's `render`\n * and any frontend `execute`; a server build (an Expo Router `+api` route)\n * keeps a server `execute` instead.\n *\n * ```js\n * // metro.config.js\n * const { getDefaultConfig } = require(\"expo/metro-config\");\n * const { withAui } = require(\"@assistant-ui/metro\");\n *\n * module.exports = withAui(getDefaultConfig(__dirname));\n * ```\n *\n * Authoring is identical to the web: a `\"use generative\"` file whose default\n * export is `defineToolkit({ ... })`, registered with `Tools({ toolkit })`.\n */\nexport function withAui<T extends MetroConfigLike>(config: T): T {\n  const self = require.resolve(\"@assistant-ui/metro/transformer\");\n  const upstream = config.transformer?.babelTransformerPath;\n\n  // Guard against a double-wrap (`withAui(withAui(config))`, or a shared config\n  // already wrapped): if it already points at our transformer, keep the real\n  // upstream captured earlier rather than overwriting it with our own path,\n  // which would make `resolveUpstream()` return this transformer and recurse.\n  if (upstream && upstream !== self) {\n    process.env[UPSTREAM_TRANSFORMER_ENV] = upstream;\n  }\n\n  return {\n    ...config,\n    transformer: {\n      ...config.transformer,\n      babelTransformerPath: self,\n    },\n  };\n}\n"],"mappings":";;AAEA,MAAMA,aAAAA,wBAAAA,EAAAA,eAAAA,QAAAA,KAAAA,EAAAA,cAAAA,UAAAA,EAAAA,IAAuC;;;;;;AAsB7C,MAAa,2BAA2B;;;;;;;;;;;;;;;;;;;;;;;AAwBxC,SAAgB,QAAmC,QAAc;CAC/D,MAAM,OAAOA,UAAQ,QAAQ,iCAAiC;CAC9D,MAAM,WAAW,OAAO,aAAa;CAMrC,IAAI,YAAY,aAAa,MAC3B,QAAQ,IAAI,4BAA4B;CAG1C,OAAO;EACL,GAAG;EACH,aAAa;GACX,GAAG,OAAO;GACV,sBAAsB;EACxB;CACF;AACF"}

package/dist/index.d.cts

@@ -0,0 +1,45 @@
+//#region src/index.d.ts
+/**
+ * The shape of a Metro / Expo config `withAui` accepts. Typed loosely so this
+ * package needs no hard dependency on `metro` or `expo`; the input shape is
+ * preserved and only `transformer.babelTransformerPath` is augmented.
+ */
+type MetroConfigLike = {
+  transformer?: {
+    babelTransformerPath?: string | undefined;
+    [key: string]: unknown;
+  } | undefined;
+  [key: string]: unknown;
+};
+/**
+ * Env var the transformer reads to delegate to the project's existing
+ * (Expo / React Native) babel transformer. Metro forks its transform workers
+ * after `metro.config` is evaluated, so they inherit this value.
+ */
+declare const UPSTREAM_TRANSFORMER_ENV = "AUI_METRO_UPSTREAM_TRANSFORMER";
+/**
+ * Wraps a Metro (or Expo) config so assistant-ui `"use generative"` modules are
+ * compiled. Such a file colocates a tool's schema, its `execute`, and its
+ * `render` via {@link https://www.assistant-ui.com/docs/tools/defining-tools | defineToolkit}.
+ *
+ * It points Metro's `babelTransformerPath` at this package's transformer, which
+ * runs the `"use generative"` compiler and then delegates to your project's
+ * existing transformer. The device (client) build keeps each tool's `render`
+ * and any frontend `execute`; a server build (an Expo Router `+api` route)
+ * keeps a server `execute` instead.
+ *
+ * ```js
+ * // metro.config.js
+ * const { getDefaultConfig } = require("expo/metro-config");
+ * const { withAui } = require("@assistant-ui/metro");
+ *
+ * module.exports = withAui(getDefaultConfig(__dirname));
+ * ```
+ *
+ * Authoring is identical to the web: a `"use generative"` file whose default
+ * export is `defineToolkit({ ... })`, registered with `Tools({ toolkit })`.
+ */
+declare function withAui<T extends MetroConfigLike>(config: T): T;
+//#endregion
+export { MetroConfigLike, UPSTREAM_TRANSFORMER_ENV, withAui };
+//# sourceMappingURL=index.d.cts.map

package/dist/index.d.cts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.cts","names":[],"sources":["../src/index.ts"],"mappings":";;AASA;;;;KAAY,eAAA;EACV,WAAA;IAEM,oBAAA;IAAA,CACC,GAAA;EAAA;EAAA,CAGN,GAAA;AAAA;;;;AAQkC;AAwBrC;cAxBa,wBAAA;;;;;;;;;;;;;AAwBmD;;;;;;;;;;iBAAhD,OAAA,WAAkB,eAAA,EAAiB,MAAA,EAAQ,CAAA,GAAI,CAAA"}