@yak-io/trpc 0.1.0

package/LICENSE

@@ -0,0 +1,36 @@
+Yak Proprietary License
+
+Copyright (c) 2025 Yak. All rights reserved.
+
+This software and associated documentation files (the "Software") are the
+proprietary property of Yak and are protected by copyright law.
+
+GRANT OF LICENSE:
+Subject to the terms of this license and your valid subscription or agreement
+with Yak, you are granted a limited, non-exclusive, non-transferable license
+to use the Software solely for integrating the Yak chatbot widget into your
+applications as intended and documented.
+
+RESTRICTIONS:
+You may NOT:
+- Modify, adapt, alter, translate, or create derivative works of the Software
+- Reverse engineer, disassemble, decompile, or otherwise attempt to derive
+  the source code of the Software
+- Redistribute, sublicense, lease, rent, or lend the Software to third parties
+- Remove or alter any proprietary notices, labels, or marks on the Software
+- Use the Software for any purpose other than as expressly permitted herein
+
+NO WARRANTY:
+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 YAK
+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.
+
+TERMINATION:
+This license is effective until terminated. Your rights under this license
+will terminate automatically without notice if you fail to comply with any
+of its terms.
+
+For licensing inquiries, contact: support@yak.io

package/README.md

@@ -0,0 +1,103 @@
+# @yak-io/trpc
+
+Adapters that turn tRPC procedures into Yak tool definitions. This package plugs directly into `@yak-io/javascript` and works seamlessly with the Next.js helpers.
+
+## What you get
+
+- `createTRPCToolExecutor` – a thin wrapper that turns procedure names into a tool executor function.
+- `createTRPCToolAdapter` – a higher level helper that returns a full `ToolSource` (manifest + executor) that can be passed straight into `createYakHandler` or `createNextYakHandler`.
+- `buildToolManifest` – introspection utility used by the adapter (exposed for custom pipelines).
+
+## Installation
+
+```bash
+pnpm add @yak-io/trpc @yak-io/javascript
+```
+
+You also need `@trpc/server` (v10+ or v11+) in your project.
+
+## Usage
+
+### 1. Build a tRPC adapter
+
+By default, all procedures from your router are exposed as tools:
+
+```ts
+import { createTRPCToolAdapter } from "@yak-io/trpc";
+import { appRouter, createContext } from "@/server/trpc";
+
+// All procedures are available
+const trpcTools = createTRPCToolAdapter({
+  router: appRouter,
+  createContext: async ({ req }) => createContext({ req }),
+});
+```
+
+#### Restricting procedures
+
+Use `allowedProcedures` to whitelist specific procedures:
+
+```ts
+const trpcTools = createTRPCToolAdapter({
+  router: appRouter,
+  createContext: async ({ req }) => createContext({ req }),
+  allowedProcedures: ["orders.list", "orders.detail"],
+});
+```
+
+Use `disallowedProcedures` to block specific procedures while allowing the rest:
+
+```ts
+const trpcTools = createTRPCToolAdapter({
+  router: appRouter,
+  createContext: async ({ req }) => createContext({ req }),
+  disallowedProcedures: ["admin.deleteUser", "billing.refund"],
+});
+```
+
+### 2. Attach it to a Yak handler
+
+```ts
+import { createYakHandler } from "@yak-io/javascript/server";
+
+export const { GET, POST } = createYakHandler({
+  routes: () => Promise.resolve([{ path: "/" }]),
+  tools: trpcTools,
+});
+```
+
+If you are in a Next.js app, simply pass the adapter to `createNextYakHandler` instead.
+
+### 3. Executor only
+
+If you already generate manifests elsewhere you can still use the lower level executor helper:
+
+```ts
+import { createTRPCToolExecutor } from "@yak-io/trpc";
+
+const executeTool = createTRPCToolExecutor({
+  router: appRouter,
+  createContext,
+  allowedProcedures: ["orders.list"],
+});
+```
+
+Then supply `getTools` + `executeTool` to any Yak handler.
+
+## Types
+
+All tool/route/chat config types are re-exported from `@yak-io/javascript/server`, e.g.
+
+```ts
+import type { ToolDefinition, ToolManifest, ToolExecutor } from "@yak-io/trpc";
+```
+
+## Security tips
+
+- For production apps, consider using `allowedProcedures` to restrict to the minimal surface area needed by the assistant, or use `disallowedProcedures` to block sensitive operations.
+- Build per-request contexts so each call is authorized with the user session from `req`.
+- Combine the adapter with additional `ToolSource`s (e.g., GraphQL or REST) by passing arrays to `createYakHandler` / `createNextYakHandler`.
+
+## License
+
+Proprietary - see LICENSE file

package/dist/adapters.d.ts

@@ -0,0 +1,63 @@
+import type { AnyRouter } from "@trpc/server";
+import type { ToolExecutor, ToolSource } from "@yak-io/javascript/server";
+/**
+ * Generic request type that works with Next.js Request
+ */
+export type GenericRequest = {
+    json(): Promise<unknown>;
+};
+/**
+ * Configuration for creating a tRPC tool executor
+ */
+export type TRPCToolExecutorConfig<TRouter extends AnyRouter, TContext, TRequest extends GenericRequest = GenericRequest> = {
+    /** tRPC router instance */
+    router: TRouter;
+    /** Function to create tRPC context from request */
+    createContext: (opts: {
+        req: TRequest;
+    }) => Promise<TContext>;
+    /**
+     * List of allowed procedure paths, e.g. ["orders.list", "user.updateProfile"].
+     * If provided, only these procedures can be invoked as tools.
+     * If omitted, all procedures are allowed by default.
+     */
+    allowedProcedures?: string[];
+    /**
+     * List of disallowed procedure paths, e.g. ["admin.deleteUser", "billing.refund"].
+     * These procedures will be excluded even if they would otherwise be allowed.
+     * Applied after allowedProcedures filtering.
+     */
+    disallowedProcedures?: string[];
+};
+/**
+ * Creates a tool executor function that uses tRPC to execute procedures
+ *
+ * This adapter allows you to use tRPC procedures as chatbot tools with the
+ * Next.js handler from @yak-io/nextjs/server
+ *
+ * @example
+ * ```ts
+ * // app/api/yak/tools/route.ts
+ * import { createNextYakToolsHandler } from "@yak-io/nextjs/server";
+ * import { createTRPCToolExecutor } from "@yak-io/trpc";
+ * import { appRouter } from "@/server/trpc/router";
+ * import { createContext } from "@/server/trpc/context";
+ *
+ * export const POST = createNextYakToolsHandler({
+ *   executeTool: createTRPCToolExecutor({
+ *     router: appRouter,
+ *     createContext,
+ *     allowedProcedures: ["orders.list", "user.updateProfile"],
+ *   }),
+ * });
+ * ```
+ */
+export declare function createTRPCToolExecutor<TRouter extends AnyRouter, TContext, TRequest extends GenericRequest = GenericRequest>(config: TRPCToolExecutorConfig<TRouter, TContext, TRequest>): ToolExecutor;
+export type TRPCToolAdapterConfig<TRouter extends AnyRouter, TContext, TRequest extends GenericRequest = GenericRequest> = TRPCToolExecutorConfig<TRouter, TContext, TRequest> & {
+    id?: string;
+};
+/**
+ * Create a core compatible tool source that bundles manifest + executor
+ */
+export declare function createTRPCToolAdapter<TRouter extends AnyRouter, TContext, TRequest extends GenericRequest = GenericRequest>(config: TRPCToolAdapterConfig<TRouter, TContext, TRequest>): ToolSource;
+//# sourceMappingURL=adapters.d.ts.map

package/dist/adapters.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"adapters.d.ts","sourceRoot":"","sources":["../src/adapters.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,cAAc,CAAC;AAE9C,OAAO,KAAK,EAAE,YAAY,EAAE,UAAU,EAAE,MAAM,2BAA2B,CAAC;AAG1E;;GAEG;AACH,MAAM,MAAM,cAAc,GAAG;IAC3B,IAAI,IAAI,OAAO,CAAC,OAAO,CAAC,CAAC;CAC1B,CAAC;AAEF;;GAEG;AACH,MAAM,MAAM,sBAAsB,CAAC,OAAO,SAAS,SAAS,EAAE,QAAQ,EAAE,QAAQ,SAAS,cAAc,GAAG,cAAc,IAAI;IAC1H,2BAA2B;IAC3B,MAAM,EAAE,OAAO,CAAC;IAChB,mDAAmD;IACnD,aAAa,EAAE,CAAC,IAAI,EAAE;QAAE,GAAG,EAAE,QAAQ,CAAA;KAAE,KAAK,OAAO,CAAC,QAAQ,CAAC,CAAC;IAC9D;;;;OAIG;IACH,iBAAiB,CAAC,EAAE,MAAM,EAAE,CAAC;IAC7B;;;;OAIG;IACH,oBAAoB,CAAC,EAAE,MAAM,EAAE,CAAC;CACjC,CAAC;AAEF;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACH,wBAAgB,sBAAsB,CACpC,OAAO,SAAS,SAAS,EACzB,QAAQ,EACR,QAAQ,SAAS,cAAc,GAAG,cAAc,EAEhD,MAAM,EAAE,sBAAsB,CAAC,OAAO,EAAE,QAAQ,EAAE,QAAQ,CAAC,GAC1D,YAAY,CAyBd;AAED,MAAM,MAAM,qBAAqB,CAC/B,OAAO,SAAS,SAAS,EACzB,QAAQ,EACR,QAAQ,SAAS,cAAc,GAAG,cAAc,IAC9C,sBAAsB,CAAC,OAAO,EAAE,QAAQ,EAAE,QAAQ,CAAC,GAAG;IACxD,EAAE,CAAC,EAAE,MAAM,CAAC;CACb,CAAC;AAEF;;GAEG;AACH,wBAAgB,qBAAqB,CACnC,OAAO,SAAS,SAAS,EACzB,QAAQ,EACR,QAAQ,SAAS,cAAc,GAAG,cAAc,EAChD,MAAM,EAAE,qBAAqB,CAAC,OAAO,EAAE,QAAQ,EAAE,QAAQ,CAAC,GAAG,UAAU,CAYxE"}

package/dist/adapters.js

@@ -0,0 +1,63 @@
+import { createDynamicCaller } from "./caller.js";
+import { buildToolManifest } from "./introspect.js";
+/**
+ * Creates a tool executor function that uses tRPC to execute procedures
+ *
+ * This adapter allows you to use tRPC procedures as chatbot tools with the
+ * Next.js handler from @yak-io/nextjs/server
+ *
+ * @example
+ * ```ts
+ * // app/api/yak/tools/route.ts
+ * import { createNextYakToolsHandler } from "@yak-io/nextjs/server";
+ * import { createTRPCToolExecutor } from "@yak-io/trpc";
+ * import { appRouter } from "@/server/trpc/router";
+ * import { createContext } from "@/server/trpc/context";
+ *
+ * export const POST = createNextYakToolsHandler({
+ *   executeTool: createTRPCToolExecutor({
+ *     router: appRouter,
+ *     createContext,
+ *     allowedProcedures: ["orders.list", "user.updateProfile"],
+ *   }),
+ * });
+ * ```
+ */
+export function createTRPCToolExecutor(config) {
+    const { router, createContext, allowedProcedures, disallowedProcedures } = config;
+    const allowedSet = allowedProcedures ? new Set(allowedProcedures) : null;
+    const disallowedSet = disallowedProcedures ? new Set(disallowedProcedures) : null;
+    return async (name, args, req) => {
+        // Check if procedure is allowed
+        // If allowedProcedures is set, procedure must be in the list
+        if (allowedSet && !allowedSet.has(name)) {
+            throw new Error(`Procedure '${name}' is not allowed`);
+        }
+        // If disallowedProcedures is set, procedure must not be in the list
+        if (disallowedSet && disallowedSet.has(name)) {
+            throw new Error(`Procedure '${name}' is not allowed`);
+        }
+        // Create tRPC context
+        const ctx = await createContext({ req: req });
+        // Create dynamic caller
+        const caller = createDynamicCaller(router, ctx);
+        // Invoke the procedure
+        return caller(name, args);
+    };
+}
+/**
+ * Create a core compatible tool source that bundles manifest + executor
+ */
+export function createTRPCToolAdapter(config) {
+    return {
+        id: config.id ?? "trpc",
+        getTools: async () => {
+            const manifest = buildToolManifest(config.router, {
+                allowedProcedures: config.allowedProcedures,
+                disallowedProcedures: config.disallowedProcedures,
+            });
+            return manifest.tools;
+        },
+        executeTool: createTRPCToolExecutor(config),
+    };
+}

package/dist/caller.d.ts

@@ -0,0 +1,25 @@
+import type { ZodType } from "zod";
+/**
+ * Coerces input values based on Zod schema types.
+ * Converts ISO date strings to Date objects only for z.date() fields.
+ * Leaves z.string() fields unchanged even if they contain ISO date strings.
+ */
+export declare function coerceInputToSchema(input: unknown, schema: ZodType | undefined): unknown;
+/**
+ * Splits a procedure path like "orders.list" into ["orders", "list"]
+ */
+export declare function splitProcedurePath(path: string): string[];
+/**
+ * Creates a dynamic caller that can invoke procedures by path string.
+ * Drills into nested router structure to find the target procedure.
+ * Automatically coerces ISO date strings to Date objects for z.date() fields.
+ *
+ * @example
+ * ```ts
+ * const caller = createDynamicCaller(appRouter, ctx);
+ * const result = await caller("orders.list", { limit: 10 });
+ * ```
+ */
+export declare function createDynamicCaller(router: any, // eslint-disable-line @typescript-eslint/no-explicit-any
+ctx: any): (name: string, input: unknown) => Promise<unknown>;
+//# sourceMappingURL=caller.d.ts.map

package/dist/caller.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"caller.d.ts","sourceRoot":"","sources":["../src/caller.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,KAAK,CAAC;AAuEnC;;;;GAIG;AACH,wBAAgB,mBAAmB,CACjC,KAAK,EAAE,OAAO,EACd,MAAM,EAAE,OAAO,GAAG,SAAS,GAC1B,OAAO,CA4DT;AAED;;GAEG;AACH,wBAAgB,kBAAkB,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,EAAE,CAEzD;AAED;;;;;;;;;;GAUG;AACH,wBAAgB,mBAAmB,CACjC,MAAM,EAAE,GAAG,EAAE,yDAAyD;AACtE,GAAG,EAAE,GAAG,GACP,CAAC,IAAI,EAAE,MAAM,EAAE,KAAK,EAAE,OAAO,KAAK,OAAO,CAAC,OAAO,CAAC,CA+CpD"}

package/dist/caller.js

@@ -0,0 +1,181 @@
+/**
+ * Properties that must never be accessed dynamically to prevent prototype pollution
+ */
+const FORBIDDEN_PROPS = new Set(["__proto__", "constructor", "prototype"]);
+/**
+ * ISO 8601 date string pattern
+ * Matches: 2024-01-15T10:30:00.000Z, 2024-01-15T10:30:00Z, 2024-01-15T10:30:00+00:00
+ */
+const ISO_DATE_REGEX = /^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}(?:\.\d{3})?(?:Z|[+-]\d{2}:\d{2})$/;
+/**
+ * Gets the Zod type name from a schema (supports both Zod 3 and Zod 4)
+ */
+function getZodTypeName(schema) {
+    // Zod 4 uses schema.type or schema._def.type
+    // Zod 3 uses schema._def.typeName
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    const s = schema;
+    return s.type ?? s._def?.type ?? s._def?.typeName;
+}
+/**
+ * Gets the inner type from wrapper Zod types (optional, nullable, default, etc.)
+ */
+function unwrapZodType(schema) {
+    const typeName = getZodTypeName(schema);
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    const def = schema._def;
+    if (typeName === "optional" ||
+        typeName === "ZodOptional" ||
+        typeName === "nullable" ||
+        typeName === "ZodNullable" ||
+        typeName === "default" ||
+        typeName === "ZodDefault") {
+        // Zod 4 uses def.innerType, Zod 3 uses def.innerType
+        const inner = def.innerType ?? def.unwrap?.();
+        if (inner)
+            return unwrapZodType(inner);
+    }
+    return schema;
+}
+/**
+ * Checks if a Zod schema represents a date type
+ */
+function isZodDate(schema) {
+    const unwrapped = unwrapZodType(schema);
+    const typeName = getZodTypeName(unwrapped);
+    return typeName === "date" || typeName === "ZodDate";
+}
+/**
+ * Gets the shape of a Zod object schema (supports both Zod 3 and Zod 4)
+ */
+function getObjectShape(schema) {
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    const def = schema._def;
+    // Zod 4: def.shape is an object
+    // Zod 3: def.shape() is a function
+    if (typeof def.shape === "function") {
+        return def.shape();
+    }
+    return def.shape;
+}
+/**
+ * Coerces input values based on Zod schema types.
+ * Converts ISO date strings to Date objects only for z.date() fields.
+ * Leaves z.string() fields unchanged even if they contain ISO date strings.
+ */
+export function coerceInputToSchema(input, schema) {
+    if (input === null || input === undefined || !schema) {
+        return input;
+    }
+    const unwrapped = unwrapZodType(schema);
+    const typeName = getZodTypeName(unwrapped);
+    // Handle date coercion
+    if ((typeName === "date" || typeName === "ZodDate") && typeof input === "string") {
+        if (ISO_DATE_REGEX.test(input)) {
+            const date = new Date(input);
+            if (!Number.isNaN(date.getTime())) {
+                return date;
+            }
+        }
+        return input;
+    }
+    // Handle arrays
+    if ((typeName === "array" || typeName === "ZodArray") && Array.isArray(input)) {
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        const def = unwrapped._def;
+        const elementSchema = def.type ?? def.element;
+        return input.map((item) => coerceInputToSchema(item, elementSchema));
+    }
+    // Handle objects
+    if ((typeName === "object" || typeName === "ZodObject") && typeof input === "object") {
+        const shape = getObjectShape(unwrapped);
+        if (!shape)
+            return input;
+        const result = {};
+        for (const [key, value] of Object.entries(input)) {
+            const fieldSchema = shape[key];
+            result[key] = fieldSchema
+                ? coerceInputToSchema(value, fieldSchema)
+                : value;
+        }
+        return result;
+    }
+    // Handle unions (e.g., z.union([z.string(), z.date()]))
+    if ((typeName === "union" || typeName === "ZodUnion") && typeof input === "string") {
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        const def = unwrapped._def;
+        const options = def.options;
+        if (options) {
+            // If any option is a date and input looks like a date, coerce it
+            const hasDateOption = options.some((opt) => isZodDate(opt));
+            if (hasDateOption && ISO_DATE_REGEX.test(input)) {
+                const date = new Date(input);
+                if (!Number.isNaN(date.getTime())) {
+                    return date;
+                }
+            }
+        }
+    }
+    return input;
+}
+/**
+ * Splits a procedure path like "orders.list" into ["orders", "list"]
+ */
+export function splitProcedurePath(path) {
+    return path.split(".");
+}
+/**
+ * Creates a dynamic caller that can invoke procedures by path string.
+ * Drills into nested router structure to find the target procedure.
+ * Automatically coerces ISO date strings to Date objects for z.date() fields.
+ *
+ * @example
+ * ```ts
+ * const caller = createDynamicCaller(appRouter, ctx);
+ * const result = await caller("orders.list", { limit: 10 });
+ * ```
+ */
+export function createDynamicCaller(router, // eslint-disable-line @typescript-eslint/no-explicit-any
+ctx // eslint-disable-line @typescript-eslint/no-explicit-any
+) {
+    const caller = router.createCaller(ctx);
+    // Get procedure definitions for schema lookup
+    const procedures = router._def.procedures; // eslint-disable-line @typescript-eslint/no-explicit-any
+    return async (name, input) => {
+        const pathParts = splitProcedurePath(name);
+        let current = caller; // eslint-disable-line @typescript-eslint/no-explicit-any
+        // Drill down to the target procedure
+        for (let i = 0; i < pathParts.length - 1; i++) {
+            const part = pathParts[i];
+            if (!part) {
+                throw new Error(`Invalid procedure path: ${name}`);
+            }
+            // Prevent prototype pollution attacks
+            if (FORBIDDEN_PROPS.has(part)) {
+                throw new Error(`Invalid procedure path: ${name}`);
+            }
+            current = current[part];
+            if (!current) {
+                throw new Error(`Procedure not found: ${name}`);
+            }
+        }
+        // Call the final procedure
+        const procedureName = pathParts[pathParts.length - 1];
+        if (!procedureName) {
+            throw new Error(`Invalid procedure path: ${name}`);
+        }
+        // Prevent prototype pollution attacks
+        if (FORBIDDEN_PROPS.has(procedureName)) {
+            throw new Error(`Invalid procedure path: ${name}`);
+        }
+        const procedure = current[procedureName];
+        if (typeof procedure !== "function") {
+            throw new Error(`Procedure not found or not callable: ${name}`);
+        }
+        // Get input schema and coerce dates based on schema types
+        const procDef = procedures[name];
+        const inputSchema = procDef?._def?.inputs?.[0];
+        const coercedInput = coerceInputToSchema(input, inputSchema);
+        return procedure(coercedInput);
+    };
+}

package/dist/createNextChatbotConfigHandler.d.ts

@@ -0,0 +1,47 @@
+import type { AnyRouter } from "@trpc/server";
+import type { RouteInfo } from "./types.js";
+/**
+ * Configuration for the chat config handler
+ */
+export type NextChatbotConfigHandlerConfig<TRouter extends AnyRouter> = {
+    /**
+     * The tRPC router to introspect for tools
+     */
+    router: TRouter;
+    /**
+     * List of allowed procedure paths for tools
+     */
+    allowedProcedures: string[];
+    /**
+     * Function to get route information
+     * This should scan your Next.js app directory and return route info
+     */
+    getRoutes: () => Promise<RouteInfo[]>;
+};
+/**
+ * Create a Next.js App Router handler that exposes combined chat configuration
+ *
+ * This handler combines both the tool manifest (tRPC procedures) and route manifest
+ * (Next.js routes) into a single endpoint for the chatbot to consume.
+ *
+ * @param config - Configuration object
+ * @returns A Next.js route handler function
+ *
+ * @example
+ * ```ts
+ * // app/api/chatbot/config/route.ts
+ * import { appRouter } from "@/server/trpc/router";
+ * import { createNextChatbotConfigHandler } from "@yak/trpc";
+ * import { scanRoutes } from "@yak/nextjs/server";
+ *
+ * export const GET = createNextChatbotConfigHandler({
+ *   router: appRouter,
+ *   allowedProcedures: ["orders.list", "user.updateProfile"],
+ *   getRoutes: async () => {
+ *     return scanRoutes("./src/app", false);
+ *   },
+ * });
+ * ```
+ */
+export declare function createNextChatbotConfigHandler<TRouter extends AnyRouter>(config: NextChatbotConfigHandlerConfig<TRouter>): (_req: Request) => Promise<Response>;
+//# sourceMappingURL=createNextChatbotConfigHandler.d.ts.map

package/dist/createNextChatbotConfigHandler.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"createNextChatbotConfigHandler.d.ts","sourceRoot":"","sources":["../src/createNextChatbotConfigHandler.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,cAAc,CAAC;AAC9C,OAAO,KAAK,EAAc,SAAS,EAAE,MAAM,YAAY,CAAC;AAGxD;;GAEG;AACH,MAAM,MAAM,8BAA8B,CAAC,OAAO,SAAS,SAAS,IAAI;IACtE;;OAEG;IACH,MAAM,EAAE,OAAO,CAAC;IAEhB;;OAEG;IACH,iBAAiB,EAAE,MAAM,EAAE,CAAC;IAE5B;;;OAGG;IACH,SAAS,EAAE,MAAM,OAAO,CAAC,SAAS,EAAE,CAAC,CAAC;CACvC,CAAC;AAEF;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AACH,wBAAgB,8BAA8B,CAC5C,OAAO,SAAS,SAAS,EAEzB,MAAM,EAAE,8BAA8B,CAAC,OAAO,CAAC,IAG7C,MAAM,OAAO,KACZ,OAAO,CAAC,QAAQ,CAAC,CAwBrB"}

package/dist/createNextChatbotConfigHandler.js

@@ -0,0 +1,49 @@
+import { buildToolManifest } from "./introspect.js";
+/**
+ * Create a Next.js App Router handler that exposes combined chat configuration
+ *
+ * This handler combines both the tool manifest (tRPC procedures) and route manifest
+ * (Next.js routes) into a single endpoint for the chatbot to consume.
+ *
+ * @param config - Configuration object
+ * @returns A Next.js route handler function
+ *
+ * @example
+ * ```ts
+ * // app/api/chatbot/config/route.ts
+ * import { appRouter } from "@/server/trpc/router";
+ * import { createNextChatbotConfigHandler } from "@yak/trpc";
+ * import { scanRoutes } from "@yak/nextjs/server";
+ *
+ * export const GET = createNextChatbotConfigHandler({
+ *   router: appRouter,
+ *   allowedProcedures: ["orders.list", "user.updateProfile"],
+ *   getRoutes: async () => {
+ *     return scanRoutes("./src/app", false);
+ *   },
+ * });
+ * ```
+ */
+export function createNextChatbotConfigHandler(config) {
+    return async function handleConfig(_req) {
+        const toolManifest = buildToolManifest(config.router, {
+            allowedProcedures: config.allowedProcedures,
+        });
+        const routes = await config.getRoutes();
+        const routeManifest = {
+            routes,
+            generated_at: new Date().toISOString(),
+        };
+        const chatConfig = {
+            tools: toolManifest,
+            routes: routeManifest,
+        };
+        return new Response(JSON.stringify(chatConfig), {
+            status: 200,
+            headers: {
+                "Content-Type": "application/json",
+                "Cache-Control": "no-store",
+            },
+        });
+    };
+}

package/dist/createNextChatbotToolManifestHandler.d.ts

@@ -0,0 +1,44 @@
+import type { AnyRouter } from "@trpc/server";
+/**
+ * Generic request type
+ */
+export type GenericRequest = {
+    json(): Promise<unknown>;
+};
+/**
+ * Configuration for the tool manifest handler
+ */
+export type NextChatbotToolManifestHandlerConfig<TRouter extends AnyRouter> = {
+    /**
+     * The tRPC router to introspect
+     */
+    router: TRouter;
+    /**
+     * List of allowed procedure paths, e.g. ["orders.list", "user.updateProfile"].
+     * Only these procedures will appear in the tool manifest.
+     */
+    allowedProcedures: string[];
+};
+/**
+ * Create a Next.js App Router handler that exposes a tool manifest
+ *
+ * This handler introspects your tRPC router at runtime and returns a JSON manifest
+ * of tools (procedures) available to the chatbot, including their input/output schemas.
+ *
+ * @param config - Configuration object
+ * @returns A Next.js route handler function
+ *
+ * @example
+ * ```ts
+ * // app/api/chatbot/tools/manifest/route.ts
+ * import { appRouter } from "@/server/trpc/router";
+ * import { createNextChatbotToolManifestHandler } from "@yak/trpc";
+ *
+ * export const GET = createNextChatbotToolManifestHandler({
+ *   router: appRouter,
+ *   allowedProcedures: ["orders.list", "user.updateProfile"],
+ * });
+ * ```
+ */
+export declare function createNextChatbotToolManifestHandler<TRouter extends AnyRouter>(config: NextChatbotToolManifestHandlerConfig<TRouter>): (_req: GenericRequest) => Promise<Response>;
+//# sourceMappingURL=createNextChatbotToolManifestHandler.d.ts.map

package/dist/createNextChatbotToolManifestHandler.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"createNextChatbotToolManifestHandler.d.ts","sourceRoot":"","sources":["../src/createNextChatbotToolManifestHandler.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,cAAc,CAAC;AAI9C;;GAEG;AACH,MAAM,MAAM,cAAc,GAAG;IAC3B,IAAI,IAAI,OAAO,CAAC,OAAO,CAAC,CAAC;CAC1B,CAAC;AAEF;;GAEG;AACH,MAAM,MAAM,oCAAoC,CAAC,OAAO,SAAS,SAAS,IAAI;IAC5E;;OAEG;IACH,MAAM,EAAE,OAAO,CAAC;IAEhB;;;OAGG;IACH,iBAAiB,EAAE,MAAM,EAAE,CAAC;CAC7B,CAAC;AAEF;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,wBAAgB,oCAAoC,CAClD,OAAO,SAAS,SAAS,EAEzB,MAAM,EAAE,oCAAoC,CAAC,OAAO,CAAC,IAGnD,MAAM,cAAc,KACnB,OAAO,CAAC,QAAQ,CAAC,CAarB"}

package/dist/createNextChatbotToolManifestHandler.js

@@ -0,0 +1,36 @@
+import { buildToolManifest } from "./introspect.js";
+/**
+ * Create a Next.js App Router handler that exposes a tool manifest
+ *
+ * This handler introspects your tRPC router at runtime and returns a JSON manifest
+ * of tools (procedures) available to the chatbot, including their input/output schemas.
+ *
+ * @param config - Configuration object
+ * @returns A Next.js route handler function
+ *
+ * @example
+ * ```ts
+ * // app/api/chatbot/tools/manifest/route.ts
+ * import { appRouter } from "@/server/trpc/router";
+ * import { createNextChatbotToolManifestHandler } from "@yak/trpc";
+ *
+ * export const GET = createNextChatbotToolManifestHandler({
+ *   router: appRouter,
+ *   allowedProcedures: ["orders.list", "user.updateProfile"],
+ * });
+ * ```
+ */
+export function createNextChatbotToolManifestHandler(config) {
+    return async function handleManifest(_req) {
+        const manifest = buildToolManifest(config.router, {
+            allowedProcedures: config.allowedProcedures,
+        });
+        return new Response(JSON.stringify(manifest), {
+            status: 200,
+            headers: {
+                "Content-Type": "application/json",
+                "Cache-Control": "no-store",
+            },
+        });
+    };
+}

package/dist/createNextChatbotToolsHandler.d.ts

@@ -0,0 +1,50 @@
+import type { AnyRouter } from "@trpc/server";
+/**
+ * Generic request type that works with Next.js Request
+ */
+export type GenericRequest = {
+    json(): Promise<unknown>;
+};
+/**
+ * Configuration for the Next.js chatbot tools handler
+ */
+export type NextChatbotToolsHandlerConfig<TRouter extends AnyRouter, TContext, TRequest extends GenericRequest = GenericRequest> = {
+    /** tRPC router instance */
+    router: TRouter;
+    /** Function to create tRPC context from request */
+    createContext: (opts: {
+        req: TRequest;
+    }) => Promise<TContext>;
+    /**
+     * List of allowed procedure paths, e.g. ["orders.list", "user.updateProfile"].
+     * Only these procedures can be invoked as tools.
+     */
+    allowedProcedures: string[];
+};
+/**
+ * Creates a Next.js App Router-compatible POST handler for chatbot tool calls.
+ *
+ * This handler:
+ * 1. Parses the tool call payload from the request
+ * 2. Validates the procedure name is in the allowlist
+ * 3. Creates a tRPC caller with the request context
+ * 4. Dynamically invokes the requested procedure
+ * 5. Returns the result or error as JSON
+ *
+ * @example
+ * ```ts
+ * // app/api/chatbot/tools/route.ts
+ * import { NextRequest } from "next/server";
+ * import { appRouter } from "@/server/trpc/router";
+ * import { createContext } from "@/server/trpc/context";
+ * import { createNextChatbotToolsHandler } from "@yak/trpc";
+ *
+ * export const POST = createNextChatbotToolsHandler({
+ *   router: appRouter,
+ *   createContext,
+ *   allowedProcedures: ["orders.list", "user.updateProfile"],
+ * });
+ * ```
+ */
+export declare function createNextChatbotToolsHandler<TRouter extends AnyRouter, TContext, TRequest extends GenericRequest = GenericRequest>(config: NextChatbotToolsHandlerConfig<TRouter, TContext, TRequest>): (req: TRequest) => Promise<Response>;
+//# sourceMappingURL=createNextChatbotToolsHandler.d.ts.map

package/dist/createNextChatbotToolsHandler.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"createNextChatbotToolsHandler.d.ts","sourceRoot":"","sources":["../src/createNextChatbotToolsHandler.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,cAAc,CAAC;AAK9C;;GAEG;AACH,MAAM,MAAM,cAAc,GAAG;IAC3B,IAAI,IAAI,OAAO,CAAC,OAAO,CAAC,CAAC;CAC1B,CAAC;AAEF;;GAEG;AACH,MAAM,MAAM,6BAA6B,CAAC,OAAO,SAAS,SAAS,EAAE,QAAQ,EAAE,QAAQ,SAAS,cAAc,GAAG,cAAc,IAAI;IACjI,2BAA2B;IAC3B,MAAM,EAAE,OAAO,CAAC;IAChB,mDAAmD;IACnD,aAAa,EAAE,CAAC,IAAI,EAAE;QAAE,GAAG,EAAE,QAAQ,CAAA;KAAE,KAAK,OAAO,CAAC,QAAQ,CAAC,CAAC;IAC9D;;;OAGG;IACH,iBAAiB,EAAE,MAAM,EAAE,CAAC;CAC7B,CAAC;AAEF;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AACH,wBAAgB,6BAA6B,CAC3C,OAAO,SAAS,SAAS,EACzB,QAAQ,EACR,QAAQ,SAAS,cAAc,GAAG,cAAc,EAEhD,MAAM,EAAE,6BAA6B,CAAC,OAAO,EAAE,QAAQ,EAAE,QAAQ,CAAC,GACjE,CAAC,GAAG,EAAE,QAAQ,KAAK,OAAO,CAAC,QAAQ,CAAC,CA8DtC"}

package/dist/createNextChatbotToolsHandler.js

@@ -0,0 +1,126 @@
+import { createDynamicCaller } from "./caller.js";
+import { logger } from "./logger.js";
+/**
+ * Creates a Next.js App Router-compatible POST handler for chatbot tool calls.
+ *
+ * This handler:
+ * 1. Parses the tool call payload from the request
+ * 2. Validates the procedure name is in the allowlist
+ * 3. Creates a tRPC caller with the request context
+ * 4. Dynamically invokes the requested procedure
+ * 5. Returns the result or error as JSON
+ *
+ * @example
+ * ```ts
+ * // app/api/chatbot/tools/route.ts
+ * import { NextRequest } from "next/server";
+ * import { appRouter } from "@/server/trpc/router";
+ * import { createContext } from "@/server/trpc/context";
+ * import { createNextChatbotToolsHandler } from "@yak/trpc";
+ *
+ * export const POST = createNextChatbotToolsHandler({
+ *   router: appRouter,
+ *   createContext,
+ *   allowedProcedures: ["orders.list", "user.updateProfile"],
+ * });
+ * ```
+ */
+export function createNextChatbotToolsHandler(config) {
+    const { router, createContext, allowedProcedures } = config;
+    return async (req) => {
+        try {
+            // Parse request body
+            const body = await req.json();
+            // Validate payload structure
+            if (!isToolCallPayload(body)) {
+                logger.warn("Invalid tool call payload received");
+                return createErrorResponse("Invalid request payload", 400);
+            }
+            const { id, name, args } = body;
+            logger.debug(`Tool call received: ${name}`, { id, args });
+            // Check if procedure is allowed
+            if (!allowedProcedures.includes(name)) {
+                logger.warn(`Procedure not allowed: ${name}`);
+                return createToolErrorResponse(id, `Procedure '${name}' is not allowed`);
+            }
+            // Create tRPC context
+            const ctx = await createContext({ req });
+            // Create dynamic caller
+            const caller = createDynamicCaller(router, ctx);
+            // Invoke the procedure
+            const result = await caller(name, args);
+            logger.debug(`Tool call succeeded: ${name}`, { id });
+            // Return success response
+            const successResult = {
+                id,
+                ok: true,
+                result,
+            };
+            return new Response(JSON.stringify(successResult), {
+                status: 200,
+                headers: {
+                    "Content-Type": "application/json",
+                },
+            });
+        }
+        catch (error) {
+            logger.error("Tool call failed", error);
+            // Extract error details
+            const body = await req.json().catch(() => ({}));
+            const id = body.id ?? "unknown";
+            const errorMessage = extractErrorMessage(error);
+            return createToolErrorResponse(id, errorMessage);
+        }
+    };
+}
+/**
+ * Type guard to validate tool call payload
+ */
+function isToolCallPayload(payload) {
+    return (typeof payload === "object" &&
+        payload !== null &&
+        "id" in payload &&
+        typeof payload.id === "string" &&
+        "name" in payload &&
+        typeof payload.name === "string" &&
+        "args" in payload);
+}
+/**
+ * Extract a safe error message from an unknown error
+ */
+function extractErrorMessage(error) {
+    if (error instanceof Error) {
+        return error.message;
+    }
+    if (typeof error === "string") {
+        return error;
+    }
+    return "An unknown error occurred";
+}
+/**
+ * Create a JSON response for tool call errors
+ */
+function createToolErrorResponse(id, error) {
+    const errorResult = {
+        id,
+        ok: false,
+        error,
+    };
+    return new Response(JSON.stringify(errorResult), {
+        status: 200, // Return 200 with error payload so client can process it
+        headers: {
+            "Content-Type": "application/json",
+        },
+    });
+}
+/**
+ * Create a generic HTTP error response
+ */
+function createErrorResponse(message, status) {
+    return new Response(JSON.stringify({ error: message }), {
+        status,
+        headers: {
+            "Content-Type": "application/json",
+        },
+    });
+}

package/dist/index.d.ts

@@ -0,0 +1,6 @@
+export { createTRPCToolExecutor, createTRPCToolAdapter } from "./adapters.js";
+export type { TRPCToolExecutorConfig, TRPCToolAdapterConfig } from "./adapters.js";
+export { buildToolManifest } from "./introspect.js";
+export type { BuildToolManifestOptions } from "./introspect.js";
+export type { ToolCallPayload, ToolCallResult, ToolDefinition, ToolManifest, RouteInfo, RouteManifest, ChatConfig, ToolExecutor, } from "@yak-io/javascript/server";
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,sBAAsB,EAAE,qBAAqB,EAAE,MAAM,eAAe,CAAC;AAC9E,YAAY,EAAE,sBAAsB,EAAE,qBAAqB,EAAE,MAAM,eAAe,CAAC;AAGnF,OAAO,EAAE,iBAAiB,EAAE,MAAM,iBAAiB,CAAC;AACpD,YAAY,EAAE,wBAAwB,EAAE,MAAM,iBAAiB,CAAC;AAGhE,YAAY,EACX,eAAe,EACf,cAAc,EACd,cAAc,EACd,YAAY,EACZ,SAAS,EACT,aAAa,EACb,UAAU,EACV,YAAY,GACZ,MAAM,2BAA2B,CAAC"}

package/dist/index.js

@@ -0,0 +1,4 @@
+// tRPC adapters for core handlers
+export { createTRPCToolExecutor, createTRPCToolAdapter } from "./adapters.js";
+// Tool manifest builder
+export { buildToolManifest } from "./introspect.js";

package/dist/introspect.d.ts

@@ -0,0 +1,44 @@
+import type { AnyRouter } from "@trpc/server";
+import type { ToolManifest } from "@yak-io/javascript/server";
+/**
+ * Options for building a tool manifest
+ */
+export type BuildToolManifestOptions = {
+    /**
+     * List of procedure paths to include (e.g., ["orders.list", "user.updateProfile"]).
+     * If omitted, all procedures are included by default.
+     */
+    allowedProcedures?: string[];
+    /**
+     * List of procedure paths to exclude (e.g., ["admin.deleteUser", "billing.refund"]).
+     * Applied after allowedProcedures filtering.
+     */
+    disallowedProcedures?: string[];
+};
+/**
+ * Build a tool manifest from a tRPC router by introspecting its procedures
+ *
+ * @param router - The tRPC router to introspect
+ * @param opts - Configuration options
+ * @param opts.allowedProcedures - List of procedure paths to include. If omitted, all procedures are included.
+ * @param opts.disallowedProcedures - List of procedure paths to exclude. Applied after allowedProcedures.
+ * @returns A tool manifest containing definitions for the filtered procedures
+ *
+ * @example
+ * ```ts
+ * // Allow all procedures
+ * const manifest = buildToolManifest(appRouter);
+ *
+ * // Only specific procedures
+ * const manifest = buildToolManifest(appRouter, {
+ *   allowedProcedures: ["orders.list", "user.updateProfile"]
+ * });
+ *
+ * // All except specific procedures
+ * const manifest = buildToolManifest(appRouter, {
+ *   disallowedProcedures: ["admin.deleteUser", "billing.refund"]
+ * });
+ * ```
+ */
+export declare function buildToolManifest(router: AnyRouter, opts?: BuildToolManifestOptions): ToolManifest;
+//# sourceMappingURL=introspect.d.ts.map

package/dist/introspect.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"introspect.d.ts","sourceRoot":"","sources":["../src/introspect.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,SAAS,EAAoB,MAAM,cAAc,CAAC;AAGhE,OAAO,KAAK,EAAkB,YAAY,EAAE,MAAM,2BAA2B,CAAC;AA4B9E;;GAEG;AACH,MAAM,MAAM,wBAAwB,GAAG;IACrC;;;OAGG;IACH,iBAAiB,CAAC,EAAE,MAAM,EAAE,CAAC;IAC7B;;;OAGG;IACH,oBAAoB,CAAC,EAAE,MAAM,EAAE,CAAC;CACjC,CAAC;AAEF;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AACH,wBAAgB,iBAAiB,CAC/B,MAAM,EAAE,SAAS,EACjB,IAAI,GAAE,wBAA6B,GAClC,YAAY,CAuCd"}

package/dist/introspect.js

@@ -0,0 +1,79 @@
+import { toJSONSchema } from "zod";
+/**
+ * Extract runtime procedure information from a tRPC router
+ */
+function getRuntimeProcedures(router) {
+    const procedures = router._def.procedures;
+    return Object.entries(procedures).map(([path, proc]) => {
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        const def = proc._def;
+        return {
+            path,
+            type: def.type,
+            inputSchema: def.inputs?.[0],
+            outputSchema: def.output ?? undefined,
+        };
+    });
+}
+/**
+ * Build a tool manifest from a tRPC router by introspecting its procedures
+ *
+ * @param router - The tRPC router to introspect
+ * @param opts - Configuration options
+ * @param opts.allowedProcedures - List of procedure paths to include. If omitted, all procedures are included.
+ * @param opts.disallowedProcedures - List of procedure paths to exclude. Applied after allowedProcedures.
+ * @returns A tool manifest containing definitions for the filtered procedures
+ *
+ * @example
+ * ```ts
+ * // Allow all procedures
+ * const manifest = buildToolManifest(appRouter);
+ *
+ * // Only specific procedures
+ * const manifest = buildToolManifest(appRouter, {
+ *   allowedProcedures: ["orders.list", "user.updateProfile"]
+ * });
+ *
+ * // All except specific procedures
+ * const manifest = buildToolManifest(appRouter, {
+ *   disallowedProcedures: ["admin.deleteUser", "billing.refund"]
+ * });
+ * ```
+ */
+export function buildToolManifest(router, opts = {}) {
+    const { allowedProcedures, disallowedProcedures } = opts;
+    const allowedSet = allowedProcedures ? new Set(allowedProcedures) : null;
+    const disallowedSet = disallowedProcedures ? new Set(disallowedProcedures) : null;
+    const runtimeProcedures = getRuntimeProcedures(router);
+    const tools = runtimeProcedures
+        .filter((p) => {
+        // If allowedProcedures is set, procedure must be in the list
+        if (allowedSet && !allowedSet.has(p.path)) {
+            return false;
+        }
+        // If disallowedProcedures is set, procedure must not be in the list
+        if (disallowedSet && disallowedSet.has(p.path)) {
+            return false;
+        }
+        return true;
+    })
+        .map((p) => {
+        const inputSchema = p.inputSchema
+            ? toJSONSchema(p.inputSchema, { unrepresentable: "any" })
+            : undefined;
+        const outputSchema = p.outputSchema
+            ? toJSONSchema(p.outputSchema, { unrepresentable: "any" })
+            : undefined;
+        return {
+            name: p.path,
+            displayName: p.path, // host app can override later if needed
+            description: `tRPC procedure ${p.path} (${p.type})`,
+            inputSchema,
+            outputSchema,
+        };
+    });
+    return {
+        tools,
+        generated_at: new Date().toISOString(),
+    };
+}

package/dist/logger.d.ts

@@ -0,0 +1,6 @@
+export declare const logger: {
+    debug: (message: string, data?: unknown) => void;
+    warn: (message: string, data?: unknown) => void;
+    error: (message: string, error?: unknown) => void;
+};
+//# sourceMappingURL=logger.d.ts.map

package/dist/logger.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"logger.d.ts","sourceRoot":"","sources":["../src/logger.ts"],"names":[],"mappings":"AAIA,eAAO,MAAM,MAAM;qBACA,MAAM,SAAS,OAAO,KAAG,IAAI;oBAM9B,MAAM,SAAS,OAAO,KAAG,IAAI;qBAI5B,MAAM,UAAU,OAAO,KAAG,IAAI;CAGhD,CAAC"}

package/dist/logger.js

@@ -0,0 +1,15 @@
+/* eslint-disable no-console */
+const isDev = process.env.NODE_ENV === "development";
+export const logger = {
+    debug: (message, data) => {
+        if (isDev) {
+            console.log(`[yak/trpc] ${message}`, data ?? "");
+        }
+    },
+    warn: (message, data) => {
+        console.warn(`[yak/trpc] ${message}`, data ?? "");
+    },
+    error: (message, error) => {
+        console.error(`[yak/trpc] ${message}`, error);
+    },
+};

package/dist/types.d.ts

@@ -0,0 +1,77 @@
+/**
+ * Generic JSON Schema type
+ */
+export type JSONSchema = Record<string, unknown>;
+/**
+ * Payload for a tool call request from the iframe
+ */
+export type ToolCallPayload = {
+    id: string;
+    name: string;
+    args: unknown;
+};
+/**
+ * Successful tool call result
+ */
+export type ToolCallSuccess = {
+    ok: true;
+    result: unknown;
+};
+/**
+ * Failed tool call result
+ */
+export type ToolCallError = {
+    ok: false;
+    error: string;
+};
+/**
+ * Union type for tool call responses
+ */
+export type ToolCallResult = ToolCallSuccess | ToolCallError;
+/**
+ * Definition of a single tool (tRPC procedure) available to the LLM
+ */
+export type ToolDefinition = {
+    /** Fully qualified procedure name, e.g. "orders.list" */
+    name: string;
+    /** Human friendly label */
+    displayName?: string;
+    /** Description shown to the LLM as a tool description */
+    description?: string;
+    /** Optional JSON Schema for input args */
+    inputSchema?: JSONSchema;
+    /** Optional JSON Schema for output shape (not required in v1) */
+    outputSchema?: JSONSchema;
+};
+/**
+ * A manifest of available tools exposed to the chatbot
+ */
+export type ToolManifest = {
+    tools: ToolDefinition[];
+    generated_at: string;
+};
+/**
+ * Information about a Next.js route
+ */
+export type RouteInfo = {
+    path: string;
+    /** Human-readable title extracted from page metadata */
+    title?: string;
+    /** Description extracted from page metadata */
+    description?: string;
+};
+/**
+ * A manifest of available routes in the Next.js application
+ */
+export type RouteManifest = {
+    routes: RouteInfo[];
+    generated_at: string;
+};
+/**
+ * Combined configuration for the chatbot including tools and routes
+ */
+export type ChatConfig = {
+    tools: ToolManifest;
+    routes: RouteManifest;
+};
+//# sourceMappingURL=types.d.ts.map

package/dist/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../src/types.ts"],"names":[],"mappings":"AAAA;;GAEG;AACH,MAAM,MAAM,UAAU,GAAG,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;AAEjD;;GAEG;AACH,MAAM,MAAM,eAAe,GAAG;IAC5B,EAAE,EAAE,MAAM,CAAC;IACX,IAAI,EAAE,MAAM,CAAC;IACb,IAAI,EAAE,OAAO,CAAC;CACf,CAAC;AAEF;;GAEG;AACH,MAAM,MAAM,eAAe,GAAG;IAC5B,EAAE,EAAE,IAAI,CAAC;IACT,MAAM,EAAE,OAAO,CAAC;CACjB,CAAC;AAEF;;GAEG;AACH,MAAM,MAAM,aAAa,GAAG;IAC1B,EAAE,EAAE,KAAK,CAAC;IACV,KAAK,EAAE,MAAM,CAAC;CACf,CAAC;AAEF;;GAEG;AACH,MAAM,MAAM,cAAc,GAAG,eAAe,GAAG,aAAa,CAAC;AAE7D;;GAEG;AACH,MAAM,MAAM,cAAc,GAAG;IAC3B,yDAAyD;IACzD,IAAI,EAAE,MAAM,CAAC;IAEb,2BAA2B;IAC3B,WAAW,CAAC,EAAE,MAAM,CAAC;IAErB,yDAAyD;IACzD,WAAW,CAAC,EAAE,MAAM,CAAC;IAErB,0CAA0C;IAC1C,WAAW,CAAC,EAAE,UAAU,CAAC;IAEzB,iEAAiE;IACjE,YAAY,CAAC,EAAE,UAAU,CAAC;CAC3B,CAAC;AAEF;;GAEG;AACH,MAAM,MAAM,YAAY,GAAG;IACzB,KAAK,EAAE,cAAc,EAAE,CAAC;IACxB,YAAY,EAAE,MAAM,CAAC;CACtB,CAAC;AAEF;;GAEG;AACH,MAAM,MAAM,SAAS,GAAG;IACtB,IAAI,EAAE,MAAM,CAAC;IACb,wDAAwD;IACxD,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,+CAA+C;IAC/C,WAAW,CAAC,EAAE,MAAM,CAAC;CACtB,CAAC;AAEF;;GAEG;AACH,MAAM,MAAM,aAAa,GAAG;IAC1B,MAAM,EAAE,SAAS,EAAE,CAAC;IACpB,YAAY,EAAE,MAAM,CAAC;CACtB,CAAC;AAEF;;GAEG;AACH,MAAM,MAAM,UAAU,GAAG;IACvB,KAAK,EAAE,YAAY,CAAC;IACpB,MAAM,EAAE,aAAa,CAAC;CACvB,CAAC"}

package/dist/types.js

@@ -0,0 +1 @@
+export {};

package/package.json

@@ -0,0 +1,57 @@
+{
+  "name": "@yak-io/trpc",
+  "version": "0.1.0",
+  "description": "tRPC adapter for yak chatbot - enables tRPC procedures as chatbot tools",
+  "type": "module",
+  "license": "SEE LICENSE IN LICENSE",
+  "author": "Yak <support@yak.io>",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/9f-au/yak.git",
+    "directory": "packages/trpc"
+  },
+  "publishConfig": {
+    "access": "public",
+    "provenance": false
+  },
+  "keywords": [
+    "yak",
+    "chatbot",
+    "ai",
+    "trpc",
+    "tools"
+  ],
+  "engines": {
+    "node": ">=18"
+  },
+  "files": [
+    "dist",
+    "LICENSE"
+  ],
+  "sideEffects": false,
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js"
+    },
+    "./package.json": "./package.json"
+  },
+  "dependencies": {
+    "@yak-io/javascript": "0.1.0"
+  },
+  "peerDependencies": {
+    "@trpc/server": "^10.0.0 || ^11.0.0",
+    "zod": "^4.0.0"
+  },
+  "devDependencies": {
+    "@trpc/server": "^11.8.0",
+    "@types/node": "^24.10.2",
+    "typescript": "^5.3.0",
+    "zod": "^4.1.13",
+    "@repo/typescript-config": "0.0.0"
+  },
+  "scripts": {
+    "build": "tsc",
+    "check-types": "tsc --noEmit"
+  }
+}